Skip to content

[Bugfix][TransferEngine] Register HugeTLB sub-views as whole huge pages - #5215

Open
NUABO wants to merge 2 commits into
kvcache-ai:mainfrom
NUABO:fix-hugetlb-subview-reg
Open

NUABO wants to merge 2 commits into
kvcache-ai:mainfrom
NUABO:fix-hugetlb-subview-reg

Conversation

@NUABO

@NUABO NUABO commented Nov 3, 2026 •

Copy link
Copy Markdown
Collaborator

Description

ibv_fork_init() makes ibv_reg_mr() run MADV_DONTFORK over the range it is handed, and the kernel refuses to split a hugetlb VMA at a boundary that falls inside a huge page. A caller that registers a view of a larger hugepage-backed mapping rather than the mapping itself therefore failed with EINVAL below libibverbs, which surfaced as a generic registration error and left such callers unable to use RDMA at all.

Widen such a registration outward to the enclosing huge pages before ibv_reg_mr is called, and deregister through that widened base. Both widened ends are hugepage boundaries and a hugetlb VMA is a whole number of those, so a request that lies inside its mapping stays inside it after widening. The published BufferDesc keeps the caller's addr/length so peers cannot reach the alignment padding, and the metadata entry stays at the caller's address.

A registration that would be both widened and chunked is refused: chunking would have to publish the padded chunks and make the padding addressable by peers. Such a request failed with EINVAL before the widening existed.

Track the range of every live hugetlb-backed MR, not only the widened ones, and refuse a registration whose range overlaps one. Overlap, not a shared base, is the criterion: RdmaContext's MR map silently drops an MR registered at a duplicate key, and unregisterMemoryRegion() madvises MADV_DOFORK over the whole MR range (issue #3639), which must not be re-opened while a second MR still covers part of it. The check and the claim are one atomic step, because a batch registration runs one worker per buffer.

A claim is released only once no MR of that registration is left. A rollback whose ibv_dereg_mr fails keeps the claim of the MR that survived and records the bookkeeping unregisterLocalMemory() needs to finish that cleanup, so a failed registration cannot strand those huge pages for the life of the process.

Add rdma_hugetlb_subview_test covering a misaligned sub-view, an already aligned registration, and both orders of a same-hugepage collision. Tighten the store's interior-sub-range test to require the registration to succeed, since the transport now handles it rather than leaving it to fail.

Suggested Merge Priority

  • P0 — Urgent: Critical security vulnerability, data loss/corruption, or widespread production outage requiring immediate action
  • P1 — High: Significant correctness or stability issue in existing functionality, or a regression blocking users without a practical workaround
  • P2 — Normal: Routine bug fix, validated performance/compatibility improvement, or new feature for a confirmed use case
  • P3 — Low: Experimental feature, optional enhancement, refactoring, or cleanup with no urgent user impact

Module

  • Transfer Engine (mooncake-transfer-engine)
  • Mooncake Store (mooncake-store)
  • Mooncake Conductor (mooncake-conductor)
  • Reshard (mooncake-reshard)
  • Mooncake EP (mooncake-ep)
  • Mooncake PG (mooncake-pg)
  • Integration (mooncake-integration)
  • P2P Store (mooncake-p2p-store)
  • Python Wheel (mooncake-wheel)
  • Common (mooncake-common)
  • Mooncake RL (mooncake-rl)
  • CI/CD
  • Docs
  • Other

Type of Change

  • Bug fix
  • New feature
  • Refactor
  • Breaking change
  • Documentation update
  • Performance improvement
  • Other

How Has This Been Tested?

Test commands:

# Example: bash scripts/run_ci_test.sh

Test results:

  • Unit tests pass
  • Integration tests pass (if applicable)
  • Manual testing done (describe below)

Checklist

  • Every commit I contribute includes my Signed-off-by trailer certifying the DCO
  • I have performed a self-review of my own code
  • I have formatted my code using ./scripts/code_format.sh
  • I have run pre-commit on the files changed in this PR and all hooks pass
  • I have updated the documentation (if applicable)
  • I have added tests to prove my changes are effective
  • For changes >500 LOC: I have filed an RFC issue

AI Assistance Disclosure

  • No AI tools were used
  • AI tools were used (specify below)

@github-actions github-actions Bot added run-ci Store Transfer Engine size/M 100-1000 changed lines (additions + deletions) labels Nov 3, 2026
@NUABO NUABO changed the title [TransferEngine] Register HugeTLB sub-views as whole huge pages [Bugfix][TransferEngine] Register HugeTLB sub-views as whole huge pages Nov 4, 2026

@alogfans alogfans left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM

@ykwd
ykwd requested a review from Icedcoco November 6, 2026 10:02
@Icedcoco

Icedcoco commented Nov 8, 2026

Copy link
Copy Markdown
Collaborator

Thanks for working on HugeTLB sub-view support. I had a few questions about the registration and cleanup behavior and wanted to check my understanding:

  1. In unregisterLocalMemoryBatch(), if MR cleanup succeeds but the deferred metadata publication fails, the hugepage claim and alias have already been released, while the caller’s address is added back to pending_dereg_. Could another logically disjoint view of the same hugepage then register successfully? If so, retrying the original unregister appears to reach findMemoryRegionContaining() with the old address, which could now resolve to the newer view’s MR. Would distinguishing a metadata-only retry from pending MR cleanup help here, or is there an invariant that prevents this sequence?

  2. Keeping the original range in BufferDesc makes sense for the normal TE bounds checks. With remote_accessible=true, though, the published rkey belongs to the widened MR, so the RNIC appears to authorize access to the surrounding padding as well. Is that broader hardware access range acceptable under the intended trust model? It might be worth clarifying this assumption, or considering whether the original hardware bounds should be preserved.

  3. For environments where RDMAV_HUGEPAGES_SAFE=1 already allows registration of the original ranges, could the new overlap check reject previously valid, non-overlapping views within the same hugepage? Similarly, the widened-and-chunked rejection seems to introduce an additional restriction. Would these compatibility cases merit a different handling strategy?

Do you think any of these cases would benefit from changes? I’d appreciate your perspective, particularly if there are assumptions or guarantees I’ve overlooked.

@NUABO

NUABO commented Nov 9, 2026

Copy link
Copy Markdown
Collaborator Author

Thanks for working on HugeTLB sub-view support. I had a few questions about the registration and cleanup behavior and wanted to check my understanding:

  1. In unregisterLocalMemoryBatch(), if MR cleanup succeeds but the deferred metadata publication fails, the hugepage claim and alias have already been released, while the caller’s address is added back to pending_dereg_. Could another logically disjoint view of the same hugepage then register successfully? If so, retrying the original unregister appears to reach findMemoryRegionContaining() with the old address, which could now resolve to the newer view’s MR. Would distinguishing a metadata-only retry from pending MR cleanup help here, or is there an invariant that prevents this sequence?
  2. Keeping the original range in BufferDesc makes sense for the normal TE bounds checks. With remote_accessible=true, though, the published rkey belongs to the widened MR, so the RNIC appears to authorize access to the surrounding padding as well. Is that broader hardware access range acceptable under the intended trust model? It might be worth clarifying this assumption, or considering whether the original hardware bounds should be preserved.
  3. For environments where RDMAV_HUGEPAGES_SAFE=1 already allows registration of the original ranges, could the new overlap check reject previously valid, non-overlapping views within the same hugepage? Similarly, the widened-and-chunked rejection seems to introduce an additional restriction. Would these compatibility cases merit a different handling strategy?

Do you think any of these cases would benefit from changes? I’d appreciate your perspective, particularly if there are assumptions or guarantees I’ve overlooked.

Thanks @Icedcoco review, these are all fair, and the first one is a real bug.

  1. Yes, that sequence is reachable, and it does deregister the wrong MR.
    In unregisterLocalMemoryBatch() every member completes unregisterLocalMemoryInternal() — MRs deregistered, hugetlb_registered_regions_ claim and hugepage_widen_aliases_
    entry released — and then the single deferred updateLocalSegmentDesc() fails and the members are re-seeded into pending_dereg_. A disjoint view of the same hugepage can
    register in that window, and the retry then runs with widened == false, so unregisterMemoryRegion(addr) goes through findMemoryRegionContaining() and resolves to the newer
    view's MR, deregistering it and madvising its whole range. The metadata_missing gate was meant to prevent exactly this, but re-seeding into pending_dereg_ asserts the
    opposite of what it needs.

We'll split the state: pending_dereg_ keeps its meaning (metadata gone, MR may still be live, retry must do the MR cleanup), and a separate pending_republish_ records the
case you describe (MRs confirmed gone, claim and alias released, only the publish outstanding). A retry in that state republishes and never reaches the MR lookup. That
covers the single-buffer path, the chunked path and the batch path.

  1. Agreed on the exposure; we'll state it. The published rkey is the widened MR's, so a peer holding it can address the padding. Keeping the original hardware bounds isn't
    expressible here: IBV access rights are per-MR and an rkey is not a sub-range capability, while the MR has to cover whole huge pages or it cannot be created at all. What
    the published range still buys is that a correctly-behaving peer only ever computes addresses inside the caller's own view. Mitigating: the padding belongs to the same
    mapping the caller handed us a sub-view of, and the overlap check guarantees no separately registered region can live there. We'll document both the widened range and that
    trust assumption.

  2. You're right, that is a regression we introduced. Under RDMAV_HUGEPAGES_SAFE=1 / IBV_FORK_UNNEEDED two non-overlapping sub-views of one hugepage used to register; our
    overlap check now refuses the second, and the widened-and-chunked rejection likewise. Since we call ibv_fork_init() ourselves, the fix we have in mind is to detect that
    fork protection is opted out and skip the widening together with the whole claim/overlap bookkeeping, restoring the previous behaviour exactly. The more robust alternative
    is to attempt the caller's range first and widen only on EINVAL, which needs no environment probing but has to make the claim atomic across the retry — happy to hear
    which you'd prefer.

@Icedcoco Icedcoco left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The proposed pending_republish_ split sounds like the right direction: once MR cleanup is confirmed, a metadata-only retry should never reach MR lookup again. Would you be open to adding a regression test for the sequence we discussed—cleanup of A, publication failure, registration of a disjoint view B in the same hugepage, then retrying A—and checking that B remains registered? Coverage across the single-buffer, chunked, and batch paths would help establish the intended behavior.

On the widened access range, documenting the trust assumption would help. One detail I would still like to clarify is that padding can contain other application data even when it has no separate registration. The overlap check prevents another registration there, but does not establish that those bytes belong exclusively to the requested view. Would it make sense to state explicitly that callers using the widening path must be comfortable exposing the entire widened range to peers holding the key?

For compatibility, I would lean toward trying the original range first and using widening as a fallback, subject to the cleanup and ownership details. That would preserve the original hardware bounds wherever registration already works. A small terminology clarification: RDMAV_HUGEPAGES_SAFE enables hugepage-aware fork handling rather than disabling fork protection, while IBV_FORK_UNNEEDED is a status returned by ibv_is_fork_initialized().

For the fallback, could we limit it to known HugeTLB host sub-views and preserve the original failure reason, since EINVAL alone is not specific to this issue? It would also be helpful to ensure that any successful registrations on other NICs are fully rolled back before retrying, and that range reservations remain consistent across both attempts.

Would this approach fit what you have in mind?

@NUABO

NUABO commented Nov 10, 2026 •

Copy link
Copy Markdown
Collaborator Author

The proposed pending_republish_ split sounds like the right direction: once MR cleanup is confirmed, a metadata-only retry should never reach MR lookup again. Would you be open to adding a regression test for the sequence we discussed—cleanup of A, publication failure, registration of a disjoint view B in the same hugepage, then retrying A—and checking that B remains registered? Coverage across the single-buffer, chunked, and batch paths would help establish the intended behavior.

On the widened access range, documenting the trust assumption would help. One detail I would still like to clarify is that padding can contain other application data even when it has no separate registration. The overlap check prevents another registration there, but does not establish that those bytes belong exclusively to the requested view. Would it make sense to state explicitly that callers using the widening path must be comfortable exposing the entire widened range to peers holding the key?

For compatibility, I would lean toward trying the original range first and using widening as a fallback, subject to the cleanup and ownership details. That would preserve the original hardware bounds wherever registration already works. A small terminology clarification: RDMAV_HUGEPAGES_SAFE enables hugepage-aware fork handling rather than disabling fork protection, while IBV_FORK_UNNEEDED is a status returned by ibv_is_fork_initialized().

For the fallback, could we limit it to known HugeTLB host sub-views and preserve the original failure reason, since EINVAL alone is not specific to this issue? It would also be helpful to ensure that any successful registrations on other NICs are fully rolled back before retrying, and that range reservations remain consistent across both attempts.

Would this approach fit what you have in mind?

hi @Icedcoco Thanks! all three land, and your terminology correction is right on both
counts:

1. Retry after a failed publication. Confirmed, and it is not only the single-buffer path. unregisterLocalMemoryBatch() re-seeds every member it cleaned into pending_dereg_ when the deferred updateLocalSegmentDesc() fails, and those members have already had their MRs deregistered and their claim and alias released. On the retry the alias is gone, so unregisterLocalMemoryInternal() falls through to the plain address, findMemoryRegionContaining() resolves to whatever now covers it, and unregisterMemoryRegion() deregisters that MR and madvises MADV_DOFORK over its whole range. We'll split the state exactly as you describe: pending_dereg_ keeps "the MR may still be live, the retry must do the MR cleanup", and a separate pending_republish_ covers "MRs confirmed gone, claim and alias released, only the publish outstanding", whose retry never reaches the MR lookup. Single-buffer, chunked and batch all go through it. Worth noting the re-seed predates this PR — the batch path could already aim at a re-registration of the same range — the widening only makes the window wider. We'll fix it here rather than file it separately.

2. Widened access range. Agreed, and your addition is the part that matters: the overlap check proves no second registration lives in the padding, but says nothing about bytes of the same mapping that were never registered at all — in our motivating case the two halves of one ShmHelper segment are exactly that. So we'll state it as an explicit caller contract rather than an internal invariant: using the widening path means accepting that the entire widened range is reachable by any peer holding the published key. We won't try to preserve the original hardware bounds — access rights are per-MR and the MR has to cover whole huge pages — but the published BufferDesc keeps the caller's range, so a correctly-behaving peer only ever computes addresses inside the caller's own view.

3. Compatibility. You're right, and our earlier framing was wrong; thanks for catching it. RDMAV_HUGEPAGES_SAFE does not disable fork protection — it makes ibv_madvise_range() take KernelPageSize from smaps and align the madvise range outward to whole pages, which is precisely why misaligned hugetlb sub-ranges register fine there. And IBV_FORK_UNNEEDED is an ibv_is_fork_initialized() status meaning the kernel copies DMA pages on fork, which is unrelated. Probing either would have been the wrong discriminator, so we're dropping that approach.

On the fallback. We'll take it: attempt the caller's range first and widen only on EINVAL, gated on the existing hugetlb detection (host-registration dmabuf export, plus detectBufferPageSize() reporting larger than the runtime base page), so an EINVAL unrelated to huge pages never reaches the widening. Concretely:

  • A failed attempt rolls back every context that did succeed before the widened retry, and if both attempts fail we return the first error, so the
    reported reason matches what the caller saw before this change.
  • The claim stays atomic across both attempts: we serialize the whole narrow-then-wide sequence under the registry mutex instead of pre-claiming the widened range, which would otherwise refuse disjoint views that can legitimately register narrow.
  • If the first attempt succeeds, nothing is claimed as widened and nothing is exposed beyond the caller's range.

On the regression test. Happy to add that sequence, with one constraint worth knowing up front: TransferMetadata::updateLocalSegmentDesc() is non-virtual and the transport owns a concrete shared_ptr<TransferMetadata>, so a publication failure cannot be injected today — it needs a small seam (a test-only failure hook, or routing those calls through an interface). We can add that here. The test class also needs a real RDMA device and a reserved 2 MiB hugepage, so it self-skips on hardware-free CI: the coverage is real locally but not in CI unless we also build a device-free harness.

One thing we won't silently claim to restore: unregister still madvises MADV_DOFORK over the MR's exact range, so for a narrow registration inside a hugepage that call fails with EINVAL — the same kernel restriction, which libibverbs works around by widening its own range and retrying per page. That is pre-existing and orthogonal, but it means "exactly the previous behaviour" leaves each such huge page DOFORK-blocked after unregister. We can widen that range too if you think it belongs in this PR; otherwise we'll file it separately.

I plan to make the above fixes in this PR and iterate until we reach the expected outcome. Once the implementation is complete, I'd appreciate it if you could review it again. Please let me know if there are any other issues you'd like me to address.

@Aionw Aionw left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

LGTM for store side

@NUABO

NUABO commented Nov 12, 2026

Copy link
Copy Markdown
Collaborator Author

The proposed pending_republish_ split sounds like the right direction: once MR cleanup is confirmed, a metadata-only retry should never reach MR lookup again. Would you be open to adding a regression test for the sequence we discussed—cleanup of A, publication failure, registration of a disjoint view B in the same hugepage, then retrying A—and checking that B remains registered? Coverage across the single-buffer, chunked, and batch paths would help establish the intended behavior.

On the widened access range, documenting the trust assumption would help. One detail I would still like to clarify is that padding can contain other application data even when it has no separate registration. The overlap check prevents another registration there, but does not establish that those bytes belong exclusively to the requested view. Would it make sense to state explicitly that callers using the widening path must be comfortable exposing the entire widened range to peers holding the key?

For compatibility, I would lean toward trying the original range first and using widening as a fallback, subject to the cleanup and ownership details. That would preserve the original hardware bounds wherever registration already works. A small terminology clarification: RDMAV_HUGEPAGES_SAFE enables hugepage-aware fork handling rather than disabling fork protection, while IBV_FORK_UNNEEDED is a status returned by ibv_is_fork_initialized().

For the fallback, could we limit it to known HugeTLB host sub-views and preserve the original failure reason, since EINVAL alone is not specific to this issue? It would also be helpful to ensure that any successful registrations on other NICs are fully rolled back before retrying, and that range reservations remain consistent across both attempts.

Would this approach fit what you have in mind?

hi @Icedcoco Thanks for the review! I've pushed changes for all three points: split pending_dereg_ / pending_republish_ so the republish path never does an MR lookup, documented the padding exposure as a caller contract on registerLocalMemory, and made registration narrow-first with widening only on EINVAL. Also added state-machine and HugeTLB tests plus extended the hardware hugepage test.

Would appreciate another look when you have a moment, thanks!

@github-actions github-actions Bot added size/L 1001+ changed lines (additions + deletions) and removed size/M 100-1000 changed lines (additions + deletions) labels Nov 12, 2026

@Icedcoco Icedcoco left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Static review of head d5814f7: the retry-state split, narrow-first EINVAL fallback, rollback handling, and caller contract address the review concerns. I found no code-level blocker under the documented trusted-peer assumption. This branch currently conflicts with main; before merging, resolve the conflicts while preserving main's RDMA metadata ownership filtering and libibverbs-based deregistration behavior. This was a static-only review; no build or tests were run.

ibv_fork_init() makes ibv_reg_mr() run MADV_DONTFORK over the range it is
handed, and the kernel refuses to split a hugetlb VMA at a boundary that falls
inside a huge page. A caller that registers a view of a larger hugepage-backed
mapping rather than the mapping itself therefore failed with EINVAL below
libibverbs, which surfaced as a generic registration error and left such callers
unable to use RDMA at all.

Widen such a registration outward to the enclosing huge pages before ibv_reg_mr
is called, and deregister through that widened base. Both widened ends are
hugepage boundaries and a hugetlb VMA is a whole number of those, so a request
that lies inside its mapping stays inside it after widening. The published
BufferDesc keeps the caller's addr/length so peers cannot reach the alignment
padding, and the metadata entry stays at the caller's address.

A registration that would be both widened and chunked is refused: chunking would
have to publish the padded chunks and make the padding addressable by peers.
Such a request failed with EINVAL before the widening existed.

Track the range of every live hugetlb-backed MR, not only the widened ones, and
refuse a registration whose range overlaps one. Overlap, not a shared base, is
the criterion: RdmaContext's MR map silently drops an MR registered at a
duplicate key, and unregisterMemoryRegion() madvises MADV_DOFORK over the whole
MR range (issue kvcache-ai#3639), which must not be re-opened while a second MR still
covers part of it. The check and the claim are one atomic step, because a batch
registration runs one worker per buffer.

A claim is released only once no MR of that registration is left. A rollback
whose ibv_dereg_mr fails keeps the claim of the MR that survived and records the
bookkeeping unregisterLocalMemory() needs to finish that cleanup, so a failed
registration cannot strand those huge pages for the life of the process.

Add rdma_hugetlb_subview_test covering a misaligned sub-view, an already
aligned registration, and both orders of a same-hugepage collision. Tighten the
store's interior-sub-range test to require the registration to succeed, since
the transport now handles it rather than leaving it to fail.

Signed-off-by: tan changzhi <544463199@qq.com>
@NUABO
NUABO force-pushed the fix-hugetlb-subview-reg branch from d5814f7 to db58510 Compare November 16, 2026 01:54
@NUABO

NUABO commented Nov 16, 2026

Copy link
Copy Markdown
Collaborator Author

hi @Icedcoco I've rebased onto current main (7a34af8) and force-pushed — head is now db58510, Would you mind taking another look when you get a chance? Thanks! The conflicts were in rdma_transport.h, rdma_transport.cpp and rdma_context.cpp. How they were resolved:

  • libibverbs-based deregistration: rdma_context.cpp takes main's side. The branch's madvise(MADV_DOFORK) in unregisterMemoryRegion() is dropped — since [Bugfix][TE] Restore fork state on memory unregister to prevent VMA exhaustion (#3639) #3660 was reverted
    upstream, ibv_dereg_mr() restores the fork state and this branch no longer touches it.
  • Metadata ownership filtering: isOwnRdmaDesc is preserved on every removal this branch performs (rollback, chunk, widened alias). One site needed more than a textual merge:
    the new pending_republish_ retry called the two-argument removeLocalMemoryBuffer(key, ...), which erases the first entry at that address regardless of owner. If another
    transport's descriptor sits there first, it would delete theirs, report success, and then clearPending(), leaving our own stale descriptor advertised with deregistered
    keys. That call now passes isOwnRdmaDesc.
  • HYLINK: main's clearSkipRegistration() and both early returns are kept. The pending_republish_ block stays first in unregisterLocalMemoryInternal() as this branch
    requires; the two address sets are disjoint by construction (the batch path excludes HyLink members from cleaned_addrs), so neither check can shadow the other.

Because the branch now defers to libibverbs rather than madvising, three comments still described MADV_DOFORK at unregister time. They now give the reasons that still hold:
duplicate-base overwrite in the MR map, and unregisterMemoryRegion() resolving by containing range.

I checked the rebase against both parents — no line present in both main and the previous head is missing from the result.

@NUABO
NUABO force-pushed the fix-hugetlb-subview-reg branch from db58510 to fb9edfd Compare November 16, 2026 02:23
…r state

Try the caller's range first and widen to the enclosing huge pages only when
ibv_reg_mr reports EINVAL. This restores registrability of disjoint sub-views
of one huge page (which worked under RDMAV_HUGEPAGES_SAFE=1) and avoids
exposing padding unless the hardware forces the widening. Surface EINVAL from
the context layer as an internal error code and translate it back to
ERR_CONTEXT before any public return.

Split the pending unregister state into pending_dereg_ (the MR may still be
live, so a retry must re-enter the per-context MR cleanup) and
pending_republish_ (every MR is confirmed gone and only the final
updateLocalSegmentDesc() is outstanding, so a retry must never perform an MR
lookup). Previously a retry could deregister a newer registration's live MR
through the range lookup. A chunked orphan bookkeeping record now supersedes
any stale republish entry at the same address, keeping surviving MRs
reachable from the caller address.

Also publish a chunked unregistration's removals even when a chunk's
deregistration failed: the local desc no longer lists them either way, and a
stale advertisement keeps peers targeting MRs that are gone on some contexts.

Document the caller contract: the widened MR and its published keys cover
whole huge pages, so a peer can address padding that may hold application data
never registered; callers unwilling to expose it must register hugepage-
aligned mappings themselves.

Tests: device-free unregister state-machine tests (fake verbs, armable storage
plugin publish failures), HugeTLB tests with fake MRs emulating ibv_fork_init,
and an extended hardware hugepage test.

Signed-off-by: tan changzhi <544463199@qq.com>
@NUABO
NUABO force-pushed the fix-hugetlb-subview-reg branch from fb9edfd to c8c8b7f Compare November 16, 2026 03:47

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

run-ci size/L 1001+ changed lines (additions + deletions) Store Transfer Engine

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants