diff --git a/kernel/src/cpu/isr.rs b/kernel/src/cpu/isr.rs index dfc0449..02bcead 100644 --- a/kernel/src/cpu/isr.rs +++ b/kernel/src/cpu/isr.rs @@ -85,10 +85,10 @@ extern "C" fn isr_handler(state: &mut ISRState) { if 48 <= state.isr && state.isr <= 254 { send_eoi(); // APIC interrupt } - IN_ISR_HANDLER.store(true, Ordering::Relaxed); + IN_ISR_HANDLER.store(true, Ordering::SeqCst); if state.isr == 254 { scheduler(state); - IN_ISR_HANDLER.store(false, Ordering::Relaxed); + IN_ISR_HANDLER.store(false, Ordering::SeqCst); return; } let handler; @@ -100,5 +100,5 @@ extern "C" fn isr_handler(state: &mut ISRState) { } else { warn!("Unhandled interrupt: {}", state.isr); } - IN_ISR_HANDLER.store(false, Ordering::Relaxed); + IN_ISR_HANDLER.store(false, Ordering::SeqCst); } diff --git a/kernel/src/cpu/paging.rs b/kernel/src/cpu/paging.rs index d59007f..7274732 100644 --- a/kernel/src/cpu/paging.rs +++ b/kernel/src/cpu/paging.rs @@ -47,8 +47,8 @@ fn invlpg(addr: u64) { } } fn virt_to_phys(virt: u64) -> u64 { - if !PAGING_ACTIVE.load(Ordering::Relaxed) { - return virt - KERNEL_HEAP_START + HEAP_PHYS_START.load(Ordering::Relaxed); + if !PAGING_ACTIVE.load(Ordering::SeqCst) { + return virt - KERNEL_HEAP_START + HEAP_PHYS_START.load(Ordering::SeqCst); } assert!(virt >= KERNEL_HEAP_START); assert!(virt < KERNEL_HEAP_START + KERNEL_HEAP_INITIAL_SIZE as u64); @@ -175,7 +175,7 @@ pub unsafe fn unmap_physical(address: u64, size: u64) { } } pub fn setup_paging(loader_struct: &LoaderStruct, phys_start: u64, heap_start: u64) { - HEAP_PHYS_START.store(heap_start, Ordering::Relaxed); + HEAP_PHYS_START.store(heap_start, Ordering::SeqCst); let mut memory_size = 0; for i in loader_struct.available_memory { if i.initial_page + i.page_count > memory_size { @@ -245,5 +245,5 @@ pub fn setup_paging(loader_struct: &LoaderStruct, phys_start: u64, heap_start: u } let mut current_pml4 = CURRENT_PML4.lock(); *current_pml4 = Some(pml4); - PAGING_ACTIVE.store(true, Ordering::Relaxed); + PAGING_ACTIVE.store(true, Ordering::SeqCst); } diff --git a/kernel/src/main.rs b/kernel/src/main.rs index cb28b47..1b759f8 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -58,7 +58,7 @@ extern "C" fn early_main(temp_loader_struct: *const LoaderStruct) -> ! { setup_idt(); setup_paging(&loader_struct, loader_struct.phys_kernel_start, loader_struct.phys_heap_start); disable_pic(); - RSDP_ADDRESS.store(loader_struct.rsdp_address, Ordering::Relaxed); + RSDP_ADDRESS.store(loader_struct.rsdp_address, Ordering::SeqCst); let early_acpi_tables; unsafe { early_acpi_tables = AcpiTables::from_rsdp(EarlyACPIHandler {}, loader_struct.rsdp_address as usize).unwrap(); diff --git a/kernel/src/sys/acpica_osl.rs b/kernel/src/sys/acpica_osl.rs index 043fec4..f041055 100644 --- a/kernel/src/sys/acpica_osl.rs +++ b/kernel/src/sys/acpica_osl.rs @@ -84,11 +84,11 @@ extern "C" fn AcpiOsFree(memory: *mut c_void) { } #[no_mangle] extern "C" fn AcpiOsGetRootPointer() -> ACPI_PHYSICAL_ADDRESS { - RSDP_ADDRESS.load(Ordering::Relaxed) + RSDP_ADDRESS.load(Ordering::SeqCst) } #[no_mangle] extern "C" fn AcpiOsGetThreadId() -> UINT64 { - if !MULTITASKING_ENABLED.load(Ordering::Relaxed) { + if !MULTITASKING_ENABLED.load(Ordering::SeqCst) { return 1; } let task_id; @@ -110,13 +110,13 @@ extern "C" fn AcpiOsInitialize() -> ACPI_STATUS { fn sci_handler() { let handler = SCI_HANDLER.lock().unwrap(); unsafe { - handler(SCI_CONTEXT.load(Ordering::Relaxed)); + handler(SCI_CONTEXT.load(Ordering::SeqCst)); } } #[no_mangle] extern "C" fn AcpiOsInstallInterruptHandler(gsi: UINT32, handler: ACPI_OSD_HANDLER, context: *mut c_void) -> ACPI_STATUS { *SCI_HANDLER.lock() = handler; - SCI_CONTEXT.store(context, Ordering::Relaxed); + SCI_CONTEXT.store(context, Ordering::SeqCst); set_irq_override(gsi as usize, 253, 1, 1); register_irq_handler(253, sci_handler); AE_OK diff --git a/kernel/src/sys/hpet.rs b/kernel/src/sys/hpet.rs index 0a6eb9f..b6fd3bf 100644 --- a/kernel/src/sys/hpet.rs +++ b/kernel/src/sys/hpet.rs @@ -34,16 +34,16 @@ static SLEEPING_LIST: Mutex> = Mutex::new(Vec::new()); static SLEEP_LOCK: Spinlock = Spinlock::new(); fn ticks_to_us(ticks: usize) -> usize { - let period = PERIOD.load(Ordering::Relaxed); + let period = PERIOD.load(Ordering::SeqCst); ticks / (usize::pow(10, 9) / period) } fn us_to_ticks(us: usize) -> usize { - let period = PERIOD.load(Ordering::Relaxed); + let period = PERIOD.load(Ordering::SeqCst); usize::pow(10, 9) / period * us } fn schedule_hpet_interrupt(sleep_until_us: usize) { let current_time = get_current_time(); - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); let mut sleep_for_us = sleep_until_us - current_time; if sleep_for_us < 10 { sleep_for_us = 10; @@ -57,15 +57,15 @@ fn schedule_hpet_interrupt(sleep_until_us: usize) { } } fn handler() { - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); unsafe { let current_config = address.add(REGISTER_TIMER0_CONFIG).read_volatile(); address.add(REGISTER_TIMER0_CONFIG).write_volatile(current_config & !TIMER_CONFIG_ENABLE); } - if EARLY_SLEEP.load(Ordering::Relaxed) { - EARLY_SLEEP.store(false, Ordering::Relaxed); + if EARLY_SLEEP.load(Ordering::SeqCst) { + EARLY_SLEEP.store(false, Ordering::SeqCst); } - if MULTITASKING_ENABLED.load(Ordering::Relaxed) { + if MULTITASKING_ENABLED.load(Ordering::SeqCst) { SLEEP_LOCK.lock(); { let mut sleeping_list = SLEEPING_LIST.lock(); @@ -90,12 +90,12 @@ fn handler() { } } fn get_current_time() -> usize { - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); let current_counter = unsafe { address.add(REGISTER_COUNTER).read_volatile() }; ticks_to_us(current_counter as usize) } pub fn sleep(us: usize) { - if MULTITASKING_ENABLED.load(Ordering::Relaxed) { + if MULTITASKING_ENABLED.load(Ordering::SeqCst) { CURRENT_TASK_LOCK.lock(); { let mut _current_task = CURRENT_TASK.lock(); @@ -106,15 +106,15 @@ pub fn sleep(us: usize) { CURRENT_TASK_LOCK.unlock(); yield_task(); } else { - EARLY_SLEEP.store(true, Ordering::Relaxed); - let address = ADDRESS.load(Ordering::Relaxed); + EARLY_SLEEP.store(true, Ordering::SeqCst); + let address = ADDRESS.load(Ordering::SeqCst); unsafe { let current_counter = address.add(REGISTER_COUNTER).read_volatile(); address.add(REGISTER_TIMER0_COMPARATOR).write_volatile(current_counter + us_to_ticks(us) as u64); let current_config = address.add(REGISTER_TIMER0_CONFIG).read_volatile(); address.add(REGISTER_TIMER0_CONFIG).write_volatile(current_config | TIMER_CONFIG_ENABLE); } - while EARLY_SLEEP.load(Ordering::Relaxed) { + while EARLY_SLEEP.load(Ordering::SeqCst) { pause(); } } @@ -132,9 +132,9 @@ pub fn sleep_internal(task: Task) { pub fn setup_hpet(tables: &AcpiTables) { let hpet_info = HpetInfo::new(tables).unwrap(); let address = unsafe { map_physical(hpet_info.base_address as u64, 0x200) } as *mut u64; - ADDRESS.store(address, Ordering::Relaxed); + ADDRESS.store(address, Ordering::SeqCst); let period = unsafe { address.add(REGISTER_CAPABILITIES).read_volatile() >> 32 } as usize; - PERIOD.store(period, Ordering::Relaxed); + PERIOD.store(period, Ordering::SeqCst); unsafe { let current_config = address.add(REGISTER_CONFIG).read_volatile(); address.add(REGISTER_CONFIG).write_volatile(current_config | CONFIG_ENABLE | CONFIG_LEGACY_REPLACEMENT); diff --git a/kernel/src/sys/ioapic.rs b/kernel/src/sys/ioapic.rs index 2d6952e..54e1e46 100644 --- a/kernel/src/sys/ioapic.rs +++ b/kernel/src/sys/ioapic.rs @@ -39,19 +39,19 @@ static IOAPICS: [IOAPIC; 32] = [EMPTY_IOAPIC; 32]; fn read_register(apic_i: usize, reg_i: u8) -> u32 { unsafe { - IOAPICS[apic_i].address.load(Ordering::Relaxed).write_volatile(reg_i as u32); - return IOAPICS[apic_i].address.load(Ordering::Relaxed).add(4).read_volatile(); + IOAPICS[apic_i].address.load(Ordering::SeqCst).write_volatile(reg_i as u32); + return IOAPICS[apic_i].address.load(Ordering::SeqCst).add(4).read_volatile(); } } fn write_register(apic_i: usize, reg_i: u8, val: u32) { unsafe { - IOAPICS[apic_i].address.load(Ordering::Relaxed).write_volatile(reg_i as u32); - IOAPICS[apic_i].address.load(Ordering::Relaxed).add(4).write_volatile(val); + IOAPICS[apic_i].address.load(Ordering::SeqCst).write_volatile(reg_i as u32); + IOAPICS[apic_i].address.load(Ordering::SeqCst).add(4).write_volatile(val); } } fn get_apic_for_gsi(gsi: usize) -> usize { for i in 0..32 { - if gsi >= IOAPICS[i].start_gsi.load(Ordering::Relaxed) as usize && gsi < IOAPICS[i].end_gsi.load(Ordering::Relaxed) as usize { + if gsi >= IOAPICS[i].start_gsi.load(Ordering::SeqCst) as usize && gsi < IOAPICS[i].end_gsi.load(Ordering::SeqCst) as usize { return i; } } @@ -59,14 +59,14 @@ fn get_apic_for_gsi(gsi: usize) -> usize { } fn read_redirection(mut gsi: usize) -> RedirectionEntry { let apic_i = get_apic_for_gsi(gsi); - gsi -= IOAPICS[apic_i].start_gsi.load(Ordering::Relaxed) as usize; + gsi -= IOAPICS[apic_i].start_gsi.load(Ordering::SeqCst) as usize; let mut redirection_int = read_register(apic_i, REGISTER_REDIRECTION + gsi as u8 * 2) as u64; redirection_int |= (read_register(apic_i, REGISTER_REDIRECTION + gsi as u8 * 2 + 1) as u64) << 32; return RedirectionEntry(redirection_int); } fn write_redirection(mut gsi: usize, redirection: RedirectionEntry) { let apic_i = get_apic_for_gsi(gsi); - gsi -= IOAPICS[apic_i].start_gsi.load(Ordering::Relaxed) as usize; + gsi -= IOAPICS[apic_i].start_gsi.load(Ordering::SeqCst) as usize; write_register(apic_i, REGISTER_REDIRECTION + gsi as u8 * 2, redirection.0 as u32); write_register(apic_i, REGISTER_REDIRECTION + gsi as u8 * 2 + 1, (redirection.0 >> 32) as u32); } @@ -81,8 +81,8 @@ pub fn register_irq_handler(vector: usize, handler: fn()) { assert!(ISR_HANDLERS.lock()[vector].is_none()); ISR_HANDLERS.lock()[vector] = Some(handler); for i in 0..32 { - let start = IOAPICS[i].start_gsi.load(Ordering::Relaxed); - let end = IOAPICS[i].end_gsi.load(Ordering::Relaxed); + let start = IOAPICS[i].start_gsi.load(Ordering::SeqCst); + let end = IOAPICS[i].end_gsi.load(Ordering::SeqCst); for j in start..end { let mut redirection = read_redirection(j as usize); if redirection.vector() == vector as u64 { @@ -95,16 +95,16 @@ pub fn register_irq_handler(vector: usize, handler: fn()) { pub fn setup_ioapic(apic_i: u8, phys: u64, gsi_base: u32) { let apic_i = apic_i as usize; let address = unsafe { map_physical(phys, 0x14) as *mut u32 }; - IOAPICS[apic_i].address.store(address, Ordering::Relaxed); - IOAPICS[apic_i].start_gsi.store(gsi_base, Ordering::Relaxed); + IOAPICS[apic_i].address.store(address, Ordering::SeqCst); + IOAPICS[apic_i].start_gsi.store(gsi_base, Ordering::SeqCst); let max_ints = (read_register(apic_i, REGISTER_VERSION) >> 16) & 0xff; - IOAPICS[apic_i].end_gsi.store(gsi_base + max_ints, Ordering::Relaxed); + IOAPICS[apic_i].end_gsi.store(gsi_base + max_ints, Ordering::SeqCst); assert!(gsi_base + max_ints < 128); for i in gsi_base..gsi_base + max_ints { let mut redirection = RedirectionEntry(0); redirection.set_mask(1); redirection.set_vector(48 + i as u64); - redirection.set_destination(BSP_LAPIC_ID.load(Ordering::Relaxed) as u64); + redirection.set_destination(BSP_LAPIC_ID.load(Ordering::SeqCst) as u64); write_redirection(i as usize, redirection); } } diff --git a/kernel/src/sys/lapic.rs b/kernel/src/sys/lapic.rs index 1f85150..67effb3 100644 --- a/kernel/src/sys/lapic.rs +++ b/kernel/src/sys/lapic.rs @@ -20,40 +20,40 @@ pub static BSP_LAPIC_ID: AtomicU8 = AtomicU8::new(0); static TICKS_PER_MS: AtomicUsize = AtomicUsize::new(0); pub fn send_eoi() { - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); unsafe { address.add(REGISTER_EOI).write_volatile(0); } } pub fn setup_lapic(phys: u64) { let address = unsafe { map_physical(phys, 0x400) as *mut u32 }; - ADDRESS.store(address, Ordering::Relaxed); + ADDRESS.store(address, Ordering::SeqCst); unsafe { - BSP_LAPIC_ID.store(address.add(REGISTER_ID).read_volatile() as u8, Ordering::Relaxed); + BSP_LAPIC_ID.store(address.add(REGISTER_ID).read_volatile() as u8, Ordering::SeqCst); address.add(REGISTER_SPURIOUS_INT).write_volatile(0x1ff); } send_eoi(); } fn calibrate_timer() { - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); unsafe { address.add(REGISTER_TIMER_INITIAL_COUNT).write_volatile(0xffffffff); } sleep(10000); let ticks_in_10ms = 0xffffffff - unsafe { address.add(REGISTER_TIMER_CURRENT_COUNT).read_volatile() }; - TICKS_PER_MS.store(ticks_in_10ms as usize / 10, Ordering::Relaxed); + TICKS_PER_MS.store(ticks_in_10ms as usize / 10, Ordering::SeqCst); unsafe { address.add(REGISTER_TIMER_INITIAL_COUNT).write_volatile(0); } } pub fn schedule_timer_interrupt() { - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); unsafe { - address.add(REGISTER_TIMER_INITIAL_COUNT).write_volatile(10 * TICKS_PER_MS.load(Ordering::Relaxed) as u32); + address.add(REGISTER_TIMER_INITIAL_COUNT).write_volatile(10 * TICKS_PER_MS.load(Ordering::SeqCst) as u32); } } pub fn setup_lapic_timer() { - let address = ADDRESS.load(Ordering::Relaxed); + let address = ADDRESS.load(Ordering::SeqCst); unsafe { address.add(REGISTER_TIMER_DIVIDE).write_volatile(3); } diff --git a/kernel/src/sys/scheduler.rs b/kernel/src/sys/scheduler.rs index 01289c7..e119049 100644 --- a/kernel/src/sys/scheduler.rs +++ b/kernel/src/sys/scheduler.rs @@ -16,7 +16,7 @@ pub static IDLE_TASK: Mutex> = Mutex::new(None); pub static SCHEDULER_LOCK: Spinlock = Spinlock::new(); pub fn scheduler(state: &mut ISRState) { - if !MULTITASKING_ENABLED.load(Ordering::Relaxed) { + if !MULTITASKING_ENABLED.load(Ordering::SeqCst) { return; } CURRENT_TASK_LOCK.lock(); @@ -49,7 +49,7 @@ pub fn scheduler(state: &mut ISRState) { CURRENT_TASK_LOCK.unlock(); } pub fn schedule_task(task: Task) { - assert!(SCHEDULER_LOCK.is_locked() || !MULTITASKING_ENABLED.load(Ordering::Relaxed)); + assert!(SCHEDULER_LOCK.is_locked() || !MULTITASKING_ENABLED.load(Ordering::SeqCst)); let mut scheduler_list = SCHEDULER_LIST.lock(); if scheduler_list.is_empty() { schedule_timer_interrupt(); @@ -57,8 +57,8 @@ pub fn schedule_task(task: Task) { scheduler_list.push_back(task); } pub fn yield_task() { - assert!(!IN_ISR_HANDLER.load(Ordering::Relaxed)); - assert_eq!(LOCKS_HELD.load(Ordering::Relaxed), 0); + assert!(!IN_ISR_HANDLER.load(Ordering::SeqCst)); + assert_eq!(LOCKS_HELD.load(Ordering::SeqCst), 0); unsafe { asm!("int $254"); } diff --git a/kernel/src/sys/sync.rs b/kernel/src/sys/sync.rs index b63e0d5..65a13f8 100644 --- a/kernel/src/sys/sync.rs +++ b/kernel/src/sys/sync.rs @@ -28,21 +28,21 @@ impl Spinlock { } pub fn lock(&self) { cli(); - while !self.locked.compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed).is_ok() {} - LOCKS_HELD.fetch_add(1, Ordering::Relaxed); + while !self.locked.compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst).is_ok() {} + LOCKS_HELD.fetch_add(1, Ordering::SeqCst); } pub fn unlock(&self) { - assert!(self.locked.load(Ordering::Relaxed)); - self.locked.store(false, Ordering::Relaxed); - LOCKS_HELD.fetch_sub(1, Ordering::Relaxed); - if !IN_ISR_HANDLER.load(Ordering::Relaxed) && LOCKS_HELD.load(Ordering::Relaxed) == 0 { + assert!(self.locked.load(Ordering::SeqCst)); + self.locked.store(false, Ordering::SeqCst); + LOCKS_HELD.fetch_sub(1, Ordering::SeqCst); + if !IN_ISR_HANDLER.load(Ordering::SeqCst) && LOCKS_HELD.load(Ordering::SeqCst) == 0 { unsafe { sti(); } } } pub fn is_locked(&self) -> bool { - self.locked.load(Ordering::Relaxed) + self.locked.load(Ordering::SeqCst) } } @@ -57,11 +57,11 @@ pub fn create_semaphore(max_count: usize, initial_count: usize) -> Arc, count: usize) { loop { let mut success = false; - let current_count = semaphore.current_count.load(Ordering::Relaxed); + let current_count = semaphore.current_count.load(Ordering::SeqCst); if current_count >= count { success = semaphore .current_count - .compare_exchange(current_count, current_count - count, Ordering::Relaxed, Ordering::Relaxed) + .compare_exchange(current_count, current_count - count, Ordering::SeqCst, Ordering::SeqCst) .is_ok(); } if success { @@ -82,7 +82,7 @@ pub fn lock_semaphore(semaphore: Arc, count: usize) { pub fn lock_semaphore_internal(mut task: Task) { let semaphore = task.block_on_semaphore.as_ref().unwrap().clone(); semaphore.spinlock.lock(); - if task.semaphore_requested_count > semaphore.current_count.load(Ordering::Relaxed) { + if task.semaphore_requested_count > semaphore.current_count.load(Ordering::SeqCst) { semaphore.blocked_list.lock().push_back(task); } else { task.block_on_semaphore = None; @@ -97,8 +97,8 @@ pub fn lock_semaphore_internal(mut task: Task) { pub fn unlock_semaphore(semaphore: Arc, count: usize) { semaphore.spinlock.lock(); { - semaphore.current_count.fetch_add(count, Ordering::Relaxed); - assert!(semaphore.current_count.load(Ordering::Relaxed) <= semaphore.max_count); + semaphore.current_count.fetch_add(count, Ordering::SeqCst); + assert!(semaphore.current_count.load(Ordering::SeqCst) <= semaphore.max_count); while let Some(mut task) = semaphore.blocked_list.lock().pop_front() { task.block_on_semaphore = None; task.semaphore_requested_count = 0; diff --git a/kernel/src/sys/task.rs b/kernel/src/sys/task.rs index b7435ff..b82b092 100644 --- a/kernel/src/sys/task.rs +++ b/kernel/src/sys/task.rs @@ -80,7 +80,7 @@ pub fn create_task(func: fn()) -> Task { let stack = Box::new(Stack([0; STACK_SIZE])); let stack_address: *const Stack = &*stack; let task = Task { - id: NEXT_TASK_ID.fetch_add(1, Ordering::Relaxed), + id: NEXT_TASK_ID.fetch_add(1, Ordering::SeqCst), state: ISRState { rax: 0, rbx: 0, @@ -101,7 +101,7 @@ pub fn create_task(func: fn()) -> Task { error_code: 0, rip: task_entry as u64, cs: 8, - rflags: RFLAGS.load(Ordering::Relaxed), + rflags: RFLAGS.load(Ordering::SeqCst), rsp: stack_address as u64 + STACK_SIZE as u64, ss: 16, }, @@ -141,7 +141,7 @@ pub fn setup_multitasking() -> ! { unsafe { asm!("pushf; pop {0:r}", out(reg) rflags); } - RFLAGS.store(rflags, core::sync::atomic::Ordering::Relaxed); + RFLAGS.store(rflags, core::sync::atomic::Ordering::SeqCst); let mut idle_task = create_task(idle); idle_task.task_state = TaskState::Idle; { @@ -149,7 +149,7 @@ pub fn setup_multitasking() -> ! { } let task = create_task(main); schedule_task(task); - MULTITASKING_ENABLED.store(true, Ordering::Relaxed); + MULTITASKING_ENABLED.store(true, Ordering::SeqCst); yield_task(); panic!("Setting up multitasking failed"); } diff --git a/loader/src/main.rs b/loader/src/main.rs index ed2b5a3..ee74e6f 100644 --- a/loader/src/main.rs +++ b/loader/src/main.rs @@ -49,16 +49,16 @@ fn main() -> Status { with_config_table(|tables| { for i in tables { if i.guid == uefi::table::cfg::ACPI2_GUID { - rsdp.store(i.address as u64, Ordering::Relaxed); + rsdp.store(i.address as u64, Ordering::SeqCst); break; } } }); - assert_ne!(rsdp.load(Ordering::Relaxed), 0, "RSDP not found"); + assert_ne!(rsdp.load(Ordering::SeqCst), 0, "RSDP not found"); let memory_map = unsafe { exit_boot_services(MemoryType::LOADER_DATA) }; let pml4 = setup_paging(&memory_map, heap_start); map_kernel(KERNEL, pml4, kernel_start); - let loader_struct = generate_loader_struct(&memory_map, kernel_start, heap_start, rsdp.load(Ordering::Relaxed)); + let loader_struct = generate_loader_struct(&memory_map, kernel_start, heap_start, rsdp.load(Ordering::SeqCst)); info!("Jumping to kernel..."); unsafe { (mem::transmute::<_, extern "C" fn(&LoaderStruct) -> !>(kernel_entry))(&loader_struct);