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) |
266 | |