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