aero_proc::syscall: fix const array parsing

* The current code parsed the array by parsing it as a slice and then
getting a reference `N` elements which does *not* make it an array (it
will still be a slice).
* Update the macro to use `validate_array_mut` to validate and construct
the array.
* Remove the length param from ArgType::Array since the
`validate_array_mut` method takes the length as a const generic
param which means that the compiler can automagically get us the length
:^)
* Remove all of the useless diagnostic since now we automagically get
the array length.

Signed-off-by: Andy-Python-Programmer <andypythonappdeveloper@gmail.com>

Author: Andy-Python-Programmer

src/aero_kernel/src/syscall/fs.rs

@@ -238,9 +238,7 @@ pub fn seek(fd: usize, offset: usize, whence: usize) -> Result<usize, AeroSyscal
 }
 
 #[aero_proc::syscall]
-pub fn pipe(fds: &mut [usize], flags: usize) -> Result<usize, AeroSyscallError> {
-    assert!(fds.len() == 2);
-
+pub fn pipe(fds: &mut [usize; 2], flags: usize) -> Result<usize, AeroSyscallError> {
     let flags = OpenFlags::from_bits(flags).ok_or(AeroSyscallError::EINVAL)?;
     let pipe = Pipe::new();
 

src/aero_kernel/src/syscall/mod.rs

@@ -194,7 +194,7 @@ pub fn generic_do_syscall(
         SYS_IOCTL => fs::ioctl(b, c, d),
         SYS_SEEK => fs::seek(b, c, d),
         SYS_ACCESS => fs::access(b, c, d, e, f),
-        SYS_PIPE => fs::pipe(b, 2, c), // TODO: We shouldn't have to pass 2 here.
+        SYS_PIPE => fs::pipe(b, c),
         SYS_UNLINK => fs::unlink(b, c, d, e),
         SYS_DUP => fs::dup(b, c),
         SYS_DUP2 => fs::dup2(b, c, d),

src/aero_kernel/src/utils/mod.rs

@@ -68,6 +68,14 @@ pub fn validate_str(ptr: *const u8, len: usize) -> Option<&'static str> {
     }
 }
 
+pub fn validate_array_mut<T, const COUNT: usize>(ptr: *mut T) -> Option<&'static mut [T; COUNT]> {
+    // We use the `validate_slice_mut` function to validate if it safe to read `COUNT` amount
+    // of memory from `ptr`. Then we convert the slice to an array.
+    let slice = validate_slice_mut::<T>(ptr, COUNT);
+    // SAFETY: We know that `slice` is a valid slice of `COUNT` elements.
+    slice.map(|e| unsafe { &mut *(e.as_ptr() as *mut [T; COUNT]) })
+}
+
 pub macro intel_asm($($code:expr,)+) {
    core::arch::global_asm!(concat!($($code),+,));
 }

src/aero_proc/src/lib.rs

@@ -3,13 +3,13 @@
 use proc_macro::{Diagnostic, Level, TokenStream};
 use proc_macro2::{Ident, Span};
 use quote::quote;
-use syn::{punctuated::Punctuated, spanned::Spanned, Expr, FnArg, Lit, Pat, Type};
+use syn::{punctuated::Punctuated, spanned::Spanned, Expr, FnArg, Pat, Type};
 
 enum ArgType {
-    Array(bool, usize),
-    Slice(bool),
-    Pointer(bool),
-    Reference(bool),
+    Array(bool),     // mutable?
+    Slice(bool),     // mutable?
+    Pointer(bool),   // mutable?
+    Reference(bool), // mutable?
     String,
     Path,
 }
@@ -82,48 +82,7 @@ pub fn syscall(_: TokenStream, item: TokenStream) -> TokenStream {
 fn determine_arg_type(typ: &Type) -> Option<ArgType> {
     match typ {
         Type::Reference(typ) => match typ.elem.as_ref() {
-            Type::Array(array) => match &array.len {
-                Expr::Lit(lit) => match &lit.lit {
-                    Lit::Int(lit) => match lit.base10_parse() {
-                        Ok(len) => Some(ArgType::Array(typ.mutability.is_some(), len)),
-                        Err(err) => {
-                            Diagnostic::spanned(
-                                lit.span().unwrap(),
-                                Level::Error,
-                                &format!("failed to parse array length: {}", err),
-                            )
-                            .emit();
-
-                            // If we can't parse the array length, we just give it an arbitrary length.
-                            // This is probably not the best way to do this, but it won't cause any
-                            // further errors to be emitted.
-                            Some(ArgType::Array(typ.mutability.is_some(), 0))
-                        }
-                    },
-                    _ => {
-                        Diagnostic::spanned(
-                            lit.span().unwrap(),
-                            Level::Error,
-                            "array length must be a constant integer",
-                        )
-                        .emit();
-
-                        // Same as above.
-                        Some(ArgType::Array(typ.mutability.is_some(), 0))
-                    }
-                },
-                _ => {
-                    Diagnostic::spanned(
-                        array.span().unwrap(),
-                        Level::Error,
-                        "array length must be a constant integer",
-                    )
-                    .emit();
-
-                    // Same as above.
-                    Some(ArgType::Array(typ.mutability.is_some(), 0))
-                }
-            },
+            Type::Array(_) => Some(ArgType::Array(typ.mutability.is_some())),
             Type::Slice(_) => Some(ArgType::Slice(typ.mutability.is_some())),
             Type::Path(path) => {
                 if path.path.segments.last().unwrap().ident == "str" {
@@ -161,7 +120,7 @@ fn process_args(args: &Punctuated<FnArg, syn::Token![,]>) -> Vec<FnArg> {
                             result.push(syn::parse_quote!(#data: usize));
                             result.push(syn::parse_quote!(#len: usize));
                         }
-                        Some(ArgType::Array(_, _)) => {
+                        Some(ArgType::Array(_)) => {
                             let data = Ident::new(&format!("{}_data", ident), Span::call_site());
 
                             result.push(syn::parse_quote!(#data: usize));
@@ -225,21 +184,13 @@ fn process_call_args(args: &Punctuated<FnArg, syn::Token![,]>) -> Vec<Expr> {
 
                                 result.push(slice_expr);
                             }
-                            ArgType::Array(is_mut, length) => {
+                            ArgType::Array(is_mut) => {
                                 let array_expr: Expr = if is_mut {
                                     syn::parse_quote! {
-                                        {
-                                            let slice = crate::utils::validate_slice_mut(#data_ident as *mut _, #length).ok_or(AeroSyscallError::EINVAL)?;
-                                            &mut slice[0..#length]
-                                        }
+                                        crate::utils::validate_array_mut(#data_ident as *mut _).ok_or(AeroSyscallError::EINVAL)?
                                     }
                                 } else {
-                                    syn::parse_quote! {
-                                        {
-                                            let slice = crate::utils::validate_slice(#data_ident as *const _, #length).ok_or(AeroSyscallError::EINVAL)?;
-                                            &slice[0..#length]
-                                        }
-                                    }
+                                    unimplemented!()
                                 };
 
                                 result.push(array_expr);