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