arch/arm64/kernel/vmlinux.lds.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * ld script to make ARM Linux kernel
   4  * taken from the i386 version by Russell King
   5  * Written by Martin Mares <mj@atrey.karlin.mff.cuni.cz>
   6  */
   7
   8 #include <asm-generic/vmlinux.lds.h>
   9 #include <asm/cache.h>
  10 #include <asm/kernel-pgtable.h>
  11 #include <asm/thread_info.h>
  12 #include <asm/memory.h>
  13 #include <asm/page.h>
  14 #include <asm/pgtable.h>
  15
  16 #include "image.h"
  17
  18 /* .exit.text needed in case of alternative patching */
  19 #define ARM_EXIT_KEEP(x)        x
  20 #define ARM_EXIT_DISCARD(x)
  21
  22 OUTPUT_ARCH(aarch64)
  23 ENTRY(_text)
  24
  25 jiffies = jiffies_64;
  26
  27
  28 #define HYPERVISOR_EXTABLE                                      \
  29         . = ALIGN(SZ_8);                                        \
  30         VMLINUX_SYMBOL(__start___kvm_ex_table) = .;             \
  31         *(__kvm_ex_table)                                       \
  32         VMLINUX_SYMBOL(__stop___kvm_ex_table) = .;
  33
  34 #define HYPERVISOR_TEXT                                 \
  35         /*                                              \
  36          * Align to 4 KB so that                        \
  37          * a) the HYP vector table is at its minimum    \
  38          *    alignment of 2048 bytes                   \
  39          * b) the HYP init code will not cross a page   \
  40          *    boundary if its size does not exceed      \
  41          *    4 KB (see related ASSERT() below)         \
  42          */                                             \
  43         . = ALIGN(SZ_4K);                               \
  44         VMLINUX_SYMBOL(__hyp_idmap_text_start) = .;     \
  45         *(.hyp.idmap.text)                              \
  46         VMLINUX_SYMBOL(__hyp_idmap_text_end) = .;       \
  47         VMLINUX_SYMBOL(__hyp_text_start) = .;           \
  48         *(.hyp.text)                                    \
  49         HYPERVISOR_EXTABLE                              \
  50         VMLINUX_SYMBOL(__hyp_text_end) = .;
  51
  52 #define IDMAP_TEXT                                      \
  53         . = ALIGN(SZ_4K);                               \
  54         VMLINUX_SYMBOL(__idmap_text_start) = .;         \
  55         *(.idmap.text)                                  \
  56         VMLINUX_SYMBOL(__idmap_text_end) = .;
  57
  58 #ifdef CONFIG_HIBERNATION
  59 #define HIBERNATE_TEXT                                  \
  60         . = ALIGN(SZ_4K);                               \
  61         VMLINUX_SYMBOL(__hibernate_exit_text_start) = .;\
  62         *(.hibernate_exit.text)                         \
  63         VMLINUX_SYMBOL(__hibernate_exit_text_end) = .;
  64 #else
  65 #define HIBERNATE_TEXT
  66 #endif
  67
  68 #ifdef CONFIG_UNMAP_KERNEL_AT_EL0
  69 #define TRAMP_TEXT                                      \
  70         . = ALIGN(PAGE_SIZE);                           \
  71         VMLINUX_SYMBOL(__entry_tramp_text_start) = .;   \
  72         *(.entry.tramp.text)                            \
  73         . = ALIGN(PAGE_SIZE);                           \
  74         VMLINUX_SYMBOL(__entry_tramp_text_end) = .;
  75 #else
  76 #define TRAMP_TEXT
  77 #endif
  78
  79 /*
  80  * The size of the PE/COFF section that covers the kernel image, which
  81  * runs from stext to _edata, must be a round multiple of the PE/COFF
  82  * FileAlignment, which we set to its minimum value of 0x200. 'stext'
  83  * itself is 4 KB aligned, so padding out _edata to a 0x200 aligned
  84  * boundary should be sufficient.
  85  */
  86 PECOFF_FILE_ALIGNMENT = 0x200;
  87
  88 #ifdef CONFIG_EFI
  89 #define PECOFF_EDATA_PADDING    \
  90         .pecoff_edata_padding : { BYTE(0); . = ALIGN(PECOFF_FILE_ALIGNMENT); }
  91 #else
  92 #define PECOFF_EDATA_PADDING
  93 #endif
  94
  95 SECTIONS
  96 {
  97         /*
  98          * XXX: The linker does not define how output sections are
  99          * assigned to input sections when there are multiple statements
 100          * matching the same input section name.  There is no documented
 101          * order of matching.
 102          */
 103         /DISCARD/ : {
 104                 ARM_EXIT_DISCARD(EXIT_TEXT)
 105                 ARM_EXIT_DISCARD(EXIT_DATA)
 106                 EXIT_CALL
 107                 *(.discard)
 108                 *(.discard.*)
 109                 *(.interp .dynamic)
 110                 *(.dynsym .dynstr .hash .gnu.hash)
 111                 *(.eh_frame)
 112         }
 113
 114         . = KIMAGE_VADDR + TEXT_OFFSET;
 115
 116         .head.text : {
 117                 _text = .;
 118                 HEAD_TEXT
 119         }
 120         .text : {                       /* Real text segment            */
 121                 _stext = .;             /* Text and read-only data      */
 122                         __exception_text_start = .;
 123                         *(.exception.text)
 124                         __exception_text_end = .;
 125                         IRQENTRY_TEXT
 126                         SOFTIRQENTRY_TEXT
 127                         ENTRY_TEXT
 128                         TEXT_TEXT
 129                         SCHED_TEXT
 130                         CPUIDLE_TEXT
 131                         LOCK_TEXT
 132                         KPROBES_TEXT
 133                         HYPERVISOR_TEXT
 134                         IDMAP_TEXT
 135                         HIBERNATE_TEXT
 136                         TRAMP_TEXT
 137                         *(.fixup)
 138                         *(.gnu.warning)
 139                 . = ALIGN(16);
 140                 *(.got)                 /* Global offset table          */
 141         }
 142
 143         . = ALIGN(SEGMENT_ALIGN);
 144         _etext = .;                     /* End of text section */
 145
 146         RO_DATA(PAGE_SIZE)              /* everything from this point to     */
 147         EXCEPTION_TABLE(8)              /* __init_begin will be marked RO NX */
 148         NOTES
 149
 150         . = ALIGN(SEGMENT_ALIGN);
 151         __init_begin = .;
 152         __inittext_begin = .;
 153
 154         INIT_TEXT_SECTION(8)
 155         .exit.text : {
 156                 ARM_EXIT_KEEP(EXIT_TEXT)
 157         }
 158
 159         . = ALIGN(4);
 160         .altinstructions : {
 161                 __alt_instructions = .;
 162                 *(.altinstructions)
 163                 __alt_instructions_end = .;
 164         }
 165
 166         . = ALIGN(PAGE_SIZE);
 167         __inittext_end = .;
 168         __initdata_begin = .;
 169
 170         .init.data : {
 171                 INIT_DATA
 172                 INIT_SETUP(16)
 173                 INIT_CALLS
 174                 CON_INITCALL
 175                 SECURITY_INITCALL
 176                 INIT_RAM_FS
 177                 *(.init.rodata.* .init.bss)     /* from the EFI stub */
 178         }
 179         .exit.data : {
 180                 ARM_EXIT_KEEP(EXIT_DATA)
 181         }
 182
 183         PERCPU_SECTION(L1_CACHE_BYTES)
 184
 185         .rela.dyn : ALIGN(8) {
 186                 *(.rela .rela*)
 187         }
 188
 189         __rela_offset   = ABSOLUTE(ADDR(.rela.dyn) - KIMAGE_VADDR);
 190         __rela_size     = SIZEOF(.rela.dyn);
 191
 192         . = ALIGN(SEGMENT_ALIGN);
 193         __initdata_end = .;
 194         __init_end = .;
 195
 196         _data = .;
 197         _sdata = .;
 198         RW_DATA_SECTION(L1_CACHE_BYTES, PAGE_SIZE, THREAD_ALIGN)
 199
 200         /*
 201          * Data written with the MMU off but read with the MMU on requires
 202          * cache lines to be invalidated, discarding up to a Cache Writeback
 203          * Granule (CWG) of data from the cache. Keep the section that
 204          * requires this type of maintenance to be in its own Cache Writeback
 205          * Granule (CWG) area so the cache maintenance operations don't
 206          * interfere with adjacent data.
 207          */
 208         .mmuoff.data.write : ALIGN(SZ_2K) {
 209                 __mmuoff_data_start = .;
 210                 *(.mmuoff.data.write)
 211         }
 212         . = ALIGN(SZ_2K);
 213         .mmuoff.data.read : {
 214                 *(.mmuoff.data.read)
 215                 __mmuoff_data_end = .;
 216         }
 217
 218         PECOFF_EDATA_PADDING
 219         __pecoff_data_rawsize = ABSOLUTE(. - __initdata_begin);
 220         _edata = .;
 221
 222         BSS_SECTION(0, 0, 0)
 223
 224         . = ALIGN(PAGE_SIZE);
 225         idmap_pg_dir = .;
 226         . += IDMAP_DIR_SIZE;
 227         swapper_pg_dir = .;
 228         . += SWAPPER_DIR_SIZE;
 229
 230 #ifdef CONFIG_ARM64_SW_TTBR0_PAN
 231         reserved_ttbr0 = .;
 232         . += RESERVED_TTBR0_SIZE;
 233 #endif
 234
 235 #ifdef CONFIG_UNMAP_KERNEL_AT_EL0
 236         tramp_pg_dir = .;
 237         . += PAGE_SIZE;
 238 #endif
 239
 240         __pecoff_data_size = ABSOLUTE(. - __initdata_begin);
 241         _end = .;
 242
 243         STABS_DEBUG
 244
 245         HEAD_SYMBOLS
 246 }
 247
 248 /*
 249  * The HYP init code and ID map text can't be longer than a page each,
 250  * and should not cross a page boundary.
 251  */
 252 ASSERT(__hyp_idmap_text_end - (__hyp_idmap_text_start & ~(SZ_4K - 1)) <= SZ_4K,
 253         "HYP init code too big or misaligned")
 254 ASSERT(__idmap_text_end - (__idmap_text_start & ~(SZ_4K - 1)) <= SZ_4K,
 255         "ID map text too big or misaligned")
 256 #ifdef CONFIG_HIBERNATION
 257 ASSERT(__hibernate_exit_text_end - (__hibernate_exit_text_start & ~(SZ_4K - 1))
 258         <= SZ_4K, "Hibernate exit text too big or misaligned")
 259 #endif
 260 #ifdef CONFIG_UNMAP_KERNEL_AT_EL0
 261 ASSERT((__entry_tramp_text_end - __entry_tramp_text_start) <= 3*PAGE_SIZE,
 262         "Entry trampoline text too big")
 263 #endif
 264 /*
 265  * If padding is applied before .head.text, virt<->phys conversions will fail.
 266  */
 267 ASSERT(_text == (KIMAGE_VADDR + TEXT_OFFSET), "HEAD is misaligned")