* [PATCH v3 0/3] module/kallsyms: sort function symbols and use binary search
@ 2026-11-18 14:51 Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 1/3] module/kallsyms: include empty names in is_ignored_kernel_symbol() Stanislaw Gruszka
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: Stanislaw Gruszka @ 2026-11-18 14:51 UTC (permalink / raw)
To: linux-modules, Sami Tolvanen, Luis Chamberlain, Petr Pavlu
Cc: linux-kernel, linux-trace-kernel, live-patching, Daniel Gomez,
Aaron Tomlin, Steven Rostedt, Masami Hiramatsu, Jordan Rome,
Viktor Malik, Petr Mladek
This series enables binary search over a separate index of core text
symbols, preserving symbol-table order and supporting livepatch modules.
v3:
- preserve core symtab order by sorting a separate index array
- index core text symbols rather than only function symbols
- enable indexed text lookup for livepatch modules
- rebase and update commit messages and subjects
- sort equal-address by descending symbol index so binary search
selects the same alias as linear search
v2: https://lore.kernel.org/linux-modules/20260327110005.16499-1-stf_xl@wp.pl/
- fix searching data symbols for CONFIG_KALLSYMS_ALL
- use kallsyms_symbol_value() in elf_sym_cmp()
v1: https://lore.kernel.org/linux-modules/20260317110423.45481-1-stf_xl@wp.pl/
Stanislaw Gruszka (3):
module/kallsyms: include empty names in is_ignored_kernel_symbol()
module/kallsyms: sort text symbol indices and use binary search
module/kallsyms: enable indexed text lookup for livepatch modules
include/linux/module.h | 2 +
include/linux/module_symbol.h | 6 +-
kernel/module/internal.h | 2 +
kernel/module/kallsyms.c | 202 +++++++++++++++++++++++++---------
scripts/mod/modpost.h | 2 +-
5 files changed, 161 insertions(+), 53 deletions(-)
--
2.52.0
^ permalink raw reply [flat|nested] 4+ messages in thread
* [PATCH v3 1/3] module/kallsyms: include empty names in is_ignored_kernel_symbol()
2026-11-18 14:51 [PATCH v3 0/3] module/kallsyms: sort function symbols and use binary search Stanislaw Gruszka
@ 2026-11-18 14:51 ` Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 2/3] module/kallsyms: sort text symbol indices and use binary search Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 3/3] module/kallsyms: enable indexed text lookup for livepatch modules Stanislaw Gruszka
2 siblings, 0 replies; 4+ messages in thread
From: Stanislaw Gruszka @ 2026-11-18 14:51 UTC (permalink / raw)
To: linux-modules, Sami Tolvanen, Luis Chamberlain, Petr Pavlu
Cc: linux-kernel, linux-trace-kernel, live-patching, Daniel Gomez,
Aaron Tomlin, Steven Rostedt, Masami Hiramatsu, Jordan Rome,
Viktor Malik, Petr Mladek
Both modpost and find_kallsyms_symbol() reject empty symbol names.
Handle them in the shared helper to avoid duplicating this check.
This also lets is_core_symbol() reject empty names referenced by a
nonzero st_name. The reserved ELF null symbol at index 0 is preserved
before calling the helper.
Signed-off-by: Stanislaw Gruszka <stf_xl@wp.pl>
---
include/linux/module_symbol.h | 6 ++++--
kernel/module/kallsyms.c | 7 +------
scripts/mod/modpost.h | 2 +-
3 files changed, 6 insertions(+), 9 deletions(-)
diff --git a/include/linux/module_symbol.h b/include/linux/module_symbol.h
index 698d3db2b37e..b93ef616a3f1 100644
--- a/include/linux/module_symbol.h
+++ b/include/linux/module_symbol.h
@@ -8,11 +8,13 @@ enum ksym_flags {
};
/*
- * Ignore local labels (.L*, L0*) and mapping symbols ($*). These symbols are
- * not useful for the kernel, for example, they should not appear in kallsyms.
+ * Ignore empty names, local labels (.L*, L0*) and mapping symbols ($*).
+ * These symbols are not useful for the kernel and should not appear in kallsyms.
*/
static inline bool is_ignored_kernel_symbol(const char *str)
{
+ if (!str[0])
+ return true;
if (str[0] == '.' && str[1] == 'L')
return true;
if (str[0] == 'L' && str[1] == '0')
diff --git a/kernel/module/kallsyms.c b/kernel/module/kallsyms.c
index 1ff8ce857d92..5dae0832714a 100644
--- a/kernel/module/kallsyms.c
+++ b/kernel/module/kallsyms.c
@@ -292,12 +292,7 @@ static const char *find_kallsyms_symbol(struct module *mod,
if (sym->st_shndx == SHN_UNDEF)
continue;
- /*
- * We ignore unnamed symbols: they're uninformative
- * and inserted at a whim.
- */
- if (*kallsyms_symbol_name(kallsyms, i) == '\0' ||
- is_ignored_kernel_symbol(kallsyms_symbol_name(kallsyms, i)))
+ if (is_ignored_kernel_symbol(kallsyms_symbol_name(kallsyms, i)))
continue;
if (thisval <= addr && thisval > bestval) {
diff --git a/scripts/mod/modpost.h b/scripts/mod/modpost.h
index 666beca685e4..eb01108702be 100644
--- a/scripts/mod/modpost.h
+++ b/scripts/mod/modpost.h
@@ -196,7 +196,7 @@ static inline bool is_valid_name(struct elf_info *elf, Elf_Sym *sym)
{
const char *name = elf->strtab + sym->st_name;
- if (!name || !strlen(name))
+ if (!name)
return false;
return !is_ignored_kernel_symbol(name);
}
--
2.52.0
^ permalink raw reply [flat|nested] 4+ messages in thread
* [PATCH v3 2/3] module/kallsyms: sort text symbol indices and use binary search
2026-11-18 14:51 [PATCH v3 0/3] module/kallsyms: sort function symbols and use binary search Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 1/3] module/kallsyms: include empty names in is_ignored_kernel_symbol() Stanislaw Gruszka
@ 2026-11-18 14:51 ` Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 3/3] module/kallsyms: enable indexed text lookup for livepatch modules Stanislaw Gruszka
2 siblings, 0 replies; 4+ messages in thread
From: Stanislaw Gruszka @ 2026-11-18 14:51 UTC (permalink / raw)
To: linux-modules, Sami Tolvanen, Luis Chamberlain, Petr Pavlu
Cc: linux-kernel, linux-trace-kernel, live-patching, Daniel Gomez,
Aaron Tomlin, Steven Rostedt, Masami Hiramatsu, Jordan Rome,
Viktor Malik, Petr Mladek
Module symbol lookup via find_kallsyms_symbol() performs a linear scan
over the entire symtab when resolving an address. The number of symbols
in module symtabs has grown over the years, largely due to additional
metadata in non-standard sections, making this lookup very slow.
Build a separate array of indices to core text symbols and sort it by
resolved address during module load. Binary-search this array for core
text address lookups to avoid scanning the entire symbol table.
Sorting only the index array preserves symbol-table order for existing
consumers.
The additional module load overhead is small. In repeated module load
tests [1], this change increased load time by up to 4%, depending on the
kernel configuration. No measurable increase was observed with cold
caches or with configurations enabling other features that increase
module load time.
Sorting could theoretically be done at build time, but would require
reproducing the kernel's symbol address resolution. Keeping that logic
in sync with the module loader would be error-prone. Build-time sorting
would also increase kernel build time, contrary to recent efforts to
reduce it [2].
The improvement can be observed when listing ftrace filter functions.
Before:
root@nano:~# time cat /sys/kernel/tracing/available_filter_functions | wc -l
74908
real 0m1.315s
user 0m0.000s
sys 0m1.312s
After:
root@nano:~# time cat /sys/kernel/tracing/available_filter_functions | wc -l
74911
real 0m0.167s
user 0m0.004s
sys 0m0.175s
(there are three more symbols introduced by the patch)
Link: https://gist.github.com/sgruszka/09f3fb1dad53a97b1aad96e1927ab117 [1]
Link: https://lwn.net/Articles/1105642/ [2]
Signed-off-by: Stanislaw Gruszka <stf_xl@wp.pl>
---
include/linux/module.h | 2 +
kernel/module/internal.h | 2 +
kernel/module/kallsyms.c | 194 ++++++++++++++++++++++++++++++---------
3 files changed, 154 insertions(+), 44 deletions(-)
diff --git a/include/linux/module.h b/include/linux/module.h
index f6f90cd88f15..8e9d049d1e07 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -374,8 +374,10 @@ struct module_memory {
struct mod_kallsyms {
Elf_Sym *symtab;
unsigned int num_symtab;
+ unsigned int num_text_syms;
char *strtab;
char *typetab;
+ unsigned int *text_idxtab;
};
#ifdef CONFIG_LIVEPATCH
diff --git a/kernel/module/internal.h b/kernel/module/internal.h
index 061161cc79d9..00538644772f 100644
--- a/kernel/module/internal.h
+++ b/kernel/module/internal.h
@@ -71,6 +71,8 @@ struct load_info {
bool sig_ok;
#ifdef CONFIG_KALLSYMS
unsigned long mod_kallsyms_init_off;
+ unsigned long num_text_syms;
+ unsigned long text_idxtab_off;
#endif
#ifdef CONFIG_MODULE_DECOMPRESS
#ifdef CONFIG_MODULE_STATS
diff --git a/kernel/module/kallsyms.c b/kernel/module/kallsyms.c
index 5dae0832714a..4e7a1c5a3b8b 100644
--- a/kernel/module/kallsyms.c
+++ b/kernel/module/kallsyms.c
@@ -10,6 +10,7 @@
#include <linux/kallsyms.h>
#include <linux/buildid.h>
#include <linux/bsearch.h>
+#include <linux/sort.h>
#include "internal.h"
/* Lookup exported symbol in given range of kernel_symbols */
@@ -75,26 +76,27 @@ static char elf_type(const Elf_Sym *sym, const struct load_info *info)
return '?';
}
-static bool is_core_symbol(struct module *mod, const struct load_info *info,
- unsigned int symnum, const Elf_Sym *src)
+static unsigned int is_core_symbol(struct module *mod,
+ const struct load_info *info,
+ unsigned int symnum, const Elf_Sym *src)
{
const Elf_Shdr *sec;
enum mod_mem_type type;
if (symnum == 0 || is_livepatch_module(mod))
- return true;
+ return 1;
if (src->st_shndx == SHN_UNDEF ||
src->st_shndx >= info->hdr->e_shnum ||
!src->st_name)
- return false;
+ return 0;
if (is_ignored_kernel_symbol(&info->strtab[src->st_name]))
- return false;
+ return 0;
#ifdef CONFIG_KALLSYMS_ALL
if (src->st_shndx == info->index.pcpu)
- return true;
+ return 1;
#endif
sec = info->sechdrs + src->st_shndx;
@@ -104,9 +106,96 @@ static bool is_core_symbol(struct module *mod, const struct load_info *info,
|| !(sec->sh_flags & SHF_EXECINSTR)
#endif
|| mod_mem_type_is_init(type))
- return false;
+ return 0;
+
+ return 1 << (type == MOD_TEXT);
+}
+
+static unsigned int bsearch_text_symbol(struct mod_kallsyms *kallsyms,
+ unsigned long addr,
+ unsigned long *bestval,
+ unsigned long *nextval)
+
+{
+ unsigned int mid, low = 1, high = kallsyms->num_text_syms + 1;
+ unsigned int sym_idx, best = 0;
+ unsigned long thisval;
+
+ while (low < high) {
+ mid = low + (high - low) / 2;
+ sym_idx = kallsyms->text_idxtab[mid - 1];
+ thisval = kallsyms_symbol_value(&kallsyms->symtab[sym_idx]);
+
+ if (thisval <= addr) {
+ *bestval = thisval;
+ best = sym_idx;
+ low = mid + 1;
+ } else {
+ *nextval = thisval;
+ high = mid;
+ }
+ }
+
+ return best;
+}
+
+static const char *kallsyms_symbol_name(struct mod_kallsyms *kallsyms,
+ unsigned int symnum)
+{
+ return kallsyms->strtab + kallsyms->symtab[symnum].st_name;
+}
+
+static unsigned int search_kallsyms_symbol(struct mod_kallsyms *kallsyms,
+ unsigned long addr,
+ unsigned long *bestval,
+ unsigned long *nextval)
+{
+ unsigned int i, best = 0;
+
+ /*
+ * Scan for closest preceding symbol, and next symbol. (ELF
+ * starts real symbols at 1).
+ */
+ for (i = 1; i < kallsyms->num_symtab; i++) {
+ const Elf_Sym *sym = &kallsyms->symtab[i];
+ unsigned long thisval = kallsyms_symbol_value(sym);
+
+ if (sym->st_shndx == SHN_UNDEF)
+ continue;
+
+ if (is_ignored_kernel_symbol(kallsyms_symbol_name(kallsyms, i)))
+ continue;
+
+ if (thisval <= addr && thisval > *bestval) {
+ best = i;
+ *bestval = thisval;
+ }
+ if (thisval > addr && thisval < *nextval)
+ *nextval = thisval;
+ }
- return true;
+ return best;
+}
+
+static int sym_idx_cmp(const void *a, const void *b, const void *priv)
+{
+ const Elf_Sym *syms = priv;
+
+ unsigned int idx_a = (*(unsigned int *)a);
+ unsigned int idx_b = (*(unsigned int *)b);
+
+ unsigned long val_a = kallsyms_symbol_value(&syms[idx_a]);
+ unsigned long val_b = kallsyms_symbol_value(&syms[idx_b]);
+
+ if (val_a < val_b)
+ return -1;
+ if (val_a > val_b)
+ return 1;
+ /*
+ * For equal-address symbols (aliases), make bsearch_text_symbol()
+ * select the same symbol as linear search.
+ */
+ return (idx_a < idx_b) - (idx_a > idx_b);
}
/*
@@ -121,7 +210,7 @@ void layout_symtab(struct module *mod, struct load_info *info)
Elf_Shdr *symsect = info->sechdrs + info->index.sym;
Elf_Shdr *strsect = info->sechdrs + info->index.str;
const Elf_Sym *src;
- unsigned int i, nsrc, ndst, strtab_size = 0;
+ unsigned int i, nsrc, ndst, ntxt, strtab_size = 0;
struct module_memory *mod_mem_data = &mod->mem[MOD_DATA];
struct module_memory *mod_mem_init_data = &mod->mem[MOD_INIT_DATA];
@@ -135,9 +224,14 @@ void layout_symtab(struct module *mod, struct load_info *info)
nsrc = symsect->sh_size / sizeof(*src);
/* Compute total space required for the core symbols' strtab. */
- for (ndst = i = 0; i < nsrc; i++) {
- if (!is_core_symbol(mod, info, i, src + i))
+ for (ndst = ntxt = i = 0; i < nsrc; i++) {
+ unsigned int sym_type;
+
+ sym_type = is_core_symbol(mod, info, i, src + i);
+ if (sym_type == 0)
continue;
+ if (sym_type == 2)
+ ntxt++;
strtab_size += strlen(&info->strtab[src[i].st_name]) + 1;
ndst++;
@@ -147,7 +241,11 @@ void layout_symtab(struct module *mod, struct load_info *info)
info->symoffs = ALIGN(mod_mem_data->size, symsect->sh_addralign ?: 1);
info->stroffs = mod_mem_data->size = info->symoffs + ndst * sizeof(Elf_Sym);
mod_mem_data->size += strtab_size;
- /* Note add_kallsyms() computes strtab_size as core_typeoffs - stroffs */
+ /* Note add_kallsyms() computes strtab_size as text_idxtab_off - stroffs */
+ info->text_idxtab_off =
+ ALIGN(mod_mem_data->size, __alignof__(unsigned int));
+ mod_mem_data->size =
+ info->text_idxtab_off + ntxt * sizeof(unsigned int);
info->core_typeoffs = mod_mem_data->size;
mod_mem_data->size += ndst * sizeof(char);
@@ -161,12 +259,28 @@ void layout_symtab(struct module *mod, struct load_info *info)
mod_mem_init_data->size = ALIGN(mod_mem_init_data->size,
__alignof__(struct mod_kallsyms));
info->mod_kallsyms_init_off = mod_mem_init_data->size;
+ info->num_text_syms = ntxt;
mod_mem_init_data->size += sizeof(struct mod_kallsyms);
info->init_typeoffs = mod_mem_init_data->size;
mod_mem_init_data->size += nsrc * sizeof(char);
}
+// static void pr_tab(unsigned int *tab, unsigned int n, Elf_Sym *syms)
+// {
+// int i;
+// // printk("\n");
+// for (i = 0; i < n; i++) {
+// printk(KERN_CONT "%d,", tab[i]);
+// }
+// printk("VALUES \n");
+// for (i = 0; i < n; i++) {
+// printk(KERN_CONT "0x%08llx,",
+// (unsigned long long)syms[tab[i]].st_value);
+// }
+// printk("\n");
+// }
+//
/*
* We use the full symtab and strtab which layout_symtab arranged to
* be appended to the init section. Later we switch to the cut-down
@@ -174,7 +288,7 @@ void layout_symtab(struct module *mod, struct load_info *info)
*/
void add_kallsyms(struct module *mod, const struct load_info *info)
{
- unsigned int i, ndst;
+ unsigned int i, ntxt, ndst;
const Elf_Sym *src;
Elf_Sym *dst;
char *s;
@@ -199,15 +313,20 @@ void add_kallsyms(struct module *mod, const struct load_info *info)
mod->core_kallsyms.symtab = dst = data_base + info->symoffs;
mod->core_kallsyms.strtab = s = data_base + info->stroffs;
mod->core_kallsyms.typetab = data_base + info->core_typeoffs;
- strtab_size = info->core_typeoffs - info->stroffs;
+ mod->core_kallsyms.text_idxtab = data_base + info->text_idxtab_off;
+ strtab_size = info->text_idxtab_off - info->stroffs;
src = kallsyms->symtab;
- for (ndst = i = 0; i < kallsyms->num_symtab; i++) {
+ for (ndst = ntxt = i = 0; i < kallsyms->num_symtab; i++) {
+ unsigned int sym_type;
ssize_t ret;
kallsyms->typetab[i] = elf_type(src + i, info);
- if (!is_core_symbol(mod, info, i, src + i))
+ sym_type = is_core_symbol(mod, info, i, src + i);
+ if (sym_type == 0)
continue;
+ if (sym_type == 2)
+ mod->core_kallsyms.text_idxtab[ntxt++] = ndst;
mod->core_kallsyms.typetab[ndst] = kallsyms->typetab[i];
dst[ndst] = src[i];
@@ -219,9 +338,14 @@ void add_kallsyms(struct module *mod, const struct load_info *info)
strtab_size -= ret + 1;
}
+ WARN_ON_ONCE(ntxt != info->num_text_syms);
+ sort_r(mod->core_kallsyms.text_idxtab, ntxt, sizeof(unsigned int),
+ sym_idx_cmp, NULL, dst);
+
/* Set up to point into init section. */
rcu_assign_pointer(mod->kallsyms, kallsyms);
mod->core_kallsyms.num_symtab = ndst;
+ mod->core_kallsyms.num_text_syms = ntxt;
}
#if IS_ENABLED(CONFIG_STACKTRACE_BUILD_ID)
@@ -244,11 +368,6 @@ void init_build_id(struct module *mod, const struct load_info *info)
}
#endif
-static const char *kallsyms_symbol_name(struct mod_kallsyms *kallsyms, unsigned int symnum)
-{
- return kallsyms->strtab + kallsyms->symtab[symnum].st_name;
-}
-
/*
* Given a module and address, find the corresponding symbol and return its name
* while providing its size and offset if needed.
@@ -258,7 +377,10 @@ static const char *find_kallsyms_symbol(struct module *mod,
unsigned long *size,
unsigned long *offset)
{
- unsigned int i, best = 0;
+ unsigned int (*search)(struct mod_kallsyms *kallsyms,
+ unsigned long addr, unsigned long *bestval,
+ unsigned long *nextval);
+ unsigned int best;
unsigned long nextval, bestval;
struct mod_kallsyms *kallsyms = rcu_dereference(mod->kallsyms);
struct module_memory *mod_mem = NULL;
@@ -269,6 +391,11 @@ static const char *find_kallsyms_symbol(struct module *mod,
continue;
#endif
if (within_module_mem_type(addr, mod, type)) {
+ if (type == MOD_TEXT && kallsyms->num_text_syms > 0)
+ search = bsearch_text_symbol;
+ else
+ search = search_kallsyms_symbol;
+
mod_mem = &mod->mem[type];
break;
}
@@ -281,28 +408,7 @@ static const char *find_kallsyms_symbol(struct module *mod,
nextval = (unsigned long)mod_mem->base + mod_mem->size;
bestval = (unsigned long)mod_mem->base - 1;
- /*
- * Scan for closest preceding symbol, and next symbol. (ELF
- * starts real symbols at 1).
- */
- for (i = 1; i < kallsyms->num_symtab; i++) {
- const Elf_Sym *sym = &kallsyms->symtab[i];
- unsigned long thisval = kallsyms_symbol_value(sym);
-
- if (sym->st_shndx == SHN_UNDEF)
- continue;
-
- if (is_ignored_kernel_symbol(kallsyms_symbol_name(kallsyms, i)))
- continue;
-
- if (thisval <= addr && thisval > bestval) {
- best = i;
- bestval = thisval;
- }
- if (thisval > addr && thisval < nextval)
- nextval = thisval;
- }
-
+ best = search(kallsyms, addr, &bestval, &nextval);
if (!best)
return NULL;
--
2.52.0
^ permalink raw reply [flat|nested] 4+ messages in thread
* [PATCH v3 3/3] module/kallsyms: enable indexed text lookup for livepatch modules
2026-11-18 14:51 [PATCH v3 0/3] module/kallsyms: sort function symbols and use binary search Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 1/3] module/kallsyms: include empty names in is_ignored_kernel_symbol() Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 2/3] module/kallsyms: sort text symbol indices and use binary search Stanislaw Gruszka
@ 2026-11-18 14:51 ` Stanislaw Gruszka
2 siblings, 0 replies; 4+ messages in thread
From: Stanislaw Gruszka @ 2026-11-18 14:51 UTC (permalink / raw)
To: linux-modules, Sami Tolvanen, Luis Chamberlain, Petr Pavlu
Cc: linux-kernel, linux-trace-kernel, live-patching, Daniel Gomez,
Aaron Tomlin, Steven Rostedt, Masami Hiramatsu, Jordan Rome,
Viktor Malik, Petr Mladek
is_core_symbol() returns early for livepatch modules, preventing their
core text symbols from entering the sorted index. Address lookup
therefore falls back to a linear scan.
Allow eligible core text symbols to be indexed while preserving all
livepatch symbols, so core text address lookups can use binary search.
Signed-off-by: Stanislaw Gruszka <stf_xl@wp.pl>
---
kernel/module/kallsyms.c | 9 +++++----
1 file changed, 5 insertions(+), 4 deletions(-)
diff --git a/kernel/module/kallsyms.c b/kernel/module/kallsyms.c
index 4e7a1c5a3b8b..8f8ac540ab5f 100644
--- a/kernel/module/kallsyms.c
+++ b/kernel/module/kallsyms.c
@@ -82,17 +82,18 @@ static unsigned int is_core_symbol(struct module *mod,
{
const Elf_Shdr *sec;
enum mod_mem_type type;
+ bool is_lp = is_livepatch_module(mod);
- if (symnum == 0 || is_livepatch_module(mod))
+ if (symnum == 0)
return 1;
if (src->st_shndx == SHN_UNDEF ||
src->st_shndx >= info->hdr->e_shnum ||
!src->st_name)
- return 0;
+ return is_lp;
if (is_ignored_kernel_symbol(&info->strtab[src->st_name]))
- return 0;
+ return is_lp;
#ifdef CONFIG_KALLSYMS_ALL
if (src->st_shndx == info->index.pcpu)
@@ -106,7 +107,7 @@ static unsigned int is_core_symbol(struct module *mod,
|| !(sec->sh_flags & SHF_EXECINSTR)
#endif
|| mod_mem_type_is_init(type))
- return 0;
+ return is_lp;
return 1 << (type == MOD_TEXT);
}
--
2.52.0
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2026-11-18 14:51 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-18 14:51 [PATCH v3 0/3] module/kallsyms: sort function symbols and use binary search Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 1/3] module/kallsyms: include empty names in is_ignored_kernel_symbol() Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 2/3] module/kallsyms: sort text symbol indices and use binary search Stanislaw Gruszka
2026-11-18 14:51 ` [PATCH v3 3/3] module/kallsyms: enable indexed text lookup for livepatch modules Stanislaw Gruszka
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®