From 7001b32a4a6fee153a07e5fdb9cece1ac176cedc Mon Sep 17 00:00:00 2001 From: "Tate, Hongliang Tian" Date: Sat, 17 Aug 2019 07:38:16 +0000 Subject: [PATCH] Format all Rust code with `cargo fmt` In addition, to ensure that all future Rust code complies with `cargo fmt`, we add a Git post-commit hook that generates warnings if the commited code is not formated consistently. --- src/libos/src/config.rs | 114 ++++++++++++---------- src/libos/src/entry.rs | 4 +- src/libos/src/fs/dev_random.rs | 5 +- src/libos/src/fs/mod.rs | 16 +-- src/libos/src/fs/root_inode.rs | 68 +++++++------ src/libos/src/fs/sgx_impl.rs | 24 +++-- src/libos/src/lib.rs | 8 +- src/libos/src/process/mod.rs | 6 +- src/libos/src/process/process.rs | 2 +- src/libos/src/process/sched.rs | 30 ++++-- src/libos/src/process/spawn/init_stack.rs | 16 +-- src/libos/src/process/spawn/init_vm.rs | 7 +- src/libos/src/process/spawn/mod.rs | 24 ++--- src/libos/src/process/spawn/segment.rs | 3 +- src/libos/src/process/task.rs | 1 - src/libos/src/process/thread.rs | 18 ++-- src/libos/src/syscall/mod.rs | 19 ++-- src/libos/src/time/mod.rs | 22 +++-- src/libos/src/vm/mod.rs | 10 +- src/libos/src/vm/process_vm.rs | 53 +++++----- src/libos/src/vm/user_space_vm.rs | 28 +++--- src/libos/src/vm/vm_manager.rs | 95 +++++++++--------- 22 files changed, 314 insertions(+), 259 deletions(-) diff --git a/src/libos/src/config.rs b/src/libos/src/config.rs index f3e90f6c..4f5e808d 100644 --- a/src/libos/src/config.rs +++ b/src/libos/src/config.rs @@ -1,50 +1,61 @@ use super::*; use serde::{Deserialize, Serialize}; -use std::sgxfs::{SgxFile}; use std::path::{Path, PathBuf}; +use std::sgxfs::SgxFile; -const LIBOS_CONFIG_PATH : &str = "Occlum.json.protected"; +const LIBOS_CONFIG_PATH: &str = "Occlum.json.protected"; lazy_static! { pub static ref LIBOS_CONFIG: Config = { let mut config_file = { let config_file = match SgxFile::open_integrity_only(LIBOS_CONFIG_PATH) { - Err(_) => panic!("Failed to find or open Occlum's config file: {}", - LIBOS_CONFIG_PATH), + Err(_) => panic!( + "Failed to find or open Occlum's config file: {}", + LIBOS_CONFIG_PATH + ), Ok(file) => file, }; let actual_mac = match config_file.get_mac() { - Err(_) => panic!("Failed to get the MAC of Occlum's config file: {}", - LIBOS_CONFIG_PATH), + Err(_) => panic!( + "Failed to get the MAC of Occlum's config file: {}", + LIBOS_CONFIG_PATH + ), Ok(mac) => mac, }; let expected_mac = conf_get_hardcoded_file_mac(); if actual_mac != expected_mac { - panic!("The MAC of Occlum's config file is not as expected: {}", - LIBOS_CONFIG_PATH); + panic!( + "The MAC of Occlum's config file is not as expected: {}", + LIBOS_CONFIG_PATH + ); } config_file }; let config_json = { let mut config_json = String::new(); - config_file.read_to_string(&mut config_json) - .map_err(|_| { - panic!("Failed to read from Occlum's config file: {}", - LIBOS_CONFIG_PATH); - }); + config_file.read_to_string(&mut config_json).map_err(|_| { + panic!( + "Failed to read from Occlum's config file: {}", + LIBOS_CONFIG_PATH + ); + }); config_json }; let config_input: InputConfig = match serde_json::from_str(&config_json) { - Err(_) => panic!("Failed to parse JSON from Occlum's config file: {}", - LIBOS_CONFIG_PATH), - Ok(config_input) => config_input + Err(_) => panic!( + "Failed to parse JSON from Occlum's config file: {}", + LIBOS_CONFIG_PATH + ), + Ok(config_input) => config_input, }; let config = match Config::from_input(&config_input) { - Err(_) => panic!("Found invalid config in Occlum's config file: {}", - LIBOS_CONFIG_PATH), - Ok(config) => config + Err(_) => panic!( + "Found invalid config in Occlum's config file: {}", + LIBOS_CONFIG_PATH + ), + Ok(config) => config, }; config }; @@ -61,20 +72,19 @@ fn conf_get_hardcoded_file_mac() -> sgx_aes_gcm_128bit_tag_t { .to_str() .expect("Invalid MAC") }; - let mac = parse_mac(mac_str) - .expect("Invalid MAC"); + let mac = parse_mac(mac_str).expect("Invalid MAC"); mac } fn parse_mac(mac_str: &str) -> Result { let bytes_str_vec = { - let bytes_str_vec : Vec<&str> = mac_str.split("-").collect(); + let bytes_str_vec: Vec<&str> = mac_str.split("-").collect(); if bytes_str_vec.len() != 16 { return errno!(EINVAL, "The length or format of MAC string is invalid"); } bytes_str_vec }; - let mut mac : sgx_aes_gcm_128bit_tag_t = Default::default(); + let mut mac: sgx_aes_gcm_128bit_tag_t = Default::default(); for (byte_i, byte_str) in bytes_str_vec.iter().enumerate() { mac[byte_i] = u8::from_str_radix(byte_str, 16) .map_err(|_| Error::new(Errno::EINVAL, "The format of MAC string is invalid"))?; @@ -82,7 +92,6 @@ fn parse_mac(mac_str: &str) -> Result { Ok(mac) } - #[derive(Debug)] pub struct Config { pub vm: ConfigVM, @@ -92,7 +101,7 @@ pub struct Config { #[derive(Debug)] pub struct ConfigVM { - pub user_space_size : usize, + pub user_space_size: usize, } #[derive(Debug)] @@ -124,7 +133,6 @@ pub struct ConfigMountOptions { pub mac: Option, } - impl Config { fn from_input(input: &InputConfig) -> Result { let vm = ConfigVM::from_input(&input.vm)?; @@ -162,7 +170,7 @@ impl ConfigProcess { impl ConfigMount { fn from_input(input: &InputConfigMount) -> Result { - const ALL_FS_TYPES : [&str; 3] = [ "sefs", "hostfs", "ramfs" ]; + const ALL_FS_TYPES: [&str; 3] = ["sefs", "hostfs", "ramfs"]; let type_ = match input.type_.as_str() { "sefs" => ConfigMountFsType::TYPE_SEFS, @@ -181,28 +189,34 @@ impl ConfigMount { }; let source = input.source.as_ref().map(|s| PathBuf::from(s)); let options = ConfigMountOptions::from_input(&input.options)?; - Ok(ConfigMount { type_, target, source, options, }) + Ok(ConfigMount { + type_, + target, + source, + options, + }) } } impl ConfigMountOptions { fn from_input(input: &InputConfigMountOptions) -> Result { - let (integrity_only, mac) = - if !input.integrity_only { - (false, None) - } else { - if input.mac.is_none() { - return errno!(EINVAL, "MAC is expected"); - } - (true, Some(parse_mac(&input.mac.as_ref().unwrap())?)) - }; - Ok(ConfigMountOptions { integrity_only, mac }) + let (integrity_only, mac) = if !input.integrity_only { + (false, None) + } else { + if input.mac.is_none() { + return errno!(EINVAL, "MAC is expected"); + } + (true, Some(parse_mac(&input.mac.as_ref().unwrap())?)) + }; + Ok(ConfigMountOptions { + integrity_only, + mac, + }) } } - fn parse_memory_size(mem_str: &str) -> Result { - const UNIT2FACTOR : [(&str, usize); 5]= [ + const UNIT2FACTOR: [(&str, usize); 5] = [ ("KB", 1024), ("MB", 1024 * 1024), ("GB", 1024 * 1024 * 1024), @@ -216,18 +230,16 @@ fn parse_memory_size(mem_str: &str) -> Result { .position(|(unit, _)| mem_str.ends_with(unit)) .ok_or_else(|| Error::new(Errno::EINVAL, "No unit")) .map(|unit_i| &UNIT2FACTOR[unit_i])?; - let number = - match mem_str[0..mem_str.len() - unit.len()] - .trim() - .parse::() - { - Err(_) => return errno!(EINVAL, "No number"), - Ok(number) => number - }; + let number = match mem_str[0..mem_str.len() - unit.len()] + .trim() + .parse::() + { + Err(_) => return errno!(EINVAL, "No number"), + Ok(number) => number, + }; Ok(number * factor) } - #[derive(Deserialize, Debug)] #[serde(deny_unknown_fields)] struct InputConfig { @@ -243,7 +255,7 @@ struct InputConfig { #[serde(deny_unknown_fields)] struct InputConfigVM { #[serde(default = "InputConfigVM::get_user_space_size")] - pub user_space_size : String, + pub user_space_size: String, } impl InputConfigVM { @@ -255,7 +267,7 @@ impl InputConfigVM { impl Default for InputConfigVM { fn default() -> InputConfigVM { InputConfigVM { - user_space_size: InputConfigVM::get_user_space_size() + user_space_size: InputConfigVM::get_user_space_size(), } } } diff --git a/src/libos/src/entry.rs b/src/libos/src/entry.rs index 23601aef..156f7907 100644 --- a/src/libos/src/entry.rs +++ b/src/libos/src/entry.rs @@ -81,9 +81,7 @@ fn do_boot(path_str: &str, argv: &Vec) -> Result<(), Error> { util::mpx_util::mpx_enable()?; // The default environment variables - let envp = vec![ - CString::new("OCCLUM=yes").unwrap() - ]; + let envp = vec![CString::new("OCCLUM=yes").unwrap()]; let file_actions = Vec::new(); let parent = &process::IDLE_PROCESS; process::do_spawn(&path_str, argv, &envp, &file_actions, parent)?; diff --git a/src/libos/src/fs/dev_random.rs b/src/libos/src/fs/dev_random.rs index d5de4ac2..cfe9f96f 100644 --- a/src/libos/src/fs/dev_random.rs +++ b/src/libos/src/fs/dev_random.rs @@ -31,9 +31,8 @@ impl File for DevRandom { } Err(e) => { if total_nbytes > 0 { - break - } - else { + break; + } else { return Err(e); } } diff --git a/src/libos/src/fs/mod.rs b/src/libos/src/fs/mod.rs index f56aac1b..ad0fdce5 100644 --- a/src/libos/src/fs/mod.rs +++ b/src/libos/src/fs/mod.rs @@ -7,32 +7,32 @@ use {process, std}; use super::*; pub use self::access::{do_access, do_faccessat, AccessFlags, AccessModes, AT_FDCWD}; +use self::dev_null::DevNull; +use self::dev_random::DevRandom; +use self::dev_zero::DevZero; pub use self::file::{File, FileRef, SgxFile, StdinFile, StdoutFile}; pub use self::file_table::{FileDesc, FileTable}; use self::inode_file::OpenOptions; pub use self::inode_file::{INodeExt, INodeFile}; -pub use self::root_inode::{ROOT_INODE}; pub use self::io_multiplexing::*; -use self::dev_null::DevNull; -use self::dev_zero::DevZero; -use self::dev_random::DevRandom; pub use self::pipe::Pipe; +pub use self::root_inode::ROOT_INODE; pub use self::socket_file::{AsSocket, SocketFile}; pub use self::unix_socket::{AsUnixSocket, UnixSocketFile}; use std::any::Any; use std::mem::uninitialized; mod access; +mod dev_null; +mod dev_random; +mod dev_zero; mod file; mod file_table; mod hostfs; mod inode_file; -mod root_inode; mod io_multiplexing; -mod dev_null; -mod dev_zero; -mod dev_random; mod pipe; +mod root_inode; mod sgx_impl; mod socket_file; mod unix_socket; diff --git a/src/libos/src/fs/root_inode.rs b/src/libos/src/fs/root_inode.rs index 2454694b..5a7f76fc 100644 --- a/src/libos/src/fs/root_inode.rs +++ b/src/libos/src/fs/root_inode.rs @@ -1,14 +1,14 @@ -use super::*; use super::hostfs::HostFS; use super::sgx_impl::SgxStorage; +use super::*; use config::{ConfigMount, ConfigMountFsType}; use std::path::{Path, PathBuf}; use rcore_fs::vfs::{FileSystem, FileType, FsError, INode}; -use rcore_fs_sefs::SEFS; -use rcore_fs_sefs::dev::*; -use rcore_fs_mountfs::{MountFS, MNode}; +use rcore_fs_mountfs::{MNode, MountFS}; use rcore_fs_ramfs::RamFS; +use rcore_fs_sefs::dev::*; +use rcore_fs_sefs::SEFS; lazy_static! { /// The root of file system @@ -26,42 +26,53 @@ lazy_static! { }; } -fn open_or_create_root_fs_according_to(mount_config: &Vec) - -> Result, Error> -{ +fn open_or_create_root_fs_according_to( + mount_config: &Vec, +) -> Result, Error> { let root_sefs_source = { let root_mount_config = mount_config .iter() .find(|m| m.target == Path::new("/")) .ok_or_else(|| Error::new(Errno::ENOENT, "The mount point at / is not specified"))?; - if root_mount_config.type_ != ConfigMountFsType::TYPE_SEFS { + if root_mount_config.type_ != ConfigMountFsType::TYPE_SEFS { return errno!(EINVAL, "The mount point at / must be SEFS"); } if root_mount_config.options.integrity_only { - return errno!(EINVAL, "The root SEFS at / must be encrypted (i.e., integrity-only is not enough)"); + return errno!( + EINVAL, + "The root SEFS at / must be encrypted (i.e., integrity-only is not enough)" + ); } if root_mount_config.source.is_none() { - return errno!(EINVAL, "The root SEFS must be given a source path (on host)"); + return errno!( + EINVAL, + "The root SEFS must be given a source path (on host)" + ); } root_mount_config.source.as_ref().unwrap() }; let root_sefs = { - SEFS::open(Box::new(SgxStorage::new(root_sefs_source, false)), - &time::OcclumTimeProvider) + SEFS::open( + Box::new(SgxStorage::new(root_sefs_source, false)), + &time::OcclumTimeProvider, + ) } .or_else(|_| { - SEFS::create(Box::new(SgxStorage::new(root_sefs_source, false)), - &time::OcclumTimeProvider) + SEFS::create( + Box::new(SgxStorage::new(root_sefs_source, false)), + &time::OcclumTimeProvider, + ) })?; let root_mountable_sefs = MountFS::new(root_sefs); Ok(root_mountable_sefs) } -fn mount_nonroot_fs_according_to(mount_config: &Vec, root: &MNode) - -> Result<(), Error> -{ +fn mount_nonroot_fs_according_to( + mount_config: &Vec, + root: &MNode, +) -> Result<(), Error> { for mc in mount_config { if mc.target == Path::new("/") { continue; @@ -79,10 +90,13 @@ fn mount_nonroot_fs_according_to(mount_config: &Vec, root: &MNode) match mc.type_ { TYPE_SEFS => { if !mc.options.integrity_only { - return errno!(EINVAL, "Must be integrity-only SEFS") + return errno!(EINVAL, "Must be integrity-only SEFS"); } if mc.source.is_none() { - return errno!(EINVAL, "Source is expected for integrity-only SEFS is supported") + return errno!( + EINVAL, + "Source is expected for integrity-only SEFS is supported" + ); } let source_path = mc.source.as_ref().unwrap(); @@ -93,28 +107,26 @@ fn mount_nonroot_fs_according_to(mount_config: &Vec, root: &MNode) }; let sefs = SEFS::open(device, &time::OcclumTimeProvider)?; mount_fs_at(sefs, &root, target_dirname)?; - }, + } TYPE_HOSTFS => { if mc.source.is_none() { - return errno!(EINVAL, "Source is expected for HostFS") + return errno!(EINVAL, "Source is expected for HostFS"); } let source_path = mc.source.as_ref().unwrap(); let hostfs = HostFS::new(source_path); mount_fs_at(hostfs, &root, target_dirname)?; - }, + } TYPE_RAMFS => { let ramfs = RamFS::new(); mount_fs_at(ramfs, &root, target_dirname)?; - }, + } } } Ok(()) } -fn mount_fs_at(fs: Arc, parent_inode: &MNode, dirname: &str) - -> Result<(), Error> -{ +fn mount_fs_at(fs: Arc, parent_inode: &MNode, dirname: &str) -> Result<(), Error> { let mount_dir = match parent_inode.find(false, dirname) { Ok(existing_dir) => { if existing_dir.metadata()?.type_ != FileType::Dir { @@ -122,9 +134,7 @@ fn mount_fs_at(fs: Arc, parent_inode: &MNode, dirname: &str) } existing_dir } - Err(_) => { - parent_inode.create(dirname, FileType::Dir, 0o777)? - } + Err(_) => parent_inode.create(dirname, FileType::Dir, 0o777)?, }; mount_dir.mount(fs); Ok(()) diff --git a/src/libos/src/fs/sgx_impl.rs b/src/libos/src/fs/sgx_impl.rs index 220e9087..0158fe82 100644 --- a/src/libos/src/fs/sgx_impl.rs +++ b/src/libos/src/fs/sgx_impl.rs @@ -1,4 +1,4 @@ -use super::{sgx_aes_gcm_128bit_tag_t}; +use super::sgx_aes_gcm_128bit_tag_t; use rcore_fs::dev::TimeProvider; use rcore_fs::vfs::Timespec; use rcore_fs_sefs::dev::*; @@ -31,7 +31,11 @@ impl SgxStorage { /// It lookups cache first, if miss, then call `open_fn` to open one, /// and add it to cache before return. #[cfg(feature = "sgx_file_cache")] - fn get(&self, file_id: usize, open_fn: impl FnOnce(&Self) -> DevResult) -> DevResult { + fn get( + &self, + file_id: usize, + open_fn: impl FnOnce(&Self) -> DevResult, + ) -> DevResult { // query cache let mut caches = self.file_cache.lock().unwrap(); if let Some(locked_file) = caches.get(&file_id) { @@ -46,7 +50,11 @@ impl SgxStorage { } /// Get file by `file_id` without cache. #[cfg(not(feature = "sgx_file_cache"))] - fn get(&self, file_id: usize, open_fn: impl FnOnce(&Self) -> DevResult) -> LockedFile { + fn get( + &self, + file_id: usize, + open_fn: impl FnOnce(&Self) -> DevResult, + ) -> LockedFile { open_fn(self) } @@ -84,11 +92,13 @@ impl Storage for SgxStorage { // Check the MAC of the root file against the given root MAC of the storage if file_id == 0 && self.root_mac.is_some() { - let root_file_mac = file.get_mac() - .expect("Failed to get mac"); + let root_file_mac = file.get_mac().expect("Failed to get mac"); if root_file_mac != self.root_mac.unwrap() { - println!("Expected MAC = {:#?}, actual MAC = {:?}", - self.root_mac.unwrap(), root_file_mac); + println!( + "Expected MAC = {:#?}, actual MAC = {:?}", + self.root_mac.unwrap(), + root_file_mac + ); return Err(DeviceError); } } diff --git a/src/libos/src/lib.rs b/src/libos/src/lib.rs index 586a8921..0cfdef86 100644 --- a/src/libos/src/lib.rs +++ b/src/libos/src/lib.rs @@ -23,9 +23,9 @@ extern crate lazy_static; #[macro_use] extern crate log; extern crate rcore_fs; -extern crate rcore_fs_sefs; -extern crate rcore_fs_ramfs; extern crate rcore_fs_mountfs; +extern crate rcore_fs_ramfs; +extern crate rcore_fs_sefs; #[macro_use] extern crate derive_builder; extern crate serde; @@ -39,9 +39,9 @@ use std::panic; #[macro_use] mod prelude; -mod errno; -mod entry; mod config; +mod entry; +mod errno; mod fs; mod misc; mod process; diff --git a/src/libos/src/process/mod.rs b/src/libos/src/process/mod.rs index 5de400bb..e7d9c4ad 100644 --- a/src/libos/src/process/mod.rs +++ b/src/libos/src/process/mod.rs @@ -3,11 +3,11 @@ pub use self::exit::{do_exit, do_wait4, ChildProcessFilter}; pub use self::futex::{futex_op_and_flags_from_u32, futex_wait, futex_wake, FutexFlags, FutexOp}; pub use self::process::{Status, IDLE_PROCESS}; pub use self::process_table::get; +pub use self::sched::{do_sched_getaffinity, do_sched_setaffinity, CpuSet}; pub use self::spawn::{do_spawn, FileAction}; pub use self::task::{current_pid, get_current, run_task}; pub use self::thread::{do_clone, do_set_tid_address, CloneFlags, ThreadGroup}; pub use self::wait::{WaitQueue, Waiter}; -pub use self::sched::{CpuSet, do_sched_getaffinity, do_sched_setaffinity}; #[allow(non_camel_case_types)] pub type pid_t = u32; @@ -71,14 +71,14 @@ mod exit; mod futex; mod process; mod process_table; +mod sched; mod spawn; mod task; mod thread; mod wait; -mod sched; use self::task::Task; use super::*; use fs::{File, FileRef, FileTable}; use misc::ResourceLimitsRef; -use vm::{ProcessVM}; +use vm::ProcessVM; diff --git a/src/libos/src/process/process.rs b/src/libos/src/process/process.rs index f1cdc238..2a67da51 100644 --- a/src/libos/src/process/process.rs +++ b/src/libos/src/process/process.rs @@ -1,7 +1,7 @@ use super::task::Task; use super::*; use fs::{File, FileRef, FileTable}; -use vm::{ProcessVM}; +use vm::ProcessVM; lazy_static! { // Dummy object to make all processes having a parent diff --git a/src/libos/src/process/sched.rs b/src/libos/src/process/sched.rs index ecfb1d76..5a115c07 100644 --- a/src/libos/src/process/sched.rs +++ b/src/libos/src/process/sched.rs @@ -1,8 +1,20 @@ use super::*; extern "C" { - fn ocall_sched_getaffinity(ret: *mut i32, errno: *mut i32, pid: i32, cpusetsize: size_t, mask: *mut c_uchar) -> sgx_status_t; - fn ocall_sched_setaffinity(ret: *mut i32, errno: *mut i32, pid: i32, cpusetsize: size_t, mask: *const c_uchar) -> sgx_status_t; + fn ocall_sched_getaffinity( + ret: *mut i32, + errno: *mut i32, + pid: i32, + cpusetsize: size_t, + mask: *mut c_uchar, + ) -> sgx_status_t; + fn ocall_sched_setaffinity( + ret: *mut i32, + errno: *mut i32, + pid: i32, + cpusetsize: size_t, + mask: *const c_uchar, + ) -> sgx_status_t; } pub struct CpuSet { @@ -11,13 +23,17 @@ pub struct CpuSet { impl CpuSet { pub fn new(len: usize) -> CpuSet { - let mut cpuset = CpuSet { vec: Vec::with_capacity(len) }; + let mut cpuset = CpuSet { + vec: Vec::with_capacity(len), + }; cpuset.vec.resize(len, 0); cpuset } pub fn from_raw_buf(ptr: *const u8, cpusize: usize) -> CpuSet { - let mut cpuset = CpuSet { vec: Vec::with_capacity(cpusize) }; + let mut cpuset = CpuSet { + vec: Vec::with_capacity(cpusize), + }; let buf_slice = unsafe { std::slice::from_raw_parts(ptr, cpusize) }; cpuset.vec.extend_from_slice(buf_slice); cpuset @@ -63,11 +79,7 @@ impl std::fmt::UpperHex for CpuSet { } fn find_host_tid(pid: pid_t) -> Result { - let process_ref = if pid == 0 { - get_current() - } else { - get(pid)? - }; + let process_ref = if pid == 0 { get_current() } else { get(pid)? }; let mut process = process_ref.lock().unwrap(); let host_tid = process.get_host_tid(); Ok(host_tid) diff --git a/src/libos/src/process/spawn/init_stack.rs b/src/libos/src/process/spawn/init_stack.rs index 3034a2ce..40e70e96 100644 --- a/src/libos/src/process/spawn/init_stack.rs +++ b/src/libos/src/process/spawn/init_stack.rs @@ -86,8 +86,7 @@ impl StackBuf { }) } - pub fn put(&self, val: u64) -> Result<*const u64, Error> - { + pub fn put(&self, val: u64) -> Result<*const u64, Error> { let val_ptr = self.alloc(8, 8)? as *mut u64; unsafe { ptr::write(val_ptr, val); @@ -206,14 +205,14 @@ pub enum AuxKey { AT_CLKTCK = 17, /* frequency at which times() increments */ /* 18...22 not used */ - AT_SECURE = 23, /* secure mode boolean */ + AT_SECURE = 23, /* secure mode boolean */ AT_BASE_PLATFORM = 24, /* string identifying real platform, may * differ from AT_PLATFORM. */ - AT_RANDOM = 25, /* address of 16 random bytes */ - AT_HWCAP2 = 26, /* extension of AT_HWCAP */ + AT_RANDOM = 25, /* address of 16 random bytes */ + AT_HWCAP2 = 26, /* extension of AT_HWCAP */ /* 28...30 not used */ - AT_EXECFN = 31, /* filename of program */ + AT_EXECFN = 31, /* filename of program */ AT_SYSINFO = 32, /* Occlum-specific entries */ @@ -238,7 +237,8 @@ impl AuxTable { if key == AuxKey::AT_NULL || key == AuxKey::AT_IGNORE { return errno!(EINVAL, "Illegal key"); } - self.table.entry(key) + self.table + .entry(key) .and_modify(|val_mut| *val_mut = val) .or_insert(val); Ok(()) @@ -248,7 +248,7 @@ impl AuxTable { self.table.get(&key).map(|val_ref| *val_ref) } - pub fn del(&mut self, key: AuxKey) -> Option{ + pub fn del(&mut self, key: AuxKey) -> Option { self.table.remove(&key) } diff --git a/src/libos/src/process/spawn/init_vm.rs b/src/libos/src/process/spawn/init_vm.rs index b6e0aade..b1e7bf29 100644 --- a/src/libos/src/process/spawn/init_vm.rs +++ b/src/libos/src/process/spawn/init_vm.rs @@ -7,7 +7,7 @@ pub fn do_init( elf_file: &ElfFile, elf_buf: &[u8], ldso_elf_file: &ElfFile, - ldso_elf_buf: &[u8] + ldso_elf_buf: &[u8], ) -> Result { // Alloc all virtual memory areas let mut code_seg = get_code_segment(elf_file)?; @@ -24,7 +24,10 @@ pub fn do_init( let ldso_code_start = 0; let ldso_code_end = align_down(ldso_data_seg.get_mem_addr(), ldso_data_seg.get_mem_align()); let ldso_data_start = ldso_code_end; - let ldso_data_end = align_up(ldso_data_seg.get_mem_addr() + ldso_data_seg.get_mem_size(), 4096); + let ldso_data_end = align_up( + ldso_data_seg.get_mem_addr() + ldso_data_seg.get_mem_size(), + 4096, + ); let ldso_code_size = ldso_code_end - ldso_code_start; let ldso_data_size = ldso_data_end - ldso_data_start; diff --git a/src/libos/src/process/spawn/mod.rs b/src/libos/src/process/spawn/mod.rs index 60090c25..c8db7397 100644 --- a/src/libos/src/process/spawn/mod.rs +++ b/src/libos/src/process/spawn/mod.rs @@ -64,8 +64,8 @@ pub fn do_spawn>( }; let ldso_elf_file = { - let ldso_elf_file = - ElfFile::new(&ldso_elf_buf).map_err(|e| (Errno::ENOEXEC, "Failed to parse the ELF file"))?; + let ldso_elf_file = ElfFile::new(&ldso_elf_buf) + .map_err(|e| (Errno::ENOEXEC, "Failed to parse the ELF file"))?; header::sanity_check(&ldso_elf_file) .map_err(|e| (Errno::ENOEXEC, "Failed to parse the ELF file"))?; /* @@ -78,15 +78,13 @@ pub fn do_spawn>( let (new_pid, new_process_ref) = { let cwd = parent_ref.lock().unwrap().get_cwd().to_owned(); - let vm = init_vm::do_init(&elf_file, &elf_buf[..], - &ldso_elf_file, &ldso_elf_buf[..])?; + let vm = init_vm::do_init(&elf_file, &elf_buf[..], &ldso_elf_file, &ldso_elf_buf[..])?; let base_addr = vm.get_base_addr(); let auxtbl = init_auxtbl(&vm, &elf_file)?; let task = { let ldso_entry = { let ldso_base_addr = vm.get_ldso_code_range().start(); - let ldso_entry = ldso_base_addr + - elf_helper::get_start_address(&ldso_elf_file)?; + let ldso_entry = ldso_base_addr + elf_helper::get_start_address(&ldso_elf_file)?; if !vm.get_ldso_code_range().contains(ldso_entry) { return errno!(EINVAL, "Invalid program entry"); } @@ -96,8 +94,13 @@ pub fn do_spawn>( let user_stack_limit = vm.get_stack_limit(); let user_rsp = init_stack::do_init(user_stack_base, 4096, argv, envp, &auxtbl)?; unsafe { - Task::new(ldso_entry, user_rsp, - user_stack_base, user_stack_limit, None)? + Task::new( + ldso_entry, + user_rsp, + user_stack_base, + user_stack_limit, + None, + )? } }; let vm_ref = Arc::new(SgxMutex::new(vm)); @@ -167,10 +170,7 @@ fn init_files(parent_ref: &ProcessRef, file_actions: &[FileAction]) -> Result Result { +fn init_auxtbl(process_vm: &ProcessVM, elf_file: &ElfFile) -> Result { let mut auxtbl = AuxTable::new(); auxtbl.set(AuxKey::AT_PAGESZ, 4096)?; auxtbl.set(AuxKey::AT_UID, 0)?; diff --git a/src/libos/src/process/spawn/segment.rs b/src/libos/src/process/spawn/segment.rs index ff4b4390..85dd82ef 100644 --- a/src/libos/src/process/spawn/segment.rs +++ b/src/libos/src/process/spawn/segment.rs @@ -40,7 +40,8 @@ impl Segment { return Err(( Errno::EINVAL, "Memory address and file offset is not equal, per modulo", - ).into()); + ) + .into()); } if ph64.mem_size < ph64.file_size { return Err((Errno::EINVAL, "Memory size must be greater than file size").into()); diff --git a/src/libos/src/process/task.rs b/src/libos/src/process/task.rs index 942515cc..a0e3beaa 100644 --- a/src/libos/src/process/task.rs +++ b/src/libos/src/process/task.rs @@ -52,7 +52,6 @@ impl Task { } } - lazy_static! { static ref NEW_PROCESS_QUEUE: SgxMutex> = { SgxMutex::new(VecDeque::new()) }; diff --git a/src/libos/src/process/thread.rs b/src/libos/src/process/thread.rs index 1aa6a9ce..39620167 100644 --- a/src/libos/src/process/thread.rs +++ b/src/libos/src/process/thread.rs @@ -1,5 +1,5 @@ +use super::vm::VMRange; use super::*; -use super::vm::{VMRange}; pub struct ThreadGroup { threads: Vec, @@ -64,9 +64,13 @@ pub fn do_clone( let user_stack_base = user_stack_range.end(); let user_stack_limit = user_stack_range.start(); unsafe { - Task::new(thread_entry, user_rsp, - user_stack_base, user_stack_limit, - new_tls)? + Task::new( + thread_entry, + user_rsp, + user_stack_base, + user_stack_limit, + new_tls, + )? } }; let files_ref = current.get_files().clone(); @@ -119,11 +123,9 @@ fn guess_user_stack_bound(vm: &ProcessVM, user_rsp: usize) -> Result<&VMRange, E // The next three cases are very unlikely, but valid else if vm.get_stack_range().contains(user_rsp) { Ok(vm.get_stack_range()) - } - else if vm.get_heap_range().contains(user_rsp) { + } else if vm.get_heap_range().contains(user_rsp) { Ok(vm.get_heap_range()) - } - else if vm.get_data_range().contains(user_rsp) { + } else if vm.get_data_range().contains(user_rsp) { Ok(vm.get_data_range()) } // Invalid diff --git a/src/libos/src/syscall/mod.rs b/src/libos/src/syscall/mod.rs index 44efd518..a2d46f92 100644 --- a/src/libos/src/syscall/mod.rs +++ b/src/libos/src/syscall/mod.rs @@ -10,12 +10,12 @@ use fs::*; use misc::{resource_t, rlimit_t, utsname_t}; use prelude::*; -use process::{pid_t, ChildProcessFilter, CloneFlags, FileAction, FutexFlags, FutexOp, CpuSet}; +use process::{pid_t, ChildProcessFilter, CloneFlags, CpuSet, FileAction, FutexFlags, FutexOp}; use std::ffi::{CStr, CString}; use std::ptr; -use time::{timeval_t, clockid_t, timespec_t}; +use time::{clockid_t, timespec_t, timeval_t}; use util::mem_util::from_user::*; -use vm::{VMPerms, MMapFlags}; +use vm::{MMapFlags, VMPerms}; use {fs, process, std, vm}; use super::*; @@ -175,8 +175,12 @@ pub extern "C" fn dispatch_syscall( ), SYS_ARCH_PRCTL => do_arch_prctl(arg0 as u32, arg1 as *mut usize), SYS_SET_TID_ADDRESS => do_set_tid_address(arg0 as *mut pid_t), - SYS_SCHED_GETAFFINITY => do_sched_getaffinity(arg0 as pid_t, arg1 as size_t, arg2 as *mut c_uchar), - SYS_SCHED_SETAFFINITY => do_sched_setaffinity(arg0 as pid_t, arg1 as size_t, arg2 as *const c_uchar), + SYS_SCHED_GETAFFINITY => { + do_sched_getaffinity(arg0 as pid_t, arg1 as size_t, arg2 as *mut c_uchar) + } + SYS_SCHED_SETAFFINITY => { + do_sched_setaffinity(arg0 as pid_t, arg1 as size_t, arg2 as *const c_uchar) + } // memory SYS_MMAP => do_mmap( @@ -803,7 +807,6 @@ fn do_clock_gettime(clockid: clockid_t, ts_u: *mut timespec_t) -> Result Result { process::do_set_tid_address(tidptr).map(|tid| tid as isize) } -fn do_sched_getaffinity(pid: pid_t, cpusize: size_t, buf: *mut c_uchar) -> Result { +fn do_sched_getaffinity(pid: pid_t, cpusize: size_t, buf: *mut c_uchar) -> Result { // Construct safe Rust types let mut buf_slice = { check_mut_array(buf, cpusize)?; @@ -983,7 +986,7 @@ fn do_sched_getaffinity(pid: pid_t, cpusize: size_t, buf: *mut c_uchar) -> Resu Ok(ret as isize) } -fn do_sched_setaffinity(pid: pid_t, cpusize: size_t, buf: *const c_uchar) -> Result { +fn do_sched_setaffinity(pid: pid_t, cpusize: size_t, buf: *const c_uchar) -> Result { // Convert unsafe C types into safe Rust types let cpuset = { check_array(buf, cpusize)?; diff --git a/src/libos/src/time/mod.rs b/src/libos/src/time/mod.rs index 27b0b765..21fb3c8a 100644 --- a/src/libos/src/time/mod.rs +++ b/src/libos/src/time/mod.rs @@ -35,7 +35,6 @@ extern "C" { fn ocall_gettimeofday(sec: *mut time_t, usec: *mut suseconds_t) -> sgx_status_t; } - #[repr(C)] #[derive(Debug, Default, Copy, Clone)] #[allow(non_camel_case_types)] @@ -50,14 +49,14 @@ pub type clockid_t = i32; #[derive(Debug, Copy, Clone)] #[allow(non_camel_case_types)] pub enum ClockID { - CLOCK_REALTIME = 0, - CLOCK_MONOTONIC = 1, + CLOCK_REALTIME = 0, + CLOCK_MONOTONIC = 1, CLOCK_PROCESS_CPUTIME_ID = 2, - CLOCK_THREAD_CPUTIME_ID = 3, - CLOCK_MONOTONIC_RAW = 4, - CLOCK_REALTIME_COARSE = 5, - CLOCK_MONOTONIC_COARSE = 6, - CLOCK_BOOTTIME = 7, + CLOCK_THREAD_CPUTIME_ID = 3, + CLOCK_MONOTONIC_RAW = 4, + CLOCK_REALTIME_COARSE = 5, + CLOCK_MONOTONIC_COARSE = 6, + CLOCK_BOOTTIME = 7, } impl ClockID { @@ -81,7 +80,11 @@ pub fn do_clock_gettime(clockid: ClockID) -> Result { let mut sec = 0; let mut nsec = 0; unsafe { - ocall_clock_gettime(clockid as clockid_t, &mut sec as *mut time_t, &mut nsec as *mut i64); + ocall_clock_gettime( + clockid as clockid_t, + &mut sec as *mut time_t, + &mut nsec as *mut i64, + ); } Ok(timespec_t { sec, nsec }) } @@ -90,7 +93,6 @@ extern "C" { fn ocall_clock_gettime(clockid: clockid_t, sec: *mut time_t, ns: *mut i64) -> sgx_status_t; } - // For SEFS pub struct OcclumTimeProvider; diff --git a/src/libos/src/vm/mod.rs b/src/libos/src/vm/mod.rs index 4567b770..c5e0bc15 100644 --- a/src/libos/src/vm/mod.rs +++ b/src/libos/src/vm/mod.rs @@ -1,14 +1,14 @@ +use fs::{File, FileDesc, FileRef}; use prelude::*; use process::{get_current, Process, ProcessRef}; -use fs::{FileDesc, FileRef, File}; use std::fmt; -mod vm_manager; -mod user_space_vm; mod process_vm; +mod user_space_vm; +mod vm_manager; -pub use self::process_vm::{ProcessVM, ProcessVMBuilder, MMapFlags, VMPerms}; -pub use self::vm_manager::{VMRange}; +pub use self::process_vm::{MMapFlags, ProcessVM, ProcessVMBuilder, VMPerms}; +pub use self::vm_manager::VMRange; pub fn do_mmap( addr: usize, diff --git a/src/libos/src/vm/process_vm.rs b/src/libos/src/vm/process_vm.rs index 7c2c8f8c..91f82aa8 100644 --- a/src/libos/src/vm/process_vm.rs +++ b/src/libos/src/vm/process_vm.rs @@ -1,10 +1,11 @@ -use super::*; -use super::vm_manager::{VMRange, VMManager, VMMapOptionsBuilder, VMMapOptions, VMMapAddr, VMInitializer}; -use super::user_space_vm::{UserSpaceVMManager, UserSpaceVMRange, USER_SPACE_VM_MANAGER}; use super::super::config; +use super::user_space_vm::{UserSpaceVMManager, UserSpaceVMRange, USER_SPACE_VM_MANAGER}; +use super::vm_manager::{ + VMInitializer, VMManager, VMMapAddr, VMMapOptions, VMMapOptionsBuilder, VMRange, +}; +use super::*; use std::slice; - #[derive(Debug, Default)] pub struct ProcessVMBuilder { code_size: usize, @@ -47,17 +48,23 @@ impl ProcessVMBuilder { let data_size = self.data_size; let ldso_code_size = self.ldso_code_size.unwrap_or(0); let ldso_data_size = self.ldso_data_size.unwrap_or(0); - let heap_size = self.heap_size.unwrap_or( - config::LIBOS_CONFIG.process.default_heap_size); - let stack_size = self.stack_size.unwrap_or( - config::LIBOS_CONFIG.process.default_stack_size); - let mmap_size = self.mmap_size.unwrap_or( - config::LIBOS_CONFIG.process.default_mmap_size); + let heap_size = self + .heap_size + .unwrap_or(config::LIBOS_CONFIG.process.default_heap_size); + let stack_size = self + .stack_size + .unwrap_or(config::LIBOS_CONFIG.process.default_stack_size); + let mmap_size = self + .mmap_size + .unwrap_or(config::LIBOS_CONFIG.process.default_mmap_size); let range_sizes = vec![ - code_size, data_size, - ldso_code_size, ldso_data_size, - heap_size, stack_size, - mmap_size + code_size, + data_size, + ldso_code_size, + ldso_data_size, + heap_size, + stack_size, + mmap_size, ]; let process_range = { @@ -109,7 +116,6 @@ impl ProcessVMBuilder { } } - /// The per-process virtual memory #[derive(Debug)] pub struct ProcessVM { @@ -212,7 +218,7 @@ impl ProcessVM { perms: VMPerms, flags: MMapFlags, fd: FileDesc, - offset: usize + offset: usize, ) -> Result { let addr_option = { if flags.contains(MMapFlags::MAP_FIXED) { @@ -235,7 +241,10 @@ impl ProcessVM { let current_ref = get_current(); let current_process = current_ref.lock().unwrap(); let file_ref = current_process.get_files().lock().unwrap().get(fd)?; - VMInitializer::LoadFromFile { file: file_ref, offset: offset } + VMInitializer::LoadFromFile { + file: file_ref, + offset: offset, + } } }; let mmap_options = VMMapOptionsBuilder::default() @@ -256,7 +265,6 @@ impl ProcessVM { } } - bitflags! { pub struct MMapFlags : u32 { const MAP_FILE = 0x0; @@ -283,12 +291,10 @@ bitflags! { impl MMapFlags { pub fn from_u32(bits: u32) -> Result { // TODO: detect non-supporting flags - MMapFlags::from_bits(bits) - .ok_or_else(|| (Errno::EINVAL, "Unknown mmap flags").into()) + MMapFlags::from_bits(bits).ok_or_else(|| (Errno::EINVAL, "Unknown mmap flags").into()) } } - bitflags! { pub struct VMPerms : u32 { const READ = 0x1; @@ -311,12 +317,10 @@ impl VMPerms { } pub fn from_u32(bits: u32) -> Result { - VMPerms::from_bits(bits) - .ok_or_else(|| (Errno::EINVAL, "Unknown permission bits").into()) + VMPerms::from_bits(bits).ok_or_else(|| (Errno::EINVAL, "Unknown permission bits").into()) } } - unsafe fn fill_zeros(addr: usize, size: usize) { let ptr = addr as *mut u8; let buf = slice::from_raw_parts_mut(ptr, size); @@ -324,4 +328,3 @@ unsafe fn fill_zeros(addr: usize, size: usize) { *b = 0; } } - diff --git a/src/libos/src/vm/user_space_vm.rs b/src/libos/src/vm/user_space_vm.rs index cfdaa782..cf6643fe 100644 --- a/src/libos/src/vm/user_space_vm.rs +++ b/src/libos/src/vm/user_space_vm.rs @@ -1,5 +1,5 @@ +use super::vm_manager::{VMManager, VMMapOptions, VMMapOptionsBuilder, VMRange}; use super::*; -use super::vm_manager::{VMRange, VMManager, VMMapOptionsBuilder, VMMapOptions}; /// The virtual memory manager for the entire user space #[derive(Debug)] @@ -10,28 +10,25 @@ pub struct UserSpaceVMManager { impl UserSpaceVMManager { pub unsafe fn from(addr: usize, size: usize) -> Result { let vm_manager = Arc::new(SgxMutex::new(VMManager::from(addr, size)?)); - Ok(UserSpaceVMManager { - vm_manager, - }) + Ok(UserSpaceVMManager { vm_manager }) } pub fn alloc(&self, size: usize) -> Result { let user_vm_range = unsafe { - let mmap_options = VMMapOptionsBuilder::default() - .size(size) - .build()?; + let mmap_options = VMMapOptionsBuilder::default().size(size).build()?; let mut vm_manager = self.vm_manager.lock().unwrap(); let user_vm_addr = vm_manager.mmap(&mmap_options)?; VMRange::from_unchecked(user_vm_addr, user_vm_addr + size) }; - Ok(UserSpaceVMRange::new(user_vm_range, self.vm_manager.clone())) + Ok(UserSpaceVMRange::new( + user_vm_range, + self.vm_manager.clone(), + )) } pub fn alloc_dummy(&self) -> UserSpaceVMRange { - let empty_user_vm_range = unsafe { - VMRange::from_unchecked(0, 0) - }; + let empty_user_vm_range = unsafe { VMRange::from_unchecked(0, 0) }; UserSpaceVMRange::new(empty_user_vm_range, self.vm_manager.clone()) } } @@ -58,7 +55,6 @@ extern "C" { pub fn vm_get_preallocated_user_space_memory(addr: &mut usize, size: &mut usize); } - #[derive(Debug)] pub struct UserSpaceVMRange { vm_range: VMRange, @@ -82,8 +78,12 @@ impl Drop for UserSpaceVMRange { fn drop(&mut self) { let addr = self.vm_range.start(); let size = self.vm_range.size(); - if size == 0 { return; } + if size == 0 { + return; + } let mut vm_manager = self.vm_manager.lock().unwrap(); - vm_manager.munmap(addr, size).expect("munmap should always succeed"); + vm_manager + .munmap(addr, size) + .expect("munmap should always succeed"); } } diff --git a/src/libos/src/vm/vm_manager.rs b/src/libos/src/vm/vm_manager.rs index 7d7c7fe4..369cc35c 100644 --- a/src/libos/src/vm/vm_manager.rs +++ b/src/libos/src/vm/vm_manager.rs @@ -1,5 +1,5 @@ use super::*; -use std::{slice}; +use std::slice; #[derive(Clone, Debug)] pub enum VMInitializer { @@ -19,12 +19,12 @@ impl VMInitializer { match self { VMInitializer::DoNothing() => { // Do nothing - }, + } VMInitializer::FillZeros() => { for b in buf { *b = 0; } - }, + } VMInitializer::LoadFromFile { file, offset } => { // TODO: make sure that read_at does not move file cursor let len = file.read_at(*offset, buf)?; @@ -37,12 +37,11 @@ impl VMInitializer { } } - #[derive(Clone, Copy, Debug, PartialEq)] pub enum VMMapAddr { - Any, // Free to choose any address - Hint(usize), // Prefer the given address - Fixed(usize), // Must be the given address + Any, // Free to choose any address + Hint(usize), // Prefer the given address + Fixed(usize), // Must be the given address } impl Default for VMMapAddr { @@ -51,21 +50,22 @@ impl Default for VMMapAddr { } } - #[derive(Builder, Debug, Default)] #[builder(build_fn(skip), no_std)] pub struct VMMapOptions { size: usize, align: usize, addr: VMMapAddr, - initializer: VMInitializer + initializer: VMInitializer, } // VMMapOptionsBuilder is generated automatically, except the build function impl VMMapOptionsBuilder { pub fn build(&self) -> Result { let size = { - let size = self.size.ok_or_else(|| (Errno::EINVAL, "Invalid size for mmap"))?; + let size = self + .size + .ok_or_else(|| (Errno::EINVAL, "Invalid size for mmap"))?; if size == 0 { return errno!(EINVAL, "Invalid size for mmap"); } @@ -82,9 +82,7 @@ impl VMMapOptionsBuilder { let addr = self.addr.unwrap_or_default(); match addr { // TODO: check addr + size overflow - VMMapAddr::Any => { - VMMapAddr::Any - } + VMMapAddr::Any => VMMapAddr::Any, VMMapAddr::Hint(addr) => { let addr = align_down(addr, PAGE_SIZE); VMMapAddr::Hint(addr) @@ -98,8 +96,8 @@ impl VMMapOptionsBuilder { } }; let initializer = match self.initializer.as_ref() { - Some(initializer) => { initializer.clone() } - None => { VMInitializer::default() } + Some(initializer) => initializer.clone(), + None => VMInitializer::default(), }; Ok(VMMapOptions { size, @@ -124,7 +122,6 @@ impl VMMapOptions { } } - #[derive(Debug, Default)] pub struct VMManager { range: VMRange, @@ -141,20 +138,14 @@ impl VMManager { let end_sentry = VMRange::from(end, end)?; vec![start_sentry, end_sentry] }; - Ok(VMManager { - range, - sub_ranges, - }) + Ok(VMManager { range, sub_ranges }) } pub fn range(&self) -> &VMRange { &self.range } - pub fn mmap( - &mut self, - options: &VMMapOptions, - ) -> Result { + pub fn mmap(&mut self, options: &VMMapOptions) -> Result { // TODO: respect options.align when mmap let addr = *options.addr(); let size = *options.size(); @@ -194,22 +185,24 @@ impl VMManager { let effective_munmap_range_opt = munmap_range.intersect(&self.range); if effective_munmap_range_opt.is_none() { - return Ok(()) + return Ok(()); } let effective_munmap_range = effective_munmap_range_opt.unwrap(); if effective_munmap_range.empty() { - return Ok(()) + return Ok(()); } effective_munmap_range }; - let new_sub_ranges = self.sub_ranges + let new_sub_ranges = self + .sub_ranges .iter() .flat_map(|subrange| { if subrange.size() > 0 { subrange.subtract(&munmap_range) - } else { // Keep the two sentry subranges intact + } else { + // Keep the two sentry subranges intact vec![*subrange] } }) @@ -219,17 +212,20 @@ impl VMManager { } pub fn find_mmap_region(&self, addr: usize) -> Result<&VMRange, Error> { - self.sub_ranges.iter() + self.sub_ranges + .iter() .find(|subrange| subrange.contains(addr)) - .ok_or(Error::new(Errno::ESRCH, - "no mmap regions that contains the address")) + .ok_or(Error::new( + Errno::ESRCH, + "no mmap regions that contains the address", + )) } // Find the free subrange that satisfies the constraints of size and address fn find_free_subrange( &mut self, size: usize, - addr: VMMapAddr + addr: VMMapAddr, ) -> Result<(usize, VMRange), Error> { // TODO: reduce the complexity from O(N) to O(log(N)), where N is // the number of existing subranges. @@ -253,9 +249,7 @@ impl VMManager { continue; } - unsafe { - VMRange::from_unchecked(free_range_start, free_range_end) - } + unsafe { VMRange::from_unchecked(free_range_start, free_range_end) } }; match addr { @@ -289,7 +283,8 @@ impl VMManager { } if result_free_range == None - || result_free_range.as_ref().unwrap().size() > free_range.size() { + || result_free_range.as_ref().unwrap().size() > free_range.size() + { result_free_range = Some(free_range); result_idx = Some(idx); } @@ -308,7 +303,7 @@ impl VMManager { &self, size: usize, addr: VMMapAddr, - free_subrange: &VMRange + free_subrange: &VMRange, ) -> VMRange { debug_assert!(free_subrange.size() >= size); @@ -384,19 +379,22 @@ impl VMRange { let other_end = other.end(); match (self_start < other_start, other_end < self_end) { - (false, false) => { - Vec::new() - } + (false, false) => Vec::new(), (false, true) => unsafe { vec![VMRange::from_unchecked(self_start.max(other_end), self_end)] - } + }, (true, false) => unsafe { - vec![VMRange::from_unchecked(self_start, self_end.min(other_start))] - } + vec![VMRange::from_unchecked( + self_start, + self_end.min(other_start), + )] + }, (true, true) => unsafe { - vec![VMRange::from_unchecked(self_start, other_start), - VMRange::from_unchecked(other_end, self_end)] - } + vec![ + VMRange::from_unchecked(self_start, other_start), + VMRange::from_unchecked(other_end, self_end), + ] + }, } } @@ -407,7 +405,10 @@ impl VMRange { return None; } unsafe { - Some(VMRange::from_unchecked(intersection_start, intersection_end)) + Some(VMRange::from_unchecked( + intersection_start, + intersection_end, + )) } } }