arch/s390/kernel/ipl.c

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