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 
136         // 如果文件指针已经超过了文件大小，则返回0
137         if self.offset > self.inode.metadata()?.size as usize {
138             return Ok(0);
139         }
140 
141         let len = self
142             .inode
143             .read_at(self.offset, len, buf, &mut self.private_data)?;
144         self.offset += len;
145         return Ok(len);
146     }
147 
148     /// @brief 从buffer向文件写入指定的字节数的数据
149     ///
150     /// @param len 要写入的字节数
151     /// @param buf 源数据buffer
152     ///
153     /// @return Ok(usize) 成功写入的字节数
154     /// @return Err(SystemError) 错误码
write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError>155     pub fn write(&mut self, len: usize, buf: &[u8]) -> Result<usize, SystemError> {
156         // 先检查本文件在权限等规则下，是否可写入。
157         self.writeable()?;
158         if buf.len() < len {
159             return Err(SystemError::ENOBUFS);
160         }
161 
162         // 如果文件指针已经超过了文件大小，则需要扩展文件大小
163         let file_size = self.inode.metadata()?.size as usize;
164         if self.offset > file_size {
165             self.inode.resize(self.offset)?;
166         }
167         let len = self
168             .inode
169             .write_at(self.offset, len, buf, &mut self.private_data)?;
170         self.offset += len;
171         return Ok(len);
172     }
173 
174     /// @brief 获取文件的元数据
metadata(&self) -> Result<Metadata, SystemError>175     pub fn metadata(&self) -> Result<Metadata, SystemError> {
176         return self.inode.metadata();
177     }
178 
179     /// @brief 根据inode号获取子目录项的名字
get_entry_name(&self, ino: usize) -> Result<String, SystemError>180     pub fn get_entry_name(&self, ino: usize) -> Result<String, SystemError> {
181         return self.inode.get_entry_name(ino);
182     }
183 
184     /// @brief 调整文件操作指针的位置
185     ///
186     /// @param origin 调整的起始位置
lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError>187     pub fn lseek(&mut self, origin: SeekFrom) -> Result<usize, SystemError> {
188         let file_type = self.inode.metadata()?.file_type;
189         match file_type {
190             FileType::Pipe | FileType::CharDevice => {
191                 return Err(SystemError::ESPIPE);
192             }
193             _ => {}
194         }
195 
196         let pos: i64;
197         match origin {
198             SeekFrom::SeekSet(offset) => {
199                 pos = offset;
200             }
201             SeekFrom::SeekCurrent(offset) => {
202                 pos = self.offset as i64 + offset;
203             }
204             SeekFrom::SeekEnd(offset) => {
205                 let metadata = self.metadata()?;
206                 pos = metadata.size + offset;
207             }
208             SeekFrom::Invalid => {
209                 return Err(SystemError::EINVAL);
210             }
211         }
212         // 根据linux man page, lseek允许超出文件末尾，并且不改变文件大小
213         // 当pos超出文件末尾时，read返回0。直到开始写入数据时，才会改变文件大小
214         if pos < 0 {
215             return Err(SystemError::EOVERFLOW);
216         }
217         self.offset = pos as usize;
218         return Ok(self.offset);
219     }
220 
221     /// @brief 判断当前文件是否可读
222     #[inline]
readable(&self) -> Result<(), SystemError>223     pub fn readable(&self) -> Result<(), SystemError> {
224         // 暂时认为只要不是write only, 就可读
225         if self.mode == FileMode::O_WRONLY {
226             return Err(SystemError::EPERM);
227         }
228 
229         return Ok(());
230     }
231 
232     /// @brief 判断当前文件是否可写
233     #[inline]
writeable(&self) -> Result<(), SystemError>234     pub fn writeable(&self) -> Result<(), SystemError> {
235         // 暂时认为只要不是read only, 就可写
236         if self.mode == FileMode::O_RDONLY {
237             return Err(SystemError::EPERM);
238         }
239 
240         return Ok(());
241     }
242 
243     /// @biref 充填dirent结构体
244     /// @return 返回dirent结构体的大小
readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError>245     pub fn readdir(&mut self, dirent: &mut Dirent) -> Result<u64, SystemError> {
246         let inode: &Arc<dyn IndexNode> = &self.inode;
247 
248         // 如果偏移量为0
249         if self.offset == 0 {
250             self.readdir_subdirs_name = inode.list()?;
251             self.readdir_subdirs_name.sort();
252         }
253 
254         // kdebug!("sub_entries={sub_entries:?}");
255         if self.readdir_subdirs_name.is_empty() {
256             self.offset = 0;
257             return Ok(0);
258         }
259         let name: String = self.readdir_subdirs_name.remove(0);
260         let sub_inode: Arc<dyn IndexNode> = match inode.find(&name) {
261             Ok(i) => i,
262             Err(e) => {
263                 kerror!("Readdir error: Failed to find sub inode, file={self:?}");
264                 return Err(e);
265             }
266         };
267 
268         let name_bytes: &[u8] = name.as_bytes();
269 
270         self.offset += 1;
271         dirent.d_ino = sub_inode.metadata().unwrap().inode_id as u64;
272         dirent.d_off = 0;
273         dirent.d_reclen = 0;
274         dirent.d_type = sub_inode.metadata().unwrap().file_type.get_file_type_num() as u8;
275         // 根据posix的规定，dirent中的d_name是一个不定长的数组，因此需要unsafe来拷贝数据
276         unsafe {
277             let ptr = &mut dirent.d_name as *mut u8;
278             let buf: &mut [u8] =
279                 ::core::slice::from_raw_parts_mut::<'static, u8>(ptr, name_bytes.len());
280             buf.copy_from_slice(name_bytes);
281         }
282 
283         // 计算dirent结构体的大小
284         return Ok((name_bytes.len() + ::core::mem::size_of::<Dirent>()
285             - ::core::mem::size_of_val(&dirent.d_name)) as u64);
286     }
287 
inode(&self) -> Arc<dyn IndexNode>288     pub fn inode(&self) -> Arc<dyn IndexNode> {
289         return self.inode.clone();
290     }
291 
292     /// @brief 尝试克隆一个文件
293     ///
294     /// @return Option<Box<File>> 克隆后的文件结构体。如果克隆失败，返回None
try_clone(&self) -> Option<Box<File>>295     pub fn try_clone(&self) -> Option<Box<File>> {
296         let mut res: Box<File> = Box::new(Self {
297             inode: self.inode.clone(),
298             offset: self.offset.clone(),
299             mode: self.mode.clone(),
300             file_type: self.file_type.clone(),
301             readdir_subdirs_name: self.readdir_subdirs_name.clone(),
302             private_data: self.private_data.clone(),
303         });
304         // 调用inode的open方法，让inode知道有新的文件打开了这个inode
305         if self.inode.open(&mut res.private_data, &res.mode).is_err() {
306             return None;
307         }
308 
309         return Some(res);
310     }
311 
312     /// @brief 获取文件的类型
313     #[inline]
file_type(&self) -> FileType314     pub fn file_type(&self) -> FileType {
315         return self.file_type;
316     }
317 
318     /// @brief 获取文件的打开模式
319     #[inline]
mode(&self) -> FileMode320     pub fn mode(&self) -> FileMode {
321         return self.mode;
322     }
323 
324     /// 获取文件是否在execve时关闭
325     #[inline]
close_on_exec(&self) -> bool326     pub fn close_on_exec(&self) -> bool {
327         return self.mode.contains(FileMode::O_CLOEXEC);
328     }
329 
330     /// 设置文件是否在execve时关闭
331     #[inline]
set_close_on_exec(&mut self, close_on_exec: bool)332     pub fn set_close_on_exec(&mut self, close_on_exec: bool) {
333         if close_on_exec {
334             self.mode.insert(FileMode::O_CLOEXEC);
335         } else {
336             self.mode.remove(FileMode::O_CLOEXEC);
337         }
338     }
339 
set_mode(&mut self, mode: FileMode) -> Result<(), SystemError>340     pub fn set_mode(&mut self, mode: FileMode) -> Result<(), SystemError> {
341         // todo: 是否需要调用inode的open方法，以更新private data（假如它与mode有关的话）?
342         // 也许需要加个更好的设计，让inode知晓文件的打开模式发生了变化，让它自己决定是否需要更新private data
343 
344         // 直接修改文件的打开模式
345         self.mode = mode;
346         return Ok(());
347     }
348 
349     /// @brief 重新设置文件的大小
350     ///
351     /// 如果文件大小增加，则文件内容不变，但是文件的空洞部分会被填充为0
352     /// 如果文件大小减小，则文件内容会被截断
353     ///
354     /// @return 成功：Ok()
355     ///         失败：Err(错误码)
ftruncate(&mut self, len: usize) -> Result<(), SystemError>356     pub fn ftruncate(&mut self, len: usize) -> Result<(), SystemError> {
357         // 如果文件不可写，返回错误
358         self.writeable()?;
359 
360         // 调用inode的truncate方法
361         self.inode.resize(len)?;
362         return Ok(());
363     }
364 }
365 
366 impl Drop for File {
drop(&mut self)367     fn drop(&mut self) {
368         let r: Result<(), SystemError> = self.inode.close(&mut self.private_data);
369         // 打印错误信息
370         if r.is_err() {
371             kerror!(
372                 "pid: {} failed to close file: {:?}, errno={:?}",
373                 current_pcb().pid,
374                 self,
375                 r.unwrap_err()
376             );
377         }
378     }
379 }
380 
381 /// @brief pcb里面的文件描述符数组
382 #[derive(Debug)]
383 pub struct FileDescriptorVec {
384     /// 当前进程打开的文件描述符
385     pub fds: [Option<Box<File>>; FileDescriptorVec::PROCESS_MAX_FD],
386 }
387 
388 impl FileDescriptorVec {
389     pub const PROCESS_MAX_FD: usize = 32;
390 
new() -> Box<FileDescriptorVec>391     pub fn new() -> Box<FileDescriptorVec> {
392         // 先声明一个未初始化的数组
393         let mut data: [MaybeUninit<Option<Box<File>>>; FileDescriptorVec::PROCESS_MAX_FD] =
394             unsafe { MaybeUninit::uninit().assume_init() };
395 
396         // 逐个把每个元素初始化为None
397         for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
398             data[i] = MaybeUninit::new(None);
399         }
400         // 由于一切都初始化完毕，因此将未初始化的类型强制转换为已经初始化的类型
401         let data: [Option<Box<File>>; FileDescriptorVec::PROCESS_MAX_FD] = unsafe {
402             core::mem::transmute::<_, [Option<Box<File>>; FileDescriptorVec::PROCESS_MAX_FD]>(data)
403         };
404 
405         // 初始化文件描述符数组结构体
406         return Box::new(FileDescriptorVec { fds: data });
407     }
408 
409     /// @brief 克隆一个文件描述符数组
410     ///
411     /// @return Box<FileDescriptorVec> 克隆后的文件描述符数组
clone(&self) -> Box<FileDescriptorVec>412     pub fn clone(&self) -> Box<FileDescriptorVec> {
413         let mut res: Box<FileDescriptorVec> = FileDescriptorVec::new();
414         for i in 0..FileDescriptorVec::PROCESS_MAX_FD {
415             if let Some(file) = &self.fds[i] {
416                 res.fds[i] = file.try_clone();
417             }
418         }
419         return res;
420     }
421 
422     /// @brief 从pcb的fds字段，获取文件描述符数组的可变引用
423     #[inline]
from_pcb(pcb: &'static process_control_block) -> Option<&'static mut FileDescriptorVec>424     pub fn from_pcb(pcb: &'static process_control_block) -> Option<&'static mut FileDescriptorVec> {
425         return unsafe { (pcb.fds as usize as *mut FileDescriptorVec).as_mut() };
426     }
427 
428     /// @brief 判断文件描述符序号是否合法
429     ///
430     /// @return true 合法
431     ///
432     /// @return false 不合法
433     #[inline]
validate_fd(fd: i32) -> bool434     pub fn validate_fd(fd: i32) -> bool {
435         if fd < 0 || fd as usize > FileDescriptorVec::PROCESS_MAX_FD {
436             return false;
437         } else {
438             return true;
439         }
440     }
441 }
442