blob: a53a4e0d281ed58cf2bd256a831abbeba51b1f19 [file]
// Copyright 2021 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::device::DeviceMode;
use crate::device::kobject::DeviceMetadata;
use crate::fs::tmpfs::TmpFs;
use crate::security;
use crate::task::dynamic_thread_spawner::SpawnRequestBuilder;
use crate::task::{CurrentTask, Kernel};
use crate::vfs::{
DirEntryHandle, FileSystemHandle, FileSystemOptions, FsNodeHandle, FsStr, LookupContext,
MountInfo, NamespaceNode, path,
};
use starnix_uapi::auth::FsCred;
use starnix_uapi::device_id::DeviceId;
use starnix_uapi::errors::Errno;
use starnix_uapi::file_mode::{FileMode, mode};
use std::sync::OnceLock;
pub fn dev_tmp_fs(
current_task: &CurrentTask,
_options: FileSystemOptions,
) -> Result<FileSystemHandle, Errno> {
Ok(DevTmpFs::from_kernel(current_task.kernel()))
}
pub struct DevTmpFs(());
#[derive(Default)]
struct DevTmpFsHandle(OnceLock<FileSystemHandle>);
impl DevTmpFs {
pub fn from_kernel(kernel: &Kernel) -> FileSystemHandle {
assert!(kernel.features.devtmpfs, "devtmpfs must be enabled in KernelFeatures");
kernel.expando.get::<DevTmpFsHandle>().0.get_or_init(|| Self::init(kernel)).clone()
}
fn from_kthread(current_task: &CurrentTask) -> FileSystemHandle {
let kernel = current_task.kernel();
assert!(kernel.features.devtmpfs, "devtmpfs must be enabled in KernelFeatures");
kernel
.expando
.get::<DevTmpFsHandle>()
.0
.get_or_init(|| Self::init_on_kthread(current_task))
.clone()
}
fn init(kernel: &Kernel) -> FileSystemHandle {
let (result_fn, req) = SpawnRequestBuilder::new()
.with_debug_name("devtmpfs-init")
.with_sync_closure(Self::init_on_kthread)
.build_with_sync_result();
kernel.kthreads.spawner().spawn_from_request(req);
result_fn().unwrap()
}
fn init_on_kthread(current_task: &CurrentTask) -> FileSystemHandle {
let kernel = current_task.kernel();
let fs = TmpFs::new_fs_with_name(kernel, "devtmpfs".into());
fs.root().node.update_info(|info| info.chmod(mode!(IFDIR, 0o755)));
security::file_system_resolve_security(current_task, &fs)
.expect("resolve devtmpfs security");
let root = fs.root();
devtmpfs_get_or_create_directory_at(current_task, root, "shm".into()).unwrap();
devtmpfs_get_or_create_directory_at(current_task, root, "pts".into()).unwrap();
let create_symlink = |dir: &FsNodeHandle, mount: &MountInfo, name: &FsStr| {
let target = "/proc/self/fd".into();
dir.create_symlink(current_task, mount, name, target, FsCred::root())
};
let mount = MountInfo::detached();
root.create_entry(current_task, &mount, "fd".into(), create_symlink).unwrap();
fs
}
}
/// Creates a device node in the devtmpfs filesystem.
///
/// This function executes the creation in a background thread and blocks the
/// calling thread until the device node is fully created. This blocking behavior
/// matches Linux.
pub fn devtmpfs_create_device(
kernel: &Kernel,
device_metadata: DeviceMetadata,
) -> Result<(), Errno> {
let closure = move |current_task: &CurrentTask| {
devtmpfs_create_device_internal(current_task, &device_metadata)
};
let (result_fn, req) = SpawnRequestBuilder::new()
.with_debug_name("devtmpfs-create-device")
.with_sync_closure(closure)
.build_with_sync_result();
kernel.kthreads.spawner().spawn_from_request(req);
result_fn()?
}
fn devtmpfs_create_device_internal(
current_task: &CurrentTask,
device_metadata: &DeviceMetadata,
) -> Result<(), Errno> {
let separator_pos = device_metadata.devname.iter().rposition(|&c| c == path::SEPARATOR);
let (device_path, device_name) = match separator_pos {
Some(pos) => device_metadata.devname.split_at(pos + 1),
None => (&[] as &[u8], device_metadata.devname.as_slice()),
};
let parent_dir = device_path
.split(|&c| c == path::SEPARATOR)
// Avoid EEXIST for 'foo//bar' and the last directory name.
.filter(|dir_name| dir_name.len() > 0)
.try_fold(DevTmpFs::from_kthread(current_task).root().clone(), |parent_dir, dir_name| {
devtmpfs_get_or_create_directory_at(current_task, &parent_dir, dir_name.into())
})?;
devtmpfs_create_device_node(
current_task,
parent_dir,
device_name.into(),
device_metadata.mode,
device_metadata.devt,
)
}
fn devtmpfs_get_or_create_directory_at(
current_task: &CurrentTask,
parent_dir: &DirEntryHandle,
dir_name: &FsStr,
) -> Result<DirEntryHandle, Errno> {
let create_dir = |dir: &FsNodeHandle, mount: &MountInfo, name: &FsStr| {
let mode = mode!(IFDIR, 0o755);
dir.create_node(current_task, mount, name, mode, DeviceId::NONE, FsCred::root())
};
let mount = MountInfo::detached();
let (entry, _status) =
parent_dir.get_or_create_entry(current_task, &mount, dir_name, create_dir)?;
Ok(entry)
}
fn devtmpfs_create_device_node(
current_task: &CurrentTask,
parent_dir: DirEntryHandle,
device_name: &FsStr,
device_mode: DeviceMode,
devt: DeviceId,
) -> Result<(), Errno> {
let mode = device_mode.file_type() | FileMode::from_bits(0o666);
// This creates content inside the temporary FS. This doesn't depend on the mount
// information.
parent_dir.create_entry(
current_task,
&MountInfo::detached(),
device_name,
|dir, mount, name| dir.create_node(current_task, mount, name, mode, devt, FsCred::root()),
)?;
Ok(())
}
/// Removes the device node for `device_metadata` from `devtmpfs` if its file mode and device ID
/// match `device_metadata`.
pub fn devtmpfs_remove_device(
current_task: &CurrentTask,
device_metadata: &DeviceMetadata,
) -> Result<(), Errno> {
let root_node =
NamespaceNode::new_anonymous(DevTmpFs::from_kernel(current_task.kernel()).root().clone());
let mut context = LookupContext::default();
let (parent_node, device_name) =
current_task.lookup_parent(&mut context, &root_node, device_metadata.devname.as_ref())?;
parent_node.entry.remove_child_if(device_name, &current_task.kernel().mounts, |child| {
let info = child.node.info();
info.mode.fmt() == device_metadata.mode.file_type() && info.rdev == device_metadata.devt
});
Ok(())
}