xref: /DragonOS/kernel/src/filesystem/devfs/mod.rs (revision 9fab312ea9921618629924ab15c28c2d255b21c6) 
1 /// 导出devfs的模块
2 pub mod null_dev;
3 pub mod zero_dev;
4 
5 use super::vfs::{
6     core::{generate_inode_id, ROOT_INODE},
7     file::FileMode,
8     syscall::ModeType,
9     FilePrivateData, FileSystem, FileType, FsInfo, IndexNode, Magic, Metadata, SuperBlock,
10 };
11 use crate::{
12     driver::base::device::device_number::DeviceNumber,
13     kerror, kinfo,
14     libs::{
15         once::Once,
16         spinlock::{SpinLock, SpinLockGuard},
17     },
18     time::PosixTimeSpec,
19 };
20 use alloc::{
21     collections::BTreeMap,
22     string::{String, ToString},
23     sync::{Arc, Weak},
24     vec::Vec,
25 };
26 use system_error::SystemError;
27 
28 const DEVFS_BLOCK_SIZE: u64 = 512;
29 const DEVFS_MAX_NAMELEN: usize = 255;
30 /// @brief dev文件系统
31 #[derive(Debug)]
32 pub struct DevFS {
33     // 文件系统根节点
34     root_inode: Arc<LockedDevFSInode>,
35     super_block: SuperBlock,
36 }
37 
38 impl FileSystem for DevFS {
39     fn as_any_ref(&self) -> &dyn core::any::Any {
40         self
41     }
42 
43     fn root_inode(&self) -> Arc<dyn super::vfs::IndexNode> {
44         return self.root_inode.clone();
45     }
46 
47     fn info(&self) -> super::vfs::FsInfo {
48         return FsInfo {
49             blk_dev_id: 0,
50             max_name_len: DEVFS_MAX_NAMELEN,
51         };
52     }
53 
54     fn name(&self) -> &str {
55         "devfs"
56     }
57 
58     fn super_block(&self) -> SuperBlock {
59         self.super_block.clone()
60     }
61 }
62 
63 impl DevFS {
64     pub fn new() -> Arc<Self> {
65         let super_block = SuperBlock::new(
66             Magic::DEVFS_MAGIC,
67             DEVFS_BLOCK_SIZE,
68             DEVFS_MAX_NAMELEN as u64,
69         );
70         // 初始化root inode
71         let root: Arc<LockedDevFSInode> = Arc::new(LockedDevFSInode(SpinLock::new(
72             // /dev 的权限设置为 读+执行，root 可以读写
73             // root 的 parent 是空指针
74             DevFSInode::new(FileType::Dir, ModeType::from_bits_truncate(0o755), 0),
75         )));
76 
77         let devfs: Arc<DevFS> = Arc::new(DevFS {
78             root_inode: root,
79             super_block,
80         });
81 
82         // 对root inode加锁，并继续完成初始化工作
83         let mut root_guard: SpinLockGuard<DevFSInode> = devfs.root_inode.0.lock();
84         root_guard.parent = Arc::downgrade(&devfs.root_inode);
85         root_guard.self_ref = Arc::downgrade(&devfs.root_inode);
86         root_guard.fs = Arc::downgrade(&devfs);
87         // 释放锁
88         drop(root_guard);
89 
90         // 创建文件夹
91         let root: &Arc<LockedDevFSInode> = &devfs.root_inode;
92         root.add_dir("char")
93             .expect("DevFS: Failed to create /dev/char");
94 
95         root.add_dir("block")
96             .expect("DevFS: Failed to create /dev/block");
97         devfs.register_bultinin_device();
98 
99         // kdebug!("ls /dev: {:?}", root.list());
100         return devfs;
101     }
102 
103     /// @brief 注册系统内部自带的设备
104     fn register_bultinin_device(&self) {
105         use null_dev::LockedNullInode;
106         use zero_dev::LockedZeroInode;
107         let dev_root: Arc<LockedDevFSInode> = self.root_inode.clone();
108         dev_root
109             .add_dev("null", LockedNullInode::new())
110             .expect("DevFS: Failed to register /dev/null");
111         dev_root
112             .add_dev("zero", LockedZeroInode::new())
113             .expect("DevFS: Failed to register /dev/zero");
114     }
115 
116     /// @brief 在devfs内注册设备
117     ///
118     /// @param name 设备名称
119     /// @param device 设备节点的结构体
120     pub fn register_device<T: DeviceINode>(
121         &self,
122         name: &str,
123         device: Arc<T>,
124     ) -> Result<(), SystemError> {
125         let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone();
126         let metadata = device.metadata()?;
127         match metadata.file_type {
128             // 字节设备挂载在 /dev/char
129             FileType::CharDevice => {
130                 if dev_root_inode.find("char").is_err() {
131                     dev_root_inode.create(
132                         "char",
133                         FileType::Dir,
134                         ModeType::from_bits_truncate(0o755),
135                     )?;
136                 }
137 
138                 let any_char_inode = dev_root_inode.find("char")?;
139                 let dev_char_inode: &LockedDevFSInode = any_char_inode
140                     .as_any_ref()
141                     .downcast_ref::<LockedDevFSInode>()
142                     .unwrap();
143                 // 在 /dev/char 下创建设备节点
144                 dev_char_inode.add_dev(name, device.clone())?;
145 
146                 // 特殊处理 tty 设备，挂载在 /dev 下
147                 if name.starts_with("tty") && name.len() > 3 {
148                     dev_root_inode.add_dev(name, device.clone())?;
149                 }
150                 // ptmx设备
151                 if name == "ptmx" {
152                     dev_root_inode.add_dev(name, device.clone())?;
153                 }
154                 device.set_fs(dev_char_inode.0.lock().fs.clone());
155             }
156             FileType::BlockDevice => {
157                 if dev_root_inode.find("block").is_err() {
158                     dev_root_inode.create(
159                         "block",
160                         FileType::Dir,
161                         ModeType::from_bits_truncate(0o755),
162                     )?;
163                 }
164 
165                 let any_block_inode = dev_root_inode.find("block")?;
166                 let dev_block_inode: &LockedDevFSInode = any_block_inode
167                     .as_any_ref()
168                     .downcast_ref::<LockedDevFSInode>()
169                     .unwrap();
170 
171                 dev_block_inode.add_dev(name, device.clone())?;
172                 device.set_fs(dev_block_inode.0.lock().fs.clone());
173             }
174             FileType::KvmDevice => {
175                 dev_root_inode
176                     .add_dev(name, device.clone())
177                     .expect("DevFS: Failed to register /dev/kvm");
178             }
179             FileType::FramebufferDevice => {
180                 dev_root_inode
181                     .add_dev(name, device.clone())
182                     .expect("DevFS: Failed to register /dev/fb");
183             }
184             _ => {
185                 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
186             }
187         }
188 
189         return Ok(());
190     }
191 
192     /// @brief 卸载设备
193     pub fn unregister_device<T: DeviceINode>(
194         &self,
195         name: &str,
196         device: Arc<T>,
197     ) -> Result<(), SystemError> {
198         let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone();
199         match device.metadata().unwrap().file_type {
200             // 字节设备挂载在 /dev/char
201             FileType::CharDevice => {
202                 if dev_root_inode.find("char").is_err() {
203                     return Err(SystemError::ENOENT);
204                 }
205 
206                 let any_char_inode = dev_root_inode.find("char")?;
207                 let dev_char_inode = any_char_inode
208                     .as_any_ref()
209                     .downcast_ref::<LockedDevFSInode>()
210                     .unwrap();
211                 // TODO： 调用设备的卸载接口（当引入卸载接口之后）
212                 dev_char_inode.remove(name)?;
213             }
214             FileType::BlockDevice => {
215                 if dev_root_inode.find("block").is_err() {
216                     return Err(SystemError::ENOENT);
217                 }
218 
219                 let any_block_inode = dev_root_inode.find("block")?;
220                 let dev_block_inode = any_block_inode
221                     .as_any_ref()
222                     .downcast_ref::<LockedDevFSInode>()
223                     .unwrap();
224 
225                 dev_block_inode.remove(name)?;
226             }
227             _ => {
228                 return Err(SystemError::EOPNOTSUPP_OR_ENOTSUP);
229             }
230         }
231 
232         return Ok(());
233     }
234 }
235 
236 /// @brief dev文件i节点(锁)
237 #[derive(Debug)]
238 pub struct LockedDevFSInode(SpinLock<DevFSInode>);
239 
240 /// @brief dev文件i节点(无锁)
241 #[derive(Debug)]
242 pub struct DevFSInode {
243     /// 指向父Inode的弱引用
244     parent: Weak<LockedDevFSInode>,
245     /// 指向自身的弱引用
246     self_ref: Weak<LockedDevFSInode>,
247     /// 子Inode的B树
248     children: BTreeMap<String, Arc<dyn IndexNode>>,
249     /// 指向inode所在的文件系统对象的指针
250     fs: Weak<DevFS>,
251     /// INode 元数据
252     metadata: Metadata,
253 }
254 
255 impl DevFSInode {
256     pub fn new(dev_type_: FileType, mode: ModeType, data_: usize) -> Self {
257         return Self::new_with_parent(Weak::default(), dev_type_, mode, data_);
258     }
259 
260     pub fn new_with_parent(
261         parent: Weak<LockedDevFSInode>,
262         dev_type_: FileType,
263         mode: ModeType,
264         data_: usize,
265     ) -> Self {
266         return DevFSInode {
267             parent,
268             self_ref: Weak::default(),
269             children: BTreeMap::new(),
270             metadata: Metadata {
271                 dev_id: 1,
272                 inode_id: generate_inode_id(),
273                 size: 0,
274                 blk_size: 0,
275                 blocks: 0,
276                 atime: PosixTimeSpec::default(),
277                 mtime: PosixTimeSpec::default(),
278                 ctime: PosixTimeSpec::default(),
279                 file_type: dev_type_, // 文件夹
280                 mode,
281                 nlinks: 1,
282                 uid: 0,
283                 gid: 0,
284                 raw_dev: DeviceNumber::from(data_ as u32),
285             },
286             fs: Weak::default(),
287         };
288     }
289 }
290 
291 impl LockedDevFSInode {
292     pub fn add_dir(&self, name: &str) -> Result<(), SystemError> {
293         let guard: SpinLockGuard<DevFSInode> = self.0.lock();
294 
295         if guard.children.contains_key(name) {
296             return Err(SystemError::EEXIST);
297         }
298 
299         match self.do_create_with_data(
300             guard,
301             name,
302             FileType::Dir,
303             ModeType::from_bits_truncate(0o755),
304             0,
305         ) {
306             Ok(inode) => inode,
307             Err(err) => {
308                 return Err(err);
309             }
310         };
311 
312         return Ok(());
313     }
314 
315     pub fn add_dev(&self, name: &str, dev: Arc<dyn IndexNode>) -> Result<(), SystemError> {
316         let mut this = self.0.lock();
317 
318         if this.children.contains_key(name) {
319             return Err(SystemError::EEXIST);
320         }
321 
322         this.children.insert(name.to_string(), dev);
323         return Ok(());
324     }
325 
326     pub fn remove(&self, name: &str) -> Result<(), SystemError> {
327         let x = self
328             .0
329             .lock()
330             .children
331             .remove(name)
332             .ok_or(SystemError::ENOENT)?;
333 
334         drop(x);
335         return Ok(());
336     }
337 
338     fn do_create_with_data(
339         &self,
340         mut guard: SpinLockGuard<DevFSInode>,
341         name: &str,
342         file_type: FileType,
343         mode: ModeType,
344         data: usize,
345     ) -> Result<Arc<dyn IndexNode>, SystemError> {
346         if guard.metadata.file_type != FileType::Dir {
347             return Err(SystemError::ENOTDIR);
348         }
349 
350         // 如果有重名的，则返回
351         if guard.children.contains_key(name) {
352             return Err(SystemError::EEXIST);
353         }
354 
355         // 创建inode
356         let result: Arc<LockedDevFSInode> = Arc::new(LockedDevFSInode(SpinLock::new(DevFSInode {
357             parent: guard.self_ref.clone(),
358             self_ref: Weak::default(),
359             children: BTreeMap::new(),
360             metadata: Metadata {
361                 dev_id: 0,
362                 inode_id: generate_inode_id(),
363                 size: 0,
364                 blk_size: 0,
365                 blocks: 0,
366                 atime: PosixTimeSpec::default(),
367                 mtime: PosixTimeSpec::default(),
368                 ctime: PosixTimeSpec::default(),
369                 file_type,
370                 mode,
371                 nlinks: 1,
372                 uid: 0,
373                 gid: 0,
374                 raw_dev: DeviceNumber::from(data as u32),
375             },
376             fs: guard.fs.clone(),
377         })));
378 
379         // 初始化inode的自引用的weak指针
380         result.0.lock().self_ref = Arc::downgrade(&result);
381 
382         // 将子inode插入父inode的B树中
383         guard.children.insert(String::from(name), result.clone());
384         return Ok(result);
385     }
386 }
387 
388 impl IndexNode for LockedDevFSInode {
389     fn as_any_ref(&self) -> &dyn core::any::Any {
390         self
391     }
392 
393     fn open(
394         &self,
395         _data: SpinLockGuard<FilePrivateData>,
396         _mode: &FileMode,
397     ) -> Result<(), SystemError> {
398         return Ok(());
399     }
400 
401     fn close(&self, _data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> {
402         return Ok(());
403     }
404 
405     fn create_with_data(
406         &self,
407         name: &str,
408         file_type: FileType,
409         mode: ModeType,
410         data: usize,
411     ) -> Result<Arc<dyn IndexNode>, SystemError> {
412         // 获取当前inode
413         let guard: SpinLockGuard<DevFSInode> = self.0.lock();
414         // 如果当前inode不是文件夹，则返回
415         return self.do_create_with_data(guard, name, file_type, mode, data);
416     }
417 
418     fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
419         let inode = self.0.lock();
420 
421         if inode.metadata.file_type != FileType::Dir {
422             return Err(SystemError::ENOTDIR);
423         }
424 
425         match name {
426             "" | "." => {
427                 return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
428             }
429             ".." => {
430                 return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
431             }
432             name => {
433                 // 在子目录项中查找
434                 return Ok(inode.children.get(name).ok_or(SystemError::ENOENT)?.clone());
435             }
436         }
437     }
438 
439     fn fs(&self) -> Arc<dyn FileSystem> {
440         return self.0.lock().fs.upgrade().unwrap();
441     }
442 
443     fn get_entry_name(&self, ino: super::vfs::InodeId) -> Result<String, SystemError> {
444         let inode: SpinLockGuard<DevFSInode> = self.0.lock();
445         if inode.metadata.file_type != FileType::Dir {
446             return Err(SystemError::ENOTDIR);
447         }
448 
449         match ino.into() {
450             0 => {
451                 return Ok(String::from("."));
452             }
453             1 => {
454                 return Ok(String::from(".."));
455             }
456             ino => {
457                 // 暴力遍历所有的children，判断inode id是否相同
458                 // TODO: 优化这里，这个地方性能很差！
459                 let mut key: Vec<String> = inode
460                     .children
461                     .keys()
462                     .filter(|k| {
463                         inode
464                             .children
465                             .get(*k)
466                             .unwrap()
467                             .metadata()
468                             .unwrap()
469                             .inode_id
470                             .into()
471                             == ino
472                     })
473                     .cloned()
474                     .collect();
475 
476                 match key.len() {
477                     0=>{return Err(SystemError::ENOENT);}
478                     1=>{return Ok(key.remove(0));}
479                     _ => panic!("Devfs get_entry_name: key.len()={key_len}>1, current inode_id={inode_id:?}, to find={to_find:?}", key_len=key.len(), inode_id = inode.metadata.inode_id, to_find=ino)
480                 }
481             }
482         }
483     }
484 
485     fn ioctl(
486         &self,
487         _cmd: u32,
488         _data: usize,
489         _private_data: &FilePrivateData,
490     ) -> Result<usize, SystemError> {
491         Err(SystemError::EOPNOTSUPP_OR_ENOTSUP)
492     }
493 
494     fn list(&self) -> Result<Vec<String>, SystemError> {
495         let info = self.metadata()?;
496         if info.file_type != FileType::Dir {
497             return Err(SystemError::ENOTDIR);
498         }
499 
500         let mut keys: Vec<String> = Vec::new();
501         keys.push(String::from("."));
502         keys.push(String::from(".."));
503         keys.append(&mut self.0.lock().children.keys().cloned().collect());
504 
505         return Ok(keys);
506     }
507 
508     fn metadata(&self) -> Result<Metadata, SystemError> {
509         return Ok(self.0.lock().metadata.clone());
510     }
511 
512     fn set_metadata(&self, metadata: &Metadata) -> Result<(), SystemError> {
513         let mut inode = self.0.lock();
514         inode.metadata.atime = metadata.atime;
515         inode.metadata.mtime = metadata.mtime;
516         inode.metadata.ctime = metadata.ctime;
517         inode.metadata.mode = metadata.mode;
518         inode.metadata.uid = metadata.uid;
519         inode.metadata.gid = metadata.gid;
520 
521         return Ok(());
522     }
523 
524     /// 读设备 - 应该调用设备的函数读写，而不是通过文件系统读写
525     fn read_at(
526         &self,
527         _offset: usize,
528         _len: usize,
529         _buf: &mut [u8],
530         _data: SpinLockGuard<FilePrivateData>,
531     ) -> Result<usize, SystemError> {
532         kerror!("DevFS: read_at is not supported!");
533         Err(SystemError::EOPNOTSUPP_OR_ENOTSUP)
534     }
535 
536     /// 写设备 - 应该调用设备的函数读写，而不是通过文件系统读写
537     fn write_at(
538         &self,
539         _offset: usize,
540         _len: usize,
541         _buf: &[u8],
542         _data: SpinLockGuard<FilePrivateData>,
543     ) -> Result<usize, SystemError> {
544         Err(SystemError::EOPNOTSUPP_OR_ENOTSUP)
545     }
546 }
547 
548 /// @brief 所有的设备INode都需要额外实现这个trait
549 pub trait DeviceINode: IndexNode {
550     fn set_fs(&self, fs: Weak<DevFS>);
551     // TODO: 增加 unregister 方法
552 }
553 
554 /// @brief 获取devfs实例的强类型不可变引用
555 macro_rules! devfs_exact_ref {
556     () => {{
557         let devfs_inode: Result<Arc<dyn IndexNode>, SystemError> = ROOT_INODE().find("dev");
558         if let Err(e) = devfs_inode {
559             kerror!("failed to get DevFS ref. errcode = {:?}", e);
560             return Err(SystemError::ENOENT);
561         }
562 
563         let binding = devfs_inode.unwrap();
564         let devfs_inode: &LockedDevFSInode = binding
565             .as_any_ref()
566             .downcast_ref::<LockedDevFSInode>()
567             .unwrap();
568         let binding = devfs_inode.fs();
569         binding
570     }
571     .as_any_ref()
572     .downcast_ref::<DevFS>()
573     .unwrap()};
574 }
575 /// @brief devfs的设备注册函数
576 pub fn devfs_register<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), SystemError> {
577     return devfs_exact_ref!().register_device(name, device);
578 }
579 
580 /// @brief devfs的设备卸载函数
581 #[allow(dead_code)]
582 pub fn devfs_unregister<T: DeviceINode>(name: &str, device: Arc<T>) -> Result<(), SystemError> {
583     return devfs_exact_ref!().unregister_device(name, device);
584 }
585 
586 pub fn devfs_init() -> Result<(), SystemError> {
587     static INIT: Once = Once::new();
588     let mut result = None;
589     INIT.call_once(|| {
590         kinfo!("Initializing DevFS...");
591         // 创建 devfs 实例
592         let devfs: Arc<DevFS> = DevFS::new();
593         // devfs 挂载
594         let _t = ROOT_INODE()
595             .find("dev")
596             .expect("Cannot find /dev")
597             .mount(devfs)
598             .expect("Failed to mount devfs");
599         kinfo!("DevFS mounted.");
600         result = Some(Ok(()));
601     });
602 
603     return result.unwrap();
604 }
605