s390/kernel/ipl.c

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