| Seq | Timestamp | Type | Name | Duration |
|---|---|---|---|---|
| 0/0 | 2026/10/20 14:09 | flow | patch-triage |
0mArgs:null Results: {
"EnableConfigs": null,
"FocusSymbols": [],
"KMSANReasoning": "",
"NeedsKMSAN": false,
"Reasoning": "The patch modifies xe_pm_runtime_suspend() in drivers/gpu/drm/xe/xe_pm.c, which is part of the Intel Xe GPU driver (CONFIG_DRM_XE). This driver targets Intel Xe/Xe2 GPUs and requires physical Intel graphics PCIe hardware that is not emulated in standard virtualized fuzzing environments (QEMU or GCE). Consequently, the modified code is structurally unreachable for syzkaller fuzzing.",
"WorthFuzzing": false
} |
| 1/1 | 2026/10/20 14:09 | action | read-patch-diff |
0mArgs:null Results: {
"PatchDiff": "commit 8dc8a9b1cbcb9c715afb0b0450a852787108e0d6\nAuthor: syz-cluster \u003ctriage@syzkaller.com\u003e\nDate: Tue Oct 20 14:08:59 2026 +0000\n\n syz-cluster: applied patch under review\n\ndiff --git a/drivers/gpu/drm/xe/xe_pm.c b/drivers/gpu/drm/xe/xe_pm.c\nindex daa7ba2df317a..9bf57ed1ea59e 100644\n--- a/drivers/gpu/drm/xe/xe_pm.c\n+++ b/drivers/gpu/drm/xe/xe_pm.c\n@@ -649,8 +649,16 @@ int xe_pm_runtime_suspend(struct xe_device *xe)\n \n \tif (xe-\u003ed3cold.allowed) {\n \t\terr = xe_bo_evict_all(xe);\n-\t\tif (err)\n+\t\tif (err) {\n+\t\t\t/*\n+\t\t\t * Runtime PM treats errors other than -EAGAIN and\n+\t\t\t * -EBUSY as fatal, so report memory shortage as\n+\t\t\t * transient to allow a later retry.\n+\t\t\t */\n+\t\t\tif (err == -ENOMEM)\n+\t\t\t\terr = -EAGAIN;\n \t\t\tgoto out_resume;\n+\t\t}\n \t}\n \n \tfor_each_gt(gt, xe, id) {\n"
} |
| 2/1 | 2026/10/20 14:09 | agent | patch-evaluator |
0mModel:core Args: null Results: {
"EnableConfigs": null,
"FocusSymbols": [],
"Reasoning": "The patch modifies xe_pm_runtime_suspend() in drivers/gpu/drm/xe/xe_pm.c, which is part of the Intel Xe GPU driver (CONFIG_DRM_XE). This driver targets Intel Xe/Xe2 GPUs and requires physical Intel graphics PCIe hardware that is not emulated in standard virtualized fuzzing environments (QEMU or GCE). Consequently, the modified code is structurally unreachable for syzkaller 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 8dc8a9b1cbcb9c715afb0b0450a852787108e0d6
Author: syz-cluster <triage@syzkaller.com>
Date: Tue Oct 20 14:08:59 2026 +0000
syz-cluster: applied patch under review
diff --git a/drivers/gpu/drm/xe/xe_pm.c b/drivers/gpu/drm/xe/xe_pm.c
index daa7ba2df317a..9bf57ed1ea59e 100644
--- a/drivers/gpu/drm/xe/xe_pm.c
+++ b/drivers/gpu/drm/xe/xe_pm.c
@@ -649,8 +649,16 @@ int xe_pm_runtime_suspend(struct xe_device *xe)
if (xe->d3cold.allowed) {
err = xe_bo_evict_all(xe);
- if (err)
+ if (err) {
+ /*
+ * Runtime PM treats errors other than -EAGAIN and
+ * -EBUSY as fatal, so report memory shortage as
+ * transient to allow a later retry.
+ */
+ if (err == -ENOMEM)
+ err = -EAGAIN;
goto out_resume;
+ }
}
for_each_gt(gt, xe, id) {
|
| 3/2 | 2026/10/20 14:09 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 3085 output: 36 thoughts: 486 Thoughts: **Analyzing a syzkaller Patch for Intel Xe Driver** Okay, so I need to evaluate this patch for syzkaller, and the target architecture is amd64. Straight to it, let's see what we're dealing with. The diff shows a change in `drivers/gpu/drm/xe/xe_pm.c`. That's the Intel Xe driver, specifically related to power management, and the function is `xe_pm_runtime_suspend`. The relevant change is around error handling in `xe_bo_evict_all()`. Looking at it, the patch introduces a check: if `xe_bo_evict_all()` returns `-ENOMEM`, it's now converted to `-EAGAIN`. The comment suggests that Runtime PM in Linux considers most errors as fatal, except for -EAGAIN and -EBUSY, so we treat memory shortage as transient, so there can be a retry later. This makes sense; hitting `-ENOMEM` during a suspend operation is a pretty common failure scenario when resources are tight, and retrying seems like a reasonable approach. Now, a quick sanity check to make sure this isn't some structurally unreachable hardware; let's see if the Intel Xe driver has any specific hardware requirements. I'll need to confirm if it's dependent on any specific hardware setup. I'm going to quickly check `drivers/gpu/drm/xe/Kconfig`. `grepper` or `read-file` will do the trick. If it's something like an FPGA or some obscure PCIe setup, that could be a significant issue, but if it's a standard GPU driver it shouldn't be a problem, so let's verify. |
| 4/2 | 2026/10/20 14:09 | tool | read-file |
0mArgs:{
"File": "drivers/gpu/drm/xe/Kconfig",
"FirstLine": 1,
"LineCount": 60
}Results: {
"Contents": " 1:\t# SPDX-License-Identifier: GPL-2.0-only\n 2:\tconfig DRM_XE\n 3:\t\ttristate \"Intel Xe2 Graphics\"\n 4:\t\tdepends on DRM \u0026\u0026 PCI\n 5:\t\tdepends on KUNIT || !KUNIT\n 6:\t\tdepends on INTEL_VSEC || !INTEL_VSEC\n 7:\t\tdepends on X86_PLATFORM_DEVICES || !(X86 \u0026\u0026 ACPI)\n 8:\t\tdepends on PAGE_SIZE_4KB || COMPILE_TEST || BROKEN\n 9:\t\tselect INTERVAL_TREE\n 10:\t\t# we need shmfs for the swappable backing store, and in particular\n 11:\t\t# the shmem_readpage() which depends upon tmpfs\n 12:\t\tselect SHMEM\n 13:\t\tselect TMPFS\n 14:\t\tselect DRM_BUDDY\n 15:\t\tselect DRM_CLIENT_SELECTION\n 16:\t\tselect DRM_KMS_HELPER\n 17:\t\tselect DRM_KUNIT_TEST_HELPERS if DRM_XE_KUNIT_TEST != n\n 18:\t\tselect DRM_PANEL\n 19:\t\tselect DRM_SUBALLOC_HELPER\n 20:\t\tselect DRM_DISPLAY_DP_HELPER\n 21:\t\tselect DRM_DISPLAY_DSC_HELPER\n 22:\t\tselect DRM_DISPLAY_HDCP_HELPER\n 23:\t\tselect DRM_DISPLAY_HDMI_HELPER\n 24:\t\tselect DRM_DISPLAY_HELPER\n 25:\t\tselect DRM_MIPI_DSI\n 26:\t\tselect RELAY\n 27:\t\tselect IRQ_WORK\n 28:\t\t# xe depends on ACPI_VIDEO when ACPI is enabled\n 29:\t\t# but for select to work, need to select ACPI_VIDEO's dependencies, ick\n 30:\t\tselect BACKLIGHT_CLASS_DEVICE if ACPI\n 31:\t\tselect INPUT if ACPI\n 32:\t\tselect ACPI_VIDEO if X86 \u0026\u0026 ACPI\n 33:\t\tselect ACPI_WMI if X86 \u0026\u0026 ACPI\n 34:\t\tselect SYNC_FILE\n 35:\t\tselect CRC32\n 36:\t\tselect SND_HDA_I915 if SND_HDA_CORE\n 37:\t\tselect CEC_CORE if CEC_NOTIFIER\n 38:\t\tselect VMAP_PFN\n 39:\t\tselect DRM_TTM\n 40:\t\tselect DRM_TTM_HELPER\n 41:\t\tselect DRM_EXEC\n 42:\t\tselect DRM_GPUSVM if !UML\n 43:\t\tselect DRM_GPUVM\n 44:\t\tselect DRM_SCHED\n 45:\t\tselect MMU_NOTIFIER\n 46:\t\tselect WANT_DEV_COREDUMP\n 47:\t\tselect AUXILIARY_BUS\n 48:\t\tselect REGMAP if I2C\n 49:\t\thelp\n 50:\t\t Driver for Intel Xe2 series GPUs and later. Experimental support\n 51:\t\t for Xe series is also available.\n 52:\t\n 53:\t\t If \"M\" is selected, the module will be called xe.\n 54:\t\n 55:\tconfig DRM_XE_DISPLAY\n 56:\t\tbool \"Enable display support\"\n 57:\t\tdepends on DRM_XE \u0026\u0026 DRM_XE=m \u0026\u0026 HAS_IOPORT\n 58:\t\tselect FB_IOMEM_HELPERS if DRM_FBDEV_EMULATION\n 59:\t\tselect I2C\n 60:\t\tselect I2C_ALGOBIT\n"
} |
| 5/2 | 2026/10/20 14:09 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 4854 output: 36 thoughts: 56 Thoughts: Okay, let's dive into this. Here's how I'd approach understanding the Intel Xe device probing and binding process, as if I were thinking it through: **Intel Xe Graphics Device Deep Dive** Right, let's get down to brass tacks. I need to understand exactly how the system identifies and binds an Intel Xe graphics device. First, I'm assuming we're dealing with a physical PCIe device – Intel Iris Xe, Arc, or one of the newer Xe2 variants. The core question is: how is this hardware recognized by the kernel? My instinct tells me the best place to start would be within the kernel's Direct Rendering Manager (DRM) drivers, specifically the `xe` driver directory, likely under `drivers/gpu/drm/xe`. I know the DRM is the standard interface, so I'll zero in on the `pci_device_id` data structure within that driver. That's the gateway. That's where the vendor and device IDs are defined and where the kernel knows what to look for on the PCI bus. I need to scrutinize how those IDs are constructed, what PCI IDs are associated with what Xe generation, and how the driver uses this list to claim a specific device and bind itself. This is where the magic happens. |
| 6/2 | 2026/10/20 14:09 | tool | grepper |
0mArgs:{
"Expression": "MODULE_DEVICE_TABLE\\(pci",
"PathPrefixes": [
"drivers/gpu/drm/xe"
]
}Results: {
"Output": "drivers/gpu/drm/xe/xe_pci.c=523=static const struct pci_device_id pciidlist[] = {\n--\ndrivers/gpu/drm/xe/xe_pci.c-545-};\ndrivers/gpu/drm/xe/xe_pci.c:546:MODULE_DEVICE_TABLE(pci, pciidlist);\ndrivers/gpu/drm/xe/xe_pci.c-547-\n"
} |
| 7/2 | 2026/10/20 14:09 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 5342 output: 42 thoughts: 19 Thoughts: Okay, here's my take on those thoughts, tailored for an expert audience: **Diving into xe_pci.c and pciidlist** Alright, time to get to the heart of the matter. I need to refresh my memory on how this is handled in `xe_pci.c`. The first thing that comes to mind is the `pciidlist`. I'm going to quickly check in there because that's usually where the breadcrumbs start for matching PCI devices. I want to see how the vendor and device IDs are organized, how the driver binding is defined, and if there's any immediate indication of what's going on with this specific device I'm dealing with. I’m hoping it's straightforward, but you know how it goes; sometimes it’s a quick win, other times it’s the tip of the iceberg. This will be my initial diagnostic step to map the PCI device and determine the course of action. |
| 8/2 | 2026/10/20 14:09 | tool | read-file |
0mArgs:{
"File": "drivers/gpu/drm/xe/xe_pci.c",
"FirstLine": 520,
"LineCount": 35
}Results: {
"Contents": " 520:\t * and subvendor IDs, we need it to come before the more general IVB\n 521:\t * PCI ID matches, otherwise we'll use the wrong info struct above.\n 522:\t */\n 523:\tstatic const struct pci_device_id pciidlist[] = {\n 524:\t\tINTEL_TGL_IDS(INTEL_VGA_DEVICE, \u0026tgl_desc),\n 525:\t\tINTEL_RKL_IDS(INTEL_VGA_DEVICE, \u0026rkl_desc),\n 526:\t\tINTEL_ADLS_IDS(INTEL_VGA_DEVICE, \u0026adl_s_desc),\n 527:\t\tINTEL_ADLP_IDS(INTEL_VGA_DEVICE, \u0026adl_p_desc),\n 528:\t\tINTEL_ADLN_IDS(INTEL_VGA_DEVICE, \u0026adl_n_desc),\n 529:\t\tINTEL_RPLU_IDS(INTEL_VGA_DEVICE, \u0026adl_p_desc),\n 530:\t\tINTEL_RPLP_IDS(INTEL_VGA_DEVICE, \u0026adl_p_desc),\n 531:\t\tINTEL_RPLS_IDS(INTEL_VGA_DEVICE, \u0026adl_s_desc),\n 532:\t\tINTEL_DG1_IDS(INTEL_VGA_DEVICE, \u0026dg1_desc),\n 533:\t\tINTEL_ATS_M_IDS(INTEL_VGA_DEVICE, \u0026ats_m_desc),\n 534:\t\tINTEL_ARL_IDS(INTEL_VGA_DEVICE, \u0026mtl_desc),\n 535:\t\tINTEL_DG2_IDS(INTEL_VGA_DEVICE, \u0026dg2_desc),\n 536:\t\tINTEL_MTL_IDS(INTEL_VGA_DEVICE, \u0026mtl_desc),\n 537:\t\tINTEL_LNL_IDS(INTEL_VGA_DEVICE, \u0026lnl_desc),\n 538:\t\tINTEL_BMG_IDS(INTEL_VGA_DEVICE, \u0026bmg_desc),\n 539:\t\tINTEL_PTL_IDS(INTEL_VGA_DEVICE, \u0026ptl_desc),\n 540:\t\tINTEL_WCL_IDS(INTEL_VGA_DEVICE, \u0026ptl_desc),\n 541:\t\tINTEL_NVLS_IDS(INTEL_VGA_DEVICE, \u0026nvls_desc),\n 542:\t\tINTEL_CRI_IDS(INTEL_PCI_DEVICE, \u0026cri_desc),\n 543:\t\tINTEL_NVLP_IDS(INTEL_VGA_DEVICE, \u0026nvlp_desc),\n 544:\t\t{ }\n 545:\t};\n 546:\tMODULE_DEVICE_TABLE(pci, pciidlist);\n 547:\t\n 548:\t/* is device_id present in comma separated list of ids */\n 549:\tstatic bool device_id_in_list(u16 device_id, const char *devices, bool negative)\n 550:\t{\n 551:\t\tchar *s, *p, *tok;\n 552:\t\tbool ret;\n 553:\t\n 554:\t\tif (!devices || !*devices)\n"
} |
| 9/2 | 2026/10/20 14:09 | llm | patch-evaluator |
0mModel:gemini-3.8-flash Args: null Results: null Tokens: input: 6441 output: 126 thoughts: 1153 Thoughts: **Analysis of Intel Xe GPU Driver Fuzzing Applicability** Okay, so I've been looking at this patch and its implications for fuzzing, specifically with syzkaller. The key here is the Intel Xe GPU driver (`drivers/gpu/drm/xe`). I immediately recognize the landscape: Tiger Lake, Rocket Lake, Alder Lake, the whole lot – all the Intel Xe generations. But here's the kicker, and this is crucial: *none* of these GPUs are emulated by standard QEMU or GCE configurations. We're talking cirrus, stdvga, bochs-display, virtio-gpu, qxl, vmware-svga – none of those even touch an Intel Xe emulation. The patch itself modifies `xe_pm_runtime_suspend`, which is part of the runtime power management for the Xe driver. This function is only ever hit when a *real* Intel Xe device is present and the system attempts to suspend it. I need to make sure this is not an easily reachable part of the code base. My initial assumption here is that this is structurally unreachable in the standard fuzzing setup, but I need to be absolutely sure. I went through the standard tests to verify my assumption. I looked for virtual or mock devices for Xe that would allow testing without real hardware, but there aren't any (e.g., no `vkms` equivalents). Xe is a PCI driver through and through: `pci_register_driver(&xe_pci_driver)`. Syzkaller, running in QEMU/GCE, *will not* have an Intel Xe GPU probed. I looked through the KUnit tests, and they're not touched by this patch. I then revisited the criteria for determining if code is "WorthFuzzing." The instructions clearly state that code involving "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" should be marked as false. Intel Xe falls *precisely* into this category. The driver is vendor-specific, the code requires a physical Intel Xe/Xe2 GPU, and it *absolutely* needs PCIe hardware that's not emulated. Therefore, the `WorthFuzzing` parameter is `false`. There is no reason to think that this code is reachable by syzkaller. Consequently, `EnableConfigs` and `FocusSymbols` are empty, and the reasoning is a concise explanation of the situation. I need to note that this is a structurally unreachable section of code for this fuzzing setup. I have validated all of the parameters. I am now confident in calling `set-results`. |
| 10/2 | 2026/10/20 14:09 | tool | set-results |
0mArgs:{
"EnableConfigs": [],
"FocusSymbols": [],
"Reasoning": "The patch modifies xe_pm_runtime_suspend() in drivers/gpu/drm/xe/xe_pm.c, which is part of the Intel Xe GPU driver (CONFIG_DRM_XE). This driver targets Intel Xe/Xe2 GPUs and requires physical Intel graphics PCIe hardware that is not emulated in standard virtualized fuzzing environments (QEMU or GCE). Consequently, the modified code is structurally unreachable for syzkaller fuzzing.",
"WorthFuzzing": false
}Results: {
"EnableConfigs": null,
"FocusSymbols": [],
"Reasoning": "The patch modifies xe_pm_runtime_suspend() in drivers/gpu/drm/xe/xe_pm.c, which is part of the Intel Xe GPU driver (CONFIG_DRM_XE). This driver targets Intel Xe/Xe2 GPUs and requires physical Intel graphics PCIe hardware that is not emulated in standard virtualized fuzzing environments (QEMU or GCE). Consequently, the modified code is structurally unreachable for syzkaller fuzzing.",
"WorthFuzzing": false
} |
| 11/1 | 2026/10/20 14:09 | 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) |
|---|