cleanup: Ioctl derive proc macro

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

Author: Andy-Python-Programmer

src/aero_kernel/src/arch/x86_64/user_copy.rs

@@ -15,11 +15,13 @@
 // You should have received a copy of the GNU General Public License
 // along with Aero. If not, see <https://www.gnu.org/licenses/>.
 
+use core::fmt::{Debug, Display};
 use core::mem::MaybeUninit;
 use core::ops::{Deref, DerefMut};
 
 use crate::interrupts::exceptions::PF_RESUME;
 use crate::mem::paging::VirtAddr;
+use crate::syscall::SysArg;
 
 use super::task::user_access_ok;
 
@@ -131,6 +133,13 @@ impl<T> UserRef<T> {
             val: unsafe { val.assume_init() },
         }
     }
+
+    pub fn take(self) -> T
+    where
+        T: Clone,
+    {
+        self.val.clone()
+    }
 }
 
 impl<T> Deref for UserRef<T> {
@@ -152,3 +161,22 @@ impl<T> Drop for UserRef<T> {
         assert!(copy_to_user(self.ptr, &self.val));
     }
 }
+
+impl<T: Debug> Display for UserRef<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.val.fmt(f)
+    }
+}
+
+impl<T: Debug> Debug for UserRef<T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "UserRef({:?})", self.val)
+    }
+}
+
+impl<T: Debug> SysArg for UserRef<T> {
+    fn from_usize(value: usize) -> Self {
+        // TODO: SAFETY
+        unsafe { Self::new(VirtAddr::new(value.try_into().unwrap())) }
+    }
+}

src/aero_kernel/src/drivers/pty.rs

@@ -17,7 +17,9 @@
 
 use core::sync::atomic::{AtomicU32, Ordering};
 
+use aero_syscall as libc;
 use aero_syscall::{Termios, WinSize};
+
 use alloc::collections::BTreeMap;
 use alloc::string::ToString;
 use alloc::sync::{Arc, Weak};
@@ -26,6 +28,7 @@ use spin::{Once, RwLock};
 
 use uapi::pty::*;
 
+use crate::arch::user_copy::UserRef;
 use crate::fs::cache::*;
 use crate::fs::devfs::DEV_FILESYSTEM;
 use crate::fs::inode::{DirEntry, FileType, INodeInterface, PollFlags};
@@ -45,6 +48,55 @@ lazy_static::lazy_static! {
 static PTS_FS: Once<Arc<PtsFs>> = Once::new();
 static PTY_ID: AtomicU32 = AtomicU32::new(0);
 
+#[derive(Debug, Ioctl)]
+pub enum TermiosCmd {
+    /// Get window size.
+    #[command(libc::TIOCGWINSZ)]
+    GetWinSize(UserRef<WinSize>),
+
+    /// Set window size.
+    #[command(libc::TIOCSWINSZ)]
+    SetWinSize(UserRef<WinSize>),
+
+    /// Get the current serial port settings.
+    ///
+    /// Equivalent to `tcgetattr(fd, argp)`.
+    #[command(libc::TCGETS)]
+    TcGets(UserRef<Termios>),
+
+    /// Allow the output buffer to drain, discard pending input, and set the current serial
+    /// port settings.
+    ///
+    /// Equivalent to `tcsetattr(fd, TCSAFLUSH, argp)`.
+    #[command(libc::TCSETSF)]
+    TcSetsf(UserRef<Termios>),
+
+    /// Allow the output buffer to drain, and set the current serial port settings.
+    ///
+    /// Equivalent to `tcsetattr(fd, TCSADRAIN, argp)`.
+    #[command(libc::TCSETSW)]
+    TcSetsw(UserRef<Termios>),
+
+    /// Make the given terminal the controlling terminal of the calling process. The calling
+    /// process must be a session leader and not have a controlling terminal already. For this
+    /// case, arg should be specified as zero.
+    ///
+    /// If this terminal is already the controlling terminal of a different session group, then the
+    /// ioctl fails with EPERM, unless the caller has the CAP_SYS_ADMIN capability and arg equals
+    /// 1, in which case the terminal is stolen, and all processes that had it as controlling
+    /// terminal lose it.
+    // FIXME: argument usize
+    #[command(libc::TIOCSCTTY)]
+    SetCtrlTerm,
+
+    /// Get the process group ID of the foreground process group on this terminal.
+    ///
+    /// When successful, equivalent to `*argp = tcgetpgrp(fd)`.
+    // FIXME: argument usize
+    #[command(libc::TIOCGPGRP)]
+    GetProcGroupId,
+}
+
 struct Master {
     id: u32,
     wq: WaitQueue,
@@ -65,6 +117,16 @@ impl Master {
             discipline: LineDiscipline::new(),
         }
     }
+
+    #[inline]
+    fn set_window_size(&self, size: WinSize) {
+        *self.window_size.lock_irq() = size;
+    }
+
+    #[inline]
+    fn get_window_size(&self) -> WinSize {
+        *self.window_size.lock_irq()
+    }
 }
 
 impl INodeInterface for Master {
@@ -180,58 +242,29 @@ impl INodeInterface for Slave {
     }
 
     fn ioctl(&self, command: usize, arg: usize) -> fs::Result<usize> {
-        match command {
-            aero_syscall::TIOCGWINSZ => {
-                let winsize = VirtAddr::new(arg as u64).read_mut::<WinSize>()?;
-                *winsize = *self.master.window_size.lock_irq();
-
-                Ok(0)
-            }
-
-            aero_syscall::TIOCSWINSZ => {
-                *self.master.window_size.lock_irq() = *VirtAddr::new(arg as u64).read_mut()?;
-                Ok(0)
-            }
-
-            aero_syscall::TCGETS => {
-                let termios = VirtAddr::new(arg as u64).read_mut::<Termios>()?;
-                *termios = self.master.discipline.termios();
-
-                Ok(0)
-            }
-
-            aero_syscall::TCSETSF => {
-                let termios = VirtAddr::new(arg as u64).read_mut::<Termios>()?;
-                self.master.discipline.set_termios(termios.clone());
-
-                Ok(0)
-            }
-
-            aero_syscall::TCSETSW => {
+        match TermiosCmd::from_command_arg(command, arg) {
+            TermiosCmd::GetWinSize(mut size) => *size = self.master.get_window_size(),
+            TermiosCmd::SetWinSize(size) => self.master.set_window_size(*size),
+            TermiosCmd::TcGets(mut termios) => *termios = self.master.discipline.termios(),
+            TermiosCmd::TcSetsf(termios) => self.master.discipline.set_termios(*termios),
+            TermiosCmd::TcSetsw(termios) => {
                 // TODO: Allow the output buffer to drain and then set the current serial port
                 // settings.
-                //
-                // Equivalent to tcsetattr(fd, TCSADRAIN, argp).
-                let termios = VirtAddr::new(arg as u64).read_mut::<Termios>()?;
-                self.master.discipline.set_termios(termios.clone());
-
-                Ok(0)
+                self.master.discipline.set_termios(*termios)
             }
 
-            aero_syscall::TIOCSCTTY => {
+            TermiosCmd::SetCtrlTerm => {
                 let current_task = scheduler::get_scheduler().current_task();
                 assert!(current_task.is_session_leader());
 
                 current_task.attach(self.sref());
-                Ok(0)
             }
 
-            // TIOCGPGRP - Get the process group ID of the foreground process group on this
-            // terminal.
-            0x540f => Err(FileSystemError::NotSupported),
-
-            _ => panic!("pty: unknown ioctl: {command}"),
+            // FIXME: the following ioctls are not implemented.
+            TermiosCmd::GetProcGroupId => return Err(FileSystemError::NotSupported),
         }
+
+        Ok(0)
     }
 
     fn poll(&self, table: Option<&mut fs::inode::PollTable>) -> fs::Result<PollFlags> {
@@ -250,9 +283,7 @@ impl INodeInterface for Slave {
     }
 
     fn read_at(&self, _offset: usize, buffer: &mut [u8]) -> fs::Result<usize> {
-        let x = self.master.discipline.read(buffer)?;
-        dbg!(core::str::from_utf8(&buffer[..x]));
-        Ok(x)
+        Ok(self.master.discipline.read(buffer)?)
     }
 
     fn write_at(&self, _offset: usize, buffer: &[u8]) -> fs::Result<usize> {

src/aero_kernel/src/main.rs

@@ -49,7 +49,8 @@
     naked_functions, // https://github.com/rust-lang/rust/issues/32408
     cfg_match, // https://github.com/rust-lang/rust/issues/115585
     strict_provenance,
-    offset_of
+    offset_of,
+    associated_type_defaults
 )]
 // TODO(andypython): can we remove the dependency of "prelude_import" and "lang_items"?
 //     `lang_items`     => is currently used for the personality function (`rust_eh_personality`).

src/aero_proc/src/ioctl.rs

@@ -0,0 +1,57 @@
+use proc_macro::TokenStream;
+use syn::{Data, DeriveInput, Path};
+
+fn make_command_enum(ast: &DeriveInput) -> TokenStream {
+    let name = &ast.ident;
+    let variants = match &ast.data {
+        Data::Enum(data) => &data.variants,
+        _ => panic!("`Ioctl` derive macro can only be used on enums."),
+    };
+
+    let mut pattern_match = vec![];
+
+    for variant in variants {
+        let attrs = &variant.attrs;
+        let ident = &variant.ident;
+
+        for attr in attrs {
+            if attr.path.get_ident().unwrap() != "command" {
+                assert_eq!(attr.path.get_ident().unwrap(), "doc");
+                continue;
+            }
+
+            let path = attr.parse_args::<Path>().unwrap();
+
+            pattern_match.push(match &variant.fields {
+                syn::Fields::Unit => quote::quote!(#path => Self::#ident),
+                syn::Fields::Unnamed(fields) => {
+                    assert!(fields.unnamed.len() == 1);
+                    quote::quote!(#path => Self::#ident(crate::syscall::SysArg::from_usize(arg)))
+                }
+
+                _ => panic!("`Ioctl` derive macro can only be used on enums with unit variants."),
+            });
+        }
+    }
+
+    // implement Ioctl::from_command_arg for the enum
+
+    quote::quote! {
+        impl #name {
+            pub fn from_command_arg(cmd: usize, arg: usize) -> Self {
+                match cmd {
+                    #(#pattern_match,)*
+                    _ => unimplemented!("unknown command: {cmd:#x}")
+                }
+            }
+        }
+    }
+    .into()
+}
+
+pub fn parse(item: TokenStream) -> TokenStream {
+    let ast: DeriveInput = syn::parse(item).unwrap();
+    let cmd_enum = make_command_enum(&ast);
+
+    cmd_enum
+}

src/aero_proc/src/lib.rs

@@ -23,6 +23,7 @@ extern crate proc_macro_error;
 mod cpu_local;
 mod downcastable;
 mod indirect;
+mod ioctl;
 mod syscall;
 mod test;
 
@@ -71,3 +72,9 @@ pub fn cpu_local(attr: TokenStream, item: TokenStream) -> TokenStream {
 pub fn indirect(attr: TokenStream, item: TokenStream) -> TokenStream {
     indirect::parse(attr, item)
 }
+
+#[proc_macro_derive(Ioctl, attributes(command))]
+#[proc_macro_error]
+pub fn ioctl(item: TokenStream) -> TokenStream {
+    ioctl::parse(item)
+}

src/aero_syscall/src/lib.rs

@@ -298,8 +298,9 @@ pub const TCSETSW: usize = 0x5403;
 pub const TCSETSF: usize = 0x5404;
 pub const TIOCSCTTY: usize = 0x540e;
 pub const TIOCNOTTY: usize = 0x5422;
+pub const TIOCGPGRP: usize = 0x540f;
 
-#[derive(Default, Copy, Clone)]
+#[derive(Default, Debug, Copy, Clone)]
 #[repr(C)]
 pub struct WinSize {
     pub ws_row: u16,