AI Trajectory


Trajectory: (Expand/Collapse All)
Seq Timestamp Type Name Duration
0/0 2026/10/25 07:20 flow patch-triage
0m Args:
null

Results:
{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "KMSANReasoning": "",
  "NeedsKMSAN": false,
  "Reasoning": "The patch modifies Rx handling and NAPI polling logic (igc_clean_rx_irq, igc_clean_rx_irq_zc, etc.) in the Intel Ethernet Controller I225/I226 (igc) driver. This driver targets vendor-specific PCIe hardware that is not emulated in standard virtualized environments (QEMU/GCE), making the modified code structurally unreachable for syzkaller.",
  "WorthFuzzing": false
}

1/1 2026/10/25 07:20 action read-patch-diff
0m Args:
null

Results:
{
  "PatchDiff": "commit 367ceb3c2a900af5ed085b7e2cff6f8950d73978\nAuthor: syz-cluster \u003ctriage@syzkaller.com\u003e\nDate:   Sun Oct 25 07:20:55 2026 +0000\n\n    syz-cluster: applied patch under review\n\ndiff --git a/drivers/net/ethernet/intel/igc/igc.h b/drivers/net/ethernet/intel/igc/igc.h\nindex 17f213cc93e45..635d49701e629 100644\n--- a/drivers/net/ethernet/intel/igc/igc.h\n+++ b/drivers/net/ethernet/intel/igc/igc.h\n@@ -198,6 +198,7 @@ struct igc_ring {\n \t\t\tstruct igc_rx_packet_stats pkt_stats;\n \t\t\tstruct u64_stats_sync rx_syncp;\n \t\t\tstruct sk_buff *skb;\n+\t\t\tbool rx_in_frame;\n \t\t};\n \t};\n \ndiff --git a/drivers/net/ethernet/intel/igc/igc_main.c b/drivers/net/ethernet/intel/igc/igc_main.c\nindex 1fb5f3cbe93c5..9ca5558c762c9 100644\n--- a/drivers/net/ethernet/intel/igc/igc_main.c\n+++ b/drivers/net/ethernet/intel/igc/igc_main.c\n@@ -474,6 +474,7 @@ static void igc_clean_rx_ring(struct igc_ring *ring)\n \t\tigc_clean_rx_ring_page_shared(ring);\n \n \tclear_ring_uses_large_buffer(ring);\n+\tring-\u003erx_in_frame = false;\n \n \tring-\u003enext_to_alloc = 0;\n \tring-\u003enext_to_clean = 0;\n@@ -673,6 +674,7 @@ static void igc_configure_rx_ring(struct igc_adapter *adapter,\n \t/* reset next-to- use/clean to place SW in sync with hardware */\n \tring-\u003enext_to_clean = 0;\n \tring-\u003enext_to_use = 0;\n+\tring-\u003erx_in_frame = false;\n \n \tif (ring-\u003exsk_pool)\n \t\tbuf_size = xsk_pool_get_rx_frame_size(ring-\u003exsk_pool);\n@@ -2111,10 +2113,8 @@ static bool igc_can_reuse_rx_page(struct igc_rx_buffer *rx_buffer,\n  * @rx_ring: Rx ring being processed\n  * @rx_desc: Rx descriptor for current buffer\n  *\n- * This function updates next to clean.  If the buffer is an EOP buffer\n- * this function exits returning false, otherwise it will place the\n- * sk_buff in the next buffer to be chained and return true indicating\n- * that this is in fact a non-EOP buffer.\n+ * Advance next to clean and retain frame position for the next descriptor.\n+ * Return true if the consumed descriptor does not end the frame.\n  */\n static bool igc_is_non_eop(struct igc_ring *rx_ring,\n \t\t\t   union igc_adv_rx_desc *rx_desc)\n@@ -2127,10 +2127,8 @@ static bool igc_is_non_eop(struct igc_ring *rx_ring,\n \n \tprefetch(IGC_RX_DESC(rx_ring, ntc));\n \n-\tif (likely(igc_test_staterr(rx_desc, IGC_RXD_STAT_EOP)))\n-\t\treturn false;\n-\n-\treturn true;\n+\trx_ring-\u003erx_in_frame = !igc_test_staterr(rx_desc, IGC_RXD_STAT_EOP);\n+\treturn unlikely(rx_ring-\u003erx_in_frame);\n }\n \n /**\n@@ -2601,7 +2599,7 @@ static void igc_update_rx_stats(struct igc_q_vector *q_vector,\n \n static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n {\n-\tunsigned int total_bytes = 0, total_packets = 0;\n+\tunsigned int total_bytes = 0, total_packets = 0, work_done = 0;\n \tstruct igc_adapter *adapter = q_vector-\u003eadapter;\n \tstruct igc_ring *rx_ring = q_vector-\u003erx.ring;\n \tstruct sk_buff *skb = rx_ring-\u003eskb;\n@@ -2609,13 +2607,15 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \tint xdp_status = 0, rx_buffer_pgcnt;\n \tint xdp_res = 0;\n \n-\twhile (likely(total_packets \u003c budget)) {\n+\twhile (likely(work_done \u003c budget)) {\n \t\tstruct igc_xdp_buff ctx = { .rx_ts = NULL };\n+\t\tbool first = !rx_ring-\u003erx_in_frame;\n \t\tstruct igc_rx_buffer *rx_buffer;\n \t\tunion igc_adv_rx_desc *rx_desc;\n \t\tunsigned int size, truesize;\n \t\tint pkt_offset = 0;\n \t\tvoid *pktbuf;\n+\t\tbool tsip;\n \n \t\t/* return some buffers to hardware, one at a time is too slow */\n \t\tif (cleaned_count \u003e= IGC_RX_BUFFER_WRITE) {\n@@ -2635,21 +2635,34 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \t\tdma_rmb();\n \n \t\trx_buffer = igc_get_rx_buffer(rx_ring, size, \u0026rx_buffer_pgcnt);\n+\t\ttsip = first \u0026\u0026 igc_test_staterr(rx_desc, IGC_RXDADV_STAT_TSIP);\n+\n+\t\tif ((!first \u0026\u0026 !skb) ||\n+\t\t    (first \u0026\u0026 igc_xdp_is_enabled(adapter) \u0026\u0026\n+\t\t     !igc_test_staterr(rx_desc, IGC_RXD_STAT_EOP)) ||\n+\t\t    unlikely(tsip \u0026\u0026 size \u003c IGC_TS_HDR_LEN)) {\n+\t\t\tif (first)\n+\t\t\t\tdev_core_stats_rx_dropped_inc(rx_ring-\u003enetdev);\n+\t\t\txdp_res = IGC_XDP_CONSUMED;\n+\t\t\tgoto xdp_done;\n+\t\t}\n+\n \t\ttruesize = igc_get_rx_frame_truesize(rx_ring, size);\n \n \t\tpktbuf = page_address(rx_buffer-\u003epage) + rx_buffer-\u003epage_offset;\n \n-\t\tif (igc_test_staterr(rx_desc, IGC_RXDADV_STAT_TSIP)) {\n+\t\tif (tsip) {\n \t\t\tctx.rx_ts = pktbuf;\n \t\t\tpkt_offset = IGC_TS_HDR_LEN;\n \t\t\tsize -= IGC_TS_HDR_LEN;\n \t\t}\n \n-\t\tif (igc_fpe_is_pmac_enabled(adapter) \u0026\u0026\n+\t\tif (first \u0026\u0026 igc_fpe_is_pmac_enabled(adapter) \u0026\u0026\n \t\t    igc_fpe_handle_mpacket(adapter, rx_desc, size, pktbuf + pkt_offset)) {\n \t\t\t/* Advance the ring next-to-clean */\n \t\t\tigc_is_non_eop(rx_ring, rx_desc);\n \t\t\tcleaned_count++;\n+\t\t\twork_done++;\n \t\t\tcontinue;\n \t\t}\n \n@@ -2664,6 +2677,12 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \t\t\txdp_res = igc_xdp_run_prog(adapter, \u0026ctx.xdp);\n \t\t}\n \n+\t\tif (xdp_res) {\n+\t\t\ttotal_bytes += size;\n+\t\t\ttotal_packets++;\n+\t\t}\n+\n+xdp_done:\n \t\tif (xdp_res) {\n \t\t\tswitch (xdp_res) {\n \t\t\tcase IGC_XDP_CONSUMED:\n@@ -2676,8 +2695,7 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \t\t\t\tbreak;\n \t\t\t}\n \n-\t\t\ttotal_packets++;\n-\t\t\ttotal_bytes += size;\n+\t\t\twork_done++;\n \t\t} else if (skb)\n \t\t\tigc_add_rx_frag(rx_ring, rx_buffer, skb, size);\n \t\telse if (ring_uses_build_skb(rx_ring))\n@@ -2700,8 +2718,15 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \t\tif (igc_is_non_eop(rx_ring, rx_desc))\n \t\t\tcontinue;\n \n+\t\tif (xdp_res) {\n+\t\t\tskb = NULL;\n+\t\t\tcontinue;\n+\t\t}\n+\n+\t\twork_done++;\n+\n \t\t/* verify the packet layout is correct */\n-\t\tif (xdp_res || igc_cleanup_headers(rx_ring, rx_desc, skb)) {\n+\t\tif (igc_cleanup_headers(rx_ring, rx_desc, skb)) {\n \t\t\tskb = NULL;\n \t\t\tcontinue;\n \t\t}\n@@ -2717,7 +2742,6 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \t\t/* reset skb pointer */\n \t\tskb = NULL;\n \n-\t\t/* update budget accounting */\n \t\ttotal_packets++;\n \t}\n \n@@ -2732,7 +2756,7 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)\n \tif (cleaned_count)\n \t\tigc_alloc_rx_buffers(rx_ring, cleaned_count);\n \n-\treturn total_packets;\n+\treturn work_done;\n }\n \n static struct sk_buff *igc_construct_skb_zc(struct igc_ring *ring,\n@@ -2797,10 +2821,10 @@ static struct igc_xdp_buff *xsk_buff_to_igc_ctx(struct xdp_buff *xdp)\n \n static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)\n {\n+\tint total_bytes = 0, total_packets = 0, work_done = 0;\n \tstruct igc_adapter *adapter = q_vector-\u003eadapter;\n \tstruct igc_ring *ring = q_vector-\u003erx.ring;\n \tu16 cleaned_count = igc_desc_unused(ring);\n-\tint total_bytes = 0, total_packets = 0;\n \tu16 ntc = ring-\u003enext_to_clean;\n \tstruct bpf_prog *prog;\n \tbool failure = false;\n@@ -2810,11 +2834,13 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)\n \n \tprog = READ_ONCE(adapter-\u003exdp_prog);\n \n-\twhile (likely(total_packets \u003c budget)) {\n+\twhile (likely(work_done \u003c budget)) {\n+\t\tbool first = !ring-\u003erx_in_frame;\n \t\tunion igc_adv_rx_desc *desc;\n \t\tstruct igc_rx_buffer *bi;\n \t\tstruct igc_xdp_buff *ctx;\n \t\tunsigned int size;\n+\t\tbool eop, tsip;\n \t\tint res;\n \n \t\tdesc = IGC_RX_DESC(ring, ntc);\n@@ -2829,11 +2855,20 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)\n \t\tdma_rmb();\n \n \t\tbi = \u0026ring-\u003erx_buffer_info[ntc];\n+\t\ttsip = first \u0026\u0026 igc_test_staterr(desc, IGC_RXDADV_STAT_TSIP);\n+\t\teop = igc_test_staterr(desc, IGC_RXD_STAT_EOP);\n+\n+\t\tif (!first || !eop || unlikely(tsip \u0026\u0026 size \u003c IGC_TS_HDR_LEN)) {\n+\t\t\tif (first)\n+\t\t\t\tdev_core_stats_rx_dropped_inc(ring-\u003enetdev);\n+\t\t\tres = IGC_XDP_CONSUMED;\n+\t\t\tgoto xdp_done;\n+\t\t}\n \n \t\tctx = xsk_buff_to_igc_ctx(bi-\u003exdp);\n \t\tctx-\u003erx_desc = desc;\n \n-\t\tif (igc_test_staterr(desc, IGC_RXDADV_STAT_TSIP)) {\n+\t\tif (tsip) {\n \t\t\tctx-\u003erx_ts = bi-\u003exdp-\u003edata;\n \n \t\t\tbi-\u003exdp-\u003edata += IGC_TS_HDR_LEN;\n@@ -2851,6 +2886,10 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)\n \t\txsk_buff_dma_sync_for_cpu(bi-\u003exdp);\n \n \t\tres = __igc_xdp_run_prog(adapter, prog, bi-\u003exdp);\n+\t\ttotal_bytes += size;\n+\t\ttotal_packets++;\n+\n+xdp_done:\n \t\tswitch (res) {\n \t\tcase IGC_XDP_PASS:\n \t\t\tigc_dispatch_skb_zc(q_vector, desc, ctx);\n@@ -2865,8 +2904,8 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)\n \t\t}\n \n \t\tbi-\u003exdp = NULL;\n-\t\ttotal_bytes += size;\n-\t\ttotal_packets++;\n+\t\tring-\u003erx_in_frame = !eop;\n+\t\twork_done++;\n \t\tcleaned_count++;\n \t\tntc++;\n \t\tif (ntc == ring-\u003ecount)\n@@ -2889,10 +2928,10 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)\n \t\t\txsk_set_rx_need_wakeup(ring-\u003exsk_pool);\n \t\telse\n \t\t\txsk_clear_rx_need_wakeup(ring-\u003exsk_pool);\n-\t\treturn total_packets;\n+\t\treturn work_done;\n \t}\n \n-\treturn failure ? budget : total_packets;\n+\treturn failure ? budget : work_done;\n }\n \n static void igc_update_tx_stats(struct igc_q_vector *q_vector,\n"
}

2/1 2026/10/25 07:20 agent patch-evaluator
0m Model:
core

Args:
null

Results:
{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch modifies Rx handling and NAPI polling logic (igc_clean_rx_irq, igc_clean_rx_irq_zc, etc.) in the Intel Ethernet Controller I225/I226 (igc) driver. This driver targets vendor-specific PCIe hardware that is not emulated in standard virtualized environments (QEMU/GCE), making the modified code structurally unreachable for syzkaller.",
  "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 367ceb3c2a900af5ed085b7e2cff6f8950d73978
Author: syz-cluster <triage@syzkaller.com>
Date:   Sun Oct 25 07:20:55 2026 +0000

    syz-cluster: applied patch under review

diff --git a/drivers/net/ethernet/intel/igc/igc.h b/drivers/net/ethernet/intel/igc/igc.h
index 17f213cc93e45..635d49701e629 100644
--- a/drivers/net/ethernet/intel/igc/igc.h
+++ b/drivers/net/ethernet/intel/igc/igc.h
@@ -198,6 +198,7 @@ struct igc_ring {
 			struct igc_rx_packet_stats pkt_stats;
 			struct u64_stats_sync rx_syncp;
 			struct sk_buff *skb;
+			bool rx_in_frame;
 		};
 	};
 
diff --git a/drivers/net/ethernet/intel/igc/igc_main.c b/drivers/net/ethernet/intel/igc/igc_main.c
index 1fb5f3cbe93c5..9ca5558c762c9 100644
--- a/drivers/net/ethernet/intel/igc/igc_main.c
+++ b/drivers/net/ethernet/intel/igc/igc_main.c
@@ -474,6 +474,7 @@ static void igc_clean_rx_ring(struct igc_ring *ring)
 		igc_clean_rx_ring_page_shared(ring);
 
 	clear_ring_uses_large_buffer(ring);
+	ring->rx_in_frame = false;
 
 	ring->next_to_alloc = 0;
 	ring->next_to_clean = 0;
@@ -673,6 +674,7 @@ static void igc_configure_rx_ring(struct igc_adapter *adapter,
 	/* reset next-to- use/clean to place SW in sync with hardware */
 	ring->next_to_clean = 0;
 	ring->next_to_use = 0;
+	ring->rx_in_frame = false;
 
 	if (ring->xsk_pool)
 		buf_size = xsk_pool_get_rx_frame_size(ring->xsk_pool);
@@ -2111,10 +2113,8 @@ static bool igc_can_reuse_rx_page(struct igc_rx_buffer *rx_buffer,
  * @rx_ring: Rx ring being processed
  * @rx_desc: Rx descriptor for current buffer
  *
- * This function updates next to clean.  If the buffer is an EOP buffer
- * this function exits returning false, otherwise it will place the
- * sk_buff in the next buffer to be chained and return true indicating
- * that this is in fact a non-EOP buffer.
+ * Advance next to clean and retain frame position for the next descriptor.
+ * Return true if the consumed descriptor does not end the frame.
  */
 static bool igc_is_non_eop(struct igc_ring *rx_ring,
 			   union igc_adv_rx_desc *rx_desc)
@@ -2127,10 +2127,8 @@ static bool igc_is_non_eop(struct igc_ring *rx_ring,
 
 	prefetch(IGC_RX_DESC(rx_ring, ntc));
 
-	if (likely(igc_test_staterr(rx_desc, IGC_RXD_STAT_EOP)))
-		return false;
-
-	return true;
+	rx_ring->rx_in_frame = !igc_test_staterr(rx_desc, IGC_RXD_STAT_EOP);
+	return unlikely(rx_ring->rx_in_frame);
 }
 
 /**
@@ -2601,7 +2599,7 @@ static void igc_update_rx_stats(struct igc_q_vector *q_vector,
 
 static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 {
-	unsigned int total_bytes = 0, total_packets = 0;
+	unsigned int total_bytes = 0, total_packets = 0, work_done = 0;
 	struct igc_adapter *adapter = q_vector->adapter;
 	struct igc_ring *rx_ring = q_vector->rx.ring;
 	struct sk_buff *skb = rx_ring->skb;
@@ -2609,13 +2607,15 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 	int xdp_status = 0, rx_buffer_pgcnt;
 	int xdp_res = 0;
 
-	while (likely(total_packets < budget)) {
+	while (likely(work_done < budget)) {
 		struct igc_xdp_buff ctx = { .rx_ts = NULL };
+		bool first = !rx_ring->rx_in_frame;
 		struct igc_rx_buffer *rx_buffer;
 		union igc_adv_rx_desc *rx_desc;
 		unsigned int size, truesize;
 		int pkt_offset = 0;
 		void *pktbuf;
+		bool tsip;
 
 		/* return some buffers to hardware, one at a time is too slow */
 		if (cleaned_count >= IGC_RX_BUFFER_WRITE) {
@@ -2635,21 +2635,34 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 		dma_rmb();
 
 		rx_buffer = igc_get_rx_buffer(rx_ring, size, &rx_buffer_pgcnt);
+		tsip = first && igc_test_staterr(rx_desc, IGC_RXDADV_STAT_TSIP);
+
+		if ((!first && !skb) ||
+		    (first && igc_xdp_is_enabled(adapter) &&
+		     !igc_test_staterr(rx_desc, IGC_RXD_STAT_EOP)) ||
+		    unlikely(tsip && size < IGC_TS_HDR_LEN)) {
+			if (first)
+				dev_core_stats_rx_dropped_inc(rx_ring->netdev);
+			xdp_res = IGC_XDP_CONSUMED;
+			goto xdp_done;
+		}
+
 		truesize = igc_get_rx_frame_truesize(rx_ring, size);
 
 		pktbuf = page_address(rx_buffer->page) + rx_buffer->page_offset;
 
-		if (igc_test_staterr(rx_desc, IGC_RXDADV_STAT_TSIP)) {
+		if (tsip) {
 			ctx.rx_ts = pktbuf;
 			pkt_offset = IGC_TS_HDR_LEN;
 			size -= IGC_TS_HDR_LEN;
 		}
 
-		if (igc_fpe_is_pmac_enabled(adapter) &&
+		if (first && igc_fpe_is_pmac_enabled(adapter) &&
 		    igc_fpe_handle_mpacket(adapter, rx_desc, size, pktbuf + pkt_offset)) {
 			/* Advance the ring next-to-clean */
 			igc_is_non_eop(rx_ring, rx_desc);
 			cleaned_count++;
+			work_done++;
 			continue;
 		}
 
@@ -2664,6 +2677,12 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 			xdp_res = igc_xdp_run_prog(adapter, &ctx.xdp);
 		}
 
+		if (xdp_res) {
+			total_bytes += size;
+			total_packets++;
+		}
+
+xdp_done:
 		if (xdp_res) {
 			switch (xdp_res) {
 			case IGC_XDP_CONSUMED:
@@ -2676,8 +2695,7 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 				break;
 			}
 
-			total_packets++;
-			total_bytes += size;
+			work_done++;
 		} else if (skb)
 			igc_add_rx_frag(rx_ring, rx_buffer, skb, size);
 		else if (ring_uses_build_skb(rx_ring))
@@ -2700,8 +2718,15 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 		if (igc_is_non_eop(rx_ring, rx_desc))
 			continue;
 
+		if (xdp_res) {
+			skb = NULL;
+			continue;
+		}
+
+		work_done++;
+
 		/* verify the packet layout is correct */
-		if (xdp_res || igc_cleanup_headers(rx_ring, rx_desc, skb)) {
+		if (igc_cleanup_headers(rx_ring, rx_desc, skb)) {
 			skb = NULL;
 			continue;
 		}
@@ -2717,7 +2742,6 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 		/* reset skb pointer */
 		skb = NULL;
 
-		/* update budget accounting */
 		total_packets++;
 	}
 
@@ -2732,7 +2756,7 @@ static int igc_clean_rx_irq(struct igc_q_vector *q_vector, const int budget)
 	if (cleaned_count)
 		igc_alloc_rx_buffers(rx_ring, cleaned_count);
 
-	return total_packets;
+	return work_done;
 }
 
 static struct sk_buff *igc_construct_skb_zc(struct igc_ring *ring,
@@ -2797,10 +2821,10 @@ static struct igc_xdp_buff *xsk_buff_to_igc_ctx(struct xdp_buff *xdp)
 
 static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)
 {
+	int total_bytes = 0, total_packets = 0, work_done = 0;
 	struct igc_adapter *adapter = q_vector->adapter;
 	struct igc_ring *ring = q_vector->rx.ring;
 	u16 cleaned_count = igc_desc_unused(ring);
-	int total_bytes = 0, total_packets = 0;
 	u16 ntc = ring->next_to_clean;
 	struct bpf_prog *prog;
 	bool failure = false;
@@ -2810,11 +2834,13 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)
 
 	prog = READ_ONCE(adapter->xdp_prog);
 
-	while (likely(total_packets < budget)) {
+	while (likely(work_done < budget)) {
+		bool first = !ring->rx_in_frame;
 		union igc_adv_rx_desc *desc;
 		struct igc_rx_buffer *bi;
 		struct igc_xdp_buff *ctx;
 		unsigned int size;
+		bool eop, tsip;
 		int res;
 
 		desc = IGC_RX_DESC(ring, ntc);
@@ -2829,11 +2855,20 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)
 		dma_rmb();
 
 		bi = &ring->rx_buffer_info[ntc];
+		tsip = first && igc_test_staterr(desc, IGC_RXDADV_STAT_TSIP);
+		eop = igc_test_staterr(desc, IGC_RXD_STAT_EOP);
+
+		if (!first || !eop || unlikely(tsip && size < IGC_TS_HDR_LEN)) {
+			if (first)
+				dev_core_stats_rx_dropped_inc(ring->netdev);
+			res = IGC_XDP_CONSUMED;
+			goto xdp_done;
+		}
 
 		ctx = xsk_buff_to_igc_ctx(bi->xdp);
 		ctx->rx_desc = desc;
 
-		if (igc_test_staterr(desc, IGC_RXDADV_STAT_TSIP)) {
+		if (tsip) {
 			ctx->rx_ts = bi->xdp->data;
 
 			bi->xdp->data += IGC_TS_HDR_LEN;
@@ -2851,6 +2886,10 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)
 		xsk_buff_dma_sync_for_cpu(bi->xdp);
 
 		res = __igc_xdp_run_prog(adapter, prog, bi->xdp);
+		total_bytes += size;
+		total_packets++;
+
+xdp_done:
 		switch (res) {
 		case IGC_XDP_PASS:
 			igc_dispatch_skb_zc(q_vector, desc, ctx);
@@ -2865,8 +2904,8 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)
 		}
 
 		bi->xdp = NULL;
-		total_bytes += size;
-		total_packets++;
+		ring->rx_in_frame = !eop;
+		work_done++;
 		cleaned_count++;
 		ntc++;
 		if (ntc == ring->count)
@@ -2889,10 +2928,10 @@ static int igc_clean_rx_irq_zc(struct igc_q_vector *q_vector, const int budget)
 			xsk_set_rx_need_wakeup(ring->xsk_pool);
 		else
 			xsk_clear_rx_need_wakeup(ring->xsk_pool);
-		return total_packets;
+		return work_done;
 	}
 
-	return failure ? budget : total_packets;
+	return failure ? budget : work_done;
 }
 
 static void igc_update_tx_stats(struct igc_q_vector *q_vector,

3/2 2026/10/25 07:20 llm patch-evaluator
0m Model:
gemini-3.8-flash

Args:
null

Results:
null

Tokens:
							input: 6618
							output: 36
							thoughts: 142
						

Thoughts:
**Evaluating this Patch Series**

Okay, let's get down to brass tacks. I need to understand the impact of this patch series. First things first: let's identify the files that are modified. Ah, I see: `drivers/net/ethernet/intel/igc/igc.h` and `drivers/net/ethernet/intel/igc/igc_main.c`. Right, IGC... that's Intel's 2.5G Ethernet Controller, specifically something like the I225 or I226. Now, before I jump to any conclusions, I need to get a better handle on the scope of this change within the IGC driver. I'll need to double-check the configuration options and see if this impacts any specific features or dependencies. Let me consult the `Kconfig` file in the IGC directory, or maybe I'll just use `grepper` or `read-file` to get a quick overview of relevant areas. Gotta make sure I understand the full context before diving into a deep analysis of the code itself.



4/2 2026/10/25 07:21 tool grepper
0m Error:
no matches

Args:
{
  "Expression": "config IGC",
  "PathPrefixes": [
    "drivers/net/ethernet/intel/igc/"
  ]
}

Results:
{
  "error": "no matches"
}

5/2 2026/10/25 07:21 llm patch-evaluator
0m Model:
gemini-3.8-flash

Args:
null

Results:
null

Tokens:
							input: 7042
							output: 33
							thoughts: 19
						

Thoughts:
Okay, here's my take on those thoughts, tailored for an expert audience:

**Navigating the Intel Ethernet Landscape: Kconfig Quest**

Right, let's get down to business. My immediate objective is clear: locate the Kconfig file within the Intel Ethernet driver hierarchy. That likely resides in `drivers/net/ethernet/intel/`. Specifically, I'm after the `Kconfig` file. I'm assuming it's structured in the standard Linux kernel fashion, defining the configuration options for the Intel Ethernet drivers. This means I can probably find configuration entries for the specific NIC models, features, or architectural variations I'm interested in, and this will be my entry point for understanding or modifying the driver configuration. It's the key to understanding the build-time customization possibilities. Now, let's go find it.



6/2 2026/10/25 07:21 tool grepper
0m Args:
{
  "Expression": "config IGC",
  "PathPrefixes": [
    "drivers/net/ethernet/intel/"
  ]
}

Results:
{
  "Output": "drivers/net/ethernet/intel/Kconfig=355=config FM10K\n--\ndrivers/net/ethernet/intel/Kconfig-372-\ndrivers/net/ethernet/intel/Kconfig:373:config IGC\ndrivers/net/ethernet/intel/Kconfig-374-\ttristate \"Intel(R) Ethernet Controller I225-LM/I225-V support\"\n--\ndrivers/net/ethernet/intel/Kconfig-390-\ndrivers/net/ethernet/intel/Kconfig:391:config IGC_LEDS\ndrivers/net/ethernet/intel/Kconfig-392-\tdef_bool LEDS_TRIGGER_NETDEV\n"
}

7/2 2026/10/25 07:21 llm patch-evaluator
0m Model:
gemini-3.8-flash

Args:
null

Results:
null

Tokens:
							input: 7456
							output: 39
							thoughts: 24
						

Thoughts:
Here's my thought process, as if I were considering that code:

**Diving into the Intel Ethernet Driver Configuration**

Okay, so I need to take a look at the configuration options for the Intel Ethernet drivers. Specifically, I'm thinking I need to understand something related to the configuration and build process, likely at line 373 of the `Kconfig` file within the `drivers/net/ethernet/intel` directory. This is where the core configuration options are defined for the driver. I’m guessing there’s something specific I'm looking for, perhaps a feature flag, a dependency, or a default setting that needs clarification. Let's see what’s defined around that line to get some context. I'll need to understand the surrounding context of the Kconfig entries in that area to know what to investigate.



8/2 2026/10/25 07:21 tool read-file
0m Args:
{
  "File": "drivers/net/ethernet/intel/Kconfig",
  "FirstLine": 370,
  "LineCount": 25
}

Results:
{
  "Contents": " 370:\t\t  To compile this driver as a module, choose M here. The module\n 371:\t\t  will be called fm10k.  MSI-X interrupt support is required\n 372:\t\n 373:\tconfig IGC\n 374:\t\ttristate \"Intel(R) Ethernet Controller I225-LM/I225-V support\"\n 375:\t\tdefault n\n 376:\t\tdepends on PCI\n 377:\t\tdepends on PTP_1588_CLOCK_OPTIONAL\n 378:\t\tdepends on ETHTOOL_NETLINK\n 379:\t\thelp\n 380:\t\t  This driver supports Intel(R) Ethernet Controller I225-LM/I225-V\n 381:\t\t  family of adapters.\n 382:\t\n 383:\t\t  For more information on how to identify your adapter, go\n 384:\t\t  to the Adapter \u0026 Driver ID Guide that can be located at:\n 385:\t\n 386:\t\t  \u003chttp://support.intel.com\u003e\n 387:\t\n 388:\t\t  To compile this driver as a module, choose M here. The module\n 389:\t\t  will be called igc.\n 390:\t\n 391:\tconfig IGC_LEDS\n 392:\t\tdef_bool LEDS_TRIGGER_NETDEV\n 393:\t\tdepends on IGC \u0026\u0026 LEDS_CLASS\n 394:\t\tdepends on LEDS_CLASS=y || IGC=m\n"
}

9/2 2026/10/25 07:21 llm patch-evaluator
0m Model:
gemini-3.8-flash

Args:
null

Results:
null

Tokens:
							input: 8097
							output: 40
							thoughts: 538
						

Thoughts:
**Analyzing the Fuzzing Worthiness of IGC Driver Modifications**

Okay, let's carefully revisit the fuzzing guidelines. Specifically, I need to pinpoint when we should return `WorthFuzzing=false` due to negative criteria. The guidelines state this should happen ONLY if *all* modified code neatly fits into specific categories: non-kernel/non-executable changes, hardware that is structurally unreachable (e.g., vendor-specific PCIe switches, specialized drivers like `mlxsw`, `pds_core`, `qed`, `ionic`, `amdgpu` which require physical hardware not emulated in standard QEMU), or unreachable execution paths like driver teardown callbacks or architecture-specific code.

Now, my focus narrows to a specific question: What about IGC? Specifically, the Intel I225-LM/I225-V NICs. Are those drivers emulated in standard QEMU? This is key to determine the "reachable hardware" aspect.

Hold on, I remember QEMU's supported NICs. My experience tells me QEMU emulates e1000 (82540EM, 82543GC, 82545EM), e1000e (82574L), and igb (82576). But *does* QEMU support `igc` for the I225/I226? I need to verify. Let's list the QEMU network devices: `e1000`, `e1000e`, `igb`, `virtio-net`, `rtl8139`, `ne2k_pci`, `pcnet`, `vmxnet3`, `sungem`, `tulip`, `rocker`.

Aha! It's clear: QEMU *does not* emulate `igc`. It has the igb (added in QEMU 8.0, 82576), e1000e, and e1000. So `igc` *isn't* natively emulated. I need to know more if it is a physical PCIe NIC driver.

I need to confirm. Let's delve into the kernel's source. I'll check `drivers/net/ethernet/intel/igc/igc_main.c` and use `grep` to look for `pci_driver` or `MODULE_DEVICE_TABLE` within that directory. This should help to confirm the driver's nature.



10/2 2026/10/25 07:21 tool grepper
0m Args:
{
  "Expression": "igc_pci_tbl",
  "PathPrefixes": [
    "drivers/net/ethernet/intel/igc/"
  ]
}

Results:
{
  "Output": "drivers/net/ethernet/intel/igc/igc_main.c=45=static const struct igc_info *igc_info_tbl[] = {\n--\ndrivers/net/ethernet/intel/igc/igc_main.c-48-\ndrivers/net/ethernet/intel/igc/igc_main.c:49:static const struct pci_device_id igc_pci_tbl[] = {\ndrivers/net/ethernet/intel/igc/igc_main.c-50-\t{ PCI_VDEVICE(INTEL, IGC_DEV_ID_I225_LM), .driver_data = board_base },\n--\ndrivers/net/ethernet/intel/igc/igc_main.c-69-\ndrivers/net/ethernet/intel/igc/igc_main.c:70:MODULE_DEVICE_TABLE(pci, igc_pci_tbl);\ndrivers/net/ethernet/intel/igc/igc_main.c-71-\n--\ndrivers/net/ethernet/intel/igc/igc_main.c=7121=static enum hrtimer_restart igc_qbv_scheduling_timer(struct hrtimer *timer)\n--\ndrivers/net/ethernet/intel/igc/igc_main.c-7150- * @pdev: PCI device information struct\ndrivers/net/ethernet/intel/igc/igc_main.c:7151: * @ent: entry in igc_pci_tbl\ndrivers/net/ethernet/intel/igc/igc_main.c-7152- *\n--\ndrivers/net/ethernet/intel/igc/igc_main.c=7787=static struct pci_driver igc_driver = {\ndrivers/net/ethernet/intel/igc/igc_main.c-7788-\t.name     = igc_driver_name,\ndrivers/net/ethernet/intel/igc/igc_main.c:7789:\t.id_table = igc_pci_tbl,\ndrivers/net/ethernet/intel/igc/igc_main.c-7790-\t.probe    = igc_probe,\n"
}

11/2 2026/10/25 07:21 llm patch-evaluator
0m Model:
gemini-3.8-flash

Args:
null

Results:
null

Tokens:
							input: 9788
							output: 43
							thoughts: 183
						

Thoughts:
**Investigating the `igc_driver`**

Okay, let's dive into this `igc_driver`. Right off the bat, it's pretty clear this is a PCI driver designed for Intel's I225 and I226 series – specifically targeting those `IGC_DEV_ID_` device IDs like `I225_LM`, `I225_V`, and so on. Pretty standard stuff so far.

But here's a thought: can I actually *probe* this thing without the physical hardware present? Does the `igc` driver have any built-in mechanisms for virtualization? Maybe a virtual bus, a mock device, or even a dummy mode? That'd be incredibly useful for testing and debugging, so it’s worth investigating. I'll need to go directly to the source for this, so I'll need to check `igc_main.c` and look for any registrations related to virtual or platform devices. This should give me my answer.



12/2 2026/10/25 07:21 tool grepper
0m Args:
{
  "Expression": "module_init|pci_register_driver",
  "PathPrefixes": [
    "drivers/net/ethernet/intel/igc/"
  ]
}

Results:
{
  "Output": "drivers/net/ethernet/intel/igc/igc_main.c=7889=static int __init igc_init_module(void)\n--\ndrivers/net/ethernet/intel/igc/igc_main.c-7895-\ndrivers/net/ethernet/intel/igc/igc_main.c:7896:\tret = pci_register_driver(\u0026igc_driver);\ndrivers/net/ethernet/intel/igc/igc_main.c-7897-\treturn ret;\n--\ndrivers/net/ethernet/intel/igc/igc_main.c-7899-\ndrivers/net/ethernet/intel/igc/igc_main.c:7900:module_init(igc_init_module);\ndrivers/net/ethernet/intel/igc/igc_main.c-7901-\n"
}

13/2 2026/10/25 07:21 llm patch-evaluator
0m Model:
gemini-3.8-flash

Args:
null

Results:
null

Tokens:
							input: 10465
							output: 123
							thoughts: 891
						

Thoughts:
**Unreachable Hardware: The IGC Driver and Fuzzing Infeasibility**

Okay, so the `igc` driver is registered via `pci_register_driver` with PCI IDs specific to Intel I225/I226 hardware. My focus is on the changes within the patch, which are concentrated in the receive packet processing routines: `igc_clean_rx_ring`, `igc_configure_rx_ring`, `igc_is_non_eop`, `igc_clean_rx_irq`, and `igc_clean_rx_irq_zc`. These are the interrupt and NAPI handlers for the physical I225/I226 controller.

Now, let's revisit the core principles. Remember the "REACHABILITY IS THE PRIMARY GATE" principle? Fuzzing effectiveness hinges on code execution within standard virtualized environments. If the code is unreachable, it's a non-starter, regardless of its internal complexity.

Specifically, Section 2's "NEGATIVE CRITERIA" tell us to return `WorthFuzzing=false` if the modified code falls into certain categories. The crucial one here is "Structurally unreachable hardware." This encompasses vendor-specific PCIe devices that aren't emulated in standard environments.

Now, the critical question: Does QEMU emulate the `igc` driver? Let's check the QEMU source code. `hw/net` has `e1000`, `e1000e`, and `igb`, but *not* `igc`. The `igb` driver emulates the 82576 GbE NIC. But `igc` is for the I225/I226 2.5GbE NICs, and it's not emulated.

Therefore, without the actual hardware or a QEMU emulation of it, the PCI probe for `igc` will never run. The network device won't be created, and the `igc_clean_rx_irq` and `igc_clean_rx_irq_zc` routines will never execute in standard syzkaller test environments (QEMU or GCE).

Thus, the modified code is *structurally unreachable hardware*. It perfectly aligns with the negative criteria.

Re-checking the instruction checklist: `WorthFuzzing=false` only if *all* modified code falls into the unreachable hardware category. The changes are solely within `drivers/net/ethernet/intel/igc/igc.h` and `drivers/net/ethernet/intel/igc/igc_main.c` – both part of the `igc` driver.

So, setting the results is straightforward:

*   `WorthFuzzing: false`
*   `FocusSymbols: []`
*   `EnableConfigs: []`
*   `Reasoning: A concise explanation of why it is not worth fuzzing (specifically mentioning that igc is an Intel PCIe NIC driver (I225/I226) that requires physical hardware not emulated in standard virtualized environments like QEMU or GCE, making the modified Rx clean/NAPI code structurally unreachable for syzkaller)`

Let's move on.



14/2 2026/10/25 07:21 tool set-results
0m Args:
{
  "EnableConfigs": [],
  "FocusSymbols": [],
  "Reasoning": "The patch modifies Rx handling and NAPI polling logic (igc_clean_rx_irq, igc_clean_rx_irq_zc, etc.) in the Intel Ethernet Controller I225/I226 (igc) driver. This driver targets vendor-specific PCIe hardware that is not emulated in standard virtualized environments (QEMU/GCE), making the modified code structurally unreachable for syzkaller.",
  "WorthFuzzing": false
}

Results:
{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch modifies Rx handling and NAPI polling logic (igc_clean_rx_irq, igc_clean_rx_irq_zc, etc.) in the Intel Ethernet Controller I225/I226 (igc) driver. This driver targets vendor-specific PCIe hardware that is not emulated in standard virtualized environments (QEMU/GCE), making the modified code structurally unreachable for syzkaller.",
  "WorthFuzzing": false
}

15/1 2026/10/25 07:21 action If
0m Args:
{
  "WorthFuzzing": false
}

Results:
null

LLM Calls Summary:
Total Calls Total Tokens Avg Tokens Total Duration (Seconds) Avg Duration (Seconds)
Tool Calls Summary:
Total Calls Total Duration (Seconds) Avg Duration (Seconds)