A secure yet efficient way to access from child (Rec) to parent (Rd) about islet HOT 4 CLOSED

// define accessor
impl<'a, E> EntryGuard<'a, E> {
    // new function for child-parent access
    // NOTE:  ==> add a comment here about the two rules for child-parent access
    pub fn parent_content<T: Content>(&self) -> &T {
       // E:  the type of child (e.g., Rec),   T: the type of parent (e.g., Rd)
       // <TODO>  do type checking--> it looks like, either (1) or (2). ==> this is for Rule-1.
       //     (1) if E::type == Rec && T::type == Rd,  error otherwise  
       //     (2) if E::type::get_parent_type() == T::type,  error otherwise
       unsafe { &*(self.addr as *const T) }
    }

   // do not make parent_content_mut() as it violates Rule-2.  ==> this is for Rule-2.
   // pub fn parent_content_mut<T: Content>(&mut self) -> &mut T {
}

// how to use it
let mut rec_granule = get_granule_if!(arg[0], GranuleState::Rec)?;
let mut rec = rec_granule.content_mut::<Rec>();
let rd = rec_granule.parent_content::<Rd>();
// accessing Rd (parent) still requires the lock of Rec (child) but not require the lock of Rd (parent).
// in this way, it's guaranteed Rd (parent) is alive as it's guaranteed Rd never gets destroyed because of rec-granule-lock.
...
rd.id();
rd.ipa_bits();