* [RFC PATCH 1/7] jump_label: expose queueing API for batched static key updates
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
2026-03-08 9:54 ` Peter Zijlstra
2026-03-06 1:50 ` [RFC PATCH 2/7] virtio: use pr_debug_ratelimited to avoid flooding Jim Cromie
` (5 subsequent siblings)
6 siblings, 1 reply; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Jason Baron, Peter Zijlstra, Josh Poimboeuf,
Thomas Gleixner, Alice Ryhl, Steven Rostedt, Ard Biesheuvel,
Alexandre Chartre, Juergen Gross, Andy Lutomirski, Ingo Molnar,
Borislav Petkov, Dave Hansen, x86, H. Peter Anvin, Kees Cook,
Nathan Chancellor, Lukas Bulwahn
Currently, `HAVE_JUMP_LABEL_BATCH` provides an architecture-level
mechanism to defer instruction synchronization (`text_poke_sync()`)
when patching a sequence of static keys. However, this deferred
batching capability is not exposed as a public kernel API. Subsystems
that need to toggle a large number of static keys (e.g.,
dynamic_debug) currently suffer from O(N) overhead due to repeated
machine-wide synchronizations (stop_machine).
This patch introduces a public queueing API to expose this deferred
synchronization mechanism to the rest of the kernel. This allows
multiple static keys to be enabled/disabled by queueing their
architecture-level updates, before applying a single machine-wide
synchronization barrier after all instructions are modified.
The new API consists of:
- static_key_enable_queued(key)
- static_key_disable_queued(key)
- static_key_apply_queued() (the global barrier/flush)
- static_branch_enable_queued(x) / static_branch_disable_queued(x) macros
NOTES:
The '_queued' API suffix was chosen to match the underlying
'arch_jump_label_transform_queue' and to avoid confusion with the
existing rate-limited 'static_key_deferred' API.
Also unify the names under the 'static_key_*' prefix, renaming
jump_label_apply_queued to static_key_apply_queued (with a
compatibility macro) for consistency.
A pr_debug() is added to show the poked addresses, this exposed the
semi-random ordering coming from dynamic-debug, despite its ordered
descriptors.
So x86/kernel/alternatives gets new code to do an insert-sort, by
memcpy & memmove after appending. This sorting yields a dramatic IPI
reduction; a following patch to dynamic-debug uses the API, and
includes the numbers.
Cc: Jason Baron <jbaron@akamai.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Josh Poimboeuf <jpoimboe@kernel.org>
Cc: Thomas Gleixner <tglx@kernel.org>
Cc: Alice Ryhl <aliceryhl@google.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Ard Biesheuvel <ardb@kernel.org>
Cc: Alexandre Chartre <alexandre.chartre@oracle.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Andy Lutomirski <luto@kernel.org>
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
arch/Kconfig | 3 +
arch/x86/Kconfig | 1 +
arch/x86/kernel/alternative.c | 50 +++++++++-----
arch/x86/kernel/jump_label.c | 13 +++-
include/linux/jump_label.h | 24 +++++++
kernel/jump_label.c | 125 +++++++++++++++++++++++++++++++---
6 files changed, 186 insertions(+), 30 deletions(-)
diff --git a/arch/Kconfig b/arch/Kconfig
index 102ddbd4298e..388a73545005 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -505,6 +505,9 @@ config HAVE_ARCH_JUMP_LABEL
config HAVE_ARCH_JUMP_LABEL_RELATIVE
bool
+config HAVE_JUMP_LABEL_BATCH
+ bool
+
config MMU_GATHER_TABLE_FREE
bool
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index e2df1b147184..4d7705890558 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -249,6 +249,7 @@ config X86
select HAVE_IOREMAP_PROT
select HAVE_IRQ_EXIT_ON_IRQ_STACK if X86_64
select HAVE_IRQ_TIME_ACCOUNTING
+ select HAVE_JUMP_LABEL_BATCH
select HAVE_JUMP_LABEL_HACK if HAVE_OBJTOOL
select HAVE_KERNEL_BZIP2
select HAVE_KERNEL_GZIP
diff --git a/arch/x86/kernel/alternative.c b/arch/x86/kernel/alternative.c
index a888ae0f01fb..85df82c36543 100644
--- a/arch/x86/kernel/alternative.c
+++ b/arch/x86/kernel/alternative.c
@@ -3137,26 +3137,19 @@ static void __smp_text_poke_batch_add(void *addr, const void *opcode, size_t len
}
/*
- * We hard rely on the text_poke_array.vec being ordered; ensure this is so by flushing
- * early if needed.
+ * We hard rely on the text_poke_array.vec being ordered; ensure this
+ * by finding where to insert to preserve the order, and mem-moving
+ * into place after appending it.
*/
-static bool text_poke_addr_ordered(void *addr)
+static int text_poke_get_insert_idx(void *addr)
{
- WARN_ON_ONCE(!addr);
+ int i;
- if (!text_poke_array.nr_entries)
- return true;
-
- /*
- * If the last current entry's address is higher than the
- * new entry's address we'd like to add, then ordering
- * is violated and we must first flush all pending patching
- * requests:
- */
- if (text_poke_addr(text_poke_array.vec + text_poke_array.nr_entries-1) > addr)
- return false;
-
- return true;
+ for (i = 0; i < text_poke_array.nr_entries; i++) {
+ if (text_poke_addr(&text_poke_array.vec[i]) > addr)
+ return i;
+ }
+ return text_poke_array.nr_entries;
}
/**
@@ -3174,9 +3167,30 @@ static bool text_poke_addr_ordered(void *addr)
*/
void __ref smp_text_poke_batch_add(void *addr, const void *opcode, size_t len, const void *emulate)
{
- if (text_poke_array.nr_entries == TEXT_POKE_ARRAY_MAX || !text_poke_addr_ordered(addr))
+ int insert_idx;
+
+ pr_debug("incoming addr=%px, current_qlen=%d\n",
+ addr, text_poke_array.nr_entries);
+
+ if (text_poke_array.nr_entries == TEXT_POKE_ARRAY_MAX)
smp_text_poke_batch_finish();
+
+ insert_idx = text_poke_get_insert_idx(addr);
__smp_text_poke_batch_add(addr, opcode, len, emulate);
+
+ if (insert_idx < text_poke_array.nr_entries - 1) {
+ struct smp_text_poke_loc tmp;
+ int last = text_poke_array.nr_entries - 1;
+ /* Copy the newly appended item out */
+ memcpy(&tmp, &text_poke_array.vec[last], sizeof(tmp));
+
+ /* Shift everything from insert_idx over by 1 */
+ memmove(&text_poke_array.vec[insert_idx + 1],
+ &text_poke_array.vec[insert_idx],
+ (last - insert_idx) * sizeof(struct smp_text_poke_loc));
+ /* Drop the new item into its sorted home */
+ memcpy(&text_poke_array.vec[insert_idx], &tmp, sizeof(tmp));
+ }
}
/**
diff --git a/arch/x86/kernel/jump_label.c b/arch/x86/kernel/jump_label.c
index a7949a54a0ff..6b5bab5f34e8 100644
--- a/arch/x86/kernel/jump_label.c
+++ b/arch/x86/kernel/jump_label.c
@@ -120,6 +120,8 @@ void arch_jump_label_transform(struct jump_entry *entry,
jump_label_transform(entry, type, 0);
}
+static int jump_label_queue_len;
+
bool arch_jump_label_transform_queue(struct jump_entry *entry,
enum jump_label_type type)
{
@@ -135,14 +137,23 @@ bool arch_jump_label_transform_queue(struct jump_entry *entry,
mutex_lock(&text_mutex);
jlp = __jump_label_patch(entry, type);
- smp_text_poke_batch_add((void *)jump_entry_code(entry), jlp.code, jlp.size, NULL);
+ smp_text_poke_batch_add((void *)jump_entry_code(entry),
+ jlp.code, jlp.size, NULL);
+ jump_label_queue_len++;
mutex_unlock(&text_mutex);
return true;
}
void arch_jump_label_transform_apply(void)
{
+ if (!jump_label_queue_len) {
+ pr_debug("no queued jump_labels to apply\n");
+ return;
+ }
+
+ pr_debug("applying %d queued jump_labels\n", jump_label_queue_len);
mutex_lock(&text_mutex);
smp_text_poke_batch_finish();
+ jump_label_queue_len = 0;
mutex_unlock(&text_mutex);
}
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index fdb79dd1ebd8..17f572abe4bb 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -234,10 +234,20 @@ extern void static_key_slow_dec_cpuslocked(struct static_key *key);
extern int static_key_count(struct static_key *key);
extern void static_key_enable(struct static_key *key);
extern void static_key_disable(struct static_key *key);
+extern void static_key_enable_queued(struct static_key *key);
+extern void static_key_disable_queued(struct static_key *key);
+extern void static_key_apply_queued(void);
extern void static_key_enable_cpuslocked(struct static_key *key);
extern void static_key_disable_cpuslocked(struct static_key *key);
extern enum jump_label_type jump_label_init_type(struct jump_entry *entry);
+#define static_branch_enable(x) static_key_enable(&(x)->key)
+#define static_branch_disable(x) static_key_disable(&(x)->key)
+#define static_branch_enable_queued(x) static_key_enable_queued(&(x)->key)
+#define static_branch_disable_queued(x) static_key_disable_queued(&(x)->key)
+#define static_branch_enable_cpuslocked(x) static_key_enable_cpuslocked(&(x)->key)
+#define static_branch_disable_cpuslocked(x) static_key_disable_cpuslocked(&(x)->key)
+
/*
* We should be using ATOMIC_INIT() for initializing .enabled, but
* the inclusion of atomic.h is problematic for inclusion of jump_label.h
@@ -340,6 +350,18 @@ static inline void static_key_disable(struct static_key *key)
atomic_set(&key->enabled, 0);
}
+static inline void static_key_enable_queued(struct static_key *key)
+{
+ static_key_enable(key);
+}
+
+static inline void static_key_disable_queued(struct static_key *key)
+{
+ static_key_disable(key);
+}
+
+static inline void static_key_apply_queued(void) {}
+
#define static_key_enable_cpuslocked(k) static_key_enable((k))
#define static_key_disable_cpuslocked(k) static_key_disable((k))
@@ -535,6 +557,8 @@ extern bool ____wrong_branch_error(void);
#define static_branch_enable(x) static_key_enable(&(x)->key)
#define static_branch_disable(x) static_key_disable(&(x)->key)
+#define static_branch_enable_queued(x) static_key_enable_queued(&(x)->key)
+#define static_branch_disable_queued(x) static_key_disable_queued(&(x)->key)
#define static_branch_enable_cpuslocked(x) static_key_enable_cpuslocked(&(x)->key)
#define static_branch_disable_cpuslocked(x) static_key_disable_cpuslocked(&(x)->key)
diff --git a/kernel/jump_label.c b/kernel/jump_label.c
index 7cb19e601426..76a0f4e68b73 100644
--- a/kernel/jump_label.c
+++ b/kernel/jump_label.c
@@ -91,6 +91,7 @@ jump_label_sort_entries(struct jump_entry *start, struct jump_entry *stop)
}
static void jump_label_update(struct static_key *key);
+static void jump_label_update_queued(struct static_key *key);
/*
* There are similar definitions for the !CONFIG_JUMP_LABEL case in jump_label.h.
@@ -250,6 +251,41 @@ void static_key_disable(struct static_key *key)
}
EXPORT_SYMBOL_GPL(static_key_disable);
+void static_key_enable_queued(struct static_key *key)
+{
+ STATIC_KEY_CHECK_USE(key);
+
+ if (atomic_read(&key->enabled) > 0) {
+ WARN_ON_ONCE(atomic_read(&key->enabled) != 1);
+ return;
+ }
+
+ jump_label_lock();
+ if (atomic_read(&key->enabled) == 0) {
+ atomic_set(&key->enabled, -1);
+ jump_label_update_queued(key);
+ atomic_set_release(&key->enabled, 1);
+ }
+ jump_label_unlock();
+}
+EXPORT_SYMBOL_GPL(static_key_enable_queued);
+
+void static_key_disable_queued(struct static_key *key)
+{
+ STATIC_KEY_CHECK_USE(key);
+
+ if (atomic_read(&key->enabled) != 1) {
+ WARN_ON_ONCE(atomic_read(&key->enabled) != 0);
+ return;
+ }
+
+ jump_label_lock();
+ if (atomic_cmpxchg(&key->enabled, 1, 0) == 1)
+ jump_label_update_queued(key);
+ jump_label_unlock();
+}
+EXPORT_SYMBOL_GPL(static_key_disable_queued);
+
static bool static_key_dec_not_one(struct static_key *key)
{
int v;
@@ -488,39 +524,59 @@ static bool jump_label_can_update(struct jump_entry *entry, bool init)
return true;
}
-#ifndef HAVE_JUMP_LABEL_BATCH
static void __jump_label_update(struct static_key *key,
struct jump_entry *entry,
struct jump_entry *stop,
bool init)
{
+#ifndef HAVE_JUMP_LABEL_BATCH
for (; (entry < stop) && (jump_entry_key(entry) == key); entry++) {
if (jump_label_can_update(entry, init))
arch_jump_label_transform(entry, jump_label_type(entry));
}
-}
#else
-static void __jump_label_update(struct static_key *key,
- struct jump_entry *entry,
- struct jump_entry *stop,
- bool init)
-{
for (; (entry < stop) && (jump_entry_key(entry) == key); entry++) {
if (!jump_label_can_update(entry, init))
continue;
if (!arch_jump_label_transform_queue(entry, jump_label_type(entry))) {
- /*
- * Queue is full: Apply the current queue and try again.
- */
arch_jump_label_transform_apply();
- BUG_ON(!arch_jump_label_transform_queue(entry, jump_label_type(entry)));
+ WARN_ON_ONCE(!arch_jump_label_transform_queue(entry, jump_label_type(entry)));
}
}
arch_jump_label_transform_apply();
+#endif
}
+
+static void __jump_label_update_queued(struct static_key *key,
+ struct jump_entry *entry,
+ struct jump_entry *stop,
+ bool init)
+{
+#ifdef HAVE_JUMP_LABEL_BATCH
+ for (; (entry < stop) && (jump_entry_key(entry) == key); entry++) {
+
+ if (!jump_label_can_update(entry, init))
+ continue;
+
+ if (!arch_jump_label_transform_queue(entry, jump_label_type(entry))) {
+ arch_jump_label_transform_apply();
+ WARN_ON_ONCE(!arch_jump_label_transform_queue(entry, jump_label_type(entry)));
+ }
+ }
+#else
+ __jump_label_update(key, entry, stop, init);
+#endif
+}
+
+void static_key_apply_queued(void)
+{
+#ifdef HAVE_JUMP_LABEL_BATCH
+ arch_jump_label_transform_apply();
#endif
+}
+EXPORT_SYMBOL_GPL(static_key_apply_queued);
void __init jump_label_init(void)
{
@@ -696,6 +752,27 @@ static void __jump_label_mod_update(struct static_key *key)
}
}
+static void __jump_label_mod_update_queued(struct static_key *key)
+{
+ struct static_key_mod *mod;
+
+ for (mod = static_key_mod(key); mod; mod = mod->next) {
+ struct jump_entry *stop;
+ struct module *m;
+
+ if (!mod->entries)
+ continue;
+
+ m = mod->mod;
+ if (!m)
+ stop = __stop___jump_table;
+ else
+ stop = m->jump_entries + m->num_jump_entries;
+ __jump_label_update_queued(key, mod->entries, stop,
+ m && m->state == MODULE_STATE_COMING);
+ }
+}
+
static int jump_label_add_module(struct module *mod)
{
struct jump_entry *iter_start = mod->jump_entries;
@@ -919,6 +996,32 @@ static void jump_label_update(struct static_key *key)
__jump_label_update(key, entry, stop, init);
}
+static void jump_label_update_queued(struct static_key *key)
+{
+ struct jump_entry *stop = __stop___jump_table;
+ bool init = system_state < SYSTEM_RUNNING;
+ struct jump_entry *entry;
+#ifdef CONFIG_MODULES
+ struct module *mod;
+
+ if (static_key_linked(key)) {
+ __jump_label_mod_update_queued(key);
+ return;
+ }
+
+ scoped_guard(rcu) {
+ mod = __module_address((unsigned long)key);
+ if (mod) {
+ stop = mod->jump_entries + mod->num_jump_entries;
+ init = mod->state == MODULE_STATE_COMING;
+ }
+ }
+#endif
+ entry = static_key_entries(key);
+ if (entry)
+ __jump_label_update_queued(key, entry, stop, init);
+}
+
#ifdef CONFIG_STATIC_KEYS_SELFTEST
static DEFINE_STATIC_KEY_TRUE(sk_true);
static DEFINE_STATIC_KEY_FALSE(sk_false);
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [RFC PATCH 1/7] jump_label: expose queueing API for batched static key updates
2026-03-06 1:50 ` [RFC PATCH 1/7] jump_label: expose queueing API for batched static key updates Jim Cromie
@ 2026-03-08 9:54 ` Peter Zijlstra
0 siblings, 0 replies; 11+ messages in thread
From: Peter Zijlstra @ 2026-03-08 9:54 UTC (permalink / raw)
To: Jim Cromie
Cc: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx,
Jason Baron, Josh Poimboeuf, Thomas Gleixner, Alice Ryhl,
Steven Rostedt, Ard Biesheuvel, Alexandre Chartre, Juergen Gross,
Andy Lutomirski, Ingo Molnar, Borislav Petkov, Dave Hansen, x86,
H. Peter Anvin, Kees Cook, Nathan Chancellor, Lukas Bulwahn
First strike for not Cc'ing me on all patches in the series :/
On Thu, Mar 05, 2026 at 06:50:04PM -0700, Jim Cromie wrote:
> Currently, `HAVE_JUMP_LABEL_BATCH` provides an architecture-level
> mechanism to defer instruction synchronization (`text_poke_sync()`)
> when patching a sequence of static keys. However, this deferred
> batching capability is not exposed as a public kernel API. Subsystems
> that need to toggle a large number of static keys (e.g.,
> dynamic_debug) currently suffer from O(N) overhead due to repeated
> machine-wide synchronizations (stop_machine).
>
> This patch introduces a public queueing API to expose this deferred
> synchronization mechanism to the rest of the kernel. This allows
> multiple static keys to be enabled/disabled by queueing their
> architecture-level updates, before applying a single machine-wide
> synchronization barrier after all instructions are modified.
>
> The new API consists of:
> - static_key_enable_queued(key)
> - static_key_disable_queued(key)
> - static_key_apply_queued() (the global barrier/flush)
> - static_branch_enable_queued(x) / static_branch_disable_queued(x) macros
>
> NOTES:
>
> The '_queued' API suffix was chosen to match the underlying
> 'arch_jump_label_transform_queue' and to avoid confusion with the
> existing rate-limited 'static_key_deferred' API.
>
> Also unify the names under the 'static_key_*' prefix, renaming
> jump_label_apply_queued to static_key_apply_queued (with a
> compatibility macro) for consistency.
>
> A pr_debug() is added to show the poked addresses, this exposed the
> semi-random ordering coming from dynamic-debug, despite its ordered
> descriptors.
>
> So x86/kernel/alternatives gets new code to do an insert-sort, by
> memcpy & memmove after appending. This sorting yields a dramatic IPI
> reduction; a following patch to dynamic-debug uses the API, and
> includes the numbers.
>
Second strike for doing *WAAAY* to many things in one patch.
> +EXPORT_SYMBOL_GPL(static_key_enable_queued);
> +EXPORT_SYMBOL_GPL(static_key_disable_queued);
> +EXPORT_SYMBOL_GPL(static_key_apply_queued);
Third strike for exposing this to modules; flipping a ton of keys is
*not* something sensible.
> + pr_debug("incoming addr=%px, current_qlen=%d\n",
> + addr, text_poke_array.nr_entries);
> +
And seriously, what?!
^ permalink raw reply [flat|nested] 11+ messages in thread
* [RFC PATCH 2/7] virtio: use pr_debug_ratelimited to avoid flooding
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 1/7] jump_label: expose queueing API for batched static key updates Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 3/7] drivers/tty/serial/serial_core: ratelimit uart_wait_until_sent Jim Cromie
` (4 subsequent siblings)
6 siblings, 0 replies; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Michael S. Tsirkin, Jason Wang, Xuan Zhuo,
Eugenio Pérez, Sumit Semwal, Christian König,
virtualization, linux-media, linaro-mm-sig
When I test dynamic-debug's static-key toggling performance in a
virtme-ng session, it is too easy to create an enormous flood of
printks to the console.
#> echo +p > /proc/dynamic_debug/control
#> echo -p > /proc/dynamic_debug/control
Now theres no "good reason" to shoot your own foot, but this is also
easy to fix, by ratelimiting the sources of the flood. I don't think
theres a loss of utility to virtio.
Example console output is below the snip. For this test-case,
ratelimiting suppresses >900k callbacks. It also allows this simple
load test for the static-key toggling performance in a following patch.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
root@drm-misc-fixes-2026-02-26-80-g9a2f253ad689:/home/jimc/projects/lx/wk-D/b0-dd# ddcmdq -p
[ 619.868567] dyndbg: query 0: "-p" mod:*
Delta-CAL (IPI): 71
- above is a noop baseline.
root@drm-misc-fixes-2026-02-26-80-g9a2f253ad689:/home/jimc/projects/lx/wk-D/b0-dd# ddcmdq +p
[ 648.876520] dyndbg: query 0: "+p" mod:*
[ 648.878263] dyndbg: match on module: led_class
[ 648.878350] dyndbg: match on module: probe
[ 648.878474] dyndbg: match on module: pci
[ 648.878636] dyndbg: match on module: pci_driver
[ 648.878743] dyndbg: match on module: irq
[ 648.878845] dyndbg: match on module: setup_bus
[ 648.879032] dyndbg: match on module: pcieportdrv
[ 648.879139] dyndbg: match on module: bwctrl
[ 648.879197] dyndbg: match on module: aspm
[ 648.879241] dyndbg: match on module: slot
[ 648.879328] dyndbg: match on module: pci_acpi
[ 648.879431] dyndbg: match on module: quirks
[ 648.879521] dyndbg: match on module: pci_hotplug
[ 648.879576] dyndbg: match on module: vgaarb
[ 648.879710] dyndbg: match on module: backlight
[ 648.879826] dyndbg: match on module: fb
[ 648.879900] dyndbg: match on module: tables
[ 648.880012] dyndbg: match on module: acpi
[ 648.880977] dyndbg: match on module: ac
[ 648.881021] dyndbg: match on module: button
[ 648.881097] dyndbg: match on module: fan
[ 648.881196] dyndbg: match on module: video
[ 648.881295] dyndbg: match on module: processor
[ 648.881558] dyndbg: match on module: thermal_lib
[ 648.881671] dyndbg: match on module: thermal
[ 648.881784] dyndbg: match on module: srat
[ 648.881860] dyndbg: match on module: battery
[ 648.881938] dyndbg: match on module: acpi_x86
[ 648.882088] dyndbg: match on module: pnp
[ 648.882219] dyndbg: match on module: dmaengine
[ 648.882351] dyndbg: match on module: virt_dma
[ 648.882429] dyndbg: match on module: acpi_dma
[ 648.882518] dyndbg: match on module: dw_dmac_core
[ 648.882619] dyndbg: match on module: virtio_ring
[ 648.882833] dyndbg: match on module: tty_io
[ 648.882835] virtqueue_get_buf_ctx_split: 852672 callbacks suppressed
[ 648.882836] No more buffers in queue
[ 648.882837] virtqueue_add_split: 4962 callbacks suppressed
[ 648.882838] Added buffer head 0 to 00000000531af360
[ 648.882842] No more buffers in queue
[ 648.882843] No more buffers in queue
[ 648.882843] No more buffers in queue
[ 648.882844] No more buffers in queue
[ 648.882844] No more buffers in queue
[ 648.882845] No more buffers in queue
[ 648.882845] No more buffers in queue
[ 648.882846] No more buffers in queue
[ 648.882846] No more buffers in queue
[ 648.882857] Added buffer head 0 to 00000000531af360
[ 648.882869] Added buffer head 0 to 00000000531af360
[ 648.882874] vring_interrupt: 88637 callbacks suppressed
[ 648.882876] virtqueue interrupt with no work for 00000000e20c0e9d
[ 648.882882] Added buffer head 0 to 00000000531af360
[ 648.882899] Added buffer head 0 to 00000000531af360
[ 648.882909] Added buffer head 0 to 00000000531af360
[ 648.882919] Added buffer head 0 to 00000000531af360
[ 648.882930] Added buffer head 0 to 00000000531af360
[ 648.882941] Added buffer head 0 to 00000000531af360
[ 648.882951] Added buffer head 0 to 00000000531af360
[ 648.883860] virtqueue interrupt with no work for 00000000531af360
[ 648.883920] virtqueue interrupt with no work for 0000000088284d45
[ 648.883980] virtqueue interrupt with no work for 000000006b8c4aa3
[ 648.884033] virtqueue interrupt with no work for 00000000f205a9b7
[ 648.884085] virtqueue interrupt with no work for 0000000021930e68
[ 648.884138] virtqueue interrupt with no work for 0000000081dad94c
[ 648.884190] virtqueue interrupt with no work for 0000000097d16d2d
[ 648.884243] virtqueue interrupt with no work for 00000000b4539010
[ 648.884296] virtqueue interrupt with no work for 00000000ac870038
[ 648.884418] dyndbg: match on module: tty_jobctrl
[ 648.884476] dyndbg: match on module: vt_ioctl
[ 648.884528] dyndbg: match on module: serial_base
[ 648.884625] dyndbg: match on module: 8250
[ 648.884698] dyndbg: match on module: 8250_base
[ 648.884795] dyndbg: match on module: 8250_exar
[ 648.884856] dyndbg: match on module: 8250_pci
[ 648.884962] dyndbg: match on module: 8250_pericom
[ 648.885014] dyndbg: match on module: virtio_console
[ 648.885091] dyndbg: match on module: iommu
[ 648.885132] dyndbg: match on module: init
[ 648.885174] dyndbg: match on module: ppr
[ 648.885216] dyndbg: match on module: iommu
[ 648.885256] dyndbg: match on module: dmar
[ 648.885334] dyndbg: match on module: iommu
[ 648.885419] dyndbg: match on module: virtio_iommu
[ 648.885481] dyndbg: match on module: drm
[ 648.885577] dyndbg: match on module: ttm
[ 648.885651] dyndbg: match on module: component
[ 648.885756] dyndbg: match on module: core
[ 648.885979] dyndbg: match on module: bus
[ 648.886081] dyndbg: match on module: dd
[ 648.886238] dyndbg: match on module: syscore
[ 648.886339] dyndbg: match on module: class
[ 648.886429] dyndbg: match on module: platform
[ 648.886519] dyndbg: match on module: faux
[ 648.886567] dyndbg: match on module: main
[ 648.886664] dyndbg: match on module: wakeup
[ 648.886765] dyndbg: match on module: firmware_class
[ 648.886925] dyndbg: match on module: regmap
[ 648.886971] dyndbg: match on module: regcache
[ 648.887089] dyndbg: match on module: regcache_flat
[ 648.887142] dyndbg: match on module: regmap_debugfs
[ 648.887195] dyndbg: match on module: mei
[ 648.887914] dyndbg: match on module: mei_me
[ 648.888149] dyndbg: match on module: dax
[ 648.888267] dyndbg: match on module: dma_buf
[ 648.888322] dyndbg: match on module: scsi_mod
[ 648.888413] dyndbg: match on module: virtio_scsi
[ 648.888486] dyndbg: match on module: libata
[ 648.888736] dyndbg: match on module: ahci
[ 648.888816] dyndbg: match on module: libahci
[ 648.888895] dyndbg: match on module: ata_piix
[ 648.888960] dyndbg: match on module: pata_amd
[ 648.889050] dyndbg: match on module: pata_oldpiix
[ 648.889124] dyndbg: match on module: pata_sch
[ 648.889172] dyndbg: match on module: mdio_bus
[ 648.889229] dyndbg: match on module: libphy
[ 648.889303] dyndbg: match on module: realtek
[ 648.889395] dyndbg: match on module: fwnode_mdio
[ 648.889468] dyndbg: match on module: virtio_net
[ 648.889697] dyndbg: match on module: pcmcia_core
[ 648.889848] dyndbg: match on module: pcmcia
[ 648.890263] dyndbg: match on module: pci_quirks
[ 648.890322] dyndbg: match on module: i8042
[ 648.890355] dyndbg: match on module: libps2
[ 648.890441] dyndbg: match on module: input_core
[ 648.890546] dyndbg: match on module: ff_memless
[ 648.890670] dyndbg: match on module: atkbd
[ 648.890724] dyndbg: match on module: psmouse
[ 648.890981] dyndbg: match on module: rtc_core
[ 648.891135] dyndbg: match on module: rtc_cmos
[ 648.891242] dyndbg: match on module: i2c_boardinfo
[ 648.891303] dyndbg: match on module: i2c_core
[ 648.891519] dyndbg: match on module: i2c_smbus
[ 648.891624] dyndbg: match on module: i2c_i801
[ 648.891757] dyndbg: match on module: pps_core
[ 648.891925] dyndbg: match on module: power_supply
[ 648.892085] dyndbg: match on module: hwmon
[ 648.892129] dyndbg: match on module: thermal_sys
[ 648.892260] dyndbg: match on module: therm_throt
[ 648.892315] dyndbg: match on module: md_mod
[ 648.892570] dyndbg: match on module: dm_mod
[ 648.892696] dyndbg: match on module: sysfs
[ 648.892741] dyndbg: match on module: dmi_scan
[ 648.892787] dyndbg: match on module: qemu_fw_cfg
[ 648.892889] dyndbg: match on module: esrt
[ 648.892935] dyndbg: match on module: mailbox
[ 648.893006] dyndbg: match on module: pcc
[ 648.893051] dyndbg: match on module: nvmem_core
[ 648.893103] dyndbg: match on module: snd
[ 648.893191] dyndbg: match on module: snd_timer
[ 648.893249] dyndbg: match on module: snd_pcm
[ 648.893356] dyndbg: match on module: snd_seq
[ 648.893514] dyndbg: match on module: snd_intel8x0
[ 648.893572] dyndbg: match on module: snd_ac97_codec
[ 648.893667] dyndbg: match on module: snd_hda_core
[ 648.893867] dyndbg: match on module: snd_intel_dspcfg
[ 648.894017] dyndbg: match on module: snd_intel_sdw_acpi
[ 648.894131] dyndbg: match on module: snd_hda_codec
[ 648.894336] dyndbg: match on module: snd_hda_codec_realtek_lib
[ 648.894479] dyndbg: match on module: snd_hda_codec_alc269
[ 648.894585] dyndbg: match on module: snd_hda_scodec_component
[ 648.894655] dyndbg: match on module: snd_hda_codec_generic
[ 648.894775] dyndbg: match on module: snd_hda_intel
[ 648.894939] dyndbg: match on module: sock
[ 648.894987] dyndbg: match on module: dev
[ 648.895119] dyndbg: match on module: sch_api
[ 648.895174] dyndbg: match on module: route
[ 648.895215] dyndbg: match on module: ip_fragment
[ 648.895264] dyndbg: match on module: ip_output
[ 648.895313] dyndbg: match on module: tcp
[ 648.895350] dyndbg: match on module: tcp_input
[ 648.895468] dyndbg: match on module: tcp_output
[ 648.895575] dyndbg: match on module: tcp_timer
[ 648.895634] dyndbg: match on module: tcp_ipv4
[ 648.895687] dyndbg: match on module: tcp_cong
[ 648.895743] dyndbg: match on module: tcp_fastopen
[ 648.895796] dyndbg: match on module: tcp_recovery
[ 648.895854] dyndbg: match on module: udp
[ 648.895951] dyndbg: match on module: arp
[ 648.895994] dyndbg: match on module: icmp
[ 648.896096] dyndbg: match on module: devinet
[ 648.896151] dyndbg: match on module: fib_trie
[ 648.896250] dyndbg: match on module: ping
[ 648.896409] dyndbg: match on module: sysctl_net_ipv4
[ 648.896505] dyndbg: match on module: ipconfig
[ 648.896567] dyndbg: match on module: tcp_cubic
[ 648.896625] dyndbg: match on module: ip6_checksum
[ 648.896718] dyndbg: match on module: sysctl_net
[ 648.896832] dyndbg: match on module: i386
[ 648.896886] dyndbg: match on module: mmconfig_shared
[ 648.896944] dyndbg: match on module: fixup
[ 648.897029] dyndbg: match on module: acpi
[ 648.897087] dyndbg: match on module: irq
[ 648.897185] dyndbg: match on module: decompress
[ 648.897253] dyndbg: match on module: kobject
[ 648.897366] dyndbg: match on module: kobject_uevent
[ 648.897478] dyndbg: applied queued updates to 1900 sites in total
[ 648.897586] applying 1879 queued jump_labels
[ 648.898378] virtqueue callback for 00000000b8493952 (000000004941ab6e)
[ 648.898493] virtio_fs_send_req: opcode 5 unique 0x45a0 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.898493] virtio_fs_send_req: opcode 5 unique 0x459e nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.898582] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.898752] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.898905] virtio_fs_send_req: opcode 5 unique 0x45a2 nodeid 0x2f2 in.len 40 out.len 4095 queue_id 1
[ 648.898912] virtio_fs_send_req: opcode 5 unique 0x45a4 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.899066] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.899183] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.899276] virtio_fs_send_req: opcode 5 unique 0x45a6 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.899281] virtio_fs_send_req: opcode 5 unique 0x45a8 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.899413] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.899528] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.899608] virtio_fs_send_req: opcode 5 unique 0x45ac nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.899608] virtio_fs_send_req: opcode 5 unique 0x45aa nodeid 0x2f2 in.len 40 out.len 4095 queue_id 1
[ 648.899711] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.899850] virtqueue callback for 00000000531af360 (00000000df837aee)
[ 648.899957] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.899989] virtio_fs_send_req: opcode 5 unique 0x45ae nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.899992] virtio_fs_send_req: opcode 5 unique 0x45b0 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.900080] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.900084] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.900520] virtio_fs_send_req: opcode 5 unique 0x45b2 nodeid 0x2f2 in.len 40 out.len 4095 queue_id 1
[ 648.900557] virtio_fs_send_req: opcode 5 unique 0x45b4 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.900725] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.901958] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.902056] virtio_fs_send_req: opcode 5 unique 0x45b6 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.902069] virtio_fs_send_req: opcode 14 unique 0x45b8 nodeid 0x245 in.len 48 out.len 16 queue_id 1
[ 648.902292] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.902409] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.902506] virtio_fs_send_req: opcode 5 unique 0x45ba nodeid 0x2f2 in.len 40 out.len 4095 queue_id 1
[ 648.902507] overlayfs: open(00000000cc553079[bin/grep/l], 0100040) -> (00000000ebc0a9b2, 01100040)
[ 648.902707] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.902793] virtio_fs_send_req: opcode 5 unique 0x45bc nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.902861] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.903071] virtio_fs_send_req: opcode 14 unique 0x45be nodeid 0x28 in.len 48 out.len 16 queue_id 1
[ 648.903072] virtio_fs_send_req: opcode 5 unique 0x45c0 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.903325] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.903329] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.903546] overlayfs: open(0000000044db1ed7[lib64/ld-linux-x86-64.so.2/l], 0100040) -> (00000000ce7f73a3, 01100040)
[ 648.903629] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.903800] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.903896] virtio_fs_send_req: opcode 5 unique 0x45c2 nodeid 0x2f2 in.len 40 out.len 4095 queue_id 1
[ 648.903921] virtio_fs_send_req: opcode 14 unique 0x45c4 nodeid 0x2b in.len 48 out.len 16 queue_id 1
[ 648.904123] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.904252] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.904382] overlayfs: open(0000000044db1ed7[/ld.so.cache/l], 0100000) -> (00000000a546e0ec, 01100000)
[ 648.904421] virtio_fs_send_req: opcode 5 unique 0x45c6 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.904521] virtio_fs_send_req: opcode 25 unique 0x45c8 nodeid 0x2b in.len 64 out.len 0 queue_id 1
[ 648.904698] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.904849] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.904982] virtio_fs_send_req: opcode 5 unique 0x45ca nodeid 0x2f2 in.len 40 out.len 4095 queue_id 1
[ 648.905003] virtio_fs_send_req: opcode 5 unique 0x45cc nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.905214] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.905333] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.905469] virtio_fs_send_req: opcode 14 unique 0x45ce nodeid 0x2f3 in.len 48 out.len 16 queue_id 1
[ 648.905476] virtio_fs_send_req: opcode 5 unique 0x45d0 nodeid 0x4b in.len 40 out.len 4095 queue_id 1
[ 648.905672] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.905803] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.905910] overlayfs: open(00000000b23a5ecd[bin/gawk/l], 0100040) -> (0000000042a63553, 01100040)
[ 648.905918] virtio_fs_send_req: opcode 14 unique 0x45d2 nodeid 0x4c in.len 48 out.len 16 queue_id 1
[ 648.906095] virtio_fs_send_req: opcode 5 unique 0x45d4 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.906255] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.906359] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.906486] overlayfs: open(0000000044db1ed7[lib64/libpcre2-8.so.0.15.0/l], 0100000) -> (00000000761f1272, 01100000)
[ 648.906498] virtio_fs_send_req: opcode 14 unique 0x45d6 nodeid 0x28 in.len 48 out.len 16 queue_id 1
[ 648.906653] virtio_fs_send_req: opcode 25 unique 0x45d8 nodeid 0x4c in.len 64 out.len 0 queue_id 1
[ 648.906842] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.906929] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.907050] overlayfs: open(000000001dc27c49[lib64/ld-linux-x86-64.so.2/l], 0100040) -> (00000000cb9765b4, 01100040)
[ 648.907060] virtio_fs_send_req: opcode 5 unique 0x45da nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.907329] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.907428] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.907453] virtio_fs_send_req: opcode 14 unique 0x45dc nodeid 0x2b in.len 48 out.len 16 queue_id 1
[ 648.907633] virtio_fs_send_req: opcode 14 unique 0x45de nodeid 0x30 in.len 48 out.len 16 queue_id 1
[ 648.907709] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.907848] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.907943] overlayfs: open(0000000044db1ed7[lib64/libc.so.6/l], 0100000) -> (000000003b97b39b, 01100000)
[ 648.907943] overlayfs: open(000000001dc27c49[/ld.so.cache/l], 0100000) -> (00000000fce78bd3, 01100000)
[ 648.908091] virtio_fs_send_req: opcode 25 unique 0x45e0 nodeid 0x30 in.len 64 out.len 0 queue_id 1
[ 648.908169] virtio_fs_send_req: opcode 25 unique 0x45e2 nodeid 0x2b in.len 64 out.len 0 queue_id 1
[ 648.908341] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.908447] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.908581] virtio_fs_send_req: opcode 5 unique 0x45e4 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.908724] virtio_fs_send_req: opcode 18 unique 0x45e6 nodeid 0x2b in.len 64 out.len 0 queue_id 1
[ 648.908776] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.908895] virtio_fs_send_req: opcode 14 unique 0x45e8 nodeid 0x2a7 in.len 48 out.len 16 queue_id 1
[ 648.908956] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.909155] virtio_fs_send_req: opcode 5 unique 0x45ea nodeid 0x2f4 in.len 40 out.len 4095 queue_id 1
[ 648.909156] overlayfs: open(0000000044db1ed7[locale/locale-archive/l], 0100000) -> (00000000a546e0ec, 01100000)
[ 648.909346] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.909427] virtio_fs_send_req: opcode 25 unique 0x45ec nodeid 0x2a7 in.len 64 out.len 0 queue_id 1
[ 648.909506] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.909725] virtio_fs_send_req: opcode 14 unique 0x45ee nodeid 0x2f5 in.len 48 out.len 16 queue_id 1
[ 648.909764] virtio_fs_send_req: opcode 14 unique 0x45f0 nodeid 0x2a9 in.len 48 out.len 16 queue_id 1
[ 648.910023] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.910119] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.910240] overlayfs: open(0000000044db1ed7[gconv/gconv-modules.cache/l], 0100000) -> (0000000046b528d3, 01100000)
[ 648.910245] overlayfs: open(000000001dc27c49[lib64/libreadline.so.8.3/l], 0100000) -> (000000006c3dd911, 01100000)
[ 648.910382] virtio_fs_send_req: opcode 25 unique 0x45f2 nodeid 0x2a9 in.len 64 out.len 0 queue_id 1
[ 648.910515] virtio_fs_send_req: opcode 25 unique 0x45f4 nodeid 0x2f5 in.len 64 out.len 0 queue_id 1
[ 648.910662] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.910775] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.910915] virtio_fs_send_req: opcode 5 unique 0x45f6 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.910930] virtio_fs_send_req: opcode 14 unique 0x45f8 nodeid 0x2b2 in.len 48 out.len 16 queue_id 1
[ 648.911124] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.911233] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.911331] overlayfs: open(0000000044db1ed7[locale/locale.alias/l], 0100000) -> (000000001b94a7b7, 01100000)
[ 648.911332] virtio_fs_send_req: opcode 5 unique 0x45fa nodeid 0x2f6 in.len 40 out.len 4095 queue_id 1
[ 648.911483] virtio_fs_send_req: opcode 25 unique 0x45fc nodeid 0x2b2 in.len 64 out.len 0 queue_id 1
[ 648.911664] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.911757] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.911865] virtio_fs_send_req: opcode 18 unique 0x45fe nodeid 0x2b2 in.len 64 out.len 0 queue_id 1
[ 648.911870] virtio_fs_send_req: opcode 14 unique 0x4600 nodeid 0x2f7 in.len 48 out.len 16 queue_id 1
[ 648.912086] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.912188] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.912284] overlayfs: open(000000001dc27c49[lib64/libmpfr.so.6.2.2/l], 0100000) -> (00000000dd259cff, 01100000)
[ 648.912289] virtio_fs_send_req: opcode 18 unique 0x4602 nodeid 0x28 in.len 64 out.len 0 queue_id 1
[ 648.912456] virtio_fs_send_req: opcode 25 unique 0x4604 nodeid 0x2f7 in.len 64 out.len 0 queue_id 1
[ 648.912515] virtio_fs_send_req: opcode 18 unique 0x4606 nodeid 0x2a9 in.len 64 out.len 0 queue_id 1
[ 648.912599] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.912603] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.912924] virtio_fs_send_req: opcode 18 unique 0x4608 nodeid 0x4c in.len 64 out.len 0 queue_id 1
[ 648.912943] virtio_fs_send_req: opcode 5 unique 0x460a nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.913017] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.913020] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.913078] virtio_fs_send_req: opcode 18 unique 0x460c nodeid 0x30 in.len 64 out.len 0 queue_id 1
[ 648.913298] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.913356] virtio_fs_send_req: opcode 18 unique 0x460e nodeid 0x2a7 in.len 64 out.len 0 queue_id 1
[ 648.913463] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.913537] virtio_fs_send_req: opcode 18 unique 0x4610 nodeid 0x245 in.len 64 out.len 0 queue_id 1
[ 648.913877] virtio_fs_send_req: opcode 5 unique 0x4612 nodeid 0x2f8 in.len 40 out.len 4095 queue_id 1
[ 648.913927] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.914084] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.914219] virtio_fs_send_req: opcode 14 unique 0x4614 nodeid 0x2f9 in.len 48 out.len 16 queue_id 1
[ 648.914388] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.914488] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.914586] overlayfs: open(000000001dc27c49[lib64/libgmp.so.10.5.0/l], 0100000) -> (00000000c480dc70, 01100000)
[ 648.914746] virtio_fs_send_req: opcode 25 unique 0x4616 nodeid 0x2f9 in.len 64 out.len 0 queue_id 1
[ 648.914898] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.914993] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.915130] virtio_fs_send_req: opcode 5 unique 0x4618 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.915297] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.915391] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.915500] virtio_fs_send_req: opcode 14 unique 0x461a nodeid 0x42 in.len 48 out.len 16 queue_id 1
[ 648.915676] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.915772] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.915873] overlayfs: open(000000001dc27c49[lib64/libm.so.6/l], 0100000) -> (00000000aab89989, 01100000)
[ 648.916022] virtio_fs_send_req: opcode 25 unique 0x461c nodeid 0x42 in.len 64 out.len 0 queue_id 1
[ 648.916184] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.916282] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.916386] virtio_fs_send_req: opcode 5 unique 0x461e nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.916559] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.916656] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.916756] virtio_fs_send_req: opcode 14 unique 0x4620 nodeid 0x30 in.len 48 out.len 16 queue_id 1
[ 648.916947] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.917045] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.917171] overlayfs: open(000000001dc27c49[lib64/libc.so.6/l], 0100000) -> (00000000065b2aff, 01100000)
[ 648.917339] virtio_fs_send_req: opcode 25 unique 0x4622 nodeid 0x30 in.len 64 out.len 0 queue_id 1
[ 648.917498] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.917596] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.917710] virtio_fs_send_req: opcode 5 unique 0x4624 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.917901] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.917998] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.918105] virtio_fs_send_req: opcode 5 unique 0x4626 nodeid 0x1ed in.len 40 out.len 4095 queue_id 1
[ 648.918283] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.918380] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.918489] virtio_fs_send_req: opcode 14 unique 0x4628 nodeid 0x1ee in.len 48 out.len 16 queue_id 1
[ 648.918682] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.918780] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.918881] overlayfs: open(000000001dc27c49[lib64/libtinfo.so.6.5/l], 0100000) -> (0000000057c26190, 01100000)
[ 648.919054] virtio_fs_send_req: opcode 25 unique 0x462a nodeid 0x1ee in.len 64 out.len 0 queue_id 1
[ 648.919219] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.919318] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.919997] virtio_fs_send_req: opcode 18 unique 0x462c nodeid 0x2b in.len 64 out.len 0 queue_id 1
[ 648.920159] virtio_fs_send_req: opcode 14 unique 0x462e nodeid 0x2a7 in.len 48 out.len 16 queue_id 1
[ 648.920169] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.920368] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.920492] overlayfs: open(000000001dc27c49[locale/locale-archive/l], 0100000) -> (00000000fce78bd3, 01100000)
[ 648.920627] virtio_fs_send_req: opcode 25 unique 0x4630 nodeid 0x2a7 in.len 64 out.len 0 queue_id 1
[ 648.920772] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.920871] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.921036] virtio_fs_send_req: opcode 14 unique 0x4632 nodeid 0x2a9 in.len 48 out.len 16 queue_id 1
[ 648.921211] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.921308] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.921400] overlayfs: open(000000001dc27c49[gconv/gconv-modules.cache/l], 0100000) -> (00000000d54e120f, 01100000)
[ 648.921523] virtio_fs_send_req: opcode 25 unique 0x4634 nodeid 0x2a9 in.len 64 out.len 0 queue_id 1
[ 648.921666] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.921770] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.921832] virtqueue callback for 00000000531af360 (00000000df837aee)
[ 648.922226] virtio_fs_send_req: opcode 18 unique 0x4636 nodeid 0x28 in.len 64 out.len 0 queue_id 1
[ 648.922326] virtio_fs_send_req: opcode 18 unique 0x4638 nodeid 0x2a9 in.len 64 out.len 0 queue_id 1
[ 648.922400] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.922416] virtio_fs_send_req: opcode 18 unique 0x463a nodeid 0x2f5 in.len 64 out.len 0 queue_id 1
[ 648.922482] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.922564] virtio_fs_send_req: opcode 18 unique 0x463c nodeid 0x2f7 in.len 64 out.len 0 queue_id 1
[ 648.922690] virtio_fs_send_req: opcode 18 unique 0x463e nodeid 0x2f9 in.len 64 out.len 0 queue_id 1
[ 648.922762] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.922780] virtio_fs_send_req: opcode 18 unique 0x4640 nodeid 0x42 in.len 64 out.len 0 queue_id 1
[ 648.922847] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.922929] virtio_fs_send_req: opcode 18 unique 0x4642 nodeid 0x30 in.len 64 out.len 0 queue_id 1
[ 648.923060] virtio_fs_send_req: opcode 18 unique 0x4644 nodeid 0x1ee in.len 64 out.len 0 queue_id 1
[ 648.923126] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.923166] virtio_fs_send_req: opcode 18 unique 0x4646 nodeid 0x2a7 in.len 64 out.len 0 queue_id 1
[ 648.923228] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.923311] virtio_fs_send_req: opcode 18 unique 0x4648 nodeid 0x2f3 in.len 64 out.len 0 queue_id 1
[ 648.923487] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.923557] virtiofs virtio0: virtio_fs_vq_done requests.0
Delta-CAL (IPI): 6007
- this number is before the insert-sort, final number is better.
[ 648.926990] virtio_fs_send_req: opcode 14 unique 0x464a nodeid 0xae in.len 48 out.len 16 queue_id 1
[ 648.927221] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.927312] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.927409] overlayfs: open(00000000ae2b3a37[/machine-id/l], 0100000) -> (00000000ebc0a9b2, 01100000)
[ 648.927537] virtio_fs_send_req: opcode 25 unique 0x464c nodeid 0xae in.len 64 out.len 0 queue_id 1
[ 648.927709] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.927798] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.927888] virtio_fs_send_req: opcode 18 unique 0x464e nodeid 0xae in.len 64 out.len 0 queue_id 1
[ 648.928052] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.928135] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.928914] virtqueue callback for 00000000b8493952 (000000004941ab6e)
[ 648.929008] virtio_fs_send_req: opcode 5 unique 0x4650 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.929175] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.929246] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.929318] virtio_fs_send_req: opcode 5 unique 0x4652 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.929467] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.929535] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.929604] virtio_fs_send_req: opcode 5 unique 0x4654 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.929751] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.929824] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.929899] virtio_fs_send_req: opcode 5 unique 0x4656 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.930043] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.930110] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.930188] virtio_fs_send_req: opcode 5 unique 0x4658 nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.930331] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.930399] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.930503] virtio_fs_send_req: opcode 5 unique 0x465a nodeid 0x23 in.len 40 out.len 4095 queue_id 1
[ 648.930648] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.930717] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.930795] virtio_fs_send_req: opcode 14 unique 0x465c nodeid 0x204 in.len 48 out.len 16 queue_id 1
[ 648.930976] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.931046] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.931132] overlayfs: open(00000000b23a5ecd[bin/sed/l], 0100040) -> (0000000074755de1, 01100040)
[ 648.931288] virtio_fs_send_req: opcode 5 unique 0x465e nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.931448] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.931517] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.931600] virtio_fs_send_req: opcode 14 unique 0x4660 nodeid 0x28 in.len 48 out.len 16 queue_id 1
[ 648.931751] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.931826] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.931906] overlayfs: open(00000000fea37e0c[lib64/ld-linux-x86-64.so.2/l], 0100040) -> (00000000ebc0a9b2, 01100040)
[ 648.932282] virtio_fs_send_req: opcode 14 unique 0x4662 nodeid 0x2b in.len 48 out.len 16 queue_id 1
[ 648.932437] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.932508] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.932593] overlayfs: open(00000000fea37e0c[/ld.so.cache/l], 0100000) -> (00000000a546e0ec, 01100000)
[ 648.932710] virtio_fs_send_req: opcode 25 unique 0x4664 nodeid 0x2b in.len 64 out.len 0 queue_id 1
[ 648.932868] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.932945] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.933038] virtio_fs_send_req: opcode 5 unique 0x4666 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.933203] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.933285] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.933377] virtio_fs_send_req: opcode 5 unique 0x4668 nodeid 0x2c in.len 40 out.len 4095 queue_id 1
[ 648.933528] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.933606] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.933695] virtio_fs_send_req: opcode 14 unique 0x466a nodeid 0x2d in.len 48 out.len 16 queue_id 1
[ 648.933850] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.933924] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.934031] overlayfs: open(00000000fea37e0c[lib64/libacl.so.1.1.2302/l], 0100000) -> (000000003b97b39b, 01100000)
[ 648.934194] virtio_fs_send_req: opcode 25 unique 0x466c nodeid 0x2d in.len 64 out.len 0 queue_id 1
[ 648.934349] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.934427] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.934513] virtio_fs_send_req: opcode 5 unique 0x466e nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.934668] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.934745] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.934835] virtio_fs_send_req: opcode 14 unique 0x4670 nodeid 0x41 in.len 48 out.len 16 queue_id 1
[ 648.934991] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.935069] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.935152] overlayfs: open(00000000fea37e0c[lib64/libselinux.so.1/l], 0100000) -> (00000000761f1272, 01100000)
[ 648.935308] virtio_fs_send_req: opcode 25 unique 0x4672 nodeid 0x41 in.len 64 out.len 0 queue_id 1
[ 648.935462] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.935540] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.935650] virtio_fs_send_req: opcode 5 unique 0x4674 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.935800] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.935899] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.935994] virtio_fs_send_req: opcode 14 unique 0x4676 nodeid 0x30 in.len 48 out.len 16 queue_id 1
[ 648.936148] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.936226] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.936316] overlayfs: open(00000000fea37e0c[lib64/libc.so.6/l], 0100000) -> (0000000046b528d3, 01100000)
[ 648.936448] virtio_fs_send_req: opcode 25 unique 0x4678 nodeid 0x30 in.len 64 out.len 0 queue_id 1
[ 648.936612] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.936691] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.936784] virtio_fs_send_req: opcode 5 unique 0x467a nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.936943] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.937022] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.937125] virtio_fs_send_req: opcode 5 unique 0x467c nodeid 0x43 in.len 40 out.len 4095 queue_id 1
[ 648.937274] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.937353] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.937447] virtio_fs_send_req: opcode 14 unique 0x467e nodeid 0x44 in.len 48 out.len 16 queue_id 1
[ 648.937604] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.937683] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.937769] overlayfs: open(00000000fea37e0c[lib64/libattr.so.1.1.2502/l], 0100000) -> (00000000ce7f73a3, 01100000)
[ 648.937964] virtio_fs_send_req: opcode 25 unique 0x4680 nodeid 0x44 in.len 64 out.len 0 queue_id 1
[ 648.938148] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.938229] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.938329] virtio_fs_send_req: opcode 5 unique 0x4682 nodeid 0x26 in.len 40 out.len 4095 queue_id 1
[ 648.938499] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.938577] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.938669] virtio_fs_send_req: opcode 5 unique 0x4684 nodeid 0x4b in.len 40 out.len 4095 queue_id 1
[ 648.938831] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.938914] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.939013] virtio_fs_send_req: opcode 14 unique 0x4686 nodeid 0x4c in.len 48 out.len 16 queue_id 1
[ 648.939192] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.939272] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.939361] overlayfs: open(00000000fea37e0c[lib64/libpcre2-8.so.0.15.0/l], 0100000) -> (000000001b94a7b7, 01100000)
[ 648.939502] virtio_fs_send_req: opcode 25 unique 0x4688 nodeid 0x4c in.len 64 out.len 0 queue_id 1
[ 648.939654] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.939734] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.940088] virtio_fs_send_req: opcode 18 unique 0x468a nodeid 0x2b in.len 64 out.len 0 queue_id 1
[ 648.940214] virtio_fs_send_req: opcode 1 unique 0x468c nodeid 0x1 in.len 48 out.len 128 queue_id 1
[ 648.940273] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.940394] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.940552] virtio_fs_send_req: opcode 14 unique 0x468e nodeid 0x2a7 in.len 48 out.len 16 queue_id 1
[ 648.940730] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.940819] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.940910] overlayfs: open(00000000fea37e0c[locale/locale-archive/l], 0100000) -> (00000000a546e0ec, 01100000)
[ 648.941042] virtio_fs_send_req: opcode 25 unique 0x4690 nodeid 0x2a7 in.len 64 out.len 0 queue_id 1
[ 648.941215] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.941295] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.941413] virtio_fs_send_req: opcode 14 unique 0x4692 nodeid 0x2a9 in.len 48 out.len 16 queue_id 1
[ 648.941577] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.941654] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.941735] overlayfs: open(00000000fea37e0c[gconv/gconv-modules.cache/l], 0100000) -> (000000007d5f2653, 01100000)
[ 648.941867] virtio_fs_send_req: opcode 25 unique 0x4694 nodeid 0x2a9 in.len 64 out.len 0 queue_id 1
[ 648.942022] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.942105] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.942374] virtio_fs_send_req: opcode 18 unique 0x4696 nodeid 0x28 in.len 64 out.len 0 queue_id 1
[ 648.942487] virtio_fs_send_req: opcode 18 unique 0x4698 nodeid 0x2a9 in.len 64 out.len 0 queue_id 1
[ 648.942559] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.942599] virtio_fs_send_req: opcode 18 unique 0x469a nodeid 0x2d in.len 64 out.len 0 queue_id 1
[ 648.942660] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.942757] virtio_fs_send_req: opcode 18 unique 0x469c nodeid 0x41 in.len 64 out.len 0 queue_id 1
[ 648.942912] virtio_fs_send_req: opcode 18 unique 0x469e nodeid 0x30 in.len 64 out.len 0 queue_id 1
[ 648.942973] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.943020] virtio_fs_send_req: opcode 18 unique 0x46a0 nodeid 0x44 in.len 64 out.len 0 queue_id 1
[ 648.943084] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.943247] virtio_fs_send_req: opcode 18 unique 0x46a2 nodeid 0x4c in.len 64 out.len 0 queue_id 1
[ 648.943318] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.943353] virtio_fs_send_req: opcode 18 unique 0x46a4 nodeid 0x2a7 in.len 64 out.len 0 queue_id 1
[ 648.943417] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.943514] virtio_fs_send_req: opcode 18 unique 0x46a6 nodeid 0x204 in.len 64 out.len 0 queue_id 1
[ 648.943698] virtqueue callback for 00000000ffb9412a (00000000c5ce06f7)
[ 648.943776] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 648.948394] uart_wait_until_sent(0), jiffies=4295316070, expire=4295316142...
root@drm-misc-fixes-2026-02-26-80-g9a2f253ad689:/home/jimc/projects/lx/wk-D/b0-dd#
---
drivers/virtio/virtio_ring.c | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 335692d41617..99f9e547d264 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -759,7 +759,7 @@ static inline int virtqueue_add_split(struct vring_virtqueue *vq,
vq->split.avail_idx_shadow);
vq->num_added++;
- pr_debug("Added buffer head %i to %p\n", head, vq);
+ pr_debug_ratelimited("Added buffer head %i to %p\n", head, vq);
END_USE(vq);
/* This is very unlikely, but theoretically possible. Kick
@@ -930,7 +930,7 @@ static void *virtqueue_get_buf_ctx_split(struct vring_virtqueue *vq,
}
if (!more_used_split(vq)) {
- pr_debug("No more buffers in queue\n");
+ pr_debug_ratelimited("No more buffers in queue\n");
END_USE(vq);
return NULL;
}
@@ -1595,7 +1595,7 @@ static int virtqueue_add_indirect_packed(struct vring_virtqueue *vq,
vq->num_added += 1;
- pr_debug("Added buffer head %i to %p\n", head, vq);
+ pr_debug_ratelimited("Added buffer head %i to %p\n", head, vq);
END_USE(vq);
return 0;
@@ -1744,7 +1744,7 @@ static inline int virtqueue_add_packed(struct vring_virtqueue *vq,
vq->packed.vring.desc[head].flags = head_flags;
vq->num_added += descs_used;
- pr_debug("Added buffer head %i to %p\n", head, vq);
+ pr_debug_ratelimited("Added buffer head %i to %p\n", head, vq);
END_USE(vq);
return 0;
@@ -1902,7 +1902,7 @@ static inline int virtqueue_add_packed_in_order(struct vring_virtqueue *vq,
vq->packed.vring.desc[head].flags = head_flags;
vq->num_added += total_sg;
- pr_debug("Added buffer head %i to %p\n", head, vq);
+ pr_debug_ratelimited("Added buffer head %i to %p\n", head, vq);
END_USE(vq);
return 0;
@@ -3231,7 +3231,7 @@ irqreturn_t vring_interrupt(int irq, void *_vq)
struct vring_virtqueue *vq = to_vvq(_vq);
if (!more_used(vq)) {
- pr_debug("virtqueue interrupt with no work for %p\n", vq);
+ pr_debug_ratelimited("virtqueue interrupt with no work for %p\n", vq);
return IRQ_NONE;
}
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread* [RFC PATCH 3/7] drivers/tty/serial/serial_core: ratelimit uart_wait_until_sent
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 1/7] jump_label: expose queueing API for batched static key updates Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 2/7] virtio: use pr_debug_ratelimited to avoid flooding Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
2026-03-06 6:32 ` Jiri Slaby
2026-03-06 1:50 ` [RFC PATCH 4/7] dyndbg: use static-key queueing API in dynamic-debug Jim Cromie
` (3 subsequent siblings)
6 siblings, 1 reply; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Greg Kroah-Hartman, Jiri Slaby, Petr Mladek,
Ilpo Järvinen, Dr. David Alan Gilbert, Joseph Tilahun,
linux-serial
Ratelimiting these pr_debug()s can reduce the console flood during
bulk dynamic-debug activation, in environments where a serial console
is used.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
drivers/tty/serial/serial_core.c | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index 487756947a96..6db465619c70 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -1790,8 +1790,8 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
expire = jiffies + timeout;
- pr_debug("uart_wait_until_sent(%u), jiffies=%lu, expire=%lu...\n",
- port->line, jiffies, expire);
+ pr_debug_ratelimited("waiting on (%u) jiffies=%lu, expire=%lu...\n",
+ port->line, jiffies, expire);
/*
* Check whether the transmitter is empty every 'char_time'.
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [RFC PATCH 3/7] drivers/tty/serial/serial_core: ratelimit uart_wait_until_sent
2026-03-06 1:50 ` [RFC PATCH 3/7] drivers/tty/serial/serial_core: ratelimit uart_wait_until_sent Jim Cromie
@ 2026-03-06 6:32 ` Jiri Slaby
2026-03-06 14:02 ` jim.cromie
0 siblings, 1 reply; 11+ messages in thread
From: Jiri Slaby @ 2026-03-06 6:32 UTC (permalink / raw)
To: Jim Cromie, linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Greg Kroah-Hartman, Petr Mladek, Ilpo Järvinen,
Dr. David Alan Gilbert, Joseph Tilahun, linux-serial
On 06. 03. 26, 2:50, Jim Cromie wrote:
> Ratelimiting these pr_debug()s can reduce the console flood during
> bulk dynamic-debug activation, in environments where a serial console
> is used.
>
> Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
> ---
> drivers/tty/serial/serial_core.c | 4 ++--
> 1 file changed, 2 insertions(+), 2 deletions(-)
>
> diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
> index 487756947a96..6db465619c70 100644
> --- a/drivers/tty/serial/serial_core.c
> +++ b/drivers/tty/serial/serial_core.c
> @@ -1790,8 +1790,8 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
>
> expire = jiffies + timeout;
>
> - pr_debug("uart_wait_until_sent(%u), jiffies=%lu, expire=%lu...\n",
> - port->line, jiffies, expire);
> + pr_debug_ratelimited("waiting on (%u) jiffies=%lu, expire=%lu...\n",
> + port->line, jiffies, expire);
The changed message does not make any sense.
--
js
suse labs
^ permalink raw reply [flat|nested] 11+ messages in thread* Re: [RFC PATCH 3/7] drivers/tty/serial/serial_core: ratelimit uart_wait_until_sent
2026-03-06 6:32 ` Jiri Slaby
@ 2026-03-06 14:02 ` jim.cromie
0 siblings, 0 replies; 11+ messages in thread
From: jim.cromie @ 2026-03-06 14:02 UTC (permalink / raw)
To: Jiri Slaby
Cc: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx,
Greg Kroah-Hartman, Petr Mladek, Ilpo Järvinen,
Dr. David Alan Gilbert, Joseph Tilahun, linux-serial
On Thu, Mar 5, 2026 at 11:32 PM Jiri Slaby <jirislaby@kernel.org> wrote:
>
> On 06. 03. 26, 2:50, Jim Cromie wrote:
> > Ratelimiting these pr_debug()s can reduce the console flood during
> > bulk dynamic-debug activation, in environments where a serial console
> > is used.
> >
> > Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
> > ---
> > drivers/tty/serial/serial_core.c | 4 ++--
> > 1 file changed, 2 insertions(+), 2 deletions(-)
> >
> > diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
> > index 487756947a96..6db465619c70 100644
> > --- a/drivers/tty/serial/serial_core.c
> > +++ b/drivers/tty/serial/serial_core.c
> > @@ -1790,8 +1790,8 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
> >
> > expire = jiffies + timeout;
> >
> > - pr_debug("uart_wait_until_sent(%u), jiffies=%lu, expire=%lu...\n",
> > - port->line, jiffies, expire);
> > + pr_debug_ratelimited("waiting on (%u) jiffies=%lu, expire=%lu...\n",
> > + port->line, jiffies, expire);
>
> The changed message does not make any sense.
>
Ackn. Given the narrow rate-limiting purpose,
I should have ignored the checkpatch warning
and kept the message as is.
In any case, my test setup didnt actually use serio,
and didnt get flooded by it, so I dont know that this
single change would be enough to fix it.
I withdraw this particular patch.
>
> --
> js
> suse labs
^ permalink raw reply [flat|nested] 11+ messages in thread
* [RFC PATCH 4/7] dyndbg: use static-key queueing API in dynamic-debug
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
` (2 preceding siblings ...)
2026-03-06 1:50 ` [RFC PATCH 3/7] drivers/tty/serial/serial_core: ratelimit uart_wait_until_sent Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 5/7] dyndbg: hoist static_key_apply_queued up Jim Cromie
` (2 subsequent siblings)
6 siblings, 0 replies; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Jason Baron, Peter Zijlstra, Josh Poimboeuf,
Thomas Gleixner, Andrew Morton
Use the new static-key queueing API in dynamic-debug
function _get_cal_count() {
# Sum all CPU columns for the 'CAL' (Function call interrupts) line
grep CAL /proc/interrupts | awk '{ sum=0; for(i=2; i<NF-2; i++) sum+=$i; print sum }'
}
function ddcmdq () {
local cal_before=$(_get_cal_count)
echo $* > /proc/dynamic_debug/control
local cal_after=$(_get_cal_count)
printf "Delta-CAL (IPI): %d\n" "$((cal_after - cal_before))"
}
Before:
#> ddcmdq +p
#> ddcmdq -p
...
[ 37.165860] virtqueue callback for 000000009e760656 (00000000011de1b1)
[ 37.165952] virtiofs virtio0: virtio_fs_vq_done requests.0
[ 37.166119] dyndbg: query 0: "-p" mod:*
Delta-CAL (IPI): 16154
After:
...
[ 32.189131] dyndbg: batch desc: ffffffff89468028, static_key addr ffffffff89468050 (fbcon_startup:1032)
[ 32.189225] dyndbg: batch desc: ffffffff89468060, static_key addr ffffffff89468088 (acpi_table_parse_entries_array:264)
[ 32.189332] dyndbg: batch desc: ffffffff89468098, static_key addr ffffffff894680c0 (acpi_table_print_madt_entry:229)
Delta-CAL (IPI): 134
Extra context:
#> wc /proc/dynamic_debug/control
1903 15092 185427 /proc/dynamic_debug/control
#> ddgrep dynamic_debug
lib/dynamic_debug.c:386 [dynamic_debug]ddebug_change =_ "batch desc: %px, static_key addr %px (%s:%d)\n"
lib/dynamic_debug.c:397 [dynamic_debug]ddebug_change =_ "applied queued updates to %d sites in total\n"
#> dmesg | grep queued
[ 26.837520] dyndbg: applied queued updates to 1902 sites in total
[ 26.837631] applying 1866 queued jump_labels
The baseline has the 2 ratelimited patches cherry-picked in, so both
of these numbers include whatever overhead is caused by virtio and
dynamic-debugs pr_debug()s.
Cc: Jason Baron <jbaron@akamai.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Josh Poimboeuf <jpoimboe@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
lib/dynamic_debug.c | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index aa16782bc93b..e555a8dbdc27 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -371,10 +371,12 @@ static int ddebug_change(const struct ddebug_query *query, struct flag_settings
#ifdef CONFIG_JUMP_LABEL
if (dp->flags & _DPRINTK_FLAGS_PRINT) {
if (!(newflags & _DPRINTK_FLAGS_PRINT))
- static_branch_disable(&dp->key.dd_key_true);
+ static_branch_disable_queued(&dp->key.dd_key_true);
} else if (newflags & _DPRINTK_FLAGS_PRINT) {
- static_branch_enable(&dp->key.dd_key_true);
+ static_branch_enable_queued(&dp->key.dd_key_true);
}
+ pr_debug("batch desc: %px, static_key addr %px (%s:%d)\n",
+ dp, &dp->key.dd_key_true, dp->function, dp->lineno);
#endif
v4pr_info("changed %s:%d [%s]%s %s => %s\n",
trim_prefix(dp->filename), dp->lineno,
@@ -384,6 +386,8 @@ static int ddebug_change(const struct ddebug_query *query, struct flag_settings
dp->flags = newflags;
}
}
+ pr_debug("applied queued updates to %d sites in total\n", nfound);
+ static_key_apply_queued();
mutex_unlock(&ddebug_lock);
return nfound;
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread* [RFC PATCH 5/7] dyndbg: hoist static_key_apply_queued up
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
` (3 preceding siblings ...)
2026-03-06 1:50 ` [RFC PATCH 4/7] dyndbg: use static-key queueing API in dynamic-debug Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 6/7] lib/dynamic_debug: add negation support to queries Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 7/7] dyndbg-test: test keyword !value negation Jim Cromie
6 siblings, 0 replies; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Jason Baron, Andrew Morton
hoist static_key_apply_queued from ddebug_change to exec_queries.
This can reduce IPIs when multiple queries are submitted together in
the same command-buffer, as when they're separated by by \n ; or %.
It won't affect single command submissions, or settings of
class-map-params, which are submitted 1 bit at a time.
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
lib/dynamic_debug.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index e555a8dbdc27..80fa8d2143e8 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -386,8 +386,6 @@ static int ddebug_change(const struct ddebug_query *query, struct flag_settings
dp->flags = newflags;
}
}
- pr_debug("applied queued updates to %d sites in total\n", nfound);
- static_key_apply_queued();
mutex_unlock(&ddebug_lock);
return nfound;
@@ -719,10 +717,12 @@ static int ddebug_exec_queries(char *query, const char *modname)
}
i++;
}
- if (i)
+ if (i) {
v2pr_info("processed %d queries, with %d matches, %d errs\n",
i, nfound, errs);
-
+ pr_debug("applied queued updates to %d sites in total\n", nfound);
+ static_key_apply_queued();
+ }
if (exitcode)
return exitcode;
return nfound;
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread* [RFC PATCH 6/7] lib/dynamic_debug: add negation support to queries
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
` (4 preceding siblings ...)
2026-03-06 1:50 ` [RFC PATCH 5/7] dyndbg: hoist static_key_apply_queued up Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
2026-03-06 1:50 ` [RFC PATCH 7/7] dyndbg-test: test keyword !value negation Jim Cromie
6 siblings, 0 replies; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Andrew Morton, Jason Baron
This allow users to invert the selection of any keyword.
For example:
echo "module !virtio* +p" > /proc/dynamic_debug/control
When I test with virtme-ng, this cmd prevents flooding the logs with
virtio activity. Its not perfect, because it cannot also avoid
flooding from pr_debugs in serial_core or other potential sources.
A more robust command is:
echo "module !virtio* +p % module serial -p" > /proc/dynamic_debug/control
Signed-off-by: Jim Cromie <jim.cromie@gmail.com>
---
lib/dynamic_debug.c | 76 +++++++++++++++++++++++++++++++--------------
1 file changed, 53 insertions(+), 23 deletions(-)
diff --git a/lib/dynamic_debug.c b/lib/dynamic_debug.c
index 80fa8d2143e8..a283d12fd64d 100644
--- a/lib/dynamic_debug.c
+++ b/lib/dynamic_debug.c
@@ -59,6 +59,10 @@ struct ddebug_query {
const char *format;
const char *class_string;
unsigned int first_lineno, last_lineno;
+ unsigned int filename_neg:1;
+ unsigned int module_neg:1;
+ unsigned int function_neg:1;
+ unsigned int format_neg:1;
};
struct ddebug_iter {
@@ -163,11 +167,12 @@ static void vpr_info_dq(const struct ddebug_query *query, const char *msg)
fmtlen--;
}
- v3pr_info("%s: func=\"%s\" file=\"%s\" module=\"%s\" format=\"%.*s\" lineno=%u-%u class=%s\n",
+ v3pr_info("%s: func%s=\"%s\" file%s=\"%s\" module%s=\"%s\" format%s=\"%.*s\" lineno=%u-%u class=%s\n",
msg,
- query->function ?: "",
- query->filename ?: "",
- query->module ?: "",
+ query->function_neg ? "!" : "", query->function ?: "",
+ query->filename_neg ? "!" : "", query->filename ?: "",
+ query->module_neg ? "!" : "", query->module ?: "",
+ query->format_neg ? "!" : "",
fmtlen, query->format ?: "",
query->first_lineno, query->last_lineno, query->class_string);
}
@@ -268,32 +273,34 @@ static bool ddebug_match_desc(const struct ddebug_query *query,
int selected_class)
{
struct _ddebug_class_map *site_map;
+ bool match;
/* match against the source filename */
- if (query->filename &&
- !match_wildcard(query->filename, dp->filename) &&
- !match_wildcard(query->filename,
- kbasename(dp->filename)) &&
- !match_wildcard(query->filename,
- trim_prefix(dp->filename)))
- return false;
+ if (query->filename) {
+ match = match_wildcard(query->filename, dp->filename) ||
+ match_wildcard(query->filename, kbasename(dp->filename)) ||
+ match_wildcard(query->filename, trim_prefix(dp->filename));
+ if (match == query->filename_neg)
+ return false;
+ }
/* match against the function */
- if (query->function &&
- !match_wildcard(query->function, dp->function))
- return false;
+ if (query->function) {
+ match = match_wildcard(query->function, dp->function);
+ if (match == query->function_neg)
+ return false;
+ }
/* match against the format */
if (query->format) {
if (*query->format == '^') {
- char *p;
/* anchored search. match must be at beginning */
- p = strstr(dp->format, query->format + 1);
- if (p != dp->format)
- return false;
- } else if (!strstr(dp->format, query->format)) {
- return false;
+ match = (strstr(dp->format, query->format + 1) == dp->format);
+ } else {
+ match = !!strstr(dp->format, query->format);
}
+ if (match == query->format_neg)
+ return false;
}
/* match against the line number range */
@@ -345,9 +352,11 @@ static int ddebug_change(const struct ddebug_query *query, struct flag_settings
struct _ddebug_class_map *mods_map;
/* match against the module name */
- if (query->module &&
- !match_wildcard(query->module, di->mod_name))
- continue;
+ if (query->module) {
+ bool match = match_wildcard(query->module, di->mod_name);
+ if (match == query->module_neg)
+ continue;
+ }
selected_class = _DPRINTK_CLASS_DFLT;
if (query->class_string) {
@@ -514,6 +523,16 @@ static int parse_linerange(struct ddebug_query *query, const char *first)
return 0;
}
+static char *check_neg(char *src, unsigned int *neg)
+{
+ if (*src == '!') {
+ *neg = 1;
+ return src + 1;
+ }
+ *neg = 0;
+ return src;
+}
+
static int check_set(const char **dest, char *src, char *name)
{
int rc = 0;
@@ -558,10 +577,15 @@ static int ddebug_parse_query(char *words[], int nwords,
for (i = 0; i < nwords; i += 2) {
char *keyword = words[i];
char *arg = words[i+1];
+ unsigned int neg;
if (!strcmp(keyword, "func")) {
+ arg = check_neg(arg, &neg);
+ query->function_neg = neg;
rc = check_set(&query->function, arg, "func");
} else if (!strcmp(keyword, "file")) {
+ arg = check_neg(arg, &neg);
+ query->filename_neg = neg;
if (check_set(&query->filename, arg, "file"))
return -EINVAL;
@@ -572,6 +596,8 @@ static int ddebug_parse_query(char *words[], int nwords,
*fline++ = '\0';
if (isalpha(*fline) || *fline == '*' || *fline == '?') {
/* take as function name */
+ fline = check_neg(fline, &neg);
+ query->function_neg = neg;
if (check_set(&query->function, fline, "func"))
return -EINVAL;
} else {
@@ -579,11 +605,15 @@ static int ddebug_parse_query(char *words[], int nwords,
return -EINVAL;
}
} else if (!strcmp(keyword, "module")) {
+ arg = check_neg(arg, &neg);
+ query->module_neg = neg;
rc = check_set(&query->module, arg, "module");
} else if (!strcmp(keyword, "format")) {
string_unescape_inplace(arg, UNESCAPE_SPACE |
UNESCAPE_OCTAL |
UNESCAPE_SPECIAL);
+ arg = check_neg(arg, &neg);
+ query->format_neg = neg;
rc = check_set(&query->format, arg, "format");
} else if (!strcmp(keyword, "line")) {
if (parse_linerange(query, arg))
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread* [RFC PATCH 7/7] dyndbg-test: test keyword !value negation
2026-03-06 1:50 [RFC PATCH 0/7] queued static-key API reduces IPIs to 134/16154 in dyndbg Jim Cromie
` (5 preceding siblings ...)
2026-03-06 1:50 ` [RFC PATCH 6/7] lib/dynamic_debug: add negation support to queries Jim Cromie
@ 2026-03-06 1:50 ` Jim Cromie
6 siblings, 0 replies; 11+ messages in thread
From: Jim Cromie @ 2026-03-06 1:50 UTC (permalink / raw)
To: linux-kernel, dri-devel, amd-gfx, intel-gvt-dev, intel-gfx
Cc: Jim Cromie, Jason Baron, Shuah Khan, linux-kselftest
---
.../dynamic_debug/dyndbg_selftest.sh | 35 +++++++++++++++++++
1 file changed, 35 insertions(+)
diff --git a/tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh b/tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh
index 09937dca3056..5c35d7cc5ecf 100755
--- a/tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh
+++ b/tools/testing/selftests/dynamic_debug/dyndbg_selftest.sh
@@ -350,12 +350,47 @@ function test_mod_submod {
ifrmmod test_dynamic_debug
}
+function test_negated_keywords {
+ echo -e "${GREEN}# TEST_NEGATED_KEYWORDS ${NC}"
+
+ # Test 1: Disable negated subset from enabled set
+ # Enables all 6 in init/main.c, then pulses ONLY those that are NOT run_init_process (the 2 blacklist sites) OFF.
+ ddcmd =_
+ ddcmd file init/main.c +p
+ check_match_ct 'init/main.c:.*=p' 6 -r
+ ddcmd file init/main.c func !run_init_process -p
+ # Result: 6 - 2 = 4 sites (run_init_process) remain enabled.
+ check_match_ct 'init/main.c:.*=p' 4 -r
+ check_match_ct 'run_init_process' 4 -r
+
+ # Test 2: Enable negated subset from clean slate
+ # Negation !run_init_process should match the 2 blacklist sites.
+ ddcmd =_
+ ddcmd file init/main.c func !run_init_process +p
+ # Verify exactly 2 sites enabled
+ check_match_ct 'init/main.c:.*=p' 2 -r
+ check_match_ct 'initcall_blacklist[[:space:]]' 1 -r
+ check_match_ct 'initcall_blacklisted[[:space:]]' 1 -r
+
+ # Test 3: Enable negated subset with wildcard
+ # Negation !run_init_* should match the same 2 blacklist sites.
+ ddcmd =_
+ ddcmd file init/main.c func !run_init_* +p
+ # Verify exactly 2 sites enabled
+ check_match_ct 'init/main.c:.*=p' 2 -r
+ check_match_ct 'initcall_blacklist[[:space:]]' 1 -r
+ check_match_ct 'initcall_blacklisted[[:space:]]' 1 -r
+
+ ddcmd =_
+}
+
tests_list=(
basic_tests
# these require test_dynamic_debug*.ko
comma_terminator_tests
test_percent_splitting
test_mod_submod
+ test_negated_keywords
)
# Run tests
--
2.53.0
^ permalink raw reply [flat|nested] 11+ messages in thread