1 #ifndef _ASM_POWERPC_HEAD_64_H 2 #define _ASM_POWERPC_HEAD_64_H 3 4 #include <asm/cache.h> 5 6 #ifdef __ASSEMBLY__ 7 /* 8 * We can't do CPP stringification and concatination directly into the section 9 * name for some reason, so these macros can do it for us. 10 */ 11 .macro define_ftsec name 12 .section ".head.text.\name\()","ax",@progbits 13 .endm 14 .macro define_data_ftsec name 15 .section ".head.data.\name\()","a",@progbits 16 .endm 17 .macro use_ftsec name 18 .section ".head.text.\name\()" 19 .endm 20 21 /* 22 * Fixed (location) sections are used by opening fixed sections and emitting 23 * fixed section entries into them before closing them. Multiple fixed sections 24 * can be open at any time. 25 * 26 * Each fixed section created in a .S file must have corresponding linkage 27 * directives including location, added to arch/powerpc/kernel/vmlinux.lds.S 28 * 29 * For each fixed section, code is generated into it in the order which it 30 * appears in the source. Fixed section entries can be placed at a fixed 31 * location within the section using _LOCATION postifx variants. These must 32 * be ordered according to their relative placements within the section. 33 * 34 * OPEN_FIXED_SECTION(section_name, start_address, end_address) 35 * FIXED_SECTION_ENTRY_BEGIN(section_name, label1) 36 * 37 * USE_FIXED_SECTION(section_name) 38 * label3: 39 * li r10,128 40 * mv r11,r10 41 42 * FIXED_SECTION_ENTRY_BEGIN_LOCATION(section_name, label2, start_address, size) 43 * FIXED_SECTION_ENTRY_END_LOCATION(section_name, label2, start_address, size) 44 * CLOSE_FIXED_SECTION(section_name) 45 * 46 * ZERO_FIXED_SECTION can be used to emit zeroed data. 47 * 48 * Troubleshooting: 49 * - If the build dies with "Error: attempt to move .org backwards" at 50 * CLOSE_FIXED_SECTION() or elsewhere, there may be something 51 * unexpected being added there. Remove the '. = x_len' line, rebuild, and 52 * check what is pushing the section down. 53 * - If the build dies in linking, check arch/powerpc/tools/head_check.sh 54 * comments. 55 * - If the kernel crashes or hangs in very early boot, it could be linker 56 * stubs at the start of the main text. 57 */ 58 59 #define OPEN_FIXED_SECTION(sname, start, end) \ 60 sname##_start = (start); \ 61 sname##_end = (end); \ 62 sname##_len = (end) - (start); \ 63 define_ftsec sname; \ 64 . = 0x0; \ 65 start_##sname: 66 67 /* 68 * .linker_stub_catch section is used to catch linker stubs from being 69 * inserted in our .text section, above the start_text label (which breaks 70 * the ABS_ADDR calculation). See kernel/vmlinux.lds.S and tools/head_check.sh 71 * for more details. We would prefer to just keep a cacheline (0x80), but 72 * 0x100 seems to be how the linker aligns branch stub groups. 73 */ 74 #ifdef CONFIG_LD_HEAD_STUB_CATCH 75 #define OPEN_TEXT_SECTION(start) \ 76 .section ".linker_stub_catch","ax",@progbits; \ 77 linker_stub_catch: \ 78 . = 0x4; \ 79 text_start = (start) + 0x100; \ 80 .section ".text","ax",@progbits; \ 81 .balign 0x100; \ 82 start_text: 83 #else 84 #define OPEN_TEXT_SECTION(start) \ 85 text_start = (start); \ 86 .section ".text","ax",@progbits; \ 87 . = 0x0; \ 88 start_text: 89 #endif 90 91 #define ZERO_FIXED_SECTION(sname, start, end) \ 92 sname##_start = (start); \ 93 sname##_end = (end); \ 94 sname##_len = (end) - (start); \ 95 define_data_ftsec sname; \ 96 . = 0x0; \ 97 . = sname##_len; 98 99 #define USE_FIXED_SECTION(sname) \ 100 fs_label = start_##sname; \ 101 fs_start = sname##_start; \ 102 use_ftsec sname; 103 104 #define USE_TEXT_SECTION() \ 105 fs_label = start_text; \ 106 fs_start = text_start; \ 107 .text 108 109 #define CLOSE_FIXED_SECTION(sname) \ 110 USE_FIXED_SECTION(sname); \ 111 . = sname##_len; \ 112 end_##sname: 113 114 115 #define __FIXED_SECTION_ENTRY_BEGIN(sname, name, __align) \ 116 USE_FIXED_SECTION(sname); \ 117 .balign __align; \ 118 .global name; \ 119 name: 120 121 #define FIXED_SECTION_ENTRY_BEGIN(sname, name) \ 122 __FIXED_SECTION_ENTRY_BEGIN(sname, name, IFETCH_ALIGN_BYTES) 123 124 #define FIXED_SECTION_ENTRY_BEGIN_LOCATION(sname, name, start, size) \ 125 USE_FIXED_SECTION(sname); \ 126 name##_start = (start); \ 127 .if ((start) % (size) != 0); \ 128 .error "Fixed section exception vector misalignment"; \ 129 .endif; \ 130 .if ((size) != 0x20) && ((size) != 0x80) && ((size) != 0x100); \ 131 .error "Fixed section exception vector bad size"; \ 132 .endif; \ 133 .if (start) < sname##_start; \ 134 .error "Fixed section underflow"; \ 135 .abort; \ 136 .endif; \ 137 . = (start) - sname##_start; \ 138 .global name; \ 139 name: 140 141 #define FIXED_SECTION_ENTRY_END_LOCATION(sname, name, start, size) \ 142 .if (start) + (size) > sname##_end; \ 143 .error "Fixed section overflow"; \ 144 .abort; \ 145 .endif; \ 146 .if (. - name > (start) + (size) - name##_start); \ 147 .error "Fixed entry overflow"; \ 148 .abort; \ 149 .endif; \ 150 . = ((start) + (size) - sname##_start); \ 151 152 153 /* 154 * These macros are used to change symbols in other fixed sections to be 155 * absolute or related to our current fixed section. 156 * 157 * - DEFINE_FIXED_SYMBOL / FIXED_SYMBOL_ABS_ADDR is used to find the 158 * absolute address of a symbol within a fixed section, from any section. 159 * 160 * - ABS_ADDR is used to find the absolute address of any symbol, from within 161 * a fixed section. 162 */ 163 #define DEFINE_FIXED_SYMBOL(label) \ 164 label##_absolute = (label - fs_label + fs_start) 165 166 #define FIXED_SYMBOL_ABS_ADDR(label) \ 167 (label##_absolute) 168 169 #define ABS_ADDR(label) (label - fs_label + fs_start) 170 171 /* 172 * Following are the BOOK3S exception handler helper macros. 173 * Handlers come in a number of types, and each type has a number of varieties. 174 * 175 * EXC_REAL_* - real, unrelocated exception vectors 176 * EXC_VIRT_* - virt (AIL), unrelocated exception vectors 177 * TRAMP_REAL_* - real, unrelocated helpers (virt can call these) 178 * TRAMP_VIRT_* - virt, unreloc helpers (in practice, real can use) 179 * TRAMP_KVM - KVM handlers that get put into real, unrelocated 180 * EXC_COMMON_* - virt, relocated common handlers 181 * 182 * The EXC handlers are given a name, and branch to name_common, or the 183 * appropriate KVM or masking function. Vector handler verieties are as 184 * follows: 185 * 186 * EXC_{REAL|VIRT}_BEGIN/END - used to open-code the exception 187 * 188 * EXC_{REAL|VIRT} - standard exception 189 * 190 * EXC_{REAL|VIRT}_suffix 191 * where _suffix is: 192 * - _MASKABLE - maskable exception 193 * - _OOL - out of line with trampoline to common handler 194 * - _HV - HV exception 195 * 196 * There can be combinations, e.g., EXC_VIRT_OOL_MASKABLE_HV 197 * 198 * The one unusual case is __EXC_REAL_OOL_HV_DIRECT, which is 199 * an OOL vector that branches to a specified handler rather than the usual 200 * trampoline that goes to common. It, and other underscore macros, should 201 * be used with care. 202 * 203 * KVM handlers come in the following verieties: 204 * TRAMP_KVM 205 * TRAMP_KVM_SKIP 206 * TRAMP_KVM_HV 207 * TRAMP_KVM_HV_SKIP 208 * 209 * COMMON handlers come in the following verieties: 210 * EXC_COMMON_BEGIN/END - used to open-code the handler 211 * EXC_COMMON 212 * EXC_COMMON_ASYNC 213 * EXC_COMMON_HV 214 * 215 * TRAMP_REAL and TRAMP_VIRT can be used with BEGIN/END. KVM 216 * and OOL handlers are implemented as types of TRAMP and TRAMP_VIRT handlers. 217 */ 218 219 #define EXC_REAL_BEGIN(name, start, size) \ 220 FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##name, start, size) 221 222 #define EXC_REAL_END(name, start, size) \ 223 FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##name, start, size) 224 225 #define EXC_VIRT_BEGIN(name, start, size) \ 226 FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size) 227 228 #define EXC_VIRT_END(name, start, size) \ 229 FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##name, start, size) 230 231 #define EXC_COMMON_BEGIN(name) \ 232 USE_TEXT_SECTION(); \ 233 .balign IFETCH_ALIGN_BYTES; \ 234 .global name; \ 235 _ASM_NOKPROBE_SYMBOL(name); \ 236 DEFINE_FIXED_SYMBOL(name); \ 237 name: 238 239 #define TRAMP_REAL_BEGIN(name) \ 240 FIXED_SECTION_ENTRY_BEGIN(real_trampolines, name) 241 242 #define TRAMP_VIRT_BEGIN(name) \ 243 FIXED_SECTION_ENTRY_BEGIN(virt_trampolines, name) 244 245 #ifdef CONFIG_KVM_BOOK3S_64_HANDLER 246 #define TRAMP_KVM_BEGIN(name) \ 247 TRAMP_VIRT_BEGIN(name) 248 #else 249 #define TRAMP_KVM_BEGIN(name) 250 #endif 251 252 #define EXC_REAL_NONE(start, size) \ 253 FIXED_SECTION_ENTRY_BEGIN_LOCATION(real_vectors, exc_real_##start##_##unused, start, size); \ 254 FIXED_SECTION_ENTRY_END_LOCATION(real_vectors, exc_real_##start##_##unused, start, size) 255 256 #define EXC_VIRT_NONE(start, size) \ 257 FIXED_SECTION_ENTRY_BEGIN_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); \ 258 FIXED_SECTION_ENTRY_END_LOCATION(virt_vectors, exc_virt_##start##_##unused, start, size); 259 260 261 #define EXC_REAL(name, start, size) \ 262 EXC_REAL_BEGIN(name, start, size); \ 263 STD_EXCEPTION_PSERIES(start, name##_common); \ 264 EXC_REAL_END(name, start, size); 265 266 #define EXC_VIRT(name, start, size, realvec) \ 267 EXC_VIRT_BEGIN(name, start, size); \ 268 STD_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \ 269 EXC_VIRT_END(name, start, size); 270 271 #define EXC_REAL_MASKABLE(name, start, size) \ 272 EXC_REAL_BEGIN(name, start, size); \ 273 MASKABLE_EXCEPTION_PSERIES(start, start, name##_common); \ 274 EXC_REAL_END(name, start, size); 275 276 #define EXC_VIRT_MASKABLE(name, start, size, realvec) \ 277 EXC_VIRT_BEGIN(name, start, size); \ 278 MASKABLE_RELON_EXCEPTION_PSERIES(start, realvec, name##_common); \ 279 EXC_VIRT_END(name, start, size); 280 281 #define EXC_REAL_HV(name, start, size) \ 282 EXC_REAL_BEGIN(name, start, size); \ 283 STD_EXCEPTION_HV(start, start, name##_common); \ 284 EXC_REAL_END(name, start, size); 285 286 #define EXC_VIRT_HV(name, start, size, realvec) \ 287 EXC_VIRT_BEGIN(name, start, size); \ 288 STD_RELON_EXCEPTION_HV(start, realvec, name##_common); \ 289 EXC_VIRT_END(name, start, size); 290 291 #define __EXC_REAL_OOL(name, start, size) \ 292 EXC_REAL_BEGIN(name, start, size); \ 293 __OOL_EXCEPTION(start, label, tramp_real_##name); \ 294 EXC_REAL_END(name, start, size); 295 296 #define __TRAMP_REAL_OOL(name, vec) \ 297 TRAMP_REAL_BEGIN(tramp_real_##name); \ 298 STD_EXCEPTION_PSERIES_OOL(vec, name##_common); \ 299 300 #define EXC_REAL_OOL(name, start, size) \ 301 __EXC_REAL_OOL(name, start, size); \ 302 __TRAMP_REAL_OOL(name, start); 303 304 #define __EXC_REAL_OOL_MASKABLE(name, start, size) \ 305 __EXC_REAL_OOL(name, start, size); 306 307 #define __TRAMP_REAL_OOL_MASKABLE(name, vec) \ 308 TRAMP_REAL_BEGIN(tramp_real_##name); \ 309 MASKABLE_EXCEPTION_PSERIES_OOL(vec, name##_common); \ 310 311 #define EXC_REAL_OOL_MASKABLE(name, start, size) \ 312 __EXC_REAL_OOL_MASKABLE(name, start, size); \ 313 __TRAMP_REAL_OOL_MASKABLE(name, start); 314 315 #define __EXC_REAL_OOL_HV_DIRECT(name, start, size, handler) \ 316 EXC_REAL_BEGIN(name, start, size); \ 317 __OOL_EXCEPTION(start, label, handler); \ 318 EXC_REAL_END(name, start, size); 319 320 #define __EXC_REAL_OOL_HV(name, start, size) \ 321 __EXC_REAL_OOL(name, start, size); 322 323 #define __TRAMP_REAL_OOL_HV(name, vec) \ 324 TRAMP_REAL_BEGIN(tramp_real_##name); \ 325 STD_EXCEPTION_HV_OOL(vec, name##_common); \ 326 327 #define EXC_REAL_OOL_HV(name, start, size) \ 328 __EXC_REAL_OOL_HV(name, start, size); \ 329 __TRAMP_REAL_OOL_HV(name, start); 330 331 #define __EXC_REAL_OOL_MASKABLE_HV(name, start, size) \ 332 __EXC_REAL_OOL(name, start, size); 333 334 #define __TRAMP_REAL_OOL_MASKABLE_HV(name, vec) \ 335 TRAMP_REAL_BEGIN(tramp_real_##name); \ 336 MASKABLE_EXCEPTION_HV_OOL(vec, name##_common); \ 337 338 #define EXC_REAL_OOL_MASKABLE_HV(name, start, size) \ 339 __EXC_REAL_OOL_MASKABLE_HV(name, start, size); \ 340 __TRAMP_REAL_OOL_MASKABLE_HV(name, start); 341 342 #define __EXC_VIRT_OOL(name, start, size) \ 343 EXC_VIRT_BEGIN(name, start, size); \ 344 __OOL_EXCEPTION(start, label, tramp_virt_##name); \ 345 EXC_VIRT_END(name, start, size); 346 347 #define __TRAMP_VIRT_OOL(name, realvec) \ 348 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 349 STD_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \ 350 351 #define EXC_VIRT_OOL(name, start, size, realvec) \ 352 __EXC_VIRT_OOL(name, start, size); \ 353 __TRAMP_VIRT_OOL(name, realvec); 354 355 #define __EXC_VIRT_OOL_MASKABLE(name, start, size) \ 356 __EXC_VIRT_OOL(name, start, size); 357 358 #define __TRAMP_VIRT_OOL_MASKABLE(name, realvec) \ 359 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 360 MASKABLE_RELON_EXCEPTION_PSERIES_OOL(realvec, name##_common); \ 361 362 #define EXC_VIRT_OOL_MASKABLE(name, start, size, realvec) \ 363 __EXC_VIRT_OOL_MASKABLE(name, start, size); \ 364 __TRAMP_VIRT_OOL_MASKABLE(name, realvec); 365 366 #define __EXC_VIRT_OOL_HV(name, start, size) \ 367 __EXC_VIRT_OOL(name, start, size); 368 369 #define __TRAMP_VIRT_OOL_HV(name, realvec) \ 370 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 371 STD_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \ 372 373 #define EXC_VIRT_OOL_HV(name, start, size, realvec) \ 374 __EXC_VIRT_OOL_HV(name, start, size); \ 375 __TRAMP_VIRT_OOL_HV(name, realvec); 376 377 #define __EXC_VIRT_OOL_MASKABLE_HV(name, start, size) \ 378 __EXC_VIRT_OOL(name, start, size); 379 380 #define __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec) \ 381 TRAMP_VIRT_BEGIN(tramp_virt_##name); \ 382 MASKABLE_RELON_EXCEPTION_HV_OOL(realvec, name##_common); \ 383 384 #define EXC_VIRT_OOL_MASKABLE_HV(name, start, size, realvec) \ 385 __EXC_VIRT_OOL_MASKABLE_HV(name, start, size); \ 386 __TRAMP_VIRT_OOL_MASKABLE_HV(name, realvec); 387 388 #define TRAMP_KVM(area, n) \ 389 TRAMP_KVM_BEGIN(do_kvm_##n); \ 390 KVM_HANDLER(area, EXC_STD, n); \ 391 392 #define TRAMP_KVM_SKIP(area, n) \ 393 TRAMP_KVM_BEGIN(do_kvm_##n); \ 394 KVM_HANDLER_SKIP(area, EXC_STD, n); \ 395 396 /* 397 * HV variant exceptions get the 0x2 bit added to their trap number. 398 */ 399 #define TRAMP_KVM_HV(area, n) \ 400 TRAMP_KVM_BEGIN(do_kvm_H##n); \ 401 KVM_HANDLER(area, EXC_HV, n + 0x2); \ 402 403 #define TRAMP_KVM_HV_SKIP(area, n) \ 404 TRAMP_KVM_BEGIN(do_kvm_H##n); \ 405 KVM_HANDLER_SKIP(area, EXC_HV, n + 0x2); \ 406 407 #define EXC_COMMON(name, realvec, hdlr) \ 408 EXC_COMMON_BEGIN(name); \ 409 STD_EXCEPTION_COMMON(realvec, name, hdlr); \ 410 411 #define EXC_COMMON_ASYNC(name, realvec, hdlr) \ 412 EXC_COMMON_BEGIN(name); \ 413 STD_EXCEPTION_COMMON_ASYNC(realvec, name, hdlr); \ 414 415 #define EXC_COMMON_HV(name, realvec, hdlr) \ 416 EXC_COMMON_BEGIN(name); \ 417 STD_EXCEPTION_COMMON(realvec + 0x2, name, hdlr); \ 418 419 #endif /* __ASSEMBLY__ */ 420 421 #endif /* _ASM_POWERPC_HEAD_64_H */ 422