2 * S390 kdump implementation
4 * Copyright IBM Corp. 2011
5 * Author(s): Michael Holzheu <holzheu@linux.vnet.ibm.com>
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>
14 #include <linux/bootmem.h>
15 #include <linux/elf.h>
16 #include <asm/asm-offsets.h>
17 #include <linux/memblock.h>
18 #include <asm/os_info.h>
23 #define PTR_ADD(x, y) (((char *) (x)) + ((unsigned long) (y)))
24 #define PTR_SUB(x, y) (((char *) (x)) - ((unsigned long) (y)))
25 #define PTR_DIFF(x, y) ((unsigned long)(((char *) (x)) - ((unsigned long) (y))))
27 static struct memblock_region oldmem_region
;
29 static struct memblock_type oldmem_type
= {
33 .regions
= &oldmem_region
,
37 struct list_head list
;
49 __vector128 vxrs_high
[16];
52 static LIST_HEAD(dump_save_areas
);
55 * Allocate a save area
57 struct save_area
* __init
save_area_alloc(bool is_boot_cpu
)
61 sa
= (void *) memblock_alloc(sizeof(*sa
), 8);
65 list_add(&sa
->list
, &dump_save_areas
);
67 list_add_tail(&sa
->list
, &dump_save_areas
);
72 * Return the address of the save area for the boot CPU
74 struct save_area
* __init
save_area_boot_cpu(void)
76 if (list_empty(&dump_save_areas
))
78 return list_first_entry(&dump_save_areas
, struct save_area
, list
);
82 * Copy CPU registers into the save area
84 void __init
save_area_add_regs(struct save_area
*sa
, void *regs
)
88 lc
= (struct lowcore
*)(regs
- __LC_FPREGS_SAVE_AREA
);
89 memcpy(&sa
->psw
, &lc
->psw_save_area
, sizeof(sa
->psw
));
90 memcpy(&sa
->ctrs
, &lc
->cregs_save_area
, sizeof(sa
->ctrs
));
91 memcpy(&sa
->gprs
, &lc
->gpregs_save_area
, sizeof(sa
->gprs
));
92 memcpy(&sa
->acrs
, &lc
->access_regs_save_area
, sizeof(sa
->acrs
));
93 memcpy(&sa
->fprs
, &lc
->floating_pt_save_area
, sizeof(sa
->fprs
));
94 memcpy(&sa
->fpc
, &lc
->fpt_creg_save_area
, sizeof(sa
->fpc
));
95 memcpy(&sa
->prefix
, &lc
->prefixreg_save_area
, sizeof(sa
->prefix
));
96 memcpy(&sa
->todpreg
, &lc
->tod_progreg_save_area
, sizeof(sa
->todpreg
));
97 memcpy(&sa
->timer
, &lc
->cpu_timer_save_area
, sizeof(sa
->timer
));
98 memcpy(&sa
->todcmp
, &lc
->clock_comp_save_area
, sizeof(sa
->todcmp
));
102 * Copy vector registers into the save area
104 void __init
save_area_add_vxrs(struct save_area
*sa
, __vector128
*vxrs
)
108 /* Copy lower halves of vector registers 0-15 */
109 for (i
= 0; i
< 16; i
++)
110 memcpy(&sa
->vxrs_low
[i
], &vxrs
[i
].u
[2], 8);
111 /* Copy vector registers 16-31 */
112 memcpy(sa
->vxrs_high
, vxrs
+ 16, 16 * sizeof(__vector128
));
116 * Return physical address for virtual address
118 static inline void *load_real_addr(void *addr
)
120 unsigned long real_addr
;
127 : "=a" (real_addr
) : "a" (addr
) : "cc");
128 return (void *)real_addr
;
132 * Copy memory of the old, dumped system to a kernel space virtual address
134 int copy_oldmem_kernel(void *dst
, void *src
, size_t count
)
136 unsigned long from
, len
;
142 if (!OLDMEM_BASE
&& from
< sclp
.hsa_size
) {
143 /* Copy from zfcpdump HSA area */
144 len
= min(count
, sclp
.hsa_size
- from
);
145 rc
= memcpy_hsa_kernel(dst
, from
, len
);
149 /* Check for swapped kdump oldmem areas */
150 if (OLDMEM_BASE
&& from
- OLDMEM_BASE
< OLDMEM_SIZE
) {
152 len
= min(count
, OLDMEM_SIZE
- from
);
153 } else if (OLDMEM_BASE
&& from
< OLDMEM_SIZE
) {
154 len
= min(count
, OLDMEM_SIZE
- from
);
159 if (is_vmalloc_or_module_addr(dst
)) {
160 ra
= load_real_addr(dst
);
161 len
= min(PAGE_SIZE
- offset_in_page(ra
), len
);
165 if (memcpy_real(ra
, (void *) from
, len
))
176 * Copy memory of the old, dumped system to a user space virtual address
178 int copy_oldmem_user(void __user
*dst
, void *src
, size_t count
)
180 unsigned long from
, len
;
185 if (!OLDMEM_BASE
&& from
< sclp
.hsa_size
) {
186 /* Copy from zfcpdump HSA area */
187 len
= min(count
, sclp
.hsa_size
- from
);
188 rc
= memcpy_hsa_user(dst
, from
, len
);
192 /* Check for swapped kdump oldmem areas */
193 if (OLDMEM_BASE
&& from
- OLDMEM_BASE
< OLDMEM_SIZE
) {
195 len
= min(count
, OLDMEM_SIZE
- from
);
196 } else if (OLDMEM_BASE
&& from
< OLDMEM_SIZE
) {
197 len
= min(count
, OLDMEM_SIZE
- from
);
202 rc
= copy_to_user_real(dst
, (void *) from
, count
);
214 * Copy one page from "oldmem"
216 ssize_t
copy_oldmem_page(unsigned long pfn
, char *buf
, size_t csize
,
217 unsigned long offset
, int userbuf
)
224 src
= (void *) (pfn
<< PAGE_SHIFT
) + offset
;
226 rc
= copy_oldmem_user((void __force __user
*) buf
, src
, csize
);
228 rc
= copy_oldmem_kernel((void *) buf
, src
, csize
);
233 * Remap "oldmem" for kdump
235 * For the kdump reserved memory this functions performs a swap operation:
236 * [0 - OLDMEM_SIZE] is mapped to [OLDMEM_BASE - OLDMEM_BASE + OLDMEM_SIZE]
238 static int remap_oldmem_pfn_range_kdump(struct vm_area_struct
*vma
,
239 unsigned long from
, unsigned long pfn
,
240 unsigned long size
, pgprot_t prot
)
242 unsigned long size_old
;
245 if (pfn
< OLDMEM_SIZE
>> PAGE_SHIFT
) {
246 size_old
= min(size
, OLDMEM_SIZE
- (pfn
<< PAGE_SHIFT
));
247 rc
= remap_pfn_range(vma
, from
,
248 pfn
+ (OLDMEM_BASE
>> PAGE_SHIFT
),
250 if (rc
|| size
== size_old
)
254 pfn
+= size_old
>> PAGE_SHIFT
;
256 return remap_pfn_range(vma
, from
, pfn
, size
, prot
);
260 * Remap "oldmem" for zfcpdump
262 * We only map available memory above HSA size. Memory below HSA size
263 * is read on demand using the copy_oldmem_page() function.
265 static int remap_oldmem_pfn_range_zfcpdump(struct vm_area_struct
*vma
,
268 unsigned long size
, pgprot_t prot
)
270 unsigned long hsa_end
= sclp
.hsa_size
;
271 unsigned long size_hsa
;
273 if (pfn
< hsa_end
>> PAGE_SHIFT
) {
274 size_hsa
= min(size
, hsa_end
- (pfn
<< PAGE_SHIFT
));
275 if (size
== size_hsa
)
279 pfn
+= size_hsa
>> PAGE_SHIFT
;
281 return remap_pfn_range(vma
, from
, pfn
, size
, prot
);
285 * Remap "oldmem" for kdump or zfcpdump
287 int remap_oldmem_pfn_range(struct vm_area_struct
*vma
, unsigned long from
,
288 unsigned long pfn
, unsigned long size
, pgprot_t prot
)
291 return remap_oldmem_pfn_range_kdump(vma
, from
, pfn
, size
, prot
);
293 return remap_oldmem_pfn_range_zfcpdump(vma
, from
, pfn
, size
,
298 * Alloc memory and panic in case of ENOMEM
300 static void *kzalloc_panic(int len
)
304 rc
= kzalloc(len
, GFP_KERNEL
);
306 panic("s390 kdump kzalloc (%d) failed", len
);
311 * Initialize ELF note
313 static void *nt_init_name(void *buf
, Elf64_Word type
, void *desc
, int d_len
,
319 note
= (Elf64_Nhdr
*)buf
;
320 note
->n_namesz
= strlen(name
) + 1;
321 note
->n_descsz
= d_len
;
323 len
= sizeof(Elf64_Nhdr
);
325 memcpy(buf
+ len
, name
, note
->n_namesz
);
326 len
= roundup(len
+ note
->n_namesz
, 4);
328 memcpy(buf
+ len
, desc
, note
->n_descsz
);
329 len
= roundup(len
+ note
->n_descsz
, 4);
331 return PTR_ADD(buf
, len
);
334 static inline void *nt_init(void *buf
, Elf64_Word type
, void *desc
, int d_len
)
336 return nt_init_name(buf
, type
, desc
, d_len
, KEXEC_CORE_NOTE_NAME
);
340 * Fill ELF notes for one CPU with save area registers
342 static void *fill_cpu_elf_notes(void *ptr
, int cpu
, struct save_area
*sa
)
344 struct elf_prstatus nt_prstatus
;
345 elf_fpregset_t nt_fpregset
;
347 /* Prepare prstatus note */
348 memset(&nt_prstatus
, 0, sizeof(nt_prstatus
));
349 memcpy(&nt_prstatus
.pr_reg
.gprs
, sa
->gprs
, sizeof(sa
->gprs
));
350 memcpy(&nt_prstatus
.pr_reg
.psw
, sa
->psw
, sizeof(sa
->psw
));
351 memcpy(&nt_prstatus
.pr_reg
.acrs
, sa
->acrs
, sizeof(sa
->acrs
));
352 nt_prstatus
.pr_pid
= cpu
;
353 /* Prepare fpregset (floating point) note */
354 memset(&nt_fpregset
, 0, sizeof(nt_fpregset
));
355 memcpy(&nt_fpregset
.fpc
, &sa
->fpc
, sizeof(sa
->fpc
));
356 memcpy(&nt_fpregset
.fprs
, &sa
->fprs
, sizeof(sa
->fprs
));
357 /* Create ELF notes for the CPU */
358 ptr
= nt_init(ptr
, NT_PRSTATUS
, &nt_prstatus
, sizeof(nt_prstatus
));
359 ptr
= nt_init(ptr
, NT_PRFPREG
, &nt_fpregset
, sizeof(nt_fpregset
));
360 ptr
= nt_init(ptr
, NT_S390_TIMER
, &sa
->timer
, sizeof(sa
->timer
));
361 ptr
= nt_init(ptr
, NT_S390_TODCMP
, &sa
->todcmp
, sizeof(sa
->todcmp
));
362 ptr
= nt_init(ptr
, NT_S390_TODPREG
, &sa
->todpreg
, sizeof(sa
->todpreg
));
363 ptr
= nt_init(ptr
, NT_S390_CTRS
, &sa
->ctrs
, sizeof(sa
->ctrs
));
364 ptr
= nt_init(ptr
, NT_S390_PREFIX
, &sa
->prefix
, sizeof(sa
->prefix
));
365 if (MACHINE_HAS_VX
) {
366 ptr
= nt_init(ptr
, NT_S390_VXRS_HIGH
,
367 &sa
->vxrs_high
, sizeof(sa
->vxrs_high
));
368 ptr
= nt_init(ptr
, NT_S390_VXRS_LOW
,
369 &sa
->vxrs_low
, sizeof(sa
->vxrs_low
));
375 * Initialize prpsinfo note (new kernel)
377 static void *nt_prpsinfo(void *ptr
)
379 struct elf_prpsinfo prpsinfo
;
381 memset(&prpsinfo
, 0, sizeof(prpsinfo
));
382 prpsinfo
.pr_sname
= 'R';
383 strcpy(prpsinfo
.pr_fname
, "vmlinux");
384 return nt_init(ptr
, NT_PRPSINFO
, &prpsinfo
, sizeof(prpsinfo
));
388 * Get vmcoreinfo using lowcore->vmcore_info (new kernel)
390 static void *get_vmcoreinfo_old(unsigned long *size
)
392 char nt_name
[11], *vmcoreinfo
;
396 if (copy_oldmem_kernel(&addr
, &S390_lowcore
.vmcore_info
, sizeof(addr
)))
398 memset(nt_name
, 0, sizeof(nt_name
));
399 if (copy_oldmem_kernel(¬e
, addr
, sizeof(note
)))
401 if (copy_oldmem_kernel(nt_name
, addr
+ sizeof(note
),
402 sizeof(nt_name
) - 1))
404 if (strcmp(nt_name
, "VMCOREINFO") != 0)
406 vmcoreinfo
= kzalloc_panic(note
.n_descsz
);
407 if (copy_oldmem_kernel(vmcoreinfo
, addr
+ 24, note
.n_descsz
))
409 *size
= note
.n_descsz
;
414 * Initialize vmcoreinfo note (new kernel)
416 static void *nt_vmcoreinfo(void *ptr
)
421 vmcoreinfo
= os_info_old_entry(OS_INFO_VMCOREINFO
, &size
);
423 vmcoreinfo
= get_vmcoreinfo_old(&size
);
426 return nt_init_name(ptr
, 0, vmcoreinfo
, size
, "VMCOREINFO");
430 * Initialize ELF header (new kernel)
432 static void *ehdr_init(Elf64_Ehdr
*ehdr
, int mem_chunk_cnt
)
434 memset(ehdr
, 0, sizeof(*ehdr
));
435 memcpy(ehdr
->e_ident
, ELFMAG
, SELFMAG
);
436 ehdr
->e_ident
[EI_CLASS
] = ELFCLASS64
;
437 ehdr
->e_ident
[EI_DATA
] = ELFDATA2MSB
;
438 ehdr
->e_ident
[EI_VERSION
] = EV_CURRENT
;
439 memset(ehdr
->e_ident
+ EI_PAD
, 0, EI_NIDENT
- EI_PAD
);
440 ehdr
->e_type
= ET_CORE
;
441 ehdr
->e_machine
= EM_S390
;
442 ehdr
->e_version
= EV_CURRENT
;
443 ehdr
->e_phoff
= sizeof(Elf64_Ehdr
);
444 ehdr
->e_ehsize
= sizeof(Elf64_Ehdr
);
445 ehdr
->e_phentsize
= sizeof(Elf64_Phdr
);
446 ehdr
->e_phnum
= mem_chunk_cnt
+ 1;
451 * Return CPU count for ELF header (new kernel)
453 static int get_cpu_cnt(void)
455 struct save_area
*sa
;
458 list_for_each_entry(sa
, &dump_save_areas
, list
)
465 * Return memory chunk count for ELF header (new kernel)
467 static int get_mem_chunk_cnt(void)
472 for_each_mem_range(idx
, &memblock
.physmem
, &oldmem_type
, NUMA_NO_NODE
,
473 MEMBLOCK_NONE
, NULL
, NULL
, NULL
)
479 * Initialize ELF loads (new kernel)
481 static void loads_init(Elf64_Phdr
*phdr
, u64 loads_offset
)
483 phys_addr_t start
, end
;
486 for_each_mem_range(idx
, &memblock
.physmem
, &oldmem_type
, NUMA_NO_NODE
,
487 MEMBLOCK_NONE
, &start
, &end
, NULL
) {
488 phdr
->p_filesz
= end
- start
;
489 phdr
->p_type
= PT_LOAD
;
490 phdr
->p_offset
= start
;
491 phdr
->p_vaddr
= start
;
492 phdr
->p_paddr
= start
;
493 phdr
->p_memsz
= end
- start
;
494 phdr
->p_flags
= PF_R
| PF_W
| PF_X
;
495 phdr
->p_align
= PAGE_SIZE
;
501 * Initialize notes (new kernel)
503 static void *notes_init(Elf64_Phdr
*phdr
, void *ptr
, u64 notes_offset
)
505 struct save_area
*sa
;
506 void *ptr_start
= ptr
;
509 ptr
= nt_prpsinfo(ptr
);
512 list_for_each_entry(sa
, &dump_save_areas
, list
)
514 ptr
= fill_cpu_elf_notes(ptr
, cpu
++, sa
);
515 ptr
= nt_vmcoreinfo(ptr
);
516 memset(phdr
, 0, sizeof(*phdr
));
517 phdr
->p_type
= PT_NOTE
;
518 phdr
->p_offset
= notes_offset
;
519 phdr
->p_filesz
= (unsigned long) PTR_SUB(ptr
, ptr_start
);
520 phdr
->p_memsz
= phdr
->p_filesz
;
525 * Create ELF core header (new kernel)
527 int elfcorehdr_alloc(unsigned long long *addr
, unsigned long long *size
)
529 Elf64_Phdr
*phdr_notes
, *phdr_loads
;
535 /* If we are not in kdump or zfcpdump mode return */
536 if (!OLDMEM_BASE
&& ipl_info
.type
!= IPL_TYPE_FCP_DUMP
)
538 /* If we cannot get HSA size for zfcpdump return error */
539 if (ipl_info
.type
== IPL_TYPE_FCP_DUMP
&& !sclp
.hsa_size
)
542 /* For kdump, exclude previous crashkernel memory */
544 oldmem_region
.base
= OLDMEM_BASE
;
545 oldmem_region
.size
= OLDMEM_SIZE
;
546 oldmem_type
.total_size
= OLDMEM_SIZE
;
549 mem_chunk_cnt
= get_mem_chunk_cnt();
551 alloc_size
= 0x1000 + get_cpu_cnt() * 0x4a0 +
552 mem_chunk_cnt
* sizeof(Elf64_Phdr
);
553 hdr
= kzalloc_panic(alloc_size
);
554 /* Init elf header */
555 ptr
= ehdr_init(hdr
, mem_chunk_cnt
);
556 /* Init program headers */
558 ptr
= PTR_ADD(ptr
, sizeof(Elf64_Phdr
));
560 ptr
= PTR_ADD(ptr
, sizeof(Elf64_Phdr
) * mem_chunk_cnt
);
562 hdr_off
= PTR_DIFF(ptr
, hdr
);
563 ptr
= notes_init(phdr_notes
, ptr
, ((unsigned long) hdr
) + hdr_off
);
565 hdr_off
= PTR_DIFF(ptr
, hdr
);
566 loads_init(phdr_loads
, hdr_off
);
567 *addr
= (unsigned long long) hdr
;
568 *size
= (unsigned long long) hdr_off
;
569 BUG_ON(elfcorehdr_size
> alloc_size
);
574 * Free ELF core header (new kernel)
576 void elfcorehdr_free(unsigned long long addr
)
578 kfree((void *)(unsigned long)addr
);
582 * Read from ELF header
584 ssize_t
elfcorehdr_read(char *buf
, size_t count
, u64
*ppos
)
586 void *src
= (void *)(unsigned long)*ppos
;
588 memcpy(buf
, src
, count
);
594 * Read from ELF notes data
596 ssize_t
elfcorehdr_read_notes(char *buf
, size_t count
, u64
*ppos
)
598 void *src
= (void *)(unsigned long)*ppos
;
600 memcpy(buf
, src
, count
);