Merge remote-tracking branch 'regulator/for-5.15' into regulator-next
[linux-2.6-microblaze.git] / arch / s390 / kernel / alternative.c
1 // SPDX-License-Identifier: GPL-2.0
2 #include <linux/module.h>
3 #include <asm/alternative.h>
4 #include <asm/facility.h>
5 #include <asm/nospec-branch.h>
6
7 #define MAX_PATCH_LEN (255 - 1)
8
9 static int __initdata_or_module alt_instr_disabled;
10
11 static int __init disable_alternative_instructions(char *str)
12 {
13         alt_instr_disabled = 1;
14         return 0;
15 }
16
17 early_param("noaltinstr", disable_alternative_instructions);
18
19 struct brcl_insn {
20         u16 opc;
21         s32 disp;
22 } __packed;
23
24 static u16 __initdata_or_module nop16 = 0x0700;
25 static u32 __initdata_or_module nop32 = 0x47000000;
26 static struct brcl_insn __initdata_or_module nop48 = {
27         0xc004, 0
28 };
29
30 static const void *nops[] __initdata_or_module = {
31         &nop16,
32         &nop32,
33         &nop48
34 };
35
36 static void __init_or_module add_jump_padding(void *insns, unsigned int len)
37 {
38         struct brcl_insn brcl = {
39                 0xc0f4,
40                 len / 2
41         };
42
43         memcpy(insns, &brcl, sizeof(brcl));
44         insns += sizeof(brcl);
45         len -= sizeof(brcl);
46
47         while (len > 0) {
48                 memcpy(insns, &nop16, 2);
49                 insns += 2;
50                 len -= 2;
51         }
52 }
53
54 static void __init_or_module add_padding(void *insns, unsigned int len)
55 {
56         if (len > 6)
57                 add_jump_padding(insns, len);
58         else if (len >= 2)
59                 memcpy(insns, nops[len / 2 - 1], len);
60 }
61
62 static void __init_or_module __apply_alternatives(struct alt_instr *start,
63                                                   struct alt_instr *end)
64 {
65         struct alt_instr *a;
66         u8 *instr, *replacement;
67         u8 insnbuf[MAX_PATCH_LEN];
68
69         /*
70          * The scan order should be from start to end. A later scanned
71          * alternative code can overwrite previously scanned alternative code.
72          */
73         for (a = start; a < end; a++) {
74                 int insnbuf_sz = 0;
75
76                 instr = (u8 *)&a->instr_offset + a->instr_offset;
77                 replacement = (u8 *)&a->repl_offset + a->repl_offset;
78
79                 if (!__test_facility(a->facility, alt_stfle_fac_list))
80                         continue;
81
82                 if (unlikely(a->instrlen % 2 || a->replacementlen % 2)) {
83                         WARN_ONCE(1, "cpu alternatives instructions length is "
84                                      "odd, skipping patching\n");
85                         continue;
86                 }
87
88                 memcpy(insnbuf, replacement, a->replacementlen);
89                 insnbuf_sz = a->replacementlen;
90
91                 if (a->instrlen > a->replacementlen) {
92                         add_padding(insnbuf + a->replacementlen,
93                                     a->instrlen - a->replacementlen);
94                         insnbuf_sz += a->instrlen - a->replacementlen;
95                 }
96
97                 s390_kernel_write(instr, insnbuf, insnbuf_sz);
98         }
99 }
100
101 void __init_or_module apply_alternatives(struct alt_instr *start,
102                                          struct alt_instr *end)
103 {
104         if (!alt_instr_disabled)
105                 __apply_alternatives(start, end);
106 }
107
108 extern struct alt_instr __alt_instructions[], __alt_instructions_end[];
109 void __init apply_alternative_instructions(void)
110 {
111         apply_alternatives(__alt_instructions, __alt_instructions_end);
112 }