On Tue, Nov 17, 2026 at 11:54 PM Paul Moore paul@paul-moore.com wrote:
On Nov 17, 2026 Albert Esteve aesteve@redhat.com wrote:
Shared-memory allocator services (e.g., Android's gralloc) allocate dma-bufs on behalf of client processes in different cgroups. Today those allocations are charged to the allocator's own cgroup, leaving client cgroups with no visibility into their actual memory consumption and defeating resource limits.
This series adds memory cgroup accounting for dma-buf allocations, building on T.J. Mercier's earlier series [1] and incorporating feedback from previous versions and LPC discussions [2].
Patch 1 introduces the MEMCG_DMABUF stat and the obj_cgroup_reserve_dmabuf()/obj_cgroup_cancel_dmabuf() and mem_cgroup_commit_dmabuf()/mem_cgroup_uncharge_dmabuf() helpers in mm/memcontrol.c
Patch 2 wires up the charging policy: dma_buf_export() stores exp_info.objcg and updates the stat, a new charge_fd field in DMA_HEAP_IOCTL_ALLOC accepts a pidfd or cgroupfd to identify the target cgroup, and __GFP_ACCOUNT is removed from system-heap allocations to avoid double counting.
Patch 3 adds DMA_BUF_IOCTL_XFER_CHARGE, a general ioctl on any dma-buf fd to transfer charges post-allocation. This covers the double-hop allocator case (SurfaceFlinger -> gralloc -> kernel) and works for buffers from any exporter that opts in. Charging is gated by dmabuf->objcg being set at export time, ensuring that transfer is only applied for buffers backed by system memory where size reflects actual bytes. If the receiving cgroup lacks capacity for the charge, the ioctl returns -ENOMEM and the original charge is preserved.
Patches 4-7 add access control for cross-cgroup charging. Letting userspace decide who to charge needs to be a privileged operation because it has material impact on OOM decision and resource limits. Charging outside the caller's own memcg subtree requires CAP_SYS_RESOURCE. On top of that, LSM hooks gate the two charge_fd flavours: security_memcg_charge_task() gates the pidfd path (target identified by task credentials) and security_memcg_charge_cgroup() gates the cgroupfd path (target identified by cgroup directory label), with SELinux implementations using process2:charge_to and cgroup:charge_to permissions.
I'm probably misunderstanding the description here, but in both cases (the pidfd or cgroupfd case), ultimately the cgroup is charged, yes? In the cgroupfd case it is more direct, but in the pidfd case it is still the cgroup associated with the process identified by pidfd, yes?
Your understanding is correct here.
If that's the case - and it very well may not be (!) - it probably makes more sense to combine the two SELinux access controls into one. Yes, the LSM hooks and callbacks would likely need to be different due to the mechanics of it, but the permission check "cgroup/charge" could be the same.
Combining SELinux access controls makes sense to me. I kept them split because I wanted to preserve granularity between the two flavours, and process2 seemed like a natural fit for the pidfd path, but I guess it can still be achieved with a single permission through the target types.
I'll rework for v6. So, in the pidfd case the check target would remain the process's domain:
allow allocator_t client_t:cgroup charge_to;
where allocator_t is the domain requesting the charge (i.e., the central allocator), and client_t is the domain of the process the pidfd refers to. The groupfd path would check the cgroup directory label like so:
allow allocator_t cgroup_t:cgroup charge_to;
Would that be ok?
Patch 8 adds selftests. The tests and vmtest script were mostly written by an LLM, closely following the style of the surrounding tests and the virtme-ng setup. All code has been reviewed and tested.
I think we need to have selinux-testsuite tests to go along with this, especially as this would be the first patchset to add cgroup controls. Historically I've pushed back on piecemeal cgroup additions, pushing for some basic design of how to manage access controls for resource management first, but since evidently no one wants to do that, we really do need tests.
Agreed! I was already playing with it between the last version and this one. I have some tests drafted, more or less. I was unfamiliar with the testsuite, so instead of offloading the work to an LLM, I tried to follow along and proceeded too slowly.
I will link a PR when sending the next version.
Known limitations:
- Single-owner model: a dma-buf carries one memcg charge regardless of how many processes share it.
Once again, I'm sure I'm misunderstanding things, but are you saying that multiple cgroups can end up sharing the same dma-buf despite only one of the cgroups taking the accounting hit?
Yes, you are correct. A dma-buf (its fd) can be shared by multiple processes from multiple cgroups, but only one holds the charge. With this series it can be transferred, but never shared.
Sharing could be a follow-up series. Perhaps splitting the charge equally? But sharing is a big problem on its own, so I preferred to keep it out of this series.
Hopefully the charged cgroup is deterministic?
Yes, the charged cgroup is deterministic: it is set at allocation, and only moves via an explicit ioctl.
- Only memcg accounting. CMA heaps would additionally need dmem controller integration.
Do you have a rough idea of how that would work? I ask only because I'm interested in seeing if that would require an additional LSM hook or if there is some way we could leverage the same hook(s) used here.
Rough idea, yes. Today, no dma-buf allocation charges dmem at all, and of course no target charging either. The first goal for CMA is simply getting those heaps accounted. In that regard, Eric Chanudet has a series making CMA allocations memcg-accountable with per-area counter [1], and is working on extending that approach to dmem. It's a bit on hold waiting for the feedback on this series.
But afaik the cross-cgroup charging and central allocator problem is mainly a system-memory one. Whether dmem ever needs the same cross-cgroup attribution (e.g., DRM central allocator wanting to charge clients' dmem budgets) is not clear to me.
Nonetheless, if it does, the internals should be mostly the same; everything, including the permission checks is controller-agnostic. Only the controller performing the charge changes. I expect no additional hook is required.
[1] https://lore.kernel.org/all/20260821-cma-memcg-regions-v1-0-d21b165b8440@red...
- If a transfer of an uncharged buffer fails, the buffer remains charged to the original cgroup. The allocator (userspace) is expected to handle this (retry, free, ...).
- The LSM hooks are intentionally narrow. Broader cgroup access controls (e.g. for the memfd/kexec handover case [2]) could be a separate effort reusing the same pattern.
- Only system heap sets exp_info.objcg today. Other exporters (DRM, V4L2, etc.) can opt in by setting it, but are not covered by this series.
- Related to the above: lazy backing-store allocation is not supported. This can be extended later, e.g., by adding a flag on the dma-buf struct for explicitly marking when memory is committed.
Similar to the CMA case, any rough ideas on what this would look like?
Yes, again I have a rough idea. We already separate reserve and commit operations, so the idea is to delay when a charge is committed. For that we can use a flag in the dma-buf struct to mark when the memory is committed. The limit is still enforced up front (so a lazy exporter cannot overcommit), and the stat reflects the actual allocation.
The permission model is also unchanged for this case. The flag only affects when the stat will reflect the charge.
Thanks! Albert.
Note on TTM/GPU accounting [3]: that effort charges system memory allocated for GPU buffers per page, with its own stats (gpu_active and gpu_reclaim). This series charges at the dma-buf level, for memory with no memory.stat category of its own; exporters whose memory is already charged by their allocator must not opt in, so the two do not overlap.
[1] https://lore.kernel.org/cgroups/20230109213809.418135-1-tjmercier@google.com... [2] https://lpc.events/event/20/contributions/2416/ [3] https://lore.kernel.org/all/20260706052330.1110909-1-airlied@gmail.com/
Signed-off-by: Albert Esteve aesteve@redhat.com
-- paul-moore.com