arch/x86/kernel/kprobes/core.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Kernel Probes (KProbes)
   4  *
   5  * Copyright (C) IBM Corporation, 2002, 2004
   6  *
   7  * 2002-Oct     Created by Vamsi Krishna S <vamsi_krishna@in.ibm.com> Kernel
   8  *              Probes initial implementation ( includes contributions from
   9  *              Rusty Russell).
  10  * 2004-July    Suparna Bhattacharya <suparna@in.ibm.com> added jumper probes
  11  *              interface to access function arguments.
  12  * 2004-Oct     Jim Keniston <jkenisto@us.ibm.com> and Prasanna S Panchamukhi
  13  *              <prasanna@in.ibm.com> adapted for x86_64 from i386.
  14  * 2005-Mar     Roland McGrath <roland@redhat.com>
  15  *              Fixed to handle %rip-relative addressing mode correctly.
  16  * 2005-May     Hien Nguyen <hien@us.ibm.com>, Jim Keniston
  17  *              <jkenisto@us.ibm.com> and Prasanna S Panchamukhi
  18  *              <prasanna@in.ibm.com> added function-return probes.
  19  * 2005-May     Rusty Lynch <rusty.lynch@intel.com>
  20  *              Added function return probes functionality
  21  * 2006-Feb     Masami Hiramatsu <hiramatu@sdl.hitachi.co.jp> added
  22  *              kprobe-booster and kretprobe-booster for i386.
  23  * 2007-Dec     Masami Hiramatsu <mhiramat@redhat.com> added kprobe-booster
  24  *              and kretprobe-booster for x86-64
  25  * 2007-Dec     Masami Hiramatsu <mhiramat@redhat.com>, Arjan van de Ven
  26  *              <arjan@infradead.org> and Jim Keniston <jkenisto@us.ibm.com>
  27  *              unified x86 kprobes code.
  28  */
  29 #include <linux/kprobes.h>
  30 #include <linux/ptrace.h>
  31 #include <linux/string.h>
  32 #include <linux/slab.h>
  33 #include <linux/hardirq.h>
  34 #include <linux/preempt.h>
  35 #include <linux/sched/debug.h>
  36 #include <linux/perf_event.h>
  37 #include <linux/extable.h>
  38 #include <linux/kdebug.h>
  39 #include <linux/kallsyms.h>
  40 #include <linux/kgdb.h>
  41 #include <linux/ftrace.h>
  42 #include <linux/kasan.h>
  43 #include <linux/moduleloader.h>
  44 #include <linux/objtool.h>
  45 #include <linux/vmalloc.h>
  46 #include <linux/pgtable.h>
  47
  48 #include <asm/text-patching.h>
  49 #include <asm/cacheflush.h>
  50 #include <asm/desc.h>
  51 #include <linux/uaccess.h>
  52 #include <asm/alternative.h>
  53 #include <asm/insn.h>
  54 #include <asm/debugreg.h>
  55 #include <asm/set_memory.h>
  56
  57 #include "common.h"
  58
  59 DEFINE_PER_CPU(struct kprobe *, current_kprobe) = NULL;
  60 DEFINE_PER_CPU(struct kprobe_ctlblk, kprobe_ctlblk);
  61
  62 #define stack_addr(regs) ((unsigned long *)regs->sp)
  63
  64 #define W(row, b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf)\
  65         (((b0##UL << 0x0)|(b1##UL << 0x1)|(b2##UL << 0x2)|(b3##UL << 0x3) |   \
  66           (b4##UL << 0x4)|(b5##UL << 0x5)|(b6##UL << 0x6)|(b7##UL << 0x7) |   \
  67           (b8##UL << 0x8)|(b9##UL << 0x9)|(ba##UL << 0xa)|(bb##UL << 0xb) |   \
  68           (bc##UL << 0xc)|(bd##UL << 0xd)|(be##UL << 0xe)|(bf##UL << 0xf))    \
  69          << (row % 32))
  70         /*
  71          * Undefined/reserved opcodes, conditional jump, Opcode Extension
  72          * Groups, and some special opcodes can not boost.
  73          * This is non-const and volatile to keep gcc from statically
  74          * optimizing it out, as variable_test_bit makes gcc think only
  75          * *(unsigned long*) is used.
  76          */
  77 static volatile u32 twobyte_is_boostable[256 / 32] = {
  78         /*      0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f          */
  79         /*      ----------------------------------------------          */
  80         W(0x00, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0) | /* 00 */
  81         W(0x10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1) , /* 10 */
  82         W(0x20, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) | /* 20 */
  83         W(0x30, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) , /* 30 */
  84         W(0x40, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) | /* 40 */
  85         W(0x50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) , /* 50 */
  86         W(0x60, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1) | /* 60 */
  87         W(0x70, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1) , /* 70 */
  88         W(0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) | /* 80 */
  89         W(0x90, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1) , /* 90 */
  90         W(0xa0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1) | /* a0 */
  91         W(0xb0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1) , /* b0 */
  92         W(0xc0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1) | /* c0 */
  93         W(0xd0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1) , /* d0 */
  94         W(0xe0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1) | /* e0 */
  95         W(0xf0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0)   /* f0 */
  96         /*      -----------------------------------------------         */
  97         /*      0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f          */
  98 };
  99 #undef W
 100
 101 struct kretprobe_blackpoint kretprobe_blacklist[] = {
 102         {"__switch_to", }, /* This function switches only current task, but
 103                               doesn't switch kernel stack.*/
 104         {NULL, NULL}    /* Terminator */
 105 };
 106
 107 const int kretprobe_blacklist_size = ARRAY_SIZE(kretprobe_blacklist);
 108
 109 static nokprobe_inline void
 110 __synthesize_relative_insn(void *dest, void *from, void *to, u8 op)
 111 {
 112         struct __arch_relative_insn {
 113                 u8 op;
 114                 s32 raddr;
 115         } __packed *insn;
 116
 117         insn = (struct __arch_relative_insn *)dest;
 118         insn->raddr = (s32)((long)(to) - ((long)(from) + 5));
 119         insn->op = op;
 120 }
 121
 122 /* Insert a jump instruction at address 'from', which jumps to address 'to'.*/
 123 void synthesize_reljump(void *dest, void *from, void *to)
 124 {
 125         __synthesize_relative_insn(dest, from, to, JMP32_INSN_OPCODE);
 126 }
 127 NOKPROBE_SYMBOL(synthesize_reljump);
 128
 129 /* Insert a call instruction at address 'from', which calls address 'to'.*/
 130 void synthesize_relcall(void *dest, void *from, void *to)
 131 {
 132         __synthesize_relative_insn(dest, from, to, CALL_INSN_OPCODE);
 133 }
 134 NOKPROBE_SYMBOL(synthesize_relcall);
 135
 136 /*
 137  * Returns non-zero if INSN is boostable.
 138  * RIP relative instructions are adjusted at copying time in 64 bits mode
 139  */
 140 int can_boost(struct insn *insn, void *addr)
 141 {
 142         kprobe_opcode_t opcode;
 143         insn_byte_t prefix;
 144         int i;
 145
 146         if (search_exception_tables((unsigned long)addr))
 147                 return 0;       /* Page fault may occur on this address. */
 148
 149         /* 2nd-byte opcode */
 150         if (insn->opcode.nbytes == 2)
 151                 return test_bit(insn->opcode.bytes[1],
 152                                 (unsigned long *)twobyte_is_boostable);
 153
 154         if (insn->opcode.nbytes != 1)
 155                 return 0;
 156
 157         for_each_insn_prefix(insn, i, prefix) {
 158                 insn_attr_t attr;
 159
 160                 attr = inat_get_opcode_attribute(prefix);
 161                 /* Can't boost Address-size override prefix and CS override prefix */
 162                 if (prefix == 0x2e || inat_is_address_size_prefix(attr))
 163                         return 0;
 164         }
 165
 166         opcode = insn->opcode.bytes[0];
 167
 168         switch (opcode) {
 169         case 0x62:              /* bound */
 170         case 0x70 ... 0x7f:     /* Conditional jumps */
 171         case 0x9a:              /* Call far */
 172         case 0xc0 ... 0xc1:     /* Grp2 */
 173         case 0xcc ... 0xce:     /* software exceptions */
 174         case 0xd0 ... 0xd3:     /* Grp2 */
 175         case 0xd6:              /* (UD) */
 176         case 0xd8 ... 0xdf:     /* ESC */
 177         case 0xe0 ... 0xe3:     /* LOOP*, JCXZ */
 178         case 0xe8 ... 0xe9:     /* near Call, JMP */
 179         case 0xeb:              /* Short JMP */
 180         case 0xf0 ... 0xf4:     /* LOCK/REP, HLT */
 181         case 0xf6 ... 0xf7:     /* Grp3 */
 182         case 0xfe:              /* Grp4 */
 183                 /* ... are not boostable */
 184                 return 0;
 185         case 0xff:              /* Grp5 */
 186                 /* Only indirect jmp is boostable */
 187                 return X86_MODRM_REG(insn->modrm.bytes[0]) == 4;
 188         default:
 189                 return 1;
 190         }
 191 }
 192
 193 static unsigned long
 194 __recover_probed_insn(kprobe_opcode_t *buf, unsigned long addr)
 195 {
 196         struct kprobe *kp;
 197         unsigned long faddr;
 198
 199         kp = get_kprobe((void *)addr);
 200         faddr = ftrace_location(addr);
 201         /*
 202          * Addresses inside the ftrace location are refused by
 203          * arch_check_ftrace_location(). Something went terribly wrong
 204          * if such an address is checked here.
 205          */
 206         if (WARN_ON(faddr && faddr != addr))
 207                 return 0UL;
 208         /*
 209          * Use the current code if it is not modified by Kprobe
 210          * and it cannot be modified by ftrace.
 211          */
 212         if (!kp && !faddr)
 213                 return addr;
 214
 215         /*
 216          * Basically, kp->ainsn.insn has an original instruction.
 217          * However, RIP-relative instruction can not do single-stepping
 218          * at different place, __copy_instruction() tweaks the displacement of
 219          * that instruction. In that case, we can't recover the instruction
 220          * from the kp->ainsn.insn.
 221          *
 222          * On the other hand, in case on normal Kprobe, kp->opcode has a copy
 223          * of the first byte of the probed instruction, which is overwritten
 224          * by int3. And the instruction at kp->addr is not modified by kprobes
 225          * except for the first byte, we can recover the original instruction
 226          * from it and kp->opcode.
 227          *
 228          * In case of Kprobes using ftrace, we do not have a copy of
 229          * the original instruction. In fact, the ftrace location might
 230          * be modified at anytime and even could be in an inconsistent state.
 231          * Fortunately, we know that the original code is the ideal 5-byte
 232          * long NOP.
 233          */
 234         if (copy_from_kernel_nofault(buf, (void *)addr,
 235                 MAX_INSN_SIZE * sizeof(kprobe_opcode_t)))
 236                 return 0UL;
 237
 238         if (faddr)
 239                 memcpy(buf, ideal_nops[NOP_ATOMIC5], 5);
 240         else
 241                 buf[0] = kp->opcode;
 242         return (unsigned long)buf;
 243 }
 244
 245 /*
 246  * Recover the probed instruction at addr for further analysis.
 247  * Caller must lock kprobes by kprobe_mutex, or disable preemption
 248  * for preventing to release referencing kprobes.
 249  * Returns zero if the instruction can not get recovered (or access failed).
 250  */
 251 unsigned long recover_probed_instruction(kprobe_opcode_t *buf, unsigned long addr)
 252 {
 253         unsigned long __addr;
 254
 255         __addr = __recover_optprobed_insn(buf, addr);
 256         if (__addr != addr)
 257                 return __addr;
 258
 259         return __recover_probed_insn(buf, addr);
 260 }
 261
 262 /* Check if paddr is at an instruction boundary */
 263 static int can_probe(unsigned long paddr)
 264 {
 265         unsigned long addr, __addr, offset = 0;
 266         struct insn insn;
 267         kprobe_opcode_t buf[MAX_INSN_SIZE];
 268
 269         if (!kallsyms_lookup_size_offset(paddr, NULL, &offset))
 270                 return 0;
 271
 272         /* Decode instructions */
 273         addr = paddr - offset;
 274         while (addr < paddr) {
 275                 int ret;
 276
 277                 /*
 278                  * Check if the instruction has been modified by another
 279                  * kprobe, in which case we replace the breakpoint by the
 280                  * original instruction in our buffer.
 281                  * Also, jump optimization will change the breakpoint to
 282                  * relative-jump. Since the relative-jump itself is
 283                  * normally used, we just go through if there is no kprobe.
 284                  */
 285                 __addr = recover_probed_instruction(buf, addr);
 286                 if (!__addr)
 287                         return 0;
 288
 289                 ret = insn_decode(&insn, (void *)__addr, MAX_INSN_SIZE, INSN_MODE_KERN);
 290                 if (ret < 0)
 291                         return 0;
 292
 293 #ifdef CONFIG_KGDB
 294                 /*
 295                  * If there is a dynamically installed kgdb sw breakpoint,
 296                  * this function should not be probed.
 297                  */
 298                 if (insn.opcode.bytes[0] == INT3_INSN_OPCODE &&
 299                     kgdb_has_hit_break(addr))
 300                         return 0;
 301 #endif
 302                 addr += insn.length;
 303         }
 304
 305         return (addr == paddr);
 306 }
 307
 308 /*
 309  * Copy an instruction with recovering modified instruction by kprobes
 310  * and adjust the displacement if the instruction uses the %rip-relative
 311  * addressing mode. Note that since @real will be the final place of copied
 312  * instruction, displacement must be adjust by @real, not @dest.
 313  * This returns the length of copied instruction, or 0 if it has an error.
 314  */
 315 int __copy_instruction(u8 *dest, u8 *src, u8 *real, struct insn *insn)
 316 {
 317         kprobe_opcode_t buf[MAX_INSN_SIZE];
 318         unsigned long recovered_insn = recover_probed_instruction(buf, (unsigned long)src);
 319         int ret;
 320
 321         if (!recovered_insn || !insn)
 322                 return 0;
 323
 324         /* This can access kernel text if given address is not recovered */
 325         if (copy_from_kernel_nofault(dest, (void *)recovered_insn,
 326                         MAX_INSN_SIZE))
 327                 return 0;
 328
 329         ret = insn_decode(insn, dest, MAX_INSN_SIZE, INSN_MODE_KERN);
 330         if (ret < 0)
 331                 return 0;
 332
 333         /* We can not probe force emulate prefixed instruction */
 334         if (insn_has_emulate_prefix(insn))
 335                 return 0;
 336
 337         /* Another subsystem puts a breakpoint, failed to recover */
 338         if (insn->opcode.bytes[0] == INT3_INSN_OPCODE)
 339                 return 0;
 340
 341         /* We should not singlestep on the exception masking instructions */
 342         if (insn_masking_exception(insn))
 343                 return 0;
 344
 345 #ifdef CONFIG_X86_64
 346         /* Only x86_64 has RIP relative instructions */
 347         if (insn_rip_relative(insn)) {
 348                 s64 newdisp;
 349                 u8 *disp;
 350                 /*
 351                  * The copied instruction uses the %rip-relative addressing
 352                  * mode.  Adjust the displacement for the difference between
 353                  * the original location of this instruction and the location
 354                  * of the copy that will actually be run.  The tricky bit here
 355                  * is making sure that the sign extension happens correctly in
 356                  * this calculation, since we need a signed 32-bit result to
 357                  * be sign-extended to 64 bits when it's added to the %rip
 358                  * value and yield the same 64-bit result that the sign-
 359                  * extension of the original signed 32-bit displacement would
 360                  * have given.
 361                  */
 362                 newdisp = (u8 *) src + (s64) insn->displacement.value
 363                           - (u8 *) real;
 364                 if ((s64) (s32) newdisp != newdisp) {
 365                         pr_err("Kprobes error: new displacement does not fit into s32 (%llx)\n", newdisp);
 366                         return 0;
 367                 }
 368                 disp = (u8 *) dest + insn_offset_displacement(insn);
 369                 *(s32 *) disp = (s32) newdisp;
 370         }
 371 #endif
 372         return insn->length;
 373 }
 374
 375 /* Prepare reljump or int3 right after instruction */
 376 static int prepare_singlestep(kprobe_opcode_t *buf, struct kprobe *p,
 377                               struct insn *insn)
 378 {
 379         int len = insn->length;
 380
 381         if (!IS_ENABLED(CONFIG_PREEMPTION) &&
 382             !p->post_handler && can_boost(insn, p->addr) &&
 383             MAX_INSN_SIZE - len >= JMP32_INSN_SIZE) {
 384                 /*
 385                  * These instructions can be executed directly if it
 386                  * jumps back to correct address.
 387                  */
 388                 synthesize_reljump(buf + len, p->ainsn.insn + len,
 389                                    p->addr + insn->length);
 390                 len += JMP32_INSN_SIZE;
 391                 p->ainsn.boostable = 1;
 392         } else {
 393                 /* Otherwise, put an int3 for trapping singlestep */
 394                 if (MAX_INSN_SIZE - len < INT3_INSN_SIZE)
 395                         return -ENOSPC;
 396
 397                 buf[len] = INT3_INSN_OPCODE;
 398                 len += INT3_INSN_SIZE;
 399         }
 400
 401         return len;
 402 }
 403
 404 /* Make page to RO mode when allocate it */
 405 void *alloc_insn_page(void)
 406 {
 407         void *page;
 408
 409         page = module_alloc(PAGE_SIZE);
 410         if (!page)
 411                 return NULL;
 412
 413         set_vm_flush_reset_perms(page);
 414         /*
 415          * First make the page read-only, and only then make it executable to
 416          * prevent it from being W+X in between.
 417          */
 418         set_memory_ro((unsigned long)page, 1);
 419
 420         /*
 421          * TODO: Once additional kernel code protection mechanisms are set, ensure
 422          * that the page was not maliciously altered and it is still zeroed.
 423          */
 424         set_memory_x((unsigned long)page, 1);
 425
 426         return page;
 427 }
 428
 429 /* Recover page to RW mode before releasing it */
 430 void free_insn_page(void *page)
 431 {
 432         module_memfree(page);
 433 }
 434
 435 /* Kprobe x86 instruction emulation - only regs->ip or IF flag modifiers */
 436
 437 static void kprobe_emulate_ifmodifiers(struct kprobe *p, struct pt_regs *regs)
 438 {
 439         switch (p->ainsn.opcode) {
 440         case 0xfa:      /* cli */
 441                 regs->flags &= ~(X86_EFLAGS_IF);
 442                 break;
 443         case 0xfb:      /* sti */
 444                 regs->flags |= X86_EFLAGS_IF;
 445                 break;
 446         case 0x9c:      /* pushf */
 447                 int3_emulate_push(regs, regs->flags);
 448                 break;
 449         case 0x9d:      /* popf */
 450                 regs->flags = int3_emulate_pop(regs);
 451                 break;
 452         }
 453         regs->ip = regs->ip - INT3_INSN_SIZE + p->ainsn.size;
 454 }
 455 NOKPROBE_SYMBOL(kprobe_emulate_ifmodifiers);
 456
 457 static void kprobe_emulate_ret(struct kprobe *p, struct pt_regs *regs)
 458 {
 459         int3_emulate_ret(regs);
 460 }
 461 NOKPROBE_SYMBOL(kprobe_emulate_ret);
 462
 463 static void kprobe_emulate_call(struct kprobe *p, struct pt_regs *regs)
 464 {
 465         unsigned long func = regs->ip - INT3_INSN_SIZE + p->ainsn.size;
 466
 467         func += p->ainsn.rel32;
 468         int3_emulate_call(regs, func);
 469 }
 470 NOKPROBE_SYMBOL(kprobe_emulate_call);
 471
 472 static nokprobe_inline
 473 void __kprobe_emulate_jmp(struct kprobe *p, struct pt_regs *regs, bool cond)
 474 {
 475         unsigned long ip = regs->ip - INT3_INSN_SIZE + p->ainsn.size;
 476
 477         if (cond)
 478                 ip += p->ainsn.rel32;
 479         int3_emulate_jmp(regs, ip);
 480 }
 481
 482 static void kprobe_emulate_jmp(struct kprobe *p, struct pt_regs *regs)
 483 {
 484         __kprobe_emulate_jmp(p, regs, true);
 485 }
 486 NOKPROBE_SYMBOL(kprobe_emulate_jmp);
 487
 488 static const unsigned long jcc_mask[6] = {
 489         [0] = X86_EFLAGS_OF,
 490         [1] = X86_EFLAGS_CF,
 491         [2] = X86_EFLAGS_ZF,
 492         [3] = X86_EFLAGS_CF | X86_EFLAGS_ZF,
 493         [4] = X86_EFLAGS_SF,
 494         [5] = X86_EFLAGS_PF,
 495 };
 496
 497 static void kprobe_emulate_jcc(struct kprobe *p, struct pt_regs *regs)
 498 {
 499         bool invert = p->ainsn.jcc.type & 1;
 500         bool match;
 501
 502         if (p->ainsn.jcc.type < 0xc) {
 503                 match = regs->flags & jcc_mask[p->ainsn.jcc.type >> 1];
 504         } else {
 505                 match = ((regs->flags & X86_EFLAGS_SF) >> X86_EFLAGS_SF_BIT) ^
 506                         ((regs->flags & X86_EFLAGS_OF) >> X86_EFLAGS_OF_BIT);
 507                 if (p->ainsn.jcc.type >= 0xe)
 508                         match = match || (regs->flags & X86_EFLAGS_ZF);
 509         }
 510         __kprobe_emulate_jmp(p, regs, (match && !invert) || (!match && invert));
 511 }
 512 NOKPROBE_SYMBOL(kprobe_emulate_jcc);
 513
 514 static void kprobe_emulate_loop(struct kprobe *p, struct pt_regs *regs)
 515 {
 516         bool match;
 517
 518         if (p->ainsn.loop.type != 3) {  /* LOOP* */
 519                 if (p->ainsn.loop.asize == 32)
 520                         match = ((*(u32 *)&regs->cx)--) != 0;
 521 #ifdef CONFIG_X86_64
 522                 else if (p->ainsn.loop.asize == 64)
 523                         match = ((*(u64 *)&regs->cx)--) != 0;
 524 #endif
 525                 else
 526                         match = ((*(u16 *)&regs->cx)--) != 0;
 527         } else {                        /* JCXZ */
 528                 if (p->ainsn.loop.asize == 32)
 529                         match = *(u32 *)(&regs->cx) == 0;
 530 #ifdef CONFIG_X86_64
 531                 else if (p->ainsn.loop.asize == 64)
 532                         match = *(u64 *)(&regs->cx) == 0;
 533 #endif
 534                 else
 535                         match = *(u16 *)(&regs->cx) == 0;
 536         }
 537
 538         if (p->ainsn.loop.type == 0)    /* LOOPNE */
 539                 match = match && !(regs->flags & X86_EFLAGS_ZF);
 540         else if (p->ainsn.loop.type == 1)       /* LOOPE */
 541                 match = match && (regs->flags & X86_EFLAGS_ZF);
 542
 543         __kprobe_emulate_jmp(p, regs, match);
 544 }
 545 NOKPROBE_SYMBOL(kprobe_emulate_loop);
 546
 547 static const int addrmode_regoffs[] = {
 548         offsetof(struct pt_regs, ax),
 549         offsetof(struct pt_regs, cx),
 550         offsetof(struct pt_regs, dx),
 551         offsetof(struct pt_regs, bx),
 552         offsetof(struct pt_regs, sp),
 553         offsetof(struct pt_regs, bp),
 554         offsetof(struct pt_regs, si),
 555         offsetof(struct pt_regs, di),
 556 #ifdef CONFIG_X86_64
 557         offsetof(struct pt_regs, r8),
 558         offsetof(struct pt_regs, r9),
 559         offsetof(struct pt_regs, r10),
 560         offsetof(struct pt_regs, r11),
 561         offsetof(struct pt_regs, r12),
 562         offsetof(struct pt_regs, r13),
 563         offsetof(struct pt_regs, r14),
 564         offsetof(struct pt_regs, r15),
 565 #endif
 566 };
 567
 568 static void kprobe_emulate_call_indirect(struct kprobe *p, struct pt_regs *regs)
 569 {
 570         unsigned long offs = addrmode_regoffs[p->ainsn.indirect.reg];
 571
 572         int3_emulate_push(regs, regs->ip - INT3_INSN_SIZE + p->ainsn.size);
 573         int3_emulate_jmp(regs, regs_get_register(regs, offs));
 574 }
 575 NOKPROBE_SYMBOL(kprobe_emulate_call_indirect);
 576
 577 static void kprobe_emulate_jmp_indirect(struct kprobe *p, struct pt_regs *regs)
 578 {
 579         unsigned long offs = addrmode_regoffs[p->ainsn.indirect.reg];
 580
 581         int3_emulate_jmp(regs, regs_get_register(regs, offs));
 582 }
 583 NOKPROBE_SYMBOL(kprobe_emulate_jmp_indirect);
 584
 585 static int prepare_emulation(struct kprobe *p, struct insn *insn)
 586 {
 587         insn_byte_t opcode = insn->opcode.bytes[0];
 588
 589         switch (opcode) {
 590         case 0xfa:              /* cli */
 591         case 0xfb:              /* sti */
 592         case 0x9c:              /* pushfl */
 593         case 0x9d:              /* popf/popfd */
 594                 /*
 595                  * IF modifiers must be emulated since it will enable interrupt while
 596                  * int3 single stepping.
 597                  */
 598                 p->ainsn.emulate_op = kprobe_emulate_ifmodifiers;
 599                 p->ainsn.opcode = opcode;
 600                 break;
 601         case 0xc2:      /* ret/lret */
 602         case 0xc3:
 603         case 0xca:
 604         case 0xcb:
 605                 p->ainsn.emulate_op = kprobe_emulate_ret;
 606                 break;
 607         case 0x9a:      /* far call absolute -- segment is not supported */
 608         case 0xea:      /* far jmp absolute -- segment is not supported */
 609         case 0xcc:      /* int3 */
 610         case 0xcf:      /* iret -- in-kernel IRET is not supported */
 611                 return -EOPNOTSUPP;
 612                 break;
 613         case 0xe8:      /* near call relative */
 614                 p->ainsn.emulate_op = kprobe_emulate_call;
 615                 if (insn->immediate.nbytes == 2)
 616                         p->ainsn.rel32 = *(s16 *)&insn->immediate.value;
 617                 else
 618                         p->ainsn.rel32 = *(s32 *)&insn->immediate.value;
 619                 break;
 620         case 0xeb:      /* short jump relative */
 621         case 0xe9:      /* near jump relative */
 622                 p->ainsn.emulate_op = kprobe_emulate_jmp;
 623                 if (insn->immediate.nbytes == 1)
 624                         p->ainsn.rel32 = *(s8 *)&insn->immediate.value;
 625                 else if (insn->immediate.nbytes == 2)
 626                         p->ainsn.rel32 = *(s16 *)&insn->immediate.value;
 627                 else
 628                         p->ainsn.rel32 = *(s32 *)&insn->immediate.value;
 629                 break;
 630         case 0x70 ... 0x7f:
 631                 /* 1 byte conditional jump */
 632                 p->ainsn.emulate_op = kprobe_emulate_jcc;
 633                 p->ainsn.jcc.type = opcode & 0xf;
 634                 p->ainsn.rel32 = *(char *)insn->immediate.bytes;
 635                 break;
 636         case 0x0f:
 637                 opcode = insn->opcode.bytes[1];
 638                 if ((opcode & 0xf0) == 0x80) {
 639                         /* 2 bytes Conditional Jump */
 640                         p->ainsn.emulate_op = kprobe_emulate_jcc;
 641                         p->ainsn.jcc.type = opcode & 0xf;
 642                         if (insn->immediate.nbytes == 2)
 643                                 p->ainsn.rel32 = *(s16 *)&insn->immediate.value;
 644                         else
 645                                 p->ainsn.rel32 = *(s32 *)&insn->immediate.value;
 646                 } else if (opcode == 0x01 &&
 647                            X86_MODRM_REG(insn->modrm.bytes[0]) == 0 &&
 648                            X86_MODRM_MOD(insn->modrm.bytes[0]) == 3) {
 649                         /* VM extensions - not supported */
 650                         return -EOPNOTSUPP;
 651                 }
 652                 break;
 653         case 0xe0:      /* Loop NZ */
 654         case 0xe1:      /* Loop */
 655         case 0xe2:      /* Loop */
 656         case 0xe3:      /* J*CXZ */
 657                 p->ainsn.emulate_op = kprobe_emulate_loop;
 658                 p->ainsn.loop.type = opcode & 0x3;
 659                 p->ainsn.loop.asize = insn->addr_bytes * 8;
 660                 p->ainsn.rel32 = *(s8 *)&insn->immediate.value;
 661                 break;
 662         case 0xff:
 663                 /*
 664                  * Since the 0xff is an extended group opcode, the instruction
 665                  * is determined by the MOD/RM byte.
 666                  */
 667                 opcode = insn->modrm.bytes[0];
 668                 if ((opcode & 0x30) == 0x10) {
 669                         if ((opcode & 0x8) == 0x8)
 670                                 return -EOPNOTSUPP;     /* far call */
 671                         /* call absolute, indirect */
 672                         p->ainsn.emulate_op = kprobe_emulate_call_indirect;
 673                 } else if ((opcode & 0x30) == 0x20) {
 674                         if ((opcode & 0x8) == 0x8)
 675                                 return -EOPNOTSUPP;     /* far jmp */
 676                         /* jmp near absolute indirect */
 677                         p->ainsn.emulate_op = kprobe_emulate_jmp_indirect;
 678                 } else
 679                         break;
 680
 681                 if (insn->addr_bytes != sizeof(unsigned long))
 682                         return -EOPNOTSUPP;     /* Don't support differnt size */
 683                 if (X86_MODRM_MOD(opcode) != 3)
 684                         return -EOPNOTSUPP;     /* TODO: support memory addressing */
 685
 686                 p->ainsn.indirect.reg = X86_MODRM_RM(opcode);
 687 #ifdef CONFIG_X86_64
 688                 if (X86_REX_B(insn->rex_prefix.value))
 689                         p->ainsn.indirect.reg += 8;
 690 #endif
 691                 break;
 692         default:
 693                 break;
 694         }
 695         p->ainsn.size = insn->length;
 696
 697         return 0;
 698 }
 699
 700 static int arch_copy_kprobe(struct kprobe *p)
 701 {
 702         struct insn insn;
 703         kprobe_opcode_t buf[MAX_INSN_SIZE];
 704         int ret, len;
 705
 706         /* Copy an instruction with recovering if other optprobe modifies it.*/
 707         len = __copy_instruction(buf, p->addr, p->ainsn.insn, &insn);
 708         if (!len)
 709                 return -EINVAL;
 710
 711         /* Analyze the opcode and setup emulate functions */
 712         ret = prepare_emulation(p, &insn);
 713         if (ret < 0)
 714                 return ret;
 715
 716         /* Add int3 for single-step or booster jmp */
 717         len = prepare_singlestep(buf, p, &insn);
 718         if (len < 0)
 719                 return len;
 720
 721         /* Also, displacement change doesn't affect the first byte */
 722         p->opcode = buf[0];
 723
 724         p->ainsn.tp_len = len;
 725         perf_event_text_poke(p->ainsn.insn, NULL, 0, buf, len);
 726
 727         /* OK, write back the instruction(s) into ROX insn buffer */
 728         text_poke(p->ainsn.insn, buf, len);
 729
 730         return 0;
 731 }
 732
 733 int arch_prepare_kprobe(struct kprobe *p)
 734 {
 735         int ret;
 736
 737         if (alternatives_text_reserved(p->addr, p->addr))
 738                 return -EINVAL;
 739
 740         if (!can_probe((unsigned long)p->addr))
 741                 return -EILSEQ;
 742
 743         memset(&p->ainsn, 0, sizeof(p->ainsn));
 744
 745         /* insn: must be on special executable page on x86. */
 746         p->ainsn.insn = get_insn_slot();
 747         if (!p->ainsn.insn)
 748                 return -ENOMEM;
 749
 750         ret = arch_copy_kprobe(p);
 751         if (ret) {
 752                 free_insn_slot(p->ainsn.insn, 0);
 753                 p->ainsn.insn = NULL;
 754         }
 755
 756         return ret;
 757 }
 758
 759 void arch_arm_kprobe(struct kprobe *p)
 760 {
 761         u8 int3 = INT3_INSN_OPCODE;
 762
 763         text_poke(p->addr, &int3, 1);
 764         text_poke_sync();
 765         perf_event_text_poke(p->addr, &p->opcode, 1, &int3, 1);
 766 }
 767
 768 void arch_disarm_kprobe(struct kprobe *p)
 769 {
 770         u8 int3 = INT3_INSN_OPCODE;
 771
 772         perf_event_text_poke(p->addr, &int3, 1, &p->opcode, 1);
 773         text_poke(p->addr, &p->opcode, 1);
 774         text_poke_sync();
 775 }
 776
 777 void arch_remove_kprobe(struct kprobe *p)
 778 {
 779         if (p->ainsn.insn) {
 780                 /* Record the perf event before freeing the slot */
 781                 perf_event_text_poke(p->ainsn.insn, p->ainsn.insn,
 782                                      p->ainsn.tp_len, NULL, 0);
 783                 free_insn_slot(p->ainsn.insn, p->ainsn.boostable);
 784                 p->ainsn.insn = NULL;
 785         }
 786 }
 787
 788 static nokprobe_inline void
 789 save_previous_kprobe(struct kprobe_ctlblk *kcb)
 790 {
 791         kcb->prev_kprobe.kp = kprobe_running();
 792         kcb->prev_kprobe.status = kcb->kprobe_status;
 793         kcb->prev_kprobe.old_flags = kcb->kprobe_old_flags;
 794         kcb->prev_kprobe.saved_flags = kcb->kprobe_saved_flags;
 795 }
 796
 797 static nokprobe_inline void
 798 restore_previous_kprobe(struct kprobe_ctlblk *kcb)
 799 {
 800         __this_cpu_write(current_kprobe, kcb->prev_kprobe.kp);
 801         kcb->kprobe_status = kcb->prev_kprobe.status;
 802         kcb->kprobe_old_flags = kcb->prev_kprobe.old_flags;
 803         kcb->kprobe_saved_flags = kcb->prev_kprobe.saved_flags;
 804 }
 805
 806 static nokprobe_inline void
 807 set_current_kprobe(struct kprobe *p, struct pt_regs *regs,
 808                    struct kprobe_ctlblk *kcb)
 809 {
 810         __this_cpu_write(current_kprobe, p);
 811         kcb->kprobe_saved_flags = kcb->kprobe_old_flags
 812                 = (regs->flags & X86_EFLAGS_IF);
 813 }
 814
 815 void arch_prepare_kretprobe(struct kretprobe_instance *ri, struct pt_regs *regs)
 816 {
 817         unsigned long *sara = stack_addr(regs);
 818
 819         ri->ret_addr = (kprobe_opcode_t *) *sara;
 820         ri->fp = sara;
 821
 822         /* Replace the return addr with trampoline addr */
 823         *sara = (unsigned long) &kretprobe_trampoline;
 824 }
 825 NOKPROBE_SYMBOL(arch_prepare_kretprobe);
 826
 827 static void kprobe_post_process(struct kprobe *cur, struct pt_regs *regs,
 828                                struct kprobe_ctlblk *kcb)
 829 {
 830         /* Restore back the original saved kprobes variables and continue. */
 831         if (kcb->kprobe_status == KPROBE_REENTER) {
 832                 /* This will restore both kcb and current_kprobe */
 833                 restore_previous_kprobe(kcb);
 834         } else {
 835                 /*
 836                  * Always update the kcb status because
 837                  * reset_curent_kprobe() doesn't update kcb.
 838                  */
 839                 kcb->kprobe_status = KPROBE_HIT_SSDONE;
 840                 if (cur->post_handler)
 841                         cur->post_handler(cur, regs, 0);
 842                 reset_current_kprobe();
 843         }
 844 }
 845 NOKPROBE_SYMBOL(kprobe_post_process);
 846
 847 static void setup_singlestep(struct kprobe *p, struct pt_regs *regs,
 848                              struct kprobe_ctlblk *kcb, int reenter)
 849 {
 850         if (setup_detour_execution(p, regs, reenter))
 851                 return;
 852
 853 #if !defined(CONFIG_PREEMPTION)
 854         if (p->ainsn.boostable) {
 855                 /* Boost up -- we can execute copied instructions directly */
 856                 if (!reenter)
 857                         reset_current_kprobe();
 858                 /*
 859                  * Reentering boosted probe doesn't reset current_kprobe,
 860                  * nor set current_kprobe, because it doesn't use single
 861                  * stepping.
 862                  */
 863                 regs->ip = (unsigned long)p->ainsn.insn;
 864                 return;
 865         }
 866 #endif
 867         if (reenter) {
 868                 save_previous_kprobe(kcb);
 869                 set_current_kprobe(p, regs, kcb);
 870                 kcb->kprobe_status = KPROBE_REENTER;
 871         } else
 872                 kcb->kprobe_status = KPROBE_HIT_SS;
 873
 874         if (p->ainsn.emulate_op) {
 875                 p->ainsn.emulate_op(p, regs);
 876                 kprobe_post_process(p, regs, kcb);
 877                 return;
 878         }
 879
 880         /* Disable interrupt, and set ip register on trampoline */
 881         regs->flags &= ~X86_EFLAGS_IF;
 882         regs->ip = (unsigned long)p->ainsn.insn;
 883 }
 884 NOKPROBE_SYMBOL(setup_singlestep);
 885
 886 /*
 887  * Called after single-stepping.  p->addr is the address of the
 888  * instruction whose first byte has been replaced by the "int3"
 889  * instruction.  To avoid the SMP problems that can occur when we
 890  * temporarily put back the original opcode to single-step, we
 891  * single-stepped a copy of the instruction.  The address of this
 892  * copy is p->ainsn.insn. We also doesn't use trap, but "int3" again
 893  * right after the copied instruction.
 894  * Different from the trap single-step, "int3" single-step can not
 895  * handle the instruction which changes the ip register, e.g. jmp,
 896  * call, conditional jmp, and the instructions which changes the IF
 897  * flags because interrupt must be disabled around the single-stepping.
 898  * Such instructions are software emulated, but others are single-stepped
 899  * using "int3".
 900  *
 901  * When the 2nd "int3" handled, the regs->ip and regs->flags needs to
 902  * be adjusted, so that we can resume execution on correct code.
 903  */
 904 static void resume_singlestep(struct kprobe *p, struct pt_regs *regs,
 905                               struct kprobe_ctlblk *kcb)
 906 {
 907         unsigned long copy_ip = (unsigned long)p->ainsn.insn;
 908         unsigned long orig_ip = (unsigned long)p->addr;
 909
 910         /* Restore saved interrupt flag and ip register */
 911         regs->flags |= kcb->kprobe_saved_flags;
 912         /* Note that regs->ip is executed int3 so must be a step back */
 913         regs->ip += (orig_ip - copy_ip) - INT3_INSN_SIZE;
 914 }
 915 NOKPROBE_SYMBOL(resume_singlestep);
 916
 917 /*
 918  * We have reentered the kprobe_handler(), since another probe was hit while
 919  * within the handler. We save the original kprobes variables and just single
 920  * step on the instruction of the new probe without calling any user handlers.
 921  */
 922 static int reenter_kprobe(struct kprobe *p, struct pt_regs *regs,
 923                           struct kprobe_ctlblk *kcb)
 924 {
 925         switch (kcb->kprobe_status) {
 926         case KPROBE_HIT_SSDONE:
 927         case KPROBE_HIT_ACTIVE:
 928         case KPROBE_HIT_SS:
 929                 kprobes_inc_nmissed_count(p);
 930                 setup_singlestep(p, regs, kcb, 1);
 931                 break;
 932         case KPROBE_REENTER:
 933                 /* A probe has been hit in the codepath leading up to, or just
 934                  * after, single-stepping of a probed instruction. This entire
 935                  * codepath should strictly reside in .kprobes.text section.
 936                  * Raise a BUG or we'll continue in an endless reentering loop
 937                  * and eventually a stack overflow.
 938                  */
 939                 pr_err("Unrecoverable kprobe detected.\n");
 940                 dump_kprobe(p);
 941                 BUG();
 942         default:
 943                 /* impossible cases */
 944                 WARN_ON(1);
 945                 return 0;
 946         }
 947
 948         return 1;
 949 }
 950 NOKPROBE_SYMBOL(reenter_kprobe);
 951
 952 static nokprobe_inline int kprobe_is_ss(struct kprobe_ctlblk *kcb)
 953 {
 954         return (kcb->kprobe_status == KPROBE_HIT_SS ||
 955                 kcb->kprobe_status == KPROBE_REENTER);
 956 }
 957
 958 /*
 959  * Interrupts are disabled on entry as trap3 is an interrupt gate and they
 960  * remain disabled throughout this function.
 961  */
 962 int kprobe_int3_handler(struct pt_regs *regs)
 963 {
 964         kprobe_opcode_t *addr;
 965         struct kprobe *p;
 966         struct kprobe_ctlblk *kcb;
 967
 968         if (user_mode(regs))
 969                 return 0;
 970
 971         addr = (kprobe_opcode_t *)(regs->ip - sizeof(kprobe_opcode_t));
 972         /*
 973          * We don't want to be preempted for the entire duration of kprobe
 974          * processing. Since int3 and debug trap disables irqs and we clear
 975          * IF while singlestepping, it must be no preemptible.
 976          */
 977
 978         kcb = get_kprobe_ctlblk();
 979         p = get_kprobe(addr);
 980
 981         if (p) {
 982                 if (kprobe_running()) {
 983                         if (reenter_kprobe(p, regs, kcb))
 984                                 return 1;
 985                 } else {
 986                         set_current_kprobe(p, regs, kcb);
 987                         kcb->kprobe_status = KPROBE_HIT_ACTIVE;
 988
 989                         /*
 990                          * If we have no pre-handler or it returned 0, we
 991                          * continue with normal processing.  If we have a
 992                          * pre-handler and it returned non-zero, that means
 993                          * user handler setup registers to exit to another
 994                          * instruction, we must skip the single stepping.
 995                          */
 996                         if (!p->pre_handler || !p->pre_handler(p, regs))
 997                                 setup_singlestep(p, regs, kcb, 0);
 998                         else
 999                                 reset_current_kprobe();
1000                         return 1;
1001                 }
1002         } else if (kprobe_is_ss(kcb)) {
1003                 p = kprobe_running();
1004                 if ((unsigned long)p->ainsn.insn < regs->ip &&
1005                     (unsigned long)p->ainsn.insn + MAX_INSN_SIZE > regs->ip) {
1006                         /* Most provably this is the second int3 for singlestep */
1007                         resume_singlestep(p, regs, kcb);
1008                         kprobe_post_process(p, regs, kcb);
1009                         return 1;
1010                 }
1011         }
1012
1013         if (*addr != INT3_INSN_OPCODE) {
1014                 /*
1015                  * The breakpoint instruction was removed right
1016                  * after we hit it.  Another cpu has removed
1017                  * either a probepoint or a debugger breakpoint
1018                  * at this address.  In either case, no further
1019                  * handling of this interrupt is appropriate.
1020                  * Back up over the (now missing) int3 and run
1021                  * the original instruction.
1022                  */
1023                 regs->ip = (unsigned long)addr;
1024                 return 1;
1025         } /* else: not a kprobe fault; let the kernel handle it */
1026
1027         return 0;
1028 }
1029 NOKPROBE_SYMBOL(kprobe_int3_handler);
1030
1031 /*
1032  * When a retprobed function returns, this code saves registers and
1033  * calls trampoline_handler() runs, which calls the kretprobe's handler.
1034  */
1035 asm(
1036         ".text\n"
1037         ".global kretprobe_trampoline\n"
1038         ".type kretprobe_trampoline, @function\n"
1039         "kretprobe_trampoline:\n"
1040         /* We don't bother saving the ss register */
1041 #ifdef CONFIG_X86_64
1042         "       pushq %rsp\n"
1043         "       pushfq\n"
1044         SAVE_REGS_STRING
1045         "       movq %rsp, %rdi\n"
1046         "       call trampoline_handler\n"
1047         /* Replace saved sp with true return address. */
1048         "       movq %rax, 19*8(%rsp)\n"
1049         RESTORE_REGS_STRING
1050         "       popfq\n"
1051 #else
1052         "       pushl %esp\n"
1053         "       pushfl\n"
1054         SAVE_REGS_STRING
1055         "       movl %esp, %eax\n"
1056         "       call trampoline_handler\n"
1057         /* Replace saved sp with true return address. */
1058         "       movl %eax, 15*4(%esp)\n"
1059         RESTORE_REGS_STRING
1060         "       popfl\n"
1061 #endif
1062         ASM_RET
1063         ".size kretprobe_trampoline, .-kretprobe_trampoline\n"
1064 );
1065 NOKPROBE_SYMBOL(kretprobe_trampoline);
1066 STACK_FRAME_NON_STANDARD(kretprobe_trampoline);
1067
1068
1069 /*
1070  * Called from kretprobe_trampoline
1071  */
1072 __used __visible void *trampoline_handler(struct pt_regs *regs)
1073 {
1074         /* fixup registers */
1075         regs->cs = __KERNEL_CS;
1076 #ifdef CONFIG_X86_32
1077         regs->gs = 0;
1078 #endif
1079         regs->ip = (unsigned long)&kretprobe_trampoline;
1080         regs->orig_ax = ~0UL;
1081
1082         return (void *)kretprobe_trampoline_handler(regs, &kretprobe_trampoline, &regs->sp);
1083 }
1084 NOKPROBE_SYMBOL(trampoline_handler);
1085
1086 int kprobe_fault_handler(struct pt_regs *regs, int trapnr)
1087 {
1088         struct kprobe *cur = kprobe_running();
1089         struct kprobe_ctlblk *kcb = get_kprobe_ctlblk();
1090
1091         if (unlikely(regs->ip == (unsigned long)cur->ainsn.insn)) {
1092                 /* This must happen on single-stepping */
1093                 WARN_ON(kcb->kprobe_status != KPROBE_HIT_SS &&
1094                         kcb->kprobe_status != KPROBE_REENTER);
1095                 /*
1096                  * We are here because the instruction being single
1097                  * stepped caused a page fault. We reset the current
1098                  * kprobe and the ip points back to the probe address
1099                  * and allow the page fault handler to continue as a
1100                  * normal page fault.
1101                  */
1102                 regs->ip = (unsigned long)cur->addr;
1103
1104                 /*
1105                  * If the IF flag was set before the kprobe hit,
1106                  * don't touch it:
1107                  */
1108                 regs->flags |= kcb->kprobe_old_flags;
1109
1110                 if (kcb->kprobe_status == KPROBE_REENTER)
1111                         restore_previous_kprobe(kcb);
1112                 else
1113                         reset_current_kprobe();
1114         } else if (kcb->kprobe_status == KPROBE_HIT_ACTIVE ||
1115                    kcb->kprobe_status == KPROBE_HIT_SSDONE) {
1116                 /*
1117                  * We increment the nmissed count for accounting,
1118                  * we can also use npre/npostfault count for accounting
1119                  * these specific fault cases.
1120                  */
1121                 kprobes_inc_nmissed_count(cur);
1122
1123                 /*
1124                  * We come here because instructions in the pre/post
1125                  * handler caused the page_fault, this could happen
1126                  * if handler tries to access user space by
1127                  * copy_from_user(), get_user() etc. Let the
1128                  * user-specified handler try to fix it first.
1129                  */
1130                 if (cur->fault_handler && cur->fault_handler(cur, regs, trapnr))
1131                         return 1;
1132         }
1133
1134         return 0;
1135 }
1136 NOKPROBE_SYMBOL(kprobe_fault_handler);
1137
1138 int __init arch_populate_kprobe_blacklist(void)
1139 {
1140         return kprobe_add_area_blacklist((unsigned long)__entry_text_start,
1141                                          (unsigned long)__entry_text_end);
1142 }
1143
1144 int __init arch_init_kprobes(void)
1145 {
1146         return 0;
1147 }
1148
1149 int arch_trampoline_kprobe(struct kprobe *p)
1150 {
1151         return 0;
1152 }