try to fix bugs

sel4_ipc/src/endpoint.rs

@@ -345,11 +345,13 @@ impl endpoint_func for endpoint {
                             .refill_ready()
                 );
                 set_thread_state(dest_thread, ThreadState::ThreadStateRunning);
-				if let Some(sc) = convert_to_option_mut_type_ref::<sched_context_t>(dest_thread.tcbSchedContext){
-					if sc.sc_sporadic() &&dest_thread.tcbSchedContext != unsafe { ksCurSC }{
-						sc.refill_unblock_check();
-					}
-				}
+                if let Some(sc) =
+                    convert_to_option_mut_type_ref::<sched_context_t>(dest_thread.tcbSchedContext)
+                {
+                    if sc.sc_sporadic() && dest_thread.tcbSchedContext != unsafe { ksCurSC } {
+                        sc.refill_unblock_check();
+                    }
+                }
                 possible_switch_to(dest_thread);
             }
         }

sel4_ipc/src/notification.rs

@@ -269,6 +269,7 @@ impl notification_func for notification {
                 {
                     self.maybeReturnSchedContext(recv_thread);
                     if recv_thread.tcbSchedContext != unsafe { ksCurSC }
+                        && recv_thread.tcbSchedContext != 0
                         && convert_to_mut_type_ref::<sched_context_t>(recv_thread.tcbSchedContext)
                             .sc_sporadic()
                     {

sel4_ipc/src/transfer.rs

@@ -356,9 +356,12 @@ impl Transfer for tcb_t {
         assert!(receiver.tcbState.get_replyObject() == 0);
         assert!(reply.replyTCB == 0);
 
-        let sc = convert_to_mut_type_ref::<sched_context_t>(receiver.tcbSchedContext);
-        if sc.sc_sporadic() && !sc.is_current() {
-            sc.refill_unblock_check();
+        if let Some(sc) =
+            convert_to_option_mut_type_ref::<sched_context_t>(receiver.tcbSchedContext)
+        {
+            if sc.sc_sporadic() && !sc.is_current() {
+                sc.refill_unblock_check();
+            }
         }
 
         let fault_type = receiver.tcbFault.get_tag();
@@ -374,6 +377,7 @@ impl Transfer for tcb_t {
             }
         }
         if receiver.tcbSchedContext != 0 && receiver.is_runnable() {
+            let sc = convert_to_mut_type_ref::<sched_context_t>(receiver.tcbSchedContext);
             if sc.refill_ready() && sc.refill_sufficient(0) {
                 possible_switch_to(receiver);
             } else {

sel4_task/src/reply.rs

@@ -27,7 +27,6 @@ impl reply {
         set_thread_state(tcb, ThreadState::ThreadStateInactive);
     }
     pub fn push(&mut self, tcb_caller: &mut tcb_t, tcb_callee: &mut tcb_t, canDonate: bool) {
-
         assert!(tcb_caller.get_ptr() != 0);
         assert!(self.get_ptr() != 0);
         assert!(self.replyTCB == 0);

sel4_task/src/sched_context.rs

@@ -94,7 +94,7 @@ impl sched_context {
     }
     #[inline]
     pub fn sc_sporadic(&self) -> bool {
-        self.get_ptr() != 0 && self.sc_active() && self.scSporadic
+        self.sc_active() && self.scSporadic
     }
     #[inline]
     pub fn postpone(&self) {

sel4_task/src/scheduler.rs

@@ -698,24 +698,22 @@ pub fn commitTime() {
 }
 #[cfg(feature = "KERNEL_MCS")]
 pub fn switch_sched_context() {
+    use sel4_common::utils::convert_to_option_mut_type_ref;
+
     let thread = get_currenct_thread();
     unsafe {
         if unlikely(ksCurSC != thread.tcbSchedContext) {
             ksReprogram = true;
-            if convert_to_mut_type_ref::<sched_context_t>(thread.tcbSchedContext)
-                .sc_constant_bandwidth()
+            if let Some(sc) =
+                convert_to_option_mut_type_ref::<sched_context_t>(thread.tcbSchedContext)
             {
-                convert_to_mut_type_ref::<sched_context_t>(thread.tcbSchedContext)
-                    .refill_unblock_check();
-            }
+                if sc.sc_constant_bandwidth() {
+                    sc.refill_unblock_check();
+                }
 
-            assert!(
-                convert_to_mut_type_ref::<sched_context_t>(thread.tcbSchedContext).refill_ready()
-            );
-            assert!(
-                convert_to_mut_type_ref::<sched_context_t>(thread.tcbSchedContext)
-                    .refill_sufficient(0)
-            );
+                assert!(sc.refill_ready());
+                assert!(sc.refill_sufficient(0));
+            }
         }
 
         if ksReprogram {

sel4_task/src/tcb.rs

@@ -17,7 +17,9 @@ use sel4_common::structures_gen::{
     cap, cap_reply_cap, cap_tag, lookup_fault, lookup_fault_Splayed, mdb_node, seL4_Fault,
     seL4_Fault_CapFault, seL4_Fault_tag, thread_state,
 };
-use sel4_common::utils::{convert_to_mut_type_ref, pageBitsForSize};
+use sel4_common::utils::{
+    convert_to_mut_type_ref, convert_to_option_mut_type_ref, pageBitsForSize,
+};
 #[cfg(feature = "ENABLE_SMP")]
 use sel4_common::BIT;
 use sel4_common::MASK;
@@ -546,14 +548,14 @@ impl tcb_t {
             {
                 // MCS
                 set_thread_state(self, ThreadState::ThreadStateRestart);
-                if convert_to_mut_type_ref::<sched_context_t>(self.tcbSchedContext).sc_sporadic()
-                    && self.tcbSchedContext != unsafe { ksCurSC }
+                if let Some(sc) =
+                    convert_to_option_mut_type_ref::<sched_context_t>(self.tcbSchedContext)
                 {
-                    convert_to_mut_type_ref::<sched_context_t>(self.tcbSchedContext)
-                        .refill_unblock_check();
+                    if sc.sc_sporadic() && self.tcbSchedContext != unsafe { ksCurSC } {
+                        sc.refill_unblock_check();
+                    }
+                    sc.schedContext_resume();
                 }
-                convert_to_mut_type_ref::<sched_context_t>(self.tcbSchedContext)
-                    .schedContext_resume();
                 if self.is_schedulable() {
                     possible_switch_to(self);
                 }