2 * ipl/reipl/dump support for Linux on s390.
4 * Copyright IBM Corp. 2005, 2012
5 * Author(s): Michael Holzheu <holzheu@de.ibm.com>
6 * Heiko Carstens <heiko.carstens@de.ibm.com>
7 * Volker Sameske <sameske@de.ibm.com>
10 #include <linux/types.h>
11 #include <linux/module.h>
12 #include <linux/device.h>
13 #include <linux/delay.h>
14 #include <linux/reboot.h>
15 #include <linux/ctype.h>
17 #include <linux/gfp.h>
18 #include <linux/crash_dump.h>
19 #include <linux/debug_locks.h>
23 #include <asm/setup.h>
24 #include <asm/cpcmd.h>
26 #include <asm/ebcdic.h>
27 #include <asm/reset.h>
29 #include <asm/checksum.h>
30 #include <asm/debug.h>
31 #include <asm/os_info.h>
34 #define IPL_PARM_BLOCK_VERSION 0
36 #define IPL_UNKNOWN_STR "unknown"
37 #define IPL_CCW_STR "ccw"
38 #define IPL_FCP_STR "fcp"
39 #define IPL_FCP_DUMP_STR "fcp_dump"
40 #define IPL_NSS_STR "nss"
42 #define DUMP_CCW_STR "ccw"
43 #define DUMP_FCP_STR "fcp"
44 #define DUMP_NONE_STR "none"
47 * Four shutdown trigger types are supported:
54 #define ON_PANIC_STR "on_panic"
55 #define ON_HALT_STR "on_halt"
56 #define ON_POFF_STR "on_poff"
57 #define ON_REIPL_STR "on_reboot"
58 #define ON_RESTART_STR "on_restart"
60 struct shutdown_action;
61 struct shutdown_trigger {
63 struct shutdown_action *action;
67 * The following shutdown action types are supported:
69 #define SHUTDOWN_ACTION_IPL_STR "ipl"
70 #define SHUTDOWN_ACTION_REIPL_STR "reipl"
71 #define SHUTDOWN_ACTION_DUMP_STR "dump"
72 #define SHUTDOWN_ACTION_VMCMD_STR "vmcmd"
73 #define SHUTDOWN_ACTION_STOP_STR "stop"
74 #define SHUTDOWN_ACTION_DUMP_REIPL_STR "dump_reipl"
76 struct shutdown_action {
78 void (*fn) (struct shutdown_trigger *trigger);
83 static char *ipl_type_str(enum ipl_type type)
90 case IPL_TYPE_FCP_DUMP:
91 return IPL_FCP_DUMP_STR;
94 case IPL_TYPE_UNKNOWN:
96 return IPL_UNKNOWN_STR;
106 static char *dump_type_str(enum dump_type type)
110 return DUMP_NONE_STR;
121 * Must be in data section since the bss section
122 * is not cleared when these are accessed.
124 static u16 ipl_devno __attribute__((__section__(".data"))) = 0;
125 u32 ipl_flags __attribute__((__section__(".data"))) = 0;
128 REIPL_METHOD_CCW_CIO,
129 REIPL_METHOD_CCW_DIAG,
131 REIPL_METHOD_FCP_RO_DIAG,
132 REIPL_METHOD_FCP_RW_DIAG,
133 REIPL_METHOD_FCP_RO_VM,
134 REIPL_METHOD_FCP_DUMP,
136 REIPL_METHOD_NSS_DIAG,
137 REIPL_METHOD_DEFAULT,
143 DUMP_METHOD_CCW_DIAG,
145 DUMP_METHOD_FCP_DIAG,
148 static int diag308_set_works = 0;
150 static struct ipl_parameter_block ipl_block;
152 static int reipl_capabilities = IPL_TYPE_UNKNOWN;
154 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
155 static enum ipl_method reipl_method = REIPL_METHOD_DEFAULT;
156 static struct ipl_parameter_block *reipl_block_fcp;
157 static struct ipl_parameter_block *reipl_block_ccw;
158 static struct ipl_parameter_block *reipl_block_nss;
159 static struct ipl_parameter_block *reipl_block_actual;
161 static int dump_capabilities = DUMP_TYPE_NONE;
162 static enum dump_type dump_type = DUMP_TYPE_NONE;
163 static enum dump_method dump_method = DUMP_METHOD_NONE;
164 static struct ipl_parameter_block *dump_block_fcp;
165 static struct ipl_parameter_block *dump_block_ccw;
167 static struct sclp_ipl_info sclp_ipl_info;
169 static inline int __diag308(unsigned long subcode, void *addr)
171 register unsigned long _addr asm("0") = (unsigned long) addr;
172 register unsigned long _rc asm("1") = 0;
175 " diag %0,%2,0x308\n"
178 : "+d" (_addr), "+d" (_rc)
179 : "d" (subcode) : "cc", "memory");
183 int diag308(unsigned long subcode, void *addr)
185 diag_stat_inc(DIAG_STAT_X308);
186 return __diag308(subcode, addr);
188 EXPORT_SYMBOL_GPL(diag308);
192 #define IPL_ATTR_SHOW_FN(_prefix, _name, _format, args...) \
193 static ssize_t sys_##_prefix##_##_name##_show(struct kobject *kobj, \
194 struct kobj_attribute *attr, \
197 return snprintf(page, PAGE_SIZE, _format, ##args); \
200 #define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value) \
201 IPL_ATTR_SHOW_FN(_prefix, _name, _format, _value) \
202 static struct kobj_attribute sys_##_prefix##_##_name##_attr = \
203 __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL)
205 #define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value) \
206 IPL_ATTR_SHOW_FN(_prefix, _name, _fmt_out, (unsigned long long) _value) \
207 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj, \
208 struct kobj_attribute *attr, \
209 const char *buf, size_t len) \
211 unsigned long long value; \
212 if (sscanf(buf, _fmt_in, &value) != 1) \
217 static struct kobj_attribute sys_##_prefix##_##_name##_attr = \
218 __ATTR(_name,(S_IRUGO | S_IWUSR), \
219 sys_##_prefix##_##_name##_show, \
220 sys_##_prefix##_##_name##_store)
222 #define DEFINE_IPL_ATTR_STR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)\
223 IPL_ATTR_SHOW_FN(_prefix, _name, _fmt_out, _value) \
224 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj, \
225 struct kobj_attribute *attr, \
226 const char *buf, size_t len) \
228 strncpy(_value, buf, sizeof(_value) - 1); \
232 static struct kobj_attribute sys_##_prefix##_##_name##_attr = \
233 __ATTR(_name,(S_IRUGO | S_IWUSR), \
234 sys_##_prefix##_##_name##_show, \
235 sys_##_prefix##_##_name##_store)
237 static void make_attrs_ro(struct attribute **attrs)
240 (*attrs)->mode = S_IRUGO;
249 static __init enum ipl_type get_ipl_type(void)
251 struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
253 if (ipl_flags & IPL_NSS_VALID)
255 if (!(ipl_flags & IPL_DEVNO_VALID))
256 return IPL_TYPE_UNKNOWN;
257 if (!(ipl_flags & IPL_PARMBLOCK_VALID))
259 if (ipl->hdr.version > IPL_MAX_SUPPORTED_VERSION)
260 return IPL_TYPE_UNKNOWN;
261 if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP)
262 return IPL_TYPE_UNKNOWN;
263 if (ipl->ipl_info.fcp.opt == DIAG308_IPL_OPT_DUMP)
264 return IPL_TYPE_FCP_DUMP;
268 struct ipl_info ipl_info;
269 EXPORT_SYMBOL_GPL(ipl_info);
271 static ssize_t ipl_type_show(struct kobject *kobj, struct kobj_attribute *attr,
274 return sprintf(page, "%s\n", ipl_type_str(ipl_info.type));
277 static struct kobj_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
279 /* VM IPL PARM routines */
280 static size_t reipl_get_ascii_vmparm(char *dest, size_t size,
281 const struct ipl_parameter_block *ipb)
285 char has_lowercase = 0;
288 if ((ipb->ipl_info.ccw.vm_flags & DIAG308_VM_FLAGS_VP_VALID) &&
289 (ipb->ipl_info.ccw.vm_parm_len > 0)) {
291 len = min_t(size_t, size - 1, ipb->ipl_info.ccw.vm_parm_len);
292 memcpy(dest, ipb->ipl_info.ccw.vm_parm, len);
293 /* If at least one character is lowercase, we assume mixed
294 * case; otherwise we convert everything to lowercase.
296 for (i = 0; i < len; i++)
297 if ((dest[i] > 0x80 && dest[i] < 0x8a) || /* a-i */
298 (dest[i] > 0x90 && dest[i] < 0x9a) || /* j-r */
299 (dest[i] > 0xa1 && dest[i] < 0xaa)) { /* s-z */
304 EBC_TOLOWER(dest, len);
312 size_t append_ipl_vmparm(char *dest, size_t size)
317 if (diag308_set_works && (ipl_block.hdr.pbt == DIAG308_IPL_TYPE_CCW))
318 rc = reipl_get_ascii_vmparm(dest, size, &ipl_block);
324 static ssize_t ipl_vm_parm_show(struct kobject *kobj,
325 struct kobj_attribute *attr, char *page)
327 char parm[DIAG308_VMPARM_SIZE + 1] = {};
329 append_ipl_vmparm(parm, sizeof(parm));
330 return sprintf(page, "%s\n", parm);
333 static size_t scpdata_length(const char* buf, size_t count)
336 if (buf[count - 1] != '\0' && buf[count - 1] != ' ')
343 static size_t reipl_append_ascii_scpdata(char *dest, size_t size,
344 const struct ipl_parameter_block *ipb)
350 count = min(size - 1, scpdata_length(ipb->ipl_info.fcp.scp_data,
351 ipb->ipl_info.fcp.scp_data_len));
356 for (i = 0; i < count; i++) {
357 if (!isascii(ipb->ipl_info.fcp.scp_data[i])) {
361 if (!has_lowercase && islower(ipb->ipl_info.fcp.scp_data[i]))
366 memcpy(dest, ipb->ipl_info.fcp.scp_data, count);
368 for (i = 0; i < count; i++)
369 dest[i] = tolower(ipb->ipl_info.fcp.scp_data[i]);
375 size_t append_ipl_scpdata(char *dest, size_t len)
380 if (ipl_block.hdr.pbt == DIAG308_IPL_TYPE_FCP)
381 rc = reipl_append_ascii_scpdata(dest, len, &ipl_block);
388 static struct kobj_attribute sys_ipl_vm_parm_attr =
389 __ATTR(parm, S_IRUGO, ipl_vm_parm_show, NULL);
391 static ssize_t sys_ipl_device_show(struct kobject *kobj,
392 struct kobj_attribute *attr, char *page)
394 struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
396 switch (ipl_info.type) {
398 return sprintf(page, "0.0.%04x\n", ipl_devno);
400 case IPL_TYPE_FCP_DUMP:
401 return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno);
407 static struct kobj_attribute sys_ipl_device_attr =
408 __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
410 static ssize_t ipl_parameter_read(struct file *filp, struct kobject *kobj,
411 struct bin_attribute *attr, char *buf,
412 loff_t off, size_t count)
414 return memory_read_from_buffer(buf, count, &off, IPL_PARMBLOCK_START,
417 static struct bin_attribute ipl_parameter_attr =
418 __BIN_ATTR(binary_parameter, S_IRUGO, ipl_parameter_read, NULL,
421 static ssize_t ipl_scp_data_read(struct file *filp, struct kobject *kobj,
422 struct bin_attribute *attr, char *buf,
423 loff_t off, size_t count)
425 unsigned int size = IPL_PARMBLOCK_START->ipl_info.fcp.scp_data_len;
426 void *scp_data = &IPL_PARMBLOCK_START->ipl_info.fcp.scp_data;
428 return memory_read_from_buffer(buf, count, &off, scp_data, size);
430 static struct bin_attribute ipl_scp_data_attr =
431 __BIN_ATTR(scp_data, S_IRUGO, ipl_scp_data_read, NULL, PAGE_SIZE);
433 static struct bin_attribute *ipl_fcp_bin_attrs[] = {
439 /* FCP ipl device attributes */
441 DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n", (unsigned long long)
442 IPL_PARMBLOCK_START->ipl_info.fcp.wwpn);
443 DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n", (unsigned long long)
444 IPL_PARMBLOCK_START->ipl_info.fcp.lun);
445 DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n", (unsigned long long)
446 IPL_PARMBLOCK_START->ipl_info.fcp.bootprog);
447 DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n", (unsigned long long)
448 IPL_PARMBLOCK_START->ipl_info.fcp.br_lba);
450 static ssize_t ipl_ccw_loadparm_show(struct kobject *kobj,
451 struct kobj_attribute *attr, char *page)
453 char loadparm[LOADPARM_LEN + 1] = {};
455 if (!sclp_ipl_info.is_valid)
456 return sprintf(page, "#unknown#\n");
457 memcpy(loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN);
458 EBCASC(loadparm, LOADPARM_LEN);
460 return sprintf(page, "%s\n", loadparm);
463 static struct kobj_attribute sys_ipl_ccw_loadparm_attr =
464 __ATTR(loadparm, 0444, ipl_ccw_loadparm_show, NULL);
466 static struct attribute *ipl_fcp_attrs[] = {
467 &sys_ipl_type_attr.attr,
468 &sys_ipl_device_attr.attr,
469 &sys_ipl_fcp_wwpn_attr.attr,
470 &sys_ipl_fcp_lun_attr.attr,
471 &sys_ipl_fcp_bootprog_attr.attr,
472 &sys_ipl_fcp_br_lba_attr.attr,
473 &sys_ipl_ccw_loadparm_attr.attr,
477 static struct attribute_group ipl_fcp_attr_group = {
478 .attrs = ipl_fcp_attrs,
479 .bin_attrs = ipl_fcp_bin_attrs,
482 /* CCW ipl device attributes */
484 static struct attribute *ipl_ccw_attrs_vm[] = {
485 &sys_ipl_type_attr.attr,
486 &sys_ipl_device_attr.attr,
487 &sys_ipl_ccw_loadparm_attr.attr,
488 &sys_ipl_vm_parm_attr.attr,
492 static struct attribute *ipl_ccw_attrs_lpar[] = {
493 &sys_ipl_type_attr.attr,
494 &sys_ipl_device_attr.attr,
495 &sys_ipl_ccw_loadparm_attr.attr,
499 static struct attribute_group ipl_ccw_attr_group_vm = {
500 .attrs = ipl_ccw_attrs_vm,
503 static struct attribute_group ipl_ccw_attr_group_lpar = {
504 .attrs = ipl_ccw_attrs_lpar
507 /* NSS ipl device attributes */
509 DEFINE_IPL_ATTR_RO(ipl_nss, name, "%s\n", kernel_nss_name);
511 static struct attribute *ipl_nss_attrs[] = {
512 &sys_ipl_type_attr.attr,
513 &sys_ipl_nss_name_attr.attr,
514 &sys_ipl_ccw_loadparm_attr.attr,
515 &sys_ipl_vm_parm_attr.attr,
519 static struct attribute_group ipl_nss_attr_group = {
520 .attrs = ipl_nss_attrs,
523 /* UNKNOWN ipl device attributes */
525 static struct attribute *ipl_unknown_attrs[] = {
526 &sys_ipl_type_attr.attr,
530 static struct attribute_group ipl_unknown_attr_group = {
531 .attrs = ipl_unknown_attrs,
534 static struct kset *ipl_kset;
536 static void __ipl_run(void *unused)
538 diag308(DIAG308_IPL, NULL);
540 __cpcmd("IPL", NULL, 0, NULL);
541 else if (ipl_info.type == IPL_TYPE_CCW)
542 reipl_ccw_dev(&ipl_info.data.ccw.dev_id);
545 static void ipl_run(struct shutdown_trigger *trigger)
547 smp_call_ipl_cpu(__ipl_run, NULL);
550 static int __init ipl_init(void)
554 ipl_kset = kset_create_and_add("ipl", NULL, firmware_kobj);
559 switch (ipl_info.type) {
562 rc = sysfs_create_group(&ipl_kset->kobj,
563 &ipl_ccw_attr_group_vm);
565 rc = sysfs_create_group(&ipl_kset->kobj,
566 &ipl_ccw_attr_group_lpar);
569 case IPL_TYPE_FCP_DUMP:
570 rc = sysfs_create_group(&ipl_kset->kobj, &ipl_fcp_attr_group);
573 rc = sysfs_create_group(&ipl_kset->kobj, &ipl_nss_attr_group);
576 rc = sysfs_create_group(&ipl_kset->kobj,
577 &ipl_unknown_attr_group);
582 panic("ipl_init failed: rc = %i\n", rc);
587 static struct shutdown_action __refdata ipl_action = {
588 .name = SHUTDOWN_ACTION_IPL_STR,
594 * reipl shutdown action: Reboot Linux on shutdown.
597 /* VM IPL PARM attributes */
598 static ssize_t reipl_generic_vmparm_show(struct ipl_parameter_block *ipb,
601 char vmparm[DIAG308_VMPARM_SIZE + 1] = {};
603 reipl_get_ascii_vmparm(vmparm, sizeof(vmparm), ipb);
604 return sprintf(page, "%s\n", vmparm);
607 static ssize_t reipl_generic_vmparm_store(struct ipl_parameter_block *ipb,
609 const char *buf, size_t len)
613 /* ignore trailing newline */
615 if ((len > 0) && (buf[len - 1] == '\n'))
618 if (ip_len > vmparm_max)
621 /* parm is used to store kernel options, check for common chars */
622 for (i = 0; i < ip_len; i++)
623 if (!(isalnum(buf[i]) || isascii(buf[i]) || isprint(buf[i])))
626 memset(ipb->ipl_info.ccw.vm_parm, 0, DIAG308_VMPARM_SIZE);
627 ipb->ipl_info.ccw.vm_parm_len = ip_len;
629 ipb->ipl_info.ccw.vm_flags |= DIAG308_VM_FLAGS_VP_VALID;
630 memcpy(ipb->ipl_info.ccw.vm_parm, buf, ip_len);
631 ASCEBC(ipb->ipl_info.ccw.vm_parm, ip_len);
633 ipb->ipl_info.ccw.vm_flags &= ~DIAG308_VM_FLAGS_VP_VALID;
640 static ssize_t reipl_nss_vmparm_show(struct kobject *kobj,
641 struct kobj_attribute *attr, char *page)
643 return reipl_generic_vmparm_show(reipl_block_nss, page);
646 static ssize_t reipl_nss_vmparm_store(struct kobject *kobj,
647 struct kobj_attribute *attr,
648 const char *buf, size_t len)
650 return reipl_generic_vmparm_store(reipl_block_nss, 56, buf, len);
654 static ssize_t reipl_ccw_vmparm_show(struct kobject *kobj,
655 struct kobj_attribute *attr, char *page)
657 return reipl_generic_vmparm_show(reipl_block_ccw, page);
660 static ssize_t reipl_ccw_vmparm_store(struct kobject *kobj,
661 struct kobj_attribute *attr,
662 const char *buf, size_t len)
664 return reipl_generic_vmparm_store(reipl_block_ccw, 64, buf, len);
667 static struct kobj_attribute sys_reipl_nss_vmparm_attr =
668 __ATTR(parm, S_IRUGO | S_IWUSR, reipl_nss_vmparm_show,
669 reipl_nss_vmparm_store);
670 static struct kobj_attribute sys_reipl_ccw_vmparm_attr =
671 __ATTR(parm, S_IRUGO | S_IWUSR, reipl_ccw_vmparm_show,
672 reipl_ccw_vmparm_store);
674 /* FCP reipl device attributes */
676 static ssize_t reipl_fcp_scpdata_read(struct file *filp, struct kobject *kobj,
677 struct bin_attribute *attr,
678 char *buf, loff_t off, size_t count)
680 size_t size = reipl_block_fcp->ipl_info.fcp.scp_data_len;
681 void *scp_data = reipl_block_fcp->ipl_info.fcp.scp_data;
683 return memory_read_from_buffer(buf, count, &off, scp_data, size);
686 static ssize_t reipl_fcp_scpdata_write(struct file *filp, struct kobject *kobj,
687 struct bin_attribute *attr,
688 char *buf, loff_t off, size_t count)
696 if (off >= DIAG308_SCPDATA_SIZE)
699 if (count > DIAG308_SCPDATA_SIZE - off)
700 count = DIAG308_SCPDATA_SIZE - off;
702 memcpy(reipl_block_fcp->ipl_info.fcp.scp_data, buf + off, count);
703 scpdata_len = off + count;
705 if (scpdata_len % 8) {
706 padding = 8 - (scpdata_len % 8);
707 memset(reipl_block_fcp->ipl_info.fcp.scp_data + scpdata_len,
709 scpdata_len += padding;
712 reipl_block_fcp->ipl_info.fcp.scp_data_len = scpdata_len;
713 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN + scpdata_len;
714 reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN + scpdata_len;
718 static struct bin_attribute sys_reipl_fcp_scp_data_attr =
719 __BIN_ATTR(scp_data, (S_IRUGO | S_IWUSR), reipl_fcp_scpdata_read,
720 reipl_fcp_scpdata_write, PAGE_SIZE);
722 static struct bin_attribute *reipl_fcp_bin_attrs[] = {
723 &sys_reipl_fcp_scp_data_attr,
727 DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%llx\n",
728 reipl_block_fcp->ipl_info.fcp.wwpn);
729 DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%llx\n",
730 reipl_block_fcp->ipl_info.fcp.lun);
731 DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
732 reipl_block_fcp->ipl_info.fcp.bootprog);
733 DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
734 reipl_block_fcp->ipl_info.fcp.br_lba);
735 DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
736 reipl_block_fcp->ipl_info.fcp.devno);
738 static void reipl_get_ascii_loadparm(char *loadparm,
739 struct ipl_parameter_block *ibp)
741 memcpy(loadparm, ibp->hdr.loadparm, LOADPARM_LEN);
742 EBCASC(loadparm, LOADPARM_LEN);
743 loadparm[LOADPARM_LEN] = 0;
747 static ssize_t reipl_generic_loadparm_show(struct ipl_parameter_block *ipb,
750 char buf[LOADPARM_LEN + 1];
752 reipl_get_ascii_loadparm(buf, ipb);
753 return sprintf(page, "%s\n", buf);
756 static ssize_t reipl_generic_loadparm_store(struct ipl_parameter_block *ipb,
757 const char *buf, size_t len)
761 /* ignore trailing newline */
763 if ((len > 0) && (buf[len - 1] == '\n'))
765 /* loadparm can have max 8 characters and must not start with a blank */
766 if ((lp_len > LOADPARM_LEN) || ((lp_len > 0) && (buf[0] == ' ')))
768 /* loadparm can only contain "a-z,A-Z,0-9,SP,." */
769 for (i = 0; i < lp_len; i++) {
770 if (isalpha(buf[i]) || isdigit(buf[i]) || (buf[i] == ' ') ||
775 /* initialize loadparm with blanks */
776 memset(ipb->hdr.loadparm, ' ', LOADPARM_LEN);
777 /* copy and convert to ebcdic */
778 memcpy(ipb->hdr.loadparm, buf, lp_len);
779 ASCEBC(ipb->hdr.loadparm, LOADPARM_LEN);
784 static ssize_t reipl_fcp_loadparm_show(struct kobject *kobj,
785 struct kobj_attribute *attr, char *page)
787 return reipl_generic_loadparm_show(reipl_block_fcp, page);
790 static ssize_t reipl_fcp_loadparm_store(struct kobject *kobj,
791 struct kobj_attribute *attr,
792 const char *buf, size_t len)
794 return reipl_generic_loadparm_store(reipl_block_fcp, buf, len);
797 static struct kobj_attribute sys_reipl_fcp_loadparm_attr =
798 __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_fcp_loadparm_show,
799 reipl_fcp_loadparm_store);
801 static struct attribute *reipl_fcp_attrs[] = {
802 &sys_reipl_fcp_device_attr.attr,
803 &sys_reipl_fcp_wwpn_attr.attr,
804 &sys_reipl_fcp_lun_attr.attr,
805 &sys_reipl_fcp_bootprog_attr.attr,
806 &sys_reipl_fcp_br_lba_attr.attr,
807 &sys_reipl_fcp_loadparm_attr.attr,
811 static struct attribute_group reipl_fcp_attr_group = {
812 .attrs = reipl_fcp_attrs,
813 .bin_attrs = reipl_fcp_bin_attrs,
816 /* CCW reipl device attributes */
818 DEFINE_IPL_ATTR_RW(reipl_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
819 reipl_block_ccw->ipl_info.ccw.devno);
822 static ssize_t reipl_nss_loadparm_show(struct kobject *kobj,
823 struct kobj_attribute *attr, char *page)
825 return reipl_generic_loadparm_show(reipl_block_nss, page);
828 static ssize_t reipl_nss_loadparm_store(struct kobject *kobj,
829 struct kobj_attribute *attr,
830 const char *buf, size_t len)
832 return reipl_generic_loadparm_store(reipl_block_nss, buf, len);
836 static ssize_t reipl_ccw_loadparm_show(struct kobject *kobj,
837 struct kobj_attribute *attr, char *page)
839 return reipl_generic_loadparm_show(reipl_block_ccw, page);
842 static ssize_t reipl_ccw_loadparm_store(struct kobject *kobj,
843 struct kobj_attribute *attr,
844 const char *buf, size_t len)
846 return reipl_generic_loadparm_store(reipl_block_ccw, buf, len);
849 static struct kobj_attribute sys_reipl_ccw_loadparm_attr =
850 __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_ccw_loadparm_show,
851 reipl_ccw_loadparm_store);
853 static struct attribute *reipl_ccw_attrs_vm[] = {
854 &sys_reipl_ccw_device_attr.attr,
855 &sys_reipl_ccw_loadparm_attr.attr,
856 &sys_reipl_ccw_vmparm_attr.attr,
860 static struct attribute *reipl_ccw_attrs_lpar[] = {
861 &sys_reipl_ccw_device_attr.attr,
862 &sys_reipl_ccw_loadparm_attr.attr,
866 static struct attribute_group reipl_ccw_attr_group_vm = {
868 .attrs = reipl_ccw_attrs_vm,
871 static struct attribute_group reipl_ccw_attr_group_lpar = {
873 .attrs = reipl_ccw_attrs_lpar,
877 /* NSS reipl device attributes */
878 static void reipl_get_ascii_nss_name(char *dst,
879 struct ipl_parameter_block *ipb)
881 memcpy(dst, ipb->ipl_info.ccw.nss_name, NSS_NAME_SIZE);
882 EBCASC(dst, NSS_NAME_SIZE);
883 dst[NSS_NAME_SIZE] = 0;
886 static ssize_t reipl_nss_name_show(struct kobject *kobj,
887 struct kobj_attribute *attr, char *page)
889 char nss_name[NSS_NAME_SIZE + 1] = {};
891 reipl_get_ascii_nss_name(nss_name, reipl_block_nss);
892 return sprintf(page, "%s\n", nss_name);
895 static ssize_t reipl_nss_name_store(struct kobject *kobj,
896 struct kobj_attribute *attr,
897 const char *buf, size_t len)
901 /* ignore trailing newline */
903 if ((len > 0) && (buf[len - 1] == '\n'))
906 if (nss_len > NSS_NAME_SIZE)
909 memset(reipl_block_nss->ipl_info.ccw.nss_name, 0x40, NSS_NAME_SIZE);
911 reipl_block_nss->ipl_info.ccw.vm_flags |=
912 DIAG308_VM_FLAGS_NSS_VALID;
913 memcpy(reipl_block_nss->ipl_info.ccw.nss_name, buf, nss_len);
914 ASCEBC(reipl_block_nss->ipl_info.ccw.nss_name, nss_len);
915 EBC_TOUPPER(reipl_block_nss->ipl_info.ccw.nss_name, nss_len);
917 reipl_block_nss->ipl_info.ccw.vm_flags &=
918 ~DIAG308_VM_FLAGS_NSS_VALID;
924 static struct kobj_attribute sys_reipl_nss_name_attr =
925 __ATTR(name, S_IRUGO | S_IWUSR, reipl_nss_name_show,
926 reipl_nss_name_store);
928 static struct kobj_attribute sys_reipl_nss_loadparm_attr =
929 __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_nss_loadparm_show,
930 reipl_nss_loadparm_store);
932 static struct attribute *reipl_nss_attrs[] = {
933 &sys_reipl_nss_name_attr.attr,
934 &sys_reipl_nss_loadparm_attr.attr,
935 &sys_reipl_nss_vmparm_attr.attr,
939 static struct attribute_group reipl_nss_attr_group = {
941 .attrs = reipl_nss_attrs,
944 static void set_reipl_block_actual(struct ipl_parameter_block *reipl_block)
946 reipl_block_actual = reipl_block;
947 os_info_entry_add(OS_INFO_REIPL_BLOCK, reipl_block_actual,
948 reipl_block->hdr.len);
953 static int reipl_set_type(enum ipl_type type)
955 if (!(reipl_capabilities & type))
960 if (diag308_set_works)
961 reipl_method = REIPL_METHOD_CCW_DIAG;
962 else if (MACHINE_IS_VM)
963 reipl_method = REIPL_METHOD_CCW_VM;
965 reipl_method = REIPL_METHOD_CCW_CIO;
966 set_reipl_block_actual(reipl_block_ccw);
969 if (diag308_set_works)
970 reipl_method = REIPL_METHOD_FCP_RW_DIAG;
971 else if (MACHINE_IS_VM)
972 reipl_method = REIPL_METHOD_FCP_RO_VM;
974 reipl_method = REIPL_METHOD_FCP_RO_DIAG;
975 set_reipl_block_actual(reipl_block_fcp);
977 case IPL_TYPE_FCP_DUMP:
978 reipl_method = REIPL_METHOD_FCP_DUMP;
981 if (diag308_set_works)
982 reipl_method = REIPL_METHOD_NSS_DIAG;
984 reipl_method = REIPL_METHOD_NSS;
985 set_reipl_block_actual(reipl_block_nss);
987 case IPL_TYPE_UNKNOWN:
988 reipl_method = REIPL_METHOD_DEFAULT;
997 static ssize_t reipl_type_show(struct kobject *kobj,
998 struct kobj_attribute *attr, char *page)
1000 return sprintf(page, "%s\n", ipl_type_str(reipl_type));
1003 static ssize_t reipl_type_store(struct kobject *kobj,
1004 struct kobj_attribute *attr,
1005 const char *buf, size_t len)
1009 if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
1010 rc = reipl_set_type(IPL_TYPE_CCW);
1011 else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
1012 rc = reipl_set_type(IPL_TYPE_FCP);
1013 else if (strncmp(buf, IPL_NSS_STR, strlen(IPL_NSS_STR)) == 0)
1014 rc = reipl_set_type(IPL_TYPE_NSS);
1015 return (rc != 0) ? rc : len;
1018 static struct kobj_attribute reipl_type_attr =
1019 __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
1021 static struct kset *reipl_kset;
1022 static struct kset *reipl_fcp_kset;
1024 static void get_ipl_string(char *dst, struct ipl_parameter_block *ipb,
1025 const enum ipl_method m)
1027 char loadparm[LOADPARM_LEN + 1] = {};
1028 char vmparm[DIAG308_VMPARM_SIZE + 1] = {};
1029 char nss_name[NSS_NAME_SIZE + 1] = {};
1032 reipl_get_ascii_loadparm(loadparm, ipb);
1033 reipl_get_ascii_nss_name(nss_name, ipb);
1034 reipl_get_ascii_vmparm(vmparm, sizeof(vmparm), ipb);
1037 case REIPL_METHOD_CCW_VM:
1038 pos = sprintf(dst, "IPL %X CLEAR", ipb->ipl_info.ccw.devno);
1040 case REIPL_METHOD_NSS:
1041 pos = sprintf(dst, "IPL %s", nss_name);
1046 if (strlen(loadparm) > 0)
1047 pos += sprintf(dst + pos, " LOADPARM '%s'", loadparm);
1048 if (strlen(vmparm) > 0)
1049 sprintf(dst + pos, " PARM %s", vmparm);
1052 static void __reipl_run(void *unused)
1054 struct ccw_dev_id devid;
1055 static char buf[128];
1057 switch (reipl_method) {
1058 case REIPL_METHOD_CCW_CIO:
1059 devid.devno = reipl_block_ccw->ipl_info.ccw.devno;
1061 reipl_ccw_dev(&devid);
1063 case REIPL_METHOD_CCW_VM:
1064 get_ipl_string(buf, reipl_block_ccw, REIPL_METHOD_CCW_VM);
1065 __cpcmd(buf, NULL, 0, NULL);
1067 case REIPL_METHOD_CCW_DIAG:
1068 diag308(DIAG308_SET, reipl_block_ccw);
1069 diag308(DIAG308_IPL, NULL);
1071 case REIPL_METHOD_FCP_RW_DIAG:
1072 diag308(DIAG308_SET, reipl_block_fcp);
1073 diag308(DIAG308_IPL, NULL);
1075 case REIPL_METHOD_FCP_RO_DIAG:
1076 diag308(DIAG308_IPL, NULL);
1078 case REIPL_METHOD_FCP_RO_VM:
1079 __cpcmd("IPL", NULL, 0, NULL);
1081 case REIPL_METHOD_NSS_DIAG:
1082 diag308(DIAG308_SET, reipl_block_nss);
1083 diag308(DIAG308_IPL, NULL);
1085 case REIPL_METHOD_NSS:
1086 get_ipl_string(buf, reipl_block_nss, REIPL_METHOD_NSS);
1087 __cpcmd(buf, NULL, 0, NULL);
1089 case REIPL_METHOD_DEFAULT:
1091 __cpcmd("IPL", NULL, 0, NULL);
1092 diag308(DIAG308_IPL, NULL);
1094 case REIPL_METHOD_FCP_DUMP:
1097 disabled_wait((unsigned long) __builtin_return_address(0));
1100 static void reipl_run(struct shutdown_trigger *trigger)
1102 smp_call_ipl_cpu(__reipl_run, NULL);
1105 static void reipl_block_ccw_init(struct ipl_parameter_block *ipb)
1107 ipb->hdr.len = IPL_PARM_BLK_CCW_LEN;
1108 ipb->hdr.version = IPL_PARM_BLOCK_VERSION;
1109 ipb->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
1110 ipb->hdr.pbt = DIAG308_IPL_TYPE_CCW;
1113 static void reipl_block_ccw_fill_parms(struct ipl_parameter_block *ipb)
1116 /* check if read scp info worked and set loadparm */
1117 if (sclp_ipl_info.is_valid)
1118 memcpy(ipb->hdr.loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN);
1120 /* read scp info failed: set empty loadparm (EBCDIC blanks) */
1121 memset(ipb->hdr.loadparm, 0x40, LOADPARM_LEN);
1122 ipb->hdr.flags = DIAG308_FLAGS_LP_VALID;
1125 if (MACHINE_IS_VM && diag308_set_works &&
1126 (ipl_block.ipl_info.ccw.vm_flags & DIAG308_VM_FLAGS_VP_VALID)) {
1128 ipb->ipl_info.ccw.vm_flags |= DIAG308_VM_FLAGS_VP_VALID;
1129 ipb->ipl_info.ccw.vm_parm_len =
1130 ipl_block.ipl_info.ccw.vm_parm_len;
1131 memcpy(ipb->ipl_info.ccw.vm_parm,
1132 ipl_block.ipl_info.ccw.vm_parm, DIAG308_VMPARM_SIZE);
1136 static int __init reipl_nss_init(void)
1143 reipl_block_nss = (void *) get_zeroed_page(GFP_KERNEL);
1144 if (!reipl_block_nss)
1147 if (!diag308_set_works)
1148 sys_reipl_nss_vmparm_attr.attr.mode = S_IRUGO;
1150 rc = sysfs_create_group(&reipl_kset->kobj, &reipl_nss_attr_group);
1154 reipl_block_ccw_init(reipl_block_nss);
1155 if (ipl_info.type == IPL_TYPE_NSS) {
1156 memset(reipl_block_nss->ipl_info.ccw.nss_name,
1157 ' ', NSS_NAME_SIZE);
1158 memcpy(reipl_block_nss->ipl_info.ccw.nss_name,
1159 kernel_nss_name, strlen(kernel_nss_name));
1160 ASCEBC(reipl_block_nss->ipl_info.ccw.nss_name, NSS_NAME_SIZE);
1161 reipl_block_nss->ipl_info.ccw.vm_flags |=
1162 DIAG308_VM_FLAGS_NSS_VALID;
1164 reipl_block_ccw_fill_parms(reipl_block_nss);
1167 reipl_capabilities |= IPL_TYPE_NSS;
1171 static int __init reipl_ccw_init(void)
1175 reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
1176 if (!reipl_block_ccw)
1179 if (MACHINE_IS_VM) {
1180 if (!diag308_set_works)
1181 sys_reipl_ccw_vmparm_attr.attr.mode = S_IRUGO;
1182 rc = sysfs_create_group(&reipl_kset->kobj,
1183 &reipl_ccw_attr_group_vm);
1185 if(!diag308_set_works)
1186 sys_reipl_ccw_loadparm_attr.attr.mode = S_IRUGO;
1187 rc = sysfs_create_group(&reipl_kset->kobj,
1188 &reipl_ccw_attr_group_lpar);
1193 reipl_block_ccw_init(reipl_block_ccw);
1194 if (ipl_info.type == IPL_TYPE_CCW) {
1195 reipl_block_ccw->ipl_info.ccw.devno = ipl_devno;
1196 reipl_block_ccw_fill_parms(reipl_block_ccw);
1199 reipl_capabilities |= IPL_TYPE_CCW;
1203 static int __init reipl_fcp_init(void)
1207 if (!diag308_set_works) {
1208 if (ipl_info.type == IPL_TYPE_FCP) {
1209 make_attrs_ro(reipl_fcp_attrs);
1210 sys_reipl_fcp_scp_data_attr.attr.mode = S_IRUGO;
1215 reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
1216 if (!reipl_block_fcp)
1219 /* sysfs: create fcp kset for mixing attr group and bin attrs */
1220 reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL,
1222 if (!reipl_fcp_kset) {
1223 free_page((unsigned long) reipl_block_fcp);
1227 rc = sysfs_create_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group);
1229 kset_unregister(reipl_fcp_kset);
1230 free_page((unsigned long) reipl_block_fcp);
1234 if (ipl_info.type == IPL_TYPE_FCP) {
1235 memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE);
1237 * Fix loadparm: There are systems where the (SCSI) LOADPARM
1238 * is invalid in the SCSI IPL parameter block, so take it
1239 * always from sclp_ipl_info.
1241 memcpy(reipl_block_fcp->hdr.loadparm, sclp_ipl_info.loadparm,
1244 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
1245 reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1246 reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
1247 reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
1248 reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL;
1250 reipl_capabilities |= IPL_TYPE_FCP;
1254 static int __init reipl_type_init(void)
1256 enum ipl_type reipl_type = ipl_info.type;
1257 struct ipl_parameter_block *reipl_block;
1260 reipl_block = os_info_old_entry(OS_INFO_REIPL_BLOCK, &size);
1264 * If we have an OS info reipl block, this will be used
1266 if (reipl_block->hdr.pbt == DIAG308_IPL_TYPE_FCP) {
1267 memcpy(reipl_block_fcp, reipl_block, size);
1268 reipl_type = IPL_TYPE_FCP;
1269 } else if (reipl_block->hdr.pbt == DIAG308_IPL_TYPE_CCW) {
1270 memcpy(reipl_block_ccw, reipl_block, size);
1271 reipl_type = IPL_TYPE_CCW;
1274 return reipl_set_type(reipl_type);
1277 static int __init reipl_init(void)
1281 reipl_kset = kset_create_and_add("reipl", NULL, firmware_kobj);
1284 rc = sysfs_create_file(&reipl_kset->kobj, &reipl_type_attr.attr);
1286 kset_unregister(reipl_kset);
1289 rc = reipl_ccw_init();
1292 rc = reipl_fcp_init();
1295 rc = reipl_nss_init();
1298 return reipl_type_init();
1301 static struct shutdown_action __refdata reipl_action = {
1302 .name = SHUTDOWN_ACTION_REIPL_STR,
1308 * dump shutdown action: Dump Linux on shutdown.
1311 /* FCP dump device attributes */
1313 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%llx\n",
1314 dump_block_fcp->ipl_info.fcp.wwpn);
1315 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%llx\n",
1316 dump_block_fcp->ipl_info.fcp.lun);
1317 DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
1318 dump_block_fcp->ipl_info.fcp.bootprog);
1319 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
1320 dump_block_fcp->ipl_info.fcp.br_lba);
1321 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
1322 dump_block_fcp->ipl_info.fcp.devno);
1324 static struct attribute *dump_fcp_attrs[] = {
1325 &sys_dump_fcp_device_attr.attr,
1326 &sys_dump_fcp_wwpn_attr.attr,
1327 &sys_dump_fcp_lun_attr.attr,
1328 &sys_dump_fcp_bootprog_attr.attr,
1329 &sys_dump_fcp_br_lba_attr.attr,
1333 static struct attribute_group dump_fcp_attr_group = {
1334 .name = IPL_FCP_STR,
1335 .attrs = dump_fcp_attrs,
1338 /* CCW dump device attributes */
1340 DEFINE_IPL_ATTR_RW(dump_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
1341 dump_block_ccw->ipl_info.ccw.devno);
1343 static struct attribute *dump_ccw_attrs[] = {
1344 &sys_dump_ccw_device_attr.attr,
1348 static struct attribute_group dump_ccw_attr_group = {
1349 .name = IPL_CCW_STR,
1350 .attrs = dump_ccw_attrs,
1355 static int dump_set_type(enum dump_type type)
1357 if (!(dump_capabilities & type))
1361 if (diag308_set_works)
1362 dump_method = DUMP_METHOD_CCW_DIAG;
1363 else if (MACHINE_IS_VM)
1364 dump_method = DUMP_METHOD_CCW_VM;
1366 dump_method = DUMP_METHOD_CCW_CIO;
1369 dump_method = DUMP_METHOD_FCP_DIAG;
1372 dump_method = DUMP_METHOD_NONE;
1378 static ssize_t dump_type_show(struct kobject *kobj,
1379 struct kobj_attribute *attr, char *page)
1381 return sprintf(page, "%s\n", dump_type_str(dump_type));
1384 static ssize_t dump_type_store(struct kobject *kobj,
1385 struct kobj_attribute *attr,
1386 const char *buf, size_t len)
1390 if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0)
1391 rc = dump_set_type(DUMP_TYPE_NONE);
1392 else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0)
1393 rc = dump_set_type(DUMP_TYPE_CCW);
1394 else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0)
1395 rc = dump_set_type(DUMP_TYPE_FCP);
1396 return (rc != 0) ? rc : len;
1399 static struct kobj_attribute dump_type_attr =
1400 __ATTR(dump_type, 0644, dump_type_show, dump_type_store);
1402 static struct kset *dump_kset;
1404 static void diag308_dump(void *dump_block)
1406 diag308(DIAG308_SET, dump_block);
1408 if (diag308(DIAG308_DUMP, NULL) != 0x302)
1410 udelay_simple(USEC_PER_SEC);
1414 static void __dump_run(void *unused)
1416 struct ccw_dev_id devid;
1417 static char buf[100];
1419 switch (dump_method) {
1420 case DUMP_METHOD_CCW_CIO:
1421 devid.devno = dump_block_ccw->ipl_info.ccw.devno;
1423 reipl_ccw_dev(&devid);
1425 case DUMP_METHOD_CCW_VM:
1426 sprintf(buf, "STORE STATUS");
1427 __cpcmd(buf, NULL, 0, NULL);
1428 sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno);
1429 __cpcmd(buf, NULL, 0, NULL);
1431 case DUMP_METHOD_CCW_DIAG:
1432 diag308_dump(dump_block_ccw);
1434 case DUMP_METHOD_FCP_DIAG:
1435 diag308_dump(dump_block_fcp);
1442 static void dump_run(struct shutdown_trigger *trigger)
1444 if (dump_method == DUMP_METHOD_NONE)
1447 smp_call_ipl_cpu(__dump_run, NULL);
1450 static int __init dump_ccw_init(void)
1454 dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
1455 if (!dump_block_ccw)
1457 rc = sysfs_create_group(&dump_kset->kobj, &dump_ccw_attr_group);
1459 free_page((unsigned long)dump_block_ccw);
1462 dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
1463 dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
1464 dump_block_ccw->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
1465 dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
1466 dump_capabilities |= DUMP_TYPE_CCW;
1470 static int __init dump_fcp_init(void)
1474 if (!sclp_ipl_info.has_dump)
1475 return 0; /* LDIPL DUMP is not installed */
1476 if (!diag308_set_works)
1478 dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
1479 if (!dump_block_fcp)
1481 rc = sysfs_create_group(&dump_kset->kobj, &dump_fcp_attr_group);
1483 free_page((unsigned long)dump_block_fcp);
1486 dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
1487 dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1488 dump_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
1489 dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
1490 dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
1491 dump_capabilities |= DUMP_TYPE_FCP;
1495 static int __init dump_init(void)
1499 dump_kset = kset_create_and_add("dump", NULL, firmware_kobj);
1502 rc = sysfs_create_file(&dump_kset->kobj, &dump_type_attr.attr);
1504 kset_unregister(dump_kset);
1507 rc = dump_ccw_init();
1510 rc = dump_fcp_init();
1513 dump_set_type(DUMP_TYPE_NONE);
1517 static struct shutdown_action __refdata dump_action = {
1518 .name = SHUTDOWN_ACTION_DUMP_STR,
1523 static void dump_reipl_run(struct shutdown_trigger *trigger)
1525 unsigned long ipib = (unsigned long) reipl_block_actual;
1528 csum = csum_partial(reipl_block_actual, reipl_block_actual->hdr.len, 0);
1529 mem_assign_absolute(S390_lowcore.ipib, ipib);
1530 mem_assign_absolute(S390_lowcore.ipib_checksum, csum);
1534 static int __init dump_reipl_init(void)
1536 if (!diag308_set_works)
1542 static struct shutdown_action __refdata dump_reipl_action = {
1543 .name = SHUTDOWN_ACTION_DUMP_REIPL_STR,
1544 .fn = dump_reipl_run,
1545 .init = dump_reipl_init,
1549 * vmcmd shutdown action: Trigger vm command on shutdown.
1552 static char vmcmd_on_reboot[128];
1553 static char vmcmd_on_panic[128];
1554 static char vmcmd_on_halt[128];
1555 static char vmcmd_on_poff[128];
1556 static char vmcmd_on_restart[128];
1558 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_reboot, "%s\n", "%s\n", vmcmd_on_reboot);
1559 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_panic, "%s\n", "%s\n", vmcmd_on_panic);
1560 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_halt, "%s\n", "%s\n", vmcmd_on_halt);
1561 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_poff, "%s\n", "%s\n", vmcmd_on_poff);
1562 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_restart, "%s\n", "%s\n", vmcmd_on_restart);
1564 static struct attribute *vmcmd_attrs[] = {
1565 &sys_vmcmd_on_reboot_attr.attr,
1566 &sys_vmcmd_on_panic_attr.attr,
1567 &sys_vmcmd_on_halt_attr.attr,
1568 &sys_vmcmd_on_poff_attr.attr,
1569 &sys_vmcmd_on_restart_attr.attr,
1573 static struct attribute_group vmcmd_attr_group = {
1574 .attrs = vmcmd_attrs,
1577 static struct kset *vmcmd_kset;
1579 static void vmcmd_run(struct shutdown_trigger *trigger)
1583 if (strcmp(trigger->name, ON_REIPL_STR) == 0)
1584 cmd = vmcmd_on_reboot;
1585 else if (strcmp(trigger->name, ON_PANIC_STR) == 0)
1586 cmd = vmcmd_on_panic;
1587 else if (strcmp(trigger->name, ON_HALT_STR) == 0)
1588 cmd = vmcmd_on_halt;
1589 else if (strcmp(trigger->name, ON_POFF_STR) == 0)
1590 cmd = vmcmd_on_poff;
1591 else if (strcmp(trigger->name, ON_RESTART_STR) == 0)
1592 cmd = vmcmd_on_restart;
1596 if (strlen(cmd) == 0)
1598 __cpcmd(cmd, NULL, 0, NULL);
1601 static int vmcmd_init(void)
1605 vmcmd_kset = kset_create_and_add("vmcmd", NULL, firmware_kobj);
1608 return sysfs_create_group(&vmcmd_kset->kobj, &vmcmd_attr_group);
1611 static struct shutdown_action vmcmd_action = {SHUTDOWN_ACTION_VMCMD_STR,
1612 vmcmd_run, vmcmd_init};
1615 * stop shutdown action: Stop Linux on shutdown.
1618 static void stop_run(struct shutdown_trigger *trigger)
1620 if (strcmp(trigger->name, ON_PANIC_STR) == 0 ||
1621 strcmp(trigger->name, ON_RESTART_STR) == 0)
1622 disabled_wait((unsigned long) __builtin_return_address(0));
1626 static struct shutdown_action stop_action = {SHUTDOWN_ACTION_STOP_STR,
1631 static struct shutdown_action *shutdown_actions_list[] = {
1632 &ipl_action, &reipl_action, &dump_reipl_action, &dump_action,
1633 &vmcmd_action, &stop_action};
1634 #define SHUTDOWN_ACTIONS_COUNT (sizeof(shutdown_actions_list) / sizeof(void *))
1640 static struct kset *shutdown_actions_kset;
1642 static int set_trigger(const char *buf, struct shutdown_trigger *trigger,
1647 for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) {
1648 if (sysfs_streq(buf, shutdown_actions_list[i]->name)) {
1649 if (shutdown_actions_list[i]->init_rc) {
1650 return shutdown_actions_list[i]->init_rc;
1652 trigger->action = shutdown_actions_list[i];
1662 static struct shutdown_trigger on_reboot_trigger = {ON_REIPL_STR,
1665 static ssize_t on_reboot_show(struct kobject *kobj,
1666 struct kobj_attribute *attr, char *page)
1668 return sprintf(page, "%s\n", on_reboot_trigger.action->name);
1671 static ssize_t on_reboot_store(struct kobject *kobj,
1672 struct kobj_attribute *attr,
1673 const char *buf, size_t len)
1675 return set_trigger(buf, &on_reboot_trigger, len);
1677 static struct kobj_attribute on_reboot_attr = __ATTR_RW(on_reboot);
1679 static void do_machine_restart(char *__unused)
1682 on_reboot_trigger.action->fn(&on_reboot_trigger);
1685 void (*_machine_restart)(char *command) = do_machine_restart;
1689 static struct shutdown_trigger on_panic_trigger = {ON_PANIC_STR, &stop_action};
1691 static ssize_t on_panic_show(struct kobject *kobj,
1692 struct kobj_attribute *attr, char *page)
1694 return sprintf(page, "%s\n", on_panic_trigger.action->name);
1697 static ssize_t on_panic_store(struct kobject *kobj,
1698 struct kobj_attribute *attr,
1699 const char *buf, size_t len)
1701 return set_trigger(buf, &on_panic_trigger, len);
1703 static struct kobj_attribute on_panic_attr = __ATTR_RW(on_panic);
1705 static void do_panic(void)
1708 on_panic_trigger.action->fn(&on_panic_trigger);
1709 stop_run(&on_panic_trigger);
1714 static struct shutdown_trigger on_restart_trigger = {ON_RESTART_STR,
1717 static ssize_t on_restart_show(struct kobject *kobj,
1718 struct kobj_attribute *attr, char *page)
1720 return sprintf(page, "%s\n", on_restart_trigger.action->name);
1723 static ssize_t on_restart_store(struct kobject *kobj,
1724 struct kobj_attribute *attr,
1725 const char *buf, size_t len)
1727 return set_trigger(buf, &on_restart_trigger, len);
1729 static struct kobj_attribute on_restart_attr = __ATTR_RW(on_restart);
1731 static void __do_restart(void *ignore)
1733 __arch_local_irq_stosm(0x04); /* enable DAT */
1735 #ifdef CONFIG_CRASH_DUMP
1738 on_restart_trigger.action->fn(&on_restart_trigger);
1739 stop_run(&on_restart_trigger);
1742 void do_restart(void)
1747 smp_call_online_cpu(__do_restart, NULL);
1752 static struct shutdown_trigger on_halt_trigger = {ON_HALT_STR, &stop_action};
1754 static ssize_t on_halt_show(struct kobject *kobj,
1755 struct kobj_attribute *attr, char *page)
1757 return sprintf(page, "%s\n", on_halt_trigger.action->name);
1760 static ssize_t on_halt_store(struct kobject *kobj,
1761 struct kobj_attribute *attr,
1762 const char *buf, size_t len)
1764 return set_trigger(buf, &on_halt_trigger, len);
1766 static struct kobj_attribute on_halt_attr = __ATTR_RW(on_halt);
1768 static void do_machine_halt(void)
1771 on_halt_trigger.action->fn(&on_halt_trigger);
1772 stop_run(&on_halt_trigger);
1774 void (*_machine_halt)(void) = do_machine_halt;
1778 static struct shutdown_trigger on_poff_trigger = {ON_POFF_STR, &stop_action};
1780 static ssize_t on_poff_show(struct kobject *kobj,
1781 struct kobj_attribute *attr, char *page)
1783 return sprintf(page, "%s\n", on_poff_trigger.action->name);
1786 static ssize_t on_poff_store(struct kobject *kobj,
1787 struct kobj_attribute *attr,
1788 const char *buf, size_t len)
1790 return set_trigger(buf, &on_poff_trigger, len);
1792 static struct kobj_attribute on_poff_attr = __ATTR_RW(on_poff);
1794 static void do_machine_power_off(void)
1797 on_poff_trigger.action->fn(&on_poff_trigger);
1798 stop_run(&on_poff_trigger);
1800 void (*_machine_power_off)(void) = do_machine_power_off;
1802 static struct attribute *shutdown_action_attrs[] = {
1803 &on_restart_attr.attr,
1804 &on_reboot_attr.attr,
1805 &on_panic_attr.attr,
1811 static struct attribute_group shutdown_action_attr_group = {
1812 .attrs = shutdown_action_attrs,
1815 static void __init shutdown_triggers_init(void)
1817 shutdown_actions_kset = kset_create_and_add("shutdown_actions", NULL,
1819 if (!shutdown_actions_kset)
1821 if (sysfs_create_group(&shutdown_actions_kset->kobj,
1822 &shutdown_action_attr_group))
1826 panic("shutdown_triggers_init failed\n");
1829 static void __init shutdown_actions_init(void)
1833 for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) {
1834 if (!shutdown_actions_list[i]->init)
1836 shutdown_actions_list[i]->init_rc =
1837 shutdown_actions_list[i]->init();
1841 static int __init s390_ipl_init(void)
1843 char str[8] = {0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40};
1845 sclp_get_ipl_info(&sclp_ipl_info);
1847 * Fix loadparm: There are systems where the (SCSI) LOADPARM
1848 * returned by read SCP info is invalid (contains EBCDIC blanks)
1849 * when the system has been booted via diag308. In that case we use
1850 * the value from diag308, if available.
1852 * There are also systems where diag308 store does not work in
1853 * case the system is booted from HMC. Fortunately in this case
1854 * READ SCP info provides the correct value.
1856 if (memcmp(sclp_ipl_info.loadparm, str, sizeof(str)) == 0 &&
1858 memcpy(sclp_ipl_info.loadparm, ipl_block.hdr.loadparm,
1860 shutdown_actions_init();
1861 shutdown_triggers_init();
1865 __initcall(s390_ipl_init);
1867 static void __init strncpy_skip_quote(char *dst, char *src, int n)
1872 for (sx = 0; src[sx] != 0; sx++) {
1875 dst[dx++] = src[sx];
1881 static int __init vmcmd_on_reboot_setup(char *str)
1885 strncpy_skip_quote(vmcmd_on_reboot, str, 127);
1886 vmcmd_on_reboot[127] = 0;
1887 on_reboot_trigger.action = &vmcmd_action;
1890 __setup("vmreboot=", vmcmd_on_reboot_setup);
1892 static int __init vmcmd_on_panic_setup(char *str)
1896 strncpy_skip_quote(vmcmd_on_panic, str, 127);
1897 vmcmd_on_panic[127] = 0;
1898 on_panic_trigger.action = &vmcmd_action;
1901 __setup("vmpanic=", vmcmd_on_panic_setup);
1903 static int __init vmcmd_on_halt_setup(char *str)
1907 strncpy_skip_quote(vmcmd_on_halt, str, 127);
1908 vmcmd_on_halt[127] = 0;
1909 on_halt_trigger.action = &vmcmd_action;
1912 __setup("vmhalt=", vmcmd_on_halt_setup);
1914 static int __init vmcmd_on_poff_setup(char *str)
1918 strncpy_skip_quote(vmcmd_on_poff, str, 127);
1919 vmcmd_on_poff[127] = 0;
1920 on_poff_trigger.action = &vmcmd_action;
1923 __setup("vmpoff=", vmcmd_on_poff_setup);
1925 static int on_panic_notify(struct notifier_block *self,
1926 unsigned long event, void *data)
1932 static struct notifier_block on_panic_nb = {
1933 .notifier_call = on_panic_notify,
1934 .priority = INT_MIN,
1937 void __init setup_ipl(void)
1939 ipl_info.type = get_ipl_type();
1940 switch (ipl_info.type) {
1942 ipl_info.data.ccw.dev_id.devno = ipl_devno;
1943 ipl_info.data.ccw.dev_id.ssid = 0;
1946 case IPL_TYPE_FCP_DUMP:
1947 ipl_info.data.fcp.dev_id.devno =
1948 IPL_PARMBLOCK_START->ipl_info.fcp.devno;
1949 ipl_info.data.fcp.dev_id.ssid = 0;
1950 ipl_info.data.fcp.wwpn = IPL_PARMBLOCK_START->ipl_info.fcp.wwpn;
1951 ipl_info.data.fcp.lun = IPL_PARMBLOCK_START->ipl_info.fcp.lun;
1954 strncpy(ipl_info.data.nss.name, kernel_nss_name,
1955 sizeof(ipl_info.data.nss.name));
1957 case IPL_TYPE_UNKNOWN:
1958 /* We have no info to copy */
1961 atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
1964 void __init ipl_update_parameters(void)
1968 rc = diag308(DIAG308_STORE, &ipl_block);
1969 if ((rc == DIAG308_RC_OK) || (rc == DIAG308_RC_NOCONFIG))
1970 diag308_set_works = 1;
1973 void __init ipl_save_parameters(void)
1975 struct cio_iplinfo iplinfo;
1978 if (cio_get_iplinfo(&iplinfo))
1981 ipl_devno = iplinfo.devno;
1982 ipl_flags |= IPL_DEVNO_VALID;
1983 if (!iplinfo.is_qdio)
1985 ipl_flags |= IPL_PARMBLOCK_VALID;
1986 src = (void *)(unsigned long)S390_lowcore.ipl_parmblock_ptr;
1987 dst = (void *)IPL_PARMBLOCK_ORIGIN;
1988 memmove(dst, src, PAGE_SIZE);
1989 S390_lowcore.ipl_parmblock_ptr = IPL_PARMBLOCK_ORIGIN;
1992 static LIST_HEAD(rcall);
1993 static DEFINE_MUTEX(rcall_mutex);
1995 void register_reset_call(struct reset_call *reset)
1997 mutex_lock(&rcall_mutex);
1998 list_add(&reset->list, &rcall);
1999 mutex_unlock(&rcall_mutex);
2001 EXPORT_SYMBOL_GPL(register_reset_call);
2003 void unregister_reset_call(struct reset_call *reset)
2005 mutex_lock(&rcall_mutex);
2006 list_del(&reset->list);
2007 mutex_unlock(&rcall_mutex);
2009 EXPORT_SYMBOL_GPL(unregister_reset_call);
2011 static void do_reset_calls(void)
2013 struct reset_call *reset;
2015 if (diag308_set_works) {
2019 list_for_each_entry(reset, &rcall, list)
2023 u32 dump_prefix_page;
2025 void s390_reset_system(void (*fn_pre)(void),
2026 void (*fn_post)(void *), void *data)
2028 struct _lowcore *lc;
2030 lc = (struct _lowcore *)(unsigned long) store_prefix();
2032 /* Stack for interrupt/machine check handler */
2033 lc->panic_stack = S390_lowcore.panic_stack;
2035 /* Save prefix page address for dump case */
2036 dump_prefix_page = (u32)(unsigned long) lc;
2038 /* Disable prefixing */
2041 /* Disable lowcore protection */
2042 __ctl_clear_bit(0,28);
2044 /* Set new machine check handler */
2045 S390_lowcore.mcck_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT;
2046 S390_lowcore.mcck_new_psw.addr =
2047 PSW_ADDR_AMODE | (unsigned long) s390_base_mcck_handler;
2049 /* Set new program check handler */
2050 S390_lowcore.program_new_psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT;
2051 S390_lowcore.program_new_psw.addr =
2052 PSW_ADDR_AMODE | (unsigned long) s390_base_pgm_handler;
2055 * Clear subchannel ID and number to signal new kernel that no CCW or
2056 * SCSI IPL has been done (for kexec and kdump)
2058 S390_lowcore.subchannel_id = 0;
2059 S390_lowcore.subchannel_nr = 0;
2061 /* Store status at absolute zero */
2064 /* Call function before reset */
2068 /* Call function after reset */