arch/powerpc/include/asm/head-64.h

   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 */