arch/x86/kernel/alternative.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #define pr_fmt(fmt) "SMP alternatives: " fmt
   3
   4 #include <linux/module.h>
   5 #include <linux/sched.h>
   6 #include <linux/perf_event.h>
   7 #include <linux/mutex.h>
   8 #include <linux/list.h>
   9 #include <linux/stringify.h>
  10 #include <linux/highmem.h>
  11 #include <linux/mm.h>
  12 #include <linux/vmalloc.h>
  13 #include <linux/memory.h>
  14 #include <linux/stop_machine.h>
  15 #include <linux/slab.h>
  16 #include <linux/kdebug.h>
  17 #include <linux/kprobes.h>
  18 #include <linux/mmu_context.h>
  19 #include <linux/bsearch.h>
  20 #include <linux/sync_core.h>
  21 #include <asm/text-patching.h>
  22 #include <asm/alternative.h>
  23 #include <asm/sections.h>
  24 #include <asm/mce.h>
  25 #include <asm/nmi.h>
  26 #include <asm/cacheflush.h>
  27 #include <asm/tlbflush.h>
  28 #include <asm/insn.h>
  29 #include <asm/io.h>
  30 #include <asm/fixmap.h>
  31 #include <asm/paravirt.h>
  32 #include <asm/asm-prototypes.h>
  33
  34 int __read_mostly alternatives_patched;
  35
  36 EXPORT_SYMBOL_GPL(alternatives_patched);
  37
  38 #define MAX_PATCH_LEN (255-1)
  39
  40 static int __initdata_or_module debug_alternative;
  41
  42 static int __init debug_alt(char *str)
  43 {
  44         debug_alternative = 1;
  45         return 1;
  46 }
  47 __setup("debug-alternative", debug_alt);
  48
  49 static int noreplace_smp;
  50
  51 static int __init setup_noreplace_smp(char *str)
  52 {
  53         noreplace_smp = 1;
  54         return 1;
  55 }
  56 __setup("noreplace-smp", setup_noreplace_smp);
  57
  58 #define DPRINTK(fmt, args...)                                           \
  59 do {                                                                    \
  60         if (debug_alternative)                                          \
  61                 printk(KERN_DEBUG pr_fmt(fmt) "\n", ##args);            \
  62 } while (0)
  63
  64 #define DUMP_BYTES(buf, len, fmt, args...)                              \
  65 do {                                                                    \
  66         if (unlikely(debug_alternative)) {                              \
  67                 int j;                                                  \
  68                                                                         \
  69                 if (!(len))                                             \
  70                         break;                                          \
  71                                                                         \
  72                 printk(KERN_DEBUG pr_fmt(fmt), ##args);                 \
  73                 for (j = 0; j < (len) - 1; j++)                         \
  74                         printk(KERN_CONT "%02hhx ", buf[j]);            \
  75                 printk(KERN_CONT "%02hhx\n", buf[j]);                   \
  76         }                                                               \
  77 } while (0)
  78
  79 static const unsigned char x86nops[] =
  80 {
  81         BYTES_NOP1,
  82         BYTES_NOP2,
  83         BYTES_NOP3,
  84         BYTES_NOP4,
  85         BYTES_NOP5,
  86         BYTES_NOP6,
  87         BYTES_NOP7,
  88         BYTES_NOP8,
  89 };
  90
  91 const unsigned char * const x86_nops[ASM_NOP_MAX+1] =
  92 {
  93         NULL,
  94         x86nops,
  95         x86nops + 1,
  96         x86nops + 1 + 2,
  97         x86nops + 1 + 2 + 3,
  98         x86nops + 1 + 2 + 3 + 4,
  99         x86nops + 1 + 2 + 3 + 4 + 5,
 100         x86nops + 1 + 2 + 3 + 4 + 5 + 6,
 101         x86nops + 1 + 2 + 3 + 4 + 5 + 6 + 7,
 102 };
 103
 104 /* Use this to add nops to a buffer, then text_poke the whole buffer. */
 105 static void __init_or_module add_nops(void *insns, unsigned int len)
 106 {
 107         while (len > 0) {
 108                 unsigned int noplen = len;
 109                 if (noplen > ASM_NOP_MAX)
 110                         noplen = ASM_NOP_MAX;
 111                 memcpy(insns, x86_nops[noplen], noplen);
 112                 insns += noplen;
 113                 len -= noplen;
 114         }
 115 }
 116
 117 extern s32 __retpoline_sites[], __retpoline_sites_end[];
 118 extern s32 __ibt_endbr_seal[], __ibt_endbr_seal_end[];
 119 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
 120 extern s32 __smp_locks[], __smp_locks_end[];
 121 void text_poke_early(void *addr, const void *opcode, size_t len);
 122
 123 /*
 124  * Are we looking at a near JMP with a 1 or 4-byte displacement.
 125  */
 126 static inline bool is_jmp(const u8 opcode)
 127 {
 128         return opcode == 0xeb || opcode == 0xe9;
 129 }
 130
 131 static void __init_or_module
 132 recompute_jump(struct alt_instr *a, u8 *orig_insn, u8 *repl_insn, u8 *insn_buff)
 133 {
 134         u8 *next_rip, *tgt_rip;
 135         s32 n_dspl, o_dspl;
 136         int repl_len;
 137
 138         if (a->replacementlen != 5)
 139                 return;
 140
 141         o_dspl = *(s32 *)(insn_buff + 1);
 142
 143         /* next_rip of the replacement JMP */
 144         next_rip = repl_insn + a->replacementlen;
 145         /* target rip of the replacement JMP */
 146         tgt_rip  = next_rip + o_dspl;
 147         n_dspl = tgt_rip - orig_insn;
 148
 149         DPRINTK("target RIP: %px, new_displ: 0x%x", tgt_rip, n_dspl);
 150
 151         if (tgt_rip - orig_insn >= 0) {
 152                 if (n_dspl - 2 <= 127)
 153                         goto two_byte_jmp;
 154                 else
 155                         goto five_byte_jmp;
 156         /* negative offset */
 157         } else {
 158                 if (((n_dspl - 2) & 0xff) == (n_dspl - 2))
 159                         goto two_byte_jmp;
 160                 else
 161                         goto five_byte_jmp;
 162         }
 163
 164 two_byte_jmp:
 165         n_dspl -= 2;
 166
 167         insn_buff[0] = 0xeb;
 168         insn_buff[1] = (s8)n_dspl;
 169         add_nops(insn_buff + 2, 3);
 170
 171         repl_len = 2;
 172         goto done;
 173
 174 five_byte_jmp:
 175         n_dspl -= 5;
 176
 177         insn_buff[0] = 0xe9;
 178         *(s32 *)&insn_buff[1] = n_dspl;
 179
 180         repl_len = 5;
 181
 182 done:
 183
 184         DPRINTK("final displ: 0x%08x, JMP 0x%lx",
 185                 n_dspl, (unsigned long)orig_insn + n_dspl + repl_len);
 186 }
 187
 188 /*
 189  * optimize_nops_range() - Optimize a sequence of single byte NOPs (0x90)
 190  *
 191  * @instr: instruction byte stream
 192  * @instrlen: length of the above
 193  * @off: offset within @instr where the first NOP has been detected
 194  *
 195  * Return: number of NOPs found (and replaced).
 196  */
 197 static __always_inline int optimize_nops_range(u8 *instr, u8 instrlen, int off)
 198 {
 199         unsigned long flags;
 200         int i = off, nnops;
 201
 202         while (i < instrlen) {
 203                 if (instr[i] != 0x90)
 204                         break;
 205
 206                 i++;
 207         }
 208
 209         nnops = i - off;
 210
 211         if (nnops <= 1)
 212                 return nnops;
 213
 214         local_irq_save(flags);
 215         add_nops(instr + off, nnops);
 216         local_irq_restore(flags);
 217
 218         DUMP_BYTES(instr, instrlen, "%px: [%d:%d) optimized NOPs: ", instr, off, i);
 219
 220         return nnops;
 221 }
 222
 223 /*
 224  * "noinline" to cause control flow change and thus invalidate I$ and
 225  * cause refetch after modification.
 226  */
 227 static void __init_or_module noinline optimize_nops(u8 *instr, size_t len)
 228 {
 229         struct insn insn;
 230         int i = 0;
 231
 232         /*
 233          * Jump over the non-NOP insns and optimize single-byte NOPs into bigger
 234          * ones.
 235          */
 236         for (;;) {
 237                 if (insn_decode_kernel(&insn, &instr[i]))
 238                         return;
 239
 240                 /*
 241                  * See if this and any potentially following NOPs can be
 242                  * optimized.
 243                  */
 244                 if (insn.length == 1 && insn.opcode.bytes[0] == 0x90)
 245                         i += optimize_nops_range(instr, len, i);
 246                 else
 247                         i += insn.length;
 248
 249                 if (i >= len)
 250                         return;
 251         }
 252 }
 253
 254 /*
 255  * Replace instructions with better alternatives for this CPU type. This runs
 256  * before SMP is initialized to avoid SMP problems with self modifying code.
 257  * This implies that asymmetric systems where APs have less capabilities than
 258  * the boot processor are not handled. Tough. Make sure you disable such
 259  * features by hand.
 260  *
 261  * Marked "noinline" to cause control flow change and thus insn cache
 262  * to refetch changed I$ lines.
 263  */
 264 void __init_or_module noinline apply_alternatives(struct alt_instr *start,
 265                                                   struct alt_instr *end)
 266 {
 267         struct alt_instr *a;
 268         u8 *instr, *replacement;
 269         u8 insn_buff[MAX_PATCH_LEN];
 270
 271         DPRINTK("alt table %px, -> %px", start, end);
 272         /*
 273          * The scan order should be from start to end. A later scanned
 274          * alternative code can overwrite previously scanned alternative code.
 275          * Some kernel functions (e.g. memcpy, memset, etc) use this order to
 276          * patch code.
 277          *
 278          * So be careful if you want to change the scan order to any other
 279          * order.
 280          */
 281         for (a = start; a < end; a++) {
 282                 int insn_buff_sz = 0;
 283                 /* Mask away "NOT" flag bit for feature to test. */
 284                 u16 feature = a->cpuid & ~ALTINSTR_FLAG_INV;
 285
 286                 instr = (u8 *)&a->instr_offset + a->instr_offset;
 287                 replacement = (u8 *)&a->repl_offset + a->repl_offset;
 288                 BUG_ON(a->instrlen > sizeof(insn_buff));
 289                 BUG_ON(feature >= (NCAPINTS + NBUGINTS) * 32);
 290
 291                 /*
 292                  * Patch if either:
 293                  * - feature is present
 294                  * - feature not present but ALTINSTR_FLAG_INV is set to mean,
 295                  *   patch if feature is *NOT* present.
 296                  */
 297                 if (!boot_cpu_has(feature) == !(a->cpuid & ALTINSTR_FLAG_INV))
 298                         goto next;
 299
 300                 DPRINTK("feat: %s%d*32+%d, old: (%pS (%px) len: %d), repl: (%px, len: %d)",
 301                         (a->cpuid & ALTINSTR_FLAG_INV) ? "!" : "",
 302                         feature >> 5,
 303                         feature & 0x1f,
 304                         instr, instr, a->instrlen,
 305                         replacement, a->replacementlen);
 306
 307                 DUMP_BYTES(instr, a->instrlen, "%px:   old_insn: ", instr);
 308                 DUMP_BYTES(replacement, a->replacementlen, "%px:   rpl_insn: ", replacement);
 309
 310                 memcpy(insn_buff, replacement, a->replacementlen);
 311                 insn_buff_sz = a->replacementlen;
 312
 313                 /*
 314                  * 0xe8 is a relative jump; fix the offset.
 315                  *
 316                  * Instruction length is checked before the opcode to avoid
 317                  * accessing uninitialized bytes for zero-length replacements.
 318                  */
 319                 if (a->replacementlen == 5 && *insn_buff == 0xe8) {
 320                         *(s32 *)(insn_buff + 1) += replacement - instr;
 321                         DPRINTK("Fix CALL offset: 0x%x, CALL 0x%lx",
 322                                 *(s32 *)(insn_buff + 1),
 323                                 (unsigned long)instr + *(s32 *)(insn_buff + 1) + 5);
 324                 }
 325
 326                 if (a->replacementlen && is_jmp(replacement[0]))
 327                         recompute_jump(a, instr, replacement, insn_buff);
 328
 329                 for (; insn_buff_sz < a->instrlen; insn_buff_sz++)
 330                         insn_buff[insn_buff_sz] = 0x90;
 331
 332                 DUMP_BYTES(insn_buff, insn_buff_sz, "%px: final_insn: ", instr);
 333
 334                 text_poke_early(instr, insn_buff, insn_buff_sz);
 335
 336 next:
 337                 optimize_nops(instr, a->instrlen);
 338         }
 339 }
 340
 341 #if defined(CONFIG_RETPOLINE) && defined(CONFIG_STACK_VALIDATION)
 342
 343 /*
 344  * CALL/JMP *%\reg
 345  */
 346 static int emit_indirect(int op, int reg, u8 *bytes)
 347 {
 348         int i = 0;
 349         u8 modrm;
 350
 351         switch (op) {
 352         case CALL_INSN_OPCODE:
 353                 modrm = 0x10; /* Reg = 2; CALL r/m */
 354                 break;
 355
 356         case JMP32_INSN_OPCODE:
 357                 modrm = 0x20; /* Reg = 4; JMP r/m */
 358                 break;
 359
 360         default:
 361                 WARN_ON_ONCE(1);
 362                 return -1;
 363         }
 364
 365         if (reg >= 8) {
 366                 bytes[i++] = 0x41; /* REX.B prefix */
 367                 reg -= 8;
 368         }
 369
 370         modrm |= 0xc0; /* Mod = 3 */
 371         modrm += reg;
 372
 373         bytes[i++] = 0xff; /* opcode */
 374         bytes[i++] = modrm;
 375
 376         return i;
 377 }
 378
 379 /*
 380  * Rewrite the compiler generated retpoline thunk calls.
 381  *
 382  * For spectre_v2=off (!X86_FEATURE_RETPOLINE), rewrite them into immediate
 383  * indirect instructions, avoiding the extra indirection.
 384  *
 385  * For example, convert:
 386  *
 387  *   CALL __x86_indirect_thunk_\reg
 388  *
 389  * into:
 390  *
 391  *   CALL *%\reg
 392  *
 393  * It also tries to inline spectre_v2=retpoline,lfence when size permits.
 394  */
 395 static int patch_retpoline(void *addr, struct insn *insn, u8 *bytes)
 396 {
 397         retpoline_thunk_t *target;
 398         int reg, ret, i = 0;
 399         u8 op, cc;
 400
 401         target = addr + insn->length + insn->immediate.value;
 402         reg = target - __x86_indirect_thunk_array;
 403
 404         if (WARN_ON_ONCE(reg & ~0xf))
 405                 return -1;
 406
 407         /* If anyone ever does: CALL/JMP *%rsp, we're in deep trouble. */
 408         BUG_ON(reg == 4);
 409
 410         if (cpu_feature_enabled(X86_FEATURE_RETPOLINE) &&
 411             !cpu_feature_enabled(X86_FEATURE_RETPOLINE_LFENCE))
 412                 return -1;
 413
 414         op = insn->opcode.bytes[0];
 415
 416         /*
 417          * Convert:
 418          *
 419          *   Jcc.d32 __x86_indirect_thunk_\reg
 420          *
 421          * into:
 422          *
 423          *   Jncc.d8 1f
 424          *   [ LFENCE ]
 425          *   JMP *%\reg
 426          *   [ NOP ]
 427          * 1:
 428          */
 429         /* Jcc.d32 second opcode byte is in the range: 0x80-0x8f */
 430         if (op == 0x0f && (insn->opcode.bytes[1] & 0xf0) == 0x80) {
 431                 cc = insn->opcode.bytes[1] & 0xf;
 432                 cc ^= 1; /* invert condition */
 433
 434                 bytes[i++] = 0x70 + cc;        /* Jcc.d8 */
 435                 bytes[i++] = insn->length - 2; /* sizeof(Jcc.d8) == 2 */
 436
 437                 /* Continue as if: JMP.d32 __x86_indirect_thunk_\reg */
 438                 op = JMP32_INSN_OPCODE;
 439         }
 440
 441         /*
 442          * For RETPOLINE_LFENCE: prepend the indirect CALL/JMP with an LFENCE.
 443          */
 444         if (cpu_feature_enabled(X86_FEATURE_RETPOLINE_LFENCE)) {
 445                 bytes[i++] = 0x0f;
 446                 bytes[i++] = 0xae;
 447                 bytes[i++] = 0xe8; /* LFENCE */
 448         }
 449
 450         ret = emit_indirect(op, reg, bytes + i);
 451         if (ret < 0)
 452                 return ret;
 453         i += ret;
 454
 455         for (; i < insn->length;)
 456                 bytes[i++] = BYTES_NOP1;
 457
 458         return i;
 459 }
 460
 461 /*
 462  * Generated by 'objtool --retpoline'.
 463  */
 464 void __init_or_module noinline apply_retpolines(s32 *start, s32 *end)
 465 {
 466         s32 *s;
 467
 468         for (s = start; s < end; s++) {
 469                 void *addr = (void *)s + *s;
 470                 struct insn insn;
 471                 int len, ret;
 472                 u8 bytes[16];
 473                 u8 op1, op2;
 474
 475                 ret = insn_decode_kernel(&insn, addr);
 476                 if (WARN_ON_ONCE(ret < 0))
 477                         continue;
 478
 479                 op1 = insn.opcode.bytes[0];
 480                 op2 = insn.opcode.bytes[1];
 481
 482                 switch (op1) {
 483                 case CALL_INSN_OPCODE:
 484                 case JMP32_INSN_OPCODE:
 485                         break;
 486
 487                 case 0x0f: /* escape */
 488                         if (op2 >= 0x80 && op2 <= 0x8f)
 489                                 break;
 490                         fallthrough;
 491                 default:
 492                         WARN_ON_ONCE(1);
 493                         continue;
 494                 }
 495
 496                 DPRINTK("retpoline at: %pS (%px) len: %d to: %pS",
 497                         addr, addr, insn.length,
 498                         addr + insn.length + insn.immediate.value);
 499
 500                 len = patch_retpoline(addr, &insn, bytes);
 501                 if (len == insn.length) {
 502                         optimize_nops(bytes, len);
 503                         DUMP_BYTES(((u8*)addr),  len, "%px: orig: ", addr);
 504                         DUMP_BYTES(((u8*)bytes), len, "%px: repl: ", addr);
 505                         text_poke_early(addr, bytes, len);
 506                 }
 507         }
 508 }
 509
 510 #else /* !RETPOLINES || !CONFIG_STACK_VALIDATION */
 511
 512 void __init_or_module noinline apply_retpolines(s32 *start, s32 *end) { }
 513
 514 #endif /* CONFIG_RETPOLINE && CONFIG_STACK_VALIDATION */
 515
 516 #ifdef CONFIG_X86_KERNEL_IBT
 517
 518 /*
 519  * Generated by: objtool --ibt
 520  */
 521 void __init_or_module noinline apply_ibt_endbr(s32 *start, s32 *end)
 522 {
 523         s32 *s;
 524
 525         for (s = start; s < end; s++) {
 526                 u32 endbr, poison = gen_endbr_poison();
 527                 void *addr = (void *)s + *s;
 528
 529                 if (WARN_ON_ONCE(get_kernel_nofault(endbr, addr)))
 530                         continue;
 531
 532                 if (WARN_ON_ONCE(!is_endbr(endbr)))
 533                         continue;
 534
 535                 DPRINTK("ENDBR at: %pS (%px)", addr, addr);
 536
 537                 /*
 538                  * When we have IBT, the lack of ENDBR will trigger #CP
 539                  */
 540                 DUMP_BYTES(((u8*)addr), 4, "%px: orig: ", addr);
 541                 DUMP_BYTES(((u8*)&poison), 4, "%px: repl: ", addr);
 542                 text_poke_early(addr, &poison, 4);
 543         }
 544 }
 545
 546 #else
 547
 548 void __init_or_module noinline apply_ibt_endbr(s32 *start, s32 *end) { }
 549
 550 #endif /* CONFIG_X86_KERNEL_IBT */
 551
 552 #ifdef CONFIG_SMP
 553 static void alternatives_smp_lock(const s32 *start, const s32 *end,
 554                                   u8 *text, u8 *text_end)
 555 {
 556         const s32 *poff;
 557
 558         for (poff = start; poff < end; poff++) {
 559                 u8 *ptr = (u8 *)poff + *poff;
 560
 561                 if (!*poff || ptr < text || ptr >= text_end)
 562                         continue;
 563                 /* turn DS segment override prefix into lock prefix */
 564                 if (*ptr == 0x3e)
 565                         text_poke(ptr, ((unsigned char []){0xf0}), 1);
 566         }
 567 }
 568
 569 static void alternatives_smp_unlock(const s32 *start, const s32 *end,
 570                                     u8 *text, u8 *text_end)
 571 {
 572         const s32 *poff;
 573
 574         for (poff = start; poff < end; poff++) {
 575                 u8 *ptr = (u8 *)poff + *poff;
 576
 577                 if (!*poff || ptr < text || ptr >= text_end)
 578                         continue;
 579                 /* turn lock prefix into DS segment override prefix */
 580                 if (*ptr == 0xf0)
 581                         text_poke(ptr, ((unsigned char []){0x3E}), 1);
 582         }
 583 }
 584
 585 struct smp_alt_module {
 586         /* what is this ??? */
 587         struct module   *mod;
 588         char            *name;
 589
 590         /* ptrs to lock prefixes */
 591         const s32       *locks;
 592         const s32       *locks_end;
 593
 594         /* .text segment, needed to avoid patching init code ;) */
 595         u8              *text;
 596         u8              *text_end;
 597
 598         struct list_head next;
 599 };
 600 static LIST_HEAD(smp_alt_modules);
 601 static bool uniproc_patched = false;    /* protected by text_mutex */
 602
 603 void __init_or_module alternatives_smp_module_add(struct module *mod,
 604                                                   char *name,
 605                                                   void *locks, void *locks_end,
 606                                                   void *text,  void *text_end)
 607 {
 608         struct smp_alt_module *smp;
 609
 610         mutex_lock(&text_mutex);
 611         if (!uniproc_patched)
 612                 goto unlock;
 613
 614         if (num_possible_cpus() == 1)
 615                 /* Don't bother remembering, we'll never have to undo it. */
 616                 goto smp_unlock;
 617
 618         smp = kzalloc(sizeof(*smp), GFP_KERNEL);
 619         if (NULL == smp)
 620                 /* we'll run the (safe but slow) SMP code then ... */
 621                 goto unlock;
 622
 623         smp->mod        = mod;
 624         smp->name       = name;
 625         smp->locks      = locks;
 626         smp->locks_end  = locks_end;
 627         smp->text       = text;
 628         smp->text_end   = text_end;
 629         DPRINTK("locks %p -> %p, text %p -> %p, name %s\n",
 630                 smp->locks, smp->locks_end,
 631                 smp->text, smp->text_end, smp->name);
 632
 633         list_add_tail(&smp->next, &smp_alt_modules);
 634 smp_unlock:
 635         alternatives_smp_unlock(locks, locks_end, text, text_end);
 636 unlock:
 637         mutex_unlock(&text_mutex);
 638 }
 639
 640 void __init_or_module alternatives_smp_module_del(struct module *mod)
 641 {
 642         struct smp_alt_module *item;
 643
 644         mutex_lock(&text_mutex);
 645         list_for_each_entry(item, &smp_alt_modules, next) {
 646                 if (mod != item->mod)
 647                         continue;
 648                 list_del(&item->next);
 649                 kfree(item);
 650                 break;
 651         }
 652         mutex_unlock(&text_mutex);
 653 }
 654
 655 void alternatives_enable_smp(void)
 656 {
 657         struct smp_alt_module *mod;
 658
 659         /* Why bother if there are no other CPUs? */
 660         BUG_ON(num_possible_cpus() == 1);
 661
 662         mutex_lock(&text_mutex);
 663
 664         if (uniproc_patched) {
 665                 pr_info("switching to SMP code\n");
 666                 BUG_ON(num_online_cpus() != 1);
 667                 clear_cpu_cap(&boot_cpu_data, X86_FEATURE_UP);
 668                 clear_cpu_cap(&cpu_data(0), X86_FEATURE_UP);
 669                 list_for_each_entry(mod, &smp_alt_modules, next)
 670                         alternatives_smp_lock(mod->locks, mod->locks_end,
 671                                               mod->text, mod->text_end);
 672                 uniproc_patched = false;
 673         }
 674         mutex_unlock(&text_mutex);
 675 }
 676
 677 /*
 678  * Return 1 if the address range is reserved for SMP-alternatives.
 679  * Must hold text_mutex.
 680  */
 681 int alternatives_text_reserved(void *start, void *end)
 682 {
 683         struct smp_alt_module *mod;
 684         const s32 *poff;
 685         u8 *text_start = start;
 686         u8 *text_end = end;
 687
 688         lockdep_assert_held(&text_mutex);
 689
 690         list_for_each_entry(mod, &smp_alt_modules, next) {
 691                 if (mod->text > text_end || mod->text_end < text_start)
 692                         continue;
 693                 for (poff = mod->locks; poff < mod->locks_end; poff++) {
 694                         const u8 *ptr = (const u8 *)poff + *poff;
 695
 696                         if (text_start <= ptr && text_end > ptr)
 697                                 return 1;
 698                 }
 699         }
 700
 701         return 0;
 702 }
 703 #endif /* CONFIG_SMP */
 704
 705 #ifdef CONFIG_PARAVIRT
 706 void __init_or_module apply_paravirt(struct paravirt_patch_site *start,
 707                                      struct paravirt_patch_site *end)
 708 {
 709         struct paravirt_patch_site *p;
 710         char insn_buff[MAX_PATCH_LEN];
 711
 712         for (p = start; p < end; p++) {
 713                 unsigned int used;
 714
 715                 BUG_ON(p->len > MAX_PATCH_LEN);
 716                 /* prep the buffer with the original instructions */
 717                 memcpy(insn_buff, p->instr, p->len);
 718                 used = paravirt_patch(p->type, insn_buff, (unsigned long)p->instr, p->len);
 719
 720                 BUG_ON(used > p->len);
 721
 722                 /* Pad the rest with nops */
 723                 add_nops(insn_buff + used, p->len - used);
 724                 text_poke_early(p->instr, insn_buff, p->len);
 725         }
 726 }
 727 extern struct paravirt_patch_site __start_parainstructions[],
 728         __stop_parainstructions[];
 729 #endif  /* CONFIG_PARAVIRT */
 730
 731 /*
 732  * Self-test for the INT3 based CALL emulation code.
 733  *
 734  * This exercises int3_emulate_call() to make sure INT3 pt_regs are set up
 735  * properly and that there is a stack gap between the INT3 frame and the
 736  * previous context. Without this gap doing a virtual PUSH on the interrupted
 737  * stack would corrupt the INT3 IRET frame.
 738  *
 739  * See entry_{32,64}.S for more details.
 740  */
 741
 742 /*
 743  * We define the int3_magic() function in assembly to control the calling
 744  * convention such that we can 'call' it from assembly.
 745  */
 746
 747 extern void int3_magic(unsigned int *ptr); /* defined in asm */
 748
 749 asm (
 750 "       .pushsection    .init.text, \"ax\", @progbits\n"
 751 "       .type           int3_magic, @function\n"
 752 "int3_magic:\n"
 753         ANNOTATE_NOENDBR
 754 "       movl    $1, (%" _ASM_ARG1 ")\n"
 755         ASM_RET
 756 "       .size           int3_magic, .-int3_magic\n"
 757 "       .popsection\n"
 758 );
 759
 760 extern void int3_selftest_ip(void); /* defined in asm below */
 761
 762 static int __init
 763 int3_exception_notify(struct notifier_block *self, unsigned long val, void *data)
 764 {
 765         unsigned long selftest = (unsigned long)&int3_selftest_ip;
 766         struct die_args *args = data;
 767         struct pt_regs *regs = args->regs;
 768
 769         OPTIMIZER_HIDE_VAR(selftest);
 770
 771         if (!regs || user_mode(regs))
 772                 return NOTIFY_DONE;
 773
 774         if (val != DIE_INT3)
 775                 return NOTIFY_DONE;
 776
 777         if (regs->ip - INT3_INSN_SIZE != selftest)
 778                 return NOTIFY_DONE;
 779
 780         int3_emulate_call(regs, (unsigned long)&int3_magic);
 781         return NOTIFY_STOP;
 782 }
 783
 784 /* Must be noinline to ensure uniqueness of int3_selftest_ip. */
 785 static noinline void __init int3_selftest(void)
 786 {
 787         static __initdata struct notifier_block int3_exception_nb = {
 788                 .notifier_call  = int3_exception_notify,
 789                 .priority       = INT_MAX-1, /* last */
 790         };
 791         unsigned int val = 0;
 792
 793         BUG_ON(register_die_notifier(&int3_exception_nb));
 794
 795         /*
 796          * Basically: int3_magic(&val); but really complicated :-)
 797          *
 798          * INT3 padded with NOP to CALL_INSN_SIZE. The int3_exception_nb
 799          * notifier above will emulate CALL for us.
 800          */
 801         asm volatile ("int3_selftest_ip:\n\t"
 802                       ANNOTATE_NOENDBR
 803                       "    int3; nop; nop; nop; nop\n\t"
 804                       : ASM_CALL_CONSTRAINT
 805                       : __ASM_SEL_RAW(a, D) (&val)
 806                       : "memory");
 807
 808         BUG_ON(val != 1);
 809
 810         unregister_die_notifier(&int3_exception_nb);
 811 }
 812
 813 void __init alternative_instructions(void)
 814 {
 815         int3_selftest();
 816
 817         /*
 818          * The patching is not fully atomic, so try to avoid local
 819          * interruptions that might execute the to be patched code.
 820          * Other CPUs are not running.
 821          */
 822         stop_nmi();
 823
 824         /*
 825          * Don't stop machine check exceptions while patching.
 826          * MCEs only happen when something got corrupted and in this
 827          * case we must do something about the corruption.
 828          * Ignoring it is worse than an unlikely patching race.
 829          * Also machine checks tend to be broadcast and if one CPU
 830          * goes into machine check the others follow quickly, so we don't
 831          * expect a machine check to cause undue problems during to code
 832          * patching.
 833          */
 834
 835         /*
 836          * Paravirt patching and alternative patching can be combined to
 837          * replace a function call with a short direct code sequence (e.g.
 838          * by setting a constant return value instead of doing that in an
 839          * external function).
 840          * In order to make this work the following sequence is required:
 841          * 1. set (artificial) features depending on used paravirt
 842          *    functions which can later influence alternative patching
 843          * 2. apply paravirt patching (generally replacing an indirect
 844          *    function call with a direct one)
 845          * 3. apply alternative patching (e.g. replacing a direct function
 846          *    call with a custom code sequence)
 847          * Doing paravirt patching after alternative patching would clobber
 848          * the optimization of the custom code with a function call again.
 849          */
 850         paravirt_set_cap();
 851
 852         /*
 853          * First patch paravirt functions, such that we overwrite the indirect
 854          * call with the direct call.
 855          */
 856         apply_paravirt(__parainstructions, __parainstructions_end);
 857
 858         /*
 859          * Rewrite the retpolines, must be done before alternatives since
 860          * those can rewrite the retpoline thunks.
 861          */
 862         apply_retpolines(__retpoline_sites, __retpoline_sites_end);
 863
 864         /*
 865          * Then patch alternatives, such that those paravirt calls that are in
 866          * alternatives can be overwritten by their immediate fragments.
 867          */
 868         apply_alternatives(__alt_instructions, __alt_instructions_end);
 869
 870         apply_ibt_endbr(__ibt_endbr_seal, __ibt_endbr_seal_end);
 871
 872 #ifdef CONFIG_SMP
 873         /* Patch to UP if other cpus not imminent. */
 874         if (!noreplace_smp && (num_present_cpus() == 1 || setup_max_cpus <= 1)) {
 875                 uniproc_patched = true;
 876                 alternatives_smp_module_add(NULL, "core kernel",
 877                                             __smp_locks, __smp_locks_end,
 878                                             _text, _etext);
 879         }
 880
 881         if (!uniproc_patched || num_possible_cpus() == 1) {
 882                 free_init_pages("SMP alternatives",
 883                                 (unsigned long)__smp_locks,
 884                                 (unsigned long)__smp_locks_end);
 885         }
 886 #endif
 887
 888         restart_nmi();
 889         alternatives_patched = 1;
 890 }
 891
 892 /**
 893  * text_poke_early - Update instructions on a live kernel at boot time
 894  * @addr: address to modify
 895  * @opcode: source of the copy
 896  * @len: length to copy
 897  *
 898  * When you use this code to patch more than one byte of an instruction
 899  * you need to make sure that other CPUs cannot execute this code in parallel.
 900  * Also no thread must be currently preempted in the middle of these
 901  * instructions. And on the local CPU you need to be protected against NMI or
 902  * MCE handlers seeing an inconsistent instruction while you patch.
 903  */
 904 void __init_or_module text_poke_early(void *addr, const void *opcode,
 905                                       size_t len)
 906 {
 907         unsigned long flags;
 908
 909         if (boot_cpu_has(X86_FEATURE_NX) &&
 910             is_module_text_address((unsigned long)addr)) {
 911                 /*
 912                  * Modules text is marked initially as non-executable, so the
 913                  * code cannot be running and speculative code-fetches are
 914                  * prevented. Just change the code.
 915                  */
 916                 memcpy(addr, opcode, len);
 917         } else {
 918                 local_irq_save(flags);
 919                 memcpy(addr, opcode, len);
 920                 local_irq_restore(flags);
 921                 sync_core();
 922
 923                 /*
 924                  * Could also do a CLFLUSH here to speed up CPU recovery; but
 925                  * that causes hangs on some VIA CPUs.
 926                  */
 927         }
 928 }
 929
 930 typedef struct {
 931         struct mm_struct *mm;
 932 } temp_mm_state_t;
 933
 934 /*
 935  * Using a temporary mm allows to set temporary mappings that are not accessible
 936  * by other CPUs. Such mappings are needed to perform sensitive memory writes
 937  * that override the kernel memory protections (e.g., W^X), without exposing the
 938  * temporary page-table mappings that are required for these write operations to
 939  * other CPUs. Using a temporary mm also allows to avoid TLB shootdowns when the
 940  * mapping is torn down.
 941  *
 942  * Context: The temporary mm needs to be used exclusively by a single core. To
 943  *          harden security IRQs must be disabled while the temporary mm is
 944  *          loaded, thereby preventing interrupt handler bugs from overriding
 945  *          the kernel memory protection.
 946  */
 947 static inline temp_mm_state_t use_temporary_mm(struct mm_struct *mm)
 948 {
 949         temp_mm_state_t temp_state;
 950
 951         lockdep_assert_irqs_disabled();
 952
 953         /*
 954          * Make sure not to be in TLB lazy mode, as otherwise we'll end up
 955          * with a stale address space WITHOUT being in lazy mode after
 956          * restoring the previous mm.
 957          */
 958         if (this_cpu_read(cpu_tlbstate_shared.is_lazy))
 959                 leave_mm(smp_processor_id());
 960
 961         temp_state.mm = this_cpu_read(cpu_tlbstate.loaded_mm);
 962         switch_mm_irqs_off(NULL, mm, current);
 963
 964         /*
 965          * If breakpoints are enabled, disable them while the temporary mm is
 966          * used. Userspace might set up watchpoints on addresses that are used
 967          * in the temporary mm, which would lead to wrong signals being sent or
 968          * crashes.
 969          *
 970          * Note that breakpoints are not disabled selectively, which also causes
 971          * kernel breakpoints (e.g., perf's) to be disabled. This might be
 972          * undesirable, but still seems reasonable as the code that runs in the
 973          * temporary mm should be short.
 974          */
 975         if (hw_breakpoint_active())
 976                 hw_breakpoint_disable();
 977
 978         return temp_state;
 979 }
 980
 981 static inline void unuse_temporary_mm(temp_mm_state_t prev_state)
 982 {
 983         lockdep_assert_irqs_disabled();
 984         switch_mm_irqs_off(NULL, prev_state.mm, current);
 985
 986         /*
 987          * Restore the breakpoints if they were disabled before the temporary mm
 988          * was loaded.
 989          */
 990         if (hw_breakpoint_active())
 991                 hw_breakpoint_restore();
 992 }
 993
 994 __ro_after_init struct mm_struct *poking_mm;
 995 __ro_after_init unsigned long poking_addr;
 996
 997 static void *__text_poke(void *addr, const void *opcode, size_t len)
 998 {
 999         bool cross_page_boundary = offset_in_page(addr) + len > PAGE_SIZE;
1000         struct page *pages[2] = {NULL};
1001         temp_mm_state_t prev;
1002         unsigned long flags;
1003         pte_t pte, *ptep;
1004         spinlock_t *ptl;
1005         pgprot_t pgprot;
1006
1007         /*
1008          * While boot memory allocator is running we cannot use struct pages as
1009          * they are not yet initialized. There is no way to recover.
1010          */
1011         BUG_ON(!after_bootmem);
1012
1013         if (!core_kernel_text((unsigned long)addr)) {
1014                 pages[0] = vmalloc_to_page(addr);
1015                 if (cross_page_boundary)
1016                         pages[1] = vmalloc_to_page(addr + PAGE_SIZE);
1017         } else {
1018                 pages[0] = virt_to_page(addr);
1019                 WARN_ON(!PageReserved(pages[0]));
1020                 if (cross_page_boundary)
1021                         pages[1] = virt_to_page(addr + PAGE_SIZE);
1022         }
1023         /*
1024          * If something went wrong, crash and burn since recovery paths are not
1025          * implemented.
1026          */
1027         BUG_ON(!pages[0] || (cross_page_boundary && !pages[1]));
1028
1029         /*
1030          * Map the page without the global bit, as TLB flushing is done with
1031          * flush_tlb_mm_range(), which is intended for non-global PTEs.
1032          */
1033         pgprot = __pgprot(pgprot_val(PAGE_KERNEL) & ~_PAGE_GLOBAL);
1034
1035         /*
1036          * The lock is not really needed, but this allows to avoid open-coding.
1037          */
1038         ptep = get_locked_pte(poking_mm, poking_addr, &ptl);
1039
1040         /*
1041          * This must not fail; preallocated in poking_init().
1042          */
1043         VM_BUG_ON(!ptep);
1044
1045         local_irq_save(flags);
1046
1047         pte = mk_pte(pages[0], pgprot);
1048         set_pte_at(poking_mm, poking_addr, ptep, pte);
1049
1050         if (cross_page_boundary) {
1051                 pte = mk_pte(pages[1], pgprot);
1052                 set_pte_at(poking_mm, poking_addr + PAGE_SIZE, ptep + 1, pte);
1053         }
1054
1055         /*
1056          * Loading the temporary mm behaves as a compiler barrier, which
1057          * guarantees that the PTE will be set at the time memcpy() is done.
1058          */
1059         prev = use_temporary_mm(poking_mm);
1060
1061         kasan_disable_current();
1062         memcpy((u8 *)poking_addr + offset_in_page(addr), opcode, len);
1063         kasan_enable_current();
1064
1065         /*
1066          * Ensure that the PTE is only cleared after the instructions of memcpy
1067          * were issued by using a compiler barrier.
1068          */
1069         barrier();
1070
1071         pte_clear(poking_mm, poking_addr, ptep);
1072         if (cross_page_boundary)
1073                 pte_clear(poking_mm, poking_addr + PAGE_SIZE, ptep + 1);
1074
1075         /*
1076          * Loading the previous page-table hierarchy requires a serializing
1077          * instruction that already allows the core to see the updated version.
1078          * Xen-PV is assumed to serialize execution in a similar manner.
1079          */
1080         unuse_temporary_mm(prev);
1081
1082         /*
1083          * Flushing the TLB might involve IPIs, which would require enabled
1084          * IRQs, but not if the mm is not used, as it is in this point.
1085          */
1086         flush_tlb_mm_range(poking_mm, poking_addr, poking_addr +
1087                            (cross_page_boundary ? 2 : 1) * PAGE_SIZE,
1088                            PAGE_SHIFT, false);
1089
1090         /*
1091          * If the text does not match what we just wrote then something is
1092          * fundamentally screwy; there's nothing we can really do about that.
1093          */
1094         BUG_ON(memcmp(addr, opcode, len));
1095
1096         local_irq_restore(flags);
1097         pte_unmap_unlock(ptep, ptl);
1098         return addr;
1099 }
1100
1101 /**
1102  * text_poke - Update instructions on a live kernel
1103  * @addr: address to modify
1104  * @opcode: source of the copy
1105  * @len: length to copy
1106  *
1107  * Only atomic text poke/set should be allowed when not doing early patching.
1108  * It means the size must be writable atomically and the address must be aligned
1109  * in a way that permits an atomic write. It also makes sure we fit on a single
1110  * page.
1111  *
1112  * Note that the caller must ensure that if the modified code is part of a
1113  * module, the module would not be removed during poking. This can be achieved
1114  * by registering a module notifier, and ordering module removal and patching
1115  * trough a mutex.
1116  */
1117 void *text_poke(void *addr, const void *opcode, size_t len)
1118 {
1119         lockdep_assert_held(&text_mutex);
1120
1121         return __text_poke(addr, opcode, len);
1122 }
1123
1124 /**
1125  * text_poke_kgdb - Update instructions on a live kernel by kgdb
1126  * @addr: address to modify
1127  * @opcode: source of the copy
1128  * @len: length to copy
1129  *
1130  * Only atomic text poke/set should be allowed when not doing early patching.
1131  * It means the size must be writable atomically and the address must be aligned
1132  * in a way that permits an atomic write. It also makes sure we fit on a single
1133  * page.
1134  *
1135  * Context: should only be used by kgdb, which ensures no other core is running,
1136  *          despite the fact it does not hold the text_mutex.
1137  */
1138 void *text_poke_kgdb(void *addr, const void *opcode, size_t len)
1139 {
1140         return __text_poke(addr, opcode, len);
1141 }
1142
1143 /**
1144  * text_poke_copy - Copy instructions into (an unused part of) RX memory
1145  * @addr: address to modify
1146  * @opcode: source of the copy
1147  * @len: length to copy, could be more than 2x PAGE_SIZE
1148  *
1149  * Not safe against concurrent execution; useful for JITs to dump
1150  * new code blocks into unused regions of RX memory. Can be used in
1151  * conjunction with synchronize_rcu_tasks() to wait for existing
1152  * execution to quiesce after having made sure no existing functions
1153  * pointers are live.
1154  */
1155 void *text_poke_copy(void *addr, const void *opcode, size_t len)
1156 {
1157         unsigned long start = (unsigned long)addr;
1158         size_t patched = 0;
1159
1160         if (WARN_ON_ONCE(core_kernel_text(start)))
1161                 return NULL;
1162
1163         mutex_lock(&text_mutex);
1164         while (patched < len) {
1165                 unsigned long ptr = start + patched;
1166                 size_t s;
1167
1168                 s = min_t(size_t, PAGE_SIZE * 2 - offset_in_page(ptr), len - patched);
1169
1170                 __text_poke((void *)ptr, opcode + patched, s);
1171                 patched += s;
1172         }
1173         mutex_unlock(&text_mutex);
1174         return addr;
1175 }
1176
1177 static void do_sync_core(void *info)
1178 {
1179         sync_core();
1180 }
1181
1182 void text_poke_sync(void)
1183 {
1184         on_each_cpu(do_sync_core, NULL, 1);
1185 }
1186
1187 struct text_poke_loc {
1188         /* addr := _stext + rel_addr */
1189         s32 rel_addr;
1190         s32 disp;
1191         u8 len;
1192         u8 opcode;
1193         const u8 text[POKE_MAX_OPCODE_SIZE];
1194         /* see text_poke_bp_batch() */
1195         u8 old;
1196 };
1197
1198 struct bp_patching_desc {
1199         struct text_poke_loc *vec;
1200         int nr_entries;
1201         atomic_t refs;
1202 };
1203
1204 static struct bp_patching_desc *bp_desc;
1205
1206 static __always_inline
1207 struct bp_patching_desc *try_get_desc(struct bp_patching_desc **descp)
1208 {
1209         /* rcu_dereference */
1210         struct bp_patching_desc *desc = __READ_ONCE(*descp);
1211
1212         if (!desc || !arch_atomic_inc_not_zero(&desc->refs))
1213                 return NULL;
1214
1215         return desc;
1216 }
1217
1218 static __always_inline void put_desc(struct bp_patching_desc *desc)
1219 {
1220         smp_mb__before_atomic();
1221         arch_atomic_dec(&desc->refs);
1222 }
1223
1224 static __always_inline void *text_poke_addr(struct text_poke_loc *tp)
1225 {
1226         return _stext + tp->rel_addr;
1227 }
1228
1229 static __always_inline int patch_cmp(const void *key, const void *elt)
1230 {
1231         struct text_poke_loc *tp = (struct text_poke_loc *) elt;
1232
1233         if (key < text_poke_addr(tp))
1234                 return -1;
1235         if (key > text_poke_addr(tp))
1236                 return 1;
1237         return 0;
1238 }
1239
1240 noinstr int poke_int3_handler(struct pt_regs *regs)
1241 {
1242         struct bp_patching_desc *desc;
1243         struct text_poke_loc *tp;
1244         int ret = 0;
1245         void *ip;
1246
1247         if (user_mode(regs))
1248                 return 0;
1249
1250         /*
1251          * Having observed our INT3 instruction, we now must observe
1252          * bp_desc:
1253          *
1254          *      bp_desc = desc                  INT3
1255          *      WMB                             RMB
1256          *      write INT3                      if (desc)
1257          */
1258         smp_rmb();
1259
1260         desc = try_get_desc(&bp_desc);
1261         if (!desc)
1262                 return 0;
1263
1264         /*
1265          * Discount the INT3. See text_poke_bp_batch().
1266          */
1267         ip = (void *) regs->ip - INT3_INSN_SIZE;
1268
1269         /*
1270          * Skip the binary search if there is a single member in the vector.
1271          */
1272         if (unlikely(desc->nr_entries > 1)) {
1273                 tp = __inline_bsearch(ip, desc->vec, desc->nr_entries,
1274                                       sizeof(struct text_poke_loc),
1275                                       patch_cmp);
1276                 if (!tp)
1277                         goto out_put;
1278         } else {
1279                 tp = desc->vec;
1280                 if (text_poke_addr(tp) != ip)
1281                         goto out_put;
1282         }
1283
1284         ip += tp->len;
1285
1286         switch (tp->opcode) {
1287         case INT3_INSN_OPCODE:
1288                 /*
1289                  * Someone poked an explicit INT3, they'll want to handle it,
1290                  * do not consume.
1291                  */
1292                 goto out_put;
1293
1294         case RET_INSN_OPCODE:
1295                 int3_emulate_ret(regs);
1296                 break;
1297
1298         case CALL_INSN_OPCODE:
1299                 int3_emulate_call(regs, (long)ip + tp->disp);
1300                 break;
1301
1302         case JMP32_INSN_OPCODE:
1303         case JMP8_INSN_OPCODE:
1304                 int3_emulate_jmp(regs, (long)ip + tp->disp);
1305                 break;
1306
1307         default:
1308                 BUG();
1309         }
1310
1311         ret = 1;
1312
1313 out_put:
1314         put_desc(desc);
1315         return ret;
1316 }
1317
1318 #define TP_VEC_MAX (PAGE_SIZE / sizeof(struct text_poke_loc))
1319 static struct text_poke_loc tp_vec[TP_VEC_MAX];
1320 static int tp_vec_nr;
1321
1322 /**
1323  * text_poke_bp_batch() -- update instructions on live kernel on SMP
1324  * @tp:                 vector of instructions to patch
1325  * @nr_entries:         number of entries in the vector
1326  *
1327  * Modify multi-byte instruction by using int3 breakpoint on SMP.
1328  * We completely avoid stop_machine() here, and achieve the
1329  * synchronization using int3 breakpoint.
1330  *
1331  * The way it is done:
1332  *      - For each entry in the vector:
1333  *              - add a int3 trap to the address that will be patched
1334  *      - sync cores
1335  *      - For each entry in the vector:
1336  *              - update all but the first byte of the patched range
1337  *      - sync cores
1338  *      - For each entry in the vector:
1339  *              - replace the first byte (int3) by the first byte of
1340  *                replacing opcode
1341  *      - sync cores
1342  */
1343 static void text_poke_bp_batch(struct text_poke_loc *tp, unsigned int nr_entries)
1344 {
1345         struct bp_patching_desc desc = {
1346                 .vec = tp,
1347                 .nr_entries = nr_entries,
1348                 .refs = ATOMIC_INIT(1),
1349         };
1350         unsigned char int3 = INT3_INSN_OPCODE;
1351         unsigned int i;
1352         int do_sync;
1353
1354         lockdep_assert_held(&text_mutex);
1355
1356         smp_store_release(&bp_desc, &desc); /* rcu_assign_pointer */
1357
1358         /*
1359          * Corresponding read barrier in int3 notifier for making sure the
1360          * nr_entries and handler are correctly ordered wrt. patching.
1361          */
1362         smp_wmb();
1363
1364         /*
1365          * First step: add a int3 trap to the address that will be patched.
1366          */
1367         for (i = 0; i < nr_entries; i++) {
1368                 tp[i].old = *(u8 *)text_poke_addr(&tp[i]);
1369                 text_poke(text_poke_addr(&tp[i]), &int3, INT3_INSN_SIZE);
1370         }
1371
1372         text_poke_sync();
1373
1374         /*
1375          * Second step: update all but the first byte of the patched range.
1376          */
1377         for (do_sync = 0, i = 0; i < nr_entries; i++) {
1378                 u8 old[POKE_MAX_OPCODE_SIZE] = { tp[i].old, };
1379                 int len = tp[i].len;
1380
1381                 if (len - INT3_INSN_SIZE > 0) {
1382                         memcpy(old + INT3_INSN_SIZE,
1383                                text_poke_addr(&tp[i]) + INT3_INSN_SIZE,
1384                                len - INT3_INSN_SIZE);
1385                         text_poke(text_poke_addr(&tp[i]) + INT3_INSN_SIZE,
1386                                   (const char *)tp[i].text + INT3_INSN_SIZE,
1387                                   len - INT3_INSN_SIZE);
1388                         do_sync++;
1389                 }
1390
1391                 /*
1392                  * Emit a perf event to record the text poke, primarily to
1393                  * support Intel PT decoding which must walk the executable code
1394                  * to reconstruct the trace. The flow up to here is:
1395                  *   - write INT3 byte
1396                  *   - IPI-SYNC
1397                  *   - write instruction tail
1398                  * At this point the actual control flow will be through the
1399                  * INT3 and handler and not hit the old or new instruction.
1400                  * Intel PT outputs FUP/TIP packets for the INT3, so the flow
1401                  * can still be decoded. Subsequently:
1402                  *   - emit RECORD_TEXT_POKE with the new instruction
1403                  *   - IPI-SYNC
1404                  *   - write first byte
1405                  *   - IPI-SYNC
1406                  * So before the text poke event timestamp, the decoder will see
1407                  * either the old instruction flow or FUP/TIP of INT3. After the
1408                  * text poke event timestamp, the decoder will see either the
1409                  * new instruction flow or FUP/TIP of INT3. Thus decoders can
1410                  * use the timestamp as the point at which to modify the
1411                  * executable code.
1412                  * The old instruction is recorded so that the event can be
1413                  * processed forwards or backwards.
1414                  */
1415                 perf_event_text_poke(text_poke_addr(&tp[i]), old, len,
1416                                      tp[i].text, len);
1417         }
1418
1419         if (do_sync) {
1420                 /*
1421                  * According to Intel, this core syncing is very likely
1422                  * not necessary and we'd be safe even without it. But
1423                  * better safe than sorry (plus there's not only Intel).
1424                  */
1425                 text_poke_sync();
1426         }
1427
1428         /*
1429          * Third step: replace the first byte (int3) by the first byte of
1430          * replacing opcode.
1431          */
1432         for (do_sync = 0, i = 0; i < nr_entries; i++) {
1433                 if (tp[i].text[0] == INT3_INSN_OPCODE)
1434                         continue;
1435
1436                 text_poke(text_poke_addr(&tp[i]), tp[i].text, INT3_INSN_SIZE);
1437                 do_sync++;
1438         }
1439
1440         if (do_sync)
1441                 text_poke_sync();
1442
1443         /*
1444          * Remove and synchronize_rcu(), except we have a very primitive
1445          * refcount based completion.
1446          */
1447         WRITE_ONCE(bp_desc, NULL); /* RCU_INIT_POINTER */
1448         if (!atomic_dec_and_test(&desc.refs))
1449                 atomic_cond_read_acquire(&desc.refs, !VAL);
1450 }
1451
1452 static void text_poke_loc_init(struct text_poke_loc *tp, void *addr,
1453                                const void *opcode, size_t len, const void *emulate)
1454 {
1455         struct insn insn;
1456         int ret, i;
1457
1458         memcpy((void *)tp->text, opcode, len);
1459         if (!emulate)
1460                 emulate = opcode;
1461
1462         ret = insn_decode_kernel(&insn, emulate);
1463         BUG_ON(ret < 0);
1464
1465         tp->rel_addr = addr - (void *)_stext;
1466         tp->len = len;
1467         tp->opcode = insn.opcode.bytes[0];
1468
1469         switch (tp->opcode) {
1470         case RET_INSN_OPCODE:
1471         case JMP32_INSN_OPCODE:
1472         case JMP8_INSN_OPCODE:
1473                 /*
1474                  * Control flow instructions without implied execution of the
1475                  * next instruction can be padded with INT3.
1476                  */
1477                 for (i = insn.length; i < len; i++)
1478                         BUG_ON(tp->text[i] != INT3_INSN_OPCODE);
1479                 break;
1480
1481         default:
1482                 BUG_ON(len != insn.length);
1483         };
1484
1485
1486         switch (tp->opcode) {
1487         case INT3_INSN_OPCODE:
1488         case RET_INSN_OPCODE:
1489                 break;
1490
1491         case CALL_INSN_OPCODE:
1492         case JMP32_INSN_OPCODE:
1493         case JMP8_INSN_OPCODE:
1494                 tp->disp = insn.immediate.value;
1495                 break;
1496
1497         default: /* assume NOP */
1498                 switch (len) {
1499                 case 2: /* NOP2 -- emulate as JMP8+0 */
1500                         BUG_ON(memcmp(emulate, x86_nops[len], len));
1501                         tp->opcode = JMP8_INSN_OPCODE;
1502                         tp->disp = 0;
1503                         break;
1504
1505                 case 5: /* NOP5 -- emulate as JMP32+0 */
1506                         BUG_ON(memcmp(emulate, x86_nops[len], len));
1507                         tp->opcode = JMP32_INSN_OPCODE;
1508                         tp->disp = 0;
1509                         break;
1510
1511                 default: /* unknown instruction */
1512                         BUG();
1513                 }
1514                 break;
1515         }
1516 }
1517
1518 /*
1519  * We hard rely on the tp_vec being ordered; ensure this is so by flushing
1520  * early if needed.
1521  */
1522 static bool tp_order_fail(void *addr)
1523 {
1524         struct text_poke_loc *tp;
1525
1526         if (!tp_vec_nr)
1527                 return false;
1528
1529         if (!addr) /* force */
1530                 return true;
1531
1532         tp = &tp_vec[tp_vec_nr - 1];
1533         if ((unsigned long)text_poke_addr(tp) > (unsigned long)addr)
1534                 return true;
1535
1536         return false;
1537 }
1538
1539 static void text_poke_flush(void *addr)
1540 {
1541         if (tp_vec_nr == TP_VEC_MAX || tp_order_fail(addr)) {
1542                 text_poke_bp_batch(tp_vec, tp_vec_nr);
1543                 tp_vec_nr = 0;
1544         }
1545 }
1546
1547 void text_poke_finish(void)
1548 {
1549         text_poke_flush(NULL);
1550 }
1551
1552 void __ref text_poke_queue(void *addr, const void *opcode, size_t len, const void *emulate)
1553 {
1554         struct text_poke_loc *tp;
1555
1556         if (unlikely(system_state == SYSTEM_BOOTING)) {
1557                 text_poke_early(addr, opcode, len);
1558                 return;
1559         }
1560
1561         text_poke_flush(addr);
1562
1563         tp = &tp_vec[tp_vec_nr++];
1564         text_poke_loc_init(tp, addr, opcode, len, emulate);
1565 }
1566
1567 /**
1568  * text_poke_bp() -- update instructions on live kernel on SMP
1569  * @addr:       address to patch
1570  * @opcode:     opcode of new instruction
1571  * @len:        length to copy
1572  * @emulate:    instruction to be emulated
1573  *
1574  * Update a single instruction with the vector in the stack, avoiding
1575  * dynamically allocated memory. This function should be used when it is
1576  * not possible to allocate memory.
1577  */
1578 void __ref text_poke_bp(void *addr, const void *opcode, size_t len, const void *emulate)
1579 {
1580         struct text_poke_loc tp;
1581
1582         if (unlikely(system_state == SYSTEM_BOOTING)) {
1583                 text_poke_early(addr, opcode, len);
1584                 return;
1585         }
1586
1587         text_poke_loc_init(&tp, addr, opcode, len, emulate);
1588         text_poke_bp_batch(&tp, 1);
1589 }