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