[mirror_ubuntu-artful-kernel.git] / arch / s390 / kernel / crash_dump.c

/*
 * 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/module.h>
#include <linux/gfp.h>
#include <linux/slab.h>
#include <linux/bootmem.h>
#include <linux/elf.h>
#include <linux/memblock.h>
#include <asm/os_info.h>
#include <asm/elf.h>
#include <asm/ipl.h>
#include <asm/sclp.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,
};

struct dump_save_areas dump_save_areas;

/*
 * Return physical address for virtual address
 */
static inline void *load_real_addr(void *addr)
{
	unsigned long real_addr;

	asm volatile(
		   "	lra     %0,0(%1)\n"
		   "	jz	0f\n"
		   "	la	%0,0\n"
		   "0:"
		   : "=a" (real_addr) : "a" (addr) : "cc");
	return (void *)real_addr;
}

/*
 * Copy real to virtual or real memory
 */
static int copy_from_realmem(void *dest, void *src, size_t count)
{
	unsigned long size;

	if (!count)
		return 0;
	if (!is_vmalloc_or_module_addr(dest))
		return memcpy_real(dest, src, count);
	do {
		size = min(count, PAGE_SIZE - (__pa(dest) & ~PAGE_MASK));
		if (memcpy_real(load_real_addr(dest), src, size))
			return -EFAULT;
		count -= size;
		dest += size;
		src += size;
	} while (count);
	return 0;
}

/*
 * Copy one page from zfcpdump "oldmem"
 *
 * For pages below HSA size memory from the HSA is copied. Otherwise
 * real memory copy is used.
 */
static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
					 unsigned long src, int userbuf)
{
	int rc;

	if (src < sclp.hsa_size) {
		rc = memcpy_hsa(buf, src, csize, userbuf);
	} else {
		if (userbuf)
			rc = copy_to_user_real((void __force __user *) buf,
					       (void *) src, csize);
		else
			rc = memcpy_real(buf, (void *) src, csize);
	}
	return rc ? rc : csize;
}

/*
 * Copy one page from kdump "oldmem"
 *
 * For the kdump reserved memory this functions performs a swap operation:
 *  - [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE] is mapped to [0 - OLDMEM_SIZE].
 *  - [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
 */
static ssize_t copy_oldmem_page_kdump(char *buf, size_t csize,
				      unsigned long src, int userbuf)

{
	int rc;

	if (src < OLDMEM_SIZE)
		src += OLDMEM_BASE;
	else if (src > OLDMEM_BASE &&
		 src < OLDMEM_BASE + OLDMEM_SIZE)
		src -= OLDMEM_BASE;
	if (userbuf)
		rc = copy_to_user_real((void __force __user *) buf,
				       (void *) src, csize);
	else
		rc = copy_from_realmem(buf, (void *) src, csize);
	return (rc == 0) ? rc : csize;
}

/*
 * Copy one page from "oldmem"
 */
ssize_t copy_oldmem_page(unsigned long pfn, char *buf, size_t csize,
			 unsigned long offset, int userbuf)
{
	unsigned long src;

	if (!csize)
		return 0;
	src = (pfn << PAGE_SHIFT) + offset;
	if (OLDMEM_BASE)
		return copy_oldmem_page_kdump(buf, csize, src, userbuf);
	else
		return copy_oldmem_page_zfcpdump(buf, csize, src, userbuf);
}

/*
 * 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_SIZE >> PAGE_SHIFT) {
		size_old = min(size, OLDMEM_SIZE - (pfn << PAGE_SHIFT));
		rc = remap_pfn_range(vma, from,
				     pfn + (OLDMEM_BASE >> 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 zfcpdump
 *
 * 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 zfcpdump
 */
int remap_oldmem_pfn_range(struct vm_area_struct *vma, unsigned long from,
			   unsigned long pfn, unsigned long size, pgprot_t prot)
{
	if (OLDMEM_BASE)
		return remap_oldmem_pfn_range_kdump(vma, from, pfn, size, prot);
	else
		return remap_oldmem_pfn_range_zfcpdump(vma, from, pfn, size,
						       prot);
}

/*
 * Copy memory from old kernel
 */
int copy_from_oldmem(void *dest, void *src, size_t count)
{
	unsigned long copied = 0;
	int rc;

	if (OLDMEM_BASE) {
		if ((unsigned long) src < OLDMEM_SIZE) {
			copied = min(count, OLDMEM_SIZE - (unsigned long) src);
			rc = copy_from_realmem(dest, src + OLDMEM_BASE, copied);
			if (rc)
				return rc;
		}
	} else {
		unsigned long hsa_end = sclp.hsa_size;
		if ((unsigned long) src < hsa_end) {
			copied = min(count, hsa_end - (unsigned long) src);
			rc = memcpy_hsa(dest, (unsigned long) src, copied, 0);
			if (rc)
				return rc;
		}
	}
	return copy_from_realmem(dest + copied, src + copied, count - copied);
}

/*
 * Alloc memory and panic in case of ENOMEM
 */
static void *kzalloc_panic(int len)
{
	void *rc;

	rc = kzalloc(len, GFP_KERNEL);
	if (!rc)
		panic("s390 kdump kzalloc (%d) failed", len);
	return rc;
}

/*
 * Initialize ELF note
 */
static void *nt_init(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);
}

/*
 * Initialize prstatus note
 */
static void *nt_prstatus(void *ptr, struct save_area *sa)
{
	struct elf_prstatus nt_prstatus;
	static int cpu_nr = 1;

	memset(&nt_prstatus, 0, sizeof(nt_prstatus));
	memcpy(&nt_prstatus.pr_reg.gprs, sa->gp_regs, sizeof(sa->gp_regs));
	memcpy(&nt_prstatus.pr_reg.psw, sa->psw, sizeof(sa->psw));
	memcpy(&nt_prstatus.pr_reg.acrs, sa->acc_regs, sizeof(sa->acc_regs));
	nt_prstatus.pr_pid = cpu_nr;
	cpu_nr++;

	return nt_init(ptr, NT_PRSTATUS, &nt_prstatus, sizeof(nt_prstatus),
			 "CORE");
}

/*
 * Initialize fpregset (floating point) note
 */
static void *nt_fpregset(void *ptr, struct save_area *sa)
{
	elf_fpregset_t nt_fpregset;

	memset(&nt_fpregset, 0, sizeof(nt_fpregset));
	memcpy(&nt_fpregset.fpc, &sa->fp_ctrl_reg, sizeof(sa->fp_ctrl_reg));
	memcpy(&nt_fpregset.fprs, &sa->fp_regs, sizeof(sa->fp_regs));

	return nt_init(ptr, NT_PRFPREG, &nt_fpregset, sizeof(nt_fpregset),
		       "CORE");
}

/*
 * Initialize timer note
 */
static void *nt_s390_timer(void *ptr, struct save_area *sa)
{
	return nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer),
			 KEXEC_CORE_NOTE_NAME);
}

/*
 * Initialize TOD clock comparator note
 */
static void *nt_s390_tod_cmp(void *ptr, struct save_area *sa)
{
	return nt_init(ptr, NT_S390_TODCMP, &sa->clk_cmp,
		       sizeof(sa->clk_cmp), KEXEC_CORE_NOTE_NAME);
}

/*
 * Initialize TOD programmable register note
 */
static void *nt_s390_tod_preg(void *ptr, struct save_area *sa)
{
	return nt_init(ptr, NT_S390_TODPREG, &sa->tod_reg,
		       sizeof(sa->tod_reg), KEXEC_CORE_NOTE_NAME);
}

/*
 * Initialize control register note
 */
static void *nt_s390_ctrs(void *ptr, struct save_area *sa)
{
	return nt_init(ptr, NT_S390_CTRS, &sa->ctrl_regs,
		       sizeof(sa->ctrl_regs), KEXEC_CORE_NOTE_NAME);
}

/*
 * Initialize prefix register note
 */
static void *nt_s390_prefix(void *ptr, struct save_area *sa)
{
	return nt_init(ptr, NT_S390_PREFIX, &sa->pref_reg,
			 sizeof(sa->pref_reg), KEXEC_CORE_NOTE_NAME);
}

/*
 * Initialize vxrs high note (full 128 bit VX registers 16-31)
 */
static void *nt_s390_vx_high(void *ptr, __vector128 *vx_regs)
{
	return nt_init(ptr, NT_S390_VXRS_HIGH, &vx_regs[16],
		       16 * sizeof(__vector128), KEXEC_CORE_NOTE_NAME);
}

/*
 * Initialize vxrs low note (lower halves of VX registers 0-15)
 */
static void *nt_s390_vx_low(void *ptr, __vector128 *vx_regs)
{
	Elf64_Nhdr *note;
	u64 len;
	int i;

	note = (Elf64_Nhdr *)ptr;
	note->n_namesz = strlen(KEXEC_CORE_NOTE_NAME) + 1;
	note->n_descsz = 16 * 8;
	note->n_type = NT_S390_VXRS_LOW;
	len = sizeof(Elf64_Nhdr);

	memcpy(ptr + len, KEXEC_CORE_NOTE_NAME, note->n_namesz);
	len = roundup(len + note->n_namesz, 4);

	ptr += len;
	/* Copy lower halves of SIMD registers 0-15 */
	for (i = 0; i < 16; i++) {
		memcpy(ptr, &vx_regs[i].u[2], 8);
		ptr += 8;
	}
	return ptr;
}

/*
 * Fill ELF notes for one CPU with save area registers
 */
static void *fill_cpu_elf_notes(void *ptr, struct save_area *sa,
				__vector128 *vx_regs)
{
	ptr = nt_prstatus(ptr, sa);
	ptr = nt_fpregset(ptr, sa);
	ptr = nt_s390_timer(ptr, sa);
	ptr = nt_s390_tod_cmp(ptr, sa);
	ptr = nt_s390_tod_preg(ptr, sa);
	ptr = nt_s390_ctrs(ptr, sa);
	ptr = nt_s390_prefix(ptr, sa);
	if (MACHINE_HAS_VX && vx_regs) {
		ptr = nt_s390_vx_low(ptr, vx_regs);
		ptr = nt_s390_vx_high(ptr, vx_regs);
	}
	return ptr;
}

/*
 * 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),
		       KEXEC_CORE_NOTE_NAME);
}

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

	if (copy_from_oldmem(&addr, &S390_lowcore.vmcore_info, sizeof(addr)))
		return NULL;
	memset(nt_name, 0, sizeof(nt_name));
	if (copy_from_oldmem(&note, addr, sizeof(note)))
		return NULL;
	if (copy_from_oldmem(nt_name, addr + sizeof(note), sizeof(nt_name) - 1))
		return NULL;
	if (strcmp(nt_name, "VMCOREINFO") != 0)
		return NULL;
	vmcoreinfo = kzalloc_panic(note.n_descsz);
	if (copy_from_oldmem(vmcoreinfo, addr + 24, note.n_descsz))
		return NULL;
	*size = note.n_descsz;
	return vmcoreinfo;
}

/*
 * Initialize vmcoreinfo note (new kernel)
 */
static void *nt_vmcoreinfo(void *ptr)
{
	unsigned long size;
	void *vmcoreinfo;

	vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
	if (!vmcoreinfo)
		vmcoreinfo = get_vmcoreinfo_old(&size);
	if (!vmcoreinfo)
		return ptr;
	return nt_init(ptr, 0, vmcoreinfo, size, "VMCOREINFO");
}

/*
 * 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)
{
	int i, cpus = 0;

	for (i = 0; i < dump_save_areas.count; i++) {
		if (dump_save_areas.areas[i]->sa.pref_reg == 0)
			continue;
		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_mem_range(idx, &memblock.physmem, &oldmem_type, NUMA_NO_NODE,
			   MEMBLOCK_NONE, NULL, 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_mem_range(idx, &memblock.physmem, &oldmem_type, NUMA_NO_NODE,
			   MEMBLOCK_NONE, &start, &end, NULL) {
		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_ext *sa_ext;
	void *ptr_start = ptr;
	int i;

	ptr = nt_prpsinfo(ptr);

	for (i = 0; i < dump_save_areas.count; i++) {
		sa_ext = dump_save_areas.areas[i];
		if (sa_ext->sa.pref_reg == 0)
			continue;
		ptr = fill_cpu_elf_notes(ptr, &sa_ext->sa, sa_ext->vx_regs);
	}
	ptr = nt_vmcoreinfo(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;
}

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

	/* If we are not in kdump or zfcpdump mode return */
	if (!OLDMEM_BASE && ipl_info.type != IPL_TYPE_FCP_DUMP)
		return 0;
	/* If we cannot get HSA size for zfcpdump return error */
	if (ipl_info.type == IPL_TYPE_FCP_DUMP && !sclp.hsa_size)
		return -ENODEV;

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

	mem_chunk_cnt = get_mem_chunk_cnt();

	alloc_size = 0x1000 + get_cpu_cnt() * 0x4a0 +
		mem_chunk_cnt * sizeof(Elf64_Phdr);
	hdr = kzalloc_panic(alloc_size);
	/* 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
60a0c68d MH	1	/*
	2	* S390 kdump implementation
	3	*
	4	* Copyright IBM Corp. 2011
	5	* Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
	6	*/
	7
	8	#include <linux/crash_dump.h>
	9	#include <asm/lowcore.h>
	10	#include <linux/kernel.h>
	11	#include <linux/module.h>
	12	#include <linux/gfp.h>
	13	#include <linux/slab.h>
60a0c68d MH	14	#include <linux/bootmem.h>
60a0c68d MH	15	#include <linux/elf.h>
50be6345	16	#include <linux/memblock.h>
4857d4bb	17	#include <asm/os_info.h>
6b563d8c HC	18	#include <asm/elf.h>
6b563d8c HC	19	#include <asm/ipl.h>
6f79d332	20	#include <asm/sclp.h>
60a0c68d MH	21
	22	#define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
	23	#define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
	24	#define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
	25
50be6345 PH	26	static struct memblock_region oldmem_region;
	27
	28	static struct memblock_type oldmem_type = {
	29	.cnt = 1,
	30	.max = 1,
	31	.total_size = 0,
	32	.regions = &oldmem_region,
	33	};
	34
58952942 MH	35	struct dump_save_areas dump_save_areas;
58952942 MH	36
191a2fa0 MH	37	/*
	38	* Return physical address for virtual address
	39	*/
	40	static inline void load_real_addr(void addr)
	41	{
	42	unsigned long real_addr;
	43
	44	asm volatile(
	45	" lra %0,0(%1)\n"
	46	" jz 0f\n"
	47	" la %0,0\n"
	48	"0:"
	49	: "=a" (real_addr) : "a" (addr) : "cc");
	50	return (void *)real_addr;
	51	}
	52
	53	/*
4d3b0664	54	* Copy real to virtual or real memory
191a2fa0	55	*/
4d3b0664	56	static int copy_from_realmem(void dest, void src, size_t count)
191a2fa0	57	{
4d3b0664	58	unsigned long size;
4d3b0664 MH	59
	60	if (!count)
	61	return 0;
	62	if (!is_vmalloc_or_module_addr(dest))
	63	return memcpy_real(dest, src, count);
	64	do {
	65	size = min(count, PAGE_SIZE - (__pa(dest) & ~PAGE_MASK));
	66	if (memcpy_real(load_real_addr(dest), src, size))
	67	return -EFAULT;
	68	count -= size;
	69	dest += size;
	70	src += size;
	71	} while (count);
	72	return 0;
191a2fa0 MH	73	}
191a2fa0 MH	74
60a0c68d	75	/*
6f79d332 MH	76	* Copy one page from zfcpdump "oldmem"
6f79d332 MH	77	*
e657d8fe	78	* For pages below HSA size memory from the HSA is copied. Otherwise
6f79d332 MH	79	* real memory copy is used.
	80	*/
	81	static ssize_t copy_oldmem_page_zfcpdump(char *buf, size_t csize,
	82	unsigned long src, int userbuf)
	83	{
	84	int rc;
	85
37c5f6c8	86	if (src < sclp.hsa_size) {
6f79d332 MH	87	rc = memcpy_hsa(buf, src, csize, userbuf);
	88	} else {
	89	if (userbuf)
	90	rc = copy_to_user_real((void __force __user *) buf,
	91	(void *) src, csize);
	92	else
	93	rc = memcpy_real(buf, (void *) src, csize);
	94	}
	95	return rc ? rc : csize;
	96	}
	97
	98	/*
	99	* Copy one page from kdump "oldmem"
60a0c68d MH	100	*
	101	* For the kdump reserved memory this functions performs a swap operation:
	102	* - [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE] is mapped to [0 - OLDMEM_SIZE].
	103	* - [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
	104	*/
6f79d332 MH	105	static ssize_t copy_oldmem_page_kdump(char *buf, size_t csize,
	106	unsigned long src, int userbuf)
	107
60a0c68d	108	{
191a2fa0	109	int rc;
60a0c68d	110
60a0c68d MH	111	if (src < OLDMEM_SIZE)
	112	src += OLDMEM_BASE;
	113	else if (src > OLDMEM_BASE &&
	114	src < OLDMEM_BASE + OLDMEM_SIZE)
	115	src -= OLDMEM_BASE;
	116	if (userbuf)
191a2fa0 MH	117	rc = copy_to_user_real((void __force __user *) buf,
191a2fa0 MH	118	(void *) src, csize);
60a0c68d	119	else
4d3b0664	120	rc = copy_from_realmem(buf, (void *) src, csize);
6f79d332 MH	121	return (rc == 0) ? rc : csize;
	122	}
	123
	124	/*
	125	* Copy one page from "oldmem"
	126	*/
	127	ssize_t copy_oldmem_page(unsigned long pfn, char *buf, size_t csize,
	128	unsigned long offset, int userbuf)
	129	{
	130	unsigned long src;
	131
	132	if (!csize)
	133	return 0;
	134	src = (pfn << PAGE_SHIFT) + offset;
	135	if (OLDMEM_BASE)
	136	return copy_oldmem_page_kdump(buf, csize, src, userbuf);
	137	else
	138	return copy_oldmem_page_zfcpdump(buf, csize, src, userbuf);
60a0c68d MH	139	}
60a0c68d MH	140
23df79da	141	/*
6f79d332	142	* Remap "oldmem" for kdump
23df79da JW	143	*
	144	* For the kdump reserved memory this functions performs a swap operation:
	145	* [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
	146	*/
6f79d332 MH	147	static int remap_oldmem_pfn_range_kdump(struct vm_area_struct *vma,
	148	unsigned long from, unsigned long pfn,
	149	unsigned long size, pgprot_t prot)
23df79da JW	150	{
	151	unsigned long size_old;
	152	int rc;
	153
	154	if (pfn < OLDMEM_SIZE >> PAGE_SHIFT) {
	155	size_old = min(size, OLDMEM_SIZE - (pfn << PAGE_SHIFT));
	156	rc = remap_pfn_range(vma, from,
	157	pfn + (OLDMEM_BASE >> PAGE_SHIFT),
	158	size_old, prot);
	159	if (rc \|\| size == size_old)
	160	return rc;
	161	size -= size_old;
	162	from += size_old;
	163	pfn += size_old >> PAGE_SHIFT;
	164	}
	165	return remap_pfn_range(vma, from, pfn, size, prot);
	166	}
	167
6f79d332 MH	168	/*
	169	* Remap "oldmem" for zfcpdump
	170	*
e657d8fe MH	171	* We only map available memory above HSA size. Memory below HSA size
e657d8fe MH	172	* is read on demand using the copy_oldmem_page() function.
6f79d332 MH	173	*/
	174	static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct *vma,
	175	unsigned long from,
	176	unsigned long pfn,
	177	unsigned long size, pgprot_t prot)
	178	{
37c5f6c8	179	unsigned long hsa_end = sclp.hsa_size;
6f79d332 MH	180	unsigned long size_hsa;
6f79d332 MH	181
e657d8fe MH	182	if (pfn < hsa_end >> PAGE_SHIFT) {
e657d8fe MH	183	size_hsa = min(size, hsa_end - (pfn << PAGE_SHIFT));
6f79d332 MH	184	if (size == size_hsa)
	185	return 0;
	186	size -= size_hsa;
	187	from += size_hsa;
	188	pfn += size_hsa >> PAGE_SHIFT;
	189	}
	190	return remap_pfn_range(vma, from, pfn, size, prot);
	191	}
	192
	193	/*
	194	* Remap "oldmem" for kdump or zfcpdump
	195	*/
	196	int remap_oldmem_pfn_range(struct vm_area_struct *vma, unsigned long from,
	197	unsigned long pfn, unsigned long size, pgprot_t prot)
	198	{
	199	if (OLDMEM_BASE)
	200	return remap_oldmem_pfn_range_kdump(vma, from, pfn, size, prot);
	201	else
	202	return remap_oldmem_pfn_range_zfcpdump(vma, from, pfn, size,
	203	prot);
	204	}
	205
60a0c68d MH	206	/*
	207	* Copy memory from old kernel
	208	*/
4857d4bb	209	int copy_from_oldmem(void dest, void src, size_t count)
60a0c68d MH	210	{
	211	unsigned long copied = 0;
	212	int rc;
	213
6f79d332 MH	214	if (OLDMEM_BASE) {
	215	if ((unsigned long) src < OLDMEM_SIZE) {
	216	copied = min(count, OLDMEM_SIZE - (unsigned long) src);
4d3b0664	217	rc = copy_from_realmem(dest, src + OLDMEM_BASE, copied);
6f79d332 MH	218	if (rc)
	219	return rc;
	220	}
	221	} else {
37c5f6c8	222	unsigned long hsa_end = sclp.hsa_size;
e657d8fe MH	223	if ((unsigned long) src < hsa_end) {
e657d8fe MH	224	copied = min(count, hsa_end - (unsigned long) src);
6f79d332 MH	225	rc = memcpy_hsa(dest, (unsigned long) src, copied, 0);
	226	if (rc)
	227	return rc;
	228	}
60a0c68d	229	}
4d3b0664	230	return copy_from_realmem(dest + copied, src + copied, count - copied);
60a0c68d MH	231	}
	232
	233	/*
	234	* Alloc memory and panic in case of ENOMEM
	235	*/
	236	static void *kzalloc_panic(int len)
	237	{
	238	void *rc;
	239
	240	rc = kzalloc(len, GFP_KERNEL);
	241	if (!rc)
	242	panic("s390 kdump kzalloc (%d) failed", len);
	243	return rc;
	244	}
	245
60a0c68d MH	246	/*
	247	* Initialize ELF note
	248	*/
	249	static void nt_init(void buf, Elf64_Word type, void *desc, int d_len,
	250	const char *name)
	251	{
	252	Elf64_Nhdr *note;
	253	u64 len;
	254
	255	note = (Elf64_Nhdr *)buf;
	256	note->n_namesz = strlen(name) + 1;
	257	note->n_descsz = d_len;
	258	note->n_type = type;
	259	len = sizeof(Elf64_Nhdr);
	260
	261	memcpy(buf + len, name, note->n_namesz);
	262	len = roundup(len + note->n_namesz, 4);
	263
	264	memcpy(buf + len, desc, note->n_descsz);
	265	len = roundup(len + note->n_descsz, 4);
	266
	267	return PTR_ADD(buf, len);
	268	}
	269
	270	/*
	271	* Initialize prstatus note
	272	*/
	273	static void nt_prstatus(void ptr, struct save_area *sa)
	274	{
	275	struct elf_prstatus nt_prstatus;
	276	static int cpu_nr = 1;
	277
	278	memset(&nt_prstatus, 0, sizeof(nt_prstatus));
	279	memcpy(&nt_prstatus.pr_reg.gprs, sa->gp_regs, sizeof(sa->gp_regs));
	280	memcpy(&nt_prstatus.pr_reg.psw, sa->psw, sizeof(sa->psw));
	281	memcpy(&nt_prstatus.pr_reg.acrs, sa->acc_regs, sizeof(sa->acc_regs));
	282	nt_prstatus.pr_pid = cpu_nr;
	283	cpu_nr++;
	284
	285	return nt_init(ptr, NT_PRSTATUS, &nt_prstatus, sizeof(nt_prstatus),
	286	"CORE");
	287	}
	288
	289	/*
	290	* Initialize fpregset (floating point) note
	291	*/
	292	static void nt_fpregset(void ptr, struct save_area *sa)
	293	{
	294	elf_fpregset_t nt_fpregset;
	295
	296	memset(&nt_fpregset, 0, sizeof(nt_fpregset));
	297	memcpy(&nt_fpregset.fpc, &sa->fp_ctrl_reg, sizeof(sa->fp_ctrl_reg));
	298	memcpy(&nt_fpregset.fprs, &sa->fp_regs, sizeof(sa->fp_regs));
	299
	300	return nt_init(ptr, NT_PRFPREG, &nt_fpregset, sizeof(nt_fpregset),
	301	"CORE");
	302	}
	303
	304	/*
	305	* Initialize timer note
	306	*/
	307	static void nt_s390_timer(void ptr, struct save_area *sa)
	308	{
	309	return nt_init(ptr, NT_S390_TIMER, &sa->timer, sizeof(sa->timer),
310	KEXEC_CORE_NOTE_NAME);
311	}
312
313	/*
314	* Initialize TOD clock comparator note
315	*/
316	static void nt_s390_tod_cmp(void ptr, struct save_area *sa)
317	{
318	return nt_init(ptr, NT_S390_TODCMP, &sa->clk_cmp,
319	sizeof(sa->clk_cmp), KEXEC_CORE_NOTE_NAME);
320	}
321
322	/*
323	* Initialize TOD programmable register note
324	*/
325	static void nt_s390_tod_preg(void ptr, struct save_area *sa)
326	{
327	return nt_init(ptr, NT_S390_TODPREG, &sa->tod_reg,
328	sizeof(sa->tod_reg), KEXEC_CORE_NOTE_NAME);
329	}
330
331	/*
332	* Initialize control register note
333	*/
334	static void nt_s390_ctrs(void ptr, struct save_area *sa)
335	{
336	return nt_init(ptr, NT_S390_CTRS, &sa->ctrl_regs,
337	sizeof(sa->ctrl_regs), KEXEC_CORE_NOTE_NAME);
338	}
339
340	/*
341	* Initialize prefix register note
342	*/
343	static void nt_s390_prefix(void ptr, struct save_area *sa)
344	{
345	return nt_init(ptr, NT_S390_PREFIX, &sa->pref_reg,
346	sizeof(sa->pref_reg), KEXEC_CORE_NOTE_NAME);
347	}
348
a62bc073 MH	349	/*
	350	* Initialize vxrs high note (full 128 bit VX registers 16-31)
	351	*/
	352	static void nt_s390_vx_high(void ptr, __vector128 *vx_regs)
	353	{
	354	return nt_init(ptr, NT_S390_VXRS_HIGH, &vx_regs[16],
	355	16 * sizeof(__vector128), KEXEC_CORE_NOTE_NAME);
	356	}
	357
	358	/*
	359	* Initialize vxrs low note (lower halves of VX registers 0-15)
	360	*/
	361	static void nt_s390_vx_low(void ptr, __vector128 *vx_regs)
	362	{
	363	Elf64_Nhdr *note;
	364	u64 len;
	365	int i;
	366
	367	note = (Elf64_Nhdr *)ptr;
	368	note->n_namesz = strlen(KEXEC_CORE_NOTE_NAME) + 1;
	369	note->n_descsz = 16 * 8;
	370	note->n_type = NT_S390_VXRS_LOW;
	371	len = sizeof(Elf64_Nhdr);
	372
	373	memcpy(ptr + len, KEXEC_CORE_NOTE_NAME, note->n_namesz);
	374	len = roundup(len + note->n_namesz, 4);
	375
	376	ptr += len;
	377	/* Copy lower halves of SIMD registers 0-15 */
	378	for (i = 0; i < 16; i++) {
3c8e5105	379	memcpy(ptr, &vx_regs[i].u[2], 8);
a62bc073 MH	380	ptr += 8;
	381	}
	382	return ptr;
	383	}
	384
60a0c68d MH	385	/*
	386	* Fill ELF notes for one CPU with save area registers
	387	*/
8a07dd02 MS	388	static void fill_cpu_elf_notes(void ptr, struct save_area *sa,
8a07dd02 MS	389	__vector128 *vx_regs)
60a0c68d MH	390	{
	391	ptr = nt_prstatus(ptr, sa);
	392	ptr = nt_fpregset(ptr, sa);
	393	ptr = nt_s390_timer(ptr, sa);
	394	ptr = nt_s390_tod_cmp(ptr, sa);
	395	ptr = nt_s390_tod_preg(ptr, sa);
	396	ptr = nt_s390_ctrs(ptr, sa);
	397	ptr = nt_s390_prefix(ptr, sa);
a62bc073 MH	398	if (MACHINE_HAS_VX && vx_regs) {
	399	ptr = nt_s390_vx_low(ptr, vx_regs);
	400	ptr = nt_s390_vx_high(ptr, vx_regs);
	401	}
60a0c68d MH	402	return ptr;
	403	}
	404
	405	/*
	406	* Initialize prpsinfo note (new kernel)
	407	*/
	408	static void nt_prpsinfo(void ptr)
	409	{
	410	struct elf_prpsinfo prpsinfo;
	411
	412	memset(&prpsinfo, 0, sizeof(prpsinfo));
	413	prpsinfo.pr_sname = 'R';
	414	strcpy(prpsinfo.pr_fname, "vmlinux");
	415	return nt_init(ptr, NT_PRPSINFO, &prpsinfo, sizeof(prpsinfo),
	416	KEXEC_CORE_NOTE_NAME);
	417	}
	418
	419	/*
4857d4bb	420	* Get vmcoreinfo using lowcore->vmcore_info (new kernel)
60a0c68d	421	*/
4857d4bb	422	static void get_vmcoreinfo_old(unsigned long size)
60a0c68d MH	423	{
	424	char nt_name[11], *vmcoreinfo;
	425	Elf64_Nhdr note;
	426	void *addr;
	427
	428	if (copy_from_oldmem(&addr, &S390_lowcore.vmcore_info, sizeof(addr)))
4857d4bb	429	return NULL;
60a0c68d MH	430	memset(nt_name, 0, sizeof(nt_name));
60a0c68d MH	431	if (copy_from_oldmem(&note, addr, sizeof(note)))
4857d4bb	432	return NULL;
60a0c68d	433	if (copy_from_oldmem(nt_name, addr + sizeof(note), sizeof(nt_name) - 1))
4857d4bb	434	return NULL;
60a0c68d	435	if (strcmp(nt_name, "VMCOREINFO") != 0)
4857d4bb MH	436	return NULL;
4857d4bb MH	437	vmcoreinfo = kzalloc_panic(note.n_descsz);
60a0c68d	438	if (copy_from_oldmem(vmcoreinfo, addr + 24, note.n_descsz))
4857d4bb MH	439	return NULL;
	440	*size = note.n_descsz;
	441	return vmcoreinfo;
	442	}
	443
	444	/*
	445	* Initialize vmcoreinfo note (new kernel)
	446	*/
	447	static void nt_vmcoreinfo(void ptr)
	448	{
	449	unsigned long size;
	450	void *vmcoreinfo;
	451
	452	vmcoreinfo = os_info_old_entry(OS_INFO_VMCOREINFO, &size);
	453	if (!vmcoreinfo)
	454	vmcoreinfo = get_vmcoreinfo_old(&size);
	455	if (!vmcoreinfo)
60a0c68d	456	return ptr;
4857d4bb	457	return nt_init(ptr, 0, vmcoreinfo, size, "VMCOREINFO");
60a0c68d MH	458	}
	459
	460	/*
	461	* Initialize ELF header (new kernel)
	462	*/
	463	static void ehdr_init(Elf64_Ehdr ehdr, int mem_chunk_cnt)
	464	{
	465	memset(ehdr, 0, sizeof(*ehdr));
	466	memcpy(ehdr->e_ident, ELFMAG, SELFMAG);
	467	ehdr->e_ident[EI_CLASS] = ELFCLASS64;
	468	ehdr->e_ident[EI_DATA] = ELFDATA2MSB;
	469	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
	470	memset(ehdr->e_ident + EI_PAD, 0, EI_NIDENT - EI_PAD);
	471	ehdr->e_type = ET_CORE;
	472	ehdr->e_machine = EM_S390;
	473	ehdr->e_version = EV_CURRENT;
	474	ehdr->e_phoff = sizeof(Elf64_Ehdr);
	475	ehdr->e_ehsize = sizeof(Elf64_Ehdr);
	476	ehdr->e_phentsize = sizeof(Elf64_Phdr);
	477	ehdr->e_phnum = mem_chunk_cnt + 1;
	478	return ehdr + 1;
	479	}
	480
	481	/*
	482	* Return CPU count for ELF header (new kernel)
	483	*/
	484	static int get_cpu_cnt(void)
	485	{
	486	int i, cpus = 0;
	487
58952942	488	for (i = 0; i < dump_save_areas.count; i++) {
a62bc073	489	if (dump_save_areas.areas[i]->sa.pref_reg == 0)
60a0c68d MH	490	continue;
	491	cpus++;
	492	}
	493	return cpus;
	494	}
	495
	496	/*
	497	* Return memory chunk count for ELF header (new kernel)
	498	*/
	499	static int get_mem_chunk_cnt(void)
	500	{
50be6345 PH	501	int cnt = 0;
	502	u64 idx;
	503
3c4aac86 AK	504	for_each_mem_range(idx, &memblock.physmem, &oldmem_type, NUMA_NO_NODE,
3c4aac86 AK	505	MEMBLOCK_NONE, NULL, NULL, NULL)
60a0c68d	506	cnt++;
60a0c68d MH	507	return cnt;
	508	}
	509
60a0c68d MH	510	/*
	511	* Initialize ELF loads (new kernel)
	512	*/
50be6345	513	static void loads_init(Elf64_Phdr *phdr, u64 loads_offset)
60a0c68d	514	{
50be6345 PH	515	phys_addr_t start, end;
50be6345 PH	516	u64 idx;
60a0c68d	517
3c4aac86 AK	518	for_each_mem_range(idx, &memblock.physmem, &oldmem_type, NUMA_NO_NODE,
3c4aac86 AK	519	MEMBLOCK_NONE, &start, &end, NULL) {
50be6345	520	phdr->p_filesz = end - start;
60a0c68d	521	phdr->p_type = PT_LOAD;
50be6345 PH	522	phdr->p_offset = start;
	523	phdr->p_vaddr = start;
	524	phdr->p_paddr = start;
	525	phdr->p_memsz = end - start;
60a0c68d MH	526	phdr->p_flags = PF_R \| PF_W \| PF_X;
	527	phdr->p_align = PAGE_SIZE;
	528	phdr++;
	529	}
60a0c68d MH	530	}
	531
	532	/*
	533	* Initialize notes (new kernel)
	534	*/
	535	static void notes_init(Elf64_Phdr phdr, void *ptr, u64 notes_offset)
	536	{
a62bc073	537	struct save_area_ext *sa_ext;
60a0c68d MH	538	void *ptr_start = ptr;
	539	int i;
	540
	541	ptr = nt_prpsinfo(ptr);
	542
58952942	543	for (i = 0; i < dump_save_areas.count; i++) {
a62bc073 MH	544	sa_ext = dump_save_areas.areas[i];
a62bc073 MH	545	if (sa_ext->sa.pref_reg == 0)
60a0c68d	546	continue;
a62bc073	547	ptr = fill_cpu_elf_notes(ptr, &sa_ext->sa, sa_ext->vx_regs);
60a0c68d MH	548	}
	549	ptr = nt_vmcoreinfo(ptr);
	550	memset(phdr, 0, sizeof(*phdr));
	551	phdr->p_type = PT_NOTE;
97b0f6f9	552	phdr->p_offset = notes_offset;
60a0c68d MH	553	phdr->p_filesz = (unsigned long) PTR_SUB(ptr, ptr_start);
	554	phdr->p_memsz = phdr->p_filesz;
	555	return ptr;
	556	}
	557
	558	/*
	559	* Create ELF core header (new kernel)
	560	*/
97b0f6f9	561	int elfcorehdr_alloc(unsigned long long addr, unsigned long long size)
60a0c68d MH	562	{
	563	Elf64_Phdr phdr_notes, phdr_loads;
	564	int mem_chunk_cnt;
	565	void ptr, hdr;
	566	u32 alloc_size;
	567	u64 hdr_off;
	568
6f79d332 MH	569	/* If we are not in kdump or zfcpdump mode return */
6f79d332 MH	570	if (!OLDMEM_BASE && ipl_info.type != IPL_TYPE_FCP_DUMP)
97b0f6f9	571	return 0;
e657d8fe	572	/* If we cannot get HSA size for zfcpdump return error */
37c5f6c8	573	if (ipl_info.type == IPL_TYPE_FCP_DUMP && !sclp.hsa_size)
e657d8fe	574	return -ENODEV;
50be6345 PH	575
	576	/* For kdump, exclude previous crashkernel memory */
	577	if (OLDMEM_BASE) {
	578	oldmem_region.base = OLDMEM_BASE;
	579	oldmem_region.size = OLDMEM_SIZE;
	580	oldmem_type.total_size = OLDMEM_SIZE;
	581	}
	582
60a0c68d MH	583	mem_chunk_cnt = get_mem_chunk_cnt();
60a0c68d MH	584
a62bc073	585	alloc_size = 0x1000 + get_cpu_cnt() * 0x4a0 +
60a0c68d MH	586	mem_chunk_cnt * sizeof(Elf64_Phdr);
	587	hdr = kzalloc_panic(alloc_size);
	588	/* Init elf header */
	589	ptr = ehdr_init(hdr, mem_chunk_cnt);
	590	/* Init program headers */
	591	phdr_notes = ptr;
	592	ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr));
	593	phdr_loads = ptr;
	594	ptr = PTR_ADD(ptr, sizeof(Elf64_Phdr) * mem_chunk_cnt);
	595	/* Init notes */
	596	hdr_off = PTR_DIFF(ptr, hdr);
	597	ptr = notes_init(phdr_notes, ptr, ((unsigned long) hdr) + hdr_off);
	598	/* Init loads */
	599	hdr_off = PTR_DIFF(ptr, hdr);
97b0f6f9 MH	600	loads_init(phdr_loads, hdr_off);
97b0f6f9 MH	601	*addr = (unsigned long long) hdr;
97b0f6f9 MH	602	*size = (unsigned long long) hdr_off;
	603	BUG_ON(elfcorehdr_size > alloc_size);
	604	return 0;
60a0c68d MH	605	}
	606
	607	/*
97b0f6f9	608	* Free ELF core header (new kernel)
60a0c68d	609	*/
97b0f6f9	610	void elfcorehdr_free(unsigned long long addr)
60a0c68d	611	{
97b0f6f9 MH	612	kfree((void *)(unsigned long)addr);
	613	}
	614
	615	/*
	616	* Read from ELF header
	617	*/
	618	ssize_t elfcorehdr_read(char buf, size_t count, u64 ppos)
	619	{
	620	void src = (void )(unsigned long)*ppos;
	621
97b0f6f9 MH	622	memcpy(buf, src, count);
	623	*ppos += count;
	624	return count;
60a0c68d MH	625	}
60a0c68d MH	626
97b0f6f9 MH	627	/*
	628	* Read from ELF notes data
	629	*/
	630	ssize_t elfcorehdr_read_notes(char buf, size_t count, u64 ppos)
	631	{
	632	void src = (void )(unsigned long)*ppos;
97b0f6f9	633
8a07dd02	634	memcpy(buf, src, count);
97b0f6f9 MH	635	*ppos += count;
	636	return count;
	637	}