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