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