| /* SPDX-License-Identifier: GPL-2.0 */ |
| /* |
| * Purgatory setup code |
| * |
| * Copyright IBM Corp. 2018 |
| * |
| * Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com> |
| */ |
| |
| #include <linux/linkage.h> |
| #include <asm/asm-offsets.h> |
| #include <asm/page.h> |
| #include <asm/sigp.h> |
| #include <asm/ptrace.h> |
| |
| /* The purgatory is the code running between two kernels. It's main purpose |
| * is to verify that the next kernel was not corrupted after load and to |
| * start it. |
| * |
| * If the next kernel is a crash kernel there are some peculiarities to |
| * consider: |
| * |
| * First the purgatory is called twice. Once only to verify the |
| * sha digest. So if the crash kernel got corrupted the old kernel can try |
| * to trigger a stand-alone dumper. And once to actually load the crash kernel. |
| * |
| * Second the purgatory also has to swap the crash memory region with its |
| * destination at address 0. As the purgatory is part of crash memory this |
| * requires some finesse. The tactic here is that the purgatory first copies |
| * itself to the end of the destination and then swaps the rest of the |
| * memory running from there. |
| */ |
| |
| #define bufsz purgatory_end-stack |
| |
| .macro MEMCPY dst,src,len |
| lgr %r0,\dst |
| lgr %r1,\len |
| lgr %r2,\src |
| lgr %r3,\len |
| |
| 20: mvcle %r0,%r2,0 |
| jo 20b |
| .endm |
| |
| .macro MEMSWAP dst,src,buf,len |
| 10: larl %r0,purgatory_end |
| larl %r1,stack |
| slgr %r0,%r1 |
| cgr \len,%r0 |
| jh 11f |
| lgr %r4,\len |
| j 12f |
| 11: lgr %r4,%r0 |
| |
| 12: MEMCPY \buf,\dst,%r4 |
| MEMCPY \dst,\src,%r4 |
| MEMCPY \src,\buf,%r4 |
| |
| agr \dst,%r4 |
| agr \src,%r4 |
| sgr \len,%r4 |
| |
| cghi \len,0 |
| jh 10b |
| .endm |
| |
| .macro START_NEXT_KERNEL base subcode |
| lg %r4,kernel_entry-\base(%r13) |
| lg %r5,load_psw_mask-\base(%r13) |
| ogr %r4,%r5 |
| stg %r4,0(%r0) |
| |
| xgr %r0,%r0 |
| lghi %r1,\subcode |
| diag %r0,%r1,0x308 |
| .endm |
| |
| .text |
| .balign PAGE_SIZE |
| SYM_CODE_START(purgatory_start) |
| /* The purgatory might be called after a diag308 so better set |
| * architecture and addressing mode. |
| */ |
| lhi %r1,1 |
| sigp %r1,%r0,SIGP_SET_ARCHITECTURE |
| sam64 |
| |
| larl %r5,gprregs |
| stmg %r6,%r15,0(%r5) |
| |
| basr %r13,0 |
| .base_crash: |
| |
| /* Setup stack */ |
| larl %r15,purgatory_end-STACK_FRAME_OVERHEAD |
| |
| /* If the next kernel is KEXEC_TYPE_CRASH the purgatory is called |
| * directly with a flag passed in %r2 whether the purgatory shall do |
| * checksum verification only (%r2 = 0 -> verification only). |
| * |
| * Check now and preserve over C function call by storing in |
| * %r10 with |
| * 1 -> checksum verification only |
| * 0 -> load new kernel |
| */ |
| lghi %r10,0 |
| lg %r11,kernel_type-.base_crash(%r13) |
| cghi %r11,1 /* KEXEC_TYPE_CRASH */ |
| jne .do_checksum_verification |
| cghi %r2,0 /* checksum verification only */ |
| jne .do_checksum_verification |
| lghi %r10,1 |
| |
| .do_checksum_verification: |
| brasl %r14,verify_sha256_digest |
| |
| cghi %r10,1 /* checksum verification only */ |
| je .return_old_kernel |
| cghi %r2,0 /* checksum match */ |
| jne .disabled_wait |
| |
| /* If the next kernel is a crash kernel the purgatory has to swap |
| * the mem regions first. |
| */ |
| cghi %r11,1 /* KEXEC_TYPE_CRASH */ |
| je .start_crash_kernel |
| |
| /* start normal kernel */ |
| START_NEXT_KERNEL .base_crash 0 |
| |
| .return_old_kernel: |
| lmg %r6,%r15,gprregs-.base_crash(%r13) |
| br %r14 |
| |
| .disabled_wait: |
| lpswe disabled_wait_psw-.base_crash(%r13) |
| |
| .start_crash_kernel: |
| /* Location of purgatory_start in crash memory */ |
| larl %r0,.base_crash |
| larl %r1,purgatory_start |
| slgr %r0,%r1 |
| lgr %r8,%r13 |
| sgr %r8,%r0 |
| |
| /* Destination for this code i.e. end of memory to be swapped. */ |
| larl %r0,purgatory_end |
| larl %r1,purgatory_start |
| slgr %r0,%r1 |
| lg %r9,crash_size-.base_crash(%r13) |
| sgr %r9,%r0 |
| |
| /* Destination in crash memory, i.e. same as r9 but in crash memory. */ |
| lg %r10,crash_start-.base_crash(%r13) |
| agr %r10,%r9 |
| |
| /* Buffer location (in crash memory) and size. As the purgatory is |
| * behind the point of no return it can re-use the stack as buffer. |
| */ |
| larl %r11,purgatory_end |
| larl %r12,stack |
| slgr %r11,%r12 |
| |
| MEMCPY %r12,%r9,%r11 /* dst -> (crash) buf */ |
| MEMCPY %r9,%r8,%r11 /* self -> dst */ |
| |
| /* Jump to new location. */ |
| lgr %r7,%r9 |
| larl %r0,.jump_to_dst |
| larl %r1,purgatory_start |
| slgr %r0,%r1 |
| agr %r7,%r0 |
| br %r7 |
| |
| .jump_to_dst: |
| basr %r13,0 |
| .base_dst: |
| |
| /* clear buffer */ |
| MEMCPY %r12,%r10,%r11 /* (crash) buf -> (crash) dst */ |
| |
| /* Load new buffer location after jump */ |
| larl %r7,stack |
| lgr %r0,%r7 |
| larl %r1,purgatory_start |
| slgr %r0,%r1 |
| agr %r10,%r0 |
| MEMCPY %r10,%r7,%r11 /* (new) buf -> (crash) buf */ |
| |
| /* Now the code is set up to run from its designated location. Start |
| * swapping the rest of crash memory now. |
| * |
| * The registers will be used as follow: |
| * |
| * %r0-%r4 reserved for macros defined above |
| * %r5-%r6 tmp registers |
| * %r7 pointer to current struct sha region |
| * %r8 index to iterate over all sha regions |
| * %r9 pointer in crash memory |
| * %r10 pointer in old kernel |
| * %r11 total size (still) to be moved |
| * %r12 pointer to buffer |
| */ |
| lgr %r12,%r7 |
| lgr %r11,%r9 |
| lghi %r10,0 |
| lg %r9,crash_start-.base_dst(%r13) |
| lghi %r8,16 /* KEXEC_SEGMENTS_MAX */ |
| larl %r7,purgatory_sha_regions |
| |
| j .loop_first |
| |
| /* Loop over all purgatory_sha_regions. */ |
| .loop_next: |
| aghi %r8,-1 |
| cghi %r8,0 |
| je .loop_out |
| |
| aghi %r7,__KEXEC_SHA_REGION_SIZE |
| |
| .loop_first: |
| lg %r5,__KEXEC_SHA_REGION_START(%r7) |
| cghi %r5,0 |
| je .loop_next |
| |
| /* Copy [end last sha region, start current sha region) */ |
| /* Note: kexec_sha_region->start points in crash memory */ |
| sgr %r5,%r9 |
| MEMCPY %r9,%r10,%r5 |
| |
| agr %r9,%r5 |
| agr %r10,%r5 |
| sgr %r11,%r5 |
| |
| /* Swap sha region */ |
| lg %r6,__KEXEC_SHA_REGION_LEN(%r7) |
| MEMSWAP %r9,%r10,%r12,%r6 |
| sg %r11,__KEXEC_SHA_REGION_LEN(%r7) |
| j .loop_next |
| |
| .loop_out: |
| /* Copy rest of crash memory */ |
| MEMCPY %r9,%r10,%r11 |
| |
| /* start crash kernel */ |
| START_NEXT_KERNEL .base_dst 1 |
| SYM_CODE_END(purgatory_start) |
| |
| SYM_DATA_LOCAL(load_psw_mask, .long 0x00080000,0x80000000) |
| .balign 8 |
| SYM_DATA_LOCAL(disabled_wait_psw, .quad 0x0002000180000000,.do_checksum_verification) |
| SYM_DATA_LOCAL(gprregs, .fill 10,8,0) |
| SYM_DATA(purgatory_sha256_digest, .skip 32) |
| SYM_DATA(purgatory_sha_regions, .skip 16*__KEXEC_SHA_REGION_SIZE) |
| SYM_DATA(kernel_entry, .skip 8) |
| SYM_DATA(kernel_type, .skip 8) |
| SYM_DATA(crash_start, .skip 8) |
| SYM_DATA(crash_size, .skip 8) |
| .balign PAGE_SIZE |
| SYM_DATA_START_LOCAL(stack) |
| /* The buffer to move this code must be as big as the code. */ |
| .skip stack-purgatory_start |
| .balign PAGE_SIZE |
| SYM_DATA_END_LABEL(stack, SYM_L_LOCAL, purgatory_end) |
