1use 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#[allow(unused_macros)]
16macro_rules! fs_log {
17 ($($arg:tt)*) => {};
18}
19
20pub struct RamInode {
24 ino: usize, file_type: FileType, mode: u32, size: usize, created: u64, modified: u64, nlinks: usize, data: Vec<u8>,
34
35 entries: BTreeMap<String, Arc<Mutex<RamInode>>>,
37}
38
39impl RamInode {
40 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, size: 0,
48 created: 0,
49 modified: 0,
50 nlinks: 1,
51 data: Vec::new(),
52 entries: BTreeMap::new(),
53 }
54 }
55
56 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, size: 0,
64 created: 0,
65 modified: 0,
66 nlinks: 1,
67 data: Vec::new(),
68 entries: BTreeMap::new(),
69 }
70 }
71
72 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 pub fn nlinks(&self) -> usize {
85 self.nlinks
86 }
87
88 pub fn read_at(&self, offset: usize, buf: &mut [u8]) -> Result<usize, FileError> {
98 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 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 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 pub fn add_entry(
169 &mut self,
170 name: String,
171 inode: Arc<Mutex<RamInode>>,
172 ) -> Result<(), FileError> {
173 if self.file_type != FileType::Directory {
175 return Err(FileError::NotDirectory);
176 }
177 if self.entries.contains_key(&name) {
179 return Err(FileError::AlreadyExists);
180 }
181 self.entries.insert(name, inode);
183 self.size = self.entries.len();
184 self.modified += 1;
185 Ok(())
187 }
188
189 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 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 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
237impl 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
256pub struct RamFile {
260 inode: Arc<Mutex<RamInode>>,
261 offset: usize, }
263
264impl RamFile {
265 pub fn new(inode: Arc<Mutex<RamInode>>) -> Self {
266 RamFile { inode, offset: 0 }
267 }
268}
269
270impl File for RamFile {
272 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; Ok(n)
277 }
278
279 fn write(&mut self, buf: &[u8]) -> Result<usize, FileError> {
281 let n = self.inode.lock().write_at(self.offset, buf)?;
282 self.offset += n; Ok(n)
284 }
285
286 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
302pub struct RamFS {
306 root: Arc<Mutex<RamInode>>, next_ino: Mutex<usize>, }
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), }
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 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 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 pub fn remove(&self, parent: Arc<Mutex<RamInode>>, name: &str) -> Result<(), FileError> {
366 parent.lock().remove_entry(name)
367 }
368
369 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 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}