LCOV - code coverage report
Current view: top level - arch/x86/mm - pgtable.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 129 217 59.4 %
Date: 2022-03-28 15:32:58 Functions: 18 29 62.1 %
Branches: 25 104 24.0 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : #include <linux/mm.h>
       3                 :            : #include <linux/gfp.h>
       4                 :            : #include <linux/hugetlb.h>
       5                 :            : #include <asm/pgalloc.h>
       6                 :            : #include <asm/pgtable.h>
       7                 :            : #include <asm/tlb.h>
       8                 :            : #include <asm/fixmap.h>
       9                 :            : #include <asm/mtrr.h>
      10                 :            : 
      11                 :            : #ifdef CONFIG_DYNAMIC_PHYSICAL_MASK
      12                 :            : phys_addr_t physical_mask __ro_after_init = (1ULL << __PHYSICAL_MASK_SHIFT) - 1;
      13                 :            : EXPORT_SYMBOL(physical_mask);
      14                 :            : #endif
      15                 :            : 
      16                 :            : #ifdef CONFIG_HIGHPTE
      17                 :            : #define PGTABLE_HIGHMEM __GFP_HIGHMEM
      18                 :            : #else
      19                 :            : #define PGTABLE_HIGHMEM 0
      20                 :            : #endif
      21                 :            : 
      22                 :            : gfp_t __userpte_alloc_gfp = GFP_PGTABLE_USER | PGTABLE_HIGHMEM;
      23                 :            : 
      24                 :    1964169 : pgtable_t pte_alloc_one(struct mm_struct *mm)
      25                 :            : {
      26                 :    1964169 :         return __pte_alloc_one(mm, __userpte_alloc_gfp);
      27                 :            : }
      28                 :            : 
      29                 :          0 : static int __init setup_userpte(char *arg)
      30                 :            : {
      31         [ #  # ]:          0 :         if (!arg)
      32                 :            :                 return -EINVAL;
      33                 :            : 
      34                 :            :         /*
      35                 :            :          * "userpte=nohigh" disables allocation of user pagetables in
      36                 :            :          * high memory.
      37                 :            :          */
      38         [ #  # ]:          0 :         if (strcmp(arg, "nohigh") == 0)
      39                 :          0 :                 __userpte_alloc_gfp &= ~__GFP_HIGHMEM;
      40                 :            :         else
      41                 :            :                 return -EINVAL;
      42                 :          0 :         return 0;
      43                 :            : }
      44                 :            : early_param("userpte", setup_userpte);
      45                 :            : 
      46                 :    1955727 : void ___pte_free_tlb(struct mmu_gather *tlb, struct page *pte)
      47                 :            : {
      48                 :    1955727 :         pgtable_pte_page_dtor(pte);
      49                 :    1955727 :         paravirt_release_pte(page_to_pfn(pte));
      50                 :    1955727 :         paravirt_tlb_remove_table(tlb, pte);
      51                 :    1955727 : }
      52                 :            : 
      53                 :            : #if CONFIG_PGTABLE_LEVELS > 2
      54                 :    1033115 : void ___pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd)
      55                 :            : {
      56         [ +  - ]:    1033115 :         struct page *page = virt_to_page(pmd);
      57                 :    1033115 :         paravirt_release_pmd(__pa(pmd) >> PAGE_SHIFT);
      58                 :            :         /*
      59                 :            :          * NOTE! For PAE, any changes to the top page-directory-pointer-table
      60                 :            :          * entries need a full cr3 reload to flush.
      61                 :            :          */
      62                 :            : #ifdef CONFIG_X86_PAE
      63                 :            :         tlb->need_flush_all = 1;
      64                 :            : #endif
      65                 :    1033115 :         pgtable_pmd_page_dtor(page);
      66                 :    1033115 :         paravirt_tlb_remove_table(tlb, page);
      67                 :    1033115 : }
      68                 :            : 
      69                 :            : #if CONFIG_PGTABLE_LEVELS > 3
      70                 :     743142 : void ___pud_free_tlb(struct mmu_gather *tlb, pud_t *pud)
      71                 :            : {
      72         [ +  - ]:    1486284 :         paravirt_release_pud(__pa(pud) >> PAGE_SHIFT);
      73                 :     743142 :         paravirt_tlb_remove_table(tlb, virt_to_page(pud));
      74                 :     743142 : }
      75                 :            : 
      76                 :            : #if CONFIG_PGTABLE_LEVELS > 4
      77                 :          0 : void ___p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d)
      78                 :            : {
      79         [ #  # ]:          0 :         paravirt_release_p4d(__pa(p4d) >> PAGE_SHIFT);
      80                 :          0 :         paravirt_tlb_remove_table(tlb, virt_to_page(p4d));
      81                 :          0 : }
      82                 :            : #endif  /* CONFIG_PGTABLE_LEVELS > 4 */
      83                 :            : #endif  /* CONFIG_PGTABLE_LEVELS > 3 */
      84                 :            : #endif  /* CONFIG_PGTABLE_LEVELS > 2 */
      85                 :            : 
      86                 :     297305 : static inline void pgd_list_add(pgd_t *pgd)
      87                 :            : {
      88                 :     297305 :         struct page *page = virt_to_page(pgd);
      89                 :            : 
      90                 :     297305 :         list_add(&page->lru, &pgd_list);
      91                 :            : }
      92                 :            : 
      93                 :     296642 : static inline void pgd_list_del(pgd_t *pgd)
      94                 :            : {
      95         [ +  - ]:     296642 :         struct page *page = virt_to_page(pgd);
      96                 :            : 
      97                 :     296642 :         list_del(&page->lru);
      98                 :     296642 : }
      99                 :            : 
     100                 :            : #define UNSHARED_PTRS_PER_PGD                           \
     101                 :            :         (SHARED_KERNEL_PMD ? KERNEL_PGD_BOUNDARY : PTRS_PER_PGD)
     102                 :            : #define MAX_UNSHARED_PTRS_PER_PGD                       \
     103                 :            :         max_t(size_t, KERNEL_PGD_BOUNDARY, PTRS_PER_PGD)
     104                 :            : 
     105                 :            : 
     106                 :     297305 : static void pgd_set_mm(pgd_t *pgd, struct mm_struct *mm)
     107                 :            : {
     108                 :     594610 :         virt_to_page(pgd)->pt_mm = mm;
     109                 :            : }
     110                 :            : 
     111                 :         56 : struct mm_struct *pgd_page_get_mm(struct page *page)
     112                 :            : {
     113                 :         56 :         return page->pt_mm;
     114                 :            : }
     115                 :            : 
     116                 :     297305 : static void pgd_ctor(struct mm_struct *mm, pgd_t *pgd)
     117                 :            : {
     118                 :            :         /* If the pgd points to a shared pagetable level (either the
     119                 :            :            ptes in non-PAE, or shared PMD in PAE), then just copy the
     120                 :            :            references from swapper_pg_dir. */
     121                 :     297305 :         if (CONFIG_PGTABLE_LEVELS == 2 ||
     122                 :            :             (CONFIG_PGTABLE_LEVELS == 3 && SHARED_KERNEL_PMD) ||
     123                 :            :             CONFIG_PGTABLE_LEVELS >= 4) {
     124                 :     297305 :                 clone_pgd_range(pgd + KERNEL_PGD_BOUNDARY,
     125                 :     297305 :                                 swapper_pg_dir + KERNEL_PGD_BOUNDARY,
     126                 :     297305 :                                 KERNEL_PGD_PTRS);
     127                 :            :         }
     128                 :            : 
     129                 :            :         /* list required to sync kernel mapping updates */
     130                 :     297305 :         if (!SHARED_KERNEL_PMD) {
     131         [ +  - ]:     297305 :                 pgd_set_mm(pgd, mm);
     132                 :     297305 :                 pgd_list_add(pgd);
     133                 :            :         }
     134                 :     297305 : }
     135                 :            : 
     136                 :     296642 : static void pgd_dtor(pgd_t *pgd)
     137                 :            : {
     138                 :     296642 :         if (SHARED_KERNEL_PMD)
     139                 :            :                 return;
     140                 :            : 
     141                 :     296642 :         spin_lock(&pgd_lock);
     142                 :     296642 :         pgd_list_del(pgd);
     143                 :     296642 :         spin_unlock(&pgd_lock);
     144                 :            : }
     145                 :            : 
     146                 :            : /*
     147                 :            :  * List of all pgd's needed for non-PAE so it can invalidate entries
     148                 :            :  * in both cached and uncached pgd's; not needed for PAE since the
     149                 :            :  * kernel pmd is shared. If PAE were not to share the pmd a similar
     150                 :            :  * tactic would be needed. This is essentially codepath-based locking
     151                 :            :  * against pageattr.c; it is the unique case in which a valid change
     152                 :            :  * of kernel pagetables can't be lazily synchronized by vmalloc faults.
     153                 :            :  * vmalloc faults work because attached pagetables are never freed.
     154                 :            :  * -- nyc
     155                 :            :  */
     156                 :            : 
     157                 :            : #ifdef CONFIG_X86_PAE
     158                 :            : /*
     159                 :            :  * In PAE mode, we need to do a cr3 reload (=tlb flush) when
     160                 :            :  * updating the top-level pagetable entries to guarantee the
     161                 :            :  * processor notices the update.  Since this is expensive, and
     162                 :            :  * all 4 top-level entries are used almost immediately in a
     163                 :            :  * new process's life, we just pre-populate them here.
     164                 :            :  *
     165                 :            :  * Also, if we're in a paravirt environment where the kernel pmd is
     166                 :            :  * not shared between pagetables (!SHARED_KERNEL_PMDS), we allocate
     167                 :            :  * and initialize the kernel pmds here.
     168                 :            :  */
     169                 :            : #define PREALLOCATED_PMDS       UNSHARED_PTRS_PER_PGD
     170                 :            : #define MAX_PREALLOCATED_PMDS   MAX_UNSHARED_PTRS_PER_PGD
     171                 :            : 
     172                 :            : /*
     173                 :            :  * We allocate separate PMDs for the kernel part of the user page-table
     174                 :            :  * when PTI is enabled. We need them to map the per-process LDT into the
     175                 :            :  * user-space page-table.
     176                 :            :  */
     177                 :            : #define PREALLOCATED_USER_PMDS   (boot_cpu_has(X86_FEATURE_PTI) ? \
     178                 :            :                                         KERNEL_PGD_PTRS : 0)
     179                 :            : #define MAX_PREALLOCATED_USER_PMDS KERNEL_PGD_PTRS
     180                 :            : 
     181                 :            : void pud_populate(struct mm_struct *mm, pud_t *pudp, pmd_t *pmd)
     182                 :            : {
     183                 :            :         paravirt_alloc_pmd(mm, __pa(pmd) >> PAGE_SHIFT);
     184                 :            : 
     185                 :            :         /* Note: almost everything apart from _PAGE_PRESENT is
     186                 :            :            reserved at the pmd (PDPT) level. */
     187                 :            :         set_pud(pudp, __pud(__pa(pmd) | _PAGE_PRESENT));
     188                 :            : 
     189                 :            :         /*
     190                 :            :          * According to Intel App note "TLBs, Paging-Structure Caches,
     191                 :            :          * and Their Invalidation", April 2007, document 317080-001,
     192                 :            :          * section 8.1: in PAE mode we explicitly have to flush the
     193                 :            :          * TLB via cr3 if the top-level pgd is changed...
     194                 :            :          */
     195                 :            :         flush_tlb_mm(mm);
     196                 :            : }
     197                 :            : #else  /* !CONFIG_X86_PAE */
     198                 :            : 
     199                 :            : /* No need to prepopulate any pagetable entries in non-PAE modes. */
     200                 :            : #define PREALLOCATED_PMDS       0
     201                 :            : #define MAX_PREALLOCATED_PMDS   0
     202                 :            : #define PREALLOCATED_USER_PMDS   0
     203                 :            : #define MAX_PREALLOCATED_USER_PMDS 0
     204                 :            : #endif  /* CONFIG_X86_PAE */
     205                 :            : 
     206                 :          0 : static void free_pmds(struct mm_struct *mm, pmd_t *pmds[], int count)
     207                 :            : {
     208                 :          0 :         int i;
     209                 :            : 
     210         [ #  # ]:          0 :         for (i = 0; i < count; i++)
     211         [ #  # ]:          0 :                 if (pmds[i]) {
     212                 :          0 :                         pgtable_pmd_page_dtor(virt_to_page(pmds[i]));
     213                 :          0 :                         free_page((unsigned long)pmds[i]);
     214                 :          0 :                         mm_dec_nr_pmds(mm);
     215                 :            :                 }
     216                 :          0 : }
     217                 :            : 
     218                 :     594610 : static int preallocate_pmds(struct mm_struct *mm, pmd_t *pmds[], int count)
     219                 :            : {
     220                 :     594610 :         int i;
     221                 :     594610 :         bool failed = false;
     222                 :     594610 :         gfp_t gfp = GFP_PGTABLE_USER;
     223                 :            : 
     224         [ -  + ]:     594610 :         if (mm == &init_mm)
     225                 :          0 :                 gfp &= ~__GFP_ACCOUNT;
     226                 :            : 
     227         [ -  + ]:     594610 :         for (i = 0; i < count; i++) {
     228                 :          0 :                 pmd_t *pmd = (pmd_t *)__get_free_page(gfp);
     229         [ #  # ]:          0 :                 if (!pmd)
     230                 :          0 :                         failed = true;
     231         [ #  # ]:          0 :                 if (pmd && !pgtable_pmd_page_ctor(virt_to_page(pmd))) {
     232                 :            :                         free_page((unsigned long)pmd);
     233                 :            :                         pmd = NULL;
     234                 :            :                         failed = true;
     235                 :            :                 }
     236         [ #  # ]:          0 :                 if (pmd)
     237                 :          0 :                         mm_inc_nr_pmds(mm);
     238                 :          0 :                 pmds[i] = pmd;
     239                 :            :         }
     240                 :            : 
     241         [ -  + ]:     594610 :         if (failed) {
     242                 :          0 :                 free_pmds(mm, pmds, count);
     243                 :          0 :                 return -ENOMEM;
     244                 :            :         }
     245                 :            : 
     246                 :            :         return 0;
     247                 :            : }
     248                 :            : 
     249                 :            : /*
     250                 :            :  * Mop up any pmd pages which may still be attached to the pgd.
     251                 :            :  * Normally they will be freed by munmap/exit_mmap, but any pmd we
     252                 :            :  * preallocate which never got a corresponding vma will need to be
     253                 :            :  * freed manually.
     254                 :            :  */
     255                 :            : static void mop_up_one_pmd(struct mm_struct *mm, pgd_t *pgdp)
     256                 :            : {
     257                 :            :         pgd_t pgd = *pgdp;
     258                 :            : 
     259                 :            :         if (pgd_val(pgd) != 0) {
     260                 :            :                 pmd_t *pmd = (pmd_t *)pgd_page_vaddr(pgd);
     261                 :            : 
     262                 :            :                 pgd_clear(pgdp);
     263                 :            : 
     264                 :            :                 paravirt_release_pmd(pgd_val(pgd) >> PAGE_SHIFT);
     265                 :            :                 pmd_free(mm, pmd);
     266                 :            :                 mm_dec_nr_pmds(mm);
     267                 :            :         }
     268                 :            : }
     269                 :            : 
     270                 :     296642 : static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp)
     271                 :            : {
     272                 :     296642 :         int i;
     273                 :            : 
     274                 :     296642 :         for (i = 0; i < PREALLOCATED_PMDS; i++)
     275                 :            :                 mop_up_one_pmd(mm, &pgdp[i]);
     276                 :            : 
     277                 :            : #ifdef CONFIG_PAGE_TABLE_ISOLATION
     278                 :            : 
     279                 :     296642 :         if (!boot_cpu_has(X86_FEATURE_PTI))
     280                 :            :                 return;
     281                 :            : 
     282                 :     296642 :         pgdp = kernel_to_user_pgdp(pgdp);
     283                 :            : 
     284                 :     296642 :         for (i = 0; i < PREALLOCATED_USER_PMDS; i++)
     285                 :            :                 mop_up_one_pmd(mm, &pgdp[i + KERNEL_PGD_BOUNDARY]);
     286                 :            : #endif
     287                 :            : }
     288                 :            : 
     289                 :     297305 : static void pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmds[])
     290                 :            : {
     291                 :     297305 :         p4d_t *p4d;
     292                 :     297305 :         pud_t *pud;
     293                 :     297305 :         int i;
     294                 :            : 
     295                 :     297305 :         if (PREALLOCATED_PMDS == 0) /* Work around gcc-3.4.x bug */
     296                 :     297305 :                 return;
     297                 :            : 
     298                 :            :         p4d = p4d_offset(pgd, 0);
     299                 :            :         pud = pud_offset(p4d, 0);
     300                 :            : 
     301                 :            :         for (i = 0; i < PREALLOCATED_PMDS; i++, pud++) {
     302                 :            :                 pmd_t *pmd = pmds[i];
     303                 :            : 
     304                 :            :                 if (i >= KERNEL_PGD_BOUNDARY)
     305                 :            :                         memcpy(pmd, (pmd_t *)pgd_page_vaddr(swapper_pg_dir[i]),
     306                 :            :                                sizeof(pmd_t) * PTRS_PER_PMD);
     307                 :            : 
     308                 :            :                 pud_populate(mm, pud, pmd);
     309                 :            :         }
     310                 :            : }
     311                 :            : 
     312                 :            : #ifdef CONFIG_PAGE_TABLE_ISOLATION
     313                 :     297305 : static void pgd_prepopulate_user_pmd(struct mm_struct *mm,
     314                 :            :                                      pgd_t *k_pgd, pmd_t *pmds[])
     315                 :            : {
     316                 :     297305 :         pgd_t *s_pgd = kernel_to_user_pgdp(swapper_pg_dir);
     317                 :     297305 :         pgd_t *u_pgd = kernel_to_user_pgdp(k_pgd);
     318                 :     297305 :         p4d_t *u_p4d;
     319                 :     297305 :         pud_t *u_pud;
     320                 :     297305 :         int i;
     321                 :            : 
     322                 :     297305 :         u_p4d = p4d_offset(u_pgd, 0);
     323                 :     297305 :         u_pud = pud_offset(u_p4d, 0);
     324                 :            : 
     325                 :     297305 :         s_pgd += KERNEL_PGD_BOUNDARY;
     326                 :     297305 :         u_pud += KERNEL_PGD_BOUNDARY;
     327                 :            : 
     328                 :     297305 :         for (i = 0; i < PREALLOCATED_USER_PMDS; i++, u_pud++, s_pgd++) {
     329                 :            :                 pmd_t *pmd = pmds[i];
     330                 :            : 
     331                 :            :                 memcpy(pmd, (pmd_t *)pgd_page_vaddr(*s_pgd),
     332                 :            :                        sizeof(pmd_t) * PTRS_PER_PMD);
     333                 :            : 
     334                 :            :                 pud_populate(mm, u_pud, pmd);
     335                 :            :         }
     336                 :            : 
     337                 :            : }
     338                 :            : #else
     339                 :            : static void pgd_prepopulate_user_pmd(struct mm_struct *mm,
     340                 :            :                                      pgd_t *k_pgd, pmd_t *pmds[])
     341                 :            : {
     342                 :            : }
     343                 :            : #endif
     344                 :            : /*
     345                 :            :  * Xen paravirt assumes pgd table should be in one page. 64 bit kernel also
     346                 :            :  * assumes that pgd should be in one page.
     347                 :            :  *
     348                 :            :  * But kernel with PAE paging that is not running as a Xen domain
     349                 :            :  * only needs to allocate 32 bytes for pgd instead of one page.
     350                 :            :  */
     351                 :            : #ifdef CONFIG_X86_PAE
     352                 :            : 
     353                 :            : #include <linux/slab.h>
     354                 :            : 
     355                 :            : #define PGD_SIZE        (PTRS_PER_PGD * sizeof(pgd_t))
     356                 :            : #define PGD_ALIGN       32
     357                 :            : 
     358                 :            : static struct kmem_cache *pgd_cache;
     359                 :            : 
     360                 :            : void __init pgtable_cache_init(void)
     361                 :            : {
     362                 :            :         /*
     363                 :            :          * When PAE kernel is running as a Xen domain, it does not use
     364                 :            :          * shared kernel pmd. And this requires a whole page for pgd.
     365                 :            :          */
     366                 :            :         if (!SHARED_KERNEL_PMD)
     367                 :            :                 return;
     368                 :            : 
     369                 :            :         /*
     370                 :            :          * when PAE kernel is not running as a Xen domain, it uses
     371                 :            :          * shared kernel pmd. Shared kernel pmd does not require a whole
     372                 :            :          * page for pgd. We are able to just allocate a 32-byte for pgd.
     373                 :            :          * During boot time, we create a 32-byte slab for pgd table allocation.
     374                 :            :          */
     375                 :            :         pgd_cache = kmem_cache_create("pgd_cache", PGD_SIZE, PGD_ALIGN,
     376                 :            :                                       SLAB_PANIC, NULL);
     377                 :            : }
     378                 :            : 
     379                 :            : static inline pgd_t *_pgd_alloc(void)
     380                 :            : {
     381                 :            :         /*
     382                 :            :          * If no SHARED_KERNEL_PMD, PAE kernel is running as a Xen domain.
     383                 :            :          * We allocate one page for pgd.
     384                 :            :          */
     385                 :            :         if (!SHARED_KERNEL_PMD)
     386                 :            :                 return (pgd_t *)__get_free_pages(GFP_PGTABLE_USER,
     387                 :            :                                                  PGD_ALLOCATION_ORDER);
     388                 :            : 
     389                 :            :         /*
     390                 :            :          * Now PAE kernel is not running as a Xen domain. We can allocate
     391                 :            :          * a 32-byte slab for pgd to save memory space.
     392                 :            :          */
     393                 :            :         return kmem_cache_alloc(pgd_cache, GFP_PGTABLE_USER);
     394                 :            : }
     395                 :            : 
     396                 :            : static inline void _pgd_free(pgd_t *pgd)
     397                 :            : {
     398                 :            :         if (!SHARED_KERNEL_PMD)
     399                 :            :                 free_pages((unsigned long)pgd, PGD_ALLOCATION_ORDER);
     400                 :            :         else
     401                 :            :                 kmem_cache_free(pgd_cache, pgd);
     402                 :            : }
     403                 :            : #else
     404                 :            : 
     405                 :     297305 : static inline pgd_t *_pgd_alloc(void)
     406                 :            : {
     407                 :     594610 :         return (pgd_t *)__get_free_pages(GFP_PGTABLE_USER,
     408                 :            :                                          PGD_ALLOCATION_ORDER);
     409                 :            : }
     410                 :            : 
     411                 :     296642 : static inline void _pgd_free(pgd_t *pgd)
     412                 :            : {
     413                 :     296642 :         free_pages((unsigned long)pgd, PGD_ALLOCATION_ORDER);
     414                 :          0 : }
     415                 :            : #endif /* CONFIG_X86_PAE */
     416                 :            : 
     417                 :     297305 : pgd_t *pgd_alloc(struct mm_struct *mm)
     418                 :            : {
     419                 :     297305 :         pgd_t *pgd;
     420                 :     297305 :         pmd_t *u_pmds[MAX_PREALLOCATED_USER_PMDS];
     421                 :     297305 :         pmd_t *pmds[MAX_PREALLOCATED_PMDS];
     422                 :            : 
     423                 :     297305 :         pgd = _pgd_alloc();
     424                 :            : 
     425         [ -  + ]:     297305 :         if (pgd == NULL)
     426                 :          0 :                 goto out;
     427                 :            : 
     428                 :     297305 :         mm->pgd = pgd;
     429                 :            : 
     430         [ -  + ]:     297305 :         if (preallocate_pmds(mm, pmds, PREALLOCATED_PMDS) != 0)
     431                 :          0 :                 goto out_free_pgd;
     432                 :            : 
     433         [ -  + ]:     297305 :         if (preallocate_pmds(mm, u_pmds, PREALLOCATED_USER_PMDS) != 0)
     434                 :          0 :                 goto out_free_pmds;
     435                 :            : 
     436                 :     297305 :         if (paravirt_pgd_alloc(mm) != 0)
     437                 :            :                 goto out_free_user_pmds;
     438                 :            : 
     439                 :            :         /*
     440                 :            :          * Make sure that pre-populating the pmds is atomic with
     441                 :            :          * respect to anything walking the pgd_list, so that they
     442                 :            :          * never see a partially populated pgd.
     443                 :            :          */
     444                 :     297305 :         spin_lock(&pgd_lock);
     445                 :            : 
     446                 :     297305 :         pgd_ctor(mm, pgd);
     447                 :     297305 :         pgd_prepopulate_pmd(mm, pgd, pmds);
     448                 :     297305 :         pgd_prepopulate_user_pmd(mm, pgd, u_pmds);
     449                 :            : 
     450                 :     297305 :         spin_unlock(&pgd_lock);
     451                 :            : 
     452                 :     297305 :         return pgd;
     453                 :            : 
     454                 :            : out_free_user_pmds:
     455                 :            :         free_pmds(mm, u_pmds, PREALLOCATED_USER_PMDS);
     456                 :            : out_free_pmds:
     457                 :          0 :         free_pmds(mm, pmds, PREALLOCATED_PMDS);
     458                 :          0 : out_free_pgd:
     459                 :          0 :         _pgd_free(pgd);
     460                 :            : out:
     461                 :            :         return NULL;
     462                 :            : }
     463                 :            : 
     464                 :     296642 : void pgd_free(struct mm_struct *mm, pgd_t *pgd)
     465                 :            : {
     466                 :     296642 :         pgd_mop_up_pmds(mm, pgd);
     467                 :     296642 :         pgd_dtor(pgd);
     468                 :     296642 :         paravirt_pgd_free(mm, pgd);
     469                 :     296642 :         _pgd_free(pgd);
     470                 :     296642 : }
     471                 :            : 
     472                 :            : /*
     473                 :            :  * Used to set accessed or dirty bits in the page table entries
     474                 :            :  * on other architectures. On x86, the accessed and dirty bits
     475                 :            :  * are tracked by hardware. However, do_wp_page calls this function
     476                 :            :  * to also make the pte writeable at the same time the dirty bit is
     477                 :            :  * set. In that case we do actually need to write the PTE.
     478                 :            :  */
     479                 :    1738213 : int ptep_set_access_flags(struct vm_area_struct *vma,
     480                 :            :                           unsigned long address, pte_t *ptep,
     481                 :            :                           pte_t entry, int dirty)
     482                 :            : {
     483         [ +  - ]:    1738213 :         int changed = !pte_same(*ptep, entry);
     484                 :            : 
     485         [ +  - ]:    1738213 :         if (changed && dirty)
     486                 :    1738213 :                 set_pte(ptep, entry);
     487                 :            : 
     488                 :    1738213 :         return changed;
     489                 :            : }
     490                 :            : 
     491                 :            : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
     492                 :            : int pmdp_set_access_flags(struct vm_area_struct *vma,
     493                 :            :                           unsigned long address, pmd_t *pmdp,
     494                 :            :                           pmd_t entry, int dirty)
     495                 :            : {
     496                 :            :         int changed = !pmd_same(*pmdp, entry);
     497                 :            : 
     498                 :            :         VM_BUG_ON(address & ~HPAGE_PMD_MASK);
     499                 :            : 
     500                 :            :         if (changed && dirty) {
     501                 :            :                 set_pmd(pmdp, entry);
     502                 :            :                 /*
     503                 :            :                  * We had a write-protection fault here and changed the pmd
     504                 :            :                  * to to more permissive. No need to flush the TLB for that,
     505                 :            :                  * #PF is architecturally guaranteed to do that and in the
     506                 :            :                  * worst-case we'll generate a spurious fault.
     507                 :            :                  */
     508                 :            :         }
     509                 :            : 
     510                 :            :         return changed;
     511                 :            : }
     512                 :            : 
     513                 :            : int pudp_set_access_flags(struct vm_area_struct *vma, unsigned long address,
     514                 :            :                           pud_t *pudp, pud_t entry, int dirty)
     515                 :            : {
     516                 :            :         int changed = !pud_same(*pudp, entry);
     517                 :            : 
     518                 :            :         VM_BUG_ON(address & ~HPAGE_PUD_MASK);
     519                 :            : 
     520                 :            :         if (changed && dirty) {
     521                 :            :                 set_pud(pudp, entry);
     522                 :            :                 /*
     523                 :            :                  * We had a write-protection fault here and changed the pud
     524                 :            :                  * to to more permissive. No need to flush the TLB for that,
     525                 :            :                  * #PF is architecturally guaranteed to do that and in the
     526                 :            :                  * worst-case we'll generate a spurious fault.
     527                 :            :                  */
     528                 :            :         }
     529                 :            : 
     530                 :            :         return changed;
     531                 :            : }
     532                 :            : #endif
     533                 :            : 
     534                 :          0 : int ptep_test_and_clear_young(struct vm_area_struct *vma,
     535                 :            :                               unsigned long addr, pte_t *ptep)
     536                 :            : {
     537                 :          0 :         int ret = 0;
     538                 :            : 
     539         [ #  # ]:          0 :         if (pte_young(*ptep))
     540                 :          0 :                 ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
     541                 :          0 :                                          (unsigned long *) &ptep->pte);
     542                 :            : 
     543                 :          0 :         return ret;
     544                 :            : }
     545                 :            : 
     546                 :            : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
     547                 :            : int pmdp_test_and_clear_young(struct vm_area_struct *vma,
     548                 :            :                               unsigned long addr, pmd_t *pmdp)
     549                 :            : {
     550                 :            :         int ret = 0;
     551                 :            : 
     552                 :            :         if (pmd_young(*pmdp))
     553                 :            :                 ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
     554                 :            :                                          (unsigned long *)pmdp);
     555                 :            : 
     556                 :            :         return ret;
     557                 :            : }
     558                 :            : int pudp_test_and_clear_young(struct vm_area_struct *vma,
     559                 :            :                               unsigned long addr, pud_t *pudp)
     560                 :            : {
     561                 :            :         int ret = 0;
     562                 :            : 
     563                 :            :         if (pud_young(*pudp))
     564                 :            :                 ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
     565                 :            :                                          (unsigned long *)pudp);
     566                 :            : 
     567                 :            :         return ret;
     568                 :            : }
     569                 :            : #endif
     570                 :            : 
     571                 :          0 : int ptep_clear_flush_young(struct vm_area_struct *vma,
     572                 :            :                            unsigned long address, pte_t *ptep)
     573                 :            : {
     574                 :            :         /*
     575                 :            :          * On x86 CPUs, clearing the accessed bit without a TLB flush
     576                 :            :          * doesn't cause data corruption. [ It could cause incorrect
     577                 :            :          * page aging and the (mistaken) reclaim of hot pages, but the
     578                 :            :          * chance of that should be relatively low. ]
     579                 :            :          *
     580                 :            :          * So as a performance optimization don't flush the TLB when
     581                 :            :          * clearing the accessed bit, it will eventually be flushed by
     582                 :            :          * a context switch or a VM operation anyway. [ In the rare
     583                 :            :          * event of it not getting flushed for a long time the delay
     584                 :            :          * shouldn't really matter because there's no real memory
     585                 :            :          * pressure for swapout to react to. ]
     586                 :            :          */
     587         [ #  # ]:          0 :         return ptep_test_and_clear_young(vma, address, ptep);
     588                 :            : }
     589                 :            : 
     590                 :            : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
     591                 :            : int pmdp_clear_flush_young(struct vm_area_struct *vma,
     592                 :            :                            unsigned long address, pmd_t *pmdp)
     593                 :            : {
     594                 :            :         int young;
     595                 :            : 
     596                 :            :         VM_BUG_ON(address & ~HPAGE_PMD_MASK);
     597                 :            : 
     598                 :            :         young = pmdp_test_and_clear_young(vma, address, pmdp);
     599                 :            :         if (young)
     600                 :            :                 flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
     601                 :            : 
     602                 :            :         return young;
     603                 :            : }
     604                 :            : #endif
     605                 :            : 
     606                 :            : /**
     607                 :            :  * reserve_top_address - reserves a hole in the top of kernel address space
     608                 :            :  * @reserve - size of hole to reserve
     609                 :            :  *
     610                 :            :  * Can be used to relocate the fixmap area and poke a hole in the top
     611                 :            :  * of kernel address space to make room for a hypervisor.
     612                 :            :  */
     613                 :          0 : void __init reserve_top_address(unsigned long reserve)
     614                 :            : {
     615                 :            : #ifdef CONFIG_X86_32
     616                 :            :         BUG_ON(fixmaps_set > 0);
     617                 :            :         __FIXADDR_TOP = round_down(-reserve, 1 << PMD_SHIFT) - PAGE_SIZE;
     618                 :            :         printk(KERN_INFO "Reserving virtual address space above 0x%08lx (rounded to 0x%08lx)\n",
     619                 :            :                -reserve, __FIXADDR_TOP + PAGE_SIZE);
     620                 :            : #endif
     621                 :          0 : }
     622                 :            : 
     623                 :            : int fixmaps_set;
     624                 :            : 
     625                 :         84 : void __native_set_fixmap(enum fixed_addresses idx, pte_t pte)
     626                 :            : {
     627                 :         84 :         unsigned long address = __fix_to_virt(idx);
     628                 :            : 
     629                 :            : #ifdef CONFIG_X86_64
     630                 :            :        /*
     631                 :            :         * Ensure that the static initial page tables are covering the
     632                 :            :         * fixmap completely.
     633                 :            :         */
     634                 :         84 :         BUILD_BUG_ON(__end_of_permanent_fixed_addresses >
     635                 :            :                      (FIXMAP_PMD_NUM * PTRS_PER_PTE));
     636                 :            : #endif
     637                 :            : 
     638         [ -  + ]:         84 :         if (idx >= __end_of_fixed_addresses) {
     639                 :          0 :                 BUG();
     640                 :            :                 return;
     641                 :            :         }
     642                 :         84 :         set_pte_vaddr(address, pte);
     643                 :         84 :         fixmaps_set++;
     644                 :            : }
     645                 :            : 
     646                 :         84 : void native_set_fixmap(unsigned /* enum fixed_addresses */ idx,
     647                 :            :                        phys_addr_t phys, pgprot_t flags)
     648                 :            : {
     649                 :            :         /* Sanitize 'prot' against any unsupported bits: */
     650                 :         84 :         pgprot_val(flags) &= __default_kernel_pte_mask;
     651                 :            : 
     652         [ +  - ]:        168 :         __native_set_fixmap(idx, pfn_pte(phys >> PAGE_SHIFT, flags));
     653                 :         84 : }
     654                 :            : 
     655                 :            : #ifdef CONFIG_HAVE_ARCH_HUGE_VMAP
     656                 :            : #ifdef CONFIG_X86_5LEVEL
     657                 :            : /**
     658                 :            :  * p4d_set_huge - setup kernel P4D mapping
     659                 :            :  *
     660                 :            :  * No 512GB pages yet -- always return 0
     661                 :            :  */
     662                 :          0 : int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)
     663                 :            : {
     664                 :          0 :         return 0;
     665                 :            : }
     666                 :            : 
     667                 :            : /**
     668                 :            :  * p4d_clear_huge - clear kernel P4D mapping when it is set
     669                 :            :  *
     670                 :            :  * No 512GB pages yet -- always return 0
     671                 :            :  */
     672                 :    2137781 : int p4d_clear_huge(p4d_t *p4d)
     673                 :            : {
     674                 :    2137781 :         return 0;
     675                 :            : }
     676                 :            : #endif
     677                 :            : 
     678                 :            : /**
     679                 :            :  * pud_set_huge - setup kernel PUD mapping
     680                 :            :  *
     681                 :            :  * MTRRs can override PAT memory types with 4KiB granularity. Therefore, this
     682                 :            :  * function sets up a huge page only if any of the following conditions are met:
     683                 :            :  *
     684                 :            :  * - MTRRs are disabled, or
     685                 :            :  *
     686                 :            :  * - MTRRs are enabled and the range is completely covered by a single MTRR, or
     687                 :            :  *
     688                 :            :  * - MTRRs are enabled and the corresponding MTRR memory type is WB, which
     689                 :            :  *   has no effect on the requested PAT memory type.
     690                 :            :  *
     691                 :            :  * Callers should try to decrease page size (1GB -> 2MB -> 4K) if the bigger
     692                 :            :  * page mapping attempt fails.
     693                 :            :  *
     694                 :            :  * Returns 1 on success and 0 on failure.
     695                 :            :  */
     696                 :          0 : int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot)
     697                 :            : {
     698                 :          0 :         u8 mtrr, uniform;
     699                 :            : 
     700                 :          0 :         mtrr = mtrr_type_lookup(addr, addr + PUD_SIZE, &uniform);
     701   [ #  #  #  #  :          0 :         if ((mtrr != MTRR_TYPE_INVALID) && (!uniform) &&
                   #  # ]
     702                 :            :             (mtrr != MTRR_TYPE_WRBACK))
     703                 :            :                 return 0;
     704                 :            : 
     705                 :            :         /* Bail out if we are we on a populated non-leaf entry: */
     706   [ #  #  #  #  :          0 :         if (pud_present(*pud) && !pud_huge(*pud))
                   #  # ]
     707                 :            :                 return 0;
     708                 :            : 
     709         [ #  # ]:          0 :         prot = pgprot_4k_2_large(prot);
     710                 :            : 
     711         [ #  # ]:          0 :         set_pte((pte_t *)pud, pfn_pte(
     712                 :            :                 (u64)addr >> PAGE_SHIFT,
     713                 :            :                 __pgprot(pgprot_val(prot) | _PAGE_PSE)));
     714                 :            : 
     715                 :          0 :         return 1;
     716                 :            : }
     717                 :            : 
     718                 :            : /**
     719                 :            :  * pmd_set_huge - setup kernel PMD mapping
     720                 :            :  *
     721                 :            :  * See text over pud_set_huge() above.
     722                 :            :  *
     723                 :            :  * Returns 1 on success and 0 on failure.
     724                 :            :  */
     725                 :       5544 : int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot)
     726                 :            : {
     727                 :       5544 :         u8 mtrr, uniform;
     728                 :            : 
     729                 :       5544 :         mtrr = mtrr_type_lookup(addr, addr + PMD_SIZE, &uniform);
     730   [ +  -  -  +  :       5544 :         if ((mtrr != MTRR_TYPE_INVALID) && (!uniform) &&
                   -  - ]
     731                 :            :             (mtrr != MTRR_TYPE_WRBACK)) {
     732         [ #  # ]:          0 :                 pr_warn_once("%s: Cannot satisfy [mem %#010llx-%#010llx] with a huge-page mapping due to MTRR override.\n",
     733                 :            :                              __func__, addr, addr + PMD_SIZE);
     734                 :          0 :                 return 0;
     735                 :            :         }
     736                 :            : 
     737                 :            :         /* Bail out if we are we on a populated non-leaf entry: */
     738   [ +  -  -  +  :      11088 :         if (pmd_present(*pmd) && !pmd_huge(*pmd))
                   -  - ]
     739                 :            :                 return 0;
     740                 :            : 
     741         [ +  - ]:       5544 :         prot = pgprot_4k_2_large(prot);
     742                 :            : 
     743         [ +  - ]:       5544 :         set_pte((pte_t *)pmd, pfn_pte(
     744                 :            :                 (u64)addr >> PAGE_SHIFT,
     745                 :            :                 __pgprot(pgprot_val(prot) | _PAGE_PSE)));
     746                 :            : 
     747                 :       5544 :         return 1;
     748                 :            : }
     749                 :            : 
     750                 :            : /**
     751                 :            :  * pud_clear_huge - clear kernel PUD mapping when it is set
     752                 :            :  *
     753                 :            :  * Returns 1 on success and 0 on failure (no PUD map is found).
     754                 :            :  */
     755                 :    2137781 : int pud_clear_huge(pud_t *pud)
     756                 :            : {
     757         [ -  + ]:    2137781 :         if (pud_large(*pud)) {
     758                 :          0 :                 pud_clear(pud);
     759                 :          0 :                 return 1;
     760                 :            :         }
     761                 :            : 
     762                 :            :         return 0;
     763                 :            : }
     764                 :            : 
     765                 :            : /**
     766                 :            :  * pmd_clear_huge - clear kernel PMD mapping when it is set
     767                 :            :  *
     768                 :            :  * Returns 1 on success and 0 on failure (no PMD map is found).
     769                 :            :  */
     770                 :    2143003 : int pmd_clear_huge(pmd_t *pmd)
     771                 :            : {
     772   [ +  +  +  + ]:    4285622 :         if (pmd_large(*pmd)) {
     773                 :        384 :                 pmd_clear(pmd);
     774                 :        384 :                 return 1;
     775                 :            :         }
     776                 :            : 
     777                 :            :         return 0;
     778                 :            : }
     779                 :            : 
     780                 :            : /*
     781                 :            :  * Until we support 512GB pages, skip them in the vmap area.
     782                 :            :  */
     783                 :          0 : int p4d_free_pud_page(p4d_t *p4d, unsigned long addr)
     784                 :            : {
     785                 :          0 :         return 0;
     786                 :            : }
     787                 :            : 
     788                 :            : #ifdef CONFIG_X86_64
     789                 :            : /**
     790                 :            :  * pud_free_pmd_page - Clear pud entry and free pmd page.
     791                 :            :  * @pud: Pointer to a PUD.
     792                 :            :  * @addr: Virtual address associated with pud.
     793                 :            :  *
     794                 :            :  * Context: The pud range has been unmapped and TLB purged.
     795                 :            :  * Return: 1 if clearing the entry succeeded. 0 otherwise.
     796                 :            :  *
     797                 :            :  * NOTE: Callers must allow a single page allocation.
     798                 :            :  */
     799                 :          0 : int pud_free_pmd_page(pud_t *pud, unsigned long addr)
     800                 :            : {
     801                 :          0 :         pmd_t *pmd, *pmd_sv;
     802                 :          0 :         pte_t *pte;
     803                 :          0 :         int i;
     804                 :            : 
     805         [ #  # ]:          0 :         pmd = (pmd_t *)pud_page_vaddr(*pud);
     806                 :          0 :         pmd_sv = (pmd_t *)__get_free_page(GFP_KERNEL);
     807         [ #  # ]:          0 :         if (!pmd_sv)
     808                 :            :                 return 0;
     809                 :            : 
     810         [ #  # ]:          0 :         for (i = 0; i < PTRS_PER_PMD; i++) {
     811                 :          0 :                 pmd_sv[i] = pmd[i];
     812         [ #  # ]:          0 :                 if (!pmd_none(pmd[i]))
     813                 :          0 :                         pmd_clear(&pmd[i]);
     814                 :            :         }
     815                 :            : 
     816                 :          0 :         pud_clear(pud);
     817                 :            : 
     818                 :            :         /* INVLPG to clear all paging-structure caches */
     819                 :          0 :         flush_tlb_kernel_range(addr, addr + PAGE_SIZE-1);
     820                 :            : 
     821         [ #  # ]:          0 :         for (i = 0; i < PTRS_PER_PMD; i++) {
     822         [ #  # ]:          0 :                 if (!pmd_none(pmd_sv[i])) {
     823         [ #  # ]:          0 :                         pte = (pte_t *)pmd_page_vaddr(pmd_sv[i]);
     824                 :          0 :                         free_page((unsigned long)pte);
     825                 :            :                 }
     826                 :            :         }
     827                 :            : 
     828                 :          0 :         free_page((unsigned long)pmd_sv);
     829                 :          0 :         free_page((unsigned long)pmd);
     830                 :            : 
     831                 :          0 :         return 1;
     832                 :            : }
     833                 :            : 
     834                 :            : /**
     835                 :            :  * pmd_free_pte_page - Clear pmd entry and free pte page.
     836                 :            :  * @pmd: Pointer to a PMD.
     837                 :            :  * @addr: Virtual address associated with pmd.
     838                 :            :  *
     839                 :            :  * Context: The pmd range has been unmapped and TLB purged.
     840                 :            :  * Return: 1 if clearing the entry succeeded. 0 otherwise.
     841                 :            :  */
     842                 :          0 : int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
     843                 :            : {
     844                 :          0 :         pte_t *pte;
     845                 :            : 
     846         [ #  # ]:          0 :         pte = (pte_t *)pmd_page_vaddr(*pmd);
     847                 :          0 :         pmd_clear(pmd);
     848                 :            : 
     849                 :            :         /* INVLPG to clear all paging-structure caches */
     850                 :          0 :         flush_tlb_kernel_range(addr, addr + PAGE_SIZE-1);
     851                 :            : 
     852                 :          0 :         free_page((unsigned long)pte);
     853                 :            : 
     854                 :          0 :         return 1;
     855                 :            : }
     856                 :            : 
     857                 :            : #else /* !CONFIG_X86_64 */
     858                 :            : 
     859                 :            : int pud_free_pmd_page(pud_t *pud, unsigned long addr)
     860                 :            : {
     861                 :            :         return pud_none(*pud);
     862                 :            : }
     863                 :            : 
     864                 :            : /*
     865                 :            :  * Disable free page handling on x86-PAE. This assures that ioremap()
     866                 :            :  * does not update sync'd pmd entries. See vmalloc_sync_one().
     867                 :            :  */
     868                 :            : int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
     869                 :            : {
     870                 :            :         return pmd_none(*pmd);
     871                 :            : }
     872                 :            : 
     873                 :            : #endif /* CONFIG_X86_64 */
     874                 :            : #endif  /* CONFIG_HAVE_ARCH_HUGE_VMAP */

Generated by: LCOV version 1.14