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