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