mm/memblock.c: skip kmemleak for kasan_init()

[sfrench/cifs-2.6.git] / arch / arm64 / mm / kasan_init.c

diff --git a/arch/arm64/mm/kasan_init.c b/arch/arm64/mm/kasan_init.c
index 63527e585aaceb6163f34898a0f4d389a3d61a03..4b55b15707a33e5a5c7c202977845f86e847bda5 100644 (file)
--- a/arch/arm64/mm/kasan_init.c
+++ b/arch/arm64/mm/kasan_init.c
@@ -39,7 +39,15 @@ static phys_addr_t __init kasan_alloc_zeroed_page(int node)
 {
        void *p = memblock_alloc_try_nid(PAGE_SIZE, PAGE_SIZE,
                                              __pa(MAX_DMA_ADDRESS),
-                                             MEMBLOCK_ALLOC_ACCESSIBLE, node);
+                                             MEMBLOCK_ALLOC_KASAN, node);
+       return __pa(p);
+}
+
+static phys_addr_t __init kasan_alloc_raw_page(int node)
+{
+       void *p = memblock_alloc_try_nid_raw(PAGE_SIZE, PAGE_SIZE,
+                                               __pa(MAX_DMA_ADDRESS),
+                                               MEMBLOCK_ALLOC_KASAN, node);
        return __pa(p);
 }
 
@@ -47,8 +55,9 @@ static pte_t *__init kasan_pte_offset(pmd_t *pmdp, unsigned long addr, int node,
                                      bool early)
 {
        if (pmd_none(READ_ONCE(*pmdp))) {
-               phys_addr_t pte_phys = early ? __pa_symbol(kasan_zero_pte)
-                                            : kasan_alloc_zeroed_page(node);
+               phys_addr_t pte_phys = early ?
+                               __pa_symbol(kasan_early_shadow_pte)
+                                       : kasan_alloc_zeroed_page(node);
                __pmd_populate(pmdp, pte_phys, PMD_TYPE_TABLE);
        }
 
@@ -60,8 +69,9 @@ static pmd_t *__init kasan_pmd_offset(pud_t *pudp, unsigned long addr, int node,
                                      bool early)
 {
        if (pud_none(READ_ONCE(*pudp))) {
-               phys_addr_t pmd_phys = early ? __pa_symbol(kasan_zero_pmd)
-                                            : kasan_alloc_zeroed_page(node);
+               phys_addr_t pmd_phys = early ?
+                               __pa_symbol(kasan_early_shadow_pmd)
+                                       : kasan_alloc_zeroed_page(node);
                __pud_populate(pudp, pmd_phys, PMD_TYPE_TABLE);
        }
 
@@ -72,8 +82,9 @@ static pud_t *__init kasan_pud_offset(pgd_t *pgdp, unsigned long addr, int node,
                                      bool early)
 {
        if (pgd_none(READ_ONCE(*pgdp))) {
-               phys_addr_t pud_phys = early ? __pa_symbol(kasan_zero_pud)
-                                            : kasan_alloc_zeroed_page(node);
+               phys_addr_t pud_phys = early ?
+                               __pa_symbol(kasan_early_shadow_pud)
+                                       : kasan_alloc_zeroed_page(node);
                __pgd_populate(pgdp, pud_phys, PMD_TYPE_TABLE);
        }
 
@@ -87,8 +98,11 @@ static void __init kasan_pte_populate(pmd_t *pmdp, unsigned long addr,
        pte_t *ptep = kasan_pte_offset(pmdp, addr, node, early);
 
        do {
-               phys_addr_t page_phys = early ? __pa_symbol(kasan_zero_page)
-                                             : kasan_alloc_zeroed_page(node);
+               phys_addr_t page_phys = early ?
+                               __pa_symbol(kasan_early_shadow_page)
+                                       : kasan_alloc_raw_page(node);
+               if (!early)
+                       memset(__va(page_phys), KASAN_SHADOW_INIT, PAGE_SIZE);
                next = addr + PAGE_SIZE;
                set_pte(ptep, pfn_pte(__phys_to_pfn(page_phys), PAGE_KERNEL));
        } while (ptep++, addr = next, addr != end && pte_none(READ_ONCE(*ptep)));
@@ -205,14 +219,14 @@ void __init kasan_init(void)
        kasan_map_populate(kimg_shadow_start, kimg_shadow_end,
                           early_pfn_to_nid(virt_to_pfn(lm_alias(_text))));
 
-       kasan_populate_zero_shadow((void *)KASAN_SHADOW_START,
-                                  (void *)mod_shadow_start);
-       kasan_populate_zero_shadow((void *)kimg_shadow_end,
-                                  kasan_mem_to_shadow((void *)PAGE_OFFSET));
+       kasan_populate_early_shadow((void *)KASAN_SHADOW_START,
+                                   (void *)mod_shadow_start);
+       kasan_populate_early_shadow((void *)kimg_shadow_end,
+                                   kasan_mem_to_shadow((void *)PAGE_OFFSET));
 
        if (kimg_shadow_start > mod_shadow_end)
-               kasan_populate_zero_shadow((void *)mod_shadow_end,
-                                          (void *)kimg_shadow_start);
+               kasan_populate_early_shadow((void *)mod_shadow_end,
+                                           (void *)kimg_shadow_start);
 
        for_each_memblock(memory, reg) {
                void *start = (void *)__phys_to_virt(reg->base);
@@ -227,16 +241,19 @@ void __init kasan_init(void)
        }
 
        /*
-        * KAsan may reuse the contents of kasan_zero_pte directly, so we
-        * should make sure that it maps the zero page read-only.
+        * KAsan may reuse the contents of kasan_early_shadow_pte directly,
+        * so we should make sure that it maps the zero page read-only.
         */
        for (i = 0; i < PTRS_PER_PTE; i++)
-               set_pte(&kasan_zero_pte[i],
-                       pfn_pte(sym_to_pfn(kasan_zero_page), PAGE_KERNEL_RO));
+               set_pte(&kasan_early_shadow_pte[i],
+                       pfn_pte(sym_to_pfn(kasan_early_shadow_page),
+                               PAGE_KERNEL_RO));
 
-       memset(kasan_zero_page, 0, PAGE_SIZE);
+       memset(kasan_early_shadow_page, KASAN_SHADOW_INIT, PAGE_SIZE);
        cpu_replace_ttbr1(lm_alias(swapper_pg_dir));
 
+       kasan_init_tags();
+
        /* At this point kasan is fully initialized. Enable error messages */
        init_task.kasan_depth = 0;
        pr_info("KernelAddressSanitizer initialized\n");