vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove physalloc* and physfree

Browse Source
This commit is contained in:
4lDO2
2023-11-17 19:53:35 +01:00
parent adff625d3d
commit 245cdf9caa
3 changed files with 0 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/call.rs
-50
View File
@@ -205,56 +205,6 @@ pub fn open<T: AsRef<str>>(path: T, flags: usize) -> Result<usize> {
unsafe { syscall3(SYS_OPEN, path.as_ref().as_ptr() as usize, path.as_ref().len(), flags) }
}
/// Allocate frames, linearly in physical memory.
///
/// # Errors
///
/// * `EPERM` - `uid != 0`
/// * `ENOMEM` - the system has run out of available memory
pub unsafe fn physalloc(size: usize) -> Result<usize> {
syscall1(SYS_PHYSALLOC, size)
}
/// Allocate frames, linearly in physical memory, with an extra set of flags. If the flags contain
/// [`PARTIAL_ALLOC`], this will result in `physalloc3` with `min = 1`.
///
/// Refer to the simpler [`physalloc`] and the more complex [`physalloc3`], that this convenience
/// function is based on.
///
/// # Errors
///
/// * `EPERM` - `uid != 0`
/// * `ENOMEM` - the system has run out of available memory
pub unsafe fn physalloc2(size: usize, flags: usize) -> Result<usize> {
let mut ret = 1usize;
physalloc3(size, flags, &mut ret)
}
/// Allocate frames, linearly in physical memory, with an extra set of flags. If the flags contain
/// [`PARTIAL_ALLOC`], the `min` parameter specifies the number of frames that have to be allocated
/// for this operation to succeed. The return value is the offset of the first frame, and `min` is
/// overwritten with the number of frames actually allocated.
///
/// Refer to the simpler [`physalloc`] and the simpler library function [`physalloc2`].
///
/// # Errors
///
/// * `EPERM` - `uid != 0`
/// * `ENOMEM` - the system has run out of available memory
/// * `EINVAL` - `min = 0`
pub unsafe fn physalloc3(size: usize, flags: usize, min: &mut usize) -> Result<usize> {
syscall3(SYS_PHYSALLOC3, size, flags, min as *mut usize as usize)
}
/// Free physically allocated pages
///
/// # Errors
///
/// * `EPERM` - `uid != 0`
pub unsafe fn physfree(physical_address: usize, size: usize) -> Result<usize> {
syscall2(SYS_PHYSFREE, physical_address, size)
}
/// Map physical memory to virtual memory
///
/// # Errors
src/flag.rs
-65
View File
@@ -173,71 +173,6 @@ bitflags! {
const PHYSMAP_NO_CACHE = 0x0000_0004;
}
}
bitflags! {
/// Extra flags for [`physalloc2`] or [`physalloc3`].
///
/// [`physalloc2`]: ../call/fn.physalloc2.html
/// [`physalloc3`]: ../call/fn.physalloc3.html
pub struct PhysallocFlags: usize {
/// Only allocate memory within the 32-bit physical memory space. This is necessary for
/// some devices may not support 64-bit memory.
const SPACE_32 = 0x0000_0001;
/// The frame that will be allocated, is going to reside anywhere in 64-bit space. This
/// flag is redundant for the most part, except when overriding some other default.
const SPACE_64 = 0x0000_0002;
/// Do a "partial allocation", which means that not all of the frames specified in the
/// frame count `size` actually have to be allocated. This means that if the allocator was
/// unable to find a physical memory range large enough, it can instead return whatever
/// range it decides is optimal. Thus, instead of letting one driver get an expensive
/// 128MiB physical memory range when the physical memory has become fragmented, and
/// failing, it can instead be given a more optimal range. If the device supports
/// scatter-gather lists, then the driver only has to allocate more ranges, and the device
/// will do vectored I/O.
///
/// PARTIAL_ALLOC supports different allocation strategies, refer to
/// [`Optimal`], [`GreatestRange`].
///
/// [`Optimal`]: ./enum.PartialAllocStrategy.html
/// [`GreatestRange`]: ./enum.PartialAllocStrategy.html
const PARTIAL_ALLOC = 0x0000_0004;
}
}
/// The bitmask of the partial allocation strategy. Currently four different strategies are
/// supported. If [`PARTIAL_ALLOC`] is not set, this bitmask is no longer reserved.
pub const PARTIAL_ALLOC_STRATEGY_MASK: usize = 0x0003_0000;
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[repr(usize)]
pub enum PartialAllocStrategy {
/// The allocator decides itself the size of the memory range, based on e.g. free memory ranges
/// and other processes which require large physical memory chunks.
Optimal = 0x0001_0000,
/// The allocator returns the absolute greatest range it can find.
GreatestRange = 0x0002_0000,
/// The allocator returns the first range that fits the minimum count, without searching extra.
Greedy = 0x0003_0000,
}
impl Default for PartialAllocStrategy {
fn default() -> Self {
Self::Optimal
}
}
impl PartialAllocStrategy {
pub fn from_raw(raw: usize) -> Option<Self> {
match raw {
0x0001_0000 => Some(Self::Optimal),
0x0002_0000 => Some(Self::GreatestRange),
0x0003_0000 => Some(Self::Greedy),
_ => None,
}
}
}
// The top 48 bits of PTRACE_* are reserved, for now
src/number.rs
-3
View File
@@ -74,9 +74,6 @@ pub const SYS_KILL: usize = 37;
pub const SYS_MPROTECT: usize = 125;
pub const SYS_MKNS: usize = 984;
pub const SYS_NANOSLEEP: usize =162;
pub const SYS_PHYSALLOC: usize =945;
pub const SYS_PHYSALLOC3: usize=9453;
pub const SYS_PHYSFREE: usize = 946;
pub const SYS_PHYSMAP: usize = 947;
pub const SYS_VIRTTOPHYS: usize=949;
pub const SYS_SETPGID: usize = 57;