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