kallsyms: new /proc/kallmodsyms with builtin modules
Subsystems (4)
PATCH v5 1/1 kallsyms: new /proc/kallmodsyms with builtin modules
/proc/kallsyms is very useful for tracers and other tools that need to map kernel symbols to addresses.
It would be useful if there were a mapping between kernel symbol and module name that only changed when the kernel source code is changed. This mapping should not change simply because a module becomes built into the kernel.
It might also be useful if there were reliable symbol size information to determine whether an address is within a symbol or outside it, especially given that there could be huge gaps between symbols.
Fix this by introducing a new config parameter CONFIG_KALLMODSYMS, which does several things at once (introduced in distinct commits inthis series).
Generate a file "modules_thick.builtin" that maps from the thin archives that make up built-in modules to their constituent object files. (This reintroduces the machinery that used to be used to generate modules.builtin. I am not wedded to this mechanism: if someone can figure out a mechanism that does not require recursing over the entire build tree, I'm happy to use it, but I suspect that no such mechanism exists, since the only place the mapping from object file to module exists is in the makefiles themselves. Regardless, this is fairly cheap, adding less than a second to a typical hot-cache build of a large enterprise kernel. This is true even though it needs to be run unconditionally whenever the .config changes.)
Generate a linker map ".tmp_vmlinux.map", converting it into ".tmp_vmlinux.ranges", mapping address ranges to object files.
Have scripts/kallsyms read these two new files to map symbol addresses to built-in-module names and then write a mapping from object file address to module name to the *.s output file.
The mapping consists of three new symbols:
- kallsyms_module_addresses/kallsyms_module_offsets encodes the address/offset of each object file (derived from the linker map), in exactly the same way as kallsyms_addresses/kallsyms_offsets does for symbols. There is no size: instead, the object files are assumed to tile the address space. (This is slightly more space-efficient than using a size). Non-text-section addresses are
skipped: for now, all the users of this interface only need module/non-module information for instruction pointer addresses, not absolute-addressed symbols and the like. This restriction can easily be lifted in future. (For why this isn't called kallsyms_objfiles, see two entries below.)
- kallsyms_module_names encodes the name of each module in a modified form of strtab: notably, if an object file appears in *multiple* modules, all of which are built in, this is encoded via a zero byte, a one-byte module count, then a series of that many null-terminated strings. Object files which appear in only one module in such a multi-module list are redirected to point inside that list, so that modules which contain some object files shared with other modules and some object files exclusive to them do not double up the module name. (There might still be some duplication between multiple multi-module lists, but this is an extremely marginal size effect, and resolving it would require an extra layer of lookup tables which would be even more complex, and incompressible to boot). As a special case, the table starts with a single zero byte which does *not* represent the start of a multi-module list.
- kallsyms_modules connects the two, encoding a table associated 1:1 with kallsyms_module_addresses / kallsyms_module_offsets, pointing at an offset in kallsyms_module_names describing which module (or modules, for a multi-module list) the code occupying this address range is part of. If an address range is part of no module (always built-in) it points at 0 (the null byte at the start of the kallsyms_module_names list). Entries in this list that would contain the same value are fused together, along with their corresponding kallsyms_module_addresses/offsets entries. Due to this fusion process, and because object files can be split apart into multiple parts by the linker for hot/cold partitioning and the like, entries in here do not really correspond to an object file, but more to some contiguous range of addresses which are guaranteed to belong to a single built-in module: so it seems best to call the symbols kallsyms_modules*. (The generator has a data structure that does correspond more closely to object files, from which kallsyms_modules is generated, and that does use 'objfiles' terminology.)
Emit a new /proc/kallmodsyms file akin to /proc/kallsyms but with built-in module names, using a new kallsyms_builtin_module_address() almost identical to kallsyms_sym_address() to get the address corresponding to a given .kallsyms_modules index, and a new get_builtin_module_idx quite similar to get_symbol_pos to determine the index in the .kallsyms_modules array that relates to a given address. Save a little time by exploiting the fact that all callers will only ever traverse this list from start to end by allowing them to pass in the previous index returned from this function as a hint:
thus very few bsearches are actually needed. (In theory this could change to just walk straight down kallsyms_module_addresses/offsets and not bother bsearching at all, but doing it this way is hardly any slower and much more robust.)
The display process is complicated a little by the weird format of the .kallsyms_module_names table: we have to look for multimodule entries and print them as space-separated lists of module names.
The resulting /proc/kallmodsyms file looks like this:
ffffffff8b013d20 409 t pt_buffer_setup_aux ffffffff8b014130 11f T intel_pt_interrupt ffffffff8b014250 2d T cpu_emergency_stop_pt
ffffffff8b014280 13a t rapl_pmu_event_init [intel_rapl_perf]
ffffffff8b0143c0 bb t rapl_event_update [intel_rapl_perf]
ffffffff8b014480 10 t rapl_pmu_event_read [intel_rapl_perf]
ffffffff8b014490 a3 t rapl_cpu_offline [intel_rapl_perf] ffffffff8b014540 24 t __rapl_event_show [intel_rapl_perf]
ffffffff8b014570 f2 t rapl_pmu_event_stop [intel_rapl_perf]
This is emitted even if intel_rapl_perf is built into the kernel.
Further down, we see what happens when object files are reused by multiple modules, all of which are built in to the kernel:
ffffffffa22b3aa0 ab t handle_timestamp [liquidio]ffffffffa22b3b50 4a t free_netbuf [liquidio]ffffffffa22b3ba0 8d t liquidio_ptp_settime [liquidio]ffffffffa22b3c30 b3 t liquidio_ptp_adjfreq [liquidio]
[...]
ffffffffa22b9490 203 t lio_vf_rep_create [liquidio] ffffffffa22b96a0 16b t lio_vf_rep_destroy [liquidio] ffffffffa22b9810 1f t lio_vf_rep_modinit [liquidio] ffffffffa22b9830 1f t lio_vf_rep_modexit [liquidio] ffffffffa22b9850 d2 t lio_ethtool_get_channels [liquidio] [liquidio_vf] ffffffffa22b9930 9c t lio_ethtool_get_ringparam [liquidio] [liquidio_vf] ffffffffa22b99d0 11 t lio_get_msglevel [liquidio] [liquidio_vf] ffffffffa22b99f0 11 t lio_vf_set_msglevel [liquidio] [liquidio_vf] ffffffffa22b9a10 2b t lio_get_pauseparam [liquidio] [liquidio_vf] ffffffffa22b9a40 738 t lio_get_ethtool_stats [liquidio] [liquidio_vf] ffffffffa22ba180 368 t lio_vf_get_ethtool_stats [liquidio] [liquidio_vf]
ffffffffa22ba4f0 37 t lio_get_regs_len [liquidio] [liquidio_vf]ffffffffa22ba530 18 t lio_get_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba550 2e t lio_set_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba580 69 t lio_set_fecparam [liquidio] [liquidio_vf]ffffffffa22ba5f0 92 t lio_get_fecparam [liquidio] [liquidio_vf]
[...]ffffffffa22cbd10 175 t liquidio_set_mac [liquidio_vf] ffffffffa22cbe90 ab t handle_timestamp [liquidio_vf]ffffffffa22cbf40 4a t free_netbuf [liquidio_vf]ffffffffa22cbf90 2b t octnet_link_status_change [liquidio_vf]ffffffffa22cbfc0 7e t liquidio_vxlan_port_command.constprop.0 [liquidio_vf]
Like /proc/kallsyms, the output is driven by address, so keeps the curious property of /proc/kallsyms that symbols (like free_netbuf above) may appear repeatedly with different addresses: but now, unlike in /proc/kallsyms, we can see that those symbols appear repeatedly because they are *different symbols* that ultimately belong to different modules, all of which are built in to the kernel.
Those symbols that come from object files that are genuinely reused and that appear only once in meory get a /proc/kallmodsyms line with [multiple] [modules] on it: consumers will have to be ready to handle such lines.
Also, kernel symbols for built-in modules will probably appear interspersed with other symbols that are part of different modules and non-modular always-built-in symbols, which, as usual, have no square-bracketed module denotation.
As with /proc/kallsyms, non-root usage produces addresses that are all zero.
I am open to changing the name and/or format of /proc/kallmodsyms, but felt it best to split it out of /proc/kallsyms to avoid breaking existing kallsyms parsers. Another possible syntax might be to use {curly brackets} or something to denote built-in modules: it might be possible to drop /proc/kallmodsyms and make /proc/kallsyms emit things in this format. (Equally, now kallmodsyms data uses very little space, the CONFIG_KALLMODSYMS config option might be something people don't want to bother with.)
The size impact of all of this is minimal: for the case above, the kallsyms2.S file went from 14107772 to 14137245 bytes, a gain of 29743 bytes, or 0.16%: vmlinux gained 10824 bytes, a gain of .017%, and the compressed vmlinux only 7552 bytes, a gain of .08%: though the latter two values are very configuration-dependent, they seem likely to scale roughly with the kernel they are part of.
The last patch is an RFC to see if the idea is considered to be worth spending more time optimizing the representation, which adds a new kallsyms_sizes section that gives the size of each symbol, and uses this info to report reliable symbol sizes to in-kernel users, and (via a new column in /proc/kallmodsyms) to out-of-kernel users too. Having reliable size info lets us identify inter-symbol gaps and sort symbols so that start/end-marker and overlapping symbols are consistently ordered with respect to the symbols they overlap. This certainly uses too much space right now, 200KiB--1MiB: a better representation is certainly needed. One that springs to mind is making the table sparse (pairs of symbol index/size), and recording explicit sizes only for those symbols that are not immediately followed by a subsequent symbol.
Differences from v4, two months ago:
- Fix building of tristate.conf if missing (usually concealed by the syncconfig being run for other reasons, but not always: the kernel test robot spotted it).
- Forward-port atop v5.15-rc3.
Differences from v3, a month earlier:
- Fix a kernel test robot warning in get_ksymbol_core (possible use of uninitialized variable if kallmodsyms was wanted but kallsyms_module_offsets was not present, which is most unlikely).
Differences from v2, a couple of months before that:
- Split the series up. In particular, the size impact of the table optimizer is now quantified, and the symbol-size patch is split out and turned into an RFC patch, with the /proc/kallmodsyms format before that patch lacking a size column. Some speculation on how to make the symbol sizes less space-wasteful is added (but not yet implemented).
- Drop a couple of unnecessary #includes, one unnecessarily exported symbol, and a needless de-staticing.
Differences from v1, a year or so back:
- Move from a straight symbol->module name mapping to a mapping from address-range to TU to module name list, bringing major space savings over the previous approach and support for object files used by many built-in modules at the same time, at the cost of a slightly more complex approach (unavoidably so, I think, given that we have to merge three data sources together: the link map in .tmp_vmlinux.ranges, the nm output on stdin, and the mapping from TU name to module names in modules_thick.builtin).
We do opportunistic merging of TUs if they cite the same modules and reuse module names where doing so is simple: see optimize_obj2mod below. I considered more extensive searches for mergeable entries and more intricate encodings of the module name list allowing TUs that are used by overlapping sets of modules to share their names, but such modules are rare enough (and such overlapping sharings are vanishingly rare) that it seemed likely to save only a few bytes at the cost of much more hard-to-test code. This is doubly true now that the tables needed are only a few kilobytes in length.
Nick Alcock (7):
kbuild: bring back tristate.conf
kbuild: add modules_thick.builtin
kbuild: generate an address ranges map at vmlinux link time
kallsyms: introduce sections needed to map symbols to built-in modules
kallsyms: optimize .kallsyms_modules*
kallsyms: add /proc/kallmodsyms
kallsyms: add reliable symbol size info
.gitignore | 1 + Documentation/dontdiff | 1 + Makefile | 23 +- include/linux/module.h | 7 +- init/Kconfig | 8 + kernel/kallsyms.c | 304 ++++++++++++++--- kernel/module.c | 4 +- scripts/Kbuild.include | 6 + scripts/Makefile | 6 + scripts/Makefile.modbuiltin | 56 ++++ scripts/kallsyms.c | 642 +++++++++++++++++++++++++++++++++++- scripts/kconfig/confdata.c | 41 ++- scripts/link-vmlinux.sh | 22 +- scripts/modules_thick.c | 200 +++++++++++ scripts/modules_thick.h | 48 +++ 15 files changed, 1301 insertions(+), 68 deletions(-) create mode 100644 scripts/Makefile.modbuiltin create mode 100644 scripts/modules_thick.c create mode 100644 scripts/modules_thick.h
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 1/7 kbuild: bring back tristate.conf
tristate.conf was dropped because it is not needed to build a modules.builtin (although dropping it introduces a few false positives into modules.builtin support), and doing so avoids one round of recursion through the build tree to build it. But kallmodsyms support requires building a mapping from object file name to built-in module name for all builtin modules: this seems to me impossible to accomplish without parsing all makefiles under the influence of tristate.conf, since the makefiles are the only place this mapping is recorded.
So bring it back for this purpose.
This partially reverts commit 8b41fc4454e36fbfdbb23f940d023d4dece2de29.
--- Makefile | 2 +- scripts/kconfig/confdata.c | 41 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 40 insertions(+), 3 deletions(-)
Makefile +1 -1
@@ -724,7 +724,7 @@ $(KCONFIG_CONFIG): # # Do not use $(call cmd,...) here. That would suppress prompts from syncconfig, # so you cannot notice that Kconfig is waiting for the user input. -%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h: $(KCONFIG_CONFIG) +%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h %/tristate.conf: $(KCONFIG_CONFIG) $(Q)$(kecho) " SYNC $@" $(Q)$(MAKE) -f $(srctree)/Makefile syncconfig else # !may-sync-config
scripts/kconfig/confdata.c +39 -2
81 lines not on this page · raw message
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 2/7 kbuild: add modules_thick.builtin
In reply to Nick AlcockThis is similar to modules.builtin, and constructed in a similar way to the way that used to be built before commit 8b41fc4454e36fbfdbb23f940d023d4dece2de29, via tristate.conf inclusion and recursive concatenation up the tree. Unlike modules.builtin, modules_thick.builtin givs the names of the object files that make up modules that are comprised of more than one object file, using a syntax similar to that of makefiles, e.g.:
crypto/crypto.o: crypto/api.o crypto/cipher.o crypto/compress.o crypto/memneq.o crypto/crypto_algapi.o: crypto/algapi.o crypto/proc.o crypto/scatterwalk.o crypto/aead.o:crypto/geniv.o:
(where the latter two are single-file modules).
An upcoming commit will use this mapping to populate /proc/kallmodsyms.
A parser is included that yields a stram of (module, objfile name[])
mappings: it's a bit baroque, but then parsing text files in C is quite painful, and I'd rather put the complexity in here than in its callers. The parser is not built in this commit, nor does it have any callers yet; nor is any rule added that causes modules_thick.builtin to actually be constructed. (Again, see a later commit for that.)
I am not wedded to the approach used to construct this file, but I don't see any other way to do it despite spending a week or so trying to tie it into Kbuild without using a separate Makefile.modbuiltin: unlike the names of builtin modules (which are also recorded in the source files themseves via MODULE_*() macros) the mapping from object file name to built-in module name is not recorded anywhere but in the makefiles themselves, so we have to at least reparse them with something to indicate the builtin-ness of each module (i.e., tristate.conf) if we are to figure out which modules are built-in and which are not.
--- .gitignore | 1 + Documentation/dontdiff | 1 + Makefile | 19 +++- scripts/Kbuild.include | 6 ++ scripts/Makefile.modbuiltin | 56 ++++++++++ scripts/modules_thick.c | 200 ++++++++++++++++++++++++++++++++++++ scripts/modules_thick.h | 48 +++++++++ 7 files changed, 330 insertions(+), 1 deletion(-) create mode 100644 scripts/Makefile.modbuiltin create mode 100644 scripts/modules_thick.c create mode 100644 scripts/modules_thick.h
.gitignore +1 -0
@@ -49,6 +49,7 @@ *.zst Module.symvers modules.order +modules_thick.builtin # # Top-level generic files
Documentation/dontdiff +1 -0
@@ -183,6 +183,7 @@ modules.builtin modules.builtin.modinfo modules.nsdeps modules.order +modules_thick.builtin modversions.h* nconf nconf-cfg
Makefile +18 -1
@@ -1507,6 +1507,23 @@ __modinst_pre: endif # CONFIG_MODULES +# modules_thick.builtin maps from kernel modules (or rather the object file +# names they would have had had they not been built in) to their constituent +# object files: we can use this to determine which modules any given object +# file is part of. (We cannot eliminate the slight redundancy here without +# double-expansion.) + +modthickbuiltin-files := $(addsuffix /modules_thick.builtin, $(build-dirs)) + +modules_thick.builtin: $(modthickbuiltin-files) + $(Q)$(AWK) '!x[$$0]++' $(addsuffix /$@, $(build-dirs)) > $@ + +# tristate.conf is not included from this Makefile. Add it as a prerequisite +# here to make it self-healing in case somebody accidentally removes it. +$(modthickbuiltin-files): include/config/tristate.conf + $(Q)$(MAKE) $(modbuiltin)=$(patsubst %/modules_thick.builtin,%,$@) builtin-file=modules_thick.builtin + + ### # Cleaning is done on three levels. # make clean Delete most generated files
@@ -1886,7 +1903,7 @@ clean: $(clean-dirs) -o -name '*.lex.c' -o -name '*.tab.[ch]' \ -o -name '*.asn1.[ch]' \ -o -name '*.symtypes' -o -name 'modules.order' \ - -o -name '.tmp_*.o.*' \ + -o -name '.tmp_*.o.*' -o -name modules_thick.builtin \ -o -name '*.c.[012]*.*' \ -o -name '*.ll' \ -o -name '*.gcno' \
scripts/Kbuild.include +6 -0
@@ -74,6 +74,12 @@ endef # $(Q)$(MAKE) $(build)=dir build := -f $(srctree)/scripts/Makefile.build obj +### +# Shorthand for $(Q)$(MAKE) -f scripts/Makefile.modbuiltin obj= +# Usage: +# $(Q)$(MAKE) $(modbuiltin)=dir +modbuiltin := -f $(srctree)/scripts/Makefile.modbuiltin obj + ### # Shorthand for $(Q)$(MAKE) -f scripts/Makefile.dtbinst obj= # Usage:
scripts/Makefile.modbuiltin new file +56 -0
56 lines not on this page · raw message
scripts/modules_thick.c new file +200 -0
200 lines not on this page · raw message
scripts/modules_thick.h new file +48 -0
48 lines not on this page · raw message
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 3/7 kbuild: generate an address ranges map at vmlinux link time
In reply to Nick AlcockThis emits a new file, .tmp_vmlinux.ranges, which maps address range/size pairs in vmlinux to the object files which make them up, e.g., in part:
0x0000000000000000 0x30 arch/x86/kernel/cpu/common.o 0x0000000000001000 0x1000 arch/x86/events/intel/ds.o 0x0000000000002000 0x4000 arch/x86/kernel/irq_64.o 0x0000000000006000 0x5000 arch/x86/kernel/process.o 0x000000000000b000 0x1000 arch/x86/kernel/cpu/common.o 0x000000000000c000 0x5000 arch/x86/mm/cpu_entry_area.o 0x0000000000011000 0x10 arch/x86/kernel/espfix_64.o 0x0000000000011010 0x2 arch/x86/kernel/cpu/common.o [...]
In my simple tests this seems to work with clang too, but if I'm not sure how stable the format of clang's linker mapfiles is: if it turns out not to work in some versions, the mapfile-massaging awk script added here might need some adjustment.
--- scripts/link-vmlinux.sh | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
scripts/link-vmlinux.sh +14 -1
@@ -196,7 +196,7 @@ vmlinux_link() ${ld} ${ldflags} -o ${output} \ ${wl}--whole-archive ${objs} ${wl}--no-whole-archive \ ${wl}--start-group ${libs} ${wl}--end-group \ - $@ ${ldlibs} + -Map=.tmp_vmlinux.map $@ ${ldlibs} } # generate .BTF typeinfo from DWARF debuginfo
@@ -248,6 +248,19 @@ kallsyms() { local kallsymopt; + # read the linker map to identify ranges of addresses: + # - for each *.o file, report address, size, pathname + # - most such lines will have four fields + # - but sometimes there is a line break after the first field + # - start reading at "Linker script and memory map" + # - stop reading at ".brk" + ${AWK} ' + /\.o$/ && start==1 { print $(NF-2), $(NF-1), $NF } + /^Linker script and memory map/ { start = 1 } + /^\.brk/ { exit(0) } + ' .tmp_vmlinux.map | sort > .tmp_vmlinux.ranges + + # get kallsyms options if [ -n "${CONFIG_KALLSYMS_ALL}" ]; then kallsymopt="${kallsymopt} --all-symbols" fi
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 4/7 kallsyms: introduce sections needed to map symbols to built-in modules
In reply to Nick AlcockThe mapping consists of three new symbols, computed by integrating the information in the (just-added) .tmp_vmlinux.ranges and modules_thick.builtin: taken together, they map address ranges (corresponding to object files on the input) to the names of zero or more modules containing those address ranges.
- kallsyms_module_addresses/kallsyms_module_offsets encodes the address/offset of each object file (derived from the linker map), in exactly the same way as kallsyms_addresses/kallsyms_offsets does for symbols. There is no size: instead, the object files are assumed to tile the address space. (This is slightly more space-efficient than using a size). Non-text-section addresses are skipped: for now, all the users of this interface only need module/non-module information for instruction pointer addresses, not absolute-addressed symbols and the like. This restriction can easily be lifted in future. (Regarding the name: right now the entries correspond pretty closely to object files, so we could call the section kallsyms_objfiles or something, but the optimizer added in the next commit will change this.)
- kallsyms_module_names encodes the name of each module in a modified form of strtab: notably, if an object file appears in *multiple* modules, all of which are built in, this is encoded via a zero byte, a one-byte module count, then a series of that many null-terminated strings. As a special case, the table starts with a single zero byte which does *not* represent the start of a multi-module list.
- kallsyms_modules connects the two, encoding a table associated 1:1 with kallsyms_module_addresses / kallsyms_module_offsets, pointing at an offset in kallsyms_module_names describing which module (or modules, for a multi-module list) the code occupying this address range is part of. If an address range is part of no module (always built-in) it points at 0 (the null byte at the start of the kallsyms_module_names list).
There is no optimization yet: kallsyms_modules and kallsyms_module_names will almost certainly contain many duplicate entries, and kallsyms_module_{addresses,offsets} may contain consecutive entries that point to the same place. The size hit is fairly substantial as a result, though still much less than a naive implementation mapping each symbol to a module name would be: 50KiB or so.
--- Makefile | 2 +- init/Kconfig | 8 + scripts/Makefile | 6 + scripts/kallsyms.c | 366 +++++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 371 insertions(+), 11 deletions(-)
Makefile +1 -1
@@ -1179,7 +1179,7 @@ cmd_link-vmlinux = \ $(CONFIG_SHELL) $< "$(LD)" "$(KBUILD_LDFLAGS)" "$(LDFLAGS_vmlinux)"; \ $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true) -vmlinux: scripts/link-vmlinux.sh autoksyms_recursive $(vmlinux-deps) FORCE +vmlinux: scripts/link-vmlinux.sh autoksyms_recursive $(vmlinux-deps) modules_thick.builtin FORCE +$(call if_changed_dep,link-vmlinux) targets := vmlinux
init/Kconfig +8 -0
@@ -1526,6 +1526,14 @@ config POSIX_TIMERS If unsure say y. +config KALLMODSYMS + default y + bool "Enable support for /proc/kallmodsyms" if EXPERT + depends on KALLSYMS + help + This option enables the /proc/kallmodsyms file, which maps symbols + to addresses and their associated modules. + config PRINTK default y bool "Enable support for printk" if EXPERT
scripts/Makefile +6 -0
@@ -32,6 +32,12 @@ HOSTCFLAGS_sorttable.o += -DUNWINDER_ORC_ENABLED HOSTLDLIBS_sorttable = -lpthread endif +kallsyms-objs := kallsyms.o + +ifdef CONFIG_KALLMODSYMS +kallsyms-objs += modules_thick.o +endif + # The following programs are only built on demand hostprogs += unifdef
scripts/kallsyms.c +356 -10
455 lines not on this page · raw message
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 5/7 kallsyms: optimize .kallsyms_modules*
In reply to Nick AlcockThese symbols are terribly inefficiently stored at the moment. Add a simple optimizer which fuses obj2mod_elem entries and uses this to implement three cheap optimizations:
- duplicate names are eliminated from .kallsyms_module_names.
- entries in .kallsyms_modules which point at single-file modules which also appear in a multi-module list are redirected to point inside that list, and the single-file entry is dropped from .kallsyms_module_names. Thus, modules which contain some object files shared with other modules and some object files exclusive to them do not double up the module name. (There might still be some duplication between multiple multi-module lists, but this is an extremely marginal size effect, and resolving it would require an extra layer of lookup tables which would be even more complex, and incompressible to boot).
- Entries in .kallsyms_modules that would contain the same value after the above optimizations are fused together, along with their corresponding .kallsyms_module_addresses/offsets entries. Due to this fusion process, and because object files can be split apart into multiple parts by the linker for hot/cold partitioning and the like, entries in .kallsyms_module_addresses/offsets no longer correspond 1:1 to object files, but more to some contiguous range of addresses which are guaranteed to belong to a single built-in module, but which may well stretch over multiple object files.
The optimizer's time complexity is O(log n) in the number of objfiles at most (and probably much lower), so, given the relatively low number of objfiles, its runtime overhead is in the noise.
Optimization reduces the overhead of the kallmodsyms tables by about 7500 items, dropping the .tmp_kallsyms2.o object file size by about 33KiB, leaving it 8672 bytes larger than before: a gain of .4%.
The vmlinux size is not yet affected because the variables are not used and are eliminated by the linker: but if they were used (after the next commit), the size impact of all of this on the final kernel is minimal:
in my testing, the kallsyms2.S file went from 14107772 to 14137245 bytes, a gain of 29743 bytes, or 0.16%: vmlinux gained 10824 bytes, a gain of .017%, and the compressed vmlinux only 7552 bytes, a gain of .08%: though the latter two values are very configuration-dependent, they seem likely to scale roughly with the kernel they are part of.
--- scripts/kallsyms.c | 267 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 258 insertions(+), 9 deletions(-)
scripts/kallsyms.c +258 -9
@@ -85,6 +85,17 @@ static unsigned int strhash(const char *s)return hash; } +static unsigned int memhash (char *s,size_t len) +{ +/* fnv32 hash */ +unsigned int hash =2166136261U ; +size_t i; + +for (i =0 ; i < len; i++) + hash = (hash ^ *(s + i)) *0x01000193 ; +return hash; +} +#define OBJ2MOD_BITS 10#define OBJ2MOD_N (1 << OBJ2MOD_BITS)#define OBJ2MOD_MASK (OBJ2MOD_N - 1)
@@ -94,14 +105,24 @@ struct obj2mod_elem {size_t nmods;/* number of modules in "mods" */ size_t mods_size;/* size of all mods together */ int mod_offset;/* offset in .kallsyms_module_names */ +/* +* If set at emission time, this points at another obj2mod entry that +* contains the module name we need (possibly at a slightly later +* offset, if the entry is for an objfile that appears in many modules). +*/ +struct obj2mod_elem *xref;struct obj2mod_elem *obj2mod_next; +struct obj2mod_elem *mod2obj_next; };/* -* Map from object files to obj2mod entries (a unique mapping). +* Map from object files to obj2mod entries (a unique mapping), and vice versa +* (not unique, but entries for objfiles in more than one module in this hash +* are ignored). */ static struct obj2mod_elem *obj2mod[OBJ2MOD_N ]; +static struct obj2mod_elem *mod2obj[OBJ2MOD_N ];static size_t num_objfiles;/*
@@ -143,6 +164,8 @@ static void obj2mod_add(char *obj, char *mod) elem =obj2mod_get (obj);if (!elem) { +int j =strhash (mod) &OBJ2MOD_MASK ; + elem =malloc (sizeof (struct obj2mod_elem ));if (!elem) goto oom;
@@ -156,8 +179,15 @@ static void obj2mod_add(char *obj, char *mod) elem->obj2mod_next = obj2mod[i]; obj2mod[i] = elem; + elem->mod2obj_next = mod2obj[j]; + mod2obj[j] = elem; num_objfiles++; }else { +/* +* TU appears in multiple modules. mod2obj for this entry will +* be ignored from now on, except insofar as it is needed to +* maintain the hash chain. +*/ elem->mods =realloc (elem->mods, elem->mods_size +strlen (mod) +1 );if (!elem->mods)
@@ -177,6 +207,164 @@ static void obj2mod_add(char *obj, char *mod)fprintf (stderr,"kallsyms: out of memory\n" ); exit(1); } + +/* +* Used inside optimize_obj2mod to identify duplicate module entries. +*/ +struct obj2mod_modhash_elem { +struct obj2mod_elem *elem; +unsigned int modhash;/* hash value of this entry */ +}; + +static int qstrcmp (const void *a,const void *b) +{ +return strcmp ((const char *) a, (const char *) b); +} + +static int qmodhash (const void *a,const void *b) +{ +const struct obj2mod_modhash_elem *el_a = a; +const struct obj2mod_modhash_elem *el_b = b; +if (el_a->modhash < el_b->modhash) +return -1 ; +else if (el_a->modhash > el_b->modhash) +return 1 ; +return 0 ; +} + +/* +* Associate all TUs in obj2mod which refer to the same module with a single +* obj2mod entry for emission, preferring to point into the module list in a +* multi-module objfile. +*/ +static void optimize_obj2mod (void ) +{ +size_t i; +size_t n =0 ; +struct obj2mod_elem *elem; +struct obj2mod_elem *dedup; +/* An array of all obj2mod_elems, later sorted by hashval. */ +struct obj2mod_modhash_elem *uniq; +struct obj2mod_modhash_elem *last; + +/* +* Canonicalize all module lists by sorting them, then compute their +* hash values. +*/ + uniq =malloc (sizeof (struct obj2mod_modhash_elem ) * num_objfiles); +if (uniq ==NULL ) + goto oom; + +for (i =0 ; i <OBJ2MOD_N ; i++) { +for (elem = obj2mod[i]; elem; elem = elem->obj2mod_next) { +if (elem->nmods >=2 ) { +char **sorter; +char *walk; +char *tmp_mods; +size_t j; + + tmp_mods =malloc (elem->mods_size); + sorter =malloc (sizeof (char *) * elem->nmods); +if (sorter ==NULL || tmp_mods ==NULL ) + goto oom; +memcpy (tmp_mods, elem->mods, elem->mods_size); + +for (j =0 , walk = tmp_mods; j < elem->nmods; + j++) { + sorter[j] = walk; + walk +=strlen (walk) +1 ; + } +qsort (sorter, elem->nmods,sizeof (char *), + qstrcmp); +for (j =0 , walk = elem->mods; j < elem->nmods; + j++) { +strcpy (walk, sorter[j]); + walk +=strlen (walk) +1 ; + } +free (tmp_mods); +free (sorter); + } + + uniq[n].elem = elem; + uniq[n].modhash =memhash (elem->mods, elem->mods_size); + n++; + } + } + +qsort (uniq, num_objfiles,sizeof (struct obj2mod_modhash_elem ), + qmodhash); + +/* +* Work over multimodule entries. These must be emitted into +* .kallsyms_module_names as a unit, but we can still optimize by +* reusing some other identical entry. Single-file modules are amenable +* to the same optimization, but we avoid doing it for now so that we +* can prefer to point them directly inside a multimodule entry. +*/ +for (i =0 , last =NULL ; i < num_objfiles; i++) { +const char *onemod; +size_t j; + +if (uniq[i].elem->nmods <2 ) +continue ; + +/* Duplicate multimodule. Reuse the first we saw. */ +if (last !=NULL && last->modhash == uniq[i].modhash) { + uniq[i].elem->xref = last->elem; +continue ; + } + +/* +* Single-module entries relating to modules also emitted as +* part of this multimodule entry can refer to it: later, we +* will hunt down the right specific module name within this +* multimodule entry and point directly to it. +*/ + onemod = uniq[i].elem->mods; +for (j = uniq[i].elem->nmods; j >0 ; j--) { +int h =strhash (onemod) &OBJ2MOD_MASK ; + +for (dedup = mod2obj[h]; dedup; + dedup = dedup->mod2obj_next) { +if (dedup->nmods >1 ) +continue ; + +if (strcmp (dedup->mods, onemod) !=0 ) +continue ; + dedup->xref = uniq[i].elem; +assert (uniq[i].elem->xref ==NULL ); + } + onemod +=strlen (onemod) +1 ; + } + + last = &uniq[i]; + } + +/* +* Now traverse all single-module entries, xreffing every one that +* relates to a given module to the first one we saw that refers to that +* module. +*/ +for (i =0 , last =NULL ; i < num_objfiles; i++) { +if (uniq[i].elem->nmods >1 ) +continue ; + +if (uniq[i].elem->xref !=NULL ) +continue ; + +/* Duplicate module name. Reuse the first we saw. */ +if (last !=NULL && last->modhash == uniq[i].modhash) { + uniq[i].elem->xref = last->elem; +assert (last->elem->xref ==NULL ); +continue ; + } + last = &uniq[i]; + } +return ; +oom: +fprintf (stderr,"kallsyms: out of memory optimizing module list\n" ); +exit (EXIT_FAILURE ); +}#endif /* CONFIG_KALLMODSYMS */ static void usage (void )
@@ -479,7 +667,7 @@ static void output_kallmodsyms_modules(void)size_t i;/* -* Traverse and emit, updating mod_offset accordingly. +* Traverse and emit, chasing xref and updating mod_offset accordingly. * Emit a single \0 at the start, to encode non-modular objfiles. */ output_label ("kallsyms_module_names" );
@@ -489,9 +677,15 @@ static void output_kallmodsyms_modules(void) elem = elem->obj2mod_next) {const char *onemod;size_t i; +struct obj2mod_elem *out_elem = elem; - elem->mod_offset = offset; - onemod = elem->mods; +if (elem->xref) + out_elem = elem->xref; +if (out_elem->mod_offset !=0 ) +continue ;/* Already emitted. */ + + out_elem->mod_offset = offset; + onemod = out_elem->mods;/* * Technically this is a waste of space: we could just
@@ -500,13 +694,13 @@ static void output_kallmodsyms_modules(void)* entry, but doing it this way makes it more obvious * when an entry is a multimodule entry. */ -if (elem->nmods !=1 ) { +if (out_elem->nmods !=1 ) {printf ("\t.byte\t0\n" ); -printf ("\t.byte\t%zi\n" , elem->nmods); +printf ("\t.byte\t%zi\n" , out_elem->nmods); offset +=2 ; } -for (i = elem->nmods; i >0 ; i--) { +for (i = out_elem->nmods; i >0 ; i--) {printf ("\t.asciz\t\"%s\"\n" , onemod); offset +=strlen (onemod) +1 ; onemod +=strlen (onemod) +1 ;
@@ -533,6 +727,13 @@ static void output_kallmodsyms_objfiles(void)long long offset;int overflow; +/* +* Fuse consecutive address ranges citing the same object file +* into one. +*/ +if (i >0 && addrmap[i-1 ].objfile == addrmap[i].objfile) +continue ; +if (base_relative) {if (!absolute_percpu) { offset = addrmap[i].addr - relative_base;
@@ -558,6 +759,13 @@ static void output_kallmodsyms_objfiles(void)for (i =0 ; i < addrmap_num; i++) {struct obj2mod_elem *elem = addrmap[i].objfile; +int orig_nmods; +const char *orig_modname; +int mod_offset; + +if (i >0 && addrmap[i-1 ].objfile == addrmap[i].objfile) +continue ; +/* * Address range cites no object file: point at 0, the built-in * module.
@@ -568,13 +776,53 @@ static void output_kallmodsyms_objfiles(void)continue ; } + orig_nmods = elem->nmods; + orig_modname = elem->mods; + +/* +* Chase down xrefs, if need be. There can only be one layer of +* these: from single-module entry to other single-module entry, +* or from single- or multi-module entry to another multi-module +* entry. Single -> single and multi -> multi always points at +* the start of the xref target, so its offset can be used as is. +*/ +if (elem->xref) + elem = elem->xref; + +if (elem->nmods ==1 || orig_nmods >1 ) + mod_offset = elem->mod_offset; +else { +/* +* If this is a reference from a single-module entry to +* a multi-module entry, hunt down the offset to this +* specific module's name (which is guaranteed to be +* present: see optimize_obj2mod). +*/ + +size_t j = elem->nmods; +const char *onemod = elem->mods; + mod_offset = elem->mod_offset; + +for (; j >0 ; j--) { +if (strcmp (orig_modname, onemod) ==0 ) +break ; + onemod +=strlen (onemod) +1 ; + } +assert (j >0 ); +/* +* +2 to skip the null byte and count at the start of +* the multimodule entry. +*/ + mod_offset += onemod - elem->mods +2 ; + } +/* * Zero offset is the initial \0, there to catch uninitialized * obj2mod entries, and is forbidden. */ -assert (elem->mod_offset !=0 ); +assert (mod_offset !=0 ); -printf ("\t.long\t0x%x\n" , elem->mod_offset); +printf ("\t.long\t0x%x\n" , mod_offset); emitted_objfiles++; }
@@ -1093,6 +1341,7 @@ static void read_modules(const char *modules_builtin)free (module_name);modules_thick_iter_free (i); +optimize_obj2mod ();/* * Read linker map.
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 6/7 kallsyms: add /proc/kallmodsyms
In reply to Nick AlcockUse the tables added in the previous commits to introduce a new /proc/kallmodsyms, in which [module names] are also given for things that *could* have been modular had they not been built in to the kernel. So symbols that are part of, say, ext4 are reported as [ext4] even if ext4 happens to be buiilt in to the kernel in this configuration.
Symbols that are part of multiple modules at the same time are shown with [multiple] [module names]: consumers will have to be ready to handle such lines. Also, kernel symbols for built-in modules will be sorted by size, as usual for the core kernel, so will probably appear interspersed with other symbols that are part of different modules and non-modular always-built-in symbols, which, as usual, have no square-bracketed module denotation. This differs from /proc/kallsyms, where all symbols associated with a module will always appear in a group (and randomly ordered).
The result looks like this:
ffffffff8b013d20 t pt_buffer_setup_aux ffffffff8b014130 T intel_pt_interrupt ffffffff8b014250 T cpu_emergency_stop_ptffffffff8b014280 t rapl_pmu_event_init [intel_rapl_perf]ffffffff8b0143c0 t rapl_event_update [intel_rapl_perf]ffffffff8b014480 t rapl_pmu_event_read [intel_rapl_perf]ffffffff8b014490 t rapl_cpu_offline [intel_rapl_perf] ffffffff8b014540 t __rapl_event_show [intel_rapl_perf]ffffffff8b014570 t rapl_pmu_event_stop [intel_rapl_perf]
This is emitted even if intel_rapl_perf is built into the kernel (but, obviously, not if it's not in the .config at all, or is in a module that is not loaded).
Further down, we see what happens when object files are reused by multiple modules, all of which are built in to the kernel:
ffffffffa22b3aa0 t handle_timestamp [liquidio]ffffffffa22b3b50 t free_netbuf [liquidio]ffffffffa22b3ba0 t liquidio_ptp_settime [liquidio]ffffffffa22b3c30 t liquidio_ptp_adjfreq [liquidio]
[...]ffffffffa22b9490 t lio_vf_rep_create [liquidio]ffffffffa22b96a0 t lio_vf_rep_destroy [liquidio]ffffffffa22b9810 t lio_vf_rep_modinit [liquidio]ffffffffa22b9830 t lio_vf_rep_modexit [liquidio]ffffffffa22b9850 t lio_ethtool_get_channels [liquidio] [liquidio_vf]ffffffffa22b9930 t lio_ethtool_get_ringparam [liquidio] [liquidio_vf]ffffffffa22b99d0 t lio_get_msglevel [liquidio] [liquidio_vf]ffffffffa22b99f0 t lio_vf_set_msglevel [liquidio] [liquidio_vf]ffffffffa22b9a10 t lio_get_pauseparam [liquidio] [liquidio_vf]ffffffffa22b9a40 t lio_get_ethtool_stats [liquidio] [liquidio_vf]ffffffffa22ba180 t lio_vf_get_ethtool_stats [liquidio] [liquidio_vf]ffffffffa22ba4f0 t lio_get_regs_len [liquidio] [liquidio_vf]ffffffffa22ba530 t lio_get_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba550 t lio_set_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba580 t lio_set_fecparam [liquidio] [liquidio_vf]ffffffffa22ba5f0 t lio_get_fecparam [liquidio] [liquidio_vf]
[...]ffffffffa22cbd10 t liquidio_set_mac [liquidio_vf] ffffffffa22cbe90 t handle_timestamp [liquidio_vf]ffffffffa22cbf40 t free_netbuf [liquidio_vf]ffffffffa22cbf90 t octnet_link_status_change [liquidio_vf]ffffffffa22cbfc0 t liquidio_vxlan_port_command.constprop.0 [liquidio_vf]
Like /proc/kallsyms, the output is driven by address, so keeps the curious property of /proc/kallsyms that symbols (like free_netbuf above) may appear repeatedly with different addresses: but now, unlike in /proc/kallsyms, we can see that those symbols appear repeatedly because they are *different symbols* that ultimately belong to different modules, all of which are built in to the kernel.
As with /proc/kallsyms, non-root usage produces addresses that are all zero.
I am not wedded to the name or format of /proc/kallmodsyms, but felt it best to split it out of /proc/kallsyms to avoid breaking existing kallsyms parsers. Another possible syntax might be to use {curly brackets} or something to denote built-in modules: it might be possible to drop /proc/kallmodsyms and make /proc/kallsyms emit things in this format. (Equally, now kallmodsyms data uses very little space, the CONFIG_KALLMODSYMS config option might be something people don't want to bother with.)
Internally, this uses a new kallsyms_builtin_module_address() almost identical to kallsyms_sym_address() to get the address corresponding to a given .kallsyms_modules index, and a new get_builtin_module_idx quite similar to get_symbol_pos to determine the index in the .kallsyms_modules array that relates to a given address. Save a little time by exploiting the fact that all callers will only ever traverse this list from start to end by allowing them to pass in the previous index returned from this function as a hint: thus very few bsearches are actually needed. (In theory this could change to just walk straight down kallsyms_module_addresses/offsets and not bother bsearching at all, but doing it this way is hardly any slower and much more robust.)
The display process is complicated a little by the weird format of the .kallsyms_module_names table: we have to look for multimodule entries and print them as space-separated lists of module names.
--- kernel/kallsyms.c | 242 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 227 insertions(+), 15 deletions(-)
kernel/kallsyms.c +227 -15
@@ -48,8 +48,18 @@ __section(".rodata") __attribute__((weak));extern const unsigned long kallsyms_relative_base __section(".rodata") __attribute__((weak)); +extern const unsigned long kallsyms_num_modules +__section(".rodata") __attribute__((weak)); + +extern const unsigned long kallsyms_module_names_len +__section(".rodata") __attribute__((weak)); +extern const char kallsyms_token_table[]__weak ;extern const u16 kallsyms_token_index[]__weak ; +extern const unsigned long kallsyms_module_addresses[]__weak ; +extern const int kallsyms_module_offsets[]__weak ; +extern const u32 kallsyms_modules[]__weak ; +extern const char kallsyms_module_names[]__weak ;extern const unsigned int kallsyms_markers[]__weak ;
@@ -185,6 +195,25 @@ static inline bool cleanup_symbol_name(char *s)static inline bool cleanup_symbol_name (char *s) {return false; }#endif +#ifdef CONFIG_KALLMODSYMS +static unsigned long kallsyms_builtin_module_address (int idx) +{ +if (!IS_ENABLED (CONFIG_KALLSYMS_BASE_RELATIVE )) +return kallsyms_module_addresses[idx]; + +/* values are unsigned offsets if --absolute-percpu is not in effect */ +if (!IS_ENABLED (CONFIG_KALLSYMS_ABSOLUTE_PERCPU )) +return kallsyms_relative_base + (u32 )kallsyms_module_offsets[idx]; + +/* ...otherwise, positive offsets are absolute values */ +if (kallsyms_module_offsets[idx] >=0 ) +return kallsyms_module_offsets[idx]; + +/* ...and negative offsets are relative to kallsyms_relative_base - 1 */ +return kallsyms_relative_base -1 - kallsyms_module_offsets[idx]; +} +#endif +/* Lookup the address for this symbol. Returns 0 if not found. */ unsigned long kallsyms_lookup_name (const char *name) {
@@ -288,6 +317,54 @@ static unsigned long get_symbol_pos(unsigned long addr,return low; } +/* +* The caller passes in an address, and we return an index to the corresponding +* builtin module index in .kallsyms_modules, or (unsigned long) -1 if none +* match. +* +* The hint_idx, if set, is a hint as to the possible return value, to handle +* the common case in which consecutive runs of addresses relate to the same +* index. +*/ +#ifdef CONFIG_KALLMODSYMS +static unsigned long get_builtin_module_idx (unsigned long addr,unsigned long hint_idx) +{ +unsigned long low, high, mid; + +if (!IS_ENABLED (CONFIG_KALLSYMS_BASE_RELATIVE )) +BUG_ON (!kallsyms_module_addresses); +else +BUG_ON (!kallsyms_module_offsets); + +/* +* Do a binary search on the sorted kallsyms_modules array. The last +* entry in this array indicates the end of the text section, not an +* object file. +*/ + low =0 ; + high = kallsyms_num_modules -1 ; + +if (hint_idx > low && hint_idx < (high -1 ) && + addr >=kallsyms_builtin_module_address (hint_idx) && + addr <kallsyms_builtin_module_address (hint_idx +1 )) +return hint_idx; + +if (addr >=kallsyms_builtin_module_address (low) + && addr <kallsyms_builtin_module_address (high)) { +while (high - low >1 ) { + mid = low + (high - low) /2 ; +if (kallsyms_builtin_module_address (mid) <= addr) + low = mid; +else + high = mid; + } +return low; + } + +return (unsigned long )-1 ; +} +#endif +/* * Lookup an address but don't bother to find any names. */
@@ -559,6 +636,8 @@ struct kallsym_iter {char type;char name[KSYM_NAME_LEN ];char module_name[MODULE_NAME_LEN ]; +const char *builtin_module_names; +unsigned long hint_builtin_module_idx;int exported;int show_value; };
@@ -589,6 +668,8 @@ static int get_ksymbol_mod(struct kallsym_iter *iter) &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported); + iter->builtin_module_names =NULL ; +if (ret <0 ) { iter->pos_mod_end = iter->pos;return 0 ;
@@ -608,6 +689,8 @@ static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter) &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported); + iter->builtin_module_names =NULL ; +if (ret <0 ) { iter->pos_ftrace_mod_end = iter->pos;return 0 ;
@@ -622,6 +705,7 @@ static int get_ksymbol_bpf(struct kallsym_iter *iter)strlcpy (iter->module_name,"bpf" ,MODULE_NAME_LEN ); iter->exported =0 ; + iter->builtin_module_names =NULL ; ret =bpf_get_kallsym (iter->pos - iter->pos_ftrace_mod_end, &iter->value, &iter->type, iter->name);
@@ -642,23 +726,53 @@ static int get_ksymbol_kprobe(struct kallsym_iter *iter) {strlcpy (iter->module_name,"__builtin__kprobes" ,MODULE_NAME_LEN ); iter->exported =0 ; + iter->builtin_module_names =NULL ;return kprobe_get_kallsym (iter->pos - iter->pos_bpf_end, &iter->value, &iter->type, iter->name) <0 ?0 :1 ; }/* Returns space to next name. */ -static unsigned long get_ksymbol_core (struct kallsym_iter *iter) +static unsigned long get_ksymbol_core (struct kallsym_iter *iter,int kallmodsyms) {unsigned off = iter->nameoff; - iter->module_name[0 ] ='\0' ; + iter->exported =0 ; iter->value =kallsyms_sym_address (iter->pos); iter->type =kallsyms_get_symbol_type (off); + iter->module_name[0 ] ='\0' ; + iter->builtin_module_names =NULL ; + off =kallsyms_expand_symbol (off, iter->name,ARRAY_SIZE (iter->name)); +#ifdef CONFIG_KALLMODSYMS +if (kallmodsyms) { +unsigned long mod_idx = (unsigned long )-1 ; + +if (kallsyms_module_offsets) + mod_idx = +get_builtin_module_idx (iter->value, + iter->hint_builtin_module_idx); +/* +* This is a built-in module iff the tables of built-in modules +* (address->module name mappings) and module names are known, +* and if the address was found there, and if the corresponding +* module index is nonzero. All other cases mean off the end of +* the binary or in a non-modular range in between one or more +* modules. (Also guard against a corrupt kallsyms_objfiles +* array pointing off the end of kallsyms_modules.) +*/ +if (kallsyms_modules !=NULL && kallsyms_module_names !=NULL && + mod_idx != (unsigned long )-1 && + kallsyms_modules[mod_idx] !=0 && + kallsyms_modules[mod_idx] < kallsyms_module_names_len) + iter->builtin_module_names = + &kallsyms_module_names[kallsyms_modules[mod_idx]]; + iter->hint_builtin_module_idx = mod_idx; + } +#endif return off - iter->nameoff; }
@@ -704,7 +818,7 @@ static int update_iter_mod(struct kallsym_iter *iter, loff_t pos) }/* Returns false if pos at or past end of file. */ -static int update_iter (struct kallsym_iter *iter,loff_t pos) +static int update_iter (struct kallsym_iter *iter,loff_t pos,int kallmodsyms) {/* Module symbols can be accessed randomly. */ if (pos >= kallsyms_num_syms)
@@ -714,7 +828,7 @@ static int update_iter(struct kallsym_iter *iter, loff_t pos)if (pos != iter->pos)reset_iter (iter, pos); - iter->nameoff +=get_ksymbol_core (iter); + iter->nameoff +=get_ksymbol_core (iter, kallmodsyms); iter->pos++;return 1 ;
@@ -724,14 +838,14 @@ static void *s_next(struct seq_file *m, void *p, loff_t *pos) { (*pos)++; -if (!update_iter (m->private, *pos)) +if (!update_iter (m->private, *pos,0 ))return NULL ;return p; }static void *s_start (struct seq_file *m,loff_t *pos) { -if (!update_iter (m->private, *pos)) +if (!update_iter (m->private, *pos,0 ))return NULL ;return m->private; }
@@ -740,7 +854,7 @@ static void s_stop(struct seq_file *m, void *p) { } -static int s_show (struct seq_file *m,void *p) +static int s_show_internal (struct seq_file *m,void *p,int kallmodsyms) {void *value;struct kallsym_iter *iter = m->private;
@@ -751,23 +865,67 @@ static int s_show(struct seq_file *m, void *p) value = iter->show_value ? (void *)iter->value :NULL ; -if (iter->module_name[0 ]) { +/* +* Real module, or built-in module and /proc/kallsyms being shown. +*/ +if (iter->module_name[0 ] !='\0' || + (iter->builtin_module_names !=NULL && kallmodsyms !=0 )) {char type;/* -* Label it "global" if it is exported, -* "local" if not exported. +* Label it "global" if it is exported, "local" if not exported. */ type = iter->exported ?toupper (iter->type) :tolower (iter->type); -seq_printf (m,"%px %c %s\t[%s]\n" , value, - type, iter->name, iter->module_name); +#ifdef CONFIG_KALLMODSYMS +if (kallmodsyms) { +/* +* /proc/kallmodsyms, built as a module. +*/ +if (iter->builtin_module_names ==NULL ) +seq_printf (m,"%px %c %s\t[%s]\n" , value, + type, iter->name, + iter->module_name); +/* +* /proc/kallmodsyms, single-module symbol. +*/ +else if (*iter->builtin_module_names !='\0' ) +seq_printf (m,"%px %c %s\t[%s]\n" , value, + type, iter->name, + iter->builtin_module_names); +/* +* /proc/kallmodsyms, multimodule symbol. Formatted +* as \0MODULE_COUNTmodule-1\0module-2\0, where +* MODULE_COUNT is a single byte, 2 or higher. +*/ +else { +size_t i = *(char *)(iter->builtin_module_names +1 ); +const char *walk = iter->builtin_module_names +2 ; + +seq_printf (m,"%px %c %s\t[%s]" , value, + type, iter->name, walk); + +while (--i >0 ) { + walk +=strlen (walk) +1 ; +seq_printf (m," [%s]" , walk); + } +seq_printf (m,"\n" ); + } + } else /* !kallmodsyms */ +#endif /* CONFIG_KALLMODSYMS */ +seq_printf (m,"%px %c %s\t[%s]\n" , value, + type, iter->name, iter->module_name); }else seq_printf (m,"%px %c %s\n" , value, iter->type, iter->name);return 0 ; } +static int s_show (struct seq_file *m,void *p) +{ +return s_show_internal (m, p,0 ); +} +static const struct seq_operations kallsyms_op = { .start = s_start, .next = s_next,
@@ -775,6 +933,35 @@ static const struct seq_operations kallsyms_op = { .show = s_show }; +#ifdef CONFIG_KALLMODSYMS +static int s_mod_show (struct seq_file *m,void *p) +{ +return s_show_internal (m, p,1 ); +} +static void *s_mod_next (struct seq_file *m,void *p,loff_t *pos) +{ + (*pos)++; + +if (!update_iter (m->private, *pos,1 )) +return NULL ; +return p; +} + +static void *s_mod_start (struct seq_file *m,loff_t *pos) +{ +if (!update_iter (m->private, *pos,1 )) +return NULL ; +return m->private; +} + +static const struct seq_operations kallmodsyms_op = { + .start = s_mod_start, + .next = s_mod_next, + .stop = s_stop, + .show = s_mod_show +}; +#endif +static inline int kallsyms_for_perf (void ) {#ifdef CONFIG_PERF_EVENTS
@@ -810,7 +997,8 @@ bool kallsyms_show_value(const struct cred *cred) } } -static int kallsyms_open (struct inode *inode,struct file *file) +static int kallsyms_open_internal (struct inode *inode,struct file *file, +const struct seq_operations *ops) {/* * We keep iterator in m->private, since normal case is to
@@ -818,7 +1006,7 @@ static int kallsyms_open(struct inode *inode, struct file *file)* using get_symbol_offset for every symbol. */ struct kallsym_iter *iter; - iter =__seq_open_private (file, &kallsyms_op,sizeof (*iter)); + iter =__seq_open_private (file, ops,sizeof (*iter));if (!iter)return -ENOMEM ;reset_iter (iter,0 );
@@ -831,6 +1019,18 @@ static int kallsyms_open(struct inode *inode, struct file *file)return 0 ; } +static int kallsyms_open (struct inode *inode,struct file *file) +{ +return kallsyms_open_internal (inode, file, &kallsyms_op); +} + +#ifdef CONFIG_KALLMODSYMS +static int kallmodsyms_open (struct inode *inode,struct file *file) +{ +return kallsyms_open_internal (inode, file, &kallmodsyms_op); +} +#endif +#ifdef CONFIG_KGDB_KDB const char *kdb_walk_kallsyms (loff_t *pos) {
@@ -841,7 +1041,7 @@ const char *kdb_walk_kallsyms(loff_t *pos)reset_iter (&kdb_walk_kallsyms_iter,0 ); }while (1 ) { -if (!update_iter (&kdb_walk_kallsyms_iter, *pos)) +if (!update_iter (&kdb_walk_kallsyms_iter, *pos,0 ))return NULL ; ++*pos;/* Some debugging symbols have no name. Ignore them. */
@@ -858,9 +1058,21 @@ static const struct proc_ops kallsyms_proc_ops = { .proc_release = seq_release_private, }; +#ifdef CONFIG_KALLMODSYMS +static const struct proc_ops kallmodsyms_proc_ops = { + .proc_open = kallmodsyms_open, + .proc_read = seq_read, + .proc_lseek = seq_lseek, + .proc_release = seq_release_private, +}; +#endif +static int __init kallsyms_init (void ) {proc_create ("kallsyms" ,0444 ,NULL , &kallsyms_proc_ops); +#ifdef CONFIG_KALLMODSYMS +proc_create ("kallmodsyms" ,0444 ,NULL , &kallmodsyms_proc_ops); +#endif return 0 ; }device_initcall (kallsyms_init);
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 7/7 kallsyms: add reliable symbol size info
In reply to Nick AlcockThe existing mechanisms in get_symbol_pos to determine the end of a symbol is an inaccurate heuristic. By passing nm -S output into scripts/kallsyms.c and writing the symbol sizes to a new .kallsyms_sizes section, we can get accurate sizes and sort the symbols accordingly, reliably sorting zero-size symbols first (on the grounds that they are usually e.g. section markers, and other symbols at the same address are conceptually contained within them and should be sorted after them), then larger symbols before smaller ones (so that overlapping symbols print the containing symbol first, before its containees). We can also use this to improve aliased symbol detection.
Emit the size info as an extra column in /proc/kallmodsyms (since its format is not yet set in stone), and export it to iterator consumers.
The notable downside of this is that the new .kallsyms_sizes is pretty
big: a PTR per symbol, so vmlinux.o grows by almost a megabyte, though it compresses pretty well, so bzImage grows by only a megabyte.
I'm not sure how to reduce this (perhaps using an array with elements sized to be no larger than needed for the contents, so that almost always two-byte entries would do? except that in my test kernel two symbols are bigger than this: sme_workarea, at 400K, and __log_buf, at 100K: the latter seems often likely to be larger than 64K). A simple scheme to reduce this would be to split the sizes array into several arrays with differently-sized elements, and run-length-compress away the zero bytes -- but that's not implemented yet, and might never be if people think the whole idea of this is pointless.
In the absence of a way to shrink things, this should probably be hidden behind a new config symbol if exposed at all, and kallmodsyms just shows zero sizes if it's configured out (but this is enough of an RFC that that's not yet done: possibly the benefits of this are too marginal to be worth it, even if they do let kall(mod)syms consumers distinguish symbols from padding, which was previously impossible).
--- include/linux/module.h | 7 ++-- kernel/kallsyms.c | 74 ++++++++++++++++++++++------------------- kernel/module.c | 4 ++- scripts/kallsyms.c | 29 +++++++++++++--- scripts/link-vmlinux.sh | 7 +++- 5 files changed, 77 insertions(+), 44 deletions(-)
include/linux/module.h +4 -3
@@ -590,7 +590,8 @@ struct module *find_module(const char *name);/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if symnum out of range. */ int module_get_kallsym (unsigned int symnum,unsigned long *value,char *type, -char *name,char *module_name,int *exported); +char *name,char *module_name,unsigned long *size, +int *exported);/* Look for this name: can be of form module:name. */ unsigned long module_kallsyms_lookup_name (const char *name);
@@ -768,8 +769,8 @@ static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long * }static inline int module_get_kallsym (unsigned int symnum,unsigned long *value, -char *type,char *name, -char *module_name,int *exported) +char *type,char *name,char *module_name, +unsigned long *size,int *exported) {return -ERANGE ; }
kernel/kallsyms.c +39 -35
154 lines not on this page · raw message
kernel/module.c +3 -1
@@ -4368,7 +4368,8 @@ int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, }int module_get_kallsym (unsigned int symnum,unsigned long *value,char *type, -char *name,char *module_name,int *exported) +char *name,char *module_name,unsigned long *size, +int *exported) {struct module *mod;
@@ -4387,6 +4388,7 @@ int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,strlcpy (name,kallsyms_symbol_name (kallsyms, symnum),KSYM_NAME_LEN );strlcpy (module_name, mod->name,MODULE_NAME_LEN ); *exported =is_exported (name, *value, mod); + *size = kallsyms->symtab[symnum].st_size;preempt_enable ();return 0 ; }
scripts/kallsyms.c +25 -4
@@ -5,7 +5,7 @@* This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. * -* Usage: nm -n vmlinux +* Usage: nm -n -S vmlinux * | scripts/kallsyms [--all-symbols] [--absolute-percpu] * [--base-relative] [--builtin=modules_thick.builtin] * > symbols.S
@@ -38,6 +38,7 @@struct sym_entry {unsigned long long addr; +unsigned long long size;unsigned int len;unsigned int start_pos;unsigned int percpu_absolute;
@@ -394,6 +395,7 @@ static bool is_ignored_symbol(const char *name, char type)"kallsyms_addresses" ,"kallsyms_offsets" ,"kallsyms_relative_base" , +"kallsyms_sizes" ,"kallsyms_num_syms" ,"kallsyms_num_modules" , "kallsyms_names",
@@ -507,10 +509,11 @@ static struct sym_entry *read_symbol(FILE *in)unsigned long long addr;unsigned int len;struct sym_entry *sym; -int rc; +int rc =0 ; +unsigned long long size; - rc =fscanf (in,"%llx %c %499s\n" , &addr, &type, name); -if (rc !=3 ) { + rc =fscanf (in,"%llx %llx %c %499s\n" , &addr, &size, &type, name); +if (rc !=4 ) {if (rc !=EOF &&fgets (name,500 , in) ==NULL )fprintf (stderr,"Read error or end of file.\n" );return NULL ;
@@ -548,6 +551,7 @@ static struct sym_entry *read_symbol(FILE *in) sym->sym[0 ] = type;strcpy (sym_name (sym), name); sym->percpu_absolute =0 ; + sym->size = size;return sym; }
@@ -932,6 +936,11 @@ static void write_src(void)printf ("\n" ); } +output_label ("kallsyms_sizes" ); +for (i =0 ; i < table_cnt; i++) +printf ("\tPTR\t%#llx\n" , table[i]->size); +printf ("\n" ); +#ifdef CONFIG_KALLMODSYMS output_kallmodsyms_modules ();output_kallmodsyms_objfiles ();
@@ -1189,6 +1198,18 @@ static int compare_symbols(const void *a, const void *b)if (sa->addr < sb->addr)return -1 ; +/* zero-size markers before nonzero-size symbols */ +if (sa->size >0 && sb->size ==0 ) +return 1 ; +if (sa->size ==0 && sb->size >0 ) +return -1 ; + +/* sort by size (large size preceding symbols it encompasses) */ +if (sa->size < sb->size) +return 1 ; +if (sa->size > sb->size) +return -1 ; +/* sort by "weakness" type */ wa = (sa->sym[0 ] =='w' ) || (sa->sym[0 ] =='W' ); wb = (sb->sym[0 ] =='w' ) || (sb->sym[0 ] =='W' );
scripts/link-vmlinux.sh +6 -1
@@ -274,7 +274,12 @@ kallsyms() fi info KSYMS ${2} - ${NM} -n ${1} | scripts/kallsyms ${kallsymopt} > ${2} + # "nm -S" does not print symbol size when size is 0 + # Therefore use awk to regularize the data: + # - when there are only three fields, add an explicit "0" + # - when there are already four fields, pass through as is + ${NM} -n -S ${1} | ${AWK} 'NF==3 {print $1, 0, $2, $3}; NF==4' | \ + scripts/kallsyms ${kallsymopt} > ${2} } # Perform one step in kallsyms generation, including temporary linking of
Signature · 1 line
2.33.0.256.gb827f06fa9
Quoted 7 lines · Nick Alcock
It would be useful if there were a mapping between kernel symbol and module name that only changed when the kernel source code is changed. This mapping should not change simply because a module becomes built into the kernel.
It might also be useful if there were reliable symbol size information to determine whether an address is within a symbol or outside it, especially given that there could be huge gaps between symbols.
This is a pretty cool series, but I'm left wondering "for what reason?" :) Perhaps I missed the specific rationale; there was a lot to run. ;)
It would be useful, sure, but is there something that does, in fact, need this, or would like this if it were available? Since this provides a userspace API, what would be consuming that API? For example, when Syscall User Dispatch was added, it was clear it was for Wine[1].
-Kees
[1] https://lore.kernel.org/lkml/160690190770.3364.5119373826178425644.tip-bot2@tip-bot2/
Signature · 1 line
Kees Cook
Quoted 11 lines · Kees Cook
Quoted 7 lines · Nick Alcock
It would be useful if there were a mapping between kernel symbol and module name that only changed when the kernel source code is changed. This mapping should not change simply because a module becomes built into the kernel.
It might also be useful if there were reliable symbol size information to determine whether an address is within a symbol or outside it, especially given that there could be huge gaps between symbols.
This is a pretty cool series, but I'm left wondering "for what reason?" :) Perhaps I missed the specific rationale; there was a lot to run. ;)
The underlying rationale that the earliest, crude version of this patch was written for is that DTrace allows symbol and type names to be module-qualified (e.g. hid`names) and we don't want people's scripts to break just because they recompile the kernel to make things a module versus not. But this problem is not DTrace-specific: given that names are not unique across the kernel when things are built as modules, many tracing tools that introspect the values of kernel symbols etc might want to let users qualify names with the modules they apply to, and more or less none of those are going to want a script that asks for "foo in the bar module" to suddenly become invalid because the user changed CONFIG_FOO=m to CONFIG_FOO=y.
Obviously, if they change it to CONFIG_FOO=n, any script that uses names from FOO is going to break: there's nothing we can do about that. But not breaking the m/y case seems like a simple quality-of- implementation issue to make it easier to redistribute scripts to anyone using FOO no matter what their module/non-module configuration, and a nice easy one to fix, if only we could easily tell what the module/symbol mapping was. And with this patch we can (at minimal cost).
(I have also found it to be useful for by-hand stuff, when I can't remember where the heck some symbol with a non-qualified name is, usually a file-scope variable: it's faster to grep kallmodsyms than to do a tags lookup, let alone a grep, if I'm debugging something I know is loaded into the kernel right now. Which often one is if one is reproducing the bug... and often the module a symbol is part of is informative. This is, obviously, crude, but it's still more useful to have more module names there than fewer if one is doing this sort of thing.)
(As an aside, this is not all a tracing system needs to do to get this sort of thing right, particularly where types are concerned: it's still possible to have conflicting type names across translation units within a single module. CTF deals with that case perfectly well via child CTF dicts, and GNU ld splits ambiguously-defined types out so that the user can say "foo_t in the bar module in wombat.c" in the rare cases where ambiguity exists.)
Quoted 4 lines
It would be useful, sure, but is there something that does, in fact, need this, or would like this if it were available? Since this provides a userspace API, what would be consuming that API? For example, when Syscall User Dispatch was added, it was clear it was for Wine[1].
We have a long-term consumer in DTrace (e.g.
<https://github.com/oracle/dtrace-utils/blob/dev/libdtrace/dt_module.c#L1323>).
(But since we control this consumer we are quite happy to change the format of kallmodsyms, integrate it with kallsyms so that kallsyms just provides the same information if the file format break were acceptable, or whatever you think most sensible. We just want this information somehow. :) e.g. the code there doesn't yet handle the symbol-in-multiple-modules case: I'll have to add that.)
But this feels useful enough to me that I'm hoping that more consumers will grow. I'm sure SystemTap would find it useful, and I'm hoping bpftrace etc might as well once that starts to handle modules. They're all going to need some sort of namespace-qualification and then they're all going to run into the same script-stability problem as soon as users try to share scripts at all. We can make that problem largely go away :)
Signature · 1 line
NULL && (void)
Quoted 16 lines · Nick Alcock
Quoted 9 lines · Kees Cook
Quoted 8 lines · Nick Alcock
It would be useful if there were a mapping between kernel symbol and module name that only changed when the kernel source code is changed. This mapping should not change simply because a module becomes built into the kernel.
It might also be useful if there were reliable symbol size information to determine whether an address is within a symbol or outside it, especially given that there could be huge gaps between symbols.
[...]Quoted 5 lines
[...]
It would be useful, sure, but is there something that does, in fact, need this, or would like this if it were available? Since this provides a userspace API, what would be consuming that API? For example, when Syscall User Dispatch was added, it was clear it was for Wine[1].
Quoted 8 lines
We have a long-term consumer in DTrace (e.g.
<https://github.com/oracle/dtrace-utils/blob/dev/libdtrace/dt_module.c#L1323>).
(But since we control this consumer we are quite happy to change the format of kallmodsyms, integrate it with kallsyms so that kallsyms just provides the same information if the file format break were acceptable, or whatever you think most sensible. We just want this information somehow. :) e.g. the code there doesn't yet handle the symbol-in-multiple-modules case: I'll have to add that.)
Ah-ha, excellent. That works for me. :) (If there is a v5, maybe add a note about DTrace to help show the specific need.)
Thanks!
-Kees
Signature · 1 line
Kees Cook
PATCH v5 1/1 kallsyms: new /proc/kallmodsyms with builtin modules
In reply to Nick Alcock/proc/kallsyms is very useful for tracers and other tools that need to map kernel symbols to addresses.
It would be useful if there were a mapping between kernel symbol and module name that only changed when the kernel source code is changed. This mapping should not change simply because a module becomes built into the kernel.
It might also be useful if there were reliable symbol size information to determine whether an address is within a symbol or outside it, especially given that there could be huge gaps between symbols.
Fix this by introducing a new config parameter CONFIG_KALLMODSYMS, which does several things at once (introduced in distinct commits inthis series).
Generate a file "modules_thick.builtin" that maps from the thin archives that make up built-in modules to their constituent object files. (This reintroduces the machinery that used to be used to generate modules.builtin. I am not wedded to this mechanism: if someone can figure out a mechanism that does not require recursing over the entire build tree, I'm happy to use it, but I suspect that no such mechanism exists, since the only place the mapping from object file to module exists is in the makefiles themselves. Regardless, this is fairly cheap, adding less than a second to a typical hot-cache build of a large enterprise kernel. This is true even though it needs to be run unconditionally whenever the .config changes.)
Generate a linker map ".tmp_vmlinux.map", converting it into ".tmp_vmlinux.ranges", mapping address ranges to object files.
Have scripts/kallsyms read these two new files to map symbol addresses to built-in-module names and then write a mapping from object file address to module name to the *.s output file.
The mapping consists of three new symbols:
- kallsyms_module_addresses/kallsyms_module_offsets encodes the address/offset of each object file (derived from the linker map), in exactly the same way as kallsyms_addresses/kallsyms_offsets does for symbols. There is no size: instead, the object files are assumed to tile the address space. (This is slightly more space-efficient than using a size). Non-text-section addresses are
skipped: for now, all the users of this interface only need module/non-module information for instruction pointer addresses, not absolute-addressed symbols and the like. This restriction can easily be lifted in future. (For why this isn't called kallsyms_objfiles, see two entries below.)
- kallsyms_module_names encodes the name of each module in a modified form of strtab: notably, if an object file appears in *multiple* modules, all of which are built in, this is encoded via a zero byte, a one-byte module count, then a series of that many null-terminated strings. Object files which appear in only one module in such a multi-module list are redirected to point inside that list, so that modules which contain some object files shared with other modules and some object files exclusive to them do not double up the module name. (There might still be some duplication between multiple multi-module lists, but this is an extremely marginal size effect, and resolving it would require an extra layer of lookup tables which would be even more complex, and incompressible to boot). As a special case, the table starts with a single zero byte which does *not* represent the start of a multi-module list.
- kallsyms_modules connects the two, encoding a table associated 1:1 with kallsyms_module_addresses / kallsyms_module_offsets, pointing at an offset in kallsyms_module_names describing which module (or modules, for a multi-module list) the code occupying this address range is part of. If an address range is part of no module (always built-in) it points at 0 (the null byte at the start of the kallsyms_module_names list). Entries in this list that would contain the same value are fused together, along with their corresponding kallsyms_module_addresses/offsets entries. Due to this fusion process, and because object files can be split apart into multiple parts by the linker for hot/cold partitioning and the like, entries in here do not really correspond to an object file, but more to some contiguous range of addresses which are guaranteed to belong to a single built-in module: so it seems best to call the symbols kallsyms_modules*. (The generator has a data structure that does correspond more closely to object files, from which kallsyms_modules is generated, and that does use 'objfiles' terminology.)
Emit a new /proc/kallmodsyms file akin to /proc/kallsyms but with built-in module names, using a new kallsyms_builtin_module_address() almost identical to kallsyms_sym_address() to get the address corresponding to a given .kallsyms_modules index, and a new get_builtin_module_idx quite similar to get_symbol_pos to determine the index in the .kallsyms_modules array that relates to a given address. Save a little time by exploiting the fact that all callers will only ever traverse this list from start to end by allowing them to pass in the previous index returned from this function as a hint:
thus very few bsearches are actually needed. (In theory this could change to just walk straight down kallsyms_module_addresses/offsets and not bother bsearching at all, but doing it this way is hardly any slower and much more robust.)
The display process is complicated a little by the weird format of the .kallsyms_module_names table: we have to look for multimodule entries and print them as space-separated lists of module names.
The resulting /proc/kallmodsyms file looks like this:
ffffffff8b013d20 409 t pt_buffer_setup_aux ffffffff8b014130 11f T intel_pt_interrupt ffffffff8b014250 2d T cpu_emergency_stop_pt
ffffffff8b014280 13a t rapl_pmu_event_init [intel_rapl_perf]
ffffffff8b0143c0 bb t rapl_event_update [intel_rapl_perf]
ffffffff8b014480 10 t rapl_pmu_event_read [intel_rapl_perf]
ffffffff8b014490 a3 t rapl_cpu_offline [intel_rapl_perf] ffffffff8b014540 24 t __rapl_event_show [intel_rapl_perf]
ffffffff8b014570 f2 t rapl_pmu_event_stop [intel_rapl_perf]
This is emitted even if intel_rapl_perf is built into the kernel.
Further down, we see what happens when object files are reused by multiple modules, all of which are built in to the kernel:
ffffffffa22b3aa0 ab t handle_timestamp [liquidio]ffffffffa22b3b50 4a t free_netbuf [liquidio]ffffffffa22b3ba0 8d t liquidio_ptp_settime [liquidio]ffffffffa22b3c30 b3 t liquidio_ptp_adjfreq [liquidio]
[...]
ffffffffa22b9490 203 t lio_vf_rep_create [liquidio] ffffffffa22b96a0 16b t lio_vf_rep_destroy [liquidio] ffffffffa22b9810 1f t lio_vf_rep_modinit [liquidio] ffffffffa22b9830 1f t lio_vf_rep_modexit [liquidio] ffffffffa22b9850 d2 t lio_ethtool_get_channels [liquidio] [liquidio_vf] ffffffffa22b9930 9c t lio_ethtool_get_ringparam [liquidio] [liquidio_vf] ffffffffa22b99d0 11 t lio_get_msglevel [liquidio] [liquidio_vf] ffffffffa22b99f0 11 t lio_vf_set_msglevel [liquidio] [liquidio_vf] ffffffffa22b9a10 2b t lio_get_pauseparam [liquidio] [liquidio_vf] ffffffffa22b9a40 738 t lio_get_ethtool_stats [liquidio] [liquidio_vf] ffffffffa22ba180 368 t lio_vf_get_ethtool_stats [liquidio] [liquidio_vf]
ffffffffa22ba4f0 37 t lio_get_regs_len [liquidio] [liquidio_vf]ffffffffa22ba530 18 t lio_get_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba550 2e t lio_set_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba580 69 t lio_set_fecparam [liquidio] [liquidio_vf]ffffffffa22ba5f0 92 t lio_get_fecparam [liquidio] [liquidio_vf]
[...]ffffffffa22cbd10 175 t liquidio_set_mac [liquidio_vf] ffffffffa22cbe90 ab t handle_timestamp [liquidio_vf]ffffffffa22cbf40 4a t free_netbuf [liquidio_vf]ffffffffa22cbf90 2b t octnet_link_status_change [liquidio_vf]ffffffffa22cbfc0 7e t liquidio_vxlan_port_command.constprop.0 [liquidio_vf]
Like /proc/kallsyms, the output is driven by address, so keeps the curious property of /proc/kallsyms that symbols (like free_netbuf above) may appear repeatedly with different addresses: but now, unlike in /proc/kallsyms, we can see that those symbols appear repeatedly because they are *different symbols* that ultimately belong to different modules, all of which are built in to the kernel.
Those symbols that come from object files that are genuinely reused and that appear only once in meory get a /proc/kallmodsyms line with [multiple] [modules] on it: consumers will have to be ready to handle such lines.
Also, kernel symbols for built-in modules will probably appear interspersed with other symbols that are part of different modules and non-modular always-built-in symbols, which, as usual, have no square-bracketed module denotation.
As with /proc/kallsyms, non-root usage produces addresses that are all zero.
I am open to changing the name and/or format of /proc/kallmodsyms, but felt it best to split it out of /proc/kallsyms to avoid breaking existing kallsyms parsers. Another possible syntax might be to use {curly brackets} or something to denote built-in modules: it might be possible to drop /proc/kallmodsyms and make /proc/kallsyms emit things in this format. (Equally, now kallmodsyms data uses very little space, the CONFIG_KALLMODSYMS config option might be something people don't want to bother with.)
The size impact of all of this is minimal: for the case above, the kallsyms2.S file went from 14107772 to 14137245 bytes, a gain of 29743 bytes, or 0.16%: vmlinux gained 10824 bytes, a gain of .017%, and the compressed vmlinux only 7552 bytes, a gain of .08%: though the latter two values are very configuration-dependent, they seem likely to scale roughly with the kernel they are part of.
The last patch is an RFC to see if the idea is considered to be worth spending more time optimizing the representation, which adds a new kallsyms_sizes section that gives the size of each symbol, and uses this info to report reliable symbol sizes to in-kernel users, and (via a new column in /proc/kallmodsyms) to out-of-kernel users too. Having reliable size info lets us identify inter-symbol gaps and sort symbols so that start/end-marker and overlapping symbols are consistently ordered with respect to the symbols they overlap. This certainly uses too much space right now, 200KiB--1MiB: a better representation is certainly needed. One that springs to mind is making the table sparse (pairs of symbol index/size), and recording explicit sizes only for those symbols that are not immediately followed by a subsequent symbol.
Differences from v4, two months ago:
- Fix building of tristate.conf if missing (usually concealed by the syncconfig being run for other reasons, but not always: the kernel test robot spotted it).
- Forward-port atop v5.15-rc3.
Differences from v3, a month earlier:
- Fix a kernel test robot warning in get_ksymbol_core (possible use of uninitialized variable if kallmodsyms was wanted but kallsyms_module_offsets was not present, which is most unlikely).
Differences from v2, a couple of months before that:
- Split the series up. In particular, the size impact of the table optimizer is now quantified, and the symbol-size patch is split out and turned into an RFC patch, with the /proc/kallmodsyms format before that patch lacking a size column. Some speculation on how to make the symbol sizes less space-wasteful is added (but not yet implemented).
- Drop a couple of unnecessary #includes, one unnecessarily exported symbol, and a needless de-staticing.
Differences from v1, a year or so back:
- Move from a straight symbol->module name mapping to a mapping from address-range to TU to module name list, bringing major space savings over the previous approach and support for object files used by many built-in modules at the same time, at the cost of a slightly more complex approach (unavoidably so, I think, given that we have to merge three data sources together: the link map in .tmp_vmlinux.ranges, the nm output on stdin, and the mapping from TU name to module names in modules_thick.builtin).
We do opportunistic merging of TUs if they cite the same modules and reuse module names where doing so is simple: see optimize_obj2mod below. I considered more extensive searches for mergeable entries and more intricate encodings of the module name list allowing TUs that are used by overlapping sets of modules to share their names, but such modules are rare enough (and such overlapping sharings are vanishingly rare) that it seemed likely to save only a few bytes at the cost of much more hard-to-test code. This is doubly true now that the tables needed are only a few kilobytes in length.
Nick Alcock (7):
kbuild: bring back tristate.conf
kbuild: add modules_thick.builtin
kbuild: generate an address ranges map at vmlinux link time
kallsyms: introduce sections needed to map symbols to built-in modules
kallsyms: optimize .kallsyms_modules*
kallsyms: add /proc/kallmodsyms
kallsyms: add reliable symbol size info
.gitignore | 1 + Documentation/dontdiff | 1 + Makefile | 23 +- include/linux/module.h | 7 +- init/Kconfig | 8 + kernel/kallsyms.c | 304 ++++++++++++++--- kernel/module.c | 4 +- scripts/Kbuild.include | 6 + scripts/Makefile | 6 + scripts/Makefile.modbuiltin | 56 ++++ scripts/kallsyms.c | 642 +++++++++++++++++++++++++++++++++++- scripts/kconfig/confdata.c | 41 ++- scripts/link-vmlinux.sh | 22 +- scripts/modules_thick.c | 200 +++++++++++ scripts/modules_thick.h | 48 +++ 15 files changed, 1301 insertions(+), 68 deletions(-) create mode 100644 scripts/Makefile.modbuiltin create mode 100644 scripts/modules_thick.c create mode 100644 scripts/modules_thick.h
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 1/7 kbuild: bring back tristate.conf
tristate.conf was dropped because it is not needed to build a modules.builtin (although dropping it introduces a few false positives into modules.builtin support), and doing so avoids one round of recursion through the build tree to build it. But kallmodsyms support requires building a mapping from object file name to built-in module name for all builtin modules: this seems to me impossible to accomplish without parsing all makefiles under the influence of tristate.conf, since the makefiles are the only place this mapping is recorded.
So bring it back for this purpose.
This partially reverts commit 8b41fc4454e36fbfdbb23f940d023d4dece2de29.
--- Makefile | 2 +- scripts/kconfig/confdata.c | 41 ++++++++++++++++++++++++++++++++++++-- 2 files changed, 40 insertions(+), 3 deletions(-)
Makefile +1 -1
@@ -724,7 +724,7 @@ $(KCONFIG_CONFIG): # # Do not use $(call cmd,...) here. That would suppress prompts from syncconfig, # so you cannot notice that Kconfig is waiting for the user input. -%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h: $(KCONFIG_CONFIG) +%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h %/tristate.conf: $(KCONFIG_CONFIG) $(Q)$(kecho) " SYNC $@" $(Q)$(MAKE) -f $(srctree)/Makefile syncconfig else # !may-sync-config
scripts/kconfig/confdata.c +39 -2
81 lines not on this page · raw message
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 2/7 kbuild: add modules_thick.builtin
In reply to Nick AlcockThis is similar to modules.builtin, and constructed in a similar way to the way that used to be built before commit 8b41fc4454e36fbfdbb23f940d023d4dece2de29, via tristate.conf inclusion and recursive concatenation up the tree. Unlike modules.builtin, modules_thick.builtin givs the names of the object files that make up modules that are comprised of more than one object file, using a syntax similar to that of makefiles, e.g.:
crypto/crypto.o: crypto/api.o crypto/cipher.o crypto/compress.o crypto/memneq.o crypto/crypto_algapi.o: crypto/algapi.o crypto/proc.o crypto/scatterwalk.o crypto/aead.o:crypto/geniv.o:
(where the latter two are single-file modules).
An upcoming commit will use this mapping to populate /proc/kallmodsyms.
A parser is included that yields a stram of (module, objfile name[])
mappings: it's a bit baroque, but then parsing text files in C is quite painful, and I'd rather put the complexity in here than in its callers. The parser is not built in this commit, nor does it have any callers yet; nor is any rule added that causes modules_thick.builtin to actually be constructed. (Again, see a later commit for that.)
I am not wedded to the approach used to construct this file, but I don't see any other way to do it despite spending a week or so trying to tie it into Kbuild without using a separate Makefile.modbuiltin: unlike the names of builtin modules (which are also recorded in the source files themseves via MODULE_*() macros) the mapping from object file name to built-in module name is not recorded anywhere but in the makefiles themselves, so we have to at least reparse them with something to indicate the builtin-ness of each module (i.e., tristate.conf) if we are to figure out which modules are built-in and which are not.
--- .gitignore | 1 + Documentation/dontdiff | 1 + Makefile | 19 +++- scripts/Kbuild.include | 6 ++ scripts/Makefile.modbuiltin | 56 ++++++++++ scripts/modules_thick.c | 200 ++++++++++++++++++++++++++++++++++++ scripts/modules_thick.h | 48 +++++++++ 7 files changed, 330 insertions(+), 1 deletion(-) create mode 100644 scripts/Makefile.modbuiltin create mode 100644 scripts/modules_thick.c create mode 100644 scripts/modules_thick.h
.gitignore +1 -0
@@ -49,6 +49,7 @@ *.zst Module.symvers modules.order +modules_thick.builtin # # Top-level generic files
Documentation/dontdiff +1 -0
@@ -183,6 +183,7 @@ modules.builtin modules.builtin.modinfo modules.nsdeps modules.order +modules_thick.builtin modversions.h* nconf nconf-cfg
Makefile +18 -1
@@ -1507,6 +1507,23 @@ __modinst_pre: endif # CONFIG_MODULES +# modules_thick.builtin maps from kernel modules (or rather the object file +# names they would have had had they not been built in) to their constituent +# object files: we can use this to determine which modules any given object +# file is part of. (We cannot eliminate the slight redundancy here without +# double-expansion.) + +modthickbuiltin-files := $(addsuffix /modules_thick.builtin, $(build-dirs)) + +modules_thick.builtin: $(modthickbuiltin-files) + $(Q)$(AWK) '!x[$$0]++' $(addsuffix /$@, $(build-dirs)) > $@ + +# tristate.conf is not included from this Makefile. Add it as a prerequisite +# here to make it self-healing in case somebody accidentally removes it. +$(modthickbuiltin-files): include/config/tristate.conf + $(Q)$(MAKE) $(modbuiltin)=$(patsubst %/modules_thick.builtin,%,$@) builtin-file=modules_thick.builtin + + ### # Cleaning is done on three levels. # make clean Delete most generated files
@@ -1886,7 +1903,7 @@ clean: $(clean-dirs) -o -name '*.lex.c' -o -name '*.tab.[ch]' \ -o -name '*.asn1.[ch]' \ -o -name '*.symtypes' -o -name 'modules.order' \ - -o -name '.tmp_*.o.*' \ + -o -name '.tmp_*.o.*' -o -name modules_thick.builtin \ -o -name '*.c.[012]*.*' \ -o -name '*.ll' \ -o -name '*.gcno' \
scripts/Kbuild.include +6 -0
@@ -74,6 +74,12 @@ endef # $(Q)$(MAKE) $(build)=dir build := -f $(srctree)/scripts/Makefile.build obj +### +# Shorthand for $(Q)$(MAKE) -f scripts/Makefile.modbuiltin obj= +# Usage: +# $(Q)$(MAKE) $(modbuiltin)=dir +modbuiltin := -f $(srctree)/scripts/Makefile.modbuiltin obj + ### # Shorthand for $(Q)$(MAKE) -f scripts/Makefile.dtbinst obj= # Usage:
scripts/Makefile.modbuiltin new file +56 -0
56 lines not on this page · raw message
scripts/modules_thick.c new file +200 -0
200 lines not on this page · raw message
scripts/modules_thick.h new file +48 -0
48 lines not on this page · raw message
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 3/7 kbuild: generate an address ranges map at vmlinux link time
In reply to Nick AlcockThis emits a new file, .tmp_vmlinux.ranges, which maps address range/size pairs in vmlinux to the object files which make them up, e.g., in part:
0x0000000000000000 0x30 arch/x86/kernel/cpu/common.o 0x0000000000001000 0x1000 arch/x86/events/intel/ds.o 0x0000000000002000 0x4000 arch/x86/kernel/irq_64.o 0x0000000000006000 0x5000 arch/x86/kernel/process.o 0x000000000000b000 0x1000 arch/x86/kernel/cpu/common.o 0x000000000000c000 0x5000 arch/x86/mm/cpu_entry_area.o 0x0000000000011000 0x10 arch/x86/kernel/espfix_64.o 0x0000000000011010 0x2 arch/x86/kernel/cpu/common.o [...]
In my simple tests this seems to work with clang too, but if I'm not sure how stable the format of clang's linker mapfiles is: if it turns out not to work in some versions, the mapfile-massaging awk script added here might need some adjustment.
--- scripts/link-vmlinux.sh | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-)
scripts/link-vmlinux.sh +14 -1
@@ -196,7 +196,7 @@ vmlinux_link() ${ld} ${ldflags} -o ${output} \ ${wl}--whole-archive ${objs} ${wl}--no-whole-archive \ ${wl}--start-group ${libs} ${wl}--end-group \ - $@ ${ldlibs} + -Map=.tmp_vmlinux.map $@ ${ldlibs} } # generate .BTF typeinfo from DWARF debuginfo
@@ -248,6 +248,19 @@ kallsyms() { local kallsymopt; + # read the linker map to identify ranges of addresses: + # - for each *.o file, report address, size, pathname + # - most such lines will have four fields + # - but sometimes there is a line break after the first field + # - start reading at "Linker script and memory map" + # - stop reading at ".brk" + ${AWK} ' + /\.o$/ && start==1 { print $(NF-2), $(NF-1), $NF } + /^Linker script and memory map/ { start = 1 } + /^\.brk/ { exit(0) } + ' .tmp_vmlinux.map | sort > .tmp_vmlinux.ranges + + # get kallsyms options if [ -n "${CONFIG_KALLSYMS_ALL}" ]; then kallsymopt="${kallsymopt} --all-symbols" fi
Signature · 1 line
2.33.0.256.gb827f06fa9
kernel test robot
build botRe: [PATCH v5 3/7] kbuild: generate an address ranges map at vmlinux link time
Thank you for the patch! Yet something to improve:
Hi Nick,
Thank you for the patch! Yet something to improve:
[auto build test ERROR on linux/master]
[also build test ERROR on linus/master v5.15-rc7]
[cannot apply to jeyu/modules-next masahiroy/kconfig next-20211029] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Nick-Alcock/kbuild-bring-back-tristate-conf/20211028-024948 base: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 2f111a6fd5b5297b4e92f53798ca086f7c7d33a4 config: um-x86_64_defconfig (attached as .config) compiler: gcc-9 (Debian 9.3.0-22) 9.3.0
reproduce (this is a W=1 build):
# https://github.com/0day-ci/linux/commit/a5f527e3449ec41735da78a430732e96080d49fe
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Nick-Alcock/kbuild-bring-back-tristate-conf/20211028-024948 git checkout a5f527e3449ec41735da78a430732e96080d49fe
# save the attached .config to linux build tree
mkdir build_dir
make W=1 O=build_dir ARCH=um SUBARCH=x86_64 SHELL=/bin/bash
If you fix the issue, kindly add following tag as appropriate
All errors (new ones prefixed by >>):
>> gcc-9: error: unrecognized command line option '-Map=.tmp_vmlinux.map'
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
PATCH v5 4/7 kallsyms: introduce sections needed to map symbols to built-in modules
In reply to Nick AlcockThe mapping consists of three new symbols, computed by integrating the information in the (just-added) .tmp_vmlinux.ranges and modules_thick.builtin: taken together, they map address ranges (corresponding to object files on the input) to the names of zero or more modules containing those address ranges.
- kallsyms_module_addresses/kallsyms_module_offsets encodes the address/offset of each object file (derived from the linker map), in exactly the same way as kallsyms_addresses/kallsyms_offsets does for symbols. There is no size: instead, the object files are assumed to tile the address space. (This is slightly more space-efficient than using a size). Non-text-section addresses are skipped: for now, all the users of this interface only need module/non-module information for instruction pointer addresses, not absolute-addressed symbols and the like. This restriction can easily be lifted in future. (Regarding the name: right now the entries correspond pretty closely to object files, so we could call the section kallsyms_objfiles or something, but the optimizer added in the next commit will change this.)
- kallsyms_module_names encodes the name of each module in a modified form of strtab: notably, if an object file appears in *multiple* modules, all of which are built in, this is encoded via a zero byte, a one-byte module count, then a series of that many null-terminated strings. As a special case, the table starts with a single zero byte which does *not* represent the start of a multi-module list.
- kallsyms_modules connects the two, encoding a table associated 1:1 with kallsyms_module_addresses / kallsyms_module_offsets, pointing at an offset in kallsyms_module_names describing which module (or modules, for a multi-module list) the code occupying this address range is part of. If an address range is part of no module (always built-in) it points at 0 (the null byte at the start of the kallsyms_module_names list).
There is no optimization yet: kallsyms_modules and kallsyms_module_names will almost certainly contain many duplicate entries, and kallsyms_module_{addresses,offsets} may contain consecutive entries that point to the same place. The size hit is fairly substantial as a result, though still much less than a naive implementation mapping each symbol to a module name would be: 50KiB or so.
--- Makefile | 2 +- init/Kconfig | 8 + scripts/Makefile | 6 + scripts/kallsyms.c | 366 +++++++++++++++++++++++++++++++++++++++++++-- 4 files changed, 371 insertions(+), 11 deletions(-)
Makefile +1 -1
@@ -1179,7 +1179,7 @@ cmd_link-vmlinux = \ $(CONFIG_SHELL) $< "$(LD)" "$(KBUILD_LDFLAGS)" "$(LDFLAGS_vmlinux)"; \ $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true) -vmlinux: scripts/link-vmlinux.sh autoksyms_recursive $(vmlinux-deps) FORCE +vmlinux: scripts/link-vmlinux.sh autoksyms_recursive $(vmlinux-deps) modules_thick.builtin FORCE +$(call if_changed_dep,link-vmlinux) targets := vmlinux
init/Kconfig +8 -0
@@ -1526,6 +1526,14 @@ config POSIX_TIMERS If unsure say y. +config KALLMODSYMS + default y + bool "Enable support for /proc/kallmodsyms" if EXPERT + depends on KALLSYMS + help + This option enables the /proc/kallmodsyms file, which maps symbols + to addresses and their associated modules. + config PRINTK default y bool "Enable support for printk" if EXPERT
scripts/Makefile +6 -0
@@ -32,6 +32,12 @@ HOSTCFLAGS_sorttable.o += -DUNWINDER_ORC_ENABLED HOSTLDLIBS_sorttable = -lpthread endif +kallsyms-objs := kallsyms.o + +ifdef CONFIG_KALLMODSYMS +kallsyms-objs += modules_thick.o +endif + # The following programs are only built on demand hostprogs += unifdef
scripts/kallsyms.c +356 -10
455 lines not on this page · raw message
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 5/7 kallsyms: optimize .kallsyms_modules*
In reply to Nick AlcockThese symbols are terribly inefficiently stored at the moment. Add a simple optimizer which fuses obj2mod_elem entries and uses this to implement three cheap optimizations:
- duplicate names are eliminated from .kallsyms_module_names.
- entries in .kallsyms_modules which point at single-file modules which also appear in a multi-module list are redirected to point inside that list, and the single-file entry is dropped from .kallsyms_module_names. Thus, modules which contain some object files shared with other modules and some object files exclusive to them do not double up the module name. (There might still be some duplication between multiple multi-module lists, but this is an extremely marginal size effect, and resolving it would require an extra layer of lookup tables which would be even more complex, and incompressible to boot).
- Entries in .kallsyms_modules that would contain the same value after the above optimizations are fused together, along with their corresponding .kallsyms_module_addresses/offsets entries. Due to this fusion process, and because object files can be split apart into multiple parts by the linker for hot/cold partitioning and the like, entries in .kallsyms_module_addresses/offsets no longer correspond 1:1 to object files, but more to some contiguous range of addresses which are guaranteed to belong to a single built-in module, but which may well stretch over multiple object files.
The optimizer's time complexity is O(log n) in the number of objfiles at most (and probably much lower), so, given the relatively low number of objfiles, its runtime overhead is in the noise.
Optimization reduces the overhead of the kallmodsyms tables by about 7500 items, dropping the .tmp_kallsyms2.o object file size by about 33KiB, leaving it 8672 bytes larger than before: a gain of .4%.
The vmlinux size is not yet affected because the variables are not used and are eliminated by the linker: but if they were used (after the next commit), the size impact of all of this on the final kernel is minimal:
in my testing, the kallsyms2.S file went from 14107772 to 14137245 bytes, a gain of 29743 bytes, or 0.16%: vmlinux gained 10824 bytes, a gain of .017%, and the compressed vmlinux only 7552 bytes, a gain of .08%: though the latter two values are very configuration-dependent, they seem likely to scale roughly with the kernel they are part of.
--- scripts/kallsyms.c | 267 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 258 insertions(+), 9 deletions(-)
scripts/kallsyms.c +258 -9
@@ -85,6 +85,17 @@ static unsigned int strhash(const char *s)return hash; } +static unsigned int memhash (char *s,size_t len) +{ +/* fnv32 hash */ +unsigned int hash =2166136261U ; +size_t i; + +for (i =0 ; i < len; i++) + hash = (hash ^ *(s + i)) *0x01000193 ; +return hash; +} +#define OBJ2MOD_BITS 10#define OBJ2MOD_N (1 << OBJ2MOD_BITS)#define OBJ2MOD_MASK (OBJ2MOD_N - 1)
@@ -94,14 +105,24 @@ struct obj2mod_elem {size_t nmods;/* number of modules in "mods" */ size_t mods_size;/* size of all mods together */ int mod_offset;/* offset in .kallsyms_module_names */ +/* +* If set at emission time, this points at another obj2mod entry that +* contains the module name we need (possibly at a slightly later +* offset, if the entry is for an objfile that appears in many modules). +*/ +struct obj2mod_elem *xref;struct obj2mod_elem *obj2mod_next; +struct obj2mod_elem *mod2obj_next; };/* -* Map from object files to obj2mod entries (a unique mapping). +* Map from object files to obj2mod entries (a unique mapping), and vice versa +* (not unique, but entries for objfiles in more than one module in this hash +* are ignored). */ static struct obj2mod_elem *obj2mod[OBJ2MOD_N ]; +static struct obj2mod_elem *mod2obj[OBJ2MOD_N ];static size_t num_objfiles;/*
@@ -143,6 +164,8 @@ static void obj2mod_add(char *obj, char *mod) elem =obj2mod_get (obj);if (!elem) { +int j =strhash (mod) &OBJ2MOD_MASK ; + elem =malloc (sizeof (struct obj2mod_elem ));if (!elem) goto oom;
@@ -156,8 +179,15 @@ static void obj2mod_add(char *obj, char *mod) elem->obj2mod_next = obj2mod[i]; obj2mod[i] = elem; + elem->mod2obj_next = mod2obj[j]; + mod2obj[j] = elem; num_objfiles++; }else { +/* +* TU appears in multiple modules. mod2obj for this entry will +* be ignored from now on, except insofar as it is needed to +* maintain the hash chain. +*/ elem->mods =realloc (elem->mods, elem->mods_size +strlen (mod) +1 );if (!elem->mods)
@@ -177,6 +207,164 @@ static void obj2mod_add(char *obj, char *mod)fprintf (stderr,"kallsyms: out of memory\n" ); exit(1); } + +/* +* Used inside optimize_obj2mod to identify duplicate module entries. +*/ +struct obj2mod_modhash_elem { +struct obj2mod_elem *elem; +unsigned int modhash;/* hash value of this entry */ +}; + +static int qstrcmp (const void *a,const void *b) +{ +return strcmp ((const char *) a, (const char *) b); +} + +static int qmodhash (const void *a,const void *b) +{ +const struct obj2mod_modhash_elem *el_a = a; +const struct obj2mod_modhash_elem *el_b = b; +if (el_a->modhash < el_b->modhash) +return -1 ; +else if (el_a->modhash > el_b->modhash) +return 1 ; +return 0 ; +} + +/* +* Associate all TUs in obj2mod which refer to the same module with a single +* obj2mod entry for emission, preferring to point into the module list in a +* multi-module objfile. +*/ +static void optimize_obj2mod (void ) +{ +size_t i; +size_t n =0 ; +struct obj2mod_elem *elem; +struct obj2mod_elem *dedup; +/* An array of all obj2mod_elems, later sorted by hashval. */ +struct obj2mod_modhash_elem *uniq; +struct obj2mod_modhash_elem *last; + +/* +* Canonicalize all module lists by sorting them, then compute their +* hash values. +*/ + uniq =malloc (sizeof (struct obj2mod_modhash_elem ) * num_objfiles); +if (uniq ==NULL ) + goto oom; + +for (i =0 ; i <OBJ2MOD_N ; i++) { +for (elem = obj2mod[i]; elem; elem = elem->obj2mod_next) { +if (elem->nmods >=2 ) { +char **sorter; +char *walk; +char *tmp_mods; +size_t j; + + tmp_mods =malloc (elem->mods_size); + sorter =malloc (sizeof (char *) * elem->nmods); +if (sorter ==NULL || tmp_mods ==NULL ) + goto oom; +memcpy (tmp_mods, elem->mods, elem->mods_size); + +for (j =0 , walk = tmp_mods; j < elem->nmods; + j++) { + sorter[j] = walk; + walk +=strlen (walk) +1 ; + } +qsort (sorter, elem->nmods,sizeof (char *), + qstrcmp); +for (j =0 , walk = elem->mods; j < elem->nmods; + j++) { +strcpy (walk, sorter[j]); + walk +=strlen (walk) +1 ; + } +free (tmp_mods); +free (sorter); + } + + uniq[n].elem = elem; + uniq[n].modhash =memhash (elem->mods, elem->mods_size); + n++; + } + } + +qsort (uniq, num_objfiles,sizeof (struct obj2mod_modhash_elem ), + qmodhash); + +/* +* Work over multimodule entries. These must be emitted into +* .kallsyms_module_names as a unit, but we can still optimize by +* reusing some other identical entry. Single-file modules are amenable +* to the same optimization, but we avoid doing it for now so that we +* can prefer to point them directly inside a multimodule entry. +*/ +for (i =0 , last =NULL ; i < num_objfiles; i++) { +const char *onemod; +size_t j; + +if (uniq[i].elem->nmods <2 ) +continue ; + +/* Duplicate multimodule. Reuse the first we saw. */ +if (last !=NULL && last->modhash == uniq[i].modhash) { + uniq[i].elem->xref = last->elem; +continue ; + } + +/* +* Single-module entries relating to modules also emitted as +* part of this multimodule entry can refer to it: later, we +* will hunt down the right specific module name within this +* multimodule entry and point directly to it. +*/ + onemod = uniq[i].elem->mods; +for (j = uniq[i].elem->nmods; j >0 ; j--) { +int h =strhash (onemod) &OBJ2MOD_MASK ; + +for (dedup = mod2obj[h]; dedup; + dedup = dedup->mod2obj_next) { +if (dedup->nmods >1 ) +continue ; + +if (strcmp (dedup->mods, onemod) !=0 ) +continue ; + dedup->xref = uniq[i].elem; +assert (uniq[i].elem->xref ==NULL ); + } + onemod +=strlen (onemod) +1 ; + } + + last = &uniq[i]; + } + +/* +* Now traverse all single-module entries, xreffing every one that +* relates to a given module to the first one we saw that refers to that +* module. +*/ +for (i =0 , last =NULL ; i < num_objfiles; i++) { +if (uniq[i].elem->nmods >1 ) +continue ; + +if (uniq[i].elem->xref !=NULL ) +continue ; + +/* Duplicate module name. Reuse the first we saw. */ +if (last !=NULL && last->modhash == uniq[i].modhash) { + uniq[i].elem->xref = last->elem; +assert (last->elem->xref ==NULL ); +continue ; + } + last = &uniq[i]; + } +return ; +oom: +fprintf (stderr,"kallsyms: out of memory optimizing module list\n" ); +exit (EXIT_FAILURE ); +}#endif /* CONFIG_KALLMODSYMS */ static void usage (void )
@@ -479,7 +667,7 @@ static void output_kallmodsyms_modules(void)size_t i;/* -* Traverse and emit, updating mod_offset accordingly. +* Traverse and emit, chasing xref and updating mod_offset accordingly. * Emit a single \0 at the start, to encode non-modular objfiles. */ output_label ("kallsyms_module_names" );
@@ -489,9 +677,15 @@ static void output_kallmodsyms_modules(void) elem = elem->obj2mod_next) {const char *onemod;size_t i; +struct obj2mod_elem *out_elem = elem; - elem->mod_offset = offset; - onemod = elem->mods; +if (elem->xref) + out_elem = elem->xref; +if (out_elem->mod_offset !=0 ) +continue ;/* Already emitted. */ + + out_elem->mod_offset = offset; + onemod = out_elem->mods;/* * Technically this is a waste of space: we could just
@@ -500,13 +694,13 @@ static void output_kallmodsyms_modules(void)* entry, but doing it this way makes it more obvious * when an entry is a multimodule entry. */ -if (elem->nmods !=1 ) { +if (out_elem->nmods !=1 ) {printf ("\t.byte\t0\n" ); -printf ("\t.byte\t%zi\n" , elem->nmods); +printf ("\t.byte\t%zi\n" , out_elem->nmods); offset +=2 ; } -for (i = elem->nmods; i >0 ; i--) { +for (i = out_elem->nmods; i >0 ; i--) {printf ("\t.asciz\t\"%s\"\n" , onemod); offset +=strlen (onemod) +1 ; onemod +=strlen (onemod) +1 ;
@@ -533,6 +727,13 @@ static void output_kallmodsyms_objfiles(void)long long offset;int overflow; +/* +* Fuse consecutive address ranges citing the same object file +* into one. +*/ +if (i >0 && addrmap[i-1 ].objfile == addrmap[i].objfile) +continue ; +if (base_relative) {if (!absolute_percpu) { offset = addrmap[i].addr - relative_base;
@@ -558,6 +759,13 @@ static void output_kallmodsyms_objfiles(void)for (i =0 ; i < addrmap_num; i++) {struct obj2mod_elem *elem = addrmap[i].objfile; +int orig_nmods; +const char *orig_modname; +int mod_offset; + +if (i >0 && addrmap[i-1 ].objfile == addrmap[i].objfile) +continue ; +/* * Address range cites no object file: point at 0, the built-in * module.
@@ -568,13 +776,53 @@ static void output_kallmodsyms_objfiles(void)continue ; } + orig_nmods = elem->nmods; + orig_modname = elem->mods; + +/* +* Chase down xrefs, if need be. There can only be one layer of +* these: from single-module entry to other single-module entry, +* or from single- or multi-module entry to another multi-module +* entry. Single -> single and multi -> multi always points at +* the start of the xref target, so its offset can be used as is. +*/ +if (elem->xref) + elem = elem->xref; + +if (elem->nmods ==1 || orig_nmods >1 ) + mod_offset = elem->mod_offset; +else { +/* +* If this is a reference from a single-module entry to +* a multi-module entry, hunt down the offset to this +* specific module's name (which is guaranteed to be +* present: see optimize_obj2mod). +*/ + +size_t j = elem->nmods; +const char *onemod = elem->mods; + mod_offset = elem->mod_offset; + +for (; j >0 ; j--) { +if (strcmp (orig_modname, onemod) ==0 ) +break ; + onemod +=strlen (onemod) +1 ; + } +assert (j >0 ); +/* +* +2 to skip the null byte and count at the start of +* the multimodule entry. +*/ + mod_offset += onemod - elem->mods +2 ; + } +/* * Zero offset is the initial \0, there to catch uninitialized * obj2mod entries, and is forbidden. */ -assert (elem->mod_offset !=0 ); +assert (mod_offset !=0 ); -printf ("\t.long\t0x%x\n" , elem->mod_offset); +printf ("\t.long\t0x%x\n" , mod_offset); emitted_objfiles++; }
@@ -1093,6 +1341,7 @@ static void read_modules(const char *modules_builtin)free (module_name);modules_thick_iter_free (i); +optimize_obj2mod ();/* * Read linker map.
Signature · 1 line
2.33.0.256.gb827f06fa9
PATCH v5 6/7 kallsyms: add /proc/kallmodsyms
In reply to Nick AlcockUse the tables added in the previous commits to introduce a new /proc/kallmodsyms, in which [module names] are also given for things that *could* have been modular had they not been built in to the kernel. So symbols that are part of, say, ext4 are reported as [ext4] even if ext4 happens to be buiilt in to the kernel in this configuration.
Symbols that are part of multiple modules at the same time are shown with [multiple] [module names]: consumers will have to be ready to handle such lines. Also, kernel symbols for built-in modules will be sorted by size, as usual for the core kernel, so will probably appear interspersed with other symbols that are part of different modules and non-modular always-built-in symbols, which, as usual, have no square-bracketed module denotation. This differs from /proc/kallsyms, where all symbols associated with a module will always appear in a group (and randomly ordered).
The result looks like this:
ffffffff8b013d20 t pt_buffer_setup_aux ffffffff8b014130 T intel_pt_interrupt ffffffff8b014250 T cpu_emergency_stop_ptffffffff8b014280 t rapl_pmu_event_init [intel_rapl_perf]ffffffff8b0143c0 t rapl_event_update [intel_rapl_perf]ffffffff8b014480 t rapl_pmu_event_read [intel_rapl_perf]ffffffff8b014490 t rapl_cpu_offline [intel_rapl_perf] ffffffff8b014540 t __rapl_event_show [intel_rapl_perf]ffffffff8b014570 t rapl_pmu_event_stop [intel_rapl_perf]
This is emitted even if intel_rapl_perf is built into the kernel (but, obviously, not if it's not in the .config at all, or is in a module that is not loaded).
Further down, we see what happens when object files are reused by multiple modules, all of which are built in to the kernel:
ffffffffa22b3aa0 t handle_timestamp [liquidio]ffffffffa22b3b50 t free_netbuf [liquidio]ffffffffa22b3ba0 t liquidio_ptp_settime [liquidio]ffffffffa22b3c30 t liquidio_ptp_adjfreq [liquidio]
[...]ffffffffa22b9490 t lio_vf_rep_create [liquidio]ffffffffa22b96a0 t lio_vf_rep_destroy [liquidio]ffffffffa22b9810 t lio_vf_rep_modinit [liquidio]ffffffffa22b9830 t lio_vf_rep_modexit [liquidio]ffffffffa22b9850 t lio_ethtool_get_channels [liquidio] [liquidio_vf]ffffffffa22b9930 t lio_ethtool_get_ringparam [liquidio] [liquidio_vf]ffffffffa22b99d0 t lio_get_msglevel [liquidio] [liquidio_vf]ffffffffa22b99f0 t lio_vf_set_msglevel [liquidio] [liquidio_vf]ffffffffa22b9a10 t lio_get_pauseparam [liquidio] [liquidio_vf]ffffffffa22b9a40 t lio_get_ethtool_stats [liquidio] [liquidio_vf]ffffffffa22ba180 t lio_vf_get_ethtool_stats [liquidio] [liquidio_vf]ffffffffa22ba4f0 t lio_get_regs_len [liquidio] [liquidio_vf]ffffffffa22ba530 t lio_get_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba550 t lio_set_priv_flags [liquidio] [liquidio_vf]ffffffffa22ba580 t lio_set_fecparam [liquidio] [liquidio_vf]ffffffffa22ba5f0 t lio_get_fecparam [liquidio] [liquidio_vf]
[...]ffffffffa22cbd10 t liquidio_set_mac [liquidio_vf] ffffffffa22cbe90 t handle_timestamp [liquidio_vf]ffffffffa22cbf40 t free_netbuf [liquidio_vf]ffffffffa22cbf90 t octnet_link_status_change [liquidio_vf]ffffffffa22cbfc0 t liquidio_vxlan_port_command.constprop.0 [liquidio_vf]
Like /proc/kallsyms, the output is driven by address, so keeps the curious property of /proc/kallsyms that symbols (like free_netbuf above) may appear repeatedly with different addresses: but now, unlike in /proc/kallsyms, we can see that those symbols appear repeatedly because they are *different symbols* that ultimately belong to different modules, all of which are built in to the kernel.
As with /proc/kallsyms, non-root usage produces addresses that are all zero.
I am not wedded to the name or format of /proc/kallmodsyms, but felt it best to split it out of /proc/kallsyms to avoid breaking existing kallsyms parsers. Another possible syntax might be to use {curly brackets} or something to denote built-in modules: it might be possible to drop /proc/kallmodsyms and make /proc/kallsyms emit things in this format. (Equally, now kallmodsyms data uses very little space, the CONFIG_KALLMODSYMS config option might be something people don't want to bother with.)
Internally, this uses a new kallsyms_builtin_module_address() almost identical to kallsyms_sym_address() to get the address corresponding to a given .kallsyms_modules index, and a new get_builtin_module_idx quite similar to get_symbol_pos to determine the index in the .kallsyms_modules array that relates to a given address. Save a little time by exploiting the fact that all callers will only ever traverse this list from start to end by allowing them to pass in the previous index returned from this function as a hint: thus very few bsearches are actually needed. (In theory this could change to just walk straight down kallsyms_module_addresses/offsets and not bother bsearching at all, but doing it this way is hardly any slower and much more robust.)
The display process is complicated a little by the weird format of the .kallsyms_module_names table: we have to look for multimodule entries and print them as space-separated lists of module names.
--- kernel/kallsyms.c | 242 +++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 227 insertions(+), 15 deletions(-)
kernel/kallsyms.c +227 -15
@@ -48,8 +48,18 @@ __section(".rodata") __attribute__((weak));extern const unsigned long kallsyms_relative_base __section(".rodata") __attribute__((weak)); +extern const unsigned long kallsyms_num_modules +__section(".rodata") __attribute__((weak)); + +extern const unsigned long kallsyms_module_names_len +__section(".rodata") __attribute__((weak)); +extern const char kallsyms_token_table[]__weak ;extern const u16 kallsyms_token_index[]__weak ; +extern const unsigned long kallsyms_module_addresses[]__weak ; +extern const int kallsyms_module_offsets[]__weak ; +extern const u32 kallsyms_modules[]__weak ; +extern const char kallsyms_module_names[]__weak ;extern const unsigned int kallsyms_markers[]__weak ;
@@ -185,6 +195,25 @@ static inline bool cleanup_symbol_name(char *s)static inline bool cleanup_symbol_name (char *s) {return false; }#endif +#ifdef CONFIG_KALLMODSYMS +static unsigned long kallsyms_builtin_module_address (int idx) +{ +if (!IS_ENABLED (CONFIG_KALLSYMS_BASE_RELATIVE )) +return kallsyms_module_addresses[idx]; + +/* values are unsigned offsets if --absolute-percpu is not in effect */ +if (!IS_ENABLED (CONFIG_KALLSYMS_ABSOLUTE_PERCPU )) +return kallsyms_relative_base + (u32 )kallsyms_module_offsets[idx]; + +/* ...otherwise, positive offsets are absolute values */ +if (kallsyms_module_offsets[idx] >=0 ) +return kallsyms_module_offsets[idx]; + +/* ...and negative offsets are relative to kallsyms_relative_base - 1 */ +return kallsyms_relative_base -1 - kallsyms_module_offsets[idx]; +} +#endif +/* Lookup the address for this symbol. Returns 0 if not found. */ unsigned long kallsyms_lookup_name (const char *name) {
@@ -288,6 +317,54 @@ static unsigned long get_symbol_pos(unsigned long addr,return low; } +/* +* The caller passes in an address, and we return an index to the corresponding +* builtin module index in .kallsyms_modules, or (unsigned long) -1 if none +* match. +* +* The hint_idx, if set, is a hint as to the possible return value, to handle +* the common case in which consecutive runs of addresses relate to the same +* index. +*/ +#ifdef CONFIG_KALLMODSYMS +static unsigned long get_builtin_module_idx (unsigned long addr,unsigned long hint_idx) +{ +unsigned long low, high, mid; + +if (!IS_ENABLED (CONFIG_KALLSYMS_BASE_RELATIVE )) +BUG_ON (!kallsyms_module_addresses); +else +BUG_ON (!kallsyms_module_offsets); + +/* +* Do a binary search on the sorted kallsyms_modules array. The last +* entry in this array indicates the end of the text section, not an +* object file. +*/ + low =0 ; + high = kallsyms_num_modules -1 ; + +if (hint_idx > low && hint_idx < (high -1 ) && + addr >=kallsyms_builtin_module_address (hint_idx) && + addr <kallsyms_builtin_module_address (hint_idx +1 )) +return hint_idx; + +if (addr >=kallsyms_builtin_module_address (low) + && addr <kallsyms_builtin_module_address (high)) { +while (high - low >1 ) { + mid = low + (high - low) /2 ; +if (kallsyms_builtin_module_address (mid) <= addr) + low = mid; +else + high = mid; + } +return low; + } + +return (unsigned long )-1 ; +} +#endif +/* * Lookup an address but don't bother to find any names. */
@@ -559,6 +636,8 @@ struct kallsym_iter {char type;char name[KSYM_NAME_LEN ];char module_name[MODULE_NAME_LEN ]; +const char *builtin_module_names; +unsigned long hint_builtin_module_idx;int exported;int show_value; };
@@ -589,6 +668,8 @@ static int get_ksymbol_mod(struct kallsym_iter *iter) &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported); + iter->builtin_module_names =NULL ; +if (ret <0 ) { iter->pos_mod_end = iter->pos;return 0 ;
@@ -608,6 +689,8 @@ static int get_ksymbol_ftrace_mod(struct kallsym_iter *iter) &iter->value, &iter->type, iter->name, iter->module_name, &iter->exported); + iter->builtin_module_names =NULL ; +if (ret <0 ) { iter->pos_ftrace_mod_end = iter->pos;return 0 ;
@@ -622,6 +705,7 @@ static int get_ksymbol_bpf(struct kallsym_iter *iter)strlcpy (iter->module_name,"bpf" ,MODULE_NAME_LEN ); iter->exported =0 ; + iter->builtin_module_names =NULL ; ret =bpf_get_kallsym (iter->pos - iter->pos_ftrace_mod_end, &iter->value, &iter->type, iter->name);
@@ -642,23 +726,53 @@ static int get_ksymbol_kprobe(struct kallsym_iter *iter) {strlcpy (iter->module_name,"__builtin__kprobes" ,MODULE_NAME_LEN ); iter->exported =0 ; + iter->builtin_module_names =NULL ;return kprobe_get_kallsym (iter->pos - iter->pos_bpf_end, &iter->value, &iter->type, iter->name) <0 ?0 :1 ; }/* Returns space to next name. */ -static unsigned long get_ksymbol_core (struct kallsym_iter *iter) +static unsigned long get_ksymbol_core (struct kallsym_iter *iter,int kallmodsyms) {unsigned off = iter->nameoff; - iter->module_name[0 ] ='\0' ; + iter->exported =0 ; iter->value =kallsyms_sym_address (iter->pos); iter->type =kallsyms_get_symbol_type (off); + iter->module_name[0 ] ='\0' ; + iter->builtin_module_names =NULL ; + off =kallsyms_expand_symbol (off, iter->name,ARRAY_SIZE (iter->name)); +#ifdef CONFIG_KALLMODSYMS +if (kallmodsyms) { +unsigned long mod_idx = (unsigned long )-1 ; + +if (kallsyms_module_offsets) + mod_idx = +get_builtin_module_idx (iter->value, + iter->hint_builtin_module_idx); +/* +* This is a built-in module iff the tables of built-in modules +* (address->module name mappings) and module names are known, +* and if the address was found there, and if the corresponding +* module index is nonzero. All other cases mean off the end of +* the binary or in a non-modular range in between one or more +* modules. (Also guard against a corrupt kallsyms_objfiles +* array pointing off the end of kallsyms_modules.) +*/ +if (kallsyms_modules !=NULL && kallsyms_module_names !=NULL && + mod_idx != (unsigned long )-1 && + kallsyms_modules[mod_idx] !=0 && + kallsyms_modules[mod_idx] < kallsyms_module_names_len) + iter->builtin_module_names = + &kallsyms_module_names[kallsyms_modules[mod_idx]]; + iter->hint_builtin_module_idx = mod_idx; + } +#endif return off - iter->nameoff; }
@@ -704,7 +818,7 @@ static int update_iter_mod(struct kallsym_iter *iter, loff_t pos) }/* Returns false if pos at or past end of file. */ -static int update_iter (struct kallsym_iter *iter,loff_t pos) +static int update_iter (struct kallsym_iter *iter,loff_t pos,int kallmodsyms) {/* Module symbols can be accessed randomly. */ if (pos >= kallsyms_num_syms)
@@ -714,7 +828,7 @@ static int update_iter(struct kallsym_iter *iter, loff_t pos)if (pos != iter->pos)reset_iter (iter, pos); - iter->nameoff +=get_ksymbol_core (iter); + iter->nameoff +=get_ksymbol_core (iter, kallmodsyms); iter->pos++;return 1 ;
@@ -724,14 +838,14 @@ static void *s_next(struct seq_file *m, void *p, loff_t *pos) { (*pos)++; -if (!update_iter (m->private, *pos)) +if (!update_iter (m->private, *pos,0 ))return NULL ;return p; }static void *s_start (struct seq_file *m,loff_t *pos) { -if (!update_iter (m->private, *pos)) +if (!update_iter (m->private, *pos,0 ))return NULL ;return m->private; }
@@ -740,7 +854,7 @@ static void s_stop(struct seq_file *m, void *p) { } -static int s_show (struct seq_file *m,void *p) +static int s_show_internal (struct seq_file *m,void *p,int kallmodsyms) {void *value;struct kallsym_iter *iter = m->private;
@@ -751,23 +865,67 @@ static int s_show(struct seq_file *m, void *p) value = iter->show_value ? (void *)iter->value :NULL ; -if (iter->module_name[0 ]) { +/* +* Real module, or built-in module and /proc/kallsyms being shown. +*/ +if (iter->module_name[0 ] !='\0' || + (iter->builtin_module_names !=NULL && kallmodsyms !=0 )) {char type;/* -* Label it "global" if it is exported, -* "local" if not exported. +* Label it "global" if it is exported, "local" if not exported. */ type = iter->exported ?toupper (iter->type) :tolower (iter->type); -seq_printf (m,"%px %c %s\t[%s]\n" , value, - type, iter->name, iter->module_name); +#ifdef CONFIG_KALLMODSYMS +if (kallmodsyms) { +/* +* /proc/kallmodsyms, built as a module. +*/ +if (iter->builtin_module_names ==NULL ) +seq_printf (m,"%px %c %s\t[%s]\n" , value, + type, iter->name, + iter->module_name); +/* +* /proc/kallmodsyms, single-module symbol. +*/ +else if (*iter->builtin_module_names !='\0' ) +seq_printf (m,"%px %c %s\t[%s]\n" , value, + type, iter->name, + iter->builtin_module_names); +/* +* /proc/kallmodsyms, multimodule symbol. Formatted +* as \0MODULE_COUNTmodule-1\0module-2\0, where +* MODULE_COUNT is a single byte, 2 or higher. +*/ +else { +size_t i = *(char *)(iter->builtin_module_names +1 ); +const char *walk = iter->builtin_module_names +2 ; + +seq_printf (m,"%px %c %s\t[%s]" , value, + type, iter->name, walk); + +while (--i >0 ) { + walk +=strlen (walk) +1 ; +seq_printf (m," [%s]" , walk); + } +seq_printf (m,"\n" ); + } + } else /* !kallmodsyms */ +#endif /* CONFIG_KALLMODSYMS */ +seq_printf (m,"%px %c %s\t[%s]\n" , value, + type, iter->name, iter->module_name); }else seq_printf (m,"%px %c %s\n" , value, iter->type, iter->name);return 0 ; } +static int s_show (struct seq_file *m,void *p) +{ +return s_show_internal (m, p,0 ); +} +static const struct seq_operations kallsyms_op = { .start = s_start, .next = s_next,
@@ -775,6 +933,35 @@ static const struct seq_operations kallsyms_op = { .show = s_show }; +#ifdef CONFIG_KALLMODSYMS +static int s_mod_show (struct seq_file *m,void *p) +{ +return s_show_internal (m, p,1 ); +} +static void *s_mod_next (struct seq_file *m,void *p,loff_t *pos) +{ + (*pos)++; + +if (!update_iter (m->private, *pos,1 )) +return NULL ; +return p; +} + +static void *s_mod_start (struct seq_file *m,loff_t *pos) +{ +if (!update_iter (m->private, *pos,1 )) +return NULL ; +return m->private; +} + +static const struct seq_operations kallmodsyms_op = { + .start = s_mod_start, + .next = s_mod_next, + .stop = s_stop, + .show = s_mod_show +}; +#endif +static inline int kallsyms_for_perf (void ) {#ifdef CONFIG_PERF_EVENTS
@@ -810,7 +997,8 @@ bool kallsyms_show_value(const struct cred *cred) } } -static int kallsyms_open (struct inode *inode,struct file *file) +static int kallsyms_open_internal (struct inode *inode,struct file *file, +const struct seq_operations *ops) {/* * We keep iterator in m->private, since normal case is to
@@ -818,7 +1006,7 @@ static int kallsyms_open(struct inode *inode, struct file *file)* using get_symbol_offset for every symbol. */ struct kallsym_iter *iter; - iter =__seq_open_private (file, &kallsyms_op,sizeof (*iter)); + iter =__seq_open_private (file, ops,sizeof (*iter));if (!iter)return -ENOMEM ;reset_iter (iter,0 );
@@ -831,6 +1019,18 @@ static int kallsyms_open(struct inode *inode, struct file *file)return 0 ; } +static int kallsyms_open (struct inode *inode,struct file *file) +{ +return kallsyms_open_internal (inode, file, &kallsyms_op); +} + +#ifdef CONFIG_KALLMODSYMS +static int kallmodsyms_open (struct inode *inode,struct file *file) +{ +return kallsyms_open_internal (inode, file, &kallmodsyms_op); +} +#endif +#ifdef CONFIG_KGDB_KDB const char *kdb_walk_kallsyms (loff_t *pos) {
@@ -841,7 +1041,7 @@ const char *kdb_walk_kallsyms(loff_t *pos)reset_iter (&kdb_walk_kallsyms_iter,0 ); }while (1 ) { -if (!update_iter (&kdb_walk_kallsyms_iter, *pos)) +if (!update_iter (&kdb_walk_kallsyms_iter, *pos,0 ))return NULL ; ++*pos;/* Some debugging symbols have no name. Ignore them. */
@@ -858,9 +1058,21 @@ static const struct proc_ops kallsyms_proc_ops = { .proc_release = seq_release_private, }; +#ifdef CONFIG_KALLMODSYMS +static const struct proc_ops kallmodsyms_proc_ops = { + .proc_open = kallmodsyms_open, + .proc_read = seq_read, + .proc_lseek = seq_lseek, + .proc_release = seq_release_private, +}; +#endif +static int __init kallsyms_init (void ) {proc_create ("kallsyms" ,0444 ,NULL , &kallsyms_proc_ops); +#ifdef CONFIG_KALLMODSYMS +proc_create ("kallmodsyms" ,0444 ,NULL , &kallmodsyms_proc_ops); +#endif return 0 ; }device_initcall (kallsyms_init);
Signature · 1 line
2.33.0.256.gb827f06fa9
kernel test robot
build botRe: [PATCH v5 6/7] kallsyms: add /proc/kallmodsyms
Thank you for the patch! Perhaps something to improve:
Hi Nick,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on linux/master]
[also build test WARNING on linus/master v5.15-rc7]
[cannot apply to jeyu/modules-next masahiroy/kconfig next-20211027] [If your patch is applied to the wrong git tree, kindly drop us a note. And when submitting patch, we suggest to use '--base' as documented in
https://git-scm.com/docs/git-format-patch]
url: https://github.com/0day-ci/linux/commits/Nick-Alcock/kbuild-bring-back-tristate-conf/20211028-024948 base: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 2f111a6fd5b5297b4e92f53798ca086f7c7d33a4 config: hexagon-randconfig-r041-20211027 (attached as .config) compiler: clang version 14.0.0 (https://github.com/llvm/llvm-project 5db7568a6a1fcb408eb8988abdaff2a225a8eb72)
reproduce (this is a W=1 build):
wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross
# https://github.com/0day-ci/linux/commit/3e2ed787d495a82851cad4d99a369524140966ae
git remote add linux-review https://github.com/0day-ci/linux
git fetch --no-tags linux-review Nick-Alcock/kbuild-bring-back-tristate-conf/20211028-024948 git checkout 3e2ed787d495a82851cad4d99a369524140966ae
# save the attached .config to linux build tree
COMPILER_INSTALL_PATH=$HOME/0day COMPILER=clang make.cross W=1 ARCH=hexagon
If you fix the issue, kindly add following tag as appropriate
All warnings (new ones prefixed by >>):
kernel/kallsyms.c:645:12: warning: no previous prototype for function 'arch_get_kallsym' [-Wmissing-prototypes] int __weak arch_get_kallsym(unsigned int symnum, unsigned long *value,
^
kernel/kallsyms.c:645:1: note: declare 'static' if the function is not intended to be used outside of this translation unit
int __weak arch_get_kallsym(unsigned int symnum, unsigned long *value,
^
static
kernel/kallsyms.c:1054:30: warning: unused variable 'kallsyms_proc_ops' [-Wunused-const-variable]
static const struct proc_ops kallsyms_proc_ops = {
^
>> kernel/kallsyms.c:1062:30: warning: unused variable 'kallmodsyms_proc_ops' [-Wunused-const-variable]
static const struct proc_ops kallmodsyms_proc_ops = {
^3 warnings generated.
vim +/kallmodsyms_proc_ops +1062 kernel/kallsyms.c
1060
1061 #ifdef CONFIG_KALLMODSYMS
> 1062 static const struct proc_ops kallmodsyms_proc_ops = { 1063 .proc_open = kallmodsyms_open,
1064 .proc_read = seq_read,
1065 .proc_lseek = seq_lseek,
1066 .proc_release = seq_release_private,
1067 };
1068 #endif
1069
---
0-DAY CI Kernel Test Service, Intel Corporation
https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org
Re: [PATCH v5 6/7] kallsyms: add /proc/kallmodsyms
For reference, and to be maximally pedantic:
Quoted 3 lines · kernel test robot
Hi Nick,
Thank you for the patch! Perhaps something to improve:
Nope! This is a (very small) flaw in the !CONFIG_PROC_FS case in include/linux/proc_fs.h. (I don't think one can seriously call it a *bug*, as such.)
It's not a problem in this patch.
Quoted 1 line
config: hexagon-randconfig-r041-20211027 (attached as .config)
This config includes:
# CONFIG_PROC_FS is not set
Quoted 1 line
All warnings (new ones prefixed by >>):
[unrelated warnings snipped]
Quoted 4 lines
static
kernel/kallsyms.c:1054:30: warning: unused variable 'kallsyms_proc_ops' [-Wunused-const-variable]
static const struct proc_ops kallsyms_proc_ops = {
^This warning already existed (and doubtless countless others just like it all over the tree in this configuration). This is because proc_create(), in the !CONFIG_PROC_FS case, is a #define that just does
nothing: so the compiler can see that none of its args are used, and will complain about those that have no other references. The proc_ops is almost certainly going to be one such.
The new warning is just the same:
Quoted 4 lines
Quoted 1 line
Quoted 1 line
kernel/kallsyms.c:1062:30: warning: unused variable 'kallmodsyms_proc_ops' [-Wunused-const-variable]static const struct proc_ops kallmodsyms_proc_ops = { ^3 warnings generated.
The kallmodsyms_proc_ops is obviously doing the same thing as kallsyms_proc_ops (because it has to), so it gets the same warning.
Short of wrapping every single declaration of a proc_ops structure, and every call to proc_create, in #ifdef CONFIG_PROC_FS (which is obviously gross and exactly the thing the macro in proc_fs.h is intended to avoid), there is no way of fixing this warning on its own: it must be fixed in proc_fs.h. (Perhaps by making a bunch of those macros into functions with __attribute__((__unused__)) attached to appropriate args.)
Signature · 1 line
NULL && (void)
PATCH v5 7/7 kallsyms: add reliable symbol size info
In reply to Nick AlcockThe existing mechanisms in get_symbol_pos to determine the end of a symbol is an inaccurate heuristic. By passing nm -S output into scripts/kallsyms.c and writing the symbol sizes to a new .kallsyms_sizes section, we can get accurate sizes and sort the symbols accordingly, reliably sorting zero-size symbols first (on the grounds that they are usually e.g. section markers, and other symbols at the same address are conceptually contained within them and should be sorted after them), then larger symbols before smaller ones (so that overlapping symbols print the containing symbol first, before its containees). We can also use this to improve aliased symbol detection.
Emit the size info as an extra column in /proc/kallmodsyms (since its format is not yet set in stone), and export it to iterator consumers.
The notable downside of this is that the new .kallsyms_sizes is pretty
big: a PTR per symbol, so vmlinux.o grows by almost a megabyte, though it compresses pretty well, so bzImage grows by only a megabyte.
I'm not sure how to reduce this (perhaps using an array with elements sized to be no larger than needed for the contents, so that almost always two-byte entries would do? except that in my test kernel two symbols are bigger than this: sme_workarea, at 400K, and __log_buf, at 100K: the latter seems often likely to be larger than 64K). A simple scheme to reduce this would be to split the sizes array into several arrays with differently-sized elements, and run-length-compress away the zero bytes -- but that's not implemented yet, and might never be if people think the whole idea of this is pointless.
In the absence of a way to shrink things, this should probably be hidden behind a new config symbol if exposed at all, and kallmodsyms just shows zero sizes if it's configured out (but this is enough of an RFC that that's not yet done: possibly the benefits of this are too marginal to be worth it, even if they do let kall(mod)syms consumers distinguish symbols from padding, which was previously impossible).
--- include/linux/module.h | 7 ++-- kernel/kallsyms.c | 74 ++++++++++++++++++++++------------------- kernel/module.c | 4 ++- scripts/kallsyms.c | 29 +++++++++++++--- scripts/link-vmlinux.sh | 7 +++- 5 files changed, 77 insertions(+), 44 deletions(-)
include/linux/module.h +4 -3
@@ -590,7 +590,8 @@ struct module *find_module(const char *name);/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if symnum out of range. */ int module_get_kallsym (unsigned int symnum,unsigned long *value,char *type, -char *name,char *module_name,int *exported); +char *name,char *module_name,unsigned long *size, +int *exported);/* Look for this name: can be of form module:name. */ unsigned long module_kallsyms_lookup_name (const char *name);
@@ -768,8 +769,8 @@ static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long * }static inline int module_get_kallsym (unsigned int symnum,unsigned long *value, -char *type,char *name, -char *module_name,int *exported) +char *type,char *name,char *module_name, +unsigned long *size,int *exported) {return -ERANGE ; }
kernel/kallsyms.c +39 -35
154 lines not on this page · raw message
kernel/module.c +3 -1
@@ -4368,7 +4368,8 @@ int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, }int module_get_kallsym (unsigned int symnum,unsigned long *value,char *type, -char *name,char *module_name,int *exported) +char *name,char *module_name,unsigned long *size, +int *exported) {struct module *mod;
@@ -4387,6 +4388,7 @@ int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,strlcpy (name,kallsyms_symbol_name (kallsyms, symnum),KSYM_NAME_LEN );strlcpy (module_name, mod->name,MODULE_NAME_LEN ); *exported =is_exported (name, *value, mod); + *size = kallsyms->symtab[symnum].st_size;preempt_enable ();return 0 ; }
scripts/kallsyms.c +25 -4
@@ -5,7 +5,7 @@* This software may be used and distributed according to the terms * of the GNU General Public License, incorporated herein by reference. * -* Usage: nm -n vmlinux +* Usage: nm -n -S vmlinux * | scripts/kallsyms [--all-symbols] [--absolute-percpu] * [--base-relative] [--builtin=modules_thick.builtin] * > symbols.S
@@ -38,6 +38,7 @@struct sym_entry {unsigned long long addr; +unsigned long long size;unsigned int len;unsigned int start_pos;unsigned int percpu_absolute;
@@ -394,6 +395,7 @@ static bool is_ignored_symbol(const char *name, char type)"kallsyms_addresses" ,"kallsyms_offsets" ,"kallsyms_relative_base" , +"kallsyms_sizes" ,"kallsyms_num_syms" ,"kallsyms_num_modules" , "kallsyms_names",
@@ -507,10 +509,11 @@ static struct sym_entry *read_symbol(FILE *in)unsigned long long addr;unsigned int len;struct sym_entry *sym; -int rc; +int rc =0 ; +unsigned long long size; - rc =fscanf (in,"%llx %c %499s\n" , &addr, &type, name); -if (rc !=3 ) { + rc =fscanf (in,"%llx %llx %c %499s\n" , &addr, &size, &type, name); +if (rc !=4 ) {if (rc !=EOF &&fgets (name,500 , in) ==NULL )fprintf (stderr,"Read error or end of file.\n" );return NULL ;
@@ -548,6 +551,7 @@ static struct sym_entry *read_symbol(FILE *in) sym->sym[0 ] = type;strcpy (sym_name (sym), name); sym->percpu_absolute =0 ; + sym->size = size;return sym; }
@@ -932,6 +936,11 @@ static void write_src(void)printf ("\n" ); } +output_label ("kallsyms_sizes" ); +for (i =0 ; i < table_cnt; i++) +printf ("\tPTR\t%#llx\n" , table[i]->size); +printf ("\n" ); +#ifdef CONFIG_KALLMODSYMS output_kallmodsyms_modules ();output_kallmodsyms_objfiles ();
@@ -1189,6 +1198,18 @@ static int compare_symbols(const void *a, const void *b)if (sa->addr < sb->addr)return -1 ; +/* zero-size markers before nonzero-size symbols */ +if (sa->size >0 && sb->size ==0 ) +return 1 ; +if (sa->size ==0 && sb->size >0 ) +return -1 ; + +/* sort by size (large size preceding symbols it encompasses) */ +if (sa->size < sb->size) +return 1 ; +if (sa->size > sb->size) +return -1 ; +/* sort by "weakness" type */ wa = (sa->sym[0 ] =='w' ) || (sa->sym[0 ] =='W' ); wb = (sb->sym[0 ] =='w' ) || (sb->sym[0 ] =='W' );
scripts/link-vmlinux.sh +6 -1
@@ -274,7 +274,12 @@ kallsyms() fi info KSYMS ${2} - ${NM} -n ${1} | scripts/kallsyms ${kallsymopt} > ${2} + # "nm -S" does not print symbol size when size is 0 + # Therefore use awk to regularize the data: + # - when there are only three fields, add an explicit "0" + # - when there are already four fields, pass through as is + ${NM} -n -S ${1} | ${AWK} 'NF==3 {print $1, 0, $2, $3}; NF==4' | \ + scripts/kallsyms ${kallsymopt} > ${2} } # Perform one step in kallsyms generation, including temporary linking of
Signature · 1 line
2.33.0.256.gb827f06fa9