arch/s390/kernel/machine_kexec_file.c

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