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