1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * s390 code for kexec_file_load system call
4 *
5 * Copyright IBM Corp. 2018
6 *
7 * Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com>
8 */
9
10 #include <linux/elf.h>
11 #include <linux/errno.h>
12 #include <linux/kexec.h>
13 #include <linux/module_signature.h>
14 #include <linux/verification.h>
15 #include <linux/vmalloc.h>
16 #include <asm/boot_data.h>
17 #include <asm/ipl.h>
18 #include <asm/setup.h>
19
20 const struct kexec_file_ops * const kexec_file_loaders[] = {
21 &s390_kexec_elf_ops,
22 &s390_kexec_image_ops,
23 NULL,
24 };
25
26 #ifdef CONFIG_KEXEC_SIG
s390_verify_sig(const char * kernel,unsigned long kernel_len)27 int s390_verify_sig(const char *kernel, unsigned long kernel_len)
28 {
29 const unsigned long marker_len = sizeof(MODULE_SIG_STRING) - 1;
30 struct module_signature *ms;
31 unsigned long sig_len;
32 int ret;
33
34 /* Skip signature verification when not secure IPLed. */
35 if (!ipl_secure_flag)
36 return 0;
37
38 if (marker_len > kernel_len)
39 return -EKEYREJECTED;
40
41 if (memcmp(kernel + kernel_len - marker_len, MODULE_SIG_STRING,
42 marker_len))
43 return -EKEYREJECTED;
44 kernel_len -= marker_len;
45
46 ms = (void *)kernel + kernel_len - sizeof(*ms);
47 kernel_len -= sizeof(*ms);
48
49 sig_len = be32_to_cpu(ms->sig_len);
50 if (sig_len >= kernel_len)
51 return -EKEYREJECTED;
52 kernel_len -= sig_len;
53
54 if (ms->id_type != PKEY_ID_PKCS7)
55 return -EKEYREJECTED;
56
57 if (ms->algo != 0 ||
58 ms->hash != 0 ||
59 ms->signer_len != 0 ||
60 ms->key_id_len != 0 ||
61 ms->__pad[0] != 0 ||
62 ms->__pad[1] != 0 ||
63 ms->__pad[2] != 0) {
64 return -EBADMSG;
65 }
66
67 ret = verify_pkcs7_signature(kernel, kernel_len,
68 kernel + kernel_len, sig_len,
69 VERIFY_USE_SECONDARY_KEYRING,
70 VERIFYING_MODULE_SIGNATURE,
71 NULL, NULL);
72 if (ret == -ENOKEY && IS_ENABLED(CONFIG_INTEGRITY_PLATFORM_KEYRING))
73 ret = verify_pkcs7_signature(kernel, kernel_len,
74 kernel + kernel_len, sig_len,
75 VERIFY_USE_PLATFORM_KEYRING,
76 VERIFYING_MODULE_SIGNATURE,
77 NULL, NULL);
78 return ret;
79 }
80 #endif /* CONFIG_KEXEC_SIG */
81
kexec_file_update_purgatory(struct kimage * image,struct s390_load_data * data)82 static int kexec_file_update_purgatory(struct kimage *image,
83 struct s390_load_data *data)
84 {
85 u64 entry, type;
86 int ret;
87
88 if (image->type == KEXEC_TYPE_CRASH) {
89 entry = STARTUP_KDUMP_OFFSET;
90 type = KEXEC_TYPE_CRASH;
91 } else {
92 entry = STARTUP_NORMAL_OFFSET;
93 type = KEXEC_TYPE_DEFAULT;
94 }
95
96 ret = kexec_purgatory_get_set_symbol(image, "kernel_entry", &entry,
97 sizeof(entry), false);
98 if (ret)
99 return ret;
100
101 ret = kexec_purgatory_get_set_symbol(image, "kernel_type", &type,
102 sizeof(type), false);
103 if (ret)
104 return ret;
105
106 if (image->type == KEXEC_TYPE_CRASH) {
107 u64 crash_size;
108
109 ret = kexec_purgatory_get_set_symbol(image, "crash_start",
110 &crashk_res.start,
111 sizeof(crashk_res.start),
112 false);
113 if (ret)
114 return ret;
115
116 crash_size = crashk_res.end - crashk_res.start + 1;
117 ret = kexec_purgatory_get_set_symbol(image, "crash_size",
118 &crash_size,
119 sizeof(crash_size),
120 false);
121 }
122 return ret;
123 }
124
kexec_file_add_purgatory(struct kimage * image,struct s390_load_data * data)125 static int kexec_file_add_purgatory(struct kimage *image,
126 struct s390_load_data *data)
127 {
128 struct kexec_buf buf;
129 int ret;
130
131 buf.image = image;
132
133 data->memsz = ALIGN(data->memsz, PAGE_SIZE);
134 buf.mem = data->memsz;
135 if (image->type == KEXEC_TYPE_CRASH)
136 buf.mem += crashk_res.start;
137
138 ret = kexec_load_purgatory(image, &buf);
139 if (ret)
140 return ret;
141 data->memsz += buf.memsz;
142
143 return kexec_file_update_purgatory(image, data);
144 }
145
kexec_file_add_initrd(struct kimage * image,struct s390_load_data * data)146 static int kexec_file_add_initrd(struct kimage *image,
147 struct s390_load_data *data)
148 {
149 struct kexec_buf buf;
150 int ret;
151
152 buf.image = image;
153
154 buf.buffer = image->initrd_buf;
155 buf.bufsz = image->initrd_buf_len;
156
157 data->memsz = ALIGN(data->memsz, PAGE_SIZE);
158 buf.mem = data->memsz;
159 if (image->type == KEXEC_TYPE_CRASH)
160 buf.mem += crashk_res.start;
161 buf.memsz = buf.bufsz;
162
163 data->parm->initrd_start = data->memsz;
164 data->parm->initrd_size = buf.memsz;
165 data->memsz += buf.memsz;
166
167 ret = kexec_add_buffer(&buf);
168 if (ret)
169 return ret;
170
171 return ipl_report_add_component(data->report, &buf, 0, 0);
172 }
173
kexec_file_add_ipl_report(struct kimage * image,struct s390_load_data * data)174 static int kexec_file_add_ipl_report(struct kimage *image,
175 struct s390_load_data *data)
176 {
177 __u32 *lc_ipl_parmblock_ptr;
178 unsigned int len, ncerts;
179 struct kexec_buf buf;
180 unsigned long addr;
181 void *ptr, *end;
182 int ret;
183
184 buf.image = image;
185
186 data->memsz = ALIGN(data->memsz, PAGE_SIZE);
187 buf.mem = data->memsz;
188 if (image->type == KEXEC_TYPE_CRASH)
189 buf.mem += crashk_res.start;
190
191 ptr = (void *)ipl_cert_list_addr;
192 end = ptr + ipl_cert_list_size;
193 ncerts = 0;
194 while (ptr < end) {
195 ncerts++;
196 len = *(unsigned int *)ptr;
197 ptr += sizeof(len);
198 ptr += len;
199 }
200
201 addr = data->memsz + data->report->size;
202 addr += ncerts * sizeof(struct ipl_rb_certificate_entry);
203 ptr = (void *)ipl_cert_list_addr;
204 while (ptr < end) {
205 len = *(unsigned int *)ptr;
206 ptr += sizeof(len);
207 ipl_report_add_certificate(data->report, ptr, addr, len);
208 addr += len;
209 ptr += len;
210 }
211
212 ret = -ENOMEM;
213 buf.buffer = ipl_report_finish(data->report);
214 if (!buf.buffer)
215 goto out;
216 buf.bufsz = data->report->size;
217 buf.memsz = buf.bufsz;
218 image->arch.ipl_buf = buf.buffer;
219
220 data->memsz += buf.memsz;
221
222 lc_ipl_parmblock_ptr =
223 data->kernel_buf + offsetof(struct lowcore, ipl_parmblock_ptr);
224 *lc_ipl_parmblock_ptr = (__u32)buf.mem;
225
226 ret = kexec_add_buffer(&buf);
227 out:
228 return ret;
229 }
230
kexec_file_add_components(struct kimage * image,int (* add_kernel)(struct kimage * image,struct s390_load_data * data))231 void *kexec_file_add_components(struct kimage *image,
232 int (*add_kernel)(struct kimage *image,
233 struct s390_load_data *data))
234 {
235 struct s390_load_data data = {0};
236 int ret;
237
238 data.report = ipl_report_init(&ipl_block);
239 if (IS_ERR(data.report))
240 return data.report;
241
242 ret = add_kernel(image, &data);
243 if (ret)
244 goto out;
245
246 if (image->cmdline_buf_len >= ARCH_COMMAND_LINE_SIZE) {
247 ret = -EINVAL;
248 goto out;
249 }
250 memcpy(data.parm->command_line, image->cmdline_buf,
251 image->cmdline_buf_len);
252
253 if (image->type == KEXEC_TYPE_CRASH) {
254 data.parm->oldmem_base = crashk_res.start;
255 data.parm->oldmem_size = crashk_res.end - crashk_res.start + 1;
256 }
257
258 if (image->initrd_buf) {
259 ret = kexec_file_add_initrd(image, &data);
260 if (ret)
261 goto out;
262 }
263
264 ret = kexec_file_add_purgatory(image, &data);
265 if (ret)
266 goto out;
267
268 if (data.kernel_mem == 0) {
269 unsigned long restart_psw = 0x0008000080000000UL;
270 restart_psw += image->start;
271 memcpy(data.kernel_buf, &restart_psw, sizeof(restart_psw));
272 image->start = 0;
273 }
274
275 ret = kexec_file_add_ipl_report(image, &data);
276 out:
277 ipl_report_free(data.report);
278 return ERR_PTR(ret);
279 }
280
arch_kexec_apply_relocations_add(struct purgatory_info * pi,Elf_Shdr * section,const Elf_Shdr * relsec,const Elf_Shdr * symtab)281 int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
282 Elf_Shdr *section,
283 const Elf_Shdr *relsec,
284 const Elf_Shdr *symtab)
285 {
286 Elf_Rela *relas;
287 int i, r_type;
288 int ret;
289
290 relas = (void *)pi->ehdr + relsec->sh_offset;
291
292 for (i = 0; i < relsec->sh_size / sizeof(*relas); i++) {
293 const Elf_Sym *sym; /* symbol to relocate */
294 unsigned long addr; /* final location after relocation */
295 unsigned long val; /* relocated symbol value */
296 void *loc; /* tmp location to modify */
297
298 sym = (void *)pi->ehdr + symtab->sh_offset;
299 sym += ELF64_R_SYM(relas[i].r_info);
300
301 if (sym->st_shndx == SHN_UNDEF)
302 return -ENOEXEC;
303
304 if (sym->st_shndx == SHN_COMMON)
305 return -ENOEXEC;
306
307 if (sym->st_shndx >= pi->ehdr->e_shnum &&
308 sym->st_shndx != SHN_ABS)
309 return -ENOEXEC;
310
311 loc = pi->purgatory_buf;
312 loc += section->sh_offset;
313 loc += relas[i].r_offset;
314
315 val = sym->st_value;
316 if (sym->st_shndx != SHN_ABS)
317 val += pi->sechdrs[sym->st_shndx].sh_addr;
318 val += relas[i].r_addend;
319
320 addr = section->sh_addr + relas[i].r_offset;
321
322 r_type = ELF64_R_TYPE(relas[i].r_info);
323 ret = arch_kexec_do_relocs(r_type, loc, val, addr);
324 if (ret) {
325 pr_err("Unknown rela relocation: %d\n", r_type);
326 return -ENOEXEC;
327 }
328 }
329 return 0;
330 }
331
arch_kexec_kernel_image_probe(struct kimage * image,void * buf,unsigned long buf_len)332 int arch_kexec_kernel_image_probe(struct kimage *image, void *buf,
333 unsigned long buf_len)
334 {
335 /* A kernel must be at least large enough to contain head.S. During
336 * load memory in head.S will be accessed, e.g. to register the next
337 * command line. If the next kernel were smaller the current kernel
338 * will panic at load.
339 */
340 if (buf_len < HEAD_END)
341 return -ENOEXEC;
342
343 return kexec_image_probe_default(image, buf, buf_len);
344 }
345
arch_kimage_file_post_load_cleanup(struct kimage * image)346 int arch_kimage_file_post_load_cleanup(struct kimage *image)
347 {
348 vfree(image->arch.ipl_buf);
349 image->arch.ipl_buf = NULL;
350
351 return kexec_image_post_load_cleanup_default(image);
352 }
353