| // 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, ¤t_task.kernel().mounts, |child| { | |
| let info = child.node.info(); | |
| info.mode.fmt() == device_metadata.mode.file_type() && info.rdev == device_metadata.devt | |
| }); | |
| Ok(()) | |
| } |