arch/x86/mm/fault.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  Copyright (C) 1995  Linus Torvalds
   4  *  Copyright (C) 2001, 2002 Andi Kleen, SuSE Labs.
   5  *  Copyright (C) 2008-2009, Red Hat Inc., Ingo Molnar
   6  */
   7 #include <linux/sched.h>                /* test_thread_flag(), ...      */
   8 #include <linux/sched/task_stack.h>     /* task_stack_*(), ...          */
   9 #include <linux/kdebug.h>               /* oops_begin/end, ...          */
  10 #include <linux/extable.h>              /* search_exception_tables      */
  11 #include <linux/memblock.h>             /* max_low_pfn                  */
  12 #include <linux/kprobes.h>              /* NOKPROBE_SYMBOL, ...         */
  13 #include <linux/mmiotrace.h>            /* kmmio_handler, ...           */
  14 #include <linux/perf_event.h>           /* perf_sw_event                */
  15 #include <linux/hugetlb.h>              /* hstate_index_to_shift        */
  16 #include <linux/prefetch.h>             /* prefetchw                    */
  17 #include <linux/context_tracking.h>     /* exception_enter(), ...       */
  18 #include <linux/uaccess.h>              /* faulthandler_disabled()      */
  19 #include <linux/efi.h>                  /* efi_recover_from_page_fault()*/
  20 #include <linux/mm_types.h>
  21
  22 #include <asm/cpufeature.h>             /* boot_cpu_has, ...            */
  23 #include <asm/traps.h>                  /* dotraplinkage, ...           */
  24 #include <asm/pgalloc.h>                /* pgd_*(), ...                 */
  25 #include <asm/fixmap.h>                 /* VSYSCALL_ADDR                */
  26 #include <asm/vsyscall.h>               /* emulate_vsyscall             */
  27 #include <asm/vm86.h>                   /* struct vm86                  */
  28 #include <asm/mmu_context.h>            /* vma_pkey()                   */
  29 #include <asm/efi.h>                    /* efi_recover_from_page_fault()*/
  30 #include <asm/desc.h>                   /* store_idt(), ...             */
  31 #include <asm/cpu_entry_area.h>         /* exception stack              */
  32 #include <asm/pgtable_areas.h>          /* VMALLOC_START, ...           */
  33
  34 #define CREATE_TRACE_POINTS
  35 #include <asm/trace/exceptions.h>
  36
  37 /*
  38  * Returns 0 if mmiotrace is disabled, or if the fault is not
  39  * handled by mmiotrace:
  40  */
  41 static nokprobe_inline int
  42 kmmio_fault(struct pt_regs *regs, unsigned long addr)
  43 {
  44         if (unlikely(is_kmmio_active()))
  45                 if (kmmio_handler(regs, addr) == 1)
  46                         return -1;
  47         return 0;
  48 }
  49
  50 /*
  51  * Prefetch quirks:
  52  *
  53  * 32-bit mode:
  54  *
  55  *   Sometimes AMD Athlon/Opteron CPUs report invalid exceptions on prefetch.
  56  *   Check that here and ignore it.
  57  *
  58  * 64-bit mode:
  59  *
  60  *   Sometimes the CPU reports invalid exceptions on prefetch.
  61  *   Check that here and ignore it.
  62  *
  63  * Opcode checker based on code by Richard Brunner.
  64  */
  65 static inline int
  66 check_prefetch_opcode(struct pt_regs *regs, unsigned char *instr,
  67                       unsigned char opcode, int *prefetch)
  68 {
  69         unsigned char instr_hi = opcode & 0xf0;
  70         unsigned char instr_lo = opcode & 0x0f;
  71
  72         switch (instr_hi) {
  73         case 0x20:
  74         case 0x30:
  75                 /*
  76                  * Values 0x26,0x2E,0x36,0x3E are valid x86 prefixes.
  77                  * In X86_64 long mode, the CPU will signal invalid
  78                  * opcode if some of these prefixes are present so
  79                  * X86_64 will never get here anyway
  80                  */
  81                 return ((instr_lo & 7) == 0x6);
  82 #ifdef CONFIG_X86_64
  83         case 0x40:
  84                 /*
  85                  * In AMD64 long mode 0x40..0x4F are valid REX prefixes
  86                  * Need to figure out under what instruction mode the
  87                  * instruction was issued. Could check the LDT for lm,
  88                  * but for now it's good enough to assume that long
  89                  * mode only uses well known segments or kernel.
  90                  */
  91                 return (!user_mode(regs) || user_64bit_mode(regs));
  92 #endif
  93         case 0x60:
  94                 /* 0x64 thru 0x67 are valid prefixes in all modes. */
  95                 return (instr_lo & 0xC) == 0x4;
  96         case 0xF0:
  97                 /* 0xF0, 0xF2, 0xF3 are valid prefixes in all modes. */
  98                 return !instr_lo || (instr_lo>>1) == 1;
  99         case 0x00:
 100                 /* Prefetch instruction is 0x0F0D or 0x0F18 */
 101                 if (probe_kernel_address(instr, opcode))
 102                         return 0;
 103
 104                 *prefetch = (instr_lo == 0xF) &&
 105                         (opcode == 0x0D || opcode == 0x18);
 106                 return 0;
 107         default:
 108                 return 0;
 109         }
 110 }
 111
 112 static int
 113 is_prefetch(struct pt_regs *regs, unsigned long error_code, unsigned long addr)
 114 {
 115         unsigned char *max_instr;
 116         unsigned char *instr;
 117         int prefetch = 0;
 118
 119         /*
 120          * If it was a exec (instruction fetch) fault on NX page, then
 121          * do not ignore the fault:
 122          */
 123         if (error_code & X86_PF_INSTR)
 124                 return 0;
 125
 126         instr = (void *)convert_ip_to_linear(current, regs);
 127         max_instr = instr + 15;
 128
 129         if (user_mode(regs) && instr >= (unsigned char *)TASK_SIZE_MAX)
 130                 return 0;
 131
 132         while (instr < max_instr) {
 133                 unsigned char opcode;
 134
 135                 if (probe_kernel_address(instr, opcode))
 136                         break;
 137
 138                 instr++;
 139
 140                 if (!check_prefetch_opcode(regs, instr, opcode, &prefetch))
 141                         break;
 142         }
 143         return prefetch;
 144 }
 145
 146 DEFINE_SPINLOCK(pgd_lock);
 147 LIST_HEAD(pgd_list);
 148
 149 #ifdef CONFIG_X86_32
 150 static inline pmd_t *vmalloc_sync_one(pgd_t *pgd, unsigned long address)
 151 {
 152         unsigned index = pgd_index(address);
 153         pgd_t *pgd_k;
 154         p4d_t *p4d, *p4d_k;
 155         pud_t *pud, *pud_k;
 156         pmd_t *pmd, *pmd_k;
 157
 158         pgd += index;
 159         pgd_k = init_mm.pgd + index;
 160
 161         if (!pgd_present(*pgd_k))
 162                 return NULL;
 163
 164         /*
 165          * set_pgd(pgd, *pgd_k); here would be useless on PAE
 166          * and redundant with the set_pmd() on non-PAE. As would
 167          * set_p4d/set_pud.
 168          */
 169         p4d = p4d_offset(pgd, address);
 170         p4d_k = p4d_offset(pgd_k, address);
 171         if (!p4d_present(*p4d_k))
 172                 return NULL;
 173
 174         pud = pud_offset(p4d, address);
 175         pud_k = pud_offset(p4d_k, address);
 176         if (!pud_present(*pud_k))
 177                 return NULL;
 178
 179         pmd = pmd_offset(pud, address);
 180         pmd_k = pmd_offset(pud_k, address);
 181
 182         if (pmd_present(*pmd) != pmd_present(*pmd_k))
 183                 set_pmd(pmd, *pmd_k);
 184
 185         if (!pmd_present(*pmd_k))
 186                 return NULL;
 187         else
 188                 BUG_ON(pmd_pfn(*pmd) != pmd_pfn(*pmd_k));
 189
 190         return pmd_k;
 191 }
 192
 193 void arch_sync_kernel_mappings(unsigned long start, unsigned long end)
 194 {
 195         unsigned long addr;
 196
 197         for (addr = start & PMD_MASK;
 198              addr >= TASK_SIZE_MAX && addr < VMALLOC_END;
 199              addr += PMD_SIZE) {
 200                 struct page *page;
 201
 202                 spin_lock(&pgd_lock);
 203                 list_for_each_entry(page, &pgd_list, lru) {
 204                         spinlock_t *pgt_lock;
 205
 206                         /* the pgt_lock only for Xen */
 207                         pgt_lock = &pgd_page_get_mm(page)->page_table_lock;
 208
 209                         spin_lock(pgt_lock);
 210                         vmalloc_sync_one(page_address(page), addr);
 211                         spin_unlock(pgt_lock);
 212                 }
 213                 spin_unlock(&pgd_lock);
 214         }
 215 }
 216
 217 /*
 218  * Did it hit the DOS screen memory VA from vm86 mode?
 219  */
 220 static inline void
 221 check_v8086_mode(struct pt_regs *regs, unsigned long address,
 222                  struct task_struct *tsk)
 223 {
 224 #ifdef CONFIG_VM86
 225         unsigned long bit;
 226
 227         if (!v8086_mode(regs) || !tsk->thread.vm86)
 228                 return;
 229
 230         bit = (address - 0xA0000) >> PAGE_SHIFT;
 231         if (bit < 32)
 232                 tsk->thread.vm86->screen_bitmap |= 1 << bit;
 233 #endif
 234 }
 235
 236 static bool low_pfn(unsigned long pfn)
 237 {
 238         return pfn < max_low_pfn;
 239 }
 240
 241 static void dump_pagetable(unsigned long address)
 242 {
 243         pgd_t *base = __va(read_cr3_pa());
 244         pgd_t *pgd = &base[pgd_index(address)];
 245         p4d_t *p4d;
 246         pud_t *pud;
 247         pmd_t *pmd;
 248         pte_t *pte;
 249
 250 #ifdef CONFIG_X86_PAE
 251         pr_info("*pdpt = %016Lx ", pgd_val(*pgd));
 252         if (!low_pfn(pgd_val(*pgd) >> PAGE_SHIFT) || !pgd_present(*pgd))
 253                 goto out;
 254 #define pr_pde pr_cont
 255 #else
 256 #define pr_pde pr_info
 257 #endif
 258         p4d = p4d_offset(pgd, address);
 259         pud = pud_offset(p4d, address);
 260         pmd = pmd_offset(pud, address);
 261         pr_pde("*pde = %0*Lx ", sizeof(*pmd) * 2, (u64)pmd_val(*pmd));
 262 #undef pr_pde
 263
 264         /*
 265          * We must not directly access the pte in the highpte
 266          * case if the page table is located in highmem.
 267          * And let's rather not kmap-atomic the pte, just in case
 268          * it's allocated already:
 269          */
 270         if (!low_pfn(pmd_pfn(*pmd)) || !pmd_present(*pmd) || pmd_large(*pmd))
 271                 goto out;
 272
 273         pte = pte_offset_kernel(pmd, address);
 274         pr_cont("*pte = %0*Lx ", sizeof(*pte) * 2, (u64)pte_val(*pte));
 275 out:
 276         pr_cont("\n");
 277 }
 278
 279 #else /* CONFIG_X86_64: */
 280
 281 #ifdef CONFIG_CPU_SUP_AMD
 282 static const char errata93_warning[] =
 283 KERN_ERR
 284 "******* Your BIOS seems to not contain a fix for K8 errata #93\n"
 285 "******* Working around it, but it may cause SEGVs or burn power.\n"
 286 "******* Please consider a BIOS update.\n"
 287 "******* Disabling USB legacy in the BIOS may also help.\n";
 288 #endif
 289
 290 /*
 291  * No vm86 mode in 64-bit mode:
 292  */
 293 static inline void
 294 check_v8086_mode(struct pt_regs *regs, unsigned long address,
 295                  struct task_struct *tsk)
 296 {
 297 }
 298
 299 static int bad_address(void *p)
 300 {
 301         unsigned long dummy;
 302
 303         return probe_kernel_address((unsigned long *)p, dummy);
 304 }
 305
 306 static void dump_pagetable(unsigned long address)
 307 {
 308         pgd_t *base = __va(read_cr3_pa());
 309         pgd_t *pgd = base + pgd_index(address);
 310         p4d_t *p4d;
 311         pud_t *pud;
 312         pmd_t *pmd;
 313         pte_t *pte;
 314
 315         if (bad_address(pgd))
 316                 goto bad;
 317
 318         pr_info("PGD %lx ", pgd_val(*pgd));
 319
 320         if (!pgd_present(*pgd))
 321                 goto out;
 322
 323         p4d = p4d_offset(pgd, address);
 324         if (bad_address(p4d))
 325                 goto bad;
 326
 327         pr_cont("P4D %lx ", p4d_val(*p4d));
 328         if (!p4d_present(*p4d) || p4d_large(*p4d))
 329                 goto out;
 330
 331         pud = pud_offset(p4d, address);
 332         if (bad_address(pud))
 333                 goto bad;
 334
 335         pr_cont("PUD %lx ", pud_val(*pud));
 336         if (!pud_present(*pud) || pud_large(*pud))
 337                 goto out;
 338
 339         pmd = pmd_offset(pud, address);
 340         if (bad_address(pmd))
 341                 goto bad;
 342
 343         pr_cont("PMD %lx ", pmd_val(*pmd));
 344         if (!pmd_present(*pmd) || pmd_large(*pmd))
 345                 goto out;
 346
 347         pte = pte_offset_kernel(pmd, address);
 348         if (bad_address(pte))
 349                 goto bad;
 350
 351         pr_cont("PTE %lx", pte_val(*pte));
 352 out:
 353         pr_cont("\n");
 354         return;
 355 bad:
 356         pr_info("BAD\n");
 357 }
 358
 359 #endif /* CONFIG_X86_64 */
 360
 361 /*
 362  * Workaround for K8 erratum #93 & buggy BIOS.
 363  *
 364  * BIOS SMM functions are required to use a specific workaround
 365  * to avoid corruption of the 64bit RIP register on C stepping K8.
 366  *
 367  * A lot of BIOS that didn't get tested properly miss this.
 368  *
 369  * The OS sees this as a page fault with the upper 32bits of RIP cleared.
 370  * Try to work around it here.
 371  *
 372  * Note we only handle faults in kernel here.
 373  * Does nothing on 32-bit.
 374  */
 375 static int is_errata93(struct pt_regs *regs, unsigned long address)
 376 {
 377 #if defined(CONFIG_X86_64) && defined(CONFIG_CPU_SUP_AMD)
 378         if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD
 379             || boot_cpu_data.x86 != 0xf)
 380                 return 0;
 381
 382         if (address != regs->ip)
 383                 return 0;
 384
 385         if ((address >> 32) != 0)
 386                 return 0;
 387
 388         address |= 0xffffffffUL << 32;
 389         if ((address >= (u64)_stext && address <= (u64)_etext) ||
 390             (address >= MODULES_VADDR && address <= MODULES_END)) {
 391                 printk_once(errata93_warning);
 392                 regs->ip = address;
 393                 return 1;
 394         }
 395 #endif
 396         return 0;
 397 }
 398
 399 /*
 400  * Work around K8 erratum #100 K8 in compat mode occasionally jumps
 401  * to illegal addresses >4GB.
 402  *
 403  * We catch this in the page fault handler because these addresses
 404  * are not reachable. Just detect this case and return.  Any code
 405  * segment in LDT is compatibility mode.
 406  */
 407 static int is_errata100(struct pt_regs *regs, unsigned long address)
 408 {
 409 #ifdef CONFIG_X86_64
 410         if ((regs->cs == __USER32_CS || (regs->cs & (1<<2))) && (address >> 32))
 411                 return 1;
 412 #endif
 413         return 0;
 414 }
 415
 416 static int is_f00f_bug(struct pt_regs *regs, unsigned long address)
 417 {
 418 #ifdef CONFIG_X86_F00F_BUG
 419         unsigned long nr;
 420
 421         /*
 422          * Pentium F0 0F C7 C8 bug workaround:
 423          */
 424         if (boot_cpu_has_bug(X86_BUG_F00F)) {
 425                 nr = (address - idt_descr.address) >> 3;
 426
 427                 if (nr == 6) {
 428                         do_invalid_op(regs, 0);
 429                         return 1;
 430                 }
 431         }
 432 #endif
 433         return 0;
 434 }
 435
 436 static void show_ldttss(const struct desc_ptr *gdt, const char *name, u16 index)
 437 {
 438         u32 offset = (index >> 3) * sizeof(struct desc_struct);
 439         unsigned long addr;
 440         struct ldttss_desc desc;
 441
 442         if (index == 0) {
 443                 pr_alert("%s: NULL\n", name);
 444                 return;
 445         }
 446
 447         if (offset + sizeof(struct ldttss_desc) >= gdt->size) {
 448                 pr_alert("%s: 0x%hx -- out of bounds\n", name, index);
 449                 return;
 450         }
 451
 452         if (probe_kernel_read(&desc, (void *)(gdt->address + offset),
 453                               sizeof(struct ldttss_desc))) {
 454                 pr_alert("%s: 0x%hx -- GDT entry is not readable\n",
 455                          name, index);
 456                 return;
 457         }
 458
 459         addr = desc.base0 | (desc.base1 << 16) | ((unsigned long)desc.base2 << 24);
 460 #ifdef CONFIG_X86_64
 461         addr |= ((u64)desc.base3 << 32);
 462 #endif
 463         pr_alert("%s: 0x%hx -- base=0x%lx limit=0x%x\n",
 464                  name, index, addr, (desc.limit0 | (desc.limit1 << 16)));
 465 }
 466
 467 static void
 468 show_fault_oops(struct pt_regs *regs, unsigned long error_code, unsigned long address)
 469 {
 470         if (!oops_may_print())
 471                 return;
 472
 473         if (error_code & X86_PF_INSTR) {
 474                 unsigned int level;
 475                 pgd_t *pgd;
 476                 pte_t *pte;
 477
 478                 pgd = __va(read_cr3_pa());
 479                 pgd += pgd_index(address);
 480
 481                 pte = lookup_address_in_pgd(pgd, address, &level);
 482
 483                 if (pte && pte_present(*pte) && !pte_exec(*pte))
 484                         pr_crit("kernel tried to execute NX-protected page - exploit attempt? (uid: %d)\n",
 485                                 from_kuid(&init_user_ns, current_uid()));
 486                 if (pte && pte_present(*pte) && pte_exec(*pte) &&
 487                                 (pgd_flags(*pgd) & _PAGE_USER) &&
 488                                 (__read_cr4() & X86_CR4_SMEP))
 489                         pr_crit("unable to execute userspace code (SMEP?) (uid: %d)\n",
 490                                 from_kuid(&init_user_ns, current_uid()));
 491         }
 492
 493         if (address < PAGE_SIZE && !user_mode(regs))
 494                 pr_alert("BUG: kernel NULL pointer dereference, address: %px\n",
 495                         (void *)address);
 496         else
 497                 pr_alert("BUG: unable to handle page fault for address: %px\n",
 498                         (void *)address);
 499
 500         pr_alert("#PF: %s %s in %s mode\n",
 501                  (error_code & X86_PF_USER)  ? "user" : "supervisor",
 502                  (error_code & X86_PF_INSTR) ? "instruction fetch" :
 503                  (error_code & X86_PF_WRITE) ? "write access" :
 504                                                "read access",
 505                              user_mode(regs) ? "user" : "kernel");
 506         pr_alert("#PF: error_code(0x%04lx) - %s\n", error_code,
 507                  !(error_code & X86_PF_PROT) ? "not-present page" :
 508                  (error_code & X86_PF_RSVD)  ? "reserved bit violation" :
 509                  (error_code & X86_PF_PK)    ? "protection keys violation" :
 510                                                "permissions violation");
 511
 512         if (!(error_code & X86_PF_USER) && user_mode(regs)) {
 513                 struct desc_ptr idt, gdt;
 514                 u16 ldtr, tr;
 515
 516                 /*
 517                  * This can happen for quite a few reasons.  The more obvious
 518                  * ones are faults accessing the GDT, or LDT.  Perhaps
 519                  * surprisingly, if the CPU tries to deliver a benign or
 520                  * contributory exception from user code and gets a page fault
 521                  * during delivery, the page fault can be delivered as though
 522                  * it originated directly from user code.  This could happen
 523                  * due to wrong permissions on the IDT, GDT, LDT, TSS, or
 524                  * kernel or IST stack.
 525                  */
 526                 store_idt(&idt);
 527
 528                 /* Usable even on Xen PV -- it's just slow. */
 529                 native_store_gdt(&gdt);
 530
 531                 pr_alert("IDT: 0x%lx (limit=0x%hx) GDT: 0x%lx (limit=0x%hx)\n",
 532                          idt.address, idt.size, gdt.address, gdt.size);
 533
 534                 store_ldt(ldtr);
 535                 show_ldttss(&gdt, "LDTR", ldtr);
 536
 537                 store_tr(tr);
 538                 show_ldttss(&gdt, "TR", tr);
 539         }
 540
 541         dump_pagetable(address);
 542 }
 543
 544 static noinline void
 545 pgtable_bad(struct pt_regs *regs, unsigned long error_code,
 546             unsigned long address)
 547 {
 548         struct task_struct *tsk;
 549         unsigned long flags;
 550         int sig;
 551
 552         flags = oops_begin();
 553         tsk = current;
 554         sig = SIGKILL;
 555
 556         printk(KERN_ALERT "%s: Corrupted page table at address %lx\n",
 557                tsk->comm, address);
 558         dump_pagetable(address);
 559
 560         if (__die("Bad pagetable", regs, error_code))
 561                 sig = 0;
 562
 563         oops_end(flags, regs, sig);
 564 }
 565
 566 static void set_signal_archinfo(unsigned long address,
 567                                 unsigned long error_code)
 568 {
 569         struct task_struct *tsk = current;
 570
 571         /*
 572          * To avoid leaking information about the kernel page
 573          * table layout, pretend that user-mode accesses to
 574          * kernel addresses are always protection faults.
 575          *
 576          * NB: This means that failed vsyscalls with vsyscall=none
 577          * will have the PROT bit.  This doesn't leak any
 578          * information and does not appear to cause any problems.
 579          */
 580         if (address >= TASK_SIZE_MAX)
 581                 error_code |= X86_PF_PROT;
 582
 583         tsk->thread.trap_nr = X86_TRAP_PF;
 584         tsk->thread.error_code = error_code | X86_PF_USER;
 585         tsk->thread.cr2 = address;
 586 }
 587
 588 static noinline void
 589 no_context(struct pt_regs *regs, unsigned long error_code,
 590            unsigned long address, int signal, int si_code)
 591 {
 592         struct task_struct *tsk = current;
 593         unsigned long flags;
 594         int sig;
 595
 596         if (user_mode(regs)) {
 597                 /*
 598                  * This is an implicit supervisor-mode access from user
 599                  * mode.  Bypass all the kernel-mode recovery code and just
 600                  * OOPS.
 601                  */
 602                 goto oops;
 603         }
 604
 605         /* Are we prepared to handle this kernel fault? */
 606         if (fixup_exception(regs, X86_TRAP_PF, error_code, address)) {
 607                 /*
 608                  * Any interrupt that takes a fault gets the fixup. This makes
 609                  * the below recursive fault logic only apply to a faults from
 610                  * task context.
 611                  */
 612                 if (in_interrupt())
 613                         return;
 614
 615                 /*
 616                  * Per the above we're !in_interrupt(), aka. task context.
 617                  *
 618                  * In this case we need to make sure we're not recursively
 619                  * faulting through the emulate_vsyscall() logic.
 620                  */
 621                 if (current->thread.sig_on_uaccess_err && signal) {
 622                         set_signal_archinfo(address, error_code);
 623
 624                         /* XXX: hwpoison faults will set the wrong code. */
 625                         force_sig_fault(signal, si_code, (void __user *)address);
 626                 }
 627
 628                 /*
 629                  * Barring that, we can do the fixup and be happy.
 630                  */
 631                 return;
 632         }
 633
 634 #ifdef CONFIG_VMAP_STACK
 635         /*
 636          * Stack overflow?  During boot, we can fault near the initial
 637          * stack in the direct map, but that's not an overflow -- check
 638          * that we're in vmalloc space to avoid this.
 639          */
 640         if (is_vmalloc_addr((void *)address) &&
 641             (((unsigned long)tsk->stack - 1 - address < PAGE_SIZE) ||
 642              address - ((unsigned long)tsk->stack + THREAD_SIZE) < PAGE_SIZE)) {
 643                 unsigned long stack = __this_cpu_ist_top_va(DF) - sizeof(void *);
 644                 /*
 645                  * We're likely to be running with very little stack space
 646                  * left.  It's plausible that we'd hit this condition but
 647                  * double-fault even before we get this far, in which case
 648                  * we're fine: the double-fault handler will deal with it.
 649                  *
 650                  * We don't want to make it all the way into the oops code
 651                  * and then double-fault, though, because we're likely to
 652                  * break the console driver and lose most of the stack dump.
 653                  */
 654                 asm volatile ("movq %[stack], %%rsp\n\t"
 655                               "call handle_stack_overflow\n\t"
 656                               "1: jmp 1b"
 657                               : ASM_CALL_CONSTRAINT
 658                               : "D" ("kernel stack overflow (page fault)"),
 659                                 "S" (regs), "d" (address),
 660                                 [stack] "rm" (stack));
 661                 unreachable();
 662         }
 663 #endif
 664
 665         /*
 666          * 32-bit:
 667          *
 668          *   Valid to do another page fault here, because if this fault
 669          *   had been triggered by is_prefetch fixup_exception would have
 670          *   handled it.
 671          *
 672          * 64-bit:
 673          *
 674          *   Hall of shame of CPU/BIOS bugs.
 675          */
 676         if (is_prefetch(regs, error_code, address))
 677                 return;
 678
 679         if (is_errata93(regs, address))
 680                 return;
 681
 682         /*
 683          * Buggy firmware could access regions which might page fault, try to
 684          * recover from such faults.
 685          */
 686         if (IS_ENABLED(CONFIG_EFI))
 687                 efi_recover_from_page_fault(address);
 688
 689 oops:
 690         /*
 691          * Oops. The kernel tried to access some bad page. We'll have to
 692          * terminate things with extreme prejudice:
 693          */
 694         flags = oops_begin();
 695
 696         show_fault_oops(regs, error_code, address);
 697
 698         if (task_stack_end_corrupted(tsk))
 699                 printk(KERN_EMERG "Thread overran stack, or stack corrupted\n");
 700
 701         sig = SIGKILL;
 702         if (__die("Oops", regs, error_code))
 703                 sig = 0;
 704
 705         /* Executive summary in case the body of the oops scrolled away */
 706         printk(KERN_DEFAULT "CR2: %016lx\n", address);
 707
 708         oops_end(flags, regs, sig);
 709 }
 710
 711 /*
 712  * Print out info about fatal segfaults, if the show_unhandled_signals
 713  * sysctl is set:
 714  */
 715 static inline void
 716 show_signal_msg(struct pt_regs *regs, unsigned long error_code,
 717                 unsigned long address, struct task_struct *tsk)
 718 {
 719         const char *loglvl = task_pid_nr(tsk) > 1 ? KERN_INFO : KERN_EMERG;
 720
 721         if (!unhandled_signal(tsk, SIGSEGV))
 722                 return;
 723
 724         if (!printk_ratelimit())
 725                 return;
 726
 727         printk("%s%s[%d]: segfault at %lx ip %px sp %px error %lx",
 728                 loglvl, tsk->comm, task_pid_nr(tsk), address,
 729                 (void *)regs->ip, (void *)regs->sp, error_code);
 730
 731         print_vma_addr(KERN_CONT " in ", regs->ip);
 732
 733         printk(KERN_CONT "\n");
 734
 735         show_opcodes(regs, loglvl);
 736 }
 737
 738 /*
 739  * The (legacy) vsyscall page is the long page in the kernel portion
 740  * of the address space that has user-accessible permissions.
 741  */
 742 static bool is_vsyscall_vaddr(unsigned long vaddr)
 743 {
 744         return unlikely((vaddr & PAGE_MASK) == VSYSCALL_ADDR);
 745 }
 746
 747 static void
 748 __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
 749                        unsigned long address, u32 pkey, int si_code)
 750 {
 751         struct task_struct *tsk = current;
 752
 753         /* User mode accesses just cause a SIGSEGV */
 754         if (user_mode(regs) && (error_code & X86_PF_USER)) {
 755                 /*
 756                  * It's possible to have interrupts off here:
 757                  */
 758                 local_irq_enable();
 759
 760                 /*
 761                  * Valid to do another page fault here because this one came
 762                  * from user space:
 763                  */
 764                 if (is_prefetch(regs, error_code, address))
 765                         return;
 766
 767                 if (is_errata100(regs, address))
 768                         return;
 769
 770                 /*
 771                  * To avoid leaking information about the kernel page table
 772                  * layout, pretend that user-mode accesses to kernel addresses
 773                  * are always protection faults.
 774                  */
 775                 if (address >= TASK_SIZE_MAX)
 776                         error_code |= X86_PF_PROT;
 777
 778                 if (likely(show_unhandled_signals))
 779                         show_signal_msg(regs, error_code, address, tsk);
 780
 781                 set_signal_archinfo(address, error_code);
 782
 783                 if (si_code == SEGV_PKUERR)
 784                         force_sig_pkuerr((void __user *)address, pkey);
 785
 786                 force_sig_fault(SIGSEGV, si_code, (void __user *)address);
 787
 788                 return;
 789         }
 790
 791         if (is_f00f_bug(regs, address))
 792                 return;
 793
 794         no_context(regs, error_code, address, SIGSEGV, si_code);
 795 }
 796
 797 static noinline void
 798 bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
 799                      unsigned long address)
 800 {
 801         __bad_area_nosemaphore(regs, error_code, address, 0, SEGV_MAPERR);
 802 }
 803
 804 static void
 805 __bad_area(struct pt_regs *regs, unsigned long error_code,
 806            unsigned long address, u32 pkey, int si_code)
 807 {
 808         struct mm_struct *mm = current->mm;
 809         /*
 810          * Something tried to access memory that isn't in our memory map..
 811          * Fix it, but check if it's kernel or user first..
 812          */
 813         up_read(&mm->mmap_sem);
 814
 815         __bad_area_nosemaphore(regs, error_code, address, pkey, si_code);
 816 }
 817
 818 static noinline void
 819 bad_area(struct pt_regs *regs, unsigned long error_code, unsigned long address)
 820 {
 821         __bad_area(regs, error_code, address, 0, SEGV_MAPERR);
 822 }
 823
 824 static inline bool bad_area_access_from_pkeys(unsigned long error_code,
 825                 struct vm_area_struct *vma)
 826 {
 827         /* This code is always called on the current mm */
 828         bool foreign = false;
 829
 830         if (!boot_cpu_has(X86_FEATURE_OSPKE))
 831                 return false;
 832         if (error_code & X86_PF_PK)
 833                 return true;
 834         /* this checks permission keys on the VMA: */
 835         if (!arch_vma_access_permitted(vma, (error_code & X86_PF_WRITE),
 836                                        (error_code & X86_PF_INSTR), foreign))
 837                 return true;
 838         return false;
 839 }
 840
 841 static noinline void
 842 bad_area_access_error(struct pt_regs *regs, unsigned long error_code,
 843                       unsigned long address, struct vm_area_struct *vma)
 844 {
 845         /*
 846          * This OSPKE check is not strictly necessary at runtime.
 847          * But, doing it this way allows compiler optimizations
 848          * if pkeys are compiled out.
 849          */
 850         if (bad_area_access_from_pkeys(error_code, vma)) {
 851                 /*
 852                  * A protection key fault means that the PKRU value did not allow
 853                  * access to some PTE.  Userspace can figure out what PKRU was
 854                  * from the XSAVE state.  This function captures the pkey from
 855                  * the vma and passes it to userspace so userspace can discover
 856                  * which protection key was set on the PTE.
 857                  *
 858                  * If we get here, we know that the hardware signaled a X86_PF_PK
 859                  * fault and that there was a VMA once we got in the fault
 860                  * handler.  It does *not* guarantee that the VMA we find here
 861                  * was the one that we faulted on.
 862                  *
 863                  * 1. T1   : mprotect_key(foo, PAGE_SIZE, pkey=4);
 864                  * 2. T1   : set PKRU to deny access to pkey=4, touches page
 865                  * 3. T1   : faults...
 866                  * 4.    T2: mprotect_key(foo, PAGE_SIZE, pkey=5);
 867                  * 5. T1   : enters fault handler, takes mmap_sem, etc...
 868                  * 6. T1   : reaches here, sees vma_pkey(vma)=5, when we really
 869                  *           faulted on a pte with its pkey=4.
 870                  */
 871                 u32 pkey = vma_pkey(vma);
 872
 873                 __bad_area(regs, error_code, address, pkey, SEGV_PKUERR);
 874         } else {
 875                 __bad_area(regs, error_code, address, 0, SEGV_ACCERR);
 876         }
 877 }
 878
 879 static void
 880 do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,
 881           vm_fault_t fault)
 882 {
 883         /* Kernel mode? Handle exceptions or die: */
 884         if (!(error_code & X86_PF_USER)) {
 885                 no_context(regs, error_code, address, SIGBUS, BUS_ADRERR);
 886                 return;
 887         }
 888
 889         /* User-space => ok to do another page fault: */
 890         if (is_prefetch(regs, error_code, address))
 891                 return;
 892
 893         set_signal_archinfo(address, error_code);
 894
 895 #ifdef CONFIG_MEMORY_FAILURE
 896         if (fault & (VM_FAULT_HWPOISON|VM_FAULT_HWPOISON_LARGE)) {
 897                 struct task_struct *tsk = current;
 898                 unsigned lsb = 0;
 899
 900                 pr_err(
 901         "MCE: Killing %s:%d due to hardware memory corruption fault at %lx\n",
 902                         tsk->comm, tsk->pid, address);
 903                 if (fault & VM_FAULT_HWPOISON_LARGE)
 904                         lsb = hstate_index_to_shift(VM_FAULT_GET_HINDEX(fault));
 905                 if (fault & VM_FAULT_HWPOISON)
 906                         lsb = PAGE_SHIFT;
 907                 force_sig_mceerr(BUS_MCEERR_AR, (void __user *)address, lsb);
 908                 return;
 909         }
 910 #endif
 911         force_sig_fault(SIGBUS, BUS_ADRERR, (void __user *)address);
 912 }
 913
 914 static noinline void
 915 mm_fault_error(struct pt_regs *regs, unsigned long error_code,
 916                unsigned long address, vm_fault_t fault)
 917 {
 918         if (fatal_signal_pending(current) && !(error_code & X86_PF_USER)) {
 919                 no_context(regs, error_code, address, 0, 0);
 920                 return;
 921         }
 922
 923         if (fault & VM_FAULT_OOM) {
 924                 /* Kernel mode? Handle exceptions or die: */
 925                 if (!(error_code & X86_PF_USER)) {
 926                         no_context(regs, error_code, address,
 927                                    SIGSEGV, SEGV_MAPERR);
 928                         return;
 929                 }
 930
 931                 /*
 932                  * We ran out of memory, call the OOM killer, and return the
 933                  * userspace (which will retry the fault, or kill us if we got
 934                  * oom-killed):
 935                  */
 936                 pagefault_out_of_memory();
 937         } else {
 938                 if (fault & (VM_FAULT_SIGBUS|VM_FAULT_HWPOISON|
 939                              VM_FAULT_HWPOISON_LARGE))
 940                         do_sigbus(regs, error_code, address, fault);
 941                 else if (fault & VM_FAULT_SIGSEGV)
 942                         bad_area_nosemaphore(regs, error_code, address);
 943                 else
 944                         BUG();
 945         }
 946 }
 947
 948 static int spurious_kernel_fault_check(unsigned long error_code, pte_t *pte)
 949 {
 950         if ((error_code & X86_PF_WRITE) && !pte_write(*pte))
 951                 return 0;
 952
 953         if ((error_code & X86_PF_INSTR) && !pte_exec(*pte))
 954                 return 0;
 955
 956         return 1;
 957 }
 958
 959 /*
 960  * Handle a spurious fault caused by a stale TLB entry.
 961  *
 962  * This allows us to lazily refresh the TLB when increasing the
 963  * permissions of a kernel page (RO -> RW or NX -> X).  Doing it
 964  * eagerly is very expensive since that implies doing a full
 965  * cross-processor TLB flush, even if no stale TLB entries exist
 966  * on other processors.
 967  *
 968  * Spurious faults may only occur if the TLB contains an entry with
 969  * fewer permission than the page table entry.  Non-present (P = 0)
 970  * and reserved bit (R = 1) faults are never spurious.
 971  *
 972  * There are no security implications to leaving a stale TLB when
 973  * increasing the permissions on a page.
 974  *
 975  * Returns non-zero if a spurious fault was handled, zero otherwise.
 976  *
 977  * See Intel Developer's Manual Vol 3 Section 4.10.4.3, bullet 3
 978  * (Optional Invalidation).
 979  */
 980 static noinline int
 981 spurious_kernel_fault(unsigned long error_code, unsigned long address)
 982 {
 983         pgd_t *pgd;
 984         p4d_t *p4d;
 985         pud_t *pud;
 986         pmd_t *pmd;
 987         pte_t *pte;
 988         int ret;
 989
 990         /*
 991          * Only writes to RO or instruction fetches from NX may cause
 992          * spurious faults.
 993          *
 994          * These could be from user or supervisor accesses but the TLB
 995          * is only lazily flushed after a kernel mapping protection
 996          * change, so user accesses are not expected to cause spurious
 997          * faults.
 998          */
 999         if (error_code != (X86_PF_WRITE | X86_PF_PROT) &&
1000             error_code != (X86_PF_INSTR | X86_PF_PROT))
1001                 return 0;
1002
1003         pgd = init_mm.pgd + pgd_index(address);
1004         if (!pgd_present(*pgd))
1005                 return 0;
1006
1007         p4d = p4d_offset(pgd, address);
1008         if (!p4d_present(*p4d))
1009                 return 0;
1010
1011         if (p4d_large(*p4d))
1012                 return spurious_kernel_fault_check(error_code, (pte_t *) p4d);
1013
1014         pud = pud_offset(p4d, address);
1015         if (!pud_present(*pud))
1016                 return 0;
1017
1018         if (pud_large(*pud))
1019                 return spurious_kernel_fault_check(error_code, (pte_t *) pud);
1020
1021         pmd = pmd_offset(pud, address);
1022         if (!pmd_present(*pmd))
1023                 return 0;
1024
1025         if (pmd_large(*pmd))
1026                 return spurious_kernel_fault_check(error_code, (pte_t *) pmd);
1027
1028         pte = pte_offset_kernel(pmd, address);
1029         if (!pte_present(*pte))
1030                 return 0;
1031
1032         ret = spurious_kernel_fault_check(error_code, pte);
1033         if (!ret)
1034                 return 0;
1035
1036         /*
1037          * Make sure we have permissions in PMD.
1038          * If not, then there's a bug in the page tables:
1039          */
1040         ret = spurious_kernel_fault_check(error_code, (pte_t *) pmd);
1041         WARN_ONCE(!ret, "PMD has incorrect permission bits\n");
1042
1043         return ret;
1044 }
1045 NOKPROBE_SYMBOL(spurious_kernel_fault);
1046
1047 int show_unhandled_signals = 1;
1048
1049 static inline int
1050 access_error(unsigned long error_code, struct vm_area_struct *vma)
1051 {
1052         /* This is only called for the current mm, so: */
1053         bool foreign = false;
1054
1055         /*
1056          * Read or write was blocked by protection keys.  This is
1057          * always an unconditional error and can never result in
1058          * a follow-up action to resolve the fault, like a COW.
1059          */
1060         if (error_code & X86_PF_PK)
1061                 return 1;
1062
1063         /*
1064          * Make sure to check the VMA so that we do not perform
1065          * faults just to hit a X86_PF_PK as soon as we fill in a
1066          * page.
1067          */
1068         if (!arch_vma_access_permitted(vma, (error_code & X86_PF_WRITE),
1069                                        (error_code & X86_PF_INSTR), foreign))
1070                 return 1;
1071
1072         if (error_code & X86_PF_WRITE) {
1073                 /* write, present and write, not present: */
1074                 if (unlikely(!(vma->vm_flags & VM_WRITE)))
1075                         return 1;
1076                 return 0;
1077         }
1078
1079         /* read, present: */
1080         if (unlikely(error_code & X86_PF_PROT))
1081                 return 1;
1082
1083         /* read, not present: */
1084         if (unlikely(!vma_is_accessible(vma)))
1085                 return 1;
1086
1087         return 0;
1088 }
1089
1090 static int fault_in_kernel_space(unsigned long address)
1091 {
1092         /*
1093          * On 64-bit systems, the vsyscall page is at an address above
1094          * TASK_SIZE_MAX, but is not considered part of the kernel
1095          * address space.
1096          */
1097         if (IS_ENABLED(CONFIG_X86_64) && is_vsyscall_vaddr(address))
1098                 return false;
1099
1100         return address >= TASK_SIZE_MAX;
1101 }
1102
1103 /*
1104  * Called for all faults where 'address' is part of the kernel address
1105  * space.  Might get called for faults that originate from *code* that
1106  * ran in userspace or the kernel.
1107  */
1108 static void
1109 do_kern_addr_fault(struct pt_regs *regs, unsigned long hw_error_code,
1110                    unsigned long address)
1111 {
1112         /*
1113          * Protection keys exceptions only happen on user pages.  We
1114          * have no user pages in the kernel portion of the address
1115          * space, so do not expect them here.
1116          */
1117         WARN_ON_ONCE(hw_error_code & X86_PF_PK);
1118
1119         /* Was the fault spurious, caused by lazy TLB invalidation? */
1120         if (spurious_kernel_fault(hw_error_code, address))
1121                 return;
1122
1123         /* kprobes don't want to hook the spurious faults: */
1124         if (kprobe_page_fault(regs, X86_TRAP_PF))
1125                 return;
1126
1127         /*
1128          * Note, despite being a "bad area", there are quite a few
1129          * acceptable reasons to get here, such as erratum fixups
1130          * and handling kernel code that can fault, like get_user().
1131          *
1132          * Don't take the mm semaphore here. If we fixup a prefetch
1133          * fault we could otherwise deadlock:
1134          */
1135         bad_area_nosemaphore(regs, hw_error_code, address);
1136 }
1137 NOKPROBE_SYMBOL(do_kern_addr_fault);
1138
1139 /* Handle faults in the user portion of the address space */
1140 static inline
1141 void do_user_addr_fault(struct pt_regs *regs,
1142                         unsigned long hw_error_code,
1143                         unsigned long address)
1144 {
1145         struct vm_area_struct *vma;
1146         struct task_struct *tsk;
1147         struct mm_struct *mm;
1148         vm_fault_t fault, major = 0;
1149         unsigned int flags = FAULT_FLAG_DEFAULT;
1150
1151         tsk = current;
1152         mm = tsk->mm;
1153
1154         /* kprobes don't want to hook the spurious faults: */
1155         if (unlikely(kprobe_page_fault(regs, X86_TRAP_PF)))
1156                 return;
1157
1158         /*
1159          * Reserved bits are never expected to be set on
1160          * entries in the user portion of the page tables.
1161          */
1162         if (unlikely(hw_error_code & X86_PF_RSVD))
1163                 pgtable_bad(regs, hw_error_code, address);
1164
1165         /*
1166          * If SMAP is on, check for invalid kernel (supervisor) access to user
1167          * pages in the user address space.  The odd case here is WRUSS,
1168          * which, according to the preliminary documentation, does not respect
1169          * SMAP and will have the USER bit set so, in all cases, SMAP
1170          * enforcement appears to be consistent with the USER bit.
1171          */
1172         if (unlikely(cpu_feature_enabled(X86_FEATURE_SMAP) &&
1173                      !(hw_error_code & X86_PF_USER) &&
1174                      !(regs->flags & X86_EFLAGS_AC)))
1175         {
1176                 bad_area_nosemaphore(regs, hw_error_code, address);
1177                 return;
1178         }
1179
1180         /*
1181          * If we're in an interrupt, have no user context or are running
1182          * in a region with pagefaults disabled then we must not take the fault
1183          */
1184         if (unlikely(faulthandler_disabled() || !mm)) {
1185                 bad_area_nosemaphore(regs, hw_error_code, address);
1186                 return;
1187         }
1188
1189         /*
1190          * It's safe to allow irq's after cr2 has been saved and the
1191          * vmalloc fault has been handled.
1192          *
1193          * User-mode registers count as a user access even for any
1194          * potential system fault or CPU buglet:
1195          */
1196         if (user_mode(regs)) {
1197                 local_irq_enable();
1198                 flags |= FAULT_FLAG_USER;
1199         } else {
1200                 if (regs->flags & X86_EFLAGS_IF)
1201                         local_irq_enable();
1202         }
1203
1204         perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, address);
1205
1206         if (hw_error_code & X86_PF_WRITE)
1207                 flags |= FAULT_FLAG_WRITE;
1208         if (hw_error_code & X86_PF_INSTR)
1209                 flags |= FAULT_FLAG_INSTRUCTION;
1210
1211 #ifdef CONFIG_X86_64
1212         /*
1213          * Faults in the vsyscall page might need emulation.  The
1214          * vsyscall page is at a high address (>PAGE_OFFSET), but is
1215          * considered to be part of the user address space.
1216          *
1217          * The vsyscall page does not have a "real" VMA, so do this
1218          * emulation before we go searching for VMAs.
1219          *
1220          * PKRU never rejects instruction fetches, so we don't need
1221          * to consider the PF_PK bit.
1222          */
1223         if (is_vsyscall_vaddr(address)) {
1224                 if (emulate_vsyscall(hw_error_code, regs, address))
1225                         return;
1226         }
1227 #endif
1228
1229         /*
1230          * Kernel-mode access to the user address space should only occur
1231          * on well-defined single instructions listed in the exception
1232          * tables.  But, an erroneous kernel fault occurring outside one of
1233          * those areas which also holds mmap_sem might deadlock attempting
1234          * to validate the fault against the address space.
1235          *
1236          * Only do the expensive exception table search when we might be at
1237          * risk of a deadlock.  This happens if we
1238          * 1. Failed to acquire mmap_sem, and
1239          * 2. The access did not originate in userspace.
1240          */
1241         if (unlikely(!down_read_trylock(&mm->mmap_sem))) {
1242                 if (!user_mode(regs) && !search_exception_tables(regs->ip)) {
1243                         /*
1244                          * Fault from code in kernel from
1245                          * which we do not expect faults.
1246                          */
1247                         bad_area_nosemaphore(regs, hw_error_code, address);
1248                         return;
1249                 }
1250 retry:
1251                 down_read(&mm->mmap_sem);
1252         } else {
1253                 /*
1254                  * The above down_read_trylock() might have succeeded in
1255                  * which case we'll have missed the might_sleep() from
1256                  * down_read():
1257                  */
1258                 might_sleep();
1259         }
1260
1261         vma = find_vma(mm, address);
1262         if (unlikely(!vma)) {
1263                 bad_area(regs, hw_error_code, address);
1264                 return;
1265         }
1266         if (likely(vma->vm_start <= address))
1267                 goto good_area;
1268         if (unlikely(!(vma->vm_flags & VM_GROWSDOWN))) {
1269                 bad_area(regs, hw_error_code, address);
1270                 return;
1271         }
1272         if (unlikely(expand_stack(vma, address))) {
1273                 bad_area(regs, hw_error_code, address);
1274                 return;
1275         }
1276
1277         /*
1278          * Ok, we have a good vm_area for this memory access, so
1279          * we can handle it..
1280          */
1281 good_area:
1282         if (unlikely(access_error(hw_error_code, vma))) {
1283                 bad_area_access_error(regs, hw_error_code, address, vma);
1284                 return;
1285         }
1286
1287         /*
1288          * If for any reason at all we couldn't handle the fault,
1289          * make sure we exit gracefully rather than endlessly redo
1290          * the fault.  Since we never set FAULT_FLAG_RETRY_NOWAIT, if
1291          * we get VM_FAULT_RETRY back, the mmap_sem has been unlocked.
1292          *
1293          * Note that handle_userfault() may also release and reacquire mmap_sem
1294          * (and not return with VM_FAULT_RETRY), when returning to userland to
1295          * repeat the page fault later with a VM_FAULT_NOPAGE retval
1296          * (potentially after handling any pending signal during the return to
1297          * userland). The return to userland is identified whenever
1298          * FAULT_FLAG_USER|FAULT_FLAG_KILLABLE are both set in flags.
1299          */
1300         fault = handle_mm_fault(vma, address, flags);
1301         major |= fault & VM_FAULT_MAJOR;
1302
1303         /* Quick path to respond to signals */
1304         if (fault_signal_pending(fault, regs)) {
1305                 if (!user_mode(regs))
1306                         no_context(regs, hw_error_code, address, SIGBUS,
1307                                    BUS_ADRERR);
1308                 return;
1309         }
1310
1311         /*
1312          * If we need to retry the mmap_sem has already been released,
1313          * and if there is a fatal signal pending there is no guarantee
1314          * that we made any progress. Handle this case first.
1315          */
1316         if (unlikely((fault & VM_FAULT_RETRY) &&
1317                      (flags & FAULT_FLAG_ALLOW_RETRY))) {
1318                 flags |= FAULT_FLAG_TRIED;
1319                 goto retry;
1320         }
1321
1322         up_read(&mm->mmap_sem);
1323         if (unlikely(fault & VM_FAULT_ERROR)) {
1324                 mm_fault_error(regs, hw_error_code, address, fault);
1325                 return;
1326         }
1327
1328         /*
1329          * Major/minor page fault accounting. If any of the events
1330          * returned VM_FAULT_MAJOR, we account it as a major fault.
1331          */
1332         if (major) {
1333                 tsk->maj_flt++;
1334                 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs, address);
1335         } else {
1336                 tsk->min_flt++;
1337                 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address);
1338         }
1339
1340         check_v8086_mode(regs, address, tsk);
1341 }
1342 NOKPROBE_SYMBOL(do_user_addr_fault);
1343
1344 static __always_inline void
1345 trace_page_fault_entries(struct pt_regs *regs, unsigned long error_code,
1346                          unsigned long address)
1347 {
1348         if (!trace_pagefault_enabled())
1349                 return;
1350
1351         if (user_mode(regs))
1352                 trace_page_fault_user(address, regs, error_code);
1353         else
1354                 trace_page_fault_kernel(address, regs, error_code);
1355 }
1356
1357 dotraplinkage void
1358 do_page_fault(struct pt_regs *regs, unsigned long hw_error_code,
1359                 unsigned long address)
1360 {
1361         prefetchw(&current->mm->mmap_sem);
1362         trace_page_fault_entries(regs, hw_error_code, address);
1363
1364         if (unlikely(kmmio_fault(regs, address)))
1365                 return;
1366
1367         /* Was the fault on kernel-controlled part of the address space? */
1368         if (unlikely(fault_in_kernel_space(address)))
1369                 do_kern_addr_fault(regs, hw_error_code, address);
1370         else
1371                 do_user_addr_fault(regs, hw_error_code, address);
1372 }
1373 NOKPROBE_SYMBOL(do_page_fault);