docs/core-api: memory-allocation: add k[mz]alloc_obj() and clarify kmalloc
Subsystems (3)
Mike Rapoport (Microsoft)
reviewercover docs/core-api: memory-allocation: add k[mz]alloc_obj() and clarify kmalloc
Update hte memory-allocation guide to describe k[mz]alloc_obj() and clarify description of kmalloc() size limitations.
And when I realized that get_maintainers.pl does not list any of mm people for that patch I added the MAINTAINERS update as well :)
---
Mike Rapoport (Microsoft) (2):
docs/core-api: memory-allocation: add k[mz]alloc_obj() and clarify kmalloc
MAINTAINERS: add memory related docs in core-mm/ to MM - MISC section
Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- MAINTAINERS | 2 ++ 2 files changed, 25 insertions(+), 7 deletions(-)
---
base-commit: cee9395acd8043be0644b25c34bfa86623f2b935
change-id: 20260831-docs-memalloc-guide-dc4db94dda96
--
Sincerely yours,
Mike.
Mike Rapoport (Microsoft)
reviewerPATCH 1/2 docs/core-api: memory-allocation: add k[mz]alloc_obj() and clarify kmalloc
Since v7.0 the most used memory allocation function is kzalloc_obj().
Update hte memory-allocation guide to describe k[mz]alloc_obj() family and make kzalloc_obj() the first answer to "How should I allocate memory?" question.
While on it, clarify description of kmalloc() size limitations.
--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)
Documentation/core-api/memory-allocation.rst +23 -7
@@ -19,6 +19,12 @@ Diversity of the allocation APIs combined with the numerous GFP flags makes the question "How should I allocate memory?" not that easy to answer, although very likely you should use +:: + + kzalloc_obj(<VAR_OR_TYPE>); + +or + :: kzalloc(<size>, GFP_KERNEL);
@@ -139,10 +145,13 @@ allocate memory for an array, there are kmalloc_array() and kcalloc() helpers. The helpers struct_size(), array_size() and array3_size() can be used to safely calculate object sizes without overflowing. -The maximal size of a chunk that can be allocated with `kmalloc` is -limited. The actual limit depends on the hardware and the kernel -configuration, but it is a good practice to use `kmalloc` for objects -smaller than page size. +Since 7.0 there are type aware kmalloc-family helpers that let you safely and +conveniently allocate a single object or arrays of objects with kzalloc_obj() +and kmalloc_obj() and their array versions kzalloc_objs() and +kmalloc_objs(). These helpers only need the type of the object that should be +allocated and the count of elements in the array for the array versions. + +As of v7.2, vast majority of the memory allocations use kzalloc_obj(). The address of a chunk allocated with `kmalloc` is aligned to at least ARCH_KMALLOC_MINALIGN bytes. For sizes which are a power of two, the
@@ -154,9 +163,16 @@ Chunks allocated with kmalloc() can be resized with krealloc(). Similarly to kmalloc_array(): a helper for resizing arrays is provided in the form of krealloc_array(). -For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the +same limit also applies to the page allocator. + +Internally, slab allocator differentiates allocations of different orders and +delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It will
Signature · 1 line
2.53.0
Quoted 4 lines · Mike Rapoport (Microsoft)
Since v7.0 the most used memory allocation function is
kzalloc_obj().Update hte memory-allocation guide to describe k[mz]alloc_obj() family
s/hte/the
Quoted 6 lines
and make
kzalloc_obj()the first answer to "How should I allocate memory?" question.While on it, clarify description of
kmalloc()size limitations.Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Quoted 63 lines
--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)Documentation/core-api/memory-allocation.rst +23
-8@@ -19,6 +19,12 @@ Diversity of the allocation APIs combined with the numerous GFP flags makes the question "How should I allocate memory?" not that easy to answer, although very likely you should use +:: + + kzalloc_obj(<VAR_OR_TYPE>); + +or + :: kzalloc(<size>, GFP_KERNEL);@@ -139,10 +145,13 @@ allocate memory for an array, there are kmalloc_array() and kcalloc() helpers. The helpers struct_size(), array_size() and array3_size() can be used to safely calculate object sizes without overflowing. -The maximal size of a chunk that can be allocated with `kmalloc` is -limited. The actual limit depends on the hardware and the kernel -configuration, but it is a good practice to use `kmalloc` for objects -smaller than page size. +Since 7.0 there are type aware kmalloc-family helpers that let you safely and +conveniently allocate a single object or arrays of objects with kzalloc_obj() +and kmalloc_obj() and their array versions kzalloc_objs() and +kmalloc_objs(). These helpers only need the type of the object that should be +allocated and the count of elements in the array for the array versions. + +As of v7.2, vast majority of the memory allocations use kzalloc_obj(). The address of a chunk allocated with `kmalloc` is aligned to at least ARCH_KMALLOC_MINALIGN bytes. For sizes which are a power of two, the@@ -154,9 +163,16 @@ Chunks allocated with kmalloc() can be resized with krealloc(). Similarly to kmalloc_array(): a helper for resizing arrays is provided in the form of krealloc_array(). -For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the +same limit also applies to the page allocator. + +Internally, slab allocator differentiates allocations of different orders and +delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It will --2.53.0
Randy Dunlap
reviewerQuoted 49 lines · Mike Rapoport (Microsoft)
Since v7.0 the most used memory allocation function is
kzalloc_obj().Update hte memory-allocation guide to describe k[mz]alloc_obj() family and make
kzalloc_obj()the first answer to "How should I allocate memory?" question.While on it, clarify description of
kmalloc()size limitations.Signed-off-by Mike Rapoport (Microsoft) <[email protected]>--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)Documentation/core-api/memory-allocation.rst +13
-4@@ -19,6 +19,12 @@ Diversity of the allocation APIs combined with the numerous GFP flags makes the question "How should I allocate memory?" not that easy to answer, although very likely you should use +:: + + kzalloc_obj(<VAR_OR_TYPE>); + +or + :: kzalloc(<size>, GFP_KERNEL);@@ -139,10 +145,13 @@ allocate memory for an array, there are kmalloc_array() and kcalloc() helpers. The helpers struct_size(), array_size() and array3_size() can be used to safely calculate object sizes without overflowing. -The maximal size of a chunk that can be allocated with `kmalloc` is -limited. The actual limit depends on the hardware and the kernel -configuration, but it is a good practice to use `kmalloc` for objects -smaller than page size. +Since 7.0 there are type aware kmalloc-family helpers that let you safely and +conveniently allocate a single object or arrays of objects with kzalloc_obj() +and kmalloc_obj() and their array versions kzalloc_objs() and +kmalloc_objs(). These helpers only need the type of the object that should be +allocated and the count of elements in the array for the array versions. + +As of v7.2, vast majority of the memory allocations use kzalloc_obj(). The address of a chunk allocated with `kmalloc` is aligned to at least ARCH_KMALLOC_MINALIGN bytes. For sizes which are a power of two, the
Documentation/core-api/memory-allocation.rst Chunks allocated with kmalloc() can be resized with krealloc(). Similarly · line 167
Quoted 8 lines
Documentation/core-api/memory-allocation.rst +2
-3@@ -154,9 +163,16 @@ Chunks allocated with kmalloc() can be resized with krealloc(). Similarly to kmalloc_array(): a helper for resizing arrays is provided in the form of krealloc_array(). -For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the
MAX_ORDER; the
Documentation/core-api/memory-allocation.rst Chunks allocated with kmalloc() can be resized with krealloc(). Similarly · line 170
Quoted 3 lines
Documentation/core-api/memory-allocation.rst +3
-0+same limit also applies to the page allocator. + +Internally, slab allocator differentiates allocations of different orders and
the slab allocator
?
Quoted 9 lines
Documentation/core-api/memory-allocation.rst +5
-0+delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It will
Signature · 1 line
~Randy
Quoted 3 lines · On Mon, 31 Aug 2026 18:13:01 +0300 "Mike Rapoport (Microsoft)"…
Since v7.0 the most used memory allocation function is
kzalloc_obj().Update hte memory-allocation guide to describe k[mz]alloc_obj() family
s/hte/the/
Quoted 4 lines
and make
kzalloc_obj()the first answer to "How should I allocate memory?" question.While on it, clarify description of
kmalloc()size limitations.
Looks good improvements to me.
Quoted 2 lines
Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Quoted 26 lines
--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)Documentation/core-api/memory-allocation.rst +6
-1@@ -19,6 +19,12 @@ Diversity of the allocation APIs combined with the numerous GFP flags makes the question "How should I allocate memory?" not that easy to answer, although very likely you should use +:: + + kzalloc_obj(<VAR_OR_TYPE>); + +or + :: kzalloc(<size>, GFP_KERNEL);@@ -139,10 +145,13 @@ allocate memory for an array, there are kmalloc_array() and kcalloc() helpers. The helpers struct_size(), array_size() and array3_size() can be used to safely calculate object sizes without overflowing. -The maximal size of a chunk that can be allocated with `kmalloc` is
Documentation/core-api/memory-allocation.rst allocate memory for an array, there are kmalloc_array() and kcalloc() · line 154
Quoted 10 lines
Documentation/core-api/memory-allocation.rst +7
-3-limited. The actual limit depends on the hardware and the kernel -configuration, but it is a good practice to use `kmalloc` for objects -smaller than page size. +Since 7.0 there are type aware kmalloc-family helpers that let you safely and +conveniently allocate a single object or arrays of objects with kzalloc_obj() +and kmalloc_obj() and their array versions kzalloc_objs() and +kmalloc_objs(). These helpers only need the type of the object that should be +allocated and the count of elements in the array for the array versions. + +As of v7.2, vast majority of the memory allocations use kzalloc_obj().
As the commit message says "Since v7.0 the most used memory allocation function is kzalloc_obj()", should we s/7.2/7.0/ ?
I also feel like the above sentence might not really needed, or can be version-neutral, e.g., Since its introduction, vast majoritiy of ... switched to use ... ? No strong opinion.
Documentation/core-api/memory-allocation.rst Chunks allocated with kmalloc() can be resized with krealloc(). Similarly · line 168
Quoted 13 lines
Documentation/core-api/memory-allocation.rst +3
-3The address of a chunk allocated with `kmalloc` is aligned to at least ARCH_KMALLOC_MINALIGN bytes. For sizes which are a power of two, the@@ -154,9 +163,16 @@ Chunks allocated with kmalloc() can be resized with krealloc(). Similarly to kmalloc_array(): a helper for resizing arrays is provided in the form of krealloc_array(). -For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the +same limit also applies to the page allocator.
I initially thought if it makes look more consistent by using kmalloc() instead of kmalloc. But seems anyway we are mixing those here and there. So I have no opinion.
Quoted 13 lines
Documentation/core-api/memory-allocation.rst +7
-0+ +Internally, slab allocator differentiates allocations of different orders and +delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It willSignature · 2 lines
-- 2.53.0
Thanks,
SJ
Quoted 9 lines · Mike Rapoport (Microsoft)
Since v7.0 the most used memory allocation function is
kzalloc_obj().Update hte memory-allocation guide to describe k[mz]alloc_obj() family and make
kzalloc_obj()the first answer to "How should I allocate memory?" question.While on it, clarify description of
kmalloc()size limitations.Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Suggestion below:
Quoted 40 lines
--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)Documentation/core-api/memory-allocation.rst +13
-4@@ -19,6 +19,12 @@ Diversity of the allocation APIs combined with the numerous GFP flags makes the question "How should I allocate memory?" not that easy to answer, although very likely you should use +:: + + kzalloc_obj(<VAR_OR_TYPE>); + +or + :: kzalloc(<size>, GFP_KERNEL);@@ -139,10 +145,13 @@ allocate memory for an array, there are kmalloc_array() and kcalloc() helpers. The helpers struct_size(), array_size() and array3_size() can be used to safely calculate object sizes without overflowing. -The maximal size of a chunk that can be allocated with `kmalloc` is -limited. The actual limit depends on the hardware and the kernel -configuration, but it is a good practice to use `kmalloc` for objects -smaller than page size. +Since 7.0 there are type aware kmalloc-family helpers that let you safely and +conveniently allocate a single object or arrays of objects with kzalloc_obj() +and kmalloc_obj() and their array versions kzalloc_objs() and +kmalloc_objs(). These helpers only need the type of the object that should be +allocated and the count of elements in the array for the array versions. + +As of v7.2, vast majority of the memory allocations use kzalloc_obj(). The address of a chunk allocated with `kmalloc` is aligned to at least ARCH_KMALLOC_MINALIGN bytes. For sizes which are a power of two, the
Documentation/core-api/memory-allocation.rst Chunks allocated with kmalloc() can be resized with krealloc(). Similarly · line 168
Quoted 9 lines
Documentation/core-api/memory-allocation.rst +3
-3@@ -154,9 +163,16 @@ Chunks allocated with kmalloc() can be resized with krealloc(). Similarly to kmalloc_array(): a helper for resizing arrays is provided in the form of krealloc_array(). -For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the +same limit also applies to the page allocator.
Would it be better to say the maximal size is KMALLOC_MAX_SIZE which is derived from page allocator's MAX_PAGE_ORDER? (Also MAX_ORDER doesn't exist anymore)
Quoted 10 lines
Documentation/core-api/memory-allocation.rst +6
-0+Internally, slab allocator differentiates allocations of different orders and +delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It will
Mike Rapoport
reviewerQuoted 7 lines · Vlastimil Babka (SUSE)
Quoted 6 lines · Mike Rapoport (Microsoft)
Since v7.0 the most used memory allocation function is
kzalloc_obj().Update hte memory-allocation guide to describe k[mz]alloc_obj() family and make
kzalloc_obj()the first answer to "How should I allocate memory?" question.
Quoted 5 lines
Quoted 3 lines
While on it, clarify description of
kmalloc()size limitations.Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Thanks!
Quoted 6 lines
Suggestion below:
Quoted 4 lines
--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)
Quoted 9 lines
Documentation/core-api/memory-allocation.rst Chunks allocated with kmalloc() can be resized with krealloc(). Similarly · line 168
Quoted 6 lines
Documentation/core-api/memory-allocation.rst +3
-3-For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the +same limit also applies to the page allocator.Would it be better to say the maximal size is
KMALLOC_MAX_SIZEwhich is derived from page allocator'sMAX_PAGE_ORDER?
My point was that whenever you allocate with kmalloc() the limit is MAX_PAGE_ORDER, not necessarily for actual slab allocations.
Quoted 1 line
(Also
MAX_ORDERdoesn't exist anymore)
Will fix.
Quoted 11 lines
Quoted 10 lines
Documentation/core-api/memory-allocation.rst +6
-0+Internally, slab allocator differentiates allocations of different orders and +delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It will
Signature · 2 lines
Sincerely yours, Mike.
Vlastimil Babka (SUSE)
reviewerQuoted 32 lines · Mike Rapoport
Quoted 7 lines · Vlastimil Babka (SUSE)
Quoted 6 lines · Mike Rapoport (Microsoft)
Since v7.0 the most used memory allocation function is
kzalloc_obj().Update hte memory-allocation guide to describe k[mz]alloc_obj() family and make
kzalloc_obj()the first answer to "How should I allocate memory?" question.Quoted 5 lines
Quoted 3 lines
While on it, clarify description of
kmalloc()size limitations.Signed-off-by Mike Rapoport (Microsoft) <[email protected]>Thanks!
Quoted 6 lines
Suggestion below:
Quoted 4 lines
--- Documentation/core-api/memory-allocation.rst | 30 +++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-)Quoted 9 lines
Documentation/core-api/memory-allocation.rst Chunks allocated with kmalloc() can be resized with krealloc(). Similarly · line 168
Quoted 6 lines
Documentation/core-api/memory-allocation.rst +3
-3-For large allocations you can use vmalloc() and vzalloc(), or directly -request pages from the page allocator. The memory allocated by `vmalloc` -and related functions is not physically contiguous. +`kmalloc` always allocates physically contiguous memory and the maximal size of +a chunk that can be allocated with `kmalloc` is limited by `MAX_ORDER`, the +same limit also applies to the page allocator.Would it be better to say the maximal size is
KMALLOC_MAX_SIZEwhich is derived from page allocator'sMAX_PAGE_ORDER?
Quoted 2 lines
My point was that whenever you allocate with
kmalloc()the limit isMAX_PAGE_ORDER, not necessarily for actual slab allocations.
The actual slab allocations limit is KMALLOC_MAX_CACHE_SIZE and that's indeed not the point and hence I wouldn't mention it here. KMALLOC_MAX_SIZE is literally a conversion of MAX_PAGE_ORDER to bytes, and since kmalloc() takes bytes and not order as an argument, it seems more natural to me, e.g.:
kmalloc always allocates physically contiguous memory and the maximal size of a chunk that can be allocated with kmalloc is limited by KMALLOC_MAX_SIZE, which matches the page allocator's MAX_PAGE_ORDER limit.
Quoted 16 lines
Quoted 1 line
(Also
MAX_ORDERdoesn't exist anymore)Will fix.
Quoted 11 lines
Quoted 10 lines
Documentation/core-api/memory-allocation.rst +6
-0+Internally, slab allocator differentiates allocations of different orders and +delegates larger allocations to the page allocator, but for the users of +`kmalloc` family it is entirely transparent. + +For large allocations that do not require physically contiguous memory you can +use vmalloc() and vzalloc() family. If you are not sure whether the allocation size is too large for `kmalloc`, it is possible to use kvmalloc() and its derivatives. It will
Mike Rapoport (Microsoft)
reviewerPATCH 2/2 MAINTAINERS: add memory related docs in core-mm/ to MM - MISC section
In reply to Mike Rapoport (Microsoft)Previous efforts to make sure that mm files are properly listed in MAINTAINERS missed
Documentation/admin-guide/mm/Documentation/core-api/memory-allocation.rst
Add them to "MEMORY MANAGEMENT - MISC"
--- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+)
MAINTAINERS +2 -0
@@ -17275,6 +17275,8 @@ F: Documentation/ABI/testing/sysfs-kernel-mm-cma F: Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers F: Documentation/ABI/testing/sysfs-kernel-mm-numa F: Documentation/admin-guide/mm/ +F: Documentation/core-api/memory-allocation.rst +F: Documentation/core-api/mm-api.rst F: Documentation/mm/ F: drivers/char/mem.c F: include/linux/cma.h
Signature · 1 line
2.53.0
Re: [PATCH 2/2] MAINTAINERS: add memory related docs in core-mm/ to MM - MISC section
Quoted 9 lines · Mike Rapoport (Microsoft)
Previous efforts to make sure that mm files are properly listed in
MAINTAINERSmissed
Documentation/admin-guide/mm/Documentation/core-api/memory-allocation.rstAdd them to "MEMORY MANAGEMENT - MISC"
Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Quoted 19 lines
--- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+)MAINTAINERS +2
-1@@ -17275,6 +17275,8 @@ F: Documentation/ABI/testing/sysfs-kernel-mm-cma F: Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers F: Documentation/ABI/testing/sysfs-kernel-mm-numa F: Documentation/admin-guide/mm/ +F: Documentation/core-api/memory-allocation.rst +F: Documentation/core-api/mm-api.rst F: Documentation/mm/ F: drivers/char/mem.c F: include/linux/cma.h --
Quoted 2 lines
2.53.0
--
Cheers, Lorenzo
Re: [PATCH 2/2] MAINTAINERS: add memory related docs in core-mm/ to MM - MISC section
In reply to Mike Rapoport (Microsoft)Quoted 7 lines · On Mon, 31 Aug 2026 18:13:02 +0300 "Mike Rapoport (Microsoft)"…
Previous efforts to make sure that mm files are properly listed in
MAINTAINERSmissed
Documentation/admin-guide/mm/Documentation/core-api/memory-allocation.rstAdd them to "MEMORY MANAGEMENT - MISC"
Makes sense to me.
Quoted 2 lines
Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Thanks,
SJ
[...]
Re: [PATCH 2/2] MAINTAINERS: add memory related docs in core-mm/ to MM - MISC section
In reply to Mike Rapoport (Microsoft)Quoted 5 lines · Mike Rapoport (Microsoft)
Previous efforts to make sure that mm files are properly listed in
MAINTAINERSmissed
Documentation/admin-guide/mm/Documentation/core-api/memory-allocation.rst
These partially don't match the actually added lines :)
Quoted 4 lines
Add them to "MEMORY MANAGEMENT - MISC"
Signed-off-by Mike Rapoport (Microsoft) <[email protected]>
Quoted 18 lines
--- MAINTAINERS | 2 ++ 1 file changed, 2 insertions(+)MAINTAINERS +2
-0@@ -17275,6 +17275,8 @@ F: Documentation/ABI/testing/sysfs-kernel-mm-cma F: Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers F: Documentation/ABI/testing/sysfs-kernel-mm-numa F: Documentation/admin-guide/mm/ +F: Documentation/core-api/memory-allocation.rst +F: Documentation/core-api/mm-api.rst F: Documentation/mm/ F: drivers/char/mem.c F: include/linux/cma.h