152 refactor control command handling

drivers/native/src/devices/window_screen/screen.rs

@@ -1,6 +1,9 @@
-use file_system::{DirectBaseOperations, DirectCharacterDevice, MountOperations, Size};
+use file_system::{
+    ControlCommand, ControlCommandIdentifier, DirectBaseOperations, DirectCharacterDevice,
+    MountOperations, Size,
+};
 use graphics::{Area, GET_RESOLUTION, RenderingColor, SET_DRAWING_AREA, WAS_RESIZED};
-use shared::align_slice_to;
+use shared::{AnyByLayout, align_slice_to};
 
 use crate::window_screen::inner_window::InnerWindow;
 
@@ -32,28 +35,23 @@ impl<'a> DirectBaseOperations for ScreenDevice<'a> {
 
     fn control(
         &self,
-        command: file_system::ControlCommand,
-        argument: &mut file_system::ControlArgument,
+        command: ControlCommandIdentifier,
+        input: &AnyByLayout,
+        output: &mut AnyByLayout,
     ) -> file_system::Result<()> {
         match command {
-            SET_DRAWING_AREA => {
-                let area: &Area = argument
-                    .cast()
-                    .ok_or(file_system::Error::InvalidParameter)?;
+            SET_DRAWING_AREA::IDENTIFIER => {
+                let area: &Area = SET_DRAWING_AREA::cast_input(input)?;
 
                 task::block_on(self.0.set_drawing_area(*area)).unwrap();
             }
-            GET_RESOLUTION => {
-                let resolution: &mut graphics::Point = argument
-                    .cast()
-                    .ok_or(file_system::Error::InvalidParameter)?;
+            GET_RESOLUTION::IDENTIFIER => {
+                let resolution: &mut graphics::Point = GET_RESOLUTION::cast_output(output)?;
 
                 *resolution = task::block_on(self.0.get_resolution()).unwrap();
             }
-            WAS_RESIZED => {
-                let was_resized: &mut bool = argument
-                    .cast()
-                    .ok_or(file_system::Error::InvalidParameter)?;
+            WAS_RESIZED::IDENTIFIER => {
+                let was_resized: &mut bool = WAS_RESIZED::cast_output(output)?;
 
                 *was_resized = task::block_on(self.0.was_resized()).unwrap();
             }

drivers/shared/src/devices/hash.rs

@@ -1,9 +1,10 @@
-use device::hash::{self, HashAlgorithm};
+use device::hash::{self, HashAlgorithm, SET_ALGORITHM};
 use file_system::{
-    BaseOperations, CharacterDevice, Context, ControlArgument, ControlCommand, Error,
+    BaseOperations, CharacterDevice, Context, ControlCommand, ControlCommandIdentifier, Error,
     MountOperations, Result, Size,
 };
 use sha2::{Digest, Sha224, Sha256, Sha384, Sha512, Sha512_224, Sha512_256, digest::DynDigest};
+use shared::AnyByLayout;
 
 #[derive(Clone)]
 struct HashDeviceContext {
@@ -69,22 +70,21 @@ impl BaseOperations for HashDevice {
     fn control(
         &self,
         context: &mut Context,
-        command: ControlCommand,
-        argument: &mut ControlArgument,
+        command: ControlCommandIdentifier,
+        input: &AnyByLayout,
+        _: &mut AnyByLayout,
     ) -> Result<()> {
         let hash_context = context
             .get_private_data_mutable_of_type::<HashDeviceContext>()
             .ok_or_else(|| file_system::Error::InvalidParameter)?;
 
         match command {
-            hash::RESET => {
+            hash::RESET::IDENTIFIER => {
                 hash_context.hasher.reset();
                 Ok(())
             }
-            hash::SET_ALGORITHM => {
-                let algorithm = argument
-                    .cast::<HashAlgorithm>()
-                    .ok_or_else(|| file_system::Error::InvalidParameter)?;
+            hash::SET_ALGORITHM::IDENTIFIER => {
+                let algorithm = SET_ALGORITHM::cast_input(input)?;
 
                 *hash_context = HashDeviceContext::new(*algorithm)?;
                 Ok(())

drivers/std/Cargo.toml

@@ -13,6 +13,7 @@ task = { workspace = true }
 users = { workspace = true }
 synchronization = { workspace = true }
 virtual_file_system = { workspace = true }
+shared = { workspace = true }
 
 libc = { version = "0.2" }
 linked_list_allocator = { version = "0.10", default-features = false, features = [

drivers/std/src/console.rs

@@ -1,11 +1,10 @@
-use std::io::{Read, Write, stderr, stdin, stdout};
-
+use crate::io::map_error;
 use file_system::{
-    ControlArgument, ControlCommand, DirectBaseOperations, DirectCharacterDevice, MountOperations,
-    Size, character_device,
+    ControlCommand, ControlCommandIdentifier, DirectBaseOperations, DirectCharacterDevice,
+    MountOperations, Size, character_device::IS_A_TERMINAL,
 };
-
-use crate::io::map_error;
+use shared::AnyByLayout;
+use std::io::{Read, Write, stderr, stdin, stdout};
 
 pub struct StandardInDevice;
 
@@ -27,10 +26,11 @@ impl DirectBaseOperations for StandardInDevice {
 
     fn control(
         &self,
-        command: ControlCommand,
-        argument: &mut ControlArgument,
+        command: ControlCommandIdentifier,
+        input: &AnyByLayout,
+        output: &mut AnyByLayout,
     ) -> file_system::Result<()> {
-        control(command, argument)
+        control(command, input, output)
     }
 }
 
@@ -55,10 +55,11 @@ impl DirectBaseOperations for StandardOutDevice {
 
     fn control(
         &self,
-        command: ControlCommand,
-        argument: &mut ControlArgument,
+        command: ControlCommandIdentifier,
+        input: &AnyByLayout,
+        output: &mut AnyByLayout,
     ) -> file_system::Result<()> {
-        control(command, argument)
+        control(command, input, output)
     }
 }
 
@@ -83,23 +84,27 @@ impl DirectBaseOperations for StandardErrorDevice {
 
     fn control(
         &self,
-        command: ControlCommand,
-        argument: &mut ControlArgument,
+        command: ControlCommandIdentifier,
+        input: &AnyByLayout,
+        output: &mut AnyByLayout,
     ) -> file_system::Result<()> {
-        control(command, argument)
+        control(command, input, output)
     }
 }
 
 impl MountOperations for StandardErrorDevice {}
 
 impl DirectCharacterDevice for StandardErrorDevice {}
 
-fn control(command: ControlCommand, argument: &mut ControlArgument) -> file_system::Result<()> {
+fn control(
+    command: ControlCommandIdentifier,
+    _: &AnyByLayout,
+    output: &mut AnyByLayout,
+) -> file_system::Result<()> {
     match command {
-        character_device::IS_A_TERMINAL => {
-            *argument
-                .cast::<bool>()
-                .ok_or(file_system::Error::InvalidParameter)? = true;
+        IS_A_TERMINAL::IDENTIFIER => {
+            let output: &mut bool = IS_A_TERMINAL::cast_output(output)?;
+            *output = true;
 
             Ok(())
         }

drivers/std/src/drive_file.rs

@@ -4,9 +4,12 @@ use std::{
 };
 
 use file_system::{
-    ControlArgument, ControlCommand, DirectBaseOperations, DirectBlockDevice, Error,
-    MountOperations, Path, Position, Size, block_device, mount::MutexMountWrapper,
+    ControlCommand, ControlCommandIdentifier, DirectBaseOperations, DirectBlockDevice, Error,
+    MountOperations, Path, Position, Size,
+    block_device::{GET_BLOCK_COUNT, GET_BLOCK_SIZE},
+    mount::MutexMountWrapper,
 };
+use shared::AnyByLayout;
 use synchronization::blocking_mutex::raw::CriticalSectionRawMutex;
 
 use crate::io::map_error;
@@ -93,19 +96,19 @@ impl DirectBaseOperations for FileDriveDevice {
 
     fn control(
         &self,
-        command: ControlCommand,
-        argument: &mut ControlArgument,
+        command: ControlCommandIdentifier,
+        _: &AnyByLayout,
+        output: &mut AnyByLayout,
     ) -> file_system::Result<()> {
         match command {
-            block_device::GET_BLOCK_SIZE => {
-                let block_size = argument.cast::<usize>().ok_or(Error::InvalidParameter)?;
-
+            GET_BLOCK_SIZE::IDENTIFIER => {
+                let block_size = GET_BLOCK_SIZE::cast_output(output)?;
                 *block_size = 512; // Fixed block size for file drive device
 
                 Ok(())
             }
-            block_device::GET_BLOCK_COUNT => {
-                let block_count = argument.cast::<Size>().ok_or(Error::InvalidParameter)?;
+            GET_BLOCK_COUNT::IDENTIFIER => {
+                let block_count = GET_BLOCK_COUNT::cast_output(output)?;
 
                 let file_size = self
                     .0
@@ -115,7 +118,7 @@ impl DirectBaseOperations for FileDriveDevice {
                     .map_err(map_error)?
                     .len();
 
-                *block_count = file_size / 512; // Fixed block size for file drive device
+                *block_count = (file_size / 512) as _; // Fixed block size for file drive device
 
                 Ok(())
             }

drivers/std/src/memory.rs

@@ -122,7 +122,7 @@ impl ManagerTrait for MemoryManager {
         }
     }
 
-    unsafe fn get_used(&self) -> usize {
+    fn get_used(&self) -> usize {
         self.regions.lock(|regions| {
             let regions = regions.borrow();
             let mut used = 0;
@@ -133,7 +133,7 @@ impl ManagerTrait for MemoryManager {
         })
     }
 
-    unsafe fn get_free(&self) -> usize {
+    fn get_free(&self) -> usize {
         self.regions.lock(|regions| {
             let regions = regions.borrow();
             let mut free = 0;

drivers/wasm/src/devices/graphics/canvas_screen.rs

@@ -1,9 +1,12 @@
 use core::slice;
 
 use alloc::{boxed::Box, rc::Rc, string::String, vec::Vec};
-use file_system::{DirectBaseOperations, DirectCharacterDevice, MountOperations, Size};
+use file_system::{
+    ControlCommand, ControlCommandIdentifier, DirectBaseOperations, DirectCharacterDevice,
+    MountOperations, Size,
+};
 use graphics::{Area, GET_RESOLUTION, Point, RenderingColor, SET_DRAWING_AREA, WAS_RESIZED};
-use shared::align_slice_to;
+use shared::{AnyByLayout, align_slice_to};
 use synchronization::{blocking_mutex::raw::CriticalSectionRawMutex, rwlock::RwLock};
 use task::block_on;
 use wasm_bindgen::{Clamped, JsCast, JsValue, prelude::Closure};
@@ -160,22 +163,19 @@ impl DirectBaseOperations for CanvasScreenDevice {
 
     fn control(
         &self,
-        command: file_system::ControlCommand,
-        argument: &mut file_system::ControlArgument,
+        command: ControlCommandIdentifier,
+        input: &AnyByLayout,
+        output: &mut AnyByLayout,
     ) -> file_system::Result<()> {
         match command {
-            SET_DRAWING_AREA => {
-                let area: &mut Area = argument
-                    .cast()
-                    .ok_or(file_system::Error::InvalidParameter)?;
+            SET_DRAWING_AREA::IDENTIFIER => {
+                let area = SET_DRAWING_AREA::cast_input(input)?;
 
                 let mut inner = block_on(self.0.write());
                 inner.area = *area;
             }
-            GET_RESOLUTION => {
-                let point: &mut Point = argument
-                    .cast()
-                    .ok_or(file_system::Error::InvalidParameter)?;
+            GET_RESOLUTION::IDENTIFIER => {
+                let point = GET_RESOLUTION::cast_output(output)?;
 
                 let inner = block_on(self.0.read());
 
@@ -185,10 +185,8 @@ impl DirectBaseOperations for CanvasScreenDevice {
 
                 *point = resolution;
             }
-            WAS_RESIZED => {
-                let was_resized: &mut bool = argument
-                    .cast()
-                    .ok_or(file_system::Error::InvalidParameter)?;
+            WAS_RESIZED::IDENTIFIER => {
+                let was_resized = WAS_RESIZED::cast_output(output)?;
 
                 let mut inner = block_on(self.0.write());
                 *was_resized = inner.was_resized;

drivers/wasm/src/memory.rs

@@ -145,14 +145,14 @@ impl ManagerTrait for MemoryManager {
             .lock(|inner| unsafe { inner.borrow_mut().heap.deallocate(pointer, layout) });
     }
 
-    unsafe fn get_used(&self) -> usize {
+    fn get_used(&self) -> usize {
         self.0.lock(|inner| {
             let inner = inner.borrow();
             inner.heap.used()
         })
     }
 
-    unsafe fn get_free(&self) -> usize {
+    fn get_free(&self) -> usize {
         self.0.lock(|inner| {
             let inner = inner.borrow();
             inner.heap.free()

modules/abi/definitions/src/file_system/functions.rs

@@ -392,13 +392,13 @@ pub unsafe extern "C" fn xila_file_system_is_a_terminal(
             Err(Error::InvalidParameter)?;
         }
 
-        let is_a_terminal = unsafe { &mut *is_a_terminal };
-
-        context::get_instance()
-            .perform_operation_on_file(file.try_into()?, |file| {
-                file.control(character_device::IS_A_TERMINAL, is_a_terminal)
-            })
-            .ok_or(Error::InvalidIdentifier)??;
+        unsafe {
+            *is_a_terminal = context::get_instance()
+                .perform_operation_on_file(file.try_into()?, |file| {
+                    file.control(character_device::IS_A_TERMINAL, &())
+                })
+                .ok_or(Error::InvalidIdentifier)??;
+        }
 
         Ok(())
     })

modules/authentication/src/hash.rs

@@ -95,9 +95,7 @@ pub async fn hash_password(
     .await
     .map_err(Error::FailedToHashPassword)?;
 
-    let mut algorithm = HashAlgorithm::Sha512;
-
-    file.control(SET_ALGORITHM, &mut algorithm)
+    file.control(SET_ALGORITHM, &HashAlgorithm::Sha512)
         .await
         .map_err(Error::FailedToHashPassword)?;
 

modules/device/src/hash.rs

@@ -1,4 +1,4 @@
-use file_system::{ControlCommand, ControlDirectionFlags};
+use file_system::{ControlCommand, define_command};
 
 #[repr(u8)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -13,6 +13,5 @@ pub enum HashAlgorithm {
     Sha512_256 = 7,
 }
 
-pub const RESET: ControlCommand = ControlCommand::new::<()>(ControlDirectionFlags::Write, b'H', 0);
-pub const SET_ALGORITHM: ControlCommand =
-    ControlCommand::new::<HashAlgorithm>(ControlDirectionFlags::Write, b'H', 1);
+define_command!(RESET, Write, b'H', 0, (), ());
+define_command!(SET_ALGORITHM, Write, b'H', 1, HashAlgorithm, ());

modules/executable/Cargo.toml

@@ -8,7 +8,7 @@ file_system = { workspace = true }
 virtual_file_system = { workspace = true }
 task = { workspace = true }
 users = { workspace = true }
-
+shared = { workspace = true }
 log = { workspace = true }
 
 [dev-dependencies]

modules/executable/src/lib.rs

@@ -112,9 +112,7 @@ pub async fn execute(
         .get_file_name()
         .ok_or(virtual_file_system::Error::InvalidPath)?;
 
-    let mut main_function: MainFunction = None;
-
-    file.control(GET_MAIN_FUNCTION, &mut main_function).await?;
+    let main_function: MainFunction = file.control(GET_MAIN_FUNCTION, &()).await?;
 
     let main = main_function.ok_or(Error::FailedToGetMainFunction)?;