2017-06-19 16:45:33 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
/*
|
|
|
|
* s390 code for kexec_file_load system call
|
|
|
|
*
|
|
|
|
* Copyright IBM Corp. 2018
|
|
|
|
*
|
|
|
|
* Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/elf.h>
|
2019-02-26 17:50:39 +08:00
|
|
|
#include <linux/errno.h>
|
2017-06-19 16:45:33 +08:00
|
|
|
#include <linux/kexec.h>
|
2019-02-26 17:50:39 +08:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/verification.h>
|
|
|
|
#include <asm/ipl.h>
|
2017-06-19 16:45:33 +08:00
|
|
|
#include <asm/setup.h>
|
|
|
|
|
|
|
|
const struct kexec_file_ops * const kexec_file_loaders[] = {
|
2017-09-11 21:15:29 +08:00
|
|
|
&s390_kexec_elf_ops,
|
2017-08-30 20:03:38 +08:00
|
|
|
&s390_kexec_image_ops,
|
2017-06-19 16:45:33 +08:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2019-02-26 17:50:39 +08:00
|
|
|
#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 */
|
|
|
|
|
2019-03-07 22:56:34 +08:00
|
|
|
static int kexec_file_update_purgatory(struct kimage *image,
|
|
|
|
struct s390_load_data *data)
|
2017-08-30 20:03:38 +08:00
|
|
|
{
|
|
|
|
u64 entry, type;
|
|
|
|
int ret;
|
|
|
|
|
2017-09-05 17:55:23 +08:00
|
|
|
if (image->type == KEXEC_TYPE_CRASH) {
|
|
|
|
entry = STARTUP_KDUMP_OFFSET;
|
|
|
|
type = KEXEC_TYPE_CRASH;
|
|
|
|
} else {
|
|
|
|
entry = STARTUP_NORMAL_OFFSET;
|
|
|
|
type = KEXEC_TYPE_DEFAULT;
|
|
|
|
}
|
|
|
|
|
2017-08-30 20:03:38 +08:00
|
|
|
ret = kexec_purgatory_get_set_symbol(image, "kernel_entry", &entry,
|
|
|
|
sizeof(entry), false);
|
2017-09-05 17:55:23 +08:00
|
|
|
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);
|
|
|
|
}
|
2017-08-30 20:03:38 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-03-07 19:48:03 +08:00
|
|
|
static int kexec_file_add_purgatory(struct kimage *image,
|
|
|
|
struct s390_load_data *data)
|
2017-08-30 20:03:38 +08:00
|
|
|
{
|
|
|
|
struct kexec_buf buf;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
buf.image = image;
|
|
|
|
|
|
|
|
data->memsz = ALIGN(data->memsz, PAGE_SIZE);
|
|
|
|
buf.mem = data->memsz;
|
2017-09-05 17:55:23 +08:00
|
|
|
if (image->type == KEXEC_TYPE_CRASH)
|
|
|
|
buf.mem += crashk_res.start;
|
2017-08-30 20:03:38 +08:00
|
|
|
|
|
|
|
ret = kexec_load_purgatory(image, &buf);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2019-03-07 22:56:34 +08:00
|
|
|
ret = kexec_file_update_purgatory(image, data);
|
2017-08-30 20:03:38 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-03-07 19:48:03 +08:00
|
|
|
static int kexec_file_add_initrd(struct kimage *image,
|
|
|
|
struct s390_load_data *data)
|
2017-08-30 20:03:38 +08:00
|
|
|
{
|
|
|
|
struct kexec_buf buf;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
buf.image = image;
|
|
|
|
|
2019-03-07 19:48:03 +08:00
|
|
|
buf.buffer = image->initrd_buf;
|
|
|
|
buf.bufsz = image->initrd_buf_len;
|
2017-08-30 20:03:38 +08:00
|
|
|
|
|
|
|
data->memsz = ALIGN(data->memsz, PAGE_SIZE);
|
|
|
|
buf.mem = data->memsz;
|
2017-09-05 17:55:23 +08:00
|
|
|
if (image->type == KEXEC_TYPE_CRASH)
|
|
|
|
buf.mem += crashk_res.start;
|
2017-08-30 20:03:38 +08:00
|
|
|
buf.memsz = buf.bufsz;
|
|
|
|
|
2019-03-07 00:36:26 +08:00
|
|
|
data->parm->initrd_start = buf.mem;
|
|
|
|
data->parm->initrd_size = buf.memsz;
|
2017-08-30 20:03:38 +08:00
|
|
|
data->memsz += buf.memsz;
|
|
|
|
|
|
|
|
ret = kexec_add_buffer(&buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-03-07 19:48:03 +08:00
|
|
|
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);
|
|
|
|
|
2019-03-07 22:56:34 +08:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2019-03-07 19:48:03 +08:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-06-19 16:45:33 +08:00
|
|
|
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);
|
|
|
|
}
|