arch/s390/purgatory/head.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * Purgatory setup code
   4  *
   5  * Copyright IBM Corp. 2018
   6  *
   7  * Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com>
   8  */
   9
  10 #include <linux/linkage.h>
  11 #include <asm/asm-offsets.h>
  12 #include <asm/page.h>
  13 #include <asm/sigp.h>
  14 #include <asm/ptrace.h>
  15
  16 /* The purgatory is the code running between two kernels. It's main purpose
  17  * is to verify that the next kernel was not corrupted after load and to
  18  * start it.
  19  *
  20  * If the next kernel is a crash kernel there are some peculiarities to
  21  * consider:
  22  *
  23  * First the purgatory is called twice. Once only to verify the
  24  * sha digest. So if the crash kernel got corrupted the old kernel can try
  25  * to trigger a stand-alone dumper. And once to actually load the crash kernel.
  26  *
  27  * Second the purgatory also has to swap the crash memory region with its
  28  * destination at address 0. As the purgatory is part of crash memory this
  29  * requires some finesse. The tactic here is that the purgatory first copies
  30  * itself to the end of the destination and then swaps the rest of the
  31  * memory running from there.
  32  */
  33
  34 #define bufsz purgatory_end-stack
  35
  36 .macro MEMCPY dst,src,len
  37         lgr     %r0,\dst
  38         lgr     %r1,\len
  39         lgr     %r2,\src
  40         lgr     %r3,\len
  41
  42 20:     mvcle   %r0,%r2,0
  43         jo      20b
  44 .endm
  45
  46 .macro MEMSWAP dst,src,buf,len
  47 10:     larl    %r0,purgatory_end
  48         larl    %r1,stack
  49         slgr    %r0,%r1
  50         cgr     \len,%r0
  51         jh      11f
  52         lgr     %r4,\len
  53         j       12f
  54 11:     lgr     %r4,%r0
  55
  56 12:     MEMCPY  \buf,\dst,%r4
  57         MEMCPY  \dst,\src,%r4
  58         MEMCPY  \src,\buf,%r4
  59
  60         agr     \dst,%r4
  61         agr     \src,%r4
  62         sgr     \len,%r4
  63
  64         cghi    \len,0
  65         jh      10b
  66 .endm
  67
  68 .macro START_NEXT_KERNEL base subcode
  69         lg      %r4,kernel_entry-\base(%r13)
  70         lg      %r5,load_psw_mask-\base(%r13)
  71         ogr     %r4,%r5
  72         stg     %r4,0(%r0)
  73
  74         xgr     %r0,%r0
  75         lghi    %r1,\subcode
  76         diag    %r0,%r1,0x308
  77 .endm
  78
  79         .text
  80         .balign PAGE_SIZE
  81 SYM_CODE_START(purgatory_start)
  82         /* The purgatory might be called after a diag308 so better set
  83          * architecture and addressing mode.
  84          */
  85         lhi     %r1,1
  86         sigp    %r1,%r0,SIGP_SET_ARCHITECTURE
  87         sam64
  88
  89         larl    %r5,gprregs
  90         stmg    %r6,%r15,0(%r5)
  91
  92         basr    %r13,0
  93 .base_crash:
  94
  95         /* Setup stack */
  96         larl    %r15,purgatory_end-STACK_FRAME_OVERHEAD
  97
  98         /* If the next kernel is KEXEC_TYPE_CRASH the purgatory is called
  99          * directly with a flag passed in %r2 whether the purgatory shall do
 100          * checksum verification only (%r2 = 0 -> verification only).
 101          *
 102          * Check now and preserve over C function call by storing in
 103          * %r10 with
 104          *      1 -> checksum verification only
 105          *      0 -> load new kernel
 106          */
 107         lghi    %r10,0
 108         lg      %r11,kernel_type-.base_crash(%r13)
 109         cghi    %r11,1          /* KEXEC_TYPE_CRASH */
 110         jne     .do_checksum_verification
 111         cghi    %r2,0           /* checksum verification only */
 112         jne     .do_checksum_verification
 113         lghi    %r10,1
 114
 115 .do_checksum_verification:
 116         brasl   %r14,verify_sha256_digest
 117
 118         cghi    %r10,1          /* checksum verification only */
 119         je      .return_old_kernel
 120         cghi    %r2,0           /* checksum match */
 121         jne     .disabled_wait
 122
 123         /* If the next kernel is a crash kernel the purgatory has to swap
 124          * the mem regions first.
 125          */
 126         cghi    %r11,1 /* KEXEC_TYPE_CRASH */
 127         je      .start_crash_kernel
 128
 129         /* start normal kernel */
 130         START_NEXT_KERNEL .base_crash 0
 131
 132 .return_old_kernel:
 133         lmg     %r6,%r15,gprregs-.base_crash(%r13)
 134         br      %r14
 135
 136 .disabled_wait:
 137         lpswe   disabled_wait_psw-.base_crash(%r13)
 138
 139 .start_crash_kernel:
 140         /* Location of purgatory_start in crash memory */
 141         larl    %r0,.base_crash
 142         larl    %r1,purgatory_start
 143         slgr    %r0,%r1
 144         lgr     %r8,%r13
 145         sgr     %r8,%r0
 146
 147         /* Destination for this code i.e. end of memory to be swapped. */
 148         larl    %r0,purgatory_end
 149         larl    %r1,purgatory_start
 150         slgr    %r0,%r1
 151         lg      %r9,crash_size-.base_crash(%r13)
 152         sgr     %r9,%r0
 153
 154         /* Destination in crash memory, i.e. same as r9 but in crash memory. */
 155         lg      %r10,crash_start-.base_crash(%r13)
 156         agr     %r10,%r9
 157
 158         /* Buffer location (in crash memory) and size. As the purgatory is
 159          * behind the point of no return it can re-use the stack as buffer.
 160          */
 161         larl    %r11,purgatory_end
 162         larl    %r12,stack
 163         slgr    %r11,%r12
 164
 165         MEMCPY  %r12,%r9,%r11   /* dst  -> (crash) buf */
 166         MEMCPY  %r9,%r8,%r11    /* self -> dst */
 167
 168         /* Jump to new location. */
 169         lgr     %r7,%r9
 170         larl    %r0,.jump_to_dst
 171         larl    %r1,purgatory_start
 172         slgr    %r0,%r1
 173         agr     %r7,%r0
 174         br      %r7
 175
 176 .jump_to_dst:
 177         basr    %r13,0
 178 .base_dst:
 179
 180         /* clear buffer */
 181         MEMCPY  %r12,%r10,%r11  /* (crash) buf -> (crash) dst */
 182
 183         /* Load new buffer location after jump */
 184         larl    %r7,stack
 185         lgr     %r0,%r7
 186         larl    %r1,purgatory_start
 187         slgr    %r0,%r1
 188         agr     %r10,%r0
 189         MEMCPY  %r10,%r7,%r11   /* (new) buf -> (crash) buf */
 190
 191         /* Now the code is set up to run from its designated location. Start
 192          * swapping the rest of crash memory now.
 193          *
 194          * The registers will be used as follow:
 195          *
 196          *      %r0-%r4 reserved for macros defined above
 197          *      %r5-%r6 tmp registers
 198          *      %r7     pointer to current struct sha region
 199          *      %r8     index to iterate over all sha regions
 200          *      %r9     pointer in crash memory
 201          *      %r10    pointer in old kernel
 202          *      %r11    total size (still) to be moved
 203          *      %r12    pointer to buffer
 204          */
 205         lgr     %r12,%r7
 206         lgr     %r11,%r9
 207         lghi    %r10,0
 208         lg      %r9,crash_start-.base_dst(%r13)
 209         lghi    %r8,16  /* KEXEC_SEGMENTS_MAX */
 210         larl    %r7,purgatory_sha_regions
 211
 212         j .loop_first
 213
 214         /* Loop over all purgatory_sha_regions. */
 215 .loop_next:
 216         aghi    %r8,-1
 217         cghi    %r8,0
 218         je      .loop_out
 219
 220         aghi    %r7,__KEXEC_SHA_REGION_SIZE
 221
 222 .loop_first:
 223         lg      %r5,__KEXEC_SHA_REGION_START(%r7)
 224         cghi    %r5,0
 225         je      .loop_next
 226
 227         /* Copy [end last sha region, start current sha region) */
 228         /* Note: kexec_sha_region->start points in crash memory */
 229         sgr     %r5,%r9
 230         MEMCPY  %r9,%r10,%r5
 231
 232         agr     %r9,%r5
 233         agr     %r10,%r5
 234         sgr     %r11,%r5
 235
 236         /* Swap sha region */
 237         lg      %r6,__KEXEC_SHA_REGION_LEN(%r7)
 238         MEMSWAP %r9,%r10,%r12,%r6
 239         sg      %r11,__KEXEC_SHA_REGION_LEN(%r7)
 240         j       .loop_next
 241
 242 .loop_out:
 243         /* Copy rest of crash memory */
 244         MEMCPY  %r9,%r10,%r11
 245
 246         /* start crash kernel */
 247         START_NEXT_KERNEL .base_dst 1
 248 SYM_CODE_END(purgatory_start)
 249
 250 SYM_DATA_LOCAL(load_psw_mask,           .long 0x00080000,0x80000000)
 251         .balign 8
 252 SYM_DATA_LOCAL(disabled_wait_psw,       .quad 0x0002000180000000,.do_checksum_verification)
 253 SYM_DATA_LOCAL(gprregs,                 .fill 10,8,0)
 254 SYM_DATA(purgatory_sha256_digest,       .skip 32)
 255 SYM_DATA(purgatory_sha_regions,         .skip 16*__KEXEC_SHA_REGION_SIZE)
 256 SYM_DATA(kernel_entry,                  .skip 8)
 257 SYM_DATA(kernel_type,                   .skip 8)
 258 SYM_DATA(crash_start,                   .skip 8)
 259 SYM_DATA(crash_size,                    .skip 8)
 260         .balign PAGE_SIZE
 261 SYM_DATA_START_LOCAL(stack)
 262         /* The buffer to move this code must be as big as the code. */
 263         .skip   stack-purgatory_start
 264         .balign PAGE_SIZE
 265 SYM_DATA_END_LABEL(stack, SYM_L_LOCAL, purgatory_end)