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