Hi Petr
On 2026/8/26 16:32, Petr Pavlu wrote:
On 8/16/26 5:16 PM, Suren Baghdasaryan wrote:
quoted
On Sat, Aug 15, 2026 at 3:45 AM Petr Pavlu [off-list ref] wrote:
quoted
On 8/12/26 7:41 AM, Hao Ge wrote:
quoted
In reserve_module_tags(), the tag overflow check is gated on
mem_alloc_profiling_enabled():
if (mem_alloc_profiling_enabled() && !tags_addressable())
If profiling is toggled off at runtime and a module is loaded whose
tags exceed the compressed-mode limit, shutdown_mem_profiling() is
skipped. vm_module_tags_populate() still maps memory for the tags and
the module loads successfully, but the total tag count now exceeds what
NR_UNUSED_PAGEFLAG_BITS can address.
Once profiling is re-enabled, ref_to_idx() computes each tag's index
as its position in the alloc_tag array. update_page_tag_ref() masks
it to alloc_tag_ref_mask before storing in page->flags. Indices
beyond the mask are truncated and idx_to_ref() resolves them to wrong
tags.
This silently corrupts /proc/allocinfo: allocated pages get attributed
to the wrong call sites, so the statistics it reports are wrong.
mem_alloc_profiling_enabled() and mem_profiling_compressed are
independent. Once compressed mode is established at boot, it stays
active regardless of runtime toggles of mem_profiling.
Remove the mem_alloc_profiling_enabled() guard. On overflow, shut down
profiling, release the reservation, and return -EAGAIN so that
layout_and_allocate() retries with profiling disabled: codetag sections
are then placed as regular module data and the module loads without
profiling rather than being rejected entirely.
When the described overflow occurs, why should codetag sections be
placed as regular module data? Will the codetag support use them in any
way, or do they simply waste space? Is the issue that alloc_hooks()
creates relocations pointing into .codetag.alloc_tags?
Correct, alloc_hooks() will have references into .codetag.alloc_tags.
With mem_profiling_support=false they should technically never be used
but I don't think it's a good idea to skip .codetag.alloc_tags section
allocation and to leave dangling pointers. Also the case described
here is an outlier, so optimizing it would not yield much benefit.
[...]
quoted
quoted
I'm not sure this is the best approach. It's complex logic for what
appears to be an edge case related to a debugging facility. It will have
the usual problem of error paths not getting enough testing and breaking
subtly over time.
An alternative could be to reset SHF_ALLOC on the codetag section to
remove it from further processing and have relocations that point to
this section resolve to something else. It seems that alloc_hooks_tag()
could tolerate this, since it only needs to reference the associated
alloc_tag when mem_alloc_profiling_enabled() is true and that gets
disabled by reserve_module_tags() on the overflow.
Hmm, yeah if we redirect the references into .codetag.alloc_tags, that
would be much better.
quoted
It is also not an ideal approach, but I feel it could be less intrusive
to the module loader. I can put together a prototype if needed.
If your approach does not cause module loading to fail when we disable
profiling, then that sounds like a good idea. If it's not too much
trouble, could you please send an RFC?
The alternative approach I mentioned unfortunately doesn't work well,
since redirecting all relocations against .codetag.alloc_tag to
a different destination is nontrivial. It would require introducing
something like frob_relocation() that is called from each
architecture-specific apply_relocate()/apply_relocate_add() after the
addend has been decoded.
Another option I realized is to change the order in which module
sections are allocated. Rather than interleaving the allocation of
codetag and regular sections, the module loader could first try to
allocate codetag sections and then allocate regular sections. If
allocation of a codetag section fails, it can naturally fall back to
being treated as a regular section. This avoids retrying the allocation
process, which I would prefer to avoid.
A prototype is below.
Thanks a lot for your prototype. I have reworked it with some changes,
and here is the link to the patch:
https://lore.kernel.org/all/20260831072104.120197-3-hao.ge@linux.dev/ (local)
The differences against your version are listed in the patch.
I originally planned to put you as the patch author, yet I was
concerned my modifications on top of your prototype might not be
clean due to missed corner cases. I therefore added the
Based-on-a-patch-by: trailer. I realise this might not be perfect
given that most of the credit is yours, and this is my first‑time
dealing with this scenario. This is also one motivation for sending
it as RFC. Feel free to tell me if this attribution is incorrect,
I will fix it in the final release.
Thanks
Best Regards
Hao