syscall: make use of the #[syscall] proc macro to generate the syslog

* Make use of the `#[syscall]` proc macro to generate the syscall log for
that syscall.
* Pass `no_return` to the macro if the syscall never returns (`#[syscall(no_return)]`)
	TODO: We may want to automagically detect this case by checking
	the return type of the function. Which is'nt that
	stright-forward since type information is not avaliable to proc
	macros (if you see how they work)

This patch makes the syslogs more readable and significantly helps in
debugging a syscall :).

Signed-off-by: Andy-Python-Programmer <[email protected]>

Author: Andy-Python-Programmer

aero.py

@@ -524,7 +524,7 @@ def run_in_emulator(args, iso_path):
 
     qemu_args = ['-cdrom', iso_path,
                  '-M', 'q35',
-                 '-m', '1G',
+                 '-m', '5G',
                  '-smp', '5',
                  '-serial', 'stdio']
 

src/aero_kernel/src/syscall/mod.rs

@@ -155,6 +155,70 @@ pub fn exec_args_from_slice(args: usize, size: usize) -> ExecArgs {
     ExecArgs { inner: result }
 }
 
+#[cfg(feature = "syslog")]
+pub(super) struct SysLog {
+    name: &'static str,
+    /// The result of the syscall.
+    result: Option<Result<usize, SyscallError>>,
+    /// The formatted argument values.
+    args: Vec<String>,
+}
+
+#[cfg(feature = "syslog")]
+impl SysLog {
+    pub fn new(name: &'static str) -> Self {
+        Self {
+            name,
+            result: None,
+            args: Vec::new(),
+        }
+    }
+
+    pub fn add_argument<T>(mut self, value: T) -> Self
+    where
+        T: core::fmt::Display,
+    {
+        self.args.push(alloc::format!("{value}"));
+        self
+    }
+
+    pub fn add_argument_dbg<T>(mut self, value: T) -> Self
+    where
+        T: core::fmt::Debug,
+    {
+        self.args.push(alloc::format!("{value:?}"));
+        self
+    }
+
+    pub fn set_result(mut self, result: Result<usize, SyscallError>) -> Self {
+        self.result = Some(result);
+        self
+    }
+
+    pub fn flush(self) {
+        let mut result = String::new();
+
+        if self.result.map(|e| e.is_ok()).unwrap_or_default() {
+            result.push_str("\x1b[1;32m");
+        } else {
+            result.push_str("\x1b[1;31m");
+        }
+
+        result.push_str(alloc::format!("{}\x1b[0m(", self.name).as_str());
+
+        for (i, e) in self.args.iter().enumerate() {
+            if i != 0 {
+                result.push_str(", ");
+            }
+
+            result.push_str(e);
+        }
+
+        result.push_str(alloc::format!(") = {:?}", self.result.unwrap()).as_str());
+        log::trace!("{result}");
+    }
+}
+
 pub fn generic_do_syscall(
     a: usize,
     b: usize,
@@ -241,40 +305,5 @@ pub fn generic_do_syscall(
         }
     };
 
-    let result_usize = aero_syscall::syscall_result_as_usize(result);
-
-    #[cfg(feature = "syslog")]
-    {
-        let name = aero_syscall::syscall_as_str(a);
-        let mut result_v = String::new();
-
-        if result.is_ok() {
-            result_v.push_str("\x1b[1;32m");
-        } else {
-            result_v.push_str("\x1b[1;31m");
-        }
-
-        result_v.push_str(name);
-        result_v.push_str("\x1b[0m");
-
-        result_v.push_str("(");
-
-        for (i, arg) in [b, c, d, e, f, g].iter().enumerate() {
-            if i != 0 {
-                result_v.push_str(", ");
-            }
-
-            let hex_arg = alloc::format!("{:#x}", *arg);
-            result_v.push_str(&hex_arg);
-        }
-
-        result_v.push_str(") = ");
-
-        let result_str = alloc::format!("{:?}", result);
-        result_v.push_str(&result_str);
-
-        log::trace!("{}", result_v);
-    }
-
-    result_usize
+    aero_syscall::syscall_result_as_usize(result)
 }

src/aero_kernel/src/syscall/process.rs

@@ -37,8 +37,8 @@ fn hostname() -> &'static Mutex<String> {
     HOSTNAME.call_once(|| Mutex::new(String::from("aero")))
 }
 
-#[syscall]
-pub fn exit(status: usize) -> ! {
+#[syscall(no_return)]
+pub fn exit(status: usize) -> Result<usize, SyscallError> {
     #[cfg(all(test, feature = "ci"))]
     crate::emu::exit_qemu(crate::emu::ExitStatus::Success);
 
@@ -113,7 +113,7 @@ pub fn kill(pid: usize, signal: usize) -> Result<usize, SyscallError> {
     }
 }
 
-#[syscall]
+#[syscall(no_return)]
 pub fn exec(
     path: &Path,
     args: usize,
@@ -328,8 +328,8 @@ pub fn sigaction(
     Ok(0)
 }
 
-#[syscall]
-pub fn shutdown() -> ! {
+#[syscall(no_return)]
+pub fn shutdown() -> Result<usize, SyscallError> {
     fs::cache::dcache().log();
 
     fs::cache::clear_inode_cache();

src/aero_proc/src/syscall.rs

@@ -24,7 +24,7 @@ use quote::quote;
 
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{Expr, FnArg, Pat, Type};
+use syn::{Expr, FnArg, NestedMeta, Pat, Type};
 
 enum ArgType {
     Array(bool),     // mutable?
@@ -35,7 +35,40 @@ enum ArgType {
     Path,
 }
 
-pub fn parse(_: TokenStream, item: TokenStream) -> TokenStream {
+#[derive(Default)]
+struct Config {
+    no_return: bool,
+}
+
+// TODO: determine if no_return by checking the return type of the syscall function;
+// if its the never type <!>.
+fn parse_attribute_args(args: Vec<NestedMeta>) -> Config {
+    let mut config = Config::default();
+
+    for attribute in args {
+        match attribute {
+            NestedMeta::Meta(meta) => match meta {
+                syn::Meta::Path(path) => {
+                    if let Some(ident) = path.get_ident() {
+                        match ident.to_string().as_str() {
+                            "no_return" => config.no_return = true,
+                            _ => emit_error!(ident.span(), "unknown attribute"),
+                        }
+                    }
+                }
+                _ => emit_error!(meta.span(), "unknown attribute"),
+            },
+            NestedMeta::Lit(e) => emit_error!(e.span(), "unknown attribute"),
+        }
+    }
+
+    config
+}
+
+pub fn parse(attr: TokenStream, item: TokenStream) -> TokenStream {
+    let attr = syn::parse_macro_input!(attr as syn::AttributeArgs);
+    let config = parse_attribute_args(attr);
+
     let parsed_fn = syn::parse_macro_input!(item as syn::ItemFn);
     let signature = &parsed_fn.sig;
 
@@ -75,10 +108,61 @@ pub fn parse(_: TokenStream, item: TokenStream) -> TokenStream {
     let ret = &signature.output;
     let body = &parsed_fn.block;
 
+    let syslog_args = orig_args
+        .iter()
+        .map(|e| match e {
+            FnArg::Typed(typed) => match typed.pat.as_ref() {
+                Pat::Ident(pat) => {
+                    let ident = &pat.ident;
+                    let typ = determine_arg_type(&typed.ty);
+
+                    if let Some(typ) = typ {
+                        match typ {
+                            ArgType::Array(_) => quote::quote!(.add_argument("<array>")),
+                            ArgType::Slice(_) => quote::quote!(.add_argument("<slice>")),
+
+                            ArgType::Pointer(_) => {
+                                quote::quote!(.add_argument(alloc::format!("*{:#x}", #ident as usize)))
+                            }
+
+                            ArgType::Reference(_) => {
+                                quote::quote!(.add_argument(alloc::format!("&{:#x}", #ident as *const _ as usize)))
+                            },
+
+                            ArgType::String | ArgType::Path => quote::quote!(.add_argument_dbg(#ident)), 
+                        }
+                    } else {
+                        quote::quote!(.add_argument(#ident))
+                    }
+                }
+                _ => unreachable!(),
+            },
+            _ => unreachable!(),
+        })
+        .collect::<Vec<_>>();
+
+    let syslog = quote::quote! {
+        #[cfg(feature = "syslog")]
+        crate::syscall::SysLog::new(stringify!(#name))
+            #(#syslog_args)*
+            .set_result(result)
+            .flush();
+    };
+
+    let compiled_body = if config.no_return {
+        quote::quote! { #body }
+    } else {
+        quote::quote! {
+            let result = #body;
+            #syslog
+            result
+        }
+    };
+
     let result = quote! {
         #(#attrs)* #vis fn #name(#(#processed_args),*) #ret {
             #(#attrs)* fn inner_syscall(#orig_args) #ret {
-                #body
+                #compiled_body
             }
 
             inner_syscall(#(#call_args),*)

src/aero_syscall/src/consts.rs

@@ -155,7 +155,16 @@ pub struct EPollEvent {
     pub data: EPollData,
 }
 
+impl core::fmt::Debug for EPollEvent {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("EPollEvent")
+            .field("events", &self.events)
+            .finish()
+    }
+}
+
 // structures for the poll API:
+#[derive(Debug)]
 pub struct PollFd {
     pub fd: i32,
     pub events: PollEventFlags,

src/aero_syscall/src/lib.rs

@@ -255,6 +255,7 @@ pub struct SysDirEntry {
     pub name: [u8; 0],
 }
 
+#[derive(Debug)]
 #[repr(C)]
 pub struct Utsname {
     pub name: [u8; 65],
@@ -421,6 +422,7 @@ pub struct Termios {
 pub const AT_FDCWD: isize = -100;
 
 #[repr(C)]
+#[derive(Debug)]
 pub struct SysInfo {
     /// Seconds since boot
     pub uptime: i64,

src/aero_syscall/src/socket.rs

@@ -1,4 +1,5 @@
 // sysdeps/aero/include/abi-bits/socket.h
+#[derive(Debug)]
 #[repr(C)]
 pub struct MessageHeader {
     name: *const u8,
@@ -14,6 +15,7 @@ pub struct MessageHeader {
 }
 
 // options/posix/include/bits/posix/iovec.h
+#[derive(Debug)]
 #[repr(C)]
 pub struct IoVec {
     base: *mut u8,