[linux-block.git] / arch / s390 / kernel / crash_dump.c

// SPDX-License-Identifier: GPL-2.0
/*
 * S390 kdump implementation
 *
 * Copyright IBM Corp. 2011
 * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
 */

#include <linux/crash_dump.h>
#include <asm/lowcore.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/gfp.h>
#include <linux/slab.h>
#include <linux/memblock.h>
#include <linux/elf.h>
#include <linux/uio.h>
#include <asm/asm-offsets.h>
#include <asm/os_info.h>
#include <asm/elf.h>
#include <asm/ipl.h>
#include <asm/sclp.h>
#include <asm/maccess.h>

#define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
#define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
#define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))

static struct memblock_region oldmem_region;

static struct memblock_type oldmem_type = {
	.cnt = 1,
	.max = 1,
	.total_size = 0,
	.regions = &oldmem_region,
	.name = "oldmem",
};

struct save_area {
	struct list_head list;
	u64 psw[2];
	u64 ctrs[16];
	u64 gprs[16];
	u32 acrs[16];
	u64 fprs[16];
	u32 fpc;
	u32 prefix;
	u32 todpreg;
	u64 timer;
	u64 todcmp;
	u64 vxrs_low[16];
	__vector128 vxrs_high[16];
};

static LIST_HEAD(dump_save_areas);

/*
 * Allocate a save area
 */
struct save_area * __init save_area_alloc(bool is_boot_cpu)
{
	struct save_area *sa;

	sa = memblock_alloc(sizeof(*sa), 8);
	if (!sa)
		return NULL;

	if (is_boot_cpu)
		list_add(&sa->list, &dump_save_areas);
	else
		list_add_tail(&sa->list, &dump_save_areas);
	return sa;
}

/*
 * Return the address of the save area for the boot CPU
 */
struct save_area * __init save_area_boot_cpu(void)
{
	return list_first_entry_or_null(&dump_save_areas, struct save_area, list);
}

/*
 * Copy CPU registers into the save area
 */
void __init save_area_add_regs(struct save_area *sa, void *regs)
{
	struct lowcore *lc;

	lc = (struct lowcore *)(regs - __LC_FPREGS_SAVE_AREA);
	memcpy(&sa->psw, &lc->psw_save_area, sizeof(sa->psw));
	memcpy(&sa->ctrs, &lc->cregs_save_area, sizeof(sa->ctrs));
	memcpy(&sa->gprs, &lc->gpregs_save_area, sizeof(sa->gprs));
	memcpy(&sa->acrs, &lc->access_regs_save_area, sizeof(sa->acrs));
	memcpy(&sa->fprs, &lc->floating_pt_save_area, sizeof(sa->fprs));
	memcpy(&sa->fpc, &lc->fpt_creg_save_area, sizeof(sa->fpc));
	memcpy(&sa->prefix, &lc->prefixreg_save_area, sizeof(sa->prefix));
	memcpy(&sa->todpreg, &lc->tod_progreg_save_area, sizeof(sa->todpreg));
	memcpy(&sa->timer, &lc->cpu_timer_save_area, sizeof(sa->timer));
	memcpy(&sa->todcmp, &lc->clock_comp_save_area, sizeof(sa->todcmp));
}

/*
 * Copy vector registers into the save area
 */
void __init save_area_add_vxrs(struct save_area *sa, __vector128 *vxrs)
{
	int i;

	/* Copy lower halves of vector registers 0-15 */
	for (i = 0; i < 16; i++)
		sa->vxrs_low[i] = vxrs[i].low;
	/* Copy vector registers 16-31 */
	memcpy(sa->vxrs_high, vxrs + 16, 16 * sizeof(__vector128));
}

static size_t copy_oldmem_iter(struct iov_iter *iter, unsigned long src, size_t count)
{
	size_t len, copied, res = 0;

	while (count) {
		if (!oldmem_data.start && src < sclp.hsa_size) {
			/* Copy from zfcp/nvme dump HSA area */
			len = min(count, sclp.hsa_size - src);
			copied = memcpy_hsa_iter(iter, src, len);
		} else {
			/* Check for swapped kdump oldmem areas */
			if (oldmem_data.start && src - oldmem_data.start < oldmem_data.size) {
				src -= oldmem_data.start;
				len = min(count, oldmem_data.size - src);
			} else if (oldmem_data.start && src < oldmem_data.size) {
				len = min(count, oldmem_data.size - src);
				src += oldmem_data.start;
			} else {
				len = count;
			}
			copied = memcpy_real_iter(iter, src, len);
		}
		count -= copied;
		src += copied;
		res += copied;
		if (copied < len)
			break;
	}
	return res;
}

int copy_oldmem_kernel(void *dst, unsigned long src, size_t count)
{
	struct iov_iter iter;
	struct kvec kvec;

	kvec.iov_base = dst;
	kvec.iov_len = count;
	iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);
	if (copy_oldmem_iter(&iter, src, count) < count)
		return -EFAULT;
	return 0;
}

/*
 * Copy one page from "oldmem"
 */
ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn, size_t csize,
			 unsigned long offset)
{
	unsigned long src;

	src = pfn_to_phys(pfn) + offset;
	return copy_oldmem_iter(iter, src, csize);
}

/*
 * Remap "oldmem" for kdump
 *
 * For the kdump reserved memory this functions performs a swap operation:
 * [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
 */
static int remap_oldmem_pfn_range_kdump(struct vm_area_struct *vma,
					unsigned long from, unsigned long pfn,
					unsigned long size, pgprot_t prot)
{
	unsigned long size_old;
	int rc;

	if (pfn < oldmem_data.size >> PAGE_SHIFT) {
		size_old = min(size, oldmem_data.size - (pfn << PAGE_SHIFT));
		rc = remap_pfn_range(vma, from,
				     pfn + (oldmem_data.start >> PAGE_SHIFT),
				     size_old, prot);
		if (rc || size == size_old)
			return rc;
		size -= size_old;
		from += size_old;
		pfn += size_old >> PAGE_SHIFT;
	}
	return remap_pfn_range(vma, from, pfn, size, prot);
}

/*
 * Remap "oldmem" for zfcp/nvme dump
 *
 * We only map available memory above HSA size. Memory below HSA size
 * is read on demand using the copy_oldmem_page() function.
 */
static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct *vma,
					   unsigned long from,
					   unsigned long pfn,
					   unsigned long size, pgprot_t prot)
{
	unsigned long hsa_end = sclp.hsa_size;
	unsigned long size_hsa;

	if (pfn < hsa_end >> PAGE_SHIFT) {
		size_hsa = min(size, hsa_end - (pfn << PAGE_SHIFT));
		if (size == size_hsa)
			return 0;
		size -= size_hsa;
		from += size_hsa;
		pfn += size_hsa >> PAGE_SHIFT;
	}
	return remap_pfn_range(vma, from, pfn, size, prot);
}

/*
 * Remap "oldmem" for kdump or zfcp/nvme dump
 */
int remap_oldmem_pfn_range(struct vm_area_struct *vma, unsigned long from,
			   unsigned long pfn, unsigned long size, pgprot_t prot)
{
	if (oldmem_data.start)
		return remap_oldmem_pfn_range_kdump(vma, from, pfn, size, prot);
	else
		return remap_oldmem_pfn_range_zfcpdump(vma, from, pfn, size,
						       prot);
}

static const char *nt_name(Elf64_Word type)
{
	const char *name = "LINUX";

	if (type == NT_PRPSINFO || type == NT_PRSTATUS || type == NT_PRFPREG)
		name = KEXEC_CORE_NOTE_NAME;
	return name;
}

/*
 * Initialize ELF note
 */
static void *nt_init_name(void *buf, Elf64_Word type, void *desc, int d_len,
			  const char *name)
{
	Elf64_Nhdr *note;
	u64 len;

	note = (Elf64_Nhdr *)buf;
	note->n_namesz = strlen(name) + 1;
	note->n_descsz = d_len;
	note->n_type = type;
	len = sizeof(Elf64_Nhdr);

	memcpy(buf + len, name, note->n_namesz);
	len = roundup(len + note->n_namesz, 4);

	memcpy(buf + len, desc, note->n_descsz);
	len = roundup(len + note->n_descsz, 4);

	return PTR_ADD(buf, len);
}

static inline void *nt_init(void *buf, Elf64_Word type, void *desc, int d_len)
{
	return nt_init_name(buf, type, desc, d_len, nt_name(type));
}

/*
 * Calculate the size of ELF note
 */
static size_t nt_size_name(int d_len, const char *name)
{
	size_t size;

	size = sizeof(Elf64_Nhdr);
	size += roundup(strlen(name) + 1, 4);
	size += roundup(d_len, 4);

	return size;
}

static inline size_t nt_size(Elf64_Word type, int d_len)
{
	return nt_size_name(d_len, nt_name(type));
}

/*
 * Fill ELF notes for one CPU with save area registers
 */
static void *fill_cpu_elf_notes(void *ptr, int cpu, struct save_area *sa)
{
	struct elf_prstatus nt_prstatus;
	elf_fpregset_t nt_fpregset;

	/* Prepare prstatus note */
	memset(&nt_prstatus, 0, sizeof(nt_prstatus));
	memcpy(&nt_prstatus.pr_reg.gprs, sa->gprs, sizeof(sa->gprs));
	memcpy(&nt_prstatus.pr_reg.psw, sa->psw, sizeof(sa->psw));
	memcpy(&nt_prstatus.pr_reg.acrs, sa->acrs, sizeof(sa->acrs));
	nt_prstatus.common.pr_pid = cpu;
	/* Prepare fpregset (floating point) note */
	memset(&nt_fpregset, 0, sizeof(nt_fpregset));
	memcpy(&nt_fpregset.fpc, &sa->fpc, sizeof(sa->fpc));
	memcpy(&nt_fpregset.fprs, &sa->fprs, sizeof(sa->fprs));
	/* Create ELF notes for the CPU */
	ptr = nt_init(ptr, NT_PRSTATUS, &nt_prstatus, sizeof(nt_prstatus));
	ptr = nt_init(ptr, NT_PRFPREG, &nt_fpregset, sizeof(nt_fpregset));
	ptr = nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer));
	ptr = nt_init(ptr, NT_S390_TODCMP, &sa->todcmp, sizeof(sa->todcmp));
	ptr = nt_init(ptr, NT_S390_TODPREG, &sa->todpreg, sizeof(sa->todpreg));
	ptr = nt_init(ptr, NT_S390_CTRS, &sa->ctrs, sizeof(sa->ctrs));
	ptr = nt_init(ptr, NT_S390_PREFIX, &sa->prefix, sizeof(sa->prefix));
	if (MACHINE_HAS_VX) {
		ptr = nt_init(ptr, NT_S390_VXRS_HIGH,
			      &sa->vxrs_high, sizeof(sa->vxrs_high));
		ptr = nt_init(ptr, NT_S390_VXRS_LOW,
			      &sa->vxrs_low, sizeof(sa->vxrs_low));
	}
	return ptr;
}

/*
 * Calculate size of ELF notes per cpu
 */
static size_t get_cpu_elf_notes_size(void)
{
	struct save_area *sa = NULL;
	size_t size;

	size =	nt_size(NT_PRSTATUS, sizeof(struct elf_prstatus));
	size +=  nt_size(NT_PRFPREG, sizeof(elf_fpregset_t));
	size +=  nt_size(NT_S390_TIMER, sizeof(sa->timer));
	size +=  nt_size(NT_S390_TODCMP, sizeof(sa->todcmp));
	size +=  nt_size(NT_S390_TODPREG, sizeof(sa->todpreg));
	size +=  nt_size(NT_S390_CTRS, sizeof(sa->ctrs));
	size +=  nt_size(NT_S390_PREFIX, sizeof(sa->prefix));
	if (MACHINE_HAS_VX) {
		size += nt_size(NT_S390_VXRS_HIGH, sizeof(sa->vxrs_high));
		size += nt_size(NT_S390_VXRS_LOW, sizeof(sa->vxrs_low));
	}

	return size;
}

/*
 * Initialize prpsinfo note (new kernel)
 */
static void *nt_prpsinfo(void *ptr)
{
	struct elf_prpsinfo prpsinfo;

	memset(&prpsinfo, 0, sizeof(prpsinfo));
	prpsinfo.pr_sname = 'R';
	strcpy(prpsinfo.pr_fname, "vmlinux");
	return nt_init(ptr, NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo));
}

/*
 * Get vmcoreinfo using lowcore->vmcore_info (new kernel)
 */
static void *get_vmcoreinfo_old(unsigned long *size)
{
	char nt_name[11], *vmcoreinfo;
	unsigned long addr;
	Elf64_Nhdr note;

	if (copy_oldmem_kernel(&addr, __LC_VMCORE_INFO, sizeof(addr)))
		return NULL;
	memset(nt_name, 0, sizeof(nt_name));
	if (copy_oldmem_kernel(&note, addr, sizeof(note)))
		return NULL;
	if (copy_oldmem_kernel(nt_name, addr + sizeof(note),
			       sizeof(nt_name) - 1))
		return NULL;
	if (strcmp(nt_name, VMCOREINFO_NOTE_NAME) != 0)
		return NULL;
	vmcoreinfo = kzalloc(note.n_descsz, GFP_KERNEL);
	if (!vmcoreinfo)
		return NULL;
	if (copy_oldmem_kernel(vmcoreinfo, addr + 24, note.n_descsz)) {
		kfree(vmcoreinfo);
		return NULL;
	}
	*size = note.n_descsz;
	return vmcoreinfo;
}

/*
 * Initialize vmcoreinfo note (new kernel)
 */
static void *nt_vmcoreinfo(void *ptr)
{
	const char *name = VMCOREINFO_NOTE_NAME;
	unsigned long size;
	void *vmcoreinfo;

	vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
	if (vmcoreinfo)
		return nt_init_name(ptr, 0, vmcoreinfo, size, name);

	vmcoreinfo = get_vmcoreinfo_old(&size);
	if (!vmcoreinfo)
		return ptr;
	ptr = nt_init_name(ptr, 0, vmcoreinfo, size, name);
	kfree(vmcoreinfo);
	return ptr;
}

static size_t nt_vmcoreinfo_size(void)
{
	const char *name = VMCOREINFO_NOTE_NAME;
	unsigned long size;
	void *vmcoreinfo;

	vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
	if (vmcoreinfo)
		return nt_size_name(size, name);

	vmcoreinfo = get_vmcoreinfo_old(&size);
	if (!vmcoreinfo)
		return 0;

	kfree(vmcoreinfo);
	return nt_size_name(size, name);
}

/*
 * Initialize final note (needed for /proc/vmcore code)
 */
static void *nt_final(void *ptr)
{
	Elf64_Nhdr *note;

	note = (Elf64_Nhdr *) ptr;
	note->n_namesz = 0;
	note->n_descsz = 0;
	note->n_type = 0;
	return PTR_ADD(ptr, sizeof(Elf64_Nhdr));
}

/*
 * Initialize ELF header (new kernel)
 */
static void *ehdr_init(Elf64_Ehdr *ehdr, int mem_chunk_cnt)
{
	memset(ehdr, 0, sizeof(*ehdr));
	memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
	ehdr->e_ident[EI_CLASS] = ELFCLASS64;
	ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
	memset(ehdr->e_ident + EI_PAD, 0, EI_NIDENT - EI_PAD);
	ehdr->e_type = ET_CORE;
	ehdr->e_machine = EM_S390;
	ehdr->e_version = EV_CURRENT;
	ehdr->e_phoff = sizeof(Elf64_Ehdr);
	ehdr->e_ehsize = sizeof(Elf64_Ehdr);
	ehdr->e_phentsize = sizeof(Elf64_Phdr);
	ehdr->e_phnum = mem_chunk_cnt + 1;
	return ehdr + 1;
}

/*
 * Return CPU count for ELF header (new kernel)
 */
static int get_cpu_cnt(void)
{
	struct save_area *sa;
	int cpus = 0;

	list_for_each_entry(sa, &dump_save_areas, list)
		if (sa->prefix != 0)
			cpus++;
	return cpus;
}

/*
 * Return memory chunk count for ELF header (new kernel)
 */
static int get_mem_chunk_cnt(void)
{
	int cnt = 0;
	u64 idx;

	for_each_physmem_range(idx, &oldmem_type, NULL, NULL)
		cnt++;
	return cnt;
}

/*
 * Initialize ELF loads (new kernel)
 */
static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
{
	phys_addr_t start, end;
	u64 idx;

	for_each_physmem_range(idx, &oldmem_type, &start, &end) {
		phdr->p_filesz = end - start;
		phdr->p_type = PT_LOAD;
		phdr->p_offset = start;
		phdr->p_vaddr = start;
		phdr->p_paddr = start;
		phdr->p_memsz = end - start;
		phdr->p_flags = PF_R | PF_W | PF_X;
		phdr->p_align = PAGE_SIZE;
		phdr++;
	}
}

/*
 * Initialize notes (new kernel)
 */
static void *notes_init(Elf64_Phdr *phdr, void *ptr, u64 notes_offset)
{
	struct save_area *sa;
	void *ptr_start = ptr;
	int cpu;

	ptr = nt_prpsinfo(ptr);

	cpu = 1;
	list_for_each_entry(sa, &dump_save_areas, list)
		if (sa->prefix != 0)
			ptr = fill_cpu_elf_notes(ptr, cpu++, sa);
	ptr = nt_vmcoreinfo(ptr);
	ptr = nt_final(ptr);
	memset(phdr, 0, sizeof(*phdr));
	phdr->p_type = PT_NOTE;
	phdr->p_offset = notes_offset;
	phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
	phdr->p_memsz = phdr->p_filesz;
	return ptr;
}

static size_t get_elfcorehdr_size(int mem_chunk_cnt)
{
	size_t size;

	size = sizeof(Elf64_Ehdr);
	/* PT_NOTES */
	size += sizeof(Elf64_Phdr);
	/* nt_prpsinfo */
	size += nt_size(NT_PRPSINFO, sizeof(struct elf_prpsinfo));
	/* regsets */
	size += get_cpu_cnt() * get_cpu_elf_notes_size();
	/* nt_vmcoreinfo */
	size += nt_vmcoreinfo_size();
	/* nt_final */
	size += sizeof(Elf64_Nhdr);
	/* PT_LOADS */
	size += mem_chunk_cnt * sizeof(Elf64_Phdr);

	return size;
}

/*
 * Create ELF core header (new kernel)
 */
int elfcorehdr_alloc(unsigned long long *addr, unsigned long long *size)
{
	Elf64_Phdr *phdr_notes, *phdr_loads;
	size_t alloc_size;
	int mem_chunk_cnt;
	void *ptr, *hdr;
	u64 hdr_off;

	/* If we are not in kdump or zfcp/nvme dump mode return */
	if (!oldmem_data.start && !is_ipl_type_dump())
		return 0;
	/* If we cannot get HSA size for zfcp/nvme dump return error */
	if (is_ipl_type_dump() && !sclp.hsa_size)
		return -ENODEV;

	/* For kdump, exclude previous crashkernel memory */
	if (oldmem_data.start) {
		oldmem_region.base = oldmem_data.start;
		oldmem_region.size = oldmem_data.size;
		oldmem_type.total_size = oldmem_data.size;
	}

	mem_chunk_cnt = get_mem_chunk_cnt();

	alloc_size = get_elfcorehdr_size(mem_chunk_cnt);

	hdr = kzalloc(alloc_size, GFP_KERNEL);

	/* Without elfcorehdr /proc/vmcore cannot be created. Thus creating
	 * a dump with this crash kernel will fail. Panic now to allow other
	 * dump mechanisms to take over.
	 */
	if (!hdr)
		panic("s390 kdump allocating elfcorehdr failed");

	/* Init elf header */
	ptr = ehdr_init(hdr, mem_chunk_cnt);
	/* Init program headers */
	phdr_notes = ptr;
	ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr));
	phdr_loads = ptr;
	ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
	/* Init notes */
	hdr_off = PTR_DIFF(ptr, hdr);
	ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
	/* Init loads */
	hdr_off = PTR_DIFF(ptr, hdr);
	loads_init(phdr_loads, hdr_off);
	*addr = (unsigned long long) hdr;
	*size = (unsigned long long) hdr_off;
	BUG_ON(elfcorehdr_size > alloc_size);
	return 0;
}

/*
 * Free ELF core header (new kernel)
 */
void elfcorehdr_free(unsigned long long addr)
{
	kfree((void *)(unsigned long)addr);
}

/*
 * Read from ELF header
 */
ssize_t elfcorehdr_read(char *buf, size_t count, u64 *ppos)
{
	void *src = (void *)(unsigned long)*ppos;

	memcpy(buf, src, count);
	*ppos += count;
	return count;
}

/*
 * Read from ELF notes data
 */
ssize_t elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos)
{
	void *src = (void *)(unsigned long)*ppos;

	memcpy(buf, src, count);
	*ppos += count;
	return count;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
60a0c68d MH	2	/*
	3	* S390 kdump implementation
	4	*
	5	* Copyright IBM Corp. 2011
	6	* Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
	7	*/
	8
	9	#include <linux/crash_dump.h>
	10	#include <asm/lowcore.h>
	11	#include <linux/kernel.h>
3994a52b PG	12	#include <linux/init.h>
3994a52b PG	13	#include <linux/mm.h>
60a0c68d MH	14	#include <linux/gfp.h>
60a0c68d MH	15	#include <linux/slab.h>
57c8a661	16	#include <linux/memblock.h>
60a0c68d	17	#include <linux/elf.h>
5d8de293	18	#include <linux/uio.h>
1a2c5840	19	#include <asm/asm-offsets.h>
4857d4bb	20	#include <asm/os_info.h>
6b563d8c HC	21	#include <asm/elf.h>
6b563d8c HC	22	#include <asm/ipl.h>
6f79d332	23	#include <asm/sclp.h>
2f0e8aae	24	#include <asm/maccess.h>
60a0c68d MH	25
	26	#define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
	27	#define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
	28	#define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
	29
50be6345 PH	30	static struct memblock_region oldmem_region;
	31
	32	static struct memblock_type oldmem_type = {
	33	.cnt = 1,
	34	.max = 1,
	35	.total_size = 0,
	36	.regions = &oldmem_region,
0262d9c8	37	.name = "oldmem",
50be6345 PH	38	};
50be6345 PH	39
1a2c5840 MS	40	struct save_area {
	41	struct list_head list;
	42	u64 psw[2];
	43	u64 ctrs[16];
	44	u64 gprs[16];
	45	u32 acrs[16];
	46	u64 fprs[16];
	47	u32 fpc;
	48	u32 prefix;
f44e07a8	49	u32 todpreg;
1a2c5840 MS	50	u64 timer;
	51	u64 todcmp;
	52	u64 vxrs_low[16];
	53	__vector128 vxrs_high[16];
	54	};
	55
	56	static LIST_HEAD(dump_save_areas);
	57
	58	/*
	59	* Allocate a save area
	60	*/
	61	struct save_area * __init save_area_alloc(bool is_boot_cpu)
	62	{
	63	struct save_area *sa;
	64
a0e45d40	65	sa = memblock_alloc(sizeof(*sa), 8);
ecc3e771	66	if (!sa)
86caa4b6	67	return NULL;
ecc3e771	68
1a2c5840 MS	69	if (is_boot_cpu)
	70	list_add(&sa->list, &dump_save_areas);
	71	else
	72	list_add_tail(&sa->list, &dump_save_areas);
	73	return sa;
	74	}
	75
	76	/*
	77	* Return the address of the save area for the boot CPU
	78	*/
	79	struct save_area * __init save_area_boot_cpu(void)
	80	{
f296190e	81	return list_first_entry_or_null(&dump_save_areas, struct save_area, list);
1a2c5840 MS	82	}
	83
	84	/*
	85	* Copy CPU registers into the save area
	86	*/
	87	void __init save_area_add_regs(struct save_area sa, void regs)
	88	{
c667aeac	89	struct lowcore *lc;
1a2c5840	90
c667aeac	91	lc = (struct lowcore *)(regs - __LC_FPREGS_SAVE_AREA);
1a2c5840 MS	92	memcpy(&sa->psw, &lc->psw_save_area, sizeof(sa->psw));
	93	memcpy(&sa->ctrs, &lc->cregs_save_area, sizeof(sa->ctrs));
	94	memcpy(&sa->gprs, &lc->gpregs_save_area, sizeof(sa->gprs));
	95	memcpy(&sa->acrs, &lc->access_regs_save_area, sizeof(sa->acrs));
	96	memcpy(&sa->fprs, &lc->floating_pt_save_area, sizeof(sa->fprs));
	97	memcpy(&sa->fpc, &lc->fpt_creg_save_area, sizeof(sa->fpc));
	98	memcpy(&sa->prefix, &lc->prefixreg_save_area, sizeof(sa->prefix));
	99	memcpy(&sa->todpreg, &lc->tod_progreg_save_area, sizeof(sa->todpreg));
	100	memcpy(&sa->timer, &lc->cpu_timer_save_area, sizeof(sa->timer));
	101	memcpy(&sa->todcmp, &lc->clock_comp_save_area, sizeof(sa->todcmp));
	102	}
	103
	104	/*
	105	* Copy vector registers into the save area
	106	*/
	107	void __init save_area_add_vxrs(struct save_area sa, __vector128 vxrs)
	108	{
	109	int i;
	110
	111	/* Copy lower halves of vector registers 0-15 */
	112	for (i = 0; i < 16; i++)
a02d584e	113	sa->vxrs_low[i] = vxrs[i].low;
1a2c5840 MS	114	/* Copy vector registers 16-31 */
	115	memcpy(sa->vxrs_high, vxrs + 16, 16 * sizeof(__vector128));
	116	}
58952942	117
fba07cd4	118	static size_t copy_oldmem_iter(struct iov_iter *iter, unsigned long src, size_t count)
60a0c68d	119	{
ebbc9570	120	size_t len, copied, res = 0;
60a0c68d	121
df9694c7	122	while (count) {
303fd988	123	if (!oldmem_data.start && src < sclp.hsa_size) {
bd37b368	124	/* Copy from zfcp/nvme dump HSA area */
303fd988	125	len = min(count, sclp.hsa_size - src);
ebbc9570	126	copied = memcpy_hsa_iter(iter, src, len);
df9694c7 MS	127	} else {
df9694c7 MS	128	/* Check for swapped kdump oldmem areas */
303fd988 AG	129	if (oldmem_data.start && src - oldmem_data.start < oldmem_data.size) {
	130	src -= oldmem_data.start;
	131	len = min(count, oldmem_data.size - src);
	132	} else if (oldmem_data.start && src < oldmem_data.size) {
	133	len = min(count, oldmem_data.size - src);
	134	src += oldmem_data.start;
df9694c7 MS	135	} else {
	136	len = count;
	137	}
2f0e8aae	138	copied = memcpy_real_iter(iter, src, len);
df9694c7	139	}
ebbc9570 AG	140	count -= copied;
	141	src += copied;
	142	res += copied;
	143	if (copied < len)
	144	break;
df9694c7	145	}
ebbc9570	146	return res;
6f79d332 MH	147	}
6f79d332 MH	148
fba07cd4 AG	149	int copy_oldmem_kernel(void *dst, unsigned long src, size_t count)
	150	{
	151	struct iov_iter iter;
	152	struct kvec kvec;
	153
	154	kvec.iov_base = dst;
	155	kvec.iov_len = count;
de4eda9d	156	iov_iter_kvec(&iter, ITER_DEST, &kvec, 1, count);
fba07cd4 AG	157	if (copy_oldmem_iter(&iter, src, count) < count)
	158	return -EFAULT;
	159	return 0;
	160	}
	161
6f79d332 MH	162	/*
	163	* Copy one page from "oldmem"
	164	*/
5d8de293 MWO	165	ssize_t copy_oldmem_page(struct iov_iter *iter, unsigned long pfn, size_t csize,
5d8de293 MWO	166	unsigned long offset)
6f79d332	167	{
303fd988	168	unsigned long src;
6f79d332	169
303fd988	170	src = pfn_to_phys(pfn) + offset;
ebbc9570	171	return copy_oldmem_iter(iter, src, csize);
60a0c68d MH	172	}
60a0c68d MH	173
23df79da	174	/*
6f79d332	175	* Remap "oldmem" for kdump
23df79da JW	176	*
	177	* For the kdump reserved memory this functions performs a swap operation:
	178	* [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
	179	*/
6f79d332 MH	180	static int remap_oldmem_pfn_range_kdump(struct vm_area_struct *vma,
	181	unsigned long from, unsigned long pfn,
	182	unsigned long size, pgprot_t prot)
23df79da JW	183	{
	184	unsigned long size_old;
	185	int rc;
	186
e9e7870f AE	187	if (pfn < oldmem_data.size >> PAGE_SHIFT) {
e9e7870f AE	188	size_old = min(size, oldmem_data.size - (pfn << PAGE_SHIFT));
23df79da	189	rc = remap_pfn_range(vma, from,
e9e7870f	190	pfn + (oldmem_data.start >> PAGE_SHIFT),
23df79da JW	191	size_old, prot);
	192	if (rc \|\| size == size_old)
	193	return rc;
	194	size -= size_old;
	195	from += size_old;
	196	pfn += size_old >> PAGE_SHIFT;
	197	}
	198	return remap_pfn_range(vma, from, pfn, size, prot);
	199	}
	200
6f79d332	201	/*
bd37b368	202	* Remap "oldmem" for zfcp/nvme dump
6f79d332	203	*
e657d8fe MH	204	* We only map available memory above HSA size. Memory below HSA size
e657d8fe MH	205	* is read on demand using the copy_oldmem_page() function.
6f79d332 MH	206	*/
	207	static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct *vma,
	208	unsigned long from,
	209	unsigned long pfn,
	210	unsigned long size, pgprot_t prot)
	211	{
37c5f6c8	212	unsigned long hsa_end = sclp.hsa_size;
6f79d332 MH	213	unsigned long size_hsa;
6f79d332 MH	214
e657d8fe MH	215	if (pfn < hsa_end >> PAGE_SHIFT) {
e657d8fe MH	216	size_hsa = min(size, hsa_end - (pfn << PAGE_SHIFT));
6f79d332 MH	217	if (size == size_hsa)
	218	return 0;
	219	size -= size_hsa;
	220	from += size_hsa;
	221	pfn += size_hsa >> PAGE_SHIFT;
	222	}
	223	return remap_pfn_range(vma, from, pfn, size, prot);
	224	}
	225
	226	/*
bd37b368	227	* Remap "oldmem" for kdump or zfcp/nvme dump
6f79d332 MH	228	*/
	229	int remap_oldmem_pfn_range(struct vm_area_struct *vma, unsigned long from,
	230	unsigned long pfn, unsigned long size, pgprot_t prot)
	231	{
e9e7870f	232	if (oldmem_data.start)
6f79d332 MH	233	return remap_oldmem_pfn_range_kdump(vma, from, pfn, size, prot);
	234	else
	235	return remap_oldmem_pfn_range_zfcpdump(vma, from, pfn, size,
	236	prot);
	237	}
	238
8cce437f PR	239	static const char *nt_name(Elf64_Word type)
	240	{
	241	const char *name = "LINUX";
	242
	243	if (type == NT_PRPSINFO \|\| type == NT_PRSTATUS \|\| type == NT_PRFPREG)
	244	name = KEXEC_CORE_NOTE_NAME;
	245	return name;
	246	}
	247
60a0c68d MH	248	/*
	249	* Initialize ELF note
	250	*/
1a2c5840 MS	251	static void nt_init_name(void buf, Elf64_Word type, void *desc, int d_len,
1a2c5840 MS	252	const char *name)
60a0c68d MH	253	{
	254	Elf64_Nhdr *note;
	255	u64 len;
	256
	257	note = (Elf64_Nhdr *)buf;
	258	note->n_namesz = strlen(name) + 1;
	259	note->n_descsz = d_len;
	260	note->n_type = type;
	261	len = sizeof(Elf64_Nhdr);
	262
	263	memcpy(buf + len, name, note->n_namesz);
	264	len = roundup(len + note->n_namesz, 4);
	265
	266	memcpy(buf + len, desc, note->n_descsz);
	267	len = roundup(len + note->n_descsz, 4);
	268
	269	return PTR_ADD(buf, len);
	270	}
	271
1a2c5840	272	static inline void nt_init(void buf, Elf64_Word type, void *desc, int d_len)
60a0c68d	273	{
8cce437f PR	274	return nt_init_name(buf, type, desc, d_len, nt_name(type));
	275	}
	276
	277	/*
	278	* Calculate the size of ELF note
	279	*/
	280	static size_t nt_size_name(int d_len, const char *name)
	281	{
	282	size_t size;
a4a81d8e	283
8cce437f PR	284	size = sizeof(Elf64_Nhdr);
	285	size += roundup(strlen(name) + 1, 4);
	286	size += roundup(d_len, 4);
	287
	288	return size;
	289	}
	290
	291	static inline size_t nt_size(Elf64_Word type, int d_len)
	292	{
	293	return nt_size_name(d_len, nt_name(type));
60a0c68d MH	294	}
	295
	296	/*
1a2c5840	297	* Fill ELF notes for one CPU with save area registers
60a0c68d	298	*/
1a2c5840	299	static void fill_cpu_elf_notes(void ptr, int cpu, struct save_area *sa)
60a0c68d	300	{
1a2c5840	301	struct elf_prstatus nt_prstatus;
60a0c68d MH	302	elf_fpregset_t nt_fpregset;
60a0c68d MH	303
1a2c5840 MS	304	/* Prepare prstatus note */
	305	memset(&nt_prstatus, 0, sizeof(nt_prstatus));
	306	memcpy(&nt_prstatus.pr_reg.gprs, sa->gprs, sizeof(sa->gprs));
	307	memcpy(&nt_prstatus.pr_reg.psw, sa->psw, sizeof(sa->psw));
	308	memcpy(&nt_prstatus.pr_reg.acrs, sa->acrs, sizeof(sa->acrs));
f2485a2d	309	nt_prstatus.common.pr_pid = cpu;
1a2c5840	310	/* Prepare fpregset (floating point) note */
60a0c68d	311	memset(&nt_fpregset, 0, sizeof(nt_fpregset));
1a2c5840 MS	312	memcpy(&nt_fpregset.fpc, &sa->fpc, sizeof(sa->fpc));
	313	memcpy(&nt_fpregset.fprs, &sa->fprs, sizeof(sa->fprs));
	314	/* Create ELF notes for the CPU */
	315	ptr = nt_init(ptr, NT_PRSTATUS, &nt_prstatus, sizeof(nt_prstatus));
	316	ptr = nt_init(ptr, NT_PRFPREG, &nt_fpregset, sizeof(nt_fpregset));
	317	ptr = nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer));
	318	ptr = nt_init(ptr, NT_S390_TODCMP, &sa->todcmp, sizeof(sa->todcmp));
	319	ptr = nt_init(ptr, NT_S390_TODPREG, &sa->todpreg, sizeof(sa->todpreg));
	320	ptr = nt_init(ptr, NT_S390_CTRS, &sa->ctrs, sizeof(sa->ctrs));
	321	ptr = nt_init(ptr, NT_S390_PREFIX, &sa->prefix, sizeof(sa->prefix));
	322	if (MACHINE_HAS_VX) {
	323	ptr = nt_init(ptr, NT_S390_VXRS_HIGH,
	324	&sa->vxrs_high, sizeof(sa->vxrs_high));
	325	ptr = nt_init(ptr, NT_S390_VXRS_LOW,
	326	&sa->vxrs_low, sizeof(sa->vxrs_low));
a62bc073	327	}
60a0c68d MH	328	return ptr;
	329	}
	330
8cce437f PR	331	/*
	332	* Calculate size of ELF notes per cpu
	333	*/
	334	static size_t get_cpu_elf_notes_size(void)
	335	{
	336	struct save_area *sa = NULL;
	337	size_t size;
	338
	339	size = nt_size(NT_PRSTATUS, sizeof(struct elf_prstatus));
	340	size += nt_size(NT_PRFPREG, sizeof(elf_fpregset_t));
	341	size += nt_size(NT_S390_TIMER, sizeof(sa->timer));
	342	size += nt_size(NT_S390_TODCMP, sizeof(sa->todcmp));
	343	size += nt_size(NT_S390_TODPREG, sizeof(sa->todpreg));
	344	size += nt_size(NT_S390_CTRS, sizeof(sa->ctrs));
	345	size += nt_size(NT_S390_PREFIX, sizeof(sa->prefix));
	346	if (MACHINE_HAS_VX) {
	347	size += nt_size(NT_S390_VXRS_HIGH, sizeof(sa->vxrs_high));
	348	size += nt_size(NT_S390_VXRS_LOW, sizeof(sa->vxrs_low));
	349	}
	350
	351	return size;
	352	}
	353
60a0c68d MH	354	/*
	355	* Initialize prpsinfo note (new kernel)
	356	*/
	357	static void nt_prpsinfo(void ptr)
	358	{
	359	struct elf_prpsinfo prpsinfo;
	360
	361	memset(&prpsinfo, 0, sizeof(prpsinfo));
	362	prpsinfo.pr_sname = 'R';
	363	strcpy(prpsinfo.pr_fname, "vmlinux");
1a2c5840	364	return nt_init(ptr, NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo));
60a0c68d MH	365	}
	366
	367	/*
4857d4bb	368	* Get vmcoreinfo using lowcore->vmcore_info (new kernel)
60a0c68d	369	*/
4857d4bb	370	static void get_vmcoreinfo_old(unsigned long size)
60a0c68d MH	371	{
60a0c68d MH	372	char nt_name[11], *vmcoreinfo;
303fd988	373	unsigned long addr;
60a0c68d	374	Elf64_Nhdr note;
60a0c68d	375
303fd988	376	if (copy_oldmem_kernel(&addr, __LC_VMCORE_INFO, sizeof(addr)))
4857d4bb	377	return NULL;
60a0c68d	378	memset(nt_name, 0, sizeof(nt_name));
df9694c7	379	if (copy_oldmem_kernel(&note, addr, sizeof(note)))
4857d4bb	380	return NULL;
df9694c7 MS	381	if (copy_oldmem_kernel(nt_name, addr + sizeof(note),
df9694c7 MS	382	sizeof(nt_name) - 1))
4857d4bb	383	return NULL;
2d2e7075	384	if (strcmp(nt_name, VMCOREINFO_NOTE_NAME) != 0)
4857d4bb	385	return NULL;
28b74653 PR	386	vmcoreinfo = kzalloc(note.n_descsz, GFP_KERNEL);
	387	if (!vmcoreinfo)
	388	return NULL;
2d2e7075 PR	389	if (copy_oldmem_kernel(vmcoreinfo, addr + 24, note.n_descsz)) {
2d2e7075 PR	390	kfree(vmcoreinfo);
4857d4bb	391	return NULL;
2d2e7075	392	}
4857d4bb MH	393	*size = note.n_descsz;
	394	return vmcoreinfo;
	395	}
	396
	397	/*
	398	* Initialize vmcoreinfo note (new kernel)
	399	*/
	400	static void nt_vmcoreinfo(void ptr)
	401	{
2d2e7075	402	const char *name = VMCOREINFO_NOTE_NAME;
4857d4bb MH	403	unsigned long size;
	404	void *vmcoreinfo;
	405
	406	vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
2d2e7075 PR	407	if (vmcoreinfo)
	408	return nt_init_name(ptr, 0, vmcoreinfo, size, name);
	409
	410	vmcoreinfo = get_vmcoreinfo_old(&size);
4857d4bb	411	if (!vmcoreinfo)
60a0c68d	412	return ptr;
2d2e7075 PR	413	ptr = nt_init_name(ptr, 0, vmcoreinfo, size, name);
	414	kfree(vmcoreinfo);
	415	return ptr;
60a0c68d MH	416	}
60a0c68d MH	417
8cce437f PR	418	static size_t nt_vmcoreinfo_size(void)
8cce437f PR	419	{
263b0e48 PR	420	const char *name = VMCOREINFO_NOTE_NAME;
	421	unsigned long size;
	422	void *vmcoreinfo;
8cce437f	423
263b0e48 PR	424	vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
	425	if (vmcoreinfo)
	426	return nt_size_name(size, name);
8cce437f	427
263b0e48 PR	428	vmcoreinfo = get_vmcoreinfo_old(&size);
263b0e48 PR	429	if (!vmcoreinfo)
8cce437f PR	430	return 0;
8cce437f PR	431
263b0e48 PR	432	kfree(vmcoreinfo);
263b0e48 PR	433	return nt_size_name(size, name);
8cce437f PR	434	}
8cce437f PR	435
dcc00b79 MH	436	/*
	437	* Initialize final note (needed for /proc/vmcore code)
	438	*/
	439	static void nt_final(void ptr)
	440	{
	441	Elf64_Nhdr *note;
	442
	443	note = (Elf64_Nhdr *) ptr;
	444	note->n_namesz = 0;
	445	note->n_descsz = 0;
	446	note->n_type = 0;
	447	return PTR_ADD(ptr, sizeof(Elf64_Nhdr));
	448	}
	449
60a0c68d MH	450	/*
	451	* Initialize ELF header (new kernel)
	452	*/
	453	static void ehdr_init(Elf64_Ehdr ehdr, int mem_chunk_cnt)
	454	{
	455	memset(ehdr, 0, sizeof(*ehdr));
	456	memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
	457	ehdr->e_ident[EI_CLASS] = ELFCLASS64;
	458	ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
	459	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
	460	memset(ehdr->e_ident + EI_PAD, 0, EI_NIDENT - EI_PAD);
	461	ehdr->e_type = ET_CORE;
	462	ehdr->e_machine = EM_S390;
	463	ehdr->e_version = EV_CURRENT;
	464	ehdr->e_phoff = sizeof(Elf64_Ehdr);
	465	ehdr->e_ehsize = sizeof(Elf64_Ehdr);
	466	ehdr->e_phentsize = sizeof(Elf64_Phdr);
	467	ehdr->e_phnum = mem_chunk_cnt + 1;
	468	return ehdr + 1;
	469	}
	470
	471	/*
	472	* Return CPU count for ELF header (new kernel)
	473	*/
	474	static int get_cpu_cnt(void)
	475	{
1a2c5840 MS	476	struct save_area *sa;
1a2c5840 MS	477	int cpus = 0;
60a0c68d	478
1a2c5840 MS	479	list_for_each_entry(sa, &dump_save_areas, list)
	480	if (sa->prefix != 0)
	481	cpus++;
60a0c68d MH	482	return cpus;
	483	}
	484
	485	/*
	486	* Return memory chunk count for ELF header (new kernel)
	487	*/
	488	static int get_mem_chunk_cnt(void)
	489	{
50be6345 PH	490	int cnt = 0;
	491	u64 idx;
	492
77649905	493	for_each_physmem_range(idx, &oldmem_type, NULL, NULL)
60a0c68d	494	cnt++;
60a0c68d MH	495	return cnt;
	496	}
	497
60a0c68d MH	498	/*
	499	* Initialize ELF loads (new kernel)
	500	*/
50be6345	501	static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
60a0c68d	502	{
50be6345 PH	503	phys_addr_t start, end;
50be6345 PH	504	u64 idx;
60a0c68d	505
77649905	506	for_each_physmem_range(idx, &oldmem_type, &start, &end) {
50be6345	507	phdr->p_filesz = end - start;
60a0c68d	508	phdr->p_type = PT_LOAD;
50be6345 PH	509	phdr->p_offset = start;
	510	phdr->p_vaddr = start;
	511	phdr->p_paddr = start;
	512	phdr->p_memsz = end - start;
60a0c68d MH	513	phdr->p_flags = PF_R \| PF_W \| PF_X;
	514	phdr->p_align = PAGE_SIZE;
	515	phdr++;
	516	}
60a0c68d MH	517	}
	518
	519	/*
	520	* Initialize notes (new kernel)
	521	*/
	522	static void notes_init(Elf64_Phdr phdr, void *ptr, u64 notes_offset)
	523	{
1a2c5840	524	struct save_area *sa;
60a0c68d	525	void *ptr_start = ptr;
1a2c5840	526	int cpu;
60a0c68d MH	527
	528	ptr = nt_prpsinfo(ptr);
	529
1a2c5840 MS	530	cpu = 1;
	531	list_for_each_entry(sa, &dump_save_areas, list)
	532	if (sa->prefix != 0)
	533	ptr = fill_cpu_elf_notes(ptr, cpu++, sa);
60a0c68d	534	ptr = nt_vmcoreinfo(ptr);
dcc00b79	535	ptr = nt_final(ptr);
60a0c68d MH	536	memset(phdr, 0, sizeof(*phdr));
60a0c68d MH	537	phdr->p_type = PT_NOTE;
97b0f6f9	538	phdr->p_offset = notes_offset;
60a0c68d MH	539	phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
	540	phdr->p_memsz = phdr->p_filesz;
	541	return ptr;
	542	}
	543
8cce437f PR	544	static size_t get_elfcorehdr_size(int mem_chunk_cnt)
	545	{
	546	size_t size;
	547
	548	size = sizeof(Elf64_Ehdr);
	549	/* PT_NOTES */
	550	size += sizeof(Elf64_Phdr);
	551	/* nt_prpsinfo */
	552	size += nt_size(NT_PRPSINFO, sizeof(struct elf_prpsinfo));
	553	/* regsets */
	554	size += get_cpu_cnt() * get_cpu_elf_notes_size();
	555	/* nt_vmcoreinfo */
	556	size += nt_vmcoreinfo_size();
	557	/* nt_final */
	558	size += sizeof(Elf64_Nhdr);
	559	/* PT_LOADS */
	560	size += mem_chunk_cnt * sizeof(Elf64_Phdr);
	561
	562	return size;
	563	}
	564
60a0c68d MH	565	/*
	566	* Create ELF core header (new kernel)
	567	*/
97b0f6f9	568	int elfcorehdr_alloc(unsigned long long addr, unsigned long long size)
60a0c68d MH	569	{
60a0c68d MH	570	Elf64_Phdr phdr_notes, phdr_loads;
f471c658	571	size_t alloc_size;
60a0c68d MH	572	int mem_chunk_cnt;
60a0c68d MH	573	void ptr, hdr;
60a0c68d MH	574	u64 hdr_off;
60a0c68d MH	575
bd37b368	576	/* If we are not in kdump or zfcp/nvme dump mode return */
e9e7870f	577	if (!oldmem_data.start && !is_ipl_type_dump())
97b0f6f9	578	return 0;
bd37b368 AE	579	/* If we cannot get HSA size for zfcp/nvme dump return error */
bd37b368 AE	580	if (is_ipl_type_dump() && !sclp.hsa_size)
e657d8fe	581	return -ENODEV;
50be6345 PH	582
50be6345 PH	583	/* For kdump, exclude previous crashkernel memory */
e9e7870f AE	584	if (oldmem_data.start) {
	585	oldmem_region.base = oldmem_data.start;
	586	oldmem_region.size = oldmem_data.size;
	587	oldmem_type.total_size = oldmem_data.size;
50be6345 PH	588	}
50be6345 PH	589
60a0c68d MH	590	mem_chunk_cnt = get_mem_chunk_cnt();
60a0c68d MH	591
8cce437f PR	592	alloc_size = get_elfcorehdr_size(mem_chunk_cnt);
8cce437f PR	593
28b74653 PR	594	hdr = kzalloc(alloc_size, GFP_KERNEL);
	595
	596	/* Without elfcorehdr /proc/vmcore cannot be created. Thus creating
	597	* a dump with this crash kernel will fail. Panic now to allow other
	598	* dump mechanisms to take over.
	599	*/
	600	if (!hdr)
	601	panic("s390 kdump allocating elfcorehdr failed");
	602
60a0c68d MH	603	/* Init elf header */
	604	ptr = ehdr_init(hdr, mem_chunk_cnt);
	605	/* Init program headers */
	606	phdr_notes = ptr;
	607	ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr));
	608	phdr_loads = ptr;
	609	ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
	610	/* Init notes */
	611	hdr_off = PTR_DIFF(ptr, hdr);
	612	ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
	613	/* Init loads */
	614	hdr_off = PTR_DIFF(ptr, hdr);
97b0f6f9 MH	615	loads_init(phdr_loads, hdr_off);
97b0f6f9 MH	616	*addr = (unsigned long long) hdr;
97b0f6f9 MH	617	*size = (unsigned long long) hdr_off;
	618	BUG_ON(elfcorehdr_size > alloc_size);
	619	return 0;
60a0c68d MH	620	}
	621
	622	/*
97b0f6f9	623	* Free ELF core header (new kernel)
60a0c68d	624	*/
97b0f6f9	625	void elfcorehdr_free(unsigned long long addr)
60a0c68d	626	{
97b0f6f9 MH	627	kfree((void *)(unsigned long)addr);
	628	}
	629
	630	/*
	631	* Read from ELF header
	632	*/
	633	ssize_t elfcorehdr_read(char buf, size_t count, u64 ppos)
	634	{
	635	void src = (void )(unsigned long)*ppos;
	636
97b0f6f9 MH	637	memcpy(buf, src, count);
	638	*ppos += count;
	639	return count;
60a0c68d MH	640	}
60a0c68d MH	641
97b0f6f9 MH	642	/*
	643	* Read from ELF notes data
	644	*/
	645	ssize_t elfcorehdr_read_notes(char buf, size_t count, u64 ppos)
	646	{
	647	void src = (void )(unsigned long)*ppos;
97b0f6f9	648
8a07dd02	649	memcpy(buf, src, count);
97b0f6f9 MH	650	*ppos += count;
	651	return count;
	652	}