      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135

    use core::cell::{RefCell, RefMut, UnsafeCell};
    use core::ops::{Deref, DerefMut};
    use riscv::register::sstatus;
    use lazy_static::*;

    /*
    /// Wrap a static data structure inside it so that we are
    /// able to access it without any `unsafe`.
    ///
    /// We should only use it in uniprocessor.
    ///
    /// In order to get mutable reference of inner data, call
    /// `exclusive_access`.
    pub struct UPSafeCell<T> {
        /// inner data
        inner: RefCell<T>,
    }

    unsafe impl<T> Sync for UPSafeCell<T> {}

    impl<T> UPSafeCell<T> {
        /// User is responsible to guarantee that inner struct is only used in
        /// uniprocessor.
        pub unsafe fn new(value: T) -> Self {
            Self {
                inner: RefCell::new(value),
            }
        }
        /// Panic if the data has been borrowed.
        pub fn exclusive_access(&self) -> RefMut<'_, T> {
            self.inner.borrow_mut()
        }
    }
    */

    pub struct UPSafeCellRaw<T> {
        inner: UnsafeCell<T>,
    }

    unsafe impl<T> Sync for UPSafeCellRaw<T> {}

    impl<T> UPSafeCellRaw<T> {
        pub unsafe fn new(value: T) -> Self {
            Self {
                inner: UnsafeCell::new(value),
            }
        }
        pub fn get_mut(&self) -> &mut T {
            unsafe { &mut (*self.inner.get()) }
        }
    }

    pub struct IntrMaskingInfo {
        nested_level: usize,
        sie_before_masking: bool,
    }

    lazy_static! {
        static ref INTR_MASKING_INFO: UPSafeCellRaw<IntrMaskingInfo> = unsafe {
            kprintln!("[KERN] sync::up::lazy_static!INTR_MASKING_INFO begin");
            UPSafeCellRaw::new(IntrMaskingInfo::new())
        };
    }

    impl IntrMaskingInfo {
        pub fn new() -> Self {
            Self {
                nested_level: 0,
                sie_before_masking: false,
            }
        }

        pub fn enter(&mut self) {
            let sie = sstatus::read().sie();
            unsafe { sstatus::clear_sie(); }
            if self.nested_level == 0 {
                self.sie_before_masking = sie;
            }
            self.nested_level += 1;
        }

        pub fn exit(&mut self) {
            self.nested_level -= 1;
            if self.nested_level == 0 && self.sie_before_masking {
                unsafe { sstatus::set_sie(); }
            }
        }
    }

    pub struct UPIntrFreeCell<T> {
        /// inner data
        inner: RefCell<T>,
    }

    unsafe impl<T> Sync for UPIntrFreeCell<T> {}

    pub struct UPIntrRefMut<'a, T>(Option<RefMut<'a, T>>);

    impl<T> UPIntrFreeCell<T> {
        pub unsafe fn new(value: T) -> Self {
            Self {
                inner: RefCell::new(value),
            }
        }
        /// Panic if the data has been borrowed.
        pub fn exclusive_access(&self) -> UPIntrRefMut<'_, T> {
            INTR_MASKING_INFO.get_mut().enter();
            UPIntrRefMut(Some(self.inner.borrow_mut()))
        }

        pub fn exclusive_session<F, V>(&self, f: F) -> V where F: FnOnce(&mut T) -> V {
            let mut inner = self.exclusive_access();
            f(inner.deref_mut())
        }
    }

    impl<'a, T> Drop for UPIntrRefMut<'a, T> {
        fn drop(&mut self) {
            self.0 = None;
            INTR_MASKING_INFO.get_mut().exit();
        }
    }

    impl<'a, T> Deref for UPIntrRefMut<'a, T> {
        type Target = T;
        fn deref(&self) -> &Self::Target {
            self.0.as_ref().unwrap().deref()
        }
    }
    impl<'a, T> DerefMut for UPIntrRefMut<'a, T> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            self.0.as_mut().unwrap().deref_mut()
        }
    }