1 /* 2 * ipl/reipl/dump support for Linux on s390. 3 * 4 * Copyright IBM Corp. 2005, 2012 5 * Author(s): Michael Holzheu <holzheu@de.ibm.com> 6 * Heiko Carstens <heiko.carstens@de.ibm.com> 7 * Volker Sameske <sameske@de.ibm.com> 8 */ 9 10 #include <linux/types.h> 11 #include <linux/module.h> 12 #include <linux/device.h> 13 #include <linux/delay.h> 14 #include <linux/reboot.h> 15 #include <linux/ctype.h> 16 #include <linux/fs.h> 17 #include <linux/gfp.h> 18 #include <linux/crash_dump.h> 19 #include <linux/debug_locks.h> 20 #include <asm/ipl.h> 21 #include <asm/smp.h> 22 #include <asm/setup.h> 23 #include <asm/cpcmd.h> 24 #include <asm/cio.h> 25 #include <asm/ebcdic.h> 26 #include <asm/reset.h> 27 #include <asm/sclp.h> 28 #include <asm/checksum.h> 29 #include <asm/debug.h> 30 #include <asm/os_info.h> 31 #include "entry.h" 32 33 #define IPL_PARM_BLOCK_VERSION 0 34 35 #define IPL_UNKNOWN_STR "unknown" 36 #define IPL_CCW_STR "ccw" 37 #define IPL_FCP_STR "fcp" 38 #define IPL_FCP_DUMP_STR "fcp_dump" 39 #define IPL_NSS_STR "nss" 40 41 #define DUMP_CCW_STR "ccw" 42 #define DUMP_FCP_STR "fcp" 43 #define DUMP_NONE_STR "none" 44 45 /* 46 * Four shutdown trigger types are supported: 47 * - panic 48 * - halt 49 * - power off 50 * - reipl 51 * - restart 52 */ 53 #define ON_PANIC_STR "on_panic" 54 #define ON_HALT_STR "on_halt" 55 #define ON_POFF_STR "on_poff" 56 #define ON_REIPL_STR "on_reboot" 57 #define ON_RESTART_STR "on_restart" 58 59 struct shutdown_action; 60 struct shutdown_trigger { 61 char *name; 62 struct shutdown_action *action; 63 }; 64 65 /* 66 * The following shutdown action types are supported: 67 */ 68 #define SHUTDOWN_ACTION_IPL_STR "ipl" 69 #define SHUTDOWN_ACTION_REIPL_STR "reipl" 70 #define SHUTDOWN_ACTION_DUMP_STR "dump" 71 #define SHUTDOWN_ACTION_VMCMD_STR "vmcmd" 72 #define SHUTDOWN_ACTION_STOP_STR "stop" 73 #define SHUTDOWN_ACTION_DUMP_REIPL_STR "dump_reipl" 74 75 struct shutdown_action { 76 char *name; 77 void (*fn) (struct shutdown_trigger *trigger); 78 int (*init) (void); 79 int init_rc; 80 }; 81 82 static char *ipl_type_str(enum ipl_type type) 83 { 84 switch (type) { 85 case IPL_TYPE_CCW: 86 return IPL_CCW_STR; 87 case IPL_TYPE_FCP: 88 return IPL_FCP_STR; 89 case IPL_TYPE_FCP_DUMP: 90 return IPL_FCP_DUMP_STR; 91 case IPL_TYPE_NSS: 92 return IPL_NSS_STR; 93 case IPL_TYPE_UNKNOWN: 94 default: 95 return IPL_UNKNOWN_STR; 96 } 97 } 98 99 enum dump_type { 100 DUMP_TYPE_NONE = 1, 101 DUMP_TYPE_CCW = 2, 102 DUMP_TYPE_FCP = 4, 103 }; 104 105 static char *dump_type_str(enum dump_type type) 106 { 107 switch (type) { 108 case DUMP_TYPE_NONE: 109 return DUMP_NONE_STR; 110 case DUMP_TYPE_CCW: 111 return DUMP_CCW_STR; 112 case DUMP_TYPE_FCP: 113 return DUMP_FCP_STR; 114 default: 115 return NULL; 116 } 117 } 118 119 /* 120 * Must be in data section since the bss section 121 * is not cleared when these are accessed. 122 */ 123 static u16 ipl_devno __attribute__((__section__(".data"))) = 0; 124 u32 ipl_flags __attribute__((__section__(".data"))) = 0; 125 126 enum ipl_method { 127 REIPL_METHOD_CCW_CIO, 128 REIPL_METHOD_CCW_DIAG, 129 REIPL_METHOD_CCW_VM, 130 REIPL_METHOD_FCP_RO_DIAG, 131 REIPL_METHOD_FCP_RW_DIAG, 132 REIPL_METHOD_FCP_RO_VM, 133 REIPL_METHOD_FCP_DUMP, 134 REIPL_METHOD_NSS, 135 REIPL_METHOD_NSS_DIAG, 136 REIPL_METHOD_DEFAULT, 137 }; 138 139 enum dump_method { 140 DUMP_METHOD_NONE, 141 DUMP_METHOD_CCW_CIO, 142 DUMP_METHOD_CCW_DIAG, 143 DUMP_METHOD_CCW_VM, 144 DUMP_METHOD_FCP_DIAG, 145 }; 146 147 static int diag308_set_works = 0; 148 149 static struct ipl_parameter_block ipl_block; 150 151 static int reipl_capabilities = IPL_TYPE_UNKNOWN; 152 153 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN; 154 static enum ipl_method reipl_method = REIPL_METHOD_DEFAULT; 155 static struct ipl_parameter_block *reipl_block_fcp; 156 static struct ipl_parameter_block *reipl_block_ccw; 157 static struct ipl_parameter_block *reipl_block_nss; 158 static struct ipl_parameter_block *reipl_block_actual; 159 160 static int dump_capabilities = DUMP_TYPE_NONE; 161 static enum dump_type dump_type = DUMP_TYPE_NONE; 162 static enum dump_method dump_method = DUMP_METHOD_NONE; 163 static struct ipl_parameter_block *dump_block_fcp; 164 static struct ipl_parameter_block *dump_block_ccw; 165 166 static struct sclp_ipl_info sclp_ipl_info; 167 168 int diag308(unsigned long subcode, void *addr) 169 { 170 register unsigned long _addr asm("0") = (unsigned long) addr; 171 register unsigned long _rc asm("1") = 0; 172 173 asm volatile( 174 " diag %0,%2,0x308\n" 175 "0:\n" 176 EX_TABLE(0b,0b) 177 : "+d" (_addr), "+d" (_rc) 178 : "d" (subcode) : "cc", "memory"); 179 return _rc; 180 } 181 EXPORT_SYMBOL_GPL(diag308); 182 183 /* SYSFS */ 184 185 #define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value) \ 186 static ssize_t sys_##_prefix##_##_name##_show(struct kobject *kobj, \ 187 struct kobj_attribute *attr, \ 188 char *page) \ 189 { \ 190 return sprintf(page, _format, _value); \ 191 } \ 192 static struct kobj_attribute sys_##_prefix##_##_name##_attr = \ 193 __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL); 194 195 #define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value) \ 196 static ssize_t sys_##_prefix##_##_name##_show(struct kobject *kobj, \ 197 struct kobj_attribute *attr, \ 198 char *page) \ 199 { \ 200 return sprintf(page, _fmt_out, \ 201 (unsigned long long) _value); \ 202 } \ 203 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj, \ 204 struct kobj_attribute *attr, \ 205 const char *buf, size_t len) \ 206 { \ 207 unsigned long long value; \ 208 if (sscanf(buf, _fmt_in, &value) != 1) \ 209 return -EINVAL; \ 210 _value = value; \ 211 return len; \ 212 } \ 213 static struct kobj_attribute sys_##_prefix##_##_name##_attr = \ 214 __ATTR(_name,(S_IRUGO | S_IWUSR), \ 215 sys_##_prefix##_##_name##_show, \ 216 sys_##_prefix##_##_name##_store); 217 218 #define DEFINE_IPL_ATTR_STR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)\ 219 static ssize_t sys_##_prefix##_##_name##_show(struct kobject *kobj, \ 220 struct kobj_attribute *attr, \ 221 char *page) \ 222 { \ 223 return sprintf(page, _fmt_out, _value); \ 224 } \ 225 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj, \ 226 struct kobj_attribute *attr, \ 227 const char *buf, size_t len) \ 228 { \ 229 strncpy(_value, buf, sizeof(_value) - 1); \ 230 strim(_value); \ 231 return len; \ 232 } \ 233 static struct kobj_attribute sys_##_prefix##_##_name##_attr = \ 234 __ATTR(_name,(S_IRUGO | S_IWUSR), \ 235 sys_##_prefix##_##_name##_show, \ 236 sys_##_prefix##_##_name##_store); 237 238 static void make_attrs_ro(struct attribute **attrs) 239 { 240 while (*attrs) { 241 (*attrs)->mode = S_IRUGO; 242 attrs++; 243 } 244 } 245 246 /* 247 * ipl section 248 */ 249 250 static __init enum ipl_type get_ipl_type(void) 251 { 252 struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START; 253 254 if (ipl_flags & IPL_NSS_VALID) 255 return IPL_TYPE_NSS; 256 if (!(ipl_flags & IPL_DEVNO_VALID)) 257 return IPL_TYPE_UNKNOWN; 258 if (!(ipl_flags & IPL_PARMBLOCK_VALID)) 259 return IPL_TYPE_CCW; 260 if (ipl->hdr.version > IPL_MAX_SUPPORTED_VERSION) 261 return IPL_TYPE_UNKNOWN; 262 if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP) 263 return IPL_TYPE_UNKNOWN; 264 if (ipl->ipl_info.fcp.opt == DIAG308_IPL_OPT_DUMP) 265 return IPL_TYPE_FCP_DUMP; 266 return IPL_TYPE_FCP; 267 } 268 269 struct ipl_info ipl_info; 270 EXPORT_SYMBOL_GPL(ipl_info); 271 272 static ssize_t ipl_type_show(struct kobject *kobj, struct kobj_attribute *attr, 273 char *page) 274 { 275 return sprintf(page, "%s\n", ipl_type_str(ipl_info.type)); 276 } 277 278 static struct kobj_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type); 279 280 /* VM IPL PARM routines */ 281 static size_t reipl_get_ascii_vmparm(char *dest, size_t size, 282 const struct ipl_parameter_block *ipb) 283 { 284 int i; 285 size_t len; 286 char has_lowercase = 0; 287 288 len = 0; 289 if ((ipb->ipl_info.ccw.vm_flags & DIAG308_VM_FLAGS_VP_VALID) && 290 (ipb->ipl_info.ccw.vm_parm_len > 0)) { 291 292 len = min_t(size_t, size - 1, ipb->ipl_info.ccw.vm_parm_len); 293 memcpy(dest, ipb->ipl_info.ccw.vm_parm, len); 294 /* If at least one character is lowercase, we assume mixed 295 * case; otherwise we convert everything to lowercase. 296 */ 297 for (i = 0; i < len; i++) 298 if ((dest[i] > 0x80 && dest[i] < 0x8a) || /* a-i */ 299 (dest[i] > 0x90 && dest[i] < 0x9a) || /* j-r */ 300 (dest[i] > 0xa1 && dest[i] < 0xaa)) { /* s-z */ 301 has_lowercase = 1; 302 break; 303 } 304 if (!has_lowercase) 305 EBC_TOLOWER(dest, len); 306 EBCASC(dest, len); 307 } 308 dest[len] = 0; 309 310 return len; 311 } 312 313 size_t append_ipl_vmparm(char *dest, size_t size) 314 { 315 size_t rc; 316 317 rc = 0; 318 if (diag308_set_works && (ipl_block.hdr.pbt == DIAG308_IPL_TYPE_CCW)) 319 rc = reipl_get_ascii_vmparm(dest, size, &ipl_block); 320 else 321 dest[0] = 0; 322 return rc; 323 } 324 325 static ssize_t ipl_vm_parm_show(struct kobject *kobj, 326 struct kobj_attribute *attr, char *page) 327 { 328 char parm[DIAG308_VMPARM_SIZE + 1] = {}; 329 330 append_ipl_vmparm(parm, sizeof(parm)); 331 return sprintf(page, "%s\n", parm); 332 } 333 334 static size_t scpdata_length(const char* buf, size_t count) 335 { 336 while (count) { 337 if (buf[count - 1] != '\0' && buf[count - 1] != ' ') 338 break; 339 count--; 340 } 341 return count; 342 } 343 344 static size_t reipl_append_ascii_scpdata(char *dest, size_t size, 345 const struct ipl_parameter_block *ipb) 346 { 347 size_t count; 348 size_t i; 349 int has_lowercase; 350 351 count = min(size - 1, scpdata_length(ipb->ipl_info.fcp.scp_data, 352 ipb->ipl_info.fcp.scp_data_len)); 353 if (!count) 354 goto out; 355 356 has_lowercase = 0; 357 for (i = 0; i < count; i++) { 358 if (!isascii(ipb->ipl_info.fcp.scp_data[i])) { 359 count = 0; 360 goto out; 361 } 362 if (!has_lowercase && islower(ipb->ipl_info.fcp.scp_data[i])) 363 has_lowercase = 1; 364 } 365 366 if (has_lowercase) 367 memcpy(dest, ipb->ipl_info.fcp.scp_data, count); 368 else 369 for (i = 0; i < count; i++) 370 dest[i] = tolower(ipb->ipl_info.fcp.scp_data[i]); 371 out: 372 dest[count] = '\0'; 373 return count; 374 } 375 376 size_t append_ipl_scpdata(char *dest, size_t len) 377 { 378 size_t rc; 379 380 rc = 0; 381 if (ipl_block.hdr.pbt == DIAG308_IPL_TYPE_FCP) 382 rc = reipl_append_ascii_scpdata(dest, len, &ipl_block); 383 else 384 dest[0] = 0; 385 return rc; 386 } 387 388 389 static struct kobj_attribute sys_ipl_vm_parm_attr = 390 __ATTR(parm, S_IRUGO, ipl_vm_parm_show, NULL); 391 392 static ssize_t sys_ipl_device_show(struct kobject *kobj, 393 struct kobj_attribute *attr, char *page) 394 { 395 struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START; 396 397 switch (ipl_info.type) { 398 case IPL_TYPE_CCW: 399 return sprintf(page, "0.0.%04x\n", ipl_devno); 400 case IPL_TYPE_FCP: 401 case IPL_TYPE_FCP_DUMP: 402 return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno); 403 default: 404 return 0; 405 } 406 } 407 408 static struct kobj_attribute sys_ipl_device_attr = 409 __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL); 410 411 static ssize_t ipl_parameter_read(struct file *filp, struct kobject *kobj, 412 struct bin_attribute *attr, char *buf, 413 loff_t off, size_t count) 414 { 415 return memory_read_from_buffer(buf, count, &off, IPL_PARMBLOCK_START, 416 IPL_PARMBLOCK_SIZE); 417 } 418 419 static struct bin_attribute ipl_parameter_attr = { 420 .attr = { 421 .name = "binary_parameter", 422 .mode = S_IRUGO, 423 }, 424 .size = PAGE_SIZE, 425 .read = &ipl_parameter_read, 426 }; 427 428 static ssize_t ipl_scp_data_read(struct file *filp, struct kobject *kobj, 429 struct bin_attribute *attr, char *buf, 430 loff_t off, size_t count) 431 { 432 unsigned int size = IPL_PARMBLOCK_START->ipl_info.fcp.scp_data_len; 433 void *scp_data = &IPL_PARMBLOCK_START->ipl_info.fcp.scp_data; 434 435 return memory_read_from_buffer(buf, count, &off, scp_data, size); 436 } 437 438 static struct bin_attribute ipl_scp_data_attr = { 439 .attr = { 440 .name = "scp_data", 441 .mode = S_IRUGO, 442 }, 443 .size = PAGE_SIZE, 444 .read = ipl_scp_data_read, 445 }; 446 447 /* FCP ipl device attributes */ 448 449 DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n", (unsigned long long) 450 IPL_PARMBLOCK_START->ipl_info.fcp.wwpn); 451 DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n", (unsigned long long) 452 IPL_PARMBLOCK_START->ipl_info.fcp.lun); 453 DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n", (unsigned long long) 454 IPL_PARMBLOCK_START->ipl_info.fcp.bootprog); 455 DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n", (unsigned long long) 456 IPL_PARMBLOCK_START->ipl_info.fcp.br_lba); 457 458 static ssize_t ipl_ccw_loadparm_show(struct kobject *kobj, 459 struct kobj_attribute *attr, char *page) 460 { 461 char loadparm[LOADPARM_LEN + 1] = {}; 462 463 if (!sclp_ipl_info.is_valid) 464 return sprintf(page, "#unknown#\n"); 465 memcpy(loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN); 466 EBCASC(loadparm, LOADPARM_LEN); 467 strim(loadparm); 468 return sprintf(page, "%s\n", loadparm); 469 } 470 471 static struct kobj_attribute sys_ipl_ccw_loadparm_attr = 472 __ATTR(loadparm, 0444, ipl_ccw_loadparm_show, NULL); 473 474 static struct attribute *ipl_fcp_attrs[] = { 475 &sys_ipl_type_attr.attr, 476 &sys_ipl_device_attr.attr, 477 &sys_ipl_fcp_wwpn_attr.attr, 478 &sys_ipl_fcp_lun_attr.attr, 479 &sys_ipl_fcp_bootprog_attr.attr, 480 &sys_ipl_fcp_br_lba_attr.attr, 481 &sys_ipl_ccw_loadparm_attr.attr, 482 NULL, 483 }; 484 485 static struct attribute_group ipl_fcp_attr_group = { 486 .attrs = ipl_fcp_attrs, 487 }; 488 489 /* CCW ipl device attributes */ 490 491 static struct attribute *ipl_ccw_attrs_vm[] = { 492 &sys_ipl_type_attr.attr, 493 &sys_ipl_device_attr.attr, 494 &sys_ipl_ccw_loadparm_attr.attr, 495 &sys_ipl_vm_parm_attr.attr, 496 NULL, 497 }; 498 499 static struct attribute *ipl_ccw_attrs_lpar[] = { 500 &sys_ipl_type_attr.attr, 501 &sys_ipl_device_attr.attr, 502 &sys_ipl_ccw_loadparm_attr.attr, 503 NULL, 504 }; 505 506 static struct attribute_group ipl_ccw_attr_group_vm = { 507 .attrs = ipl_ccw_attrs_vm, 508 }; 509 510 static struct attribute_group ipl_ccw_attr_group_lpar = { 511 .attrs = ipl_ccw_attrs_lpar 512 }; 513 514 /* NSS ipl device attributes */ 515 516 DEFINE_IPL_ATTR_RO(ipl_nss, name, "%s\n", kernel_nss_name); 517 518 static struct attribute *ipl_nss_attrs[] = { 519 &sys_ipl_type_attr.attr, 520 &sys_ipl_nss_name_attr.attr, 521 &sys_ipl_ccw_loadparm_attr.attr, 522 &sys_ipl_vm_parm_attr.attr, 523 NULL, 524 }; 525 526 static struct attribute_group ipl_nss_attr_group = { 527 .attrs = ipl_nss_attrs, 528 }; 529 530 /* UNKNOWN ipl device attributes */ 531 532 static struct attribute *ipl_unknown_attrs[] = { 533 &sys_ipl_type_attr.attr, 534 NULL, 535 }; 536 537 static struct attribute_group ipl_unknown_attr_group = { 538 .attrs = ipl_unknown_attrs, 539 }; 540 541 static struct kset *ipl_kset; 542 543 static int __init ipl_register_fcp_files(void) 544 { 545 int rc; 546 547 rc = sysfs_create_group(&ipl_kset->kobj, &ipl_fcp_attr_group); 548 if (rc) 549 goto out; 550 rc = sysfs_create_bin_file(&ipl_kset->kobj, &ipl_parameter_attr); 551 if (rc) 552 goto out_ipl_parm; 553 rc = sysfs_create_bin_file(&ipl_kset->kobj, &ipl_scp_data_attr); 554 if (!rc) 555 goto out; 556 557 sysfs_remove_bin_file(&ipl_kset->kobj, &ipl_parameter_attr); 558 559 out_ipl_parm: 560 sysfs_remove_group(&ipl_kset->kobj, &ipl_fcp_attr_group); 561 out: 562 return rc; 563 } 564 565 static void __ipl_run(void *unused) 566 { 567 diag308(DIAG308_IPL, NULL); 568 if (MACHINE_IS_VM) 569 __cpcmd("IPL", NULL, 0, NULL); 570 else if (ipl_info.type == IPL_TYPE_CCW) 571 reipl_ccw_dev(&ipl_info.data.ccw.dev_id); 572 } 573 574 static void ipl_run(struct shutdown_trigger *trigger) 575 { 576 smp_call_ipl_cpu(__ipl_run, NULL); 577 } 578 579 static int __init ipl_init(void) 580 { 581 int rc; 582 583 ipl_kset = kset_create_and_add("ipl", NULL, firmware_kobj); 584 if (!ipl_kset) { 585 rc = -ENOMEM; 586 goto out; 587 } 588 switch (ipl_info.type) { 589 case IPL_TYPE_CCW: 590 if (MACHINE_IS_VM) 591 rc = sysfs_create_group(&ipl_kset->kobj, 592 &ipl_ccw_attr_group_vm); 593 else 594 rc = sysfs_create_group(&ipl_kset->kobj, 595 &ipl_ccw_attr_group_lpar); 596 break; 597 case IPL_TYPE_FCP: 598 case IPL_TYPE_FCP_DUMP: 599 rc = ipl_register_fcp_files(); 600 break; 601 case IPL_TYPE_NSS: 602 rc = sysfs_create_group(&ipl_kset->kobj, &ipl_nss_attr_group); 603 break; 604 default: 605 rc = sysfs_create_group(&ipl_kset->kobj, 606 &ipl_unknown_attr_group); 607 break; 608 } 609 out: 610 if (rc) 611 panic("ipl_init failed: rc = %i\n", rc); 612 613 return 0; 614 } 615 616 static struct shutdown_action __refdata ipl_action = { 617 .name = SHUTDOWN_ACTION_IPL_STR, 618 .fn = ipl_run, 619 .init = ipl_init, 620 }; 621 622 /* 623 * reipl shutdown action: Reboot Linux on shutdown. 624 */ 625 626 /* VM IPL PARM attributes */ 627 static ssize_t reipl_generic_vmparm_show(struct ipl_parameter_block *ipb, 628 char *page) 629 { 630 char vmparm[DIAG308_VMPARM_SIZE + 1] = {}; 631 632 reipl_get_ascii_vmparm(vmparm, sizeof(vmparm), ipb); 633 return sprintf(page, "%s\n", vmparm); 634 } 635 636 static ssize_t reipl_generic_vmparm_store(struct ipl_parameter_block *ipb, 637 size_t vmparm_max, 638 const char *buf, size_t len) 639 { 640 int i, ip_len; 641 642 /* ignore trailing newline */ 643 ip_len = len; 644 if ((len > 0) && (buf[len - 1] == '\n')) 645 ip_len--; 646 647 if (ip_len > vmparm_max) 648 return -EINVAL; 649 650 /* parm is used to store kernel options, check for common chars */ 651 for (i = 0; i < ip_len; i++) 652 if (!(isalnum(buf[i]) || isascii(buf[i]) || isprint(buf[i]))) 653 return -EINVAL; 654 655 memset(ipb->ipl_info.ccw.vm_parm, 0, DIAG308_VMPARM_SIZE); 656 ipb->ipl_info.ccw.vm_parm_len = ip_len; 657 if (ip_len > 0) { 658 ipb->ipl_info.ccw.vm_flags |= DIAG308_VM_FLAGS_VP_VALID; 659 memcpy(ipb->ipl_info.ccw.vm_parm, buf, ip_len); 660 ASCEBC(ipb->ipl_info.ccw.vm_parm, ip_len); 661 } else { 662 ipb->ipl_info.ccw.vm_flags &= ~DIAG308_VM_FLAGS_VP_VALID; 663 } 664 665 return len; 666 } 667 668 /* NSS wrapper */ 669 static ssize_t reipl_nss_vmparm_show(struct kobject *kobj, 670 struct kobj_attribute *attr, char *page) 671 { 672 return reipl_generic_vmparm_show(reipl_block_nss, page); 673 } 674 675 static ssize_t reipl_nss_vmparm_store(struct kobject *kobj, 676 struct kobj_attribute *attr, 677 const char *buf, size_t len) 678 { 679 return reipl_generic_vmparm_store(reipl_block_nss, 56, buf, len); 680 } 681 682 /* CCW wrapper */ 683 static ssize_t reipl_ccw_vmparm_show(struct kobject *kobj, 684 struct kobj_attribute *attr, char *page) 685 { 686 return reipl_generic_vmparm_show(reipl_block_ccw, page); 687 } 688 689 static ssize_t reipl_ccw_vmparm_store(struct kobject *kobj, 690 struct kobj_attribute *attr, 691 const char *buf, size_t len) 692 { 693 return reipl_generic_vmparm_store(reipl_block_ccw, 64, buf, len); 694 } 695 696 static struct kobj_attribute sys_reipl_nss_vmparm_attr = 697 __ATTR(parm, S_IRUGO | S_IWUSR, reipl_nss_vmparm_show, 698 reipl_nss_vmparm_store); 699 static struct kobj_attribute sys_reipl_ccw_vmparm_attr = 700 __ATTR(parm, S_IRUGO | S_IWUSR, reipl_ccw_vmparm_show, 701 reipl_ccw_vmparm_store); 702 703 /* FCP reipl device attributes */ 704 705 static ssize_t reipl_fcp_scpdata_read(struct file *filp, struct kobject *kobj, 706 struct bin_attribute *attr, 707 char *buf, loff_t off, size_t count) 708 { 709 size_t size = reipl_block_fcp->ipl_info.fcp.scp_data_len; 710 void *scp_data = reipl_block_fcp->ipl_info.fcp.scp_data; 711 712 return memory_read_from_buffer(buf, count, &off, scp_data, size); 713 } 714 715 static ssize_t reipl_fcp_scpdata_write(struct file *filp, struct kobject *kobj, 716 struct bin_attribute *attr, 717 char *buf, loff_t off, size_t count) 718 { 719 size_t padding; 720 size_t scpdata_len; 721 722 if (off < 0) 723 return -EINVAL; 724 725 if (off >= DIAG308_SCPDATA_SIZE) 726 return -ENOSPC; 727 728 if (count > DIAG308_SCPDATA_SIZE - off) 729 count = DIAG308_SCPDATA_SIZE - off; 730 731 memcpy(reipl_block_fcp->ipl_info.fcp.scp_data, buf + off, count); 732 scpdata_len = off + count; 733 734 if (scpdata_len % 8) { 735 padding = 8 - (scpdata_len % 8); 736 memset(reipl_block_fcp->ipl_info.fcp.scp_data + scpdata_len, 737 0, padding); 738 scpdata_len += padding; 739 } 740 741 reipl_block_fcp->ipl_info.fcp.scp_data_len = scpdata_len; 742 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN + scpdata_len; 743 reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN + scpdata_len; 744 745 return count; 746 } 747 748 static struct bin_attribute sys_reipl_fcp_scp_data_attr = { 749 .attr = { 750 .name = "scp_data", 751 .mode = S_IRUGO | S_IWUSR, 752 }, 753 .size = PAGE_SIZE, 754 .read = reipl_fcp_scpdata_read, 755 .write = reipl_fcp_scpdata_write, 756 }; 757 758 DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%llx\n", 759 reipl_block_fcp->ipl_info.fcp.wwpn); 760 DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%llx\n", 761 reipl_block_fcp->ipl_info.fcp.lun); 762 DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n", 763 reipl_block_fcp->ipl_info.fcp.bootprog); 764 DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n", 765 reipl_block_fcp->ipl_info.fcp.br_lba); 766 DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n", 767 reipl_block_fcp->ipl_info.fcp.devno); 768 769 static void reipl_get_ascii_loadparm(char *loadparm, 770 struct ipl_parameter_block *ibp) 771 { 772 memcpy(loadparm, ibp->hdr.loadparm, LOADPARM_LEN); 773 EBCASC(loadparm, LOADPARM_LEN); 774 loadparm[LOADPARM_LEN] = 0; 775 strim(loadparm); 776 } 777 778 static ssize_t reipl_generic_loadparm_show(struct ipl_parameter_block *ipb, 779 char *page) 780 { 781 char buf[LOADPARM_LEN + 1]; 782 783 reipl_get_ascii_loadparm(buf, ipb); 784 return sprintf(page, "%s\n", buf); 785 } 786 787 static ssize_t reipl_generic_loadparm_store(struct ipl_parameter_block *ipb, 788 const char *buf, size_t len) 789 { 790 int i, lp_len; 791 792 /* ignore trailing newline */ 793 lp_len = len; 794 if ((len > 0) && (buf[len - 1] == '\n')) 795 lp_len--; 796 /* loadparm can have max 8 characters and must not start with a blank */ 797 if ((lp_len > LOADPARM_LEN) || ((lp_len > 0) && (buf[0] == ' '))) 798 return -EINVAL; 799 /* loadparm can only contain "a-z,A-Z,0-9,SP,." */ 800 for (i = 0; i < lp_len; i++) { 801 if (isalpha(buf[i]) || isdigit(buf[i]) || (buf[i] == ' ') || 802 (buf[i] == '.')) 803 continue; 804 return -EINVAL; 805 } 806 /* initialize loadparm with blanks */ 807 memset(ipb->hdr.loadparm, ' ', LOADPARM_LEN); 808 /* copy and convert to ebcdic */ 809 memcpy(ipb->hdr.loadparm, buf, lp_len); 810 ASCEBC(ipb->hdr.loadparm, LOADPARM_LEN); 811 return len; 812 } 813 814 /* FCP wrapper */ 815 static ssize_t reipl_fcp_loadparm_show(struct kobject *kobj, 816 struct kobj_attribute *attr, char *page) 817 { 818 return reipl_generic_loadparm_show(reipl_block_fcp, page); 819 } 820 821 static ssize_t reipl_fcp_loadparm_store(struct kobject *kobj, 822 struct kobj_attribute *attr, 823 const char *buf, size_t len) 824 { 825 return reipl_generic_loadparm_store(reipl_block_fcp, buf, len); 826 } 827 828 static struct kobj_attribute sys_reipl_fcp_loadparm_attr = 829 __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_fcp_loadparm_show, 830 reipl_fcp_loadparm_store); 831 832 static struct attribute *reipl_fcp_attrs[] = { 833 &sys_reipl_fcp_device_attr.attr, 834 &sys_reipl_fcp_wwpn_attr.attr, 835 &sys_reipl_fcp_lun_attr.attr, 836 &sys_reipl_fcp_bootprog_attr.attr, 837 &sys_reipl_fcp_br_lba_attr.attr, 838 &sys_reipl_fcp_loadparm_attr.attr, 839 NULL, 840 }; 841 842 static struct attribute_group reipl_fcp_attr_group = { 843 .attrs = reipl_fcp_attrs, 844 }; 845 846 /* CCW reipl device attributes */ 847 848 DEFINE_IPL_ATTR_RW(reipl_ccw, device, "0.0.%04llx\n", "0.0.%llx\n", 849 reipl_block_ccw->ipl_info.ccw.devno); 850 851 /* NSS wrapper */ 852 static ssize_t reipl_nss_loadparm_show(struct kobject *kobj, 853 struct kobj_attribute *attr, char *page) 854 { 855 return reipl_generic_loadparm_show(reipl_block_nss, page); 856 } 857 858 static ssize_t reipl_nss_loadparm_store(struct kobject *kobj, 859 struct kobj_attribute *attr, 860 const char *buf, size_t len) 861 { 862 return reipl_generic_loadparm_store(reipl_block_nss, buf, len); 863 } 864 865 /* CCW wrapper */ 866 static ssize_t reipl_ccw_loadparm_show(struct kobject *kobj, 867 struct kobj_attribute *attr, char *page) 868 { 869 return reipl_generic_loadparm_show(reipl_block_ccw, page); 870 } 871 872 static ssize_t reipl_ccw_loadparm_store(struct kobject *kobj, 873 struct kobj_attribute *attr, 874 const char *buf, size_t len) 875 { 876 return reipl_generic_loadparm_store(reipl_block_ccw, buf, len); 877 } 878 879 static struct kobj_attribute sys_reipl_ccw_loadparm_attr = 880 __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_ccw_loadparm_show, 881 reipl_ccw_loadparm_store); 882 883 static struct attribute *reipl_ccw_attrs_vm[] = { 884 &sys_reipl_ccw_device_attr.attr, 885 &sys_reipl_ccw_loadparm_attr.attr, 886 &sys_reipl_ccw_vmparm_attr.attr, 887 NULL, 888 }; 889 890 static struct attribute *reipl_ccw_attrs_lpar[] = { 891 &sys_reipl_ccw_device_attr.attr, 892 &sys_reipl_ccw_loadparm_attr.attr, 893 NULL, 894 }; 895 896 static struct attribute_group reipl_ccw_attr_group_vm = { 897 .name = IPL_CCW_STR, 898 .attrs = reipl_ccw_attrs_vm, 899 }; 900 901 static struct attribute_group reipl_ccw_attr_group_lpar = { 902 .name = IPL_CCW_STR, 903 .attrs = reipl_ccw_attrs_lpar, 904 }; 905 906 907 /* NSS reipl device attributes */ 908 static void reipl_get_ascii_nss_name(char *dst, 909 struct ipl_parameter_block *ipb) 910 { 911 memcpy(dst, ipb->ipl_info.ccw.nss_name, NSS_NAME_SIZE); 912 EBCASC(dst, NSS_NAME_SIZE); 913 dst[NSS_NAME_SIZE] = 0; 914 } 915 916 static ssize_t reipl_nss_name_show(struct kobject *kobj, 917 struct kobj_attribute *attr, char *page) 918 { 919 char nss_name[NSS_NAME_SIZE + 1] = {}; 920 921 reipl_get_ascii_nss_name(nss_name, reipl_block_nss); 922 return sprintf(page, "%s\n", nss_name); 923 } 924 925 static ssize_t reipl_nss_name_store(struct kobject *kobj, 926 struct kobj_attribute *attr, 927 const char *buf, size_t len) 928 { 929 int nss_len; 930 931 /* ignore trailing newline */ 932 nss_len = len; 933 if ((len > 0) && (buf[len - 1] == '\n')) 934 nss_len--; 935 936 if (nss_len > NSS_NAME_SIZE) 937 return -EINVAL; 938 939 memset(reipl_block_nss->ipl_info.ccw.nss_name, 0x40, NSS_NAME_SIZE); 940 if (nss_len > 0) { 941 reipl_block_nss->ipl_info.ccw.vm_flags |= 942 DIAG308_VM_FLAGS_NSS_VALID; 943 memcpy(reipl_block_nss->ipl_info.ccw.nss_name, buf, nss_len); 944 ASCEBC(reipl_block_nss->ipl_info.ccw.nss_name, nss_len); 945 EBC_TOUPPER(reipl_block_nss->ipl_info.ccw.nss_name, nss_len); 946 } else { 947 reipl_block_nss->ipl_info.ccw.vm_flags &= 948 ~DIAG308_VM_FLAGS_NSS_VALID; 949 } 950 951 return len; 952 } 953 954 static struct kobj_attribute sys_reipl_nss_name_attr = 955 __ATTR(name, S_IRUGO | S_IWUSR, reipl_nss_name_show, 956 reipl_nss_name_store); 957 958 static struct kobj_attribute sys_reipl_nss_loadparm_attr = 959 __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_nss_loadparm_show, 960 reipl_nss_loadparm_store); 961 962 static struct attribute *reipl_nss_attrs[] = { 963 &sys_reipl_nss_name_attr.attr, 964 &sys_reipl_nss_loadparm_attr.attr, 965 &sys_reipl_nss_vmparm_attr.attr, 966 NULL, 967 }; 968 969 static struct attribute_group reipl_nss_attr_group = { 970 .name = IPL_NSS_STR, 971 .attrs = reipl_nss_attrs, 972 }; 973 974 static void set_reipl_block_actual(struct ipl_parameter_block *reipl_block) 975 { 976 reipl_block_actual = reipl_block; 977 os_info_entry_add(OS_INFO_REIPL_BLOCK, reipl_block_actual, 978 reipl_block->hdr.len); 979 } 980 981 /* reipl type */ 982 983 static int reipl_set_type(enum ipl_type type) 984 { 985 if (!(reipl_capabilities & type)) 986 return -EINVAL; 987 988 switch(type) { 989 case IPL_TYPE_CCW: 990 if (diag308_set_works) 991 reipl_method = REIPL_METHOD_CCW_DIAG; 992 else if (MACHINE_IS_VM) 993 reipl_method = REIPL_METHOD_CCW_VM; 994 else 995 reipl_method = REIPL_METHOD_CCW_CIO; 996 set_reipl_block_actual(reipl_block_ccw); 997 break; 998 case IPL_TYPE_FCP: 999 if (diag308_set_works) 1000 reipl_method = REIPL_METHOD_FCP_RW_DIAG; 1001 else if (MACHINE_IS_VM) 1002 reipl_method = REIPL_METHOD_FCP_RO_VM; 1003 else 1004 reipl_method = REIPL_METHOD_FCP_RO_DIAG; 1005 set_reipl_block_actual(reipl_block_fcp); 1006 break; 1007 case IPL_TYPE_FCP_DUMP: 1008 reipl_method = REIPL_METHOD_FCP_DUMP; 1009 break; 1010 case IPL_TYPE_NSS: 1011 if (diag308_set_works) 1012 reipl_method = REIPL_METHOD_NSS_DIAG; 1013 else 1014 reipl_method = REIPL_METHOD_NSS; 1015 set_reipl_block_actual(reipl_block_nss); 1016 break; 1017 case IPL_TYPE_UNKNOWN: 1018 reipl_method = REIPL_METHOD_DEFAULT; 1019 break; 1020 default: 1021 BUG(); 1022 } 1023 reipl_type = type; 1024 return 0; 1025 } 1026 1027 static ssize_t reipl_type_show(struct kobject *kobj, 1028 struct kobj_attribute *attr, char *page) 1029 { 1030 return sprintf(page, "%s\n", ipl_type_str(reipl_type)); 1031 } 1032 1033 static ssize_t reipl_type_store(struct kobject *kobj, 1034 struct kobj_attribute *attr, 1035 const char *buf, size_t len) 1036 { 1037 int rc = -EINVAL; 1038 1039 if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0) 1040 rc = reipl_set_type(IPL_TYPE_CCW); 1041 else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0) 1042 rc = reipl_set_type(IPL_TYPE_FCP); 1043 else if (strncmp(buf, IPL_NSS_STR, strlen(IPL_NSS_STR)) == 0) 1044 rc = reipl_set_type(IPL_TYPE_NSS); 1045 return (rc != 0) ? rc : len; 1046 } 1047 1048 static struct kobj_attribute reipl_type_attr = 1049 __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store); 1050 1051 static struct kset *reipl_kset; 1052 static struct kset *reipl_fcp_kset; 1053 1054 static void get_ipl_string(char *dst, struct ipl_parameter_block *ipb, 1055 const enum ipl_method m) 1056 { 1057 char loadparm[LOADPARM_LEN + 1] = {}; 1058 char vmparm[DIAG308_VMPARM_SIZE + 1] = {}; 1059 char nss_name[NSS_NAME_SIZE + 1] = {}; 1060 size_t pos = 0; 1061 1062 reipl_get_ascii_loadparm(loadparm, ipb); 1063 reipl_get_ascii_nss_name(nss_name, ipb); 1064 reipl_get_ascii_vmparm(vmparm, sizeof(vmparm), ipb); 1065 1066 switch (m) { 1067 case REIPL_METHOD_CCW_VM: 1068 pos = sprintf(dst, "IPL %X CLEAR", ipb->ipl_info.ccw.devno); 1069 break; 1070 case REIPL_METHOD_NSS: 1071 pos = sprintf(dst, "IPL %s", nss_name); 1072 break; 1073 default: 1074 break; 1075 } 1076 if (strlen(loadparm) > 0) 1077 pos += sprintf(dst + pos, " LOADPARM '%s'", loadparm); 1078 if (strlen(vmparm) > 0) 1079 sprintf(dst + pos, " PARM %s", vmparm); 1080 } 1081 1082 static void __reipl_run(void *unused) 1083 { 1084 struct ccw_dev_id devid; 1085 static char buf[128]; 1086 1087 switch (reipl_method) { 1088 case REIPL_METHOD_CCW_CIO: 1089 devid.devno = reipl_block_ccw->ipl_info.ccw.devno; 1090 devid.ssid = 0; 1091 reipl_ccw_dev(&devid); 1092 break; 1093 case REIPL_METHOD_CCW_VM: 1094 get_ipl_string(buf, reipl_block_ccw, REIPL_METHOD_CCW_VM); 1095 __cpcmd(buf, NULL, 0, NULL); 1096 break; 1097 case REIPL_METHOD_CCW_DIAG: 1098 diag308(DIAG308_SET, reipl_block_ccw); 1099 diag308(DIAG308_IPL, NULL); 1100 break; 1101 case REIPL_METHOD_FCP_RW_DIAG: 1102 diag308(DIAG308_SET, reipl_block_fcp); 1103 diag308(DIAG308_IPL, NULL); 1104 break; 1105 case REIPL_METHOD_FCP_RO_DIAG: 1106 diag308(DIAG308_IPL, NULL); 1107 break; 1108 case REIPL_METHOD_FCP_RO_VM: 1109 __cpcmd("IPL", NULL, 0, NULL); 1110 break; 1111 case REIPL_METHOD_NSS_DIAG: 1112 diag308(DIAG308_SET, reipl_block_nss); 1113 diag308(DIAG308_IPL, NULL); 1114 break; 1115 case REIPL_METHOD_NSS: 1116 get_ipl_string(buf, reipl_block_nss, REIPL_METHOD_NSS); 1117 __cpcmd(buf, NULL, 0, NULL); 1118 break; 1119 case REIPL_METHOD_DEFAULT: 1120 if (MACHINE_IS_VM) 1121 __cpcmd("IPL", NULL, 0, NULL); 1122 diag308(DIAG308_IPL, NULL); 1123 break; 1124 case REIPL_METHOD_FCP_DUMP: 1125 break; 1126 } 1127 disabled_wait((unsigned long) __builtin_return_address(0)); 1128 } 1129 1130 static void reipl_run(struct shutdown_trigger *trigger) 1131 { 1132 smp_call_ipl_cpu(__reipl_run, NULL); 1133 } 1134 1135 static void reipl_block_ccw_init(struct ipl_parameter_block *ipb) 1136 { 1137 ipb->hdr.len = IPL_PARM_BLK_CCW_LEN; 1138 ipb->hdr.version = IPL_PARM_BLOCK_VERSION; 1139 ipb->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN; 1140 ipb->hdr.pbt = DIAG308_IPL_TYPE_CCW; 1141 } 1142 1143 static void reipl_block_ccw_fill_parms(struct ipl_parameter_block *ipb) 1144 { 1145 /* LOADPARM */ 1146 /* check if read scp info worked and set loadparm */ 1147 if (sclp_ipl_info.is_valid) 1148 memcpy(ipb->hdr.loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN); 1149 else 1150 /* read scp info failed: set empty loadparm (EBCDIC blanks) */ 1151 memset(ipb->hdr.loadparm, 0x40, LOADPARM_LEN); 1152 ipb->hdr.flags = DIAG308_FLAGS_LP_VALID; 1153 1154 /* VM PARM */ 1155 if (MACHINE_IS_VM && diag308_set_works && 1156 (ipl_block.ipl_info.ccw.vm_flags & DIAG308_VM_FLAGS_VP_VALID)) { 1157 1158 ipb->ipl_info.ccw.vm_flags |= DIAG308_VM_FLAGS_VP_VALID; 1159 ipb->ipl_info.ccw.vm_parm_len = 1160 ipl_block.ipl_info.ccw.vm_parm_len; 1161 memcpy(ipb->ipl_info.ccw.vm_parm, 1162 ipl_block.ipl_info.ccw.vm_parm, DIAG308_VMPARM_SIZE); 1163 } 1164 } 1165 1166 static int __init reipl_nss_init(void) 1167 { 1168 int rc; 1169 1170 if (!MACHINE_IS_VM) 1171 return 0; 1172 1173 reipl_block_nss = (void *) get_zeroed_page(GFP_KERNEL); 1174 if (!reipl_block_nss) 1175 return -ENOMEM; 1176 1177 if (!diag308_set_works) 1178 sys_reipl_nss_vmparm_attr.attr.mode = S_IRUGO; 1179 1180 rc = sysfs_create_group(&reipl_kset->kobj, &reipl_nss_attr_group); 1181 if (rc) 1182 return rc; 1183 1184 reipl_block_ccw_init(reipl_block_nss); 1185 if (ipl_info.type == IPL_TYPE_NSS) { 1186 memset(reipl_block_nss->ipl_info.ccw.nss_name, 1187 ' ', NSS_NAME_SIZE); 1188 memcpy(reipl_block_nss->ipl_info.ccw.nss_name, 1189 kernel_nss_name, strlen(kernel_nss_name)); 1190 ASCEBC(reipl_block_nss->ipl_info.ccw.nss_name, NSS_NAME_SIZE); 1191 reipl_block_nss->ipl_info.ccw.vm_flags |= 1192 DIAG308_VM_FLAGS_NSS_VALID; 1193 1194 reipl_block_ccw_fill_parms(reipl_block_nss); 1195 } 1196 1197 reipl_capabilities |= IPL_TYPE_NSS; 1198 return 0; 1199 } 1200 1201 static int __init reipl_ccw_init(void) 1202 { 1203 int rc; 1204 1205 reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL); 1206 if (!reipl_block_ccw) 1207 return -ENOMEM; 1208 1209 if (MACHINE_IS_VM) { 1210 if (!diag308_set_works) 1211 sys_reipl_ccw_vmparm_attr.attr.mode = S_IRUGO; 1212 rc = sysfs_create_group(&reipl_kset->kobj, 1213 &reipl_ccw_attr_group_vm); 1214 } else { 1215 if(!diag308_set_works) 1216 sys_reipl_ccw_loadparm_attr.attr.mode = S_IRUGO; 1217 rc = sysfs_create_group(&reipl_kset->kobj, 1218 &reipl_ccw_attr_group_lpar); 1219 } 1220 if (rc) 1221 return rc; 1222 1223 reipl_block_ccw_init(reipl_block_ccw); 1224 if (ipl_info.type == IPL_TYPE_CCW) { 1225 reipl_block_ccw->ipl_info.ccw.devno = ipl_devno; 1226 reipl_block_ccw_fill_parms(reipl_block_ccw); 1227 } 1228 1229 reipl_capabilities |= IPL_TYPE_CCW; 1230 return 0; 1231 } 1232 1233 static int __init reipl_fcp_init(void) 1234 { 1235 int rc; 1236 1237 if (!diag308_set_works) { 1238 if (ipl_info.type == IPL_TYPE_FCP) { 1239 make_attrs_ro(reipl_fcp_attrs); 1240 sys_reipl_fcp_scp_data_attr.attr.mode = S_IRUGO; 1241 } else 1242 return 0; 1243 } 1244 1245 reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL); 1246 if (!reipl_block_fcp) 1247 return -ENOMEM; 1248 1249 /* sysfs: create fcp kset for mixing attr group and bin attrs */ 1250 reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL, 1251 &reipl_kset->kobj); 1252 if (!reipl_fcp_kset) { 1253 free_page((unsigned long) reipl_block_fcp); 1254 return -ENOMEM; 1255 } 1256 1257 rc = sysfs_create_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group); 1258 if (rc) { 1259 kset_unregister(reipl_fcp_kset); 1260 free_page((unsigned long) reipl_block_fcp); 1261 return rc; 1262 } 1263 1264 rc = sysfs_create_bin_file(&reipl_fcp_kset->kobj, 1265 &sys_reipl_fcp_scp_data_attr); 1266 if (rc) { 1267 sysfs_remove_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group); 1268 kset_unregister(reipl_fcp_kset); 1269 free_page((unsigned long) reipl_block_fcp); 1270 return rc; 1271 } 1272 1273 if (ipl_info.type == IPL_TYPE_FCP) { 1274 memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE); 1275 /* 1276 * Fix loadparm: There are systems where the (SCSI) LOADPARM 1277 * is invalid in the SCSI IPL parameter block, so take it 1278 * always from sclp_ipl_info. 1279 */ 1280 memcpy(reipl_block_fcp->hdr.loadparm, sclp_ipl_info.loadparm, 1281 LOADPARM_LEN); 1282 } else { 1283 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN; 1284 reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION; 1285 reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN; 1286 reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP; 1287 reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL; 1288 } 1289 reipl_capabilities |= IPL_TYPE_FCP; 1290 return 0; 1291 } 1292 1293 static int __init reipl_type_init(void) 1294 { 1295 enum ipl_type reipl_type = ipl_info.type; 1296 struct ipl_parameter_block *reipl_block; 1297 unsigned long size; 1298 1299 reipl_block = os_info_old_entry(OS_INFO_REIPL_BLOCK, &size); 1300 if (!reipl_block) 1301 goto out; 1302 /* 1303 * If we have an OS info reipl block, this will be used 1304 */ 1305 if (reipl_block->hdr.pbt == DIAG308_IPL_TYPE_FCP) { 1306 memcpy(reipl_block_fcp, reipl_block, size); 1307 reipl_type = IPL_TYPE_FCP; 1308 } else if (reipl_block->hdr.pbt == DIAG308_IPL_TYPE_CCW) { 1309 memcpy(reipl_block_ccw, reipl_block, size); 1310 reipl_type = IPL_TYPE_CCW; 1311 } 1312 out: 1313 return reipl_set_type(reipl_type); 1314 } 1315 1316 static int __init reipl_init(void) 1317 { 1318 int rc; 1319 1320 reipl_kset = kset_create_and_add("reipl", NULL, firmware_kobj); 1321 if (!reipl_kset) 1322 return -ENOMEM; 1323 rc = sysfs_create_file(&reipl_kset->kobj, &reipl_type_attr.attr); 1324 if (rc) { 1325 kset_unregister(reipl_kset); 1326 return rc; 1327 } 1328 rc = reipl_ccw_init(); 1329 if (rc) 1330 return rc; 1331 rc = reipl_fcp_init(); 1332 if (rc) 1333 return rc; 1334 rc = reipl_nss_init(); 1335 if (rc) 1336 return rc; 1337 return reipl_type_init(); 1338 } 1339 1340 static struct shutdown_action __refdata reipl_action = { 1341 .name = SHUTDOWN_ACTION_REIPL_STR, 1342 .fn = reipl_run, 1343 .init = reipl_init, 1344 }; 1345 1346 /* 1347 * dump shutdown action: Dump Linux on shutdown. 1348 */ 1349 1350 /* FCP dump device attributes */ 1351 1352 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%llx\n", 1353 dump_block_fcp->ipl_info.fcp.wwpn); 1354 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%llx\n", 1355 dump_block_fcp->ipl_info.fcp.lun); 1356 DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n", 1357 dump_block_fcp->ipl_info.fcp.bootprog); 1358 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n", 1359 dump_block_fcp->ipl_info.fcp.br_lba); 1360 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n", 1361 dump_block_fcp->ipl_info.fcp.devno); 1362 1363 static struct attribute *dump_fcp_attrs[] = { 1364 &sys_dump_fcp_device_attr.attr, 1365 &sys_dump_fcp_wwpn_attr.attr, 1366 &sys_dump_fcp_lun_attr.attr, 1367 &sys_dump_fcp_bootprog_attr.attr, 1368 &sys_dump_fcp_br_lba_attr.attr, 1369 NULL, 1370 }; 1371 1372 static struct attribute_group dump_fcp_attr_group = { 1373 .name = IPL_FCP_STR, 1374 .attrs = dump_fcp_attrs, 1375 }; 1376 1377 /* CCW dump device attributes */ 1378 1379 DEFINE_IPL_ATTR_RW(dump_ccw, device, "0.0.%04llx\n", "0.0.%llx\n", 1380 dump_block_ccw->ipl_info.ccw.devno); 1381 1382 static struct attribute *dump_ccw_attrs[] = { 1383 &sys_dump_ccw_device_attr.attr, 1384 NULL, 1385 }; 1386 1387 static struct attribute_group dump_ccw_attr_group = { 1388 .name = IPL_CCW_STR, 1389 .attrs = dump_ccw_attrs, 1390 }; 1391 1392 /* dump type */ 1393 1394 static int dump_set_type(enum dump_type type) 1395 { 1396 if (!(dump_capabilities & type)) 1397 return -EINVAL; 1398 switch (type) { 1399 case DUMP_TYPE_CCW: 1400 if (diag308_set_works) 1401 dump_method = DUMP_METHOD_CCW_DIAG; 1402 else if (MACHINE_IS_VM) 1403 dump_method = DUMP_METHOD_CCW_VM; 1404 else 1405 dump_method = DUMP_METHOD_CCW_CIO; 1406 break; 1407 case DUMP_TYPE_FCP: 1408 dump_method = DUMP_METHOD_FCP_DIAG; 1409 break; 1410 default: 1411 dump_method = DUMP_METHOD_NONE; 1412 } 1413 dump_type = type; 1414 return 0; 1415 } 1416 1417 static ssize_t dump_type_show(struct kobject *kobj, 1418 struct kobj_attribute *attr, char *page) 1419 { 1420 return sprintf(page, "%s\n", dump_type_str(dump_type)); 1421 } 1422 1423 static ssize_t dump_type_store(struct kobject *kobj, 1424 struct kobj_attribute *attr, 1425 const char *buf, size_t len) 1426 { 1427 int rc = -EINVAL; 1428 1429 if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0) 1430 rc = dump_set_type(DUMP_TYPE_NONE); 1431 else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0) 1432 rc = dump_set_type(DUMP_TYPE_CCW); 1433 else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0) 1434 rc = dump_set_type(DUMP_TYPE_FCP); 1435 return (rc != 0) ? rc : len; 1436 } 1437 1438 static struct kobj_attribute dump_type_attr = 1439 __ATTR(dump_type, 0644, dump_type_show, dump_type_store); 1440 1441 static struct kset *dump_kset; 1442 1443 static void diag308_dump(void *dump_block) 1444 { 1445 diag308(DIAG308_SET, dump_block); 1446 while (1) { 1447 if (diag308(DIAG308_DUMP, NULL) != 0x302) 1448 break; 1449 udelay_simple(USEC_PER_SEC); 1450 } 1451 } 1452 1453 static void __dump_run(void *unused) 1454 { 1455 struct ccw_dev_id devid; 1456 static char buf[100]; 1457 1458 switch (dump_method) { 1459 case DUMP_METHOD_CCW_CIO: 1460 devid.devno = dump_block_ccw->ipl_info.ccw.devno; 1461 devid.ssid = 0; 1462 reipl_ccw_dev(&devid); 1463 break; 1464 case DUMP_METHOD_CCW_VM: 1465 sprintf(buf, "STORE STATUS"); 1466 __cpcmd(buf, NULL, 0, NULL); 1467 sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno); 1468 __cpcmd(buf, NULL, 0, NULL); 1469 break; 1470 case DUMP_METHOD_CCW_DIAG: 1471 diag308_dump(dump_block_ccw); 1472 break; 1473 case DUMP_METHOD_FCP_DIAG: 1474 diag308_dump(dump_block_fcp); 1475 break; 1476 default: 1477 break; 1478 } 1479 } 1480 1481 static void dump_run(struct shutdown_trigger *trigger) 1482 { 1483 if (dump_method == DUMP_METHOD_NONE) 1484 return; 1485 smp_send_stop(); 1486 smp_call_ipl_cpu(__dump_run, NULL); 1487 } 1488 1489 static int __init dump_ccw_init(void) 1490 { 1491 int rc; 1492 1493 dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL); 1494 if (!dump_block_ccw) 1495 return -ENOMEM; 1496 rc = sysfs_create_group(&dump_kset->kobj, &dump_ccw_attr_group); 1497 if (rc) { 1498 free_page((unsigned long)dump_block_ccw); 1499 return rc; 1500 } 1501 dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN; 1502 dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION; 1503 dump_block_ccw->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN; 1504 dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW; 1505 dump_capabilities |= DUMP_TYPE_CCW; 1506 return 0; 1507 } 1508 1509 static int __init dump_fcp_init(void) 1510 { 1511 int rc; 1512 1513 if (!sclp_ipl_info.has_dump) 1514 return 0; /* LDIPL DUMP is not installed */ 1515 if (!diag308_set_works) 1516 return 0; 1517 dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL); 1518 if (!dump_block_fcp) 1519 return -ENOMEM; 1520 rc = sysfs_create_group(&dump_kset->kobj, &dump_fcp_attr_group); 1521 if (rc) { 1522 free_page((unsigned long)dump_block_fcp); 1523 return rc; 1524 } 1525 dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN; 1526 dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION; 1527 dump_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN; 1528 dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP; 1529 dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP; 1530 dump_capabilities |= DUMP_TYPE_FCP; 1531 return 0; 1532 } 1533 1534 static int __init dump_init(void) 1535 { 1536 int rc; 1537 1538 dump_kset = kset_create_and_add("dump", NULL, firmware_kobj); 1539 if (!dump_kset) 1540 return -ENOMEM; 1541 rc = sysfs_create_file(&dump_kset->kobj, &dump_type_attr.attr); 1542 if (rc) { 1543 kset_unregister(dump_kset); 1544 return rc; 1545 } 1546 rc = dump_ccw_init(); 1547 if (rc) 1548 return rc; 1549 rc = dump_fcp_init(); 1550 if (rc) 1551 return rc; 1552 dump_set_type(DUMP_TYPE_NONE); 1553 return 0; 1554 } 1555 1556 static struct shutdown_action __refdata dump_action = { 1557 .name = SHUTDOWN_ACTION_DUMP_STR, 1558 .fn = dump_run, 1559 .init = dump_init, 1560 }; 1561 1562 static void dump_reipl_run(struct shutdown_trigger *trigger) 1563 { 1564 unsigned long ipib = (unsigned long) reipl_block_actual; 1565 unsigned int csum; 1566 1567 csum = csum_partial(reipl_block_actual, reipl_block_actual->hdr.len, 0); 1568 mem_assign_absolute(S390_lowcore.ipib, ipib); 1569 mem_assign_absolute(S390_lowcore.ipib_checksum, csum); 1570 dump_run(trigger); 1571 } 1572 1573 static int __init dump_reipl_init(void) 1574 { 1575 if (!diag308_set_works) 1576 return -EOPNOTSUPP; 1577 else 1578 return 0; 1579 } 1580 1581 static struct shutdown_action __refdata dump_reipl_action = { 1582 .name = SHUTDOWN_ACTION_DUMP_REIPL_STR, 1583 .fn = dump_reipl_run, 1584 .init = dump_reipl_init, 1585 }; 1586 1587 /* 1588 * vmcmd shutdown action: Trigger vm command on shutdown. 1589 */ 1590 1591 static char vmcmd_on_reboot[128]; 1592 static char vmcmd_on_panic[128]; 1593 static char vmcmd_on_halt[128]; 1594 static char vmcmd_on_poff[128]; 1595 static char vmcmd_on_restart[128]; 1596 1597 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_reboot, "%s\n", "%s\n", vmcmd_on_reboot); 1598 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_panic, "%s\n", "%s\n", vmcmd_on_panic); 1599 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_halt, "%s\n", "%s\n", vmcmd_on_halt); 1600 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_poff, "%s\n", "%s\n", vmcmd_on_poff); 1601 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_restart, "%s\n", "%s\n", vmcmd_on_restart); 1602 1603 static struct attribute *vmcmd_attrs[] = { 1604 &sys_vmcmd_on_reboot_attr.attr, 1605 &sys_vmcmd_on_panic_attr.attr, 1606 &sys_vmcmd_on_halt_attr.attr, 1607 &sys_vmcmd_on_poff_attr.attr, 1608 &sys_vmcmd_on_restart_attr.attr, 1609 NULL, 1610 }; 1611 1612 static struct attribute_group vmcmd_attr_group = { 1613 .attrs = vmcmd_attrs, 1614 }; 1615 1616 static struct kset *vmcmd_kset; 1617 1618 static void vmcmd_run(struct shutdown_trigger *trigger) 1619 { 1620 char *cmd; 1621 1622 if (strcmp(trigger->name, ON_REIPL_STR) == 0) 1623 cmd = vmcmd_on_reboot; 1624 else if (strcmp(trigger->name, ON_PANIC_STR) == 0) 1625 cmd = vmcmd_on_panic; 1626 else if (strcmp(trigger->name, ON_HALT_STR) == 0) 1627 cmd = vmcmd_on_halt; 1628 else if (strcmp(trigger->name, ON_POFF_STR) == 0) 1629 cmd = vmcmd_on_poff; 1630 else if (strcmp(trigger->name, ON_RESTART_STR) == 0) 1631 cmd = vmcmd_on_restart; 1632 else 1633 return; 1634 1635 if (strlen(cmd) == 0) 1636 return; 1637 __cpcmd(cmd, NULL, 0, NULL); 1638 } 1639 1640 static int vmcmd_init(void) 1641 { 1642 if (!MACHINE_IS_VM) 1643 return -EOPNOTSUPP; 1644 vmcmd_kset = kset_create_and_add("vmcmd", NULL, firmware_kobj); 1645 if (!vmcmd_kset) 1646 return -ENOMEM; 1647 return sysfs_create_group(&vmcmd_kset->kobj, &vmcmd_attr_group); 1648 } 1649 1650 static struct shutdown_action vmcmd_action = {SHUTDOWN_ACTION_VMCMD_STR, 1651 vmcmd_run, vmcmd_init}; 1652 1653 /* 1654 * stop shutdown action: Stop Linux on shutdown. 1655 */ 1656 1657 static void stop_run(struct shutdown_trigger *trigger) 1658 { 1659 if (strcmp(trigger->name, ON_PANIC_STR) == 0 || 1660 strcmp(trigger->name, ON_RESTART_STR) == 0) 1661 disabled_wait((unsigned long) __builtin_return_address(0)); 1662 smp_stop_cpu(); 1663 } 1664 1665 static struct shutdown_action stop_action = {SHUTDOWN_ACTION_STOP_STR, 1666 stop_run, NULL}; 1667 1668 /* action list */ 1669 1670 static struct shutdown_action *shutdown_actions_list[] = { 1671 &ipl_action, &reipl_action, &dump_reipl_action, &dump_action, 1672 &vmcmd_action, &stop_action}; 1673 #define SHUTDOWN_ACTIONS_COUNT (sizeof(shutdown_actions_list) / sizeof(void *)) 1674 1675 /* 1676 * Trigger section 1677 */ 1678 1679 static struct kset *shutdown_actions_kset; 1680 1681 static int set_trigger(const char *buf, struct shutdown_trigger *trigger, 1682 size_t len) 1683 { 1684 int i; 1685 1686 for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) { 1687 if (sysfs_streq(buf, shutdown_actions_list[i]->name)) { 1688 if (shutdown_actions_list[i]->init_rc) { 1689 return shutdown_actions_list[i]->init_rc; 1690 } else { 1691 trigger->action = shutdown_actions_list[i]; 1692 return len; 1693 } 1694 } 1695 } 1696 return -EINVAL; 1697 } 1698 1699 /* on reipl */ 1700 1701 static struct shutdown_trigger on_reboot_trigger = {ON_REIPL_STR, 1702 &reipl_action}; 1703 1704 static ssize_t on_reboot_show(struct kobject *kobj, 1705 struct kobj_attribute *attr, char *page) 1706 { 1707 return sprintf(page, "%s\n", on_reboot_trigger.action->name); 1708 } 1709 1710 static ssize_t on_reboot_store(struct kobject *kobj, 1711 struct kobj_attribute *attr, 1712 const char *buf, size_t len) 1713 { 1714 return set_trigger(buf, &on_reboot_trigger, len); 1715 } 1716 1717 static struct kobj_attribute on_reboot_attr = 1718 __ATTR(on_reboot, 0644, on_reboot_show, on_reboot_store); 1719 1720 static void do_machine_restart(char *__unused) 1721 { 1722 smp_send_stop(); 1723 on_reboot_trigger.action->fn(&on_reboot_trigger); 1724 reipl_run(NULL); 1725 } 1726 void (*_machine_restart)(char *command) = do_machine_restart; 1727 1728 /* on panic */ 1729 1730 static struct shutdown_trigger on_panic_trigger = {ON_PANIC_STR, &stop_action}; 1731 1732 static ssize_t on_panic_show(struct kobject *kobj, 1733 struct kobj_attribute *attr, char *page) 1734 { 1735 return sprintf(page, "%s\n", on_panic_trigger.action->name); 1736 } 1737 1738 static ssize_t on_panic_store(struct kobject *kobj, 1739 struct kobj_attribute *attr, 1740 const char *buf, size_t len) 1741 { 1742 return set_trigger(buf, &on_panic_trigger, len); 1743 } 1744 1745 static struct kobj_attribute on_panic_attr = 1746 __ATTR(on_panic, 0644, on_panic_show, on_panic_store); 1747 1748 static void do_panic(void) 1749 { 1750 lgr_info_log(); 1751 on_panic_trigger.action->fn(&on_panic_trigger); 1752 stop_run(&on_panic_trigger); 1753 } 1754 1755 /* on restart */ 1756 1757 static struct shutdown_trigger on_restart_trigger = {ON_RESTART_STR, 1758 &stop_action}; 1759 1760 static ssize_t on_restart_show(struct kobject *kobj, 1761 struct kobj_attribute *attr, char *page) 1762 { 1763 return sprintf(page, "%s\n", on_restart_trigger.action->name); 1764 } 1765 1766 static ssize_t on_restart_store(struct kobject *kobj, 1767 struct kobj_attribute *attr, 1768 const char *buf, size_t len) 1769 { 1770 return set_trigger(buf, &on_restart_trigger, len); 1771 } 1772 1773 static struct kobj_attribute on_restart_attr = 1774 __ATTR(on_restart, 0644, on_restart_show, on_restart_store); 1775 1776 static void __do_restart(void *ignore) 1777 { 1778 __arch_local_irq_stosm(0x04); /* enable DAT */ 1779 smp_send_stop(); 1780 #ifdef CONFIG_CRASH_DUMP 1781 crash_kexec(NULL); 1782 #endif 1783 on_restart_trigger.action->fn(&on_restart_trigger); 1784 stop_run(&on_restart_trigger); 1785 } 1786 1787 void do_restart(void) 1788 { 1789 tracing_off(); 1790 debug_locks_off(); 1791 lgr_info_log(); 1792 smp_call_online_cpu(__do_restart, NULL); 1793 } 1794 1795 /* on halt */ 1796 1797 static struct shutdown_trigger on_halt_trigger = {ON_HALT_STR, &stop_action}; 1798 1799 static ssize_t on_halt_show(struct kobject *kobj, 1800 struct kobj_attribute *attr, char *page) 1801 { 1802 return sprintf(page, "%s\n", on_halt_trigger.action->name); 1803 } 1804 1805 static ssize_t on_halt_store(struct kobject *kobj, 1806 struct kobj_attribute *attr, 1807 const char *buf, size_t len) 1808 { 1809 return set_trigger(buf, &on_halt_trigger, len); 1810 } 1811 1812 static struct kobj_attribute on_halt_attr = 1813 __ATTR(on_halt, 0644, on_halt_show, on_halt_store); 1814 1815 1816 static void do_machine_halt(void) 1817 { 1818 smp_send_stop(); 1819 on_halt_trigger.action->fn(&on_halt_trigger); 1820 stop_run(&on_halt_trigger); 1821 } 1822 void (*_machine_halt)(void) = do_machine_halt; 1823 1824 /* on power off */ 1825 1826 static struct shutdown_trigger on_poff_trigger = {ON_POFF_STR, &stop_action}; 1827 1828 static ssize_t on_poff_show(struct kobject *kobj, 1829 struct kobj_attribute *attr, char *page) 1830 { 1831 return sprintf(page, "%s\n", on_poff_trigger.action->name); 1832 } 1833 1834 static ssize_t on_poff_store(struct kobject *kobj, 1835 struct kobj_attribute *attr, 1836 const char *buf, size_t len) 1837 { 1838 return set_trigger(buf, &on_poff_trigger, len); 1839 } 1840 1841 static struct kobj_attribute on_poff_attr = 1842 __ATTR(on_poff, 0644, on_poff_show, on_poff_store); 1843 1844 1845 static void do_machine_power_off(void) 1846 { 1847 smp_send_stop(); 1848 on_poff_trigger.action->fn(&on_poff_trigger); 1849 stop_run(&on_poff_trigger); 1850 } 1851 void (*_machine_power_off)(void) = do_machine_power_off; 1852 1853 static void __init shutdown_triggers_init(void) 1854 { 1855 shutdown_actions_kset = kset_create_and_add("shutdown_actions", NULL, 1856 firmware_kobj); 1857 if (!shutdown_actions_kset) 1858 goto fail; 1859 if (sysfs_create_file(&shutdown_actions_kset->kobj, 1860 &on_reboot_attr.attr)) 1861 goto fail; 1862 if (sysfs_create_file(&shutdown_actions_kset->kobj, 1863 &on_panic_attr.attr)) 1864 goto fail; 1865 if (sysfs_create_file(&shutdown_actions_kset->kobj, 1866 &on_halt_attr.attr)) 1867 goto fail; 1868 if (sysfs_create_file(&shutdown_actions_kset->kobj, 1869 &on_poff_attr.attr)) 1870 goto fail; 1871 if (sysfs_create_file(&shutdown_actions_kset->kobj, 1872 &on_restart_attr.attr)) 1873 goto fail; 1874 return; 1875 fail: 1876 panic("shutdown_triggers_init failed\n"); 1877 } 1878 1879 static void __init shutdown_actions_init(void) 1880 { 1881 int i; 1882 1883 for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) { 1884 if (!shutdown_actions_list[i]->init) 1885 continue; 1886 shutdown_actions_list[i]->init_rc = 1887 shutdown_actions_list[i]->init(); 1888 } 1889 } 1890 1891 static int __init s390_ipl_init(void) 1892 { 1893 char str[8] = {0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40}; 1894 1895 sclp_get_ipl_info(&sclp_ipl_info); 1896 /* 1897 * Fix loadparm: There are systems where the (SCSI) LOADPARM 1898 * returned by read SCP info is invalid (contains EBCDIC blanks) 1899 * when the system has been booted via diag308. In that case we use 1900 * the value from diag308, if available. 1901 * 1902 * There are also systems where diag308 store does not work in 1903 * case the system is booted from HMC. Fortunately in this case 1904 * READ SCP info provides the correct value. 1905 */ 1906 if (memcmp(sclp_ipl_info.loadparm, str, sizeof(str)) == 0 && 1907 diag308_set_works) 1908 memcpy(sclp_ipl_info.loadparm, ipl_block.hdr.loadparm, 1909 LOADPARM_LEN); 1910 shutdown_actions_init(); 1911 shutdown_triggers_init(); 1912 return 0; 1913 } 1914 1915 __initcall(s390_ipl_init); 1916 1917 static void __init strncpy_skip_quote(char *dst, char *src, int n) 1918 { 1919 int sx, dx; 1920 1921 dx = 0; 1922 for (sx = 0; src[sx] != 0; sx++) { 1923 if (src[sx] == '"') 1924 continue; 1925 dst[dx++] = src[sx]; 1926 if (dx >= n) 1927 break; 1928 } 1929 } 1930 1931 static int __init vmcmd_on_reboot_setup(char *str) 1932 { 1933 if (!MACHINE_IS_VM) 1934 return 1; 1935 strncpy_skip_quote(vmcmd_on_reboot, str, 127); 1936 vmcmd_on_reboot[127] = 0; 1937 on_reboot_trigger.action = &vmcmd_action; 1938 return 1; 1939 } 1940 __setup("vmreboot=", vmcmd_on_reboot_setup); 1941 1942 static int __init vmcmd_on_panic_setup(char *str) 1943 { 1944 if (!MACHINE_IS_VM) 1945 return 1; 1946 strncpy_skip_quote(vmcmd_on_panic, str, 127); 1947 vmcmd_on_panic[127] = 0; 1948 on_panic_trigger.action = &vmcmd_action; 1949 return 1; 1950 } 1951 __setup("vmpanic=", vmcmd_on_panic_setup); 1952 1953 static int __init vmcmd_on_halt_setup(char *str) 1954 { 1955 if (!MACHINE_IS_VM) 1956 return 1; 1957 strncpy_skip_quote(vmcmd_on_halt, str, 127); 1958 vmcmd_on_halt[127] = 0; 1959 on_halt_trigger.action = &vmcmd_action; 1960 return 1; 1961 } 1962 __setup("vmhalt=", vmcmd_on_halt_setup); 1963 1964 static int __init vmcmd_on_poff_setup(char *str) 1965 { 1966 if (!MACHINE_IS_VM) 1967 return 1; 1968 strncpy_skip_quote(vmcmd_on_poff, str, 127); 1969 vmcmd_on_poff[127] = 0; 1970 on_poff_trigger.action = &vmcmd_action; 1971 return 1; 1972 } 1973 __setup("vmpoff=", vmcmd_on_poff_setup); 1974 1975 static int on_panic_notify(struct notifier_block *self, 1976 unsigned long event, void *data) 1977 { 1978 do_panic(); 1979 return NOTIFY_OK; 1980 } 1981 1982 static struct notifier_block on_panic_nb = { 1983 .notifier_call = on_panic_notify, 1984 .priority = INT_MIN, 1985 }; 1986 1987 void __init setup_ipl(void) 1988 { 1989 ipl_info.type = get_ipl_type(); 1990 switch (ipl_info.type) { 1991 case IPL_TYPE_CCW: 1992 ipl_info.data.ccw.dev_id.devno = ipl_devno; 1993 ipl_info.data.ccw.dev_id.ssid = 0; 1994 break; 1995 case IPL_TYPE_FCP: 1996 case IPL_TYPE_FCP_DUMP: 1997 ipl_info.data.fcp.dev_id.devno = 1998 IPL_PARMBLOCK_START->ipl_info.fcp.devno; 1999 ipl_info.data.fcp.dev_id.ssid = 0; 2000 ipl_info.data.fcp.wwpn = IPL_PARMBLOCK_START->ipl_info.fcp.wwpn; 2001 ipl_info.data.fcp.lun = IPL_PARMBLOCK_START->ipl_info.fcp.lun; 2002 break; 2003 case IPL_TYPE_NSS: 2004 strncpy(ipl_info.data.nss.name, kernel_nss_name, 2005 sizeof(ipl_info.data.nss.name)); 2006 break; 2007 case IPL_TYPE_UNKNOWN: 2008 /* We have no info to copy */ 2009 break; 2010 } 2011 atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb); 2012 } 2013 2014 void __init ipl_update_parameters(void) 2015 { 2016 int rc; 2017 2018 rc = diag308(DIAG308_STORE, &ipl_block); 2019 if ((rc == DIAG308_RC_OK) || (rc == DIAG308_RC_NOCONFIG)) 2020 diag308_set_works = 1; 2021 } 2022 2023 void __init ipl_save_parameters(void) 2024 { 2025 struct cio_iplinfo iplinfo; 2026 void *src, *dst; 2027 2028 if (cio_get_iplinfo(&iplinfo)) 2029 return; 2030 2031 ipl_devno = iplinfo.devno; 2032 ipl_flags |= IPL_DEVNO_VALID; 2033 if (!iplinfo.is_qdio) 2034 return; 2035 ipl_flags |= IPL_PARMBLOCK_VALID; 2036 src = (void *)(unsigned long)S390_lowcore.ipl_parmblock_ptr; 2037 dst = (void *)IPL_PARMBLOCK_ORIGIN; 2038 memmove(dst, src, PAGE_SIZE); 2039 S390_lowcore.ipl_parmblock_ptr = IPL_PARMBLOCK_ORIGIN; 2040 } 2041 2042 static LIST_HEAD(rcall); 2043 static DEFINE_MUTEX(rcall_mutex); 2044 2045 void register_reset_call(struct reset_call *reset) 2046 { 2047 mutex_lock(&rcall_mutex); 2048 list_add(&reset->list, &rcall); 2049 mutex_unlock(&rcall_mutex); 2050 } 2051 EXPORT_SYMBOL_GPL(register_reset_call); 2052 2053 void unregister_reset_call(struct reset_call *reset) 2054 { 2055 mutex_lock(&rcall_mutex); 2056 list_del(&reset->list); 2057 mutex_unlock(&rcall_mutex); 2058 } 2059 EXPORT_SYMBOL_GPL(unregister_reset_call); 2060 2061 static void do_reset_calls(void) 2062 { 2063 struct reset_call *reset; 2064 2065 #ifdef CONFIG_64BIT 2066 if (diag308_set_works) { 2067 diag308_reset(); 2068 return; 2069 } 2070 #endif 2071 list_for_each_entry(reset, &rcall, list) 2072 reset->fn(); 2073 } 2074 2075 u32 dump_prefix_page; 2076 2077 void s390_reset_system(void (*func)(void *), void *data) 2078 { 2079 struct _lowcore *lc; 2080 2081 lc = (struct _lowcore *)(unsigned long) store_prefix(); 2082 2083 /* Stack for interrupt/machine check handler */ 2084 lc->panic_stack = S390_lowcore.panic_stack; 2085 2086 /* Save prefix page address for dump case */ 2087 dump_prefix_page = (u32)(unsigned long) lc; 2088 2089 /* Disable prefixing */ 2090 set_prefix(0); 2091 2092 /* Disable lowcore protection */ 2093 __ctl_clear_bit(0,28); 2094 2095 /* Set new machine check handler */ 2096 S390_lowcore.mcck_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT; 2097 S390_lowcore.mcck_new_psw.addr = 2098 PSW_ADDR_AMODE | (unsigned long) s390_base_mcck_handler; 2099 2100 /* Set new program check handler */ 2101 S390_lowcore.program_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT; 2102 S390_lowcore.program_new_psw.addr = 2103 PSW_ADDR_AMODE | (unsigned long) s390_base_pgm_handler; 2104 2105 /* 2106 * Clear subchannel ID and number to signal new kernel that no CCW or 2107 * SCSI IPL has been done (for kexec and kdump) 2108 */ 2109 S390_lowcore.subchannel_id = 0; 2110 S390_lowcore.subchannel_nr = 0; 2111 2112 /* Store status at absolute zero */ 2113 store_status(); 2114 2115 do_reset_calls(); 2116 if (func) 2117 func(data); 2118 } 2119