diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/dma.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/dma.rs
index 9dac37bee3..ae4eb549d1 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/dma.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/dma.rs
@@ -124,11 +124,9 @@ pub extern "C" fn dma_alloc_coherent(
 
     let phys = virt_to_phys(vaddr as usize);
     if phys == 0 {
-// SAFETY: caller must verify the safety contract for this operation
         unsafe { dealloc(vaddr, layout) };
         return ptr::null_mut();
     }
-// SAFETY: caller must verify the safety contract for this operation
 
     unsafe { *dma_handle = phys as u64 };
     log::debug!(
@@ -145,8 +143,7 @@ pub extern "C" fn dma_free_coherent(_dev: *mut u8, size: usize, vaddr: *mut u8,
     if vaddr.is_null() || size == 0 {
         return;
     }
-    let layout = match Layout::from_size_alig// SAFETY: caller must verify the safety contract for this operation
-n(size, 4096) {
+    let layout = match Layout::from_size_align(size, 4096) {
         Ok(l) => l,
         Err(_) => return,
     };
@@ -241,11 +238,9 @@ pub extern "C" fn dma_pool_destroy(pool: *mut DmaPool) {
         let entries = allocations
             .lock()
             .map(|entries| entries.clone())
-            .unwrap_or_d// SAFETY: caller must verify the safety contract for this operation
-efault();
+            .unwrap_or_default();
         for entry in entries {
-            if let Ok(layout) = Layout::from_size_align(entry.size.max(1), entry.align.m// SAFETY: caller must verify the safety contract for this operation
-ax(1)) {
+            if let Ok(layout) = Layout::from_size_align(entry.size.max(1), entry.align.max(1)) {
                 unsafe { dealloc(entry.vaddr as *mut u8, layout) };
             }
         }
@@ -272,21 +267,17 @@ pub extern "C" fn dma_pool_alloc(pool: *mut DmaPool, _flags: u32, handle: *mut u
 
     let layout = match Layout::from_size_align(pool_ref.size, pool_ref.align.max(1)) {
         Ok(layout) => layout,
-        Err(_) // SAFETY: caller must verify the safety contract for this operation
-=> return ptr::null_mut(),
+        Err(_) => return ptr::null_mut(),
     };
 
-    let vaddr = unsafe { alloc_zeroe// SAFETY: caller must verify the safety contract for this operation
-d(layout) };
+    let vaddr = unsafe { alloc_zeroed(layout) };
     if vaddr.is_null() {
-        return ptr::null_mut// SAFETY: caller must verify the safety contract for this operation
-();
+        return ptr::null_mut();
     }
 
     let dma = virt_to_phys(vaddr as usize) as u64;
     if dma == 0 || crosses_boundary(dma, pool_ref.size, pool_ref.boundary) {
-        unsafe { dealloc(vad// SAFETY: caller must verify the safety contract for this operation
-dr, layout) };
+        unsafe { dealloc(vaddr, layout) };
         return ptr::null_mut();
     }
 
@@ -311,8 +302,7 @@ dr, layout) };
 }
 
 #[no_mangle]
-pub extern "C" fn dma_pool_free(pool: *mut DmaPool, vaddr: *// SAFETY: caller must verify the safety contract for this operation
-mut u8, addr: u64) {
+pub extern "C" fn dma_pool_free(pool: *mut DmaPool, vaddr: *mut u8, addr: u64) {
     if pool.is_null() || vaddr.is_null() {
         return;
     }
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/drm_shim.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/drm_shim.rs
index 95d8c5278f..df0be52849 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/drm_shim.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/drm_shim.rs
@@ -45,7 +45,6 @@ struct DrmFile {
 
 unsafe fn write_handle_count(obj: *mut u8, count: u32) {
     let cobj = obj as *mut CallerGemObject;
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         (*cobj).handle_count = count;
     }
@@ -53,14 +52,12 @@ unsafe fn write_handle_count(obj: *mut u8, count: u32) {
 
 unsafe fn write_size(obj: *mut u8, size: usize) {
     let cobj = obj as *mut CallerGemObject;
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         (*cobj).size = size;
     }
 }
 
-unsafe fn read_size(ob// SAFETY: caller must verify the safety contract for this operation
-j: *mut u8) -> usize {
+unsafe fn read_size(obj: *mut u8) -> usize {
     let cobj = obj as *const CallerGemObject;
     unsafe { (*cobj).size }
 }
@@ -458,8 +455,7 @@ pub extern "C" fn drm_dev_register(_dev: *mut u8, flags: u64) -> i32 {
 }
 
 #[no_mangle]
-pub extern "C" fn drm_dev_unregister(_dev: *mut // SAFETY: caller must verify the safety contract for this operation
-u8) {}
+pub extern "C" fn drm_dev_unregister(_dev: *mut u8) {}
 
 #[no_mangle]
 pub extern "C" fn drm_gem_object_init(_dev: *mut u8, obj: *mut u8, size: usize) -> i32 {
@@ -508,8 +504,7 @@ pub extern "C" fn drm_gem_handle_create(file: *mut u8, obj: *mut u8, handlep: *m
         return -EINVAL;
     }
 
-    let key = obj as u// SAFETY: caller must verify the safety contract for this operation
-size;
+    let key = obj as usize;
     let size = unsafe { read_size(obj) };
 
     let create = DrmGemCreateWire {
@@ -542,8 +537,7 @@ size;
         state.handles.push(response.handle);
         Some(state.handle_count)
     });
-    let // SAFETY: caller must verify the safety contract for this operation
-new_count = match new_count {
+    let new_count = match new_count {
         Some(c) => c,
         None => {
             log::error!(
@@ -573,14 +567,12 @@ new_count = match new_count {
 }
 
 #[no_mangle]
-pub extern "C" fn drm_gem_handle_delete(file: *// SAFETY: caller must verify the safety contract for this operation
-mut u8, handle: u32) {
+pub extern "C" fn drm_gem_handle_delete(file: *mut u8, handle: u32) {
     let obj_key = with_handles(|handles| handles.remove(&handle));
 
     if let Some(key) = obj_key {
         with_objects(|objects| {
-            if let Some(state) = objects.// SAFETY: caller must verify the safety contract for this operation
-get_mut(&key) {
+            if let Some(state) = objects.get_mut(&key) {
                 state.handles.retain(|h| *h != handle);
                 state.handle_count = state.handle_count.saturating_sub(1);
                 unsafe {
@@ -621,7 +613,6 @@ pub extern "C" fn drm_gem_handle_lookup(_file: *mut u8, handle: u32) -> *mut u8
             }
         }
         None => {
-         // SAFETY: caller must verify the safety contract for this operation
    log::warn!("drm_gem_handle_lookup: handle={} not found", handle);
             ptr::null_mut()
         }
@@ -650,7 +641,6 @@ pub extern "C" fn drm_gem_object_lookup(_file: *mut u8, handle: u32) -> *mut u8
             } else {
                 log::warn!(
                     "drm_gem_object_lookup: handle={} maps to obj={:#x} but object released",
-          // SAFETY: caller must verify the safety contract for this operation
           handle,
                     key
                 );
@@ -672,8 +662,7 @@ pub extern "C" fn drm_gem_object_put(obj: *mut u8) {
     let key = obj as usize;
     with_objects(|objects| {
         if let Some(state) = objects.get_mut(&key) {
-            state.handle_count = state.handle_count.saturating_// SAFETY: caller must verify the safety contract for this operation
-sub(1);
+            state.handle_count = state.handle_count.saturating_sub(1);
             unsafe {
                 write_handle_count(obj, state.handle_count);
             }
@@ -749,8 +738,7 @@ pub extern "C" fn drm_crtc_handle_vblank(crtc: *mut u8) -> u32 {
         Err(poisoned) => poisoned.into_inner(),
     };
     let entry = counters.entry(key).or_insert(0);
-    *entry = entry.wrappi// SAFETY: caller must verify the safety contract for this operation
-ng_add(1);
+    *entry = entry.wrapping_add(1);
     *entry
 }
 
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/firmware.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/firmware.rs
index d443adc8ce..6c24a3059a 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/firmware.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/firmware.rs
@@ -79,7 +79,6 @@ fn install_firmware(fw: *mut *mut Firmware, data: Vec<u8>) -> i32 {
         size,
         data: ptr as *const u8,
     });
-// SAFETY: caller must verify the safety contract for this operation
     unsafe { *fw = Box::into_raw(firmware) };
     0
 }
@@ -103,7 +102,6 @@ impl Drop for Firmware {
     fn drop(&mut self) {
         if !self.data.is_null() && self.size > 0 {
             let layout = match std::alloc::Layout::from_size_align(self.size, 1) {
-        // SAFETY: caller must verify the safety contract for this operation
         Ok(l) => l,
                 Err(_) => return,
             };
@@ -179,8 +177,7 @@ pub extern "C" fn request_firmware_nowait(
     let fw_addr = fw_ptr as usize;
     let context_addr = context as usize;
     std::thread::spawn(move || {
-        cont(fw_addr as *const Firmware, context_addr as *mu// SAFETY: caller must verify the safety contract for this operation
-t u8);
+        cont(fw_addr as *const Firmware, context_addr as *mut u8);
     });
 
     0
@@ -216,8 +213,7 @@ mod tests {
     }
 
     #[test]
-    fn request_firmware_direc// SAFETY: caller must verify the safety contract for this operation
-t_uses_override_root() {
+    fn request_firmware_direct_uses_override_root() {
         let _guard = TEST_ENV_LOCK.lock().unwrap();
         let root = temp_root("rbos-linux-kpi-fw");
         std::fs::write(root.join("iwlwifi-test.ucode"), [1u8, 2, 3]).unwrap();
@@ -226,15 +222,13 @@ t_uses_override_root() {
         }
 
         let mut fw: *mut Firmware = ptr::null_mut();
-        let name = // SAFETY: caller must verify the safety contract for this operation
-CString::new("iwlwifi-test.ucode").unwrap();
+        let name = CString::new("iwlwifi-test.ucode").unwrap();
         let rc = request_firmware_direct(&mut fw, name.as_ptr().cast::<u8>(), ptr::null_mut());
         assert_eq!(rc, 0);
         assert!(!fw.is_null());
         assert_eq!(unsafe { (*fw).size }, 3);
         release_firmware(fw);
         unsafe {
-// SAFETY: caller must verify the safety contract for this operation
             std::env::remove_var("REDBEAR_LINUX_KPI_FIRMWARE_ROOT");
         }
     }
@@ -253,13 +247,11 @@ CString::new("iwlwifi-test.ucode").unwrap();
         extern "C" fn callback(fw: *const Firmware, _context: *mut u8) {
             assert!(!fw.is_null());
             CALLED.store(true, Ordering::Release);
-            re// SAFETY: caller must verify the safety contract for this operation
-lease_firmware(fw as *mut Firmware);
+            release_firmware(fw as *mut Firmware);
         }
 
         let name = CString::new("iwlwifi-test-async.ucode").unwrap();
         let rc = request_firmware_nowait(
-        // SAFETY: caller must verify the safety contract for this operation
     ptr::null_mut(),
             0,
             name.as_ptr().cast::<u8>(),
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/idr.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/idr.rs
index 0d1f460161..2c80b05fe6 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/idr.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/idr.rs
@@ -16,7 +16,6 @@ pub extern "C" fn rust_idr_init(internal: *mut *mut c_void) {
     if internal.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
 
     unsafe {
         let boxed = Box::new(Idr {
@@ -176,7 +175,6 @@ pub extern "C" fn rust_idr_destroy(internal: *mut *mut c_void) {
     if internal.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
 
     unsafe {
         let raw = *internal;
@@ -217,7 +215,6 @@ pub extern "C" fn rust_idr_for_each_entry(internal: *mut c_void, id: *mut i32) -
         }
     }
 
- // SAFETY: caller must verify the safety contract for this operation
    match (found_id, found_ptr) {
         (Some(key), Some(ptr)) => {
             unsafe { *id = key as i32 };
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/io.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/io.rs
index e80dbbb104..8516635ee0 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/io.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/io.rs
@@ -79,37 +79,31 @@ pub extern "C" fn writel(val: u32, addr: *mut u8) {
 }
 
 #[no_mangle]
-pub extern "C" fn readq(addr: *co// SAFETY: caller must verify the safety contract for this operation
-nst u8) -> u64 {
+pub extern "C" fn readq(addr: *const u8) -> u64 {
     if addr.is_null() {
         return 0;
     }
-    unsafe { ptr::read_volatile(ad// SAFETY: caller must verify the safety contract for this operation
-dr as *const u64) }
+    unsafe { ptr::read_volatile(addr as *const u64) }
 }
 
 #[no_mangle]
 pub extern "C" fn writeq(val: u64, addr: *mut u8) {
-    if addr.is_// SAFETY: caller must verify the safety contract for this operation
-null() {
+    if addr.is_null() {
         return;
     }
-    unsafe { ptr::write_volatile(addr as *mut u64, va// SAFETY: caller must verify the safety contract for this operation
-l) };
+    unsafe { ptr::write_volatile(addr as *mut u64, val) };
 }
 
 #[no_mangle]
 pub extern "C" fn readb(addr: *const u8) -> u8 {
-    if addr.is_null()// SAFETY: caller must verify the safety contract for this operation
- {
+    if addr.is_null() {
         return 0;
     }
     unsafe { ptr::read_volatile(addr) }
 }
 
 #[no_mangle]
-pub extern "C" f// SAFETY: caller must verify the safety contract for this operation
-n writeb(val: u8, addr: *mut u8) {
+pub extern "C" fn writeb(val: u8, addr: *mut u8) {
     if addr.is_null() {
         return;
     }
@@ -117,8 +111,7 @@ n writeb(val: u8, addr: *mut u8) {
 }
 
 #[no_mangle]
-pub extern "C"// SAFETY: caller must verify the safety contract for this operation
- fn readw(addr: *const u8) -> u16 {
+pub extern "C" fn readw(addr: *const u8) -> u16 {
     if addr.is_null() {
         return 0;
     }
@@ -126,13 +119,11 @@ pub extern "C"// SAFETY: caller must verify the safety contract for this operati
 }
 
 #[no_mangle]
-pub e// SAFETY: caller must verify the safety contract for this operation
-xtern "C" fn writew(val: u16, addr: *mut u8) {
+pub extern "C" fn writew(val: u16, addr: *mut u8) {
     if addr.is_null() {
         return;
     }
-    unsafe { ptr::write_volatile(addr // SAFETY: caller must verify the safety contract for this operation
-as *mut u16, val) };
+    unsafe { ptr::write_volatile(addr as *mut u16, val) };
 }
 
 #[no_mangle]
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/list.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/list.rs
index c33e3254b4..4b300f29f4 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/list.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/list.rs
@@ -11,7 +11,6 @@ pub extern "C" fn init_list_head(head: *mut ListHead) {
     if head.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         (*head).next = head;
         (*head).prev = head;
@@ -23,7 +22,6 @@ pub extern "C" fn list_add(new: *mut ListHead, head: *mut ListHead) {
     if new.is_null() || head.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
 
     unsafe {
         let next = (*head).next;
@@ -37,8 +35,7 @@ pub extern "C" fn list_add(new: *mut ListHead, head: *mut ListHead) {
 }
 
 #[no_mangle]
-pub extern "C" fn list_add_tail(new: *mut ListHead, head: *mut ListHe// SAFETY: caller must verify the safety contract for this operation
-ad) {
+pub extern "C" fn list_add_tail(new: *mut ListHead, head: *mut ListHead) {
     if new.is_null() || head.is_null() {
         return;
     }
@@ -49,8 +46,7 @@ ad) {
         (*new).prev = prev;
         (*head).prev = new;
         if !prev.is_null() {
-            (*prev).next// SAFETY: caller must verify the safety contract for this operation
- = new;
+            (*prev).next= new;
         }
     }
 }
@@ -82,7 +78,6 @@ pub extern "C" fn list_empty(head: *const ListHead) -> i32 {
     }
     if ptr::eq(unsafe { (*head).next } as *const ListHead, head) {
         1
- // SAFETY: caller must verify the safety contract for this operation
    } else {
         0
     }
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/mac80211.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/mac80211.rs
index ac40946db8..8bdd47b9d5 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/mac80211.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/mac80211.rs
@@ -223,7 +223,6 @@ pub extern "C" fn ieee80211_free_hw(hw: *mut Ieee80211Hw) {
     if let Ok(mut registry) = STA_REGISTRY.lock() {
         registry.retain(|_, entry| entry.hw != hw_key);
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         let hw_box = Box::from_raw(hw);
         if !hw_box.priv_data.is_null() {
@@ -250,7 +249,6 @@ pub extern "C" fn ieee80211_register_hw(hw: *mut Ieee80211Hw) -> i32 {
     if rc != 0 {
         return rc;
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe { &*hw }.registered.store(1, Ordering::Release);
     0
 }
@@ -260,8 +258,7 @@ pub extern "C" fn ieee80211_unregister_hw(hw: *mut Ieee80211Hw) {
     if hw.is_null() {
         return;
     }
-    if unsafe { &*hw }.registered.load(Ordering::Acquire) == 0 {// SAFETY: caller must verify the safety contract for this operation
-
+    if unsafe { &*hw }.registered.load(Ordering::Acquire) == 0 {
         return;
     }
     wiphy_unregister(unsafe { (*hw).wiphy });
@@ -361,8 +358,7 @@ pub extern "C" fn ieee80211_scan_completed(hw: *mut Ieee80211Hw, aborted: bool)
         n_ssids: 0,
         n_channels: 0,
     };
-    super::wireless::cfg80211_scan_done(&mut scan_request, &scan_// SAFETY: caller must verify the safety contract for this operation
-info);
+    super::wireless::cfg80211_scan_done(&mut scan_request, &scan_info);
 }
 
 #[no_mangle]
@@ -569,8 +565,7 @@ pub extern "C" fn ieee80211_tx_status(hw: *mut Ieee80211Hw, skb: *mut SkBuff) {
     }
 
     log::trace!(
-        "ieee80211_tx_status: hw={:#x} skb={:#x// SAFETY: caller must verify the safety contract for this operation
-}",
+        "ieee80211_tx_status: hw={:#x} skb={:#x}",
         hw_key,
         skb as usize
     );
@@ -608,7 +603,6 @@ pub extern "C" fn ieee80211_get_tid(skb: *const SkBuff) -> u8 {
 #[repr(C)]
 struct ChanDef {
     center_freq: u32,
-// SAFETY: caller must verify the safety contract for this operation
     band: u16,
     channel: *mut c_void,
 }
@@ -713,7 +707,6 @@ pub extern "C" fn ieee80211_find_sta(hw: *mut Ieee80211Hw, addr: *const u8) -> *
     for (sta_ptr, entry) in registry.iter() {
         if entry.hw != hw as usize || entry.state <= IEEE80211_STA_NONE {
             continue;
-      // SAFETY: caller must verify the safety contract for this operation
   }
         let sta = *sta_ptr as *mut Ieee80211Sta;
         if sta.is_null() {
@@ -913,7 +906,6 @@ mod tests {
         let hw = ieee80211_alloc_hw_nm(0, ptr::null(), ptr::null());
         assert!(!hw.is_null());
 
-    // SAFETY: caller must verify the safety contract for this operation
     RX_RECEIVED.store(0, Ordering::Release);
         ieee80211_register_rx_handler(hw, Some(test_rx_callback));
 
@@ -921,8 +913,7 @@ mod tests {
             0x88u8, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x06, 0x05, 0x04, 0x03,
             0x02, 0x01, 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00, 0x08, 0x06,
         ];
-        let skb = super::super::net::alloc// SAFETY: caller must verify the safety contract for this operation
-_skb(128, 0);
+        let skb = super::super::net::alloc_skb(128, 0);
         assert!(!skb.is_null());
         unsafe {
             ptr::copy_nonoverlapping(data.as_ptr(), (*skb).data, data.len());
@@ -939,8 +930,7 @@ _skb(128, 0);
             ptr::copy_nonoverlapping(data.as_ptr(), (*skb2).data, data.len());
             (*skb2).len = data.len() as u32;
         }
-        ieee80211_rx_irqsafe// SAFETY: caller must verify the safety contract for this operation
-(hw, skb2);
+        ieee80211_rx_irqsafe(hw, skb2);
         assert_eq!(ieee80211_rx_drain(hw), 1);
         assert_eq!(RX_RECEIVED.load(Ordering::Acquire), 1);
 
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/memory.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/memory.rs
index f308ec757c..9f1a6d2684 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/memory.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/memory.rs
@@ -86,7 +86,6 @@ fn dma32_alloc(size: usize) -> *mut u8 {
                     tracker.insert(SendU8Ptr(candidate), layout);
                     return candidate;
                 }
-// SAFETY: caller must verify the safety contract for this operation
                 unsafe { dealloc(candidate, layout) };
                 return ptr::null_mut();
             }
@@ -95,15 +94,13 @@ fn dma32_alloc(size: usize) -> *mut u8 {
                 "dma32_alloc: virt_to_phys failed for {:#x}",
                 candidate as usize
             );
-// SAFETY: caller must verify the safety contract for this operation
             unsafe { dealloc(candidate, layout) };
             continue;
         }
 
         if phys as u64 >= DMA32_LIMIT {
             log::debug!(
-                "dma32_alloc: attempt {} phys={:#x} >= 4GB, ret// SAFETY: caller must verify the safety contract for this operation
-rying",
+                "dma32_alloc: attempt {} phys={:#x} >= 4GB, retrying",
                 attempt,
                 phys
             );
@@ -116,7 +113,6 @@ rying",
             size,
             candidate as usize,
             phys
-     // SAFETY: caller must verify the safety contract for this operation
    );
 
         if let Ok(mut tracker) = DMA32_TRACKER.lock() {
@@ -163,8 +159,7 @@ pub extern "C" fn kmalloc(size: usize, flags: u32) -> *mut u8 {
     if ptr.is_null() {
         return ptr::null_mut();
     }
-    if let Ok(mut tracker) = ALLOC_TRACKER.lock// SAFETY: caller must verify the safety contract for this operation
-() {
+    if let Ok(mut tracker) = ALLOC_TRACKER.lock() {
         tracker.insert(SendU8Ptr(ptr), layout);
     }
     ptr
@@ -181,8 +176,7 @@ pub extern "C" fn kzalloc(size: usize, flags: u32) -> *mut u8 {
 
 #[no_mangle]
 pub extern "C" fn kfree(ptr: *const u8) {
-    if ptr.is_nu// SAFETY: caller must verify the safety contract for this operation
-ll() {
+    if ptr.is_null() {
         return;
     }
 
@@ -194,7 +188,6 @@ ll() {
         };
         if let Some(layout) = dma32_tracker.remove(&SendU8Ptr(ptr as *mut u8)) {
             unsafe { dealloc(ptr as *mut u8, layout) };
-// SAFETY: caller must verify the safety contract for this operation
             return;
         }
     }
@@ -246,12 +239,9 @@ pub extern "C" fn krealloc(ptr: *const u8, new_size: usize, flags: u32) -> *mut
         }
     };
 
-    let ol// SAFETY: caller must verify the safety contract for this operation
-d_size = old_layout.map(|l| l.size()).unwrap_or(0);
-    let ne// SAFETY: caller must verify the safety contract for this operation
-w_ptr = kmalloc(new_size, flags);
+    let old_size = old_layout.map(|l| l.size()).unwrap_or(0);
+    let new_ptr = kmalloc(new_size, flags);
     if new_ptr.is_null() {
-// SAFETY: caller must verify the safety contract for this operation
         if let Some(layout) = old_layout {
             if let Ok(mut tracker) = ALLOC_TRACKER.lock() {
                 tracker.insert(SendU8Ptr(mut_ptr), layout);
@@ -331,8 +321,7 @@ mod tests {
     fn test_kmalloc_dma32_multiple() {
         // Allocate and free multiple DMA32 buffers
         let p1 = kmalloc(128, GFP_DMA32);
-        let p2 = kmalloc(25// SAFETY: caller must verify the safety contract for this operation
-6, GFP_DMA32);
+        let p2 = kmalloc(256, GFP_DMA32);
         assert!(!p1.is_null());
         assert!(!p2.is_null());
         kfree(p1);
@@ -347,8 +336,7 @@ mod tests {
     }
 
     #[test]
-    fn test_krealloc_zero_size_f// SAFETY: caller must verify the safety contract for this operation
-rees_and_returns_null() {
+    fn test_krealloc_zero_size_frees_and_returns_null() {
         let p = kmalloc(64, GFP_KERNEL);
         assert!(!p.is_null());
         assert!(krealloc(p, 0, GFP_KERNEL).is_null());
@@ -359,8 +347,7 @@ rees_and_returns_null() {
         let p = kmalloc(8, GFP_KERNEL);
         assert!(!p.is_null());
         unsafe { ptr::write_bytes(p, 0xAB, 8) };
-        let q = krealloc(p, // SAFETY: caller must verify the safety contract for this operation
-64, GFP_KERNEL);
+        let q = krealloc(p, 64, GFP_KERNEL);
         assert!(!q.is_null());
         for i in 0..8 {
             assert_eq!(unsafe { *q.add(i) }, 0xAB);
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/net.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/net.rs
index 3c9393c6ed..3757e3900f 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/net.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/net.rs
@@ -125,7 +125,6 @@ pub extern "C" fn kfree_skb(skb: *mut SkBuff) {
     if skb.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         release_skb_buffer(skb);
         drop(Box::from_raw(skb));
@@ -240,7 +239,6 @@ pub extern "C" fn skb_queue_head_init(list: *mut SkBuffHead) {
     if list.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
 
     unsafe {
         (*list).next = ptr::null_mut();
@@ -251,8 +249,7 @@ pub extern "C" fn skb_queue_head_init(list: *mut SkBuffHead) {
 }
 
 #[no_mangle]
-pub extern "C" fn skb_queue_tail(list: *mut SkBuffHead, newsk: *mut SkBuff// SAFETY: caller must verify the safety contract for this operation
-) {
+pub extern "C" fn skb_queue_tail(list: *mut SkBuffHead, newsk: *mut SkBuff) {
     if list.is_null() || newsk.is_null() {
         return;
     }
@@ -274,8 +271,7 @@ pub extern "C" fn skb_queue_tail(list: *mut SkBuffHead, newsk: *mut SkBuff// SAF
 }
 
 #[no_mangle]
-pub extern "C" fn skb_dequ// SAFETY: caller must verify the safety contract for this operation
-eue(list: *mut SkBuffHead) -> *mut SkBuff {
+pub extern "C" fn skb_dequeue(list: *mut SkBuffHead) -> *mut SkBuff {
     if list.is_null() || unsafe { (*list).qlen } == 0 {
         return ptr::null_mut();
     }
@@ -310,14 +306,12 @@ pub extern "C" fn skb_queue_purge(list: *mut SkBuffHead) {
         if skb.is_null() {
             break;
         }
- // SAFETY: caller must verify the safety contract for this operation
        kfree_skb(skb);
     }
 }
 
 #[no_mangle]
-pub extern "C" fn skb_peek(list: *const SkBuffHead) -// SAFETY: caller must verify the safety contract for this operation
-> *mut SkBuff {
+pub extern "C" fn skb_peek(list: *const SkBuffHead) -> *mut SkBuff {
     if list.is_null() || unsafe { (*list).qlen } == 0 {
         ptr::null_mut()
     } else {
@@ -358,10 +352,8 @@ pub extern "C" fn skb_copy(src: *const SkBuff, gfp: u32) -> *mut SkBuff {
         return ptr::null_mut();
     }
 
-    let src_ref = unsafe { &*// SAFETY: caller must verify the safety contract for this operation
-src };
-    let dst = alloc_s// SAFETY: caller must verify the safety contract for this operation
-kb(src_ref.end, gfp);
+    let src_ref = unsafe { &*src };
+    let dst = alloc_skb(src_ref.end, gfp);
     if dst.is_null() {
         return ptr::null_mut();
     }
@@ -398,11 +390,9 @@ pub extern "C" fn skb_clone(skb: *const SkBuff, _gfp: u32) -> *mut SkBuff {
 
     unsafe { &*skb_ref.shared }
         .refcount
-  // SAFETY: caller must verify the safety contract for this operation
       .fetch_add(1, Ordering::AcqRel);
     Box::into_raw(Box::new(SkBuff {
-        head: skb_ref.h// SAFETY: caller must verify the safety contract for this operation
-ead,
+        head: skb_ref.head,
         data: skb_ref.data,
         len: skb_ref.len,
         tail: skb_ref.tail,
@@ -466,7 +456,6 @@ pub extern "C" fn alloc_netdev_mqs(
             if value == 0 {
                 break;
             }
-     // SAFETY: caller must verify the safety contract for this operation
    }
     }
 
@@ -491,22 +480,18 @@ pub extern "C" fn alloc_netdev_mqs(
     Box::into_raw(dev)
 }
 
-#[no// SAFETY: caller must verify the safety contract for this operation
-_mangle]
+#[no_mangle]
 pub extern "C" fn free_netdev(dev: *mut NetDevice) {
     if dev.is_null() {
         return;
     }
-    unsafe // SAFETY: caller must verify the safety contract for this operation
-{
+    unsafe {
         let dev_box = Box::from_raw(dev);
         if !dev_box.priv_data.is_null() {
             let layout = Layout::from_size_align(
-   // SAFETY: caller must verify the safety contract for this operation
              dev_box.priv_alloc_size.max(1),
                 dev_box.priv_alloc_align.max(1),
             )
- // SAFETY: caller must verify the safety contract for this operation
            .ok();
             if let Some(layout) = layout {
                 dealloc(dev_box.priv_data.cast::<u8>(), layout);
@@ -527,8 +512,7 @@ pub extern "C" fn register_netdev(dev: *mut NetDevice) -> i32 {
     0
 }
 
-#[no_// SAFETY: caller must verify the safety contract for this operation
-mangle]
+#[no_mangle]
 pub extern "C" fn unregister_netdev(dev: *mut NetDevice) {
     if dev.is_null() {
         return;
@@ -559,7 +543,6 @@ pub extern "C" fn netif_carrier_ok(dev: *const NetDevice) -> i32 {
         return 0;
     }
     if unsafe { &*dev }.carrier.load(Ordering::Acquire) != 0 {
-    // SAFETY: caller must verify the safety contract for this operation
     1
     } else {
         0
@@ -601,7 +584,6 @@ pub extern "C" fn napi_schedule(napi: *mut NapiStruct) {
             Ordering::Acquire,
         )
         .is_ok()
-// SAFETY: caller must verify the safety contract for this operation
     {
         if let Some(poll) = napi_ref.poll {
             let _ = poll(napi, napi_ref.weight);
@@ -609,8 +591,7 @@ pub extern "C" fn napi_schedule(napi: *mut NapiStruct) {
     }
 }
 
-#// SAFETY: caller must verify the safety contract for this operation
-[no_mangle]
+#[no_mangle]
 pub extern "C" fn napi_complete_done(napi: *mut NapiStruct, work_done: i32) -> i32 {
     if napi.is_null() || work_done < 0 {
         return 0;
@@ -673,8 +654,7 @@ mod tests {
     static SETUP_CALLS: AtomicUsize = AtomicUsize::new(0);
     static NAPI_POLLS: AtomicUsize = AtomicUsize::new(0);
 
-    extern "C" fn test_setup(_dev: *mut Net// SAFETY: caller must verify the safety contract for this operation
-Device) {
+    extern "C" fn test_setup(_dev: *mut NetDevice) {
         SETUP_CALLS.fetch_add(1, Ordering::AcqRel);
     }
 
@@ -746,14 +726,12 @@ Device) {
         assert_eq!(skb_queue_len(&queue), 1);
         kfree_skb(skb);
         skb_queue_purge(&mut queue);
-        assert_eq!(skb_queue_e// SAFETY: caller must verify the safety contract for this operation
-mpty(&queue), 1);
+        assert_eq!(skb_queue_empty(&queue), 1);
         kfree_skb(clone);
     }
 
     #[test]
-    fn net_device_carrier_track// SAFETY: caller must verify the safety contract for this operation
-ing_works() {
+    fn net_device_carrier_tracking_works() {
         let name = CString::new("wlan%d").expect("valid test CString");
         let dev = alloc_netdev_mqs(
             0usize,
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/pci.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/pci.rs
index 0fd77aa400..79a0bcaacd 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/pci.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/pci.rs
@@ -282,7 +282,6 @@ fn replace_current_device(location: PciLocation, dev_ptr: *mut PciDev) {
             ptr: dev_ptr as usize,
         }) {
             clear_irq_vectors_for_ptr(previous.ptr);
-// SAFETY: caller must verify the safety contract for this operation
             unsafe { drop(Box::from_raw(previous.ptr as *mut PciDev)) };
         }
     }
@@ -292,7 +291,6 @@ fn clear_current_device() {
     if let Ok(mut state) = CURRENT_DEVICE.lock() {
         if let Some(previous) = state.take() {
             clear_irq_vectors_for_ptr(previous.ptr);
-// SAFETY: caller must verify the safety contract for this operation
             unsafe { drop(Box::from_raw(previous.ptr as *mut PciDev)) };
         }
     }
@@ -481,21 +479,17 @@ pub extern "C" fn pci_enable_device(dev: *mut PciDev) -> i32 {
 
         if let Err(error) = pci.enable_device() {
             log::warn!(
-    // SAFETY: caller must verify the safety contract for this operation
             "pci_enable_device: failed to enable {:04x}:{:04x}: {}",
                 unsafe { (*dev).vendor },
                 unsafe { (*dev).device },
-                err// SAFETY: caller must verify the safety contract for this operation
-or
-  // SAFETY: caller must verify the safety contract for this operation
+                error
           );
             return -EIO;
         }
     }
 
     log::info!(
-        "pci_enable_device: vendor=0x{:04x} device=0x{:04x}"// SAFETY: caller must verify the safety contract for this operation
-,
+        "pci_enable_device: vendor=0x{:04x} device=0x{:04x}",
         unsafe { (*dev).vendor },
         unsafe { (*dev).device }
     );
@@ -505,8 +499,7 @@ or
 
 #[no_mangle]
 pub extern "C" fn pci_disable_device(dev: *mut PciDev) {
-    if dev.// SAFETY: caller must verify the safety contract for this operation
-is_null() {
+    if dev.is_null() {
         return;
     }
     log::info!("pci_disable_device");
@@ -531,8 +524,7 @@ pub extern "C" fn pci_iomap(dev: *mut PciDev, bar: u32, max_len: usize) -> *mut
 }
 
 #[no_mangle]
-pub extern "C" fn pci_iounmap(_dev: *mut PciDev, addr: *mut u8, size: usi// SAFETY: caller must verify the safety contract for this operation
-ze) {
+pub extern "C" fn pci_iounmap(_dev: *mut PciDev, addr: *mut u8, size: usize) {
     super::io::iounmap(addr, size);
 }
 
@@ -720,8 +712,7 @@ fn pcie_cap_reg(dev: *mut PciDev, pos: u32, align: u32) -> Result<u32, i32> {
         return Err(-EINVAL);
     }
     let cap = find_capability_offset(dev, PCI_CAP_ID_EXP)?;
-    Ok(cap +// SAFETY: caller must verify the safety contract for this operation
- pos)
+    Ok(cap + pos)
 }
 
 #[no_mangle]
@@ -864,11 +855,9 @@ pub extern "C" fn pci_restore_state(dev: *mut PciDev) -> i32 {
         }
     }
     // Restore the command register (low word of dword 1) without
-    // writing the status register // SAFETY: caller must verify the safety contract for this operation
-(high word) — status bits are
+    // writing the status register (high word) — status bits are
     // write-1-to-clear and must not be toggled by a restore.
-    match pci.read_config_dwo// SAFETY: caller must verify the safety contract for this operation
-rd(0x04) {
+    match pci.read_config_dword(0x04) {
         Ok(current) => {
             let updated = (current & 0xFFFF_0000) | (buf[1] & 0xFFFF);
             match pci.write_config_dword(0x04, updated) {
@@ -961,8 +950,7 @@ pub extern "C" fn pci_irq_vector(dev: *mut PciDev, vector_idx: i32) -> i32 {
     let Some(allocated) = vectors.get(&(dev as usize)) else {
         return -EINVAL;
     };
-    alloc// SAFETY: caller must verify the safety contract for this operation
-ated
+    allocated
         .vectors
         .get(vector_idx as usize)
         .copied()
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/sync.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/sync.rs
index f5c43dfda3..aac51ff282 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/sync.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/sync.rs
@@ -15,7 +15,6 @@ pub extern "C" fn mutex_init(m: *mut LinuxMutex) {
     if m.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         (*m).state = AtomicU8::new(UNLOCKED);
     }
@@ -56,13 +55,11 @@ pub extern "C" fn mutex_unlock(m: *mut LinuxMutex) {
     if m.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe { &*m }.state.store(UNLOCKED, Ordering::Release);
 }
 
 #[no_mangle]
-pub extern "C" fn mutex_is_locked(m: *mut Li// SAFETY: caller must verify the safety contract for this operation
-nuxMutex) -> bool {
+pub extern "C" fn mutex_is_locked(m: *mut LinuxMutex) -> bool {
     if m.is_null() {
         return false;
     }
@@ -72,7 +69,6 @@ nuxMutex) -> bool {
 #[repr(C)]
 #[derive(Default)]
 pub struct Spinlock {
-  // SAFETY: caller must verify the safety contract for this operation
   locked: AtomicU8,
 }
 
@@ -94,8 +90,7 @@ pub extern "C" fn spin_lock(lock: *mut Spinlock) {
     while unsafe {
         (*lock)
             .locked
-            .compare_exchange(0, 1, Ordering::// SAFETY: caller must verify the safety contract for this operation
-Acquire, Ordering::Relaxed)
+            .compare_exchange(0, 1, Ordering::Acquire, Ordering::Relaxed)
     }
     .is_err()
     {
@@ -113,8 +108,7 @@ pub extern "C" fn spin_unlock(lock: *mut Spinlock) {
     }
 }
 
-static IRQ_DEPTH: s// SAFETY: caller must verify the safety contract for this operation
-td::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
+static IRQ_DEPTH: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0);
 
 #[no_mangle]
 pub extern "C" fn spin_lock_irqsave(lock: *mut Spinlock, flags: *mut u64) -> u64 {
@@ -123,7 +117,6 @@ pub extern "C" fn spin_lock_irqsave(lock: *mut Spinlock, flags: *mut u64) -> u64
     if !flags.is_null() {
         unsafe { *flags = prev_depth as u64 };
     }
-    // SAFETY: caller must verify the safety contract for this operation
 prev_depth as u64
 }
 
@@ -153,8 +146,7 @@ pub extern "C" fn local_irq_disable() {
 
 #[no_mangle]
 pub extern "C" fn local_irq_enable() {
-    let _ = IRQ_DEPTH.fetch_update(Ordering::AcqRel, Ordering::Relaxed// SAFETY: caller must verify the safety contract for this operation
-, |depth| {
+    let _ = IRQ_DEPTH.fetch_update(Ordering::AcqRel, Ordering::Relaxed, |depth| {
         Some(depth.saturating_sub(1))
     });
 }
@@ -167,7 +159,6 @@ pub extern "C" fn irqs_disabled() -> bool {
 #[repr(C)]
 pub struct Completion {
     done: AtomicU8,
- // SAFETY: caller must verify the safety contract for this operation
    _padding: [u8; 63],
 }
 
@@ -177,7 +168,6 @@ pub struct AtomicT {
 }
 
 #[no_mangle]
-// SAFETY: caller must verify the safety contract for this operation
 pub extern "C" fn init_completion(c: *mut Completion) {
     if c.is_null() {
         return;
@@ -220,28 +210,23 @@ pub extern "C" fn wait_for_completion(c: *mut Completion) {
 }
 
 #[no_mangle]
-pub extern "C" fn wait_for_completion_timeout(c: *mut Completion// SAFETY: caller must verify the safety contract for this operation
-, timeout_ms: u64) -> i32 {
+pub extern "C" fn wait_for_completion_timeout(c: *mut Completion, timeout_ms: u64) -> i32 {
     if c.is_null() {
         return 0;
     }
 
-    if unsafe { &*c }.don// SAFETY: caller must verify the safety contract for this operation
-e.load(Ordering::Acquire) != 0 {
+    if unsafe { &*c }.done.load(Ordering::Acquire) != 0 {
         return 1;
     }
 
     let deadline = Instant::now()
-        .ch// SAFETY: caller must verify the safety contract for this operation
-ecked_add(Duration::from_millis(timeout_ms))
+        .checked_add(Duration::from_millis(timeout_ms))
         .unwrap_or_else(Instant::now);
 
-    loop // SAFETY: caller must verify the safety contract for this operation
-{
+    loop {
         if unsafe { &*c }.done.load(Ordering::Acquire) != 0 {
             return 1;
         }
-       // SAFETY: caller must verify the safety contract for this operation
  if Instant::now() >= deadline {
             return 0;
         }
@@ -278,22 +263,19 @@ pub extern "C" fn atomic_add(i: i32, v: *mut AtomicT) {
     if v.is_null() {
         return;
     }
-    unsafe { &*v }.value.fetch_add// SAFETY: caller must verify the safety contract for this operation
-(i, Ordering::SeqCst);
+    unsafe { &*v }.value.fetch_add(i, Ordering::SeqCst);
 }
 
 #[no_mangle]
 pub extern "C" fn atomic_sub(i: i32, v: *mut AtomicT) {
     if v.is_null() {
-      // SAFETY: caller must verify the safety contract for this operation
   return;
     }
     unsafe { &*v }.value.fetch_sub(i, Ordering::SeqCst);
 }
 
 #[no_mangle]
-pub extern "C" fn atomic_inc(// SAFETY: caller must verify the safety contract for this operation
-v: *mut AtomicT) {
+pub extern "C" fn atomic_inc(v: *mut AtomicT) {
     atomic_add(1, v);
 }
 
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/timer.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/timer.rs
index 66a878e9a7..2b05a460e8 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/timer.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/timer.rs
@@ -125,7 +125,6 @@ pub extern "C" fn setup_timer(
     }
 
     let function_ptr = function as usize as *mut ();
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         ptr::write(
             timer,
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/wait.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/wait.rs
index 6a6f339c6f..889b738c63 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/wait.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/wait.rs
@@ -138,7 +138,6 @@ pub extern "C" fn init_waitqueue_head(wq: *mut WaitQueueHead) {
     if wq.is_null() {
         return;
     }
-// SAFETY: caller must verify the safety contract for this operation
 
     unsafe {
         ptr::write(
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/wireless.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/wireless.rs
index af47f8d8ff..40d8e8b941 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/wireless.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/wireless.rs
@@ -177,7 +177,6 @@ pub extern "C" fn wiphy_free(wiphy: *mut Wiphy) {
     if let Ok(mut bands_map) = WIPY_BANDS_MAP.lock() {
         bands_map.remove(&wiphy_key);
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe {
         let wiphy_box = Box::from_raw(wiphy);
         if !wiphy_box.priv_data.is_null() {
@@ -199,14 +198,12 @@ pub extern "C" fn wiphy_register(wiphy: *mut Wiphy) -> i32 {
     if unsafe { &*wiphy }.registered.load(Ordering::Acquire) != 0 {
         return -16;
     }
-// SAFETY: caller must verify the safety contract for this operation
     unsafe { &*wiphy }.registered.store(1, Ordering::Release);
     0
 }
 
 #[no_mangle]
-pub extern "C" fn wiphy_unregister// SAFETY: caller must verify the safety contract for this operation
-(wiphy: *mut Wiphy) {
+pub extern "C" fn wiphy_unregister(wiphy: *mut Wiphy) {
     if wiphy.is_null() {
         return;
     }
@@ -218,7 +215,6 @@ pub extern "C" fn cfg80211_scan_done(
     request: *mut Cfg80211ScanRequest,
     info: *const Cfg80211ScanInfo,
 ) {
- // SAFETY: caller must verify the safety contract for this operation
    if request.is_null() {
         return;
     }
@@ -233,7 +229,6 @@ pub extern "C" fn cfg80211_scan_done(
         (*wdev).scan_aborted = if info.is_null() {
             false
         } else {
-       // SAFETY: caller must verify the safety contract for this operation
      (*info).aborted
         };
     }
@@ -241,8 +236,7 @@ pub extern "C" fn cfg80211_scan_done(
 
 fn netdev_to_wireless_dev(dev: *mut c_void) -> *mut WirelessDev {
     if dev.is_null() {
-        return ptr::null_mut()// SAFETY: caller must verify the safety contract for this operation
-;
+        return ptr::null_mut();
     }
     let dev = dev.cast::<NetDevice>();
     unsafe { (*dev).ieee80211_ptr.cast::<WirelessDev>() }
@@ -258,8 +252,7 @@ fn copy_bssid(dst: &mut WirelessDev, bssid: *const u8) {
     unsafe {
         ptr::copy_nonoverlapping(bssid, dst.last_bssid.as_mut_ptr(), dst.last_bssid.len());
     }
-    dst.// SAFETY: caller must verify the safety contract for this operation
-has_bssid = true;
+    dst.has_bssid = true;
 }
 
 #[no_mangle]
@@ -284,8 +277,7 @@ pub extern "C" fn cfg80211_connect_result(
         wdev_ref.connected = status == 0;
         wdev_ref.last_status = status;
         wdev_ref.locally_generated = false;
-        copy_bssid(wdev_re// SAFETY: caller must verify the safety contract for this operation
-f, bssid);
+        copy_bssid(wdev_ref, bssid);
     }
 
     if status == 0 {
@@ -335,7 +327,6 @@ pub extern "C" fn cfg80211_connect_bss(
         dev,
         bssid,
         req_ie,
-// SAFETY: caller must verify the safety contract for this operation
         req_ie_len,
         resp_ie,
         resp_ie_len,
@@ -462,8 +453,7 @@ pub struct Cfg80211Bss {
     pub channel: *mut Ieee80211Channel,
     pub signal: i16,
     pub capability: u16,
-    pub beacon_int// SAFETY: caller must verify the safety contract for this operation
-erval: u16,
+    pub beacon_interval: u16,
     pub ies: *const u8,
     pub ies_len: usize,
     wiphy: usize,
@@ -481,7 +471,6 @@ pub extern "C" fn cfg80211_inform_bss(
     capability: u16,
     beacon_interval: u16,
     ies: *const u8,
-// SAFETY: caller must verify the safety contract for this operation
     ies_len: usize,
     signal: i32,
     _gfp: u32,
@@ -570,8 +559,7 @@ pub extern "C" fn cfg80211_put_bss(bss: *mut Cfg80211Bss) {
     registry.retain(|entry| entry.as_ref() as *const Cfg80211Bss as usize != bss_addr);
     let removed = before != registry.len();
     if removed {
-        if let Ok(// SAFETY: caller must verify the safety contract for this operation
-mut ies_map) = BSS_IES.lock() {
+        if let Ok(mut ies_map) = BSS_IES.lock() {
             ies_map.remove(&bss_addr);
         }
     }
@@ -600,8 +588,7 @@ pub extern "C" fn cfg80211_get_bss(
         return ptr::null_mut();
     };
 
-    let want_bssid = if bssid.i// SAFETY: caller must verify the safety contract for this operation
-s_null() {
+    let want_bssid = if bssid.is_null() {
         None
     } else {
         let mut bytes = [0u8; 6];
@@ -640,8 +627,7 @@ s_null() {
                         break;
                     }
                     if tag_id == 0 && tag_len == ws.len() {
-                        if &ies_// SAFETY: caller must verify the safety contract for this operation
-slice[offset + 2..offset + 2 + tag_len] == ws.as_slice() {
+                        if &ies_slice[offset + 2..offset + 2 + tag_len] == ws.as_slice() {
                             found = true;
                             break;
                         }
@@ -654,7 +640,6 @@ slice[offset + 2..offset + 2 + tag_len] == ws.as_slice() {
             }
         }
         return entry.as_ref() as *const Cfg80211Bss as *mut Cfg80211Bss;
-    // SAFETY: caller must verify the safety contract for this operation
 }
 
     ptr::null_mut()
@@ -687,7 +672,6 @@ pub extern "C" fn cfg80211_new_sta(
 pub extern "C" fn cfg80211_rx_mgmt(
     wdev: *mut WirelessDev,
     freq: u32,
-    // SAFETY: caller must verify the safety contract for this operation
 sig_dbm: i32,
     buf: *const u8,
     len: usize,
@@ -807,8 +791,7 @@ mod tests {
         let wiphy = wiphy_new_nm(ptr::null(), 0, ptr::null());
         assert!(!wiphy.is_null());
         assert_eq!(wiphy_register(wiphy), 0);
-        assert_eq!(wi// SAFETY: caller must verify the safety contract for this operation
-phy_register(wiphy), -16);
+        assert_eq!(wiphy_register(wiphy), -16);
         assert_eq!(unsafe { (*wiphy).registered.load(Ordering::Acquire) }, 1);
         wiphy_unregister(wiphy);
         assert_eq!(unsafe { (*wiphy).registered.load(Ordering::Acquire) }, 0);
@@ -896,8 +879,7 @@ phy_register(wiphy), -16);
 
         assert_eq!(channel.band, NL80211_BAND_5GHZ);
         assert_eq!(channel.center_freq, 5180);
-        assert// SAFETY: caller must verify the safety contract for this operation
-_eq!(channel.hw_value, 36);
+        assert_eq!(channel.hw_value, 36);
         assert_ne!(channel.flags & IEEE80211_CHAN_NO_IR, 0);
         assert_ne!(channel.flags & IEEE80211_CHAN_RADAR, 0);
         assert_ne!(channel.flags & IEEE80211_CHAN_NO_80MHZ, 0);
@@ -946,8 +928,7 @@ _eq!(channel.hw_value, 36);
         assert_eq!(wdev_state.mgmt_rx_data, sta.to_vec());
         assert_eq!(wdev_state.mgmt_tx_cookie, 99);
         assert!(wdev_state.mgmt_tx_ack);
-        assert_eq!(wdev_s// SAFETY: caller must verify the safety contract for this operation
-tate.mgmt_tx_data, sta.to_vec());
+        assert_eq!(wdev_state.mgmt_tx_data, sta.to_vec());
         drop(events);
 
         assert_eq!(ieee80211_channel_to_frequency(1, NL80211_BAND_2GHZ), 2412);
diff --git a/local/recipes/drivers/linux-kpi/source/src/rust_impl/workqueue.rs b/local/recipes/drivers/linux-kpi/source/src/rust_impl/workqueue.rs
index 6784e4a451..4eb5c609c7 100644
--- a/local/recipes/drivers/linux-kpi/source/src/rust_impl/workqueue.rs
+++ b/local/recipes/drivers/linux-kpi/source/src/rust_impl/workqueue.rs
@@ -124,7 +124,6 @@ pub extern "C" fn alloc_workqueue(
     let name_str = if name.is_null() {
         String::from("unknown")
     } else {
-// SAFETY: caller must verify the safety contract for this operation
         unsafe {
             let mut len = 0;
             while *name.add(len) != 0 {