Skip to main content

ahrightos_fs/
ramfs.rs

1//! 内存文件系统(RamFS)
2//!
3//! 将所有数据存储在RAM中的简单文件系统
4
5use super::file::{File, FileError, FileType, SeekFrom};
6use super::inode::{permissions, Inode};
7use alloc::collections::BTreeMap;
8use alloc::string::String;
9use alloc::sync::Arc;
10use alloc::vec::Vec;
11use spin::Mutex;
12
13// Teaching crate logging is intentionally a no-op here; kernel-specific
14// console output stays in the executable crate.
15#[allow(unused_macros)]
16macro_rules! fs_log {
17    ($($arg:tt)*) => {};
18}
19
20/// RamFS Inode结构
21///
22/// 存储文件元数据和数据
23pub struct RamInode {
24    ino: usize,          // Inode编号
25    file_type: FileType, // 文件类型
26    mode: u32,           // 权限位
27    size: usize,         // 文件大小
28    created: u64,        // 创建时间
29    modified: u64,       // 修改时间
30    nlinks: usize,       // 硬链接计数
31
32    // 文件数据(用于普通文件)
33    data: Vec<u8>,
34
35    // 目录项(用于目录)
36    entries: BTreeMap<String, Arc<Mutex<RamInode>>>,
37}
38
39impl RamInode {
40    /// 创建新的文件inode
41    pub fn new_file(ino: usize) -> Self {
42        fs_log!("Creating new file inode #{}", ino);
43        RamInode {
44            ino,
45            file_type: FileType::RegularFile,
46            mode: permissions::S_DEFAULT_FILE, // 0o644
47            size: 0,
48            created: 0,
49            modified: 0,
50            nlinks: 1,
51            data: Vec::new(),
52            entries: BTreeMap::new(),
53        }
54    }
55
56    /// 创建新的目录inode
57    pub fn new_directory(ino: usize) -> Self {
58        fs_log!("Creating new directory inode #{}", ino);
59        RamInode {
60            ino,
61            file_type: FileType::Directory,
62            mode: permissions::S_DEFAULT_DIR, // 0o755
63            size: 0,
64            created: 0,
65            modified: 0,
66            nlinks: 1,
67            data: Vec::new(),
68            entries: BTreeMap::new(),
69        }
70    }
71
72    /// Return file metadata for stat-like callers.
73    pub fn metadata(&self) -> super::file::FileMetadata {
74        super::file::FileMetadata {
75            file_type: self.file_type,
76            size: self.size,
77            mode: self.mode,
78            created: self.created,
79            modified: self.modified,
80        }
81    }
82
83    /// Return the inode link count.
84    pub fn nlinks(&self) -> usize {
85        self.nlinks
86    }
87
88    /// 从文件的指定位置读取数据
89    ///
90    /// # 参数
91    /// * `offset` - 起始位置
92    /// * `buf` - 读取缓冲区
93    ///
94    /// # 返回值
95    /// * Ok(n) - 成功读取n字节
96    /// * Err(e) - 读取失败
97    pub fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize, FileError> {
98        // 检查文件类型
99        if self.file_type != FileType::RegularFile {
100            return Err(FileError::IsDirectory);
101        }
102
103        if offset >= self.data.len() {
104            return Ok(0);
105        }
106
107        let end = core::cmp::min(offset.saturating_add(buf.len()), self.data.len());
108        let n = end - offset;
109        buf[..n].copy_from_slice(&self.data[offset..end]);
110        Ok(n)
111    }
112
113    /// 向文件的指定位置写入数据
114    ///
115    /// # 参数
116    /// * `offset` - 起始位置
117    /// * `buf` - 要写入的数据
118    ///
119    /// # 返回值
120    /// * Ok(n) - 成功写入n字节
121    /// * Err(e) - 写入失败
122    pub fn write_at(&mut self, offset: usize, buf: &[u8]) -> Result<usize, FileError> {
123        if self.file_type != FileType::RegularFile {
124            return Err(FileError::IsDirectory);
125        }
126
127        let end = offset
128            .checked_add(buf.len())
129            .ok_or(FileError::InvalidOperation)?;
130        if end > self.data.len() {
131            self.data.resize(end, 0);
132        }
133
134        self.data[offset..end].copy_from_slice(buf);
135        self.size = self.data.len();
136        self.modified += 1;
137        Ok(buf.len())
138    }
139
140    /// 将文件截断到指定大小
141    ///
142    /// # 参数
143    /// * `size` - 新的文件大小
144    ///
145    /// # 示例
146    /// - truncate(0): 清空文件
147    /// - truncate(100): 将文件设置为100字节
148    pub fn truncate(&mut self, size: usize) -> Result<(), FileError> {
149        if self.file_type != FileType::RegularFile {
150            return Err(FileError::IsDirectory);
151        }
152
153        self.data.resize(size, 0);
154        self.size = size;
155        self.modified += 1;
156        Ok(())
157    }
158
159    /// 向目录添加条目
160    ///
161    /// # 参数
162    /// * `name` - 条目名称
163    /// * `inode` - Inode引用
164    ///
165    /// # 错误
166    /// * NotDirectory - 不是目录
167    /// * AlreadyExists - 条目已存在
168    pub fn add_entry(
169        &mut self,
170        name: String,
171        inode: Arc<Mutex<RamInode>>,
172    ) -> Result<(), FileError> {
173        // Step 1: 检查文件类型
174        if self.file_type != FileType::Directory {
175            return Err(FileError::NotDirectory);
176        }
177        // Step 2: 检查是否已存在同名条目
178        if self.entries.contains_key(&name) {
179            return Err(FileError::AlreadyExists);
180        }
181        // Step 3: 插入新条目
182        self.entries.insert(name, inode);
183        self.size = self.entries.len();
184        self.modified += 1;
185        // Step 4: 返回成功
186        Ok(())
187    }
188
189    /// 在目录中查找条目
190    ///
191    /// # 参数
192    /// * `name` - 要查找的条目名称
193    ///
194    /// # 返回值
195    /// * Ok(inode) - 找到的条目
196    /// * Err(NotFound) - 条目不存在
197    pub fn lookup(&self, name: &str) -> Result<Arc<Mutex<RamInode>>, FileError> {
198        if self.file_type != FileType::Directory {
199            return Err(FileError::NotDirectory);
200        }
201
202        self.entries.get(name).cloned().ok_or(FileError::NotFound)
203    }
204
205    /// 从目录中删除条目
206    ///
207    /// # 参数
208    /// * `name` - 要删除的条目名称
209    ///
210    /// # 注意
211    /// 只删除目录项,不删除inode
212    /// (当引用计数为0时,Inode会自动释放)
213    pub fn remove_entry(&mut self, name: &str) -> Result<(), FileError> {
214        if self.file_type != FileType::Directory {
215            return Err(FileError::NotDirectory);
216        }
217
218        self.entries.remove(name).ok_or(FileError::NotFound)?;
219        self.size = self.entries.len();
220        self.modified += 1;
221        Ok(())
222    }
223
224    /// 列出目录中的所有条目
225    ///
226    /// # 返回值
227    /// 条目名称的向量(按字母顺序排序)
228    pub fn list_entries(&self) -> Result<Vec<String>, FileError> {
229        if self.file_type != FileType::Directory {
230            return Err(FileError::NotDirectory);
231        }
232
233        Ok(self.entries.keys().cloned().collect())
234    }
235}
236
237/// 实现Inode trait
238impl Inode for RamInode {
239    fn ino(&self) -> usize {
240        self.ino
241    }
242
243    fn file_type(&self) -> FileType {
244        self.file_type
245    }
246
247    fn size(&self) -> usize {
248        self.size
249    }
250
251    fn mode(&self) -> u32 {
252        self.mode
253    }
254}
255
256/// RamFS文件句柄
257///
258/// 包装RamInode并维护当前offset
259pub struct RamFile {
260    inode: Arc<Mutex<RamInode>>,
261    offset: usize, // 当前读写位置
262}
263
264impl RamFile {
265    pub fn new(inode: Arc<Mutex<RamInode>>) -> Self {
266        RamFile { inode, offset: 0 }
267    }
268}
269
270/// 实现File trait
271impl File for RamFile {
272    /// 从当前offset读取
273    fn read(&mut self, buf: &mut [u8]) -> Result<usize, FileError> {
274        let n = self.inode.lock().read_at(self.offset, buf)?;
275        self.offset += n; // 更新offset
276        Ok(n)
277    }
278
279    /// 向当前offset写入
280    fn write(&mut self, buf: &[u8]) -> Result<usize, FileError> {
281        let n = self.inode.lock().write_at(self.offset, buf)?;
282        self.offset += n; // 更新offset
283        Ok(n)
284    }
285
286    /// 移动到新位置
287    fn seek(&mut self, pos: SeekFrom) -> Result<usize, FileError> {
288        let size = self.inode.lock().size();
289        let new_offset = match pos {
290            SeekFrom::Start(offset) => offset,
291            SeekFrom::Current(delta) if delta >= 0 => self.offset.saturating_add(delta as usize),
292            SeekFrom::Current(delta) => self.offset.saturating_sub((-delta) as usize),
293            SeekFrom::End(delta) if delta >= 0 => size.saturating_add(delta as usize),
294            SeekFrom::End(delta) => size.saturating_sub((-delta) as usize),
295        };
296
297        self.offset = new_offset;
298        Ok(self.offset)
299    }
300}
301
302/// RamFS文件系统
303///
304/// 管理inode分配和根目录
305pub struct RamFS {
306    root: Arc<Mutex<RamInode>>, // 根目录
307    next_ino: Mutex<usize>,     // 下一个可用的inode号
308}
309
310impl RamFS {
311    pub fn new() -> Self {
312        let root = Arc::new(Mutex::new(RamInode::new_directory(1)));
313        RamFS {
314            root,
315            next_ino: Mutex::new(2), // 1已分配给root
316        }
317    }
318
319    fn alloc_ino(&self) -> usize {
320        let mut next = self.next_ino.lock();
321        let ino = *next;
322        *next += 1;
323        ino
324    }
325
326    pub fn root(&self) -> Arc<Mutex<RamInode>> {
327        self.root.clone()
328    }
329
330    /// 在目录中创建文件
331    ///
332    /// # 参数
333    /// * `parent` - 父目录inode
334    /// * `name` - 文件名
335    ///
336    /// # 返回值
337    /// 新文件的inode
338    pub fn create_file(
339        &self,
340        parent: Arc<Mutex<RamInode>>,
341        name: String,
342    ) -> Result<Arc<Mutex<RamInode>>, FileError> {
343        let ino = self.alloc_ino();
344        let inode = Arc::new(Mutex::new(RamInode::new_file(ino)));
345        parent.lock().add_entry(name, inode.clone())?;
346        Ok(inode)
347    }
348
349    /// 在父目录中创建目录
350    pub fn create_directory(
351        &self,
352        parent: Arc<Mutex<RamInode>>,
353        name: String,
354    ) -> Result<Arc<Mutex<RamInode>>, FileError> {
355        let ino = self.alloc_ino();
356        let inode = Arc::new(Mutex::new(RamInode::new_directory(ino)));
357        parent.lock().add_entry(name, inode.clone())?;
358        Ok(inode)
359    }
360
361    /// 删除文件或目录
362    ///
363    /// # 注意
364    /// 删除目录前必须为空
365    pub fn remove(&self, parent: Arc<Mutex<RamInode>>, name: &str) -> Result<(), FileError> {
366        parent.lock().remove_entry(name)
367    }
368
369    /// 在目录中查找文件
370    pub fn lookup(
371        &self,
372        parent: Arc<Mutex<RamInode>>,
373        name: &str,
374    ) -> Result<Arc<Mutex<RamInode>>, FileError> {
375        parent.lock().lookup(name)
376    }
377
378    /// 打开文件用于读写
379    ///
380    /// # 错误
381    /// * IsDirectory - 不能将目录作为文件打开
382    pub fn open_file(&self, inode: Arc<Mutex<RamInode>>) -> Result<RamFile, FileError> {
383        let file_type = inode.lock().file_type();
384        if file_type != FileType::RegularFile {
385            return Err(FileError::IsDirectory);
386        }
387        Ok(RamFile::new(inode))
388    }
389}
390
391impl Default for RamFS {
392    fn default() -> Self {
393        Self::new()
394    }
395}