misc(absolute_path): rename and return a PathBuf

* Rename `absolute_path_str` -> `absolute_path`
* Make it return a `PathBuf`

Signed-off-by: Anhad Singh <[email protected]>

Author: Andy-Python-Programmer

src/aero_kernel/src/fs/cache.rs

@@ -38,6 +38,7 @@ use spin::Once;
 use crate::fs::inode::{DirEntry, INodeInterface};
 use crate::utils::sync::BMutex;
 
+use super::path::PathBuf;
 use super::FileSystem;
 
 pub static INODE_CACHE: Once<Arc<INodeCache>> = Once::new();
@@ -317,7 +318,7 @@ pub type DirCacheItem = CacheArc<CacheItem<DirCacheKey, DirEntry>>;
 impl Debug for DirCacheItem {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_tuple("DirCacheItem")
-            .field(&self.absolute_path_str())
+            .field(&self.absolute_path())
             .finish()
     }
 }
@@ -367,14 +368,14 @@ impl Cacheable<DirCacheKey> for DirEntry {
 }
 
 pub trait DirCacheImpl {
-    fn absolute_path_str(&self) -> String;
+    fn absolute_path(&self) -> PathBuf;
 }
 
 impl DirCacheImpl for DirCacheItem {
-    fn absolute_path_str(&self) -> String {
+    fn absolute_path(&self) -> PathBuf {
         let mut current_entry = Some(self.clone());
         let mut path_nodes = Vec::new();
-        let mut result = String::new();
+        let mut result = PathBuf::new();
 
         // We need to collect all of the path nodes, reverse them and then join them
         // with the path separator.
@@ -384,12 +385,13 @@ impl DirCacheImpl for DirCacheItem {
         }
 
         for node in path_nodes.iter().rev() {
-            result.push_str(node);
+            result.push(node.as_str());
+            // result.push_str(node);
 
-            // If we are not at the root node, we need to add the path separator.
-            if node != "/" {
-                result.push('/');
-            }
+            // // If we are not at the root node, we need to add the path separator.
+            // if node != "/" {
+            //     result.push('/');
+            // }
         }
 
         result

src/aero_kernel/src/fs/file_table.rs

@@ -68,17 +68,7 @@ impl FileHandle {
         let offset = self.offset.load(Ordering::SeqCst);
         let new_offset = self.inode.inode().read_at(offset, buffer)?;
 
-        if self.inode.absolute_path_str().contains("/tmp/ccAAAAAA.s") {
-            log::debug!(
-                "read {} bytes from {}  ----- hi mom ----- {:?}",
-                new_offset,
-                self.inode.absolute_path_str(),
-                buffer
-            );
-        }
-
         self.offset.fetch_add(new_offset, Ordering::SeqCst);
-
         Ok(new_offset)
     }
 
@@ -87,7 +77,6 @@ impl FileHandle {
         let new_offset = self.inode.inode().write_at(offset, buffer)?;
 
         self.offset.fetch_add(new_offset, Ordering::SeqCst);
-
         Ok(new_offset)
     }
 
@@ -223,7 +212,7 @@ impl FileTable {
             log::debug!(
                 "file handle: (fd={}, path=`{}`)",
                 handle.fd,
-                handle.inode.absolute_path_str()
+                handle.inode.absolute_path()
             )
         }
     }

src/aero_kernel/src/fs/mod.rs

@@ -223,7 +223,7 @@ pub fn lookup_path_with(
                                 ) {
                                     Ok(x) => x,
                                     Err(e) => {
-                                        dbg!(component, cwd.absolute_path_str());
+                                        dbg!(component, cwd.absolute_path());
                                         return Err(dbg!(e));
                                     }
                                 };

src/aero_kernel/src/fs/path.rs

@@ -66,6 +66,11 @@ impl Path {
     pub fn as_bytes(&self) -> &[u8] {
         self.0.as_bytes()
     }
+
+    /// Returns the byte length of the path.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
 }
 
 impl Borrow<Path> for PathBuf {
@@ -91,11 +96,24 @@ impl AsRef<Path> for Path {
     }
 }
 
+impl AsRef<Path> for &str {
+    #[inline]
+    fn as_ref(&self) -> &Path {
+        Path::new(self)
+    }
+}
+
 /// An owned, mutable path (akin to [`String`]).
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PathBuf(String);
 
 impl PathBuf {
+    /// Allocates an empty `PathBuf`.
+    #[inline]
+    pub fn new() -> Self {
+        Self(String::new())
+    }
+
     #[inline]
     fn as_mut_vec(&mut self) -> &mut Vec<u8> {
         // TODO: safety?
@@ -154,6 +172,13 @@ impl AsRef<Path> for PathBuf {
     }
 }
 
+impl Into<String> for PathBuf {
+    #[inline]
+    fn into(self) -> String {
+        self.0
+    }
+}
+
 impl Display for PathBuf {
     #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

src/aero_kernel/src/syscall/fs.rs

@@ -55,7 +55,7 @@ impl FileDescriptor {
 impl fmt::Display for FileDescriptor {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Ok(file_handle) = self.handle() {
-            let path = file_handle.inode.absolute_path_str();
+            let path = file_handle.inode.absolute_path();
             write!(f, "{{ {} -> {} }}", self.0, path)
         } else {
             // invalid file descriptor
@@ -470,7 +470,7 @@ pub fn fstat(fd: usize, path: &Path, flags: usize, stat: &mut Stat) -> Result<us
         return Ok(0);
     }
 
-    log::debug!("{}", at.absolute_path_str());
+    log::debug!("{}", at.absolute_path());
 
     let ent = fs::lookup_path_with(at, path, LookupMode::None, true)?;
     *stat = ent.inode().stat()?;
@@ -502,7 +502,7 @@ pub fn read_link(path: &Path, buffer: &mut [u8]) -> Result<usize, SyscallError>
     let resolved_path = if resolved_path.is_absolute() {
         resolved_path
     } else {
-        Path::new(&cwd.absolute_path_str()).join(resolved_path)
+        cwd.absolute_path().join(resolved_path)
     };
 
     let size = core::cmp::min(resolved_path.as_str().len(), buffer.len());

src/aero_kernel/src/userland/scheduler/mod.rs

@@ -131,9 +131,14 @@ impl Scheduler {
 
     pub fn log_ptable(&self) {
         self.tasks.0.lock().iter().for_each(|(pid, task)| {
+            let path: String = task
+                .path()
+                .map(|path| path.into())
+                .unwrap_or("<unknown>".into());
+
             log::info!(
                 "task(pid={pid:?}, path={:?}, state={:?})",
-                task.path().unwrap_or(String::from("<unknown>")),
+                path,
                 task.state()
             )
         });

src/aero_kernel/src/userland/task/mod.rs

@@ -28,6 +28,7 @@ use core::ops::Range;
 use core::sync::atomic::{AtomicBool, AtomicU8, AtomicUsize, Ordering};
 
 use crate::fs::cache::{DirCacheImpl, DirCacheItem};
+use crate::fs::path::PathBuf;
 use crate::fs::{self, FileSystem};
 use crate::mem::paging::*;
 
@@ -510,11 +511,8 @@ impl Task {
         }
     }
 
-    pub fn path(&self) -> Option<String> {
-        self.executable
-            .lock()
-            .as_ref()
-            .map(|e| e.absolute_path_str())
+    pub fn path(&self) -> Option<PathBuf> {
+        self.executable.lock().as_ref().map(|e| e.absolute_path())
     }
 
     pub fn exec(
@@ -648,8 +646,8 @@ impl Task {
         self.cwd.read().as_ref().unwrap().inode.clone()
     }
 
-    pub fn get_cwd(&self) -> String {
-        self.cwd.read().as_ref().unwrap().inode.absolute_path_str()
+    pub fn get_cwd(&self) -> PathBuf {
+        self.cwd.read().as_ref().unwrap().inode.absolute_path()
     }
 
     pub fn set_cwd(&self, cwd: DirCacheItem) {

src/aero_kernel/src/userland/vm.rs

@@ -872,7 +872,7 @@ impl VmProtected {
                 protection,
                 flags,
                 offset,
-                z.map(|f| f.absolute_path_str())
+                z.map(|f| f.absolute_path())
             );
 
             crate::unwind::unwind_stack_trace();
@@ -915,19 +915,19 @@ impl VmProtected {
         if let Some(shebang) = parse_shebang(bin.clone())? {
             log::debug!(
                 "shebang: (interpreter={}, argument={})",
-                shebang.interpreter.absolute_path_str(),
+                shebang.interpreter.absolute_path(),
                 shebang.argument
             );
 
             let mut largv = ExecArgs::default();
 
-            largv.push(shebang.interpreter.absolute_path_str().as_bytes());
+            largv.push(shebang.interpreter.absolute_path().as_bytes());
 
             if !shebang.argument.is_empty() {
                 largv.push(shebang.argument.as_bytes());
             }
 
-            largv.push(bin.absolute_path_str().as_bytes());
+            largv.push(bin.absolute_path().as_bytes());
 
             if let Some(argv) = argv {
                 largv.extend(&argv.inner[1..])