2 * Based on arch/arm/mm/fault.c
4 * Copyright (C) 1995 Linus Torvalds
5 * Copyright (C) 1995-2004 Russell King
6 * Copyright (C) 2012 ARM Ltd.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include <linux/extable.h>
22 #include <linux/signal.h>
24 #include <linux/hardirq.h>
25 #include <linux/init.h>
26 #include <linux/kprobes.h>
27 #include <linux/uaccess.h>
28 #include <linux/page-flags.h>
29 #include <linux/sched/signal.h>
30 #include <linux/sched/debug.h>
31 #include <linux/highmem.h>
32 #include <linux/perf_event.h>
33 #include <linux/preempt.h>
34 #include <linux/hugetlb.h>
37 #include <asm/cpufeature.h>
38 #include <asm/exception.h>
39 #include <asm/debug-monitors.h>
41 #include <asm/sysreg.h>
42 #include <asm/system_misc.h>
43 #include <asm/pgtable.h>
44 #include <asm/tlbflush.h>
46 #include <acpi/ghes.h>
49 int (*fn)(unsigned long addr, unsigned int esr,
50 struct pt_regs *regs);
56 static const struct fault_info fault_info[];
58 static inline const struct fault_info *esr_to_fault_info(unsigned int esr)
60 return fault_info + (esr & 63);
64 static inline int notify_page_fault(struct pt_regs *regs, unsigned int esr)
68 /* kprobe_running() needs smp_processor_id() */
69 if (!user_mode(regs)) {
71 if (kprobe_running() && kprobe_fault_handler(regs, esr))
79 static inline int notify_page_fault(struct pt_regs *regs, unsigned int esr)
86 * Dump out the page tables associated with 'addr' in the currently active mm.
88 void show_pte(unsigned long addr)
93 if (addr < TASK_SIZE) {
95 mm = current->active_mm;
97 pr_alert("[%016lx] user address but active_mm is swapper\n",
101 } else if (addr >= VA_START) {
105 pr_alert("[%016lx] address between user and kernel address ranges\n",
110 pr_alert("%s pgtable: %luk pages, %u-bit VAs, pgd = %p\n",
111 mm == &init_mm ? "swapper" : "user", PAGE_SIZE / SZ_1K,
113 pgd = pgd_offset(mm, addr);
114 pr_alert("[%016lx] *pgd=%016llx", addr, pgd_val(*pgd));
121 if (pgd_none(*pgd) || pgd_bad(*pgd))
124 pud = pud_offset(pgd, addr);
125 pr_cont(", *pud=%016llx", pud_val(*pud));
126 if (pud_none(*pud) || pud_bad(*pud))
129 pmd = pmd_offset(pud, addr);
130 pr_cont(", *pmd=%016llx", pmd_val(*pmd));
131 if (pmd_none(*pmd) || pmd_bad(*pmd))
134 pte = pte_offset_map(pmd, addr);
135 pr_cont(", *pte=%016llx", pte_val(*pte));
142 #ifdef CONFIG_ARM64_HW_AFDBM
144 * This function sets the access flags (dirty, accessed), as well as write
145 * permission, and only to a more permissive setting.
147 * It needs to cope with hardware update of the accessed/dirty state by other
148 * agents in the system and can safely skip the __sync_icache_dcache() call as,
149 * like set_pte_at(), the PTE is never changed from no-exec to exec here.
151 * Returns whether or not the PTE actually changed.
153 int ptep_set_access_flags(struct vm_area_struct *vma,
154 unsigned long address, pte_t *ptep,
155 pte_t entry, int dirty)
160 if (pte_same(*ptep, entry))
163 /* only preserve the access flags and write permission */
164 pte_val(entry) &= PTE_AF | PTE_WRITE | PTE_DIRTY;
166 /* set PTE_RDONLY if actual read-only or clean PTE */
167 if (!pte_write(entry) || !pte_sw_dirty(entry))
168 pte_val(entry) |= PTE_RDONLY;
171 * Setting the flags must be done atomically to avoid racing with the
172 * hardware update of the access/dirty state. The PTE_RDONLY bit must
173 * be set to the most permissive (lowest value) of *ptep and entry
174 * (calculated as: a & b == ~(~a | ~b)).
176 pte_val(entry) ^= PTE_RDONLY;
177 asm volatile("// ptep_set_access_flags\n"
178 " prfm pstl1strm, %2\n"
180 " eor %0, %0, %3 // negate PTE_RDONLY in *ptep\n"
181 " orr %0, %0, %4 // set flags\n"
182 " eor %0, %0, %3 // negate final PTE_RDONLY\n"
183 " stxr %w1, %0, %2\n"
185 : "=&r" (old_pteval), "=&r" (tmp), "+Q" (pte_val(*ptep))
186 : "L" (PTE_RDONLY), "r" (pte_val(entry)));
188 flush_tlb_fix_spurious_fault(vma, address);
193 static bool is_el1_instruction_abort(unsigned int esr)
195 return ESR_ELx_EC(esr) == ESR_ELx_EC_IABT_CUR;
198 static inline bool is_permission_fault(unsigned int esr, struct pt_regs *regs,
201 unsigned int ec = ESR_ELx_EC(esr);
202 unsigned int fsc_type = esr & ESR_ELx_FSC_TYPE;
204 if (ec != ESR_ELx_EC_DABT_CUR && ec != ESR_ELx_EC_IABT_CUR)
207 if (fsc_type == ESR_ELx_FSC_PERM)
210 if (addr < USER_DS && system_uses_ttbr0_pan())
211 return fsc_type == ESR_ELx_FSC_FAULT &&
212 (regs->pstate & PSR_PAN_BIT);
218 * The kernel tried to access some page that wasn't present.
220 static void __do_kernel_fault(unsigned long addr, unsigned int esr,
221 struct pt_regs *regs)
226 * Are we prepared to handle this kernel fault?
227 * We are almost certainly not prepared to handle instruction faults.
229 if (!is_el1_instruction_abort(esr) && fixup_exception(regs))
233 * No handler, we'll have to terminate things with extreme prejudice.
237 if (is_permission_fault(esr, regs, addr)) {
238 if (esr & ESR_ELx_WNR)
239 msg = "write to read-only memory";
241 msg = "read from unreadable memory";
242 } else if (addr < PAGE_SIZE) {
243 msg = "NULL pointer dereference";
245 msg = "paging request";
248 pr_alert("Unable to handle kernel %s at virtual address %08lx\n", msg,
252 die("Oops", regs, esr);
258 * Something tried to access memory that isn't in our memory map. User mode
259 * accesses just cause a SIGSEGV
261 static void __do_user_fault(struct task_struct *tsk, unsigned long addr,
262 unsigned int esr, unsigned int sig, int code,
263 struct pt_regs *regs, int fault)
266 const struct fault_info *inf;
267 unsigned int lsb = 0;
269 if (unhandled_signal(tsk, sig) && show_unhandled_signals_ratelimited()) {
270 inf = esr_to_fault_info(esr);
271 pr_info("%s[%d]: unhandled %s (%d) at 0x%08lx, esr 0x%03x",
272 tsk->comm, task_pid_nr(tsk), inf->name, sig,
274 print_vma_addr(KERN_CONT ", in ", regs->pc);
279 tsk->thread.fault_address = addr;
280 tsk->thread.fault_code = esr;
284 si.si_addr = (void __user *)addr;
286 * Either small page or large page may be poisoned.
287 * In other words, VM_FAULT_HWPOISON_LARGE and
288 * VM_FAULT_HWPOISON are mutually exclusive.
290 if (fault & VM_FAULT_HWPOISON_LARGE)
291 lsb = hstate_index_to_shift(VM_FAULT_GET_HINDEX(fault));
292 else if (fault & VM_FAULT_HWPOISON)
294 si.si_addr_lsb = lsb;
296 force_sig_info(sig, &si, tsk);
299 static void do_bad_area(unsigned long addr, unsigned int esr, struct pt_regs *regs)
301 struct task_struct *tsk = current;
302 const struct fault_info *inf;
305 * If we are in kernel mode at this point, we have no context to
306 * handle this fault with.
308 if (user_mode(regs)) {
309 inf = esr_to_fault_info(esr);
310 __do_user_fault(tsk, addr, esr, inf->sig, inf->code, regs, 0);
312 __do_kernel_fault(addr, esr, regs);
315 #define VM_FAULT_BADMAP 0x010000
316 #define VM_FAULT_BADACCESS 0x020000
318 static int __do_page_fault(struct mm_struct *mm, unsigned long addr,
319 unsigned int mm_flags, unsigned long vm_flags,
320 struct task_struct *tsk)
322 struct vm_area_struct *vma;
325 vma = find_vma(mm, addr);
326 fault = VM_FAULT_BADMAP;
329 if (unlikely(vma->vm_start > addr))
333 * Ok, we have a good vm_area for this memory access, so we can handle
338 * Check that the permissions on the VMA allow for the fault which
341 if (!(vma->vm_flags & vm_flags)) {
342 fault = VM_FAULT_BADACCESS;
346 return handle_mm_fault(vma, addr & PAGE_MASK, mm_flags);
349 if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
355 static bool is_el0_instruction_abort(unsigned int esr)
357 return ESR_ELx_EC(esr) == ESR_ELx_EC_IABT_LOW;
360 static int __kprobes do_page_fault(unsigned long addr, unsigned int esr,
361 struct pt_regs *regs)
363 struct task_struct *tsk;
364 struct mm_struct *mm;
365 int fault, sig, code, major = 0;
366 unsigned long vm_flags = VM_READ | VM_WRITE;
367 unsigned int mm_flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;
369 if (notify_page_fault(regs, esr))
376 * If we're in an interrupt or have no user context, we must not take
379 if (faulthandler_disabled() || !mm)
383 mm_flags |= FAULT_FLAG_USER;
385 if (is_el0_instruction_abort(esr)) {
387 } else if ((esr & ESR_ELx_WNR) && !(esr & ESR_ELx_CM)) {
389 mm_flags |= FAULT_FLAG_WRITE;
392 if (addr < USER_DS && is_permission_fault(esr, regs, addr)) {
393 /* regs->orig_addr_limit may be 0 if we entered from EL0 */
394 if (regs->orig_addr_limit == KERNEL_DS)
395 die("Accessing user space memory with fs=KERNEL_DS", regs, esr);
397 if (is_el1_instruction_abort(esr))
398 die("Attempting to execute userspace memory", regs, esr);
400 if (!search_exception_tables(regs->pc))
401 die("Accessing user space memory outside uaccess.h routines", regs, esr);
404 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS, 1, regs, addr);
407 * As per x86, we may deadlock here. However, since the kernel only
408 * validly references user space from well defined areas of the code,
409 * we can bug out early if this is from code which shouldn't.
411 if (!down_read_trylock(&mm->mmap_sem)) {
412 if (!user_mode(regs) && !search_exception_tables(regs->pc))
415 down_read(&mm->mmap_sem);
418 * The above down_read_trylock() might have succeeded in which
419 * case, we'll have missed the might_sleep() from down_read().
422 #ifdef CONFIG_DEBUG_VM
423 if (!user_mode(regs) && !search_exception_tables(regs->pc))
428 fault = __do_page_fault(mm, addr, mm_flags, vm_flags, tsk);
429 major |= fault & VM_FAULT_MAJOR;
431 if (fault & VM_FAULT_RETRY) {
433 * If we need to retry but a fatal signal is pending,
434 * handle the signal first. We do not need to release
435 * the mmap_sem because it would already be released
436 * in __lock_page_or_retry in mm/filemap.c.
438 if (fatal_signal_pending(current))
442 * Clear FAULT_FLAG_ALLOW_RETRY to avoid any risk of
445 if (mm_flags & FAULT_FLAG_ALLOW_RETRY) {
446 mm_flags &= ~FAULT_FLAG_ALLOW_RETRY;
447 mm_flags |= FAULT_FLAG_TRIED;
451 up_read(&mm->mmap_sem);
454 * Handle the "normal" (no error) case first.
456 if (likely(!(fault & (VM_FAULT_ERROR | VM_FAULT_BADMAP |
457 VM_FAULT_BADACCESS)))) {
459 * Major/minor page fault accounting is only done
460 * once. If we go through a retry, it is extremely
461 * likely that the page will be found in page cache at
466 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MAJ, 1, regs,
470 perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs,
478 * If we are in kernel mode at this point, we have no context to
479 * handle this fault with.
481 if (!user_mode(regs))
484 if (fault & VM_FAULT_OOM) {
486 * We ran out of memory, call the OOM killer, and return to
487 * userspace (which will retry the fault, or kill us if we got
490 pagefault_out_of_memory();
494 if (fault & VM_FAULT_SIGBUS) {
496 * We had some memory, but were unable to successfully fix up
501 } else if (fault & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE)) {
503 code = BUS_MCEERR_AR;
506 * Something tried to access memory that isn't in our memory
510 code = fault == VM_FAULT_BADACCESS ?
511 SEGV_ACCERR : SEGV_MAPERR;
514 __do_user_fault(tsk, addr, esr, sig, code, regs, fault);
518 __do_kernel_fault(addr, esr, regs);
523 * First Level Translation Fault Handler
525 * We enter here because the first level page table doesn't contain a valid
526 * entry for the address.
528 * If the address is in kernel space (>= TASK_SIZE), then we are probably
529 * faulting in the vmalloc() area.
531 * If the init_task's first level page tables contains the relevant entry, we
532 * copy the it to this task. If not, we send the process a signal, fixup the
533 * exception, or oops the kernel.
535 * NOTE! We MUST NOT take any locks for this case. We may be in an interrupt
536 * or a critical region, and should only copy the information from the master
537 * page table, nothing more.
539 static int __kprobes do_translation_fault(unsigned long addr,
541 struct pt_regs *regs)
543 if (addr < TASK_SIZE)
544 return do_page_fault(addr, esr, regs);
546 do_bad_area(addr, esr, regs);
550 static int do_alignment_fault(unsigned long addr, unsigned int esr,
551 struct pt_regs *regs)
553 do_bad_area(addr, esr, regs);
558 * This abort handler always returns "fault".
560 static int do_bad(unsigned long addr, unsigned int esr, struct pt_regs *regs)
566 * This abort handler deals with Synchronous External Abort.
567 * It calls notifiers, and then returns "fault".
569 static int do_sea(unsigned long addr, unsigned int esr, struct pt_regs *regs)
572 const struct fault_info *inf;
575 inf = esr_to_fault_info(esr);
576 pr_err("Synchronous External Abort: %s (0x%08x) at 0x%016lx\n",
577 inf->name, esr, addr);
580 * Synchronous aborts may interrupt code which had interrupts masked.
581 * Before calling out into the wider kernel tell the interested
584 if (IS_ENABLED(CONFIG_ACPI_APEI_SEA)) {
585 if (interrupts_enabled(regs))
588 ret = ghes_notify_sea();
590 if (interrupts_enabled(regs))
594 info.si_signo = SIGBUS;
597 if (esr & ESR_ELx_FnV)
600 info.si_addr = (void __user *)addr;
601 arm64_notify_die("", regs, &info, esr);
606 static const struct fault_info fault_info[] = {
607 { do_bad, SIGBUS, 0, "ttbr address size fault" },
608 { do_bad, SIGBUS, 0, "level 1 address size fault" },
609 { do_bad, SIGBUS, 0, "level 2 address size fault" },
610 { do_bad, SIGBUS, 0, "level 3 address size fault" },
611 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 0 translation fault" },
612 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 1 translation fault" },
613 { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 2 translation fault" },
614 { do_page_fault, SIGSEGV, SEGV_MAPERR, "level 3 translation fault" },
615 { do_bad, SIGBUS, 0, "unknown 8" },
616 { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 1 access flag fault" },
617 { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 2 access flag fault" },
618 { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 3 access flag fault" },
619 { do_bad, SIGBUS, 0, "unknown 12" },
620 { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 1 permission fault" },
621 { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 2 permission fault" },
622 { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 3 permission fault" },
623 { do_sea, SIGBUS, 0, "synchronous external abort" },
624 { do_bad, SIGBUS, 0, "unknown 17" },
625 { do_bad, SIGBUS, 0, "unknown 18" },
626 { do_bad, SIGBUS, 0, "unknown 19" },
627 { do_sea, SIGBUS, 0, "level 0 (translation table walk)" },
628 { do_sea, SIGBUS, 0, "level 1 (translation table walk)" },
629 { do_sea, SIGBUS, 0, "level 2 (translation table walk)" },
630 { do_sea, SIGBUS, 0, "level 3 (translation table walk)" },
631 { do_sea, SIGBUS, 0, "synchronous parity or ECC error" },
632 { do_bad, SIGBUS, 0, "unknown 25" },
633 { do_bad, SIGBUS, 0, "unknown 26" },
634 { do_bad, SIGBUS, 0, "unknown 27" },
635 { do_sea, SIGBUS, 0, "level 0 synchronous parity error (translation table walk)" },
636 { do_sea, SIGBUS, 0, "level 1 synchronous parity error (translation table walk)" },
637 { do_sea, SIGBUS, 0, "level 2 synchronous parity error (translation table walk)" },
638 { do_sea, SIGBUS, 0, "level 3 synchronous parity error (translation table walk)" },
639 { do_bad, SIGBUS, 0, "unknown 32" },
640 { do_alignment_fault, SIGBUS, BUS_ADRALN, "alignment fault" },
641 { do_bad, SIGBUS, 0, "unknown 34" },
642 { do_bad, SIGBUS, 0, "unknown 35" },
643 { do_bad, SIGBUS, 0, "unknown 36" },
644 { do_bad, SIGBUS, 0, "unknown 37" },
645 { do_bad, SIGBUS, 0, "unknown 38" },
646 { do_bad, SIGBUS, 0, "unknown 39" },
647 { do_bad, SIGBUS, 0, "unknown 40" },
648 { do_bad, SIGBUS, 0, "unknown 41" },
649 { do_bad, SIGBUS, 0, "unknown 42" },
650 { do_bad, SIGBUS, 0, "unknown 43" },
651 { do_bad, SIGBUS, 0, "unknown 44" },
652 { do_bad, SIGBUS, 0, "unknown 45" },
653 { do_bad, SIGBUS, 0, "unknown 46" },
654 { do_bad, SIGBUS, 0, "unknown 47" },
655 { do_bad, SIGBUS, 0, "TLB conflict abort" },
656 { do_bad, SIGBUS, 0, "unknown 49" },
657 { do_bad, SIGBUS, 0, "unknown 50" },
658 { do_bad, SIGBUS, 0, "unknown 51" },
659 { do_bad, SIGBUS, 0, "implementation fault (lockdown abort)" },
660 { do_bad, SIGBUS, 0, "implementation fault (unsupported exclusive)" },
661 { do_bad, SIGBUS, 0, "unknown 54" },
662 { do_bad, SIGBUS, 0, "unknown 55" },
663 { do_bad, SIGBUS, 0, "unknown 56" },
664 { do_bad, SIGBUS, 0, "unknown 57" },
665 { do_bad, SIGBUS, 0, "unknown 58" },
666 { do_bad, SIGBUS, 0, "unknown 59" },
667 { do_bad, SIGBUS, 0, "unknown 60" },
668 { do_bad, SIGBUS, 0, "section domain fault" },
669 { do_bad, SIGBUS, 0, "page domain fault" },
670 { do_bad, SIGBUS, 0, "unknown 63" },
674 * Handle Synchronous External Aborts that occur in a guest kernel.
676 * The return value will be zero if the SEA was successfully handled
677 * and non-zero if there was an error processing the error or there was
678 * no error to process.
680 int handle_guest_sea(phys_addr_t addr, unsigned int esr)
684 if (IS_ENABLED(CONFIG_ACPI_APEI_SEA))
685 ret = ghes_notify_sea();
691 * Dispatch a data abort to the relevant handler.
693 asmlinkage void __exception do_mem_abort(unsigned long addr, unsigned int esr,
694 struct pt_regs *regs)
696 const struct fault_info *inf = esr_to_fault_info(esr);
699 if (!inf->fn(addr, esr, regs))
702 pr_alert("Unhandled fault: %s (0x%08x) at 0x%016lx\n",
703 inf->name, esr, addr);
705 info.si_signo = inf->sig;
707 info.si_code = inf->code;
708 info.si_addr = (void __user *)addr;
709 arm64_notify_die("", regs, &info, esr);
713 * Handle stack alignment exceptions.
715 asmlinkage void __exception do_sp_pc_abort(unsigned long addr,
717 struct pt_regs *regs)
720 struct task_struct *tsk = current;
722 if (show_unhandled_signals && unhandled_signal(tsk, SIGBUS))
723 pr_info_ratelimited("%s[%d]: %s exception: pc=%p sp=%p\n",
724 tsk->comm, task_pid_nr(tsk),
725 esr_get_class_string(esr), (void *)regs->pc,
728 info.si_signo = SIGBUS;
730 info.si_code = BUS_ADRALN;
731 info.si_addr = (void __user *)addr;
732 arm64_notify_die("Oops - SP/PC alignment exception", regs, &info, esr);
735 int __init early_brk64(unsigned long addr, unsigned int esr,
736 struct pt_regs *regs);
739 * __refdata because early_brk64 is __init, but the reference to it is
740 * clobbered at arch_initcall time.
741 * See traps.c and debug-monitors.c:debug_traps_init().
743 static struct fault_info __refdata debug_fault_info[] = {
744 { do_bad, SIGTRAP, TRAP_HWBKPT, "hardware breakpoint" },
745 { do_bad, SIGTRAP, TRAP_HWBKPT, "hardware single-step" },
746 { do_bad, SIGTRAP, TRAP_HWBKPT, "hardware watchpoint" },
747 { do_bad, SIGBUS, 0, "unknown 3" },
748 { do_bad, SIGTRAP, TRAP_BRKPT, "aarch32 BKPT" },
749 { do_bad, SIGTRAP, 0, "aarch32 vector catch" },
750 { early_brk64, SIGTRAP, TRAP_BRKPT, "aarch64 BRK" },
751 { do_bad, SIGBUS, 0, "unknown 7" },
754 void __init hook_debug_fault_code(int nr,
755 int (*fn)(unsigned long, unsigned int, struct pt_regs *),
756 int sig, int code, const char *name)
758 BUG_ON(nr < 0 || nr >= ARRAY_SIZE(debug_fault_info));
760 debug_fault_info[nr].fn = fn;
761 debug_fault_info[nr].sig = sig;
762 debug_fault_info[nr].code = code;
763 debug_fault_info[nr].name = name;
766 asmlinkage int __exception do_debug_exception(unsigned long addr,
768 struct pt_regs *regs)
770 const struct fault_info *inf = debug_fault_info + DBG_ESR_EVT(esr);
775 * Tell lockdep we disabled irqs in entry.S. Do nothing if they were
776 * already disabled to preserve the last enabled/disabled addresses.
778 if (interrupts_enabled(regs))
779 trace_hardirqs_off();
781 if (!inf->fn(addr, esr, regs)) {
784 pr_alert("Unhandled debug exception: %s (0x%08x) at 0x%016lx\n",
785 inf->name, esr, addr);
787 info.si_signo = inf->sig;
789 info.si_code = inf->code;
790 info.si_addr = (void __user *)addr;
791 arm64_notify_die("", regs, &info, 0);
795 if (interrupts_enabled(regs))
800 NOKPROBE_SYMBOL(do_debug_exception);
802 #ifdef CONFIG_ARM64_PAN
803 int cpu_enable_pan(void *__unused)
806 * We modify PSTATE. This won't work from irq context as the PSTATE
807 * is discarded once we return from the exception.
809 WARN_ON_ONCE(in_interrupt());
811 config_sctlr_el1(SCTLR_EL1_SPAN, 0);
812 asm(SET_PSTATE_PAN(1));
815 #endif /* CONFIG_ARM64_PAN */