From d954e3d006acf8519dd101f3487c4e65c7dd7900 Mon Sep 17 00:00:00 2001
From: Qingsong Chen <changxian.cqs@antgroup.com>
Date: Thu, 13 Nov 2025 09:06:07 +0000
Subject: [PATCH] Move ranged integer to aster-util crate

---
 kernel/libs/aster-util/src/lib.rs            |  1 +
 kernel/libs/aster-util/src/ranged_integer.rs | 57 ++++++++++++++++++++
 kernel/src/sched/nice.rs                     | 49 +----------------
 kernel/src/sched/sched_class/real_time.rs    |  3 +-
 4 files changed, 61 insertions(+), 49 deletions(-)
 create mode 100644 kernel/libs/aster-util/src/ranged_integer.rs

diff --git a/kernel/libs/aster-util/src/lib.rs b/kernel/libs/aster-util/src/lib.rs
index fe7691799..25559491f 100644
--- a/kernel/libs/aster-util/src/lib.rs
+++ b/kernel/libs/aster-util/src/lib.rs
@@ -13,6 +13,7 @@ pub mod fixed_point;
 pub mod mem_obj_slice;
 pub mod per_cpu_counter;
 pub mod printer;
+pub mod ranged_integer;
 pub mod safe_ptr;
 pub mod slot_vec;
 pub mod union_read_ptr;
diff --git a/kernel/libs/aster-util/src/ranged_integer.rs b/kernel/libs/aster-util/src/ranged_integer.rs
new file mode 100644
index 000000000..16893168e
--- /dev/null
+++ b/kernel/libs/aster-util/src/ranged_integer.rs
@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MPL-2.0
+
+//! Ranged integer types.
+//!
+//! This module provides generic ranged integer types that enforce value always stay
+//! within the specified range.
+
+macro_rules! define_ranged_integer {
+    ($visibility: vis, $name: ident, $type: ty) => {
+        #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
+        $visibility struct $name<const MIN: $type, const MAX: $type>($type);
+
+        impl<const MIN: $type, const MAX: $type> $name<MIN, MAX> {
+            $visibility const MIN: Self = Self::new(MIN);
+            $visibility const MAX: Self = Self::new(MAX);
+
+            $visibility const fn new(val: $type) -> Self {
+                assert!(val >= MIN && val <= MAX);
+                Self(val)
+            }
+
+            $visibility fn set(&mut self, val: $type) {
+                assert!(val >= MIN && val <= MAX);
+                self.0 = val;
+            }
+
+            $visibility const fn get(self) -> $type {
+                self.0
+            }
+        }
+
+        impl<const MIN: $type, const MAX: $type> From<$name<MIN, MAX>> for $type {
+            fn from(value: $name<MIN, MAX>) -> Self {
+                value.0
+            }
+        }
+
+        impl<const MIN: $type, const MAX: $type> TryFrom<$type> for $name<MIN, MAX> {
+            type Error = &'static str;
+
+            fn try_from(value: $type) -> Result<Self, Self::Error> {
+                if value < MIN || value > MAX {
+                    Err("Initialized with out-of-range value.")
+                } else {
+                    Ok(Self(value))
+                }
+            }
+        }
+    };
+}
+
+define_ranged_integer!(pub, RangedI8, i8);
+define_ranged_integer!(pub, RangedU8, u8);
+define_ranged_integer!(pub, RangedI16, i16);
+define_ranged_integer!(pub, RangedU16, u16);
+define_ranged_integer!(pub, RangedI32, i32);
+define_ranged_integer!(pub, RangedU32, u32);
diff --git a/kernel/src/sched/nice.rs b/kernel/src/sched/nice.rs
index 6f7b69cfe..db5576a23 100644
--- a/kernel/src/sched/nice.rs
+++ b/kernel/src/sched/nice.rs
@@ -2,6 +2,7 @@
 
 use core::sync::atomic::AtomicI8;
 
+use aster_util::ranged_integer::RangedI8;
 use atomic_integer_wrapper::define_atomic_version_of_integer_like_type;
 
 /// The process scheduling nice value.
@@ -55,51 +56,3 @@ impl TryFrom<i8> for Nice {
         Ok(Self::new(range))
     }
 }
-
-macro_rules! define_ranged_integer {
-    ($visibility: vis, $name: ident, $type: ty) => {
-        #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
-        $visibility struct $name<const MIN: $type, const MAX: $type>($type);
-
-        impl<const MIN: $type, const MAX: $type> $name<MIN, MAX> {
-            $visibility const MIN: Self = Self::new(MIN);
-            $visibility const MAX: Self = Self::new(MAX);
-
-            $visibility const fn new(val: $type) -> Self {
-                assert!(val >= MIN && val <= MAX);
-                Self(val)
-            }
-
-            $visibility fn set(&mut self, val: $type) {
-                assert!(val >= MIN && val <= MAX);
-                self.0 = val;
-            }
-
-            $visibility const fn get(self) -> $type {
-                self.0
-            }
-        }
-
-        impl<const MIN: $type, const MAX: $type> From<$name<MIN, MAX>> for $type {
-            fn from(value: $name<MIN, MAX>) -> Self {
-                value.0
-            }
-        }
-
-        impl<const MIN: $type, const MAX: $type> TryFrom<$type> for $name<MIN, MAX> {
-            type Error = &'static str;
-
-            fn try_from(value: $type) -> Result<Self, Self::Error> {
-                if value < MIN || value > MAX {
-                    Err("Initialized with out-of-range value.")
-                } else {
-                    Ok(Self(value))
-                }
-            }
-        }
-    };
-}
-
-define_ranged_integer!(pub, RangedI8, i8);
-
-define_ranged_integer!(pub, RangedU8, u8);
diff --git a/kernel/src/sched/sched_class/real_time.rs b/kernel/src/sched/sched_class/real_time.rs
index 177c3a936..00bc94f76 100644
--- a/kernel/src/sched/sched_class/real_time.rs
+++ b/kernel/src/sched/sched_class/real_time.rs
@@ -7,6 +7,7 @@ use core::{
     sync::atomic::{AtomicU64, AtomicU8, Ordering::Relaxed},
 };
 
+use aster_util::ranged_integer::RangedU8;
 use bitvec::{bitarr, BitArr};
 use ostd::{
     cpu::CpuId,
@@ -17,7 +18,7 @@ use ostd::{
 };
 
 use super::{time::base_slice_clocks, CurrentRuntime, SchedAttr, SchedClassRq};
-use crate::{sched::nice::RangedU8, thread::AsThread};
+use crate::thread::AsThread;
 
 pub type RealTimePriority = RangedU8<1, 99>;