alloc_tag: introduce IOCTL-based filtering for MAP
Subsystems (7)
v8 cover alloc_tag: introduce IOCTL-based filtering for MAP
Currently, memory allocation profiling data is primarily exposed through /proc/allocinfo. While useful for manual inspection, this text-based interface poses challenges for production monitoring and large-scale analysis:
1. Userspace must parse large amounts of text to extract specific fields.
2. To find specific tags, userspace must read the entire dataset, requiring many context switches and high data copying.
3. The kernel currently aggregates per-CPU counters for every allocation size, even those the user intends to filter out immediately.
This series introduces a new IOCTL-based binary interface for allocinfo that supports kernel-side filtering. By allowing the user to specify a filter mask, we significantly reduce the work performed in-kernel and the amount of data transferred to userspace. The IOCTL mechanism was chosen for allocinfo to address the per-CPU counter aggregation bottleneck. A traditional read() operation must report the total allocation count and sizes for every code tag in the system. Doing so requires iterating across all CPUs to sum their per-CPU counters for thousands of tags, which introduces substantial runtime overhead.
The IOCTL interface allows userspace to push selective filtering criteria directly into the kernel before the per-CPU counter aggregation. The kernel aggregates per-CPU counters only for a small subset of tags that match the filter. This results in significant performance improvement.
Beyond fast filtered retrieval, the IOCTL foundation allows introducing a context capture mechanism in the future to capture the context for specific allocations.
Performance measurements were conducted on an Intel Xeon Platinum 8481C (224 CPUs) with caches dropped before each run.
The IOCTL mechanism shows a ~20x performance improvement for filtered queries. The kernel avoids the expensive per-CPU counter aggregation (alloc_tag_read) for any tags that fail the initial string or location filters.
Scenario 1: Specific File Filtering (arch/x86/events/rapl.c)
1. Traditional (cat /proc/allocinfo | grep): 22ms (sys)
2. IOCTL Interface: 1ms (sys)
Scenario 2: Compound Filtering (Filename + Size)
1. Traditional: (cat ... | grep | awk): 21ms (sys)
2. IOCTL Interface: 1ms (sys)
Scenario 3: Size-Based Filtering (min_size = 1MB)
1. Traditional: (cat ... | awk): 21ms (sys)
2. IOCTL Interface: 14ms (sys)
v8 changes:
- Patch 6/6: Changed KSFT_FAIL to KSFT_SKIP for scenarios where the test cannot run because the kernel wasn't built withCONFIG_MEM_ALLOC_PROFILING.
v7 changes:
- Patch 5/6: Used $KHDR_INCLUDES in the kselftest Makefile. Replaced goto statetments with break in get_filtered_ioctl_entries function.
- Patch 6/6: In test_size_filter, added a verification step to validate the size of the found tag matches target_size. In test_lineno_filter,
improved the comment, and verified that ioctl retrieves the original tag that was used to record target_lineno.
v6 changes:
- Patch 1/6: Added comments explaining why last 64 characters are compared in the filter.
- Patch 3/6: Moved allocinfo_prefetch_counters outside of allocinfo_to_params
- Patch 5/6: Fixed fd leak in get_filtered_ioctl_entries() function. Added alloc_tag selftest to the top-level Makefile.
- Patch 6/6: Moved include for errno.h to this patch.
v5 changes:
- Patch 1/6: Added explicit mutex_destroy.
- Patch 5/6: Self-contained file descriptors to avoid wrap-around errors in retry loops.
- Patch 6/6: Fixed minor issues raised by sashiko in v4.
v4 changes:
- Patch 1/6: Fixed a copyright comment inside include/uapi/linux/alloc_tag.h
- Patch 3/6: Among other nits, fixed the inadvertent build failure introduced in v3.
- Patch 4/6: Included a comment stating that the accurate field in struct allocinfo_tag is only used for filtering.
- Patch 5/6: Modified test to trim prefix and keep suffix for entries with filenames exceeding the size limit.
- Patch 6/6: Modified test_size_filter such that if content_id changes between the moment when procfs and ioctl entries are read, both
entries are invalidated and re-fetched. Removed the tags->count == 0 check from test_lineno_filter as it's virtually unreachable.
v3 changes:
- Patch 1/6: Modified Documentation to indicate that map supports ioctl(). Modified struct allocinfo_count to use
__attribute__((aligned(8))) instead of manual padding. Removed redundance type-casting. Added comments for static functions in lib/alloc_tag.c. Introduced a new seq counter for content_id that gets bumped every time module is loaded / unloaded. Introduced logic to validate user specified position is not greater than number of allocation tags and return early if it is. Changed strscpy to strscpy_pad to not echo arbitrary user data back to the user.
- Patch 2/6: Handled the case where user wants to specifically filter for built-in modules. Included some comments for static functions.
- Patch 3/6: Modified logic to only fetch per-CPU counters for codetags that satisfy other filters. Included some comments for static
functions.
v2 changes:
- Patch 1/6: Introduced locking for m->private. Also included the new uapi header file in MAINTAINERS list.
- Patch 2/6: Handled the case where ALLOCINFO_FILTER_MASK_MODNAME is passed but ct->modname is NULL.
- Patch 3/6: Moved min_size and max_size outside of struct allocinfo_tag into struct allocinfo_filter. Added validation that min_size <= max_size. Prefetched alloc_tag_counters if size based filter masks are provided to avoid assimilating per-cpu counters twice.
- Patch 5/6: Removed the hardcoded logic to skip the header, instead the test will skip lines that don't match the format. Also included the newly added alloc_tag selftests directory in MAINTAINERS list.
Abhishek Bapat (5):
alloc_tag: add ioctl filters to /proc/allocinfo
alloc_tag: add size-based filtering to ioctl
alloc_tag: add accuracy based filtering to ioctl
kselftest: alloc_tag: add kselftest for ioctl interface
kselftest: alloc_tag: extend the allocinfo ioctl kselftest
Suren Baghdasaryan (1):
alloc_tag: add ioctl to /proc/allocinfo
Documentation/mm/allocation-profiling.rst | 5 + .../userspace-api/ioctl/ioctl-number.rst | 2 + MAINTAINERS | 2 + include/linux/codetag.h | 2 + include/uapi/linux/alloc_tag.h | 99 ++++ lib/codetag.c | 18 + mm/alloc_tag.c | 344 ++++++++++- tools/testing/selftests/Makefile | 1 + tools/testing/selftests/alloc_tag/Makefile | 9 + .../alloc_tag/allocinfo_ioctl_test.c | 548 ++++++++++++++++++ 10 files changed, 1028 insertions(+), 2 deletions(-) create mode 100644 include/uapi/linux/alloc_tag.h create mode 100644 tools/testing/selftests/alloc_tag/Makefile create mode 100644 tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c
base-commit: d11ba1f570615ec8d4814d6313ee1d7075a33787
Signature · 1 line
2.55.0.795.g602f6c329a-goog
PATCH v8 1/6 alloc_tag: add ioctl to /proc/allocinfo
From: Suren Baghdasaryan <[email protected]>
Add the following ioctl commands for /proc/allocinfo file:
ALLOCINFO_IOC_CONTENT_ID - gets content identifier which can be used to check whether the file content has changed specifically due to module load/unload. Every time a module is loaded / unloaded, the returned value will be different. By comparing the identifier value at the beginning and at the end of the content retrieval operation, users can validate retrieved information for consistency.
ALLOCINFO_IOC_GET_AT - gets the record at the specified position. This is the position of a record in /proc/allocinfo.
ALLOCINFO_IOC_GET_NEXT - gets the record next to the last retrieved one. If no records were previously retrieved, returns the first record.
Note, function file and module names often have the same prefixes, therefore when filtering for them, we compare the last 64 characters to minimize the chances of name collisions.
--- Documentation/mm/allocation-profiling.rst | 5 + .../userspace-api/ioctl/ioctl-number.rst | 2 + MAINTAINERS | 1 + include/linux/codetag.h | 2 + include/uapi/linux/alloc_tag.h | 65 +++++ lib/codetag.c | 18 ++ mm/alloc_tag.c | 238 +++++++++++++++++- 7 files changed, 329 insertions(+), 2 deletions(-) create mode 100644 include/uapi/linux/alloc_tag.h
Documentation/mm/allocation-profiling.rst +5 -0
@@ -46,6 +46,11 @@ sysctl: Runtime info: /proc/allocinfo + Profiling data can be retrieved either by reading `/proc/allocinfo` directly as + text or programmatically via `ioctl()` calls defined in `<uapi/linux/alloc_tag.h>`. + The ioctl interface supports structured binary data extraction as well as filtering + by module name, function, file, line number, accuracy, or allocation size limits. + Example output:: root@moria-kvm:~# sort -g /proc/allocinfo|tail|numfmt --to=iec
Documentation/userspace-api/ioctl/ioctl-number.rst +2 -0
@@ -346,6 +346,8 @@ Code Seq# Include File Comments <mailto:[email protected]> 0xA5 20-2F linux/surface_aggregator/dtx.h Microsoft Surface DTX driver <mailto:[email protected]> +0xA6 00-0F uapi/linux/alloc_tag.h Memory allocation profiling + <mailto:[email protected]> 0xAA 00-3F linux/uapi/linux/userfaultfd.h 0xAB 00-1F linux/nbd.h 0xAC 00-1F linux/raw.h
MAINTAINERS +1 -0
@@ -16936,6 +16936,7 @@ S: Maintained F: Documentation/mm/allocation-profiling.rst F: include/linux/alloc_tag.h F: include/linux/pgalloc_tag.h +F: include/uapi/linux/alloc_tag.h F: mm/alloc_tag.c MEMORY MANAGEMENT - BALLOON
include/linux/codetag.h +2 -0
@@ -77,6 +77,8 @@ struct codetag_iterator {void codetag_lock_module_list (struct codetag_type *cttype);bool codetag_trylock_module_list (struct codetag_type *cttype);void codetag_unlock_module_list (struct codetag_type *cttype); +unsigned long codetag_get_content_id (struct codetag_type *cttype); +unsigned int codetag_get_count (struct codetag_type *cttype);struct codetag_iterator codetag_get_ct_iter (struct codetag_type *cttype);struct codetag *codetag_next_ct (struct codetag_iterator *iter);
include/uapi/linux/alloc_tag.h new file +65 -0
65 lines not on this page · raw message
lib/codetag.c +18 -0
@@ -19,6 +19,8 @@ struct codetag_type {struct codetag_type_desc desc;/* generates unique sequence number for module load */ unsigned long next_mod_seq; +/* bumped on every module load and unload */ +unsigned long content_id; };struct codetag_range {
@@ -50,6 +52,20 @@ void codetag_unlock_module_list(struct codetag_type *cttype)up_read (&cttype->mod_lock); } +unsigned long codetag_get_content_id (struct codetag_type *cttype) +{ +lockdep_assert_held (&cttype->mod_lock); + +return cttype->content_id; +} + +unsigned int codetag_get_count (struct codetag_type *cttype) +{ +lockdep_assert_held (&cttype->mod_lock); + +return cttype->count; +} +struct codetag_iterator codetag_get_ct_iter (struct codetag_type *cttype) {struct codetag_iterator iter = {
@@ -204,6 +220,7 @@ static int codetag_module_init(struct codetag_type *cttype, struct module *mod)down_write (&cttype->mod_lock); cmod->mod_seq = ++cttype->next_mod_seq; + ++cttype->content_id; mod_id =idr_alloc (&cttype->mod_idr, cmod,0 ,0 ,GFP_KERNEL );if (mod_id >=0 ) {if (cttype->desc.module_load) {
@@ -368,6 +385,7 @@ void codetag_unload_module(struct module *mod) cttype->count -=range_size (cttype, &cmod->range);idr_remove (&cttype->mod_idr, mod_id);kfree (cmod); + ++cttype->content_id; }up_write (&cttype->mod_lock);if (found && cttype->desc.free_section_mem)
mm/alloc_tag.c +236 -2
268 lines not on this page · raw message
Signature · 1 line
2.55.0.795.g602f6c329a-goog
PATCH v8 2/6 alloc_tag: add ioctl filters to /proc/allocinfo
In reply to Abhishek BapatExtend the capability of the IOCTL mechanism to filter allocations based on tag's module name, function name, file name and line number.
--- include/uapi/linux/alloc_tag.h | 26 ++++++++++++- mm/alloc_tag.c | 68 ++++++++++++++++++++++++++++++++-- 2 files changed, 89 insertions(+), 5 deletions(-)
include/uapi/linux/alloc_tag.h +25 -1
@@ -45,8 +45,32 @@ struct allocinfo_tag_data {struct allocinfo_counter counter; }; +enum { +ALLOCINFO_FILTER_MODNAME , +ALLOCINFO_FILTER_FUNCTION , +ALLOCINFO_FILTER_FILENAME , +ALLOCINFO_FILTER_LINENO , + __ALLOCINFO_FILTER_LAST =ALLOCINFO_FILTER_LINENO +}; + +#define ALLOCINFO_FILTER_MASK_MODNAME (1 << ALLOCINFO_FILTER_MODNAME) +#define ALLOCINFO_FILTER_MASK_FUNCTION (1 << ALLOCINFO_FILTER_FUNCTION) +#define ALLOCINFO_FILTER_MASK_FILENAME (1 << ALLOCINFO_FILTER_FILENAME) +#define ALLOCINFO_FILTER_MASK_LINENO (1 << ALLOCINFO_FILTER_LINENO) + +#define ALLOCINFO_FILTER_MASKS \ + ((1 << (__ALLOCINFO_FILTER_LAST + 1)) - 1) + +struct allocinfo_filter { +__u64 mask;/* bitmask of the filter fields used */ +struct allocinfo_tag fields; +}; +struct allocinfo_get_at { -__u64 pos;/* input */ +/* inputs */ +__u64 pos; +struct allocinfo_filter filter; +/* output */ struct allocinfo_tag_data data; };
mm/alloc_tag.c +64 -4
117 lines not on this page · raw message
Signature · 1 line
2.55.0.795.g602f6c329a-goog
PATCH v8 3/6 alloc_tag: add size-based filtering to ioctl
In reply to Abhishek BapatExtend the allocinfo filtering mechanism to allow users to filter tags based on the total number of bytes allocated [min_size, max_size]. The size range is inclusive.
Filtering by size involves retrieving allocinfo per-CPU counters, which is an expensive operation. Hence, the performance of size-based filtering will be worse than other filters.
--- include/uapi/linux/alloc_tag.h | 8 ++++- mm/alloc_tag.c | 64 +++++++++++++++++++++++++++------- 2 files changed, 58 insertions(+), 14 deletions(-)
include/uapi/linux/alloc_tag.h +7 -1
@@ -50,13 +50,17 @@ enum {ALLOCINFO_FILTER_FUNCTION ,ALLOCINFO_FILTER_FILENAME ,ALLOCINFO_FILTER_LINENO , - __ALLOCINFO_FILTER_LAST = ALLOCINFO_FILTER_LINENO +ALLOCINFO_FILTER_MIN_SIZE , +ALLOCINFO_FILTER_MAX_SIZE , + __ALLOCINFO_FILTER_LAST = ALLOCINFO_FILTER_MAX_SIZE };#define ALLOCINFO_FILTER_MASK_MODNAME (1 << ALLOCINFO_FILTER_MODNAME)#define ALLOCINFO_FILTER_MASK_FUNCTION (1 << ALLOCINFO_FILTER_FUNCTION)#define ALLOCINFO_FILTER_MASK_FILENAME (1 << ALLOCINFO_FILTER_FILENAME)#define ALLOCINFO_FILTER_MASK_LINENO (1 << ALLOCINFO_FILTER_LINENO) +#define ALLOCINFO_FILTER_MASK_MIN_SIZE (1 << ALLOCINFO_FILTER_MIN_SIZE) +#define ALLOCINFO_FILTER_MASK_MAX_SIZE (1 << ALLOCINFO_FILTER_MAX_SIZE)#define ALLOCINFO_FILTER_MASKS \ ((1 << (__ALLOCINFO_FILTER_LAST + 1)) - 1)
@@ -64,6 +68,8 @@ enum {struct allocinfo_filter {__u64 mask;/* bitmask of the filter fields used */ struct allocinfo_tag fields; +__u64 min_size; +__u64 max_size; };struct allocinfo_get_at {
mm/alloc_tag.c +51 -13
132 lines not on this page · raw message
Signature · 1 line
2.55.0.795.g602f6c329a-goog
PATCH v8 4/6 alloc_tag: add accuracy based filtering to ioctl
In reply to Abhishek BapatExtend the allocinfo filtering mechanism to allow users to filter tags based on their accuracy.
--- include/uapi/linux/alloc_tag.h | 4 ++++ mm/alloc_tag.c | 8 ++++++++ 2 files changed, 12 insertions(+)
include/uapi/linux/alloc_tag.h +4 -0
@@ -31,6 +31,8 @@ struct allocinfo_tag {char function[ALLOCINFO_STR_SIZE ];char filename[ALLOCINFO_STR_SIZE ];__u64 lineno; +/* filter criteria only; see allocinfo_counter.accurate for actual accuracy */ +__u64 inaccurate; };/* The alignment ensures 32-bit compatible interfaces are not broken */
@@ -50,6 +52,7 @@ enum {ALLOCINFO_FILTER_FUNCTION ,ALLOCINFO_FILTER_FILENAME ,ALLOCINFO_FILTER_LINENO , +ALLOCINFO_FILTER_INACCURATE ,ALLOCINFO_FILTER_MIN_SIZE ,ALLOCINFO_FILTER_MAX_SIZE , __ALLOCINFO_FILTER_LAST =ALLOCINFO_FILTER_MAX_SIZE
@@ -59,6 +62,7 @@ enum {#define ALLOCINFO_FILTER_MASK_FUNCTION (1 << ALLOCINFO_FILTER_FUNCTION)#define ALLOCINFO_FILTER_MASK_FILENAME (1 << ALLOCINFO_FILTER_FILENAME)#define ALLOCINFO_FILTER_MASK_LINENO (1 << ALLOCINFO_FILTER_LINENO) +#define ALLOCINFO_FILTER_MASK_INACCURATE (1 << ALLOCINFO_FILTER_INACCURATE)#define ALLOCINFO_FILTER_MASK_MIN_SIZE (1 << ALLOCINFO_FILTER_MIN_SIZE)#define ALLOCINFO_FILTER_MASK_MAX_SIZE (1 << ALLOCINFO_FILTER_MAX_SIZE)
mm/alloc_tag.c +8 -0
@@ -252,6 +252,8 @@ static bool matches_filter(struct codetag *ct, struct allocinfo_filter *filter,struct alloc_tag_counters *counters, bool *fetched_counters) { + bool inaccurate; +if (!filter || !filter->mask)return true;
@@ -277,6 +279,12 @@ static bool matches_filter(struct codetag *ct, struct allocinfo_filter *filter, ct->lineno != filter->fields.lineno)return false; +if (filter->mask &ALLOCINFO_FILTER_MASK_INACCURATE ) { + inaccurate = !!(ct->flags &CODETAG_FLAG_INACCURATE ); +if (inaccurate != !!(filter->fields.inaccurate)) +return false; + } +if (filter->mask & (ALLOCINFO_FILTER_MASK_MIN_SIZE |ALLOCINFO_FILTER_MASK_MAX_SIZE )) {if (!*fetched_counters) { *counters =allocinfo_prefetch_counters (ct);
Signature · 1 line
2.55.0.795.g602f6c329a-goog
PATCH v8 5/6 kselftest: alloc_tag: add kselftest for ioctl interface
In reply to Abhishek BapatIntroduce a kselftest to verify the new IOCTL-based interface for /proc/allocinfo. The test covers:
1. Validation of the filename filter.
2. Validation of the function filter.
The first test validates the functionality of the filename filter. Using "mm/memory.c" as the candidate filename filter, it retrieves filtered entries from both procfs and ioctl and matches the first VEC_MAX_ENTRIES entries.
The second test validates the functionality of the function filter. It uses "dup_mm" as the candidate function as we do not expect this function name to change frequently and hence won't be needing to modify this test often.
Note that both the tests match line no, function name and file name fields. Bytes allocated and calls are not matched as those values may change in the time when the data is being read from procfs and ioctl and hence can lead to false negatives.
--- MAINTAINERS | 1 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/alloc_tag/Makefile | 9 + .../alloc_tag/allocinfo_ioctl_test.c | 334 ++++++++++++++++++ 4 files changed, 345 insertions(+) create mode 100644 tools/testing/selftests/alloc_tag/Makefile create mode 100644 tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c
MAINTAINERS +1 -0
@@ -16938,6 +16938,7 @@ F: include/linux/alloc_tag.h F: include/linux/pgalloc_tag.h F: include/uapi/linux/alloc_tag.h F: mm/alloc_tag.c +F: tools/testing/selftests/alloc_tag/ MEMORY MANAGEMENT - BALLOON M: Andrew Morton <[email protected]>
tools/testing/selftests/Makefile +1 -0
@@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 TARGETS += acct +TARGETS += alloc_tag TARGETS += alsa TARGETS += amd-pstate TARGETS += arm64
tools/testing/selftests/alloc_tag/Makefile new file +9 -0
@@ -0,0 +1,9 @@ +# SPDX-License-Identifier: GPL-2.0 + +TEST_GEN_PROGS := allocinfo_ioctl_test + +CFLAGS += -Wall +CFLAGS += $(KHDR_INCLUDES) + +include ../lib.mk +
tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c new file +334 -0
334 lines not on this page · raw message
Signature · 1 line
2.55.0.795.g602f6c329a-goog
Re: [PATCH v8 5/6] kselftest: alloc_tag: add kselftest for ioctl interface
Hi Abhishek
Quoted 75 lines · Abhishek Bapat
Introduce a kselftest to verify the new IOCTL-based interface for
/proc/allocinfo. The test covers:1. Validation of the filename filter.
2. Validation of the function filter.The first test validates the functionality of the filename filter. Using "
mm/memory.c" as the candidate filename filter, it retrieves filtered entries from both procfs and ioctl and matches the firstVEC_MAX_ENTRIESentries.The second test validates the functionality of the function filter. It uses "
dup_mm" as the candidate function as we do not expect this function name to change frequently and hence won't be needing to modify this test often.Note that both the tests match line no, function name and file name fields. Bytes allocated and calls are not matched as those values may change in the time when the data is being read from procfs and ioctl and hence can lead to false negatives.
Signed-off-by Abhishek Bapat <[email protected]>--- MAINTAINERS | 1 + tools/testing/selftests/Makefile | 1 + tools/testing/selftests/alloc_tag/Makefile | 9 + .../alloc_tag/allocinfo_ioctl_test.c | 334 ++++++++++++++++++ 4 files changed, 345 insertions(+)create mode 100644
tools/testing/selftests/alloc_tag/Makefilecreate mode 100644tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.cMAINTAINERS +1
-0@@ -16938,6 +16938,7 @@ F: include/linux/alloc_tag.h F: include/linux/pgalloc_tag.h F: include/uapi/linux/alloc_tag.h F: mm/alloc_tag.c +F: tools/testing/selftests/alloc_tag/ MEMORY MANAGEMENT - BALLOON M: Andrew Morton <[email protected]>tools/testing/selftests/Makefile +1
-0@@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 TARGETS += acct +TARGETS += alloc_tag TARGETS += alsa TARGETS += amd-pstate TARGETS += arm64tools/testing/selftests/alloc_tag/Makefile new file +9
-0@@ -0,0 +1,9 @@ +# SPDX-License-Identifier: GPL-2.0 + +TEST_GEN_PROGS := allocinfo_ioctl_test + +CFLAGS += -Wall +CFLAGS += $(KHDR_INCLUDES) + +include ../lib.mk +tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c new file +0
-0
tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c line 7
Quoted 7 lines
tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c new file +7
-0@@ -0,0 +1,334 @@ +// SPDX-License-Identifier: GPL-2.0-only + +/* kselftest for allocinfo ioctl +* allocinfo ioctl retrives allocinfo data through ioctl +* Copyright (C) 2026 Google, Inc. +*/ +
I recall we discussed the "retrives" typo previously.
nit: s/retrives/retrieves/
I've verified this selftest on kernels both with and without CONFIG_MEM_ALLOC_PROFILING enabled,
and it works as expected.
Thanks
Best Regards
Hao
Quoted 327 lines
tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c new file +327
-0+#include <fcntl.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdbool.h> +#include <unistd.h> +#include <sys/ioctl.h> +#include <linux/types.h> +#include <linux/alloc_tag.h> +#include "../kselftest.h" + +#define MAX_LINE_LEN 512 +#define ALLOCINFO_PROC "/proc/allocinfo" + +enum ioctl_ret { +IOCTL_SUCCESS =0 , +IOCTL_FAILURE =1 , +IOCTL_INVALID_DATA =2 , +}; + +#define VEC_MAX_ENTRIES 32 + +struct allocinfo_tag_data_vec { +struct allocinfo_tag_data tag[VEC_MAX_ENTRIES ]; +__u64 count; +}; + +static inline int __allocinfo_get_content_id (int dev_fd,struct allocinfo_content_id *params) +{ +return ioctl (dev_fd,ALLOCINFO_IOC_CONTENT_ID , params); +} + +static inline int __allocinfo_get_at (int dev_fd,struct allocinfo_get_at *params) +{ +return ioctl (dev_fd,ALLOCINFO_IOC_GET_AT , params); +} + +static inline int __allocinfo_get_next (int dev_fd,struct allocinfo_tag_data *params) +{ +return ioctl (dev_fd,ALLOCINFO_IOC_GET_NEXT , params); +} + +static bool match_entry (const struct allocinfo_tag_data *procfs_entry, +const struct allocinfo_tag_data *tag_data, +bool match_bytes,bool match_calls,bool match_lineno, +bool match_function,bool match_filename) +{ +if (match_bytes && tag_data->counter.bytes != procfs_entry->counter.bytes) { +ksft_print_msg ("size retrieved through ioctl does not match procfs\n" ); +return false; + } + +if (match_calls && tag_data->counter.calls != procfs_entry->counter.calls) { +ksft_print_msg ("call count retrieved through ioctl does not match procfs\n" ); +return false; + } + +if (match_lineno && tag_data->tag.lineno != procfs_entry->tag.lineno) { +ksft_print_msg ("lineno retrieved through ioctl does not match procfs\n" ); +return false; + } + +if (match_function && +strncmp (tag_data->tag.function, procfs_entry->tag.function,ALLOCINFO_STR_SIZE )) { +ksft_print_msg ("function retrieved through ioctl does not match procfs\n" ); +return false; + } + +if (match_filename && +strncmp (tag_data->tag.filename, procfs_entry->tag.filename,ALLOCINFO_STR_SIZE )) { +ksft_print_msg ("filename retrieved through ioctl does not match procfs\n" ); +return false; + } +return true; +} + +static bool match_entries (const struct allocinfo_tag_data_vec *procfs_entries, +const struct allocinfo_tag_data_vec *tags, +bool match_bytes,bool match_calls,bool match_lineno, +bool match_function,bool match_filename) +{ +__u64 i; + +if (procfs_entries->count != tags->count) { +ksft_print_msg ("Entry count mismatch. ioctl entries: %llu, proc entries: %llu\n" , + tags->count, procfs_entries->count); +return false; + } +for (i =0 ; i < procfs_entries->count; i++) { +if (!match_entry (&procfs_entries->tag[i], &tags->tag[i], + match_bytes, match_calls, match_lineno, + match_function, match_filename)) { +ksft_print_msg ("%lluth entry does not match.\n" , i); +return false; + } + } +return true; +} + +static const char *allocinfo_str (const char *str) +{ +size_t len =strlen (str); + +if (len >=ALLOCINFO_STR_SIZE ) + str += (len -ALLOCINFO_STR_SIZE ) +1 ; +return str; +} + +static void allocinfo_copy_str (char *dest,const char *src) +{ +strncpy (dest,allocinfo_str (src),ALLOCINFO_STR_SIZE -1 ); + dest[ALLOCINFO_STR_SIZE -1 ] ='\0' ; +} + +static int get_filtered_procfs_entries (struct allocinfo_tag_data_vec *procfs_entries, +const struct allocinfo_filter *filter) +{ +FILE *fp =fopen (ALLOCINFO_PROC ,"r" ); +char line[MAX_LINE_LEN ]; +int matches; +struct allocinfo_tag_data procfs_entry; + +if (!fp) { +ksft_print_msg ("Failed to open " ALLOCINFO_PROC " for reading\n" ); +return 1 ; + } +memset (procfs_entries,0 ,sizeof (*procfs_entries)); +while (fgets (line,sizeof (line), fp) && procfs_entries->count <VEC_MAX_ENTRIES ) { +char filename[MAX_LINE_LEN ]; +char function[MAX_LINE_LEN ]; + +memset (&procfs_entry,0 ,sizeof (procfs_entry)); + matches =sscanf (line,"%llu %llu %[^:]:%llu func:%s" , + &procfs_entry.counter.bytes, + &procfs_entry.counter.calls, + filename, + &procfs_entry.tag.lineno, + function); + +if (matches !=5 ) +continue ; + +allocinfo_copy_str (procfs_entry.tag.filename, filename); +allocinfo_copy_str (procfs_entry.tag.function, function); + +if (filter->mask &ALLOCINFO_FILTER_MASK_FILENAME ) { +if (strncmp (procfs_entry.tag.filename, + filter->fields.filename,ALLOCINFO_STR_SIZE )) +continue ; + } +if (filter->mask &ALLOCINFO_FILTER_MASK_FUNCTION ) { +if (strncmp (procfs_entry.tag.function, + filter->fields.function,ALLOCINFO_STR_SIZE )) +continue ; + } +if (filter->mask &ALLOCINFO_FILTER_MASK_LINENO ) { +if (procfs_entry.tag.lineno != filter->fields.lineno) +continue ; + } +if (filter->mask &ALLOCINFO_FILTER_MASK_MIN_SIZE ) { +if (procfs_entry.counter.bytes < filter->min_size) +continue ; + } +if (filter->mask &ALLOCINFO_FILTER_MASK_MAX_SIZE ) { +if (procfs_entry.counter.bytes > filter->max_size) +continue ; + } + +memcpy (&procfs_entries->tag[procfs_entries->count++], &procfs_entry, +sizeof (procfs_entry)); + } +fclose (fp); +return 0 ; +} + +static enum ioctl_ret get_filtered_ioctl_entries (struct allocinfo_tag_data_vec *tags, +const struct allocinfo_filter *filter, +__u64 start_pos) +{ +int fd =open (ALLOCINFO_PROC ,O_RDONLY ); + +if (fd <0 ) { +ksft_print_msg ("Failed to open " ALLOCINFO_PROC " for IOCTL\n" ); +return IOCTL_FAILURE ; + } + +struct allocinfo_content_id start_cont_id, end_cont_id; +struct allocinfo_get_at get_at_params; +const int max_retries =10 ; +int retry_count =0 ; +int status; + +/* +* __allocinfo_get_content_id may return different values if a kernel module was loaded +* between the two calls. If that happens, the data gathered cannot be considered consistent +* and hence needs to be fetched again to avoid flakiness. +*/ +do { +if (__allocinfo_get_content_id (fd, &start_cont_id)) { +ksft_print_msg ("allocinfo_get_content_id failed\n" ); + status =IOCTL_FAILURE ; +break ; + } + +memset (tags,0 ,sizeof (*tags)); +memset (&get_at_params,0 ,sizeof (get_at_params)); +memcpy (&get_at_params.filter, filter,sizeof (*filter)); + get_at_params.pos = start_pos; +if (__allocinfo_get_at (fd, &get_at_params)) { +ksft_print_msg ("allocinfo_get_at failed\n" ); + status =IOCTL_FAILURE ; +break ; + } +memcpy (&tags->tag[tags->count++], &get_at_params.data,sizeof (get_at_params.data)); + +while (tags->count <VEC_MAX_ENTRIES && +__allocinfo_get_next (fd, &tags->tag[tags->count]) ==0 ) + tags->count++; + +if (__allocinfo_get_content_id (fd, &end_cont_id)) { +ksft_print_msg ("allocinfo_get_content_id failed\n" ); + status =IOCTL_FAILURE ; +break ; + } + +if (start_cont_id.id == end_cont_id.id) { + status =IOCTL_SUCCESS ; + }else { +ksft_print_msg ("allocinfo_get_content_id mismatch, retrying...\n" ); + status =IOCTL_INVALID_DATA ; + } + }while (status ==IOCTL_INVALID_DATA && retry_count++ < max_retries); + +close (fd); +return status; +} + +static int run_filter_test (const struct allocinfo_filter *filter) +{ +struct allocinfo_tag_data_vec *tags =malloc (sizeof (*tags)); +struct allocinfo_tag_data_vec *procfs_entries =malloc (sizeof (*procfs_entries)); +int ioctl_status; +int ret =KSFT_PASS ; + +if (!tags || !procfs_entries) { +ksft_print_msg ("Memory allocation failed.\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +if (get_filtered_procfs_entries (procfs_entries, filter)) { +ksft_print_msg ("Error retrieving entries from " ALLOCINFO_PROC "\n" ); + ret =KSFT_SKIP ; + goto exit; + } + +if (procfs_entries->count ==0 ) { +ksft_print_msg ("No entries found in " ALLOCINFO_PROC ", skipping test\n" ); + ret =KSFT_SKIP ; + goto exit; + } + + ioctl_status =get_filtered_ioctl_entries (tags, filter,0 ); +if (ioctl_status ==IOCTL_INVALID_DATA ) { +ksft_print_msg ("Trouble retrieving valid IOCTL entries, skipping.\n" ); + ret =KSFT_SKIP ; + goto exit; + } +if (ioctl_status ==IOCTL_FAILURE ) { +ksft_print_msg ("Error retrieving IOCTL entries.\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +if (!match_entries (procfs_entries, tags, false, false, true, true, true)) + ret =KSFT_FAIL ; + +exit: +free (tags); +free (procfs_entries); +return ret; +} + +static int test_filename_filter (void ) +{ +struct allocinfo_filter filter; +const char *target_filename ="mm/memory.c" ; + +memset (&filter,0 ,sizeof (filter)); + filter.mask |=ALLOCINFO_FILTER_MASK_FILENAME ; +strncpy (filter.fields.filename, target_filename,ALLOCINFO_STR_SIZE ); + +return run_filter_test (&filter); +} + +static int test_function_filter (void ) +{ +struct allocinfo_filter filter; +const char *target_function ="dup_mm" ; + +memset (&filter,0 ,sizeof (filter)); + filter.mask |=ALLOCINFO_FILTER_MASK_FUNCTION ; +strncpy (filter.fields.function, target_function,ALLOCINFO_STR_SIZE ); + +return run_filter_test (&filter); +} + +int main (int argc,char *argv[]) +{ +int ret; + +ksft_set_plan (2 ); + + ret =test_filename_filter (); +if (ret ==KSFT_SKIP ) +ksft_test_result_skip ("Skipping test_filename_filter\n" ); +else +ksft_test_result (ret ==KSFT_PASS ,"test_filename_filter\n" ); + + ret =test_function_filter (); +if (ret ==KSFT_SKIP ) +ksft_test_result_skip ("Skipping test_function_filter\n" ); +else +ksft_test_result (ret ==KSFT_PASS ,"test_function_filter\n" ); + +ksft_finished (); +}
PATCH v8 6/6 kselftest: alloc_tag: extend the allocinfo ioctl kselftest
In reply to Abhishek BapatAdd the following 2 scenarios to the allocinfo ioctl kselftest:
1. Validate size based filtering
2. Validate lineno based filtering
The first test uses "do_init_module" as the candidate function for the test. This is because the associated site will only allocate memory when a kernel module is loaded. The return value of get_content_id() changes every time modules are loaded or unloaded. Hence, as long as get_content_id() values at the start and the end of the test are the same, the memory allocated by the do_init_module call site should also remain the same. Consequently, the test can assume consistency between the value returned by the ioctl and the procfs resulting in less flakiness.
--- .../alloc_tag/allocinfo_ioctl_test.c | 216 +++++++++++++++++- 1 file changed, 215 insertions(+), 1 deletion(-)
tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c +215 -1
@@ -5,6 +5,7 @@* Copyright (C) 2026 Google, Inc. */ +#include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h>
@@ -312,11 +313,212 @@ static int test_function_filter(void)return run_filter_test (&filter); } +static int test_size_filter (void ) +{ +int fd; +struct allocinfo_tag_data_vec *tags =malloc (sizeof (*tags)); +struct allocinfo_tag_data_vec *procfs_entries =malloc (sizeof (*procfs_entries)); +struct allocinfo_filter filter; +int ret =KSFT_PASS ; +__u64 target_size, i, pos; +struct allocinfo_tag_data *found_tag =NULL ; +const char *target_function ="do_init_module" ; +struct allocinfo_content_id start_cont_id, end_cont_id; +int retry =0 ; +const int max_retries =10 ; + +if (!tags || !procfs_entries) { +ksft_print_msg ("Memory allocation failed.\n" ); + ret =KSFT_FAIL ; + goto freemem; + } + + fd =open (ALLOCINFO_PROC ,O_RDONLY ); +if (fd <0 ) { +ksft_print_msg ("Failed to open " ALLOCINFO_PROC ": %s\n" ,strerror (errno)); + ret =KSFT_SKIP ; + goto freemem; + } + +do { + found_tag =NULL ; + pos =0 ; + +if (__allocinfo_get_content_id (fd, &start_cont_id)) { +ksft_print_msg ("allocinfo_get_content_id failed\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +memset (&filter,0 ,sizeof (filter)); + filter.mask |=ALLOCINFO_FILTER_MASK_FUNCTION ; +strncpy (filter.fields.function, target_function,ALLOCINFO_STR_SIZE ); + +if (get_filtered_procfs_entries (procfs_entries, &filter)) { +ksft_print_msg ("Error retrieving entries from " ALLOCINFO_PROC "\n" ); + ret =KSFT_SKIP ; + goto exit; + } + +if (procfs_entries->count ==0 ) { +ksft_print_msg ("Function %s not found in procfs\n" , target_function); + ret =KSFT_SKIP ; + goto exit; + } + + target_size = procfs_entries->tag[0 ].counter.bytes; + +memset (&filter,0 ,sizeof (filter)); + filter.mask |=ALLOCINFO_FILTER_MASK_MIN_SIZE |ALLOCINFO_FILTER_MASK_MAX_SIZE ; + filter.min_size = target_size; + filter.max_size = target_size; + +while (1 ) { +struct allocinfo_get_at get_at_params; + +memset (&get_at_params,0 ,sizeof (get_at_params)); +memcpy (&get_at_params.filter, &filter,sizeof (filter)); + get_at_params.pos = pos; + +if (__allocinfo_get_at (fd, &get_at_params)) +break ; + + tags->count =0 ; +memcpy (&tags->tag[tags->count++], &get_at_params.data, +sizeof (get_at_params.data)); + +while (tags->count <VEC_MAX_ENTRIES && +__allocinfo_get_next (fd, &tags->tag[tags->count]) ==0 ) + tags->count++; + +for (i =0 ; i < tags->count; i++) { +if (strcmp (tags->tag[i].tag.function, target_function) ==0 ) { + found_tag = &tags->tag[i]; +break ; + } + } + +if (found_tag || tags->count <VEC_MAX_ENTRIES ) +break ; + + pos += tags->count; + } + +if (__allocinfo_get_content_id (fd, &end_cont_id)) { +ksft_print_msg ("allocinfo_get_content_id failed\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +if (start_cont_id.id == end_cont_id.id) +break ; + +ksft_print_msg ("Module load detected during size verification, retrying...\n" ); + }while (retry++ < max_retries); + +if (start_cont_id.id == end_cont_id.id && !found_tag) { +ksft_print_msg ("Entry with function %s not found in IOCTL results\n" , + target_function); + ret =KSFT_FAIL ; + }else if (start_cont_id.id != end_cont_id.id) { +ksft_print_msg ("Failed to match content_ids for procfs and IOCTL, skipping...\n" ); + ret =KSFT_SKIP ; + }else if (found_tag && found_tag->counter.bytes != target_size) { +ksft_print_msg ("IOCTL entry size %llu does not match target size %llu\n" , + found_tag->counter.bytes, target_size); + ret =KSFT_FAIL ; + } + +exit: +close (fd); +freemem: +free (tags); +free (procfs_entries); +return ret; +} + +static int test_lineno_filter (void ) +{ +struct allocinfo_tag_data_vec *tags =malloc (sizeof (*tags)); +struct allocinfo_tag_data_vec *procfs_entries =malloc (sizeof (*procfs_entries)); +struct allocinfo_filter filter; +enum ioctl_ret ioctl_status; +int ret =KSFT_PASS ; +__u64 target_lineno, i; +struct allocinfo_tag_data *target_tag; +bool found = false; + +if (!tags || !procfs_entries) { +ksft_print_msg ("Memory allocation failed.\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +memset (&filter,0 ,sizeof (filter)); + +if (get_filtered_procfs_entries (procfs_entries, &filter)) { +ksft_print_msg ("Error retrieving entries from " ALLOCINFO_PROC "\n" ); + ret =KSFT_SKIP ; + goto exit; + } +if (procfs_entries->count ==0 ) { +ksft_print_msg ("Could not retrieve procfs entries\n" ); + ret =KSFT_SKIP ; + goto exit; + } +/* +* We depend on the procfs results to determine the line number for the filter before +* making the ioctl query. Hence, we cannot reuse run_filter_test here. +*/ + target_tag = &procfs_entries->tag[0 ]; + target_lineno = target_tag->tag.lineno; + + filter.mask |=ALLOCINFO_FILTER_MASK_LINENO ; + filter.fields.lineno = target_lineno; + + ioctl_status =get_filtered_ioctl_entries (tags, &filter,0 ); +if (ioctl_status ==IOCTL_INVALID_DATA ) { +ksft_print_msg ("Trouble retrieving valid IOCTL entries, skipping.\n" ); + ret =KSFT_SKIP ; + goto exit; + } +if (ioctl_status ==IOCTL_FAILURE ) { +ksft_print_msg ("Error retrieving IOCTL entries.\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +for (i =0 ; i < tags->count; i++) { +if (tags->tag[i].tag.lineno != target_lineno) { +ksft_print_msg ("IOCTL entry %llu has incorrect lineno %llu.\n" , + i, tags->tag[i].tag.lineno); + ret =KSFT_FAIL ; + goto exit; + } + +if (strncmp (tags->tag[i].tag.function, target_tag->tag.function, +ALLOCINFO_STR_SIZE ) ==0 && +strncmp (tags->tag[i].tag.filename, target_tag->tag.filename, +ALLOCINFO_STR_SIZE ) ==0 ) + found = true; + } + +if (!found) { +ksft_print_msg ("Original procfs entry not found in IOCTL lineno filter results.\n" ); + ret =KSFT_FAIL ; + } + +exit: +free (tags); +free (procfs_entries); +return ret; +} +int main (int argc,char *argv[]) {int ret; -ksft_set_plan (2 ); +ksft_set_plan (4 ); ret =test_filename_filter ();if (ret ==KSFT_SKIP )
@@ -330,5 +532,17 @@ int main(int argc, char *argv[])else ksft_test_result (ret ==KSFT_PASS ,"test_function_filter\n" ); + ret =test_size_filter (); +if (ret ==KSFT_SKIP ) +ksft_test_result_skip ("Skipping test_size_filter\n" ); +else +ksft_test_result (ret ==KSFT_PASS ,"test_size_filter\n" ); + + ret =test_lineno_filter (); +if (ret ==KSFT_SKIP ) +ksft_test_result_skip ("Skipping test_lineno_filter\n" ); +else +ksft_test_result (ret ==KSFT_PASS ,"test_lineno_filter\n" ); +ksft_finished (); }
Signature · 1 line
2.55.0.795.g602f6c329a-goog
Re: [PATCH v8 6/6] kselftest: alloc_tag: extend the allocinfo ioctl kselftest
Hi Abhishek
Quoted 14 lines · Abhishek Bapat
Add the following 2 scenarios to the allocinfo ioctl kselftest:
1. Validate size based filtering
2. Validate lineno based filteringThe first test uses "
do_init_module" as the candidate function for the test. This is because the associated site will only allocate memory when a kernel module is loaded. The return value ofget_content_id()changes every time modules are loaded or unloaded. Hence, as long asget_content_id()values at the start and the end of the test are the same, the memory allocated by thedo_init_modulecall site should also remain the same. Consequently, the test can assume consistency between the value returned by the ioctl and the procfs resulting in less flakiness.
Quoted 1 line
Signed-off-by Abhishek Bapat <[email protected]>
Quoted 248 lines
--- .../alloc_tag/allocinfo_ioctl_test.c | 216 +++++++++++++++++- 1 file changed, 215 insertions(+), 1 deletion(-)tools/testing/selftests/alloc_tag/allocinfo_ioctl_test.c +215
-1@@ -5,6 +5,7 @@* Copyright (C) 2026 Google, Inc. */ +#include <errno.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> @@ -312,11 +313,212 @@ static int test_function_filter(void)return run_filter_test (&filter); } +static int test_size_filter (void ) +{ +int fd; +struct allocinfo_tag_data_vec *tags =malloc (sizeof (*tags)); +struct allocinfo_tag_data_vec *procfs_entries =malloc (sizeof (*procfs_entries)); +struct allocinfo_filter filter; +int ret =KSFT_PASS ; +__u64 target_size, i, pos; +struct allocinfo_tag_data *found_tag =NULL ; +const char *target_function ="do_init_module" ; +struct allocinfo_content_id start_cont_id, end_cont_id; +int retry =0 ; +const int max_retries =10 ; + +if (!tags || !procfs_entries) { +ksft_print_msg ("Memory allocation failed.\n" ); + ret =KSFT_FAIL ; + goto freemem; + } + + fd =open (ALLOCINFO_PROC ,O_RDONLY ); +if (fd <0 ) { +ksft_print_msg ("Failed to open " ALLOCINFO_PROC ": %s\n" ,strerror (errno)); + ret =KSFT_SKIP ; + goto freemem; + } + +do { + found_tag =NULL ; + pos =0 ; + +if (__allocinfo_get_content_id (fd, &start_cont_id)) { +ksft_print_msg ("allocinfo_get_content_id failed\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +memset (&filter,0 ,sizeof (filter)); + filter.mask |=ALLOCINFO_FILTER_MASK_FUNCTION ; +strncpy (filter.fields.function, target_function,ALLOCINFO_STR_SIZE ); + +if (get_filtered_procfs_entries (procfs_entries, &filter)) { +ksft_print_msg ("Error retrieving entries from " ALLOCINFO_PROC "\n" ); + ret =KSFT_SKIP ; + goto exit; + } + +if (procfs_entries->count ==0 ) { +ksft_print_msg ("Function %s not found in procfs\n" , target_function); + ret =KSFT_SKIP ; + goto exit; + } + + target_size = procfs_entries->tag[0 ].counter.bytes; + +memset (&filter,0 ,sizeof (filter)); + filter.mask |=ALLOCINFO_FILTER_MASK_MIN_SIZE |ALLOCINFO_FILTER_MASK_MAX_SIZE ; + filter.min_size = target_size; + filter.max_size = target_size; + +while (1 ) { +struct allocinfo_get_at get_at_params; + +memset (&get_at_params,0 ,sizeof (get_at_params)); +memcpy (&get_at_params.filter, &filter,sizeof (filter)); + get_at_params.pos = pos; + +if (__allocinfo_get_at (fd, &get_at_params)) +break ; + + tags->count =0 ; +memcpy (&tags->tag[tags->count++], &get_at_params.data, +sizeof (get_at_params.data)); + +while (tags->count <VEC_MAX_ENTRIES && +__allocinfo_get_next (fd, &tags->tag[tags->count]) ==0 ) + tags->count++; + +for (i =0 ; i < tags->count; i++) { +if (strcmp (tags->tag[i].tag.function, target_function) ==0 ) { + found_tag = &tags->tag[i]; +break ; + } + } + +if (found_tag || tags->count <VEC_MAX_ENTRIES ) +break ; + + pos += tags->count; + } + +if (__allocinfo_get_content_id (fd, &end_cont_id)) { +ksft_print_msg ("allocinfo_get_content_id failed\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +if (start_cont_id.id == end_cont_id.id) +break ; + +ksft_print_msg ("Module load detected during size verification, retrying...\n" ); + }while (retry++ < max_retries); + +if (start_cont_id.id == end_cont_id.id && !found_tag) { +ksft_print_msg ("Entry with function %s not found in IOCTL results\n" , + target_function); + ret =KSFT_FAIL ; + }else if (start_cont_id.id != end_cont_id.id) { +ksft_print_msg ("Failed to match content_ids for procfs and IOCTL, skipping...\n" ); + ret =KSFT_SKIP ; + }else if (found_tag && found_tag->counter.bytes != target_size) { +ksft_print_msg ("IOCTL entry size %llu does not match target size %llu\n" , + found_tag->counter.bytes, target_size); + ret =KSFT_FAIL ; + } + +exit: +close (fd); +freemem: +free (tags); +free (procfs_entries); +return ret; +} + +static int test_lineno_filter (void ) +{ +struct allocinfo_tag_data_vec *tags =malloc (sizeof (*tags)); +struct allocinfo_tag_data_vec *procfs_entries =malloc (sizeof (*procfs_entries)); +struct allocinfo_filter filter; +enum ioctl_ret ioctl_status; +int ret =KSFT_PASS ; +__u64 target_lineno, i; +struct allocinfo_tag_data *target_tag; +bool found = false; + +if (!tags || !procfs_entries) { +ksft_print_msg ("Memory allocation failed.\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +memset (&filter,0 ,sizeof (filter)); + +if (get_filtered_procfs_entries (procfs_entries, &filter)) { +ksft_print_msg ("Error retrieving entries from " ALLOCINFO_PROC "\n" ); + ret =KSFT_SKIP ; + goto exit; + } +if (procfs_entries->count ==0 ) { +ksft_print_msg ("Could not retrieve procfs entries\n" ); + ret =KSFT_SKIP ; + goto exit; + } +/* +* We depend on the procfs results to determine the line number for the filter before +* making the ioctl query. Hence, we cannot reuse run_filter_test here. +*/ + target_tag = &procfs_entries->tag[0 ]; + target_lineno = target_tag->tag.lineno; + + filter.mask |=ALLOCINFO_FILTER_MASK_LINENO ; + filter.fields.lineno = target_lineno; + + ioctl_status =get_filtered_ioctl_entries (tags, &filter,0 ); +if (ioctl_status ==IOCTL_INVALID_DATA ) { +ksft_print_msg ("Trouble retrieving valid IOCTL entries, skipping.\n" ); + ret =KSFT_SKIP ; + goto exit; + } +if (ioctl_status ==IOCTL_FAILURE ) { +ksft_print_msg ("Error retrieving IOCTL entries.\n" ); + ret =KSFT_FAIL ; + goto exit; + } + +for (i =0 ; i < tags->count; i++) { +if (tags->tag[i].tag.lineno != target_lineno) { +ksft_print_msg ("IOCTL entry %llu has incorrect lineno %llu.\n" , + i, tags->tag[i].tag.lineno); + ret =KSFT_FAIL ; + goto exit; + } + +if (strncmp (tags->tag[i].tag.function, target_tag->tag.function, +ALLOCINFO_STR_SIZE ) ==0 && +strncmp (tags->tag[i].tag.filename, target_tag->tag.filename, +ALLOCINFO_STR_SIZE ) ==0 ) + found = true; + } + +if (!found) { +ksft_print_msg ("Original procfs entry not found in IOCTL lineno filter results.\n" ); + ret =KSFT_FAIL ; + } + +exit: +free (tags); +free (procfs_entries); +return ret; +} +int main (int argc,char *argv[]) {int ret; -ksft_set_plan (2 ); +ksft_set_plan (4 ); ret =test_filename_filter ();if (ret ==KSFT_SKIP )@@ -330,5 +532,17 @@ int main(int argc, char *argv[])else ksft_test_result (ret ==KSFT_PASS ,"test_function_filter\n" ); + ret =test_size_filter (); +if (ret ==KSFT_SKIP ) +ksft_test_result_skip ("Skipping test_size_filter\n" ); +else +ksft_test_result (ret ==KSFT_PASS ,"test_size_filter\n" ); + + ret =test_lineno_filter (); +if (ret ==KSFT_SKIP ) +ksft_test_result_skip ("Skipping test_lineno_filter\n" ); +else +ksft_test_result (ret ==KSFT_PASS ,"test_lineno_filter\n" ); +ksft_finished (); }
Andrew Morton
maintainerQuoted 12 lines · On Wed, 8 Jul 2026 18:01:22 +0000 Abhishek Bapat <[email protected]>…
Currently, memory allocation profiling data is primarily exposed through
/proc/allocinfo. While useful for manual inspection, this text-based interface poses challenges for production monitoring and large-scale analysis:1. Userspace must parse large amounts of text to extract specific fields.
2. To find specific tags, userspace must read the entire dataset, requiring many context switches and high data copying.
3. The kernel currently aggregates per-CPU counters for every allocation size, even those the user intends to filter out immediately.
Quoted 2 lines
This series introduces a new IOCTL-based binary interface for allocinfo that supports kernel-side filtering.
Thanks. The important bits are reviewed, let's get this in there for some testing.
Sashiko had a lot to say:
https://sashiko.dev/#/patchset/[email protected]
I think you've already been over this. but please double-check - maybe it found something new.