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