LCOV - code coverage report
Current view: top level - mm/kasan - init.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 91 250 36.4 %
Date: 2022-03-28 16:04:14 Functions: 6 21 28.6 %
Branches: 58 226 25.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * This file contains some kasan initialization code.
       4                 :            :  *
       5                 :            :  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
       6                 :            :  * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com>
       7                 :            :  *
       8                 :            :  * This program is free software; you can redistribute it and/or modify
       9                 :            :  * it under the terms of the GNU General Public License version 2 as
      10                 :            :  * published by the Free Software Foundation.
      11                 :            :  *
      12                 :            :  */
      13                 :            : 
      14                 :            : #include <linux/memblock.h>
      15                 :            : #include <linux/init.h>
      16                 :            : #include <linux/kasan.h>
      17                 :            : #include <linux/kernel.h>
      18                 :            : #include <linux/mm.h>
      19                 :            : #include <linux/pfn.h>
      20                 :            : #include <linux/slab.h>
      21                 :            : 
      22                 :            : #include <asm/page.h>
      23                 :            : #include <asm/pgalloc.h>
      24                 :            : 
      25                 :            : #include "kasan.h"
      26                 :            : 
      27                 :            : /*
      28                 :            :  * This page serves two purposes:
      29                 :            :  *   - It used as early shadow memory. The entire shadow region populated
      30                 :            :  *     with this page, before we will be able to setup normal shadow memory.
      31                 :            :  *   - Latter it reused it as zero shadow to cover large ranges of memory
      32                 :            :  *     that allowed to access, but not handled by kasan (vmalloc/vmemmap ...).
      33                 :            :  */
      34                 :            : unsigned char kasan_early_shadow_page[PAGE_SIZE] __page_aligned_bss;
      35                 :            : 
      36                 :            : #if CONFIG_PGTABLE_LEVELS > 4
      37                 :            : p4d_t kasan_early_shadow_p4d[MAX_PTRS_PER_P4D] __page_aligned_bss;
      38                 :          0 : static inline bool kasan_p4d_table(pgd_t pgd)
      39                 :            : {
      40         [ #  # ]:          0 :         return pgd_page(pgd) == virt_to_page(lm_alias(kasan_early_shadow_p4d));
      41                 :            : }
      42                 :            : #else
      43                 :            : static inline bool kasan_p4d_table(pgd_t pgd)
      44                 :            : {
      45                 :            :         return false;
      46                 :            : }
      47                 :            : #endif
      48                 :            : #if CONFIG_PGTABLE_LEVELS > 3
      49                 :            : pud_t kasan_early_shadow_pud[PTRS_PER_PUD] __page_aligned_bss;
      50                 :          0 : static inline bool kasan_pud_table(p4d_t p4d)
      51                 :            : {
      52         [ #  # ]:          0 :         return p4d_page(p4d) == virt_to_page(lm_alias(kasan_early_shadow_pud));
      53                 :            : }
      54                 :            : #else
      55                 :            : static inline bool kasan_pud_table(p4d_t p4d)
      56                 :            : {
      57                 :            :         return false;
      58                 :            : }
      59                 :            : #endif
      60                 :            : #if CONFIG_PGTABLE_LEVELS > 2
      61                 :            : pmd_t kasan_early_shadow_pmd[PTRS_PER_PMD] __page_aligned_bss;
      62                 :          0 : static inline bool kasan_pmd_table(pud_t pud)
      63                 :            : {
      64   [ #  #  #  # ]:          0 :         return pud_page(pud) == virt_to_page(lm_alias(kasan_early_shadow_pmd));
      65                 :            : }
      66                 :            : #else
      67                 :            : static inline bool kasan_pmd_table(pud_t pud)
      68                 :            : {
      69                 :            :         return false;
      70                 :            : }
      71                 :            : #endif
      72                 :            : pte_t kasan_early_shadow_pte[PTRS_PER_PTE] __page_aligned_bss;
      73                 :            : 
      74                 :          0 : static inline bool kasan_pte_table(pmd_t pmd)
      75                 :            : {
      76   [ #  #  #  # ]:          0 :         return pmd_page(pmd) == virt_to_page(lm_alias(kasan_early_shadow_pte));
      77                 :            : }
      78                 :            : 
      79                 :          0 : static inline bool kasan_early_shadow_page_entry(pte_t pte)
      80                 :            : {
      81   [ #  #  #  # ]:          0 :         return pte_page(pte) == virt_to_page(lm_alias(kasan_early_shadow_page));
      82                 :            : }
      83                 :            : 
      84                 :         91 : static __init void *early_alloc(size_t size, int node)
      85                 :            : {
      86         [ +  - ]:        182 :         void *ptr = memblock_alloc_try_nid(size, size, __pa(MAX_DMA_ADDRESS),
      87                 :            :                                            MEMBLOCK_ALLOC_ACCESSIBLE, node);
      88                 :            : 
      89         [ -  + ]:         91 :         if (!ptr)
      90                 :          0 :                 panic("%s: Failed to allocate %zu bytes align=%zx nid=%d from=%llx\n",
      91         [ #  # ]:          0 :                       __func__, size, size, node, (u64)__pa(MAX_DMA_ADDRESS));
      92                 :            : 
      93                 :         91 :         return ptr;
      94                 :            : }
      95                 :            : 
      96                 :         26 : static void __ref zero_pte_populate(pmd_t *pmd, unsigned long addr,
      97                 :            :                                 unsigned long end)
      98                 :            : {
      99         [ +  - ]:         26 :         pte_t *pte = pte_offset_kernel(pmd, addr);
     100                 :         26 :         pte_t zero_pte;
     101                 :            : 
     102                 :         26 :         zero_pte = pfn_pte(PFN_DOWN(__pa_symbol(kasan_early_shadow_page)),
     103         [ +  - ]:         26 :                                 PAGE_KERNEL);
     104                 :         26 :         zero_pte = pte_wrprotect(zero_pte);
     105                 :            : 
     106         [ +  + ]:       7176 :         while (addr + PAGE_SIZE <= end) {
     107         [ +  - ]:       7150 :                 set_pte_at(&init_mm, addr, pte, zero_pte);
     108                 :       7150 :                 addr += PAGE_SIZE;
     109         [ +  - ]:       7150 :                 pte = pte_offset_kernel(pmd, addr);
     110                 :            :         }
     111                 :         26 : }
     112                 :            : 
     113                 :         52 : static int __ref zero_pmd_populate(pud_t *pud, unsigned long addr,
     114                 :            :                                 unsigned long end)
     115                 :            : {
     116         [ +  - ]:         52 :         pmd_t *pmd = pmd_offset(pud, addr);
     117                 :      18317 :         unsigned long next;
     118                 :            : 
     119                 :      18317 :         do {
     120         [ +  + ]:      18317 :                 next = pmd_addr_end(addr, end);
     121                 :            : 
     122   [ +  +  +  + ]:      18317 :                 if (IS_ALIGNED(addr, PMD_SIZE) && end - addr >= PMD_SIZE) {
     123                 :      18291 :                         pmd_populate_kernel(&init_mm, pmd,
     124         [ +  - ]:      18291 :                                         lm_alias(kasan_early_shadow_pte));
     125                 :      18291 :                         continue;
     126                 :            :                 }
     127                 :            : 
     128         [ +  + ]:         26 :                 if (pmd_none(*pmd)) {
     129                 :         13 :                         pte_t *p;
     130                 :            : 
     131         [ -  + ]:         13 :                         if (slab_is_available())
     132                 :          0 :                                 p = pte_alloc_one_kernel(&init_mm);
     133                 :            :                         else
     134                 :         13 :                                 p = early_alloc(PAGE_SIZE, NUMA_NO_NODE);
     135         [ +  - ]:         13 :                         if (!p)
     136                 :            :                                 return -ENOMEM;
     137                 :            : 
     138         [ +  - ]:         13 :                         pmd_populate_kernel(&init_mm, pmd, p);
     139                 :            :                 }
     140                 :         26 :                 zero_pte_populate(pmd, addr, next);
     141         [ +  + ]:      18317 :         } while (pmd++, addr = next, addr != end);
     142                 :            : 
     143                 :            :         return 0;
     144                 :            : }
     145                 :            : 
     146                 :        104 : static int __ref zero_pud_populate(p4d_t *p4d, unsigned long addr,
     147                 :            :                                 unsigned long end)
     148                 :            : {
     149                 :        104 :         pud_t *pud = pud_offset(p4d, addr);
     150                 :      19981 :         unsigned long next;
     151                 :            : 
     152                 :      19981 :         do {
     153         [ +  + ]:      19981 :                 next = pud_addr_end(addr, end);
     154   [ +  +  +  + ]:      19981 :                 if (IS_ALIGNED(addr, PUD_SIZE) && end - addr >= PUD_SIZE) {
     155                 :      19929 :                         pmd_t *pmd;
     156                 :            : 
     157                 :      19929 :                         pud_populate(&init_mm, pud,
     158         [ +  - ]:      19929 :                                         lm_alias(kasan_early_shadow_pmd));
     159         [ +  - ]:      19929 :                         pmd = pmd_offset(pud, addr);
     160                 :      19929 :                         pmd_populate_kernel(&init_mm, pmd,
     161         [ +  - ]:      19929 :                                         lm_alias(kasan_early_shadow_pte));
     162                 :      19929 :                         continue;
     163                 :            :                 }
     164                 :            : 
     165         [ +  + ]:         52 :                 if (pud_none(*pud)) {
     166                 :         26 :                         pmd_t *p;
     167                 :            : 
     168         [ -  + ]:         26 :                         if (slab_is_available()) {
     169                 :          0 :                                 p = pmd_alloc(&init_mm, pud, addr);
     170         [ #  # ]:          0 :                                 if (!p)
     171                 :            :                                         return -ENOMEM;
     172                 :            :                         } else {
     173                 :         26 :                                 pud_populate(&init_mm, pud,
     174                 :         26 :                                         early_alloc(PAGE_SIZE, NUMA_NO_NODE));
     175                 :            :                         }
     176                 :            :                 }
     177                 :         52 :                 zero_pmd_populate(pud, addr, next);
     178         [ +  + ]:      19981 :         } while (pud++, addr = next, addr != end);
     179                 :            : 
     180                 :            :         return 0;
     181                 :            : }
     182                 :            : 
     183                 :        104 : static int __ref zero_p4d_populate(pgd_t *pgd, unsigned long addr,
     184                 :            :                                 unsigned long end)
     185                 :            : {
     186                 :        104 :         p4d_t *p4d = p4d_offset(pgd, addr);
     187                 :        104 :         unsigned long next;
     188                 :            : 
     189                 :        104 :         do {
     190         [ -  + ]:        104 :                 next = p4d_addr_end(addr, end);
     191   [ +  +  -  + ]:        104 :                 if (IS_ALIGNED(addr, P4D_SIZE) && end - addr >= P4D_SIZE) {
     192                 :          0 :                         pud_t *pud;
     193                 :          0 :                         pmd_t *pmd;
     194                 :            : 
     195                 :          0 :                         p4d_populate(&init_mm, p4d,
     196                 :          0 :                                         lm_alias(kasan_early_shadow_pud));
     197         [ #  # ]:          0 :                         pud = pud_offset(p4d, addr);
     198                 :          0 :                         pud_populate(&init_mm, pud,
     199         [ #  # ]:          0 :                                         lm_alias(kasan_early_shadow_pmd));
     200         [ #  # ]:          0 :                         pmd = pmd_offset(pud, addr);
     201                 :          0 :                         pmd_populate_kernel(&init_mm, pmd,
     202         [ #  # ]:          0 :                                         lm_alias(kasan_early_shadow_pte));
     203                 :          0 :                         continue;
     204                 :            :                 }
     205                 :            : 
     206         [ +  + ]:        104 :                 if (p4d_none(*p4d)) {
     207                 :         52 :                         pud_t *p;
     208                 :            : 
     209         [ -  + ]:         52 :                         if (slab_is_available()) {
     210                 :          0 :                                 p = pud_alloc(&init_mm, p4d, addr);
     211         [ #  # ]:          0 :                                 if (!p)
     212                 :            :                                         return -ENOMEM;
     213                 :            :                         } else {
     214                 :         52 :                                 p4d_populate(&init_mm, p4d,
     215                 :         52 :                                         early_alloc(PAGE_SIZE, NUMA_NO_NODE));
     216                 :            :                         }
     217                 :            :                 }
     218                 :        104 :                 zero_pud_populate(p4d, addr, next);
     219         [ -  + ]:        104 :         } while (p4d++, addr = next, addr != end);
     220                 :            : 
     221                 :            :         return 0;
     222                 :            : }
     223                 :            : 
     224                 :            : /**
     225                 :            :  * kasan_populate_early_shadow - populate shadow memory region with
     226                 :            :  *                               kasan_early_shadow_page
     227                 :            :  * @shadow_start - start of the memory range to populate
     228                 :            :  * @shadow_end   - end of the memory range to populate
     229                 :            :  */
     230                 :         78 : int __ref kasan_populate_early_shadow(const void *shadow_start,
     231                 :            :                                         const void *shadow_end)
     232                 :            : {
     233                 :         78 :         unsigned long addr = (unsigned long)shadow_start;
     234                 :         78 :         unsigned long end = (unsigned long)shadow_end;
     235                 :         78 :         pgd_t *pgd = pgd_offset_k(addr);
     236                 :        273 :         unsigned long next;
     237                 :            : 
     238                 :        273 :         do {
     239         [ +  + ]:        273 :                 next = pgd_addr_end(addr, end);
     240                 :            : 
     241   [ +  +  +  + ]:        273 :                 if (IS_ALIGNED(addr, PGDIR_SIZE) && end - addr >= PGDIR_SIZE) {
     242                 :        169 :                         p4d_t *p4d;
     243                 :        169 :                         pud_t *pud;
     244                 :        169 :                         pmd_t *pmd;
     245                 :            : 
     246                 :            :                         /*
     247                 :            :                          * kasan_early_shadow_pud should be populated with pmds
     248                 :            :                          * at this moment.
     249                 :            :                          * [pud,pmd]_populate*() below needed only for
     250                 :            :                          * 3,2 - level page tables where we don't have
     251                 :            :                          * puds,pmds, so pgd_populate(), pud_populate()
     252                 :            :                          * is noops.
     253                 :            :                          *
     254                 :            :                          * The ifndef is required to avoid build breakage.
     255                 :            :                          *
     256                 :            :                          * With 5level-fixup.h, pgd_populate() is not nop and
     257                 :            :                          * we reference kasan_early_shadow_p4d. It's not defined
     258                 :            :                          * unless 5-level paging enabled.
     259                 :            :                          *
     260                 :            :                          * The ifndef can be dropped once all KASAN-enabled
     261                 :            :                          * architectures will switch to pgtable-nop4d.h.
     262                 :            :                          */
     263                 :            : #ifndef __ARCH_HAS_5LEVEL_HACK
     264                 :        169 :                         pgd_populate(&init_mm, pgd,
     265                 :        169 :                                         lm_alias(kasan_early_shadow_p4d));
     266                 :            : #endif
     267                 :        169 :                         p4d = p4d_offset(pgd, addr);
     268                 :        169 :                         p4d_populate(&init_mm, p4d,
     269                 :        169 :                                         lm_alias(kasan_early_shadow_pud));
     270         [ +  - ]:        169 :                         pud = pud_offset(p4d, addr);
     271                 :        169 :                         pud_populate(&init_mm, pud,
     272         [ +  - ]:        169 :                                         lm_alias(kasan_early_shadow_pmd));
     273         [ +  - ]:        169 :                         pmd = pmd_offset(pud, addr);
     274                 :        169 :                         pmd_populate_kernel(&init_mm, pmd,
     275         [ +  - ]:        169 :                                         lm_alias(kasan_early_shadow_pte));
     276                 :        169 :                         continue;
     277                 :            :                 }
     278                 :            : 
     279         [ -  + ]:        104 :                 if (pgd_none(*pgd)) {
     280                 :          0 :                         p4d_t *p;
     281                 :            : 
     282         [ #  # ]:          0 :                         if (slab_is_available()) {
     283                 :          0 :                                 p = p4d_alloc(&init_mm, pgd, addr);
     284         [ #  # ]:          0 :                                 if (!p)
     285                 :            :                                         return -ENOMEM;
     286                 :            :                         } else {
     287                 :          0 :                                 pgd_populate(&init_mm, pgd,
     288                 :          0 :                                         early_alloc(PAGE_SIZE, NUMA_NO_NODE));
     289                 :            :                         }
     290                 :            :                 }
     291                 :        104 :                 zero_p4d_populate(pgd, addr, next);
     292         [ +  + ]:        273 :         } while (pgd++, addr = next, addr != end);
     293                 :            : 
     294                 :            :         return 0;
     295                 :            : }
     296                 :            : 
     297                 :          0 : static void kasan_free_pte(pte_t *pte_start, pmd_t *pmd)
     298                 :            : {
     299                 :          0 :         pte_t *pte;
     300                 :          0 :         int i;
     301                 :            : 
     302         [ #  # ]:          0 :         for (i = 0; i < PTRS_PER_PTE; i++) {
     303                 :          0 :                 pte = pte_start + i;
     304         [ #  # ]:          0 :                 if (!pte_none(*pte))
     305                 :            :                         return;
     306                 :            :         }
     307                 :            : 
     308         [ #  # ]:          0 :         pte_free_kernel(&init_mm, (pte_t *)page_to_virt(pmd_page(*pmd)));
     309                 :          0 :         pmd_clear(pmd);
     310                 :            : }
     311                 :            : 
     312                 :          0 : static void kasan_free_pmd(pmd_t *pmd_start, pud_t *pud)
     313                 :            : {
     314                 :          0 :         pmd_t *pmd;
     315                 :          0 :         int i;
     316                 :            : 
     317         [ #  # ]:          0 :         for (i = 0; i < PTRS_PER_PMD; i++) {
     318                 :          0 :                 pmd = pmd_start + i;
     319         [ #  # ]:          0 :                 if (!pmd_none(*pmd))
     320                 :            :                         return;
     321                 :            :         }
     322                 :            : 
     323         [ #  # ]:          0 :         pmd_free(&init_mm, (pmd_t *)page_to_virt(pud_page(*pud)));
     324                 :          0 :         pud_clear(pud);
     325                 :            : }
     326                 :            : 
     327                 :          0 : static void kasan_free_pud(pud_t *pud_start, p4d_t *p4d)
     328                 :            : {
     329                 :          0 :         pud_t *pud;
     330                 :          0 :         int i;
     331                 :            : 
     332         [ #  # ]:          0 :         for (i = 0; i < PTRS_PER_PUD; i++) {
     333                 :          0 :                 pud = pud_start + i;
     334         [ #  # ]:          0 :                 if (!pud_none(*pud))
     335                 :            :                         return;
     336                 :            :         }
     337                 :            : 
     338                 :          0 :         pud_free(&init_mm, (pud_t *)page_to_virt(p4d_page(*p4d)));
     339                 :          0 :         p4d_clear(p4d);
     340                 :            : }
     341                 :            : 
     342                 :          0 : static void kasan_free_p4d(p4d_t *p4d_start, pgd_t *pgd)
     343                 :            : {
     344                 :          0 :         p4d_t *p4d;
     345                 :          0 :         int i;
     346                 :            : 
     347         [ #  # ]:          0 :         for (i = 0; i < PTRS_PER_P4D; i++) {
     348                 :          0 :                 p4d = p4d_start + i;
     349         [ #  # ]:          0 :                 if (!p4d_none(*p4d))
     350                 :            :                         return;
     351                 :            :         }
     352                 :            : 
     353                 :          0 :         p4d_free(&init_mm, (p4d_t *)page_to_virt(pgd_page(*pgd)));
     354      [ #  #  # ]:          0 :         pgd_clear(pgd);
     355                 :            : }
     356                 :            : 
     357                 :          0 : static void kasan_remove_pte_table(pte_t *pte, unsigned long addr,
     358                 :            :                                 unsigned long end)
     359                 :            : {
     360                 :          0 :         unsigned long next;
     361                 :            : 
     362         [ #  # ]:          0 :         for (; addr < end; addr = next, pte++) {
     363                 :          0 :                 next = (addr + PAGE_SIZE) & PAGE_MASK;
     364                 :          0 :                 if (next > end)
     365                 :            :                         next = end;
     366                 :            : 
     367         [ #  # ]:          0 :                 if (!pte_present(*pte))
     368                 :          0 :                         continue;
     369                 :            : 
     370   [ #  #  #  # ]:          0 :                 if (WARN_ON(!kasan_early_shadow_page_entry(*pte)))
     371                 :          0 :                         continue;
     372                 :          0 :                 pte_clear(&init_mm, addr, pte);
     373                 :            :         }
     374                 :          0 : }
     375                 :            : 
     376                 :          0 : static void kasan_remove_pmd_table(pmd_t *pmd, unsigned long addr,
     377                 :            :                                 unsigned long end)
     378                 :            : {
     379                 :          0 :         unsigned long next;
     380                 :            : 
     381         [ #  # ]:          0 :         for (; addr < end; addr = next, pmd++) {
     382                 :          0 :                 pte_t *pte;
     383                 :            : 
     384         [ #  # ]:          0 :                 next = pmd_addr_end(addr, end);
     385                 :            : 
     386   [ #  #  #  # ]:          0 :                 if (!pmd_present(*pmd))
     387                 :          0 :                         continue;
     388                 :            : 
     389         [ #  # ]:          0 :                 if (kasan_pte_table(*pmd)) {
     390         [ #  # ]:          0 :                         if (IS_ALIGNED(addr, PMD_SIZE) &&
     391         [ #  # ]:          0 :                             IS_ALIGNED(next, PMD_SIZE))
     392                 :          0 :                                 pmd_clear(pmd);
     393                 :          0 :                         continue;
     394                 :            :                 }
     395                 :          0 :                 pte = pte_offset_kernel(pmd, addr);
     396                 :          0 :                 kasan_remove_pte_table(pte, addr, next);
     397         [ #  # ]:          0 :                 kasan_free_pte(pte_offset_kernel(pmd, 0), pmd);
     398                 :            :         }
     399                 :          0 : }
     400                 :            : 
     401                 :          0 : static void kasan_remove_pud_table(pud_t *pud, unsigned long addr,
     402                 :            :                                 unsigned long end)
     403                 :            : {
     404                 :          0 :         unsigned long next;
     405                 :            : 
     406         [ #  # ]:          0 :         for (; addr < end; addr = next, pud++) {
     407                 :          0 :                 pmd_t *pmd, *pmd_base;
     408                 :            : 
     409         [ #  # ]:          0 :                 next = pud_addr_end(addr, end);
     410                 :            : 
     411   [ #  #  #  # ]:          0 :                 if (!pud_present(*pud))
     412                 :          0 :                         continue;
     413                 :            : 
     414         [ #  # ]:          0 :                 if (kasan_pmd_table(*pud)) {
     415         [ #  # ]:          0 :                         if (IS_ALIGNED(addr, PUD_SIZE) &&
     416         [ #  # ]:          0 :                             IS_ALIGNED(next, PUD_SIZE))
     417                 :          0 :                                 pud_clear(pud);
     418                 :          0 :                         continue;
     419                 :            :                 }
     420                 :          0 :                 pmd = pmd_offset(pud, addr);
     421                 :          0 :                 pmd_base = pmd_offset(pud, 0);
     422                 :          0 :                 kasan_remove_pmd_table(pmd, addr, next);
     423                 :          0 :                 kasan_free_pmd(pmd_base, pud);
     424                 :            :         }
     425                 :          0 : }
     426                 :            : 
     427                 :          0 : static void kasan_remove_p4d_table(p4d_t *p4d, unsigned long addr,
     428                 :            :                                 unsigned long end)
     429                 :            : {
     430                 :          0 :         unsigned long next;
     431                 :            : 
     432         [ #  # ]:          0 :         for (; addr < end; addr = next, p4d++) {
     433                 :          0 :                 pud_t *pud;
     434                 :            : 
     435         [ #  # ]:          0 :                 next = p4d_addr_end(addr, end);
     436                 :            : 
     437         [ #  # ]:          0 :                 if (!p4d_present(*p4d))
     438                 :          0 :                         continue;
     439                 :            : 
     440         [ #  # ]:          0 :                 if (kasan_pud_table(*p4d)) {
     441         [ #  # ]:          0 :                         if (IS_ALIGNED(addr, P4D_SIZE) &&
     442         [ #  # ]:          0 :                             IS_ALIGNED(next, P4D_SIZE))
     443                 :          0 :                                 p4d_clear(p4d);
     444                 :          0 :                         continue;
     445                 :            :                 }
     446                 :          0 :                 pud = pud_offset(p4d, addr);
     447                 :          0 :                 kasan_remove_pud_table(pud, addr, next);
     448                 :          0 :                 kasan_free_pud(pud_offset(p4d, 0), p4d);
     449                 :            :         }
     450                 :          0 : }
     451                 :            : 
     452                 :          0 : void kasan_remove_zero_shadow(void *start, unsigned long size)
     453                 :            : {
     454                 :          0 :         unsigned long addr, end, next;
     455                 :          0 :         pgd_t *pgd;
     456                 :            : 
     457         [ #  # ]:          0 :         addr = (unsigned long)kasan_mem_to_shadow(start);
     458                 :          0 :         end = addr + (size >> KASAN_SHADOW_SCALE_SHIFT);
     459                 :            : 
     460   [ #  #  #  # ]:          0 :         if (WARN_ON((unsigned long)start %
     461                 :          0 :                         (KASAN_SHADOW_SCALE_SIZE * PAGE_SIZE)) ||
     462   [ #  #  #  # ]:          0 :             WARN_ON(size % (KASAN_SHADOW_SCALE_SIZE * PAGE_SIZE)))
     463                 :            :                 return;
     464                 :            : 
     465         [ #  # ]:          0 :         for (; addr < end; addr = next) {
     466                 :          0 :                 p4d_t *p4d;
     467                 :            : 
     468         [ #  # ]:          0 :                 next = pgd_addr_end(addr, end);
     469                 :            : 
     470                 :          0 :                 pgd = pgd_offset_k(addr);
     471         [ #  # ]:          0 :                 if (!pgd_present(*pgd))
     472                 :          0 :                         continue;
     473                 :            : 
     474         [ #  # ]:          0 :                 if (kasan_p4d_table(*pgd)) {
     475         [ #  # ]:          0 :                         if (IS_ALIGNED(addr, PGDIR_SIZE) &&
     476         [ #  # ]:          0 :                             IS_ALIGNED(next, PGDIR_SIZE))
     477      [ #  #  # ]:          0 :                                 pgd_clear(pgd);
     478                 :          0 :                         continue;
     479                 :            :                 }
     480                 :            : 
     481                 :          0 :                 p4d = p4d_offset(pgd, addr);
     482                 :          0 :                 kasan_remove_p4d_table(p4d, addr, next);
     483                 :          0 :                 kasan_free_p4d(p4d_offset(pgd, 0), pgd);
     484                 :            :         }
     485                 :            : }
     486                 :            : 
     487                 :          0 : int kasan_add_zero_shadow(void *start, unsigned long size)
     488                 :            : {
     489                 :          0 :         int ret;
     490                 :          0 :         void *shadow_start, *shadow_end;
     491                 :            : 
     492         [ #  # ]:          0 :         shadow_start = kasan_mem_to_shadow(start);
     493                 :          0 :         shadow_end = shadow_start + (size >> KASAN_SHADOW_SCALE_SHIFT);
     494                 :            : 
     495   [ #  #  #  # ]:          0 :         if (WARN_ON((unsigned long)start %
     496                 :          0 :                         (KASAN_SHADOW_SCALE_SIZE * PAGE_SIZE)) ||
     497   [ #  #  #  # ]:          0 :             WARN_ON(size % (KASAN_SHADOW_SCALE_SIZE * PAGE_SIZE)))
     498                 :            :                 return -EINVAL;
     499                 :            : 
     500                 :          0 :         ret = kasan_populate_early_shadow(shadow_start, shadow_end);
     501         [ #  # ]:          0 :         if (ret)
     502                 :          0 :                 kasan_remove_zero_shadow(shadow_start,
     503                 :            :                                         size >> KASAN_SHADOW_SCALE_SHIFT);
     504                 :            :         return ret;
     505                 :            : }

Generated by: LCOV version 1.14