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