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 if (!reipl_block_actual) 1161 return; 1162 os_info_entry_add_data(OS_INFO_REIPL_BLOCK, reipl_block_actual, 1163 reipl_block_actual->hdr.len); 1164 } 1165 1166 /* reipl type */ 1167 1168 static int reipl_set_type(enum ipl_type type) 1169 { 1170 if (!(reipl_capabilities & type)) 1171 return -EINVAL; 1172 1173 switch(type) { 1174 case IPL_TYPE_CCW: 1175 reipl_block_actual = reipl_block_ccw; 1176 break; 1177 case IPL_TYPE_ECKD: 1178 reipl_block_actual = reipl_block_eckd; 1179 break; 1180 case IPL_TYPE_FCP: 1181 reipl_block_actual = reipl_block_fcp; 1182 break; 1183 case IPL_TYPE_NVME: 1184 reipl_block_actual = reipl_block_nvme; 1185 break; 1186 case IPL_TYPE_NSS: 1187 reipl_block_actual = reipl_block_nss; 1188 break; 1189 default: 1190 break; 1191 } 1192 reipl_type = type; 1193 return 0; 1194 } 1195 1196 static ssize_t reipl_type_show(struct kobject *kobj, 1197 struct kobj_attribute *attr, char *page) 1198 { 1199 return sysfs_emit(page, "%s\n", ipl_type_str(reipl_type)); 1200 } 1201 1202 static ssize_t reipl_type_store(struct kobject *kobj, 1203 struct kobj_attribute *attr, 1204 const char *buf, size_t len) 1205 { 1206 int rc = -EINVAL; 1207 1208 if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0) 1209 rc = reipl_set_type(IPL_TYPE_CCW); 1210 else if (strncmp(buf, IPL_ECKD_STR, strlen(IPL_ECKD_STR)) == 0) 1211 rc = reipl_set_type(IPL_TYPE_ECKD); 1212 else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0) 1213 rc = reipl_set_type(IPL_TYPE_FCP); 1214 else if (strncmp(buf, IPL_NVME_STR, strlen(IPL_NVME_STR)) == 0) 1215 rc = reipl_set_type(IPL_TYPE_NVME); 1216 else if (strncmp(buf, IPL_NSS_STR, strlen(IPL_NSS_STR)) == 0) 1217 rc = reipl_set_type(IPL_TYPE_NSS); 1218 return (rc != 0) ? rc : len; 1219 } 1220 1221 static struct kobj_attribute reipl_type_attr = 1222 __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store); 1223 1224 static struct kset *reipl_kset; 1225 static struct kset *reipl_fcp_kset; 1226 static struct kset *reipl_nvme_kset; 1227 static struct kset *reipl_eckd_kset; 1228 1229 static void __reipl_run(void *unused) 1230 { 1231 switch (reipl_type) { 1232 case IPL_TYPE_CCW: 1233 diag308(DIAG308_SET, reipl_block_ccw); 1234 if (reipl_ccw_clear) 1235 diag308(DIAG308_LOAD_CLEAR, NULL); 1236 else 1237 diag308(DIAG308_LOAD_NORMAL_DUMP, NULL); 1238 break; 1239 case IPL_TYPE_ECKD: 1240 diag308(DIAG308_SET, reipl_block_eckd); 1241 if (reipl_eckd_clear) 1242 diag308(DIAG308_LOAD_CLEAR, NULL); 1243 else 1244 diag308(DIAG308_LOAD_NORMAL, NULL); 1245 break; 1246 case IPL_TYPE_FCP: 1247 diag308(DIAG308_SET, reipl_block_fcp); 1248 if (reipl_fcp_clear) 1249 diag308(DIAG308_LOAD_CLEAR, NULL); 1250 else 1251 diag308(DIAG308_LOAD_NORMAL, NULL); 1252 break; 1253 case IPL_TYPE_NVME: 1254 diag308(DIAG308_SET, reipl_block_nvme); 1255 if (reipl_nvme_clear) 1256 diag308(DIAG308_LOAD_CLEAR, NULL); 1257 else 1258 diag308(DIAG308_LOAD_NORMAL, NULL); 1259 break; 1260 case IPL_TYPE_NSS: 1261 diag308(DIAG308_SET, reipl_block_nss); 1262 diag308(DIAG308_LOAD_CLEAR, NULL); 1263 break; 1264 case IPL_TYPE_UNKNOWN: 1265 diag308(DIAG308_LOAD_CLEAR, NULL); 1266 break; 1267 case IPL_TYPE_FCP_DUMP: 1268 case IPL_TYPE_NVME_DUMP: 1269 case IPL_TYPE_ECKD_DUMP: 1270 break; 1271 } 1272 disabled_wait(); 1273 } 1274 1275 static void reipl_run(struct shutdown_trigger *trigger) 1276 { 1277 smp_call_ipl_cpu(__reipl_run, NULL); 1278 } 1279 1280 static void reipl_block_ccw_init(struct ipl_parameter_block *ipb) 1281 { 1282 ipb->hdr.len = IPL_BP_CCW_LEN; 1283 ipb->hdr.version = IPL_PARM_BLOCK_VERSION; 1284 ipb->pb0_hdr.len = IPL_BP0_CCW_LEN; 1285 ipb->pb0_hdr.pbt = IPL_PBT_CCW; 1286 } 1287 1288 static void reipl_block_ccw_fill_parms(struct ipl_parameter_block *ipb) 1289 { 1290 /* LOADPARM */ 1291 /* check if read scp info worked and set loadparm */ 1292 if (sclp_ipl_info.is_valid) 1293 memcpy(ipb->ccw.loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN); 1294 else 1295 /* read scp info failed: set empty loadparm (EBCDIC blanks) */ 1296 memset(ipb->ccw.loadparm, 0x40, LOADPARM_LEN); 1297 ipb->ccw.flags = IPL_PB0_FLAG_LOADPARM; 1298 1299 /* VM PARM */ 1300 if (machine_is_vm() && ipl_block_valid && 1301 (ipl_block.ccw.vm_flags & IPL_PB0_CCW_VM_FLAG_VP)) { 1302 1303 ipb->ccw.vm_flags |= IPL_PB0_CCW_VM_FLAG_VP; 1304 ipb->ccw.vm_parm_len = ipl_block.ccw.vm_parm_len; 1305 memcpy(ipb->ccw.vm_parm, 1306 ipl_block.ccw.vm_parm, DIAG308_VMPARM_SIZE); 1307 } 1308 } 1309 1310 static int __init reipl_nss_init(void) 1311 { 1312 int rc; 1313 1314 if (!machine_is_vm()) 1315 return 0; 1316 1317 reipl_block_nss = (void *) get_zeroed_page(GFP_KERNEL); 1318 if (!reipl_block_nss) 1319 return -ENOMEM; 1320 1321 rc = sysfs_create_group(&reipl_kset->kobj, &reipl_nss_attr_group); 1322 if (rc) 1323 return rc; 1324 1325 reipl_block_ccw_init(reipl_block_nss); 1326 reipl_capabilities |= IPL_TYPE_NSS; 1327 return 0; 1328 } 1329 1330 static int __init reipl_ccw_init(void) 1331 { 1332 int rc; 1333 1334 reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL); 1335 if (!reipl_block_ccw) 1336 return -ENOMEM; 1337 1338 rc = sysfs_create_group(&reipl_kset->kobj, 1339 machine_is_vm() ? &reipl_ccw_attr_group_vm 1340 : &reipl_ccw_attr_group_lpar); 1341 if (rc) 1342 return rc; 1343 1344 reipl_block_ccw_init(reipl_block_ccw); 1345 if (ipl_info.type == IPL_TYPE_CCW) { 1346 reipl_block_ccw->ccw.ssid = ipl_block.ccw.ssid; 1347 reipl_block_ccw->ccw.devno = ipl_block.ccw.devno; 1348 reipl_block_ccw_fill_parms(reipl_block_ccw); 1349 } 1350 1351 reipl_capabilities |= IPL_TYPE_CCW; 1352 return 0; 1353 } 1354 1355 static int __init reipl_fcp_init(void) 1356 { 1357 int rc; 1358 1359 reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL); 1360 if (!reipl_block_fcp) 1361 return -ENOMEM; 1362 1363 /* sysfs: create fcp kset for mixing attr group and bin attrs */ 1364 reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL, 1365 &reipl_kset->kobj); 1366 if (!reipl_fcp_kset) { 1367 free_page((unsigned long) reipl_block_fcp); 1368 return -ENOMEM; 1369 } 1370 1371 rc = sysfs_create_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group); 1372 if (rc) 1373 goto out1; 1374 1375 if (test_facility(141)) { 1376 rc = sysfs_create_file(&reipl_fcp_kset->kobj, 1377 &sys_reipl_fcp_clear_attr.attr); 1378 if (rc) 1379 goto out2; 1380 } else { 1381 reipl_fcp_clear = true; 1382 } 1383 1384 if (ipl_info.type == IPL_TYPE_FCP) { 1385 memcpy(reipl_block_fcp, &ipl_block, sizeof(ipl_block)); 1386 /* 1387 * Fix loadparm: There are systems where the (SCSI) LOADPARM 1388 * is invalid in the SCSI IPL parameter block, so take it 1389 * always from sclp_ipl_info. 1390 */ 1391 memcpy(reipl_block_fcp->fcp.loadparm, sclp_ipl_info.loadparm, 1392 LOADPARM_LEN); 1393 } else { 1394 reipl_block_fcp->hdr.len = IPL_BP_FCP_LEN; 1395 reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION; 1396 reipl_block_fcp->fcp.len = IPL_BP0_FCP_LEN; 1397 reipl_block_fcp->fcp.pbt = IPL_PBT_FCP; 1398 reipl_block_fcp->fcp.opt = IPL_PB0_FCP_OPT_IPL; 1399 } 1400 reipl_capabilities |= IPL_TYPE_FCP; 1401 return 0; 1402 1403 out2: 1404 sysfs_remove_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group); 1405 out1: 1406 kset_unregister(reipl_fcp_kset); 1407 free_page((unsigned long) reipl_block_fcp); 1408 return rc; 1409 } 1410 1411 static int __init reipl_nvme_init(void) 1412 { 1413 int rc; 1414 1415 reipl_block_nvme = (void *) get_zeroed_page(GFP_KERNEL); 1416 if (!reipl_block_nvme) 1417 return -ENOMEM; 1418 1419 /* sysfs: create kset for mixing attr group and bin attrs */ 1420 reipl_nvme_kset = kset_create_and_add(IPL_NVME_STR, NULL, 1421 &reipl_kset->kobj); 1422 if (!reipl_nvme_kset) { 1423 free_page((unsigned long) reipl_block_nvme); 1424 return -ENOMEM; 1425 } 1426 1427 rc = sysfs_create_group(&reipl_nvme_kset->kobj, &reipl_nvme_attr_group); 1428 if (rc) 1429 goto out1; 1430 1431 if (test_facility(141)) { 1432 rc = sysfs_create_file(&reipl_nvme_kset->kobj, 1433 &sys_reipl_nvme_clear_attr.attr); 1434 if (rc) 1435 goto out2; 1436 } else { 1437 reipl_nvme_clear = true; 1438 } 1439 1440 if (ipl_info.type == IPL_TYPE_NVME) { 1441 memcpy(reipl_block_nvme, &ipl_block, sizeof(ipl_block)); 1442 /* 1443 * Fix loadparm: There are systems where the (SCSI) LOADPARM 1444 * is invalid in the IPL parameter block, so take it 1445 * always from sclp_ipl_info. 1446 */ 1447 memcpy(reipl_block_nvme->nvme.loadparm, sclp_ipl_info.loadparm, 1448 LOADPARM_LEN); 1449 } else { 1450 reipl_block_nvme->hdr.len = IPL_BP_NVME_LEN; 1451 reipl_block_nvme->hdr.version = IPL_PARM_BLOCK_VERSION; 1452 reipl_block_nvme->nvme.len = IPL_BP0_NVME_LEN; 1453 reipl_block_nvme->nvme.pbt = IPL_PBT_NVME; 1454 reipl_block_nvme->nvme.opt = IPL_PB0_NVME_OPT_IPL; 1455 } 1456 reipl_capabilities |= IPL_TYPE_NVME; 1457 return 0; 1458 1459 out2: 1460 sysfs_remove_group(&reipl_nvme_kset->kobj, &reipl_nvme_attr_group); 1461 out1: 1462 kset_unregister(reipl_nvme_kset); 1463 free_page((unsigned long) reipl_block_nvme); 1464 return rc; 1465 } 1466 1467 static int __init reipl_eckd_init(void) 1468 { 1469 int rc; 1470 1471 if (!sclp.has_sipl_eckd) 1472 return 0; 1473 1474 reipl_block_eckd = (void *)get_zeroed_page(GFP_KERNEL); 1475 if (!reipl_block_eckd) 1476 return -ENOMEM; 1477 1478 /* sysfs: create kset for mixing attr group and bin attrs */ 1479 reipl_eckd_kset = kset_create_and_add(IPL_ECKD_STR, NULL, 1480 &reipl_kset->kobj); 1481 if (!reipl_eckd_kset) { 1482 free_page((unsigned long)reipl_block_eckd); 1483 return -ENOMEM; 1484 } 1485 1486 rc = sysfs_create_group(&reipl_eckd_kset->kobj, &reipl_eckd_attr_group); 1487 if (rc) 1488 goto out1; 1489 1490 if (test_facility(141)) { 1491 rc = sysfs_create_file(&reipl_eckd_kset->kobj, 1492 &sys_reipl_eckd_clear_attr.attr); 1493 if (rc) 1494 goto out2; 1495 } else { 1496 reipl_eckd_clear = true; 1497 } 1498 1499 if (ipl_info.type == IPL_TYPE_ECKD) { 1500 memcpy(reipl_block_eckd, &ipl_block, sizeof(ipl_block)); 1501 } else { 1502 reipl_block_eckd->hdr.len = IPL_BP_ECKD_LEN; 1503 reipl_block_eckd->hdr.version = IPL_PARM_BLOCK_VERSION; 1504 reipl_block_eckd->eckd.len = IPL_BP0_ECKD_LEN; 1505 reipl_block_eckd->eckd.pbt = IPL_PBT_ECKD; 1506 reipl_block_eckd->eckd.opt = IPL_PB0_ECKD_OPT_IPL; 1507 } 1508 reipl_capabilities |= IPL_TYPE_ECKD; 1509 return 0; 1510 1511 out2: 1512 sysfs_remove_group(&reipl_eckd_kset->kobj, &reipl_eckd_attr_group); 1513 out1: 1514 kset_unregister(reipl_eckd_kset); 1515 free_page((unsigned long)reipl_block_eckd); 1516 return rc; 1517 } 1518 1519 static int __init reipl_type_init(void) 1520 { 1521 enum ipl_type reipl_type = ipl_info.type; 1522 struct ipl_parameter_block *reipl_block; 1523 unsigned long size; 1524 1525 reipl_block = os_info_old_entry(OS_INFO_REIPL_BLOCK, &size); 1526 if (!reipl_block) 1527 goto out; 1528 /* 1529 * If we have an OS info reipl block, this will be used 1530 */ 1531 if (reipl_block->pb0_hdr.pbt == IPL_PBT_FCP) { 1532 memcpy(reipl_block_fcp, reipl_block, size); 1533 reipl_type = IPL_TYPE_FCP; 1534 } else if (reipl_block->pb0_hdr.pbt == IPL_PBT_NVME) { 1535 memcpy(reipl_block_nvme, reipl_block, size); 1536 reipl_type = IPL_TYPE_NVME; 1537 } else if (reipl_block->pb0_hdr.pbt == IPL_PBT_CCW) { 1538 memcpy(reipl_block_ccw, reipl_block, size); 1539 reipl_type = IPL_TYPE_CCW; 1540 } else if (reipl_block->pb0_hdr.pbt == IPL_PBT_ECKD) { 1541 memcpy(reipl_block_eckd, reipl_block, size); 1542 reipl_type = IPL_TYPE_ECKD; 1543 } 1544 out: 1545 return reipl_set_type(reipl_type); 1546 } 1547 1548 static int __init reipl_init(void) 1549 { 1550 int rc; 1551 1552 reipl_kset = kset_create_and_add("reipl", NULL, firmware_kobj); 1553 if (!reipl_kset) 1554 return -ENOMEM; 1555 rc = sysfs_create_file(&reipl_kset->kobj, &reipl_type_attr.attr); 1556 if (rc) { 1557 kset_unregister(reipl_kset); 1558 return rc; 1559 } 1560 rc = reipl_ccw_init(); 1561 if (rc) 1562 return rc; 1563 rc = reipl_eckd_init(); 1564 if (rc) 1565 return rc; 1566 rc = reipl_fcp_init(); 1567 if (rc) 1568 return rc; 1569 rc = reipl_nvme_init(); 1570 if (rc) 1571 return rc; 1572 rc = reipl_nss_init(); 1573 if (rc) 1574 return rc; 1575 return reipl_type_init(); 1576 } 1577 1578 static struct shutdown_action __refdata reipl_action = { 1579 .name = SHUTDOWN_ACTION_REIPL_STR, 1580 .fn = reipl_run, 1581 .init = reipl_init, 1582 }; 1583 1584 /* 1585 * dump shutdown action: Dump Linux on shutdown. 1586 */ 1587 1588 /* FCP dump device attributes */ 1589 1590 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%llx\n", 1591 dump_block_fcp->fcp.wwpn); 1592 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%llx\n", 1593 dump_block_fcp->fcp.lun); 1594 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n", 1595 dump_block_fcp->fcp.br_lba); 1596 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n", 1597 dump_block_fcp->fcp.devno); 1598 DEFINE_IPL_ATTR_BOOTPROG_RW(dump_fcp, bootprog, "%lld\n", "%lld\n", 1599 dump_block_fcp->hdr, 1600 dump_block_fcp->fcp.bootprog); 1601 1602 DEFINE_IPL_ATTR_SCP_DATA_RW(dump_fcp, dump_block_fcp->hdr, 1603 dump_block_fcp->fcp, 1604 IPL_BP_FCP_LEN, IPL_BP0_FCP_LEN, 1605 DIAG308_SCPDATA_SIZE); 1606 1607 static struct attribute *dump_fcp_attrs[] = { 1608 &sys_dump_fcp_device_attr.attr, 1609 &sys_dump_fcp_wwpn_attr.attr, 1610 &sys_dump_fcp_lun_attr.attr, 1611 &sys_dump_fcp_bootprog_attr.attr, 1612 &sys_dump_fcp_br_lba_attr.attr, 1613 NULL, 1614 }; 1615 1616 static const struct bin_attribute *const dump_fcp_bin_attrs[] = { 1617 &sys_dump_fcp_scp_data_attr, 1618 NULL, 1619 }; 1620 1621 static const struct attribute_group dump_fcp_attr_group = { 1622 .name = IPL_FCP_STR, 1623 .attrs = dump_fcp_attrs, 1624 .bin_attrs = dump_fcp_bin_attrs, 1625 }; 1626 1627 /* NVME dump device attributes */ 1628 DEFINE_IPL_ATTR_RW(dump_nvme, fid, "0x%08llx\n", "%llx\n", 1629 dump_block_nvme->nvme.fid); 1630 DEFINE_IPL_ATTR_RW(dump_nvme, nsid, "0x%08llx\n", "%llx\n", 1631 dump_block_nvme->nvme.nsid); 1632 DEFINE_IPL_ATTR_RW(dump_nvme, br_lba, "%lld\n", "%llx\n", 1633 dump_block_nvme->nvme.br_lba); 1634 DEFINE_IPL_ATTR_BOOTPROG_RW(dump_nvme, bootprog, "%lld\n", "%llx\n", 1635 dump_block_nvme->hdr, 1636 dump_block_nvme->nvme.bootprog); 1637 1638 DEFINE_IPL_ATTR_SCP_DATA_RW(dump_nvme, dump_block_nvme->hdr, 1639 dump_block_nvme->nvme, 1640 IPL_BP_NVME_LEN, IPL_BP0_NVME_LEN, 1641 DIAG308_SCPDATA_SIZE); 1642 1643 static struct attribute *dump_nvme_attrs[] = { 1644 &sys_dump_nvme_fid_attr.attr, 1645 &sys_dump_nvme_nsid_attr.attr, 1646 &sys_dump_nvme_bootprog_attr.attr, 1647 &sys_dump_nvme_br_lba_attr.attr, 1648 NULL, 1649 }; 1650 1651 static const struct bin_attribute *const dump_nvme_bin_attrs[] = { 1652 &sys_dump_nvme_scp_data_attr, 1653 NULL, 1654 }; 1655 1656 static const struct attribute_group dump_nvme_attr_group = { 1657 .name = IPL_NVME_STR, 1658 .attrs = dump_nvme_attrs, 1659 .bin_attrs = dump_nvme_bin_attrs, 1660 }; 1661 1662 /* ECKD dump device attributes */ 1663 DEFINE_IPL_CCW_ATTR_RW(dump_eckd, device, dump_block_eckd->eckd); 1664 DEFINE_IPL_ATTR_BOOTPROG_RW(dump_eckd, bootprog, "%lld\n", "%llx\n", 1665 dump_block_eckd->hdr, 1666 dump_block_eckd->eckd.bootprog); 1667 1668 IPL_ATTR_BR_CHR_SHOW_FN(dump, dump_block_eckd->eckd); 1669 IPL_ATTR_BR_CHR_STORE_FN(dump, dump_block_eckd->eckd); 1670 1671 static struct kobj_attribute sys_dump_eckd_br_chr_attr = 1672 __ATTR(br_chr, 0644, eckd_dump_br_chr_show, eckd_dump_br_chr_store); 1673 1674 DEFINE_IPL_ATTR_SCP_DATA_RW(dump_eckd, dump_block_eckd->hdr, 1675 dump_block_eckd->eckd, 1676 IPL_BP_ECKD_LEN, IPL_BP0_ECKD_LEN, 1677 DIAG308_SCPDATA_SIZE); 1678 1679 static struct attribute *dump_eckd_attrs[] = { 1680 &sys_dump_eckd_device_attr.attr, 1681 &sys_dump_eckd_bootprog_attr.attr, 1682 &sys_dump_eckd_br_chr_attr.attr, 1683 NULL, 1684 }; 1685 1686 static const struct bin_attribute *const dump_eckd_bin_attrs[] = { 1687 &sys_dump_eckd_scp_data_attr, 1688 NULL, 1689 }; 1690 1691 static const struct attribute_group dump_eckd_attr_group = { 1692 .name = IPL_ECKD_STR, 1693 .attrs = dump_eckd_attrs, 1694 .bin_attrs = dump_eckd_bin_attrs, 1695 }; 1696 1697 /* CCW dump device attributes */ 1698 DEFINE_IPL_CCW_ATTR_RW(dump_ccw, device, dump_block_ccw->ccw); 1699 1700 static struct attribute *dump_ccw_attrs[] = { 1701 &sys_dump_ccw_device_attr.attr, 1702 NULL, 1703 }; 1704 1705 static struct attribute_group dump_ccw_attr_group = { 1706 .name = IPL_CCW_STR, 1707 .attrs = dump_ccw_attrs, 1708 }; 1709 1710 /* dump type */ 1711 1712 static int dump_set_type(enum dump_type type) 1713 { 1714 if (!(dump_capabilities & type)) 1715 return -EINVAL; 1716 dump_type = type; 1717 return 0; 1718 } 1719 1720 static ssize_t dump_type_show(struct kobject *kobj, 1721 struct kobj_attribute *attr, char *page) 1722 { 1723 return sysfs_emit(page, "%s\n", dump_type_str(dump_type)); 1724 } 1725 1726 static ssize_t dump_type_store(struct kobject *kobj, 1727 struct kobj_attribute *attr, 1728 const char *buf, size_t len) 1729 { 1730 int rc = -EINVAL; 1731 1732 if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0) 1733 rc = dump_set_type(DUMP_TYPE_NONE); 1734 else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0) 1735 rc = dump_set_type(DUMP_TYPE_CCW); 1736 else if (strncmp(buf, DUMP_ECKD_STR, strlen(DUMP_ECKD_STR)) == 0) 1737 rc = dump_set_type(DUMP_TYPE_ECKD); 1738 else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0) 1739 rc = dump_set_type(DUMP_TYPE_FCP); 1740 else if (strncmp(buf, DUMP_NVME_STR, strlen(DUMP_NVME_STR)) == 0) 1741 rc = dump_set_type(DUMP_TYPE_NVME); 1742 return (rc != 0) ? rc : len; 1743 } 1744 1745 static struct kobj_attribute dump_type_attr = 1746 __ATTR(dump_type, 0644, dump_type_show, dump_type_store); 1747 1748 static ssize_t dump_area_size_show(struct kobject *kobj, 1749 struct kobj_attribute *attr, char *page) 1750 { 1751 return sysfs_emit(page, "%lu\n", sclp.hsa_size); 1752 } 1753 1754 static struct kobj_attribute dump_area_size_attr = __ATTR_RO(dump_area_size); 1755 1756 static struct attribute *dump_attrs[] = { 1757 &dump_type_attr.attr, 1758 &dump_area_size_attr.attr, 1759 NULL, 1760 }; 1761 1762 static struct attribute_group dump_attr_group = { 1763 .attrs = dump_attrs, 1764 }; 1765 1766 static struct kset *dump_kset; 1767 1768 static void diag308_dump(void *dump_block) 1769 { 1770 diag308(DIAG308_SET, dump_block); 1771 while (1) { 1772 if (diag308(DIAG308_LOAD_NORMAL_DUMP, NULL) != 0x302) 1773 break; 1774 udelay(USEC_PER_SEC); 1775 } 1776 } 1777 1778 static void __dump_run(void *unused) 1779 { 1780 switch (dump_type) { 1781 case DUMP_TYPE_CCW: 1782 diag308_dump(dump_block_ccw); 1783 break; 1784 case DUMP_TYPE_ECKD: 1785 diag308_dump(dump_block_eckd); 1786 break; 1787 case DUMP_TYPE_FCP: 1788 diag308_dump(dump_block_fcp); 1789 break; 1790 case DUMP_TYPE_NVME: 1791 diag308_dump(dump_block_nvme); 1792 break; 1793 default: 1794 break; 1795 } 1796 } 1797 1798 static void dump_run(struct shutdown_trigger *trigger) 1799 { 1800 if (dump_type == DUMP_TYPE_NONE) 1801 return; 1802 smp_send_stop(); 1803 smp_call_ipl_cpu(__dump_run, NULL); 1804 } 1805 1806 static int __init dump_ccw_init(void) 1807 { 1808 int rc; 1809 1810 dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL); 1811 if (!dump_block_ccw) 1812 return -ENOMEM; 1813 rc = sysfs_create_group(&dump_kset->kobj, &dump_ccw_attr_group); 1814 if (rc) { 1815 free_page((unsigned long)dump_block_ccw); 1816 return rc; 1817 } 1818 dump_block_ccw->hdr.len = IPL_BP_CCW_LEN; 1819 dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION; 1820 dump_block_ccw->ccw.len = IPL_BP0_CCW_LEN; 1821 dump_block_ccw->ccw.pbt = IPL_PBT_CCW; 1822 dump_capabilities |= DUMP_TYPE_CCW; 1823 return 0; 1824 } 1825 1826 static int __init dump_fcp_init(void) 1827 { 1828 int rc; 1829 1830 if (!sclp_ipl_info.has_dump) 1831 return 0; /* LDIPL DUMP is not installed */ 1832 dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL); 1833 if (!dump_block_fcp) 1834 return -ENOMEM; 1835 rc = sysfs_create_group(&dump_kset->kobj, &dump_fcp_attr_group); 1836 if (rc) { 1837 free_page((unsigned long)dump_block_fcp); 1838 return rc; 1839 } 1840 dump_block_fcp->hdr.len = IPL_BP_FCP_LEN; 1841 dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION; 1842 dump_block_fcp->fcp.len = IPL_BP0_FCP_LEN; 1843 dump_block_fcp->fcp.pbt = IPL_PBT_FCP; 1844 dump_block_fcp->fcp.opt = IPL_PB0_FCP_OPT_DUMP; 1845 dump_capabilities |= DUMP_TYPE_FCP; 1846 return 0; 1847 } 1848 1849 static int __init dump_nvme_init(void) 1850 { 1851 int rc; 1852 1853 if (!sclp_ipl_info.has_dump) 1854 return 0; /* LDIPL DUMP is not installed */ 1855 dump_block_nvme = (void *) get_zeroed_page(GFP_KERNEL); 1856 if (!dump_block_nvme) 1857 return -ENOMEM; 1858 rc = sysfs_create_group(&dump_kset->kobj, &dump_nvme_attr_group); 1859 if (rc) { 1860 free_page((unsigned long)dump_block_nvme); 1861 return rc; 1862 } 1863 dump_block_nvme->hdr.len = IPL_BP_NVME_LEN; 1864 dump_block_nvme->hdr.version = IPL_PARM_BLOCK_VERSION; 1865 dump_block_nvme->nvme.len = IPL_BP0_NVME_LEN; 1866 dump_block_nvme->nvme.pbt = IPL_PBT_NVME; 1867 dump_block_nvme->nvme.opt = IPL_PB0_NVME_OPT_DUMP; 1868 dump_capabilities |= DUMP_TYPE_NVME; 1869 return 0; 1870 } 1871 1872 static int __init dump_eckd_init(void) 1873 { 1874 int rc; 1875 1876 if (!sclp_ipl_info.has_dump || !sclp.has_sipl_eckd) 1877 return 0; /* LDIPL DUMP is not installed */ 1878 dump_block_eckd = (void *)get_zeroed_page(GFP_KERNEL); 1879 if (!dump_block_eckd) 1880 return -ENOMEM; 1881 rc = sysfs_create_group(&dump_kset->kobj, &dump_eckd_attr_group); 1882 if (rc) { 1883 free_page((unsigned long)dump_block_eckd); 1884 return rc; 1885 } 1886 dump_block_eckd->hdr.len = IPL_BP_ECKD_LEN; 1887 dump_block_eckd->hdr.version = IPL_PARM_BLOCK_VERSION; 1888 dump_block_eckd->eckd.len = IPL_BP0_ECKD_LEN; 1889 dump_block_eckd->eckd.pbt = IPL_PBT_ECKD; 1890 dump_block_eckd->eckd.opt = IPL_PB0_ECKD_OPT_DUMP; 1891 dump_capabilities |= DUMP_TYPE_ECKD; 1892 return 0; 1893 } 1894 1895 static int __init dump_init(void) 1896 { 1897 int rc; 1898 1899 dump_kset = kset_create_and_add("dump", NULL, firmware_kobj); 1900 if (!dump_kset) 1901 return -ENOMEM; 1902 rc = sysfs_create_group(&dump_kset->kobj, &dump_attr_group); 1903 if (rc) { 1904 kset_unregister(dump_kset); 1905 return rc; 1906 } 1907 rc = dump_ccw_init(); 1908 if (rc) 1909 return rc; 1910 rc = dump_eckd_init(); 1911 if (rc) 1912 return rc; 1913 rc = dump_fcp_init(); 1914 if (rc) 1915 return rc; 1916 rc = dump_nvme_init(); 1917 if (rc) 1918 return rc; 1919 dump_set_type(DUMP_TYPE_NONE); 1920 return 0; 1921 } 1922 1923 static struct shutdown_action __refdata dump_action = { 1924 .name = SHUTDOWN_ACTION_DUMP_STR, 1925 .fn = dump_run, 1926 .init = dump_init, 1927 }; 1928 1929 static void dump_reipl_run(struct shutdown_trigger *trigger) 1930 { 1931 struct lowcore *abs_lc; 1932 unsigned long ipib = 0; 1933 unsigned int csum = 0; 1934 1935 /* 1936 * Set REIPL_CLEAR flag in os_info flags entry indicating 1937 * 'clear' sysfs attribute has been set on the panicked system 1938 * for specified reipl type. 1939 * Always set for IPL_TYPE_NSS and IPL_TYPE_UNKNOWN. 1940 */ 1941 if ((reipl_type == IPL_TYPE_CCW && reipl_ccw_clear) || 1942 (reipl_type == IPL_TYPE_ECKD && reipl_eckd_clear) || 1943 (reipl_type == IPL_TYPE_FCP && reipl_fcp_clear) || 1944 (reipl_type == IPL_TYPE_NVME && reipl_nvme_clear) || 1945 reipl_type == IPL_TYPE_NSS || 1946 reipl_type == IPL_TYPE_UNKNOWN) 1947 os_info_flags |= OS_INFO_FLAG_REIPL_CLEAR; 1948 os_info_entry_add_data(OS_INFO_FLAGS_ENTRY, &os_info_flags, sizeof(os_info_flags)); 1949 if (reipl_block_actual) { 1950 ipib = __pa(reipl_block_actual); 1951 csum = (__force unsigned int)cksm(reipl_block_actual, reipl_block_actual->hdr.len, 0); 1952 } 1953 abs_lc = get_abs_lowcore(); 1954 abs_lc->ipib = ipib; 1955 abs_lc->ipib_checksum = csum; 1956 put_abs_lowcore(abs_lc); 1957 dump_run(trigger); 1958 } 1959 1960 static struct shutdown_action __refdata dump_reipl_action = { 1961 .name = SHUTDOWN_ACTION_DUMP_REIPL_STR, 1962 .fn = dump_reipl_run, 1963 }; 1964 1965 /* 1966 * vmcmd shutdown action: Trigger vm command on shutdown. 1967 */ 1968 1969 #define VMCMD_MAX_SIZE 240 1970 1971 static char vmcmd_on_reboot[VMCMD_MAX_SIZE + 1]; 1972 static char vmcmd_on_panic[VMCMD_MAX_SIZE + 1]; 1973 static char vmcmd_on_halt[VMCMD_MAX_SIZE + 1]; 1974 static char vmcmd_on_poff[VMCMD_MAX_SIZE + 1]; 1975 static char vmcmd_on_restart[VMCMD_MAX_SIZE + 1]; 1976 1977 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_reboot, "%s\n", "%s\n", vmcmd_on_reboot); 1978 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_panic, "%s\n", "%s\n", vmcmd_on_panic); 1979 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_halt, "%s\n", "%s\n", vmcmd_on_halt); 1980 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_poff, "%s\n", "%s\n", vmcmd_on_poff); 1981 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_restart, "%s\n", "%s\n", vmcmd_on_restart); 1982 1983 static struct attribute *vmcmd_attrs[] = { 1984 &sys_vmcmd_on_reboot_attr.attr, 1985 &sys_vmcmd_on_panic_attr.attr, 1986 &sys_vmcmd_on_halt_attr.attr, 1987 &sys_vmcmd_on_poff_attr.attr, 1988 &sys_vmcmd_on_restart_attr.attr, 1989 NULL, 1990 }; 1991 1992 static struct attribute_group vmcmd_attr_group = { 1993 .attrs = vmcmd_attrs, 1994 }; 1995 1996 static struct kset *vmcmd_kset; 1997 1998 static void vmcmd_run(struct shutdown_trigger *trigger) 1999 { 2000 char *cmd; 2001 2002 if (strcmp(trigger->name, ON_REIPL_STR) == 0) 2003 cmd = vmcmd_on_reboot; 2004 else if (strcmp(trigger->name, ON_PANIC_STR) == 0) 2005 cmd = vmcmd_on_panic; 2006 else if (strcmp(trigger->name, ON_HALT_STR) == 0) 2007 cmd = vmcmd_on_halt; 2008 else if (strcmp(trigger->name, ON_POFF_STR) == 0) 2009 cmd = vmcmd_on_poff; 2010 else if (strcmp(trigger->name, ON_RESTART_STR) == 0) 2011 cmd = vmcmd_on_restart; 2012 else 2013 return; 2014 2015 if (strlen(cmd) == 0) 2016 return; 2017 __cpcmd(cmd, NULL, 0, NULL); 2018 } 2019 2020 static int vmcmd_init(void) 2021 { 2022 if (!machine_is_vm()) 2023 return -EOPNOTSUPP; 2024 vmcmd_kset = kset_create_and_add("vmcmd", NULL, firmware_kobj); 2025 if (!vmcmd_kset) 2026 return -ENOMEM; 2027 return sysfs_create_group(&vmcmd_kset->kobj, &vmcmd_attr_group); 2028 } 2029 2030 static struct shutdown_action vmcmd_action = { 2031 .name = SHUTDOWN_ACTION_VMCMD_STR, 2032 .fn = vmcmd_run, 2033 .init = vmcmd_init 2034 }; 2035 2036 /* 2037 * stop shutdown action: Stop Linux on shutdown. 2038 */ 2039 2040 static void stop_run(struct shutdown_trigger *trigger) 2041 { 2042 if (strcmp(trigger->name, ON_PANIC_STR) == 0 || 2043 strcmp(trigger->name, ON_RESTART_STR) == 0) 2044 disabled_wait(); 2045 smp_stop_cpu(); 2046 } 2047 2048 static struct shutdown_action stop_action = { 2049 .name = SHUTDOWN_ACTION_STOP_STR, 2050 .fn = stop_run 2051 }; 2052 2053 /* action list */ 2054 2055 static struct shutdown_action *shutdown_actions_list[] = { 2056 &ipl_action, 2057 &reipl_action, 2058 &dump_reipl_action, 2059 &dump_action, 2060 &vmcmd_action, 2061 &stop_action 2062 }; 2063 2064 /* 2065 * Trigger section 2066 */ 2067 2068 static struct kset *shutdown_actions_kset; 2069 2070 static int set_trigger(const char *buf, struct shutdown_trigger *trigger, 2071 size_t len) 2072 { 2073 int i; 2074 2075 for (i = 0; i < ARRAY_SIZE(shutdown_actions_list); i++) { 2076 if (sysfs_streq(buf, shutdown_actions_list[i]->name)) { 2077 if (shutdown_actions_list[i]->init_rc) { 2078 return shutdown_actions_list[i]->init_rc; 2079 } else { 2080 trigger->action = shutdown_actions_list[i]; 2081 return len; 2082 } 2083 } 2084 } 2085 return -EINVAL; 2086 } 2087 2088 /* on reipl */ 2089 2090 static struct shutdown_trigger on_reboot_trigger = { 2091 .name = ON_REIPL_STR, 2092 .action = &reipl_action 2093 }; 2094 2095 static ssize_t on_reboot_show(struct kobject *kobj, 2096 struct kobj_attribute *attr, char *page) 2097 { 2098 return sysfs_emit(page, "%s\n", on_reboot_trigger.action->name); 2099 } 2100 2101 static ssize_t on_reboot_store(struct kobject *kobj, 2102 struct kobj_attribute *attr, 2103 const char *buf, size_t len) 2104 { 2105 return set_trigger(buf, &on_reboot_trigger, len); 2106 } 2107 static struct kobj_attribute on_reboot_attr = __ATTR_RW(on_reboot); 2108 2109 static void do_machine_restart(char *__unused) 2110 { 2111 smp_send_stop(); 2112 on_reboot_trigger.action->fn(&on_reboot_trigger); 2113 reipl_run(NULL); 2114 } 2115 void (*_machine_restart)(char *command) = do_machine_restart; 2116 2117 /* on panic */ 2118 static struct shutdown_trigger on_panic_trigger = { 2119 .name = ON_PANIC_STR, 2120 .action = &stop_action 2121 }; 2122 2123 static ssize_t on_panic_show(struct kobject *kobj, 2124 struct kobj_attribute *attr, char *page) 2125 { 2126 return sysfs_emit(page, "%s\n", on_panic_trigger.action->name); 2127 } 2128 2129 static ssize_t on_panic_store(struct kobject *kobj, 2130 struct kobj_attribute *attr, 2131 const char *buf, size_t len) 2132 { 2133 return set_trigger(buf, &on_panic_trigger, len); 2134 } 2135 static struct kobj_attribute on_panic_attr = __ATTR_RW(on_panic); 2136 2137 static void do_panic(void) 2138 { 2139 lgr_info_log(); 2140 on_panic_trigger.action->fn(&on_panic_trigger); 2141 stop_run(&on_panic_trigger); 2142 } 2143 2144 /* on restart */ 2145 static struct shutdown_trigger on_restart_trigger = { 2146 .name = ON_RESTART_STR, 2147 .action = &stop_action 2148 }; 2149 2150 static ssize_t on_restart_show(struct kobject *kobj, 2151 struct kobj_attribute *attr, char *page) 2152 { 2153 return sysfs_emit(page, "%s\n", on_restart_trigger.action->name); 2154 } 2155 2156 static ssize_t on_restart_store(struct kobject *kobj, 2157 struct kobj_attribute *attr, 2158 const char *buf, size_t len) 2159 { 2160 return set_trigger(buf, &on_restart_trigger, len); 2161 } 2162 static struct kobj_attribute on_restart_attr = __ATTR_RW(on_restart); 2163 2164 static void __do_restart(void *ignore) 2165 { 2166 smp_send_stop(); 2167 #ifdef CONFIG_CRASH_DUMP 2168 crash_kexec(NULL); 2169 #endif 2170 on_restart_trigger.action->fn(&on_restart_trigger); 2171 stop_run(&on_restart_trigger); 2172 } 2173 2174 void do_restart(void *arg) 2175 { 2176 tracing_off(); 2177 debug_locks_off(); 2178 lgr_info_log(); 2179 smp_call_ipl_cpu(__do_restart, arg); 2180 } 2181 2182 /* on halt */ 2183 static struct shutdown_trigger on_halt_trigger = { 2184 .name = ON_HALT_STR, 2185 .action = &stop_action 2186 }; 2187 2188 static ssize_t on_halt_show(struct kobject *kobj, 2189 struct kobj_attribute *attr, char *page) 2190 { 2191 return sysfs_emit(page, "%s\n", on_halt_trigger.action->name); 2192 } 2193 2194 static ssize_t on_halt_store(struct kobject *kobj, 2195 struct kobj_attribute *attr, 2196 const char *buf, size_t len) 2197 { 2198 return set_trigger(buf, &on_halt_trigger, len); 2199 } 2200 static struct kobj_attribute on_halt_attr = __ATTR_RW(on_halt); 2201 2202 static void do_machine_halt(void) 2203 { 2204 smp_send_stop(); 2205 on_halt_trigger.action->fn(&on_halt_trigger); 2206 stop_run(&on_halt_trigger); 2207 } 2208 void (*_machine_halt)(void) = do_machine_halt; 2209 2210 /* on power off */ 2211 static struct shutdown_trigger on_poff_trigger = { 2212 .name = ON_POFF_STR, 2213 .action = &stop_action 2214 }; 2215 2216 static ssize_t on_poff_show(struct kobject *kobj, 2217 struct kobj_attribute *attr, char *page) 2218 { 2219 return sysfs_emit(page, "%s\n", on_poff_trigger.action->name); 2220 } 2221 2222 static ssize_t on_poff_store(struct kobject *kobj, 2223 struct kobj_attribute *attr, 2224 const char *buf, size_t len) 2225 { 2226 return set_trigger(buf, &on_poff_trigger, len); 2227 } 2228 static struct kobj_attribute on_poff_attr = __ATTR_RW(on_poff); 2229 2230 static void do_machine_power_off(void) 2231 { 2232 smp_send_stop(); 2233 on_poff_trigger.action->fn(&on_poff_trigger); 2234 stop_run(&on_poff_trigger); 2235 } 2236 void (*_machine_power_off)(void) = do_machine_power_off; 2237 2238 static struct attribute *shutdown_action_attrs[] = { 2239 &on_restart_attr.attr, 2240 &on_reboot_attr.attr, 2241 &on_panic_attr.attr, 2242 &on_halt_attr.attr, 2243 &on_poff_attr.attr, 2244 NULL, 2245 }; 2246 2247 static struct attribute_group shutdown_action_attr_group = { 2248 .attrs = shutdown_action_attrs, 2249 }; 2250 2251 static void __init shutdown_triggers_init(void) 2252 { 2253 shutdown_actions_kset = kset_create_and_add("shutdown_actions", NULL, 2254 firmware_kobj); 2255 if (!shutdown_actions_kset) 2256 goto fail; 2257 if (sysfs_create_group(&shutdown_actions_kset->kobj, 2258 &shutdown_action_attr_group)) 2259 goto fail; 2260 return; 2261 fail: 2262 panic("shutdown_triggers_init failed\n"); 2263 } 2264 2265 static void __init shutdown_actions_init(void) 2266 { 2267 int i; 2268 2269 for (i = 0; i < ARRAY_SIZE(shutdown_actions_list); i++) { 2270 if (!shutdown_actions_list[i]->init) 2271 continue; 2272 shutdown_actions_list[i]->init_rc = 2273 shutdown_actions_list[i]->init(); 2274 } 2275 } 2276 2277 static int __init s390_ipl_init(void) 2278 { 2279 char str[8] = {0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40}; 2280 2281 sclp_early_get_ipl_info(&sclp_ipl_info); 2282 /* 2283 * Fix loadparm: There are systems where the (SCSI) LOADPARM 2284 * returned by read SCP info is invalid (contains EBCDIC blanks) 2285 * when the system has been booted via diag308. In that case we use 2286 * the value from diag308, if available. 2287 * 2288 * There are also systems where diag308 store does not work in 2289 * case the system is booted from HMC. Fortunately in this case 2290 * READ SCP info provides the correct value. 2291 */ 2292 if (memcmp(sclp_ipl_info.loadparm, str, sizeof(str)) == 0 && ipl_block_valid) 2293 memcpy(sclp_ipl_info.loadparm, ipl_block.ccw.loadparm, LOADPARM_LEN); 2294 shutdown_actions_init(); 2295 shutdown_triggers_init(); 2296 return 0; 2297 } 2298 2299 __initcall(s390_ipl_init); 2300 2301 static void __init strscpy_skip_quote(char *dst, char *src, int n) 2302 { 2303 int sx, dx; 2304 2305 if (!n) 2306 return; 2307 for (sx = 0, dx = 0; src[sx]; sx++) { 2308 if (src[sx] == '"') 2309 continue; 2310 dst[dx] = src[sx]; 2311 if (dx + 1 == n) 2312 break; 2313 dx++; 2314 } 2315 dst[dx] = '\0'; 2316 } 2317 2318 static int __init vmcmd_on_reboot_setup(char *str) 2319 { 2320 if (!machine_is_vm()) 2321 return 1; 2322 strscpy_skip_quote(vmcmd_on_reboot, str, sizeof(vmcmd_on_reboot)); 2323 on_reboot_trigger.action = &vmcmd_action; 2324 return 1; 2325 } 2326 __setup("vmreboot=", vmcmd_on_reboot_setup); 2327 2328 static int __init vmcmd_on_panic_setup(char *str) 2329 { 2330 if (!machine_is_vm()) 2331 return 1; 2332 strscpy_skip_quote(vmcmd_on_panic, str, sizeof(vmcmd_on_panic)); 2333 on_panic_trigger.action = &vmcmd_action; 2334 return 1; 2335 } 2336 __setup("vmpanic=", vmcmd_on_panic_setup); 2337 2338 static int __init vmcmd_on_halt_setup(char *str) 2339 { 2340 if (!machine_is_vm()) 2341 return 1; 2342 strscpy_skip_quote(vmcmd_on_halt, str, sizeof(vmcmd_on_halt)); 2343 on_halt_trigger.action = &vmcmd_action; 2344 return 1; 2345 } 2346 __setup("vmhalt=", vmcmd_on_halt_setup); 2347 2348 static int __init vmcmd_on_poff_setup(char *str) 2349 { 2350 if (!machine_is_vm()) 2351 return 1; 2352 strscpy_skip_quote(vmcmd_on_poff, str, sizeof(vmcmd_on_poff)); 2353 on_poff_trigger.action = &vmcmd_action; 2354 return 1; 2355 } 2356 __setup("vmpoff=", vmcmd_on_poff_setup); 2357 2358 static int on_panic_notify(struct notifier_block *self, 2359 unsigned long event, void *data) 2360 { 2361 do_panic(); 2362 return NOTIFY_OK; 2363 } 2364 2365 static struct notifier_block on_panic_nb = { 2366 .notifier_call = on_panic_notify, 2367 .priority = INT_MIN, 2368 }; 2369 2370 void __init setup_ipl(void) 2371 { 2372 BUILD_BUG_ON(sizeof(struct ipl_parameter_block) != PAGE_SIZE); 2373 2374 ipl_info.type = get_ipl_type(); 2375 switch (ipl_info.type) { 2376 case IPL_TYPE_CCW: 2377 ipl_info.data.ccw.dev_id.ssid = ipl_block.ccw.ssid; 2378 ipl_info.data.ccw.dev_id.devno = ipl_block.ccw.devno; 2379 break; 2380 case IPL_TYPE_ECKD: 2381 case IPL_TYPE_ECKD_DUMP: 2382 ipl_info.data.eckd.dev_id.ssid = ipl_block.eckd.ssid; 2383 ipl_info.data.eckd.dev_id.devno = ipl_block.eckd.devno; 2384 break; 2385 case IPL_TYPE_FCP: 2386 case IPL_TYPE_FCP_DUMP: 2387 ipl_info.data.fcp.dev_id.ssid = 0; 2388 ipl_info.data.fcp.dev_id.devno = ipl_block.fcp.devno; 2389 ipl_info.data.fcp.wwpn = ipl_block.fcp.wwpn; 2390 ipl_info.data.fcp.lun = ipl_block.fcp.lun; 2391 break; 2392 case IPL_TYPE_NVME: 2393 case IPL_TYPE_NVME_DUMP: 2394 ipl_info.data.nvme.fid = ipl_block.nvme.fid; 2395 ipl_info.data.nvme.nsid = ipl_block.nvme.nsid; 2396 break; 2397 case IPL_TYPE_NSS: 2398 case IPL_TYPE_UNKNOWN: 2399 /* We have no info to copy */ 2400 break; 2401 } 2402 atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb); 2403 } 2404 2405 void __no_stack_protector s390_reset_system(void) 2406 { 2407 /* Disable prefixing */ 2408 set_prefix(0); 2409 2410 /* Disable lowcore protection */ 2411 local_ctl_clear_bit(0, CR0_LOW_ADDRESS_PROTECTION_BIT); 2412 diag_amode31_ops.diag308_reset(); 2413 } 2414 2415 bool arch_get_secureboot(void) 2416 { 2417 return ipl_secure_flag; 2418 } 2419 2420 #ifdef CONFIG_KEXEC_FILE 2421 2422 int ipl_report_add_component(struct ipl_report *report, struct kexec_buf *kbuf, 2423 unsigned char flags, unsigned short cert) 2424 { 2425 struct ipl_report_component *comp; 2426 2427 comp = vzalloc(sizeof(*comp)); 2428 if (!comp) 2429 return -ENOMEM; 2430 list_add_tail(&comp->list, &report->components); 2431 2432 comp->entry.addr = kbuf->mem; 2433 comp->entry.len = kbuf->memsz; 2434 comp->entry.flags = flags; 2435 comp->entry.certificate_index = cert; 2436 2437 report->size += sizeof(comp->entry); 2438 2439 return 0; 2440 } 2441 2442 int ipl_report_add_certificate(struct ipl_report *report, void *key, 2443 unsigned long addr, unsigned long len) 2444 { 2445 struct ipl_report_certificate *cert; 2446 2447 cert = vzalloc(sizeof(*cert)); 2448 if (!cert) 2449 return -ENOMEM; 2450 list_add_tail(&cert->list, &report->certificates); 2451 2452 cert->entry.addr = addr; 2453 cert->entry.len = len; 2454 cert->key = key; 2455 2456 report->size += sizeof(cert->entry); 2457 report->size += cert->entry.len; 2458 2459 return 0; 2460 } 2461 2462 struct ipl_report *ipl_report_init(struct ipl_parameter_block *ipib) 2463 { 2464 struct ipl_report *report; 2465 2466 report = vzalloc(sizeof(*report)); 2467 if (!report) 2468 return ERR_PTR(-ENOMEM); 2469 2470 report->ipib = ipib; 2471 INIT_LIST_HEAD(&report->components); 2472 INIT_LIST_HEAD(&report->certificates); 2473 2474 report->size = ALIGN(ipib->hdr.len, 8); 2475 report->size += sizeof(struct ipl_rl_hdr); 2476 report->size += sizeof(struct ipl_rb_components); 2477 report->size += sizeof(struct ipl_rb_certificates); 2478 2479 return report; 2480 } 2481 2482 void *ipl_report_finish(struct ipl_report *report) 2483 { 2484 struct ipl_report_certificate *cert; 2485 struct ipl_report_component *comp; 2486 struct ipl_rb_certificates *certs; 2487 struct ipl_parameter_block *ipib; 2488 struct ipl_rb_components *comps; 2489 struct ipl_rl_hdr *rl_hdr; 2490 void *buf, *ptr; 2491 2492 buf = vzalloc(report->size); 2493 if (!buf) 2494 goto out; 2495 ptr = buf; 2496 2497 memcpy(ptr, report->ipib, report->ipib->hdr.len); 2498 ipib = ptr; 2499 if (ipl_secure_flag) 2500 ipib->hdr.flags |= IPL_PL_FLAG_SIPL; 2501 ipib->hdr.flags |= IPL_PL_FLAG_IPLSR; 2502 ptr += report->ipib->hdr.len; 2503 ptr = PTR_ALIGN(ptr, 8); 2504 2505 rl_hdr = ptr; 2506 ptr += sizeof(*rl_hdr); 2507 2508 comps = ptr; 2509 comps->rbt = IPL_RBT_COMPONENTS; 2510 ptr += sizeof(*comps); 2511 list_for_each_entry(comp, &report->components, list) { 2512 memcpy(ptr, &comp->entry, sizeof(comp->entry)); 2513 ptr += sizeof(comp->entry); 2514 } 2515 comps->len = ptr - (void *)comps; 2516 2517 certs = ptr; 2518 certs->rbt = IPL_RBT_CERTIFICATES; 2519 ptr += sizeof(*certs); 2520 list_for_each_entry(cert, &report->certificates, list) { 2521 memcpy(ptr, &cert->entry, sizeof(cert->entry)); 2522 ptr += sizeof(cert->entry); 2523 } 2524 certs->len = ptr - (void *)certs; 2525 rl_hdr->len = ptr - (void *)rl_hdr; 2526 2527 list_for_each_entry(cert, &report->certificates, list) { 2528 memcpy(ptr, cert->key, cert->entry.len); 2529 ptr += cert->entry.len; 2530 } 2531 2532 BUG_ON(ptr > buf + report->size); 2533 out: 2534 return buf; 2535 } 2536 2537 int ipl_report_free(struct ipl_report *report) 2538 { 2539 struct ipl_report_component *comp, *ncomp; 2540 struct ipl_report_certificate *cert, *ncert; 2541 2542 list_for_each_entry_safe(comp, ncomp, &report->components, list) 2543 vfree(comp); 2544 2545 list_for_each_entry_safe(cert, ncert, &report->certificates, list) 2546 vfree(cert); 2547 2548 vfree(report); 2549 2550 return 0; 2551 } 2552 2553 #endif 2554