AI Trajectory

null

{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "KMSANReasoning": "",
  "NeedsKMSAN": false,
  "Reasoning": "The patch is a purely mechanical refactoring that migrates the static key API from the older `struct static_key` and `static_key_slow_inc` to the newer `DECLARE_STATIC_KEY_FALSE` and `static_branch_inc` macros. It does not introduce any new functional logic or alter the execution flow, so it does not require fuzzing.",
  "WorthFuzzing": false
}

null

{
  "PatchDiff": "commit 3fd69e45692ce9b7e4d0cd454f401cb733dcd62e\nAuthor: syz-cluster \u003ctriage@syzkaller.com\u003e\nDate:   Wed Aug 19 08:31:18 2026 +0000\n\n    syz-cluster: applied patch under review\n\ndiff --git a/arch/arm64/kernel/paravirt.c b/arch/arm64/kernel/paravirt.c\nindex 572efb96b23fe..30bf61d031eb7 100644\n--- a/arch/arm64/kernel/paravirt.c\n+++ b/arch/arm64/kernel/paravirt.c\n@@ -157,9 +157,9 @@ int __init pv_time_init(void)\n \n \tstatic_call_update(pv_steal_clock, para_steal_clock);\n \n-\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n \tif (steal_acc)\n-\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n \n \tpr_info(\"using stolen time PV\\n\");\n \ndiff --git a/arch/loongarch/kernel/paravirt.c b/arch/loongarch/kernel/paravirt.c\nindex 10821cce554c0..e8965a3f80824 100644\n--- a/arch/loongarch/kernel/paravirt.c\n+++ b/arch/loongarch/kernel/paravirt.c\n@@ -308,10 +308,10 @@ int __init pv_time_init(void)\n \n \tstatic_call_update(pv_steal_clock, paravt_steal_clock);\n \n-\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING\n \tif (steal_acc)\n-\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n #endif\n \n \tif (static_key_enabled(\u0026virt_preempt_key))\ndiff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c\nindex 1223dc9612429..8dcbc4bb70256 100644\n--- a/arch/powerpc/platforms/pseries/setup.c\n+++ b/arch/powerpc/platforms/pseries/setup.c\n@@ -852,9 +852,9 @@ static void __init pSeries_setup_arch(void)\n \t\t\tstatic_branch_enable(\u0026shared_processor);\n \t\t\tpv_spinlocks_init();\n #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING\n-\t\t\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\t\t\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n \t\t\tif (steal_acc)\n-\t\t\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\t\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n #endif\n \t\t}\n \ndiff --git a/arch/riscv/kernel/paravirt.c b/arch/riscv/kernel/paravirt.c\nindex 5f56be79cd062..9c13a6f1ea2af 100644\n--- a/arch/riscv/kernel/paravirt.c\n+++ b/arch/riscv/kernel/paravirt.c\n@@ -116,9 +116,9 @@ int __init pv_time_init(void)\n \n \tstatic_call_update(pv_steal_clock, pv_time_steal_clock);\n \n-\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n \tif (steal_acc)\n-\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n \n \tpr_info(\"Computing paravirt steal-time\\n\");\n \ndiff --git a/arch/x86/kernel/cpu/vmware.c b/arch/x86/kernel/cpu/vmware.c\nindex 34b73573b108d..f7ab9e7902cfe 100644\n--- a/arch/x86/kernel/cpu/vmware.c\n+++ b/arch/x86/kernel/cpu/vmware.c\n@@ -328,9 +328,9 @@ static int vmware_cpu_down_prepare(unsigned int cpu)\n static __init int activate_jump_labels(void)\n {\n \tif (has_steal_clock) {\n-\t\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\t\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n \t\tif (steal_acc)\n-\t\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n \t}\n \n \treturn 0;\ndiff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c\nindex dcef84da304b8..d3dcd64f22c22 100644\n--- a/arch/x86/kernel/kvm.c\n+++ b/arch/x86/kernel/kvm.c\n@@ -1052,9 +1052,9 @@ const __initconst struct hypervisor_x86 x86_hyper_kvm = {\n static __init int activate_jump_labels(void)\n {\n \tif (has_steal_clock) {\n-\t\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\t\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n \t\tif (steal_acc)\n-\t\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n \t}\n \n \treturn 0;\ndiff --git a/drivers/xen/time.c b/drivers/xen/time.c\nindex a2be0a4d45b0b..a02d48a2aa684 100644\n--- a/drivers/xen/time.c\n+++ b/drivers/xen/time.c\n@@ -169,7 +169,7 @@ void __init xen_time_setup_guest(void)\n \n \tstatic_call_update(pv_steal_clock, xen_steal_clock);\n \n-\tstatic_key_slow_inc(\u0026paravirt_steal_enabled);\n+\tstatic_branch_inc(\u0026paravirt_steal_enabled);\n \tif (xen_runstate_remote)\n-\t\tstatic_key_slow_inc(\u0026paravirt_steal_rq_enabled);\n+\t\tstatic_branch_inc(\u0026paravirt_steal_rq_enabled);\n }\ndiff --git a/include/linux/sched/cputime.h b/include/linux/sched/cputime.h\nindex e90efaf6d26e9..694126411dfea 100644\n--- a/include/linux/sched/cputime.h\n+++ b/include/linux/sched/cputime.h\n@@ -182,9 +182,9 @@ extern unsigned long long\n task_sched_runtime(struct task_struct *task);\n \n #ifdef CONFIG_PARAVIRT\n-struct static_key;\n-extern struct static_key paravirt_steal_enabled;\n-extern struct static_key paravirt_steal_rq_enabled;\n+#include \u003clinux/jump_label.h\u003e\n+DECLARE_STATIC_KEY_FALSE(paravirt_steal_enabled);\n+DECLARE_STATIC_KEY_FALSE(paravirt_steal_rq_enabled);\n \n #ifdef CONFIG_HAVE_PV_STEAL_CLOCK_GEN\n u64 dummy_steal_clock(int cpu);\ndiff --git a/kernel/sched/core.c b/kernel/sched/core.c\nindex 96226707c2f61..786975d4ca1eb 100644\n--- a/kernel/sched/core.c\n+++ b/kernel/sched/core.c\n@@ -795,7 +795,7 @@ struct rq *_task_rq_lock(struct task_struct *p, struct rq_flags *rf)\n \n /* Use CONFIG_PARAVIRT as this will avoid more #ifdef in arch code. */\n #ifdef CONFIG_PARAVIRT\n-struct static_key paravirt_steal_rq_enabled;\n+DEFINE_STATIC_KEY_FALSE(paravirt_steal_rq_enabled);\n #endif\n \n static void update_rq_clock_task(struct rq *rq, s64 delta)\n@@ -834,7 +834,7 @@ static void update_rq_clock_task(struct rq *rq, s64 delta)\n \t}\n #endif\n #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING\n-\tif (static_key_false((\u0026paravirt_steal_rq_enabled))) {\n+\tif (static_branch_unlikely(\u0026paravirt_steal_rq_enabled)) {\n \t\tu64 prev_steal;\n \n \t\tsteal = prev_steal = paravirt_steal_clock(cpu_of(rq));\ndiff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c\nindex 06bddaa738e52..f16970ca81d08 100644\n--- a/kernel/sched/cputime.c\n+++ b/kernel/sched/cputime.c\n@@ -255,7 +255,7 @@ void __account_forceidle_time(struct task_struct *p, u64 delta)\n  * occasion account more time than the calling functions think elapsed.\n  */\n #ifdef CONFIG_PARAVIRT\n-struct static_key paravirt_steal_enabled;\n+DEFINE_STATIC_KEY_FALSE(paravirt_steal_enabled);\n \n #ifdef CONFIG_HAVE_PV_STEAL_CLOCK_GEN\n static u64 native_steal_clock(int cpu)\n@@ -270,7 +270,7 @@ DEFINE_STATIC_CALL(pv_steal_clock, native_steal_clock);\n static __always_inline u64 steal_account_process_time(u64 maxtime)\n {\n #ifdef CONFIG_PARAVIRT\n-\tif (static_key_false(\u0026paravirt_steal_enabled)) {\n+\tif (static_branch_unlikely(\u0026paravirt_steal_enabled)) {\n \t\tu64 steal;\n \n \t\tsteal = paravirt_steal_clock(smp_processor_id());\n"
}

best-expensive

null

{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch is a purely mechanical refactoring that migrates the static key API from the older `struct static_key` and `static_key_slow_inc` to the newer `DECLARE_STATIC_KEY_FALSE` and `static_branch_inc` macros. It does not introduce any new functional logic or alter the execution flow, so it does not require fuzzing.",
  "WorthFuzzing": false
}

You are an expert Linux kernel maintainer.
Your job is to review a provided patch series and determine
if it makes functional changes to the kernel that should be fuzzed.

IMPORTANT: The changes have ALREADY been applied and committed as the HEAD commit in
your workspace. Do NOT rely on your internal knowledge of the kernel. You must actively
use your code access tools to examine the actual source code and confirm any assumptions.

Return WorthFuzzing=false if the patch only contains:
- Modifications to Documentation/, Kconfig files, or code comments.
- Purely decorative changes, such as logging (e.g., pr_err, printk) or tracepoints.
- Changes to numeric constants or macros that do not functionally alter execution flow.
- Code paths that are impossible to reach in virtualized environments like GCE or QEMU,
  even when utilizing software-emulated hardware (e.g., usb gadget, mac80211_hwsim).
- Code in vendor-specific PCIe switch, SmartNIC, or GPU drivers (e.g., mlxsw, pds_core, qed,
  ionic, amdgpu) that require physical PCIe hardware cards not emulated in standard QEMU.
- Driver .remove, .shutdown, or pci_unregister_driver teardown callbacks (e.g., igb_remove)
  that are executed only during PCI hot-unplug or sysfs driver unbind operations.

If it modifies reachable core kernel logic, drivers, or architectures, use your code search
tools to verify the code can be executed, then return WorthFuzzing=true.

When returning WorthFuzzing=true, you MUST ALSO:
1. Extract any specific kernel functions that should be heavily fuzzed into FocusSymbols.
   Avoid listing generic hot-path functions to prevent skewed test distributions.
   Prefer non-static, non-inlined API entrypoint functions over internal static helper functions
   (which are inlined by the compiler and do not have distinct symbol addresses).
2. Identify any specific CONFIG_ options required to properly test this new/modified feature.
   Go and look into the Kconfig files and check for ifdefs around the code, do not make assumptions.
   Also check "depends on" lines in Kconfig to include any non-standard parent subsystem configs
   needed for Kbuild to compile the code statically into vmlinux. List them in the EnableConfigs
   output array, and DO NOT add a '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.

For your convenience, here is the diff of the changes:
commit 3fd69e45692ce9b7e4d0cd454f401cb733dcd62e
Author: syz-cluster <triage@syzkaller.com>
Date:   Wed Aug 19 08:31:18 2026 +0000

    syz-cluster: applied patch under review

diff --git a/arch/arm64/kernel/paravirt.c b/arch/arm64/kernel/paravirt.c
index 572efb96b23fe..30bf61d031eb7 100644
--- a/arch/arm64/kernel/paravirt.c
+++ b/arch/arm64/kernel/paravirt.c
@@ -157,9 +157,9 @@ int __init pv_time_init(void)
 
 	static_call_update(pv_steal_clock, para_steal_clock);
 
-	static_key_slow_inc(&paravirt_steal_enabled);
+	static_branch_inc(&paravirt_steal_enabled);
 	if (steal_acc)
-		static_key_slow_inc(&paravirt_steal_rq_enabled);
+		static_branch_inc(&paravirt_steal_rq_enabled);
 
 	pr_info("using stolen time PV\n");
 
diff --git a/arch/loongarch/kernel/paravirt.c b/arch/loongarch/kernel/paravirt.c
index 10821cce554c0..e8965a3f80824 100644
--- a/arch/loongarch/kernel/paravirt.c
+++ b/arch/loongarch/kernel/paravirt.c
@@ -308,10 +308,10 @@ int __init pv_time_init(void)
 
 	static_call_update(pv_steal_clock, paravt_steal_clock);
 
-	static_key_slow_inc(&paravirt_steal_enabled);
+	static_branch_inc(&paravirt_steal_enabled);
 #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
 	if (steal_acc)
-		static_key_slow_inc(&paravirt_steal_rq_enabled);
+		static_branch_inc(&paravirt_steal_rq_enabled);
 #endif
 
 	if (static_key_enabled(&virt_preempt_key))
diff --git a/arch/powerpc/platforms/pseries/setup.c b/arch/powerpc/platforms/pseries/setup.c
index 1223dc9612429..8dcbc4bb70256 100644
--- a/arch/powerpc/platforms/pseries/setup.c
+++ b/arch/powerpc/platforms/pseries/setup.c
@@ -852,9 +852,9 @@ static void __init pSeries_setup_arch(void)
 			static_branch_enable(&shared_processor);
 			pv_spinlocks_init();
 #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
-			static_key_slow_inc(&paravirt_steal_enabled);
+			static_branch_inc(&paravirt_steal_enabled);
 			if (steal_acc)
-				static_key_slow_inc(&paravirt_steal_rq_enabled);
+				static_branch_inc(&paravirt_steal_rq_enabled);
 #endif
 		}
 
diff --git a/arch/riscv/kernel/paravirt.c b/arch/riscv/kernel/paravirt.c
index 5f56be79cd062..9c13a6f1ea2af 100644
--- a/arch/riscv/kernel/paravirt.c
+++ b/arch/riscv/kernel/paravirt.c
@@ -116,9 +116,9 @@ int __init pv_time_init(void)
 
 	static_call_update(pv_steal_clock, pv_time_steal_clock);
 
-	static_key_slow_inc(&paravirt_steal_enabled);
+	static_branch_inc(&paravirt_steal_enabled);
 	if (steal_acc)
-		static_key_slow_inc(&paravirt_steal_rq_enabled);
+		static_branch_inc(&paravirt_steal_rq_enabled);
 
 	pr_info("Computing paravirt steal-time\n");
 
diff --git a/arch/x86/kernel/cpu/vmware.c b/arch/x86/kernel/cpu/vmware.c
index 34b73573b108d..f7ab9e7902cfe 100644
--- a/arch/x86/kernel/cpu/vmware.c
+++ b/arch/x86/kernel/cpu/vmware.c
@@ -328,9 +328,9 @@ static int vmware_cpu_down_prepare(unsigned int cpu)
 static __init int activate_jump_labels(void)
 {
 	if (has_steal_clock) {
-		static_key_slow_inc(&paravirt_steal_enabled);
+		static_branch_inc(&paravirt_steal_enabled);
 		if (steal_acc)
-			static_key_slow_inc(&paravirt_steal_rq_enabled);
+			static_branch_inc(&paravirt_steal_rq_enabled);
 	}
 
 	return 0;
diff --git a/arch/x86/kernel/kvm.c b/arch/x86/kernel/kvm.c
index dcef84da304b8..d3dcd64f22c22 100644
--- a/arch/x86/kernel/kvm.c
+++ b/arch/x86/kernel/kvm.c
@@ -1052,9 +1052,9 @@ const __initconst struct hypervisor_x86 x86_hyper_kvm = {
 static __init int activate_jump_labels(void)
 {
 	if (has_steal_clock) {
-		static_key_slow_inc(&paravirt_steal_enabled);
+		static_branch_inc(&paravirt_steal_enabled);
 		if (steal_acc)
-			static_key_slow_inc(&paravirt_steal_rq_enabled);
+			static_branch_inc(&paravirt_steal_rq_enabled);
 	}
 
 	return 0;
diff --git a/drivers/xen/time.c b/drivers/xen/time.c
index a2be0a4d45b0b..a02d48a2aa684 100644
--- a/drivers/xen/time.c
+++ b/drivers/xen/time.c
@@ -169,7 +169,7 @@ void __init xen_time_setup_guest(void)
 
 	static_call_update(pv_steal_clock, xen_steal_clock);
 
-	static_key_slow_inc(&paravirt_steal_enabled);
+	static_branch_inc(&paravirt_steal_enabled);
 	if (xen_runstate_remote)
-		static_key_slow_inc(&paravirt_steal_rq_enabled);
+		static_branch_inc(&paravirt_steal_rq_enabled);
 }
diff --git a/include/linux/sched/cputime.h b/include/linux/sched/cputime.h
index e90efaf6d26e9..694126411dfea 100644
--- a/include/linux/sched/cputime.h
+++ b/include/linux/sched/cputime.h
@@ -182,9 +182,9 @@ extern unsigned long long
 task_sched_runtime(struct task_struct *task);
 
 #ifdef CONFIG_PARAVIRT
-struct static_key;
-extern struct static_key paravirt_steal_enabled;
-extern struct static_key paravirt_steal_rq_enabled;
+#include <linux/jump_label.h>
+DECLARE_STATIC_KEY_FALSE(paravirt_steal_enabled);
+DECLARE_STATIC_KEY_FALSE(paravirt_steal_rq_enabled);
 
 #ifdef CONFIG_HAVE_PV_STEAL_CLOCK_GEN
 u64 dummy_steal_clock(int cpu);
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 96226707c2f61..786975d4ca1eb 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -795,7 +795,7 @@ struct rq *_task_rq_lock(struct task_struct *p, struct rq_flags *rf)
 
 /* Use CONFIG_PARAVIRT as this will avoid more #ifdef in arch code. */
 #ifdef CONFIG_PARAVIRT
-struct static_key paravirt_steal_rq_enabled;
+DEFINE_STATIC_KEY_FALSE(paravirt_steal_rq_enabled);
 #endif
 
 static void update_rq_clock_task(struct rq *rq, s64 delta)
@@ -834,7 +834,7 @@ static void update_rq_clock_task(struct rq *rq, s64 delta)
 	}
 #endif
 #ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
-	if (static_key_false((&paravirt_steal_rq_enabled))) {
+	if (static_branch_unlikely(&paravirt_steal_rq_enabled)) {
 		u64 prev_steal;
 
 		steal = prev_steal = paravirt_steal_clock(cpu_of(rq));
diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c
index 06bddaa738e52..f16970ca81d08 100644
--- a/kernel/sched/cputime.c
+++ b/kernel/sched/cputime.c
@@ -255,7 +255,7 @@ void __account_forceidle_time(struct task_struct *p, u64 delta)
  * occasion account more time than the calling functions think elapsed.
  */
 #ifdef CONFIG_PARAVIRT
-struct static_key paravirt_steal_enabled;
+DEFINE_STATIC_KEY_FALSE(paravirt_steal_enabled);
 
 #ifdef CONFIG_HAVE_PV_STEAL_CLOCK_GEN
 static u64 native_steal_clock(int cpu)
@@ -270,7 +270,7 @@ DEFINE_STATIC_CALL(pv_steal_clock, native_steal_clock);
 static __always_inline u64 steal_account_process_time(u64 maxtime)
 {
 #ifdef CONFIG_PARAVIRT
-	if (static_key_false(&paravirt_steal_enabled)) {
+	if (static_branch_unlikely(&paravirt_steal_enabled)) {
 		u64 steal;
 
 		steal = paravirt_steal_clock(smp_processor_id());

gemini-3.1-pro-preview

null

null

							input: 4518
							output: 109
							thoughts: 573
						

**Refactoring Static Keys for Paravirt Steal**

Okay, so I'm looking at this patch and it's basically a straightforward API migration for static keys, specifically around `paravirt_steal_enabled` and `paravirt_steal_rq_enabled`. The changes are: swapping `static_key_slow_inc` for `static_branch_inc` and `static_key_false` for `static_branch_unlikely`. We're also seeing the `struct static_key` declarations being replaced with `DECLARE_STATIC_KEY_FALSE` and `DEFINE_STATIC_KEY_FALSE`. This all screams "mechanical refactoring," which is what I suspected.

I initially had a fleeting moment of, "Wait, `static_branch_inc` with `static_key`? Hmm, gotta verify." But a quick check of `include/linux/jump_label.h` confirms that this is indeed how the new API works with the `DECLARE_STATIC_KEY_FALSE` and `DEFINE_STATIC_KEY_FALSE` macros. The old API used the `struct static_key` and functions like `static_key_slow_inc`, and this patch is just bringing us up to speed.

To be extra certain, I need to double-check that there's absolutely no functional change here. Let's compare the behaviors: `static_key_slow_inc` increments, `static_branch_inc` increments. Good. `static_key_false` checks, `static_branch_unlikely` also checks. Seems identical from a functional perspective.

Looking at the diff directly reinforces this. We're seeing direct substitutions. No altered logic or control flow.

```c
-	static_key_slow_inc(&paravirt_steal_enabled);
+	static_branch_inc(&paravirt_steal_enabled);
```

```c
-struct static_key paravirt_steal_enabled;
-extern struct static_key paravirt_steal_rq_enabled;
+#include <linux/jump_label.h>
+DECLARE_STATIC_KEY_FALSE(paravirt_steal_enabled);
+DECLARE_STATIC_KEY_FALSE(paravirt_steal_rq_enabled);
```

```c
-struct static_key paravirt_steal_rq_enabled;
+DEFINE_STATIC_KEY_FALSE(paravirt_steal_rq_enabled);
```

```c
-	if (static_key_false((&paravirt_steal_rq_enabled))) {
+	if (static_branch_unlikely(&paravirt_steal_rq_enabled)) {
```

So, purely a mechanical refactoring. This has zero impact on how the code *executes*. Therefore, `WorthFuzzing=false`. Time to call set-results.

{
  "EnableConfigs": [],
  "FocusSymbols": [],
  "Reasoning": "The patch is a purely mechanical refactoring that migrates the static key API from the older `struct static_key` and `static_key_slow_inc` to the newer `DECLARE_STATIC_KEY_FALSE` and `static_branch_inc` macros. It does not introduce any new functional logic or alter the execution flow, so it does not require fuzzing.",
  "WorthFuzzing": false
}

{
  "EnableConfigs": null,
  "FocusSymbols": [],
  "Reasoning": "The patch is a purely mechanical refactoring that migrates the static key API from the older `struct static_key` and `static_key_slow_inc` to the newer `DECLARE_STATIC_KEY_FALSE` and `static_branch_inc` macros. It does not introduce any new functional logic or alter the execution flow, so it does not require fuzzing.",
  "WorthFuzzing": false
}

{
  "WorthFuzzing": false
}

null