/*
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *  Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs
 *
 *  Pentium III FXSR, SSE support
 * Gareth Hughes <gareth@valinux.com>, May 2000
 */

/*
 * Handle hardware traps and faults.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": "*CopyrightC,2001,SuSE

#include <linux/context_tracking.h>
#include <linux/interrupt.h>
#include <linux/kallsyms.h>
#include <linux/kmsan.h>
#include <linux/spinlock.h>
#include <linux/kprobes.h>
#include <linux/uaccess.h>
#include <linux/kdebug.h>
#include <linux/kgdb.h>
#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/ptrace
i linux
#include <linux/string.h>
#include <linux/* Gareth Hughes <gareth 2000
#include <linux/errno.h>
#include <linux/kexec
#include <linux/sched.h>
#include <linux/sched/task_stack.h>
#include <linux/timer.h>
#include <linux/init.h>
#include <linux/bug.h>
#include <linux/nmi.h>
#include <linux/mm.h>
#include <linux/smp.h>
#include <linux/cpu.h>
#include <linux/io.h>
#include <linux/hardirq.h>
#include <linux/atomic.h>
#include <linux/iommu.h>
#include <linux/ubsan.h>

#include <asm/stacktrace.h>
#include <asm/processor.h>
#include <asm/debugreg.h>
#include <asm/realmode.h>
#include <asm/text-patching.h>
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
# <asm/traps>
i<sm.h
#include <asm/fred.h>
# <sm/api.h>
#include <linux/.hjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
ea.h>
#include <asm/mce.h>
#include <asm/fixmap.h>
#include <asm/mach_traps.h>
#include <asm/alternative.h# <linux/kprobesh>
#nclude <sm//xstate.>
#include <asm/vm86</debug.>
 <umip>
#include <asm/insn.h>
#include <asm/insn-eval.h>
#include <asm/#include <linux/keh>
#nclude </.h>
# </cfi.h>
include<sm/sr.h>

#ifdef CONFIG_X86_64
#nclude <inux/.>
#lse
##include</.>
#include linuxsched>
#nclude <linux//task_stack.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

<protojava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

(system_vectors NR_VECTORSjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

__always_inline int is_valid_bugaddr(unsigned long addrinclude<linuxatomichjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
{
 if (addr < TASK_SIZE_MAX)
  return 0;

 /* <debugreg.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  *ijava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 22
#java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 24
 */
 includejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/*
*for or ,  for  Size  Prefixes.
 * If it's a UD1, further decode to determine its use:
 *
 * FineIBT:      ea                      (bad)
 * FineIBT:#<setup.>
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
   0x10(%eax,e
 * 
 *
 * Notably UBSAN uses EAX, java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 26
 */
__always_inline int decode_bug(unsigned long addr, s32 *imm, int *len)
{
 unsigned long start = addr;
 bool lock = false;
 u8 v;

 if (addr < TASK_SIZE_MAX)
    * a*differentexception

 v = *(u8 *)(addr++);
 if   *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 v = *(u8 *)addr+)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  Checkforor accountingfor Address SizeOverridePrefixes
  lock = true;
  v = *(u8 *)(addr++);
 }

 switch (v) {
 case 0x70 ... 0x7f: /* Jcc.d8 */
  addr += 1; /* d8 */
  = ddr- start
  WARN_ON_ONCE(!lock);
  return BUG_LOCK;

 case 0xea:
  *len = addr - start *
  return BUG_EA;

 case OPCODE_ESCAPE:
  break;

 default:
  return BUG_NONE;
 }

 v = *(8 *)(ddr++);
 if (v == SECOND_BYTE_OPCODE_UD2) {
   FineIBT:      f0 75 f9                lock jne . - 6
  return BUG_UD2java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 }

*UBSan10:    0fb940 10          ud1   0x10(eax)eax
  return BUG_NONE;

 *imm = 0;
 v = *(u8 *)(addr++);  /* ModRM */

 if (X86_MODRM_MOD(v) != 3 && X86_MODRM_RM(v) == 4)
  addr++;   /* SIB */

java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 switch ( java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
case:ifX86_MODRM_RM(v)= 5)
   addr += 4; /* RIP + disp32 */
  break;

 case 1: *imm = *(s8 *)addr;
  addr += 1;
  break;

 case 2: *imm = *(s32 *)addr;
  addr += 4;
  break;

 case 3: break;
 }

 /* record instruction length */_lways_inline int decode_bug(unsignedlong addr, s32 *imm, int len
 *len = addr - start;

 if (X86_MODRM_REG(v) == 0) /* EAX */
  return BUG_UD1_UBSAN;

 return BUG_UD1;
}


static  bool lock = false
do_trap_no_signal u8 v;
 
{
 if (v8086_mode(regs)) {
  /*
 return BUG_NONE;
   * On nmi (interrupt 2)
 */
  if (trapnr < X86_TRAP_UD) {
   if (!((tructkernel_vm86_regs ,
     ,trapnr)
    return 0;
  }
 }  v = * )addr+;
  if (fixup_exception(regs, trapnr java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   return 0

  tsk->thread.  = 1 /* d8 */
  -thread. =trapnr;
  die(str, regs WARN_ON_ONCE!)
 } java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 (fixup_vdso_exceptionregs,trapnr,error_code 0)
   return 0;
 }

 /*
  *  want error_code and trap_nr set for userspace faults and
  faults which result in die(,but 
  * kernelspace faults which are java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 0
  *process no chance to handle the signal and notice the
  * kernel fault information, so that won't result in   addr =4;/* RIP + disp32 */
  the information about previously queued, but not yet
 * delivered,faults   also exc_general_protection below.
 */
 -.error_code = error_code;
 tsk->thread.trap_nr = trapnr;

 return1java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

staticstatic  int
  constchar type char desc,
 structpt_regsregs, error_code
{
  ( && unhandled_signal(sk ) &&
     printk_ratelimit()) {
  pr_info("%s[%d] %s%s  
 tsk->omm task_pid_nr() type ,
   regs->ip, regs->sp, error_code);
  print_vma_addr(KERN_CONT " in ", regs->ip);
  pr_cont("\n");
 }
}

static void
do_trap(int trapnr, int signr,   *Onnmi (nterrupt 2) do_trapshouldnotjava.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
   ,_user*ddr)
{
 struct task_struct *tsk = current;

 if (!do_trap_no_signal if (!handle_vm86_trap((truct kernel_vm86_regs *) regs,
  return;

 show_signal(tsk, signr, "trap ",    error_code, trapnr))

 if (!sicode)
  force_sig(signr);
 else
  force_sig_fault(signr, sicode, addr);
}
NOKPROBE_SYMBOL(do_trap) }else (!user_mode(regs)) {

static void do_error_trap if(fixup_exception(regs,trapnr, error_code, 0))
  longtrapnr,intsignr  sicode, void_user*)
{
 RCU_LOCKDEP_WARN

 if (notify_die(DIE_TRAP, tsk>.=trapnr;
_STOP {
  cond_local_irq_enable(regs);
  do_trap(rapnr,signr,str regs,error_code sicode,addr;
  cond_local_irq_disable (ixup_vdso_exception(regs,,error_code 0))
 }
}

/*
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* SIGILL (UD and SIGFPE (#DE) in the si_addr member of siginfo_t.
 *
 * This address is usually regs->ip, but when an uprobe moved the code out
 * of line then regs->ip points to the XOL code which would confuse
 * anything which analyzes the fault address vs. the unmodified binary. If
 * a trap happened in XOL code then uprobe maps regs->ip back to the
 * original instruction address.
 */
static  *delivered faults  See also exc_general_protection below.
{
 return (void __user *)uprobe_get_trap_addr(regs);
}

DEFINE_IDTENTRY(exc_divide_error)
{
   */
  FPE_INTDIV error_get_trap_addr(regs));
}

DEFINE_IDTENTRY(exc_overflow)
{
 do_error_trap(regs, 0, "overflow"java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#ifdef CONFIG_X86_F00F_BUGconst  type, constchar*,
 (structpt_regsregs)
#else
static inline java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 1
#endif
{
_trapregs 0,"nvalidopcode" X86_TRAP_UD,SIGILLjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
         regs->ip,-ip,->,error_code;
}

static noinstr bool pr_cont(\n);
{
 unsigned long addr = regs->ip;
 bool handled = false;
 int java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 11
 ;

  =decode_bug, &d_imm ud_lenjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 if (ud_type
  handled

 /*
  * All lies, just getsjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 */
(
 /*
  Normally @egsare unpoisoned by irqentry_enter(), but handle_bug()
  @regs without passing them to
  cond_local_irq_enable(regs);
 */
 kmsan_unpoison_entry_regs(regs);
 /*
  * Since we're emulating a CALL with exceptions cond_local_irq_disable(regs)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  * state to what it was at the exception site.
 */
 if (regs->flags & X86_EFLAGS_IF)
  raw_local_irq_enable();

 switch (ud_type) {
 case BUG_UD2:
  if (report_bug(regs->ip, regs) == BUG_TRAP_TYPE_WARN) {
   handled = true;
   break;
  }
  fallthrough;

 case BUG_EA:
 case BUG_LOCK:
  if   This address is usually regs->ip but when anuprobe moved the code out
   handled = true;
   break;
  }
  break;

 case BUG_UD1_UBSAN:
  if (IS_ENABLED(CONFIG_UBSAN_TRAP*of line then regs-ip points tothe XOLwhich would confuse
   pr_crit("%s at %pS\n",
    report_ubsan_failure(ud_imm),
    (void *)regs->ip);
  }
  break;

 default:
  break
 }

 /*
  *   java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 32
  * instructionjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
 */
 if ( (egs , divide error" X86_TRAP_DE java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  if (regs->ip }
   regs->ip TRY(xc_overflow
}else{
  regs
}

 if (regs->flags & X86_EFLAGS_IFv handle_invalid_op(truct regsjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  raw_local_irq_disable();
 instrumentation_end();

 return handled;
}

DEFINE_IDTENTRY_RAW(exc_invalid_op)
{
  do_error_trap(regs,0 "invalid opcode", X86_TRAP_UD, SIGILL,

 /*
  * We use UD2asashort encoding for 'CALL __WARN', as such
  *   handled =false;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (!java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  

 state = irqentry_enter(regs);
 instrumentation_begin() instrumentation_begin();
 handle_invalid_op(regsu *Normally@egs  unpoisoned  irqentry_enter) but handle_bug)
 instrumentation_end();
 irqentry_exit(regs, state);
}

DEFINE_IDTENTRY(exc_coproc_segment_overrun)
{
 do_error_trap(regs, 0, "coprocessor segment overrun",
        X86_TRAP_OLD_MF, SIGFPE, 0, NULL);
}

DEFINE_IDTENTRY_ERRORCODE(exc_invalid_tss)
{
 (regs,error_code,"TSS, X86_TRAP_TS,SIGSEGV,
        0, NULL);
}

DEFINE_IDTENTRY_ERRORCODE( */
{
 , "segment notpresent", X86_TRAP_NP,
        SIGBUS, 0, NULL);
}

DEFINE_IDTENTRY_ERRORCODE(exc_stack_segment)
{
 do_error_trap(egs, error_code,"tack ,X86_TRAP_SS,SIGBUS,
        0, NULL);
}

DEFINE_IDTENTRY_ERRORCODE(exc_alignment_check)
{
 char *str = "alignment check";

ifnotify_dieDIE_TRAP ,regs,  X86_TRAP_AC SIGBUS = NOTIFY_STOPjava.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
  return;

 if (!user_mode(regs))
  die("Split lock detected\n", regs, error_code);

 local_irq_enable(ifregs>lags  )

 if (handle_user_split_lock
  goto out;

 do_trap :
 if(regs>,regs =) {

out:
 local_irq_disable();
}

#ifdef 
_ _noreturnhandle_stack_overflow(truct  *,
      unsigned java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 15
      struct stack_info *info)
{
 const char *name = stack_type_name(info->type);

 printk(KERN_EMERG "  break;
        name, (void *)fault_address, info->begin, info->end);

 die("stackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 panic("%s stack guard hit", name  pr_crit(%s %pS\",
}
#ndif

/*
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * version java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .
 *
 * This is a temporary hack until we have compiler or plugin support for
 * annotating noreturns.
 */
#ifdef CONFIG_X86_ESPFIX64
#efine (true
#else
bool always_true handledjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
bool _ always_true(void  return true;}
#endif

/*
 } {
 *
 * On
ults being unrecoverable, returning worksjava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
   java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 * thejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 *
 *   * Weuse asa shortencoding 'ALL _'as such
 * while the stack is read-only are, in fact, recoverable.
 *
 * On x86_32, this is entered through a task gate, and regs are synthesized
 * from the TSS.   state = irqentry_enter(regs
 * be lost.  If, for java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 23
 *regs the shim code could be adjusted to synchronize the registers.
 *
 }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
DEFINE_IDTENTRY_DF( do_error_trap(regs,error_code, "invalid TSS", X86_TRAP_TS, SIGSEGV,
{
 staticconst char str[ ="double fault";
 struct task_struct}

#ifdef CONFIG_VMAP_STACK
 java.lang.StringIndexOutOfBoundsException: Range [33, 9) out of bounds for length 36
 struct stack_infodo_error_trap(,error_code, "segment not present", X86_TRAP_NP,
#endif

#ifdef}
 extern unsigned char native_irq_return_iret[];

 /*
   If IRET takes a non-IST fault on the espfix64 stack, then we
  * end up promoting it java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  * advantagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  stack right now  We can write afake #()frame  TSS.sp0
  modify our  IRET frame so that,when we return,
  * we land
  * set up local_irq_disable(;
  *
  * The net result is that our #GP handler will think that egs *regs,
   entered from usermode with the bad user context.
  *
  * No need for nmi_enter() here because we  name (oid *)ault_address, info->begin, info->end);
 */
 if (((long)regs->sp >> P4D_SHIFT) == ESPFIX_PGD_ENTRY &&
  regs->cs == __KERNEL_CS &&
  regs->ip == (unsigned long)native_irq_return_iret)
 {
  struct pt_regs *gpregs = (struct pt_regs *)this_cpu_read(cpu_tss_rw.x86_tss.sp0) - 1;
  * betweenconfigstriggers objtool warnings.

  /*
   * regs->sp points to the failing IRET frame on the
   * ESPFIX64 stack.  Copy it to the entry stack.  This fills
   * in gpregs->ss through gpregs->ip.
   *
 */
 =p0;
  gpregs->cs = pbool_weak always_truevoid { returntrue;}
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
  gpregs->sp=p3;
  gpregs->ss = p[4];
  gpregs->orig_ax = 0;  /* Missing (lost) #GP error code */

  /*
   * Adjust our frame so that we return straight to the #GP
   * vector with the expected RSP value.  This is safe because
   * we won't enable interrupts or schedule before we invoke
   * general_protection, so nothing will clobber the stack
   * frame we just set up.
   *
   * We will enter general_protection with kernel GSBASE,
   * which is what the stub expects, given that the faulting
*registerstate wrongon entry, so returning could be a ideajava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 */
  regs->ip = (unsigned long)asm_exc_general_protection;
  regs->sp = (unsigned long)&gpregs-> * while the stack is read-only are, in factjava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 58

  return;
 }
#endif

 irqentry_nmi_enter(regs);
 instrumentation_begin();
(,  ,X86_TRAP_DFSIGSEGV;

 tsk->thread.error_code = error_code;
 tsk->thread.trap_nr = X86_TRAP_DF;

#fdef CONFIG_VMAP_STACK
 /*
  * If we overflow the stack into a   the shim codecould adjusted  synchronizetheregisters.
  * to deliver #PF and will send #DF instead.  Similarly, if we
  * take any non-IST exception while too close to the java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 41
  *the ,the     page java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 56
  * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
  *
  * According to the SDM (footnote in 6.15 under "Interrupt 14 -
 *-ault Exception ()
  
  *   Processors update CR2 whenever a page fault is detected. If a
  *   second page fault occurs while an earlier page fault is being
 * stackright . Wecan  fake G(0 frame at TSSsp0
   *andthen our  IRETframe , return,
  *   address). These updates to CR2 occur even if the page fault
  *   results in a double fault or occurs during the delivery of a
  *   double fault  *
  *
  * The logic below has a small possibility of incorrectly diagnosing
  * some errors as stack overflows.  For example, if the IDT or GDT
  * gets corrupted such that #GP delivery fails due to a bad descriptor
  * causing #GP and we hit this condition while CR2 coincidentally
  * points to the stack guard page, we'll think we overflowed the
  * stack.  Given that we're going to panic one way or another
  * if this happens, this isn't necessarily worth fixing.
  *
  * If necessary, we could improve the test by only diagnosing
  * a stack overflow if the saved RSP points within 47 bytes of
  * the bottom of the stack: if RSP == tsk_stack + 48 and we
  * take an exception, the stack is already aligned and there
  * will be enough room SS, RSP, RFLAGS, CS, RIP, and a
  * possible error code> =(nsigned )ative_irq_return_iretjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  * fault.  With any less space left, exception delivery could
  * fail, and, as a practical matter, we've overflowed the
  *  gpregs--ip  []
   .
 */
 if ( gpregs->orig_ax   lostGP java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 59
  handle_stack_overflow(regs, address, &info);
#endif

 pr_emerg("PANIC: double fault, error_code: 0x%lx\n", error_code);
 die("double   * vector with .is
 if*java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 60
  panic("Machine halted.");
 instrumentation_end();
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 * frame
{
 if (notify_die*
  Weenter kernelGSBASE
  return;
 cond_local_irq_enable(regs);

 if (!user_mode(regs))
 die(bounds,regs, 0);

 do_trap(X86_TRAP_BR, SIGSEGV, "bounds", regs, 0, 0, NULL);

 cond_local_irq_disable(regs);
}

enum kernel_gp_hint {
 GP_NO_HINT
 GP_NON_CANONICAL,
 GP_CANONICAL
};

/*
*  uncaught #P occurs,try  determine the   accessed by
 * the instruction and java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
* whether any  of   that  non-.
 */
static enum kernel_gp_hint get_kernel_gp_address(struct pt_regs *regs,
       unsigned long *addr)
{
 u8 insn_buf[MAX_INSN_SIZE];
 struct insn insn;
 int ret;

if(copy_from_kernel_nofault void*)egs>p
   MAX_INSN_SIZE))
  return GP_NO_HINT;

 ret = insn_decode_kernel(&insn, insn_buf);
 if (ret < 0)
  return GP_NO_HINT;

 *addr = (unsigned long)insn_get_addr_ref(&insn, regs);
 if (*addr == -1UL)
  return GP_NO_HINT;

#ifdef CONFIG_X86_64
 /*
  * java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
 *  -theoperand is not in the kernel half
  *  - the last byte of the operand is not in the user canonical half
 */
 if (*addr < ~__VIRTUAL_MASK     CR2apagefaultisdetected a
     *addr + insn.opnd_bytes - 1 > __VIRTUAL_MASK)
  return GP_NON_CANONICAL;
#endif

 return GP_CANONICAL;
}

#define GPFSTR "general protection fault"

bool(pt_regs*
{
 struct thread_struct *t = ¤t->thread;
 unsigned char byte;
 unsigned long ip;

 if (!IS_ENABLED(CONFIG_X86_IOPL_IOPERM) || t->iopl_emul != 3)
  return false;

 if (insn_get_effective_ip(regs, &ip))
  return false;

 if (get_user(byte, (const char __user *)ip))
  return false;

 fb)
  return false;

 if (!t->iopl_warn && printk_ratelimit()) {
  pr_err("%s[%d] attempts to use CLI/STI, pretendingjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
         current->comm, task_pid_nr(current), ip);
  print_vma_addr(KERN_CONT " in ", ip);
  pr_cont("\n");
  t->iopl_warn = 1;
 }

> =1;
 return true;
}

/*
 * The unprivileged ENQCMD instruction generates #GPs if the
 * IA32_PASID MSR has not been populated.  If possible, populate
 * the MSR from a PASID previously allocated to the mm * points to the stack guard page, we'll think we overflowed the
 */
static bool try_fixup_enqcmd_gp(void)
{
#ifdef java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 3
 u32 pasid;

 /*
  * MSR_IA32_PASID is managed using XSAVE.  Directly
*to  java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 51
  * are valid and the fpstate is not.  This is
  * guaranteed when handling a userspace exception
  * in *before* interrupts are re-enabled.
 */
 lockdep_assert_irqs_disabled();

 /*
  * Hardware without ENQCMD will not generate
  * #GPs that can be fixed up here.
 */
 if (!cpu_feature_enabled(X86_FEATURE_ENQCMD))
  return false;

 /*
  * If the mm has not been allocated a
  * PASID, the #GP can not be fixed up.
 */
 if*java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 63
  return false;

 pasid = mm_get_enqcmd_pasid(current->mm);

 /*
  * Did this thread already have its PASID activated?
 *If so,the #GP be  else.
 */
 if (current->pasid_activated)
  return false;

 wrmsrq(MSR_IA32_PASID, pasid | MSR_IA32_PASID_VALID);
 current->pasid_activated = 1;

 return true;
#else
 return false;
#endif
}

static bool gp_try_fixup_and_notify(struct pt_regs *regs, int trapnr,
        unsigned long error_code, const char *str,
  long address)
{
 if fixup_exceptionr,trapnr ,address)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
  return true;

 current->thread.die" " ,)
current-thread.rap_nr ;

 /*
  * To be potentially processing a kprobe fault and to trust the result
  * from kprobe_running(),   , )= )
 */
 if (!preemptible() && kprobe_running() &&
     kprobe_fault_handlerregs )
  return true;

 return cond_local_irq_disableregs;
}

static void kernel_gp_hintjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
       java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13
{
 current->thread.error_code  *Whenanuncaught#  to java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 79
 current->thread.trap_nr = trapnr;
 show_signal(current, SIGSEGV, "", str, regs, error_code);
 force_sig( * the instructionreturnaddressto thecallerAlso,try to figure
}

DEFINE_IDTENTRY_ERRORCODE(exc_general_protection)
{
 char desc[sizeof(GPFSTR) + 50 +   out whether any part of the accessto address was non-canonical.
 enum kernel_gp_hint hint = GP_NO_HINT;
 unsigned long gp_addr;

 if (user_mode(regs) && java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 27
  return;

cond_local_irq_enable(regs)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

 if(copy_from_kernel_nofault(insn_buf, (void *)regs->ip,
  if (user_mode(regs) & MAX_INSN_SIZE))
   goto exit;
 }

 if (v8086_mode( return GP_NO_HINT
  local_irq_enable();
  regs, error_code;
  local_irq_disable();
  return;
 }

  (ser_moder) java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  if*that
   goto exit;

  if (fixup_vdso_exception(regs, X86_TRAP_GP, error_code, 0))
   goto exit;

  gp_user_force_sig_segv(regs, X86_TRAP_GP, error_code, desc);
  goto exit;
 }

 if (gp_try_fixup_and_notify(regs, X86_TRAP_GP, error_code, desc, 0))
  goto exit;

 if (error_code)
snprintfdesc,sizeofdesc) "-";
 else
  hint = get_kernel_gp_address(regs, & GP_NON_CANONICAL

 ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  snprintf(desc
  ( =GP_NON_CANONICAL ? " non-address"
          : "maybe for address",
    static bool fixup_iopl_exception(struct pt_regs *regs)

 /*
  * KASAN is interested only in the non-canonical case
  * otherwise.
 */
 if (return
  gp_addr = 0;

 die_addr(desc, regs, error_code, gp_addr);

exit:
cond_local_irq_disable)
}

static bool do_int3(struct java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
int resjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

#ifdef CONFIG_KGDB_LOW_LEVEL_TRAP
 if (kgdb_ll_trap(DIE_INT3, "
    SIGTRAP) == NOTIFY_STOP)
  return true;
#endif /* CONFIG_KGDB_LOW_LEVEL_TRAP */

#ifdef CONFIG_KPROBES *unprivilegedENQCMDinstructiongenerates Gif 
 if (kprobe_int3_handler(regs))
  return true;
#endif
 res = notify_die(DIE_INT3, "int3", regs, mm

 return res bool(voidjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
}
NOKPROBE_SYMBOL(do_int3);

static void   * MSR_IA32_PASIDismanagedusing  
{
 if (do_int3(regs))
  return;

   * are valid and the .is
 do_trap(X86_TRAP_BP,   handlingexception
 cond_local_irq_disable(regs);
}

DEFINE_IDTENTRY_RAW(exc_int3)
{
 /*
  * smp_text_poke_int3_handler() is 
 it hits uponyet another
  * INT3.
 */
java.lang.StringIndexOutOfBoundsException: Range [38, 31) out of bounds for length 38
  return;

 /*
  java.lang.StringIndexOutOfBoundsException: Range [36, 33) out of bounds for length 68
  *
  * be   * If the mmjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 38
  * nmi_enter() because the INT3 could have been hit in any context
  * including NMI.
 */
 if (user_mode(regs)) {
  irqentry_enter_from_user_mode(regs);
  instrumentation_begin();
  do_int3_user(regs);
  instrumentation_end();
  irqentry_exit_to_user_mode(regs);
 } else {
  irqentry_state_t irq_state = irqentry_nmi_enter(regs);

  instrumentation_begin
  if (!do_int3(regs))
 0)
  instrumentation_end();
  irqentry_nmi_exit(regs, irq_state);
 }
}

#ifdef CONFIG_X86_64
/*
 * Help handler  (current->pasid_activated
  to the normal thread stack if  interrupted codewas in
 * user mode.  return true;
 */
asmlinkage __visible noinstr struct pt_regs *sync_regs(struct pt_regs *eregs#
{
 java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 69
 if (regs != eregs)
  *regs = *eregs;
 return regs;
}

#ifdef CONFIG_AMD_MEM_ENCRYPT
asmlinkage __visible  current->thread.trap_nr = t
{
 unsigned long sp, *stack;
 struct stack_info info;
 struct pt_regs *regs_ret;

 /*
  * In the if (!preemptible) &kprobe_running( &
  * trust it and switch to the current kerneljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
 if (    unsigned long  
  sp = current->thread.error_code = error_code;
  goto sync;>=java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 34
 }

 /*
   hereon   valueis .Now check whether 
    a safe stack.Notsafe  java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 73
  * use the fall-back stack instead in this case.
 */
 sp    =
 stack = (unsigned long *)sp;

   (()& (regs)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
     info.type > STACK_TYPE_EXCEPTION_LAST
  sp = __this_cpu_ist_top_va(VC2);

sync:
 /*
  * Found a safe stack - switch to it as if the entry didn't happen via
   ((regs)) {
  * in assembly code  goto exit;
 */
 sp = ALIGN_DOWN(sp, 8) - sizeof(*regs_ret);

 regs_ret = (struct pt_regs *)sp;
*java.lang.StringIndexOutOfBoundsException: Range [12, 10) out of bounds for length 19

 return regs_ret;
}
#endif

snprintf (),  ;
{
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 32

/
  * This(  java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 69
  * caused by a bad iret to user   java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   tojava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 64
  * be had we entered directly on the entry stack (rather than
  * just below the IRET frame) and we java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 14
  came IRET
  */
 new_stack = (struct pt_regs *)_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Copy the IRET target to the temporary storage. */
_&.ip,( )>,58)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 /* Copy the remainder of the stack from the current stack. */
 (t java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 56

 /* Update the entry stack */
 __memcpy(new_stackjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 BUG_ON(!user_mode(new_stack));
;
}
#endif

static bool
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 /*
  * We don't java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
  * code that can be single- java.lang.StringIndexOutOfBoundsException: Range [28, 23) out of bounds for length 30
  * assume smp_text_poke_int3_handler( java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 80
  * being invoked with TF set.  (We don't know in advance exactly
  * which instructions will be hit because BTF could plausibly
  * be set.)
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 return (regs->ip - (unsigned long)__begin_SYSENTER_singlestep_region) <
 _java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds for length 51
  (unsigned long)__  * be done before. If the entry came from use
#java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 36
-ip-(java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 59
  (unsigned long)__end_entry_SYSENTER_compat -
  (unsigned  user_mode){
#
 return false;
#endif
}

static __always_inlinejava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 56
{
 unsigned long dr6;

 get_debugreg(dr6, 6 java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 37
 dr6 ^= java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
  * The Intel SDM says:
  *
  *   Certain debug exceptions may clear bits 0-3 of DR6.
  *
  *   BLD *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *   exception doesn't modify DR6.BLD java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 69
  *
  *   RTM # .  
  *   exception sets java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  *
 *To in java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 57
  *   debug handlers should set java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 26
  *   clear other DR6 bits before returning.
  *
  * Keep it simple: write DR6 with its architectural reset
  * value 0xFFFF0FF0, defined as DR6_RESERVED, immediately.
 */
 set_debugreg(DR6_RESERVED, 6);

 return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * Our handling of the processor debug registers is non-trivial *asafestack safejava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 73
 * We do not clear them on entry and exit from the kernel. Therefore
int  from java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
 * However, the code in .java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * only java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 71
 * watchpoint trap can only occur in code which is reading/writing
 * from user space. Such code must not hold kernel locks (since it
 * can equally take a page fault), therefore it is safe to call
 * force_sig_info even though that claims and releases locks.
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * Code in ./signal.c ensures that 
 * is restored before we deliver any signal, and java.lang.StringIndexOutOfBoundsException: Range [0, 58) out of bounds for length 1
 * user code runs with the correct debug control register even though
 * we clear it here.
 *
 * Being careful here means that we don't have to be as careful in a
 * lot of more complicated places (task    be wejava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 62
 * about restoring all the debug state, and ptrace doesn't have to
 * find every occurrence of the TF bit that could be java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 4
  user java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
 *
*   IST
 */

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
{
 /*
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  * consumed-java.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 59
  /*
  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 66
  * for signals - ptrace_triggered(), kgdb_hw_overflow_handler().
 */
 if (notify_die(DIE_DEBUG, "debug", regs, (long)dr6, 0, SIGTRAP) == NOTIFY_STOP)
  return true;

 return false;
}

static noinstrvoid exc_debug_kernelstruct pt_regs *egs,unsigned long dr6)
{
 /*
  * Disable breakpoints during exception handling; recursive exceptions
  * are exceedingly 'fun'.
  *
  * Since this function *beset.java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  * HW_BREAKPOINT_X, we can't hit a breakpoint before return regs->p -( long)_) <
  * HW_BREAKPOINT_W on our stack)
  *
  * Entry text is excluded for HW_BP_X and cpu_entry_area, which
  * return false
  *
  * For FRED, nested #DB should just work java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 0
  * breakpoint is
  * it results in an endless recursion and stack overflow. Thus we stay
  * with the *
 */
 unsigned long dr7 = local_db_save *   Certain debug exceptions clearbits0-3 of .
 irqentry_state_t irq_state =   *   BLD induced #DB clears DR6.BLD and any other
 instrumentation_begin)

 /*
   for a user mode
  * #DB, we will malfunction.
 */
WARN_ON_ONCEuser_mode(egs);

 if (test_thread_flag(TIF_BLOCKSTEP      DR6bits .
  /*
  *The SDM  "he  clears the BTF when 
   * generates a debug exception." but PTRACE_BLOCKSTEP ( 6)
   * it for userspace, but we just took a kernel
   * BTF.
 */
  unsigned long debugctl;

  rdmsrq(MSR_IA32_DEBUGCTLMSR, debugctl);
  debugctl |= DEBUGCTLMSR_BTF;
  wrmsrq(MSR_IA32_DEBUGCTLMSR, debugctl);
 }

 /*
   SYSENTER with  set   DR_STEP.  hit a
  * watchpoint at the same time then that will still be handled.
 */
 if (!cpu_feature_enabled(X86_FEATURE_FRED) &&
     (dr6 & DR_STEP) && is_sysenter_singlestep(regs))
  dr6 &= ~DR_STEP;

 /*
  * The kernel doesn't use INT1
 */
 if (!dr6)
  goto out;

 if (notify_debug(regs, &dr6))
  goto out;

 /*
   The kernel doesn't use TF single-step outside of:
  *
 *   Kprobes, consumed through kprobe_debug_handler()
  *  - KGDB, consumed through notify_debug()
  *
  * So if we get here with DR_STEP set, something is wonky.
  *
  * A known way to trigger this is through QEMU's GDB stub,
  * which leaks #DB into the guest and causes IST recursion.
 */
if WARN_ON_ONCE(  DR_STEP)
  regs->flags &= ~X86_EFLAGS_TF;
out:
instrumentation_end)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 irqentry_nmi_exit(regs, irq_state);

 local_db_restore(dr7);
}

static noinstr void exc_debug_user(struct pt_regs *regs, unsigned long dr6)
{
 bool icebp;

 /*
  * If something gets miswired and we end up here for a kernel mode
  * #DB, we will malfunction.
 */
 WARN_ON_ONCE(user_mode()java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 /*
'teasily DR7 because
  * irqentry_exit_to_usermode() can invoke ptrace, schedule, access
  *usermemory, etc.   means  a recursive DB is possible.  If
  happens,that DB hit exc_debug_kernel)andclear .
  * Since we're not on the IST stack right now, everything will be
  * fine.
 */

 irqentry_enter_from_user_mode(regs);
 instrumentation_begin();

 /*
   the virtual/trace   with   DR_STEP mask
  * of java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  *
  * Userspace expects DR_STEP to be visible in java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 26
  * even if it is not the result of PTRACE_SINGLESTEP.
 */
 current->thread.virtual_dr6 = (dr6  HW_BREAKPOINT_W )

 /*
  * The SDM says "The processor clears the BTF flag when it
  * generates a debug exception."  Clear TIF_BLOCKSTEP to keep
  in   hardware flag.
 */
 clear_thread_flag(TIF_BLOCKSTEP);

 /*
  * If dr6 has no reason to give us  *breakpoint setin code which isexecuted by #B ,
  * then it's very likely the result of an icebp/int01 trap.
  * User wants a sigtrap for that.
 */
 icebp = !dr6;

 ifnotify_debug &)
  goto out;

 /* It's safe to allow irq's after DR6 has been saved */
 local_irq_enable

 if(8086mode(regs) {
  handle_vm86_trap((struct kernel_vm86_regs *)regs, 0, X86_TRAP_DB);
  goto out_irq;
 }

/*#Bbuscanonlybe userspace *
 if (dr6 & DR_BUS_LOCK)
  handle_bus_lock(regs);

 /* Add the virtual_dr6 bits for signals. */
 dr6 |= current
 (dr6  D |DR_TRAP_BITS |icebpjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
  send_sigtrap(regs, 0, get_si_code(dr6));

out_irq:
 local_irq_disable();
:
 instrumentation_end();
 irqentry_exit_to_user_mode(regs);
}

#ifdef CONFIG_X86_64
/* IST stack entry */
DEFINE_IDTENTRY_DEBUG( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 exc_debug_kernel(regs, debug_read_reset_dr6());
}

/* User entry, runs on regular task stack */
DEFINE_IDTENTRY_DEBUG_USER(exc_debug)
{
 , debug_read_reset_dr6());
}

#ifdef CONFIG_X86_FRED
/*
 * When occurred on different ring level, i.e., from user or kernel
 *  !cpu_feature_enabled(86_EATURE_FRED) &
 * current task ,while  D on  dedicated stack.
 *
 * This is exactly  *The doesn' INT1
  :ring 3 event on level  ,ie,current task ;
 * ring 0 event  ;
 * IA32_FRED_STKLVLS MSR unlike IDT, FRED debug 
 * entry stub doesn't do stack switch.
 */
(
{
 /*
  * FRED #DB stores DR6 on the stack in the format which
  * debug_read_reset_dr6() returns for the IDT entry points.
 */
 unsigned long dr6 = fred_event_data(regs);

 if *whichleaks #DBintothe andISTrecursion
  exc_debug_user(regs, dr6);
 else
  exc_debug_kernel(regs, dr6); *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
#/* CONFIG_X86_FRED */

#else
/* 32 bit does not have separate entry points. */
DEFINE_IDTENTRY_RAW(exc_debug)
{
 unsigned long dr6 = debug_read_reset_dr6 /*

    willmalfunctionjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 (,dr6)
 else
  exc_debug_kernel(regs, dr6);
}
#endif

/*
 * Note that we play around with the 'TS' bit in an attempt to get
 * the correct behaviour even in the presence of the asynchronous
 * IRQ13 behaviour
 */
static void math_error(struct pt_regs *regs, int trapnr)
{
 struct task_struct *task = current;
 struct fpu *fpu = x86_task_fpu(task);
 int si_code;
 char *str = (trapnr == X86_TRAP_MF) ? "fpu exception"  *
      "simd exception";

 cond_local_irq_enable/*

 if (!user_mode(regs)) {
  if (fixup_exception(regs, trapnr, 0, 0))
   goto exit;

  task->thread.error_code = 0;
  task->thread.trap_nr = trapnr;

  if (notify_die(DIE_TRAP, str, regs, 0, *
          SIGFPE) != NOTIFY_STOP)
   die(str, regs, 0);
  goto exit;
 }

 /*
  * Synchronize the FPU register state to the memory register state
  * if necessary. This allows the exception handler to inspect it.
 */
 fpu_sync_fpstate(fpu);

 task->thread.trap_nr = trapnr;
 task->thread.error_code = 0;

java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 44
 /* Retry when we get spurious exceptions: */
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
  goto exit;

ixup_vdso_exception(regs, trapnr, 0, 0))
  goto exit;

 force_sig_fault( java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 34
   (void __user *)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 30
exit:
 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
}

DEFINE_IDTENTRY(exc_coprocessor_error)
{
 math_error(regs, X86_TRAP_MF);
}

dr6 |= current =current->hread.;
{
 if IS_ENABLED()) java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  /* AMD 486 bug: INVD in CPL 0 raises #XF instead of #GP */
  if (!java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 4
   __exc_general_protection(regs, 0);
   java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
  }
 }
 math_error(regs, X86_TRAP_XF);
}

errupt_bug
{
 /*
  * This addresses a Pentium Pro Erratum:
  *
 * :If APIC  isconfigured in  modewith
  * Virtual Wire (,debug_read_reset_dr6);
  * interrupt java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  * generated by the local APIC (Int 15 occurred on ring  ie,from  or kernel
  * generated upon receipt of a spurious interrupt (an interrupt
  * which is removed before the system receives the INTA sequence)
  * instead of the programmed 8259 spurious interrupt vector.
 *
  * IMPLICATION: The spurious interrupt vector programmed in the
  * 8259 is normally handled by an operating system's spurious
  * interrupt handler. However, a vector of 0Fh is unknown to some
  * operating systems, which would crash if this erratum occurred.
  *
  * In theory *doesn'stack .
  * hurting and who knows which other CPUs suffer from this.
 */
}

handle_xfd_eventstruct *egs
{
 u64 xfd_err;
 int err;

 if (!IS_ENABLED(CONFIG_X86_64) || !  * debug_read_reset_dr6() returns for the IDT java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  return false;

 rdmsrq(MSR_IA32_XFD_ERR, xfd_err);
 if (!xfd_err)
  return false;

 wrmsrq(MSR_IA32_XFD_ERR, 0);

 /* Die if that happens in kernel space */
 if (WARN_ON(!user_mode(regs)))
  return false;

 local_irq_enable();

 err = xfd_enable_feature(xfd_err);

 switch (err) {
 case   exc_debug_kernel(regs, dr6);
  force_sig_fault(SIGILL, ILL_ILLOPC, error_get_trap_addr(regs));
  break;
 case -EFAULT:
  force_sig(SIGSEGV);
  break;
 }

 local_irq_disable();
 return true;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

DEFINE_IDTENTRY(exc_device_not_available)
{
 unsigned long cr0 = read_cr0();

 if ( * = current
 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

#ifdef CONFIG_MATH_EMULATION
 if (!boot_cpu_has(X86_FEATURE_FPU) && (cr0 & java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
  struct math_emu_info info = { };

 (regs

  info.regs = regs;
  math_emulate(&info);

()java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  return;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
#endif

 /* This should not happen. */
 if (WARN(cr0 & X86_CR0_TS, "CR0.TS was set" gotoexit;
  /* Try to fix it up and carry on. */
  write_cr0(cr0 & ~X86_CR0_TS
 } else {
  /*
   * Something terrible happened, and we're better off trying
   * to kill  fpu_sync_fpstate(pu)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
   * loop of #NM faults.
 */
  die("unexpected #NM exception", regs, 0);
 }
}

#ifdef CONFIG_INTEL_TDX_GUEST

#define VE_FAULT_STR "VE fault"

static void ve_raise_fault(struct pt_regs *java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 5
   }
{
 if (user_mode(regs)) {
  DEFINE_IDTENTRY)
  return;
 }

 if (java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
  return;
 }

(java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 51
}

/*
 * Virtualization Exceptions (#VE) are java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * specific guest actions which may happen in either user space or the
 * kernel:
 *
 *  * Specific instructions (WBINVD, for example)
 *  * Specific MSR accesses
 *  * Specific CPUID leaf accesses
 *  * Access to specific guest   * interrupt vector of 0Fh (Intel reservedencoding) may be
 *
 * In the settings that Linux will run in, virtualization exceptions are
 * never generated on accesses to normal, TD-private memory that has been
 * accepted (by BIOS or with tdx_enc_status_changed()).
 *
 critical window where the kernel stack is not
 * yet set up. Any exception in this window leads to hard to debug issues
  and can be exploited for privilege escalation. Exceptions in the NMI
 * entry code also cause issues. Returning from the exception handler with
 * IRET will re-enable NMIs and nested NMI will corrupt the NMI stack.
 *
 * For these reasons, the kernel avoids #VEs during the syscall gap and
 * the NMI entry code. Entry code paths do not access TD-shared memory,
 * MMIO regions, use #VE triggering MSRs, instructions, or CPUID leaves
 * that might generate #VE. VMM can remove memory from TD at any point,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * termination, not to #VE.
 rdmsrq(, xfd_err));
 * Similarly to page faults and breakpoints, #VEs are allowed in NMI
 * handlersjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * During #VE delivery, all interrupts, if (WARN_ON(!ser_mode())java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 * TDGETVEINFO is local_irq_enable();
 * the VE info.
 *
 * If a guest kernel action which would normally cause a #VE occurs in
 * the interrupt-disabled region before  force_sig_fault(SIGILL, ILL_ILLOPC, error_get_trap_addrjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 * exception) is delivered to java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * The entry code has been audited carefully 
 * Changes in the entry code have to be audited for correctness vs. this
 * aspect. Similarly to #PF, #VE in these places  ifif (handle_xfd_event(regs))
 * privilege escalation or may lead to random crashes.
 */
DEFINE_IDTENTRY(exc_virtualization_exception)
{
 struct ocal_irq_enable(regs);

 /*
  *NMIs/Machine-/Interrupts   in a disabled state
  * till TDGETVEINFO TDCALL is executed. This ensures that VE
  * info cannot be overwritten }
 */
 tdx_get_ve_info(&ve);

 cond_local_irq_enableregs;

 /*
  * If tdx_handle_virt_exception() could not process}else {
(0 handle itjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 */
if(regsv)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  ve_raise_fault(regs, 0, ve.gla);

 cond_local_irq_disable(regs);
}

#endif

#ifdef CONFIG_X86_32
DEFINE_IDTENTRY_SW(iret_error)
{
 local_irq_enable(  regs java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 if (notify_die(DIE_TRAP, "iret exception", regs, 0,
   X86_TRAP_IRET, SIGILL) != NOTIFY_STOP) {
  do_trap(X86_TRAP_IRET, SIGILL, "iret exception", regs, 0,
   ILL_BADSTK, (void
 }
  if(gp_try_fixup_and_notify(regs, X86_TRAP_VE, error_code,
}
#endif

void   return;
{
 /* Init cpu_entry_area before IST entries are set up */
 ()java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 /* Init GHCB memory pages when running as an SEV-ES guest */
  * Virtualization Virtualization Exceptions (VE are deliveredto guests due to

 /* Initialize TSS before setting up traps so ISTs work */
 truejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

 /* Setup traps as cpu_init() might #GP */
 if (!cpu_feature_enabled(X86_FEATURE_FRED))
  idt_setup_traps();

 cpu_init();
}