Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  *    ipl/reipl/dump support for Linux on s390.
0004  *
0005  *    Copyright IBM Corp. 2005, 2012
0006  *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
0007  *       Volker Sameske <sameske@de.ibm.com>
0008  */
0009 
0010 #include <linux/types.h>
0011 #include <linux/export.h>
0012 #include <linux/init.h>
0013 #include <linux/device.h>
0014 #include <linux/delay.h>
0015 #include <linux/panic_notifier.h>
0016 #include <linux/reboot.h>
0017 #include <linux/ctype.h>
0018 #include <linux/fs.h>
0019 #include <linux/gfp.h>
0020 #include <linux/crash_dump.h>
0021 #include <linux/debug_locks.h>
0022 #include <asm/asm-extable.h>
0023 #include <asm/diag.h>
0024 #include <asm/ipl.h>
0025 #include <asm/smp.h>
0026 #include <asm/setup.h>
0027 #include <asm/cpcmd.h>
0028 #include <asm/ebcdic.h>
0029 #include <asm/sclp.h>
0030 #include <asm/checksum.h>
0031 #include <asm/debug.h>
0032 #include <asm/os_info.h>
0033 #include <asm/sections.h>
0034 #include <asm/boot_data.h>
0035 #include "entry.h"
0036 
0037 #define IPL_PARM_BLOCK_VERSION 0
0038 
0039 #define IPL_UNKNOWN_STR     "unknown"
0040 #define IPL_CCW_STR     "ccw"
0041 #define IPL_FCP_STR     "fcp"
0042 #define IPL_FCP_DUMP_STR    "fcp_dump"
0043 #define IPL_NVME_STR        "nvme"
0044 #define IPL_NVME_DUMP_STR   "nvme_dump"
0045 #define IPL_NSS_STR     "nss"
0046 
0047 #define DUMP_CCW_STR        "ccw"
0048 #define DUMP_FCP_STR        "fcp"
0049 #define DUMP_NVME_STR       "nvme"
0050 #define DUMP_NONE_STR       "none"
0051 
0052 /*
0053  * Four shutdown trigger types are supported:
0054  * - panic
0055  * - halt
0056  * - power off
0057  * - reipl
0058  * - restart
0059  */
0060 #define ON_PANIC_STR        "on_panic"
0061 #define ON_HALT_STR     "on_halt"
0062 #define ON_POFF_STR     "on_poff"
0063 #define ON_REIPL_STR        "on_reboot"
0064 #define ON_RESTART_STR      "on_restart"
0065 
0066 struct shutdown_action;
0067 struct shutdown_trigger {
0068     char *name;
0069     struct shutdown_action *action;
0070 };
0071 
0072 /*
0073  * The following shutdown action types are supported:
0074  */
0075 #define SHUTDOWN_ACTION_IPL_STR     "ipl"
0076 #define SHUTDOWN_ACTION_REIPL_STR   "reipl"
0077 #define SHUTDOWN_ACTION_DUMP_STR    "dump"
0078 #define SHUTDOWN_ACTION_VMCMD_STR   "vmcmd"
0079 #define SHUTDOWN_ACTION_STOP_STR    "stop"
0080 #define SHUTDOWN_ACTION_DUMP_REIPL_STR  "dump_reipl"
0081 
0082 struct shutdown_action {
0083     char *name;
0084     void (*fn) (struct shutdown_trigger *trigger);
0085     int (*init) (void);
0086     int init_rc;
0087 };
0088 
0089 static char *ipl_type_str(enum ipl_type type)
0090 {
0091     switch (type) {
0092     case IPL_TYPE_CCW:
0093         return IPL_CCW_STR;
0094     case IPL_TYPE_FCP:
0095         return IPL_FCP_STR;
0096     case IPL_TYPE_FCP_DUMP:
0097         return IPL_FCP_DUMP_STR;
0098     case IPL_TYPE_NSS:
0099         return IPL_NSS_STR;
0100     case IPL_TYPE_NVME:
0101         return IPL_NVME_STR;
0102     case IPL_TYPE_NVME_DUMP:
0103         return IPL_NVME_DUMP_STR;
0104     case IPL_TYPE_UNKNOWN:
0105     default:
0106         return IPL_UNKNOWN_STR;
0107     }
0108 }
0109 
0110 enum dump_type {
0111     DUMP_TYPE_NONE  = 1,
0112     DUMP_TYPE_CCW   = 2,
0113     DUMP_TYPE_FCP   = 4,
0114     DUMP_TYPE_NVME  = 8,
0115 };
0116 
0117 static char *dump_type_str(enum dump_type type)
0118 {
0119     switch (type) {
0120     case DUMP_TYPE_NONE:
0121         return DUMP_NONE_STR;
0122     case DUMP_TYPE_CCW:
0123         return DUMP_CCW_STR;
0124     case DUMP_TYPE_FCP:
0125         return DUMP_FCP_STR;
0126     case DUMP_TYPE_NVME:
0127         return DUMP_NVME_STR;
0128     default:
0129         return NULL;
0130     }
0131 }
0132 
0133 int __bootdata_preserved(ipl_block_valid);
0134 struct ipl_parameter_block __bootdata_preserved(ipl_block);
0135 int __bootdata_preserved(ipl_secure_flag);
0136 
0137 unsigned long __bootdata_preserved(ipl_cert_list_addr);
0138 unsigned long __bootdata_preserved(ipl_cert_list_size);
0139 
0140 unsigned long __bootdata(early_ipl_comp_list_addr);
0141 unsigned long __bootdata(early_ipl_comp_list_size);
0142 
0143 static int reipl_capabilities = IPL_TYPE_UNKNOWN;
0144 
0145 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
0146 static struct ipl_parameter_block *reipl_block_fcp;
0147 static struct ipl_parameter_block *reipl_block_nvme;
0148 static struct ipl_parameter_block *reipl_block_ccw;
0149 static struct ipl_parameter_block *reipl_block_nss;
0150 static struct ipl_parameter_block *reipl_block_actual;
0151 
0152 static int dump_capabilities = DUMP_TYPE_NONE;
0153 static enum dump_type dump_type = DUMP_TYPE_NONE;
0154 static struct ipl_parameter_block *dump_block_fcp;
0155 static struct ipl_parameter_block *dump_block_nvme;
0156 static struct ipl_parameter_block *dump_block_ccw;
0157 
0158 static struct sclp_ipl_info sclp_ipl_info;
0159 
0160 static bool reipl_nvme_clear;
0161 static bool reipl_fcp_clear;
0162 static bool reipl_ccw_clear;
0163 
0164 static inline int __diag308(unsigned long subcode, void *addr)
0165 {
0166     union register_pair r1;
0167 
0168     r1.even = (unsigned long) addr;
0169     r1.odd  = 0;
0170     asm volatile(
0171         "   diag    %[r1],%[subcode],0x308\n"
0172         "0: nopr    %%r7\n"
0173         EX_TABLE(0b,0b)
0174         : [r1] "+&d" (r1.pair)
0175         : [subcode] "d" (subcode)
0176         : "cc", "memory");
0177     return r1.odd;
0178 }
0179 
0180 int diag308(unsigned long subcode, void *addr)
0181 {
0182     diag_stat_inc(DIAG_STAT_X308);
0183     return __diag308(subcode, addr);
0184 }
0185 EXPORT_SYMBOL_GPL(diag308);
0186 
0187 /* SYSFS */
0188 
0189 #define IPL_ATTR_SHOW_FN(_prefix, _name, _format, args...)      \
0190 static ssize_t sys_##_prefix##_##_name##_show(struct kobject *kobj, \
0191         struct kobj_attribute *attr,                \
0192         char *page)                     \
0193 {                                   \
0194     return scnprintf(page, PAGE_SIZE, _format, ##args);     \
0195 }
0196 
0197 #define IPL_ATTR_CCW_STORE_FN(_prefix, _name, _ipl_blk)         \
0198 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj,    \
0199         struct kobj_attribute *attr,                \
0200         const char *buf, size_t len)                \
0201 {                                   \
0202     unsigned long long ssid, devno;                 \
0203                                     \
0204     if (sscanf(buf, "0.%llx.%llx\n", &ssid, &devno) != 2)       \
0205         return -EINVAL;                     \
0206                                     \
0207     if (ssid > __MAX_SSID || devno > __MAX_SUBCHANNEL)      \
0208         return -EINVAL;                     \
0209                                     \
0210     _ipl_blk.ssid = ssid;                       \
0211     _ipl_blk.devno = devno;                     \
0212     return len;                         \
0213 }
0214 
0215 #define DEFINE_IPL_CCW_ATTR_RW(_prefix, _name, _ipl_blk)        \
0216 IPL_ATTR_SHOW_FN(_prefix, _name, "0.%x.%04x\n",             \
0217          _ipl_blk.ssid, _ipl_blk.devno);            \
0218 IPL_ATTR_CCW_STORE_FN(_prefix, _name, _ipl_blk);            \
0219 static struct kobj_attribute sys_##_prefix##_##_name##_attr =       \
0220     __ATTR(_name, (S_IRUGO | S_IWUSR),              \
0221            sys_##_prefix##_##_name##_show,              \
0222            sys_##_prefix##_##_name##_store)             \
0223 
0224 #define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value)     \
0225 IPL_ATTR_SHOW_FN(_prefix, _name, _format, _value)           \
0226 static struct kobj_attribute sys_##_prefix##_##_name##_attr =       \
0227     __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL)
0228 
0229 #define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)   \
0230 IPL_ATTR_SHOW_FN(_prefix, _name, _fmt_out, (unsigned long long) _value) \
0231 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj,    \
0232         struct kobj_attribute *attr,                \
0233         const char *buf, size_t len)                \
0234 {                                   \
0235     unsigned long long value;                   \
0236     if (sscanf(buf, _fmt_in, &value) != 1)              \
0237         return -EINVAL;                     \
0238     _value = value;                         \
0239     return len;                         \
0240 }                                   \
0241 static struct kobj_attribute sys_##_prefix##_##_name##_attr =       \
0242     __ATTR(_name,(S_IRUGO | S_IWUSR),               \
0243             sys_##_prefix##_##_name##_show,         \
0244             sys_##_prefix##_##_name##_store)
0245 
0246 #define DEFINE_IPL_ATTR_STR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)\
0247 IPL_ATTR_SHOW_FN(_prefix, _name, _fmt_out, _value)          \
0248 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj,    \
0249         struct kobj_attribute *attr,                \
0250         const char *buf, size_t len)                \
0251 {                                   \
0252     strncpy(_value, buf, sizeof(_value) - 1);           \
0253     strim(_value);                          \
0254     return len;                         \
0255 }                                   \
0256 static struct kobj_attribute sys_##_prefix##_##_name##_attr =       \
0257     __ATTR(_name,(S_IRUGO | S_IWUSR),               \
0258             sys_##_prefix##_##_name##_show,         \
0259             sys_##_prefix##_##_name##_store)
0260 
0261 /*
0262  * ipl section
0263  */
0264 
0265 static __init enum ipl_type get_ipl_type(void)
0266 {
0267     if (!ipl_block_valid)
0268         return IPL_TYPE_UNKNOWN;
0269 
0270     switch (ipl_block.pb0_hdr.pbt) {
0271     case IPL_PBT_CCW:
0272         return IPL_TYPE_CCW;
0273     case IPL_PBT_FCP:
0274         if (ipl_block.fcp.opt == IPL_PB0_FCP_OPT_DUMP)
0275             return IPL_TYPE_FCP_DUMP;
0276         else
0277             return IPL_TYPE_FCP;
0278     case IPL_PBT_NVME:
0279         if (ipl_block.nvme.opt == IPL_PB0_NVME_OPT_DUMP)
0280             return IPL_TYPE_NVME_DUMP;
0281         else
0282             return IPL_TYPE_NVME;
0283     }
0284     return IPL_TYPE_UNKNOWN;
0285 }
0286 
0287 struct ipl_info ipl_info;
0288 EXPORT_SYMBOL_GPL(ipl_info);
0289 
0290 static ssize_t ipl_type_show(struct kobject *kobj, struct kobj_attribute *attr,
0291                  char *page)
0292 {
0293     return sprintf(page, "%s\n", ipl_type_str(ipl_info.type));
0294 }
0295 
0296 static struct kobj_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
0297 
0298 static ssize_t ipl_secure_show(struct kobject *kobj,
0299                    struct kobj_attribute *attr, char *page)
0300 {
0301     return sprintf(page, "%i\n", !!ipl_secure_flag);
0302 }
0303 
0304 static struct kobj_attribute sys_ipl_secure_attr =
0305     __ATTR(secure, 0444, ipl_secure_show, NULL);
0306 
0307 static ssize_t ipl_has_secure_show(struct kobject *kobj,
0308                    struct kobj_attribute *attr, char *page)
0309 {
0310     return sprintf(page, "%i\n", !!sclp.has_sipl);
0311 }
0312 
0313 static struct kobj_attribute sys_ipl_has_secure_attr =
0314     __ATTR(has_secure, 0444, ipl_has_secure_show, NULL);
0315 
0316 static ssize_t ipl_vm_parm_show(struct kobject *kobj,
0317                 struct kobj_attribute *attr, char *page)
0318 {
0319     char parm[DIAG308_VMPARM_SIZE + 1] = {};
0320 
0321     if (ipl_block_valid && (ipl_block.pb0_hdr.pbt == IPL_PBT_CCW))
0322         ipl_block_get_ascii_vmparm(parm, sizeof(parm), &ipl_block);
0323     return sprintf(page, "%s\n", parm);
0324 }
0325 
0326 static struct kobj_attribute sys_ipl_vm_parm_attr =
0327     __ATTR(parm, S_IRUGO, ipl_vm_parm_show, NULL);
0328 
0329 static ssize_t sys_ipl_device_show(struct kobject *kobj,
0330                    struct kobj_attribute *attr, char *page)
0331 {
0332     switch (ipl_info.type) {
0333     case IPL_TYPE_CCW:
0334         return sprintf(page, "0.%x.%04x\n", ipl_block.ccw.ssid,
0335                    ipl_block.ccw.devno);
0336     case IPL_TYPE_FCP:
0337     case IPL_TYPE_FCP_DUMP:
0338         return sprintf(page, "0.0.%04x\n", ipl_block.fcp.devno);
0339     case IPL_TYPE_NVME:
0340     case IPL_TYPE_NVME_DUMP:
0341         return sprintf(page, "%08ux\n", ipl_block.nvme.fid);
0342     default:
0343         return 0;
0344     }
0345 }
0346 
0347 static struct kobj_attribute sys_ipl_device_attr =
0348     __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
0349 
0350 static ssize_t ipl_parameter_read(struct file *filp, struct kobject *kobj,
0351                   struct bin_attribute *attr, char *buf,
0352                   loff_t off, size_t count)
0353 {
0354     return memory_read_from_buffer(buf, count, &off, &ipl_block,
0355                        ipl_block.hdr.len);
0356 }
0357 static struct bin_attribute ipl_parameter_attr =
0358     __BIN_ATTR(binary_parameter, S_IRUGO, ipl_parameter_read, NULL,
0359            PAGE_SIZE);
0360 
0361 static ssize_t ipl_scp_data_read(struct file *filp, struct kobject *kobj,
0362                  struct bin_attribute *attr, char *buf,
0363                  loff_t off, size_t count)
0364 {
0365     unsigned int size = ipl_block.fcp.scp_data_len;
0366     void *scp_data = &ipl_block.fcp.scp_data;
0367 
0368     return memory_read_from_buffer(buf, count, &off, scp_data, size);
0369 }
0370 
0371 static ssize_t ipl_nvme_scp_data_read(struct file *filp, struct kobject *kobj,
0372                  struct bin_attribute *attr, char *buf,
0373                  loff_t off, size_t count)
0374 {
0375     unsigned int size = ipl_block.nvme.scp_data_len;
0376     void *scp_data = &ipl_block.nvme.scp_data;
0377 
0378     return memory_read_from_buffer(buf, count, &off, scp_data, size);
0379 }
0380 
0381 static struct bin_attribute ipl_scp_data_attr =
0382     __BIN_ATTR(scp_data, S_IRUGO, ipl_scp_data_read, NULL, PAGE_SIZE);
0383 
0384 static struct bin_attribute ipl_nvme_scp_data_attr =
0385     __BIN_ATTR(scp_data, S_IRUGO, ipl_nvme_scp_data_read, NULL, PAGE_SIZE);
0386 
0387 static struct bin_attribute *ipl_fcp_bin_attrs[] = {
0388     &ipl_parameter_attr,
0389     &ipl_scp_data_attr,
0390     NULL,
0391 };
0392 
0393 static struct bin_attribute *ipl_nvme_bin_attrs[] = {
0394     &ipl_parameter_attr,
0395     &ipl_nvme_scp_data_attr,
0396     NULL,
0397 };
0398 
0399 /* FCP ipl device attributes */
0400 
0401 DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n",
0402            (unsigned long long)ipl_block.fcp.wwpn);
0403 DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n",
0404            (unsigned long long)ipl_block.fcp.lun);
0405 DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n",
0406            (unsigned long long)ipl_block.fcp.bootprog);
0407 DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n",
0408            (unsigned long long)ipl_block.fcp.br_lba);
0409 
0410 /* NVMe ipl device attributes */
0411 DEFINE_IPL_ATTR_RO(ipl_nvme, fid, "0x%08llx\n",
0412            (unsigned long long)ipl_block.nvme.fid);
0413 DEFINE_IPL_ATTR_RO(ipl_nvme, nsid, "0x%08llx\n",
0414            (unsigned long long)ipl_block.nvme.nsid);
0415 DEFINE_IPL_ATTR_RO(ipl_nvme, bootprog, "%lld\n",
0416            (unsigned long long)ipl_block.nvme.bootprog);
0417 DEFINE_IPL_ATTR_RO(ipl_nvme, br_lba, "%lld\n",
0418            (unsigned long long)ipl_block.nvme.br_lba);
0419 
0420 static ssize_t ipl_ccw_loadparm_show(struct kobject *kobj,
0421                      struct kobj_attribute *attr, char *page)
0422 {
0423     char loadparm[LOADPARM_LEN + 1] = {};
0424 
0425     if (!sclp_ipl_info.is_valid)
0426         return sprintf(page, "#unknown#\n");
0427     memcpy(loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN);
0428     EBCASC(loadparm, LOADPARM_LEN);
0429     strim(loadparm);
0430     return sprintf(page, "%s\n", loadparm);
0431 }
0432 
0433 static struct kobj_attribute sys_ipl_ccw_loadparm_attr =
0434     __ATTR(loadparm, 0444, ipl_ccw_loadparm_show, NULL);
0435 
0436 static struct attribute *ipl_fcp_attrs[] = {
0437     &sys_ipl_type_attr.attr,
0438     &sys_ipl_device_attr.attr,
0439     &sys_ipl_fcp_wwpn_attr.attr,
0440     &sys_ipl_fcp_lun_attr.attr,
0441     &sys_ipl_fcp_bootprog_attr.attr,
0442     &sys_ipl_fcp_br_lba_attr.attr,
0443     &sys_ipl_ccw_loadparm_attr.attr,
0444     &sys_ipl_secure_attr.attr,
0445     &sys_ipl_has_secure_attr.attr,
0446     NULL,
0447 };
0448 
0449 static struct attribute_group ipl_fcp_attr_group = {
0450     .attrs = ipl_fcp_attrs,
0451     .bin_attrs = ipl_fcp_bin_attrs,
0452 };
0453 
0454 static struct attribute *ipl_nvme_attrs[] = {
0455     &sys_ipl_type_attr.attr,
0456     &sys_ipl_nvme_fid_attr.attr,
0457     &sys_ipl_nvme_nsid_attr.attr,
0458     &sys_ipl_nvme_bootprog_attr.attr,
0459     &sys_ipl_nvme_br_lba_attr.attr,
0460     &sys_ipl_ccw_loadparm_attr.attr,
0461     &sys_ipl_secure_attr.attr,
0462     &sys_ipl_has_secure_attr.attr,
0463     NULL,
0464 };
0465 
0466 static struct attribute_group ipl_nvme_attr_group = {
0467     .attrs = ipl_nvme_attrs,
0468     .bin_attrs = ipl_nvme_bin_attrs,
0469 };
0470 
0471 
0472 /* CCW ipl device attributes */
0473 
0474 static struct attribute *ipl_ccw_attrs_vm[] = {
0475     &sys_ipl_type_attr.attr,
0476     &sys_ipl_device_attr.attr,
0477     &sys_ipl_ccw_loadparm_attr.attr,
0478     &sys_ipl_vm_parm_attr.attr,
0479     &sys_ipl_secure_attr.attr,
0480     &sys_ipl_has_secure_attr.attr,
0481     NULL,
0482 };
0483 
0484 static struct attribute *ipl_ccw_attrs_lpar[] = {
0485     &sys_ipl_type_attr.attr,
0486     &sys_ipl_device_attr.attr,
0487     &sys_ipl_ccw_loadparm_attr.attr,
0488     &sys_ipl_secure_attr.attr,
0489     &sys_ipl_has_secure_attr.attr,
0490     NULL,
0491 };
0492 
0493 static struct attribute_group ipl_ccw_attr_group_vm = {
0494     .attrs = ipl_ccw_attrs_vm,
0495 };
0496 
0497 static struct attribute_group ipl_ccw_attr_group_lpar = {
0498     .attrs = ipl_ccw_attrs_lpar
0499 };
0500 
0501 /* UNKNOWN ipl device attributes */
0502 
0503 static struct attribute *ipl_unknown_attrs[] = {
0504     &sys_ipl_type_attr.attr,
0505     NULL,
0506 };
0507 
0508 static struct attribute_group ipl_unknown_attr_group = {
0509     .attrs = ipl_unknown_attrs,
0510 };
0511 
0512 static struct kset *ipl_kset;
0513 
0514 static void __ipl_run(void *unused)
0515 {
0516     __bpon();
0517     diag308(DIAG308_LOAD_CLEAR, NULL);
0518 }
0519 
0520 static void ipl_run(struct shutdown_trigger *trigger)
0521 {
0522     smp_call_ipl_cpu(__ipl_run, NULL);
0523 }
0524 
0525 static int __init ipl_init(void)
0526 {
0527     int rc;
0528 
0529     ipl_kset = kset_create_and_add("ipl", NULL, firmware_kobj);
0530     if (!ipl_kset) {
0531         rc = -ENOMEM;
0532         goto out;
0533     }
0534     switch (ipl_info.type) {
0535     case IPL_TYPE_CCW:
0536         if (MACHINE_IS_VM)
0537             rc = sysfs_create_group(&ipl_kset->kobj,
0538                         &ipl_ccw_attr_group_vm);
0539         else
0540             rc = sysfs_create_group(&ipl_kset->kobj,
0541                         &ipl_ccw_attr_group_lpar);
0542         break;
0543     case IPL_TYPE_FCP:
0544     case IPL_TYPE_FCP_DUMP:
0545         rc = sysfs_create_group(&ipl_kset->kobj, &ipl_fcp_attr_group);
0546         break;
0547     case IPL_TYPE_NVME:
0548     case IPL_TYPE_NVME_DUMP:
0549         rc = sysfs_create_group(&ipl_kset->kobj, &ipl_nvme_attr_group);
0550         break;
0551     default:
0552         rc = sysfs_create_group(&ipl_kset->kobj,
0553                     &ipl_unknown_attr_group);
0554         break;
0555     }
0556 out:
0557     if (rc)
0558         panic("ipl_init failed: rc = %i\n", rc);
0559 
0560     return 0;
0561 }
0562 
0563 static struct shutdown_action __refdata ipl_action = {
0564     .name   = SHUTDOWN_ACTION_IPL_STR,
0565     .fn = ipl_run,
0566     .init   = ipl_init,
0567 };
0568 
0569 /*
0570  * reipl shutdown action: Reboot Linux on shutdown.
0571  */
0572 
0573 /* VM IPL PARM attributes */
0574 static ssize_t reipl_generic_vmparm_show(struct ipl_parameter_block *ipb,
0575                       char *page)
0576 {
0577     char vmparm[DIAG308_VMPARM_SIZE + 1] = {};
0578 
0579     ipl_block_get_ascii_vmparm(vmparm, sizeof(vmparm), ipb);
0580     return sprintf(page, "%s\n", vmparm);
0581 }
0582 
0583 static ssize_t reipl_generic_vmparm_store(struct ipl_parameter_block *ipb,
0584                       size_t vmparm_max,
0585                       const char *buf, size_t len)
0586 {
0587     int i, ip_len;
0588 
0589     /* ignore trailing newline */
0590     ip_len = len;
0591     if ((len > 0) && (buf[len - 1] == '\n'))
0592         ip_len--;
0593 
0594     if (ip_len > vmparm_max)
0595         return -EINVAL;
0596 
0597     /* parm is used to store kernel options, check for common chars */
0598     for (i = 0; i < ip_len; i++)
0599         if (!(isalnum(buf[i]) || isascii(buf[i]) || isprint(buf[i])))
0600             return -EINVAL;
0601 
0602     memset(ipb->ccw.vm_parm, 0, DIAG308_VMPARM_SIZE);
0603     ipb->ccw.vm_parm_len = ip_len;
0604     if (ip_len > 0) {
0605         ipb->ccw.vm_flags |= IPL_PB0_CCW_VM_FLAG_VP;
0606         memcpy(ipb->ccw.vm_parm, buf, ip_len);
0607         ASCEBC(ipb->ccw.vm_parm, ip_len);
0608     } else {
0609         ipb->ccw.vm_flags &= ~IPL_PB0_CCW_VM_FLAG_VP;
0610     }
0611 
0612     return len;
0613 }
0614 
0615 /* NSS wrapper */
0616 static ssize_t reipl_nss_vmparm_show(struct kobject *kobj,
0617                      struct kobj_attribute *attr, char *page)
0618 {
0619     return reipl_generic_vmparm_show(reipl_block_nss, page);
0620 }
0621 
0622 static ssize_t reipl_nss_vmparm_store(struct kobject *kobj,
0623                       struct kobj_attribute *attr,
0624                       const char *buf, size_t len)
0625 {
0626     return reipl_generic_vmparm_store(reipl_block_nss, 56, buf, len);
0627 }
0628 
0629 /* CCW wrapper */
0630 static ssize_t reipl_ccw_vmparm_show(struct kobject *kobj,
0631                      struct kobj_attribute *attr, char *page)
0632 {
0633     return reipl_generic_vmparm_show(reipl_block_ccw, page);
0634 }
0635 
0636 static ssize_t reipl_ccw_vmparm_store(struct kobject *kobj,
0637                       struct kobj_attribute *attr,
0638                       const char *buf, size_t len)
0639 {
0640     return reipl_generic_vmparm_store(reipl_block_ccw, 64, buf, len);
0641 }
0642 
0643 static struct kobj_attribute sys_reipl_nss_vmparm_attr =
0644     __ATTR(parm, S_IRUGO | S_IWUSR, reipl_nss_vmparm_show,
0645                     reipl_nss_vmparm_store);
0646 static struct kobj_attribute sys_reipl_ccw_vmparm_attr =
0647     __ATTR(parm, S_IRUGO | S_IWUSR, reipl_ccw_vmparm_show,
0648                     reipl_ccw_vmparm_store);
0649 
0650 /* FCP reipl device attributes */
0651 
0652 static ssize_t reipl_fcp_scpdata_read(struct file *filp, struct kobject *kobj,
0653                       struct bin_attribute *attr,
0654                       char *buf, loff_t off, size_t count)
0655 {
0656     size_t size = reipl_block_fcp->fcp.scp_data_len;
0657     void *scp_data = reipl_block_fcp->fcp.scp_data;
0658 
0659     return memory_read_from_buffer(buf, count, &off, scp_data, size);
0660 }
0661 
0662 static ssize_t reipl_fcp_scpdata_write(struct file *filp, struct kobject *kobj,
0663                        struct bin_attribute *attr,
0664                        char *buf, loff_t off, size_t count)
0665 {
0666     size_t scpdata_len = count;
0667     size_t padding;
0668 
0669 
0670     if (off)
0671         return -EINVAL;
0672 
0673     memcpy(reipl_block_fcp->fcp.scp_data, buf, count);
0674     if (scpdata_len % 8) {
0675         padding = 8 - (scpdata_len % 8);
0676         memset(reipl_block_fcp->fcp.scp_data + scpdata_len,
0677                0, padding);
0678         scpdata_len += padding;
0679     }
0680 
0681     reipl_block_fcp->hdr.len = IPL_BP_FCP_LEN + scpdata_len;
0682     reipl_block_fcp->fcp.len = IPL_BP0_FCP_LEN + scpdata_len;
0683     reipl_block_fcp->fcp.scp_data_len = scpdata_len;
0684 
0685     return count;
0686 }
0687 static struct bin_attribute sys_reipl_fcp_scp_data_attr =
0688     __BIN_ATTR(scp_data, (S_IRUGO | S_IWUSR), reipl_fcp_scpdata_read,
0689            reipl_fcp_scpdata_write, DIAG308_SCPDATA_SIZE);
0690 
0691 static struct bin_attribute *reipl_fcp_bin_attrs[] = {
0692     &sys_reipl_fcp_scp_data_attr,
0693     NULL,
0694 };
0695 
0696 DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%llx\n",
0697            reipl_block_fcp->fcp.wwpn);
0698 DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%llx\n",
0699            reipl_block_fcp->fcp.lun);
0700 DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
0701            reipl_block_fcp->fcp.bootprog);
0702 DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
0703            reipl_block_fcp->fcp.br_lba);
0704 DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
0705            reipl_block_fcp->fcp.devno);
0706 
0707 static void reipl_get_ascii_loadparm(char *loadparm,
0708                      struct ipl_parameter_block *ibp)
0709 {
0710     memcpy(loadparm, ibp->common.loadparm, LOADPARM_LEN);
0711     EBCASC(loadparm, LOADPARM_LEN);
0712     loadparm[LOADPARM_LEN] = 0;
0713     strim(loadparm);
0714 }
0715 
0716 static ssize_t reipl_generic_loadparm_show(struct ipl_parameter_block *ipb,
0717                        char *page)
0718 {
0719     char buf[LOADPARM_LEN + 1];
0720 
0721     reipl_get_ascii_loadparm(buf, ipb);
0722     return sprintf(page, "%s\n", buf);
0723 }
0724 
0725 static ssize_t reipl_generic_loadparm_store(struct ipl_parameter_block *ipb,
0726                         const char *buf, size_t len)
0727 {
0728     int i, lp_len;
0729 
0730     /* ignore trailing newline */
0731     lp_len = len;
0732     if ((len > 0) && (buf[len - 1] == '\n'))
0733         lp_len--;
0734     /* loadparm can have max 8 characters and must not start with a blank */
0735     if ((lp_len > LOADPARM_LEN) || ((lp_len > 0) && (buf[0] == ' ')))
0736         return -EINVAL;
0737     /* loadparm can only contain "a-z,A-Z,0-9,SP,." */
0738     for (i = 0; i < lp_len; i++) {
0739         if (isalpha(buf[i]) || isdigit(buf[i]) || (buf[i] == ' ') ||
0740             (buf[i] == '.'))
0741             continue;
0742         return -EINVAL;
0743     }
0744     /* initialize loadparm with blanks */
0745     memset(ipb->common.loadparm, ' ', LOADPARM_LEN);
0746     /* copy and convert to ebcdic */
0747     memcpy(ipb->common.loadparm, buf, lp_len);
0748     ASCEBC(ipb->common.loadparm, LOADPARM_LEN);
0749     ipb->common.flags |= IPL_PB0_FLAG_LOADPARM;
0750     return len;
0751 }
0752 
0753 /* FCP wrapper */
0754 static ssize_t reipl_fcp_loadparm_show(struct kobject *kobj,
0755                        struct kobj_attribute *attr, char *page)
0756 {
0757     return reipl_generic_loadparm_show(reipl_block_fcp, page);
0758 }
0759 
0760 static ssize_t reipl_fcp_loadparm_store(struct kobject *kobj,
0761                     struct kobj_attribute *attr,
0762                     const char *buf, size_t len)
0763 {
0764     return reipl_generic_loadparm_store(reipl_block_fcp, buf, len);
0765 }
0766 
0767 static struct kobj_attribute sys_reipl_fcp_loadparm_attr =
0768     __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_fcp_loadparm_show,
0769                         reipl_fcp_loadparm_store);
0770 
0771 static ssize_t reipl_fcp_clear_show(struct kobject *kobj,
0772                     struct kobj_attribute *attr, char *page)
0773 {
0774     return sprintf(page, "%u\n", reipl_fcp_clear);
0775 }
0776 
0777 static ssize_t reipl_fcp_clear_store(struct kobject *kobj,
0778                      struct kobj_attribute *attr,
0779                      const char *buf, size_t len)
0780 {
0781     if (strtobool(buf, &reipl_fcp_clear) < 0)
0782         return -EINVAL;
0783     return len;
0784 }
0785 
0786 static struct attribute *reipl_fcp_attrs[] = {
0787     &sys_reipl_fcp_device_attr.attr,
0788     &sys_reipl_fcp_wwpn_attr.attr,
0789     &sys_reipl_fcp_lun_attr.attr,
0790     &sys_reipl_fcp_bootprog_attr.attr,
0791     &sys_reipl_fcp_br_lba_attr.attr,
0792     &sys_reipl_fcp_loadparm_attr.attr,
0793     NULL,
0794 };
0795 
0796 static struct attribute_group reipl_fcp_attr_group = {
0797     .attrs = reipl_fcp_attrs,
0798     .bin_attrs = reipl_fcp_bin_attrs,
0799 };
0800 
0801 static struct kobj_attribute sys_reipl_fcp_clear_attr =
0802     __ATTR(clear, 0644, reipl_fcp_clear_show, reipl_fcp_clear_store);
0803 
0804 /* NVME reipl device attributes */
0805 
0806 static ssize_t reipl_nvme_scpdata_read(struct file *filp, struct kobject *kobj,
0807                       struct bin_attribute *attr,
0808                       char *buf, loff_t off, size_t count)
0809 {
0810     size_t size = reipl_block_nvme->nvme.scp_data_len;
0811     void *scp_data = reipl_block_nvme->nvme.scp_data;
0812 
0813     return memory_read_from_buffer(buf, count, &off, scp_data, size);
0814 }
0815 
0816 static ssize_t reipl_nvme_scpdata_write(struct file *filp, struct kobject *kobj,
0817                        struct bin_attribute *attr,
0818                        char *buf, loff_t off, size_t count)
0819 {
0820     size_t scpdata_len = count;
0821     size_t padding;
0822 
0823     if (off)
0824         return -EINVAL;
0825 
0826     memcpy(reipl_block_nvme->nvme.scp_data, buf, count);
0827     if (scpdata_len % 8) {
0828         padding = 8 - (scpdata_len % 8);
0829         memset(reipl_block_nvme->nvme.scp_data + scpdata_len,
0830                0, padding);
0831         scpdata_len += padding;
0832     }
0833 
0834     reipl_block_nvme->hdr.len = IPL_BP_FCP_LEN + scpdata_len;
0835     reipl_block_nvme->nvme.len = IPL_BP0_FCP_LEN + scpdata_len;
0836     reipl_block_nvme->nvme.scp_data_len = scpdata_len;
0837 
0838     return count;
0839 }
0840 
0841 static struct bin_attribute sys_reipl_nvme_scp_data_attr =
0842     __BIN_ATTR(scp_data, (S_IRUGO | S_IWUSR), reipl_nvme_scpdata_read,
0843            reipl_nvme_scpdata_write, DIAG308_SCPDATA_SIZE);
0844 
0845 static struct bin_attribute *reipl_nvme_bin_attrs[] = {
0846     &sys_reipl_nvme_scp_data_attr,
0847     NULL,
0848 };
0849 
0850 DEFINE_IPL_ATTR_RW(reipl_nvme, fid, "0x%08llx\n", "%llx\n",
0851            reipl_block_nvme->nvme.fid);
0852 DEFINE_IPL_ATTR_RW(reipl_nvme, nsid, "0x%08llx\n", "%llx\n",
0853            reipl_block_nvme->nvme.nsid);
0854 DEFINE_IPL_ATTR_RW(reipl_nvme, bootprog, "%lld\n", "%lld\n",
0855            reipl_block_nvme->nvme.bootprog);
0856 DEFINE_IPL_ATTR_RW(reipl_nvme, br_lba, "%lld\n", "%lld\n",
0857            reipl_block_nvme->nvme.br_lba);
0858 
0859 /* nvme wrapper */
0860 static ssize_t reipl_nvme_loadparm_show(struct kobject *kobj,
0861                        struct kobj_attribute *attr, char *page)
0862 {
0863     return reipl_generic_loadparm_show(reipl_block_nvme, page);
0864 }
0865 
0866 static ssize_t reipl_nvme_loadparm_store(struct kobject *kobj,
0867                     struct kobj_attribute *attr,
0868                     const char *buf, size_t len)
0869 {
0870     return reipl_generic_loadparm_store(reipl_block_nvme, buf, len);
0871 }
0872 
0873 static struct kobj_attribute sys_reipl_nvme_loadparm_attr =
0874     __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_nvme_loadparm_show,
0875                         reipl_nvme_loadparm_store);
0876 
0877 static struct attribute *reipl_nvme_attrs[] = {
0878     &sys_reipl_nvme_fid_attr.attr,
0879     &sys_reipl_nvme_nsid_attr.attr,
0880     &sys_reipl_nvme_bootprog_attr.attr,
0881     &sys_reipl_nvme_br_lba_attr.attr,
0882     &sys_reipl_nvme_loadparm_attr.attr,
0883     NULL,
0884 };
0885 
0886 static struct attribute_group reipl_nvme_attr_group = {
0887     .attrs = reipl_nvme_attrs,
0888     .bin_attrs = reipl_nvme_bin_attrs
0889 };
0890 
0891 static ssize_t reipl_nvme_clear_show(struct kobject *kobj,
0892                      struct kobj_attribute *attr, char *page)
0893 {
0894     return sprintf(page, "%u\n", reipl_nvme_clear);
0895 }
0896 
0897 static ssize_t reipl_nvme_clear_store(struct kobject *kobj,
0898                       struct kobj_attribute *attr,
0899                       const char *buf, size_t len)
0900 {
0901     if (strtobool(buf, &reipl_nvme_clear) < 0)
0902         return -EINVAL;
0903     return len;
0904 }
0905 
0906 static struct kobj_attribute sys_reipl_nvme_clear_attr =
0907     __ATTR(clear, 0644, reipl_nvme_clear_show, reipl_nvme_clear_store);
0908 
0909 /* CCW reipl device attributes */
0910 DEFINE_IPL_CCW_ATTR_RW(reipl_ccw, device, reipl_block_ccw->ccw);
0911 
0912 /* NSS wrapper */
0913 static ssize_t reipl_nss_loadparm_show(struct kobject *kobj,
0914                        struct kobj_attribute *attr, char *page)
0915 {
0916     return reipl_generic_loadparm_show(reipl_block_nss, page);
0917 }
0918 
0919 static ssize_t reipl_nss_loadparm_store(struct kobject *kobj,
0920                     struct kobj_attribute *attr,
0921                     const char *buf, size_t len)
0922 {
0923     return reipl_generic_loadparm_store(reipl_block_nss, buf, len);
0924 }
0925 
0926 /* CCW wrapper */
0927 static ssize_t reipl_ccw_loadparm_show(struct kobject *kobj,
0928                        struct kobj_attribute *attr, char *page)
0929 {
0930     return reipl_generic_loadparm_show(reipl_block_ccw, page);
0931 }
0932 
0933 static ssize_t reipl_ccw_loadparm_store(struct kobject *kobj,
0934                     struct kobj_attribute *attr,
0935                     const char *buf, size_t len)
0936 {
0937     return reipl_generic_loadparm_store(reipl_block_ccw, buf, len);
0938 }
0939 
0940 static struct kobj_attribute sys_reipl_ccw_loadparm_attr =
0941     __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_ccw_loadparm_show,
0942                         reipl_ccw_loadparm_store);
0943 
0944 static ssize_t reipl_ccw_clear_show(struct kobject *kobj,
0945                     struct kobj_attribute *attr, char *page)
0946 {
0947     return sprintf(page, "%u\n", reipl_ccw_clear);
0948 }
0949 
0950 static ssize_t reipl_ccw_clear_store(struct kobject *kobj,
0951                      struct kobj_attribute *attr,
0952                      const char *buf, size_t len)
0953 {
0954     if (strtobool(buf, &reipl_ccw_clear) < 0)
0955         return -EINVAL;
0956     return len;
0957 }
0958 
0959 static struct kobj_attribute sys_reipl_ccw_clear_attr =
0960     __ATTR(clear, 0644, reipl_ccw_clear_show, reipl_ccw_clear_store);
0961 
0962 static struct attribute *reipl_ccw_attrs_vm[] = {
0963     &sys_reipl_ccw_device_attr.attr,
0964     &sys_reipl_ccw_loadparm_attr.attr,
0965     &sys_reipl_ccw_vmparm_attr.attr,
0966     &sys_reipl_ccw_clear_attr.attr,
0967     NULL,
0968 };
0969 
0970 static struct attribute *reipl_ccw_attrs_lpar[] = {
0971     &sys_reipl_ccw_device_attr.attr,
0972     &sys_reipl_ccw_loadparm_attr.attr,
0973     &sys_reipl_ccw_clear_attr.attr,
0974     NULL,
0975 };
0976 
0977 static struct attribute_group reipl_ccw_attr_group_vm = {
0978     .name  = IPL_CCW_STR,
0979     .attrs = reipl_ccw_attrs_vm,
0980 };
0981 
0982 static struct attribute_group reipl_ccw_attr_group_lpar = {
0983     .name  = IPL_CCW_STR,
0984     .attrs = reipl_ccw_attrs_lpar,
0985 };
0986 
0987 
0988 /* NSS reipl device attributes */
0989 static void reipl_get_ascii_nss_name(char *dst,
0990                      struct ipl_parameter_block *ipb)
0991 {
0992     memcpy(dst, ipb->ccw.nss_name, NSS_NAME_SIZE);
0993     EBCASC(dst, NSS_NAME_SIZE);
0994     dst[NSS_NAME_SIZE] = 0;
0995 }
0996 
0997 static ssize_t reipl_nss_name_show(struct kobject *kobj,
0998                    struct kobj_attribute *attr, char *page)
0999 {
1000     char nss_name[NSS_NAME_SIZE + 1] = {};
1001 
1002     reipl_get_ascii_nss_name(nss_name, reipl_block_nss);
1003     return sprintf(page, "%s\n", nss_name);
1004 }
1005 
1006 static ssize_t reipl_nss_name_store(struct kobject *kobj,
1007                     struct kobj_attribute *attr,
1008                     const char *buf, size_t len)
1009 {
1010     int nss_len;
1011 
1012     /* ignore trailing newline */
1013     nss_len = len;
1014     if ((len > 0) && (buf[len - 1] == '\n'))
1015         nss_len--;
1016 
1017     if (nss_len > NSS_NAME_SIZE)
1018         return -EINVAL;
1019 
1020     memset(reipl_block_nss->ccw.nss_name, 0x40, NSS_NAME_SIZE);
1021     if (nss_len > 0) {
1022         reipl_block_nss->ccw.vm_flags |= IPL_PB0_CCW_VM_FLAG_NSS;
1023         memcpy(reipl_block_nss->ccw.nss_name, buf, nss_len);
1024         ASCEBC(reipl_block_nss->ccw.nss_name, nss_len);
1025         EBC_TOUPPER(reipl_block_nss->ccw.nss_name, nss_len);
1026     } else {
1027         reipl_block_nss->ccw.vm_flags &= ~IPL_PB0_CCW_VM_FLAG_NSS;
1028     }
1029 
1030     return len;
1031 }
1032 
1033 static struct kobj_attribute sys_reipl_nss_name_attr =
1034     __ATTR(name, S_IRUGO | S_IWUSR, reipl_nss_name_show,
1035                     reipl_nss_name_store);
1036 
1037 static struct kobj_attribute sys_reipl_nss_loadparm_attr =
1038     __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_nss_loadparm_show,
1039                         reipl_nss_loadparm_store);
1040 
1041 static struct attribute *reipl_nss_attrs[] = {
1042     &sys_reipl_nss_name_attr.attr,
1043     &sys_reipl_nss_loadparm_attr.attr,
1044     &sys_reipl_nss_vmparm_attr.attr,
1045     NULL,
1046 };
1047 
1048 static struct attribute_group reipl_nss_attr_group = {
1049     .name  = IPL_NSS_STR,
1050     .attrs = reipl_nss_attrs,
1051 };
1052 
1053 void set_os_info_reipl_block(void)
1054 {
1055     os_info_entry_add(OS_INFO_REIPL_BLOCK, reipl_block_actual,
1056               reipl_block_actual->hdr.len);
1057 }
1058 
1059 /* reipl type */
1060 
1061 static int reipl_set_type(enum ipl_type type)
1062 {
1063     if (!(reipl_capabilities & type))
1064         return -EINVAL;
1065 
1066     switch(type) {
1067     case IPL_TYPE_CCW:
1068         reipl_block_actual = reipl_block_ccw;
1069         break;
1070     case IPL_TYPE_FCP:
1071         reipl_block_actual = reipl_block_fcp;
1072         break;
1073     case IPL_TYPE_NVME:
1074         reipl_block_actual = reipl_block_nvme;
1075         break;
1076     case IPL_TYPE_NSS:
1077         reipl_block_actual = reipl_block_nss;
1078         break;
1079     default:
1080         break;
1081     }
1082     reipl_type = type;
1083     return 0;
1084 }
1085 
1086 static ssize_t reipl_type_show(struct kobject *kobj,
1087                    struct kobj_attribute *attr, char *page)
1088 {
1089     return sprintf(page, "%s\n", ipl_type_str(reipl_type));
1090 }
1091 
1092 static ssize_t reipl_type_store(struct kobject *kobj,
1093                 struct kobj_attribute *attr,
1094                 const char *buf, size_t len)
1095 {
1096     int rc = -EINVAL;
1097 
1098     if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
1099         rc = reipl_set_type(IPL_TYPE_CCW);
1100     else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
1101         rc = reipl_set_type(IPL_TYPE_FCP);
1102     else if (strncmp(buf, IPL_NVME_STR, strlen(IPL_NVME_STR)) == 0)
1103         rc = reipl_set_type(IPL_TYPE_NVME);
1104     else if (strncmp(buf, IPL_NSS_STR, strlen(IPL_NSS_STR)) == 0)
1105         rc = reipl_set_type(IPL_TYPE_NSS);
1106     return (rc != 0) ? rc : len;
1107 }
1108 
1109 static struct kobj_attribute reipl_type_attr =
1110     __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
1111 
1112 static struct kset *reipl_kset;
1113 static struct kset *reipl_fcp_kset;
1114 static struct kset *reipl_nvme_kset;
1115 
1116 static void __reipl_run(void *unused)
1117 {
1118     switch (reipl_type) {
1119     case IPL_TYPE_CCW:
1120         diag308(DIAG308_SET, reipl_block_ccw);
1121         if (reipl_ccw_clear)
1122             diag308(DIAG308_LOAD_CLEAR, NULL);
1123         else
1124             diag308(DIAG308_LOAD_NORMAL_DUMP, NULL);
1125         break;
1126     case IPL_TYPE_FCP:
1127         diag308(DIAG308_SET, reipl_block_fcp);
1128         if (reipl_fcp_clear)
1129             diag308(DIAG308_LOAD_CLEAR, NULL);
1130         else
1131             diag308(DIAG308_LOAD_NORMAL, NULL);
1132         break;
1133     case IPL_TYPE_NVME:
1134         diag308(DIAG308_SET, reipl_block_nvme);
1135         if (reipl_nvme_clear)
1136             diag308(DIAG308_LOAD_CLEAR, NULL);
1137         else
1138             diag308(DIAG308_LOAD_NORMAL, NULL);
1139         break;
1140     case IPL_TYPE_NSS:
1141         diag308(DIAG308_SET, reipl_block_nss);
1142         diag308(DIAG308_LOAD_CLEAR, NULL);
1143         break;
1144     case IPL_TYPE_UNKNOWN:
1145         diag308(DIAG308_LOAD_CLEAR, NULL);
1146         break;
1147     case IPL_TYPE_FCP_DUMP:
1148     case IPL_TYPE_NVME_DUMP:
1149         break;
1150     }
1151     disabled_wait();
1152 }
1153 
1154 static void reipl_run(struct shutdown_trigger *trigger)
1155 {
1156     smp_call_ipl_cpu(__reipl_run, NULL);
1157 }
1158 
1159 static void reipl_block_ccw_init(struct ipl_parameter_block *ipb)
1160 {
1161     ipb->hdr.len = IPL_BP_CCW_LEN;
1162     ipb->hdr.version = IPL_PARM_BLOCK_VERSION;
1163     ipb->pb0_hdr.len = IPL_BP0_CCW_LEN;
1164     ipb->pb0_hdr.pbt = IPL_PBT_CCW;
1165 }
1166 
1167 static void reipl_block_ccw_fill_parms(struct ipl_parameter_block *ipb)
1168 {
1169     /* LOADPARM */
1170     /* check if read scp info worked and set loadparm */
1171     if (sclp_ipl_info.is_valid)
1172         memcpy(ipb->ccw.loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN);
1173     else
1174         /* read scp info failed: set empty loadparm (EBCDIC blanks) */
1175         memset(ipb->ccw.loadparm, 0x40, LOADPARM_LEN);
1176     ipb->ccw.flags = IPL_PB0_FLAG_LOADPARM;
1177 
1178     /* VM PARM */
1179     if (MACHINE_IS_VM && ipl_block_valid &&
1180         (ipl_block.ccw.vm_flags & IPL_PB0_CCW_VM_FLAG_VP)) {
1181 
1182         ipb->ccw.vm_flags |= IPL_PB0_CCW_VM_FLAG_VP;
1183         ipb->ccw.vm_parm_len = ipl_block.ccw.vm_parm_len;
1184         memcpy(ipb->ccw.vm_parm,
1185                ipl_block.ccw.vm_parm, DIAG308_VMPARM_SIZE);
1186     }
1187 }
1188 
1189 static int __init reipl_nss_init(void)
1190 {
1191     int rc;
1192 
1193     if (!MACHINE_IS_VM)
1194         return 0;
1195 
1196     reipl_block_nss = (void *) get_zeroed_page(GFP_KERNEL);
1197     if (!reipl_block_nss)
1198         return -ENOMEM;
1199 
1200     rc = sysfs_create_group(&reipl_kset->kobj, &reipl_nss_attr_group);
1201     if (rc)
1202         return rc;
1203 
1204     reipl_block_ccw_init(reipl_block_nss);
1205     reipl_capabilities |= IPL_TYPE_NSS;
1206     return 0;
1207 }
1208 
1209 static int __init reipl_ccw_init(void)
1210 {
1211     int rc;
1212 
1213     reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
1214     if (!reipl_block_ccw)
1215         return -ENOMEM;
1216 
1217     rc = sysfs_create_group(&reipl_kset->kobj,
1218                 MACHINE_IS_VM ? &reipl_ccw_attr_group_vm
1219                           : &reipl_ccw_attr_group_lpar);
1220     if (rc)
1221         return rc;
1222 
1223     reipl_block_ccw_init(reipl_block_ccw);
1224     if (ipl_info.type == IPL_TYPE_CCW) {
1225         reipl_block_ccw->ccw.ssid = ipl_block.ccw.ssid;
1226         reipl_block_ccw->ccw.devno = ipl_block.ccw.devno;
1227         reipl_block_ccw_fill_parms(reipl_block_ccw);
1228     }
1229 
1230     reipl_capabilities |= IPL_TYPE_CCW;
1231     return 0;
1232 }
1233 
1234 static int __init reipl_fcp_init(void)
1235 {
1236     int rc;
1237 
1238     reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
1239     if (!reipl_block_fcp)
1240         return -ENOMEM;
1241 
1242     /* sysfs: create fcp kset for mixing attr group and bin attrs */
1243     reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL,
1244                          &reipl_kset->kobj);
1245     if (!reipl_fcp_kset) {
1246         free_page((unsigned long) reipl_block_fcp);
1247         return -ENOMEM;
1248     }
1249 
1250     rc = sysfs_create_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group);
1251     if (rc)
1252         goto out1;
1253 
1254     if (test_facility(141)) {
1255         rc = sysfs_create_file(&reipl_fcp_kset->kobj,
1256                        &sys_reipl_fcp_clear_attr.attr);
1257         if (rc)
1258             goto out2;
1259     } else {
1260         reipl_fcp_clear = true;
1261     }
1262 
1263     if (ipl_info.type == IPL_TYPE_FCP) {
1264         memcpy(reipl_block_fcp, &ipl_block, sizeof(ipl_block));
1265         /*
1266          * Fix loadparm: There are systems where the (SCSI) LOADPARM
1267          * is invalid in the SCSI IPL parameter block, so take it
1268          * always from sclp_ipl_info.
1269          */
1270         memcpy(reipl_block_fcp->fcp.loadparm, sclp_ipl_info.loadparm,
1271                LOADPARM_LEN);
1272     } else {
1273         reipl_block_fcp->hdr.len = IPL_BP_FCP_LEN;
1274         reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1275         reipl_block_fcp->fcp.len = IPL_BP0_FCP_LEN;
1276         reipl_block_fcp->fcp.pbt = IPL_PBT_FCP;
1277         reipl_block_fcp->fcp.opt = IPL_PB0_FCP_OPT_IPL;
1278     }
1279     reipl_capabilities |= IPL_TYPE_FCP;
1280     return 0;
1281 
1282 out2:
1283     sysfs_remove_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group);
1284 out1:
1285     kset_unregister(reipl_fcp_kset);
1286     free_page((unsigned long) reipl_block_fcp);
1287     return rc;
1288 }
1289 
1290 static int __init reipl_nvme_init(void)
1291 {
1292     int rc;
1293 
1294     reipl_block_nvme = (void *) get_zeroed_page(GFP_KERNEL);
1295     if (!reipl_block_nvme)
1296         return -ENOMEM;
1297 
1298     /* sysfs: create kset for mixing attr group and bin attrs */
1299     reipl_nvme_kset = kset_create_and_add(IPL_NVME_STR, NULL,
1300                          &reipl_kset->kobj);
1301     if (!reipl_nvme_kset) {
1302         free_page((unsigned long) reipl_block_nvme);
1303         return -ENOMEM;
1304     }
1305 
1306     rc = sysfs_create_group(&reipl_nvme_kset->kobj, &reipl_nvme_attr_group);
1307     if (rc)
1308         goto out1;
1309 
1310     if (test_facility(141)) {
1311         rc = sysfs_create_file(&reipl_nvme_kset->kobj,
1312                        &sys_reipl_nvme_clear_attr.attr);
1313         if (rc)
1314             goto out2;
1315     } else {
1316         reipl_nvme_clear = true;
1317     }
1318 
1319     if (ipl_info.type == IPL_TYPE_NVME) {
1320         memcpy(reipl_block_nvme, &ipl_block, sizeof(ipl_block));
1321         /*
1322          * Fix loadparm: There are systems where the (SCSI) LOADPARM
1323          * is invalid in the IPL parameter block, so take it
1324          * always from sclp_ipl_info.
1325          */
1326         memcpy(reipl_block_nvme->nvme.loadparm, sclp_ipl_info.loadparm,
1327                LOADPARM_LEN);
1328     } else {
1329         reipl_block_nvme->hdr.len = IPL_BP_NVME_LEN;
1330         reipl_block_nvme->hdr.version = IPL_PARM_BLOCK_VERSION;
1331         reipl_block_nvme->nvme.len = IPL_BP0_NVME_LEN;
1332         reipl_block_nvme->nvme.pbt = IPL_PBT_NVME;
1333         reipl_block_nvme->nvme.opt = IPL_PB0_NVME_OPT_IPL;
1334     }
1335     reipl_capabilities |= IPL_TYPE_NVME;
1336     return 0;
1337 
1338 out2:
1339     sysfs_remove_group(&reipl_nvme_kset->kobj, &reipl_nvme_attr_group);
1340 out1:
1341     kset_unregister(reipl_nvme_kset);
1342     free_page((unsigned long) reipl_block_nvme);
1343     return rc;
1344 }
1345 
1346 static int __init reipl_type_init(void)
1347 {
1348     enum ipl_type reipl_type = ipl_info.type;
1349     struct ipl_parameter_block *reipl_block;
1350     unsigned long size;
1351 
1352     reipl_block = os_info_old_entry(OS_INFO_REIPL_BLOCK, &size);
1353     if (!reipl_block)
1354         goto out;
1355     /*
1356      * If we have an OS info reipl block, this will be used
1357      */
1358     if (reipl_block->pb0_hdr.pbt == IPL_PBT_FCP) {
1359         memcpy(reipl_block_fcp, reipl_block, size);
1360         reipl_type = IPL_TYPE_FCP;
1361     } else if (reipl_block->pb0_hdr.pbt == IPL_PBT_NVME) {
1362         memcpy(reipl_block_nvme, reipl_block, size);
1363         reipl_type = IPL_TYPE_NVME;
1364     } else if (reipl_block->pb0_hdr.pbt == IPL_PBT_CCW) {
1365         memcpy(reipl_block_ccw, reipl_block, size);
1366         reipl_type = IPL_TYPE_CCW;
1367     }
1368 out:
1369     return reipl_set_type(reipl_type);
1370 }
1371 
1372 static int __init reipl_init(void)
1373 {
1374     int rc;
1375 
1376     reipl_kset = kset_create_and_add("reipl", NULL, firmware_kobj);
1377     if (!reipl_kset)
1378         return -ENOMEM;
1379     rc = sysfs_create_file(&reipl_kset->kobj, &reipl_type_attr.attr);
1380     if (rc) {
1381         kset_unregister(reipl_kset);
1382         return rc;
1383     }
1384     rc = reipl_ccw_init();
1385     if (rc)
1386         return rc;
1387     rc = reipl_fcp_init();
1388     if (rc)
1389         return rc;
1390     rc = reipl_nvme_init();
1391     if (rc)
1392         return rc;
1393     rc = reipl_nss_init();
1394     if (rc)
1395         return rc;
1396     return reipl_type_init();
1397 }
1398 
1399 static struct shutdown_action __refdata reipl_action = {
1400     .name   = SHUTDOWN_ACTION_REIPL_STR,
1401     .fn = reipl_run,
1402     .init   = reipl_init,
1403 };
1404 
1405 /*
1406  * dump shutdown action: Dump Linux on shutdown.
1407  */
1408 
1409 /* FCP dump device attributes */
1410 
1411 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%llx\n",
1412            dump_block_fcp->fcp.wwpn);
1413 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%llx\n",
1414            dump_block_fcp->fcp.lun);
1415 DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
1416            dump_block_fcp->fcp.bootprog);
1417 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
1418            dump_block_fcp->fcp.br_lba);
1419 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
1420            dump_block_fcp->fcp.devno);
1421 
1422 static struct attribute *dump_fcp_attrs[] = {
1423     &sys_dump_fcp_device_attr.attr,
1424     &sys_dump_fcp_wwpn_attr.attr,
1425     &sys_dump_fcp_lun_attr.attr,
1426     &sys_dump_fcp_bootprog_attr.attr,
1427     &sys_dump_fcp_br_lba_attr.attr,
1428     NULL,
1429 };
1430 
1431 static struct attribute_group dump_fcp_attr_group = {
1432     .name  = IPL_FCP_STR,
1433     .attrs = dump_fcp_attrs,
1434 };
1435 
1436 /* NVME dump device attributes */
1437 DEFINE_IPL_ATTR_RW(dump_nvme, fid, "0x%08llx\n", "%llx\n",
1438            dump_block_nvme->nvme.fid);
1439 DEFINE_IPL_ATTR_RW(dump_nvme, nsid, "0x%08llx\n", "%llx\n",
1440            dump_block_nvme->nvme.nsid);
1441 DEFINE_IPL_ATTR_RW(dump_nvme, bootprog, "%lld\n", "%llx\n",
1442            dump_block_nvme->nvme.bootprog);
1443 DEFINE_IPL_ATTR_RW(dump_nvme, br_lba, "%lld\n", "%llx\n",
1444            dump_block_nvme->nvme.br_lba);
1445 
1446 static struct attribute *dump_nvme_attrs[] = {
1447     &sys_dump_nvme_fid_attr.attr,
1448     &sys_dump_nvme_nsid_attr.attr,
1449     &sys_dump_nvme_bootprog_attr.attr,
1450     &sys_dump_nvme_br_lba_attr.attr,
1451     NULL,
1452 };
1453 
1454 static struct attribute_group dump_nvme_attr_group = {
1455     .name  = IPL_NVME_STR,
1456     .attrs = dump_nvme_attrs,
1457 };
1458 
1459 /* CCW dump device attributes */
1460 DEFINE_IPL_CCW_ATTR_RW(dump_ccw, device, dump_block_ccw->ccw);
1461 
1462 static struct attribute *dump_ccw_attrs[] = {
1463     &sys_dump_ccw_device_attr.attr,
1464     NULL,
1465 };
1466 
1467 static struct attribute_group dump_ccw_attr_group = {
1468     .name  = IPL_CCW_STR,
1469     .attrs = dump_ccw_attrs,
1470 };
1471 
1472 /* dump type */
1473 
1474 static int dump_set_type(enum dump_type type)
1475 {
1476     if (!(dump_capabilities & type))
1477         return -EINVAL;
1478     dump_type = type;
1479     return 0;
1480 }
1481 
1482 static ssize_t dump_type_show(struct kobject *kobj,
1483                   struct kobj_attribute *attr, char *page)
1484 {
1485     return sprintf(page, "%s\n", dump_type_str(dump_type));
1486 }
1487 
1488 static ssize_t dump_type_store(struct kobject *kobj,
1489                    struct kobj_attribute *attr,
1490                    const char *buf, size_t len)
1491 {
1492     int rc = -EINVAL;
1493 
1494     if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0)
1495         rc = dump_set_type(DUMP_TYPE_NONE);
1496     else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0)
1497         rc = dump_set_type(DUMP_TYPE_CCW);
1498     else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0)
1499         rc = dump_set_type(DUMP_TYPE_FCP);
1500     else if (strncmp(buf, DUMP_NVME_STR, strlen(DUMP_NVME_STR)) == 0)
1501         rc = dump_set_type(DUMP_TYPE_NVME);
1502     return (rc != 0) ? rc : len;
1503 }
1504 
1505 static struct kobj_attribute dump_type_attr =
1506     __ATTR(dump_type, 0644, dump_type_show, dump_type_store);
1507 
1508 static struct kset *dump_kset;
1509 
1510 static void diag308_dump(void *dump_block)
1511 {
1512     diag308(DIAG308_SET, dump_block);
1513     while (1) {
1514         if (diag308(DIAG308_LOAD_NORMAL_DUMP, NULL) != 0x302)
1515             break;
1516         udelay(USEC_PER_SEC);
1517     }
1518 }
1519 
1520 static void __dump_run(void *unused)
1521 {
1522     switch (dump_type) {
1523     case DUMP_TYPE_CCW:
1524         diag308_dump(dump_block_ccw);
1525         break;
1526     case DUMP_TYPE_FCP:
1527         diag308_dump(dump_block_fcp);
1528         break;
1529     case DUMP_TYPE_NVME:
1530         diag308_dump(dump_block_nvme);
1531         break;
1532     default:
1533         break;
1534     }
1535 }
1536 
1537 static void dump_run(struct shutdown_trigger *trigger)
1538 {
1539     if (dump_type == DUMP_TYPE_NONE)
1540         return;
1541     smp_send_stop();
1542     smp_call_ipl_cpu(__dump_run, NULL);
1543 }
1544 
1545 static int __init dump_ccw_init(void)
1546 {
1547     int rc;
1548 
1549     dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
1550     if (!dump_block_ccw)
1551         return -ENOMEM;
1552     rc = sysfs_create_group(&dump_kset->kobj, &dump_ccw_attr_group);
1553     if (rc) {
1554         free_page((unsigned long)dump_block_ccw);
1555         return rc;
1556     }
1557     dump_block_ccw->hdr.len = IPL_BP_CCW_LEN;
1558     dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
1559     dump_block_ccw->ccw.len = IPL_BP0_CCW_LEN;
1560     dump_block_ccw->ccw.pbt = IPL_PBT_CCW;
1561     dump_capabilities |= DUMP_TYPE_CCW;
1562     return 0;
1563 }
1564 
1565 static int __init dump_fcp_init(void)
1566 {
1567     int rc;
1568 
1569     if (!sclp_ipl_info.has_dump)
1570         return 0; /* LDIPL DUMP is not installed */
1571     dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
1572     if (!dump_block_fcp)
1573         return -ENOMEM;
1574     rc = sysfs_create_group(&dump_kset->kobj, &dump_fcp_attr_group);
1575     if (rc) {
1576         free_page((unsigned long)dump_block_fcp);
1577         return rc;
1578     }
1579     dump_block_fcp->hdr.len = IPL_BP_FCP_LEN;
1580     dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1581     dump_block_fcp->fcp.len = IPL_BP0_FCP_LEN;
1582     dump_block_fcp->fcp.pbt = IPL_PBT_FCP;
1583     dump_block_fcp->fcp.opt = IPL_PB0_FCP_OPT_DUMP;
1584     dump_capabilities |= DUMP_TYPE_FCP;
1585     return 0;
1586 }
1587 
1588 static int __init dump_nvme_init(void)
1589 {
1590     int rc;
1591 
1592     if (!sclp_ipl_info.has_dump)
1593         return 0; /* LDIPL DUMP is not installed */
1594     dump_block_nvme = (void *) get_zeroed_page(GFP_KERNEL);
1595     if (!dump_block_nvme)
1596         return -ENOMEM;
1597     rc = sysfs_create_group(&dump_kset->kobj, &dump_nvme_attr_group);
1598     if (rc) {
1599         free_page((unsigned long)dump_block_nvme);
1600         return rc;
1601     }
1602     dump_block_nvme->hdr.len = IPL_BP_NVME_LEN;
1603     dump_block_nvme->hdr.version = IPL_PARM_BLOCK_VERSION;
1604     dump_block_nvme->fcp.len = IPL_BP0_NVME_LEN;
1605     dump_block_nvme->fcp.pbt = IPL_PBT_NVME;
1606     dump_block_nvme->fcp.opt = IPL_PB0_NVME_OPT_DUMP;
1607     dump_capabilities |= DUMP_TYPE_NVME;
1608     return 0;
1609 }
1610 
1611 static int __init dump_init(void)
1612 {
1613     int rc;
1614 
1615     dump_kset = kset_create_and_add("dump", NULL, firmware_kobj);
1616     if (!dump_kset)
1617         return -ENOMEM;
1618     rc = sysfs_create_file(&dump_kset->kobj, &dump_type_attr.attr);
1619     if (rc) {
1620         kset_unregister(dump_kset);
1621         return rc;
1622     }
1623     rc = dump_ccw_init();
1624     if (rc)
1625         return rc;
1626     rc = dump_fcp_init();
1627     if (rc)
1628         return rc;
1629     rc = dump_nvme_init();
1630     if (rc)
1631         return rc;
1632     dump_set_type(DUMP_TYPE_NONE);
1633     return 0;
1634 }
1635 
1636 static struct shutdown_action __refdata dump_action = {
1637     .name   = SHUTDOWN_ACTION_DUMP_STR,
1638     .fn = dump_run,
1639     .init   = dump_init,
1640 };
1641 
1642 static void dump_reipl_run(struct shutdown_trigger *trigger)
1643 {
1644     unsigned long ipib = (unsigned long) reipl_block_actual;
1645     unsigned int csum;
1646 
1647     csum = (__force unsigned int)
1648            csum_partial(reipl_block_actual, reipl_block_actual->hdr.len, 0);
1649     put_abs_lowcore(ipib, ipib);
1650     put_abs_lowcore(ipib_checksum, csum);
1651     dump_run(trigger);
1652 }
1653 
1654 static struct shutdown_action __refdata dump_reipl_action = {
1655     .name   = SHUTDOWN_ACTION_DUMP_REIPL_STR,
1656     .fn = dump_reipl_run,
1657 };
1658 
1659 /*
1660  * vmcmd shutdown action: Trigger vm command on shutdown.
1661  */
1662 
1663 static char vmcmd_on_reboot[128];
1664 static char vmcmd_on_panic[128];
1665 static char vmcmd_on_halt[128];
1666 static char vmcmd_on_poff[128];
1667 static char vmcmd_on_restart[128];
1668 
1669 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_reboot, "%s\n", "%s\n", vmcmd_on_reboot);
1670 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_panic, "%s\n", "%s\n", vmcmd_on_panic);
1671 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_halt, "%s\n", "%s\n", vmcmd_on_halt);
1672 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_poff, "%s\n", "%s\n", vmcmd_on_poff);
1673 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_restart, "%s\n", "%s\n", vmcmd_on_restart);
1674 
1675 static struct attribute *vmcmd_attrs[] = {
1676     &sys_vmcmd_on_reboot_attr.attr,
1677     &sys_vmcmd_on_panic_attr.attr,
1678     &sys_vmcmd_on_halt_attr.attr,
1679     &sys_vmcmd_on_poff_attr.attr,
1680     &sys_vmcmd_on_restart_attr.attr,
1681     NULL,
1682 };
1683 
1684 static struct attribute_group vmcmd_attr_group = {
1685     .attrs = vmcmd_attrs,
1686 };
1687 
1688 static struct kset *vmcmd_kset;
1689 
1690 static void vmcmd_run(struct shutdown_trigger *trigger)
1691 {
1692     char *cmd;
1693 
1694     if (strcmp(trigger->name, ON_REIPL_STR) == 0)
1695         cmd = vmcmd_on_reboot;
1696     else if (strcmp(trigger->name, ON_PANIC_STR) == 0)
1697         cmd = vmcmd_on_panic;
1698     else if (strcmp(trigger->name, ON_HALT_STR) == 0)
1699         cmd = vmcmd_on_halt;
1700     else if (strcmp(trigger->name, ON_POFF_STR) == 0)
1701         cmd = vmcmd_on_poff;
1702     else if (strcmp(trigger->name, ON_RESTART_STR) == 0)
1703         cmd = vmcmd_on_restart;
1704     else
1705         return;
1706 
1707     if (strlen(cmd) == 0)
1708         return;
1709     __cpcmd(cmd, NULL, 0, NULL);
1710 }
1711 
1712 static int vmcmd_init(void)
1713 {
1714     if (!MACHINE_IS_VM)
1715         return -EOPNOTSUPP;
1716     vmcmd_kset = kset_create_and_add("vmcmd", NULL, firmware_kobj);
1717     if (!vmcmd_kset)
1718         return -ENOMEM;
1719     return sysfs_create_group(&vmcmd_kset->kobj, &vmcmd_attr_group);
1720 }
1721 
1722 static struct shutdown_action vmcmd_action = {SHUTDOWN_ACTION_VMCMD_STR,
1723                           vmcmd_run, vmcmd_init};
1724 
1725 /*
1726  * stop shutdown action: Stop Linux on shutdown.
1727  */
1728 
1729 static void stop_run(struct shutdown_trigger *trigger)
1730 {
1731     if (strcmp(trigger->name, ON_PANIC_STR) == 0 ||
1732         strcmp(trigger->name, ON_RESTART_STR) == 0)
1733         disabled_wait();
1734     smp_stop_cpu();
1735 }
1736 
1737 static struct shutdown_action stop_action = {SHUTDOWN_ACTION_STOP_STR,
1738                          stop_run, NULL};
1739 
1740 /* action list */
1741 
1742 static struct shutdown_action *shutdown_actions_list[] = {
1743     &ipl_action, &reipl_action, &dump_reipl_action, &dump_action,
1744     &vmcmd_action, &stop_action};
1745 #define SHUTDOWN_ACTIONS_COUNT (sizeof(shutdown_actions_list) / sizeof(void *))
1746 
1747 /*
1748  * Trigger section
1749  */
1750 
1751 static struct kset *shutdown_actions_kset;
1752 
1753 static int set_trigger(const char *buf, struct shutdown_trigger *trigger,
1754                size_t len)
1755 {
1756     int i;
1757 
1758     for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) {
1759         if (sysfs_streq(buf, shutdown_actions_list[i]->name)) {
1760             if (shutdown_actions_list[i]->init_rc) {
1761                 return shutdown_actions_list[i]->init_rc;
1762             } else {
1763                 trigger->action = shutdown_actions_list[i];
1764                 return len;
1765             }
1766         }
1767     }
1768     return -EINVAL;
1769 }
1770 
1771 /* on reipl */
1772 
1773 static struct shutdown_trigger on_reboot_trigger = {ON_REIPL_STR,
1774                             &reipl_action};
1775 
1776 static ssize_t on_reboot_show(struct kobject *kobj,
1777                   struct kobj_attribute *attr, char *page)
1778 {
1779     return sprintf(page, "%s\n", on_reboot_trigger.action->name);
1780 }
1781 
1782 static ssize_t on_reboot_store(struct kobject *kobj,
1783                    struct kobj_attribute *attr,
1784                    const char *buf, size_t len)
1785 {
1786     return set_trigger(buf, &on_reboot_trigger, len);
1787 }
1788 static struct kobj_attribute on_reboot_attr = __ATTR_RW(on_reboot);
1789 
1790 static void do_machine_restart(char *__unused)
1791 {
1792     smp_send_stop();
1793     on_reboot_trigger.action->fn(&on_reboot_trigger);
1794     reipl_run(NULL);
1795 }
1796 void (*_machine_restart)(char *command) = do_machine_restart;
1797 
1798 /* on panic */
1799 
1800 static struct shutdown_trigger on_panic_trigger = {ON_PANIC_STR, &stop_action};
1801 
1802 static ssize_t on_panic_show(struct kobject *kobj,
1803                  struct kobj_attribute *attr, char *page)
1804 {
1805     return sprintf(page, "%s\n", on_panic_trigger.action->name);
1806 }
1807 
1808 static ssize_t on_panic_store(struct kobject *kobj,
1809                   struct kobj_attribute *attr,
1810                   const char *buf, size_t len)
1811 {
1812     return set_trigger(buf, &on_panic_trigger, len);
1813 }
1814 static struct kobj_attribute on_panic_attr = __ATTR_RW(on_panic);
1815 
1816 static void do_panic(void)
1817 {
1818     lgr_info_log();
1819     on_panic_trigger.action->fn(&on_panic_trigger);
1820     stop_run(&on_panic_trigger);
1821 }
1822 
1823 /* on restart */
1824 
1825 static struct shutdown_trigger on_restart_trigger = {ON_RESTART_STR,
1826     &stop_action};
1827 
1828 static ssize_t on_restart_show(struct kobject *kobj,
1829                    struct kobj_attribute *attr, char *page)
1830 {
1831     return sprintf(page, "%s\n", on_restart_trigger.action->name);
1832 }
1833 
1834 static ssize_t on_restart_store(struct kobject *kobj,
1835                 struct kobj_attribute *attr,
1836                 const char *buf, size_t len)
1837 {
1838     return set_trigger(buf, &on_restart_trigger, len);
1839 }
1840 static struct kobj_attribute on_restart_attr = __ATTR_RW(on_restart);
1841 
1842 static void __do_restart(void *ignore)
1843 {
1844     smp_send_stop();
1845 #ifdef CONFIG_CRASH_DUMP
1846     crash_kexec(NULL);
1847 #endif
1848     on_restart_trigger.action->fn(&on_restart_trigger);
1849     stop_run(&on_restart_trigger);
1850 }
1851 
1852 void do_restart(void *arg)
1853 {
1854     tracing_off();
1855     debug_locks_off();
1856     lgr_info_log();
1857     smp_call_online_cpu(__do_restart, arg);
1858 }
1859 
1860 /* on halt */
1861 
1862 static struct shutdown_trigger on_halt_trigger = {ON_HALT_STR, &stop_action};
1863 
1864 static ssize_t on_halt_show(struct kobject *kobj,
1865                 struct kobj_attribute *attr, char *page)
1866 {
1867     return sprintf(page, "%s\n", on_halt_trigger.action->name);
1868 }
1869 
1870 static ssize_t on_halt_store(struct kobject *kobj,
1871                  struct kobj_attribute *attr,
1872                  const char *buf, size_t len)
1873 {
1874     return set_trigger(buf, &on_halt_trigger, len);
1875 }
1876 static struct kobj_attribute on_halt_attr = __ATTR_RW(on_halt);
1877 
1878 static void do_machine_halt(void)
1879 {
1880     smp_send_stop();
1881     on_halt_trigger.action->fn(&on_halt_trigger);
1882     stop_run(&on_halt_trigger);
1883 }
1884 void (*_machine_halt)(void) = do_machine_halt;
1885 
1886 /* on power off */
1887 
1888 static struct shutdown_trigger on_poff_trigger = {ON_POFF_STR, &stop_action};
1889 
1890 static ssize_t on_poff_show(struct kobject *kobj,
1891                 struct kobj_attribute *attr, char *page)
1892 {
1893     return sprintf(page, "%s\n", on_poff_trigger.action->name);
1894 }
1895 
1896 static ssize_t on_poff_store(struct kobject *kobj,
1897                  struct kobj_attribute *attr,
1898                  const char *buf, size_t len)
1899 {
1900     return set_trigger(buf, &on_poff_trigger, len);
1901 }
1902 static struct kobj_attribute on_poff_attr = __ATTR_RW(on_poff);
1903 
1904 static void do_machine_power_off(void)
1905 {
1906     smp_send_stop();
1907     on_poff_trigger.action->fn(&on_poff_trigger);
1908     stop_run(&on_poff_trigger);
1909 }
1910 void (*_machine_power_off)(void) = do_machine_power_off;
1911 
1912 static struct attribute *shutdown_action_attrs[] = {
1913     &on_restart_attr.attr,
1914     &on_reboot_attr.attr,
1915     &on_panic_attr.attr,
1916     &on_halt_attr.attr,
1917     &on_poff_attr.attr,
1918     NULL,
1919 };
1920 
1921 static struct attribute_group shutdown_action_attr_group = {
1922     .attrs = shutdown_action_attrs,
1923 };
1924 
1925 static void __init shutdown_triggers_init(void)
1926 {
1927     shutdown_actions_kset = kset_create_and_add("shutdown_actions", NULL,
1928                             firmware_kobj);
1929     if (!shutdown_actions_kset)
1930         goto fail;
1931     if (sysfs_create_group(&shutdown_actions_kset->kobj,
1932                    &shutdown_action_attr_group))
1933         goto fail;
1934     return;
1935 fail:
1936     panic("shutdown_triggers_init failed\n");
1937 }
1938 
1939 static void __init shutdown_actions_init(void)
1940 {
1941     int i;
1942 
1943     for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) {
1944         if (!shutdown_actions_list[i]->init)
1945             continue;
1946         shutdown_actions_list[i]->init_rc =
1947             shutdown_actions_list[i]->init();
1948     }
1949 }
1950 
1951 static int __init s390_ipl_init(void)
1952 {
1953     char str[8] = {0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40};
1954 
1955     sclp_early_get_ipl_info(&sclp_ipl_info);
1956     /*
1957      * Fix loadparm: There are systems where the (SCSI) LOADPARM
1958      * returned by read SCP info is invalid (contains EBCDIC blanks)
1959      * when the system has been booted via diag308. In that case we use
1960      * the value from diag308, if available.
1961      *
1962      * There are also systems where diag308 store does not work in
1963      * case the system is booted from HMC. Fortunately in this case
1964      * READ SCP info provides the correct value.
1965      */
1966     if (memcmp(sclp_ipl_info.loadparm, str, sizeof(str)) == 0 && ipl_block_valid)
1967         memcpy(sclp_ipl_info.loadparm, ipl_block.ccw.loadparm, LOADPARM_LEN);
1968     shutdown_actions_init();
1969     shutdown_triggers_init();
1970     return 0;
1971 }
1972 
1973 __initcall(s390_ipl_init);
1974 
1975 static void __init strncpy_skip_quote(char *dst, char *src, int n)
1976 {
1977     int sx, dx;
1978 
1979     dx = 0;
1980     for (sx = 0; src[sx] != 0; sx++) {
1981         if (src[sx] == '"')
1982             continue;
1983         dst[dx++] = src[sx];
1984         if (dx >= n)
1985             break;
1986     }
1987 }
1988 
1989 static int __init vmcmd_on_reboot_setup(char *str)
1990 {
1991     if (!MACHINE_IS_VM)
1992         return 1;
1993     strncpy_skip_quote(vmcmd_on_reboot, str, 127);
1994     vmcmd_on_reboot[127] = 0;
1995     on_reboot_trigger.action = &vmcmd_action;
1996     return 1;
1997 }
1998 __setup("vmreboot=", vmcmd_on_reboot_setup);
1999 
2000 static int __init vmcmd_on_panic_setup(char *str)
2001 {
2002     if (!MACHINE_IS_VM)
2003         return 1;
2004     strncpy_skip_quote(vmcmd_on_panic, str, 127);
2005     vmcmd_on_panic[127] = 0;
2006     on_panic_trigger.action = &vmcmd_action;
2007     return 1;
2008 }
2009 __setup("vmpanic=", vmcmd_on_panic_setup);
2010 
2011 static int __init vmcmd_on_halt_setup(char *str)
2012 {
2013     if (!MACHINE_IS_VM)
2014         return 1;
2015     strncpy_skip_quote(vmcmd_on_halt, str, 127);
2016     vmcmd_on_halt[127] = 0;
2017     on_halt_trigger.action = &vmcmd_action;
2018     return 1;
2019 }
2020 __setup("vmhalt=", vmcmd_on_halt_setup);
2021 
2022 static int __init vmcmd_on_poff_setup(char *str)
2023 {
2024     if (!MACHINE_IS_VM)
2025         return 1;
2026     strncpy_skip_quote(vmcmd_on_poff, str, 127);
2027     vmcmd_on_poff[127] = 0;
2028     on_poff_trigger.action = &vmcmd_action;
2029     return 1;
2030 }
2031 __setup("vmpoff=", vmcmd_on_poff_setup);
2032 
2033 static int on_panic_notify(struct notifier_block *self,
2034                unsigned long event, void *data)
2035 {
2036     do_panic();
2037     return NOTIFY_OK;
2038 }
2039 
2040 static struct notifier_block on_panic_nb = {
2041     .notifier_call = on_panic_notify,
2042     .priority = INT_MIN,
2043 };
2044 
2045 void __init setup_ipl(void)
2046 {
2047     BUILD_BUG_ON(sizeof(struct ipl_parameter_block) != PAGE_SIZE);
2048 
2049     ipl_info.type = get_ipl_type();
2050     switch (ipl_info.type) {
2051     case IPL_TYPE_CCW:
2052         ipl_info.data.ccw.dev_id.ssid = ipl_block.ccw.ssid;
2053         ipl_info.data.ccw.dev_id.devno = ipl_block.ccw.devno;
2054         break;
2055     case IPL_TYPE_FCP:
2056     case IPL_TYPE_FCP_DUMP:
2057         ipl_info.data.fcp.dev_id.ssid = 0;
2058         ipl_info.data.fcp.dev_id.devno = ipl_block.fcp.devno;
2059         ipl_info.data.fcp.wwpn = ipl_block.fcp.wwpn;
2060         ipl_info.data.fcp.lun = ipl_block.fcp.lun;
2061         break;
2062     case IPL_TYPE_NVME:
2063     case IPL_TYPE_NVME_DUMP:
2064         ipl_info.data.nvme.fid = ipl_block.nvme.fid;
2065         ipl_info.data.nvme.nsid = ipl_block.nvme.nsid;
2066         break;
2067     case IPL_TYPE_NSS:
2068     case IPL_TYPE_UNKNOWN:
2069         /* We have no info to copy */
2070         break;
2071     }
2072     atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
2073 }
2074 
2075 void s390_reset_system(void)
2076 {
2077     /* Disable prefixing */
2078     set_prefix(0);
2079 
2080     /* Disable lowcore protection */
2081     __ctl_clear_bit(0, 28);
2082     diag_amode31_ops.diag308_reset();
2083 }
2084 
2085 #ifdef CONFIG_KEXEC_FILE
2086 
2087 int ipl_report_add_component(struct ipl_report *report, struct kexec_buf *kbuf,
2088                  unsigned char flags, unsigned short cert)
2089 {
2090     struct ipl_report_component *comp;
2091 
2092     comp = vzalloc(sizeof(*comp));
2093     if (!comp)
2094         return -ENOMEM;
2095     list_add_tail(&comp->list, &report->components);
2096 
2097     comp->entry.addr = kbuf->mem;
2098     comp->entry.len = kbuf->memsz;
2099     comp->entry.flags = flags;
2100     comp->entry.certificate_index = cert;
2101 
2102     report->size += sizeof(comp->entry);
2103 
2104     return 0;
2105 }
2106 
2107 int ipl_report_add_certificate(struct ipl_report *report, void *key,
2108                    unsigned long addr, unsigned long len)
2109 {
2110     struct ipl_report_certificate *cert;
2111 
2112     cert = vzalloc(sizeof(*cert));
2113     if (!cert)
2114         return -ENOMEM;
2115     list_add_tail(&cert->list, &report->certificates);
2116 
2117     cert->entry.addr = addr;
2118     cert->entry.len = len;
2119     cert->key = key;
2120 
2121     report->size += sizeof(cert->entry);
2122     report->size += cert->entry.len;
2123 
2124     return 0;
2125 }
2126 
2127 struct ipl_report *ipl_report_init(struct ipl_parameter_block *ipib)
2128 {
2129     struct ipl_report *report;
2130 
2131     report = vzalloc(sizeof(*report));
2132     if (!report)
2133         return ERR_PTR(-ENOMEM);
2134 
2135     report->ipib = ipib;
2136     INIT_LIST_HEAD(&report->components);
2137     INIT_LIST_HEAD(&report->certificates);
2138 
2139     report->size = ALIGN(ipib->hdr.len, 8);
2140     report->size += sizeof(struct ipl_rl_hdr);
2141     report->size += sizeof(struct ipl_rb_components);
2142     report->size += sizeof(struct ipl_rb_certificates);
2143 
2144     return report;
2145 }
2146 
2147 void *ipl_report_finish(struct ipl_report *report)
2148 {
2149     struct ipl_report_certificate *cert;
2150     struct ipl_report_component *comp;
2151     struct ipl_rb_certificates *certs;
2152     struct ipl_parameter_block *ipib;
2153     struct ipl_rb_components *comps;
2154     struct ipl_rl_hdr *rl_hdr;
2155     void *buf, *ptr;
2156 
2157     buf = vzalloc(report->size);
2158     if (!buf)
2159         goto out;
2160     ptr = buf;
2161 
2162     memcpy(ptr, report->ipib, report->ipib->hdr.len);
2163     ipib = ptr;
2164     if (ipl_secure_flag)
2165         ipib->hdr.flags |= IPL_PL_FLAG_SIPL;
2166     ipib->hdr.flags |= IPL_PL_FLAG_IPLSR;
2167     ptr += report->ipib->hdr.len;
2168     ptr = PTR_ALIGN(ptr, 8);
2169 
2170     rl_hdr = ptr;
2171     ptr += sizeof(*rl_hdr);
2172 
2173     comps = ptr;
2174     comps->rbt = IPL_RBT_COMPONENTS;
2175     ptr += sizeof(*comps);
2176     list_for_each_entry(comp, &report->components, list) {
2177         memcpy(ptr, &comp->entry, sizeof(comp->entry));
2178         ptr += sizeof(comp->entry);
2179     }
2180     comps->len = ptr - (void *)comps;
2181 
2182     certs = ptr;
2183     certs->rbt = IPL_RBT_CERTIFICATES;
2184     ptr += sizeof(*certs);
2185     list_for_each_entry(cert, &report->certificates, list) {
2186         memcpy(ptr, &cert->entry, sizeof(cert->entry));
2187         ptr += sizeof(cert->entry);
2188     }
2189     certs->len = ptr - (void *)certs;
2190     rl_hdr->len = ptr - (void *)rl_hdr;
2191 
2192     list_for_each_entry(cert, &report->certificates, list) {
2193         memcpy(ptr, cert->key, cert->entry.len);
2194         ptr += cert->entry.len;
2195     }
2196 
2197     BUG_ON(ptr > buf + report->size);
2198 out:
2199     return buf;
2200 }
2201 
2202 int ipl_report_free(struct ipl_report *report)
2203 {
2204     struct ipl_report_component *comp, *ncomp;
2205     struct ipl_report_certificate *cert, *ncert;
2206 
2207     list_for_each_entry_safe(comp, ncomp, &report->components, list)
2208         vfree(comp);
2209 
2210     list_for_each_entry_safe(cert, ncert, &report->certificates, list)
2211         vfree(cert);
2212 
2213     vfree(report);
2214 
2215     return 0;
2216 }
2217 
2218 #endif
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!