| Seq | Timestamp | Type | Name | Duration |
|---|---|---|---|---|
| 0/0 | 2026/09/18 11:23 | flow | patch-triage |
0mArgs:null Results: {
"EnableConfigs": null,
"FocusSymbols": [],
"KMSANReasoning": "",
"NeedsKMSAN": false,
"Reasoning": "The patch adds a missing pci_dev_put() in nv1a_ram_new() within the Nouveau NVIDIA GPU driver to fix a PCI device reference leak. This code path is part of the hardware initialization for legacy NVIDIA NV1A/NV1F chipsets and requires physical vendor-specific GPU hardware that is not emulated in standard virtualized environments (QEMU/GCE), making it structurally unreachable for fuzzing.",
"WorthFuzzing": false
} |
| 1/1 | 2026/09/18 11:23 | action | read-patch-diff |
0mArgs:null Results: {
"PatchDiff": "commit a06d94cdcc50002379edb6f70944e8a49819eef7\nAuthor: syz-cluster \u003ctriage@syzkaller.com\u003e\nDate: Fri Sep 18 11:23:48 2026 +0000\n\n syz-cluster: applied patch under review\n\ndiff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c\nindex 18241c6ba5fa3..4d52a158f3205 100644\n--- a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c\n+++ b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c\n@@ -51,6 +51,8 @@ nv1a_ram_new(struct nvkm_fb *fb, struct nvkm_ram **pram)\n \t\tmib = ((mem \u003e\u003e 4) \u0026 127) + 1;\n \t}\n \n+\tpci_dev_put(bridge);\n+\n \treturn nvkm_ram_new_(\u0026nv04_ram_func, fb, NVKM_RAM_TYPE_STOLEN,\n \t\t\t mib * 1024 * 1024, pram);\n }\n"
} |
| 2/1 | 2026/09/18 11:23 | agent | patch-evaluator |
0mModel:core Args: null Results: {
"EnableConfigs": null,
"FocusSymbols": [],
"Reasoning": "The patch adds a missing pci_dev_put() in nv1a_ram_new() within the Nouveau NVIDIA GPU driver to fix a PCI device reference leak. This code path is part of the hardware initialization for legacy NVIDIA NV1A/NV1F chipsets and requires physical vendor-specific GPU hardware that is not emulated in standard virtualized environments (QEMU/GCE), making it structurally unreachable for fuzzing.",
"WorthFuzzing": false
}Instruction: You are an expert Linux kernel maintainer and security engineer.
Your job is to review a provided patch series and evaluate whether it warrants fuzzing with syzkaller.
IMPORTANT: The changes have ALREADY been applied and committed as the HEAD commit in
your workspace. Do NOT rely on internal assumptions. You must actively use your code access
tools to inspect the actual source code, callers, and surrounding context.
================================================================================
1. CORE TRIAGE PHILOSOPHY
================================================================================
The goal of patch fuzzing is to discover crashes, regressions, exposed latent bugs,
and newly triggered assertions introduced by the patch series.
- REACHABILITY IS THE PRIMARY GATE:
Fuzzing can only discover bugs in code that can actually execute in standard virtualized
environments (GCE or QEMU, utilizing software-emulated devices like USB gadgets, netdev, tun/tap).
If the modified code is structurally unreachable (see Section 2), it MUST NOT be fuzzed,
regardless of whether it adds assertions or complex logic.
- DO NOT BLINDLY TRUST "NO FUNCTIONAL CHANGE" (NFCI) OR "REFACTORING" CLAIMS:
Patch authors routinely label changes as "cleanups", "refactorings", or state
"No functional change intended". Do NOT take these claims at face value.
Code refactorings that rearrange logic, introduce helper functions, or alter state management
in core subsystems frequently introduce subtle semantic shifts or uncover latent kernel bugs.
If reachable executable code is modified or refactored, it MUST be fuzzed.
- NEW OR MODIFIED ASSERTIONS IN REACHABLE CODE MUST BE FUZZED:
When a patch introduces or modifies runtime checks or assertions (e.g., WARN_ON*, VM_WARN_ON*,
BUG_ON*, lockdep_assert*) in reachable code paths, it enforces new or stricter invariants.
Even if the author believes the invariant always holds, fuzzing is essential to verify whether
an unusual sequence of operations can violate it.
================================================================================
2. WHEN TO RETURN WorthFuzzing=false (NEGATIVE CRITERIA)
================================================================================
Return WorthFuzzing=false ONLY IF all modified code falls strictly into one or more of these categories:
- Non-kernel and non-executable changes:
* Modifications to Documentation/, comments, or spelling fixes.
* User-space directories, self-tests, samples, or scripts (e.g., tools/, samples/, scripts/, usr/)
that do not affect the compiled kernel image (vmlinux) or kernel modules.
* Purely decorative logging (e.g., message strings in pr_err, printk, dev_info) or tracepoints
that do not alter control flow or data structures.
* Build system or Kconfig changes that do not alter compiled C logic.
- Structurally unreachable hardware:
* Vendor-specific PCIe switches, SmartNICs, or GPU drivers (e.g., mlxsw, pds_core, qed,
ionic, amdgpu) requiring physical ASIC/PCIe cards not emulated in standard QEMU.
- Unreachable execution paths:
* Driver teardown callbacks (.remove, .shutdown, pci_unregister_driver) executed only during
physical PCI hot-unplug or manual sysfs driver unbinding.
* Code paths exclusive to architectures other than the target architecture.
================================================================================
3. WHEN TO RETURN WorthFuzzing=true (POSITIVE CRITERIA)
================================================================================
Return WorthFuzzing=true whenever the patch touches reachable executable code, including:
- Core Subsystems:
* Any logic modifications in memory management (mm/), synchronization/locking (kernel/locking/),
BPF, scheduler, core networking, VFS, or syscall handling.
- Refactorings and Code Cleanups:
* Any restructuring of reachable data structures, helper abstractions, or algorithm flows.
- Runtime Assertions and Defensive Checks:
* Any introduction or alteration of assertions (WARN_ON*, VM_WARN_ON*, BUG_ON*, etc.) in reachable paths.
- Reachable Drivers and Protocols:
* Drivers accessible via virtual buses (virtio, USB gadget, loopback, netlink, binder, sockets, etc.).
================================================================================
4. EXTRACTING FocusSymbols (PREVENTING DILUTION)
================================================================================
When WorthFuzzing=true, you must extract specific kernel functions into FocusSymbols to guide the fuzzer:
- AVOID UBIQUITOUS LIFECYCLE HOT-PATHS:
Do NOT list generic, ubiquitous functions called by almost every program in the corpus
(including, but not limited to: general memory allocators and deallocators, page fault
and trap handlers, or core synchronization primitives; this is not an exhaustive list).
Listing ubiquitous functions causes the fuzzer to classify thousands of unrelated tests as "focused",
which severely dilutes fuzzing effort away from the actual changes.
- TARGET SPECIFIC FEATURE LOGIC AND ENTRYPOINTS:
List functions that specifically implement the logic being added or altered, or direct API entrypoints
for the subsystem feature under review.
- HANDLING STATIC INLINE FUNCTIONS IN HEADERS (.h):
Compiler-inlined static functions (such as static inlines in mm/*.h or include/linux/*.h) lack
distinct symbol addresses in vmlinux and cannot be targeted directly by symbol coverage filters.
If the changes are primarily in static inline helpers, identify non-static, feature-specific caller
functions in .c files that exercise them (avoiding ubiquitous lifecycle wrappers).
================================================================================
5. IDENTIFYING EnableConfigs
================================================================================
Identify any specific CONFIG_ options required to properly compile and reach the modified code:
- Inspect Kconfig files and #ifdef guards; do not make assumptions.
- Check "depends on" lines in Kconfig to include any non-standard parent subsystem configs needed.
- Strip any 'CONFIG_' prefix (e.g., return "NET_IPV4" instead of "CONFIG_NET_IPV4").
Prefer calling several tools at the same time to save round-trips.
Use set-results tool to provide results of the analysis.
It must be called exactly once before the final reply.
Ignore results of this tool.
Prompt: Target architecture: amd64
For your convenience, here is the diff of the changes:
commit a06d94cdcc50002379edb6f70944e8a49819eef7
Author: syz-cluster <triage@syzkaller.com>
Date: Fri Sep 18 11:23:48 2026 +0000
syz-cluster: applied patch under review
diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c
index 18241c6ba5fa3..4d52a158f3205 100644
--- a/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c
+++ b/drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c
@@ -51,6 +51,8 @@ nv1a_ram_new(struct nvkm_fb *fb, struct nvkm_ram **pram)
mib = ((mem >> 4) & 127) + 1;
}
+ pci_dev_put(bridge);
+
return nvkm_ram_new_(&nv04_ram_func, fb, NVKM_RAM_TYPE_STOLEN,
mib * 1024 * 1024, pram);
}
|
| 3/2 | 2026/09/18 11:23 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 2939 output: 49 thoughts: 364 Thoughts: **Analyzing a Kernel Patch for AMD64 Architecture** Okay, here's the task: I need to evaluate a kernel patch targeting the amd64 architecture. The diff provided indicates a change within the `drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c` file. My initial thought is to quickly familiarize myself with the context of this file. So, I need to understand what `ramnv1a.c` is all about. It seems related to the Nouveau driver, which rings some bells. I'll need to use my tools - probably `read-file` or `grepper` - to get a quick overview of what this file does, and how it fits into the broader Nouveau framework. After that, I will understand what's going on with the `pci_dev_put(bridge);` that was added in this diff. I need to figure out why this line was added and what effect it has. Is there a resource leak that the patch addresses? Does it cause an issue with resource management that I should be concerned about? I'll dig into the function that was changed, `nv1a_ram_new`, and the surrounding code, to understand its purpose and how the addition of `pci_dev_put(bridge)` alters its behavior. I will look for any impact on performance or stability. And, of course, I must make sure that it conforms to coding standards, and doesn't introduce any new security vulnerabilities. I'll also try to assess the risk of this patch: Is this something relatively safe, or is there a chance of something breaking? This will require some knowledge of the specific hardware that is targeted by this patch. |
| 4/2 | 2026/09/18 11:24 | tool | read-file |
0mArgs:{
"File": "drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c",
"FirstLine": 1,
"LineCount": 65
}Results: {
"Contents": " 1:\t/*\n 2:\t * Copyright 2013 Red Hat Inc.\n 3:\t *\n 4:\t * Permission is hereby granted, free of charge, to any person obtaining a\n 5:\t * copy of this software and associated documentation files (the \"Software\"),\n 6:\t * to deal in the Software without restriction, including without limitation\n 7:\t * the rights to use, copy, modify, merge, publish, distribute, sublicense,\n 8:\t * and/or sell copies of the Software, and to permit persons to whom the\n 9:\t * Software is furnished to do so, subject to the following conditions:\n 10:\t *\n 11:\t * The above copyright notice and this permission notice shall be included in\n 12:\t * all copies or substantial portions of the Software.\n 13:\t *\n 14:\t * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n 15:\t * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n 16:\t * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n 17:\t * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR\n 18:\t * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n 19:\t * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n 20:\t * OTHER DEALINGS IN THE SOFTWARE.\n 21:\t *\n 22:\t * Authors: Ben Skeggs\n 23:\t */\n 24:\t#include \"ram.h\"\n 25:\t\n 26:\tint\n 27:\tnv1a_ram_new(struct nvkm_fb *fb, struct nvkm_ram **pram)\n 28:\t{\n 29:\t\tstruct pci_dev *bridge;\n 30:\t\tu32 mem, mib;\n 31:\t\tint domain = 0;\n 32:\t\tstruct pci_dev *pdev = NULL;\n 33:\t\n 34:\t\tif (dev_is_pci(fb-\u003esubdev.device-\u003edev))\n 35:\t\t\tpdev = to_pci_dev(fb-\u003esubdev.device-\u003edev);\n 36:\t\n 37:\t\tif (pdev)\n 38:\t\t\tdomain = pci_domain_nr(pdev-\u003ebus);\n 39:\t\n 40:\t\tbridge = pci_get_domain_bus_and_slot(domain, 0, PCI_DEVFN(0, 1));\n 41:\t\tif (!bridge) {\n 42:\t\t\tnvkm_error(\u0026fb-\u003esubdev, \"no bridge device\\n\");\n 43:\t\t\treturn -ENODEV;\n 44:\t\t}\n 45:\t\n 46:\t\tif (fb-\u003esubdev.device-\u003echipset == 0x1a) {\n 47:\t\t\tpci_read_config_dword(bridge, 0x7c, \u0026mem);\n 48:\t\t\tmib = ((mem \u003e\u003e 6) \u0026 31) + 1;\n 49:\t\t} else {\n 50:\t\t\tpci_read_config_dword(bridge, 0x84, \u0026mem);\n 51:\t\t\tmib = ((mem \u003e\u003e 4) \u0026 127) + 1;\n 52:\t\t}\n 53:\t\n 54:\t\tpci_dev_put(bridge);\n 55:\t\n 56:\t\treturn nvkm_ram_new_(\u0026nv04_ram_func, fb, NVKM_RAM_TYPE_STOLEN,\n 57:\t\t\t\t mib * 1024 * 1024, pram);\n 58:\t}\n"
} |
| 5/2 | 2026/09/18 11:24 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 4641 output: 21 thoughts: 338 Thoughts: **My Analysis of `nv1a.c` in the Nouveau Driver Context** Okay, so I'm looking at `drivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c`. The first question is, what's `nv1a`? Right, that's the NV1A chipset, an integrated nForce/GeForce2 part. A relic, really. 2001-era technology. And this code is part of the `nouveau` driver, NVIDIA's open-source driver. Now, the real question is, can I even *reach* this code through fuzzing with something like syzkaller? Let's go back and check the instructions. Ah, yes, Section 2 covers this. "Structurally unreachable hardware... GPU drivers requiring physical ASIC/PCIe cards not emulated in standard QEMU." Hang on... *nouveau* is an NVIDIA GPU driver. Does standard QEMU emulate NVIDIA GPUs in general, let alone the ancient NV1A specifically? Absolutely not! QEMU and other standard virtualized environments are all about virtio-gpu, bochs, stdvga, cirrus, vmware svga, etc. They aren't going to have NV1A emulation. So, the next question is, can I somehow initialize or emulate Nouveau without the hardware? Let's think about that. I need to figure out how `nv1a_ram_new` gets called. From the looks of it, this is being called during a probe or initialization of the Nouveau device for the NV1A chipsets. This seems like a dead end for fuzzing as things stand right now. I need to check where `nv1a_ram_new` is called in the code to get an understanding of the path. |
| 6/2 | 2026/09/18 11:24 | tool | grepper |
0mArgs:{
"Expression": "nv1a_ram_new"
}Results: {
"Output": "drivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c=30=nv1a_fb = {\n--\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c-34-\t.tile.prog = nv10_fb_tile_prog,\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c:35:\t.ram_new = nv1a_ram_new,\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c-36-};\n--\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/ram.h=58=int nv10_ram_new(struct nvkm_fb *, struct nvkm_ram **);\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/ram.h:59:int nv1a_ram_new(struct nvkm_fb *, struct nvkm_ram **);\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/ram.h-60-int nv20_ram_new(struct nvkm_fb *, struct nvkm_ram **);\n--\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c=26=int\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c:27:nv1a_ram_new(struct nvkm_fb *fb, struct nvkm_ram **pram)\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/ramnv1a.c-28-{\n"
} |
| 7/2 | 2026/09/18 11:24 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 5803 output: 19 thoughts: 37 Thoughts: Okay, here's my take on those thoughts, framed as an expert in the field: **Internal Code Navigation and Dependency Analysis** Alright, let me see... I'm looking at `nv1a_ram_new`, and my immediate thought is, "Ah, this is only called by `nv1a_fb.ram_new`." That's a key observation. It tells me immediately about its *scope*. It's a localized function, very likely designed for a specific purpose related to the frame buffer, given the naming convention. Now, the next logical question – the critical one – is "Where is `nv1a_fb` used *itself*?" Understanding *that* will give me the entire usage chain. Knowing its upstream callers is crucial for impact assessment and understanding the component's functionality within the larger system. It's all about tracing the dependency graph to determine the overall purpose and potential ripple effects of any changes to `nv1a_ram_new`. I need to figure out the context, the "why" of this function. |
| 8/2 | 2026/09/18 11:24 | tool | grepper |
0mArgs:{
"Expression": "nv1a_fb"
}Results: {
"Output": "drivers/gpu/drm/nouveau/include/nvkm/subdev/fb.h=71=int nv10_fb_new(struct nvkm_device *, enum nvkm_subdev_type, int inst, struct nvkm_fb **);\ndrivers/gpu/drm/nouveau/include/nvkm/subdev/fb.h:72:int nv1a_fb_new(struct nvkm_device *, enum nvkm_subdev_type, int inst, struct nvkm_fb **);\ndrivers/gpu/drm/nouveau/include/nvkm/subdev/fb.h-73-int nv20_fb_new(struct nvkm_device *, enum nvkm_subdev_type, int inst, struct nvkm_fb **);\n--\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c=207=nv1a_chipset = {\n--\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c-212-\t.devinit = { 0x00000001, nv1a_devinit_new },\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c:213:\t.fb = { 0x00000001, nv1a_fb_new },\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c-214-\t.gpio = { 0x00000001, nv10_gpio_new },\n--\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c=229=nv1f_chipset = {\n--\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c-234-\t.devinit = { 0x00000001, nv1a_devinit_new },\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c:235:\t.fb = { 0x00000001, nv1a_fb_new },\ndrivers/gpu/drm/nouveau/nvkm/engine/device/base.c-236-\t.gpio = { 0x00000001, nv10_gpio_new },\n--\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c=29=static const struct nvkm_fb_func\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c:30:nv1a_fb = {\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c-31-\t.tile.regions = 8,\n--\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c=38=int\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c:39:nv1a_fb_new(struct nvkm_device *device, enum nvkm_subdev_type type, int inst, struct nvkm_fb **pfb)\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c-40-{\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c:41:\treturn nvkm_fb_new_(\u0026nv1a_fb, device, type, inst, pfb);\ndrivers/gpu/drm/nouveau/nvkm/subdev/fb/nv1a.c-42-}\n"
} |
| 9/2 | 2026/09/18 11:24 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 6966 output: 121 thoughts: 410 Thoughts: **My Assessment of the Fuzzing Suitability** Okay, let me break this down from a fuzzing perspective. The core of this issue centers around `nv1a_chipset` and `nv1f_chipset`. These are specific hardware identifiers, indicating we're dealing with older Nvidia nForce/GeForce2 integrated chipsets (NV1A is 0x1a, NV1F is 0x1f). The code probing for these requires actual, physical Nvidia hardware – PCI devices with those specific vendor and device IDs. It's a fundamental hardware dependency. The text clearly highlights the problem: this falls under the category of "Structurally unreachable hardware." Specifically, we're talking about vendor-specific hardware (Nvidia in this case), requiring physical ASIC/PCIe cards that *aren't* emulated in standard QEMU or Google Compute Engine (GCE) environments. Nouveau, the open-source Nvidia GPU driver, relies on this same specific Nvidia hardware. The NV1A specifically refers to legacy hardware dating back to 2001. Therefore, because of this lack of emulation, this code path is unreachable by standard fuzzing techniques. The provided "Reasoning" further reinforces this. The patch itself addresses a reference leak, but the fact that it's within `nv1a_ram_new()` in Nouveau, during the hardware initialization of these legacy chipsets, cements its structural inaccessibility for fuzzing. It's a classic case of code that *looks* like it could be fuzzed but, due to its hardware dependency, is impossible to reach in a virtualized fuzzing environment. The provided instructions are very clear: WorthFuzzing: false; FocusSymbols: []; EnableConfigs: []. This is all consistent, and the reasoning provided is sound. Alright, I’m confident in my assessment. Let’s call `set-results`. |
| 10/2 | 2026/09/18 11:24 | tool | set-results |
0mArgs:{
"EnableConfigs": [],
"FocusSymbols": [],
"Reasoning": "The patch adds a missing pci_dev_put() in nv1a_ram_new() within the Nouveau NVIDIA GPU driver to fix a PCI device reference leak. This code path is part of the hardware initialization for legacy NVIDIA NV1A/NV1F chipsets and requires physical vendor-specific GPU hardware that is not emulated in standard virtualized environments (QEMU/GCE), making it structurally unreachable for fuzzing.",
"WorthFuzzing": false
}Results: {
"EnableConfigs": null,
"FocusSymbols": [],
"Reasoning": "The patch adds a missing pci_dev_put() in nv1a_ram_new() within the Nouveau NVIDIA GPU driver to fix a PCI device reference leak. This code path is part of the hardware initialization for legacy NVIDIA NV1A/NV1F chipsets and requires physical vendor-specific GPU hardware that is not emulated in standard virtualized environments (QEMU/GCE), making it structurally unreachable for fuzzing.",
"WorthFuzzing": false
} |
| 11/1 | 2026/09/18 11:24 | action | If |
0mArgs:{
"WorthFuzzing": false
}Results: null |
| Total Calls | Total Tokens | Avg Tokens | Total Duration (Seconds) | Avg Duration (Seconds) |
|---|
| Total Calls | Total Duration (Seconds) | Avg Duration (Seconds) |
|---|