aero_proc: add downcastable proc macro :)

Andy-Python-Programmer · Andy-Python-Programmer · commit 6f7eadaf0e94 · 2022-06-21T18:35:24.000+10:00
Signed-off-by: Andy-Python-Programmer &lt;andypythonappdeveloper@gmail.com&gt;
diff --git a/src/Cargo.lock b/src/Cargo.lock
diff --git a/src/aero_kernel/src/drivers/drm/mod.rs b/src/aero_kernel/src/drivers/drm/mod.rs
@@ -32,17 +32,15 @@ use crate::fs::devfs;
 use crate::fs::inode::INodeInterface;
 use crate::fs::FileSystemError;
 
-use crate::utils;
-use crate::utils::Downcastable;
-
 use crate::mem::paging::*;
 use crate::utils::sync::Mutex;
 
 use uapi::drm::*;
 
 /// Represents modset objects visible to userspace; this includes connectors,
 /// CRTCs, encoders, frambuffers and planes.
-trait ModeObject: Send + Sync + Downcastable {
+#[downcastable]
+trait ModeObject: Send + Sync {
     /// Returns the mode object's ID.
     fn id(&self) -> u32;
     fn object(&self) -> Arc<dyn ModeObject>;
@@ -51,22 +49,22 @@ trait ModeObject: Send + Sync + Downcastable {
 
     /// Converts this mode object into a connector.
     fn as_connector(&self) -> Option<Arc<Connector>> {
-        utils::downcast::<dyn ModeObject, Connector>(&self.object())
+        self.object().downcast_arc::<Connector>()
     }
 
     /// Converts this mode object into an encoder.
     fn as_encoder(&self) -> Option<Arc<Encoder>> {
-        utils::downcast::<dyn ModeObject, Encoder>(&self.object())
+        self.object().downcast_arc::<Encoder>()
     }
 
     /// Converts this mode object into a CRTC.
     fn as_crtc(&self) -> Option<Arc<Crtc>> {
-        utils::downcast::<dyn ModeObject, Crtc>(&self.object())
+        self.object().downcast_arc::<Crtc>()
     }
 
     /// Converts this mode object into a framebuffer.
     fn as_framebuffer(&self) -> Option<Arc<Framebuffer>> {
-        utils::downcast::<dyn ModeObject, Framebuffer>(&self.object())
+        self.object().downcast_arc::<Framebuffer>()
     }
 }
 
diff --git a/src/aero_kernel/src/fs/inode.rs b/src/aero_kernel/src/fs/inode.rs
@@ -35,7 +35,6 @@ use crate::socket::SocketAddr;
 use crate::userland::scheduler;
 use crate::utils::sync::BlockQueue;
 use crate::utils::sync::Mutex;
-use crate::utils::Downcastable;
 
 use super::cache;
 use super::cache::Cacheable;
@@ -71,7 +70,8 @@ impl Drop for PollTable {
 /// inode which includes its type, size, the number of links referring to it,
 /// and the list of blocks holding the file's content. For example device files,
 /// files on the disk, etc...
-pub trait INodeInterface: Send + Sync + Downcastable {
+#[downcastable]
+pub trait INodeInterface: Send + Sync {
     /// Returns the inode metadata of `this` inode.
     fn metadata(&self) -> Result<Metadata> {
         Err(FileSystemError::NotSupported)
diff --git a/src/aero_kernel/src/fs/procfs.rs b/src/aero_kernel/src/fs/procfs.rs
@@ -4,7 +4,6 @@ use alloc::collections::BTreeMap;
 use alloc::string::{String, ToString};
 use alloc::sync::{Arc, Weak};
 
-use crate::utils::downcast;
 use spin::{Once, RwLock};
 
 use crate::fs::inode::FileType;
@@ -142,7 +141,9 @@ impl LockedProcINode {
         let inode = filesystem.allocate_inode(file_type, contents);
         let inode_cached = icache.make_item_no_cache(CachedINode::new(inode));
 
-        downcast::<dyn INodeInterface, LockedProcINode>(&inode_cached.inner())
+        inode_cached
+            .inner()
+            .downcast_arc::<LockedProcINode>()
             .unwrap()
             .init(
                 &this.node,
@@ -263,17 +264,20 @@ impl ProcFs {
 
         root_dir.filesystem.call_once(|| Arc::downgrade(&copy));
 
-        let down = downcast::<dyn INodeInterface, LockedProcINode>(root_cached.inner()).unwrap();
+        let inode = root_cached
+            .inner()
+            .downcast_arc::<LockedProcINode>()
+            .unwrap();
 
-        down.init(
+        inode.init(
             &ramfs.root_inode.downgrade(),
             &&root_cached.downgrade(),
             &Arc::downgrade(&ramfs),
             FileType::Directory,
         );
 
-        down.make_inode("cpuinfo", FileType::File, FileContents::CpuInfo)?;
-        down.make_inode("cmdline", FileType::File, FileContents::CmdLine)?;
+        inode.make_inode("cpuinfo", FileType::File, FileContents::CpuInfo)?;
+        inode.make_inode("cmdline", FileType::File, FileContents::CmdLine)?;
 
         Ok(ramfs)
     }
diff --git a/src/aero_kernel/src/fs/ramfs.rs b/src/aero_kernel/src/fs/ramfs.rs
@@ -33,7 +33,6 @@ use alloc::vec::Vec;
 use spin::RwLock;
 
 use crate::mem::paging::*;
-use crate::utils::downcast;
 use crate::utils::sync::Mutex;
 
 use super::cache::{self, CacheWeak};
@@ -98,8 +97,10 @@ impl LockedRamINode {
         let inode = filesystem.allocate_inode(file_type, contents);
         let inode_cached = icache.make_item_no_cache(CachedINode::new(inode));
 
-        downcast::<dyn INodeInterface, LockedRamINode>(&inode_cached.inner())
-            .expect("Failed to downcast cached inode on creation")
+        inode_cached
+            .inner()
+            .downcast_arc::<LockedRamINode>()
+            .unwrap()
             .init(
                 &this.node,
                 &inode_cached.downgrade(),
@@ -440,8 +441,10 @@ impl RamFs {
 
         root_dir.filesystem.call_once(|| Arc::downgrade(&copy));
 
-        downcast::<dyn INodeInterface, LockedRamINode>(root_cached.inner())
-            .expect("cannot downcast inode to ram inode")
+        root_cached
+            .inner()
+            .downcast_arc::<LockedRamINode>()
+            .unwrap()
             .init(
                 &ramfs.root_inode.downgrade(),
                 &&root_cached.downgrade(),
diff --git a/src/aero_kernel/src/socket/unix.rs b/src/aero_kernel/src/socket/unix.rs
@@ -28,7 +28,6 @@ use spin::RwLock;
 use crate::fs;
 use crate::fs::inode::{DirEntry, FileType, INodeInterface, Metadata, PollTable};
 use crate::fs::{FileSystemError, Path, Result};
-use crate::utils::downcast;
 use crate::utils::sync::BlockQueue;
 
 use super::SocketAddr;
@@ -137,7 +136,10 @@ impl INodeInterface for UnixSocket {
         let path = path_from_unix_sock(address)?;
         let socket = fs::lookup_path(path)?;
 
-        let target = downcast::<dyn INodeInterface, UnixSocket>(&socket.inode().as_unix_socket()?)
+        let target = socket
+            .inode()
+            .as_unix_socket()?
+            .downcast_arc::<UnixSocket>()
             .ok_or(FileSystemError::NotSocket)?; // NOTE: the provided socket was not a unix socket.
 
         let mut target = target.inner.write();
diff --git a/src/aero_kernel/src/syscall/fs.rs b/src/aero_kernel/src/syscall/fs.rs
@@ -24,13 +24,12 @@ use aero_syscall::{AeroSyscallError, OpenFlags, Stat};
 use crate::fs::epoll::EPoll;
 use crate::fs::eventfd::EventFd;
 use crate::fs::file_table::DuplicateHint;
-use crate::fs::inode::{DirEntry, INodeInterface};
+use crate::fs::inode::DirEntry;
 use crate::fs::pipe::Pipe;
 use crate::fs::{self, lookup_path, LookupMode};
 use crate::userland::scheduler;
 
 use crate::fs::Path;
-use crate::utils::downcast;
 
 #[syscall]
 pub fn write(fd: usize, buffer: &[u8]) -> Result<usize, AeroSyscallError> {
@@ -433,7 +432,9 @@ pub fn epoll_ctl(
 
     match mode {
         EPOLL_CTL_ADD => {
-            let epoll = downcast::<dyn INodeInterface, EPoll>(&epfd.inode())
+            let epoll = epfd
+                .inode()
+                .downcast_arc::<EPoll>()
                 .ok_or(AeroSyscallError::EINVAL)?;
 
             epoll.add_event(fd, event.clone())?;
@@ -461,8 +462,10 @@ pub fn epoll_pwait(
         .get_handle(epfd)
         .ok_or(AeroSyscallError::EBADFD)?;
 
-    let epfd =
-        downcast::<dyn INodeInterface, EPoll>(&epfd.inode()).ok_or(AeroSyscallError::EINVAL)?;
+    let epfd = epfd
+        .inode()
+        .downcast_arc::<EPoll>()
+        .ok_or(AeroSyscallError::EINVAL)?;
 
     let mut old_mask = 0;
 
diff --git a/src/aero_kernel/src/userland/scheduler/mod.rs b/src/aero_kernel/src/userland/scheduler/mod.rs
@@ -30,17 +30,14 @@ use crate::{fs::cache::DirCacheItem, syscall::ExecArgs};
 
 use spin::Once;
 
-use crate::utils::Downcastable;
-
 use self::round_robin::RoundRobin;
 use super::signals::SignalResult;
 use super::task::{Task, TaskId};
 
 static SCHEDULER: Once<Scheduler> = Once::new();
 
-/// Scheduler interface for each scheduling algorithm. The struct implementing
-/// this trait has to implement [Send], [Sync] and [Downcastable].
-pub trait SchedulerInterface: Send + Sync + Downcastable {
+#[downcastable]
+pub trait SchedulerInterface: Send + Sync {
     /// Register the provided task into the task scheduler queue.
     fn register_task(&self, task: Arc<Task>);
 
diff --git a/src/aero_kernel/src/userland/scheduler/round_robin.rs b/src/aero_kernel/src/userland/scheduler/round_robin.rs
@@ -26,7 +26,7 @@ use crate::userland::signals::{SignalError, SignalResult};
 use crate::userland::task::{SchedTaskAdapter, Task, TaskState};
 
 use crate::utils::sync::IrqGuard;
-use crate::utils::{downcast, PerCpu};
+use crate::utils::PerCpu;
 
 use super::SchedulerInterface;
 
@@ -314,19 +314,21 @@ unsafe impl Sync for RoundRobin {}
 /// the child process is sweeped, it will be listed in the process table as a zombie
 /// or defunct process.
 fn sweeper() {
-    let scheduler = super::get_scheduler();
-    let round_robin: Option<Arc<RoundRobin>> = downcast(&scheduler.inner);
-    let scheduler_ref = round_robin.expect("Failed to downcast the scheduler");
+    let scheduler_ref = super::get_scheduler()
+        .inner
+        .downcast_arc::<RoundRobin>()
+        .unwrap();
 
     loop {
         scheduler_ref.sweep_dead();
     }
 }
 
 fn preempter() {
-    let scheduler = super::get_scheduler();
-    let round_robin: Option<Arc<RoundRobin>> = downcast(&scheduler.inner);
-    let scheduler_ref = round_robin.expect("Failed to downcast the scheduler");
+    let scheduler_ref = super::get_scheduler()
+        .inner
+        .downcast_arc::<RoundRobin>()
+        .unwrap();
 
     loop {
         scheduler_ref.schedule_next_task();
diff --git a/src/aero_kernel/src/utils/mod.rs b/src/aero_kernel/src/utils/mod.rs
@@ -105,14 +105,6 @@ impl<T: Copy> VolatileCell<T> {
     }
 }
 
-pub fn downcast<S, T>(arc: &Arc<S>) -> Option<Arc<T>>
-where
-    S: Downcastable + ?Sized,
-    T: Send + Sync + 'static,
-{
-    arc.clone().as_any().downcast::<T>().ok()
-}
-
 pub struct PerCpu<T> {
     data: UnsafeCell<Unique<T>>,
 }
diff --git a/src/aero_proc/Cargo.toml b/src/aero_proc/Cargo.toml
@@ -13,6 +13,7 @@ proc-macro = true
 
 [dependencies]
 proc-macro2 = "1.0.37"
+proc-macro-error = "1.0.4"
 quote = "1.0.18"
 
 [dependencies.syn]
diff --git a/src/aero_proc/src/downcastable.rs b/src/aero_proc/src/downcastable.rs
@@ -0,0 +1,38 @@
+use proc_macro::TokenStream;
+use syn::spanned::Spanned;
+
+pub fn parse(_: TokenStream, item: TokenStream) -> TokenStream {
+    let parsed_trait = syn::parse_macro_input!(item as syn::ItemTrait);
+
+    let vis = &parsed_trait.vis;
+    let name = &parsed_trait.ident;
+    let items = &parsed_trait.items;
+    let generics = &parsed_trait.generics;
+
+    // `auto` and `unsafe` traits are not allowed:
+    parsed_trait
+        .auto_token
+        .map(|e| emit_error!(e.span(), "`auto` traits are not downcastable"));
+
+    parsed_trait
+        .unsafety
+        .map(|e| emit_error!(e.span(), "`unsafe` traits are not downcastable"));
+
+    let super_traits = parsed_trait.supertraits.clone();
+
+    quote::quote! {
+        #vis trait #name #generics: #super_traits + crate::utils::Downcastable {
+            #(#items)*
+        }
+
+        // #[downcast]: implement downcast functions:
+        impl dyn #name #generics {
+            /// Downcast's an `Arc`ed trait object to an `Arc`ed object if the underlying object
+            /// is of type `T`.
+            pub fn downcast_arc<T: #name #generics>(self: &alloc::sync::Arc<Self>) -> Option<alloc::sync::Arc<T>> {
+                self.clone().as_any().downcast::<T>().ok()
+            }
+        }
+    }
+    .into()
+}
diff --git a/src/aero_proc/src/lib.rs b/src/aero_proc/src/lib.rs
@@ -19,8 +19,12 @@
 
 #![feature(proc_macro_diagnostic, proc_macro_span)]
 
-mod syscall_macro;
-mod test_macro;
+#[macro_use]
+extern crate proc_macro_error;
+
+mod downcastable;
+mod syscall;
+mod test;
 
 use proc_macro::TokenStream;
 
@@ -35,7 +39,7 @@ use proc_macro::TokenStream;
 /// ```
 #[proc_macro_attribute]
 pub fn test(attr: TokenStream, item: TokenStream) -> TokenStream {
-    test_macro::parse(attr, item)
+    test::parse(attr, item)
 }
 
 /// Validates input buffers, structures, path and strings auto-magically.
@@ -45,5 +49,11 @@ pub fn test(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// have generic parameters.
 #[proc_macro_attribute]
 pub fn syscall(attr: TokenStream, item: TokenStream) -> TokenStream {
-    syscall_macro::parse(attr, item)
+    syscall::parse(attr, item)
+}
+
+#[proc_macro_attribute]
+#[proc_macro_error]
+pub fn downcastable(attr: TokenStream, item: TokenStream) -> TokenStream {
+    downcastable::parse(attr, item)
 }
diff --git a/src/aero_proc/src/syscall.rs b/src/aero_proc/src/syscall.rs
diff --git a/src/aero_proc/src/test.rs b/src/aero_proc/src/test.rs

Original file line number	Diff line number	Diff line change
`@@ -105,14 +105,6 @@ impl<T: Copy> VolatileCell<T> {`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`		`-pub fn downcast<S, T>(arc: &Arc<S>) -> Option<Arc<T>>`
`109`		`-where`
`110`		`- S: Downcastable + ?Sized,`
`111`		`- T: Send + Sync + 'static,`
`112`		`-{`
`113`		`- arc.clone().as_any().downcast::<T>().ok()`
`114`		`-}`
`115`		`-`
`116`	`108`	`pub struct PerCpu<T> {`
`117`	`109`	`data: UnsafeCell<Unique<T>>,`
`118`	`110`	`}`