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