xref: /DragonOS/kernel/src/filesystem/vfs/file.rs (revision 676b8ef62e1a0a1e52d65b40c53c1636a2954040) 
1 use core::mem::MaybeUninit;
2 
3 use alloc::{boxed::Box, string::String, sync::Arc, vec::Vec};
4 
5 use crate::{
6     arch::asm::current::current_pcb,
7     driver::tty::TtyFilePrivateData,
8     filesystem::procfs::ProcfsFilePrivateData,
9     include::bindings::bindings::{
10         process_control_block,
11     },
12     io::SeekFrom,
13     kerror, syscall::SystemError,
14 };
15 
16 use super::{Dirent, FileType, IndexNode, Metadata};
17 
18 /// 文件私有信息的枚举类型
19 #[derive(Debug, Clone)]
20 pub enum FilePrivateData {
21     /// procfs文件私有信息
22     Procfs(ProcfsFilePrivateData),
23     /// Tty设备的私有信息
24     Tty(TtyFilePrivateData),
25     /// 不需要文件私有信息
26     Unused,
27 }
28 
29 impl Default for FilePrivateData {
30     fn default() -> Self {
31         return Self::Unused;
32     }
33 }
34 
35 bitflags! {
36     /// @brief 文件打开模式
37     /// 其中，低2bit组合而成的数字的值，用于表示访问权限。其他的bit，才支持通过按位或的方式来表示参数
38     ///
39     /// 与Linux 5.19.10的uapi/asm-generic/fcntl.h相同
40     /// https://opengrok.ringotek.cn/xref/linux-5.19.10/tools/include/uapi/asm-generic/fcntl.h#19
41     pub struct FileMode: u32{
42     /* File access modes for `open' and `fcntl'.  */
43     /// Open Read-only
44     const O_RDONLY = 0o0;
45     /// Open Write-only
46     const O_WRONLY = 0o1;
47     /// Open read/write
48     const O_RDWR = 0o2;
49     /// Mask for file access modes
50     const O_ACCMODE = 0o00000003;
51 
52     /* Bits OR'd into the second argument to open.  */
53     /// Create file if it does not exist
54     const O_CREAT = 0o00000100;
55     /// Fail if file already exists
56     const O_EXCL = 0o00000200;
57     /// Do not assign controlling terminal
58     const O_NOCTTY = 0o00000400;
59     /// 文件存在且是普通文件，并以O_RDWR或O_WRONLY打开，则它会被清空
60     const O_TRUNC = 0o00001000;
61     /// 文件指针会被移动到文件末尾
62     const O_APPEND = 0o00002000;
63     /// 非阻塞式IO模式
64     const O_NONBLOCK = 0o00004000;
65     /// used to be O_SYNC, see below
66     const O_DSYNC = 0o00010000;
67     /// fcntl, for BSD compatibility
68     const FASYNC = 0o00020000;
69     /* direct disk access hint */
70     const O_DIRECT = 0o00040000;
71     const O_LARGEFILE = 0o00100000;
72     /// 打开的必须是一个目录
73     const O_DIRECTORY = 0o00200000;
74     /// Do not follow symbolic links
75     const O_NOFOLLOW = 0o00400000;
76     const O_NOATIME = 0o01000000;
77     /// set close_on_exec
78     const O_CLOEXEC = 0o02000000;
79     }
80 }
81 
82 /// @brief 抽象文件结构体
83 #[derive(Debug)]
84 pub struct File {
85     inode: Arc<dyn IndexNode>,
86     /// 对于文件，表示字节偏移量；对于文件夹，表示当前操作的子目录项偏移量
87     offset: usize,
88     /// 文件的打开模式
89     mode: FileMode,
90     /// 文件类型
91     file_type: FileType,
92     /// readdir时候用的，暂存的本次循环中，所有子目录项的名字的数组
93     readdir_subdirs_name: Vec<String>,
94     pub private_data: FilePrivateData,
95 }
96 
97 impl File {
98     /// @brief 创建一个新的文件对象
99     ///
100     /// @param inode 文件对象对应的inode
101     /// @param mode 文件的打开模式
102     pub fn new(inode: Arc<dyn IndexNode>, mode: FileMode) -> Result<Self, SystemError> {
103         let file_type: FileType = inode.metadata()?.file_type;
104         let mut f = File {
105             inode,
106             offset: 0,
107             mode,
108             file_type,
109             readdir_subdirs_name: Vec::new(),
110             private_data: FilePrivateData::default(),
111         };
112         // kdebug!("inode:{:?}",f.inode);
113         f.inode.open(&mut f.private_data, &mode)?;
114         return Ok(f);
115     }
116 
117     /// @brief 从文件中读取指定的字节数到buffer中
118     ///
119     /// @param len 要读取的字节数
120     /// @param buf 目标buffer
121     ///
122     /// @return Ok(usize) 成功读取的字节数
123     /// @return Err(SystemError) 错误码
124     pub fn read(&mut self, len: usize, buf: &mut [u8]) -> Result<usize, SystemError> {
125         // 先检查本文件在权限等规则下，是否可读取。
126         self.readable()?;
127 
128         if buf.len() < len {
129             return Err(SystemError::ENOBUFS);
130         }
131 
132         let len = self
133             .inode
134             .read_at(self.offset, len, buf, &mut self.private_data)?;
135         self.offset += len;
136         return Ok(len);
137     }
138 
139     /// @brief 从buffer向文件写入指定的字节数的数据
140     ///
141     /// @param len 要写入的字节数
142     /// @param buf 源数据buffer
143     ///
144     /// @return Ok(usize) 成功写入的字节数
145     /// @return Err(SystemError) 错误码
146     pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
147         // 先检查本文件在权限等规则下，是否可写入。
148         self.writeable()?;
149         if buf.len() < len {
150             return Err(SystemError::ENOBUFS);
151         }
152         let len = self
153             .inode
154             .write_at(self.offset, len, buf, &mut FilePrivateData::Unused)?;
155         self.offset += len;
156         return Ok(len);
157     }
158 
159     /// @brief 获取文件的元数据
160     pub fn metadata(&self) -> Result<Metadata, SystemError> {
161         return self.inode.metadata();
162     }
163 
164     /// @brief 根据inode号获取子目录项的名字
165     pub fn get_entry_name(&self, ino: usize) -> Result<String, SystemError> {
166         return self.inode.get_entry_name(ino);
167     }
168 
169     /// @brief 调整文件操作指针的位置
170     ///
171     /// @param origin 调整的起始位置
172     pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
173         if self.inode.metadata().unwrap().file_type == FileType::Pipe {
174             return Err(SystemError::ESPIPE);
175         }
176         let pos: i64;
177         match origin {
178             SeekFrom::SeekSet(offset) => {
179                 pos = offset;
180             }
181             SeekFrom::SeekCurrent(offset) => {
182                 pos = self.offset as i64 + offset;
183             }
184             SeekFrom::SeekEnd(offset) => {
185                 let metadata = self.metadata()?;
186                 pos = metadata.size + offset;
187             }
188             SeekFrom::Invalid => {
189                 return Err(SystemError::EINVAL);
190             }
191         }
192 
193         if pos < 0 || pos > self.metadata()?.size {
194             return Err(SystemError::EOVERFLOW);
195         }
196         self.offset = pos as usize;
197         return Ok(self.offset);
198     }
199 
200     /// @brief 判断当前文件是否可读
201     #[inline]
202     pub fn readable(&self) -> Result<(), SystemError> {
203         // 暂时认为只要不是write only, 就可读
204         if self.mode == FileMode::O_WRONLY {
205             return Err(SystemError::EPERM);
206         }
207 
208         return Ok(());
209     }
210 
211     /// @brief 判断当前文件是否可写
212     #[inline]
213     pub fn writeable(&self) -> Result<(), SystemError> {
214         // 暂时认为只要不是read only, 就可写
215         if self.mode == FileMode::O_RDONLY {
216             return Err(SystemError::EPERM);
217         }
218 
219         return Ok(());
220     }
221 
222     /// @biref 充填dirent结构体
223     /// @return 返回dirent结构体的大小
224     pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError> {
225         let inode: &Arc<dyn IndexNode> = &self.inode;
226 
227         // 如果偏移量为0
228         if self.offset == 0 {
229             self.readdir_subdirs_name = inode.list()?;
230             self.readdir_subdirs_name.sort();
231         }
232 
233         // kdebug!("sub_entries={sub_entries:?}");
234         if self.readdir_subdirs_name.is_empty() {
235             self.offset = 0;
236             return Ok(0);
237         }
238         let name: String = self.readdir_subdirs_name.remove(0);
239         let sub_inode: Arc<dyn IndexNode> = match inode.find(&name) {
240             Ok(i) => i,
241             Err(e) => {
242                 kerror!("Readdir error: Failed to find sub inode, file={self:?}");
243                 return Err(e);
244             }
245         };
246 
247         let name_bytes: &[u8] = name.as_bytes();
248 
249         self.offset += 1;
250         dirent.d_ino = sub_inode.metadata().unwrap().inode_id as u64;
251         dirent.d_off = 0;
252         dirent.d_reclen = 0;
253         dirent.d_type = sub_inode.metadata().unwrap().file_type.get_file_type_num() as u8;
254         // 根据posix的规定，dirent中的d_name是一个不定长的数组，因此需要unsafe来拷贝数据
255         unsafe {
256             let ptr = &mut dirent.d_name as *mut u8;
257             let buf: &mut [u8] =
258                 ::core::slice::from_raw_parts_mut::<'static, u8>(ptr, name_bytes.len());
259             buf.copy_from_slice(name_bytes);
260         }
261 
262         // 计算dirent结构体的大小
263         return Ok((name_bytes.len() + ::core::mem::size_of::<Dirent>()
264             - ::core::mem::size_of_val(&dirent.d_name)) as u64);
265     }
266 
267     pub fn inode(&self) -> Arc<dyn IndexNode> {
268         return self.inode.clone();
269     }
270 
271     /// @brief 尝试克隆一个文件
272     ///
273     /// @return Option<Box<File>> 克隆后的文件结构体。如果克隆失败，返回None
274     pub fn try_clone(&self) -> Option<Box<File>> {
275         let mut res: Box<File> = Box::new(Self {
276             inode: self.inode.clone(),
277             offset: self.offset.clone(),
278             mode: self.mode.clone(),
279             file_type: self.file_type.clone(),
280             readdir_subdirs_name: self.readdir_subdirs_name.clone(),
281             private_data: self.private_data.clone(),
282         });
283         // 调用inode的open方法，让inode知道有新的文件打开了这个inode
284         if self.inode.open(&mut res.private_data, &res.mode).is_err() {
285             return None;
286         }
287 
288         return Some(res);
289     }
290 }
291 
292 impl Drop for File {
293     fn drop(&mut self) {
294         let r: Result<(), SystemError> = self.inode.close(&mut self.private_data);
295         // 打印错误信息
296         if r.is_err() {
297             kerror!(
298                 "pid: {} failed to close file: {:?}, errno={:?}",
299                 current_pcb().pid,
300                 self,
301                 r.unwrap_err()
302             );
303         }
304     }
305 }
306 
307 /// @brief pcb里面的文件描述符数组
308 #[derive(Debug)]
309 pub struct FileDescriptorVec {
310     /// 当前进程打开的文件描述符
311     pub fds: [Option<Box<File>>; FileDescriptorVec::PROCESS_MAX_FD],
312 }
313 
314 impl FileDescriptorVec {
315     pub const PROCESS_MAX_FD: usize = 32;
316 
317     pub fn new() -> Box<FileDescriptorVec> {
318         // 先声明一个未初始化的数组
319         let mut data: [MaybeUninit<Option<Box<File>>>; FileDescriptorVec::PROCESS_MAX_FD] =
320             unsafe { MaybeUninit::uninit().assume_init() };
321 
322         // 逐个把每个元素初始化为None
323         for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
324             data[i] = MaybeUninit::new(None);
325         }
326         // 由于一切都初始化完毕，因此将未初始化的类型强制转换为已经初始化的类型
327         let data: [Option<Box<File>>; FileDescriptorVec::PROCESS_MAX_FD] = unsafe {
328             core::mem::transmute::<_, [Option<Box<File>>; FileDescriptorVec::PROCESS_MAX_FD]>(data)
329         };
330 
331         // 初始化文件描述符数组结构体
332         return Box::new(FileDescriptorVec { fds: data });
333     }
334 
335     /// @brief 克隆一个文件描述符数组
336     ///
337     /// @return Box<FileDescriptorVec> 克隆后的文件描述符数组
338     pub fn clone(&self) -> Box<FileDescriptorVec> {
339         let mut res: Box<FileDescriptorVec> = FileDescriptorVec::new();
340         for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
341             if let Some(file) = &self.fds[i] {
342                 res.fds[i] = file.try_clone();
343             }
344         }
345         return res;
346     }
347 
348     /// @brief 从pcb的fds字段，获取文件描述符数组的可变引用
349     #[inline]
350     pub fn from_pcb(pcb: &'static process_control_block) -> Option<&'static mut FileDescriptorVec> {
351         return unsafe { (pcb.fds as usize as *mut FileDescriptorVec).as_mut() };
352     }
353 
354     /// @brief 判断文件描述符序号是否合法
355     ///
356     /// @return true 合法
357     ///
358     /// @return false 不合法
359     #[inline]
360     pub fn validate_fd(fd: i32) -> bool {
361         if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD {
362             return false;
363         } else {
364             return true;
365         }
366     }
367 }
368