Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * ELF loader 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/errno.h>
11#include <linux/kernel.h>
12#include <linux/kexec.h>
13#include <asm/setup.h>
14
15static int kexec_file_add_elf_kernel(struct kimage *image,
16 struct s390_load_data *data,
17 char *kernel, unsigned long kernel_len)
18{
19 struct kexec_buf buf;
20 const Elf_Ehdr *ehdr;
21 const Elf_Phdr *phdr;
22 int i, ret;
23
24 ehdr = (Elf_Ehdr *)kernel;
25 buf.image = image;
26
27 phdr = (void *)ehdr + ehdr->e_phoff;
28 for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
29 if (phdr->p_type != PT_LOAD)
30 continue;
31
32 buf.buffer = kernel + phdr->p_offset;
33 buf.bufsz = phdr->p_filesz;
34
35 buf.mem = ALIGN(phdr->p_paddr, phdr->p_align);
36 buf.memsz = phdr->p_memsz;
37
38 if (phdr->p_paddr == 0) {
39 data->kernel_buf = buf.buffer;
40 data->memsz += STARTUP_NORMAL_OFFSET;
41
42 buf.buffer += STARTUP_NORMAL_OFFSET;
43 buf.bufsz -= STARTUP_NORMAL_OFFSET;
44
45 buf.mem += STARTUP_NORMAL_OFFSET;
46 buf.memsz -= STARTUP_NORMAL_OFFSET;
47 }
48
49 if (image->type == KEXEC_TYPE_CRASH)
50 buf.mem += crashk_res.start;
51
52 ret = kexec_add_buffer(&buf);
53 if (ret)
54 return ret;
55
56 data->memsz += buf.memsz;
57 }
58
59 return 0;
60}
61
62static void *s390_elf_load(struct kimage *image,
63 char *kernel, unsigned long kernel_len,
64 char *initrd, unsigned long initrd_len,
65 char *cmdline, unsigned long cmdline_len)
66{
67 struct s390_load_data data = {0};
68 const Elf_Ehdr *ehdr;
69 const Elf_Phdr *phdr;
70 size_t size;
71 int i, ret;
72
73 /* image->fobs->probe already checked for valid ELF magic number. */
74 ehdr = (Elf_Ehdr *)kernel;
75
76 if (ehdr->e_type != ET_EXEC ||
77 ehdr->e_ident[EI_CLASS] != ELFCLASS64 ||
78 !elf_check_arch(ehdr))
79 return ERR_PTR(-EINVAL);
80
81 if (!ehdr->e_phnum || ehdr->e_phentsize != sizeof(Elf_Phdr))
82 return ERR_PTR(-EINVAL);
83
84 size = ehdr->e_ehsize + ehdr->e_phoff;
85 size += ehdr->e_phentsize * ehdr->e_phnum;
86 if (size > kernel_len)
87 return ERR_PTR(-EINVAL);
88
89 phdr = (void *)ehdr + ehdr->e_phoff;
90 size = ALIGN(size, phdr->p_align);
91 for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
92 if (phdr->p_type == PT_INTERP)
93 return ERR_PTR(-EINVAL);
94
95 if (phdr->p_offset > kernel_len)
96 return ERR_PTR(-EINVAL);
97
98 size += ALIGN(phdr->p_filesz, phdr->p_align);
99 }
100
101 if (size > kernel_len)
102 return ERR_PTR(-EINVAL);
103
104 ret = kexec_file_add_elf_kernel(image, &data, kernel, kernel_len);
105 if (ret)
106 return ERR_PTR(ret);
107
108 if (!data.memsz)
109 return ERR_PTR(-EINVAL);
110
111 if (initrd) {
112 ret = kexec_file_add_initrd(image, &data, initrd, initrd_len);
113 if (ret)
114 return ERR_PTR(ret);
115 }
116
117 ret = kexec_file_add_purgatory(image, &data);
118 if (ret)
119 return ERR_PTR(ret);
120
121 return kexec_file_update_kernel(image, &data);
122}
123
124static int s390_elf_probe(const char *buf, unsigned long len)
125{
126 const Elf_Ehdr *ehdr;
127
128 if (len < sizeof(Elf_Ehdr))
129 return -ENOEXEC;
130
131 ehdr = (Elf_Ehdr *)buf;
132
133 /* Only check the ELF magic number here and do proper validity check
134 * in the loader. Any check here that fails would send the erroneous
135 * ELF file to the image loader that does not care what it gets.
136 * (Most likely) causing behavior not intended by the user.
137 */
138 if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0)
139 return -ENOEXEC;
140
141 return 0;
142}
143
144const struct kexec_file_ops s390_kexec_elf_ops = {
145 .probe = s390_elf_probe,
146 .load = s390_elf_load,
147};
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * ELF loader 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/errno.h>
11#include <linux/kernel.h>
12#include <linux/kexec.h>
13#include <asm/ipl.h>
14#include <asm/setup.h>
15
16static int kexec_file_add_kernel_elf(struct kimage *image,
17 struct s390_load_data *data)
18{
19 struct kexec_buf buf;
20 const Elf_Ehdr *ehdr;
21 const Elf_Phdr *phdr;
22 Elf_Addr entry;
23 void *kernel;
24 int i, ret;
25
26 kernel = image->kernel_buf;
27 ehdr = (Elf_Ehdr *)kernel;
28 buf.image = image;
29 if (image->type == KEXEC_TYPE_CRASH)
30 entry = STARTUP_KDUMP_OFFSET;
31 else
32 entry = ehdr->e_entry;
33
34 phdr = (void *)ehdr + ehdr->e_phoff;
35 for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
36 if (phdr->p_type != PT_LOAD)
37 continue;
38
39 buf.buffer = kernel + phdr->p_offset;
40 buf.bufsz = phdr->p_filesz;
41
42 buf.mem = ALIGN(phdr->p_paddr, phdr->p_align);
43#ifdef CONFIG_CRASH_DUMP
44 if (image->type == KEXEC_TYPE_CRASH)
45 buf.mem += crashk_res.start;
46#endif
47 buf.memsz = phdr->p_memsz;
48 data->memsz = ALIGN(data->memsz, phdr->p_align) + buf.memsz;
49
50 if (entry - phdr->p_paddr < phdr->p_memsz) {
51 data->kernel_buf = buf.buffer;
52 data->kernel_mem = buf.mem;
53 data->parm = buf.buffer + PARMAREA;
54 }
55
56 ipl_report_add_component(data->report, &buf,
57 IPL_RB_COMPONENT_FLAG_SIGNED |
58 IPL_RB_COMPONENT_FLAG_VERIFIED,
59 IPL_RB_CERT_UNKNOWN);
60 ret = kexec_add_buffer(&buf);
61 if (ret)
62 return ret;
63 }
64
65 return data->memsz ? 0 : -EINVAL;
66}
67
68static void *s390_elf_load(struct kimage *image,
69 char *kernel, unsigned long kernel_len,
70 char *initrd, unsigned long initrd_len,
71 char *cmdline, unsigned long cmdline_len)
72{
73 const Elf_Ehdr *ehdr;
74 const Elf_Phdr *phdr;
75 size_t size;
76 int i;
77
78 /* image->fobs->probe already checked for valid ELF magic number. */
79 ehdr = (Elf_Ehdr *)kernel;
80
81 if (ehdr->e_type != ET_EXEC ||
82 ehdr->e_ident[EI_CLASS] != ELFCLASS64 ||
83 !elf_check_arch(ehdr))
84 return ERR_PTR(-EINVAL);
85
86 if (!ehdr->e_phnum || ehdr->e_phentsize != sizeof(Elf_Phdr))
87 return ERR_PTR(-EINVAL);
88
89 size = ehdr->e_ehsize + ehdr->e_phoff;
90 size += ehdr->e_phentsize * ehdr->e_phnum;
91 if (size > kernel_len)
92 return ERR_PTR(-EINVAL);
93
94 phdr = (void *)ehdr + ehdr->e_phoff;
95 size = ALIGN(size, phdr->p_align);
96 for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
97 if (phdr->p_type == PT_INTERP)
98 return ERR_PTR(-EINVAL);
99
100 if (phdr->p_offset > kernel_len)
101 return ERR_PTR(-EINVAL);
102
103 size += ALIGN(phdr->p_filesz, phdr->p_align);
104 }
105
106 if (size > kernel_len)
107 return ERR_PTR(-EINVAL);
108
109 return kexec_file_add_components(image, kexec_file_add_kernel_elf);
110}
111
112static int s390_elf_probe(const char *buf, unsigned long len)
113{
114 const Elf_Ehdr *ehdr;
115
116 if (len < sizeof(Elf_Ehdr))
117 return -ENOEXEC;
118
119 ehdr = (Elf_Ehdr *)buf;
120
121 /* Only check the ELF magic number here and do proper validity check
122 * in the loader. Any check here that fails would send the erroneous
123 * ELF file to the image loader that does not care what it gets.
124 * (Most likely) causing behavior not intended by the user.
125 */
126 if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0)
127 return -ENOEXEC;
128
129 return 0;
130}
131
132const struct kexec_file_ops s390_kexec_elf_ops = {
133 .probe = s390_elf_probe,
134 .load = s390_elf_load,
135#ifdef CONFIG_KEXEC_SIG
136 .verify_sig = s390_verify_sig,
137#endif /* CONFIG_KEXEC_SIG */
138};