drm/asahi: Hook up crashdump to devcoredump

Signed-off-by: Asahi Lina <lina@asahilina.net>

Author: hoshinolina

drivers/gpu/drm/asahi/Kconfig

@@ -25,6 +25,7 @@ config DRM_ASAHI
 	select RUST_DRM_GEM_SHMEM_HELPER
 	select RUST_DRM_GPUVM
 	select RUST_APPLE_RTKIT
+	select WANT_DEV_COREDUMP
 	help
 	  DRM driver for Apple AGX GPUs (G13x, found in the M1 SoC family)
 

drivers/gpu/drm/asahi/asahi.rs

@@ -6,6 +6,7 @@
 mod alloc;
 mod buffer;
 mod channel;
+#[cfg(CONFIG_DEV_COREDUMP)]
 mod crashdump;
 mod debug;
 mod driver;

drivers/gpu/drm/asahi/crashdump.rs

@@ -7,12 +7,18 @@
 
 use core::mem::size_of;
 
-use kernel::{error::Result, page::Page, prelude::*, types::Owned};
+use kernel::{
+    devcoredump::DevCoreDump,
+    error::Result,
+    page::{Page, PAGE_MASK, PAGE_SHIFT, PAGE_SIZE},
+    prelude::*,
+    types::Owned,
+    uapi,
+};
 
 use crate::hw;
 use crate::pgtable::{self, DumpedPage, Prot, UAT_PGSZ};
 use crate::util::align;
-use kernel::uapi;
 
 pub(crate) struct CrashDump {
     headers: KVVec<u8>,
@@ -261,3 +267,39 @@ impl CrashDumpBuilder {
         Ok(CrashDump { headers, pages })
     }
 }
+
+impl DevCoreDump for CrashDump {
+    fn read(&self, buf: &mut [u8], mut offset: usize) -> Result<usize> {
+        let mut read = 0;
+        let mut left = buf.len();
+        if offset < self.headers.len() {
+            let block = left.min(self.headers.len() - offset);
+            buf[..block].copy_from_slice(&self.headers[offset..offset + block]);
+            read += block;
+            offset += block;
+            left -= block;
+        }
+        if left == 0 {
+            return Ok(read);
+        }
+        offset -= self.headers.len(); // Offset from the page area
+
+        while left > 0 {
+            let page_index = offset >> PAGE_SHIFT;
+            let page_offset = offset & !PAGE_MASK;
+            let block = left.min(PAGE_SIZE - page_offset);
+            let Some(page) = self.pages.get(page_index) else {
+                break;
+            };
+            let slice = &mut buf[read..read + block];
+            // SAFETY: We own the page, and the slice guarantees the
+            // dst length is sufficient.
+            unsafe { page.read_raw(slice.as_mut_ptr(), page_offset, slice.len())? };
+            read += block;
+            offset += block;
+            left -= block;
+        }
+
+        Ok(read)
+    }
+}

drivers/gpu/drm/asahi/gpu.rs

@@ -17,7 +17,7 @@ use core::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use core::time::Duration;
 
 use kernel::{
-    c_str,
+    c_str, devcoredump,
     error::code::*,
     macros::versions,
     prelude::*,
@@ -26,7 +26,7 @@ use kernel::{
         lock::{mutex::MutexBackend, Guard},
         Arc, Mutex, UniqueArc,
     },
-    time::{clock, Now},
+    time::{clock, msecs_to_jiffies, Now},
     types::ForeignOwnable,
 };
 
@@ -36,8 +36,7 @@ use crate::driver::{AsahiDevRef, AsahiDevice, AsahiDriver};
 use crate::fw::channels::{ChannelErrorType, PipeType};
 use crate::fw::types::{U32, U64};
 use crate::{
-    alloc, buffer, channel, crashdump, event, fw, gem, hw, initdata, mem, mmu, queue, regs,
-    workqueue,
+    alloc, buffer, channel, event, fw, gem, hw, initdata, mem, mmu, queue, regs, workqueue,
 };
 
 const DEBUG_CLASS: DebugFlags = DebugFlags::Gpu;
@@ -336,8 +335,9 @@ impl rtkit::Operations for GpuManager::ver {
 
         data.crashed.store(true, Ordering::Relaxed);
 
+        #[cfg(CONFIG_DEV_COREDUMP)]
         if let Err(e) = data.generate_crashdump(crashlog) {
-            dev_err!(dev.as_ref(), "Could not dump kernel VM pages: {:?}\n", e);
+            dev_err!(dev.as_ref(), "Could not generate crashdump: {:?}\n", e);
         }
 
         if debug_enabled(DebugFlags::OopsOnGpuCrash) {
@@ -1123,19 +1123,28 @@ impl GpuManager::ver {
         Ok(())
     }
 
+    #[cfg(CONFIG_DEV_COREDUMP)]
     fn generate_crashdump(&self, crashlog: Option<&[u8]>) -> Result {
         // Lock the allocators, to block kernel/FW memory mutations (mostly)
         let kalloc = self.alloc();
         let pages = self.uat.dump_kernel_pages()?;
         core::mem::drop(kalloc);
 
-        let mut crashdump = crashdump::CrashDumpBuilder::new(pages)?;
+        let mut crashdump = crate::crashdump::CrashDumpBuilder::new(pages)?;
         let initdata_addr = self.initdata.gpu_va().get();
         crashdump.add_agx_info(self.cfg, &self.dyncfg, initdata_addr)?;
         if let Some(crashlog) = crashlog {
             crashdump.add_crashlog(crashlog)?;
         }
-        let crashdump = crashdump.finalize();
+        let crashdump = KBox::new(crashdump.finalize()?, GFP_KERNEL)?;
+
+        devcoredump::dev_coredump(
+            self.dev.as_ref(),
+            &crate::THIS_MODULE,
+            crashdump,
+            GFP_KERNEL,
+            msecs_to_jiffies(60 * 60 * 1000),
+        );
 
         Ok(())
     }