libnvdimm/altmap: Track namespace boundaries in altmap
Subsystems (3)
PATCH 1/2 libnvdimm/altmap: Track namespace boundaries in altmap
With PFN_MODE_PMEM namespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.
When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
This fix kernel crash reported below:
[ 132.034989] WARNING: CPU: 13 PID: 13719 at mm/memremap.c:133 devm_memremap_pages_release+0x2d8/0x2e0 [ 133.464754] BUG: Unable to handle kernel data access at 0xc00c00010b204000 [ 133.464760] Faulting instruction address: 0xc00000000007580c [ 133.464766] Oops: Kernel access of bad area, sig: 11 [#1] [ 133.464771] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries ..... [ 133.464901] NIP [c00000000007580c] vmemmap_free+0x2ac/0x3d0 [ 133.464906] LR [c0000000000757f8] vmemmap_free+0x298/0x3d0 [ 133.464910] Call Trace: [ 133.464914] [c000007cbfd0f7b0] [c0000000000757f8] vmemmap_free+0x298/0x3d0 (unreliable) [ 133.464921] [c000007cbfd0f8d0] [c000000000370a44] section_deactivate+0x1a4/0x240 [ 133.464928] [c000007cbfd0f980] [c000000000386270] __remove_pages+0x3a0/0x590 [ 133.464935] [c000007cbfd0fa50] [c000000000074158] arch_remove_memory+0x88/0x160 [ 133.464942] [c000007cbfd0fae0] [c0000000003be8c0] devm_memremap_pages_release+0x150/0x2e0 [ 133.464949] [c000007cbfd0fb70] [c000000000738ea0] devm_action_release+0x30/0x50 [ 133.464955] [c000007cbfd0fb90] [c00000000073a5a4] release_nodes+0x344/0x400 [ 133.464961] [c000007cbfd0fc40] [c00000000073378c] device_release_driver_internal+0x15c/0x250 [ 133.464968] [c000007cbfd0fc80] [c00000000072fd14] unbind_store+0x104/0x110 [ 133.464973] [c000007cbfd0fcd0] [c00000000072ee24] drv_attr_store+0x44/0x70 [ 133.464981] [c000007cbfd0fcf0] [c0000000004a32bc] sysfs_kf_write+0x6c/0xa0 [ 133.464987] [c000007cbfd0fd10] [c0000000004a1dfc] kernfs_fop_write+0x17c/0x250 [ 133.464993] [c000007cbfd0fd60] [c0000000003c348c] __vfs_write+0x3c/0x70 [ 133.464999] [c000007cbfd0fd80] [c0000000003c75d0] vfs_write+0xd0/0x250
--- arch/powerpc/mm/init_64.c | 17 ++++++++++++++++- drivers/nvdimm/pfn_devs.c | 2 ++ include/linux/memremap.h | 1 + 3 files changed, 19 insertions(+), 1 deletion(-)
arch/powerpc/mm/init_64.c +16 -1
@@ -172,6 +172,21 @@ static __meminit void vmemmap_list_populate(unsigned long phys, vmemmap_list = vmem_back; } +static bool altmap_cross_boundary (struct vmem_altmap *altmap,unsigned long start, +unsigned long page_size) +{ +unsigned long nr_pfn = page_size /sizeof (struct page ); +unsigned long start_pfn =page_to_pfn ((struct page *)start); + +if ((start_pfn + nr_pfn) > altmap->end_pfn) +return true; + +if (start_pfn < altmap->base_pfn) +return true; + +return false; +} +int __meminit vmemmap_populate (unsigned long start,unsigned long end,int node,struct vmem_altmap *altmap) {
@@ -194,7 +209,7 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,* fail due to alignment issues when using 16MB hugepages, so * fall back to system memory if the altmap allocation fail. */ -if (altmap) { +if (altmap && !altmap_cross_boundary (altmap, start, page_size)) { p =altmap_alloc_block_buf (page_size, altmap);if (!p)pr_debug ("altmap block allocation failed, falling back to system memory" );
drivers/nvdimm/pfn_devs.c +2 -0
@@ -618,9 +618,11 @@ static int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap)struct nd_namespace_common *ndns = nd_pfn->ndns;struct nd_namespace_io *nsio =to_nd_namespace_io (&ndns->dev);resource_size_t base = nsio->res.start + start_pad; +resource_size_t end = nsio->res.end - end_trunc;struct vmem_altmap __altmap = { .base_pfn =init_altmap_base (base), .reserve =init_altmap_reserve (base), + .end_pfn =PHYS_PFN (end), };memcpy (res, &nsio->res,sizeof (*res));
include/linux/memremap.h +1 -0
@@ -17,6 +17,7 @@ struct device;*/ struct vmem_altmap {const unsigned long base_pfn; +const unsigned long end_pfn;const unsigned long reserve;unsigned long free;unsigned long align;
Signature · 6 lines
2.21.0 _______________________________________________ Linux-nvdimm mailing list [email protected] https://lists.01.org/mailman/listinfo/linux-nvdimm
PATCH 2/2 powerpc/nvdimm: Update vmemmap_populated to check sub-section range
With commit: 7cc7867fb061 ("mm/devm_memremap_pages: enable sub-section remap") pmem namespaces are remapped in 2M chunks. On architectures like ppc64 we can map the memmap area using 16MB hugepage size and that can cover a memory range of 16G.
While enabling new pmem namespaces, since memory is added in sub-section chunks, before creating a new memmap mapping, kernel should check whether there is an existing memmap mapping covering the new pmem namespace. Currently, this is validated by checking whether the section covering the range is already initialized or not. Considering there can be multiple namespaces in the same section this can result in wrong validation. Update this to check for sub-sections in the range. This is done by checking for all pfns in the range we are mapping.
We could optimize this by checking only just one pfn in each sub-section. But since this is not fast-path we keep this simple.
--- arch/powerpc/mm/init_64.c | 45 ++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 22 deletions(-)
arch/powerpc/mm/init_64.c +23 -22
@@ -70,30 +70,24 @@ EXPORT_SYMBOL_GPL(kernstart_addr);#ifdef CONFIG_SPARSEMEM_VMEMMAP /* -* Given an address within the vmemmap, determine the pfn of the page that -* represents the start of the section it is within. Note that we have to -* do this by hand as the proffered address may not be correctly aligned. -* Subtraction of non-aligned pointers produces undefined results. -*/ -static unsigned long __meminit vmemmap_section_start (unsigned long page) -{ -unsigned long offset = page - ((unsigned long )(vmemmap)); - -/* Return the pfn of the start of the section. */ -return (offset /sizeof (struct page )) &PAGE_SECTION_MASK ; -} - -/* -* Check if this vmemmap page is already initialised. If any section +* Check if this vmemmap page is already initialised. If any sub section * which overlaps this vmemmap page is initialised then this page is * initialised already. */ -static int __meminit vmemmap_populated (unsigned long start,int page_size) + +static int __meminit vmemmap_populated (unsigned long start,int size) { -unsigned long end = start + page_size; - start = (unsigned long )(pfn_to_page (vmemmap_section_start (start))); +unsigned long end = start + size; -for (; start < end; start += (PAGES_PER_SECTION *sizeof (struct page ))) +/* start is size aligned and it is always > sizeof(struct page) */ +VM_BUG_ON (start &sizeof (struct page )); +for (; start < end; start +=sizeof (struct page )) +/* +* pfn valid check here is intended to really check +* whether we have any subsection already initialized +* in this range. We keep it simple by checking every +* pfn in the range. +*/ if (pfn_valid (page_to_pfn ((struct page *)start)))return 1 ;
@@ -201,6 +195,12 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,void *p =NULL ;int rc; +/* +* This vmemmap range is backing different subsections. If any +* of that subsection is marked valid, that means we already +* have initialized a page table covering this range and hence +* the vmemmap range is populated. +*/ if (vmemmap_populated (start, page_size))continue ;
@@ -290,9 +290,10 @@ void __ref vmemmap_free(unsigned long start, unsigned long end,struct page *page;/* -* the section has already be marked as invalid, so -* vmemmap_populated() true means some other sections still -* in this page, so skip it. +* We have already marked the subsection we are trying to remove +* invalid. So if we want to remove the vmemmap range, we +* need to make sure there is no subsection marked valid +* in this range. */ if (vmemmap_populated (start, page_size))continue ;
Signature · 6 lines
2.21.0 _______________________________________________ Linux-nvdimm mailing list [email protected] https://lists.01.org/mailman/listinfo/linux-nvdimm
Re: [PATCH 2/2] powerpc/nvdimm: Update vmemmap_populated to check sub-section range
Quoted 51 lines · Aneesh Kumar K.V
With commit:
7cc7867fb061("mm/devm_memremap_pages: enable sub-section remap") pmem namespaces are remapped in 2M chunks. On architectures like ppc64 we can map the memmap area using 16MB hugepage size and that can cover a memory range of 16G.While enabling new pmem namespaces, since memory is added in sub-section chunks, before creating a new memmap mapping, kernel should check whether there is an existing memmap mapping covering the new pmem namespace. Currently, this is validated by checking whether the section covering the range is already initialized or not. Considering there can be multiple namespaces in the same section this can result in wrong validation. Update this to check for sub-sections in the range. This is done by checking for all pfns in the range we are mapping.
We could optimize this by checking only just one pfn in each sub-section. But since this is not fast-path we keep this simple.
Signed-off-by Aneesh Kumar K.V <[email protected]>--- arch/powerpc/mm/init_64.c | 45 ++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 22 deletions(-)arch/powerpc/mm/init_64.c +1
-16@@ -70,30 +70,24 @@ EXPORT_SYMBOL_GPL(kernstart_addr);#ifdef CONFIG_SPARSEMEM_VMEMMAP /* -* Given an address within the vmemmap, determine the pfn of the page that -* represents the start of the section it is within. Note that we have to -* do this by hand as the proffered address may not be correctly aligned. -* Subtraction of non-aligned pointers produces undefined results. -*/ -static unsigned long __meminit vmemmap_section_start (unsigned long page) -{ -unsigned long offset = page - ((unsigned long )(vmemmap)); - -/* Return the pfn of the start of the section. */ -return (offset /sizeof (struct page )) &PAGE_SECTION_MASK ; -} - -/* -* Check if this vmemmap page is already initialised. If any section +* Check if this vmemmap page is already initialised. If any sub section * which overlaps this vmemmap page is initialised then this page is * initialised already. */ -static int __meminit vmemmap_populated (unsigned long start,int page_size)
arch/powerpc/mm/init_64.c EXPORT_SYMBOL_GPL(kernstart_addr); · line 83
Quoted 10 lines
arch/powerpc/mm/init_64.c +5
-3+ +static int __meminit vmemmap_populated (unsigned long start,int size) { -unsigned long end = start + page_size; - start = (unsigned long )(pfn_to_page (vmemmap_section_start (start))); +unsigned long end = start + size; -for (; start < end; start += (PAGES_PER_SECTION *sizeof (struct page ))) +/* start is size aligned and it is always > sizeof(struct page) */ +VM_BUG_ON (start &sizeof (struct page ));
If start is size aligned why not include that assumption in the VM_BUG_ON()?
Otherwise it seems this patch could be reduced simply by:
s/PAGE_SECTION_MASK/PAGE_SUBSECTION_MASK/
s/PAGES_PER_SECTION/PAGES_PER_SUBSECTION/
...and leave the vmemmap_section_start() function in place? In other words this path used to guarantee that 'start' was aligned to the minimum mem-hotplug granularity, the change looks ok on the surface, but it seems a subtle change in semantics.
Can you get an ack from a powerpc maintainer, or maybe this patch should route through the powerpc tree?
I'll take patch1 through the nvdimm tree.
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Re: [PATCH 2/2] powerpc/nvdimm: Update vmemmap_populated to check sub-section range
Quoted 68 lines · Dan Williams
Quoted 51 lines · Aneesh Kumar K.V
With commit:
7cc7867fb061("mm/devm_memremap_pages: enable sub-section remap") pmem namespaces are remapped in 2M chunks. On architectures like ppc64 we can map the memmap area using 16MB hugepage size and that can cover a memory range of 16G.While enabling new pmem namespaces, since memory is added in sub-section chunks, before creating a new memmap mapping, kernel should check whether there is an existing memmap mapping covering the new pmem namespace. Currently, this is validated by checking whether the section covering the range is already initialized or not. Considering there can be multiple namespaces in the same section this can result in wrong validation. Update this to check for sub-sections in the range. This is done by checking for all pfns in the range we are mapping.
We could optimize this by checking only just one pfn in each sub-section. But since this is not fast-path we keep this simple.
Signed-off-by Aneesh Kumar K.V <[email protected]>--- arch/powerpc/mm/init_64.c | 45 ++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 22 deletions(-)arch/powerpc/mm/init_64.c +1
-16@@ -70,30 +70,24 @@ EXPORT_SYMBOL_GPL(kernstart_addr);#ifdef CONFIG_SPARSEMEM_VMEMMAP /* -* Given an address within the vmemmap, determine the pfn of the page that -* represents the start of the section it is within. Note that we have to -* do this by hand as the proffered address may not be correctly aligned. -* Subtraction of non-aligned pointers produces undefined results. -*/ -static unsigned long __meminit vmemmap_section_start (unsigned long page) -{ -unsigned long offset = page - ((unsigned long )(vmemmap)); - -/* Return the pfn of the start of the section. */ -return (offset /sizeof (struct page )) &PAGE_SECTION_MASK ; -} - -/* -* Check if this vmemmap page is already initialised. If any section +* Check if this vmemmap page is already initialised. If any sub section * which overlaps this vmemmap page is initialised then this page is * initialised already. */ -static int __meminit vmemmap_populated (unsigned long start,int page_size)arch/powerpc/mm/init_64.c EXPORT_SYMBOL_GPL(kernstart_addr); · line 83
Quoted 10 lines
arch/powerpc/mm/init_64.c +5
-3+ +static int __meminit vmemmap_populated (unsigned long start,int size) { -unsigned long end = start + page_size; - start = (unsigned long )(pfn_to_page (vmemmap_section_start (start))); +unsigned long end = start + size; -for (; start < end; start += (PAGES_PER_SECTION *sizeof (struct page ))) +/* start is size aligned and it is always > sizeof(struct page) */ +VM_BUG_ON (start &sizeof (struct page ));If start is size aligned why not include that assumption in the
VM_BUG_ON()?Otherwise it seems this patch could be reduced simply by:
Quoted 8 lines
s/PAGE_SECTION_MASK/PAGE_SUBSECTION_MASK/
s/PAGES_PER_SECTION/PAGES_PER_SUBSECTION/...and leave the
vmemmap_section_start()function in place? In other words this path used to guarantee that 'start' was aligned to the minimum mem-hotplug granularity, the change looks ok on the surface, but it seems a subtle change in semantics.
How about this?
/*
* Given an address within the vmemmap, determine the page that
* represents the start of the subsection it is within. Note that we
have to
* do this by hand as the proffered address may not be correctly aligned.
* Subtraction of non-aligned pointers produces undefined results.
*/
static struct page * __meminit vmemmap_subsection_start(unsigned long vmemmap_addr)
{
unsigned long start_pfn;
unsigned long offset = vmemmap_addr - ((unsigned long)(vmemmap));
/* Return the pfn of the start of the section. */
start_pfn = (offset / sizeof(struct page)) & PAGE_SUBSECTION_MASK;
return pfn_to_page(start_pfn);
}/*
* Since memory is added in sub-section chunks, before creating a new
vmemmap
* mapping, the kernel should check whether there is an existing memmap
mapping
* covering the new subsection added. This is needed because kernel can map
* vmemmap area using 16MB pages which will cover a memory range of
16G. Such
* a range covers multiple subsections (2M)
*
* If any subsection in the 16G range mapped by vmemmap is valid we
consider the
* vmemmap populated (There is a page table entry already present). We
can't do
* a page table lookup here because with the hash translation we don't keep
* vmemmap details in linux page table.
*/
static int __meminit vmemmap_populated(unsigned long vmemmap_addr, int vmemmap_map_size)
{
struct page *start;
unsigned long vmemmap_end = vmemmap_addr + vmemmap_map_size;
start = vmemmap_subsection_start(vmemmap_addr);
for (; (unsigned long)start < vmemmap_end; start += PAGES_PER_SUBSECTION)
/*
* pfn valid check here is intended to really check
* whether we have any subsection already initialized
* in this range.
*/
if (pfn_valid(page_to_pfn(start)))
return 1;
return 0;
}Quoted 3 lines
Can you get an ack from a powerpc maintainer, or maybe this patch should route through the powerpc tree?
I guess this can go via powerpc tree. I will send an update V2 patch for this alone and work with Michael to pick that up.
Quoted 2 lines
I'll take patch1 through the nvdimm tree.
Thanks.
-aneesh
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Re: [PATCH 2/2] powerpc/nvdimm: Update vmemmap_populated to check sub-section range
In reply to Aneesh Kumar K.VQuoted 33 lines · Aneesh Kumar K.V
With commit:
7cc7867fb061("mm/devm_memremap_pages: enable sub-section remap") pmem namespaces are remapped in 2M chunks. On architectures like ppc64 we can map the memmap area using 16MB hugepage size and that can cover a memory range of 16G.While enabling new pmem namespaces, since memory is added in sub-section chunks, before creating a new memmap mapping, kernel should check whether there is an existing memmap mapping covering the new pmem namespace. Currently, this is validated by checking whether the section covering the range is already initialized or not. Considering there can be multiple namespaces in the same section this can result in wrong validation. Update this to check for sub-sections in the range. This is done by checking for all pfns in the range we are mapping.
We could optimize this by checking only just one pfn in each sub-section. But since this is not fast-path we keep this simple.
Signed-off-by Aneesh Kumar K.V <[email protected]>--- arch/powerpc/mm/init_64.c | 45 ++++++++++++++++++++------------------- 1 file changed, 23 insertions(+), 22 deletions(-)arch/powerpc/mm/init_64.c +0
-2@@ -70,30 +70,24 @@ EXPORT_SYMBOL_GPL(kernstart_addr);#ifdef CONFIG_SPARSEMEM_VMEMMAP /* -* Given an address within the vmemmap, determine the pfn of the page that -* represents the start of the section it is within. Note that we have to
arch/powerpc/mm/init_64.c EXPORT_SYMBOL_GPL(kernstart_addr); · line 84
Quoted 10 lines
arch/powerpc/mm/init_64.c +0
-10-* do this by hand as the proffered address may not be correctly aligned. -* Subtraction of non-aligned pointers produces undefined results. -*/ -static unsigned long __meminit vmemmap_section_start (unsigned long page) -{ -unsigned long offset = page - ((unsigned long )(vmemmap)); - -/* Return the pfn of the start of the section. */ -return (offset /sizeof (struct page )) &PAGE_SECTION_MASK ; -}
If you want to go with Dan's suggestion of keeping the function and using PAGE_SUBSECTION_MASK then can you fold the pfn_to_page() below into vmemmap_section_start()? The current behaviour of returning a pfn makes no sense to me.
Quoted 6 lines
arch/powerpc/mm/init_64.c +1
-2-* Check if this vmemmap page is already initialised. If any section +* Check if this vmemmap page is already initialised. If any sub section * which overlaps this vmemmap page is initialised then this page is * initialised already. */ -static int __meminit vmemmap_populated (unsigned long start,int page_size)
arch/powerpc/mm/init_64.c EXPORT_SYMBOL_GPL(kernstart_addr); · line 83
Quoted 10 lines
arch/powerpc/mm/init_64.c +5
-3+ +static int __meminit vmemmap_populated (unsigned long start,int size) { -unsigned long end = start + page_size; - start = (unsigned long )(pfn_to_page (vmemmap_section_start (start))); +unsigned long end = start + size; -for (; start < end; start += (PAGES_PER_SECTION *sizeof (struct page ))) +/* start is size aligned and it is always > sizeof(struct page) */ +VM_BUG_ON (start &sizeof (struct page ));
Shouldn't the test be: start & (sizeof(struct page) - 1)? VM_BUG_ON(start != ALIGN(start, page_size)) would be clearer.
arch/powerpc/mm/init_64.c EXPORT_SYMBOL_GPL(kernstart_addr); · line 92
Quoted 9 lines
arch/powerpc/mm/init_64.c +7
-0+for (; start < end; start +=sizeof (struct page )) +/* +* pfn valid check here is intended to really check +* whether we have any subsection already initialized +* in this range. We keep it simple by checking every +* pfn in the range. +*/ if (pfn_valid (page_to_pfn ((struct page *)start)))return 1 ;
Having a few lines of separation between the for () and the loop body always looks a bit sketch, even if it's just a comment. Wrapping the block in braces or moving the comment above the loop is probably a good idea.
Looks fine otherwise
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 130 lines
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback
to allocation from memory.This fix kernel crash reported below:
[ 132.034989] WARNING: CPU: 13 PID: 13719 at mm/memremap.c:133 devm_memremap_pages_release+0x2d8/0x2e0 [ 133.464754] BUG: Unable to handle kernel data access at 0xc00c00010b204000 [ 133.464760] Faulting instruction address: 0xc00000000007580c [ 133.464766] Oops: Kernel access of bad area, sig: 11 [#1] [ 133.464771] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries ..... [ 133.464901] NIP [c00000000007580c] vmemmap_free+0x2ac/0x3d0 [ 133.464906] LR [c0000000000757f8] vmemmap_free+0x298/0x3d0 [ 133.464910] Call Trace: [ 133.464914] [c000007cbfd0f7b0] [c0000000000757f8] vmemmap_free+0x298/0x3d0 (unreliable) [ 133.464921] [c000007cbfd0f8d0] [c000000000370a44] section_deactivate+0x1a4/0x240 [ 133.464928] [c000007cbfd0f980] [c000000000386270] __remove_pages+0x3a0/0x590 [ 133.464935] [c000007cbfd0fa50] [c000000000074158] arch_remove_memory+0x88/0x160 [ 133.464942] [c000007cbfd0fae0] [c0000000003be8c0] devm_memremap_pages_release+0x150/0x2e0 [ 133.464949] [c000007cbfd0fb70] [c000000000738ea0] devm_action_release+0x30/0x50 [ 133.464955] [c000007cbfd0fb90] [c00000000073a5a4] release_nodes+0x344/0x400 [ 133.464961] [c000007cbfd0fc40] [c00000000073378c] device_release_driver_internal+0x15c/0x250 [ 133.464968] [c000007cbfd0fc80] [c00000000072fd14] unbind_store+0x104/0x110 [ 133.464973] [c000007cbfd0fcd0] [c00000000072ee24] drv_attr_store+0x44/0x70 [ 133.464981] [c000007cbfd0fcf0] [c0000000004a32bc] sysfs_kf_write+0x6c/0xa0 [ 133.464987] [c000007cbfd0fd10] [c0000000004a1dfc] kernfs_fop_write+0x17c/0x250 [ 133.464993] [c000007cbfd0fd60] [c0000000003c348c] __vfs_write+0x3c/0x70 [ 133.464999] [c000007cbfd0fd80] [c0000000003c75d0] vfs_write+0xd0/0x250Reported-by Sachin Sant <[email protected]>Signed-off-by Aneesh Kumar K.V <[email protected]>--- arch/powerpc/mm/init_64.c | 17 ++++++++++++++++- drivers/nvdimm/pfn_devs.c | 2 ++ include/linux/memremap.h | 1 + 3 files changed, 19 insertions(+), 1 deletion(-)arch/powerpc/mm/init_64.c +15
-0@@ -172,6 +172,21 @@ static __meminit void vmemmap_list_populate(unsignedlong phys, vmemmap_list = vmem_back; } +static bool altmap_cross_boundary (struct vmem_altmap *altmap,unsigned long start, +unsigned long page_size) +{ +unsigned long nr_pfn = page_size /sizeof (struct page ); +unsigned long start_pfn =page_to_pfn ((struct page *)start); + +if ((start_pfn + nr_pfn) > altmap->end_pfn) +return true; + +if (start_pfn < altmap->base_pfn) +return true; + +return false; +} + int __meminit vmemmap_populate(unsigned long start, unsigned long end, intnode,
arch/powerpc/mm/init_64.c +1
-1struct vmem_altmap *altmap) {@@ -194,7 +209,7 @@ int __meminit vmemmap_populate(unsigned long start,unsigned long end, int node, * fail due to alignment issues when using 16MB hugepages, so * fall back to system memory if the altmap allocation fail. */ -if (altmap) { +if (altmap && !altmap_cross_boundary (altmap, start, page_size)) { p =altmap_alloc_block_buf (page_size, altmap);if (!p)arch/powerpc/mm/init_64.c +0
-0pr_debug ("altmap block allocation failed, falling back to system memory");drivers/nvdimm/pfn_devs.c +2
-0@@ -618,9 +618,11 @@ static int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap)struct nd_namespace_common *ndns = nd_pfn->ndns;struct nd_namespace_io *nsio =to_nd_namespace_io (&ndns->dev);resource_size_t base = nsio->res.start + start_pad; +resource_size_t end = nsio->res.end - end_trunc;struct vmem_altmap __altmap = { .base_pfn =init_altmap_base (base), .reserve =init_altmap_reserve (base), + .end_pfn =PHYS_PFN (end), };drivers/nvdimm/pfn_devs.c +0
-0memcpy (res, &nsio->res,sizeof (*res));include/linux/memremap.h +1
-1@@ -17,6 +17,7 @@ struct device;*/ struct vmem_altmap {const unsigned long base_pfn; +const unsigned long end_pfn;const unsigned long reserve;unsigned long free;unsigned long align; --
Quoted 1 line
2.21.0
This patch looks good to me. It helps to prevent
namespace access across boundaries for altmap
hugepage allocation.
Thanks,
Pankaj
Quoted 6 lines
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 6 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.
Quoted 7 lines
When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
Shouldn't this instead be comprehended by nd_pfn_init() to increase the reservation size so that it fits in the alignment? It may not always be possible to fall back to allocation from memory for extremely large pmem devices. I.e. at 64GB of memmap per 1TB of pmem there may not be enough DRAM to store the memmap.
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 16 lines · Dan Williams
Quoted 6 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.Quoted 7 lines
When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
Quoted 6 lines
Shouldn't this instead be comprehended by
nd_pfn_init()to increase the reservation size so that it fits in the alignment? It may not always be possible to fall back to allocation from memory for extremely large pmem devices. I.e. at 64GB of memmap per 1TB of pmem there may not be enough DRAM to store the memmap.
We do switch between DRAM and device for memmap allocation. ppc64 vmemmap_populate does
if (altmap && !altmap_cross_boundary(altmap, start, page_size)) {
p = altmap_alloc_block_buf(page_size, altmap);
if (!p)
pr_debug("altmap block allocation failed, falling back to system memory");
}
if (!p)
p = vmemmap_alloc_block_buf(page_size, node);With that we should be using DRAM for the first and the last mapping, rest of the memmap should be backed by device.
-aneesh
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 37 lines · Aneesh Kumar K.V
Quoted 16 lines · Dan Williams
Quoted 6 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.Quoted 7 lines
When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
Quoted 6 lines
Shouldn't this instead be comprehended by
nd_pfn_init()to increase the reservation size so that it fits in the alignment? It may not always be possible to fall back to allocation from memory for extremely large pmem devices. I.e. at 64GB of memmap per 1TB of pmem there may not be enough DRAM to store the memmap.We do switch between DRAM and device for memmap allocation. ppc64
vmemmap_populatedoesif (altmap && !altmap_cross_boundary(altmap, start, page_size)) { p = altmap_alloc_block_buf(page_size, altmap); if (!p) pr_debug("altmap block allocation failed, falling back to system memory"); } if (!p) p = vmemmap_alloc_block_buf(page_size, node);
Quoted 2 lines
With that we should be using DRAM for the first and the last mapping, rest of the memmap should be backed by device.
Ah, ok, makes sense.
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 39 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
This fix kernel crash reported below:
[ 132.034989] WARNING: CPU: 13 PID: 13719 at mm/memremap.c:133 devm_memremap_pages_release+0x2d8/0x2e0 [ 133.464754] BUG: Unable to handle kernel data access at 0xc00c00010b204000 [ 133.464760] Faulting instruction address: 0xc00000000007580c [ 133.464766] Oops: Kernel access of bad area, sig: 11 [#1] [ 133.464771] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries ..... [ 133.464901] NIP [c00000000007580c] vmemmap_free+0x2ac/0x3d0 [ 133.464906] LR [c0000000000757f8] vmemmap_free+0x298/0x3d0 [ 133.464910] Call Trace: [ 133.464914] [c000007cbfd0f7b0] [c0000000000757f8] vmemmap_free+0x298/0x3d0 (unreliable) [ 133.464921] [c000007cbfd0f8d0] [c000000000370a44] section_deactivate+0x1a4/0x240 [ 133.464928] [c000007cbfd0f980] [c000000000386270] __remove_pages+0x3a0/0x590 [ 133.464935] [c000007cbfd0fa50] [c000000000074158] arch_remove_memory+0x88/0x160 [ 133.464942] [c000007cbfd0fae0] [c0000000003be8c0] devm_memremap_pages_release+0x150/0x2e0 [ 133.464949] [c000007cbfd0fb70] [c000000000738ea0] devm_action_release+0x30/0x50 [ 133.464955] [c000007cbfd0fb90] [c00000000073a5a4] release_nodes+0x344/0x400 [ 133.464961] [c000007cbfd0fc40] [c00000000073378c] device_release_driver_internal+0x15c/0x250 [ 133.464968] [c000007cbfd0fc80] [c00000000072fd14] unbind_store+0x104/0x110 [ 133.464973] [c000007cbfd0fcd0] [c00000000072ee24] drv_attr_store+0x44/0x70 [ 133.464981] [c000007cbfd0fcf0] [c0000000004a32bc] sysfs_kf_write+0x6c/0xa0 [ 133.464987] [c000007cbfd0fd10] [c0000000004a1dfc] kernfs_fop_write+0x17c/0x250 [ 133.464993] [c000007cbfd0fd60] [c0000000003c348c] __vfs_write+0x3c/0x70 [ 133.464999] [c000007cbfd0fd80] [c0000000003c75d0] vfs_write+0xd0/0x250
Quoted 7 lines
Reported-by Sachin Sant <[email protected]>Signed-off-by Aneesh Kumar K.V <[email protected]>--- arch/powerpc/mm/init_64.c | 17 ++++++++++++++++- drivers/nvdimm/pfn_devs.c | 2 ++ include/linux/memremap.h | 1 + 3 files changed, 19 insertions(+), 1 deletion(-)
Quoted 71 lines
arch/powerpc/mm/init_64.c +16
-1@@ -172,6 +172,21 @@ static __meminit void vmemmap_list_populate(unsigned long phys, vmemmap_list = vmem_back; } +static bool altmap_cross_boundary (struct vmem_altmap *altmap,unsigned long start, +unsigned long page_size) +{ +unsigned long nr_pfn = page_size /sizeof (struct page ); +unsigned long start_pfn =page_to_pfn ((struct page *)start); + +if ((start_pfn + nr_pfn) > altmap->end_pfn) +return true; + +if (start_pfn < altmap->base_pfn) +return true; + +return false; +} +int __meminit vmemmap_populate (unsigned long start,unsigned long end,int node,struct vmem_altmap *altmap) {@@ -194,7 +209,7 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,* fail due to alignment issues when using 16MB hugepages, so * fall back to system memory if the altmap allocation fail. */ -if (altmap) { +if (altmap && !altmap_cross_boundary (altmap, start, page_size)) { p =altmap_alloc_block_buf (page_size, altmap);if (!p)pr_debug ("altmap block allocation failed, falling back to system memory" );drivers/nvdimm/pfn_devs.c +2
-0@@ -618,9 +618,11 @@ static int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap)struct nd_namespace_common *ndns = nd_pfn->ndns;struct nd_namespace_io *nsio =to_nd_namespace_io (&ndns->dev);resource_size_t base = nsio->res.start + start_pad; +resource_size_t end = nsio->res.end - end_trunc;struct vmem_altmap __altmap = { .base_pfn =init_altmap_base (base), .reserve =init_altmap_reserve (base), + .end_pfn =PHYS_PFN (end), };memcpy (res, &nsio->res,sizeof (*res));include/linux/memremap.h +1
-0@@ -17,6 +17,7 @@ struct device;*/ struct vmem_altmap {const unsigned long base_pfn; +const unsigned long end_pfn;const unsigned long reserve;unsigned long free;unsigned long align;Signature · 6 lines
2.21.0 _______________________________________________ Linux-nvdimm mailing list [email protected] https://lists.01.org/mailman/listinfo/linux-nvdimm
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Looks good,
Signature · 12 lines
Johannes Thumshirn SUSE Labs Filesystems [email protected] +49 911 74053 689 SUSE Software Solutions Germany GmbH Maxfeldstr. 5 90409 Nürnberg Germany (HRB 247165, AG München) Key fingerprint = EC38 9CAB C2C4 F25D 8600 D0D0 0393 969D 2D76 0850 _______________________________________________ Linux-nvdimm mailing list [email protected] https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 31 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
This fix kernel crash reported below:
[ 132.034989] WARNING: CPU: 13 PID: 13719 at mm/memremap.c:133 devm_memremap_pages_release+0x2d8/0x2e0 [ 133.464754] BUG: Unable to handle kernel data access at 0xc00c00010b204000 [ 133.464760] Faulting instruction address: 0xc00000000007580c [ 133.464766] Oops: Kernel access of bad area, sig: 11 [#1] [ 133.464771] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries ..... [ 133.464901] NIP [c00000000007580c] vmemmap_free+0x2ac/0x3d0 [ 133.464906] LR [c0000000000757f8] vmemmap_free+0x298/0x3d0 [ 133.464910] Call Trace: [ 133.464914] [c000007cbfd0f7b0] [c0000000000757f8] vmemmap_free+0x298/0x3d0 (unreliable) [ 133.464921] [c000007cbfd0f8d0] [c000000000370a44] section_deactivate+0x1a4/0x240 [ 133.464928] [c000007cbfd0f980] [c000000000386270] __remove_pages+0x3a0/0x590 [ 133.464935] [c000007cbfd0fa50] [c000000000074158] arch_remove_memory+0x88/0x160 [ 133.464942] [c000007cbfd0fae0] [c0000000003be8c0] devm_memremap_pages_release+0x150/0x2e0 [ 133.464949] [c000007cbfd0fb70] [c000000000738ea0] devm_action_release+0x30/0x50
Quoted 8 lines
[ 133.464955] [c000007cbfd0fb90] [c00000000073a5a4] release_nodes+0x344/0x400 [ 133.464961] [c000007cbfd0fc40] [c00000000073378c] device_release_driver_internal+0x15c/0x250 [ 133.464968] [c000007cbfd0fc80] [c00000000072fd14] unbind_store+0x104/0x110 [ 133.464973] [c000007cbfd0fcd0] [c00000000072ee24] drv_attr_store+0x44/0x70 [ 133.464981] [c000007cbfd0fcf0] [c0000000004a32bc] sysfs_kf_write+0x6c/0xa0 [ 133.464987] [c000007cbfd0fd10] [c0000000004a1dfc] kernfs_fop_write+0x17c/0x250 [ 133.464993] [c000007cbfd0fd60] [c0000000003c348c] __vfs_write+0x3c/0x70 [ 133.464999] [c000007cbfd0fd80] [c0000000003c75d0] vfs_write+0xd0/0x250
Question, does this crash only happen when the namespace is not 16MB aligned? In other words was this bug exposed by the subsection-hotplug changes and should it contain Fixes: tag for those commits?
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 42 lines · Dan Williams
Quoted 31 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
This fix kernel crash reported below:
[ 132.034989] WARNING: CPU: 13 PID: 13719 at mm/memremap.c:133 devm_memremap_pages_release+0x2d8/0x2e0 [ 133.464754] BUG: Unable to handle kernel data access at 0xc00c00010b204000 [ 133.464760] Faulting instruction address: 0xc00000000007580c [ 133.464766] Oops: Kernel access of bad area, sig: 11 [#1] [ 133.464771] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries ..... [ 133.464901] NIP [c00000000007580c] vmemmap_free+0x2ac/0x3d0 [ 133.464906] LR [c0000000000757f8] vmemmap_free+0x298/0x3d0 [ 133.464910] Call Trace: [ 133.464914] [c000007cbfd0f7b0] [c0000000000757f8] vmemmap_free+0x298/0x3d0 (unreliable) [ 133.464921] [c000007cbfd0f8d0] [c000000000370a44] section_deactivate+0x1a4/0x240 [ 133.464928] [c000007cbfd0f980] [c000000000386270] __remove_pages+0x3a0/0x590 [ 133.464935] [c000007cbfd0fa50] [c000000000074158] arch_remove_memory+0x88/0x160 [ 133.464942] [c000007cbfd0fae0] [c0000000003be8c0] devm_memremap_pages_release+0x150/0x2e0 [ 133.464949] [c000007cbfd0fb70] [c000000000738ea0] devm_action_release+0x30/0x50Quoted 8 lines
[ 133.464955] [c000007cbfd0fb90] [c00000000073a5a4] release_nodes+0x344/0x400 [ 133.464961] [c000007cbfd0fc40] [c00000000073378c] device_release_driver_internal+0x15c/0x250 [ 133.464968] [c000007cbfd0fc80] [c00000000072fd14] unbind_store+0x104/0x110 [ 133.464973] [c000007cbfd0fcd0] [c00000000072ee24] drv_attr_store+0x44/0x70 [ 133.464981] [c000007cbfd0fcf0] [c0000000004a32bc] sysfs_kf_write+0x6c/0xa0 [ 133.464987] [c000007cbfd0fd10] [c0000000004a1dfc] kernfs_fop_write+0x17c/0x250 [ 133.464993] [c000007cbfd0fd60] [c0000000003c348c] __vfs_write+0x3c/0x70 [ 133.464999] [c000007cbfd0fd80] [c0000000003c75d0] vfs_write+0xd0/0x250
Quoted 4 lines
Question, does this crash only happen when the namespace is not 16MB aligned? In other words was this bug exposed by the subsection-hotplug changes and should it contain Fixes: tag for those commits?
We are able to hit this crash even with older kernels. This happens when we have multiple namespaces from the same region of size 26G. In that case we need to make sure we don't end up using altmap from one namespace for mapping vmemmap of the adjacent namespace.
Considering this impacts ppc64 and we got the ppc64 SCM support in 4.20. may be we can do just
Cc: <[email protected]> # 4.20+
-aneesh
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm
Quoted 49 lines · Aneesh Kumar K.V
Quoted 42 lines · Dan Williams
Quoted 31 lines · Aneesh Kumar K.V
With
PFN_MODE_PMEMnamespace, the memmap area is allocated from the device area. Some architectures map the memmap area with large page size. On architectures like ppc64, 16MB page for memap mapping can map 262144 pfns. This maps a namespace size of 16G.When populating memmap region with 16MB page from the device area, make sure the allocated space is not used to map resources outside this namespace. Such usage of device area will prevent a namespace destroy.
Add resource end pnf in altmap and use that to check if the memmap area allocation can map pfn outside the namespace. On ppc64 in such case we fallback to allocation from memory.
This fix kernel crash reported below:
[ 132.034989] WARNING: CPU: 13 PID: 13719 at mm/memremap.c:133 devm_memremap_pages_release+0x2d8/0x2e0 [ 133.464754] BUG: Unable to handle kernel data access at 0xc00c00010b204000 [ 133.464760] Faulting instruction address: 0xc00000000007580c [ 133.464766] Oops: Kernel access of bad area, sig: 11 [#1] [ 133.464771] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries ..... [ 133.464901] NIP [c00000000007580c] vmemmap_free+0x2ac/0x3d0 [ 133.464906] LR [c0000000000757f8] vmemmap_free+0x298/0x3d0 [ 133.464910] Call Trace: [ 133.464914] [c000007cbfd0f7b0] [c0000000000757f8] vmemmap_free+0x298/0x3d0 (unreliable) [ 133.464921] [c000007cbfd0f8d0] [c000000000370a44] section_deactivate+0x1a4/0x240 [ 133.464928] [c000007cbfd0f980] [c000000000386270] __remove_pages+0x3a0/0x590 [ 133.464935] [c000007cbfd0fa50] [c000000000074158] arch_remove_memory+0x88/0x160 [ 133.464942] [c000007cbfd0fae0] [c0000000003be8c0] devm_memremap_pages_release+0x150/0x2e0 [ 133.464949] [c000007cbfd0fb70] [c000000000738ea0] devm_action_release+0x30/0x50Quoted 8 lines
[ 133.464955] [c000007cbfd0fb90] [c00000000073a5a4] release_nodes+0x344/0x400 [ 133.464961] [c000007cbfd0fc40] [c00000000073378c] device_release_driver_internal+0x15c/0x250 [ 133.464968] [c000007cbfd0fc80] [c00000000072fd14] unbind_store+0x104/0x110 [ 133.464973] [c000007cbfd0fcd0] [c00000000072ee24] drv_attr_store+0x44/0x70 [ 133.464981] [c000007cbfd0fcf0] [c0000000004a32bc] sysfs_kf_write+0x6c/0xa0 [ 133.464987] [c000007cbfd0fd10] [c0000000004a1dfc] kernfs_fop_write+0x17c/0x250 [ 133.464993] [c000007cbfd0fd60] [c0000000003c348c] __vfs_write+0x3c/0x70 [ 133.464999] [c000007cbfd0fd80] [c0000000003c75d0] vfs_write+0xd0/0x250Quoted 4 lines
Question, does this crash only happen when the namespace is not 16MB aligned? In other words was this bug exposed by the subsection-hotplug changes and should it contain Fixes: tag for those commits?
Quoted 8 lines
We are able to hit this crash even with older kernels. This happens when we have multiple namespaces from the same region of size 26G. In that case we need to make sure we don't end up using altmap from one namespace for mapping vmemmap of the adjacent namespace.
Considering this impacts ppc64 and we got the ppc64 SCM support in 4.20. may be we can do just
Cc: <[email protected]> # 4.20+
Ok, thanks!
_______________________________________________
Linux-nvdimm mailing list
[email protected]
https://lists.01.org/mailman/listinfo/linux-nvdimm