Simplify current codes with TryFromNum

services/libs/jinux-std/src/error.rs

@@ -256,6 +256,12 @@ impl From<alloc::ffi::NulError> for Error {
     }
 }
 
+impl From<int_to_c_enum::TryFromIntError> for Error {
+    fn from(_: int_to_c_enum::TryFromIntError) -> Self {
+        Error::with_message(Errno::EINVAL, "Invalid enum value")
+    }
+}
+
 #[macro_export]
 macro_rules! return_errno {
     ($errno: expr) => {

services/libs/jinux-std/src/fs/utils/fcntl.rs

@@ -1,33 +1,11 @@
 use crate::prelude::*;
 
-macro_rules! define_fcntl_cmd {
-    ($($name: ident = $value: expr),*) => {
-        #[repr(i32)]
-        #[derive(Debug, Clone, Copy)]
-        #[allow(non_camel_case_types)]
-        pub enum FcntlCmd {
-            $($name = $value,)*
-        }
-
-        $(
-            pub const $name: i32 = $value;
-        )*
-
-        impl TryFrom<i32> for FcntlCmd {
-            type Error = Error;
-            fn try_from(value: i32) -> Result<Self> {
-                match value {
-                    $($name => Ok(FcntlCmd::$name),)*
-                    _ => return_errno_with_message!(Errno::EINVAL, "Unknown fcntl cmd"),
-                }
-            }
-        }
-    }
-}
-
-define_fcntl_cmd! {
+#[repr(i32)]
+#[derive(Debug, Clone, Copy, TryFromInt)]
+#[allow(non_camel_case_types)]
+pub enum FcntlCmd {
     F_DUPFD = 0,
     F_GETFD = 1,
     F_SETFD = 2,
-    F_DUPFD_CLOEXEC = 1030
+    F_DUPFD_CLOEXEC = 1030,
 }

services/libs/jinux-std/src/fs/utils/ioctl.rs

@@ -1,30 +1,8 @@
 use crate::prelude::*;
 
-macro_rules! define_ioctl_cmd {
-    ($($name: ident = $value: expr),*) => {
-        #[repr(u32)]
-        #[derive(Debug, Clone, Copy)]
-        pub enum IoctlCmd {
-            $($name = $value,)*
-        }
-
-        $(
-            pub const $name: u32 = $value;
-        )*
-
-        impl TryFrom<u32> for IoctlCmd {
-            type Error = Error;
-            fn try_from(value: u32) -> Result<Self> {
-                match value {
-                    $($name => Ok(IoctlCmd::$name),)*
-                    _ => return_errno!(Errno::EINVAL),
-                }
-            }
-        }
-    }
-}
-
-define_ioctl_cmd! {
+#[repr(u32)]
+#[derive(Debug, Clone, Copy, TryFromInt)]
+pub enum IoctlCmd {
     // Get terminal attributes
     TCGETS = 0x5401,
     TCSETS = 0x5402,
@@ -34,5 +12,5 @@ define_ioctl_cmd! {
     TIOCSPGRP = 0x5410,
     // Set window size
     TIOCGWINSZ = 0x5413,
-    TIOCSWINSZ = 0x5414
+    TIOCSWINSZ = 0x5414,
 }

services/libs/jinux-std/src/prelude.rs

@@ -15,6 +15,7 @@ pub(crate) use alloc::vec::Vec;
 pub(crate) use bitflags::bitflags;
 pub(crate) use core::any::Any;
 pub(crate) use core::ffi::CStr;
+pub(crate) use int_to_c_enum::TryFromInt;
 pub(crate) use jinux_frame::config::PAGE_SIZE;
 pub(crate) use jinux_frame::sync::{Mutex, MutexGuard};
 pub(crate) use jinux_frame::vm::Vaddr;

services/libs/jinux-std/src/process/rlimit.rs

@@ -37,7 +37,7 @@ impl Default for ResourceLimits {
 }
 
 #[repr(u32)]
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, TryFromInt)]
 pub enum ResourceType {
     RLIMIT_CPU = 0,
     RLIMIT_FSIZE = 1,
@@ -57,32 +57,6 @@ pub enum ResourceType {
     RLIMIT_RTTIME = 15,
 }
 
-impl TryFrom<u32> for ResourceType {
-    type Error = Error;
-
-    fn try_from(value: u32) -> Result<Self> {
-        match value {
-            0 => Ok(ResourceType::RLIMIT_CPU),
-            1 => Ok(ResourceType::RLIMIT_FSIZE),
-            2 => Ok(ResourceType::RLIMIT_DATA),
-            3 => Ok(ResourceType::RLIMIT_STACK),
-            4 => Ok(ResourceType::RLIMIT_CORE),
-            5 => Ok(ResourceType::RLIMIT_RSS),
-            6 => Ok(ResourceType::RLIMIT_NPROC),
-            7 => Ok(ResourceType::RLIMIT_NOFILE),
-            8 => Ok(ResourceType::RLIMIT_MEMLOCK),
-            9 => Ok(ResourceType::RLIMIT_AS),
-            10 => Ok(ResourceType::RLIMIT_LOCKS),
-            11 => Ok(ResourceType::RLIMIT_SIGPENDING),
-            12 => Ok(ResourceType::RLIMIT_MSGQUEUE),
-            13 => Ok(ResourceType::RLIMIT_NICE),
-            14 => Ok(ResourceType::RLIMIT_RTPRIO),
-            15 => Ok(ResourceType::RLIMIT_RTTIME),
-            _ => return_errno_with_message!(Errno::EINVAL, "invalid resource type"),
-        }
-    }
-}
-
 pub const RLIMIT_COUNT: usize = 16;
 
 #[derive(Debug, Clone, Copy, Pod)]

services/libs/jinux-std/src/syscall/arch_prctl.rs

@@ -6,7 +6,8 @@ use crate::{log_syscall_entry, prelude::*};
 use super::SyscallReturn;
 
 #[allow(non_camel_case_types)]
-#[derive(Debug)]
+#[repr(u64)]
+#[derive(Debug, TryFromInt)]
 pub enum ArchPrctlCode {
     ARCH_SET_GS = 0x1001,
     ARCH_SET_FS = 0x1002,
@@ -14,20 +15,6 @@ pub enum ArchPrctlCode {
     ARCH_GET_GS = 0x1004,
 }
 
-impl TryFrom<u64> for ArchPrctlCode {
-    type Error = Error;
-
-    fn try_from(value: u64) -> Result<Self> {
-        match value {
-            0x1001 => Ok(ArchPrctlCode::ARCH_SET_GS),
-            0x1002 => Ok(ArchPrctlCode::ARCH_SET_FS),
-            0x1003 => Ok(ArchPrctlCode::ARCH_GET_FS),
-            0x1004 => Ok(ArchPrctlCode::ARCH_GET_GS),
-            _ => return_errno_with_message!(Errno::EINVAL, "Unknown code for arch_prctl"),
-        }
-    }
-}
-
 pub fn sys_arch_prctl(code: u64, addr: u64, context: &mut UserContext) -> Result<SyscallReturn> {
     log_syscall_entry!(SYS_ARCH_PRCTL);
     let arch_prctl_code = ArchPrctlCode::try_from(code)?;

services/libs/jinux-std/src/syscall/madvise.rs

@@ -38,7 +38,7 @@ fn madv_dontneed(start: Vaddr, len: usize) -> Result<()> {
 }
 
 #[repr(i32)]
-#[derive(Debug, Clone, Copy, Pod)]
+#[derive(Debug, Clone, Copy, TryFromInt)]
 #[allow(non_camel_case_types)]
 /// This definition is the same from linux
 pub enum MadviseBehavior {
@@ -77,19 +77,3 @@ pub enum MadviseBehavior {
 
     MADV_DONTNEED_LOCKED = 24, /* like DONTNEED, but drop locked pages too */
 }
-
-impl TryFrom<i32> for MadviseBehavior {
-    type Error = Error;
-
-    fn try_from(value: i32) -> Result<Self> {
-        let behavior = match value {
-            0 => MadviseBehavior::MADV_NORMAL,
-            1 => MadviseBehavior::MADV_RANDOM,
-            2 => MadviseBehavior::MADV_SEQUENTIAL,
-            3 => MadviseBehavior::MADV_WILLNEED,
-            4 => MadviseBehavior::MADV_DONTNEED,
-            _ => return_errno_with_message!(Errno::EINVAL, "invalid madvise behavior"),
-        };
-        Ok(behavior)
-    }
-}

services/libs/jinux-std/src/syscall/rt_sigprocmask.rs

@@ -64,24 +64,10 @@ fn do_rt_sigprocmask(
     Ok(())
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, TryFromInt)]
 #[repr(u32)]
 pub enum MaskOp {
     Block = 0,
     Unblock = 1,
     SetMask = 2,
 }
-
-impl TryFrom<u32> for MaskOp {
-    type Error = Error;
-
-    fn try_from(value: u32) -> Result<Self> {
-        let op = match value {
-            0 => MaskOp::Block,
-            1 => MaskOp::Unblock,
-            2 => MaskOp::SetMask,
-            _ => return_errno_with_message!(Errno::EINVAL, "invalid mask op"),
-        };
-        Ok(op)
-    }
-}

services/libs/jinux-std/src/time/mod.rs

@@ -11,7 +11,7 @@ pub type time_t = i64;
 pub type suseconds_t = i64;
 pub type clock_t = i64;
 
-#[derive(Debug, Copy, Clone, Pod)]
+#[derive(Debug, Copy, Clone, TryFromInt)]
 #[repr(i32)]
 pub enum ClockID {
     CLOCK_REALTIME = 0,
@@ -24,24 +24,6 @@ pub enum ClockID {
     CLOCK_BOOTTIME = 7,
 }
 
-impl TryFrom<clockid_t> for ClockID {
-    type Error = Error;
-
-    fn try_from(value: clockid_t) -> Result<Self> {
-        Ok(match value as i32 {
-            0 => ClockID::CLOCK_REALTIME,
-            1 => ClockID::CLOCK_MONOTONIC,
-            2 => ClockID::CLOCK_PROCESS_CPUTIME_ID,
-            3 => ClockID::CLOCK_THREAD_CPUTIME_ID,
-            4 => ClockID::CLOCK_MONOTONIC_RAW,
-            5 => ClockID::CLOCK_REALTIME_COARSE,
-            6 => ClockID::CLOCK_MONOTONIC_COARSE,
-            7 => ClockID::CLOCK_BOOTTIME,
-            _ => return_errno_with_message!(Errno::EINVAL, "invalid clockid"),
-        })
-    }
-}
-
 #[repr(C)]
 #[derive(Debug, Default, Copy, Clone, Pod)]
 pub struct timespec_t {