summaryrefslogtreecommitdiffstats
Commit message (Collapse)AuthorAge
* tools: pin GR push-buffer window from guest pagemap per boot; widen ↵Arthur Hanson Rasmusson13 days
| | | | | | | | | | | | | | | | | injected-pin table The GR channel GPFIFO entries point at pushes in the client GPU VA window (observed 0x200400000 + stride, one allocation per channel) and the pump cannot read them: pushes_nomap grows and the tracking-semaphore releases they carry never land. The pushes are sysmem pages mapped into the client process, so /proc/<pid>/pagemap in the guest gives the GPA. New guest helper guest_pmap_win.py batch-reads the pagemap of a VA range (512 entries per pread). New host tool pin_gr_window.py rescans the window on an interval, follows cdt pid changes, and injects VA->PA runs through sema_map_add (same mechanism as the counters and the CE pushbuffer pins). The injected-pin table grows 8k -> 32k slots so the CE pushbuffer (4096) plus the GR window pages fit without drops.
* kernel: batch the map-add channel rewind; trust injected streams for opsArthur Hanson Rasmusson13 days
| | | | | | | | | | | | | | | | | Two fixes for the CE data path. (1) svc_handle_map_add rewound every channel by 8 ring entries on every injected mapping; a 16 MB push-buffer pin is thousands of page injections, so the pump's last_get was pinned in place and it re-read the same entries for the whole batch (3645 submissions, zero ops). The rewind now runs once per drained batch. (2) The push-start heuristic (op=INC_METHOD at address 0) rejects UVM's real CE memop pushes, which start with an IMM method at address 8 (observed 0x60020002, PTE data words) or a release method at 0x700 (0x200381c0); a buffer read through a host-injected (ipin) translation is now decoded fully trusted, ops included. Result on the next boot: memset=2718/0/0 ringops=1794 (first sustained CE work), false 12k->1.9k. semfix_watch: bulk-pin contiguous runs via sema_map_add len, read rm_mem size, 16 MB (4096 page) cap, non-blocking QMP read (the fixed 30 ms sleep made 4096 gva2gpa calls take two minutes), and KEEP_TRACE=1 to preserve the guest trace for post-mortems.
* kernel: decode release pushes read through injected pins instead of rescuing ↵Arthur Hanson Rasmusson13 days
| | | | | | | | | | | | | them Real CE release pushes start with INC_METHOD addr 0x700 (0x200381c0, count 3, subch 4), and svc_method_stream_plausible requires method address 0, so every readable release push was treated as a false pairing, rescued (fails) and skipped - the client's tracking-semaphore release never applied and cuCtxCreate waited forever (slot payload 74 vs queued 75). A buffer read through a host-injected (ipin) translation is now decoded release-only (allow_ops=false) when it fails the push-start heuristic; self-discovered translations keep the strict rescue path.
* kernel: authoritative host-injected VA->PA pins (ipin table) + wider pin tableArthur Hanson Rasmusson13 days
| | | | | | | | | | | | | | The CE push-buffer page 0x120000000 resolved to a zero-filled page even after sema_map_add injected the correct translation: the shared pin table silently dropped inserts once a hash cluster exceeded the 32-probe window (the page hashes to slot 0, a hot cluster), and lookups fell through to the content-scanned map and answered with a stale page - so every CE push read as implausible and memset stayed 0. Injected translations now live in a separate authoritative table checked before every other source and are never written by self-discovery; the general pin table is 4x larger with a 4x probe window and counts drops (pin_drop/ipin_drop) in the stats line. guest_kprobes.sh disables the kprobe group before removal (EBUSY) and matches p:kprobes/<name>; the guest wait sampler can run counters-only with GDB=0.
* guest-diag: deterministic channel->pool->manager->pushbuffer chain + ↵Arthur Hanson Rasmusson13 days
| | | | | | | | | | | | | | | chunk-read diagnostics semfix_watch.py now resolves the CE pushbuffer from guest truth instead of scanning a wide raw window: it walks uvm_channel_t +0=pool, pool+0=manager, manager+8=pushbuffer, pushbuffer+8=rm_mem, rm_mem+0x10=vas[] and prefers the rm_mem whose GPU VA is in the 0x120000000 CE pushbuffer range. Three entry points: uvch probe on __uvm_push_begin_acquire_on_channel_with_info, uvbp probe on uvm_pushbuffer_begin_push, and the uvmt tracking-sem kptr (channel scan back from sem). Misses now print structured hop counters so a failed chunk read is distinguishable from a failed chain. guest_kprobes.sh (re)installs uvmt/uvch/uvbp/uvpbf after every guest boot (plain, module: and bare spellings).
* guest-diag: identify pushbuffer rm_mem by vmalloc CPU VA (any GPU VA)Arthur Hanson Rasmusson13 days
|
* guest-diag: widen pushbuffer chain scan (256KB, slab-prefix filter)Arthur Hanson Rasmusson13 days
|
* guest-diag: read trace before clearing (one-shot pushbuffer-create events)Arthur Hanson Rasmusson13 days
|
* guest-diag: per-page pushbuffer translation, per-client re-pinArthur Hanson Rasmusson13 days
|
* guest-diag: resolve pushbuffer from uvpbf kprobe pointer (deterministic)Arthur Hanson Rasmusson13 days
|
* guest-diag: bound pushbuffer fallback scan (400 candidates / 30s)Arthur Hanson Rasmusson13 days
|
* guest-diag: pushbuffer resolution fallback (direct pushbuffer pointer ↵Arthur Hanson Rasmusson13 days
| | | | candidates)
* guest-diag: semfix also resolves+pins the CE pushbuffer range (descending ↵Arthur Hanson Rasmusson13 days
| | | | GPA layout)
* sema-svc: fake_rel applies releases immediately (skip multi-second CE rescue ↵Arthur Hanson Rasmusson13 days
| | | | scans)
* sema-svc: learn the tracking-sem VA from readable pushes for the release ↵Arthur Hanson Rasmusson13 days
| | | | fallback
* guest-diag: injector handles slow chan_dump (3s wait, last-marker parse)Arthur Hanson Rasmusson13 days
|
* sema-svc: optional CE release fallback for unreadable pushes (sema_fake_rel)Arthur Hanson Rasmusson13 days
|
* guest-diag: semfix watcher (stale sem-pool VA->PA from guest truth); ↵Arthur Hanson Rasmusson13 days
| | | | injector marker-based handle discovery
* sema-svc: async VA->PA injection queue; guest-diag: fast counter+pin ↵Arthur Hanson Rasmusson13 days
| | | | injector, wait sampler
* tools: cuda_cycle.sh - detect channels from dmesg (client timeout is ~30 s)Arthur Hanson Rasmusson13 days
| | | | | | The client times out the context-init counter wait in ~30 s; the previous poll loop spent ~50 s on chan_dump round-trips before injecting. Count the per-channel first-pump log lines straight from dmesg every 0.5 s instead.
* tools: cuda_cycle.sh polls channels every 2 s to shrink publish latencyArthur Hanson Rasmusson13 days
|
* tools: inject_counters.sh - counter index order is descending by handleArthur Hanson Rasmusson13 days
| | | | | | | | Live verification: the trackers waiting on counter slots idx2/idx3 belong to the channels 2nd/3rd from the top of the ascending handle list, and the only channel whose GPFIFO put advanced to 2 was the 4th from the top, whose tracker polled idx3. Zip descending handles with ascending counter indices by default; ORDER=asc restores creation order.
* tools: cuda_cycle.sh - one-command CUDA bring-up attemptArthur Hanson Rasmusson13 days
| | | | | | | Restart the VM, push the guest tools, start cdt holding on failure, wait for the 20 GR channels, register/pin the completion counters and arm scanerr.py, so each iteration is a single command. scanerr now loops over scanner hits until a hit carries a non-zero RM error record.
* tools: scanerr.py - dump the non-zero RM error record behind a forced 999Arthur Hanson Rasmusson13 days
| | | | | | | | The libcuda error scanner (FUN_0054fa00) walks a context list and returns 999 when its force flag is set and any context's RM error record has a non-zero class. ctx999 only shows the first (zeroed) record; scanerr walks the whole list and prints every non-zero record so the failing control or alloc is named. Pushed by push_guest_tools.sh.
* tools: durable guest counter enumeration/injection and VA readerArthur Hanson Rasmusson13 days
| | | | | | | | | | | | | | | | | | | The counter enumeration/injection workflow lived in the guest's /tmp and was lost on every restart. Make it durable under tools/guest-diag: - sem_counters.py: translate a process's per-channel u32 completion counters (16-byte stride in the /dev/nvidiactl counter page) to guest PAs through /proc/<pid>/pagemap; --pairs emits handle,va,pa triples. - sem_slots.py: read/write the counter slots via /proc/<pid>/mem (fallback for the host counter publish). - read_va.py: hex dump a process VA (UVM sysmem GPU VAs are usually valid CPU VAs in the owning process); --u32 for method streams. - inject_counters.sh: host-side one-shot: push the tool, take the GR handles from the live chan_dump, enumerate, then register each counter with sema_counter and pin its VA with sema_map_add. - push_guest_tools.sh: push the new tools after every VM start. - launch_qemu_direct.sh: parameterized mdev UUID/paths instead of a stale hardcoded one; committed so it survives checkouts.
* sema: fix host stack-overflow hang; robust VA resolution; dispatcher lock fixArthur Hanson Rasmusson13 days
| | | | | | | | | | | | | | | | | | | | | | | - svc_handle_chan_dump()/svc_decode_stream(): static snapshot buffers. The 128-channel local array made an ~18 KB frame, which overflows the 16 KB kernel stack in the function prologue and panicked the host 2-3 s after a VM attached the vGPU (proven from EFI pstore: guard page hit at svc_handle_chan_dump+0x20, sub rsp,0x4850). - svc_pump_channels(): write-back now also persists expected_sem_payload, rescue_last and rescue_fail. The pump works on a snapshot copy, so without this the stale-entry skip and the rescue rate limit could never fire and the payload expectation was reinitialized every pass. - svc_targeted_resolve(): sliced scan (128 MB per call, one VA at a time, failed-VA cache) instead of a full-RAM scan per miss; no longer appends to the sorted map out of order. - svc_rebuild(): merges new scan results into the previous map (fresh translation wins in place, new VAs appended) instead of replacing it wholesale, so live translations survive a scan-yield collapse. - Warning fixes: misleading indentation, unused variable, jiffies typecheck. Frame audit: largest frame now 872 B. - Includes the previous session's uncommitted work: sema_counter / shadow_scan / shadow_dump debug params, exit stage markers, pdev ref fix, and the dynamic dispatcher request_firmware-out-of-spinlock fix.
* sema: consume stale GPFIFO entries after repeated rescue failuresArthur Hanson Rasmusson13 days
| | | | | | | | Entries whose push buffer was overwritten (the rescue cannot validate any candidate page) were retried forever, rescanning RAM every 5 s and leaving the ring stuck behind them. After three real rescue failures (rate-limited attempts do not count) the entry is consumed with a 'skipping stale entry' log and the pump moves on. New skip= stat.
* sema: rescue entries anywhere in a pushbuffer slotArthur Hanson Rasmusson14 days
| | | | | | | | Mid-slot entry VAs were rejected by the alignment guard, leaving their false translations permanent. Candidate 2 (the group's page minus the push length) is the PA of the entry VA's page regardless of alignment; pin only the pages the push occupies for mid-slot entries and the whole 1 MB slot for slot-aligned ones. Validation by read-back is unchanged.
* sema: rescue by exact release group at any offset, with validated pin alignmentArthur Hanson Rasmusson14 days
| | | | | | | | | | | | | | Kernel: the slot-aligned failing entries carry pushes whose release group is not at the page's fixed +0x10 offset, so the shape matcher found nothing. Scan every 4-byte offset for the exact group (hdr 0x20038090, hi==1, lo&0xfff==slot, follower LAUNCH_DMA sem-release; payload may lag the tracked expectation) with the header compared first. Each match yields two candidate pin bases - the group's page and the page implied by treating the group as the end of this entry's push - and each candidate is validated by pinning and reading the entry VA back before it is accepted. Live: 13 rescues pinned the MEMOPS slots; the 12700-byte push then decoded to 29 op-runs with a real release, and memset=338 fills (page-table clears) executed ~13 s before the client's rc=999.
* sema: strong rescue signature; rescue on false translations; slot pinArthur Hanson Rasmusson14 days
| | | | | | | | | | | | The content rescue matched only the release group bytes and had matched GSP firmware pages. It now requires the full known push shape around the release (two SET_OBJECT class binds, the 3-word SET_SEMAPHORE_A run with this channel's next payload, and the LAUNCH_DMA semaphore-release follower), and it is also invoked when a trusted read resolves but the buffer does not parse as a push (false content-scanned pair; observed firmware/kernel-data pages), not only when the VA is unmapped. The rescue pins the whole 1 MB push-buffer slot, which is what the UVM MEMOPS channels' pushbuffer pool (0x1200_0000 + n*1MB) needs. New false= stat.
* sema: include the push VA in the per-push summaryArthur Hanson Rasmusson14 days
| | | | | | The long bogus pushes (RISC-V tails) could not be tied back to the ring entry they came from; log the GPFIFO entry VA with each push so the false translations are identifiable and can be compared against probes.
* sema: refuse work from buffers that do not start like a pushArthur Hanson Rasmusson14 days
| | | | | | | | | | The discovered VA->PA map is content-scanned and can hand a ring entry's push VA a false translation; observed: GSP firmware pages read as a 12700-byte method stream whose fills would have been executed into vidmem. Work now requires the buffer to start with a plausible first method (INC_METHOD, address 0, sane count that fits the length); releases still apply from such buffers so a shifted stream is not lost. New 'denied' counter in the sweep stats.
* sema: per-push release/ops summary; never run work from rescued pagesArthur Hanson Rasmusson14 days
| | | | | | | | | | | | | Log one line per ring-decoded push (channel, engine, length, op-run count, decoded release VA/payload, last 24 bytes) to make the push->tracker path observable; it showed that the content rescue had been pinning unrelated RAM pages: pushes of length 4196/8500/12700 whose tails are RISC-V code (ecall/jal) - GSP firmware or other code pages whose bytes matched the expected release pattern. Those pages decode as plausible but bogus method streams, so work executed from them can write garbage into vidmem. Rescued pages now apply the release only (allow_ops=false); work requires a page read through a trusted translation.
* gsp_rm: keep and log the CE fault method buffer memdescs (0xa06c010a)Arthur Hanson Rasmusson14 days
| | | | | | | | | | | NVA06C_CTRL_CMD_INTERNAL_PROMOTE_FAULT_METHOD_BUFFERS is sent at channel-group allocation; it hands the GSP each runqueue's 12 KB CE fault method buffer as {base (GPU physical), size, alignment, addressSpace, cpuCacheAttrib} plus a bar2Addr. Parse and log them, and keep the last set per channel-group object so the addresses (guest structures we cannot otherwise enumerate) are available to the engine emulation. Live: two 12 KB buffers per group, base = guest PA, addressSpace = 1, buffers zeroed (no faults posted yet).
* guest-diag: pin_sem_fast.sh - 2 s tracker-sem pinner with a per-pid guardArthur Hanson Rasmusson14 days
| | | | | | | | | The 15 s pinner loses the race against the client's internal deadline in most boots: in the one boot where UVM's page-table write pushes were submitted the pin had landed early, and later pins (60 s+) left the client dead before submitting anything. Poll the guest pagemap every 2 s and pin 0x20400f000 once per cdt pid (re-pinning the same pid also stirred the pump's rewind repeatedly, which is why the guard exists).
* sema: add walk_probe - trace the page-table walk for a VAArthur Hanson Rasmusson14 days
| | | | | | | | | | New module parameter walk_probe <va> runs the recorded-va-space walks and the discovered-directory walk directly (pin/lat/pair map bypassed) with per-level tracing, and prints the result of each. This separates 'the page tables are not walkable' from 'the VA->PA pair map already answers' when a translation is missing. Baseline on a live boot: root PDB entries are zero (L0 e=0 idx=0) so the writes UVM issues into the level pages have no parent entry yet.
* sema: run work at the LAUNCH_DMA release path too; log LAUNCH_DMA inventoryArthur Hanson Rasmusson14 days
| | | | | | | | | | | | | | | The CE pushes UVM's MEMOPS channels submit release through SET_SEMAPHORE_A plus a LAUNCH_DMA with SEMAPHORE_TYPE=RELEASE_ONE_WORD. That path still gated the push's collected fills/copies on the semaphore being readable and behind the payload - the same bootstrap deadlock as the REPORT_SEM path fixed before: the page-table writes that make the semaphores translatable were dropped. Run the work unconditionally there as well (trusted-ring pushes only). Also log a one-line LAUNCH_DMA inventory (channel, engine, dma word, modes, offsets, line length, collected op count) for the first pushes read through rings, which is how the UVM page-table write sequence (fill 512x8 zero + 16-byte PTE copies + release) was identified.
* sema: always run a decoded push's work when the push is reachedArthur Hanson Rasmusson14 days
| | | | | | | | | | | | | The pump gated collected fills/copies on the tracking semaphore being translatable and behind the release payload. On real hardware the work always executes and the release only orders observers, so the gate dropped work exactly when it was needed to bootstrap translations (UVM's CE memsets writing page tables into vidmem, whose tracking semaphores live in the address space those writes create) and skipped pushes as stale as soon as a tracking semaphore advanced past them. Execute the work at the release method for every push read through a trusted ring; swept-RAM decoding still never runs work. Count op runs in the sweep stats (ringops).
* guest-diag: ctx999.py (scanner/ctx gdb capture); fix pinner exact-VA matchArthur Hanson Rasmusson14 days
| | | | | | | | | | | ctx999.py arms the scanner entry/returns plus cuCtxCreate and dumps the ctx->mgr->reg->record chain at the stop. First live capture: the scanner is called with param_2=1 during normal context creation and correctly returns 0 on a zero record (mgr[+0], the channel handle, and the record walk are now confirmed live). pin_miss_pages.sh must match the exact VA pmapall printed: guest_pmap_all.py returns the first nvidia page at-or-above va-min, so a page that is not present resolves to an unrelated mapping (it pinned a UVM page for 0x20400f000).
* guest-diag: adaptive miss-driven pinner; cdt holds on failure for inspectionArthur Hanson Rasmusson14 days
| | | | | | | | | | pin_miss_pages.sh watches the host journal for release-miss VAs, resolves each page for the live cdt pid through the guest pagemap and injects it (the injection rewinds the pump so releases consumed under a stale pin are re-read); it re-pins when a new cdt pid appears. cuda_drv_test prints cuGetErrorName/String on failure and, with CDT_HOLD=<seconds>, stays alive so the RM error record and tracker state can be inspected after cuCtxCreate has given up.
* gsp_rm: retire event records on FREE; guest-diag: bp999 dumps the RM error ↵Arthur Hanson Rasmusson14 days
| | | | | | | | | | | | | | record A freed client's notifier events (hSrcResource 0) stayed valid in the event table, so the fallback wake-up nudge kept posting POST_EVENT records for a (hClient, hEvent) pair the guest RM no longer knows; every one asserts in CliGetEventInfo (kernel_gsp.c:466) and is dropped (171 failures in the 15:24 window of the last run, zero after this fix). FREE now retires the matching event record (and a client's records when its root object is freed). bp999.py now walks rdi -> ctx -> ctx[0x1291] -> +0x10 -> +0x10 and prints the RM error notification record, and push_guest_tools.sh ships it to the guest.
* guest-diag: nmi_catch.sh - sysrq-l sampler that keeps nvidia kernel stacksArthur Hanson Rasmusson14 days
| | | | | | | | | | The guest RM's expiring waits are kernel busy-polls and all of their functions are notrace, so ftrace/kprobes cannot name them. sysrq-l NMI backtraces can: this sampler triggers them and keeps only the Comm and [nvidia] frame lines per round, so the wait/teardown stacks survive dmesg ring wraps. Caught the adapter-shutdown scrubber stack (channelReadChannelMemdesc <- ceutilsUpdateProgress <- scrubberDestruct <- memmgrDestroyInternalChannels <- gpuStatePreUnload <- nv_shutdown_adapter).
* sema: clamp the pin-rewind at ring start - never wrap below zeroArthur Hanson Rasmusson14 days
| | | | | | | The rewind used entries - (N - get) for get < N, which for an empty ring (get=0, put=0) jumped last_get to entries-8, so the pump read ring slots the producer had never reached and could execute stale/garbage entries. Replay only recently consumed slots, clamped at 0.
* sema: re-run recent ring entries when a translation is replacedArthur Hanson Rasmusson2026-09-28
| | | | | | | | | | | | | | | | | A pin injected after the pump consumed pushes that release through that VA resolved against the old (or bogus) translation, so the releases were compared as stale against the old page's values and dropped - a new client that maps fresh pages at the same VAs then waits forever. Rewind every channel's last_get by 8 ring entries on injection so the pump re-reads those pushes under the new translation; the release and fill application paths are forward-progress guarded and idempotent, so re-execution is safe. The handler runs in the service thread, which also runs the pump, so no pass can be in flight during the rewind. Diagnosed from cdt4: its tracker releases were consumed while the pin still pointed at the previous cdt's page (value 1), so payload <= cur and every release was dropped as stale; re-pinning afterwards could not resurrect them because the ring entries had already been consumed.
* sema: never execute work decoded from swept RAM; pin only tracker semsArthur Hanson Rasmusson2026-09-28
| | | | | | | | | | | | | | | | | | | The content sweep reads arbitrary guest RAM and ran the full push decoder on every page, so fabricated method streams in unrelated data executed fills/copies: one boot scanned 65M pages, 'decoded' 124k pushes and ran dozens of memsets from false positives - writes into live guest memory (a guest kernel crashed in nvidia_uvm right after such a boot). - Swept pages now only permit the bounded semaphore-release writes; fills and copies execute only for pushes the pump read through a trusted ring translation. - Pushes read for a compute (GR) channel apply releases only: their method space is not the copy engine's, so aliased encodings must never become memory writes. - sempages.py derives the pages to pin from the client's tracker objects (sem object + sem memory) instead of matching bare sem-object shapes, which pinned 140 pages where the client has ~53 sems; shape scan remains as a fallback when no tracker resolves.
* sema: GR ring autopin must not trust an early base or a pre-existing pinArthur Hanson Rasmusson2026-09-28
| | | | | | | | | | | | | | | | | | | | | | Two failure modes kept every GR channel dark despite the ring layout being known: - The CE region size was latched on the first autopin attempt, which can run before all CE channels are registered; a too-small base then points every GR candidate at a chunk whose entry 0 is zeros, and it stays wrong for the life of the boot. Recompute the base from the live CE ranks on every pass. - An existing pin for a ring VA (e.g. from a convention guess) made the autopin mark the rank done without validating the ring - a wrong USERD is then never corrected. Validate the candidate chunk (entry 0 decode + USERD put/get) first and only fall back to trusting an existing pin when the chunk does not validate; on success overwrite the pin. Also log one diagnostic line per GR rank when the chunk does not validate yet, so a silent autopin failure is visible in dmesg. Live: fresh boot, no manual ring pins - 20/20 GR channels auto-pinned (correct USERD 0x142000 + 0x3000*i) and ran entry 0 (get=1 sub=1) once the push pages were bridged.
* sem: run GR channels - accept CE methods on subchannel 0, discover GR ringsArthur Hanson Rasmusson2026-09-28
| | | | | | | | | | | | | | | | | | | | | - The CE semaphore/memset method groups also arrive on subchannel 0 (CUDA's push library binds the copy class on compute channels to carry the work-submission releases), so the stream decoder accepts both 0 and 4. - GR (compute) channel rings live in the same video-memory allocation as the CE rings, 0x3000 bytes per channel after them: ring (0x2000) at ce_end + 0x3000*rank, USERD at +0x2000. Discover and pin them once the CE ranks are known; verified against ring entry 0 (1 MB aligned push VA in the client window, sane length) and the USERD's put/get, so a layout change costs a failed pin, not a wrong one. Gated by sema_gr_rings (default on). - memprobe: require the sem-VA triple in the sem-object scanner (a bare qword in the window matches thousands of unrelated pointers once the ring/pushbuffer windows are part of the range). Live evidence: ring entries read through the guest's /proc/pid/mem decode to the GR channels' first pushes; pinning the ring (fb 0x140000+0x3000*rank), USERD (ring+0x2000) and first-push pages made all 20 GR channels execute their entry 0 for the first time (get=1 sub=1).
* sema-svc: apply releases promptly and decode compute-push releasesArthur Hanson Rasmusson2026-09-28
| | | | | | | | | | | | | | | | | | The content sweep now: - decodes a release whose method stream continues with any INC_METHOD, not only the CE LAUNCH_DMA group, so the releases at the head of a compute/GR channel's first push are applied too; - remembers releases whose target VA had no translation (deferred list) and retries them every service pass, so a VA->PA injection lands them immediately instead of after the next full sweep; - re-arms the fast sliced sweep for a few seconds after an injection; - treats a channel whose USERD/ring cannot be resolved as stalled, so the sweep keeps looking for the releases its unreadable pushes carry. tools: add per-cdt client-pin helper (sem pages + /dev/nvidia0 windows), sem-page scanner and memprobe fixes (short-read guard, --brief). Live-verified: injecting a client sem page applied 12 deferred releases within a second; the service kept applying (89 -> 202) while cdt ran.
* gsp_rm: advertise two GRCEs on TU104 (host reports 3 async CEs of 5); CE1 ↵Arthur Hanson Rasmusson2026-09-26
| | | | shares GR's runlist/PBDMA
* tools/guest-diag: decode engine-list, classlist and CE-cap RM control ↵Arthur Hanson Rasmusson2026-09-26
| | | | replies in the ioctl tracer
generated by cgit v1.2.3 (git 2.39.1) at 2026-10-12 15:09:32 +0000