mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-18 08:52:45 +00:00
working through an initial Flash format routine as a pipecleaner
clean compile checkpoint, not much else.
This commit is contained in:
parent
8b59bcdf61
commit
fabc84aaf6
6 changed files with 168 additions and 71 deletions
|
|
@ -1,7 +1,5 @@
|
||||||
use rkyv::{Archive, Deserialize, Serialize};
|
use rkyv::{Archive, Deserialize, Serialize};
|
||||||
|
|
||||||
use crate::backend::PAGE_SIZE;
|
|
||||||
|
|
||||||
pub(crate) const SERVER_NAME_PDDB: &str = "_Plausibly Deniable Database_";
|
pub(crate) const SERVER_NAME_PDDB: &str = "_Plausibly Deniable Database_";
|
||||||
pub(crate) const PDDB_MAX_BASIS_NAME_LEN: usize = 64;
|
pub(crate) const PDDB_MAX_BASIS_NAME_LEN: usize = 64;
|
||||||
pub(crate) const PDDB_MAX_DICT_NAME_LEN: usize = 64;
|
pub(crate) const PDDB_MAX_DICT_NAME_LEN: usize = 64;
|
||||||
|
|
|
||||||
|
|
@ -1,5 +1,5 @@
|
||||||
use crate::api::*;
|
use crate::api::*;
|
||||||
use crate::api::{PDDB_MAX_DICT_NAME_LEN, PDDB_MAX_KEY_NAME_LEN};
|
use super::*;
|
||||||
|
|
||||||
use core::num::NonZeroU64;
|
use core::num::NonZeroU64;
|
||||||
use core::ops::{Deref, DerefMut};
|
use core::ops::{Deref, DerefMut};
|
||||||
|
|
@ -30,12 +30,19 @@ pub(crate) struct BasisRoot {
|
||||||
pub(crate) name: [u8; PDDB_MAX_BASIS_NAME_LEN],
|
pub(crate) name: [u8; PDDB_MAX_BASIS_NAME_LEN],
|
||||||
/// increments every time the BasisRoot is modified. This field must saturate, not roll over.
|
/// increments every time the BasisRoot is modified. This field must saturate, not roll over.
|
||||||
pub(crate) age: u32,
|
pub(crate) age: u32,
|
||||||
pub(crate) num_dictionaries: u32,
|
/*
|
||||||
/// a cache of up FREE_CACHE_SIZE indicating the location of free space in the dictionary
|
/// a cache of up FREE_CACHE_SIZE indicating the location of free space for use by basis
|
||||||
/// allocation. This saves from having to do frequent free space search/compaction operations
|
/// functions, such as adding growing the size of this structure, adding more dictionaries,
|
||||||
/// on memory during writes and updates.
|
/// adding keys to dictionaries, or extending existing keys. This saves from having to do
|
||||||
|
/// frequent free space search/compaction operations on memory during writes and updates.
|
||||||
pub(crate) free_cache: [Option<FreeSpace>; FREE_CACHE_SIZE],
|
pub(crate) free_cache: [Option<FreeSpace>; FREE_CACHE_SIZE],
|
||||||
// dict_slice: [DictPointer], // a synthetic record that is a slice of dictionaries
|
*/
|
||||||
|
/// "open end" of the pre-allocated space for the Basis. All Basis data must exist in an extent that is
|
||||||
|
/// less than this value. This can be grown and shrunk with allocation and compaction processes.
|
||||||
|
pub(crate) prealloc_open_end: PageAlignedU64,
|
||||||
|
pub(crate) num_dictionaries: u32,
|
||||||
|
// dict_slice: [DictPointer], // DictPointers + num_dictionaries above can be turned into a dict_slice
|
||||||
|
////// the following records are appended by the Serialization routine
|
||||||
// pad: [u8], // padding out to the next 4096-byte block less 16 bytes
|
// pad: [u8], // padding out to the next 4096-byte block less 16 bytes
|
||||||
// p_tag: [u8; 16], // auth tag output of the AES-GCM-SIV
|
// p_tag: [u8; 16], // auth tag output of the AES-GCM-SIV
|
||||||
}
|
}
|
||||||
|
|
@ -43,7 +50,7 @@ impl Deref for BasisRoot {
|
||||||
type Target = [u8];
|
type Target = [u8];
|
||||||
fn deref(&self) -> &[u8] {
|
fn deref(&self) -> &[u8] {
|
||||||
unsafe {
|
unsafe {
|
||||||
slice::from_raw_parts(self as *const BasisRoot as *const u8, mem::size_of::<BasisRoot>())
|
core::slice::from_raw_parts(self as *const BasisRoot as *const u8, core::mem::size_of::<BasisRoot>())
|
||||||
as &[u8]
|
as &[u8]
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -52,7 +59,7 @@ impl Deref for BasisRoot {
|
||||||
impl DerefMut for BasisRoot {
|
impl DerefMut for BasisRoot {
|
||||||
fn deref_mut(&mut self) -> &mut [u8] {
|
fn deref_mut(&mut self) -> &mut [u8] {
|
||||||
unsafe {
|
unsafe {
|
||||||
slice::from_raw_parts_mut(self as *mut BasisRoot as *mut u8, mem::size_of::<BasisRoot>())
|
core::slice::from_raw_parts_mut(self as *mut BasisRoot as *mut u8, core::mem::size_of::<BasisRoot>())
|
||||||
as &mut [u8]
|
as &mut [u8]
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -66,7 +73,7 @@ pub(crate) struct DictPointer {
|
||||||
addr: u64, // the virtual address of the dictionary
|
addr: u64, // the virtual address of the dictionary
|
||||||
}
|
}
|
||||||
|
|
||||||
/// FreeSpace address space is in the Basis virtual memory space
|
/// FreeSpace address space is in the virtual memory space of the containing Basis
|
||||||
#[derive(Copy, Clone)]
|
#[derive(Copy, Clone)]
|
||||||
pub(crate) struct FreeSpace {
|
pub(crate) struct FreeSpace {
|
||||||
start: u64,
|
start: u64,
|
||||||
|
|
|
||||||
|
|
@ -1,6 +1,7 @@
|
||||||
use core::num::NonZeroU32;
|
use core::num::NonZeroU32;
|
||||||
|
|
||||||
use super::PAGE_SIZE;
|
use super::PAGE_SIZE;
|
||||||
|
use crate::*;
|
||||||
|
|
||||||
#[repr(u8)]
|
#[repr(u8)]
|
||||||
pub(crate) enum SpaceState {
|
pub(crate) enum SpaceState {
|
||||||
|
|
|
||||||
|
|
@ -5,6 +5,7 @@ use rand_core::{CryptoRng, RngCore};
|
||||||
use cipher::{BlockCipher, BlockDecrypt};
|
use cipher::{BlockCipher, BlockDecrypt};
|
||||||
use root_keys::api::{AesRootkeyType, Block};
|
use root_keys::api::{AesRootkeyType, Block};
|
||||||
use core::ops::Deref;
|
use core::ops::Deref;
|
||||||
|
use core::convert::TryFrom;
|
||||||
|
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
use std::io::{Result, Error, ErrorKind};
|
use std::io::{Result, Error, ErrorKind};
|
||||||
|
|
@ -18,20 +19,19 @@ pub(crate) const INITIAL_BASIS_ALLOC: usize = 16;
|
||||||
pub const PAGE_SIZE: usize = spinor::SPINOR_ERASE_SIZE as usize;
|
pub const PAGE_SIZE: usize = spinor::SPINOR_ERASE_SIZE as usize;
|
||||||
|
|
||||||
#[repr(C, packed)] // this can map directly into Flash
|
#[repr(C, packed)] // this can map directly into Flash
|
||||||
#[derive(Default)]
|
|
||||||
pub(crate) struct StaticCryptoData {
|
pub(crate) struct StaticCryptoData {
|
||||||
/// aes-256 key of the system basis, encrypted with the User0 root key
|
/// aes-256 key of the system basis, encrypted with the User0 root key
|
||||||
system_key: [u8; 32],
|
pub(crate) system_key: [u8; 32],
|
||||||
/// a pool of fixed data used to pick salts, based on a hash of the basis name
|
/// a pool of fixed data used to pick salts, based on a hash of the basis name
|
||||||
salt_base: [u8; 2048],
|
pub(crate) salt_base: [u8; 2048],
|
||||||
/// also random data, but no specific purpose
|
/// also random data, but no specific purpose
|
||||||
reserved: [u8; 2016],
|
pub(crate) reserved: [u8; 2016],
|
||||||
}
|
}
|
||||||
impl Deref for StaticCryptoData {
|
impl Deref for StaticCryptoData {
|
||||||
type Target = [u8];
|
type Target = [u8];
|
||||||
fn deref(&self) -> &[u8] {
|
fn deref(&self) -> &[u8] {
|
||||||
unsafe {
|
unsafe {
|
||||||
slice::from_raw_parts(self as *const StaticCryptoData as *const u8, mem::size_of::<StaticCryptoData>())
|
core::slice::from_raw_parts(self as *const StaticCryptoData as *const u8, core::mem::size_of::<StaticCryptoData>())
|
||||||
as &[u8]
|
as &[u8]
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -69,18 +69,18 @@ impl PddbOs {
|
||||||
|
|
||||||
// the mbbb is located one page off from the Page Table
|
// the mbbb is located one page off from the Page Table
|
||||||
let key_phys_base = PageAlignedU32::from(core::mem::size_of::<PageTableInFlash>());
|
let key_phys_base = PageAlignedU32::from(core::mem::size_of::<PageTableInFlash>());
|
||||||
let mbbb_phys_base = PageAlignedU32::from(key_phys_base + PAGE_SIZE);
|
let mbbb_phys_base = key_phys_base + PageAlignedU32::from(PAGE_SIZE);
|
||||||
let fscb_phys_base = PageAlignedU32::from(u32::From(mbbb_phys_base) + MBBB_PAGES as u32 * PAGE_SIZE);
|
let fscb_phys_base = PageAlignedU32::from(mbbb_phys_base.as_u32() + MBBB_PAGES as u32 * PAGE_SIZE as u32);
|
||||||
PddbOs {
|
PddbOs {
|
||||||
spinor: spinor::Spinor::new(&xns).unwrap(),
|
spinor: spinor::Spinor::new(&xns).unwrap(),
|
||||||
rootkeys: root_keys::new(&xns, Some(AesRootkeyType::User0)).expect("FATAL: couldn't access RootKeys!"),
|
rootkeys: root_keys::RootKeys::new(&xns, Some(AesRootkeyType::User0)).expect("FATAL: couldn't access RootKeys!"),
|
||||||
pddb_mr: pddb,
|
pddb_mr: pddb,
|
||||||
trng: trng::Trng::new(&xns).unwrap(),
|
trng: trng::Trng::new(&xns).unwrap(),
|
||||||
pt_phys_base: PageAlignedU32::from(0),
|
pt_phys_base: PageAlignedU32::from(0 as u32),
|
||||||
key_phys_base,
|
key_phys_base,
|
||||||
mbbb_phys_base,
|
mbbb_phys_base,
|
||||||
fscb_phys_base,
|
fscb_phys_base,
|
||||||
data_phys_base: PageAlignedU32::from(u32::From(fscb_phys_base) + FSCB_PAGES * PAGE_SIZE),
|
data_phys_base: PageAlignedU32::from(fscb_phys_base.as_u32() + FSCB_PAGES as u32 * PAGE_SIZE as u32),
|
||||||
system_basis_key: None,
|
system_basis_key: None,
|
||||||
v2p_map: HashMap::<BasisRoot, HashMap<VirtAddr, ReversePte>>::new(),
|
v2p_map: HashMap::<BasisRoot, HashMap<VirtAddr, ReversePte>>::new(),
|
||||||
}
|
}
|
||||||
|
|
@ -116,7 +116,7 @@ impl PddbOs {
|
||||||
|
|
||||||
// step 2. create the system basis root structure
|
// step 2. create the system basis root structure
|
||||||
let mut name: [u8; PDDB_MAX_BASIS_NAME_LEN] = [0; PDDB_MAX_BASIS_NAME_LEN];
|
let mut name: [u8; PDDB_MAX_BASIS_NAME_LEN] = [0; PDDB_MAX_BASIS_NAME_LEN];
|
||||||
for (&src, dst) in (PDDB_DEFAULT_SYSTEM_BASIS.as_bytes().iter().zip(name.iter_mut())) {
|
for (&src, dst) in PDDB_DEFAULT_SYSTEM_BASIS.as_bytes().iter().zip(name.iter_mut()) {
|
||||||
*dst = src;
|
*dst = src;
|
||||||
}
|
}
|
||||||
let mut basis_root = BasisRoot {
|
let mut basis_root = BasisRoot {
|
||||||
|
|
@ -127,47 +127,53 @@ impl PddbOs {
|
||||||
name,
|
name,
|
||||||
age: 0,
|
age: 0,
|
||||||
num_dictionaries: 0,
|
num_dictionaries: 0,
|
||||||
free_cache: [None; FREE_CACHE_SIZE],
|
prealloc_open_end: PageAlignedU64::from(INITIAL_BASIS_ALLOC * PAGE_SIZE),
|
||||||
};
|
};
|
||||||
// allocate a few initial free pages to the basis, so it can operate a bit without having
|
|
||||||
// to immediately call a time-consuming free space acquisition.
|
|
||||||
basis_root.free_cache[0] = Some(FreeSpace {
|
|
||||||
start: PAGE_SIZE,
|
|
||||||
len: (INITIAL_BASIS_ALLOC - 1) * PAGE_SIZE,
|
|
||||||
});
|
|
||||||
// extract a slice-u8 that maps onto the basis_root record, allowing us to patch this into a FLASH page
|
// extract a slice-u8 that maps onto the basis_root record, allowing us to patch this into a FLASH page
|
||||||
let br_slice: &[u8] = basis_root.deref();
|
let br_slice: &[u8] = basis_root.deref();
|
||||||
|
|
||||||
// step 3. create our key material
|
// step 3. create our key material
|
||||||
if !self.rootkeys.ensure_aes_password() {
|
// consider: making ensure_aes_password() a pub-scoped function? let's see how this works in practice.
|
||||||
return Err(Error::new(ErrorKind::PermissionDenied, "unlock password was incorrect"));
|
//if !self.rootkeys.ensure_aes_password() {
|
||||||
}
|
// return Err(Error::new(ErrorKind::PermissionDenied, "unlock password was incorrect"));
|
||||||
|
//}
|
||||||
assert!(core::mem::size_of::<StaticCryptoData>() == PAGE_SIZE, "StaticCryptoData structure is not correctly sized");
|
assert!(core::mem::size_of::<StaticCryptoData>() == PAGE_SIZE, "StaticCryptoData structure is not correctly sized");
|
||||||
let mut crypto_keys = StaticCryptoData::default();
|
let mut system_basis_key: [u8; 32] = [0; 32];
|
||||||
self.trng.fill_bytes(&crypto_keys.system_key); // this is our "encrypted" key
|
self.trng.fill_bytes(&mut system_basis_key);
|
||||||
self.trng.fill_bytes(&crypto_keys.salt_base);
|
let mut basis_key_enc: [u8; 32] = system_basis_key.clone();
|
||||||
self.trng.fill_bytes(&crypto_keys.reserved);
|
self.system_basis_key = Some(system_basis_key); // causes system_basis_key to be owned by self
|
||||||
|
log::info!("sanity check: plaintext system basis key: {:x?}", basis_key_enc);
|
||||||
|
self.rootkeys.decrypt_block(Block::from_mut_slice(&mut basis_key_enc));
|
||||||
|
log::info!("sanity check: encrypted system basis key: {:x?}", basis_key_enc);
|
||||||
|
let mut crypto_keys = StaticCryptoData {
|
||||||
|
system_key: [0; 32],
|
||||||
|
salt_base: [0; 2048],
|
||||||
|
reserved: [0; 2016],
|
||||||
|
};
|
||||||
|
// copy the encrypted key into the data structure for commit to Flash
|
||||||
|
for (&src, dst) in basis_key_enc.iter().zip(crypto_keys.system_key.iter_mut()) {
|
||||||
|
*dst = src;
|
||||||
|
}
|
||||||
|
self.trng.fill_bytes(&mut crypto_keys.salt_base);
|
||||||
|
self.trng.fill_bytes(&mut crypto_keys.reserved);
|
||||||
self.spinor.patch(
|
self.spinor.patch(
|
||||||
self.pddb_mr.as_slice(),
|
self.pddb_mr.as_slice(),
|
||||||
xous::PDDB_LOC,
|
xous::PDDB_LOC,
|
||||||
crypto_keys.deref(),
|
crypto_keys.deref(),
|
||||||
u32::From(self.key_phys_base)
|
self.key_phys_base.as_u32()
|
||||||
).expect("couldn't burn keys");
|
).expect("couldn't burn keys");
|
||||||
|
|
||||||
{ // create a block so we know that the system_basis_key goes out of scope when this is done
|
|
||||||
let mut system_basis_key: [u8; 32] = [0; 32];
|
|
||||||
// copy the encrypted key into the buffer
|
|
||||||
for (&src, dst) in crypto_keys.system_key.iter().zip(system_basis_key.iter_mut()) {
|
|
||||||
*dst = src;
|
|
||||||
}
|
|
||||||
log::info!("sanity check: encrypted root key: {:x?}", system_basis_key);
|
|
||||||
self.rootkeys.decrypt_block(Block::from_mut_slice(&mut system_basis_key));
|
|
||||||
log::info!("sanity check: decrypted root key: {:x?}", system_basis_key);
|
|
||||||
self.system_basis_key = Some(system_basis_key);
|
|
||||||
}
|
|
||||||
// now we have a copy of the AES key necessary to encrypt the default System basis that we created in step 2.
|
// now we have a copy of the AES key necessary to encrypt the default System basis that we created in step 2.
|
||||||
|
|
||||||
// step 4. generate & write initial page table entries
|
// step 4. Create a hashmap for our reverse PTE, and add it to the Pddb's cache
|
||||||
|
// we don't have a fscb yet, and everything is free space, so we will manually place these initial entries.
|
||||||
|
let mut basis_v2p_map = HashMap::<VirtAddr, ReversePte>::new();
|
||||||
|
for phys_page in (
|
||||||
|
self.data_phys_base.as_u32()..self.data_phys_base.as_u32() + basis_root.prealloc_open_end.as_u32()
|
||||||
|
).step_by(PAGE_SIZE) {
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
// step 5. generate & write initial page table entries
|
||||||
// page table organization:
|
// page table organization:
|
||||||
//
|
//
|
||||||
// offset from |
|
// offset from |
|
||||||
|
|
|
||||||
|
|
@ -9,8 +9,8 @@ use bitflags::bitflags;
|
||||||
bitflags! {
|
bitflags! {
|
||||||
/// flags used by the page table
|
/// flags used by the page table
|
||||||
pub struct PtFlags: u8 {
|
pub struct PtFlags: u8 {
|
||||||
/// Pages that don't decrypt properly are marked as LOCKED in the cache.
|
/// Pages that don't decrypt properly are marked as INVALID in the cache.
|
||||||
const LOCKED = 0b0000_0000;
|
const INVALID = 0b0000_0000;
|
||||||
/// set for records that are synced to the copy in Flash. Every valid record
|
/// set for records that are synced to the copy in Flash. Every valid record
|
||||||
/// from Flash should have this set; it should only be cleared for blocks in Cache.
|
/// from Flash should have this set; it should only be cleared for blocks in Cache.
|
||||||
const CLEAN = 0b0000_0001;
|
const CLEAN = 0b0000_0001;
|
||||||
|
|
@ -18,7 +18,7 @@ bitflags! {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
impl Default for PtFlags {
|
impl Default for PtFlags {
|
||||||
fn default() -> PtFlags {PtFlags::UNINITIALIZED}
|
fn default() -> PtFlags {PtFlags::INVALID}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A Page Table Entry. Contains the address map of the corresponding entry,
|
/// A Page Table Entry. Contains the address map of the corresponding entry,
|
||||||
|
|
@ -38,7 +38,7 @@ pub(crate) struct Pte {
|
||||||
/// the virtual address is 48 bits long
|
/// the virtual address is 48 bits long
|
||||||
pddb_addr: [u8; 6],
|
pddb_addr: [u8; 6],
|
||||||
/// this maps to a u8
|
/// this maps to a u8
|
||||||
flags: PtFags,
|
flags: PtFlags,
|
||||||
reserved: u8,
|
reserved: u8,
|
||||||
/// 32-bit strength of a nonce, but can be varied
|
/// 32-bit strength of a nonce, but can be varied
|
||||||
nonce: [u8; 4],
|
nonce: [u8; 4],
|
||||||
|
|
@ -48,11 +48,10 @@ pub(crate) struct Pte {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[repr(C, packed)]
|
#[repr(C, packed)]
|
||||||
#[derive(Default)]
|
|
||||||
pub(crate) struct ReversePte {
|
pub(crate) struct ReversePte {
|
||||||
phys_addr: PhysAddr,
|
phys_addr: PhysAddr,
|
||||||
/// this maps to a u8
|
/// this maps to a u8
|
||||||
flags: PtFags,
|
flags: PtFlags,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub const PDDB_SIZE_PAGES: usize = xous::PDDB_LEN as usize / PAGE_SIZE;
|
pub const PDDB_SIZE_PAGES: usize = xous::PDDB_LEN as usize / PAGE_SIZE;
|
||||||
|
|
@ -63,7 +62,6 @@ pub const PDDB_SIZE_PAGES: usize = xous::PDDB_LEN as usize / PAGE_SIZE;
|
||||||
/// always corresponds to the base of data in FLASH, which means the excess
|
/// always corresponds to the base of data in FLASH, which means the excess
|
||||||
/// pages are going to be toward the high end of the page table range.
|
/// pages are going to be toward the high end of the page table range.
|
||||||
#[repr(C, packed)]
|
#[repr(C, packed)]
|
||||||
#[derive(Default)]
|
|
||||||
pub(crate) struct PageTableInFlash {
|
pub(crate) struct PageTableInFlash {
|
||||||
table: [Pte; PDDB_SIZE_PAGES],
|
table: [Pte; PDDB_SIZE_PAGES],
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,43 +1,130 @@
|
||||||
use core::num::{NonZeroU32, NonZeroU64};
|
use core::num::{NonZeroU32, NonZeroU64};
|
||||||
|
use core::convert::TryFrom;
|
||||||
|
use core::ops::Add;
|
||||||
|
use super::PAGE_SIZE;
|
||||||
/// PAGE_SIZE is required to be a power of two. 0x1000 -> 0x1000 - 1 = 0xFFF, which forms the bitmasks below.
|
/// PAGE_SIZE is required to be a power of two. 0x1000 -> 0x1000 - 1 = 0xFFF, which forms the bitmasks below.
|
||||||
struct PageAlignedU64(u64);
|
#[derive(Copy, Clone)]
|
||||||
impl From<u64> for PageAlignedU64 {
|
pub(crate) struct PageAlignedU64(u64);
|
||||||
fn from(arg: u64) -> Self {
|
impl PageAlignedU64 {
|
||||||
if arg & (PAGE_SIZE - 1) == 0 {
|
pub(crate) fn as_u32(&self) -> u32 {
|
||||||
PageAlignedU64(arg & !(PAGE_SIZE - 1))
|
if self.0 <= u32::MAX as u64 {
|
||||||
|
self.0 as u32
|
||||||
} else {
|
} else {
|
||||||
PageAlignedU64((arg & !(PAGE_SIZE - 1)) + PAGE_SIZE)
|
panic!("This PageAlignedU64 would not fit into a PageAlignedU32");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
pub(crate) fn as_u64(&self) -> u64 {self.0}
|
||||||
|
}
|
||||||
|
impl From<u64> for PageAlignedU64 {
|
||||||
|
fn from(arg: u64) -> Self {
|
||||||
|
if arg & (PAGE_SIZE as u64 - 1) == 0 {
|
||||||
|
PageAlignedU64(arg & !(PAGE_SIZE as u64 - 1))
|
||||||
|
} else {
|
||||||
|
PageAlignedU64((arg & !(PAGE_SIZE as u64 - 1)) + PAGE_SIZE as u64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl From<PageAlignedU32> for PageAlignedU64 {
|
||||||
|
fn from(arg: PageAlignedU32) -> Self { PageAlignedU64(arg.0 as u64) } // already aligned, and it fits.
|
||||||
}
|
}
|
||||||
impl From<u32> for PageAlignedU64 {
|
impl From<u32> for PageAlignedU64 {
|
||||||
fn from(arg: u32) -> Self {
|
fn from(arg: u32) -> Self {
|
||||||
if arg & (PAGE_SIZE - 1) == 0 {
|
if arg & (PAGE_SIZE as u32 - 1) == 0 {
|
||||||
PageAlignedU64(arg as u64 & !(PAGE_SIZE - 1))
|
PageAlignedU64(arg as u64 & !(PAGE_SIZE as u64 - 1))
|
||||||
} else {
|
} else {
|
||||||
PageAlignedU64((arg as u64 & !(PAGE_SIZE - 1)) + PAGE_SIZE)
|
PageAlignedU64((arg as u64 & !(PAGE_SIZE as u64 - 1)) + PAGE_SIZE as u64)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
struct PageAlignedU32(u32);
|
impl From<usize> for PageAlignedU64 {
|
||||||
|
fn from(arg: usize) -> Self {
|
||||||
|
if arg & (PAGE_SIZE - 1) == 0 {
|
||||||
|
PageAlignedU64(arg as u64 & !(PAGE_SIZE as u64 - 1))
|
||||||
|
} else {
|
||||||
|
PageAlignedU64((arg as u64 & !(PAGE_SIZE as u64 - 1)) + PAGE_SIZE as u64)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
impl Add for PageAlignedU64 {
|
||||||
|
type Output = PageAlignedU64;
|
||||||
|
fn add(self, other: PageAlignedU64) -> PageAlignedU64 {
|
||||||
|
PageAlignedU64(self.0 + other.0)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Copy, Clone)]
|
||||||
|
pub(crate) struct PageAlignedU32(u32);
|
||||||
|
impl PageAlignedU32 {
|
||||||
|
pub(crate) fn as_u32(&self) -> u32 {self.0}
|
||||||
|
pub(crate) fn as_u64(&self) -> u64 {self.0 as u64}
|
||||||
|
}
|
||||||
impl From<u32> for PageAlignedU32 {
|
impl From<u32> for PageAlignedU32 {
|
||||||
fn from(arg: u32) -> Self {
|
fn from(arg: u32) -> Self {
|
||||||
if arg & (PAGE_SIZE - 1) == 0 {
|
if arg & (PAGE_SIZE as u32 - 1) == 0 {
|
||||||
PageAlignedU32(arg & !(PAGE_SIZE - 1))
|
PageAlignedU32(arg & !(PAGE_SIZE as u32 - 1))
|
||||||
} else {
|
} else {
|
||||||
PageAlignedU32((arg & !(PAGE_SIZE - 1)) + PAGE_SIZE)
|
PageAlignedU32((arg & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
impl From<usize> for PageAlignedU32 {
|
||||||
|
fn from(arg: usize) -> Self {
|
||||||
|
if arg & (PAGE_SIZE as usize - 1) == 0 {
|
||||||
|
PageAlignedU32(arg as u32 & !(PAGE_SIZE as u32 - 1))
|
||||||
|
} else {
|
||||||
|
PageAlignedU32((arg as u32 & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
/* // let's get real, this is kind of a waste of cycles to check this...
|
||||||
|
impl TryFrom<usize> for PageAlignedU32 {
|
||||||
|
type Error = &'static str;
|
||||||
|
fn try_from(arg: usize) -> Result<Self, Self::Error> {
|
||||||
|
if arg > u32::MAX as usize {
|
||||||
|
Err("PageAlignedU32 only accepts usize less than u32::MAX")
|
||||||
|
} else {
|
||||||
|
Ok(
|
||||||
|
if arg & (PAGE_SIZE - 1) == 0 {
|
||||||
|
PageAlignedU32(arg as u32 & !(PAGE_SIZE as u32 - 1))
|
||||||
|
} else {
|
||||||
|
PageAlignedU32((arg as u32 & !(PAGE_SIZE as u32 - 1)) + PAGE_SIZE as u32)
|
||||||
|
}
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
*/
|
||||||
impl From<PageAlignedU32> for u32 {
|
impl From<PageAlignedU32> for u32 {
|
||||||
fn from(arg: PageAlignedU32) -> Self {
|
fn from(arg: PageAlignedU32) -> Self {
|
||||||
arg.0
|
arg.0
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
impl Add for PageAlignedU32 {
|
||||||
|
type Output = PageAlignedU32;
|
||||||
|
fn add(self, other: PageAlignedU32) -> PageAlignedU32 {
|
||||||
|
PageAlignedU32(self.0 + other.0 as u32)
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
fn add(self, other: usize) -> PageAlignedU32 {
|
||||||
|
let page_aligned_other = if other & (PAGE_SIZE - 1) == 0 {
|
||||||
|
other & !(PAGE_SIZE - 1)
|
||||||
|
} else {
|
||||||
|
(other & !(PAGE_SIZE - 1)) + PAGE_SIZE
|
||||||
|
};
|
||||||
|
// saturate adds
|
||||||
|
if self.0 as usize + page_aligned_other > u32::MAX as usize {
|
||||||
|
PageAlignedU32(u32::MAX)
|
||||||
|
} else {
|
||||||
|
PageAlignedU32(self.0 + page_aligned_other as u32)
|
||||||
|
}
|
||||||
|
}*/
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
#[derive(Hash, Copy, Clone, PartialEq, Eq)]
|
||||||
pub struct PhysAddr(NonZeroU32);
|
pub struct PhysAddr(NonZeroU32);
|
||||||
|
|
||||||
|
#[derive(Hash, Copy, Clone, PartialEq, Eq)]
|
||||||
pub struct VirtAddr(NonZeroU64);
|
pub struct VirtAddr(NonZeroU64);
|
||||||
|
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue