Merge pull request #261 from ZR233/fix/smp

[fix] Update memory ordering for atomic

Author: equation314

modules/axruntime/src/lib.rs

@@ -186,7 +186,7 @@ pub extern "C" fn rust_main(cpu_id: usize, dtb: usize) -> ! {
     ctor_bare::call_ctors();
 
     info!("Primary CPU {} init OK.", cpu_id);
-    INITED_CPUS.fetch_add(1, Ordering::Relaxed);
+    INITED_CPUS.fetch_add(1, Ordering::Release);
 
     while !is_init_ok() {
         core::hint::spin_loop();

modules/axruntime/src/mp.rs

@@ -33,7 +33,7 @@ pub fn start_secondary_cpus(primary_cpu_id: usize) {
 /// It is called from the bootstrapping code in [axhal].
 #[unsafe(no_mangle)]
 pub extern "C" fn rust_main_secondary(cpu_id: usize) -> ! {
-    ENTERED_CPUS.fetch_add(1, Ordering::Relaxed);
+    ENTERED_CPUS.fetch_add(1, Ordering::Release);
     info!("Secondary CPU {:x} started.", cpu_id);
 
     #[cfg(feature = "paging")]
@@ -45,7 +45,7 @@ pub extern "C" fn rust_main_secondary(cpu_id: usize) -> ! {
     axtask::init_scheduler_secondary();
 
     info!("Secondary CPU {:x} init OK.", cpu_id);
-    super::INITED_CPUS.fetch_add(1, Ordering::Relaxed);
+    super::INITED_CPUS.fetch_add(1, Ordering::Release);
 
     while !super::is_init_ok() {
         core::hint::spin_loop();

modules/axtask/src/task.rs

@@ -361,13 +361,13 @@ impl TaskInner {
     #[inline]
     #[cfg(feature = "preempt")]
     pub(crate) fn disable_preempt(&self) {
-        self.preempt_disable_count.fetch_add(1, Ordering::Relaxed);
+        self.preempt_disable_count.fetch_add(1, Ordering::Release);
     }
 
     #[inline]
     #[cfg(feature = "preempt")]
     pub(crate) fn enable_preempt(&self, resched: bool) {
-        if self.preempt_disable_count.fetch_sub(1, Ordering::Relaxed) == 1 && resched {
+        if self.preempt_disable_count.fetch_sub(1, Ordering::Release) == 1 && resched {
             // If current task is pending to be preempted, do rescheduling.
             Self::current_check_preempt_pending();
         }

modules/axtask/src/tests.rs

@@ -19,15 +19,15 @@ fn test_sched_fifo() {
             move || {
                 println!("sched-fifo: Hello, task {}! ({})", i, current().id_name());
                 axtask::yield_now();
-                let order = FINISHED_TASKS.fetch_add(1, Ordering::Relaxed);
+                let order = FINISHED_TASKS.fetch_add(1, Ordering::Release);
                 assert_eq!(order, i); // FIFO scheduler
             },
             format!("T{}", i),
             0x1000,
         );
     }
 
-    while FINISHED_TASKS.load(Ordering::Relaxed) < NUM_TASKS {
+    while FINISHED_TASKS.load(Ordering::Acquire) < NUM_TASKS {
         axtask::yield_now();
     }
 }
@@ -55,10 +55,10 @@ fn test_fp_state_switch() {
 
             println!("fp_state_switch: Float {} = {}", i, value);
             assert!((value - float).abs() < 1e-9);
-            FINISHED_TASKS.fetch_add(1, Ordering::Relaxed);
+            FINISHED_TASKS.fetch_add(1, Ordering::Release);
         });
     }
-    while FINISHED_TASKS.load(Ordering::Relaxed) < NUM_TASKS {
+    while FINISHED_TASKS.load(Ordering::Acquire) < NUM_TASKS {
         axtask::yield_now();
     }
 }
@@ -76,31 +76,31 @@ fn test_wait_queue() {
 
     for _ in 0..NUM_TASKS {
         axtask::spawn(move || {
-            COUNTER.fetch_add(1, Ordering::Relaxed);
+            COUNTER.fetch_add(1, Ordering::Release);
             println!("wait_queue: task {:?} started", current().id());
             WQ1.notify_one(true); // WQ1.wait_until()
             WQ2.wait();
 
             assert!(!current().in_wait_queue());
 
-            COUNTER.fetch_sub(1, Ordering::Relaxed);
+            COUNTER.fetch_sub(1, Ordering::Release);
             println!("wait_queue: task {:?} finished", current().id());
             WQ1.notify_one(true); // WQ1.wait_until()
         });
     }
 
     println!("task {:?} is waiting for tasks to start...", current().id());
-    WQ1.wait_until(|| COUNTER.load(Ordering::Relaxed) == NUM_TASKS);
-    assert_eq!(COUNTER.load(Ordering::Relaxed), NUM_TASKS);
+    WQ1.wait_until(|| COUNTER.load(Ordering::Acquire) == NUM_TASKS);
+    assert_eq!(COUNTER.load(Ordering::Acquire), NUM_TASKS);
     assert!(!current().in_wait_queue());
     WQ2.notify_all(true); // WQ2.wait()
 
     println!(
         "task {:?} is waiting for tasks to finish...",
         current().id()
     );
-    WQ1.wait_until(|| COUNTER.load(Ordering::Relaxed) == 0);
-    assert_eq!(COUNTER.load(Ordering::Relaxed), 0);
+    WQ1.wait_until(|| COUNTER.load(Ordering::Acquire) == 0);
+    assert_eq!(COUNTER.load(Ordering::Acquire), 0);
     assert!(!current().in_wait_queue());
 }
 

modules/axtask/src/wait_queue.rs

@@ -21,13 +21,13 @@ use crate::{AxTaskRef, CurrentTask, current_run_queue, select_run_queue};
 /// axtask::init_scheduler();
 /// // spawn a new task that updates `VALUE` and notifies the main task
 /// axtask::spawn(|| {
-///     assert_eq!(VALUE.load(Ordering::Relaxed), 0);
-///     VALUE.fetch_add(1, Ordering::Relaxed);
+///     assert_eq!(VALUE.load(Ordering::Acquire), 0);
+///     VALUE.fetch_add(1, Ordering::Release);
 ///     WQ.notify_one(true); // wake up the main task
 /// });
 ///
 /// WQ.wait(); // block until `notify()` is called
-/// assert_eq!(VALUE.load(Ordering::Relaxed), 1);
+/// assert_eq!(VALUE.load(Ordering::Acquire), 1);
 /// ```
 pub struct WaitQueue {
     queue: SpinNoIrq<VecDeque<AxTaskRef>>,

tools/raspi4/chainloader/src/bsp/raspberrypi/driver.rs

@@ -59,13 +59,13 @@ fn driver_gpio() -> Result<(), &'static str> {
 /// See child function calls.
 pub unsafe fn init() -> Result<(), &'static str> {
     static INIT_DONE: AtomicBool = AtomicBool::new(false);
-    if INIT_DONE.load(Ordering::Relaxed) {
+    if INIT_DONE.load(Ordering::Acquire) {
         return Err("Init already done");
     }
 
     driver_uart()?;
     driver_gpio()?;
 
-    INIT_DONE.store(true, Ordering::Relaxed);
+    INIT_DONE.store(true, Ordering::Release);
     Ok(())
 }

tools/raspi4/chainloader/src/panic_wait.rs

@@ -31,8 +31,8 @@ fn panic_prevent_reenter() {
 
     static PANIC_IN_PROGRESS: AtomicBool = AtomicBool::new(false);
 
-    if !PANIC_IN_PROGRESS.load(Ordering::Relaxed) {
-        PANIC_IN_PROGRESS.store(true, Ordering::Relaxed);
+    if !PANIC_IN_PROGRESS.load(Ordering::Acquire) {
+        PANIC_IN_PROGRESS.store(true, Ordering::Release);
 
         return;
     }