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 15 static 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 62 static 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 124 static 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 144 const struct kexec_file_ops s390_kexec_elf_ops = { 145 .probe = s390_elf_probe, 146 .load = s390_elf_load, 147 }; 148