LCOV - code coverage report
Current view: top level - arch/x86/mm - kasan_init_64.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 175 203 86.2 %
Date: 2022-03-28 16:04:14 Functions: 11 11 100.0 %
Branches: 89 190 46.8 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : #define DISABLE_BRANCH_PROFILING
       3                 :            : #define pr_fmt(fmt) "kasan: " fmt
       4                 :            : 
       5                 :            : /* cpu_feature_enabled() cannot be used this early */
       6                 :            : #define USE_EARLY_PGTABLE_L5
       7                 :            : 
       8                 :            : #include <linux/memblock.h>
       9                 :            : #include <linux/kasan.h>
      10                 :            : #include <linux/kdebug.h>
      11                 :            : #include <linux/mm.h>
      12                 :            : #include <linux/sched.h>
      13                 :            : #include <linux/sched/task.h>
      14                 :            : #include <linux/vmalloc.h>
      15                 :            : 
      16                 :            : #include <asm/e820/types.h>
      17                 :            : #include <asm/pgalloc.h>
      18                 :            : #include <asm/tlbflush.h>
      19                 :            : #include <asm/sections.h>
      20                 :            : #include <asm/pgtable.h>
      21                 :            : #include <asm/cpu_entry_area.h>
      22                 :            : 
      23                 :            : extern struct range pfn_mapped[E820_MAX_ENTRIES];
      24                 :            : 
      25                 :            : static p4d_t tmp_p4d_table[MAX_PTRS_PER_P4D] __initdata __aligned(PAGE_SIZE);
      26                 :            : 
      27                 :      14625 : static __init void *early_alloc(size_t size, int nid, bool should_panic)
      28                 :            : {
      29                 :      14625 :         void *ptr = memblock_alloc_try_nid(size, size,
      30         [ +  - ]:      14625 :                         __pa(MAX_DMA_ADDRESS), MEMBLOCK_ALLOC_ACCESSIBLE, nid);
      31                 :            : 
      32         [ -  + ]:      14625 :         if (!ptr && should_panic)
      33         [ #  # ]:          0 :                 panic("%pS: Failed to allocate page, nid=%d from=%lx\n",
      34                 :            :                       (void *)_RET_IP_, nid, __pa(MAX_DMA_ADDRESS));
      35                 :            : 
      36                 :      14625 :         return ptr;
      37                 :            : }
      38                 :            : 
      39                 :        949 : static void __init kasan_populate_pmd(pmd_t *pmd, unsigned long addr,
      40                 :            :                                       unsigned long end, int nid)
      41                 :            : {
      42                 :        949 :         pte_t *pte;
      43                 :            : 
      44         [ +  - ]:        949 :         if (pmd_none(*pmd)) {
      45                 :        949 :                 void *p;
      46                 :            : 
      47         [ +  - ]:        949 :                 if (boot_cpu_has(X86_FEATURE_PSE) &&
      48         [ +  + ]:        949 :                     ((end - addr) == PMD_SIZE) &&
      49         [ +  - ]:        910 :                     IS_ALIGNED(addr, PMD_SIZE)) {
      50                 :        910 :                         p = early_alloc(PMD_SIZE, nid, false);
      51   [ +  -  +  -  :       1820 :                         if (p && pmd_set_huge(pmd, __pa(p), PAGE_KERNEL))
                   +  - ]
      52                 :        910 :                                 return;
      53         [ #  # ]:          0 :                         else if (p)
      54         [ #  # ]:          0 :                                 memblock_free(__pa(p), PMD_SIZE);
      55                 :            :                 }
      56                 :            : 
      57                 :         39 :                 p = early_alloc(PAGE_SIZE, nid, true);
      58         [ +  - ]:         39 :                 pmd_populate_kernel(&init_mm, pmd, p);
      59                 :            :         }
      60                 :            : 
      61         [ +  - ]:         39 :         pte = pte_offset_kernel(pmd, addr);
      62                 :      13650 :         do {
      63                 :      13650 :                 pte_t entry;
      64                 :      13650 :                 void *p;
      65                 :            : 
      66         [ -  + ]:      13650 :                 if (!pte_none(*pte))
      67                 :          0 :                         continue;
      68                 :            : 
      69                 :      13650 :                 p = early_alloc(PAGE_SIZE, nid, true);
      70         [ +  - ]:      13650 :                 entry = pfn_pte(PFN_DOWN(__pa(p)), PAGE_KERNEL);
      71                 :      13650 :                 set_pte_at(&init_mm, addr, pte, entry);
      72         [ +  + ]:      13650 :         } while (pte++, addr += PAGE_SIZE, addr != end);
      73                 :            : }
      74                 :            : 
      75                 :         39 : static void __init kasan_populate_pud(pud_t *pud, unsigned long addr,
      76                 :            :                                       unsigned long end, int nid)
      77                 :            : {
      78                 :         39 :         pmd_t *pmd;
      79                 :         39 :         unsigned long next;
      80                 :            : 
      81         [ +  + ]:         39 :         if (pud_none(*pud)) {
      82                 :         26 :                 void *p;
      83                 :            : 
      84         [ -  + ]:         26 :                 if (boot_cpu_has(X86_FEATURE_GBPAGES) &&
      85         [ #  # ]:          0 :                     ((end - addr) == PUD_SIZE) &&
      86         [ #  # ]:          0 :                     IS_ALIGNED(addr, PUD_SIZE)) {
      87                 :          0 :                         p = early_alloc(PUD_SIZE, nid, false);
      88   [ #  #  #  #  :          0 :                         if (p && pud_set_huge(pud, __pa(p), PAGE_KERNEL))
                   #  # ]
      89                 :          0 :                                 return;
      90         [ #  # ]:          0 :                         else if (p)
      91         [ #  # ]:          0 :                                 memblock_free(__pa(p), PUD_SIZE);
      92                 :            :                 }
      93                 :            : 
      94                 :         26 :                 p = early_alloc(PAGE_SIZE, nid, true);
      95         [ +  - ]:         26 :                 pud_populate(&init_mm, pud, p);
      96                 :            :         }
      97                 :            : 
      98         [ +  - ]:         39 :         pmd = pmd_offset(pud, addr);
      99                 :        949 :         do {
     100         [ +  + ]:        949 :                 next = pmd_addr_end(addr, end);
     101   [ +  -  +  - ]:       1898 :                 if (!pmd_large(*pmd))
     102                 :        949 :                         kasan_populate_pmd(pmd, addr, next, nid);
     103         [ +  + ]:        949 :         } while (pmd++, addr = next, addr != end);
     104                 :            : }
     105                 :            : 
     106                 :         39 : static void __init kasan_populate_p4d(p4d_t *p4d, unsigned long addr,
     107                 :            :                                       unsigned long end, int nid)
     108                 :            : {
     109                 :         39 :         pud_t *pud;
     110                 :         39 :         unsigned long next;
     111                 :            : 
     112         [ -  + ]:         39 :         if (p4d_none(*p4d)) {
     113                 :          0 :                 void *p = early_alloc(PAGE_SIZE, nid, true);
     114                 :            : 
     115                 :          0 :                 p4d_populate(&init_mm, p4d, p);
     116                 :            :         }
     117                 :            : 
     118                 :         39 :         pud = pud_offset(p4d, addr);
     119                 :         39 :         do {
     120         [ -  + ]:         39 :                 next = pud_addr_end(addr, end);
     121         [ +  - ]:         39 :                 if (!pud_large(*pud))
     122                 :         39 :                         kasan_populate_pud(pud, addr, next, nid);
     123         [ -  + ]:         39 :         } while (pud++, addr = next, addr != end);
     124                 :         39 : }
     125                 :            : 
     126                 :         39 : static void __init kasan_populate_pgd(pgd_t *pgd, unsigned long addr,
     127                 :            :                                       unsigned long end, int nid)
     128                 :            : {
     129                 :         39 :         void *p;
     130                 :         39 :         p4d_t *p4d;
     131                 :         39 :         unsigned long next;
     132                 :            : 
     133   [ -  +  -  - ]:         39 :         if (pgd_none(*pgd)) {
     134                 :          0 :                 p = early_alloc(PAGE_SIZE, nid, true);
     135                 :          0 :                 pgd_populate(&init_mm, pgd, p);
     136                 :            :         }
     137                 :            : 
     138         [ -  + ]:         39 :         p4d = p4d_offset(pgd, addr);
     139                 :         39 :         do {
     140         [ -  + ]:         39 :                 next = p4d_addr_end(addr, end);
     141                 :         39 :                 kasan_populate_p4d(p4d, addr, next, nid);
     142         [ -  + ]:         39 :         } while (p4d++, addr = next, addr != end);
     143                 :         39 : }
     144                 :            : 
     145                 :         39 : static void __init kasan_populate_shadow(unsigned long addr, unsigned long end,
     146                 :            :                                          int nid)
     147                 :            : {
     148                 :         39 :         pgd_t *pgd;
     149                 :         39 :         unsigned long next;
     150                 :            : 
     151                 :         39 :         addr = addr & PAGE_MASK;
     152                 :         39 :         end = round_up(end, PAGE_SIZE);
     153                 :         39 :         pgd = pgd_offset_k(addr);
     154                 :         39 :         do {
     155         [ +  - ]:         39 :                 next = pgd_addr_end(addr, end);
     156                 :         39 :                 kasan_populate_pgd(pgd, addr, next, nid);
     157         [ -  + ]:         39 :         } while (pgd++, addr = next, addr != end);
     158                 :         39 : }
     159                 :            : 
     160                 :            : static void __init map_range(struct range *range)
     161                 :            : {
     162                 :            :         unsigned long start;
     163                 :            :         unsigned long end;
     164                 :            : 
     165                 :            :         start = (unsigned long)kasan_mem_to_shadow(pfn_to_kaddr(range->start));
     166                 :            :         end = (unsigned long)kasan_mem_to_shadow(pfn_to_kaddr(range->end));
     167                 :            : 
     168                 :            :         kasan_populate_shadow(start, end, early_pfn_to_nid(range->start));
     169                 :            : }
     170                 :            : 
     171                 :         13 : static void __init clear_pgds(unsigned long start,
     172                 :            :                         unsigned long end)
     173                 :            : {
     174                 :         13 :         pgd_t *pgd;
     175                 :            :         /* See comment in kasan_init() */
     176                 :         13 :         unsigned long pgd_end = end & PGDIR_MASK;
     177                 :            : 
     178         [ +  + ]:        429 :         for (; start < pgd_end; start += PGDIR_SIZE) {
     179                 :        416 :                 pgd = pgd_offset_k(start);
     180                 :            :                 /*
     181                 :            :                  * With folded p4d, pgd_clear() is nop, use p4d_clear()
     182                 :            :                  * instead.
     183                 :            :                  */
     184         [ -  + ]:        416 :                 if (pgtable_l5_enabled())
     185                 :          0 :                         pgd_clear(pgd);
     186                 :            :                 else
     187                 :        416 :                         p4d_clear(p4d_offset(pgd, start));
     188                 :            :         }
     189                 :            : 
     190                 :         13 :         pgd = pgd_offset_k(start);
     191         [ -  + ]:         13 :         for (; start < end; start += P4D_SIZE)
     192         [ #  # ]:          0 :                 p4d_clear(p4d_offset(pgd, start));
     193                 :         13 : }
     194                 :            : 
     195                 :        832 : static inline p4d_t *early_p4d_offset(pgd_t *pgd, unsigned long addr)
     196                 :            : {
     197                 :        832 :         unsigned long p4d;
     198                 :            : 
     199                 :        832 :         if (!pgtable_l5_enabled())
     200                 :            :                 return (p4d_t *)pgd;
     201                 :            : 
     202                 :          0 :         p4d = pgd_val(*pgd) & PTE_PFN_MASK;
     203                 :          0 :         p4d += __START_KERNEL_map - phys_base;
     204                 :          0 :         return (p4d_t *)p4d + p4d_index(addr);
     205                 :            : }
     206                 :            : 
     207                 :        832 : static void __init kasan_early_p4d_populate(pgd_t *pgd,
     208                 :            :                 unsigned long addr,
     209                 :            :                 unsigned long end)
     210                 :            : {
     211                 :        832 :         pgd_t pgd_entry;
     212                 :        832 :         p4d_t *p4d, p4d_entry;
     213                 :        832 :         unsigned long next;
     214                 :            : 
     215   [ -  +  -  - ]:        832 :         if (pgd_none(*pgd)) {
     216         [ #  # ]:          0 :                 pgd_entry = __pgd(_KERNPG_TABLE |
     217                 :            :                                         __pa_nodebug(kasan_early_shadow_p4d));
     218                 :          0 :                 set_pgd(pgd, pgd_entry);
     219                 :            :         }
     220                 :            : 
     221         [ -  + ]:        832 :         p4d = early_p4d_offset(pgd, addr);
     222                 :        832 :         do {
     223         [ -  + ]:        832 :                 next = p4d_addr_end(addr, end);
     224                 :            : 
     225         [ -  + ]:        832 :                 if (!p4d_none(*p4d))
     226                 :          0 :                         continue;
     227                 :            : 
     228   [ -  +  -  + ]:       1664 :                 p4d_entry = __p4d(_KERNPG_TABLE |
     229                 :            :                                         __pa_nodebug(kasan_early_shadow_pud));
     230         [ -  + ]:        832 :                 set_p4d(p4d, p4d_entry);
     231   [ -  +  -  - ]:        832 :         } while (p4d++, addr = next, addr != end && p4d_none(*p4d));
     232                 :        832 : }
     233                 :            : 
     234                 :         26 : static void __init kasan_map_early_shadow(pgd_t *pgd)
     235                 :            : {
     236                 :            :         /* See comment in kasan_init() */
     237         [ +  - ]:         26 :         unsigned long addr = KASAN_SHADOW_START & PGDIR_MASK;
     238         [ +  - ]:         26 :         unsigned long end = KASAN_SHADOW_END;
     239                 :         26 :         unsigned long next;
     240                 :            : 
     241                 :         26 :         pgd += pgd_index(addr);
     242                 :        832 :         do {
     243         [ +  + ]:        832 :                 next = pgd_addr_end(addr, end);
     244                 :        832 :                 kasan_early_p4d_populate(pgd, addr, next);
     245         [ +  + ]:        832 :         } while (pgd++, addr = next, addr != end);
     246                 :         26 : }
     247                 :            : 
     248                 :            : static void __init kasan_shallow_populate_p4ds(pgd_t *pgd,
     249                 :            :                                                unsigned long addr,
     250                 :            :                                                unsigned long end)
     251                 :            : {
     252                 :            :         p4d_t *p4d;
     253                 :            :         unsigned long next;
     254                 :            :         void *p;
     255                 :            : 
     256                 :            :         p4d = p4d_offset(pgd, addr);
     257                 :            :         do {
     258                 :            :                 next = p4d_addr_end(addr, end);
     259                 :            : 
     260                 :            :                 if (p4d_none(*p4d)) {
     261                 :            :                         p = early_alloc(PAGE_SIZE, NUMA_NO_NODE, true);
     262                 :            :                         p4d_populate(&init_mm, p4d, p);
     263                 :            :                 }
     264                 :            :         } while (p4d++, addr = next, addr != end);
     265                 :            : }
     266                 :            : 
     267                 :            : static void __init kasan_shallow_populate_pgds(void *start, void *end)
     268                 :            : {
     269                 :            :         unsigned long addr, next;
     270                 :            :         pgd_t *pgd;
     271                 :            :         void *p;
     272                 :            : 
     273                 :            :         addr = (unsigned long)start;
     274                 :            :         pgd = pgd_offset_k(addr);
     275                 :            :         do {
     276                 :            :                 next = pgd_addr_end(addr, (unsigned long)end);
     277                 :            : 
     278                 :            :                 if (pgd_none(*pgd)) {
     279                 :            :                         p = early_alloc(PAGE_SIZE, NUMA_NO_NODE, true);
     280                 :            :                         pgd_populate(&init_mm, pgd, p);
     281                 :            :                 }
     282                 :            : 
     283                 :            :                 /*
     284                 :            :                  * we need to populate p4ds to be synced when running in
     285                 :            :                  * four level mode - see sync_global_pgds_l4()
     286                 :            :                  */
     287                 :            :                 kasan_shallow_populate_p4ds(pgd, addr, next);
     288                 :            :         } while (pgd++, addr = next, addr != (unsigned long)end);
     289                 :            : }
     290                 :            : 
     291                 :         13 : void __init kasan_early_init(void)
     292                 :            : {
     293                 :         13 :         int i;
     294         [ -  + ]:         13 :         pteval_t pte_val = __pa_nodebug(kasan_early_shadow_page) |
     295                 :            :                                 __PAGE_KERNEL | _PAGE_ENC;
     296         [ -  + ]:         13 :         pmdval_t pmd_val = __pa_nodebug(kasan_early_shadow_pte) | _KERNPG_TABLE;
     297         [ -  + ]:         13 :         pudval_t pud_val = __pa_nodebug(kasan_early_shadow_pmd) | _KERNPG_TABLE;
     298         [ -  + ]:         13 :         p4dval_t p4d_val = __pa_nodebug(kasan_early_shadow_pud) | _KERNPG_TABLE;
     299                 :            : 
     300                 :            :         /* Mask out unsupported __PAGE_KERNEL bits: */
     301                 :         13 :         pte_val &= __default_kernel_pte_mask;
     302                 :         13 :         pmd_val &= __default_kernel_pte_mask;
     303                 :         13 :         pud_val &= __default_kernel_pte_mask;
     304                 :         13 :         p4d_val &= __default_kernel_pte_mask;
     305                 :            : 
     306         [ +  + ]:       6669 :         for (i = 0; i < PTRS_PER_PTE; i++)
     307                 :       6656 :                 kasan_early_shadow_pte[i] = __pte(pte_val);
     308                 :            : 
     309         [ +  + ]:       6669 :         for (i = 0; i < PTRS_PER_PMD; i++)
     310                 :       6656 :                 kasan_early_shadow_pmd[i] = __pmd(pmd_val);
     311                 :            : 
     312         [ +  + ]:       6669 :         for (i = 0; i < PTRS_PER_PUD; i++)
     313                 :       6656 :                 kasan_early_shadow_pud[i] = __pud(pud_val);
     314                 :            : 
     315   [ -  +  -  - ]:         13 :         for (i = 0; pgtable_l5_enabled() && i < PTRS_PER_P4D; i++)
     316                 :          0 :                 kasan_early_shadow_p4d[i] = __p4d(p4d_val);
     317                 :            : 
     318                 :         13 :         kasan_map_early_shadow(early_top_pgt);
     319                 :         13 :         kasan_map_early_shadow(init_top_pgt);
     320                 :         13 : }
     321                 :            : 
     322                 :         13 : void __init kasan_init(void)
     323                 :            : {
     324                 :         13 :         int i;
     325                 :         13 :         void *shadow_cpu_entry_begin, *shadow_cpu_entry_end;
     326                 :            : 
     327                 :         13 :         memcpy(early_top_pgt, init_top_pgt, sizeof(early_top_pgt));
     328                 :            : 
     329                 :            :         /*
     330                 :            :          * We use the same shadow offset for 4- and 5-level paging to
     331                 :            :          * facilitate boot-time switching between paging modes.
     332                 :            :          * As result in 5-level paging mode KASAN_SHADOW_START and
     333                 :            :          * KASAN_SHADOW_END are not aligned to PGD boundary.
     334                 :            :          *
     335                 :            :          * KASAN_SHADOW_START doesn't share PGD with anything else.
     336                 :            :          * We claim whole PGD entry to make things easier.
     337                 :            :          *
     338                 :            :          * KASAN_SHADOW_END lands in the last PGD entry and it collides with
     339                 :            :          * bunch of things like kernel code, modules, EFI mapping, etc.
     340                 :            :          * We need to take extra steps to not overwrite them.
     341                 :            :          */
     342         [ -  + ]:         13 :         if (pgtable_l5_enabled()) {
     343                 :          0 :                 void *ptr;
     344                 :            : 
     345                 :          0 :                 ptr = (void *)pgd_page_vaddr(*pgd_offset_k(KASAN_SHADOW_END));
     346                 :          0 :                 memcpy(tmp_p4d_table, (void *)ptr, sizeof(tmp_p4d_table));
     347   [ #  #  #  #  :          0 :                 set_pgd(&early_top_pgt[pgd_index(KASAN_SHADOW_END)],
                   #  # ]
     348                 :            :                                 __pgd(__pa(tmp_p4d_table) | _KERNPG_TABLE));
     349                 :            :         }
     350                 :            : 
     351         [ -  + ]:         13 :         load_cr3(early_top_pgt);
     352                 :         13 :         __flush_tlb_all();
     353                 :            : 
     354   [ +  -  +  - ]:         39 :         clear_pgds(KASAN_SHADOW_START & PGDIR_MASK, KASAN_SHADOW_END);
     355                 :            : 
     356                 :         26 :         kasan_populate_early_shadow((void *)(KASAN_SHADOW_START & PGDIR_MASK),
     357         [ +  - ]:         13 :                         kasan_mem_to_shadow((void *)PAGE_OFFSET));
     358                 :            : 
     359         [ +  - ]:         39 :         for (i = 0; i < E820_MAX_ENTRIES; i++) {
     360         [ +  + ]:         26 :                 if (pfn_mapped[i].end == 0)
     361                 :            :                         break;
     362                 :            : 
     363                 :         13 :                 map_range(&pfn_mapped[i]);
     364                 :            :         }
     365                 :            : 
     366                 :         13 :         shadow_cpu_entry_begin = (void *)CPU_ENTRY_AREA_BASE;
     367         [ +  - ]:         13 :         shadow_cpu_entry_begin = kasan_mem_to_shadow(shadow_cpu_entry_begin);
     368                 :         13 :         shadow_cpu_entry_begin = (void *)round_down(
     369                 :            :                         (unsigned long)shadow_cpu_entry_begin, PAGE_SIZE);
     370                 :            : 
     371                 :         13 :         shadow_cpu_entry_end = (void *)(CPU_ENTRY_AREA_BASE +
     372                 :            :                                         CPU_ENTRY_AREA_MAP_SIZE);
     373                 :         13 :         shadow_cpu_entry_end = kasan_mem_to_shadow(shadow_cpu_entry_end);
     374                 :         13 :         shadow_cpu_entry_end = (void *)round_up(
     375                 :            :                         (unsigned long)shadow_cpu_entry_end, PAGE_SIZE);
     376                 :            : 
     377                 :         13 :         kasan_populate_early_shadow(
     378         [ +  - ]:         26 :                 kasan_mem_to_shadow((void *)PAGE_OFFSET + MAXMEM),
     379         [ +  - ]:         13 :                 kasan_mem_to_shadow((void *)VMALLOC_START));
     380                 :            : 
     381                 :            :         /*
     382                 :            :          * If we're in full vmalloc mode, don't back vmalloc space with early
     383                 :            :          * shadow pages. Instead, prepopulate pgds/p4ds so they are synced to
     384                 :            :          * the global table and we can populate the lower levels on demand.
     385                 :            :          */
     386                 :         13 :         if (IS_ENABLED(CONFIG_KASAN_VMALLOC))
     387                 :            :                 kasan_shallow_populate_pgds(
     388                 :            :                         kasan_mem_to_shadow((void *)VMALLOC_START),
     389                 :            :                         kasan_mem_to_shadow((void *)VMALLOC_END));
     390                 :            :         else
     391         [ +  - ]:         26 :                 kasan_populate_early_shadow(
     392                 :            :                         kasan_mem_to_shadow((void *)VMALLOC_START),
     393         [ +  - ]:         26 :                         kasan_mem_to_shadow((void *)VMALLOC_END));
     394                 :            : 
     395         [ +  - ]:         26 :         kasan_populate_early_shadow(
     396         [ +  - ]:         26 :                 kasan_mem_to_shadow((void *)VMALLOC_END + 1),
     397                 :            :                 shadow_cpu_entry_begin);
     398                 :            : 
     399                 :         13 :         kasan_populate_shadow((unsigned long)shadow_cpu_entry_begin,
     400                 :            :                               (unsigned long)shadow_cpu_entry_end, 0);
     401                 :            : 
     402                 :         13 :         kasan_populate_early_shadow(shadow_cpu_entry_end,
     403                 :            :                         kasan_mem_to_shadow((void *)__START_KERNEL_map));
     404                 :            : 
     405         [ -  + ]:         26 :         kasan_populate_shadow((unsigned long)kasan_mem_to_shadow(_stext),
     406                 :            :                               (unsigned long)kasan_mem_to_shadow(_end),
     407                 :            :                               early_pfn_to_nid(__pa(_stext)));
     408                 :            : 
     409         [ +  - ]:         13 :         kasan_populate_early_shadow(kasan_mem_to_shadow((void *)MODULES_END),
     410   [ +  -  +  - ]:         39 :                                         (void *)KASAN_SHADOW_END);
     411                 :            : 
     412         [ -  + ]:         13 :         load_cr3(init_top_pgt);
     413                 :         13 :         __flush_tlb_all();
     414                 :            : 
     415                 :            :         /*
     416                 :            :          * kasan_early_shadow_page has been used as early shadow memory, thus
     417                 :            :          * it may contain some garbage. Now we can clear and write protect it,
     418                 :            :          * since after the TLB flush no one should write to it.
     419                 :            :          */
     420                 :         13 :         memset(kasan_early_shadow_page, 0, PAGE_SIZE);
     421         [ +  + ]:       6682 :         for (i = 0; i < PTRS_PER_PTE; i++) {
     422                 :       6656 :                 pte_t pte;
     423                 :       6656 :                 pgprot_t prot;
     424                 :            : 
     425                 :       6656 :                 prot = __pgprot(__PAGE_KERNEL_RO | _PAGE_ENC);
     426                 :       6656 :                 pgprot_val(prot) &= __default_kernel_pte_mask;
     427                 :            : 
     428         [ -  + ]:      13312 :                 pte = __pte(__pa(kasan_early_shadow_page) | pgprot_val(prot));
     429                 :       6656 :                 set_pte(&kasan_early_shadow_pte[i], pte);
     430                 :            :         }
     431                 :            :         /* Flush TLBs again to be sure that write protection applied. */
     432                 :         13 :         __flush_tlb_all();
     433                 :            : 
     434                 :         13 :         init_task.kasan_depth = 0;
     435                 :         13 :         pr_info("KernelAddressSanitizer initialized\n");
     436                 :         13 : }

Generated by: LCOV version 1.14