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