// SPDX-License-Identifier: GPL-2.0 /* * s390 code for kexec_file_load system call * * Copyright IBM Corp. 2018 * * Author(s): Philipp Rudo */ #include #include #include #include #include #include #include const struct kexec_file_ops * const kexec_file_loaders[] = { &s390_kexec_elf_ops, &s390_kexec_image_ops, NULL, }; #ifdef CONFIG_KEXEC_VERIFY_SIG /* * Module signature information block. * * The constituents of the signature section are, in order: * * - Signer's name * - Key identifier * - Signature data * - Information block */ struct module_signature { u8 algo; /* Public-key crypto algorithm [0] */ u8 hash; /* Digest algorithm [0] */ u8 id_type; /* Key identifier type [PKEY_ID_PKCS7] */ u8 signer_len; /* Length of signer's name [0] */ u8 key_id_len; /* Length of key identifier [0] */ u8 __pad[3]; __be32 sig_len; /* Length of signature data */ }; #define PKEY_ID_PKCS7 2 int s390_verify_sig(const char *kernel, unsigned long kernel_len) { const unsigned long marker_len = sizeof(MODULE_SIG_STRING) - 1; struct module_signature *ms; unsigned long sig_len; /* Skip signature verification when not secure IPLed. */ if (!ipl_secure_flag) return 0; if (marker_len > kernel_len) return -EKEYREJECTED; if (memcmp(kernel + kernel_len - marker_len, MODULE_SIG_STRING, marker_len)) return -EKEYREJECTED; kernel_len -= marker_len; ms = (void *)kernel + kernel_len - sizeof(*ms); kernel_len -= sizeof(*ms); sig_len = be32_to_cpu(ms->sig_len); if (sig_len >= kernel_len) return -EKEYREJECTED; kernel_len -= sig_len; if (ms->id_type != PKEY_ID_PKCS7) return -EKEYREJECTED; if (ms->algo != 0 || ms->hash != 0 || ms->signer_len != 0 || ms->key_id_len != 0 || ms->__pad[0] != 0 || ms->__pad[1] != 0 || ms->__pad[2] != 0) { return -EBADMSG; } return verify_pkcs7_signature(kernel, kernel_len, kernel + kernel_len, sig_len, VERIFY_USE_PLATFORM_KEYRING, VERIFYING_MODULE_SIGNATURE, NULL, NULL); } #endif /* CONFIG_KEXEC_VERIFY_SIG */ static int kexec_file_update_purgatory(struct kimage *image, struct s390_load_data *data) { u64 entry, type; int ret; if (image->type == KEXEC_TYPE_CRASH) { entry = STARTUP_KDUMP_OFFSET; type = KEXEC_TYPE_CRASH; } else { entry = STARTUP_NORMAL_OFFSET; type = KEXEC_TYPE_DEFAULT; } ret = kexec_purgatory_get_set_symbol(image, "kernel_entry", &entry, sizeof(entry), false); if (ret) return ret; ret = kexec_purgatory_get_set_symbol(image, "kernel_type", &type, sizeof(type), false); if (ret) return ret; if (image->type == KEXEC_TYPE_CRASH) { u64 crash_size; ret = kexec_purgatory_get_set_symbol(image, "crash_start", &crashk_res.start, sizeof(crashk_res.start), false); if (ret) return ret; crash_size = crashk_res.end - crashk_res.start + 1; ret = kexec_purgatory_get_set_symbol(image, "crash_size", &crash_size, sizeof(crash_size), false); } return ret; } static int kexec_file_add_purgatory(struct kimage *image, struct s390_load_data *data) { struct kexec_buf buf; int ret; buf.image = image; data->memsz = ALIGN(data->memsz, PAGE_SIZE); buf.mem = data->memsz; if (image->type == KEXEC_TYPE_CRASH) buf.mem += crashk_res.start; ret = kexec_load_purgatory(image, &buf); if (ret) return ret; ret = kexec_file_update_purgatory(image, data); return ret; } static int kexec_file_add_initrd(struct kimage *image, struct s390_load_data *data) { struct kexec_buf buf; int ret; buf.image = image; buf.buffer = image->initrd_buf; buf.bufsz = image->initrd_buf_len; data->memsz = ALIGN(data->memsz, PAGE_SIZE); buf.mem = data->memsz; if (image->type == KEXEC_TYPE_CRASH) buf.mem += crashk_res.start; buf.memsz = buf.bufsz; data->parm->initrd_start = buf.mem; data->parm->initrd_size = buf.memsz; data->memsz += buf.memsz; ret = kexec_add_buffer(&buf); return ret; } void *kexec_file_add_components(struct kimage *image, int (*add_kernel)(struct kimage *image, struct s390_load_data *data)) { struct s390_load_data data = {0}; int ret; ret = add_kernel(image, &data); if (ret) return ERR_PTR(ret); if (image->cmdline_buf_len >= ARCH_COMMAND_LINE_SIZE) return ERR_PTR(-EINVAL); memcpy(data.parm->command_line, image->cmdline_buf, image->cmdline_buf_len); if (image->type == KEXEC_TYPE_CRASH) { data.parm->oldmem_base = crashk_res.start; data.parm->oldmem_size = crashk_res.end - crashk_res.start + 1; } if (image->initrd_buf) { ret = kexec_file_add_initrd(image, &data); if (ret) return ERR_PTR(ret); } ret = kexec_file_add_purgatory(image, &data); if (ret) return ERR_PTR(ret); if (data.kernel_mem == 0) { unsigned long restart_psw = 0x0008000080000000UL; restart_psw += image->start; memcpy(data.kernel_buf, &restart_psw, sizeof(restart_psw)); image->start = 0; } return NULL; } int arch_kexec_apply_relocations_add(struct purgatory_info *pi, Elf_Shdr *section, const Elf_Shdr *relsec, const Elf_Shdr *symtab) { Elf_Rela *relas; int i; relas = (void *)pi->ehdr + relsec->sh_offset; for (i = 0; i < relsec->sh_size / sizeof(*relas); i++) { const Elf_Sym *sym; /* symbol to relocate */ unsigned long addr; /* final location after relocation */ unsigned long val; /* relocated symbol value */ void *loc; /* tmp location to modify */ sym = (void *)pi->ehdr + symtab->sh_offset; sym += ELF64_R_SYM(relas[i].r_info); if (sym->st_shndx == SHN_UNDEF) return -ENOEXEC; if (sym->st_shndx == SHN_COMMON) return -ENOEXEC; if (sym->st_shndx >= pi->ehdr->e_shnum && sym->st_shndx != SHN_ABS) return -ENOEXEC; loc = pi->purgatory_buf; loc += section->sh_offset; loc += relas[i].r_offset; val = sym->st_value; if (sym->st_shndx != SHN_ABS) val += pi->sechdrs[sym->st_shndx].sh_addr; val += relas[i].r_addend; addr = section->sh_addr + relas[i].r_offset; switch (ELF64_R_TYPE(relas[i].r_info)) { case R_390_8: /* Direct 8 bit. */ *(u8 *)loc = val; break; case R_390_12: /* Direct 12 bit. */ *(u16 *)loc &= 0xf000; *(u16 *)loc |= val & 0xfff; break; case R_390_16: /* Direct 16 bit. */ *(u16 *)loc = val; break; case R_390_20: /* Direct 20 bit. */ *(u32 *)loc &= 0xf00000ff; *(u32 *)loc |= (val & 0xfff) << 16; /* DL */ *(u32 *)loc |= (val & 0xff000) >> 4; /* DH */ break; case R_390_32: /* Direct 32 bit. */ *(u32 *)loc = val; break; case R_390_64: /* Direct 64 bit. */ *(u64 *)loc = val; break; case R_390_PC16: /* PC relative 16 bit. */ *(u16 *)loc = (val - addr); break; case R_390_PC16DBL: /* PC relative 16 bit shifted by 1. */ *(u16 *)loc = (val - addr) >> 1; break; case R_390_PC32DBL: /* PC relative 32 bit shifted by 1. */ *(u32 *)loc = (val - addr) >> 1; break; case R_390_PC32: /* PC relative 32 bit. */ *(u32 *)loc = (val - addr); break; case R_390_PC64: /* PC relative 64 bit. */ *(u64 *)loc = (val - addr); break; default: break; } } return 0; } int arch_kexec_kernel_image_probe(struct kimage *image, void *buf, unsigned long buf_len) { /* A kernel must be at least large enough to contain head.S. During * load memory in head.S will be accessed, e.g. to register the next * command line. If the next kernel were smaller the current kernel * will panic at load. * * 0x11000 = sizeof(head.S) */ if (buf_len < 0x11000) return -ENOEXEC; return kexec_image_probe_default(image, buf, buf_len); }