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,22 +7,28 @@
 
 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>,
     pages: KVVec<Owned<Page>>,
 }
 
-const NOTE_NAME_AGX: &str = &"AGX";
+const NOTE_NAME_AGX: &str = "AGX";
 const NOTE_AGX_DUMP_INFO: u32 = 1;
 
-const NOTE_NAME_RTKIT: &str = &"RTKIT";
+const NOTE_NAME_RTKIT: &str = "RTKIT";
 const NOTE_RTKIT_CRASHLOG: u32 = 1;
 
 #[repr(C)]
@@ -47,8 +53,12 @@ pub(crate) struct CrashDumpBuilder {
     notes: KVec<ELFNote>,
 }
 
-// Helper to convert ELF headers into byte slices
-// TODO: Hook this up into kernel::AsBytes somehow
+/// Helper to convert ELF headers into byte slices
+/// TODO: Hook this up into kernel::AsBytes somehow
+///
+/// # Safety
+///
+/// Types implementing this trait must have no padding bytes.
 unsafe trait AsBytes: Sized {
     fn as_bytes(&self) -> &[u8] {
         // SAFETY: This trait is only implemented for types with no padding bytes
@@ -57,10 +67,7 @@ unsafe trait AsBytes: Sized {
     fn slice_as_bytes(slice: &[Self]) -> &[u8] {
         // SAFETY: This trait is only implemented for types with no padding bytes
         unsafe {
-            core::slice::from_raw_parts(
-                slice.as_ptr() as *const u8,
-                slice.len() * size_of::<Self>(),
-            )
+            core::slice::from_raw_parts(slice.as_ptr() as *const u8, core::mem::size_of_val(slice))
         }
     }
 }
@@ -118,7 +125,7 @@ impl CrashDumpBuilder {
 
     pub(crate) fn add_crashlog(&mut self, crashlog: &[u8]) -> Result {
         let mut data = KVVec::new();
-        data.extend_from_slice(&crashlog, GFP_KERNEL)?;
+        data.extend_from_slice(crashlog, GFP_KERNEL)?;
 
         self.notes.push(
             ELFNote {
@@ -143,7 +150,7 @@ impl CrashDumpBuilder {
         ehdr.e_ident[uapi::EI_VERSION as usize] = uapi::EV_CURRENT as u8;
         ehdr.e_type = uapi::ET_CORE as u16;
         ehdr.e_machine = uapi::EM_AARCH64 as u16;
-        ehdr.e_version = uapi::EV_CURRENT as u32;
+        ehdr.e_version = uapi::EV_CURRENT;
         ehdr.e_entry = FIRMWARE_ENTRYPOINT;
         ehdr.e_ehsize = core::mem::size_of::<uapi::Elf64_Ehdr>() as u16;
         ehdr.e_phentsize = core::mem::size_of::<uapi::Elf64_Phdr>() as u16;
@@ -188,7 +195,6 @@ impl CrashDumpBuilder {
                         p_memsz: UAT_PGSZ as u64,
                         p_flags: flags,
                         p_align: UAT_PGSZ as u64,
-                        ..Default::default()
                     },
                     GFP_KERNEL,
                 )?;
@@ -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

@@ -16,7 +16,7 @@ use core::ops::Range;
 use core::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 
 use kernel::{
-    c_str,
+    c_str, devcoredump,
     error::code::*,
     macros::versions,
     new_mutex,
@@ -36,8 +36,7 @@ use crate::driver::{AsahiDevRef, AsahiDevice};
 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) {
@@ -1118,19 +1118,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(())
     }