cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

kexec_elf.c (3364B)

      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		if (image->type == KEXEC_TYPE_CRASH)
     44			buf.mem += crashk_res.start;
     45		buf.memsz = phdr->p_memsz;
     46		data->memsz = ALIGN(data->memsz, phdr->p_align) + buf.memsz;
     47
     48		if (entry - phdr->p_paddr < phdr->p_memsz) {
     49			data->kernel_buf = buf.buffer;
     50			data->kernel_mem = buf.mem;
     51			data->parm = buf.buffer + PARMAREA;
     52		}
     53
     54		ipl_report_add_component(data->report, &buf,
     55					 IPL_RB_COMPONENT_FLAG_SIGNED |
     56					 IPL_RB_COMPONENT_FLAG_VERIFIED,
     57					 IPL_RB_CERT_UNKNOWN);
     58		ret = kexec_add_buffer(&buf);
     59		if (ret)
     60			return ret;
     61	}
     62
     63	return data->memsz ? 0 : -EINVAL;
     64}
     65
     66static void *s390_elf_load(struct kimage *image,
     67			   char *kernel, unsigned long kernel_len,
     68			   char *initrd, unsigned long initrd_len,
     69			   char *cmdline, unsigned long cmdline_len)
     70{
     71	const Elf_Ehdr *ehdr;
     72	const Elf_Phdr *phdr;
     73	size_t size;
     74	int i;
     75
     76	/* image->fobs->probe already checked for valid ELF magic number. */
     77	ehdr = (Elf_Ehdr *)kernel;
     78
     79	if (ehdr->e_type != ET_EXEC ||
     80	    ehdr->e_ident[EI_CLASS] != ELFCLASS64 ||
     81	    !elf_check_arch(ehdr))
     82		return ERR_PTR(-EINVAL);
     83
     84	if (!ehdr->e_phnum || ehdr->e_phentsize != sizeof(Elf_Phdr))
     85		return ERR_PTR(-EINVAL);
     86
     87	size = ehdr->e_ehsize + ehdr->e_phoff;
     88	size += ehdr->e_phentsize * ehdr->e_phnum;
     89	if (size > kernel_len)
     90		return ERR_PTR(-EINVAL);
     91
     92	phdr = (void *)ehdr + ehdr->e_phoff;
     93	size = ALIGN(size, phdr->p_align);
     94	for (i = 0; i < ehdr->e_phnum; i++, phdr++) {
     95		if (phdr->p_type == PT_INTERP)
     96			return ERR_PTR(-EINVAL);
     97
     98		if (phdr->p_offset > kernel_len)
     99			return ERR_PTR(-EINVAL);
    100
    101		size += ALIGN(phdr->p_filesz, phdr->p_align);
    102	}
    103
    104	if (size > kernel_len)
    105		return ERR_PTR(-EINVAL);
    106
    107	return kexec_file_add_components(image, kexec_file_add_kernel_elf);
    108}
    109
    110static int s390_elf_probe(const char *buf, unsigned long len)
    111{
    112	const Elf_Ehdr *ehdr;
    113
    114	if (len < sizeof(Elf_Ehdr))
    115		return -ENOEXEC;
    116
    117	ehdr = (Elf_Ehdr *)buf;
    118
    119	/* Only check the ELF magic number here and do proper validity check
    120	 * in the loader. Any check here that fails would send the erroneous
    121	 * ELF file to the image loader that does not care what it gets.
    122	 * (Most likely) causing behavior not intended by the user.
    123	 */
    124	if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG) != 0)
    125		return -ENOEXEC;
    126
    127	return 0;
    128}
    129
    130const struct kexec_file_ops s390_kexec_elf_ops = {
    131	.probe = s390_elf_probe,
    132	.load = s390_elf_load,
    133#ifdef CONFIG_KEXEC_SIG
    134	.verify_sig = s390_verify_sig,
    135#endif /* CONFIG_KEXEC_SIG */
    136};