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 __return_sites[], __return_sites_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,amd 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_AMD: 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 #ifdef CONFIG_RETHUNK
 511 /*
 512  * Rewrite the compiler generated return thunk tail-calls.
 513  *
 514  * For example, convert:
 515  *
 516  *   JMP __x86_return_thunk
 517  *
 518  * into:
 519  *
 520  *   RET
 521  */
 522 static int patch_return(void *addr, struct insn *insn, u8 *bytes)
 523 {
 524         int i = 0;
 525
 526         if (cpu_feature_enabled(X86_FEATURE_RETHUNK))
 527                 return -1;
 528
 529         bytes[i++] = RET_INSN_OPCODE;
 530
 531         for (; i < insn->length;)
 532                 bytes[i++] = INT3_INSN_OPCODE;
 533
 534         return i;
 535 }
 536
 537 void __init_or_module noinline apply_returns(s32 *start, s32 *end)
 538 {
 539         s32 *s;
 540
 541         for (s = start; s < end; s++) {
 542                 void *dest = NULL, *addr = (void *)s + *s;
 543                 struct insn insn;
 544                 int len, ret;
 545                 u8 bytes[16];
 546                 u8 op;
 547
 548                 ret = insn_decode_kernel(&insn, addr);
 549                 if (WARN_ON_ONCE(ret < 0))
 550                         continue;
 551
 552                 op = insn.opcode.bytes[0];
 553                 if (op == JMP32_INSN_OPCODE)
 554                         dest = addr + insn.length + insn.immediate.value;
 555
 556                 if (__static_call_fixup(addr, op, dest) ||
 557                     WARN_ONCE(dest != &__x86_return_thunk,
 558                               "missing return thunk: %pS-%pS: %*ph",
 559                               addr, dest, 5, addr))
 560                         continue;
 561
 562                 DPRINTK("return thunk at: %pS (%px) len: %d to: %pS",
 563                         addr, addr, insn.length,
 564                         addr + insn.length + insn.immediate.value);
 565
 566                 len = patch_return(addr, &insn, bytes);
 567                 if (len == insn.length) {
 568                         DUMP_BYTES(((u8*)addr),  len, "%px: orig: ", addr);
 569                         DUMP_BYTES(((u8*)bytes), len, "%px: repl: ", addr);
 570                         text_poke_early(addr, bytes, len);
 571                 }
 572         }
 573 }
 574 #else
 575 void __init_or_module noinline apply_returns(s32 *start, s32 *end) { }
 576 #endif /* CONFIG_RETHUNK */
 577
 578 #else /* !RETPOLINES || !CONFIG_STACK_VALIDATION */
 579
 580 void __init_or_module noinline apply_retpolines(s32 *start, s32 *end) { }
 581 void __init_or_module noinline apply_returns(s32 *start, s32 *end) { }
 582
 583 #endif /* CONFIG_RETPOLINE && CONFIG_STACK_VALIDATION */
 584
 585 #ifdef CONFIG_SMP
 586 static void alternatives_smp_lock(const s32 *start, const s32 *end,
 587                                   u8 *text, u8 *text_end)
 588 {
 589         const s32 *poff;
 590
 591         for (poff = start; poff < end; poff++) {
 592                 u8 *ptr = (u8 *)poff + *poff;
 593
 594                 if (!*poff || ptr < text || ptr >= text_end)
 595                         continue;
 596                 /* turn DS segment override prefix into lock prefix */
 597                 if (*ptr == 0x3e)
 598                         text_poke(ptr, ((unsigned char []){0xf0}), 1);
 599         }
 600 }
 601
 602 static void alternatives_smp_unlock(const s32 *start, const s32 *end,
 603                                     u8 *text, u8 *text_end)
 604 {
 605         const s32 *poff;
 606
 607         for (poff = start; poff < end; poff++) {
 608                 u8 *ptr = (u8 *)poff + *poff;
 609
 610                 if (!*poff || ptr < text || ptr >= text_end)
 611                         continue;
 612                 /* turn lock prefix into DS segment override prefix */
 613                 if (*ptr == 0xf0)
 614                         text_poke(ptr, ((unsigned char []){0x3E}), 1);
 615         }
 616 }
 617
 618 struct smp_alt_module {
 619         /* what is this ??? */
 620         struct module   *mod;
 621         char            *name;
 622
 623         /* ptrs to lock prefixes */
 624         const s32       *locks;
 625         const s32       *locks_end;
 626
 627         /* .text segment, needed to avoid patching init code ;) */
 628         u8              *text;
 629         u8              *text_end;
 630
 631         struct list_head next;
 632 };
 633 static LIST_HEAD(smp_alt_modules);
 634 static bool uniproc_patched = false;    /* protected by text_mutex */
 635
 636 void __init_or_module alternatives_smp_module_add(struct module *mod,
 637                                                   char *name,
 638                                                   void *locks, void *locks_end,
 639                                                   void *text,  void *text_end)
 640 {
 641         struct smp_alt_module *smp;
 642
 643         mutex_lock(&text_mutex);
 644         if (!uniproc_patched)
 645                 goto unlock;
 646
 647         if (num_possible_cpus() == 1)
 648                 /* Don't bother remembering, we'll never have to undo it. */
 649                 goto smp_unlock;
 650
 651         smp = kzalloc(sizeof(*smp), GFP_KERNEL);
 652         if (NULL == smp)
 653                 /* we'll run the (safe but slow) SMP code then ... */
 654                 goto unlock;
 655
 656         smp->mod        = mod;
 657         smp->name       = name;
 658         smp->locks      = locks;
 659         smp->locks_end  = locks_end;
 660         smp->text       = text;
 661         smp->text_end   = text_end;
 662         DPRINTK("locks %p -> %p, text %p -> %p, name %s\n",
 663                 smp->locks, smp->locks_end,
 664                 smp->text, smp->text_end, smp->name);
 665
 666         list_add_tail(&smp->next, &smp_alt_modules);
 667 smp_unlock:
 668         alternatives_smp_unlock(locks, locks_end, text, text_end);
 669 unlock:
 670         mutex_unlock(&text_mutex);
 671 }
 672
 673 void __init_or_module alternatives_smp_module_del(struct module *mod)
 674 {
 675         struct smp_alt_module *item;
 676
 677         mutex_lock(&text_mutex);
 678         list_for_each_entry(item, &smp_alt_modules, next) {
 679                 if (mod != item->mod)
 680                         continue;
 681                 list_del(&item->next);
 682                 kfree(item);
 683                 break;
 684         }
 685         mutex_unlock(&text_mutex);
 686 }
 687
 688 void alternatives_enable_smp(void)
 689 {
 690         struct smp_alt_module *mod;
 691
 692         /* Why bother if there are no other CPUs? */
 693         BUG_ON(num_possible_cpus() == 1);
 694
 695         mutex_lock(&text_mutex);
 696
 697         if (uniproc_patched) {
 698                 pr_info("switching to SMP code\n");
 699                 BUG_ON(num_online_cpus() != 1);
 700                 clear_cpu_cap(&boot_cpu_data, X86_FEATURE_UP);
 701                 clear_cpu_cap(&cpu_data(0), X86_FEATURE_UP);
 702                 list_for_each_entry(mod, &smp_alt_modules, next)
 703                         alternatives_smp_lock(mod->locks, mod->locks_end,
 704                                               mod->text, mod->text_end);
 705                 uniproc_patched = false;
 706         }
 707         mutex_unlock(&text_mutex);
 708 }
 709
 710 /*
 711  * Return 1 if the address range is reserved for SMP-alternatives.
 712  * Must hold text_mutex.
 713  */
 714 int alternatives_text_reserved(void *start, void *end)
 715 {
 716         struct smp_alt_module *mod;
 717         const s32 *poff;
 718         u8 *text_start = start;
 719         u8 *text_end = end;
 720
 721         lockdep_assert_held(&text_mutex);
 722
 723         list_for_each_entry(mod, &smp_alt_modules, next) {
 724                 if (mod->text > text_end || mod->text_end < text_start)
 725                         continue;
 726                 for (poff = mod->locks; poff < mod->locks_end; poff++) {
 727                         const u8 *ptr = (const u8 *)poff + *poff;
 728
 729                         if (text_start <= ptr && text_end > ptr)
 730                                 return 1;
 731                 }
 732         }
 733
 734         return 0;
 735 }
 736 #endif /* CONFIG_SMP */
 737
 738 #ifdef CONFIG_PARAVIRT
 739 void __init_or_module apply_paravirt(struct paravirt_patch_site *start,
 740                                      struct paravirt_patch_site *end)
 741 {
 742         struct paravirt_patch_site *p;
 743         char insn_buff[MAX_PATCH_LEN];
 744
 745         for (p = start; p < end; p++) {
 746                 unsigned int used;
 747
 748                 BUG_ON(p->len > MAX_PATCH_LEN);
 749                 /* prep the buffer with the original instructions */
 750                 memcpy(insn_buff, p->instr, p->len);
 751                 used = paravirt_patch(p->type, insn_buff, (unsigned long)p->instr, p->len);
 752
 753                 BUG_ON(used > p->len);
 754
 755                 /* Pad the rest with nops */
 756                 add_nops(insn_buff + used, p->len - used);
 757                 text_poke_early(p->instr, insn_buff, p->len);
 758         }
 759 }
 760 extern struct paravirt_patch_site __start_parainstructions[],
 761         __stop_parainstructions[];
 762 #endif  /* CONFIG_PARAVIRT */
 763
 764 /*
 765  * Self-test for the INT3 based CALL emulation code.
 766  *
 767  * This exercises int3_emulate_call() to make sure INT3 pt_regs are set up
 768  * properly and that there is a stack gap between the INT3 frame and the
 769  * previous context. Without this gap doing a virtual PUSH on the interrupted
 770  * stack would corrupt the INT3 IRET frame.
 771  *
 772  * See entry_{32,64}.S for more details.
 773  */
 774
 775 /*
 776  * We define the int3_magic() function in assembly to control the calling
 777  * convention such that we can 'call' it from assembly.
 778  */
 779
 780 extern void int3_magic(unsigned int *ptr); /* defined in asm */
 781
 782 asm (
 783 "       .pushsection    .init.text, \"ax\", @progbits\n"
 784 "       .type           int3_magic, @function\n"
 785 "int3_magic:\n"
 786 "       movl    $1, (%" _ASM_ARG1 ")\n"
 787         ASM_RET
 788 "       .size           int3_magic, .-int3_magic\n"
 789 "       .popsection\n"
 790 );
 791
 792 extern __initdata unsigned long int3_selftest_ip; /* defined in asm below */
 793
 794 static int __init
 795 int3_exception_notify(struct notifier_block *self, unsigned long val, void *data)
 796 {
 797         struct die_args *args = data;
 798         struct pt_regs *regs = args->regs;
 799
 800         if (!regs || user_mode(regs))
 801                 return NOTIFY_DONE;
 802
 803         if (val != DIE_INT3)
 804                 return NOTIFY_DONE;
 805
 806         if (regs->ip - INT3_INSN_SIZE != int3_selftest_ip)
 807                 return NOTIFY_DONE;
 808
 809         int3_emulate_call(regs, (unsigned long)&int3_magic);
 810         return NOTIFY_STOP;
 811 }
 812
 813 static void __init int3_selftest(void)
 814 {
 815         static __initdata struct notifier_block int3_exception_nb = {
 816                 .notifier_call  = int3_exception_notify,
 817                 .priority       = INT_MAX-1, /* last */
 818         };
 819         unsigned int val = 0;
 820
 821         BUG_ON(register_die_notifier(&int3_exception_nb));
 822
 823         /*
 824          * Basically: int3_magic(&val); but really complicated :-)
 825          *
 826          * Stick the address of the INT3 instruction into int3_selftest_ip,
 827          * then trigger the INT3, padded with NOPs to match a CALL instruction
 828          * length.
 829          */
 830         asm volatile ("1: int3; nop; nop; nop; nop\n\t"
 831                       ".pushsection .init.data,\"aw\"\n\t"
 832                       ".align " __ASM_SEL(4, 8) "\n\t"
 833                       ".type int3_selftest_ip, @object\n\t"
 834                       ".size int3_selftest_ip, " __ASM_SEL(4, 8) "\n\t"
 835                       "int3_selftest_ip:\n\t"
 836                       __ASM_SEL(.long, .quad) " 1b\n\t"
 837                       ".popsection\n\t"
 838                       : ASM_CALL_CONSTRAINT
 839                       : __ASM_SEL_RAW(a, D) (&val)
 840                       : "memory");
 841
 842         BUG_ON(val != 1);
 843
 844         unregister_die_notifier(&int3_exception_nb);
 845 }
 846
 847 void __init alternative_instructions(void)
 848 {
 849         int3_selftest();
 850
 851         /*
 852          * The patching is not fully atomic, so try to avoid local
 853          * interruptions that might execute the to be patched code.
 854          * Other CPUs are not running.
 855          */
 856         stop_nmi();
 857
 858         /*
 859          * Don't stop machine check exceptions while patching.
 860          * MCEs only happen when something got corrupted and in this
 861          * case we must do something about the corruption.
 862          * Ignoring it is worse than an unlikely patching race.
 863          * Also machine checks tend to be broadcast and if one CPU
 864          * goes into machine check the others follow quickly, so we don't
 865          * expect a machine check to cause undue problems during to code
 866          * patching.
 867          */
 868
 869         /*
 870          * Paravirt patching and alternative patching can be combined to
 871          * replace a function call with a short direct code sequence (e.g.
 872          * by setting a constant return value instead of doing that in an
 873          * external function).
 874          * In order to make this work the following sequence is required:
 875          * 1. set (artificial) features depending on used paravirt
 876          *    functions which can later influence alternative patching
 877          * 2. apply paravirt patching (generally replacing an indirect
 878          *    function call with a direct one)
 879          * 3. apply alternative patching (e.g. replacing a direct function
 880          *    call with a custom code sequence)
 881          * Doing paravirt patching after alternative patching would clobber
 882          * the optimization of the custom code with a function call again.
 883          */
 884         paravirt_set_cap();
 885
 886         /*
 887          * First patch paravirt functions, such that we overwrite the indirect
 888          * call with the direct call.
 889          */
 890         apply_paravirt(__parainstructions, __parainstructions_end);
 891
 892         /*
 893          * Rewrite the retpolines, must be done before alternatives since
 894          * those can rewrite the retpoline thunks.
 895          */
 896         apply_retpolines(__retpoline_sites, __retpoline_sites_end);
 897         apply_returns(__return_sites, __return_sites_end);
 898
 899         /*
 900          * Then patch alternatives, such that those paravirt calls that are in
 901          * alternatives can be overwritten by their immediate fragments.
 902          */
 903         apply_alternatives(__alt_instructions, __alt_instructions_end);
 904
 905 #ifdef CONFIG_SMP
 906         /* Patch to UP if other cpus not imminent. */
 907         if (!noreplace_smp && (num_present_cpus() == 1 || setup_max_cpus <= 1)) {
 908                 uniproc_patched = true;
 909                 alternatives_smp_module_add(NULL, "core kernel",
 910                                             __smp_locks, __smp_locks_end,
 911                                             _text, _etext);
 912         }
 913
 914         if (!uniproc_patched || num_possible_cpus() == 1) {
 915                 free_init_pages("SMP alternatives",
 916                                 (unsigned long)__smp_locks,
 917                                 (unsigned long)__smp_locks_end);
 918         }
 919 #endif
 920
 921         restart_nmi();
 922         alternatives_patched = 1;
 923 }
 924
 925 /**
 926  * text_poke_early - Update instructions on a live kernel at boot time
 927  * @addr: address to modify
 928  * @opcode: source of the copy
 929  * @len: length to copy
 930  *
 931  * When you use this code to patch more than one byte of an instruction
 932  * you need to make sure that other CPUs cannot execute this code in parallel.
 933  * Also no thread must be currently preempted in the middle of these
 934  * instructions. And on the local CPU you need to be protected against NMI or
 935  * MCE handlers seeing an inconsistent instruction while you patch.
 936  */
 937 void __init_or_module text_poke_early(void *addr, const void *opcode,
 938                                       size_t len)
 939 {
 940         unsigned long flags;
 941
 942         if (boot_cpu_has(X86_FEATURE_NX) &&
 943             is_module_text_address((unsigned long)addr)) {
 944                 /*
 945                  * Modules text is marked initially as non-executable, so the
 946                  * code cannot be running and speculative code-fetches are
 947                  * prevented. Just change the code.
 948                  */
 949                 memcpy(addr, opcode, len);
 950         } else {
 951                 local_irq_save(flags);
 952                 memcpy(addr, opcode, len);
 953                 local_irq_restore(flags);
 954                 sync_core();
 955
 956                 /*
 957                  * Could also do a CLFLUSH here to speed up CPU recovery; but
 958                  * that causes hangs on some VIA CPUs.
 959                  */
 960         }
 961 }
 962
 963 typedef struct {
 964         struct mm_struct *mm;
 965 } temp_mm_state_t;
 966
 967 /*
 968  * Using a temporary mm allows to set temporary mappings that are not accessible
 969  * by other CPUs. Such mappings are needed to perform sensitive memory writes
 970  * that override the kernel memory protections (e.g., W^X), without exposing the
 971  * temporary page-table mappings that are required for these write operations to
 972  * other CPUs. Using a temporary mm also allows to avoid TLB shootdowns when the
 973  * mapping is torn down.
 974  *
 975  * Context: The temporary mm needs to be used exclusively by a single core. To
 976  *          harden security IRQs must be disabled while the temporary mm is
 977  *          loaded, thereby preventing interrupt handler bugs from overriding
 978  *          the kernel memory protection.
 979  */
 980 static inline temp_mm_state_t use_temporary_mm(struct mm_struct *mm)
 981 {
 982         temp_mm_state_t temp_state;
 983
 984         lockdep_assert_irqs_disabled();
 985
 986         /*
 987          * Make sure not to be in TLB lazy mode, as otherwise we'll end up
 988          * with a stale address space WITHOUT being in lazy mode after
 989          * restoring the previous mm.
 990          */
 991         if (this_cpu_read(cpu_tlbstate_shared.is_lazy))
 992                 leave_mm(smp_processor_id());
 993
 994         temp_state.mm = this_cpu_read(cpu_tlbstate.loaded_mm);
 995         switch_mm_irqs_off(NULL, mm, current);
 996
 997         /*
 998          * If breakpoints are enabled, disable them while the temporary mm is
 999          * used. Userspace might set up watchpoints on addresses that are used
1000          * in the temporary mm, which would lead to wrong signals being sent or
1001          * crashes.
1002          *
1003          * Note that breakpoints are not disabled selectively, which also causes
1004          * kernel breakpoints (e.g., perf's) to be disabled. This might be
1005          * undesirable, but still seems reasonable as the code that runs in the
1006          * temporary mm should be short.
1007          */
1008         if (hw_breakpoint_active())
1009                 hw_breakpoint_disable();
1010
1011         return temp_state;
1012 }
1013
1014 static inline void unuse_temporary_mm(temp_mm_state_t prev_state)
1015 {
1016         lockdep_assert_irqs_disabled();
1017         switch_mm_irqs_off(NULL, prev_state.mm, current);
1018
1019         /*
1020          * Restore the breakpoints if they were disabled before the temporary mm
1021          * was loaded.
1022          */
1023         if (hw_breakpoint_active())
1024                 hw_breakpoint_restore();
1025 }
1026
1027 __ro_after_init struct mm_struct *poking_mm;
1028 __ro_after_init unsigned long poking_addr;
1029
1030 static void *__text_poke(void *addr, const void *opcode, size_t len)
1031 {
1032         bool cross_page_boundary = offset_in_page(addr) + len > PAGE_SIZE;
1033         struct page *pages[2] = {NULL};
1034         temp_mm_state_t prev;
1035         unsigned long flags;
1036         pte_t pte, *ptep;
1037         spinlock_t *ptl;
1038         pgprot_t pgprot;
1039
1040         /*
1041          * While boot memory allocator is running we cannot use struct pages as
1042          * they are not yet initialized. There is no way to recover.
1043          */
1044         BUG_ON(!after_bootmem);
1045
1046         if (!core_kernel_text((unsigned long)addr)) {
1047                 pages[0] = vmalloc_to_page(addr);
1048                 if (cross_page_boundary)
1049                         pages[1] = vmalloc_to_page(addr + PAGE_SIZE);
1050         } else {
1051                 pages[0] = virt_to_page(addr);
1052                 WARN_ON(!PageReserved(pages[0]));
1053                 if (cross_page_boundary)
1054                         pages[1] = virt_to_page(addr + PAGE_SIZE);
1055         }
1056         /*
1057          * If something went wrong, crash and burn since recovery paths are not
1058          * implemented.
1059          */
1060         BUG_ON(!pages[0] || (cross_page_boundary && !pages[1]));
1061
1062         /*
1063          * Map the page without the global bit, as TLB flushing is done with
1064          * flush_tlb_mm_range(), which is intended for non-global PTEs.
1065          */
1066         pgprot = __pgprot(pgprot_val(PAGE_KERNEL) & ~_PAGE_GLOBAL);
1067
1068         /*
1069          * The lock is not really needed, but this allows to avoid open-coding.
1070          */
1071         ptep = get_locked_pte(poking_mm, poking_addr, &ptl);
1072
1073         /*
1074          * This must not fail; preallocated in poking_init().
1075          */
1076         VM_BUG_ON(!ptep);
1077
1078         local_irq_save(flags);
1079
1080         pte = mk_pte(pages[0], pgprot);
1081         set_pte_at(poking_mm, poking_addr, ptep, pte);
1082
1083         if (cross_page_boundary) {
1084                 pte = mk_pte(pages[1], pgprot);
1085                 set_pte_at(poking_mm, poking_addr + PAGE_SIZE, ptep + 1, pte);
1086         }
1087
1088         /*
1089          * Loading the temporary mm behaves as a compiler barrier, which
1090          * guarantees that the PTE will be set at the time memcpy() is done.
1091          */
1092         prev = use_temporary_mm(poking_mm);
1093
1094         kasan_disable_current();
1095         memcpy((u8 *)poking_addr + offset_in_page(addr), opcode, len);
1096         kasan_enable_current();
1097
1098         /*
1099          * Ensure that the PTE is only cleared after the instructions of memcpy
1100          * were issued by using a compiler barrier.
1101          */
1102         barrier();
1103
1104         pte_clear(poking_mm, poking_addr, ptep);
1105         if (cross_page_boundary)
1106                 pte_clear(poking_mm, poking_addr + PAGE_SIZE, ptep + 1);
1107
1108         /*
1109          * Loading the previous page-table hierarchy requires a serializing
1110          * instruction that already allows the core to see the updated version.
1111          * Xen-PV is assumed to serialize execution in a similar manner.
1112          */
1113         unuse_temporary_mm(prev);
1114
1115         /*
1116          * Flushing the TLB might involve IPIs, which would require enabled
1117          * IRQs, but not if the mm is not used, as it is in this point.
1118          */
1119         flush_tlb_mm_range(poking_mm, poking_addr, poking_addr +
1120                            (cross_page_boundary ? 2 : 1) * PAGE_SIZE,
1121                            PAGE_SHIFT, false);
1122
1123         /*
1124          * If the text does not match what we just wrote then something is
1125          * fundamentally screwy; there's nothing we can really do about that.
1126          */
1127         BUG_ON(memcmp(addr, opcode, len));
1128
1129         local_irq_restore(flags);
1130         pte_unmap_unlock(ptep, ptl);
1131         return addr;
1132 }
1133
1134 /**
1135  * text_poke - Update instructions on a live kernel
1136  * @addr: address to modify
1137  * @opcode: source of the copy
1138  * @len: length to copy
1139  *
1140  * Only atomic text poke/set should be allowed when not doing early patching.
1141  * It means the size must be writable atomically and the address must be aligned
1142  * in a way that permits an atomic write. It also makes sure we fit on a single
1143  * page.
1144  *
1145  * Note that the caller must ensure that if the modified code is part of a
1146  * module, the module would not be removed during poking. This can be achieved
1147  * by registering a module notifier, and ordering module removal and patching
1148  * trough a mutex.
1149  */
1150 void *text_poke(void *addr, const void *opcode, size_t len)
1151 {
1152         lockdep_assert_held(&text_mutex);
1153
1154         return __text_poke(addr, opcode, len);
1155 }
1156
1157 /**
1158  * text_poke_kgdb - Update instructions on a live kernel by kgdb
1159  * @addr: address to modify
1160  * @opcode: source of the copy
1161  * @len: length to copy
1162  *
1163  * Only atomic text poke/set should be allowed when not doing early patching.
1164  * It means the size must be writable atomically and the address must be aligned
1165  * in a way that permits an atomic write. It also makes sure we fit on a single
1166  * page.
1167  *
1168  * Context: should only be used by kgdb, which ensures no other core is running,
1169  *          despite the fact it does not hold the text_mutex.
1170  */
1171 void *text_poke_kgdb(void *addr, const void *opcode, size_t len)
1172 {
1173         return __text_poke(addr, opcode, len);
1174 }
1175
1176 static void do_sync_core(void *info)
1177 {
1178         sync_core();
1179 }
1180
1181 void text_poke_sync(void)
1182 {
1183         on_each_cpu(do_sync_core, NULL, 1);
1184 }
1185
1186 struct text_poke_loc {
1187         /* addr := _stext + rel_addr */
1188         s32 rel_addr;
1189         s32 disp;
1190         u8 len;
1191         u8 opcode;
1192         const u8 text[POKE_MAX_OPCODE_SIZE];
1193         /* see text_poke_bp_batch() */
1194         u8 old;
1195 };
1196
1197 struct bp_patching_desc {
1198         struct text_poke_loc *vec;
1199         int nr_entries;
1200         atomic_t refs;
1201 };
1202
1203 static struct bp_patching_desc *bp_desc;
1204
1205 static __always_inline
1206 struct bp_patching_desc *try_get_desc(struct bp_patching_desc **descp)
1207 {
1208         /* rcu_dereference */
1209         struct bp_patching_desc *desc = __READ_ONCE(*descp);
1210
1211         if (!desc || !arch_atomic_inc_not_zero(&desc->refs))
1212                 return NULL;
1213
1214         return desc;
1215 }
1216
1217 static __always_inline void put_desc(struct bp_patching_desc *desc)
1218 {
1219         smp_mb__before_atomic();
1220         arch_atomic_dec(&desc->refs);
1221 }
1222
1223 static __always_inline void *text_poke_addr(struct text_poke_loc *tp)
1224 {
1225         return _stext + tp->rel_addr;
1226 }
1227
1228 static __always_inline int patch_cmp(const void *key, const void *elt)
1229 {
1230         struct text_poke_loc *tp = (struct text_poke_loc *) elt;
1231
1232         if (key < text_poke_addr(tp))
1233                 return -1;
1234         if (key > text_poke_addr(tp))
1235                 return 1;
1236         return 0;
1237 }
1238
1239 noinstr int poke_int3_handler(struct pt_regs *regs)
1240 {
1241         struct bp_patching_desc *desc;
1242         struct text_poke_loc *tp;
1243         int ret = 0;
1244         void *ip;
1245
1246         if (user_mode(regs))
1247                 return 0;
1248
1249         /*
1250          * Having observed our INT3 instruction, we now must observe
1251          * bp_desc:
1252          *
1253          *      bp_desc = desc                  INT3
1254          *      WMB                             RMB
1255          *      write INT3                      if (desc)
1256          */
1257         smp_rmb();
1258
1259         desc = try_get_desc(&bp_desc);
1260         if (!desc)
1261                 return 0;
1262
1263         /*
1264          * Discount the INT3. See text_poke_bp_batch().
1265          */
1266         ip = (void *) regs->ip - INT3_INSN_SIZE;
1267
1268         /*
1269          * Skip the binary search if there is a single member in the vector.
1270          */
1271         if (unlikely(desc->nr_entries > 1)) {
1272                 tp = __inline_bsearch(ip, desc->vec, desc->nr_entries,
1273                                       sizeof(struct text_poke_loc),
1274                                       patch_cmp);
1275                 if (!tp)
1276                         goto out_put;
1277         } else {
1278                 tp = desc->vec;
1279                 if (text_poke_addr(tp) != ip)
1280                         goto out_put;
1281         }
1282
1283         ip += tp->len;
1284
1285         switch (tp->opcode) {
1286         case INT3_INSN_OPCODE:
1287                 /*
1288                  * Someone poked an explicit INT3, they'll want to handle it,
1289                  * do not consume.
1290                  */
1291                 goto out_put;
1292
1293         case RET_INSN_OPCODE:
1294                 int3_emulate_ret(regs);
1295                 break;
1296
1297         case CALL_INSN_OPCODE:
1298                 int3_emulate_call(regs, (long)ip + tp->disp);
1299                 break;
1300
1301         case JMP32_INSN_OPCODE:
1302         case JMP8_INSN_OPCODE:
1303                 int3_emulate_jmp(regs, (long)ip + tp->disp);
1304                 break;
1305
1306         default:
1307                 BUG();
1308         }
1309
1310         ret = 1;
1311
1312 out_put:
1313         put_desc(desc);
1314         return ret;
1315 }
1316
1317 #define TP_VEC_MAX (PAGE_SIZE / sizeof(struct text_poke_loc))
1318 static struct text_poke_loc tp_vec[TP_VEC_MAX];
1319 static int tp_vec_nr;
1320
1321 /**
1322  * text_poke_bp_batch() -- update instructions on live kernel on SMP
1323  * @tp:                 vector of instructions to patch
1324  * @nr_entries:         number of entries in the vector
1325  *
1326  * Modify multi-byte instruction by using int3 breakpoint on SMP.
1327  * We completely avoid stop_machine() here, and achieve the
1328  * synchronization using int3 breakpoint.
1329  *
1330  * The way it is done:
1331  *      - For each entry in the vector:
1332  *              - add a int3 trap to the address that will be patched
1333  *      - sync cores
1334  *      - For each entry in the vector:
1335  *              - update all but the first byte of the patched range
1336  *      - sync cores
1337  *      - For each entry in the vector:
1338  *              - replace the first byte (int3) by the first byte of
1339  *                replacing opcode
1340  *      - sync cores
1341  */
1342 static void text_poke_bp_batch(struct text_poke_loc *tp, unsigned int nr_entries)
1343 {
1344         struct bp_patching_desc desc = {
1345                 .vec = tp,
1346                 .nr_entries = nr_entries,
1347                 .refs = ATOMIC_INIT(1),
1348         };
1349         unsigned char int3 = INT3_INSN_OPCODE;
1350         unsigned int i;
1351         int do_sync;
1352
1353         lockdep_assert_held(&text_mutex);
1354
1355         smp_store_release(&bp_desc, &desc); /* rcu_assign_pointer */
1356
1357         /*
1358          * Corresponding read barrier in int3 notifier for making sure the
1359          * nr_entries and handler are correctly ordered wrt. patching.
1360          */
1361         smp_wmb();
1362
1363         /*
1364          * First step: add a int3 trap to the address that will be patched.
1365          */
1366         for (i = 0; i < nr_entries; i++) {
1367                 tp[i].old = *(u8 *)text_poke_addr(&tp[i]);
1368                 text_poke(text_poke_addr(&tp[i]), &int3, INT3_INSN_SIZE);
1369         }
1370
1371         text_poke_sync();
1372
1373         /*
1374          * Second step: update all but the first byte of the patched range.
1375          */
1376         for (do_sync = 0, i = 0; i < nr_entries; i++) {
1377                 u8 old[POKE_MAX_OPCODE_SIZE] = { tp[i].old, };
1378                 int len = tp[i].len;
1379
1380                 if (len - INT3_INSN_SIZE > 0) {
1381                         memcpy(old + INT3_INSN_SIZE,
1382                                text_poke_addr(&tp[i]) + INT3_INSN_SIZE,
1383                                len - INT3_INSN_SIZE);
1384                         text_poke(text_poke_addr(&tp[i]) + INT3_INSN_SIZE,
1385                                   (const char *)tp[i].text + INT3_INSN_SIZE,
1386                                   len - INT3_INSN_SIZE);
1387                         do_sync++;
1388                 }
1389
1390                 /*
1391                  * Emit a perf event to record the text poke, primarily to
1392                  * support Intel PT decoding which must walk the executable code
1393                  * to reconstruct the trace. The flow up to here is:
1394                  *   - write INT3 byte
1395                  *   - IPI-SYNC
1396                  *   - write instruction tail
1397                  * At this point the actual control flow will be through the
1398                  * INT3 and handler and not hit the old or new instruction.
1399                  * Intel PT outputs FUP/TIP packets for the INT3, so the flow
1400                  * can still be decoded. Subsequently:
1401                  *   - emit RECORD_TEXT_POKE with the new instruction
1402                  *   - IPI-SYNC
1403                  *   - write first byte
1404                  *   - IPI-SYNC
1405                  * So before the text poke event timestamp, the decoder will see
1406                  * either the old instruction flow or FUP/TIP of INT3. After the
1407                  * text poke event timestamp, the decoder will see either the
1408                  * new instruction flow or FUP/TIP of INT3. Thus decoders can
1409                  * use the timestamp as the point at which to modify the
1410                  * executable code.
1411                  * The old instruction is recorded so that the event can be
1412                  * processed forwards or backwards.
1413                  */
1414                 perf_event_text_poke(text_poke_addr(&tp[i]), old, len,
1415                                      tp[i].text, len);
1416         }
1417
1418         if (do_sync) {
1419                 /*
1420                  * According to Intel, this core syncing is very likely
1421                  * not necessary and we'd be safe even without it. But
1422                  * better safe than sorry (plus there's not only Intel).
1423                  */
1424                 text_poke_sync();
1425         }
1426
1427         /*
1428          * Third step: replace the first byte (int3) by the first byte of
1429          * replacing opcode.
1430          */
1431         for (do_sync = 0, i = 0; i < nr_entries; i++) {
1432                 if (tp[i].text[0] == INT3_INSN_OPCODE)
1433                         continue;
1434
1435                 text_poke(text_poke_addr(&tp[i]), tp[i].text, INT3_INSN_SIZE);
1436                 do_sync++;
1437         }
1438
1439         if (do_sync)
1440                 text_poke_sync();
1441
1442         /*
1443          * Remove and synchronize_rcu(), except we have a very primitive
1444          * refcount based completion.
1445          */
1446         WRITE_ONCE(bp_desc, NULL); /* RCU_INIT_POINTER */
1447         if (!atomic_dec_and_test(&desc.refs))
1448                 atomic_cond_read_acquire(&desc.refs, !VAL);
1449 }
1450
1451 static void text_poke_loc_init(struct text_poke_loc *tp, void *addr,
1452                                const void *opcode, size_t len, const void *emulate)
1453 {
1454         struct insn insn;
1455         int ret, i;
1456
1457         memcpy((void *)tp->text, opcode, len);
1458         if (!emulate)
1459                 emulate = opcode;
1460
1461         ret = insn_decode_kernel(&insn, emulate);
1462         BUG_ON(ret < 0);
1463
1464         tp->rel_addr = addr - (void *)_stext;
1465         tp->len = len;
1466         tp->opcode = insn.opcode.bytes[0];
1467
1468         switch (tp->opcode) {
1469         case RET_INSN_OPCODE:
1470         case JMP32_INSN_OPCODE:
1471         case JMP8_INSN_OPCODE:
1472                 /*
1473                  * Control flow instructions without implied execution of the
1474                  * next instruction can be padded with INT3.
1475                  */
1476                 for (i = insn.length; i < len; i++)
1477                         BUG_ON(tp->text[i] != INT3_INSN_OPCODE);
1478                 break;
1479
1480         default:
1481                 BUG_ON(len != insn.length);
1482         };
1483
1484
1485         switch (tp->opcode) {
1486         case INT3_INSN_OPCODE:
1487         case RET_INSN_OPCODE:
1488                 break;
1489
1490         case CALL_INSN_OPCODE:
1491         case JMP32_INSN_OPCODE:
1492         case JMP8_INSN_OPCODE:
1493                 tp->disp = insn.immediate.value;
1494                 break;
1495
1496         default: /* assume NOP */
1497                 switch (len) {
1498                 case 2: /* NOP2 -- emulate as JMP8+0 */
1499                         BUG_ON(memcmp(emulate, x86_nops[len], len));
1500                         tp->opcode = JMP8_INSN_OPCODE;
1501                         tp->disp = 0;
1502                         break;
1503
1504                 case 5: /* NOP5 -- emulate as JMP32+0 */
1505                         BUG_ON(memcmp(emulate, x86_nops[len], len));
1506                         tp->opcode = JMP32_INSN_OPCODE;
1507                         tp->disp = 0;
1508                         break;
1509
1510                 default: /* unknown instruction */
1511                         BUG();
1512                 }
1513                 break;
1514         }
1515 }
1516
1517 /*
1518  * We hard rely on the tp_vec being ordered; ensure this is so by flushing
1519  * early if needed.
1520  */
1521 static bool tp_order_fail(void *addr)
1522 {
1523         struct text_poke_loc *tp;
1524
1525         if (!tp_vec_nr)
1526                 return false;
1527
1528         if (!addr) /* force */
1529                 return true;
1530
1531         tp = &tp_vec[tp_vec_nr - 1];
1532         if ((unsigned long)text_poke_addr(tp) > (unsigned long)addr)
1533                 return true;
1534
1535         return false;
1536 }
1537
1538 static void text_poke_flush(void *addr)
1539 {
1540         if (tp_vec_nr == TP_VEC_MAX || tp_order_fail(addr)) {
1541                 text_poke_bp_batch(tp_vec, tp_vec_nr);
1542                 tp_vec_nr = 0;
1543         }
1544 }
1545
1546 void text_poke_finish(void)
1547 {
1548         text_poke_flush(NULL);
1549 }
1550
1551 void __ref text_poke_queue(void *addr, const void *opcode, size_t len, const void *emulate)
1552 {
1553         struct text_poke_loc *tp;
1554
1555         if (unlikely(system_state == SYSTEM_BOOTING)) {
1556                 text_poke_early(addr, opcode, len);
1557                 return;
1558         }
1559
1560         text_poke_flush(addr);
1561
1562         tp = &tp_vec[tp_vec_nr++];
1563         text_poke_loc_init(tp, addr, opcode, len, emulate);
1564 }
1565
1566 /**
1567  * text_poke_bp() -- update instructions on live kernel on SMP
1568  * @addr:       address to patch
1569  * @opcode:     opcode of new instruction
1570  * @len:        length to copy
1571  * @emulate:    instruction to be emulated
1572  *
1573  * Update a single instruction with the vector in the stack, avoiding
1574  * dynamically allocated memory. This function should be used when it is
1575  * not possible to allocate memory.
1576  */
1577 void __ref text_poke_bp(void *addr, const void *opcode, size_t len, const void *emulate)
1578 {
1579         struct text_poke_loc tp;
1580
1581         if (unlikely(system_state == SYSTEM_BOOTING)) {
1582                 text_poke_early(addr, opcode, len);
1583                 return;
1584         }
1585
1586         text_poke_loc_init(&tp, addr, opcode, len, emulate);
1587         text_poke_bp_batch(&tp, 1);
1588 }