blob: 9c52810386960fb3f4719e41960eeb0d99c3306b [file]
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
use crate::directory::ExtDirectory;
use crate::file::ExtFile;
use crate::symlink::ExtSymlink;
use crate::types::ExtAttributes;
use ext4_lib::processor::Ext4Processor;
use ext4_lib::readers::{BlockDeviceReader, ReaderWriter, VmoReader};
use ext4_lib::structs::{self, EntryType, MIN_EXT4_SIZE};
use fidl::endpoints::ClientEnd;
use fidl_fuchsia_storage_block::BlockMarker;
use log::error;
use std::sync::Arc;
mod directory;
mod file;
mod node;
mod symlink;
mod types;
pub enum FsSourceType {
BlockDevice(ClientEnd<BlockMarker>),
Vmo(zx::Vmo),
}
#[derive(Debug, PartialEq)]
pub enum ConstructFsError {
VmoReadError(zx::Status),
ParsingError(structs::ParsingError),
FileVmoError(zx::Status),
NodeError(zx::Status),
}
impl From<structs::ParsingError> for ConstructFsError {
fn from(value: structs::ParsingError) -> Self {
Self::ParsingError(value)
}
}
pub fn construct_fs(
source: FsSourceType,
read_only: bool,
inspector: &fuchsia_inspect::Inspector,
) -> Result<Arc<ExtDirectory>, ConstructFsError> {
let reader: Arc<dyn ReaderWriter> = match source {
FsSourceType::BlockDevice(block_device) => {
Arc::new(BlockDeviceReader::from_client_end(block_device).map_err(|e| {
error!("Error constructing file system: {}", e);
ConstructFsError::VmoReadError(zx::Status::IO_INVALID)
})?)
}
FsSourceType::Vmo(vmo) => {
let size = vmo.get_size().map_err(ConstructFsError::VmoReadError)?;
if size < MIN_EXT4_SIZE as u64 {
// Too small to even fit the first copy of the ext4 Super Block.
return Err(ConstructFsError::VmoReadError(zx::Status::NO_SPACE));
}
Arc::new(VmoReader::new(Arc::new(vmo)))
}
};
let processor = Arc::new(Ext4Processor::new(reader, read_only));
let dir = build_fs_dir(processor.clone(), structs::ROOT_INODE_NUM, read_only)?;
processor.record_statistics(inspector.root());
Ok(dir)
}
fn build_fs_dir(
processor: Arc<Ext4Processor>,
ino: u32,
read_only: bool,
) -> Result<Arc<ExtDirectory>, ConstructFsError> {
let inode = processor.inode(ino)?;
let entries = processor.entries_from_inode(&inode)?;
let attributes = ExtAttributes::from_inode(inode);
let xattrs = processor.inode_xattrs(ino)?;
let dir = ExtDirectory::new(ino as u64, attributes, xattrs);
for entry in entries {
let entry_name = entry.name()?;
if entry_name == "." || entry_name == ".." {
continue;
}
let entry_ino = u32::from(entry.e2d_ino);
match EntryType::from_u8(entry.e2d_type)? {
EntryType::Directory => {
dir.insert_child(
entry_name,
build_fs_dir(processor.clone(), entry_ino, read_only)?,
)
.map_err(ConstructFsError::NodeError)?;
}
EntryType::RegularFile => {
dir.insert_child(
entry_name,
ExtFile::from_processor(processor.clone(), entry_ino, read_only)
.map_err(ConstructFsError::NodeError)?,
)
.map_err(ConstructFsError::NodeError)?;
}
EntryType::SymLink => {
dir.insert_child(
entry_name,
ExtSymlink::from_processor(processor.clone(), entry_ino)
.map_err(ConstructFsError::NodeError)?,
)
.map_err(ConstructFsError::NodeError)?;
}
_ => {
// TODO(https://fxbug.dev/42073143): Handle other types.
}
}
}
Ok(dir)
}
#[cfg(test)]
mod tests {
use super::{ExtAttributes, ExtDirectory, ExtSymlink, FsSourceType, construct_fs};
use ext4_lib::parser::XattrMap;
use ext4_lib::structs::MIN_EXT4_SIZE;
use fidl_fuchsia_io as fio;
use fidl_fuchsia_storage_block as fblock;
use fuchsia_async as fasync;
use fuchsia_fs::directory::{DirEntry, DirentKind, open_file, open_node, readdir};
use fuchsia_fs::file::{WriteError, read_to_string, write};
use futures::stream::StreamExt as _;
use std::fs;
use std::sync::Arc;
use test_vmo_backed_block_server::VmoBackedServer;
use zx::{Status, Vmo};
const BLOCK_SIZE: u32 = 512;
#[fuchsia::test]
fn image_too_small() {
let vmo = Vmo::create(10).expect("VMO is created");
vmo.write(b"too small", 0).expect("VMO write() succeeds");
let buffer = FsSourceType::Vmo(vmo);
assert!(
construct_fs(buffer, true, &fuchsia_inspect::Inspector::default()).is_err(),
"Expected failed parsing of VMO."
);
}
#[fuchsia::test]
fn invalid_fs() {
let vmo = Vmo::create(MIN_EXT4_SIZE as u64).expect("VMO is created");
vmo.write(b"not ext4", 0).expect("VMO write() succeeds");
let buffer = FsSourceType::Vmo(vmo);
assert!(
construct_fs(buffer, true, &fuchsia_inspect::Inspector::default()).is_err(),
"Expected failed parsing of VMO."
);
}
#[fuchsia::test]
async fn list_root() {
let data = fs::read("/pkg/data/nest.img").expect("Unable to read file");
let vmo = Vmo::create(data.len() as u64).expect("VMO is created");
vmo.write(data.as_slice(), 0).expect("VMO write() succeeds");
let buffer = FsSourceType::Vmo(vmo);
let tree = construct_fs(buffer, true, &fuchsia_inspect::Inspector::default())
.expect("construct_fs parses the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE,
);
let expected = vec![
DirEntry { name: String::from("file1"), kind: DirentKind::File },
DirEntry { name: String::from("inner"), kind: DirentKind::Directory },
DirEntry { name: String::from("lost+found"), kind: DirentKind::Directory },
];
assert_eq!(readdir(&root).await.unwrap(), expected);
let file = open_file(&root, "file1", fio::PERM_READABLE).await.unwrap();
assert_eq!(read_to_string(&file).await.unwrap(), "file1 contents.\n");
file.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
root.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
}
#[fuchsia::test]
async fn get_dac_attributes() {
let data = fs::read("/pkg/data/dac_attributes.img").expect("Unable to read file");
let vmo = Vmo::create(data.len() as u64).expect("VMO is created");
vmo.write(data.as_slice(), 0).expect("VMO write() succeeds");
let buffer = FsSourceType::Vmo(vmo);
let tree = construct_fs(buffer, true, &fuchsia_inspect::Inspector::default())
.expect("construct_fs parses the VMO");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE,
);
let expected_entries = vec![
DirEntry { name: String::from("dir_1000"), kind: DirentKind::Directory },
DirEntry { name: String::from("dir_root"), kind: DirentKind::Directory },
DirEntry { name: String::from("file_1000"), kind: DirentKind::File },
DirEntry { name: String::from("file_root"), kind: DirentKind::File },
DirEntry { name: String::from("lost+found"), kind: DirentKind::Directory },
];
assert_eq!(readdir(&root).await.unwrap(), expected_entries);
#[derive(Debug, PartialEq)]
struct Node {
name: String,
mode: u32,
uid: u32,
gid: u32,
}
let expected_attributes = vec![
Node { name: String::from("dir_1000"), mode: 0x416D, uid: 1000, gid: 1000 },
Node { name: String::from("dir_root"), mode: 0x4140, uid: 0, gid: 0 },
Node { name: String::from("file_1000"), mode: 0x8124, uid: 1000, gid: 1000 },
Node { name: String::from("file_root"), mode: 0x8100, uid: 0, gid: 0 },
];
let attributes_query = fio::NodeAttributesQuery::MODE
| fio::NodeAttributesQuery::UID
| fio::NodeAttributesQuery::GID;
for expected_node in &expected_attributes {
let node_proxy = open_node(&root, expected_node.name.as_str(), fio::PERM_READABLE)
.await
.expect("node open failed");
let (mut_attrs, _immut_attrs) = node_proxy
.get_attributes(attributes_query)
.await
.expect("node get_attributes() failed")
.map_err(Status::err_from_raw)
.expect("node get_attributes() error");
let node = Node {
name: expected_node.name.clone(),
mode: mut_attrs.mode.expect("node attributes missing mode"),
uid: mut_attrs.uid.expect("node attributes missing uid"),
gid: mut_attrs.gid.expect("node attributes missing gid"),
};
node_proxy
.close()
.await
.expect("node close failed")
.map_err(Status::err_from_raw)
.expect("node close error");
assert_eq!(node, *expected_node);
}
root.close().await.unwrap().map_err(Status::err_from_raw).unwrap();
}
#[fuchsia::test]
async fn test_constructing_writeable_fs_and_writing_to_allocated_region() {
// Create a device that is Ext4 formatted.
let server = Arc::new(VmoBackedServer::from_file(BLOCK_SIZE, "/pkg/data/nest.img"));
let server_clone = server.clone();
let (block_client_end1, block_server_end1) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task =
executor.run_singlethreaded(server_clone.serve(block_server_end1.into_stream()));
});
// Write to the allocated extent of this file.
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end1),
/* read_only= */ false,
&fuchsia_inspect::Inspector::default(),
)
.expect("failed to parse the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE | fio::PERM_WRITABLE,
);
let file = open_file(&root, "file1", fio::PERM_READABLE | fio::PERM_WRITABLE)
.await
.expect("failed to open file");
let original_contents = "file1 contents.\n";
assert_eq!(read_to_string(&file).await.expect("failed to read file"), original_contents);
let new_contents = "new";
let offset = 5;
file.seek(fio::SeekOrigin::Start, offset)
.await
.expect("failed FIDL seek")
.map_err(zx::Status::err_from_raw)
.expect("failed to seek file");
write(&file, new_contents).await.expect("failed to write to file");
file.close()
.await
.expect("failed FIDL file close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close file");
root.close()
.await
.expect("failed FIDL dir close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close root");
// Construct Ext4 fs again, and verify that the written data is still there.
let server_clone = server.clone();
let (block_client_end2, block_server_end2) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task =
executor.run_singlethreaded(server_clone.serve(block_server_end2.into_stream()));
});
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end2),
/* read_only= */ true,
&fuchsia_inspect::Inspector::default(),
)
.expect("construct_fs parses the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE,
);
let file =
open_file(&root, "file1", fio::PERM_READABLE).await.expect("failed to open file");
let mut expected_bytes = original_contents.as_bytes().to_vec();
expected_bytes[offset as usize..offset as usize + new_contents.len()]
.copy_from_slice(new_contents.as_bytes());
assert_eq!(
read_to_string(&file).await.expect("failed to read file"),
String::from_utf8(expected_bytes).unwrap()
);
file.close()
.await
.expect("failed FIDL file close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close file");
root.close()
.await
.expect("failed FIDL dir close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close root");
}
#[fuchsia::test]
async fn test_writing_past_eof_fails() {
let server = Arc::new(VmoBackedServer::from_file(BLOCK_SIZE, "/pkg/data/nest.img"));
let server_clone = server.clone();
let (block_client_end1, block_server_end1) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task =
executor.run_singlethreaded(server_clone.serve(block_server_end1.into_stream()));
});
// Write to the allocated extent of this file.
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end1),
/* read_only= */ false,
&fuchsia_inspect::Inspector::default(),
)
.expect("failed to parse the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE | fio::PERM_WRITABLE,
);
let file = open_file(&root, "file1", fio::PERM_READABLE | fio::PERM_WRITABLE)
.await
.expect("failed to open file");
let original_contents = read_to_string(&file).await.expect("failed to read file");
// There is not enough allocated bytes in this file to write this new content.
let new_contents = [1u8; 8192];
file.seek(fio::SeekOrigin::Start, 0)
.await
.expect("failed FIDL seek")
.map_err(zx::Status::err_from_raw)
.expect("failed to seek file");
let error = write(&file, &new_contents)
.await
.expect_err("write to unallocated region passed unexpectedly");
match error {
WriteError::WriteError(status) => assert_eq!(status, zx::Status::NOT_SUPPORTED),
_ => panic!("Unexpected error: {:?}", error),
}
file.close()
.await
.expect("failed FIDL file close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close file");
root.close()
.await
.expect("failed FIDL dir close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close root");
// Construct Ext4 fs again, and verify that the written data is still there.
let server_clone = server.clone();
let (block_client_end2, block_server_end2) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task =
executor.run_singlethreaded(server_clone.serve(block_server_end2.into_stream()));
});
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end2),
/* read_only= */ true,
&fuchsia_inspect::Inspector::default(),
)
.expect("construct_fs parses the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE,
);
let file =
open_file(&root, "file1", fio::PERM_READABLE).await.expect("failed to open file");
assert_eq!(read_to_string(&file).await.expect("failed to read file"), original_contents);
file.close()
.await
.expect("failed FIDL file close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close file");
root.close()
.await
.expect("failed FIDL dir close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close root");
}
#[fuchsia::test]
async fn test_file_sync() {
let data = fs::read("/pkg/data/nest.img").expect("failed to read file");
let vmo = Vmo::create(data.len() as u64).expect("failed to create VMO");
vmo.write(data.as_slice(), 0).expect("failed to write to VMO");
// Clone VMO to observe underlying changes made by the server.
let vmo_clone = vmo.duplicate_handle(zx::Rights::SAME_RIGHTS).expect("failed to clone vmo");
let server =
VmoBackedServer::from_vmo(BLOCK_SIZE, vmo).expect("Failed to create VmoBackedServer");
let (block_client_end, block_server_end) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task = executor.run_singlethreaded(server.serve(block_server_end.into_stream()));
});
// Write to the allocated extent of this file.
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end),
/* read_only= */ false,
&fuchsia_inspect::Inspector::default(),
)
.expect("failed to parse the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE | fio::PERM_WRITABLE,
);
let file = open_file(&root, "file1", fio::PERM_READABLE | fio::PERM_WRITABLE)
.await
.expect("failed to open file");
let mut old_vmo_contents = vec![0u8; data.len()];
vmo_clone.read(&mut old_vmo_contents, 0).expect("failed to read from vmo clone");
let new_contents = "FILE1 CONTENTS!\n";
file.seek(fio::SeekOrigin::Start, 0)
.await
.expect("failed FIDL seek")
.map_err(zx::Status::err_from_raw)
.expect("failed to seek file");
write(&file, new_contents).await.expect("failed to write to file");
let mut vmo_contents_after_write = vec![0u8; data.len()];
vmo_clone.read(&mut vmo_contents_after_write, 0).expect("failed to read from vmo clone");
// The write is stored in the device cache but has not yet been been flushed to the
// underlying VMO.
assert_eq!(
old_vmo_contents, vmo_contents_after_write,
"Data should be cached and not yet flushed to VmoBackedServer"
);
// Closing the file will call sync to flush the contents to the backing VMO.
file.close()
.await
.expect("sync check failed")
.map_err(zx::Status::err_from_raw)
.expect("sync error");
let mut vmo_contents_after_sync = vec![0u8; data.len()];
vmo_clone.read(&mut vmo_contents_after_sync, 0).expect("failed to read from vmo clone");
// Data should now be flushed to underlying VMO.
assert_ne!(
old_vmo_contents, vmo_contents_after_sync,
"Data should be flushed to VmoBackedServer after sync"
);
root.close()
.await
.expect("failed FIDL dir close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close root");
}
#[fuchsia::test]
async fn test_metrics_of_fs_with_multiple_files() {
let server = VmoBackedServer::from_file(BLOCK_SIZE, "/pkg/data/nest.img");
let (block_client_end, block_server_end) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task = executor.run_singlethreaded(server.serve(block_server_end.into_stream()));
});
let inspector = fuchsia_inspect::Inspector::default();
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end),
/* read_only= */ false,
&inspector,
)
.expect("failed to parse the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE | fio::PERM_WRITABLE,
);
let file1 = open_file(
&root,
"file1",
fio::PERM_READABLE | fio::PERM_WRITABLE | fio::Flags::FILE_TRUNCATE,
)
.await
.expect("open with truncate should succeed");
let contents = read_to_string(&file1).await.expect("failed to read file");
assert_eq!(contents, "");
diagnostics_assertions::assert_data_tree!(inspector, root: {
file_metrics: {
num_open_requests: 1u64,
num_read_requests: 1u64,
num_truncate_requests: 1u64,
num_write_requests: 0u64,
num_writes_past_eof_attempts: 0u64,
num_successful_overwrites: 0u64,
num_blocks_overwritten: 0u64,
}
});
file1
.seek(fio::SeekOrigin::Start, 0)
.await
.expect("failed to seek")
.map_err(zx::Status::err_from_raw)
.expect("seek error");
write(&file1, "FILE1 CONTENTS!\n").await.expect("failed to write to file");
file1
.seek(fio::SeekOrigin::Start, 0)
.await
.expect("failed to seek")
.map_err(zx::Status::err_from_raw)
.expect("seek error");
// `read_to_string` loops read until no bytes are read back. So for non-empty strings, we
// expect to see two more read requests.
let new_contents = read_to_string(&file1).await.expect("failed to read file");
assert_eq!(new_contents, "FILE1 CONTENTS!\n");
diagnostics_assertions::assert_data_tree!(inspector, root: {
file_metrics: {
num_open_requests: 1u64,
num_read_requests: 3u64,
num_truncate_requests: 1u64,
num_write_requests: 1u64,
num_writes_past_eof_attempts: 0u64,
num_successful_overwrites: 1u64,
num_blocks_overwritten: 1u64,
}
});
// Perform opens and reads on another file. Should see them reflected in the inspector
// metrics.
let file2 = open_file(&root, "inner/file2", fio::PERM_READABLE | fio::PERM_WRITABLE)
.await
.expect("failed to open inner/file2");
let _contents = read_to_string(&file2).await.expect("failed to read file2");
diagnostics_assertions::assert_data_tree!(inspector, root: {
file_metrics: {
num_open_requests: 2u64,
num_read_requests: 5u64,
num_truncate_requests: 1u64,
num_write_requests: 1u64,
num_writes_past_eof_attempts: 0u64,
num_successful_overwrites: 1u64,
num_blocks_overwritten: 1u64,
}
});
root.close()
.await
.expect("failed FIDL dir close")
.map_err(zx::Status::err_from_raw)
.expect("failed to close root");
}
#[fuchsia::test]
async fn test_truncate_and_write() {
let server = VmoBackedServer::from_file(BLOCK_SIZE, "/pkg/data/1file.img");
let (block_client_end, block_server_end) =
fidl::endpoints::create_endpoints::<fblock::BlockMarker>();
std::thread::spawn(move || {
let mut executor = fasync::TestExecutor::new();
let _task = executor.run_singlethreaded(server.serve(block_server_end.into_stream()));
});
let inspector = fuchsia_inspect::Inspector::default();
let tree = construct_fs(
FsSourceType::BlockDevice(block_client_end),
/* read_only= */ false,
&inspector,
)
.expect("failed to parse the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE | fio::PERM_WRITABLE,
);
// Check original contents
let file = open_file(&root, "file1", fio::PERM_READABLE).await.expect("open failed");
let original_contents = read_to_string(&file).await.expect("read failed");
assert_eq!(original_contents, "file1 contents.\n");
file.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
// Open with TRUNCATE, reading from this should return empty string.
let file = open_file(
&root,
"file1",
fio::PERM_READABLE | fio::PERM_WRITABLE | fio::Flags::FILE_TRUNCATE,
)
.await
.expect("open with truncate failed");
assert_eq!(read_to_string(&file).await.expect("read failed"), "");
// Write to the file and verify we see new contents.
let new_content = "FILE1 CONTENTS.\n";
write(&file, new_content).await.expect("write failed");
file.seek(fio::SeekOrigin::Start, 0)
.await
.expect("seek failed")
.map_err(zx::Status::err_from_raw)
.expect("seek error");
assert_eq!(read_to_string(&file).await.expect("read failed"), new_content);
// Check that writing past original file size fails.
let huge_content = vec![1u8; 50];
let error =
write(&file, &huge_content).await.expect_err("write past allocated size should fail");
match error {
WriteError::WriteError(status) => assert_eq!(status, zx::Status::NOT_SUPPORTED),
_ => panic!("Unexpected error: {:?}", error),
}
// Check that overwriting the file partially is not supported.
let partial_content = vec![1u8; 2];
let error = write(&file, &partial_content)
.await
.expect_err("write past allocated size should fail");
match error {
WriteError::WriteError(status) => assert_eq!(status, zx::Status::NOT_SUPPORTED),
_ => panic!("Unexpected error: {:?}", error),
}
// We see the content written previously.
file.seek(fio::SeekOrigin::Start, 0)
.await
.expect("seek failed")
.map_err(zx::Status::err_from_raw)
.expect("seek error");
assert_eq!(read_to_string(&file).await.expect("read failed"), new_content);
file.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
root.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
}
#[fuchsia::test]
async fn test_symlink() {
let root_dir = ExtDirectory::new(1, ExtAttributes::default(), XattrMap::default());
let symlink_target = b"target/path";
let symlink_node = ExtSymlink::new(
2,
ExtAttributes::default(),
XattrMap::default(),
symlink_target.to_vec(),
);
root_dir.insert_child("my_symlink", symlink_node).unwrap();
let root = vfs::directory::serve(
root_dir,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE,
);
// Verify readdir lists the symlink with DirentKind::Symlink
let expected =
vec![DirEntry { name: String::from("my_symlink"), kind: DirentKind::Symlink }];
assert_eq!(readdir(&root).await.unwrap(), expected);
// Verify we can open the symlink and read its target
let (symlink_proxy, server_end) = fidl::endpoints::create_proxy::<fio::SymlinkMarker>();
root.open(
"my_symlink",
fio::Flags::PROTOCOL_SYMLINK | fio::PERM_READABLE,
&fio::Options::default(),
server_end.into_channel().into(),
)
.expect("open symlink failed");
let target_bytes = symlink_proxy.describe().await.expect("describe failed").target.unwrap();
assert_eq!(target_bytes, symlink_target);
// Verify that trying to traverse through the symlink fails with
// NOT_DIR.
let (node_proxy, server_end) = fidl::endpoints::create_proxy::<fio::NodeMarker>();
root.open(
"my_symlink/child",
fio::Flags::empty(),
&fio::Options::default(),
server_end.into_channel().into(),
)
.expect("open path through symlink failed");
let mut event_stream = node_proxy.take_event_stream();
let event = event_stream.next().await.unwrap().expect_err("expected closed channel error");
match event {
fidl::Error::ClientChannelClosed { epitaph, .. } => {
assert_eq!(epitaph, Status::NOT_DIR)
}
other => panic!("Unexpected event error: {:?}", other),
}
symlink_proxy.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
root.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
}
#[fuchsia::test]
async fn test_symlink_from_image() {
let data = fs::read("/pkg/data/symlink.img").expect("Unable to read file");
let vmo = Vmo::create(data.len() as u64).expect("VMO is created");
vmo.write(data.as_slice(), 0).expect("VMO write() succeeds");
let buffer = FsSourceType::Vmo(vmo);
let tree = construct_fs(buffer, true, &fuchsia_inspect::Inspector::default())
.expect("construct_fs parses the vmo");
let root = vfs::directory::serve(
tree,
vfs::execution_scope::ExecutionScope::new(),
fio::PERM_READABLE,
);
let expected = vec![
DirEntry { name: String::from("file1"), kind: DirentKind::File },
DirEntry { name: String::from("lost+found"), kind: DirentKind::Directory },
DirEntry { name: String::from("symlink1"), kind: DirentKind::Symlink },
];
let mut actual = readdir(&root).await.unwrap();
actual.sort_by_key(|e| e.name.clone());
assert_eq!(actual, expected);
let (symlink_proxy, server_end) = fidl::endpoints::create_proxy::<fio::SymlinkMarker>();
root.open(
"symlink1",
fio::Flags::PROTOCOL_SYMLINK | fio::PERM_READABLE,
&fio::Options::default(),
server_end.into_channel().into(),
)
.expect("open symlink failed");
let target_bytes = symlink_proxy.describe().await.expect("describe failed").target.unwrap();
assert_eq!(target_bytes, b"file1");
symlink_proxy.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
root.close().await.unwrap().map_err(zx::Status::err_from_raw).unwrap();
}
}