1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _ASM_S390_ALTERNATIVE_H 3 #define _ASM_S390_ALTERNATIVE_H 4 5 #ifndef __ASSEMBLY__ 6 7 #include <linux/types.h> 8 #include <linux/stddef.h> 9 #include <linux/stringify.h> 10 11 struct alt_instr { 12 s32 instr_offset; /* original instruction */ 13 s32 repl_offset; /* offset to replacement instruction */ 14 u16 facility; /* facility bit set for replacement */ 15 u8 instrlen; /* length of original instruction */ 16 u8 replacementlen; /* length of new instruction */ 17 } __packed; 18 19 void apply_alternative_instructions(void); 20 void apply_alternatives(struct alt_instr *start, struct alt_instr *end); 21 22 /* 23 * |661: |662: |6620 |663: 24 * +-----------+---------------------+ 25 * | oldinstr | oldinstr_padding | 26 * | +----------+----------+ 27 * | | | | 28 * | | >6 bytes |6/4/2 nops| 29 * | |6 bytes jg-----------> 30 * +-----------+---------------------+ 31 * ^^ static padding ^^ 32 * 33 * .altinstr_replacement section 34 * +---------------------+-----------+ 35 * |6641: |6651: 36 * | alternative instr 1 | 37 * +-----------+---------+- - - - - -+ 38 * |6642: |6652: | 39 * | alternative instr 2 | padding 40 * +---------------------+- - - - - -+ 41 * ^ runtime ^ 42 * 43 * .altinstructions section 44 * +---------------------------------+ 45 * | alt_instr entries for each | 46 * | alternative instr | 47 * +---------------------------------+ 48 */ 49 50 #define b_altinstr(num) "664"#num 51 #define e_altinstr(num) "665"#num 52 53 #define e_oldinstr_pad_end "663" 54 #define oldinstr_len "662b-661b" 55 #define oldinstr_total_len e_oldinstr_pad_end"b-661b" 56 #define altinstr_len(num) e_altinstr(num)"b-"b_altinstr(num)"b" 57 #define oldinstr_pad_len(num) \ 58 "-(((" altinstr_len(num) ")-(" oldinstr_len ")) > 0) * " \ 59 "((" altinstr_len(num) ")-(" oldinstr_len "))" 60 61 #define INSTR_LEN_SANITY_CHECK(len) \ 62 ".if " len " > 254\n" \ 63 "\t.error \"cpu alternatives does not support instructions " \ 64 "blocks > 254 bytes\"\n" \ 65 ".endif\n" \ 66 ".if (" len ") %% 2\n" \ 67 "\t.error \"cpu alternatives instructions length is odd\"\n" \ 68 ".endif\n" 69 70 #define OLDINSTR_PADDING(oldinstr, num) \ 71 ".if " oldinstr_pad_len(num) " > 6\n" \ 72 "\tjg " e_oldinstr_pad_end "f\n" \ 73 "6620:\n" \ 74 "\t.rept (" oldinstr_pad_len(num) " - (6620b-662b)) / 2\n" \ 75 "\tnopr\n" \ 76 ".else\n" \ 77 "\t.rept " oldinstr_pad_len(num) " / 6\n" \ 78 "\t.brcl 0,0\n" \ 79 "\t.endr\n" \ 80 "\t.rept " oldinstr_pad_len(num) " %% 6 / 4\n" \ 81 "\tnop\n" \ 82 "\t.endr\n" \ 83 "\t.rept " oldinstr_pad_len(num) " %% 6 %% 4 / 2\n" \ 84 "\tnopr\n" \ 85 ".endr\n" \ 86 ".endif\n" 87 88 #define OLDINSTR(oldinstr, num) \ 89 "661:\n\t" oldinstr "\n662:\n" \ 90 OLDINSTR_PADDING(oldinstr, num) \ 91 e_oldinstr_pad_end ":\n" \ 92 INSTR_LEN_SANITY_CHECK(oldinstr_len) 93 94 #define OLDINSTR_2(oldinstr, num1, num2) \ 95 "661:\n\t" oldinstr "\n662:\n" \ 96 ".if " altinstr_len(num1) " < " altinstr_len(num2) "\n" \ 97 OLDINSTR_PADDING(oldinstr, num2) \ 98 ".else\n" \ 99 OLDINSTR_PADDING(oldinstr, num1) \ 100 ".endif\n" \ 101 e_oldinstr_pad_end ":\n" \ 102 INSTR_LEN_SANITY_CHECK(oldinstr_len) 103 104 #define ALTINSTR_ENTRY(facility, num) \ 105 "\t.long 661b - .\n" /* old instruction */ \ 106 "\t.long " b_altinstr(num)"b - .\n" /* alt instruction */ \ 107 "\t.word " __stringify(facility) "\n" /* facility bit */ \ 108 "\t.byte " oldinstr_total_len "\n" /* source len */ \ 109 "\t.byte " altinstr_len(num) "\n" /* alt instruction len */ 110 111 #define ALTINSTR_REPLACEMENT(altinstr, num) /* replacement */ \ 112 b_altinstr(num)":\n\t" altinstr "\n" e_altinstr(num) ":\n" \ 113 INSTR_LEN_SANITY_CHECK(altinstr_len(num)) 114 115 /* alternative assembly primitive: */ 116 #define ALTERNATIVE(oldinstr, altinstr, facility) \ 117 ".pushsection .altinstr_replacement, \"ax\"\n" \ 118 ALTINSTR_REPLACEMENT(altinstr, 1) \ 119 ".popsection\n" \ 120 OLDINSTR(oldinstr, 1) \ 121 ".pushsection .altinstructions,\"a\"\n" \ 122 ALTINSTR_ENTRY(facility, 1) \ 123 ".popsection\n" 124 125 #define ALTERNATIVE_2(oldinstr, altinstr1, facility1, altinstr2, facility2)\ 126 ".pushsection .altinstr_replacement, \"ax\"\n" \ 127 ALTINSTR_REPLACEMENT(altinstr1, 1) \ 128 ALTINSTR_REPLACEMENT(altinstr2, 2) \ 129 ".popsection\n" \ 130 OLDINSTR_2(oldinstr, 1, 2) \ 131 ".pushsection .altinstructions,\"a\"\n" \ 132 ALTINSTR_ENTRY(facility1, 1) \ 133 ALTINSTR_ENTRY(facility2, 2) \ 134 ".popsection\n" 135 136 /* 137 * Alternative instructions for different CPU types or capabilities. 138 * 139 * This allows to use optimized instructions even on generic binary 140 * kernels. 141 * 142 * oldinstr is padded with jump and nops at compile time if altinstr is 143 * longer. altinstr is padded with jump and nops at run-time during patching. 144 * 145 * For non barrier like inlines please define new variants 146 * without volatile and memory clobber. 147 */ 148 #define alternative(oldinstr, altinstr, facility) \ 149 asm_inline volatile(ALTERNATIVE(oldinstr, altinstr, facility) : : : "memory") 150 151 #define alternative_2(oldinstr, altinstr1, facility1, altinstr2, facility2) \ 152 asm_inline volatile(ALTERNATIVE_2(oldinstr, altinstr1, facility1, \ 153 altinstr2, facility2) ::: "memory") 154 155 /* Alternative inline assembly with input. */ 156 #define alternative_input(oldinstr, newinstr, feature, input...) \ 157 asm_inline volatile (ALTERNATIVE(oldinstr, newinstr, feature) \ 158 : : input) 159 160 /* Like alternative_input, but with a single output argument */ 161 #define alternative_io(oldinstr, altinstr, facility, output, input...) \ 162 asm_inline volatile(ALTERNATIVE(oldinstr, altinstr, facility) \ 163 : output : input) 164 165 /* Use this macro if more than one output parameter is needed. */ 166 #define ASM_OUTPUT2(a...) a 167 168 /* Use this macro if clobbers are needed without inputs. */ 169 #define ASM_NO_INPUT_CLOBBER(clobber...) : clobber 170 171 #endif /* __ASSEMBLY__ */ 172 173 #endif /* _ASM_S390_ALTERNATIVE_H */ 174