From nobody Mon Sep 28 23:55:42 2026 Received: from mail-lf1-f48.google.com (mail-lf1-f48.google.com [209.85.167.48]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AC1DC2DB7BF for ; Sat, 15 Aug 2026 05:08:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786770514; cv=none; b=ZztAl6/TdaKsIDRwwXSrZvGQgrvxaohHVS26KZcYHhk7qViVv5MaDUNbUWkWa/T5OantPSCwmtKLjaFOAmh3/h8IBGF1DEDwxMPmU7AIs7O4GX8LjOL+1y7Ayp0TW3vnGuAIgjl5vU2rwEb3+HgZMckhfzIpOm3q6Iqe29wgYaA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786770514; c=relaxed/simple; bh=x/hwKM8ZjjTyX8V3Z5jrI8tGMrC3skshKBk+D9MC3fk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=oBuiSNdOuMwdE1vDqXZ4+Yja/vlw1QOGSdVKJXoc3JL1uWm3lA1NetNnkV5R9IM5LSoCAYsAFIRP/60/YbqUDq8t5vsuNRQvGaIdNaxruvJiz6YgeQk6du0zl392Idbe6Ew8D7lmM8N93oq0B52OikhGVxW/AWYEYJ9lD4bEOzM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=cq82jSWu; arc=none smtp.client-ip=209.85.167.48 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="cq82jSWu" Received: by mail-lf1-f48.google.com with SMTP id 2adb3069b0e04-5b0231a3e86so1568019e87.0 for ; Fri, 14 Aug 2026 22:08:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1786770511; x=1787375311; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=Rh9k5ls4P7h2XTEAea6XCmlOeGaVyD2hBG03bRb/WIs=; b=cq82jSWukFtIZR8zx3sN73h30AaA7xsVrUscOIk2a/KTCwpGBIX7g9c7uGHumPxK6+ BRystKB3QSgw5jRNbjuzZMcoAoHzppxNW5xDze9hbqXiqG+UAia9nYtMuPhFXkacxIYH uSzDkBTAfMkz/C25mscymUiiq/b7Txgmn3QbTQmGFQKzMVErRsxXYVo1NL98AF4PY/s+ Dh8uMPA6dfRjN2YQn25xQY1rV9976IdGMELIArLWvLzDv1bA+kLlQ6xL+qzz2KkM84yM GDG1qRCv8uymXuFa8VCjv36SSzCHwLQ5l29CviA9LITIMfiiqEauYDgkP0TgecpxJlJ5 SPSw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786770511; x=1787375311; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=Rh9k5ls4P7h2XTEAea6XCmlOeGaVyD2hBG03bRb/WIs=; b=P5AIgXOeJzflIa9PE8jIaa+O3FJkvGBOl7pUftrQKVv9Aq/Q6tgO3EFZMd7ub5e0Du u+zPJXi6EoujmMB/dGqimxpicGp5MBTWNVSnelkVl3EqSIyl5FrVIH9qvwvWpaI2w6RN MuuTvczYEiFGOugNB8Cs5sVSMwaWTBSRD44SFtAH4XkvX7cWVAilubWQxYYjWQ84WgsD baJumI/4gIWtVJWN2ED607J9fs/NDrjBJJyAgg/W9Y2DlQ2DDrh46MpZPOlaFtytmrBP K1cTY5KC+DYT6SSAc9JvepEG/7luhbLUhKurfF0dA2y5WQ7fABgs/FjicsVUU++DVGYq vnaA== X-Forwarded-Encrypted: i=1; AHgh+RpFji/pOCSj+KStM+JbwLQxQK2zQa+3vL1kYa3dQvaCm9Cik41Qel1KAooaj7hVGxAXtVTUpwRe8hAKids=@vger.kernel.org X-Gm-Message-State: AOJu0YxQlDYMfUKQKtbNmgKE7ftMcXMhREe/abNULhuvsAfpUhQyAW2h 0byaMXg5B8rE5Gxvx7B9BgBd3IiFtCZQM7Z/bSxuBsU8/hjIrpVWB1cu X-Gm-Gg: AR+sD12srzwyCw7ha9lrkHgehk1HrN+3u9o17TLgO/s/uwhoDOB+dmeBddO9HyhU1WL GFyg0enVS/jL8r/j0G5pOMAt3Ah3mwA5G3EQgyVGiD4KWVOoRfduxadCeMiBevWENQsDekVRTbS M6F5tpAA0cNk7XUAv4iwa9xHfADKTZzSx3QbC6T2Nm9lrOJ6Z+Ygswg+s4p7Ot/3ZIhCx3lq70X /76gwVUmMjtG3+8W43JVn6JfXosOJhngkfXC/a3jHLbBIukYTw19SwBFok9G/pOXtcUxqx0OOWr 8qW9eUKtyrAmSAWelM7+EasSnOU66u7I4uLpxxegFOX5p8W2t2Pkj/1PelMHGOs1eXB8edrB/mt AUHX6aQ5odbrfMt5OKwr1kXdNG0UXrKv3M2ZVEKRO7gYvTh1P7o4kCu3FpUoaKHrt++NAr3+/zq lbsiIysELarzxiTQIKotFb79R3aBgMoLjnPXS71+8MwrYvO0/5YbsGnUFWfAFrHalDe9I= X-Received: by 2002:a05:6512:1151:b0:5b0:1df9:2ae5 with SMTP id 2adb3069b0e04-5b45910e5aamr1653610e87.14.1786770510343; Fri, 14 Aug 2026 22:08:30 -0700 (PDT) Received: from localhost ([95.190.110.153]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5b458b9a9a7sm932354e87.13.2026.08.14.22.08.29 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Aug 2026 22:08:30 -0700 (PDT) From: Vladislav Zaharov To: dakr@kernel.org, jhubbard@nvidia.com Cc: acourbot@nvidia.com, aliceryhl@google.com, ttabi@nvidia.com, gary@garyguo.net, nova-gpu@lists.linux.dev, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Vladislav Zaharov Subject: [PATCH v2 1/2] gpu: nova-core: gsp: retain the GSP-RM log buffers after unbind Date: Sat, 15 Aug 2026 12:08:25 +0700 Message-ID: <20260815050826.306717-2-vladazaharova2018@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260815050826.306717-1-vladazaharova2018@gmail.com> References: <20260815050826.306717-1-vladazaharova2018@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The GSP-RM log buffers are exposed through debugfs, but the Scope that owns them lives in Gsp, inside GspResources, inside the Gpu built by probe(). They are DMA allocations of the device and cannot outlive it, so the entries go away as soon as the GPU is unbound - and, more to the point, as soon as probe() fails, which is exactly when the log of a GSP that did not come up is the thing one wants to read. Add a gsp_keep_logs module parameter. When it is set, dropping the log buffers copies whatever the GSP wrote into memory owned by the module and exposes the copies until the module is unloaded. A buffer whose "put" pointer is still zero was never written to and is skipped. The copies live in a "retained" directory, created during module init rather than on first use, which keeps the teardown path from having to reach for DEBUGFS_ROOT. Keeping them out of the directory used by bound GPUs also means a device coming back does not find its debugfs name taken by its own history; nouveau, which recreates the entries under the name of the GPU that just went away, has that problem. The parameter is a u8 taking 0 or 1 rather than a bool, as the module parameter abstraction has no bool in this tree yet. While at it, move the log buffer code out of gsp.rs into gsp/logbuffer.rs. Assisted-by: Claude:claude-opus-5 Signed-off-by: Vladislav Zaharov --- drivers/gpu/nova-core/gsp.rs | 100 ++--------- drivers/gpu/nova-core/gsp/logbuffer.rs | 235 +++++++++++++++++++++++++ drivers/gpu/nova-core/nova_core.rs | 28 +++ 3 files changed, 282 insertions(+), 81 deletions(-) create mode 100644 drivers/gpu/nova-core/gsp/logbuffer.rs diff --git a/drivers/gpu/nova-core/gsp.rs b/drivers/gpu/nova-core/gsp.rs index 13f361406a6c..1e697c859a2f 100644 --- a/drivers/gpu/nova-core/gsp.rs +++ b/drivers/gpu/nova-core/gsp.rs @@ -12,11 +12,7 @@ CoherentView, DmaAddress, // }, - io::{ - io_project, - io_write, - Io, // - }, + io::io_write, pci, prelude::*, // }; @@ -24,9 +20,13 @@ pub(crate) mod cmdq; pub(crate) mod commands; mod fw; +mod logbuffer; mod regs; mod sequencer; =20 +use logbuffer::LogBuffers; +pub(crate) use logbuffer::RetainedLogs; + pub(crate) use fw::{ GspFmcBootParams, GspFwWprMeta, @@ -77,10 +77,6 @@ pub(crate) fn dev(&self) -> &'gpu device::Device { } } =20 -/// Number of GSP pages to use in a RM log buffer. -const RM_LOG_BUFFER_NUM_PAGES: usize =3D 0x10; -const LOG_BUFFER_SIZE: usize =3D RM_LOG_BUFFER_NUM_PAGES * GSP_PAGE_SIZE; - /// Array of page table entries, as understood by the GSP bootloader. #[repr(C)] #[derive(FromBytes, IntoBytes)] @@ -101,49 +97,6 @@ fn init(view: CoherentView<'_, Self>, start: DmaAddress= ) -> Result<()> { } } =20 -/// The logging buffers are byte queues that contain encoded printf-like -/// messages from GSP-RM. They need to be decoded by a special application -/// that can parse the buffers. -/// -/// The 'loginit' buffer contains logs from early GSP-RM init and -/// exception dumps. The 'logrm' buffer contains the subsequent logs. Bot= h are -/// written to directly by GSP-RM and can be any multiple of GSP_PAGE_SIZE. -/// -/// The physical address map for the log buffer is stored in the buffer -/// itself, starting with offset 1. Offset 0 contains the "put" pointer (p= p). -/// Initially, pp is equal to 0. If the buffer has valid logging data in i= t, -/// then pp points to index into the buffer where the next logging entry w= ill -/// be written. Therefore, the logging data is valid if: -/// 1 <=3D pp < sizeof(buffer)/sizeof(u64) -struct LogBuffer(Coherent<[u8; LOG_BUFFER_SIZE]>); - -impl LogBuffer { - /// Creates a new `LogBuffer` mapped on `dev`. - fn new(dev: &device::Device) -> Result { - let obj =3D Self(Coherent::zeroed(dev, GFP_KERNEL)?); - - let start_addr =3D obj.0.dma_address(); - - let pte_view =3D io_project!( - obj.0, - [build: size_of::()..][build: ..RM_LOG_BUFFER_NUM_PAGES *= size_of::()] - ) - .try_cast::>()?; - PteArray::init(pte_view, start_addr)?; - - Ok(obj) - } -} - -struct LogBuffers { - /// Init log buffer. - loginit: LogBuffer, - /// Interrupts log buffer. - logintr: LogBuffer, - /// RM log buffer. - logrm: LogBuffer, -} - /// GSP runtime data. #[pin_data] pub(crate) struct Gsp { @@ -165,9 +118,7 @@ pub(crate) fn new(pdev: &pci::Device) ->= impl PinInit) = -> impl PinInit); + +impl LogBuffer { + /// Creates a new `LogBuffer` mapped on `dev`. + fn new(dev: &device::Device) -> Result { + let obj =3D Self(Coherent::zeroed(dev, GFP_KERNEL)?); + + let start_addr =3D obj.0.dma_address(); + + let pte_view =3D io_project!( + obj.0, + [build: size_of::()..][build: ..RM_LOG_BUFFER_NUM_PAGES *= size_of::()] + ) + .try_cast::>()?; + PteArray::init(pte_view, start_addr)?; + + Ok(obj) + } + + /// Copies the contents of this buffer into memory that does not belon= g to the device. + /// + /// A buffer the GSP never wrote to yields an empty vector, as it hold= s nothing worth keeping. + fn snapshot(&self) -> Result> { + // Offset 0 holds the "put" pointer, which the GSP advances as it = appends entries. It is + // still zero if nothing was ever logged. + let put =3D io_project!(self.0, [build: ..size_of::()]).try_c= ast::()?; + if put.read_val() =3D=3D 0 { + return Ok(VVec::new()); + } + + let mut snapshot =3D VVec::zeroed(LOG_BUFFER_SIZE, GFP_KERNEL)?; + io_project!(self.0, [build: ..]).copy_to_slice(&mut snapshot); + + Ok(snapshot) + } +} + +/// The log buffers of a GPU, for as long as it is bound to the driver. +pub(super) struct LogBuffers { + /// Device the buffers belong to. Also names their debugfs directory. + dev: ARef, + /// Init log buffer. + pub(super) loginit: LogBuffer, + /// Interrupts log buffer. + pub(super) logintr: LogBuffer, + /// RM log buffer. + pub(super) logrm: LogBuffer, +} + +impl LogBuffers { + /// Allocates the three log buffers of `dev`. + pub(super) fn new(dev: &device::Device) -> Result= { + Ok(Self { + dev: dev.into(), + loginit: LogBuffer::new(dev)?, + logintr: LogBuffer::new(dev)?, + logrm: LogBuffer::new(dev)?, + }) + } + + /// Creates an initializer exposing these buffers under a directory na= med after `dev`. + pub(super) fn scope<'a>( + self, + dev: &'a device::Device, + ) -> impl PinInit, Infallible> + 'a { + #[allow(static_mut_refs)] + // SAFETY: `DEBUGFS_ROOT` is created before driver registration an= d cleared + // after driver unregistration, so no probe() can race with its mo= dification. + // + // PANIC: `DEBUGFS_ROOT` cannot be `None` here. It is set before = driver + // registration and cleared after driver unregistration, so it is = always + // `Some` for the entire lifetime that probe() can be called. + let log_parent: &debugfs::Dir =3D + unsafe { crate::DEBUGFS_ROOT.as_ref() }.expect("DEBUGFS_ROOT n= ot initialized"); + + log_parent.scope(self, dev.name(), |logs, dir| { + dir.read_binary_file(c"loginit", &logs.loginit.0); + dir.read_binary_file(c"logintr", &logs.logintr.0); + dir.read_binary_file(c"logrm", &logs.logrm.0); + }) + } + + /// Preserves whatever the GSP logged, so it can still be read once th= e GPU is gone. + /// + /// The buffers are DMA allocations of the device and cannot outlive i= t, so their contents are + /// copied into memory owned by the module and exposed through fresh d= ebugfs entries. Those + /// live until the module is unloaded. + /// + /// Does nothing if `gsp_keep_logs` was not set when the module was lo= aded, as there is then + /// no directory to put the copies in. + fn retain(&self) -> Result { + let mut retained =3D crate::RETAINED_LOGS.lock(); + + let Some(dir) =3D retained.dir.clone() else { + return Ok(()); + }; + + let logs =3D RetainedLogBuffers { + dev: self.dev.clone(), + loginit: self.loginit.snapshot()?, + logintr: self.logintr.snapshot()?, + logrm: self.logrm.snapshot()?, + }; + + // Nothing was ever logged, so there is nothing to keep. A copy fr= om an earlier run of + // this device is deliberately left alone: logs from a run that fa= iled are worth more + // than the silence of one that did not. + if logs.loginit.is_empty() && logs.logintr.is_empty() && logs.logr= m.is_empty() { + return Ok(()); + } + + // Take every allocation that can fail before the previous copy of= this device is + // dropped, so that running out of memory here cannot leave it wit= h no logs at all. + let scope =3D KBox::>::new_unin= it(GFP_KERNEL)?; + retained.gpus.reserve(1, GFP_KERNEL)?; + + // An earlier run of the same device may have left a copy behind, = and its directory + // carries the name about to be used again, so it has to go first.= Nothing below can + // fail, so the replacement is guaranteed to take its place. + retained + .gpus + .retain(|gpu| gpu.dev.name() !=3D self.dev.name()); + + let scope =3D scope.write_pin_init(dir.scope(logs, self.dev.name()= , |logs, dir| { + if !logs.loginit.is_empty() { + dir.read_binary_file(c"loginit", &logs.loginit); + } + if !logs.logintr.is_empty() { + dir.read_binary_file(c"logintr", &logs.logintr); + } + if !logs.logrm.is_empty() { + dir.read_binary_file(c"logrm", &logs.logrm); + } + }))?; + + retained.gpus.push(scope, GFP_KERNEL)?; + + dev_dbg!(self.dev, "GSP-RM log buffers retained\n"); + + Ok(()) + } +} + +impl Drop for LogBuffers { + fn drop(&mut self) { + if let Err(e) =3D self.retain() { + dev_warn!(self.dev, "failed to retain GSP-RM log buffers: {:?}= \n", e); + } + } +} + +/// Copies of the log buffers of a GPU that is no longer around. +struct RetainedLogBuffers { + /// Device the buffers came from. + dev: ARef, + /// Contents of the init log buffer, empty if it was never written to. + loginit: VVec, + /// Contents of the interrupts log buffer, empty if it was never writt= en to. + logintr: VVec, + /// Contents of the RM log buffer, empty if it was never written to. + logrm: VVec, +} + +/// Log buffers of GPUs that are gone, and the debugfs entries exposing th= em. +/// +/// The copies live under a `retained` directory of their own instead of n= ext to the entries of +/// the GPUs that are actually bound, so that a device coming back does no= t find its name taken. +pub(crate) struct RetainedLogs { + /// Parent directory of all copies. `None` unless retaining was asked = for. + dir: Option, + /// One entry per GPU. + gpus: KVec>>>, +} + +impl RetainedLogs { + /// Creates an empty set of retained log buffers, retaining disabled. + pub(crate) const fn new() -> Self { + Self { + dir: None, + gpus: KVec::new(), + } + } + + /// Creates the directory the copies will live in, enabling retaining. + pub(crate) fn enable(&mut self, parent: &debugfs::Dir) { + self.dir =3D Some(parent.subdir(c"retained")); + } + + /// Releases every copy and the directory holding them. + pub(crate) fn clear(&mut self) { + self.gpus.clear(); + self.dir =3D None; + } +} diff --git a/drivers/gpu/nova-core/nova_core.rs b/drivers/gpu/nova-core/nov= a_core.rs index 35a8b1214b0e..fedb9f0f5275 100644 --- a/drivers/gpu/nova-core/nova_core.rs +++ b/drivers/gpu/nova-core/nova_core.rs @@ -30,11 +30,21 @@ // TODO: Move this into per-module data once that exists. static mut DEBUGFS_ROOT: Option =3D None; =20 +kernel::sync::global_lock! { + /// Log buffers of GPUs that are gone, kept around until the module is= unloaded. + // TODO: Move this into per-module data once that exists. + unsafe(uninit) static RETAINED_LOGS: Mutex =3D gsp:= :RetainedLogs::new(); +} + /// Guard that clears `DEBUGFS_ROOT` when dropped. struct DebugfsRootGuard; =20 impl Drop for DebugfsRootGuard { fn drop(&mut self) { + // Retained log buffers own debugfs entries below `DEBUGFS_ROOT`, = so they have to go away + // before it does. + RETAINED_LOGS.lock().clear(); + // SAFETY: This guard is dropped after `_driver` (due to field ord= er), // so the driver is unregistered and no probe() can be running. unsafe { DEBUGFS_ROOT =3D None }; @@ -54,6 +64,16 @@ impl InPlaceModule for NovaCoreModule { fn init(module: &'static kernel::ThisModule) -> impl PinInit { let dir =3D debugfs::Dir::new(c"nova-core"); =20 + // SAFETY: Module initialization runs exactly once, and before the= driver is registered, + // so no probe can have touched `RETAINED_LOGS` yet. + unsafe { RETAINED_LOGS.init() }; + + // Creating the directory up front is what makes retaining possibl= e without reaching for + // `DEBUGFS_ROOT` later, from the teardown path of a device. + if *module_parameters::gsp_keep_logs.value() !=3D 0 { + RETAINED_LOGS.lock().enable(&dir); + } + // SAFETY: We are the only driver code running during init, so the= re // cannot be any concurrent access to `DEBUGFS_ROOT`. unsafe { DEBUGFS_ROOT =3D Some(dir) }; @@ -72,6 +92,14 @@ fn init(module: &'static kernel::ThisModule) -> impl Pin= Init { description: "Nova Core GPU driver", license: "GPL v2", firmware: [], + params: { + // TODO: Use `bool` once the module parameter abstraction supports= it; until then this + // takes 0 or 1. + gsp_keep_logs: u8 { + default: 0, + description: "Keep the GSP-RM log buffers in debugfs after the= ir GPU is gone (0|1)", + }, + }, } =20 kernel::module_firmware!(firmware::ModInfoBuilder); --=20 2.55.0 From nobody Mon Sep 28 23:55:42 2026 Received: from mail-lf1-f53.google.com (mail-lf1-f53.google.com [209.85.167.53]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A59B1309EE6 for ; Sat, 15 Aug 2026 05:08:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.167.53 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786770515; cv=none; b=nEcyxf/l1lQAXSz+g34b2tooXJ97UjlA58CO3IehGCTKMmCqcMIK6DgzCfCyYdv4EKoDsQH+VihmZU0qCjuUiepsllYuNinH6uh9f+h3OgvHVZiN3oOWGIRhUltOr7UvV1bkH6CZHZX80nHDE9u92ZvroELHUUUKPV3rkLZDnGU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1786770515; c=relaxed/simple; bh=RNy0Oc1b5YVJpZS5AO65ioCXwPG1K+v8mTvUlX+rTyw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=KzgDOvAu+0aRQWoTp51ItWGpcklNYr7OEzqEmqFLTwDevEVOlqG8YfYL6U8yuJZqP8IH1QnVJm5MgaRKZmsxFdEiVlaTfZVZ8OfBw331aCZef2gFKdYcavHrAO3usZ5TzoA6ow78LbYfqfuTjDcA0TBbm/x3EE07NocvvsSC34o= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=BsRDisr7; arc=none smtp.client-ip=209.85.167.53 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="BsRDisr7" Received: by mail-lf1-f53.google.com with SMTP id 2adb3069b0e04-5b01910b499so1530154e87.0 for ; Fri, 14 Aug 2026 22:08:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1786770512; x=1787375312; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=NgkFZajAQJmzi//1l9aIpRfIFvgCaKKT8i3Z0CDYaWs=; b=BsRDisr7X573Z13shKNL3Hmc0qYzP/gS8Zc+twBo+D/giYqckTW9MXO/HwC687ObKK 6pLdIrVWtJNZLSOPXjzo/m+VudFPyrShUVwdryeLkJAfxqMgG1zH4oHWqYndGXOhVKsC y+BANMkCZq9kdLt32cyEOEiqk8ZTFlQUuQ4m9TQygZAfmVXHOtmTz8ob9z5JIXro7725 kOe+Tmbu7tqRt8govU/axrum+4bd7M3uddC/FbGBUTdqzJrDLH8FaYI6ZWkJ5TmTo3Tm Lx23lDSv3JkYGtg4e1/j/+0kmACub49Hd4C21r1Fzlf3BW6g2MQDpoenE+AH1boAk6Zc E8bA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1786770512; x=1787375312; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=NgkFZajAQJmzi//1l9aIpRfIFvgCaKKT8i3Z0CDYaWs=; b=cRQpLKK5ZXW67feEY+YEBgUwF5DGfcgpK0AS1Wt1iMr4kPa7C20Em4eEoZrfJpjXo9 F4iWk8Gn3sl8vssjGmqbHCz+brBKoqe7Y0jIIEBkiJYed5W0S05zvRtDn7iKNL76hqxJ GPTW8rSsFKLJHYNVLVEKqFoRUjVPtpJxFIRKz/OMwvqCe1ho0BpL0KgJnCgu99Ior3Af NENpUFoxDbhWRgKhIIsXRQSI4cc4uQ3TUX+MTS9A40Zjz5HacTRj33Xbx4OGtnGu3TXl AtCYcEZ+C8gOmyST6hg/KLo0vuP6Oo1K9CvWRHtzBad24CeeI6KYC4TJYB7FpAQtjBsQ l5Cw== X-Forwarded-Encrypted: i=1; AHgh+Rqw/HFQl+Pk0rykHKZHL0olxwYYhk52wqwt4qLRicGdjaoeluwssezPqHTu4Fp3pkDYhOrqcUY83s6w2Lk=@vger.kernel.org X-Gm-Message-State: AOJu0YwLshpVixFOhBmYmA9Hs4OYOLlzRE2PXFhm9aDAbLtL0InJWxFB Vc0cw6CdDPcOGVa1TinN9SBnSV9vaPS2+eRplUXElJj9ZICOQAUNJLK+ X-Gm-Gg: AR+sD12hs6LVwfFTMR1bF2HWdnlK/V5Z57IoPv6mBzUVNLAA+OO7nwvTqSaFmgbD+M5 fBrA8CaqRFsEhJAH0tNrz0FvmUrFxK71l8Ps+X1ftO9lGD1pJFxBoCn1B9nn3Wgyd+Oo2jiUO16 iJHZWQYTIueeJAYqG/TmxIVXK5IlpAHKSXfITnlcSCG/jLWpuGlRVbikKjfZ0VDLKsmieKqqn5/ WkabFR03AwjzFoDiZKnmt/RM+Fnn7DLjsgt0tdNQjXBz3LcPV1hu7lXWLrwIbFYlpPe5ucO/BeS de8AVeGIPrp/zNK3B6s51XcpRw5PL1i8aFkCHUA4EUen/GX232gNf4s45GFrbpQMBBinQ2tk9Xe PcJWVY2hiwy5TFwi+Tnx76IjO7xJB5hCE8eo7R+9Ul37kDTntLseotRGvSRBAv6nrQjRZplfs05 hp7Eas0IpBWdNu42KnX7DdX3c4zCyJhu8sEkuHuv1wUIerWixHLX+yJkeW8q45sCJLzac= X-Received: by 2002:a05:6512:150e:20b0:5ad:68aa:8a78 with SMTP id 2adb3069b0e04-5b453b9adeemr2672003e87.5.1786770511539; Fri, 14 Aug 2026 22:08:31 -0700 (PDT) Received: from localhost ([95.190.110.153]) by smtp.gmail.com with ESMTPSA id 2adb3069b0e04-5b458b9a9a7sm932354e87.13.2026.08.14.22.08.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 14 Aug 2026 22:08:31 -0700 (PDT) From: Vladislav Zaharov To: dakr@kernel.org, jhubbard@nvidia.com Cc: acourbot@nvidia.com, aliceryhl@google.com, ttabi@nvidia.com, gary@garyguo.net, nova-gpu@lists.linux.dev, dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, linux-doc@vger.kernel.org, Vladislav Zaharov Subject: [PATCH v2 2/2] Documentation: nova: remove completed GSP log buffer task Date: Sat, 15 Aug 2026 12:08:26 +0700 Message-ID: <20260815050826.306717-3-vladazaharova2018@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260815050826.306717-1-vladazaharova2018@gmail.com> References: <20260815050826.306717-1-vladazaharova2018@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Exposing the GSP-RM log buffers through debugfs is implemented, and with the gsp_keep_logs module parameter they now also survive a failed probe, which was the part of the task that was still missing. Assisted-by: Claude:claude-opus-5 Signed-off-by: Vladislav Zaharov --- Documentation/gpu/nova/core/todo.rst | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/Documentation/gpu/nova/core/todo.rst b/Documentation/gpu/nova/= core/todo.rst index d5130b2b08fb..cae0578d32f1 100644 --- a/Documentation/gpu/nova/core/todo.rst +++ b/Documentation/gpu/nova/core/todo.rst @@ -141,18 +141,6 @@ Implement support for instmem (bar2) used to store pag= e tables. GPU System Processor (GSP) =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D =20 -Export GSP log buffers ----------------------- - -Recent patches from Timur Tabi [1] added support to expose GSP-RM log buff= ers -(even after failure to probe the driver) through debugfs. - -This is also an interesting feature for nova-core, especially in the early= days. - -| Link: https://lore.kernel.org/nouveau/20241030202952.694055-2-ttabi@nvid= ia.com/ [1] -| Reference: Debugfs abstractions -| Complexity: Intermediate - GSP firmware abstraction ------------------------ =20 --=20 2.55.0