arch/arm64/kernel/vmlinux.lds.S

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