[v4 00/15] complete deferred page initialization

[v4 00/15] complete deferred page initialization

[Pavel Tatashin]

Changelog:
v3 - v2
- Rewrote code to zero sturct pages in __init_single_page() as
  suggested by Michal Hocko
- Added code to handle issues related to accessing struct page
  memory before they are initialized.

v2 - v3
- Addressed David Miller comments about one change per patch:
    * Splited changes to platforms into 4 patches
    * Made "do not zero vmemmap_buf" as a separate patch

v1 - v2
- Per request, added s390 to deferred "struct page" zeroing
- Collected performance data on x86 which proofs the importance to
  keep memset() as prefetch (see below).

SMP machines can benefit from the DEFERRED_STRUCT_PAGE_INIT config option,
which defers initializing struct pages until all cpus have been started so
it can be done in parallel.

However, this feature is sub-optimal, because the deferred page
initialization code expects that the struct pages have already been zeroed,
and the zeroing is done early in boot with a single thread only.  Also, we
access that memory and set flags before struct pages are initialized. All
of this is fixed in this patchset.

In this work we do the following:
- Never read access struct page until it was initialized
- Never set any fields in struct pages before they are initialized
- Zero struct page at the beginning of struct page initialization

Performance improvements on x86 machine with 8 nodes:
Intel(R) Xeon(R) CPU E7-8895 v3 @ 2.60GHz

Single threaded struct page init: 7.6s/T improvement
Deferred struct page init: 10.2s/T improvement

Pavel Tatashin (15):
  x86/mm: reserve only exiting low pages
  x86/mm: setting fields in deferred pages
  sparc64/mm: setting fields in deferred pages
  mm: discard memblock data later
  mm: don't accessed uninitialized struct pages
  sparc64: simplify vmemmap_populate
  mm: defining memblock_virt_alloc_try_nid_raw
  mm: zero struct pages during initialization
  sparc64: optimized struct page zeroing
  x86/kasan: explicitly zero kasan shadow memory
  arm64/kasan: explicitly zero kasan shadow memory
  mm: explicitly zero pagetable memory
  mm: stop zeroing memory during allocation in vmemmap
  mm: optimize early system hash allocations
  mm: debug for raw alloctor

 arch/arm64/mm/kasan_init.c          |  32 ++++++++
 arch/sparc/include/asm/pgtable_64.h |  18 +++++
 arch/sparc/mm/init_64.c             |  31 +++-----
 arch/x86/kernel/setup.c             |   5 +-
 arch/x86/mm/init_64.c               |   9 ++-
 arch/x86/mm/kasan_init_64.c         |  29 +++++++
 include/linux/bootmem.h             |  11 +++
 include/linux/memblock.h            |  10 ++-
 include/linux/mm.h                  |   9 +++
 mm/memblock.c                       | 152 ++++++++++++++++++++++++++++--------
 mm/nobootmem.c                      |  16 ----
 mm/page_alloc.c                     |  29 ++++---
 mm/sparse-vmemmap.c                 |  10 ++-
 mm/sparse.c                         |   6 +-
 14 files changed, 279 insertions(+), 88 deletions(-)

--
2.13.3

[v4 00/15] complete deferred page initialization

[Pavel Tatashin]

Changelog:
v3 - v2
- Rewrote code to zero sturct pages in __init_single_page() as
  suggested by Michal Hocko
- Added code to handle issues related to accessing struct page
  memory before they are initialized.

v2 - v3
- Addressed David Miller comments about one change per patch:
    * Splited changes to platforms into 4 patches
    * Made "do not zero vmemmap_buf" as a separate patch

v1 - v2
- Per request, added s390 to deferred "struct page" zeroing
- Collected performance data on x86 which proofs the importance to
  keep memset() as prefetch (see below).

SMP machines can benefit from the DEFERRED_STRUCT_PAGE_INIT config option,
which defers initializing struct pages until all cpus have been started so
it can be done in parallel.

However, this feature is sub-optimal, because the deferred page
initialization code expects that the struct pages have already been zeroed,
and the zeroing is done early in boot with a single thread only.  Also, we
access that memory and set flags before struct pages are initialized. All
of this is fixed in this patchset.

In this work we do the following:
- Never read access struct page until it was initialized
- Never set any fields in struct pages before they are initialized
- Zero struct page at the beginning of struct page initialization

Performance improvements on x86 machine with 8 nodes:
Intel(R) Xeon(R) CPU E7-8895 v3 @ 2.60GHz

Single threaded struct page init: 7.6s/T improvement
Deferred struct page init: 10.2s/T improvement

Pavel Tatashin (15):
  x86/mm: reserve only exiting low pages
  x86/mm: setting fields in deferred pages
  sparc64/mm: setting fields in deferred pages
  mm: discard memblock data later
  mm: don't accessed uninitialized struct pages
  sparc64: simplify vmemmap_populate
  mm: defining memblock_virt_alloc_try_nid_raw
  mm: zero struct pages during initialization
  sparc64: optimized struct page zeroing
  x86/kasan: explicitly zero kasan shadow memory
  arm64/kasan: explicitly zero kasan shadow memory
  mm: explicitly zero pagetable memory
  mm: stop zeroing memory during allocation in vmemmap
  mm: optimize early system hash allocations
  mm: debug for raw alloctor

 arch/arm64/mm/kasan_init.c          |  32 ++++++++
 arch/sparc/include/asm/pgtable_64.h |  18 +++++
 arch/sparc/mm/init_64.c             |  31 +++-----
 arch/x86/kernel/setup.c             |   5 +-
 arch/x86/mm/init_64.c               |   9 ++-
 arch/x86/mm/kasan_init_64.c         |  29 +++++++
 include/linux/bootmem.h             |  11 +++
 include/linux/memblock.h            |  10 ++-
 include/linux/mm.h                  |   9 +++
 mm/memblock.c                       | 152 ++++++++++++++++++++++++++++--------
 mm/nobootmem.c                      |  16 ----
 mm/page_alloc.c                     |  29 ++++---
 mm/sparse-vmemmap.c                 |  10 ++-
 mm/sparse.c                         |   6 +-
 14 files changed, 279 insertions(+), 88 deletions(-)

--
2.13.3

[v4 00/15] complete deferred page initialization

[Pavel Tatashin]

Changelog:
v3 - v2
- Rewrote code to zero sturct pages in __init_single_page() as
  suggested by Michal Hocko
- Added code to handle issues related to accessing struct page
  memory before they are initialized.

v2 - v3
- Addressed David Miller comments about one change per patch:
    * Splited changes to platforms into 4 patches
    * Made "do not zero vmemmap_buf" as a separate patch

v1 - v2
- Per request, added s390 to deferred "struct page" zeroing
- Collected performance data on x86 which proofs the importance to
  keep memset() as prefetch (see below).

SMP machines can benefit from the DEFERRED_STRUCT_PAGE_INIT config option,
which defers initializing struct pages until all cpus have been started so
it can be done in parallel.

However, this feature is sub-optimal, because the deferred page
initialization code expects that the struct pages have already been zeroed,
and the zeroing is done early in boot with a single thread only.  Also, we
access that memory and set flags before struct pages are initialized. All
of this is fixed in this patchset.

In this work we do the following:
- Never read access struct page until it was initialized
- Never set any fields in struct pages before they are initialized
- Zero struct page at the beginning of struct page initialization

Performance improvements on x86 machine with 8 nodes:
Intel(R) Xeon(R) CPU E7-8895 v3 @ 2.60GHz

Single threaded struct page init: 7.6s/T improvement
Deferred struct page init: 10.2s/T improvement

Pavel Tatashin (15):
  x86/mm: reserve only exiting low pages
  x86/mm: setting fields in deferred pages
  sparc64/mm: setting fields in deferred pages
  mm: discard memblock data later
  mm: don't accessed uninitialized struct pages
  sparc64: simplify vmemmap_populate
  mm: defining memblock_virt_alloc_try_nid_raw
  mm: zero struct pages during initialization
  sparc64: optimized struct page zeroing
  x86/kasan: explicitly zero kasan shadow memory
  arm64/kasan: explicitly zero kasan shadow memory
  mm: explicitly zero pagetable memory
  mm: stop zeroing memory during allocation in vmemmap
  mm: optimize early system hash allocations
  mm: debug for raw alloctor

 arch/arm64/mm/kasan_init.c          |  32 ++++++++
 arch/sparc/include/asm/pgtable_64.h |  18 +++++
 arch/sparc/mm/init_64.c             |  31 +++-----
 arch/x86/kernel/setup.c             |   5 +-
 arch/x86/mm/init_64.c               |   9 ++-
 arch/x86/mm/kasan_init_64.c         |  29 +++++++
 include/linux/bootmem.h             |  11 +++
 include/linux/memblock.h            |  10 ++-
 include/linux/mm.h                  |   9 +++
 mm/memblock.c                       | 152 ++++++++++++++++++++++++++++--------
 mm/nobootmem.c                      |  16 ----
 mm/page_alloc.c                     |  29 ++++---
 mm/sparse-vmemmap.c                 |  10 ++-
 mm/sparse.c                         |   6 +-
 14 files changed, 279 insertions(+), 88 deletions(-)

--
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 00/15] complete deferred page initialization

[Pavel Tatashin]

Changelog:
v3 - v2
- Rewrote code to zero sturct pages in __init_single_page() as
  suggested by Michal Hocko
- Added code to handle issues related to accessing struct page
  memory before they are initialized.

v2 - v3
- Addressed David Miller comments about one change per patch:
    * Splited changes to platforms into 4 patches
    * Made "do not zero vmemmap_buf" as a separate patch

v1 - v2
- Per request, added s390 to deferred "struct page" zeroing
- Collected performance data on x86 which proofs the importance to
  keep memset() as prefetch (see below).

SMP machines can benefit from the DEFERRED_STRUCT_PAGE_INIT config option,
which defers initializing struct pages until all cpus have been started so
it can be done in parallel.

However, this feature is sub-optimal, because the deferred page
initialization code expects that the struct pages have already been zeroed,
and the zeroing is done early in boot with a single thread only.  Also, we
access that memory and set flags before struct pages are initialized. All
of this is fixed in this patchset.

In this work we do the following:
- Never read access struct page until it was initialized
- Never set any fields in struct pages before they are initialized
- Zero struct page at the beginning of struct page initialization

Performance improvements on x86 machine with 8 nodes:
Intel(R) Xeon(R) CPU E7-8895 v3 @ 2.60GHz

Single threaded struct page init: 7.6s/T improvement
Deferred struct page init: 10.2s/T improvement

Pavel Tatashin (15):
  x86/mm: reserve only exiting low pages
  x86/mm: setting fields in deferred pages
  sparc64/mm: setting fields in deferred pages
  mm: discard memblock data later
  mm: don't accessed uninitialized struct pages
  sparc64: simplify vmemmap_populate
  mm: defining memblock_virt_alloc_try_nid_raw
  mm: zero struct pages during initialization
  sparc64: optimized struct page zeroing
  x86/kasan: explicitly zero kasan shadow memory
  arm64/kasan: explicitly zero kasan shadow memory
  mm: explicitly zero pagetable memory
  mm: stop zeroing memory during allocation in vmemmap
  mm: optimize early system hash allocations
  mm: debug for raw alloctor

 arch/arm64/mm/kasan_init.c          |  32 ++++++++
 arch/sparc/include/asm/pgtable_64.h |  18 +++++
 arch/sparc/mm/init_64.c             |  31 +++-----
 arch/x86/kernel/setup.c             |   5 +-
 arch/x86/mm/init_64.c               |   9 ++-
 arch/x86/mm/kasan_init_64.c         |  29 +++++++
 include/linux/bootmem.h             |  11 +++
 include/linux/memblock.h            |  10 ++-
 include/linux/mm.h                  |   9 +++
 mm/memblock.c                       | 152 ++++++++++++++++++++++++++++--------
 mm/nobootmem.c                      |  16 ----
 mm/page_alloc.c                     |  29 ++++---
 mm/sparse-vmemmap.c                 |  10 ++-
 mm/sparse.c                         |   6 +-
 14 files changed, 279 insertions(+), 88 deletions(-)

--
2.13.3

[v4 01/15] x86/mm: reserve only exiting low pages

[Pavel Tatashin]

Struct pages are initialized by going through __init_single_page(). Since
the existing physical memory in memblock is represented in memblock.memory
list, struct page for every page from this list goes through
__init_single_page().

The second memblock list: memblock.reserved, manages the allocated memory.
The memory that won't be available to kernel allocator. So, every page from
this list goes through reserve_bootmem_region(), where certain struct page
fields are set, the assumption being that the struct pages have been
initialized beforehand.

In trim_low_memory_range() we unconditionally reserve memoryfrom PFN 0, but
memblock.memory might start at a later PFN. For example, in QEMU,
e820__memblock_setup() can use PFN 1 as the first PFN in memblock.memory,
so PFN 0 is not on memblock.memory (and hence isn't initialized via
__init_single_page) but is on memblock.reserved (and hence we set fields in
the uninitialized struct page).

Currently, the struct page memory is always zeroed during allocation,
which prevents this problem from being detected. But, if some asserts
provided by CONFIG_DEBUG_VM_PGFLAGS are tighten, this problem may become
visible in existing kernels.

In this patchset we will stop zeroing struct page memory during allocation.
Therefore, this bug must be fixed in order to avoid random assert failures
caused by CONFIG_DEBUG_VM_PGFLAGS triggers.

The fix is to reserve memory from the first existing PFN.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/kernel/setup.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 3486d0498800..489cdc141bcb 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -790,7 +790,10 @@ early_param("reservelow", parse_reservelow);
 
 static void __init trim_low_memory_range(void)
 {
-	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
+	unsigned long min_pfn = find_min_pfn_with_active_regions();
+	phys_addr_t base = min_pfn << PAGE_SHIFT;
+
+	memblock_reserve(base, ALIGN(reserve_low, PAGE_SIZE));
 }
 	
 /*
-- 
2.13.3

[v4 01/15] x86/mm: reserve only exiting low pages

[Pavel Tatashin]

Struct pages are initialized by going through __init_single_page(). Since
the existing physical memory in memblock is represented in memblock.memory
list, struct page for every page from this list goes through
__init_single_page().

The second memblock list: memblock.reserved, manages the allocated memory.
The memory that won't be available to kernel allocator. So, every page from
this list goes through reserve_bootmem_region(), where certain struct page
fields are set, the assumption being that the struct pages have been
initialized beforehand.

In trim_low_memory_range() we unconditionally reserve memoryfrom PFN 0, but
memblock.memory might start at a later PFN. For example, in QEMU,
e820__memblock_setup() can use PFN 1 as the first PFN in memblock.memory,
so PFN 0 is not on memblock.memory (and hence isn't initialized via
__init_single_page) but is on memblock.reserved (and hence we set fields in
the uninitialized struct page).

Currently, the struct page memory is always zeroed during allocation,
which prevents this problem from being detected. But, if some asserts
provided by CONFIG_DEBUG_VM_PGFLAGS are tighten, this problem may become
visible in existing kernels.

In this patchset we will stop zeroing struct page memory during allocation.
Therefore, this bug must be fixed in order to avoid random assert failures
caused by CONFIG_DEBUG_VM_PGFLAGS triggers.

The fix is to reserve memory from the first existing PFN.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/kernel/setup.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 3486d0498800..489cdc141bcb 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -790,7 +790,10 @@ early_param("reservelow", parse_reservelow);
 
 static void __init trim_low_memory_range(void)
 {
-	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
+	unsigned long min_pfn = find_min_pfn_with_active_regions();
+	phys_addr_t base = min_pfn << PAGE_SHIFT;
+
+	memblock_reserve(base, ALIGN(reserve_low, PAGE_SIZE));
 }
 	
 /*
-- 
2.13.3

[v4 01/15] x86/mm: reserve only exiting low pages

[Pavel Tatashin]

Struct pages are initialized by going through __init_single_page(). Since
the existing physical memory in memblock is represented in memblock.memory
list, struct page for every page from this list goes through
__init_single_page().

The second memblock list: memblock.reserved, manages the allocated memory.
The memory that won't be available to kernel allocator. So, every page from
this list goes through reserve_bootmem_region(), where certain struct page
fields are set, the assumption being that the struct pages have been
initialized beforehand.

In trim_low_memory_range() we unconditionally reserve memoryfrom PFN 0, but
memblock.memory might start at a later PFN. For example, in QEMU,
e820__memblock_setup() can use PFN 1 as the first PFN in memblock.memory,
so PFN 0 is not on memblock.memory (and hence isn't initialized via
__init_single_page) but is on memblock.reserved (and hence we set fields in
the uninitialized struct page).

Currently, the struct page memory is always zeroed during allocation,
which prevents this problem from being detected. But, if some asserts
provided by CONFIG_DEBUG_VM_PGFLAGS are tighten, this problem may become
visible in existing kernels.

In this patchset we will stop zeroing struct page memory during allocation.
Therefore, this bug must be fixed in order to avoid random assert failures
caused by CONFIG_DEBUG_VM_PGFLAGS triggers.

The fix is to reserve memory from the first existing PFN.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/kernel/setup.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 3486d0498800..489cdc141bcb 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -790,7 +790,10 @@ early_param("reservelow", parse_reservelow);
 
 static void __init trim_low_memory_range(void)
 {
-	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
+	unsigned long min_pfn = find_min_pfn_with_active_regions();
+	phys_addr_t base = min_pfn << PAGE_SHIFT;
+
+	memblock_reserve(base, ALIGN(reserve_low, PAGE_SIZE));
 }
 	
 /*
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 01/15] x86/mm: reserve only exiting low pages

[Pavel Tatashin]

Struct pages are initialized by going through __init_single_page(). Since
the existing physical memory in memblock is represented in memblock.memory
list, struct page for every page from this list goes through
__init_single_page().

The second memblock list: memblock.reserved, manages the allocated memory.
The memory that won't be available to kernel allocator. So, every page from
this list goes through reserve_bootmem_region(), where certain struct page
fields are set, the assumption being that the struct pages have been
initialized beforehand.

In trim_low_memory_range() we unconditionally reserve memoryfrom PFN 0, but
memblock.memory might start at a later PFN. For example, in QEMU,
e820__memblock_setup() can use PFN 1 as the first PFN in memblock.memory,
so PFN 0 is not on memblock.memory (and hence isn't initialized via
__init_single_page) but is on memblock.reserved (and hence we set fields in
the uninitialized struct page).

Currently, the struct page memory is always zeroed during allocation,
which prevents this problem from being detected. But, if some asserts
provided by CONFIG_DEBUG_VM_PGFLAGS are tighten, this problem may become
visible in existing kernels.

In this patchset we will stop zeroing struct page memory during allocation.
Therefore, this bug must be fixed in order to avoid random assert failures
caused by CONFIG_DEBUG_VM_PGFLAGS triggers.

The fix is to reserve memory from the first existing PFN.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/kernel/setup.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 3486d0498800..489cdc141bcb 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -790,7 +790,10 @@ early_param("reservelow", parse_reservelow);
 
 static void __init trim_low_memory_range(void)
 {
-	memblock_reserve(0, ALIGN(reserve_low, PAGE_SIZE));
+	unsigned long min_pfn = find_min_pfn_with_active_regions();
+	phys_addr_t base = min_pfn << PAGE_SHIFT;
+
+	memblock_reserve(base, ALIGN(reserve_low, PAGE_SIZE));
 }
 	
 /*
-- 
2.13.3

[v4 02/15] x86/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

        mem_init() {
                register_page_bootmem_info();
                free_all_bootmem();
                ...
        }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

  mem_init
   register_page_bootmem_info
    register_page_bootmem_info_node
     get_page_bootmem
      .. setting fields here ..
      such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/init_64.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 136422d7d539..1e863baec847 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -1165,12 +1165,17 @@ void __init mem_init(void)
 
 	/* clear_bss() already clear the empty_zero_page */
 
-	register_page_bootmem_info();
-
 	/* this will put all memory onto the freelists */
 	free_all_bootmem();
 	after_bootmem = 1;
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/* Register memory areas for /proc/kcore */
 	kclist_add(&kcore_vsyscall, (void *)VSYSCALL_ADDR,
 			 PAGE_SIZE, KCORE_OTHER);
-- 
2.13.3

[v4 02/15] x86/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

        mem_init() {
                register_page_bootmem_info();
                free_all_bootmem();
                ...
        }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

  mem_init
   register_page_bootmem_info
    register_page_bootmem_info_node
     get_page_bootmem
      .. setting fields here ..
      such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/init_64.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 136422d7d539..1e863baec847 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -1165,12 +1165,17 @@ void __init mem_init(void)
 
 	/* clear_bss() already clear the empty_zero_page */
 
-	register_page_bootmem_info();
-
 	/* this will put all memory onto the freelists */
 	free_all_bootmem();
 	after_bootmem = 1;
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/* Register memory areas for /proc/kcore */
 	kclist_add(&kcore_vsyscall, (void *)VSYSCALL_ADDR,
 			 PAGE_SIZE, KCORE_OTHER);
-- 
2.13.3

[v4 02/15] x86/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

        mem_init() {
                register_page_bootmem_info();
                free_all_bootmem();
                ...
        }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

  mem_init
   register_page_bootmem_info
    register_page_bootmem_info_node
     get_page_bootmem
      .. setting fields here ..
      such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/init_64.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 136422d7d539..1e863baec847 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -1165,12 +1165,17 @@ void __init mem_init(void)
 
 	/* clear_bss() already clear the empty_zero_page */
 
-	register_page_bootmem_info();
-
 	/* this will put all memory onto the freelists */
 	free_all_bootmem();
 	after_bootmem = 1;
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/* Register memory areas for /proc/kcore */
 	kclist_add(&kcore_vsyscall, (void *)VSYSCALL_ADDR,
 			 PAGE_SIZE, KCORE_OTHER);
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 02/15] x86/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

        mem_init() {
                register_page_bootmem_info();
                free_all_bootmem();
                ...
        }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

  mem_init
   register_page_bootmem_info
    register_page_bootmem_info_node
     get_page_bootmem
      .. setting fields here ..
      such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/init_64.c | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 136422d7d539..1e863baec847 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -1165,12 +1165,17 @@ void __init mem_init(void)
 
 	/* clear_bss() already clear the empty_zero_page */
 
-	register_page_bootmem_info();
-
 	/* this will put all memory onto the freelists */
 	free_all_bootmem();
 	after_bootmem = 1;
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/* Register memory areas for /proc/kcore */
 	kclist_add(&kcore_vsyscall, (void *)VSYSCALL_ADDR,
 			 PAGE_SIZE, KCORE_OTHER);
-- 
2.13.3

[v4 03/15] sparc64/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

 mem_init() {
	 register_page_bootmem_info();
	 free_all_bootmem();
	 ...
 }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

mem_init
register_page_bootmem_info
 register_page_bootmem_info_node
  get_page_bootmem
   .. setting fields here ..
   such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 3c40ebd50f92..ba957b763c07 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2464,9 +2464,15 @@ void __init mem_init(void)
 {
 	high_memory = __va(last_valid_pfn << PAGE_SHIFT);
 
-	register_page_bootmem_info();
 	free_all_bootmem();
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/*
 	 * Set up the zero page, mark it reserved, so that page count
 	 * is not manipulated when freeing the page from user ptes.
-- 
2.13.3

[v4 03/15] sparc64/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

 mem_init() {
	 register_page_bootmem_info();
	 free_all_bootmem();
	 ...
 }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

mem_init
register_page_bootmem_info
 register_page_bootmem_info_node
  get_page_bootmem
   .. setting fields here ..
   such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 3c40ebd50f92..ba957b763c07 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2464,9 +2464,15 @@ void __init mem_init(void)
 {
 	high_memory = __va(last_valid_pfn << PAGE_SHIFT);
 
-	register_page_bootmem_info();
 	free_all_bootmem();
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/*
 	 * Set up the zero page, mark it reserved, so that page count
 	 * is not manipulated when freeing the page from user ptes.
-- 
2.13.3

[v4 03/15] sparc64/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

 mem_init() {
	 register_page_bootmem_info();
	 free_all_bootmem();
	 ...
 }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

mem_init
register_page_bootmem_info
 register_page_bootmem_info_node
  get_page_bootmem
   .. setting fields here ..
   such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 3c40ebd50f92..ba957b763c07 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2464,9 +2464,15 @@ void __init mem_init(void)
 {
 	high_memory = __va(last_valid_pfn << PAGE_SHIFT);
 
-	register_page_bootmem_info();
 	free_all_bootmem();
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/*
 	 * Set up the zero page, mark it reserved, so that page count
 	 * is not manipulated when freeing the page from user ptes.
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 03/15] sparc64/mm: setting fields in deferred pages

[Pavel Tatashin]

Without deferred struct page feature (CONFIG_DEFERRED_STRUCT_PAGE_INIT),
flags and other fields in "struct page"es are never changed prior to first
initializing struct pages by going through __init_single_page().

With deferred struct page feature enabled there is a case where we set some
fields prior to initializing:

 mem_init() {
	 register_page_bootmem_info();
	 free_all_bootmem();
	 ...
 }

When register_page_bootmem_info() is called only non-deferred struct pages
are initialized. But, this function goes through some reserved pages which
might be part of the deferred, and thus are not yet initialized.

mem_init
register_page_bootmem_info
 register_page_bootmem_info_node
  get_page_bootmem
   .. setting fields here ..
   such as: page->freelist = (void *)type;

We end-up with similar issue as in the previous patch, where currently we
do not observe problem as memory is zeroed. But, if flag asserts are
changed we can start hitting issues.

Also, because in this patch series we will stop zeroing struct page memory
during allocation, we must make sure that struct pages are properly
initialized prior to using them.

The deferred-reserved pages are initialized in free_all_bootmem().
Therefore, the fix is to switch the above calls.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 3c40ebd50f92..ba957b763c07 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2464,9 +2464,15 @@ void __init mem_init(void)
 {
 	high_memory = __va(last_valid_pfn << PAGE_SHIFT);
 
-	register_page_bootmem_info();
 	free_all_bootmem();
 
+	/* Must be done after boot memory is put on freelist, because here we
+	 * might set fields in deferred struct pages that have not yet been
+	 * initialized, and free_all_bootmem() initializes all the reserved
+	 * deferred pages for us.
+	 */
+	register_page_bootmem_info();
+
 	/*
 	 * Set up the zero page, mark it reserved, so that page count
 	 * is not manipulated when freeing the page from user ptes.
-- 
2.13.3

[v4 04/15] mm: discard memblock data later

[Pavel Tatashin]

There is existing use after free bug when deferred struct pages are
enabled:

The memblock_add() allocates memory for the memory array if more than
128 entries are needed.  See comment in e820__memblock_setup():

  * The bootstrap memblock region count maximum is 128 entries
  * (INIT_MEMBLOCK_REGIONS), but EFI might pass us more E820 entries
  * than that - so allow memblock resizing.

This memblock memory is freed here:
        free_low_memory_core_early()

We access the freed memblock.memory later in boot when deferred pages are
initialized in this path:

        deferred_init_memmap()
                for_each_mem_pfn_range()
                  __next_mem_pfn_range()
                    type = &memblock.memory;

One possible explanation for why this use-after-free hasn't been hit
before is that the limit of INIT_MEMBLOCK_REGIONS has never been exceeded
at least on systems where deferred struct pages were enabled.

Another reason why we want this problem fixed in this patch series is,
in the next patch, we will need to access memblock.reserved from
deferred_init_memmap().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  7 +++++--
 mm/memblock.c            | 38 +++++++++++++++++---------------------
 mm/nobootmem.c           | 16 ----------------
 mm/page_alloc.c          |  2 ++
 4 files changed, 24 insertions(+), 39 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 77d427974f57..c89d16c88512 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -61,9 +61,11 @@ extern int memblock_debug;
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
 #define __init_memblock __meminit
 #define __initdata_memblock __meminitdata
+void memblock_discard(void);
 #else
 #define __init_memblock
 #define __initdata_memblock
+#define memblock_discard()
 #endif
 
 #define memblock_dbg(fmt, ...) \
@@ -74,8 +76,6 @@ phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
 					int nid, ulong flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
 				   phys_addr_t size, phys_addr_t align);
-phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
-phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr);
 void memblock_allow_resize(void);
 int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid);
 int memblock_add(phys_addr_t base, phys_addr_t size);
@@ -110,6 +110,9 @@ void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
 void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
 				phys_addr_t *out_end);
 
+void __memblock_free_early(phys_addr_t base, phys_addr_t size);
+void __memblock_free_late(phys_addr_t base, phys_addr_t size);
+
 /**
  * for_each_mem_range - iterate through memblock areas from type_a and not
  * included in type_b. Or just type_a if type_b is NULL.
diff --git a/mm/memblock.c b/mm/memblock.c
index 2cb25fe4452c..3a2707914064 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -285,31 +285,27 @@ static void __init_memblock memblock_remove_region(struct memblock_type *type, u
 }
 
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-
-phys_addr_t __init_memblock get_allocated_memblock_reserved_regions_info(
-					phys_addr_t *addr)
-{
-	if (memblock.reserved.regions == memblock_reserved_init_regions)
-		return 0;
-
-	*addr = __pa(memblock.reserved.regions);
-
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.reserved.max);
-}
-
-phys_addr_t __init_memblock get_allocated_memblock_memory_regions_info(
-					phys_addr_t *addr)
+/**
+ * Discard memory and reserved arrays if they were allocated
+ */
+void __init_memblock memblock_discard(void)
 {
-	if (memblock.memory.regions == memblock_memory_init_regions)
-		return 0;
+	phys_addr_t addr, size;
 
-	*addr = __pa(memblock.memory.regions);
+	if (memblock.reserved.regions != memblock_reserved_init_regions) {
+		addr = __pa(memblock.reserved.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.reserved.max);
+		__memblock_free_late(addr, size);
+	}
 
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.memory.max);
+	if (memblock.memory.regions == memblock_memory_init_regions) {
+		addr = __pa(memblock.memory.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.memory.max);
+		__memblock_free_late(addr, size);
+	}
 }
-
 #endif
 
 /**
diff --git a/mm/nobootmem.c b/mm/nobootmem.c
index 36454d0f96ee..3637809a18d0 100644
--- a/mm/nobootmem.c
+++ b/mm/nobootmem.c
@@ -146,22 +146,6 @@ static unsigned long __init free_low_memory_core_early(void)
 				NULL)
 		count += __free_memory_core(start, end);
 
-#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-	{
-		phys_addr_t size;
-
-		/* Free memblock.reserved array if it was allocated */
-		size = get_allocated_memblock_reserved_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-
-		/* Free memblock.memory array if it was allocated */
-		size = get_allocated_memblock_memory_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-	}
-#endif
-
 	return count;
 }
 
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 6d30e914afb6..87fb35ac0b87 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1584,6 +1584,8 @@ void __init page_alloc_init_late(void)
 	/* Reinit limits that are based on free pages after the kernel is up */
 	files_maxfiles_init();
 #endif
+	/* Discard memblock private memory */
+	memblock_discard();
 
 	for_each_populated_zone(zone)
 		set_zone_contiguous(zone);
-- 
2.13.3

[v4 04/15] mm: discard memblock data later

[Pavel Tatashin]

There is existing use after free bug when deferred struct pages are
enabled:

The memblock_add() allocates memory for the memory array if more than
128 entries are needed.  See comment in e820__memblock_setup():

  * The bootstrap memblock region count maximum is 128 entries
  * (INIT_MEMBLOCK_REGIONS), but EFI might pass us more E820 entries
  * than that - so allow memblock resizing.

This memblock memory is freed here:
        free_low_memory_core_early()

We access the freed memblock.memory later in boot when deferred pages are
initialized in this path:

        deferred_init_memmap()
                for_each_mem_pfn_range()
                  __next_mem_pfn_range()
                    type = &memblock.memory;

One possible explanation for why this use-after-free hasn't been hit
before is that the limit of INIT_MEMBLOCK_REGIONS has never been exceeded
at least on systems where deferred struct pages were enabled.

Another reason why we want this problem fixed in this patch series is,
in the next patch, we will need to access memblock.reserved from
deferred_init_memmap().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  7 +++++--
 mm/memblock.c            | 38 +++++++++++++++++---------------------
 mm/nobootmem.c           | 16 ----------------
 mm/page_alloc.c          |  2 ++
 4 files changed, 24 insertions(+), 39 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 77d427974f57..c89d16c88512 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -61,9 +61,11 @@ extern int memblock_debug;
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
 #define __init_memblock __meminit
 #define __initdata_memblock __meminitdata
+void memblock_discard(void);
 #else
 #define __init_memblock
 #define __initdata_memblock
+#define memblock_discard()
 #endif
 
 #define memblock_dbg(fmt, ...) \
@@ -74,8 +76,6 @@ phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
 					int nid, ulong flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
 				   phys_addr_t size, phys_addr_t align);
-phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
-phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr);
 void memblock_allow_resize(void);
 int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid);
 int memblock_add(phys_addr_t base, phys_addr_t size);
@@ -110,6 +110,9 @@ void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
 void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
 				phys_addr_t *out_end);
 
+void __memblock_free_early(phys_addr_t base, phys_addr_t size);
+void __memblock_free_late(phys_addr_t base, phys_addr_t size);
+
 /**
  * for_each_mem_range - iterate through memblock areas from type_a and not
  * included in type_b. Or just type_a if type_b is NULL.
diff --git a/mm/memblock.c b/mm/memblock.c
index 2cb25fe4452c..3a2707914064 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -285,31 +285,27 @@ static void __init_memblock memblock_remove_region(struct memblock_type *type, u
 }
 
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-
-phys_addr_t __init_memblock get_allocated_memblock_reserved_regions_info(
-					phys_addr_t *addr)
-{
-	if (memblock.reserved.regions == memblock_reserved_init_regions)
-		return 0;
-
-	*addr = __pa(memblock.reserved.regions);
-
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.reserved.max);
-}
-
-phys_addr_t __init_memblock get_allocated_memblock_memory_regions_info(
-					phys_addr_t *addr)
+/**
+ * Discard memory and reserved arrays if they were allocated
+ */
+void __init_memblock memblock_discard(void)
 {
-	if (memblock.memory.regions == memblock_memory_init_regions)
-		return 0;
+	phys_addr_t addr, size;
 
-	*addr = __pa(memblock.memory.regions);
+	if (memblock.reserved.regions != memblock_reserved_init_regions) {
+		addr = __pa(memblock.reserved.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.reserved.max);
+		__memblock_free_late(addr, size);
+	}
 
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.memory.max);
+	if (memblock.memory.regions == memblock_memory_init_regions) {
+		addr = __pa(memblock.memory.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.memory.max);
+		__memblock_free_late(addr, size);
+	}
 }
-
 #endif
 
 /**
diff --git a/mm/nobootmem.c b/mm/nobootmem.c
index 36454d0f96ee..3637809a18d0 100644
--- a/mm/nobootmem.c
+++ b/mm/nobootmem.c
@@ -146,22 +146,6 @@ static unsigned long __init free_low_memory_core_early(void)
 				NULL)
 		count += __free_memory_core(start, end);
 
-#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-	{
-		phys_addr_t size;
-
-		/* Free memblock.reserved array if it was allocated */
-		size = get_allocated_memblock_reserved_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-
-		/* Free memblock.memory array if it was allocated */
-		size = get_allocated_memblock_memory_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-	}
-#endif
-
 	return count;
 }
 
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 6d30e914afb6..87fb35ac0b87 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1584,6 +1584,8 @@ void __init page_alloc_init_late(void)
 	/* Reinit limits that are based on free pages after the kernel is up */
 	files_maxfiles_init();
 #endif
+	/* Discard memblock private memory */
+	memblock_discard();
 
 	for_each_populated_zone(zone)
 		set_zone_contiguous(zone);
-- 
2.13.3

[v4 04/15] mm: discard memblock data later

[Pavel Tatashin]

There is existing use after free bug when deferred struct pages are
enabled:

The memblock_add() allocates memory for the memory array if more than
128 entries are needed.  See comment in e820__memblock_setup():

  * The bootstrap memblock region count maximum is 128 entries
  * (INIT_MEMBLOCK_REGIONS), but EFI might pass us more E820 entries
  * than that - so allow memblock resizing.

This memblock memory is freed here:
        free_low_memory_core_early()

We access the freed memblock.memory later in boot when deferred pages are
initialized in this path:

        deferred_init_memmap()
                for_each_mem_pfn_range()
                  __next_mem_pfn_range()
                    type = &memblock.memory;

One possible explanation for why this use-after-free hasn't been hit
before is that the limit of INIT_MEMBLOCK_REGIONS has never been exceeded
at least on systems where deferred struct pages were enabled.

Another reason why we want this problem fixed in this patch series is,
in the next patch, we will need to access memblock.reserved from
deferred_init_memmap().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  7 +++++--
 mm/memblock.c            | 38 +++++++++++++++++---------------------
 mm/nobootmem.c           | 16 ----------------
 mm/page_alloc.c          |  2 ++
 4 files changed, 24 insertions(+), 39 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 77d427974f57..c89d16c88512 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -61,9 +61,11 @@ extern int memblock_debug;
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
 #define __init_memblock __meminit
 #define __initdata_memblock __meminitdata
+void memblock_discard(void);
 #else
 #define __init_memblock
 #define __initdata_memblock
+#define memblock_discard()
 #endif
 
 #define memblock_dbg(fmt, ...) \
@@ -74,8 +76,6 @@ phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
 					int nid, ulong flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
 				   phys_addr_t size, phys_addr_t align);
-phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
-phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr);
 void memblock_allow_resize(void);
 int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid);
 int memblock_add(phys_addr_t base, phys_addr_t size);
@@ -110,6 +110,9 @@ void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
 void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
 				phys_addr_t *out_end);
 
+void __memblock_free_early(phys_addr_t base, phys_addr_t size);
+void __memblock_free_late(phys_addr_t base, phys_addr_t size);
+
 /**
  * for_each_mem_range - iterate through memblock areas from type_a and not
  * included in type_b. Or just type_a if type_b is NULL.
diff --git a/mm/memblock.c b/mm/memblock.c
index 2cb25fe4452c..3a2707914064 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -285,31 +285,27 @@ static void __init_memblock memblock_remove_region(struct memblock_type *type, u
 }
 
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-
-phys_addr_t __init_memblock get_allocated_memblock_reserved_regions_info(
-					phys_addr_t *addr)
-{
-	if (memblock.reserved.regions == memblock_reserved_init_regions)
-		return 0;
-
-	*addr = __pa(memblock.reserved.regions);
-
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.reserved.max);
-}
-
-phys_addr_t __init_memblock get_allocated_memblock_memory_regions_info(
-					phys_addr_t *addr)
+/**
+ * Discard memory and reserved arrays if they were allocated
+ */
+void __init_memblock memblock_discard(void)
 {
-	if (memblock.memory.regions == memblock_memory_init_regions)
-		return 0;
+	phys_addr_t addr, size;
 
-	*addr = __pa(memblock.memory.regions);
+	if (memblock.reserved.regions != memblock_reserved_init_regions) {
+		addr = __pa(memblock.reserved.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.reserved.max);
+		__memblock_free_late(addr, size);
+	}
 
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.memory.max);
+	if (memblock.memory.regions == memblock_memory_init_regions) {
+		addr = __pa(memblock.memory.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.memory.max);
+		__memblock_free_late(addr, size);
+	}
 }
-
 #endif
 
 /**
diff --git a/mm/nobootmem.c b/mm/nobootmem.c
index 36454d0f96ee..3637809a18d0 100644
--- a/mm/nobootmem.c
+++ b/mm/nobootmem.c
@@ -146,22 +146,6 @@ static unsigned long __init free_low_memory_core_early(void)
 				NULL)
 		count += __free_memory_core(start, end);
 
-#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-	{
-		phys_addr_t size;
-
-		/* Free memblock.reserved array if it was allocated */
-		size = get_allocated_memblock_reserved_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-
-		/* Free memblock.memory array if it was allocated */
-		size = get_allocated_memblock_memory_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-	}
-#endif
-
 	return count;
 }
 
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 6d30e914afb6..87fb35ac0b87 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1584,6 +1584,8 @@ void __init page_alloc_init_late(void)
 	/* Reinit limits that are based on free pages after the kernel is up */
 	files_maxfiles_init();
 #endif
+	/* Discard memblock private memory */
+	memblock_discard();
 
 	for_each_populated_zone(zone)
 		set_zone_contiguous(zone);
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 04/15] mm: discard memblock data later

[Pavel Tatashin]

There is existing use after free bug when deferred struct pages are
enabled:

The memblock_add() allocates memory for the memory array if more than
128 entries are needed.  See comment in e820__memblock_setup():

  * The bootstrap memblock region count maximum is 128 entries
  * (INIT_MEMBLOCK_REGIONS), but EFI might pass us more E820 entries
  * than that - so allow memblock resizing.

This memblock memory is freed here:
        free_low_memory_core_early()

We access the freed memblock.memory later in boot when deferred pages are
initialized in this path:

        deferred_init_memmap()
                for_each_mem_pfn_range()
                  __next_mem_pfn_range()
                    type = &memblock.memory;

One possible explanation for why this use-after-free hasn't been hit
before is that the limit of INIT_MEMBLOCK_REGIONS has never been exceeded
at least on systems where deferred struct pages were enabled.

Another reason why we want this problem fixed in this patch series is,
in the next patch, we will need to access memblock.reserved from
deferred_init_memmap().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  7 +++++--
 mm/memblock.c            | 38 +++++++++++++++++---------------------
 mm/nobootmem.c           | 16 ----------------
 mm/page_alloc.c          |  2 ++
 4 files changed, 24 insertions(+), 39 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 77d427974f57..c89d16c88512 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -61,9 +61,11 @@ extern int memblock_debug;
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
 #define __init_memblock __meminit
 #define __initdata_memblock __meminitdata
+void memblock_discard(void);
 #else
 #define __init_memblock
 #define __initdata_memblock
+#define memblock_discard()
 #endif
 
 #define memblock_dbg(fmt, ...) \
@@ -74,8 +76,6 @@ phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
 					int nid, ulong flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
 				   phys_addr_t size, phys_addr_t align);
-phys_addr_t get_allocated_memblock_reserved_regions_info(phys_addr_t *addr);
-phys_addr_t get_allocated_memblock_memory_regions_info(phys_addr_t *addr);
 void memblock_allow_resize(void);
 int memblock_add_node(phys_addr_t base, phys_addr_t size, int nid);
 int memblock_add(phys_addr_t base, phys_addr_t size);
@@ -110,6 +110,9 @@ void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
 void __next_reserved_mem_region(u64 *idx, phys_addr_t *out_start,
 				phys_addr_t *out_end);
 
+void __memblock_free_early(phys_addr_t base, phys_addr_t size);
+void __memblock_free_late(phys_addr_t base, phys_addr_t size);
+
 /**
  * for_each_mem_range - iterate through memblock areas from type_a and not
  * included in type_b. Or just type_a if type_b is NULL.
diff --git a/mm/memblock.c b/mm/memblock.c
index 2cb25fe4452c..3a2707914064 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -285,31 +285,27 @@ static void __init_memblock memblock_remove_region(struct memblock_type *type, u
 }
 
 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-
-phys_addr_t __init_memblock get_allocated_memblock_reserved_regions_info(
-					phys_addr_t *addr)
-{
-	if (memblock.reserved.regions = memblock_reserved_init_regions)
-		return 0;
-
-	*addr = __pa(memblock.reserved.regions);
-
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.reserved.max);
-}
-
-phys_addr_t __init_memblock get_allocated_memblock_memory_regions_info(
-					phys_addr_t *addr)
+/**
+ * Discard memory and reserved arrays if they were allocated
+ */
+void __init_memblock memblock_discard(void)
 {
-	if (memblock.memory.regions = memblock_memory_init_regions)
-		return 0;
+	phys_addr_t addr, size;
 
-	*addr = __pa(memblock.memory.regions);
+	if (memblock.reserved.regions != memblock_reserved_init_regions) {
+		addr = __pa(memblock.reserved.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.reserved.max);
+		__memblock_free_late(addr, size);
+	}
 
-	return PAGE_ALIGN(sizeof(struct memblock_region) *
-			  memblock.memory.max);
+	if (memblock.memory.regions = memblock_memory_init_regions) {
+		addr = __pa(memblock.memory.regions);
+		size = PAGE_ALIGN(sizeof(struct memblock_region) *
+				  memblock.memory.max);
+		__memblock_free_late(addr, size);
+	}
 }
-
 #endif
 
 /**
diff --git a/mm/nobootmem.c b/mm/nobootmem.c
index 36454d0f96ee..3637809a18d0 100644
--- a/mm/nobootmem.c
+++ b/mm/nobootmem.c
@@ -146,22 +146,6 @@ static unsigned long __init free_low_memory_core_early(void)
 				NULL)
 		count += __free_memory_core(start, end);
 
-#ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
-	{
-		phys_addr_t size;
-
-		/* Free memblock.reserved array if it was allocated */
-		size = get_allocated_memblock_reserved_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-
-		/* Free memblock.memory array if it was allocated */
-		size = get_allocated_memblock_memory_regions_info(&start);
-		if (size)
-			count += __free_memory_core(start, start + size);
-	}
-#endif
-
 	return count;
 }
 
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 6d30e914afb6..87fb35ac0b87 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1584,6 +1584,8 @@ void __init page_alloc_init_late(void)
 	/* Reinit limits that are based on free pages after the kernel is up */
 	files_maxfiles_init();
 #endif
+	/* Discard memblock private memory */
+	memblock_discard();
 
 	for_each_populated_zone(zone)
 		set_zone_contiguous(zone);
-- 
2.13.3

Re: [v4 04/15] mm: discard memblock data later

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 1983 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: tile-allmodconfig (attached as .config)
compiler: tilegx-linux-gcc (GCC) 4.6.2
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=tile 

All errors (new ones prefixed by >>):

   mm/page_alloc.c: In function 'page_alloc_init_late':
>> mm/page_alloc.c:1588:2: error: implicit declaration of function 'memblock_discard'
   cc1: some warnings being treated as errors

vim +/memblock_discard +1588 mm/page_alloc.c

  1567	
  1568	void __init page_alloc_init_late(void)
  1569	{
  1570		struct zone *zone;
  1571	
  1572	#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
  1573		int nid;
  1574	
  1575		/* There will be num_node_state(N_MEMORY) threads */
  1576		atomic_set(&pgdat_init_n_undone, num_node_state(N_MEMORY));
  1577		for_each_node_state(nid, N_MEMORY) {
  1578			kthread_run(deferred_init_memmap, NODE_DATA(nid), "pgdatinit%d", nid);
  1579		}
  1580	
  1581		/* Block until all are initialised */
  1582		wait_for_completion(&pgdat_init_all_done_comp);
  1583	
  1584		/* Reinit limits that are based on free pages after the kernel is up */
  1585		files_maxfiles_init();
  1586	#endif
  1587		/* Discard memblock private memory */
> 1588		memblock_discard();
  1589	
  1590		for_each_populated_zone(zone)
  1591			set_zone_contiguous(zone);
  1592	}
  1593	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 49784 bytes --]

[v4 04/15] mm: discard memblock data later

[kbuild test robot]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: tile-allmodconfig (attached as .config)
compiler: tilegx-linux-gcc (GCC) 4.6.2
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=tile 

All errors (new ones prefixed by >>):

   mm/page_alloc.c: In function 'page_alloc_init_late':
>> mm/page_alloc.c:1588:2: error: implicit declaration of function 'memblock_discard'
   cc1: some warnings being treated as errors

vim +/memblock_discard +1588 mm/page_alloc.c

  1567	
  1568	void __init page_alloc_init_late(void)
  1569	{
  1570		struct zone *zone;
  1571	
  1572	#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
  1573		int nid;
  1574	
  1575		/* There will be num_node_state(N_MEMORY) threads */
  1576		atomic_set(&pgdat_init_n_undone, num_node_state(N_MEMORY));
  1577		for_each_node_state(nid, N_MEMORY) {
  1578			kthread_run(deferred_init_memmap, NODE_DATA(nid), "pgdatinit%d", nid);
  1579		}
  1580	
  1581		/* Block until all are initialised */
  1582		wait_for_completion(&pgdat_init_all_done_comp);
  1583	
  1584		/* Reinit limits that are based on free pages after the kernel is up */
  1585		files_maxfiles_init();
  1586	#endif
  1587		/* Discard memblock private memory */
> 1588		memblock_discard();
  1589	
  1590		for_each_populated_zone(zone)
  1591			set_zone_contiguous(zone);
  1592	}
  1593	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
-------------- next part --------------
A non-text attachment was scrubbed...
Name: .config.gz
Type: application/gzip
Size: 49784 bytes
Desc: not available
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20170803/5078114a/attachment-0001.gz>

Re: [v4 04/15] mm: discard memblock data later

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 1983 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: tile-allmodconfig (attached as .config)
compiler: tilegx-linux-gcc (GCC) 4.6.2
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=tile 

All errors (new ones prefixed by >>):

   mm/page_alloc.c: In function 'page_alloc_init_late':
>> mm/page_alloc.c:1588:2: error: implicit declaration of function 'memblock_discard'
   cc1: some warnings being treated as errors

vim +/memblock_discard +1588 mm/page_alloc.c

  1567	
  1568	void __init page_alloc_init_late(void)
  1569	{
  1570		struct zone *zone;
  1571	
  1572	#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
  1573		int nid;
  1574	
  1575		/* There will be num_node_state(N_MEMORY) threads */
  1576		atomic_set(&pgdat_init_n_undone, num_node_state(N_MEMORY));
  1577		for_each_node_state(nid, N_MEMORY) {
  1578			kthread_run(deferred_init_memmap, NODE_DATA(nid), "pgdatinit%d", nid);
  1579		}
  1580	
  1581		/* Block until all are initialised */
  1582		wait_for_completion(&pgdat_init_all_done_comp);
  1583	
  1584		/* Reinit limits that are based on free pages after the kernel is up */
  1585		files_maxfiles_init();
  1586	#endif
  1587		/* Discard memblock private memory */
> 1588		memblock_discard();
  1589	
  1590		for_each_populated_zone(zone)
  1591			set_zone_contiguous(zone);
  1592	}
  1593	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 49784 bytes --]

Re: [v4 04/15] mm: discard memblock data later

[kbuild test robot]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: multipart/mixed; boundary="--Qxx1br4bt0+wmkIi", Size: 69540 bytes --]


--Qxx1br4bt0+wmkIi
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: tile-allmodconfig (attached as .config)
compiler: tilegx-linux-gcc (GCC) 4.6.2
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=tile 

All errors (new ones prefixed by >>):

   mm/page_alloc.c: In function 'page_alloc_init_late':
>> mm/page_alloc.c:1588:2: error: implicit declaration of function 'memblock_discard'
   cc1: some warnings being treated as errors

vim +/memblock_discard +1588 mm/page_alloc.c

  1567	
  1568	void __init page_alloc_init_late(void)
  1569	{
  1570		struct zone *zone;
  1571	
  1572	#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
  1573		int nid;
  1574	
  1575		/* There will be num_node_state(N_MEMORY) threads */
  1576		atomic_set(&pgdat_init_n_undone, num_node_state(N_MEMORY));
  1577		for_each_node_state(nid, N_MEMORY) {
  1578			kthread_run(deferred_init_memmap, NODE_DATA(nid), "pgdatinit%d", nid);
  1579		}
  1580	
  1581		/* Block until all are initialised */
  1582		wait_for_completion(&pgdat_init_all_done_comp);
  1583	
  1584		/* Reinit limits that are based on free pages after the kernel is up */
  1585		files_maxfiles_init();
  1586	#endif
  1587		/* Discard memblock private memory */
> 1588		memblock_discard();
  1589	
  1590		for_each_populated_zone(zone)
  1591			set_zone_contiguous(zone);
  1592	}
  1593	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

--Qxx1br4bt0+wmkIi
Content-Type: application/gzip
Content-Disposition: attachment; filename=".config.gz"
Content-Transfer-Encoding: base64
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=

--Qxx1br4bt0+wmkIi--

[v4 05/15] mm: don't accessed uninitialized struct pages

[Pavel Tatashin]

In deferred_init_memmap() where all deferred struct pages are initialized
we have a check like this:

    if (page->flags) {
            VM_BUG_ON(page_zone(page) != zone);
            goto free_range;
    }

This way we are checking if the current deferred page has already been
initialized. It works, because memory for struct pages has been zeroed, and
the only way flags are not zero if it went through __init_single_page()
before.  But, once we change the current behavior and won't zero the memory
in memblock allocator, we cannot trust anything inside "struct page"es
until they are initialized. This patch fixes this.

This patch defines a new accessor memblock_get_reserved_pfn_range()
which returns successive ranges of reserved PFNs.  deferred_init_memmap()
calls it to determine if a PFN and its struct page has already been
initialized.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  3 +++
 mm/memblock.c            | 54 ++++++++++++++++++++++++++++++++++++++++++------
 mm/page_alloc.c          | 11 +++++++++-
 3 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index c89d16c88512..9d8dabedf5ba 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -321,6 +321,9 @@ int memblock_is_map_memory(phys_addr_t addr);
 int memblock_is_region_memory(phys_addr_t base, phys_addr_t size);
 bool memblock_is_reserved(phys_addr_t addr);
 bool memblock_is_region_reserved(phys_addr_t base, phys_addr_t size);
+void memblock_get_reserved_pfn_range(unsigned long pfn,
+				     unsigned long *pfn_start,
+				     unsigned long *pfn_end);
 
 extern void __memblock_dump_all(void);
 
diff --git a/mm/memblock.c b/mm/memblock.c
index 3a2707914064..e6df054e3180 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1580,7 +1580,13 @@ void __init memblock_mem_limit_remove_map(phys_addr_t limit)
 	memblock_cap_memory_range(0, max_addr);
 }
 
-static int __init_memblock memblock_search(struct memblock_type *type, phys_addr_t addr)
+/**
+ * Return index in regions array if addr is within the region. Otherwise
+ * return -1. If -1 is returned and *next_idx is not %NULL, sets it to the
+ * next region index or -1 if there is none.
+ */
+static int __init_memblock memblock_search(struct memblock_type *type,
+					   phys_addr_t addr, int *next_idx)
 {
 	unsigned int left = 0, right = type->cnt;
 
@@ -1595,22 +1601,26 @@ static int __init_memblock memblock_search(struct memblock_type *type, phys_addr
 		else
 			return mid;
 	} while (left < right);
+
+	if (next_idx)
+		*next_idx = (right == type->cnt) ? -1 : right;
+
 	return -1;
 }
 
 bool __init memblock_is_reserved(phys_addr_t addr)
 {
-	return memblock_search(&memblock.reserved, addr) != -1;
+	return memblock_search(&memblock.reserved, addr, NULL) != -1;
 }
 
 bool __init_memblock memblock_is_memory(phys_addr_t addr)
 {
-	return memblock_search(&memblock.memory, addr) != -1;
+	return memblock_search(&memblock.memory, addr, NULL) != -1;
 }
 
 int __init_memblock memblock_is_map_memory(phys_addr_t addr)
 {
-	int i = memblock_search(&memblock.memory, addr);
+	int i = memblock_search(&memblock.memory, addr, NULL);
 
 	if (i == -1)
 		return false;
@@ -1622,7 +1632,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
 			 unsigned long *start_pfn, unsigned long *end_pfn)
 {
 	struct memblock_type *type = &memblock.memory;
-	int mid = memblock_search(type, PFN_PHYS(pfn));
+	int mid = memblock_search(type, PFN_PHYS(pfn), NULL);
 
 	if (mid == -1)
 		return -1;
@@ -1646,7 +1656,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
  */
 int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size)
 {
-	int idx = memblock_search(&memblock.memory, base);
+	int idx = memblock_search(&memblock.memory, base, NULL);
 	phys_addr_t end = base + memblock_cap_size(base, &size);
 
 	if (idx == -1)
@@ -1656,6 +1666,38 @@ int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size
 }
 
 /**
+ * memblock_get_reserved_pfn_range - search for the next reserved region
+ *
+ * @pfn: start searching from this pfn.
+ *
+ * RETURNS:
+ * [start_pfn, end_pfn), where start_pfn >= pfn. If none is found
+ * start_pfn, and end_pfn are both set to ULONG_MAX.
+ */
+void __init_memblock memblock_get_reserved_pfn_range(unsigned long pfn,
+						     unsigned long *start_pfn,
+						     unsigned long *end_pfn)
+{
+	struct memblock_type *type = &memblock.reserved;
+	int next_idx, idx;
+
+	idx = memblock_search(type, PFN_PHYS(pfn), &next_idx);
+	if (idx == -1 && next_idx == -1) {
+		*start_pfn = ULONG_MAX;
+		*end_pfn = ULONG_MAX;
+		return;
+	}
+
+	if (idx == -1) {
+		idx = next_idx;
+		*start_pfn = PFN_DOWN(type->regions[idx].base);
+	} else {
+		*start_pfn = pfn;
+	}
+	*end_pfn = PFN_DOWN(type->regions[idx].base + type->regions[idx].size);
+}
+
+/**
  * memblock_is_region_reserved - check if a region intersects reserved memory
  * @base: base of region to check
  * @size: size of region to check
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 87fb35ac0b87..99b9e2e06319 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1447,6 +1447,7 @@ static int __init deferred_init_memmap(void *data)
 	pg_data_t *pgdat = data;
 	int nid = pgdat->node_id;
 	struct mminit_pfnnid_cache nid_init_state = { };
+	unsigned long resv_start_pfn = 0, resv_end_pfn = 0;
 	unsigned long start = jiffies;
 	unsigned long nr_pages = 0;
 	unsigned long walk_start, walk_end;
@@ -1491,6 +1492,10 @@ static int __init deferred_init_memmap(void *data)
 			pfn = zone->zone_start_pfn;
 
 		for (; pfn < end_pfn; pfn++) {
+			if (pfn >= resv_end_pfn)
+				memblock_get_reserved_pfn_range(pfn,
+								&resv_start_pfn,
+								&resv_end_pfn);
 			if (!pfn_valid_within(pfn))
 				goto free_range;
 
@@ -1524,7 +1529,11 @@ static int __init deferred_init_memmap(void *data)
 				cond_resched();
 			}
 
-			if (page->flags) {
+			/*
+			 * Check if this page has already been initialized due
+			 * to being reserved during boot in memblock.
+			 */
+			if (pfn >= resv_start_pfn) {
 				VM_BUG_ON(page_zone(page) != zone);
 				goto free_range;
 			}
-- 
2.13.3

[v4 05/15] mm: don't accessed uninitialized struct pages

[Pavel Tatashin]

In deferred_init_memmap() where all deferred struct pages are initialized
we have a check like this:

    if (page->flags) {
            VM_BUG_ON(page_zone(page) != zone);
            goto free_range;
    }

This way we are checking if the current deferred page has already been
initialized. It works, because memory for struct pages has been zeroed, and
the only way flags are not zero if it went through __init_single_page()
before.  But, once we change the current behavior and won't zero the memory
in memblock allocator, we cannot trust anything inside "struct page"es
until they are initialized. This patch fixes this.

This patch defines a new accessor memblock_get_reserved_pfn_range()
which returns successive ranges of reserved PFNs.  deferred_init_memmap()
calls it to determine if a PFN and its struct page has already been
initialized.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  3 +++
 mm/memblock.c            | 54 ++++++++++++++++++++++++++++++++++++++++++------
 mm/page_alloc.c          | 11 +++++++++-
 3 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index c89d16c88512..9d8dabedf5ba 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -321,6 +321,9 @@ int memblock_is_map_memory(phys_addr_t addr);
 int memblock_is_region_memory(phys_addr_t base, phys_addr_t size);
 bool memblock_is_reserved(phys_addr_t addr);
 bool memblock_is_region_reserved(phys_addr_t base, phys_addr_t size);
+void memblock_get_reserved_pfn_range(unsigned long pfn,
+				     unsigned long *pfn_start,
+				     unsigned long *pfn_end);
 
 extern void __memblock_dump_all(void);
 
diff --git a/mm/memblock.c b/mm/memblock.c
index 3a2707914064..e6df054e3180 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1580,7 +1580,13 @@ void __init memblock_mem_limit_remove_map(phys_addr_t limit)
 	memblock_cap_memory_range(0, max_addr);
 }
 
-static int __init_memblock memblock_search(struct memblock_type *type, phys_addr_t addr)
+/**
+ * Return index in regions array if addr is within the region. Otherwise
+ * return -1. If -1 is returned and *next_idx is not %NULL, sets it to the
+ * next region index or -1 if there is none.
+ */
+static int __init_memblock memblock_search(struct memblock_type *type,
+					   phys_addr_t addr, int *next_idx)
 {
 	unsigned int left = 0, right = type->cnt;
 
@@ -1595,22 +1601,26 @@ static int __init_memblock memblock_search(struct memblock_type *type, phys_addr
 		else
 			return mid;
 	} while (left < right);
+
+	if (next_idx)
+		*next_idx = (right == type->cnt) ? -1 : right;
+
 	return -1;
 }
 
 bool __init memblock_is_reserved(phys_addr_t addr)
 {
-	return memblock_search(&memblock.reserved, addr) != -1;
+	return memblock_search(&memblock.reserved, addr, NULL) != -1;
 }
 
 bool __init_memblock memblock_is_memory(phys_addr_t addr)
 {
-	return memblock_search(&memblock.memory, addr) != -1;
+	return memblock_search(&memblock.memory, addr, NULL) != -1;
 }
 
 int __init_memblock memblock_is_map_memory(phys_addr_t addr)
 {
-	int i = memblock_search(&memblock.memory, addr);
+	int i = memblock_search(&memblock.memory, addr, NULL);
 
 	if (i == -1)
 		return false;
@@ -1622,7 +1632,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
 			 unsigned long *start_pfn, unsigned long *end_pfn)
 {
 	struct memblock_type *type = &memblock.memory;
-	int mid = memblock_search(type, PFN_PHYS(pfn));
+	int mid = memblock_search(type, PFN_PHYS(pfn), NULL);
 
 	if (mid == -1)
 		return -1;
@@ -1646,7 +1656,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
  */
 int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size)
 {
-	int idx = memblock_search(&memblock.memory, base);
+	int idx = memblock_search(&memblock.memory, base, NULL);
 	phys_addr_t end = base + memblock_cap_size(base, &size);
 
 	if (idx == -1)
@@ -1656,6 +1666,38 @@ int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size
 }
 
 /**
+ * memblock_get_reserved_pfn_range - search for the next reserved region
+ *
+ * @pfn: start searching from this pfn.
+ *
+ * RETURNS:
+ * [start_pfn, end_pfn), where start_pfn >= pfn. If none is found
+ * start_pfn, and end_pfn are both set to ULONG_MAX.
+ */
+void __init_memblock memblock_get_reserved_pfn_range(unsigned long pfn,
+						     unsigned long *start_pfn,
+						     unsigned long *end_pfn)
+{
+	struct memblock_type *type = &memblock.reserved;
+	int next_idx, idx;
+
+	idx = memblock_search(type, PFN_PHYS(pfn), &next_idx);
+	if (idx == -1 && next_idx == -1) {
+		*start_pfn = ULONG_MAX;
+		*end_pfn = ULONG_MAX;
+		return;
+	}
+
+	if (idx == -1) {
+		idx = next_idx;
+		*start_pfn = PFN_DOWN(type->regions[idx].base);
+	} else {
+		*start_pfn = pfn;
+	}
+	*end_pfn = PFN_DOWN(type->regions[idx].base + type->regions[idx].size);
+}
+
+/**
  * memblock_is_region_reserved - check if a region intersects reserved memory
  * @base: base of region to check
  * @size: size of region to check
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 87fb35ac0b87..99b9e2e06319 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1447,6 +1447,7 @@ static int __init deferred_init_memmap(void *data)
 	pg_data_t *pgdat = data;
 	int nid = pgdat->node_id;
 	struct mminit_pfnnid_cache nid_init_state = { };
+	unsigned long resv_start_pfn = 0, resv_end_pfn = 0;
 	unsigned long start = jiffies;
 	unsigned long nr_pages = 0;
 	unsigned long walk_start, walk_end;
@@ -1491,6 +1492,10 @@ static int __init deferred_init_memmap(void *data)
 			pfn = zone->zone_start_pfn;
 
 		for (; pfn < end_pfn; pfn++) {
+			if (pfn >= resv_end_pfn)
+				memblock_get_reserved_pfn_range(pfn,
+								&resv_start_pfn,
+								&resv_end_pfn);
 			if (!pfn_valid_within(pfn))
 				goto free_range;
 
@@ -1524,7 +1529,11 @@ static int __init deferred_init_memmap(void *data)
 				cond_resched();
 			}
 
-			if (page->flags) {
+			/*
+			 * Check if this page has already been initialized due
+			 * to being reserved during boot in memblock.
+			 */
+			if (pfn >= resv_start_pfn) {
 				VM_BUG_ON(page_zone(page) != zone);
 				goto free_range;
 			}
-- 
2.13.3

[v4 05/15] mm: don't accessed uninitialized struct pages

[Pavel Tatashin]

In deferred_init_memmap() where all deferred struct pages are initialized
we have a check like this:

    if (page->flags) {
            VM_BUG_ON(page_zone(page) != zone);
            goto free_range;
    }

This way we are checking if the current deferred page has already been
initialized. It works, because memory for struct pages has been zeroed, and
the only way flags are not zero if it went through __init_single_page()
before.  But, once we change the current behavior and won't zero the memory
in memblock allocator, we cannot trust anything inside "struct page"es
until they are initialized. This patch fixes this.

This patch defines a new accessor memblock_get_reserved_pfn_range()
which returns successive ranges of reserved PFNs.  deferred_init_memmap()
calls it to determine if a PFN and its struct page has already been
initialized.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  3 +++
 mm/memblock.c            | 54 ++++++++++++++++++++++++++++++++++++++++++------
 mm/page_alloc.c          | 11 +++++++++-
 3 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index c89d16c88512..9d8dabedf5ba 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -321,6 +321,9 @@ int memblock_is_map_memory(phys_addr_t addr);
 int memblock_is_region_memory(phys_addr_t base, phys_addr_t size);
 bool memblock_is_reserved(phys_addr_t addr);
 bool memblock_is_region_reserved(phys_addr_t base, phys_addr_t size);
+void memblock_get_reserved_pfn_range(unsigned long pfn,
+				     unsigned long *pfn_start,
+				     unsigned long *pfn_end);
 
 extern void __memblock_dump_all(void);
 
diff --git a/mm/memblock.c b/mm/memblock.c
index 3a2707914064..e6df054e3180 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1580,7 +1580,13 @@ void __init memblock_mem_limit_remove_map(phys_addr_t limit)
 	memblock_cap_memory_range(0, max_addr);
 }
 
-static int __init_memblock memblock_search(struct memblock_type *type, phys_addr_t addr)
+/**
+ * Return index in regions array if addr is within the region. Otherwise
+ * return -1. If -1 is returned and *next_idx is not %NULL, sets it to the
+ * next region index or -1 if there is none.
+ */
+static int __init_memblock memblock_search(struct memblock_type *type,
+					   phys_addr_t addr, int *next_idx)
 {
 	unsigned int left = 0, right = type->cnt;
 
@@ -1595,22 +1601,26 @@ static int __init_memblock memblock_search(struct memblock_type *type, phys_addr
 		else
 			return mid;
 	} while (left < right);
+
+	if (next_idx)
+		*next_idx = (right == type->cnt) ? -1 : right;
+
 	return -1;
 }
 
 bool __init memblock_is_reserved(phys_addr_t addr)
 {
-	return memblock_search(&memblock.reserved, addr) != -1;
+	return memblock_search(&memblock.reserved, addr, NULL) != -1;
 }
 
 bool __init_memblock memblock_is_memory(phys_addr_t addr)
 {
-	return memblock_search(&memblock.memory, addr) != -1;
+	return memblock_search(&memblock.memory, addr, NULL) != -1;
 }
 
 int __init_memblock memblock_is_map_memory(phys_addr_t addr)
 {
-	int i = memblock_search(&memblock.memory, addr);
+	int i = memblock_search(&memblock.memory, addr, NULL);
 
 	if (i == -1)
 		return false;
@@ -1622,7 +1632,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
 			 unsigned long *start_pfn, unsigned long *end_pfn)
 {
 	struct memblock_type *type = &memblock.memory;
-	int mid = memblock_search(type, PFN_PHYS(pfn));
+	int mid = memblock_search(type, PFN_PHYS(pfn), NULL);
 
 	if (mid == -1)
 		return -1;
@@ -1646,7 +1656,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
  */
 int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size)
 {
-	int idx = memblock_search(&memblock.memory, base);
+	int idx = memblock_search(&memblock.memory, base, NULL);
 	phys_addr_t end = base + memblock_cap_size(base, &size);
 
 	if (idx == -1)
@@ -1656,6 +1666,38 @@ int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size
 }
 
 /**
+ * memblock_get_reserved_pfn_range - search for the next reserved region
+ *
+ * @pfn: start searching from this pfn.
+ *
+ * RETURNS:
+ * [start_pfn, end_pfn), where start_pfn >= pfn. If none is found
+ * start_pfn, and end_pfn are both set to ULONG_MAX.
+ */
+void __init_memblock memblock_get_reserved_pfn_range(unsigned long pfn,
+						     unsigned long *start_pfn,
+						     unsigned long *end_pfn)
+{
+	struct memblock_type *type = &memblock.reserved;
+	int next_idx, idx;
+
+	idx = memblock_search(type, PFN_PHYS(pfn), &next_idx);
+	if (idx == -1 && next_idx == -1) {
+		*start_pfn = ULONG_MAX;
+		*end_pfn = ULONG_MAX;
+		return;
+	}
+
+	if (idx == -1) {
+		idx = next_idx;
+		*start_pfn = PFN_DOWN(type->regions[idx].base);
+	} else {
+		*start_pfn = pfn;
+	}
+	*end_pfn = PFN_DOWN(type->regions[idx].base + type->regions[idx].size);
+}
+
+/**
  * memblock_is_region_reserved - check if a region intersects reserved memory
  * @base: base of region to check
  * @size: size of region to check
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 87fb35ac0b87..99b9e2e06319 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1447,6 +1447,7 @@ static int __init deferred_init_memmap(void *data)
 	pg_data_t *pgdat = data;
 	int nid = pgdat->node_id;
 	struct mminit_pfnnid_cache nid_init_state = { };
+	unsigned long resv_start_pfn = 0, resv_end_pfn = 0;
 	unsigned long start = jiffies;
 	unsigned long nr_pages = 0;
 	unsigned long walk_start, walk_end;
@@ -1491,6 +1492,10 @@ static int __init deferred_init_memmap(void *data)
 			pfn = zone->zone_start_pfn;
 
 		for (; pfn < end_pfn; pfn++) {
+			if (pfn >= resv_end_pfn)
+				memblock_get_reserved_pfn_range(pfn,
+								&resv_start_pfn,
+								&resv_end_pfn);
 			if (!pfn_valid_within(pfn))
 				goto free_range;
 
@@ -1524,7 +1529,11 @@ static int __init deferred_init_memmap(void *data)
 				cond_resched();
 			}
 
-			if (page->flags) {
+			/*
+			 * Check if this page has already been initialized due
+			 * to being reserved during boot in memblock.
+			 */
+			if (pfn >= resv_start_pfn) {
 				VM_BUG_ON(page_zone(page) != zone);
 				goto free_range;
 			}
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 05/15] mm: don't accessed uninitialized struct pages

[Pavel Tatashin]

In deferred_init_memmap() where all deferred struct pages are initialized
we have a check like this:

    if (page->flags) {
            VM_BUG_ON(page_zone(page) != zone);
            goto free_range;
    }

This way we are checking if the current deferred page has already been
initialized. It works, because memory for struct pages has been zeroed, and
the only way flags are not zero if it went through __init_single_page()
before.  But, once we change the current behavior and won't zero the memory
in memblock allocator, we cannot trust anything inside "struct page"es
until they are initialized. This patch fixes this.

This patch defines a new accessor memblock_get_reserved_pfn_range()
which returns successive ranges of reserved PFNs.  deferred_init_memmap()
calls it to determine if a PFN and its struct page has already been
initialized.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/memblock.h |  3 +++
 mm/memblock.c            | 54 ++++++++++++++++++++++++++++++++++++++++++------
 mm/page_alloc.c          | 11 +++++++++-
 3 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index c89d16c88512..9d8dabedf5ba 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -321,6 +321,9 @@ int memblock_is_map_memory(phys_addr_t addr);
 int memblock_is_region_memory(phys_addr_t base, phys_addr_t size);
 bool memblock_is_reserved(phys_addr_t addr);
 bool memblock_is_region_reserved(phys_addr_t base, phys_addr_t size);
+void memblock_get_reserved_pfn_range(unsigned long pfn,
+				     unsigned long *pfn_start,
+				     unsigned long *pfn_end);
 
 extern void __memblock_dump_all(void);
 
diff --git a/mm/memblock.c b/mm/memblock.c
index 3a2707914064..e6df054e3180 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1580,7 +1580,13 @@ void __init memblock_mem_limit_remove_map(phys_addr_t limit)
 	memblock_cap_memory_range(0, max_addr);
 }
 
-static int __init_memblock memblock_search(struct memblock_type *type, phys_addr_t addr)
+/**
+ * Return index in regions array if addr is within the region. Otherwise
+ * return -1. If -1 is returned and *next_idx is not %NULL, sets it to the
+ * next region index or -1 if there is none.
+ */
+static int __init_memblock memblock_search(struct memblock_type *type,
+					   phys_addr_t addr, int *next_idx)
 {
 	unsigned int left = 0, right = type->cnt;
 
@@ -1595,22 +1601,26 @@ static int __init_memblock memblock_search(struct memblock_type *type, phys_addr
 		else
 			return mid;
 	} while (left < right);
+
+	if (next_idx)
+		*next_idx = (right = type->cnt) ? -1 : right;
+
 	return -1;
 }
 
 bool __init memblock_is_reserved(phys_addr_t addr)
 {
-	return memblock_search(&memblock.reserved, addr) != -1;
+	return memblock_search(&memblock.reserved, addr, NULL) != -1;
 }
 
 bool __init_memblock memblock_is_memory(phys_addr_t addr)
 {
-	return memblock_search(&memblock.memory, addr) != -1;
+	return memblock_search(&memblock.memory, addr, NULL) != -1;
 }
 
 int __init_memblock memblock_is_map_memory(phys_addr_t addr)
 {
-	int i = memblock_search(&memblock.memory, addr);
+	int i = memblock_search(&memblock.memory, addr, NULL);
 
 	if (i = -1)
 		return false;
@@ -1622,7 +1632,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
 			 unsigned long *start_pfn, unsigned long *end_pfn)
 {
 	struct memblock_type *type = &memblock.memory;
-	int mid = memblock_search(type, PFN_PHYS(pfn));
+	int mid = memblock_search(type, PFN_PHYS(pfn), NULL);
 
 	if (mid = -1)
 		return -1;
@@ -1646,7 +1656,7 @@ int __init_memblock memblock_search_pfn_nid(unsigned long pfn,
  */
 int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size)
 {
-	int idx = memblock_search(&memblock.memory, base);
+	int idx = memblock_search(&memblock.memory, base, NULL);
 	phys_addr_t end = base + memblock_cap_size(base, &size);
 
 	if (idx = -1)
@@ -1656,6 +1666,38 @@ int __init_memblock memblock_is_region_memory(phys_addr_t base, phys_addr_t size
 }
 
 /**
+ * memblock_get_reserved_pfn_range - search for the next reserved region
+ *
+ * @pfn: start searching from this pfn.
+ *
+ * RETURNS:
+ * [start_pfn, end_pfn), where start_pfn >= pfn. If none is found
+ * start_pfn, and end_pfn are both set to ULONG_MAX.
+ */
+void __init_memblock memblock_get_reserved_pfn_range(unsigned long pfn,
+						     unsigned long *start_pfn,
+						     unsigned long *end_pfn)
+{
+	struct memblock_type *type = &memblock.reserved;
+	int next_idx, idx;
+
+	idx = memblock_search(type, PFN_PHYS(pfn), &next_idx);
+	if (idx = -1 && next_idx = -1) {
+		*start_pfn = ULONG_MAX;
+		*end_pfn = ULONG_MAX;
+		return;
+	}
+
+	if (idx = -1) {
+		idx = next_idx;
+		*start_pfn = PFN_DOWN(type->regions[idx].base);
+	} else {
+		*start_pfn = pfn;
+	}
+	*end_pfn = PFN_DOWN(type->regions[idx].base + type->regions[idx].size);
+}
+
+/**
  * memblock_is_region_reserved - check if a region intersects reserved memory
  * @base: base of region to check
  * @size: size of region to check
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 87fb35ac0b87..99b9e2e06319 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1447,6 +1447,7 @@ static int __init deferred_init_memmap(void *data)
 	pg_data_t *pgdat = data;
 	int nid = pgdat->node_id;
 	struct mminit_pfnnid_cache nid_init_state = { };
+	unsigned long resv_start_pfn = 0, resv_end_pfn = 0;
 	unsigned long start = jiffies;
 	unsigned long nr_pages = 0;
 	unsigned long walk_start, walk_end;
@@ -1491,6 +1492,10 @@ static int __init deferred_init_memmap(void *data)
 			pfn = zone->zone_start_pfn;
 
 		for (; pfn < end_pfn; pfn++) {
+			if (pfn >= resv_end_pfn)
+				memblock_get_reserved_pfn_range(pfn,
+								&resv_start_pfn,
+								&resv_end_pfn);
 			if (!pfn_valid_within(pfn))
 				goto free_range;
 
@@ -1524,7 +1529,11 @@ static int __init deferred_init_memmap(void *data)
 				cond_resched();
 			}
 
-			if (page->flags) {
+			/*
+			 * Check if this page has already been initialized due
+			 * to being reserved during boot in memblock.
+			 */
+			if (pfn >= resv_start_pfn) {
 				VM_BUG_ON(page_zone(page) != zone);
 				goto free_range;
 			}
-- 
2.13.3

[v4 06/15] sparc64: simplify vmemmap_populate

[Pavel Tatashin]

Remove duplicating code by using common functions
vmemmap_pud_populate and vmemmap_pgd_populate.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index ba957b763c07..e18947e9ab6c 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2567,30 +2567,19 @@ int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
 	vstart = vstart & PMD_MASK;
 	vend = ALIGN(vend, PMD_SIZE);
 	for (; vstart < vend; vstart += PMD_SIZE) {
-		pgd_t *pgd = pgd_offset_k(vstart);
+		pgd_t *pgd = vmemmap_pgd_populate(vstart, node);
 		unsigned long pte;
 		pud_t *pud;
 		pmd_t *pmd;
 
-		if (pgd_none(*pgd)) {
-			pud_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
+		if (!pgd)
+			return -ENOMEM;
 
-			if (!new)
-				return -ENOMEM;
-			pgd_populate(&init_mm, pgd, new);
-		}
-
-		pud = pud_offset(pgd, vstart);
-		if (pud_none(*pud)) {
-			pmd_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
-
-			if (!new)
-				return -ENOMEM;
-			pud_populate(&init_mm, pud, new);
-		}
+		pud = vmemmap_pud_populate(pgd, vstart, node);
+		if (!pud)
+			return -ENOMEM;
 
 		pmd = pmd_offset(pud, vstart);
-
 		pte = pmd_val(*pmd);
 		if (!(pte & _PAGE_VALID)) {
 			void *block = vmemmap_alloc_block(PMD_SIZE, node);
-- 
2.13.3

[v4 06/15] sparc64: simplify vmemmap_populate

[Pavel Tatashin]

Remove duplicating code by using common functions
vmemmap_pud_populate and vmemmap_pgd_populate.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index ba957b763c07..e18947e9ab6c 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2567,30 +2567,19 @@ int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
 	vstart = vstart & PMD_MASK;
 	vend = ALIGN(vend, PMD_SIZE);
 	for (; vstart < vend; vstart += PMD_SIZE) {
-		pgd_t *pgd = pgd_offset_k(vstart);
+		pgd_t *pgd = vmemmap_pgd_populate(vstart, node);
 		unsigned long pte;
 		pud_t *pud;
 		pmd_t *pmd;
 
-		if (pgd_none(*pgd)) {
-			pud_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
+		if (!pgd)
+			return -ENOMEM;
 
-			if (!new)
-				return -ENOMEM;
-			pgd_populate(&init_mm, pgd, new);
-		}
-
-		pud = pud_offset(pgd, vstart);
-		if (pud_none(*pud)) {
-			pmd_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
-
-			if (!new)
-				return -ENOMEM;
-			pud_populate(&init_mm, pud, new);
-		}
+		pud = vmemmap_pud_populate(pgd, vstart, node);
+		if (!pud)
+			return -ENOMEM;
 
 		pmd = pmd_offset(pud, vstart);
-
 		pte = pmd_val(*pmd);
 		if (!(pte & _PAGE_VALID)) {
 			void *block = vmemmap_alloc_block(PMD_SIZE, node);
-- 
2.13.3

[v4 06/15] sparc64: simplify vmemmap_populate

[Pavel Tatashin]

Remove duplicating code by using common functions
vmemmap_pud_populate and vmemmap_pgd_populate.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index ba957b763c07..e18947e9ab6c 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2567,30 +2567,19 @@ int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
 	vstart = vstart & PMD_MASK;
 	vend = ALIGN(vend, PMD_SIZE);
 	for (; vstart < vend; vstart += PMD_SIZE) {
-		pgd_t *pgd = pgd_offset_k(vstart);
+		pgd_t *pgd = vmemmap_pgd_populate(vstart, node);
 		unsigned long pte;
 		pud_t *pud;
 		pmd_t *pmd;
 
-		if (pgd_none(*pgd)) {
-			pud_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
+		if (!pgd)
+			return -ENOMEM;
 
-			if (!new)
-				return -ENOMEM;
-			pgd_populate(&init_mm, pgd, new);
-		}
-
-		pud = pud_offset(pgd, vstart);
-		if (pud_none(*pud)) {
-			pmd_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
-
-			if (!new)
-				return -ENOMEM;
-			pud_populate(&init_mm, pud, new);
-		}
+		pud = vmemmap_pud_populate(pgd, vstart, node);
+		if (!pud)
+			return -ENOMEM;
 
 		pmd = pmd_offset(pud, vstart);
-
 		pte = pmd_val(*pmd);
 		if (!(pte & _PAGE_VALID)) {
 			void *block = vmemmap_alloc_block(PMD_SIZE, node);
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 06/15] sparc64: simplify vmemmap_populate

[Pavel Tatashin]

Remove duplicating code by using common functions
vmemmap_pud_populate and vmemmap_pgd_populate.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/mm/init_64.c | 23 ++++++-----------------
 1 file changed, 6 insertions(+), 17 deletions(-)

diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index ba957b763c07..e18947e9ab6c 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -2567,30 +2567,19 @@ int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
 	vstart = vstart & PMD_MASK;
 	vend = ALIGN(vend, PMD_SIZE);
 	for (; vstart < vend; vstart += PMD_SIZE) {
-		pgd_t *pgd = pgd_offset_k(vstart);
+		pgd_t *pgd = vmemmap_pgd_populate(vstart, node);
 		unsigned long pte;
 		pud_t *pud;
 		pmd_t *pmd;
 
-		if (pgd_none(*pgd)) {
-			pud_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
+		if (!pgd)
+			return -ENOMEM;
 
-			if (!new)
-				return -ENOMEM;
-			pgd_populate(&init_mm, pgd, new);
-		}
-
-		pud = pud_offset(pgd, vstart);
-		if (pud_none(*pud)) {
-			pmd_t *new = vmemmap_alloc_block(PAGE_SIZE, node);
-
-			if (!new)
-				return -ENOMEM;
-			pud_populate(&init_mm, pud, new);
-		}
+		pud = vmemmap_pud_populate(pgd, vstart, node);
+		if (!pud)
+			return -ENOMEM;
 
 		pmd = pmd_offset(pud, vstart);
-
 		pte = pmd_val(*pmd);
 		if (!(pte & _PAGE_VALID)) {
 			void *block = vmemmap_alloc_block(PMD_SIZE, node);
-- 
2.13.3

[v4 07/15] mm: defining memblock_virt_alloc_try_nid_raw

[Pavel Tatashin]

A new variant of memblock_virt_alloc_* allocations:
memblock_virt_alloc_try_nid_raw()
    - Does not zero the allocated memory
    - Does not panic if request cannot be satisfied

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/bootmem.h | 11 ++++++++++
 mm/memblock.c           | 53 ++++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index e223d91b6439..0a0a37f3e292 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -160,6 +160,9 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
 #define BOOTMEM_ALLOC_ANYWHERE		(~(phys_addr_t)0)
 
 /* FIXME: Move to memblock.h at a point where we remove nobootmem.c */
+void *memblock_virt_alloc_try_nid_raw(phys_addr_t size, phys_addr_t align,
+				      phys_addr_t min_addr,
+				      phys_addr_t max_addr, int nid);
 void *memblock_virt_alloc_try_nid_nopanic(phys_addr_t size,
 		phys_addr_t align, phys_addr_t min_addr,
 		phys_addr_t max_addr, int nid);
@@ -176,6 +179,14 @@ static inline void * __init memblock_virt_alloc(
 					    NUMA_NO_NODE);
 }
 
+static inline void * __init memblock_virt_alloc_raw(
+					phys_addr_t size,  phys_addr_t align)
+{
+	return memblock_virt_alloc_try_nid_raw(size, align, BOOTMEM_LOW_LIMIT,
+					    BOOTMEM_ALLOC_ACCESSIBLE,
+					    NUMA_NO_NODE);
+}
+
 static inline void * __init memblock_virt_alloc_nopanic(
 					phys_addr_t size, phys_addr_t align)
 {
diff --git a/mm/memblock.c b/mm/memblock.c
index e6df054e3180..bdf31f207fa4 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1327,7 +1327,6 @@ static void * __init memblock_virt_alloc_internal(
 	return NULL;
 done:
 	ptr = phys_to_virt(alloc);
-	memset(ptr, 0, size);
 
 	/*
 	 * The min_count is set to 0 so that bootmem allocated blocks
@@ -1341,6 +1340,38 @@ static void * __init memblock_virt_alloc_internal(
 }
 
 /**
+ * memblock_virt_alloc_try_nid_raw - allocate boot memory block without zeroing
+ * memory and without panicking
+ * @size: size of memory block to be allocated in bytes
+ * @align: alignment of the region and block's size
+ * @min_addr: the lower bound of the memory region from where the allocation
+ *	  is preferred (phys address)
+ * @max_addr: the upper bound of the memory region from where the allocation
+ *	      is preferred (phys address), or %BOOTMEM_ALLOC_ACCESSIBLE to
+ *	      allocate only from memory limited by memblock.current_limit value
+ * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
+ *
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. Does not zero allocated memory, does not panic if request
+ * cannot be satisfied.
+ *
+ * RETURNS:
+ * Virtual address of allocated memory block on success, NULL on failure.
+ */
+void * __init memblock_virt_alloc_try_nid_raw(
+			phys_addr_t size, phys_addr_t align,
+			phys_addr_t min_addr, phys_addr_t max_addr,
+			int nid)
+{
+	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
+		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
+		     (u64)max_addr, (void *)_RET_IP_);
+
+	return memblock_virt_alloc_internal(size, align,
+					    min_addr, max_addr, nid);
+}
+
+/**
  * memblock_virt_alloc_try_nid_nopanic - allocate boot memory block
  * @size: size of memory block to be allocated in bytes
  * @align: alignment of the region and block's size
@@ -1351,8 +1382,8 @@ static void * __init memblock_virt_alloc_internal(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public version of _memblock_virt_alloc_try_nid_nopanic() which provides
- * additional debug information (including caller info), if enabled.
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. This function zeroes the allocated memory.
  *
  * RETURNS:
  * Virtual address of allocated memory block on success, NULL on failure.
@@ -1362,11 +1393,17 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
 				phys_addr_t min_addr, phys_addr_t max_addr,
 				int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
-	return memblock_virt_alloc_internal(size, align, min_addr,
-					     max_addr, nid);
+
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+	if (ptr)
+		memset(ptr, 0, size);
+	return ptr;
 }
 
 /**
@@ -1380,7 +1417,7 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public panicking version of _memblock_virt_alloc_try_nid_nopanic()
+ * Public panicking version of memblock_virt_alloc_try_nid_nopanic()
  * which provides debug information (including caller info), if enabled,
  * and panics if the request can not be satisfied.
  *
@@ -1399,8 +1436,10 @@ void * __init memblock_virt_alloc_try_nid(
 		     (u64)max_addr, (void *)_RET_IP_);
 	ptr = memblock_virt_alloc_internal(size, align,
 					   min_addr, max_addr, nid);
-	if (ptr)
+	if (ptr) {
+		memset(ptr, 0, size);
 		return ptr;
+	}
 
 	panic("%s: Failed to allocate %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx\n",
 	      __func__, (u64)size, (u64)align, nid, (u64)min_addr,
-- 
2.13.3

[v4 07/15] mm: defining memblock_virt_alloc_try_nid_raw

[Pavel Tatashin]

A new variant of memblock_virt_alloc_* allocations:
memblock_virt_alloc_try_nid_raw()
    - Does not zero the allocated memory
    - Does not panic if request cannot be satisfied

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/bootmem.h | 11 ++++++++++
 mm/memblock.c           | 53 ++++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index e223d91b6439..0a0a37f3e292 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -160,6 +160,9 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
 #define BOOTMEM_ALLOC_ANYWHERE		(~(phys_addr_t)0)
 
 /* FIXME: Move to memblock.h at a point where we remove nobootmem.c */
+void *memblock_virt_alloc_try_nid_raw(phys_addr_t size, phys_addr_t align,
+				      phys_addr_t min_addr,
+				      phys_addr_t max_addr, int nid);
 void *memblock_virt_alloc_try_nid_nopanic(phys_addr_t size,
 		phys_addr_t align, phys_addr_t min_addr,
 		phys_addr_t max_addr, int nid);
@@ -176,6 +179,14 @@ static inline void * __init memblock_virt_alloc(
 					    NUMA_NO_NODE);
 }
 
+static inline void * __init memblock_virt_alloc_raw(
+					phys_addr_t size,  phys_addr_t align)
+{
+	return memblock_virt_alloc_try_nid_raw(size, align, BOOTMEM_LOW_LIMIT,
+					    BOOTMEM_ALLOC_ACCESSIBLE,
+					    NUMA_NO_NODE);
+}
+
 static inline void * __init memblock_virt_alloc_nopanic(
 					phys_addr_t size, phys_addr_t align)
 {
diff --git a/mm/memblock.c b/mm/memblock.c
index e6df054e3180..bdf31f207fa4 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1327,7 +1327,6 @@ static void * __init memblock_virt_alloc_internal(
 	return NULL;
 done:
 	ptr = phys_to_virt(alloc);
-	memset(ptr, 0, size);
 
 	/*
 	 * The min_count is set to 0 so that bootmem allocated blocks
@@ -1341,6 +1340,38 @@ static void * __init memblock_virt_alloc_internal(
 }
 
 /**
+ * memblock_virt_alloc_try_nid_raw - allocate boot memory block without zeroing
+ * memory and without panicking
+ * @size: size of memory block to be allocated in bytes
+ * @align: alignment of the region and block's size
+ * @min_addr: the lower bound of the memory region from where the allocation
+ *	  is preferred (phys address)
+ * @max_addr: the upper bound of the memory region from where the allocation
+ *	      is preferred (phys address), or %BOOTMEM_ALLOC_ACCESSIBLE to
+ *	      allocate only from memory limited by memblock.current_limit value
+ * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
+ *
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. Does not zero allocated memory, does not panic if request
+ * cannot be satisfied.
+ *
+ * RETURNS:
+ * Virtual address of allocated memory block on success, NULL on failure.
+ */
+void * __init memblock_virt_alloc_try_nid_raw(
+			phys_addr_t size, phys_addr_t align,
+			phys_addr_t min_addr, phys_addr_t max_addr,
+			int nid)
+{
+	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
+		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
+		     (u64)max_addr, (void *)_RET_IP_);
+
+	return memblock_virt_alloc_internal(size, align,
+					    min_addr, max_addr, nid);
+}
+
+/**
  * memblock_virt_alloc_try_nid_nopanic - allocate boot memory block
  * @size: size of memory block to be allocated in bytes
  * @align: alignment of the region and block's size
@@ -1351,8 +1382,8 @@ static void * __init memblock_virt_alloc_internal(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public version of _memblock_virt_alloc_try_nid_nopanic() which provides
- * additional debug information (including caller info), if enabled.
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. This function zeroes the allocated memory.
  *
  * RETURNS:
  * Virtual address of allocated memory block on success, NULL on failure.
@@ -1362,11 +1393,17 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
 				phys_addr_t min_addr, phys_addr_t max_addr,
 				int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
-	return memblock_virt_alloc_internal(size, align, min_addr,
-					     max_addr, nid);
+
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+	if (ptr)
+		memset(ptr, 0, size);
+	return ptr;
 }
 
 /**
@@ -1380,7 +1417,7 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public panicking version of _memblock_virt_alloc_try_nid_nopanic()
+ * Public panicking version of memblock_virt_alloc_try_nid_nopanic()
  * which provides debug information (including caller info), if enabled,
  * and panics if the request can not be satisfied.
  *
@@ -1399,8 +1436,10 @@ void * __init memblock_virt_alloc_try_nid(
 		     (u64)max_addr, (void *)_RET_IP_);
 	ptr = memblock_virt_alloc_internal(size, align,
 					   min_addr, max_addr, nid);
-	if (ptr)
+	if (ptr) {
+		memset(ptr, 0, size);
 		return ptr;
+	}
 
 	panic("%s: Failed to allocate %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx\n",
 	      __func__, (u64)size, (u64)align, nid, (u64)min_addr,
-- 
2.13.3

[v4 07/15] mm: defining memblock_virt_alloc_try_nid_raw

[Pavel Tatashin]

A new variant of memblock_virt_alloc_* allocations:
memblock_virt_alloc_try_nid_raw()
    - Does not zero the allocated memory
    - Does not panic if request cannot be satisfied

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/bootmem.h | 11 ++++++++++
 mm/memblock.c           | 53 ++++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index e223d91b6439..0a0a37f3e292 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -160,6 +160,9 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
 #define BOOTMEM_ALLOC_ANYWHERE		(~(phys_addr_t)0)
 
 /* FIXME: Move to memblock.h at a point where we remove nobootmem.c */
+void *memblock_virt_alloc_try_nid_raw(phys_addr_t size, phys_addr_t align,
+				      phys_addr_t min_addr,
+				      phys_addr_t max_addr, int nid);
 void *memblock_virt_alloc_try_nid_nopanic(phys_addr_t size,
 		phys_addr_t align, phys_addr_t min_addr,
 		phys_addr_t max_addr, int nid);
@@ -176,6 +179,14 @@ static inline void * __init memblock_virt_alloc(
 					    NUMA_NO_NODE);
 }
 
+static inline void * __init memblock_virt_alloc_raw(
+					phys_addr_t size,  phys_addr_t align)
+{
+	return memblock_virt_alloc_try_nid_raw(size, align, BOOTMEM_LOW_LIMIT,
+					    BOOTMEM_ALLOC_ACCESSIBLE,
+					    NUMA_NO_NODE);
+}
+
 static inline void * __init memblock_virt_alloc_nopanic(
 					phys_addr_t size, phys_addr_t align)
 {
diff --git a/mm/memblock.c b/mm/memblock.c
index e6df054e3180..bdf31f207fa4 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1327,7 +1327,6 @@ static void * __init memblock_virt_alloc_internal(
 	return NULL;
 done:
 	ptr = phys_to_virt(alloc);
-	memset(ptr, 0, size);
 
 	/*
 	 * The min_count is set to 0 so that bootmem allocated blocks
@@ -1341,6 +1340,38 @@ static void * __init memblock_virt_alloc_internal(
 }
 
 /**
+ * memblock_virt_alloc_try_nid_raw - allocate boot memory block without zeroing
+ * memory and without panicking
+ * @size: size of memory block to be allocated in bytes
+ * @align: alignment of the region and block's size
+ * @min_addr: the lower bound of the memory region from where the allocation
+ *	  is preferred (phys address)
+ * @max_addr: the upper bound of the memory region from where the allocation
+ *	      is preferred (phys address), or %BOOTMEM_ALLOC_ACCESSIBLE to
+ *	      allocate only from memory limited by memblock.current_limit value
+ * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
+ *
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. Does not zero allocated memory, does not panic if request
+ * cannot be satisfied.
+ *
+ * RETURNS:
+ * Virtual address of allocated memory block on success, NULL on failure.
+ */
+void * __init memblock_virt_alloc_try_nid_raw(
+			phys_addr_t size, phys_addr_t align,
+			phys_addr_t min_addr, phys_addr_t max_addr,
+			int nid)
+{
+	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
+		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
+		     (u64)max_addr, (void *)_RET_IP_);
+
+	return memblock_virt_alloc_internal(size, align,
+					    min_addr, max_addr, nid);
+}
+
+/**
  * memblock_virt_alloc_try_nid_nopanic - allocate boot memory block
  * @size: size of memory block to be allocated in bytes
  * @align: alignment of the region and block's size
@@ -1351,8 +1382,8 @@ static void * __init memblock_virt_alloc_internal(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public version of _memblock_virt_alloc_try_nid_nopanic() which provides
- * additional debug information (including caller info), if enabled.
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. This function zeroes the allocated memory.
  *
  * RETURNS:
  * Virtual address of allocated memory block on success, NULL on failure.
@@ -1362,11 +1393,17 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
 				phys_addr_t min_addr, phys_addr_t max_addr,
 				int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
-	return memblock_virt_alloc_internal(size, align, min_addr,
-					     max_addr, nid);
+
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+	if (ptr)
+		memset(ptr, 0, size);
+	return ptr;
 }
 
 /**
@@ -1380,7 +1417,7 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public panicking version of _memblock_virt_alloc_try_nid_nopanic()
+ * Public panicking version of memblock_virt_alloc_try_nid_nopanic()
  * which provides debug information (including caller info), if enabled,
  * and panics if the request can not be satisfied.
  *
@@ -1399,8 +1436,10 @@ void * __init memblock_virt_alloc_try_nid(
 		     (u64)max_addr, (void *)_RET_IP_);
 	ptr = memblock_virt_alloc_internal(size, align,
 					   min_addr, max_addr, nid);
-	if (ptr)
+	if (ptr) {
+		memset(ptr, 0, size);
 		return ptr;
+	}
 
 	panic("%s: Failed to allocate %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx\n",
 	      __func__, (u64)size, (u64)align, nid, (u64)min_addr,
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 07/15] mm: defining memblock_virt_alloc_try_nid_raw

[Pavel Tatashin]

A new variant of memblock_virt_alloc_* allocations:
memblock_virt_alloc_try_nid_raw()
    - Does not zero the allocated memory
    - Does not panic if request cannot be satisfied

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/bootmem.h | 11 ++++++++++
 mm/memblock.c           | 53 ++++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 57 insertions(+), 7 deletions(-)

diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index e223d91b6439..0a0a37f3e292 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -160,6 +160,9 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
 #define BOOTMEM_ALLOC_ANYWHERE		(~(phys_addr_t)0)
 
 /* FIXME: Move to memblock.h at a point where we remove nobootmem.c */
+void *memblock_virt_alloc_try_nid_raw(phys_addr_t size, phys_addr_t align,
+				      phys_addr_t min_addr,
+				      phys_addr_t max_addr, int nid);
 void *memblock_virt_alloc_try_nid_nopanic(phys_addr_t size,
 		phys_addr_t align, phys_addr_t min_addr,
 		phys_addr_t max_addr, int nid);
@@ -176,6 +179,14 @@ static inline void * __init memblock_virt_alloc(
 					    NUMA_NO_NODE);
 }
 
+static inline void * __init memblock_virt_alloc_raw(
+					phys_addr_t size,  phys_addr_t align)
+{
+	return memblock_virt_alloc_try_nid_raw(size, align, BOOTMEM_LOW_LIMIT,
+					    BOOTMEM_ALLOC_ACCESSIBLE,
+					    NUMA_NO_NODE);
+}
+
 static inline void * __init memblock_virt_alloc_nopanic(
 					phys_addr_t size, phys_addr_t align)
 {
diff --git a/mm/memblock.c b/mm/memblock.c
index e6df054e3180..bdf31f207fa4 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1327,7 +1327,6 @@ static void * __init memblock_virt_alloc_internal(
 	return NULL;
 done:
 	ptr = phys_to_virt(alloc);
-	memset(ptr, 0, size);
 
 	/*
 	 * The min_count is set to 0 so that bootmem allocated blocks
@@ -1341,6 +1340,38 @@ static void * __init memblock_virt_alloc_internal(
 }
 
 /**
+ * memblock_virt_alloc_try_nid_raw - allocate boot memory block without zeroing
+ * memory and without panicking
+ * @size: size of memory block to be allocated in bytes
+ * @align: alignment of the region and block's size
+ * @min_addr: the lower bound of the memory region from where the allocation
+ *	  is preferred (phys address)
+ * @max_addr: the upper bound of the memory region from where the allocation
+ *	      is preferred (phys address), or %BOOTMEM_ALLOC_ACCESSIBLE to
+ *	      allocate only from memory limited by memblock.current_limit value
+ * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
+ *
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. Does not zero allocated memory, does not panic if request
+ * cannot be satisfied.
+ *
+ * RETURNS:
+ * Virtual address of allocated memory block on success, NULL on failure.
+ */
+void * __init memblock_virt_alloc_try_nid_raw(
+			phys_addr_t size, phys_addr_t align,
+			phys_addr_t min_addr, phys_addr_t max_addr,
+			int nid)
+{
+	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
+		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
+		     (u64)max_addr, (void *)_RET_IP_);
+
+	return memblock_virt_alloc_internal(size, align,
+					    min_addr, max_addr, nid);
+}
+
+/**
  * memblock_virt_alloc_try_nid_nopanic - allocate boot memory block
  * @size: size of memory block to be allocated in bytes
  * @align: alignment of the region and block's size
@@ -1351,8 +1382,8 @@ static void * __init memblock_virt_alloc_internal(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public version of _memblock_virt_alloc_try_nid_nopanic() which provides
- * additional debug information (including caller info), if enabled.
+ * Public function, provides additional debug information (including caller
+ * info), if enabled. This function zeroes the allocated memory.
  *
  * RETURNS:
  * Virtual address of allocated memory block on success, NULL on failure.
@@ -1362,11 +1393,17 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
 				phys_addr_t min_addr, phys_addr_t max_addr,
 				int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
-	return memblock_virt_alloc_internal(size, align, min_addr,
-					     max_addr, nid);
+
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+	if (ptr)
+		memset(ptr, 0, size);
+	return ptr;
 }
 
 /**
@@ -1380,7 +1417,7 @@ void * __init memblock_virt_alloc_try_nid_nopanic(
  *	      allocate only from memory limited by memblock.current_limit value
  * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
- * Public panicking version of _memblock_virt_alloc_try_nid_nopanic()
+ * Public panicking version of memblock_virt_alloc_try_nid_nopanic()
  * which provides debug information (including caller info), if enabled,
  * and panics if the request can not be satisfied.
  *
@@ -1399,8 +1436,10 @@ void * __init memblock_virt_alloc_try_nid(
 		     (u64)max_addr, (void *)_RET_IP_);
 	ptr = memblock_virt_alloc_internal(size, align,
 					   min_addr, max_addr, nid);
-	if (ptr)
+	if (ptr) {
+		memset(ptr, 0, size);
 		return ptr;
+	}
 
 	panic("%s: Failed to allocate %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx\n",
 	      __func__, (u64)size, (u64)align, nid, (u64)min_addr,
-- 
2.13.3

[v4 08/15] mm: zero struct pages during initialization

[Pavel Tatashin]

Add struct page zeroing as a part of initialization of other fields in
__init_single_page().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/mm.h | 9 +++++++++
 mm/page_alloc.c    | 1 +
 2 files changed, 10 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 46b9ac5e8569..183ac5e733db 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -94,6 +94,15 @@ extern int mmap_rnd_compat_bits __read_mostly;
 #endif
 
 /*
+ * On some architectures it is expensive to call memset() for small sizes.
+ * Those architectures should provide their own implementation of "struct page"
+ * zeroing by defining this macro in <asm/pgtable.h>.
+ */
+#ifndef mm_zero_struct_page
+#define mm_zero_struct_page(pp)  ((void)memset((pp), 0, sizeof(struct page)))
+#endif
+
+/*
  * Default maximum number of active map areas, this limits the number of vmas
  * per mm struct. Users can overwrite this number by sysctl but there is a
  * problem.
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 99b9e2e06319..debea7c0febb 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1168,6 +1168,7 @@ static void free_one_page(struct zone *zone,
 static void __meminit __init_single_page(struct page *page, unsigned long pfn,
 				unsigned long zone, int nid)
 {
+	mm_zero_struct_page(page);
 	set_page_links(page, zone, nid, pfn);
 	init_page_count(page);
 	page_mapcount_reset(page);
-- 
2.13.3

[v4 08/15] mm: zero struct pages during initialization

[Pavel Tatashin]

Add struct page zeroing as a part of initialization of other fields in
__init_single_page().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/mm.h | 9 +++++++++
 mm/page_alloc.c    | 1 +
 2 files changed, 10 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 46b9ac5e8569..183ac5e733db 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -94,6 +94,15 @@ extern int mmap_rnd_compat_bits __read_mostly;
 #endif
 
 /*
+ * On some architectures it is expensive to call memset() for small sizes.
+ * Those architectures should provide their own implementation of "struct page"
+ * zeroing by defining this macro in <asm/pgtable.h>.
+ */
+#ifndef mm_zero_struct_page
+#define mm_zero_struct_page(pp)  ((void)memset((pp), 0, sizeof(struct page)))
+#endif
+
+/*
  * Default maximum number of active map areas, this limits the number of vmas
  * per mm struct. Users can overwrite this number by sysctl but there is a
  * problem.
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 99b9e2e06319..debea7c0febb 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1168,6 +1168,7 @@ static void free_one_page(struct zone *zone,
 static void __meminit __init_single_page(struct page *page, unsigned long pfn,
 				unsigned long zone, int nid)
 {
+	mm_zero_struct_page(page);
 	set_page_links(page, zone, nid, pfn);
 	init_page_count(page);
 	page_mapcount_reset(page);
-- 
2.13.3

[v4 08/15] mm: zero struct pages during initialization

[Pavel Tatashin]

Add struct page zeroing as a part of initialization of other fields in
__init_single_page().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/mm.h | 9 +++++++++
 mm/page_alloc.c    | 1 +
 2 files changed, 10 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 46b9ac5e8569..183ac5e733db 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -94,6 +94,15 @@ extern int mmap_rnd_compat_bits __read_mostly;
 #endif
 
 /*
+ * On some architectures it is expensive to call memset() for small sizes.
+ * Those architectures should provide their own implementation of "struct page"
+ * zeroing by defining this macro in <asm/pgtable.h>.
+ */
+#ifndef mm_zero_struct_page
+#define mm_zero_struct_page(pp)  ((void)memset((pp), 0, sizeof(struct page)))
+#endif
+
+/*
  * Default maximum number of active map areas, this limits the number of vmas
  * per mm struct. Users can overwrite this number by sysctl but there is a
  * problem.
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 99b9e2e06319..debea7c0febb 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1168,6 +1168,7 @@ static void free_one_page(struct zone *zone,
 static void __meminit __init_single_page(struct page *page, unsigned long pfn,
 				unsigned long zone, int nid)
 {
+	mm_zero_struct_page(page);
 	set_page_links(page, zone, nid, pfn);
 	init_page_count(page);
 	page_mapcount_reset(page);
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 08/15] mm: zero struct pages during initialization

[Pavel Tatashin]

Add struct page zeroing as a part of initialization of other fields in
__init_single_page().

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 include/linux/mm.h | 9 +++++++++
 mm/page_alloc.c    | 1 +
 2 files changed, 10 insertions(+)

diff --git a/include/linux/mm.h b/include/linux/mm.h
index 46b9ac5e8569..183ac5e733db 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -94,6 +94,15 @@ extern int mmap_rnd_compat_bits __read_mostly;
 #endif
 
 /*
+ * On some architectures it is expensive to call memset() for small sizes.
+ * Those architectures should provide their own implementation of "struct page"
+ * zeroing by defining this macro in <asm/pgtable.h>.
+ */
+#ifndef mm_zero_struct_page
+#define mm_zero_struct_page(pp)  ((void)memset((pp), 0, sizeof(struct page)))
+#endif
+
+/*
  * Default maximum number of active map areas, this limits the number of vmas
  * per mm struct. Users can overwrite this number by sysctl but there is a
  * problem.
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 99b9e2e06319..debea7c0febb 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1168,6 +1168,7 @@ static void free_one_page(struct zone *zone,
 static void __meminit __init_single_page(struct page *page, unsigned long pfn,
 				unsigned long zone, int nid)
 {
+	mm_zero_struct_page(page);
 	set_page_links(page, zone, nid, pfn);
 	init_page_count(page);
 	page_mapcount_reset(page);
-- 
2.13.3

[v4 09/15] sparc64: optimized struct page zeroing

[Pavel Tatashin]

Add an optimized mm_zero_struct_page(), so struct page's are zeroed without
calling memset(). We do eight regular stores, thus avoid cost of membar.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/include/asm/pgtable_64.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/arch/sparc/include/asm/pgtable_64.h b/arch/sparc/include/asm/pgtable_64.h
index 6fbd931f0570..23ad51ea5340 100644
--- a/arch/sparc/include/asm/pgtable_64.h
+++ b/arch/sparc/include/asm/pgtable_64.h
@@ -230,6 +230,24 @@ extern unsigned long _PAGE_ALL_SZ_BITS;
 extern struct page *mem_map_zero;
 #define ZERO_PAGE(vaddr)	(mem_map_zero)
 
+/* This macro must be updated when the size of struct page changes,
+ * so use static assert to enforce the assumed size.
+ */
+#define	mm_zero_struct_page(pp)					\
+	do {							\
+		unsigned long *_pp = (void *)(pp);		\
+								\
+		BUILD_BUG_ON(sizeof(struct page) != 64);	\
+		_pp[0] = 0;					\
+		_pp[1] = 0;					\
+		_pp[2] = 0;					\
+		_pp[3] = 0;					\
+		_pp[4] = 0;					\
+		_pp[5] = 0;					\
+		_pp[6] = 0;					\
+		_pp[7] = 0;					\
+	} while (0)
+
 /* PFNs are real physical page numbers.  However, mem_map only begins to record
  * per-page information starting at pfn_base.  This is to handle systems where
  * the first physical page in the machine is at some huge physical address,
-- 
2.13.3

[v4 09/15] sparc64: optimized struct page zeroing

[Pavel Tatashin]

Add an optimized mm_zero_struct_page(), so struct page's are zeroed without
calling memset(). We do eight regular stores, thus avoid cost of membar.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/include/asm/pgtable_64.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/arch/sparc/include/asm/pgtable_64.h b/arch/sparc/include/asm/pgtable_64.h
index 6fbd931f0570..23ad51ea5340 100644
--- a/arch/sparc/include/asm/pgtable_64.h
+++ b/arch/sparc/include/asm/pgtable_64.h
@@ -230,6 +230,24 @@ extern unsigned long _PAGE_ALL_SZ_BITS;
 extern struct page *mem_map_zero;
 #define ZERO_PAGE(vaddr)	(mem_map_zero)
 
+/* This macro must be updated when the size of struct page changes,
+ * so use static assert to enforce the assumed size.
+ */
+#define	mm_zero_struct_page(pp)					\
+	do {							\
+		unsigned long *_pp = (void *)(pp);		\
+								\
+		BUILD_BUG_ON(sizeof(struct page) != 64);	\
+		_pp[0] = 0;					\
+		_pp[1] = 0;					\
+		_pp[2] = 0;					\
+		_pp[3] = 0;					\
+		_pp[4] = 0;					\
+		_pp[5] = 0;					\
+		_pp[6] = 0;					\
+		_pp[7] = 0;					\
+	} while (0)
+
 /* PFNs are real physical page numbers.  However, mem_map only begins to record
  * per-page information starting at pfn_base.  This is to handle systems where
  * the first physical page in the machine is at some huge physical address,
-- 
2.13.3

[v4 09/15] sparc64: optimized struct page zeroing

[Pavel Tatashin]

Add an optimized mm_zero_struct_page(), so struct page's are zeroed without
calling memset(). We do eight regular stores, thus avoid cost of membar.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/include/asm/pgtable_64.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/arch/sparc/include/asm/pgtable_64.h b/arch/sparc/include/asm/pgtable_64.h
index 6fbd931f0570..23ad51ea5340 100644
--- a/arch/sparc/include/asm/pgtable_64.h
+++ b/arch/sparc/include/asm/pgtable_64.h
@@ -230,6 +230,24 @@ extern unsigned long _PAGE_ALL_SZ_BITS;
 extern struct page *mem_map_zero;
 #define ZERO_PAGE(vaddr)	(mem_map_zero)
 
+/* This macro must be updated when the size of struct page changes,
+ * so use static assert to enforce the assumed size.
+ */
+#define	mm_zero_struct_page(pp)					\
+	do {							\
+		unsigned long *_pp = (void *)(pp);		\
+								\
+		BUILD_BUG_ON(sizeof(struct page) != 64);	\
+		_pp[0] = 0;					\
+		_pp[1] = 0;					\
+		_pp[2] = 0;					\
+		_pp[3] = 0;					\
+		_pp[4] = 0;					\
+		_pp[5] = 0;					\
+		_pp[6] = 0;					\
+		_pp[7] = 0;					\
+	} while (0)
+
 /* PFNs are real physical page numbers.  However, mem_map only begins to record
  * per-page information starting at pfn_base.  This is to handle systems where
  * the first physical page in the machine is at some huge physical address,
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 09/15] sparc64: optimized struct page zeroing

[Pavel Tatashin]

Add an optimized mm_zero_struct_page(), so struct page's are zeroed without
calling memset(). We do eight regular stores, thus avoid cost of membar.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/sparc/include/asm/pgtable_64.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/arch/sparc/include/asm/pgtable_64.h b/arch/sparc/include/asm/pgtable_64.h
index 6fbd931f0570..23ad51ea5340 100644
--- a/arch/sparc/include/asm/pgtable_64.h
+++ b/arch/sparc/include/asm/pgtable_64.h
@@ -230,6 +230,24 @@ extern unsigned long _PAGE_ALL_SZ_BITS;
 extern struct page *mem_map_zero;
 #define ZERO_PAGE(vaddr)	(mem_map_zero)
 
+/* This macro must be updated when the size of struct page changes,
+ * so use static assert to enforce the assumed size.
+ */
+#define	mm_zero_struct_page(pp)					\
+	do {							\
+		unsigned long *_pp = (void *)(pp);		\
+								\
+		BUILD_BUG_ON(sizeof(struct page) != 64);	\
+		_pp[0] = 0;					\
+		_pp[1] = 0;					\
+		_pp[2] = 0;					\
+		_pp[3] = 0;					\
+		_pp[4] = 0;					\
+		_pp[5] = 0;					\
+		_pp[6] = 0;					\
+		_pp[7] = 0;					\
+	} while (0)
+
 /* PFNs are real physical page numbers.  However, mem_map only begins to record
  * per-page information starting at pfn_base.  This is to handle systems where
  * the first physical page in the machine is at some huge physical address,
-- 
2.13.3

Re: [v4 09/15] sparc64: optimized struct page zeroing

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 4664 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sparc64-allmodconfig (attached as .config)
compiler: sparc64-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sparc64 

All error/warnings (new ones prefixed by >>):

   In file included from include/uapi/linux/stddef.h:1:0,
                    from include/linux/stddef.h:4,
                    from mm/page_alloc.c:17:
   mm/page_alloc.c: In function '__init_single_page':
>> include/linux/compiler.h:542:38: error: call to '__compiletime_assert_1171' declared with attribute error: BUILD_BUG_ON failed: sizeof(struct page) != 64
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
                                         ^
   include/linux/compiler.h:525:4: note: in definition of macro '__compiletime_assert'
       prefix ## suffix();    \
       ^~~~~~
   include/linux/compiler.h:542:2: note: in expansion of macro '_compiletime_assert'
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
     ^~~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:46:37: note: in expansion of macro 'compiletime_assert'
    #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
                                        ^~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:70:2: note: in expansion of macro 'BUILD_BUG_ON_MSG'
     BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition)
     ^~~~~~~~~~~~~~~~
>> arch/sparc/include/asm/pgtable_64.h:240:3: note: in expansion of macro 'BUILD_BUG_ON'
      BUILD_BUG_ON(sizeof(struct page) != 64); \
      ^~~~~~~~~~~~
>> mm/page_alloc.c:1171:2: note: in expansion of macro 'mm_zero_struct_page'
     mm_zero_struct_page(page);
     ^~~~~~~~~~~~~~~~~~~

vim +/__compiletime_assert_1171 +542 include/linux/compiler.h

c361d3e5 Daniel Santos 2013-02-21  519  
9a8ab1c3 Daniel Santos 2013-02-21  520  #define __compiletime_assert(condition, msg, prefix, suffix)		\
9a8ab1c3 Daniel Santos 2013-02-21  521  	do {								\
9a8ab1c3 Daniel Santos 2013-02-21  522  		bool __cond = !(condition);				\
9a8ab1c3 Daniel Santos 2013-02-21  523  		extern void prefix ## suffix(void) __compiletime_error(msg); \
9a8ab1c3 Daniel Santos 2013-02-21  524  		if (__cond)						\
9a8ab1c3 Daniel Santos 2013-02-21  525  			prefix ## suffix();				\
9a8ab1c3 Daniel Santos 2013-02-21  526  		__compiletime_error_fallback(__cond);			\
9a8ab1c3 Daniel Santos 2013-02-21  527  	} while (0)
9a8ab1c3 Daniel Santos 2013-02-21  528  
9a8ab1c3 Daniel Santos 2013-02-21  529  #define _compiletime_assert(condition, msg, prefix, suffix) \
9a8ab1c3 Daniel Santos 2013-02-21  530  	__compiletime_assert(condition, msg, prefix, suffix)
9a8ab1c3 Daniel Santos 2013-02-21  531  
9a8ab1c3 Daniel Santos 2013-02-21  532  /**
9a8ab1c3 Daniel Santos 2013-02-21  533   * compiletime_assert - break build and emit msg if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  534   * @condition: a compile-time constant condition to check
9a8ab1c3 Daniel Santos 2013-02-21  535   * @msg:       a message to emit if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  536   *
9a8ab1c3 Daniel Santos 2013-02-21  537   * In tradition of POSIX assert, this macro will break the build if the
9a8ab1c3 Daniel Santos 2013-02-21  538   * supplied condition is *false*, emitting the supplied error message if the
9a8ab1c3 Daniel Santos 2013-02-21  539   * compiler has support to do so.
9a8ab1c3 Daniel Santos 2013-02-21  540   */
9a8ab1c3 Daniel Santos 2013-02-21  541  #define compiletime_assert(condition, msg) \
9a8ab1c3 Daniel Santos 2013-02-21 @542  	_compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
9a8ab1c3 Daniel Santos 2013-02-21  543  

:::::: The code at line 542 was first introduced by commit
:::::: 9a8ab1c39970a4938a72d94e6fd13be88a797590 bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG

:::::: TO: Daniel Santos <daniel.santos@pobox.com>
:::::: CC: Linus Torvalds <torvalds@linux-foundation.org>

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 51272 bytes --]

[v4 09/15] sparc64: optimized struct page zeroing

[kbuild test robot]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sparc64-allmodconfig (attached as .config)
compiler: sparc64-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sparc64 

All error/warnings (new ones prefixed by >>):

   In file included from include/uapi/linux/stddef.h:1:0,
                    from include/linux/stddef.h:4,
                    from mm/page_alloc.c:17:
   mm/page_alloc.c: In function '__init_single_page':
>> include/linux/compiler.h:542:38: error: call to '__compiletime_assert_1171' declared with attribute error: BUILD_BUG_ON failed: sizeof(struct page) != 64
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
                                         ^
   include/linux/compiler.h:525:4: note: in definition of macro '__compiletime_assert'
       prefix ## suffix();    \
       ^~~~~~
   include/linux/compiler.h:542:2: note: in expansion of macro '_compiletime_assert'
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
     ^~~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:46:37: note: in expansion of macro 'compiletime_assert'
    #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
                                        ^~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:70:2: note: in expansion of macro 'BUILD_BUG_ON_MSG'
     BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition)
     ^~~~~~~~~~~~~~~~
>> arch/sparc/include/asm/pgtable_64.h:240:3: note: in expansion of macro 'BUILD_BUG_ON'
      BUILD_BUG_ON(sizeof(struct page) != 64); \
      ^~~~~~~~~~~~
>> mm/page_alloc.c:1171:2: note: in expansion of macro 'mm_zero_struct_page'
     mm_zero_struct_page(page);
     ^~~~~~~~~~~~~~~~~~~

vim +/__compiletime_assert_1171 +542 include/linux/compiler.h

c361d3e5 Daniel Santos 2013-02-21  519  
9a8ab1c3 Daniel Santos 2013-02-21  520  #define __compiletime_assert(condition, msg, prefix, suffix)		\
9a8ab1c3 Daniel Santos 2013-02-21  521  	do {								\
9a8ab1c3 Daniel Santos 2013-02-21  522  		bool __cond = !(condition);				\
9a8ab1c3 Daniel Santos 2013-02-21  523  		extern void prefix ## suffix(void) __compiletime_error(msg); \
9a8ab1c3 Daniel Santos 2013-02-21  524  		if (__cond)						\
9a8ab1c3 Daniel Santos 2013-02-21  525  			prefix ## suffix();				\
9a8ab1c3 Daniel Santos 2013-02-21  526  		__compiletime_error_fallback(__cond);			\
9a8ab1c3 Daniel Santos 2013-02-21  527  	} while (0)
9a8ab1c3 Daniel Santos 2013-02-21  528  
9a8ab1c3 Daniel Santos 2013-02-21  529  #define _compiletime_assert(condition, msg, prefix, suffix) \
9a8ab1c3 Daniel Santos 2013-02-21  530  	__compiletime_assert(condition, msg, prefix, suffix)
9a8ab1c3 Daniel Santos 2013-02-21  531  
9a8ab1c3 Daniel Santos 2013-02-21  532  /**
9a8ab1c3 Daniel Santos 2013-02-21  533   * compiletime_assert - break build and emit msg if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  534   * @condition: a compile-time constant condition to check
9a8ab1c3 Daniel Santos 2013-02-21  535   * @msg:       a message to emit if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  536   *
9a8ab1c3 Daniel Santos 2013-02-21  537   * In tradition of POSIX assert, this macro will break the build if the
9a8ab1c3 Daniel Santos 2013-02-21  538   * supplied condition is *false*, emitting the supplied error message if the
9a8ab1c3 Daniel Santos 2013-02-21  539   * compiler has support to do so.
9a8ab1c3 Daniel Santos 2013-02-21  540   */
9a8ab1c3 Daniel Santos 2013-02-21  541  #define compiletime_assert(condition, msg) \
9a8ab1c3 Daniel Santos 2013-02-21 @542  	_compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
9a8ab1c3 Daniel Santos 2013-02-21  543  

:::::: The code at line 542 was first introduced by commit
:::::: 9a8ab1c39970a4938a72d94e6fd13be88a797590 bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG

:::::: TO: Daniel Santos <daniel.santos@pobox.com>
:::::: CC: Linus Torvalds <torvalds@linux-foundation.org>

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
-------------- next part --------------
A non-text attachment was scrubbed...
Name: .config.gz
Type: application/gzip
Size: 51272 bytes
Desc: not available
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20170803/ad2e99cb/attachment-0001.gz>

Re: [v4 09/15] sparc64: optimized struct page zeroing

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 4664 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sparc64-allmodconfig (attached as .config)
compiler: sparc64-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sparc64 

All error/warnings (new ones prefixed by >>):

   In file included from include/uapi/linux/stddef.h:1:0,
                    from include/linux/stddef.h:4,
                    from mm/page_alloc.c:17:
   mm/page_alloc.c: In function '__init_single_page':
>> include/linux/compiler.h:542:38: error: call to '__compiletime_assert_1171' declared with attribute error: BUILD_BUG_ON failed: sizeof(struct page) != 64
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
                                         ^
   include/linux/compiler.h:525:4: note: in definition of macro '__compiletime_assert'
       prefix ## suffix();    \
       ^~~~~~
   include/linux/compiler.h:542:2: note: in expansion of macro '_compiletime_assert'
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
     ^~~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:46:37: note: in expansion of macro 'compiletime_assert'
    #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
                                        ^~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:70:2: note: in expansion of macro 'BUILD_BUG_ON_MSG'
     BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition)
     ^~~~~~~~~~~~~~~~
>> arch/sparc/include/asm/pgtable_64.h:240:3: note: in expansion of macro 'BUILD_BUG_ON'
      BUILD_BUG_ON(sizeof(struct page) != 64); \
      ^~~~~~~~~~~~
>> mm/page_alloc.c:1171:2: note: in expansion of macro 'mm_zero_struct_page'
     mm_zero_struct_page(page);
     ^~~~~~~~~~~~~~~~~~~

vim +/__compiletime_assert_1171 +542 include/linux/compiler.h

c361d3e5 Daniel Santos 2013-02-21  519  
9a8ab1c3 Daniel Santos 2013-02-21  520  #define __compiletime_assert(condition, msg, prefix, suffix)		\
9a8ab1c3 Daniel Santos 2013-02-21  521  	do {								\
9a8ab1c3 Daniel Santos 2013-02-21  522  		bool __cond = !(condition);				\
9a8ab1c3 Daniel Santos 2013-02-21  523  		extern void prefix ## suffix(void) __compiletime_error(msg); \
9a8ab1c3 Daniel Santos 2013-02-21  524  		if (__cond)						\
9a8ab1c3 Daniel Santos 2013-02-21  525  			prefix ## suffix();				\
9a8ab1c3 Daniel Santos 2013-02-21  526  		__compiletime_error_fallback(__cond);			\
9a8ab1c3 Daniel Santos 2013-02-21  527  	} while (0)
9a8ab1c3 Daniel Santos 2013-02-21  528  
9a8ab1c3 Daniel Santos 2013-02-21  529  #define _compiletime_assert(condition, msg, prefix, suffix) \
9a8ab1c3 Daniel Santos 2013-02-21  530  	__compiletime_assert(condition, msg, prefix, suffix)
9a8ab1c3 Daniel Santos 2013-02-21  531  
9a8ab1c3 Daniel Santos 2013-02-21  532  /**
9a8ab1c3 Daniel Santos 2013-02-21  533   * compiletime_assert - break build and emit msg if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  534   * @condition: a compile-time constant condition to check
9a8ab1c3 Daniel Santos 2013-02-21  535   * @msg:       a message to emit if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  536   *
9a8ab1c3 Daniel Santos 2013-02-21  537   * In tradition of POSIX assert, this macro will break the build if the
9a8ab1c3 Daniel Santos 2013-02-21  538   * supplied condition is *false*, emitting the supplied error message if the
9a8ab1c3 Daniel Santos 2013-02-21  539   * compiler has support to do so.
9a8ab1c3 Daniel Santos 2013-02-21  540   */
9a8ab1c3 Daniel Santos 2013-02-21  541  #define compiletime_assert(condition, msg) \
9a8ab1c3 Daniel Santos 2013-02-21 @542  	_compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
9a8ab1c3 Daniel Santos 2013-02-21  543  

:::::: The code at line 542 was first introduced by commit
:::::: 9a8ab1c39970a4938a72d94e6fd13be88a797590 bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG

:::::: TO: Daniel Santos <daniel.santos@pobox.com>
:::::: CC: Linus Torvalds <torvalds@linux-foundation.org>

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 51272 bytes --]

Re: [v4 09/15] sparc64: optimized struct page zeroing

[kbuild test robot]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: multipart/mixed; boundary="--gBBFr7Ir9EOA20Yy", Size: 74233 bytes --]


--gBBFr7Ir9EOA20Yy
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3 next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sparc64-allmodconfig (attached as .config)
compiler: sparc64-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sparc64 

All error/warnings (new ones prefixed by >>):

   In file included from include/uapi/linux/stddef.h:1:0,
                    from include/linux/stddef.h:4,
                    from mm/page_alloc.c:17:
   mm/page_alloc.c: In function '__init_single_page':
>> include/linux/compiler.h:542:38: error: call to '__compiletime_assert_1171' declared with attribute error: BUILD_BUG_ON failed: sizeof(struct page) != 64
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
                                         ^
   include/linux/compiler.h:525:4: note: in definition of macro '__compiletime_assert'
       prefix ## suffix();    \
       ^~~~~~
   include/linux/compiler.h:542:2: note: in expansion of macro '_compiletime_assert'
     _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
     ^~~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:46:37: note: in expansion of macro 'compiletime_assert'
    #define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
                                        ^~~~~~~~~~~~~~~~~~
   include/linux/build_bug.h:70:2: note: in expansion of macro 'BUILD_BUG_ON_MSG'
     BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition)
     ^~~~~~~~~~~~~~~~
>> arch/sparc/include/asm/pgtable_64.h:240:3: note: in expansion of macro 'BUILD_BUG_ON'
      BUILD_BUG_ON(sizeof(struct page) != 64); \
      ^~~~~~~~~~~~
>> mm/page_alloc.c:1171:2: note: in expansion of macro 'mm_zero_struct_page'
     mm_zero_struct_page(page);
     ^~~~~~~~~~~~~~~~~~~

vim +/__compiletime_assert_1171 +542 include/linux/compiler.h

c361d3e5 Daniel Santos 2013-02-21  519  
9a8ab1c3 Daniel Santos 2013-02-21  520  #define __compiletime_assert(condition, msg, prefix, suffix)		\
9a8ab1c3 Daniel Santos 2013-02-21  521  	do {								\
9a8ab1c3 Daniel Santos 2013-02-21  522  		bool __cond = !(condition);				\
9a8ab1c3 Daniel Santos 2013-02-21  523  		extern void prefix ## suffix(void) __compiletime_error(msg); \
9a8ab1c3 Daniel Santos 2013-02-21  524  		if (__cond)						\
9a8ab1c3 Daniel Santos 2013-02-21  525  			prefix ## suffix();				\
9a8ab1c3 Daniel Santos 2013-02-21  526  		__compiletime_error_fallback(__cond);			\
9a8ab1c3 Daniel Santos 2013-02-21  527  	} while (0)
9a8ab1c3 Daniel Santos 2013-02-21  528  
9a8ab1c3 Daniel Santos 2013-02-21  529  #define _compiletime_assert(condition, msg, prefix, suffix) \
9a8ab1c3 Daniel Santos 2013-02-21  530  	__compiletime_assert(condition, msg, prefix, suffix)
9a8ab1c3 Daniel Santos 2013-02-21  531  
9a8ab1c3 Daniel Santos 2013-02-21  532  /**
9a8ab1c3 Daniel Santos 2013-02-21  533   * compiletime_assert - break build and emit msg if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  534   * @condition: a compile-time constant condition to check
9a8ab1c3 Daniel Santos 2013-02-21  535   * @msg:       a message to emit if condition is false
9a8ab1c3 Daniel Santos 2013-02-21  536   *
9a8ab1c3 Daniel Santos 2013-02-21  537   * In tradition of POSIX assert, this macro will break the build if the
9a8ab1c3 Daniel Santos 2013-02-21  538   * supplied condition is *false*, emitting the supplied error message if the
9a8ab1c3 Daniel Santos 2013-02-21  539   * compiler has support to do so.
9a8ab1c3 Daniel Santos 2013-02-21  540   */
9a8ab1c3 Daniel Santos 2013-02-21  541  #define compiletime_assert(condition, msg) \
9a8ab1c3 Daniel Santos 2013-02-21 @542  	_compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
9a8ab1c3 Daniel Santos 2013-02-21  543  

:::::: The code at line 542 was first introduced by commit
:::::: 9a8ab1c39970a4938a72d94e6fd13be88a797590 bug.h, compiler.h: introduce compiletime_assert & BUILD_BUG_ON_MSG

:::::: TO: Daniel Santos <daniel.santos@pobox.com>
:::::: CC: Linus Torvalds <torvalds@linux-foundation.org>

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

--gBBFr7Ir9EOA20Yy
Content-Type: application/gzip
Content-Disposition: attachment; filename=".config.gz"
Content-Transfer-Encoding: base64
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--gBBFr7Ir9EOA20Yy--

[v4 10/15] x86/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/kasan_init_64.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/arch/x86/mm/kasan_init_64.c b/arch/x86/mm/kasan_init_64.c
index 02c9d7553409..7d06cf0b0b6e 100644
--- a/arch/x86/mm/kasan_init_64.c
+++ b/arch/x86/mm/kasan_init_64.c
@@ -84,6 +84,28 @@ static struct notifier_block kasan_die_notifier = {
 };
 #endif
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	u64 i, start, end;
+
+	for (i = 0; i < E820_MAX_ENTRIES && pfn_mapped[i].end; i++) {
+		void *kaddr_start = pfn_to_kaddr(pfn_mapped[i].start);
+		void *kaddr_end = pfn_to_kaddr(pfn_mapped[i].end);
+
+		start = (u64)kasan_mem_to_shadow(kaddr_start);
+		end = (u64)kasan_mem_to_shadow(kaddr_end);
+		memset((void *)start, 0, end - start);
+	}
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_early_init(void)
 {
 	int i;
@@ -156,6 +178,13 @@ void __init kasan_init(void)
 		pte_t pte = __pte(__pa(kasan_zero_page) | __PAGE_KERNEL_RO);
 		set_pte(&kasan_zero_pte[i], pte);
 	}
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	/* Flush TLBs again to be sure that write protection applied. */
 	__flush_tlb_all();
 
-- 
2.13.3

[v4 10/15] x86/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/kasan_init_64.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/arch/x86/mm/kasan_init_64.c b/arch/x86/mm/kasan_init_64.c
index 02c9d7553409..7d06cf0b0b6e 100644
--- a/arch/x86/mm/kasan_init_64.c
+++ b/arch/x86/mm/kasan_init_64.c
@@ -84,6 +84,28 @@ static struct notifier_block kasan_die_notifier = {
 };
 #endif
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	u64 i, start, end;
+
+	for (i = 0; i < E820_MAX_ENTRIES && pfn_mapped[i].end; i++) {
+		void *kaddr_start = pfn_to_kaddr(pfn_mapped[i].start);
+		void *kaddr_end = pfn_to_kaddr(pfn_mapped[i].end);
+
+		start = (u64)kasan_mem_to_shadow(kaddr_start);
+		end = (u64)kasan_mem_to_shadow(kaddr_end);
+		memset((void *)start, 0, end - start);
+	}
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_early_init(void)
 {
 	int i;
@@ -156,6 +178,13 @@ void __init kasan_init(void)
 		pte_t pte = __pte(__pa(kasan_zero_page) | __PAGE_KERNEL_RO);
 		set_pte(&kasan_zero_pte[i], pte);
 	}
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	/* Flush TLBs again to be sure that write protection applied. */
 	__flush_tlb_all();
 
-- 
2.13.3

[v4 10/15] x86/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/kasan_init_64.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/arch/x86/mm/kasan_init_64.c b/arch/x86/mm/kasan_init_64.c
index 02c9d7553409..7d06cf0b0b6e 100644
--- a/arch/x86/mm/kasan_init_64.c
+++ b/arch/x86/mm/kasan_init_64.c
@@ -84,6 +84,28 @@ static struct notifier_block kasan_die_notifier = {
 };
 #endif
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	u64 i, start, end;
+
+	for (i = 0; i < E820_MAX_ENTRIES && pfn_mapped[i].end; i++) {
+		void *kaddr_start = pfn_to_kaddr(pfn_mapped[i].start);
+		void *kaddr_end = pfn_to_kaddr(pfn_mapped[i].end);
+
+		start = (u64)kasan_mem_to_shadow(kaddr_start);
+		end = (u64)kasan_mem_to_shadow(kaddr_end);
+		memset((void *)start, 0, end - start);
+	}
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_early_init(void)
 {
 	int i;
@@ -156,6 +178,13 @@ void __init kasan_init(void)
 		pte_t pte = __pte(__pa(kasan_zero_page) | __PAGE_KERNEL_RO);
 		set_pte(&kasan_zero_pte[i], pte);
 	}
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	/* Flush TLBs again to be sure that write protection applied. */
 	__flush_tlb_all();
 
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 10/15] x86/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/x86/mm/kasan_init_64.c | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/arch/x86/mm/kasan_init_64.c b/arch/x86/mm/kasan_init_64.c
index 02c9d7553409..7d06cf0b0b6e 100644
--- a/arch/x86/mm/kasan_init_64.c
+++ b/arch/x86/mm/kasan_init_64.c
@@ -84,6 +84,28 @@ static struct notifier_block kasan_die_notifier = {
 };
 #endif
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	u64 i, start, end;
+
+	for (i = 0; i < E820_MAX_ENTRIES && pfn_mapped[i].end; i++) {
+		void *kaddr_start = pfn_to_kaddr(pfn_mapped[i].start);
+		void *kaddr_end = pfn_to_kaddr(pfn_mapped[i].end);
+
+		start = (u64)kasan_mem_to_shadow(kaddr_start);
+		end = (u64)kasan_mem_to_shadow(kaddr_end);
+		memset((void *)start, 0, end - start);
+	}
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_early_init(void)
 {
 	int i;
@@ -156,6 +178,13 @@ void __init kasan_init(void)
 		pte_t pte = __pte(__pa(kasan_zero_page) | __PAGE_KERNEL_RO);
 		set_pte(&kasan_zero_pte[i], pte);
 	}
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	/* Flush TLBs again to be sure that write protection applied. */
 	__flush_tlb_all();
 
-- 
2.13.3

[v4 11/15] arm64/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/arm64/mm/kasan_init.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/arch/arm64/mm/kasan_init.c b/arch/arm64/mm/kasan_init.c
index 81f03959a4ab..a57104bc54b8 100644
--- a/arch/arm64/mm/kasan_init.c
+++ b/arch/arm64/mm/kasan_init.c
@@ -135,6 +135,31 @@ static void __init clear_pgds(unsigned long start,
 		set_pgd(pgd_offset_k(start), __pgd(0));
 }
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	struct memblock_region *reg;
+	u64 start, end;
+
+	for_each_memblock(memory, reg) {
+		start = __phys_to_virt(reg->base);
+		end = __phys_to_virt(reg->base + reg->size);
+
+		if (start >= end)
+			break;
+
+		memset((void *)start, 0, end - start);
+	}
+
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_init(void)
 {
 	u64 kimg_shadow_start, kimg_shadow_end;
@@ -205,6 +230,13 @@ void __init kasan_init(void)
 			pfn_pte(sym_to_pfn(kasan_zero_page), PAGE_KERNEL_RO));
 
 	memset(kasan_zero_page, 0, PAGE_SIZE);
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	cpu_replace_ttbr1(lm_alias(swapper_pg_dir));
 
 	/* At this point kasan is fully initialized. Enable error messages */
-- 
2.13.3

[v4 11/15] arm64/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/arm64/mm/kasan_init.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/arch/arm64/mm/kasan_init.c b/arch/arm64/mm/kasan_init.c
index 81f03959a4ab..a57104bc54b8 100644
--- a/arch/arm64/mm/kasan_init.c
+++ b/arch/arm64/mm/kasan_init.c
@@ -135,6 +135,31 @@ static void __init clear_pgds(unsigned long start,
 		set_pgd(pgd_offset_k(start), __pgd(0));
 }
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	struct memblock_region *reg;
+	u64 start, end;
+
+	for_each_memblock(memory, reg) {
+		start = __phys_to_virt(reg->base);
+		end = __phys_to_virt(reg->base + reg->size);
+
+		if (start >= end)
+			break;
+
+		memset((void *)start, 0, end - start);
+	}
+
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_init(void)
 {
 	u64 kimg_shadow_start, kimg_shadow_end;
@@ -205,6 +230,13 @@ void __init kasan_init(void)
 			pfn_pte(sym_to_pfn(kasan_zero_page), PAGE_KERNEL_RO));
 
 	memset(kasan_zero_page, 0, PAGE_SIZE);
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	cpu_replace_ttbr1(lm_alias(swapper_pg_dir));
 
 	/* At this point kasan is fully initialized. Enable error messages */
-- 
2.13.3

[v4 11/15] arm64/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/arm64/mm/kasan_init.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/arch/arm64/mm/kasan_init.c b/arch/arm64/mm/kasan_init.c
index 81f03959a4ab..a57104bc54b8 100644
--- a/arch/arm64/mm/kasan_init.c
+++ b/arch/arm64/mm/kasan_init.c
@@ -135,6 +135,31 @@ static void __init clear_pgds(unsigned long start,
 		set_pgd(pgd_offset_k(start), __pgd(0));
 }
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	struct memblock_region *reg;
+	u64 start, end;
+
+	for_each_memblock(memory, reg) {
+		start = __phys_to_virt(reg->base);
+		end = __phys_to_virt(reg->base + reg->size);
+
+		if (start >= end)
+			break;
+
+		memset((void *)start, 0, end - start);
+	}
+
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_init(void)
 {
 	u64 kimg_shadow_start, kimg_shadow_end;
@@ -205,6 +230,13 @@ void __init kasan_init(void)
 			pfn_pte(sym_to_pfn(kasan_zero_page), PAGE_KERNEL_RO));
 
 	memset(kasan_zero_page, 0, PAGE_SIZE);
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	cpu_replace_ttbr1(lm_alias(swapper_pg_dir));
 
 	/* At this point kasan is fully initialized. Enable error messages */
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 11/15] arm64/kasan: explicitly zero kasan shadow memory

[Pavel Tatashin]

To optimize the performance of struct page initialization,
vmemmap_populate() will no longer zero memory.

We must explicitly zero the memory that is allocated by vmemmap_populate()
for kasan, as this memory does not go through struct page initialization
path.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 arch/arm64/mm/kasan_init.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/arch/arm64/mm/kasan_init.c b/arch/arm64/mm/kasan_init.c
index 81f03959a4ab..a57104bc54b8 100644
--- a/arch/arm64/mm/kasan_init.c
+++ b/arch/arm64/mm/kasan_init.c
@@ -135,6 +135,31 @@ static void __init clear_pgds(unsigned long start,
 		set_pgd(pgd_offset_k(start), __pgd(0));
 }
 
+/*
+ * Memory that was allocated by vmemmap_populate is not zeroed, so we must
+ * zero it here explicitly.
+ */
+static void
+zero_vemmap_populated_memory(void)
+{
+	struct memblock_region *reg;
+	u64 start, end;
+
+	for_each_memblock(memory, reg) {
+		start = __phys_to_virt(reg->base);
+		end = __phys_to_virt(reg->base + reg->size);
+
+		if (start >= end)
+			break;
+
+		memset((void *)start, 0, end - start);
+	}
+
+	start = (u64)kasan_mem_to_shadow(_stext);
+	end = (u64)kasan_mem_to_shadow(_end);
+	memset((void *)start, 0, end - start);
+}
+
 void __init kasan_init(void)
 {
 	u64 kimg_shadow_start, kimg_shadow_end;
@@ -205,6 +230,13 @@ void __init kasan_init(void)
 			pfn_pte(sym_to_pfn(kasan_zero_page), PAGE_KERNEL_RO));
 
 	memset(kasan_zero_page, 0, PAGE_SIZE);
+
+	/*
+	 * vmemmap_populate does not zero the memory, so we need to zero it
+	 * explicitly
+	 */
+	zero_vemmap_populated_memory();
+
 	cpu_replace_ttbr1(lm_alias(swapper_pg_dir));
 
 	/* At this point kasan is fully initialized. Enable error messages */
-- 
2.13.3

[v4 12/15] mm: explicitly zero pagetable memory

[Pavel Tatashin]

Soon vmemmap_alloc_block() will no longer zero the block, so zero memory
at its call sites for everything except struct pages.  Struct page memory
is zero'd by struct page initialization.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index c50b1a14d55e..d40c721ab19f 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -191,6 +191,7 @@ pmd_t * __meminit vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pmd_populate_kernel(&init_mm, pmd, p);
 	}
 	return pmd;
@@ -203,6 +204,7 @@ pud_t * __meminit vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pud_populate(&init_mm, pud, p);
 	}
 	return pud;
@@ -215,6 +217,7 @@ p4d_t * __meminit vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		p4d_populate(&init_mm, p4d, p);
 	}
 	return p4d;
@@ -227,6 +230,7 @@ pgd_t * __meminit vmemmap_pgd_populate(unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pgd_populate(&init_mm, pgd, p);
 	}
 	return pgd;
-- 
2.13.3

[v4 12/15] mm: explicitly zero pagetable memory

[Pavel Tatashin]

Soon vmemmap_alloc_block() will no longer zero the block, so zero memory
at its call sites for everything except struct pages.  Struct page memory
is zero'd by struct page initialization.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index c50b1a14d55e..d40c721ab19f 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -191,6 +191,7 @@ pmd_t * __meminit vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pmd_populate_kernel(&init_mm, pmd, p);
 	}
 	return pmd;
@@ -203,6 +204,7 @@ pud_t * __meminit vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pud_populate(&init_mm, pud, p);
 	}
 	return pud;
@@ -215,6 +217,7 @@ p4d_t * __meminit vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		p4d_populate(&init_mm, p4d, p);
 	}
 	return p4d;
@@ -227,6 +230,7 @@ pgd_t * __meminit vmemmap_pgd_populate(unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pgd_populate(&init_mm, pgd, p);
 	}
 	return pgd;
-- 
2.13.3

[v4 12/15] mm: explicitly zero pagetable memory

[Pavel Tatashin]

Soon vmemmap_alloc_block() will no longer zero the block, so zero memory
at its call sites for everything except struct pages.  Struct page memory
is zero'd by struct page initialization.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index c50b1a14d55e..d40c721ab19f 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -191,6 +191,7 @@ pmd_t * __meminit vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pmd_populate_kernel(&init_mm, pmd, p);
 	}
 	return pmd;
@@ -203,6 +204,7 @@ pud_t * __meminit vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pud_populate(&init_mm, pud, p);
 	}
 	return pud;
@@ -215,6 +217,7 @@ p4d_t * __meminit vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		p4d_populate(&init_mm, p4d, p);
 	}
 	return p4d;
@@ -227,6 +230,7 @@ pgd_t * __meminit vmemmap_pgd_populate(unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pgd_populate(&init_mm, pgd, p);
 	}
 	return pgd;
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 12/15] mm: explicitly zero pagetable memory

[Pavel Tatashin]

Soon vmemmap_alloc_block() will no longer zero the block, so zero memory
at its call sites for everything except struct pages.  Struct page memory
is zero'd by struct page initialization.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index c50b1a14d55e..d40c721ab19f 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -191,6 +191,7 @@ pmd_t * __meminit vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pmd_populate_kernel(&init_mm, pmd, p);
 	}
 	return pmd;
@@ -203,6 +204,7 @@ pud_t * __meminit vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pud_populate(&init_mm, pud, p);
 	}
 	return pud;
@@ -215,6 +217,7 @@ p4d_t * __meminit vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		p4d_populate(&init_mm, p4d, p);
 	}
 	return p4d;
@@ -227,6 +230,7 @@ pgd_t * __meminit vmemmap_pgd_populate(unsigned long addr, int node)
 		void *p = vmemmap_alloc_block(PAGE_SIZE, node);
 		if (!p)
 			return NULL;
+		memset(p, 0, PAGE_SIZE);
 		pgd_populate(&init_mm, pgd, p);
 	}
 	return pgd;
-- 
2.13.3

[v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[Pavel Tatashin]

Replace allocators in sprase-vmemmap to use the non-zeroing version. So,
we will get the performance improvement by zeroing the memory in parallel
when struct pages are zeroed.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 6 +++---
 mm/sparse.c         | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index d40c721ab19f..3b646b5ce1b6 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -41,7 +41,7 @@ static void * __ref __earlyonly_bootmem_alloc(int node,
 				unsigned long align,
 				unsigned long goal)
 {
-	return memblock_virt_alloc_try_nid(size, align, goal,
+	return memblock_virt_alloc_try_nid_raw(size, align, goal,
 					    BOOTMEM_ALLOC_ACCESSIBLE, node);
 }
 
@@ -56,11 +56,11 @@ void * __meminit vmemmap_alloc_block(unsigned long size, int node)
 
 		if (node_state(node, N_HIGH_MEMORY))
 			page = alloc_pages_node(
-				node, GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				node, GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		else
 			page = alloc_pages(
-				GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		if (page)
 			return page_address(page);
diff --git a/mm/sparse.c b/mm/sparse.c
index 7b4be3fd5cac..0e315766ad11 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -441,9 +441,9 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
 	}
 
 	size = PAGE_ALIGN(size);
-	map = memblock_virt_alloc_try_nid(size * map_count,
-					  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
-					  BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
+	map = memblock_virt_alloc_try_nid_raw(size * map_count,
+					      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
+					      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
 	if (map) {
 		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
 			if (!present_section_nr(pnum))
-- 
2.13.3

[v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[Pavel Tatashin]

Replace allocators in sprase-vmemmap to use the non-zeroing version. So,
we will get the performance improvement by zeroing the memory in parallel
when struct pages are zeroed.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 6 +++---
 mm/sparse.c         | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index d40c721ab19f..3b646b5ce1b6 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -41,7 +41,7 @@ static void * __ref __earlyonly_bootmem_alloc(int node,
 				unsigned long align,
 				unsigned long goal)
 {
-	return memblock_virt_alloc_try_nid(size, align, goal,
+	return memblock_virt_alloc_try_nid_raw(size, align, goal,
 					    BOOTMEM_ALLOC_ACCESSIBLE, node);
 }
 
@@ -56,11 +56,11 @@ void * __meminit vmemmap_alloc_block(unsigned long size, int node)
 
 		if (node_state(node, N_HIGH_MEMORY))
 			page = alloc_pages_node(
-				node, GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				node, GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		else
 			page = alloc_pages(
-				GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		if (page)
 			return page_address(page);
diff --git a/mm/sparse.c b/mm/sparse.c
index 7b4be3fd5cac..0e315766ad11 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -441,9 +441,9 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
 	}
 
 	size = PAGE_ALIGN(size);
-	map = memblock_virt_alloc_try_nid(size * map_count,
-					  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
-					  BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
+	map = memblock_virt_alloc_try_nid_raw(size * map_count,
+					      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
+					      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
 	if (map) {
 		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
 			if (!present_section_nr(pnum))
-- 
2.13.3

[v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[Pavel Tatashin]

Replace allocators in sprase-vmemmap to use the non-zeroing version. So,
we will get the performance improvement by zeroing the memory in parallel
when struct pages are zeroed.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 6 +++---
 mm/sparse.c         | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index d40c721ab19f..3b646b5ce1b6 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -41,7 +41,7 @@ static void * __ref __earlyonly_bootmem_alloc(int node,
 				unsigned long align,
 				unsigned long goal)
 {
-	return memblock_virt_alloc_try_nid(size, align, goal,
+	return memblock_virt_alloc_try_nid_raw(size, align, goal,
 					    BOOTMEM_ALLOC_ACCESSIBLE, node);
 }
 
@@ -56,11 +56,11 @@ void * __meminit vmemmap_alloc_block(unsigned long size, int node)
 
 		if (node_state(node, N_HIGH_MEMORY))
 			page = alloc_pages_node(
-				node, GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				node, GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		else
 			page = alloc_pages(
-				GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		if (page)
 			return page_address(page);
diff --git a/mm/sparse.c b/mm/sparse.c
index 7b4be3fd5cac..0e315766ad11 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -441,9 +441,9 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
 	}
 
 	size = PAGE_ALIGN(size);
-	map = memblock_virt_alloc_try_nid(size * map_count,
-					  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
-					  BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
+	map = memblock_virt_alloc_try_nid_raw(size * map_count,
+					      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
+					      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
 	if (map) {
 		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
 			if (!present_section_nr(pnum))
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[Pavel Tatashin]

Replace allocators in sprase-vmemmap to use the non-zeroing version. So,
we will get the performance improvement by zeroing the memory in parallel
when struct pages are zeroed.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/sparse-vmemmap.c | 6 +++---
 mm/sparse.c         | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index d40c721ab19f..3b646b5ce1b6 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -41,7 +41,7 @@ static void * __ref __earlyonly_bootmem_alloc(int node,
 				unsigned long align,
 				unsigned long goal)
 {
-	return memblock_virt_alloc_try_nid(size, align, goal,
+	return memblock_virt_alloc_try_nid_raw(size, align, goal,
 					    BOOTMEM_ALLOC_ACCESSIBLE, node);
 }
 
@@ -56,11 +56,11 @@ void * __meminit vmemmap_alloc_block(unsigned long size, int node)
 
 		if (node_state(node, N_HIGH_MEMORY))
 			page = alloc_pages_node(
-				node, GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				node, GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		else
 			page = alloc_pages(
-				GFP_KERNEL | __GFP_ZERO | __GFP_RETRY_MAYFAIL,
+				GFP_KERNEL | __GFP_RETRY_MAYFAIL,
 				get_order(size));
 		if (page)
 			return page_address(page);
diff --git a/mm/sparse.c b/mm/sparse.c
index 7b4be3fd5cac..0e315766ad11 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -441,9 +441,9 @@ void __init sparse_mem_maps_populate_node(struct page **map_map,
 	}
 
 	size = PAGE_ALIGN(size);
-	map = memblock_virt_alloc_try_nid(size * map_count,
-					  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
-					  BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
+	map = memblock_virt_alloc_try_nid_raw(size * map_count,
+					      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
+					      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
 	if (map) {
 		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
 			if (!present_section_nr(pnum))
-- 
2.13.3

Re: [v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 3710 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sh-allmodconfig (attached as .config)
compiler: sh4-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sh 

All error/warnings (new ones prefixed by >>):

   mm/sparse.c: In function 'sparse_mem_maps_populate_node':
>> mm/sparse.c:444:8: error: implicit declaration of function 'memblock_virt_alloc_try_nid_raw' [-Werror=implicit-function-declaration]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>> mm/sparse.c:444:6: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
         ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_try_nid_raw +444 mm/sparse.c

   406	
   407	#ifndef CONFIG_SPARSEMEM_VMEMMAP
   408	struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
   409	{
   410		struct page *map;
   411		unsigned long size;
   412	
   413		map = alloc_remap(nid, sizeof(struct page) * PAGES_PER_SECTION);
   414		if (map)
   415			return map;
   416	
   417		size = PAGE_ALIGN(sizeof(struct page) * PAGES_PER_SECTION);
   418		map = memblock_virt_alloc_try_nid(size,
   419						  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   420						  BOOTMEM_ALLOC_ACCESSIBLE, nid);
   421		return map;
   422	}
   423	void __init sparse_mem_maps_populate_node(struct page **map_map,
   424						  unsigned long pnum_begin,
   425						  unsigned long pnum_end,
   426						  unsigned long map_count, int nodeid)
   427	{
   428		void *map;
   429		unsigned long pnum;
   430		unsigned long size = sizeof(struct page) * PAGES_PER_SECTION;
   431	
   432		map = alloc_remap(nodeid, size * map_count);
   433		if (map) {
   434			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   435				if (!present_section_nr(pnum))
   436					continue;
   437				map_map[pnum] = map;
   438				map += size;
   439			}
   440			return;
   441		}
   442	
   443		size = PAGE_ALIGN(size);
 > 444		map = memblock_virt_alloc_try_nid_raw(size * map_count,
   445						      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   446						      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
   447		if (map) {
   448			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   449				if (!present_section_nr(pnum))
   450					continue;
   451				map_map[pnum] = map;
   452				map += size;
   453			}
   454			return;
   455		}
   456	
   457		/* fallback */
   458		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   459			struct mem_section *ms;
   460	
   461			if (!present_section_nr(pnum))
   462				continue;
   463			map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
   464			if (map_map[pnum])
   465				continue;
   466			ms = __nr_to_section(pnum);
   467			pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
   468			       __func__);
   469			ms->section_mem_map = 0;
   470		}
   471	}
   472	#endif /* !CONFIG_SPARSEMEM_VMEMMAP */
   473	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 45971 bytes --]

[v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[kbuild test robot]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sh-allmodconfig (attached as .config)
compiler: sh4-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sh 

All error/warnings (new ones prefixed by >>):

   mm/sparse.c: In function 'sparse_mem_maps_populate_node':
>> mm/sparse.c:444:8: error: implicit declaration of function 'memblock_virt_alloc_try_nid_raw' [-Werror=implicit-function-declaration]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>> mm/sparse.c:444:6: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
         ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_try_nid_raw +444 mm/sparse.c

   406	
   407	#ifndef CONFIG_SPARSEMEM_VMEMMAP
   408	struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
   409	{
   410		struct page *map;
   411		unsigned long size;
   412	
   413		map = alloc_remap(nid, sizeof(struct page) * PAGES_PER_SECTION);
   414		if (map)
   415			return map;
   416	
   417		size = PAGE_ALIGN(sizeof(struct page) * PAGES_PER_SECTION);
   418		map = memblock_virt_alloc_try_nid(size,
   419						  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   420						  BOOTMEM_ALLOC_ACCESSIBLE, nid);
   421		return map;
   422	}
   423	void __init sparse_mem_maps_populate_node(struct page **map_map,
   424						  unsigned long pnum_begin,
   425						  unsigned long pnum_end,
   426						  unsigned long map_count, int nodeid)
   427	{
   428		void *map;
   429		unsigned long pnum;
   430		unsigned long size = sizeof(struct page) * PAGES_PER_SECTION;
   431	
   432		map = alloc_remap(nodeid, size * map_count);
   433		if (map) {
   434			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   435				if (!present_section_nr(pnum))
   436					continue;
   437				map_map[pnum] = map;
   438				map += size;
   439			}
   440			return;
   441		}
   442	
   443		size = PAGE_ALIGN(size);
 > 444		map = memblock_virt_alloc_try_nid_raw(size * map_count,
   445						      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   446						      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
   447		if (map) {
   448			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   449				if (!present_section_nr(pnum))
   450					continue;
   451				map_map[pnum] = map;
   452				map += size;
   453			}
   454			return;
   455		}
   456	
   457		/* fallback */
   458		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   459			struct mem_section *ms;
   460	
   461			if (!present_section_nr(pnum))
   462				continue;
   463			map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
   464			if (map_map[pnum])
   465				continue;
   466			ms = __nr_to_section(pnum);
   467			pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
   468			       __func__);
   469			ms->section_mem_map = 0;
   470		}
   471	}
   472	#endif /* !CONFIG_SPARSEMEM_VMEMMAP */
   473	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
-------------- next part --------------
A non-text attachment was scrubbed...
Name: .config.gz
Type: application/gzip
Size: 45971 bytes
Desc: not available
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20170803/f659ee9a/attachment-0001.gz>

Re: [v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 3710 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sh-allmodconfig (attached as .config)
compiler: sh4-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sh 

All error/warnings (new ones prefixed by >>):

   mm/sparse.c: In function 'sparse_mem_maps_populate_node':
>> mm/sparse.c:444:8: error: implicit declaration of function 'memblock_virt_alloc_try_nid_raw' [-Werror=implicit-function-declaration]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>> mm/sparse.c:444:6: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
         ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_try_nid_raw +444 mm/sparse.c

   406	
   407	#ifndef CONFIG_SPARSEMEM_VMEMMAP
   408	struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
   409	{
   410		struct page *map;
   411		unsigned long size;
   412	
   413		map = alloc_remap(nid, sizeof(struct page) * PAGES_PER_SECTION);
   414		if (map)
   415			return map;
   416	
   417		size = PAGE_ALIGN(sizeof(struct page) * PAGES_PER_SECTION);
   418		map = memblock_virt_alloc_try_nid(size,
   419						  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   420						  BOOTMEM_ALLOC_ACCESSIBLE, nid);
   421		return map;
   422	}
   423	void __init sparse_mem_maps_populate_node(struct page **map_map,
   424						  unsigned long pnum_begin,
   425						  unsigned long pnum_end,
   426						  unsigned long map_count, int nodeid)
   427	{
   428		void *map;
   429		unsigned long pnum;
   430		unsigned long size = sizeof(struct page) * PAGES_PER_SECTION;
   431	
   432		map = alloc_remap(nodeid, size * map_count);
   433		if (map) {
   434			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   435				if (!present_section_nr(pnum))
   436					continue;
   437				map_map[pnum] = map;
   438				map += size;
   439			}
   440			return;
   441		}
   442	
   443		size = PAGE_ALIGN(size);
 > 444		map = memblock_virt_alloc_try_nid_raw(size * map_count,
   445						      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   446						      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
   447		if (map) {
   448			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   449				if (!present_section_nr(pnum))
   450					continue;
   451				map_map[pnum] = map;
   452				map += size;
   453			}
   454			return;
   455		}
   456	
   457		/* fallback */
   458		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   459			struct mem_section *ms;
   460	
   461			if (!present_section_nr(pnum))
   462				continue;
   463			map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
   464			if (map_map[pnum])
   465				continue;
   466			ms = __nr_to_section(pnum);
   467			pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
   468			       __func__);
   469			ms->section_mem_map = 0;
   470		}
   471	}
   472	#endif /* !CONFIG_SPARSEMEM_VMEMMAP */
   473	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 45971 bytes --]

Re: [v4 13/15] mm: stop zeroing memory during allocation in vmemmap

[kbuild test robot]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: multipart/mixed; boundary="--mP3DRpeJDSE+ciuQ", Size: 66113 bytes --]


--mP3DRpeJDSE+ciuQ
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: sh-allmodconfig (attached as .config)
compiler: sh4-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=sh 

All error/warnings (new ones prefixed by >>):

   mm/sparse.c: In function 'sparse_mem_maps_populate_node':
>> mm/sparse.c:444:8: error: implicit declaration of function 'memblock_virt_alloc_try_nid_raw' [-Werror=implicit-function-declaration]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
>> mm/sparse.c:444:6: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
     map = memblock_virt_alloc_try_nid_raw(size * map_count,
         ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_try_nid_raw +444 mm/sparse.c

   406	
   407	#ifndef CONFIG_SPARSEMEM_VMEMMAP
   408	struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
   409	{
   410		struct page *map;
   411		unsigned long size;
   412	
   413		map = alloc_remap(nid, sizeof(struct page) * PAGES_PER_SECTION);
   414		if (map)
   415			return map;
   416	
   417		size = PAGE_ALIGN(sizeof(struct page) * PAGES_PER_SECTION);
   418		map = memblock_virt_alloc_try_nid(size,
   419						  PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   420						  BOOTMEM_ALLOC_ACCESSIBLE, nid);
   421		return map;
   422	}
   423	void __init sparse_mem_maps_populate_node(struct page **map_map,
   424						  unsigned long pnum_begin,
   425						  unsigned long pnum_end,
   426						  unsigned long map_count, int nodeid)
   427	{
   428		void *map;
   429		unsigned long pnum;
   430		unsigned long size = sizeof(struct page) * PAGES_PER_SECTION;
   431	
   432		map = alloc_remap(nodeid, size * map_count);
   433		if (map) {
   434			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   435				if (!present_section_nr(pnum))
   436					continue;
   437				map_map[pnum] = map;
   438				map += size;
   439			}
   440			return;
   441		}
   442	
   443		size = PAGE_ALIGN(size);
 > 444		map = memblock_virt_alloc_try_nid_raw(size * map_count,
   445						      PAGE_SIZE, __pa(MAX_DMA_ADDRESS),
   446						      BOOTMEM_ALLOC_ACCESSIBLE, nodeid);
   447		if (map) {
   448			for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   449				if (!present_section_nr(pnum))
   450					continue;
   451				map_map[pnum] = map;
   452				map += size;
   453			}
   454			return;
   455		}
   456	
   457		/* fallback */
   458		for (pnum = pnum_begin; pnum < pnum_end; pnum++) {
   459			struct mem_section *ms;
   460	
   461			if (!present_section_nr(pnum))
   462				continue;
   463			map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
   464			if (map_map[pnum])
   465				continue;
   466			ms = __nr_to_section(pnum);
   467			pr_err("%s: sparsemem memory map backing failed some memory will not be available\n",
   468			       __func__);
   469			ms->section_mem_map = 0;
   470		}
   471	}
   472	#endif /* !CONFIG_SPARSEMEM_VMEMMAP */
   473	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

--mP3DRpeJDSE+ciuQ
Content-Type: application/gzip
Content-Disposition: attachment; filename=".config.gz"
Content-Transfer-Encoding: base64
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--mP3DRpeJDSE+ciuQ--

[v4 14/15] mm: optimize early system hash allocations

[Pavel Tatashin]

Clients can call alloc_large_system_hash() with flag: HASH_ZERO to specify
that memory that was allocated for system hash needs to be zeroed,
otherwise the memory does not need to be zeroed, and client will initialize
it.

If memory does not need to be zero'd, call the new
memblock_virt_alloc_raw() interface, and thus improve the boot performance.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/page_alloc.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index debea7c0febb..623e2f7634e7 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -7350,18 +7350,17 @@ void *__init alloc_large_system_hash(const char *tablename,
 
 	log2qty = ilog2(numentries);
 
-	/*
-	 * memblock allocator returns zeroed memory already, so HASH_ZERO is
-	 * currently not used when HASH_EARLY is specified.
-	 */
 	gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
 	do {
 		size = bucketsize << log2qty;
-		if (flags & HASH_EARLY)
-			table = memblock_virt_alloc_nopanic(size, 0);
-		else if (hashdist)
+		if (flags & HASH_EARLY) {
+			if (flags & HASH_ZERO)
+				table = memblock_virt_alloc_nopanic(size, 0);
+			else
+				table = memblock_virt_alloc_raw(size, 0);
+		} else if (hashdist) {
 			table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
-		else {
+		} else {
 			/*
 			 * If bucketsize is not a power-of-two, we may free
 			 * some pages at the end of hash table which
-- 
2.13.3

[v4 14/15] mm: optimize early system hash allocations

[Pavel Tatashin]

Clients can call alloc_large_system_hash() with flag: HASH_ZERO to specify
that memory that was allocated for system hash needs to be zeroed,
otherwise the memory does not need to be zeroed, and client will initialize
it.

If memory does not need to be zero'd, call the new
memblock_virt_alloc_raw() interface, and thus improve the boot performance.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/page_alloc.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index debea7c0febb..623e2f7634e7 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -7350,18 +7350,17 @@ void *__init alloc_large_system_hash(const char *tablename,
 
 	log2qty = ilog2(numentries);
 
-	/*
-	 * memblock allocator returns zeroed memory already, so HASH_ZERO is
-	 * currently not used when HASH_EARLY is specified.
-	 */
 	gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
 	do {
 		size = bucketsize << log2qty;
-		if (flags & HASH_EARLY)
-			table = memblock_virt_alloc_nopanic(size, 0);
-		else if (hashdist)
+		if (flags & HASH_EARLY) {
+			if (flags & HASH_ZERO)
+				table = memblock_virt_alloc_nopanic(size, 0);
+			else
+				table = memblock_virt_alloc_raw(size, 0);
+		} else if (hashdist) {
 			table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
-		else {
+		} else {
 			/*
 			 * If bucketsize is not a power-of-two, we may free
 			 * some pages@the end of hash table which
-- 
2.13.3

[v4 14/15] mm: optimize early system hash allocations

[Pavel Tatashin]

Clients can call alloc_large_system_hash() with flag: HASH_ZERO to specify
that memory that was allocated for system hash needs to be zeroed,
otherwise the memory does not need to be zeroed, and client will initialize
it.

If memory does not need to be zero'd, call the new
memblock_virt_alloc_raw() interface, and thus improve the boot performance.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/page_alloc.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index debea7c0febb..623e2f7634e7 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -7350,18 +7350,17 @@ void *__init alloc_large_system_hash(const char *tablename,
 
 	log2qty = ilog2(numentries);
 
-	/*
-	 * memblock allocator returns zeroed memory already, so HASH_ZERO is
-	 * currently not used when HASH_EARLY is specified.
-	 */
 	gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
 	do {
 		size = bucketsize << log2qty;
-		if (flags & HASH_EARLY)
-			table = memblock_virt_alloc_nopanic(size, 0);
-		else if (hashdist)
+		if (flags & HASH_EARLY) {
+			if (flags & HASH_ZERO)
+				table = memblock_virt_alloc_nopanic(size, 0);
+			else
+				table = memblock_virt_alloc_raw(size, 0);
+		} else if (hashdist) {
 			table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
-		else {
+		} else {
 			/*
 			 * If bucketsize is not a power-of-two, we may free
 			 * some pages at the end of hash table which
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 14/15] mm: optimize early system hash allocations

[Pavel Tatashin]

Clients can call alloc_large_system_hash() with flag: HASH_ZERO to specify
that memory that was allocated for system hash needs to be zeroed,
otherwise the memory does not need to be zeroed, and client will initialize
it.

If memory does not need to be zero'd, call the new
memblock_virt_alloc_raw() interface, and thus improve the boot performance.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/page_alloc.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index debea7c0febb..623e2f7634e7 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -7350,18 +7350,17 @@ void *__init alloc_large_system_hash(const char *tablename,
 
 	log2qty = ilog2(numentries);
 
-	/*
-	 * memblock allocator returns zeroed memory already, so HASH_ZERO is
-	 * currently not used when HASH_EARLY is specified.
-	 */
 	gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
 	do {
 		size = bucketsize << log2qty;
-		if (flags & HASH_EARLY)
-			table = memblock_virt_alloc_nopanic(size, 0);
-		else if (hashdist)
+		if (flags & HASH_EARLY) {
+			if (flags & HASH_ZERO)
+				table = memblock_virt_alloc_nopanic(size, 0);
+			else
+				table = memblock_virt_alloc_raw(size, 0);
+		} else if (hashdist) {
 			table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
-		else {
+		} else {
 			/*
 			 * If bucketsize is not a power-of-two, we may free
 			 * some pages at the end of hash table which
-- 
2.13.3

Re: [v4 14/15] mm: optimize early system hash allocations

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 3972 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: mips-allmodconfig (attached as .config)
compiler: mips-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=mips 

All error/warnings (new ones prefixed by >>):

   mm/page_alloc.c: In function 'alloc_large_system_hash':
>> mm/page_alloc.c:7369:13: error: implicit declaration of function 'memblock_virt_alloc_raw' [-Werror=implicit-function-declaration]
        table = memblock_virt_alloc_raw(size, 0);
                ^~~~~~~~~~~~~~~~~~~~~~~
>> mm/page_alloc.c:7369:11: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
        table = memblock_virt_alloc_raw(size, 0);
              ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_raw +7369 mm/page_alloc.c

  7328	
  7329			/* limit to 1 bucket per 2^scale bytes of low memory */
  7330			if (scale > PAGE_SHIFT)
  7331				numentries >>= (scale - PAGE_SHIFT);
  7332			else
  7333				numentries <<= (PAGE_SHIFT - scale);
  7334	
  7335			/* Make sure we've got at least a 0-order allocation.. */
  7336			if (unlikely(flags & HASH_SMALL)) {
  7337				/* Makes no sense without HASH_EARLY */
  7338				WARN_ON(!(flags & HASH_EARLY));
  7339				if (!(numentries >> *_hash_shift)) {
  7340					numentries = 1UL << *_hash_shift;
  7341					BUG_ON(!numentries);
  7342				}
  7343			} else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
  7344				numentries = PAGE_SIZE / bucketsize;
  7345		}
  7346		numentries = roundup_pow_of_two(numentries);
  7347	
  7348		/* limit allocation size to 1/16 total memory by default */
  7349		if (max == 0) {
  7350			max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
  7351			do_div(max, bucketsize);
  7352		}
  7353		max = min(max, 0x80000000ULL);
  7354	
  7355		if (numentries < low_limit)
  7356			numentries = low_limit;
  7357		if (numentries > max)
  7358			numentries = max;
  7359	
  7360		log2qty = ilog2(numentries);
  7361	
  7362		gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
  7363		do {
  7364			size = bucketsize << log2qty;
  7365			if (flags & HASH_EARLY) {
  7366				if (flags & HASH_ZERO)
  7367					table = memblock_virt_alloc_nopanic(size, 0);
  7368				else
> 7369					table = memblock_virt_alloc_raw(size, 0);
  7370			} else if (hashdist) {
  7371				table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
  7372			} else {
  7373				/*
  7374				 * If bucketsize is not a power-of-two, we may free
  7375				 * some pages at the end of hash table which
  7376				 * alloc_pages_exact() automatically does
  7377				 */
  7378				if (get_order(size) < MAX_ORDER) {
  7379					table = alloc_pages_exact(size, gfp_flags);
  7380					kmemleak_alloc(table, size, 1, gfp_flags);
  7381				}
  7382			}
  7383		} while (!table && size > PAGE_SIZE && --log2qty);
  7384	
  7385		if (!table)
  7386			panic("Failed to allocate %s hash table\n", tablename);
  7387	
  7388		pr_info("%s hash table entries: %ld (order: %d, %lu bytes)\n",
  7389			tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size);
  7390	
  7391		if (_hash_shift)
  7392			*_hash_shift = log2qty;
  7393		if (_hash_mask)
  7394			*_hash_mask = (1 << log2qty) - 1;
  7395	
  7396		return table;
  7397	}
  7398	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 47112 bytes --]

[v4 14/15] mm: optimize early system hash allocations

[kbuild test robot]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: mips-allmodconfig (attached as .config)
compiler: mips-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=mips 

All error/warnings (new ones prefixed by >>):

   mm/page_alloc.c: In function 'alloc_large_system_hash':
>> mm/page_alloc.c:7369:13: error: implicit declaration of function 'memblock_virt_alloc_raw' [-Werror=implicit-function-declaration]
        table = memblock_virt_alloc_raw(size, 0);
                ^~~~~~~~~~~~~~~~~~~~~~~
>> mm/page_alloc.c:7369:11: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
        table = memblock_virt_alloc_raw(size, 0);
              ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_raw +7369 mm/page_alloc.c

  7328	
  7329			/* limit to 1 bucket per 2^scale bytes of low memory */
  7330			if (scale > PAGE_SHIFT)
  7331				numentries >>= (scale - PAGE_SHIFT);
  7332			else
  7333				numentries <<= (PAGE_SHIFT - scale);
  7334	
  7335			/* Make sure we've got@least a 0-order allocation.. */
  7336			if (unlikely(flags & HASH_SMALL)) {
  7337				/* Makes no sense without HASH_EARLY */
  7338				WARN_ON(!(flags & HASH_EARLY));
  7339				if (!(numentries >> *_hash_shift)) {
  7340					numentries = 1UL << *_hash_shift;
  7341					BUG_ON(!numentries);
  7342				}
  7343			} else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
  7344				numentries = PAGE_SIZE / bucketsize;
  7345		}
  7346		numentries = roundup_pow_of_two(numentries);
  7347	
  7348		/* limit allocation size to 1/16 total memory by default */
  7349		if (max == 0) {
  7350			max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
  7351			do_div(max, bucketsize);
  7352		}
  7353		max = min(max, 0x80000000ULL);
  7354	
  7355		if (numentries < low_limit)
  7356			numentries = low_limit;
  7357		if (numentries > max)
  7358			numentries = max;
  7359	
  7360		log2qty = ilog2(numentries);
  7361	
  7362		gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
  7363		do {
  7364			size = bucketsize << log2qty;
  7365			if (flags & HASH_EARLY) {
  7366				if (flags & HASH_ZERO)
  7367					table = memblock_virt_alloc_nopanic(size, 0);
  7368				else
> 7369					table = memblock_virt_alloc_raw(size, 0);
  7370			} else if (hashdist) {
  7371				table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
  7372			} else {
  7373				/*
  7374				 * If bucketsize is not a power-of-two, we may free
  7375				 * some pages at the end of hash table which
  7376				 * alloc_pages_exact() automatically does
  7377				 */
  7378				if (get_order(size) < MAX_ORDER) {
  7379					table = alloc_pages_exact(size, gfp_flags);
  7380					kmemleak_alloc(table, size, 1, gfp_flags);
  7381				}
  7382			}
  7383		} while (!table && size > PAGE_SIZE && --log2qty);
  7384	
  7385		if (!table)
  7386			panic("Failed to allocate %s hash table\n", tablename);
  7387	
  7388		pr_info("%s hash table entries: %ld (order: %d, %lu bytes)\n",
  7389			tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size);
  7390	
  7391		if (_hash_shift)
  7392			*_hash_shift = log2qty;
  7393		if (_hash_mask)
  7394			*_hash_mask = (1 << log2qty) - 1;
  7395	
  7396		return table;
  7397	}
  7398	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation
-------------- next part --------------
A non-text attachment was scrubbed...
Name: .config.gz
Type: application/gzip
Size: 47112 bytes
Desc: not available
URL: <http://lists.infradead.org/pipermail/linux-arm-kernel/attachments/20170803/603cce2a/attachment-0001.gz>

Re: [v4 14/15] mm: optimize early system hash allocations

[kbuild test robot]

[-- Attachment #1: Type: text/plain, Size: 3972 bytes --]

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: mips-allmodconfig (attached as .config)
compiler: mips-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=mips 

All error/warnings (new ones prefixed by >>):

   mm/page_alloc.c: In function 'alloc_large_system_hash':
>> mm/page_alloc.c:7369:13: error: implicit declaration of function 'memblock_virt_alloc_raw' [-Werror=implicit-function-declaration]
        table = memblock_virt_alloc_raw(size, 0);
                ^~~~~~~~~~~~~~~~~~~~~~~
>> mm/page_alloc.c:7369:11: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
        table = memblock_virt_alloc_raw(size, 0);
              ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_raw +7369 mm/page_alloc.c

  7328	
  7329			/* limit to 1 bucket per 2^scale bytes of low memory */
  7330			if (scale > PAGE_SHIFT)
  7331				numentries >>= (scale - PAGE_SHIFT);
  7332			else
  7333				numentries <<= (PAGE_SHIFT - scale);
  7334	
  7335			/* Make sure we've got at least a 0-order allocation.. */
  7336			if (unlikely(flags & HASH_SMALL)) {
  7337				/* Makes no sense without HASH_EARLY */
  7338				WARN_ON(!(flags & HASH_EARLY));
  7339				if (!(numentries >> *_hash_shift)) {
  7340					numentries = 1UL << *_hash_shift;
  7341					BUG_ON(!numentries);
  7342				}
  7343			} else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
  7344				numentries = PAGE_SIZE / bucketsize;
  7345		}
  7346		numentries = roundup_pow_of_two(numentries);
  7347	
  7348		/* limit allocation size to 1/16 total memory by default */
  7349		if (max == 0) {
  7350			max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
  7351			do_div(max, bucketsize);
  7352		}
  7353		max = min(max, 0x80000000ULL);
  7354	
  7355		if (numentries < low_limit)
  7356			numentries = low_limit;
  7357		if (numentries > max)
  7358			numentries = max;
  7359	
  7360		log2qty = ilog2(numentries);
  7361	
  7362		gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
  7363		do {
  7364			size = bucketsize << log2qty;
  7365			if (flags & HASH_EARLY) {
  7366				if (flags & HASH_ZERO)
  7367					table = memblock_virt_alloc_nopanic(size, 0);
  7368				else
> 7369					table = memblock_virt_alloc_raw(size, 0);
  7370			} else if (hashdist) {
  7371				table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
  7372			} else {
  7373				/*
  7374				 * If bucketsize is not a power-of-two, we may free
  7375				 * some pages at the end of hash table which
  7376				 * alloc_pages_exact() automatically does
  7377				 */
  7378				if (get_order(size) < MAX_ORDER) {
  7379					table = alloc_pages_exact(size, gfp_flags);
  7380					kmemleak_alloc(table, size, 1, gfp_flags);
  7381				}
  7382			}
  7383		} while (!table && size > PAGE_SIZE && --log2qty);
  7384	
  7385		if (!table)
  7386			panic("Failed to allocate %s hash table\n", tablename);
  7387	
  7388		pr_info("%s hash table entries: %ld (order: %d, %lu bytes)\n",
  7389			tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size);
  7390	
  7391		if (_hash_shift)
  7392			*_hash_shift = log2qty;
  7393		if (_hash_mask)
  7394			*_hash_mask = (1 << log2qty) - 1;
  7395	
  7396		return table;
  7397	}
  7398	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[-- Attachment #2: .config.gz --]
[-- Type: application/gzip, Size: 47112 bytes --]

Re: [v4 14/15] mm: optimize early system hash allocations

[kbuild test robot]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: multipart/mixed; boundary="--7AUc2qLy4jB3hD7Z", Size: 67916 bytes --]


--7AUc2qLy4jB3hD7Z
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline

Hi Pavel,

[auto build test ERROR on mmotm/master]
[also build test ERROR on v4.13-rc3]
[cannot apply to next-20170802]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Pavel-Tatashin/complete-deferred-page-initialization/20170803-081025
base:   git://git.cmpxchg.org/linux-mmotm.git master
config: mips-allmodconfig (attached as .config)
compiler: mips-linux-gnu-gcc (Debian 6.1.1-9) 6.1.1 20160705
reproduce:
        wget https://raw.githubusercontent.com/01org/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross
        chmod +x ~/bin/make.cross
        # save the attached .config to linux build tree
        make.cross ARCH=mips 

All error/warnings (new ones prefixed by >>):

   mm/page_alloc.c: In function 'alloc_large_system_hash':
>> mm/page_alloc.c:7369:13: error: implicit declaration of function 'memblock_virt_alloc_raw' [-Werror=implicit-function-declaration]
        table = memblock_virt_alloc_raw(size, 0);
                ^~~~~~~~~~~~~~~~~~~~~~~
>> mm/page_alloc.c:7369:11: warning: assignment makes pointer from integer without a cast [-Wint-conversion]
        table = memblock_virt_alloc_raw(size, 0);
              ^
   cc1: some warnings being treated as errors

vim +/memblock_virt_alloc_raw +7369 mm/page_alloc.c

  7328	
  7329			/* limit to 1 bucket per 2^scale bytes of low memory */
  7330			if (scale > PAGE_SHIFT)
  7331				numentries >>= (scale - PAGE_SHIFT);
  7332			else
  7333				numentries <<= (PAGE_SHIFT - scale);
  7334	
  7335			/* Make sure we've got at least a 0-order allocation.. */
  7336			if (unlikely(flags & HASH_SMALL)) {
  7337				/* Makes no sense without HASH_EARLY */
  7338				WARN_ON(!(flags & HASH_EARLY));
  7339				if (!(numentries >> *_hash_shift)) {
  7340					numentries = 1UL << *_hash_shift;
  7341					BUG_ON(!numentries);
  7342				}
  7343			} else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
  7344				numentries = PAGE_SIZE / bucketsize;
  7345		}
  7346		numentries = roundup_pow_of_two(numentries);
  7347	
  7348		/* limit allocation size to 1/16 total memory by default */
  7349		if (max == 0) {
  7350			max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
  7351			do_div(max, bucketsize);
  7352		}
  7353		max = min(max, 0x80000000ULL);
  7354	
  7355		if (numentries < low_limit)
  7356			numentries = low_limit;
  7357		if (numentries > max)
  7358			numentries = max;
  7359	
  7360		log2qty = ilog2(numentries);
  7361	
  7362		gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
  7363		do {
  7364			size = bucketsize << log2qty;
  7365			if (flags & HASH_EARLY) {
  7366				if (flags & HASH_ZERO)
  7367					table = memblock_virt_alloc_nopanic(size, 0);
  7368				else
> 7369					table = memblock_virt_alloc_raw(size, 0);
  7370			} else if (hashdist) {
  7371				table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
  7372			} else {
  7373				/*
  7374				 * If bucketsize is not a power-of-two, we may free
  7375				 * some pages at the end of hash table which
  7376				 * alloc_pages_exact() automatically does
  7377				 */
  7378				if (get_order(size) < MAX_ORDER) {
  7379					table = alloc_pages_exact(size, gfp_flags);
  7380					kmemleak_alloc(table, size, 1, gfp_flags);
  7381				}
  7382			}
  7383		} while (!table && size > PAGE_SIZE && --log2qty);
  7384	
  7385		if (!table)
  7386			panic("Failed to allocate %s hash table\n", tablename);
  7387	
  7388		pr_info("%s hash table entries: %ld (order: %d, %lu bytes)\n",
  7389			tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size);
  7390	
  7391		if (_hash_shift)
  7392			*_hash_shift = log2qty;
  7393		if (_hash_mask)
  7394			*_hash_mask = (1 << log2qty) - 1;
  7395	
  7396		return table;
  7397	}
  7398	

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

--7AUc2qLy4jB3hD7Z
Content-Type: application/gzip
Content-Disposition: attachment; filename=".config.gz"
Content-Transfer-Encoding: base64
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--7AUc2qLy4jB3hD7Z--

[v4 15/15] mm: debug for raw alloctor

[Pavel Tatashin]

When CONFIG_DEBUG_VM is enabled, this patch sets all the memory that is
returned by memblock_virt_alloc_try_nid_raw() to ones to ensure that no
places excpect zeroed memory.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/memblock.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/mm/memblock.c b/mm/memblock.c
index bdf31f207fa4..b6f90e75946c 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1363,12 +1363,19 @@ void * __init memblock_virt_alloc_try_nid_raw(
 			phys_addr_t min_addr, phys_addr_t max_addr,
 			int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
 
-	return memblock_virt_alloc_internal(size, align,
-					    min_addr, max_addr, nid);
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+#ifdef CONFIG_DEBUG_VM
+	if (ptr && size > 0)
+		memset(ptr, 0xff, size);
+#endif
+	return ptr;
 }
 
 /**
-- 
2.13.3

[v4 15/15] mm: debug for raw alloctor

[Pavel Tatashin]

When CONFIG_DEBUG_VM is enabled, this patch sets all the memory that is
returned by memblock_virt_alloc_try_nid_raw() to ones to ensure that no
places excpect zeroed memory.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/memblock.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/mm/memblock.c b/mm/memblock.c
index bdf31f207fa4..b6f90e75946c 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1363,12 +1363,19 @@ void * __init memblock_virt_alloc_try_nid_raw(
 			phys_addr_t min_addr, phys_addr_t max_addr,
 			int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
 
-	return memblock_virt_alloc_internal(size, align,
-					    min_addr, max_addr, nid);
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+#ifdef CONFIG_DEBUG_VM
+	if (ptr && size > 0)
+		memset(ptr, 0xff, size);
+#endif
+	return ptr;
 }
 
 /**
-- 
2.13.3

[v4 15/15] mm: debug for raw alloctor

[Pavel Tatashin]

When CONFIG_DEBUG_VM is enabled, this patch sets all the memory that is
returned by memblock_virt_alloc_try_nid_raw() to ones to ensure that no
places excpect zeroed memory.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/memblock.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/mm/memblock.c b/mm/memblock.c
index bdf31f207fa4..b6f90e75946c 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1363,12 +1363,19 @@ void * __init memblock_virt_alloc_try_nid_raw(
 			phys_addr_t min_addr, phys_addr_t max_addr,
 			int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
 
-	return memblock_virt_alloc_internal(size, align,
-					    min_addr, max_addr, nid);
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+#ifdef CONFIG_DEBUG_VM
+	if (ptr && size > 0)
+		memset(ptr, 0xff, size);
+#endif
+	return ptr;
 }
 
 /**
-- 
2.13.3

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org.  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>

[v4 15/15] mm: debug for raw alloctor

[Pavel Tatashin]

When CONFIG_DEBUG_VM is enabled, this patch sets all the memory that is
returned by memblock_virt_alloc_try_nid_raw() to ones to ensure that no
places excpect zeroed memory.

Signed-off-by: Pavel Tatashin <pasha.tatashin@oracle.com>
Reviewed-by: Steven Sistare <steven.sistare@oracle.com>
Reviewed-by: Daniel Jordan <daniel.m.jordan@oracle.com>
Reviewed-by: Bob Picco <bob.picco@oracle.com>
---
 mm/memblock.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/mm/memblock.c b/mm/memblock.c
index bdf31f207fa4..b6f90e75946c 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1363,12 +1363,19 @@ void * __init memblock_virt_alloc_try_nid_raw(
 			phys_addr_t min_addr, phys_addr_t max_addr,
 			int nid)
 {
+	void *ptr;
+
 	memblock_dbg("%s: %llu bytes align=0x%llx nid=%d from=0x%llx max_addr=0x%llx %pF\n",
 		     __func__, (u64)size, (u64)align, nid, (u64)min_addr,
 		     (u64)max_addr, (void *)_RET_IP_);
 
-	return memblock_virt_alloc_internal(size, align,
-					    min_addr, max_addr, nid);
+	ptr = memblock_virt_alloc_internal(size, align,
+					   min_addr, max_addr, nid);
+#ifdef CONFIG_DEBUG_VM
+	if (ptr && size > 0)
+		memset(ptr, 0xff, size);
+#endif
+	return ptr;
 }
 
 /**
-- 
2.13.3