1/* 2 * zcore module to export memory content and register sets for creating system 3 * dumps on SCSI disks (zfcpdump). The "zcore/mem" debugfs file shows the same 4 * dump format as s390 standalone dumps. 5 * 6 * For more information please refer to Documentation/s390/zfcpdump.txt 7 * 8 * Copyright IBM Corp. 2003,2007 9 * Author(s): Michael Holzheu 10 */ 11 12#include <linux/init.h> 13#include <linux/miscdevice.h> 14#include <linux/utsname.h> 15#include <linux/debugfs.h> 16#include <asm/ipl.h> 17#include <asm/sclp.h> 18#include <asm/setup.h> 19#include <asm/sigp.h> 20#include <asm/uaccess.h> 21#include <asm/debug.h> 22#include <asm/processor.h> 23#include <asm/irqflags.h> 24#include "sclp.h" 25 26#define TRACE(x...) debug_sprintf_event(zcore_dbf, 1, x) 27#define MSG(x...) printk( KERN_ALERT x ) 28#define ERROR_MSG(x...) printk ( KERN_ALERT "DUMP: " x ) 29 30#define TO_USER 0 31#define TO_KERNEL 1 32 33enum arch_id { 34 ARCH_S390 = 0, 35 ARCH_S390X = 1, 36}; 37 38/* dump system info */ 39 40struct sys_info { 41 enum arch_id arch; 42 unsigned long sa_base; 43 u32 sa_size; 44 int cpu_map[NR_CPUS]; 45 unsigned long mem_size; 46 union save_area lc_mask; 47}; 48 49static struct sys_info sys_info; 50static struct debug_info *zcore_dbf; 51static int hsa_available; 52static struct dentry *zcore_dir; 53static struct dentry *zcore_file; 54 55/* 56 * Copy memory from HSA to kernel or user memory (not reentrant): 57 * 58 * @dest: Kernel or user buffer where memory should be copied to 59 * @src: Start address within HSA where data should be copied 60 * @count: Size of buffer, which should be copied 61 * @mode: Either TO_KERNEL or TO_USER 62 */ 63static int memcpy_hsa(void *dest, unsigned long src, size_t count, int mode) 64{ 65 int offs, blk_num; 66 static char buf[PAGE_SIZE] __attribute__((__aligned__(PAGE_SIZE))); 67 68 if (count == 0) 69 return 0; 70 71 /* copy first block */ 72 offs = 0; 73 if ((src % PAGE_SIZE) != 0) { 74 blk_num = src / PAGE_SIZE + 2; 75 if (sclp_sdias_copy(buf, blk_num, 1)) { 76 TRACE("sclp_sdias_copy() failed\n"); 77 return -EIO; 78 } 79 offs = min((PAGE_SIZE - (src % PAGE_SIZE)), count); 80 if (mode == TO_USER) { 81 if (copy_to_user((__force __user void*) dest, 82 buf + (src % PAGE_SIZE), offs)) 83 return -EFAULT; 84 } else 85 memcpy(dest, buf + (src % PAGE_SIZE), offs); 86 } 87 if (offs == count) 88 goto out; 89 90 /* copy middle */ 91 for (; (offs + PAGE_SIZE) <= count; offs += PAGE_SIZE) { 92 blk_num = (src + offs) / PAGE_SIZE + 2; 93 if (sclp_sdias_copy(buf, blk_num, 1)) { 94 TRACE("sclp_sdias_copy() failed\n"); 95 return -EIO; 96 } 97 if (mode == TO_USER) { 98 if (copy_to_user((__force __user void*) dest + offs, 99 buf, PAGE_SIZE)) 100 return -EFAULT; 101 } else 102 memcpy(dest + offs, buf, PAGE_SIZE); 103 } 104 if (offs == count) 105 goto out; 106 107 /* copy last block */ 108 blk_num = (src + offs) / PAGE_SIZE + 2; 109 if (sclp_sdias_copy(buf, blk_num, 1)) { 110 TRACE("sclp_sdias_copy() failed\n"); 111 return -EIO; 112 } 113 if (mode == TO_USER) { 114 if (copy_to_user((__force __user void*) dest + offs, buf, 115 PAGE_SIZE)) 116 return -EFAULT; 117 } else 118 memcpy(dest + offs, buf, count - offs); 119out: 120 return 0; 121} 122 123static int memcpy_hsa_user(void __user *dest, unsigned long src, size_t count) 124{ 125 return memcpy_hsa((void __force *) dest, src, count, TO_USER); 126} 127 128static int memcpy_hsa_kernel(void *dest, unsigned long src, size_t count) 129{ 130 return memcpy_hsa(dest, src, count, TO_KERNEL); 131} 132 133static int memcpy_real(void *dest, unsigned long src, size_t count) 134{ 135 unsigned long flags; 136 int rc = -EFAULT; 137 register unsigned long _dest asm("2") = (unsigned long) dest; 138 register unsigned long _len1 asm("3") = (unsigned long) count; 139 register unsigned long _src asm("4") = src; 140 register unsigned long _len2 asm("5") = (unsigned long) count; 141 142 if (count == 0) 143 return 0; 144 flags = __raw_local_irq_stnsm(0xf8); /* switch to real mode */ 145 asm volatile ( 146 "0: mvcle %1,%2,0x0\n" 147 "1: jo 0b\n" 148 " lhi %0,0x0\n" 149 "2:\n" 150 EX_TABLE(1b,2b) 151 : "+d" (rc) 152 : "d" (_dest), "d" (_src), "d" (_len1), "d" (_len2) 153 : "cc", "memory"); 154 __raw_local_irq_ssm(flags); 155 156 return rc; 157} 158 159static int memcpy_real_user(__user void *dest, unsigned long src, size_t count) 160{ 161 static char buf[4096]; 162 int offs = 0, size; 163 164 while (offs < count) { 165 size = min(sizeof(buf), count - offs); 166 if (memcpy_real(buf, src + offs, size)) 167 return -EFAULT; 168 if (copy_to_user(dest + offs, buf, size)) 169 return -EFAULT; 170 offs += size; 171 } 172 return 0; 173} 174 175#ifdef __s390x__ 176/* 177 * Convert s390x (64 bit) cpu info to s390 (32 bit) cpu info 178 */ 179static void __init s390x_to_s390_regs(union save_area *out, union save_area *in, 180 int cpu) 181{ 182 int i; 183 184 for (i = 0; i < 16; i++) { 185 out->s390.gp_regs[i] = in->s390x.gp_regs[i] & 0x00000000ffffffff; 186 out->s390.acc_regs[i] = in->s390x.acc_regs[i]; 187 out->s390.ctrl_regs[i] = 188 in->s390x.ctrl_regs[i] & 0x00000000ffffffff; 189 } 190 /* locore for 31 bit has only space for fpregs 0,2,4,6 */ 191 out->s390.fp_regs[0] = in->s390x.fp_regs[0]; 192 out->s390.fp_regs[1] = in->s390x.fp_regs[2]; 193 out->s390.fp_regs[2] = in->s390x.fp_regs[4]; 194 out->s390.fp_regs[3] = in->s390x.fp_regs[6]; 195 memcpy(&(out->s390.psw[0]), &(in->s390x.psw[0]), 4); 196 out->s390.psw[1] |= 0x8; /* set bit 12 */ 197 memcpy(&(out->s390.psw[4]),&(in->s390x.psw[12]), 4); 198 out->s390.psw[4] |= 0x80; /* set (31bit) addressing bit */ 199 out->s390.pref_reg = in->s390x.pref_reg; 200 out->s390.timer = in->s390x.timer; 201 out->s390.clk_cmp = in->s390x.clk_cmp; 202} 203 204static void __init s390x_to_s390_save_areas(void) 205{ 206 int i = 1; 207 static union save_area tmp; 208 209 while (zfcpdump_save_areas[i]) { 210 s390x_to_s390_regs(&tmp, zfcpdump_save_areas[i], i); 211 memcpy(zfcpdump_save_areas[i], &tmp, sizeof(tmp)); 212 i++; 213 } 214} 215 216#endif /* __s390x__ */ 217 218static int __init init_cpu_info(enum arch_id arch) 219{ 220 union save_area *sa; 221 222 /* get info for boot cpu from lowcore, stored in the HSA */ 223 224 sa = kmalloc(sizeof(*sa), GFP_KERNEL); 225 if (!sa) { 226 ERROR_MSG("kmalloc failed: %s: %i\n",__FUNCTION__, __LINE__); 227 return -ENOMEM; 228 } 229 if (memcpy_hsa_kernel(sa, sys_info.sa_base, sys_info.sa_size) < 0) { 230 ERROR_MSG("could not copy from HSA\n"); 231 kfree(sa); 232 return -EIO; 233 } 234 zfcpdump_save_areas[0] = sa; 235 236#ifdef __s390x__ 237 /* convert s390x regs to s390, if we are dumping an s390 Linux */ 238 239 if (arch == ARCH_S390) 240 s390x_to_s390_save_areas(); 241#endif 242 243 return 0; 244} 245 246static DEFINE_MUTEX(zcore_mutex); 247 248#define DUMP_VERSION 0x3 249#define DUMP_MAGIC 0xa8190173618f23fdULL 250#define DUMP_ARCH_S390X 2 251#define DUMP_ARCH_S390 1 252#define HEADER_SIZE 4096 253 254/* dump header dumped according to s390 crash dump format */ 255 256struct zcore_header { 257 u64 magic; 258 u32 version; 259 u32 header_size; 260 u32 dump_level; 261 u32 page_size; 262 u64 mem_size; 263 u64 mem_start; 264 u64 mem_end; 265 u32 num_pages; 266 u32 pad1; 267 u64 tod; 268 cpuid_t cpu_id; 269 u32 arch_id; 270 u32 volnr; 271 u32 build_arch; 272 u64 rmem_size; 273 char pad2[4016]; 274} __attribute__((packed,__aligned__(16))); 275 276static struct zcore_header zcore_header = { 277 .magic = DUMP_MAGIC, 278 .version = DUMP_VERSION, 279 .header_size = 4096, 280 .dump_level = 0, 281 .page_size = PAGE_SIZE, 282 .mem_start = 0, 283#ifdef __s390x__ 284 .build_arch = DUMP_ARCH_S390X, 285#else 286 .build_arch = DUMP_ARCH_S390, 287#endif 288}; 289 290/* 291 * Copy lowcore info to buffer. Use map in order to copy only register parts. 292 * 293 * @buf: User buffer 294 * @sa: Pointer to save area 295 * @sa_off: Offset in save area to copy 296 * @len: Number of bytes to copy 297 */ 298static int copy_lc(void __user *buf, void *sa, int sa_off, int len) 299{ 300 int i; 301 char *lc_mask = (char*)&sys_info.lc_mask; 302 303 for (i = 0; i < len; i++) { 304 if (!lc_mask[i + sa_off]) 305 continue; 306 if (copy_to_user(buf + i, sa + sa_off + i, 1)) 307 return -EFAULT; 308 } 309 return 0; 310} 311 312/* 313 * Copy lowcores info to memory, if necessary 314 * 315 * @buf: User buffer 316 * @addr: Start address of buffer in dump memory 317 * @count: Size of buffer 318 */ 319static int zcore_add_lc(char __user *buf, unsigned long start, size_t count) 320{ 321 unsigned long end; 322 int i = 0; 323 324 if (count == 0) 325 return 0; 326 327 end = start + count; 328 while (zfcpdump_save_areas[i]) { 329 unsigned long cp_start, cp_end; /* copy range */ 330 unsigned long sa_start, sa_end; /* save area range */ 331 unsigned long prefix; 332 unsigned long sa_off, len, buf_off; 333 334 if (sys_info.arch == ARCH_S390) 335 prefix = zfcpdump_save_areas[i]->s390.pref_reg; 336 else 337 prefix = zfcpdump_save_areas[i]->s390x.pref_reg; 338 339 sa_start = prefix + sys_info.sa_base; 340 sa_end = prefix + sys_info.sa_base + sys_info.sa_size; 341 342 if ((end < sa_start) || (start > sa_end)) 343 goto next; 344 cp_start = max(start, sa_start); 345 cp_end = min(end, sa_end); 346 347 buf_off = cp_start - start; 348 sa_off = cp_start - sa_start; 349 len = cp_end - cp_start; 350 351 TRACE("copy_lc for: %lx\n", start); 352 if (copy_lc(buf + buf_off, zfcpdump_save_areas[i], sa_off, len)) 353 return -EFAULT; 354next: 355 i++; 356 } 357 return 0; 358} 359 360/* 361 * Read routine for zcore character device 362 * First 4K are dump header 363 * Next 32MB are HSA Memory 364 * Rest is read from absolute Memory 365 */ 366static ssize_t zcore_read(struct file *file, char __user *buf, size_t count, 367 loff_t *ppos) 368{ 369 unsigned long mem_start; /* Start address in memory */ 370 size_t mem_offs; /* Offset in dump memory */ 371 size_t hdr_count; /* Size of header part of output buffer */ 372 size_t size; 373 int rc; 374 375 mutex_lock(&zcore_mutex); 376 377 if (*ppos > (sys_info.mem_size + HEADER_SIZE)) { 378 rc = -EINVAL; 379 goto fail; 380 } 381 382 count = min(count, (size_t) (sys_info.mem_size + HEADER_SIZE - *ppos)); 383 384 /* Copy dump header */ 385 if (*ppos < HEADER_SIZE) { 386 size = min(count, (size_t) (HEADER_SIZE - *ppos)); 387 if (copy_to_user(buf, &zcore_header + *ppos, size)) { 388 rc = -EFAULT; 389 goto fail; 390 } 391 hdr_count = size; 392 mem_start = 0; 393 } else { 394 hdr_count = 0; 395 mem_start = *ppos - HEADER_SIZE; 396 } 397 398 mem_offs = 0; 399 400 /* Copy from HSA data */ 401 if (*ppos < (ZFCPDUMP_HSA_SIZE + HEADER_SIZE)) { 402 size = min((count - hdr_count), (size_t) (ZFCPDUMP_HSA_SIZE 403 - mem_start)); 404 rc = memcpy_hsa_user(buf + hdr_count, mem_start, size); 405 if (rc) 406 goto fail; 407 408 mem_offs += size; 409 } 410 411 /* Copy from real mem */ 412 size = count - mem_offs - hdr_count; 413 rc = memcpy_real_user(buf + hdr_count + mem_offs, mem_start + mem_offs, 414 size); 415 if (rc) 416 goto fail; 417 418 /* 419 * Since s390 dump analysis tools like lcrash or crash 420 * expect register sets in the prefix pages of the cpus, 421 * we copy them into the read buffer, if necessary. 422 * buf + hdr_count: Start of memory part of output buffer 423 * mem_start: Start memory address to copy from 424 * count - hdr_count: Size of memory area to copy 425 */ 426 if (zcore_add_lc(buf + hdr_count, mem_start, count - hdr_count)) { 427 rc = -EFAULT; 428 goto fail; 429 } 430 *ppos += count; 431fail: 432 mutex_unlock(&zcore_mutex); 433 return (rc < 0) ? rc : count; 434} 435 436static int zcore_open(struct inode *inode, struct file *filp) 437{ 438 if (!hsa_available) 439 return -ENODATA; 440 else 441 return capable(CAP_SYS_RAWIO) ? 0 : -EPERM; 442} 443 444static int zcore_release(struct inode *inode, struct file *filep) 445{ 446 diag308(DIAG308_REL_HSA, NULL); 447 hsa_available = 0; 448 return 0; 449} 450 451static loff_t zcore_lseek(struct file *file, loff_t offset, int orig) 452{ 453 loff_t rc; 454 455 mutex_lock(&zcore_mutex); 456 switch (orig) { 457 case 0: 458 file->f_pos = offset; 459 rc = file->f_pos; 460 break; 461 case 1: 462 file->f_pos += offset; 463 rc = file->f_pos; 464 break; 465 default: 466 rc = -EINVAL; 467 } 468 mutex_unlock(&zcore_mutex); 469 return rc; 470} 471 472static struct file_operations zcore_fops = { 473 .owner = THIS_MODULE, 474 .llseek = zcore_lseek, 475 .read = zcore_read, 476 .open = zcore_open, 477 .release = zcore_release, 478}; 479 480 481static void __init set_s390_lc_mask(union save_area *map) 482{ 483 memset(&map->s390.ext_save, 0xff, sizeof(map->s390.ext_save)); 484 memset(&map->s390.timer, 0xff, sizeof(map->s390.timer)); 485 memset(&map->s390.clk_cmp, 0xff, sizeof(map->s390.clk_cmp)); 486 memset(&map->s390.psw, 0xff, sizeof(map->s390.psw)); 487 memset(&map->s390.pref_reg, 0xff, sizeof(map->s390.pref_reg)); 488 memset(&map->s390.acc_regs, 0xff, sizeof(map->s390.acc_regs)); 489 memset(&map->s390.fp_regs, 0xff, sizeof(map->s390.fp_regs)); 490 memset(&map->s390.gp_regs, 0xff, sizeof(map->s390.gp_regs)); 491 memset(&map->s390.ctrl_regs, 0xff, sizeof(map->s390.ctrl_regs)); 492} 493 494static void __init set_s390x_lc_mask(union save_area *map) 495{ 496 memset(&map->s390x.fp_regs, 0xff, sizeof(map->s390x.fp_regs)); 497 memset(&map->s390x.gp_regs, 0xff, sizeof(map->s390x.gp_regs)); 498 memset(&map->s390x.psw, 0xff, sizeof(map->s390x.psw)); 499 memset(&map->s390x.pref_reg, 0xff, sizeof(map->s390x.pref_reg)); 500 memset(&map->s390x.fp_ctrl_reg, 0xff, sizeof(map->s390x.fp_ctrl_reg)); 501 memset(&map->s390x.tod_reg, 0xff, sizeof(map->s390x.tod_reg)); 502 memset(&map->s390x.timer, 0xff, sizeof(map->s390x.timer)); 503 memset(&map->s390x.clk_cmp, 0xff, sizeof(map->s390x.clk_cmp)); 504 memset(&map->s390x.acc_regs, 0xff, sizeof(map->s390x.acc_regs)); 505 memset(&map->s390x.ctrl_regs, 0xff, sizeof(map->s390x.ctrl_regs)); 506} 507 508/* 509 * Initialize dump globals for a given architecture 510 */ 511static int __init sys_info_init(enum arch_id arch) 512{ 513 switch (arch) { 514 case ARCH_S390X: 515 MSG("DETECTED 'S390X (64 bit) OS'\n"); 516 sys_info.sa_base = SAVE_AREA_BASE_S390X; 517 sys_info.sa_size = sizeof(struct save_area_s390x); 518 set_s390x_lc_mask(&sys_info.lc_mask); 519 break; 520 case ARCH_S390: 521 MSG("DETECTED 'S390 (32 bit) OS'\n"); 522 sys_info.sa_base = SAVE_AREA_BASE_S390; 523 sys_info.sa_size = sizeof(struct save_area_s390); 524 set_s390_lc_mask(&sys_info.lc_mask); 525 break; 526 default: 527 ERROR_MSG("unknown architecture 0x%x.\n",arch); 528 return -EINVAL; 529 } 530 sys_info.arch = arch; 531 if (init_cpu_info(arch)) { 532 ERROR_MSG("get cpu info failed\n"); 533 return -ENOMEM; 534 } 535 sys_info.mem_size = real_memory_size; 536 537 return 0; 538} 539 540static int __init check_sdias(void) 541{ 542 int rc, act_hsa_size; 543 544 rc = sclp_sdias_blk_count(); 545 if (rc < 0) { 546 ERROR_MSG("Could not determine HSA size\n"); 547 return rc; 548 } 549 act_hsa_size = (rc - 1) * PAGE_SIZE; 550 if (act_hsa_size < ZFCPDUMP_HSA_SIZE) { 551 ERROR_MSG("HSA size too small: %i\n", act_hsa_size); 552 return -EINVAL; 553 } 554 return 0; 555} 556 557static void __init zcore_header_init(int arch, struct zcore_header *hdr) 558{ 559 if (arch == ARCH_S390X) 560 hdr->arch_id = DUMP_ARCH_S390X; 561 else 562 hdr->arch_id = DUMP_ARCH_S390; 563 hdr->mem_size = sys_info.mem_size; 564 hdr->rmem_size = sys_info.mem_size; 565 hdr->mem_end = sys_info.mem_size; 566 hdr->num_pages = sys_info.mem_size / PAGE_SIZE; 567 hdr->tod = get_clock(); 568 get_cpu_id(&hdr->cpu_id); 569} 570 571static int __init zcore_init(void) 572{ 573 unsigned char arch; 574 int rc; 575 576 if (ipl_info.type != IPL_TYPE_FCP_DUMP) 577 return -ENODATA; 578 579 zcore_dbf = debug_register("zcore", 4, 1, 4 * sizeof(long)); 580 debug_register_view(zcore_dbf, &debug_sprintf_view); 581 debug_set_level(zcore_dbf, 6); 582 583 TRACE("devno: %x\n", ipl_info.data.fcp.dev_id.devno); 584 TRACE("wwpn: %llx\n", (unsigned long long) ipl_info.data.fcp.wwpn); 585 TRACE("lun: %llx\n", (unsigned long long) ipl_info.data.fcp.lun); 586 587 rc = sclp_sdias_init(); 588 if (rc) 589 goto fail; 590 591 rc = check_sdias(); 592 if (rc) { 593 ERROR_MSG("Dump initialization failed\n"); 594 goto fail; 595 } 596 597 rc = memcpy_hsa_kernel(&arch, __LC_AR_MODE_ID, 1); 598 if (rc) { 599 ERROR_MSG("sdial memcpy for arch id failed\n"); 600 goto fail; 601 } 602 603#ifndef __s390x__ 604 if (arch == ARCH_S390X) { 605 ERROR_MSG("32 bit dumper can't dump 64 bit system!\n"); 606 rc = -EINVAL; 607 goto fail; 608 } 609#endif 610 611 rc = sys_info_init(arch); 612 if (rc) { 613 ERROR_MSG("arch init failed\n"); 614 goto fail; 615 } 616 617 zcore_header_init(arch, &zcore_header); 618 619 zcore_dir = debugfs_create_dir("zcore" , NULL); 620 if (!zcore_dir) { 621 rc = -ENOMEM; 622 goto fail; 623 } 624 zcore_file = debugfs_create_file("mem", S_IRUSR, zcore_dir, NULL, 625 &zcore_fops); 626 if (!zcore_file) { 627 debugfs_remove(zcore_dir); 628 rc = -ENOMEM; 629 goto fail; 630 } 631 hsa_available = 1; 632 return 0; 633 634fail: 635 diag308(DIAG308_REL_HSA, NULL); 636 return rc; 637} 638 639static void __exit zcore_exit(void) 640{ 641 debug_unregister(zcore_dbf); 642 sclp_sdias_exit(); 643 diag308(DIAG308_REL_HSA, NULL); 644} 645 646MODULE_AUTHOR("Copyright IBM Corp. 2003,2007"); 647MODULE_DESCRIPTION("zcore module for zfcpdump support"); 648MODULE_LICENSE("GPL"); 649 650subsys_initcall(zcore_init); 651module_exit(zcore_exit); 652