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/ebcdic.h>
  28 #include <asm/sclp.h>
  29 #include <asm/checksum.h>
  30 #include <asm/debug.h>
  31 #include <asm/os_info.h>
  32 #include <asm/sections.h>
  33 #include <asm/boot_data.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 struct ipl_parameter_block __bootdata(early_ipl_block);
 123 int __bootdata(early_ipl_block_valid);
 124
 125 static int ipl_block_valid;
 126 static struct ipl_parameter_block ipl_block;
 127
 128 static int reipl_capabilities = IPL_TYPE_UNKNOWN;
 129
 130 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
 131 static struct ipl_parameter_block *reipl_block_fcp;
 132 static struct ipl_parameter_block *reipl_block_ccw;
 133 static struct ipl_parameter_block *reipl_block_nss;
 134 static struct ipl_parameter_block *reipl_block_actual;
 135
 136 static int dump_capabilities = DUMP_TYPE_NONE;
 137 static enum dump_type dump_type = DUMP_TYPE_NONE;
 138 static struct ipl_parameter_block *dump_block_fcp;
 139 static struct ipl_parameter_block *dump_block_ccw;
 140
 141 static struct sclp_ipl_info sclp_ipl_info;
 142
 143 static inline int __diag308(unsigned long subcode, void *addr)
 144 {
 145         register unsigned long _addr asm("0") = (unsigned long) addr;
 146         register unsigned long _rc asm("1") = 0;
 147
 148         asm volatile(
 149                 "       diag    %0,%2,0x308\n"
 150                 "0:     nopr    %%r7\n"
 151                 EX_TABLE(0b,0b)
 152                 : "+d" (_addr), "+d" (_rc)
 153                 : "d" (subcode) : "cc", "memory");
 154         return _rc;
 155 }
 156
 157 int diag308(unsigned long subcode, void *addr)
 158 {
 159         if (IS_ENABLED(CONFIG_KASAN))
 160                 __arch_local_irq_stosm(0x04); /* enable DAT */
 161         diag_stat_inc(DIAG_STAT_X308);
 162         return __diag308(subcode, addr);
 163 }
 164 EXPORT_SYMBOL_GPL(diag308);
 165
 166 /* SYSFS */
 167
 168 #define IPL_ATTR_SHOW_FN(_prefix, _name, _format, args...)              \
 169 static ssize_t sys_##_prefix##_##_name##_show(struct kobject *kobj,     \
 170                 struct kobj_attribute *attr,                            \
 171                 char *page)                                             \
 172 {                                                                       \
 173         return snprintf(page, PAGE_SIZE, _format, ##args);              \
 174 }
 175
 176 #define IPL_ATTR_CCW_STORE_FN(_prefix, _name, _ipl_blk)                 \
 177 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj,    \
 178                 struct kobj_attribute *attr,                            \
 179                 const char *buf, size_t len)                            \
 180 {                                                                       \
 181         unsigned long long ssid, devno;                                 \
 182                                                                         \
 183         if (sscanf(buf, "0.%llx.%llx\n", &ssid, &devno) != 2)           \
 184                 return -EINVAL;                                         \
 185                                                                         \
 186         if (ssid > __MAX_SSID || devno > __MAX_SUBCHANNEL)              \
 187                 return -EINVAL;                                         \
 188                                                                         \
 189         _ipl_blk.ssid = ssid;                                           \
 190         _ipl_blk.devno = devno;                                         \
 191         return len;                                                     \
 192 }
 193
 194 #define DEFINE_IPL_CCW_ATTR_RW(_prefix, _name, _ipl_blk)                \
 195 IPL_ATTR_SHOW_FN(_prefix, _name, "0.%x.%04x\n",                         \
 196                  _ipl_blk.ssid, _ipl_blk.devno);                        \
 197 IPL_ATTR_CCW_STORE_FN(_prefix, _name, _ipl_blk);                        \
 198 static struct kobj_attribute sys_##_prefix##_##_name##_attr =           \
 199         __ATTR(_name, (S_IRUGO | S_IWUSR),                              \
 200                sys_##_prefix##_##_name##_show,                          \
 201                sys_##_prefix##_##_name##_store)                         \
 202
 203 #define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value)             \
 204 IPL_ATTR_SHOW_FN(_prefix, _name, _format, _value)                       \
 205 static struct kobj_attribute sys_##_prefix##_##_name##_attr =           \
 206         __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL)
 207
 208 #define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)   \
 209 IPL_ATTR_SHOW_FN(_prefix, _name, _fmt_out, (unsigned long long) _value) \
 210 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj,    \
 211                 struct kobj_attribute *attr,                            \
 212                 const char *buf, size_t len)                            \
 213 {                                                                       \
 214         unsigned long long value;                                       \
 215         if (sscanf(buf, _fmt_in, &value) != 1)                          \
 216                 return -EINVAL;                                         \
 217         _value = value;                                                 \
 218         return len;                                                     \
 219 }                                                                       \
 220 static struct kobj_attribute sys_##_prefix##_##_name##_attr =           \
 221         __ATTR(_name,(S_IRUGO | S_IWUSR),                               \
 222                         sys_##_prefix##_##_name##_show,                 \
 223                         sys_##_prefix##_##_name##_store)
 224
 225 #define DEFINE_IPL_ATTR_STR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)\
 226 IPL_ATTR_SHOW_FN(_prefix, _name, _fmt_out, _value)                      \
 227 static ssize_t sys_##_prefix##_##_name##_store(struct kobject *kobj,    \
 228                 struct kobj_attribute *attr,                            \
 229                 const char *buf, size_t len)                            \
 230 {                                                                       \
 231         strncpy(_value, buf, sizeof(_value) - 1);                       \
 232         strim(_value);                                                  \
 233         return len;                                                     \
 234 }                                                                       \
 235 static struct kobj_attribute sys_##_prefix##_##_name##_attr =           \
 236         __ATTR(_name,(S_IRUGO | S_IWUSR),                               \
 237                         sys_##_prefix##_##_name##_show,                 \
 238                         sys_##_prefix##_##_name##_store)
 239
 240 /*
 241  * ipl section
 242  */
 243
 244 static __init enum ipl_type get_ipl_type(void)
 245 {
 246         if (!ipl_block_valid)
 247                 return IPL_TYPE_UNKNOWN;
 248
 249         switch (ipl_block.hdr.pbt) {
 250         case DIAG308_IPL_TYPE_CCW:
 251                 return IPL_TYPE_CCW;
 252         case DIAG308_IPL_TYPE_FCP:
 253                 if (ipl_block.ipl_info.fcp.opt == DIAG308_IPL_OPT_DUMP)
 254                         return IPL_TYPE_FCP_DUMP;
 255                 else
 256                         return IPL_TYPE_FCP;
 257         }
 258         return IPL_TYPE_UNKNOWN;
 259 }
 260
 261 struct ipl_info ipl_info;
 262 EXPORT_SYMBOL_GPL(ipl_info);
 263
 264 static ssize_t ipl_type_show(struct kobject *kobj, struct kobj_attribute *attr,
 265                              char *page)
 266 {
 267         return sprintf(page, "%s\n", ipl_type_str(ipl_info.type));
 268 }
 269
 270 static struct kobj_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
 271
 272 static ssize_t ipl_vm_parm_show(struct kobject *kobj,
 273                                 struct kobj_attribute *attr, char *page)
 274 {
 275         char parm[DIAG308_VMPARM_SIZE + 1] = {};
 276
 277         if (ipl_block_valid && (ipl_block.hdr.pbt == DIAG308_IPL_TYPE_CCW))
 278                 ipl_block_get_ascii_vmparm(parm, sizeof(parm), &ipl_block);
 279         return sprintf(page, "%s\n", parm);
 280 }
 281
 282 static struct kobj_attribute sys_ipl_vm_parm_attr =
 283         __ATTR(parm, S_IRUGO, ipl_vm_parm_show, NULL);
 284
 285 static ssize_t sys_ipl_device_show(struct kobject *kobj,
 286                                    struct kobj_attribute *attr, char *page)
 287 {
 288         switch (ipl_info.type) {
 289         case IPL_TYPE_CCW:
 290                 return sprintf(page, "0.%x.%04x\n", ipl_block.ipl_info.ccw.ssid,
 291                                ipl_block.ipl_info.ccw.devno);
 292         case IPL_TYPE_FCP:
 293         case IPL_TYPE_FCP_DUMP:
 294                 return sprintf(page, "0.0.%04x\n",
 295                                ipl_block.ipl_info.fcp.devno);
 296         default:
 297                 return 0;
 298         }
 299 }
 300
 301 static struct kobj_attribute sys_ipl_device_attr =
 302         __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
 303
 304 static ssize_t ipl_parameter_read(struct file *filp, struct kobject *kobj,
 305                                   struct bin_attribute *attr, char *buf,
 306                                   loff_t off, size_t count)
 307 {
 308         return memory_read_from_buffer(buf, count, &off, &ipl_block,
 309                                        ipl_block.hdr.len);
 310 }
 311 static struct bin_attribute ipl_parameter_attr =
 312         __BIN_ATTR(binary_parameter, S_IRUGO, ipl_parameter_read, NULL,
 313                    PAGE_SIZE);
 314
 315 static ssize_t ipl_scp_data_read(struct file *filp, struct kobject *kobj,
 316                                  struct bin_attribute *attr, char *buf,
 317                                  loff_t off, size_t count)
 318 {
 319         unsigned int size = ipl_block.ipl_info.fcp.scp_data_len;
 320         void *scp_data = &ipl_block.ipl_info.fcp.scp_data;
 321
 322         return memory_read_from_buffer(buf, count, &off, scp_data, size);
 323 }
 324 static struct bin_attribute ipl_scp_data_attr =
 325         __BIN_ATTR(scp_data, S_IRUGO, ipl_scp_data_read, NULL, PAGE_SIZE);
 326
 327 static struct bin_attribute *ipl_fcp_bin_attrs[] = {
 328         &ipl_parameter_attr,
 329         &ipl_scp_data_attr,
 330         NULL,
 331 };
 332
 333 /* FCP ipl device attributes */
 334
 335 DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n",
 336                    (unsigned long long)ipl_block.ipl_info.fcp.wwpn);
 337 DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n",
 338                    (unsigned long long)ipl_block.ipl_info.fcp.lun);
 339 DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n",
 340                    (unsigned long long)ipl_block.ipl_info.fcp.bootprog);
 341 DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n",
 342                    (unsigned long long)ipl_block.ipl_info.fcp.br_lba);
 343
 344 static ssize_t ipl_ccw_loadparm_show(struct kobject *kobj,
 345                                      struct kobj_attribute *attr, char *page)
 346 {
 347         char loadparm[LOADPARM_LEN + 1] = {};
 348
 349         if (!sclp_ipl_info.is_valid)
 350                 return sprintf(page, "#unknown#\n");
 351         memcpy(loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN);
 352         EBCASC(loadparm, LOADPARM_LEN);
 353         strim(loadparm);
 354         return sprintf(page, "%s\n", loadparm);
 355 }
 356
 357 static struct kobj_attribute sys_ipl_ccw_loadparm_attr =
 358         __ATTR(loadparm, 0444, ipl_ccw_loadparm_show, NULL);
 359
 360 static struct attribute *ipl_fcp_attrs[] = {
 361         &sys_ipl_type_attr.attr,
 362         &sys_ipl_device_attr.attr,
 363         &sys_ipl_fcp_wwpn_attr.attr,
 364         &sys_ipl_fcp_lun_attr.attr,
 365         &sys_ipl_fcp_bootprog_attr.attr,
 366         &sys_ipl_fcp_br_lba_attr.attr,
 367         &sys_ipl_ccw_loadparm_attr.attr,
 368         NULL,
 369 };
 370
 371 static struct attribute_group ipl_fcp_attr_group = {
 372         .attrs = ipl_fcp_attrs,
 373         .bin_attrs = ipl_fcp_bin_attrs,
 374 };
 375
 376 /* CCW ipl device attributes */
 377
 378 static struct attribute *ipl_ccw_attrs_vm[] = {
 379         &sys_ipl_type_attr.attr,
 380         &sys_ipl_device_attr.attr,
 381         &sys_ipl_ccw_loadparm_attr.attr,
 382         &sys_ipl_vm_parm_attr.attr,
 383         NULL,
 384 };
 385
 386 static struct attribute *ipl_ccw_attrs_lpar[] = {
 387         &sys_ipl_type_attr.attr,
 388         &sys_ipl_device_attr.attr,
 389         &sys_ipl_ccw_loadparm_attr.attr,
 390         NULL,
 391 };
 392
 393 static struct attribute_group ipl_ccw_attr_group_vm = {
 394         .attrs = ipl_ccw_attrs_vm,
 395 };
 396
 397 static struct attribute_group ipl_ccw_attr_group_lpar = {
 398         .attrs = ipl_ccw_attrs_lpar
 399 };
 400
 401 /* UNKNOWN ipl device attributes */
 402
 403 static struct attribute *ipl_unknown_attrs[] = {
 404         &sys_ipl_type_attr.attr,
 405         NULL,
 406 };
 407
 408 static struct attribute_group ipl_unknown_attr_group = {
 409         .attrs = ipl_unknown_attrs,
 410 };
 411
 412 static struct kset *ipl_kset;
 413
 414 static void __ipl_run(void *unused)
 415 {
 416         __bpon();
 417         diag308(DIAG308_LOAD_CLEAR, NULL);
 418 }
 419
 420 static void ipl_run(struct shutdown_trigger *trigger)
 421 {
 422         smp_call_ipl_cpu(__ipl_run, NULL);
 423 }
 424
 425 static int __init ipl_init(void)
 426 {
 427         int rc;
 428
 429         ipl_kset = kset_create_and_add("ipl", NULL, firmware_kobj);
 430         if (!ipl_kset) {
 431                 rc = -ENOMEM;
 432                 goto out;
 433         }
 434         switch (ipl_info.type) {
 435         case IPL_TYPE_CCW:
 436                 if (MACHINE_IS_VM)
 437                         rc = sysfs_create_group(&ipl_kset->kobj,
 438                                                 &ipl_ccw_attr_group_vm);
 439                 else
 440                         rc = sysfs_create_group(&ipl_kset->kobj,
 441                                                 &ipl_ccw_attr_group_lpar);
 442                 break;
 443         case IPL_TYPE_FCP:
 444         case IPL_TYPE_FCP_DUMP:
 445                 rc = sysfs_create_group(&ipl_kset->kobj, &ipl_fcp_attr_group);
 446                 break;
 447         default:
 448                 rc = sysfs_create_group(&ipl_kset->kobj,
 449                                         &ipl_unknown_attr_group);
 450                 break;
 451         }
 452 out:
 453         if (rc)
 454                 panic("ipl_init failed: rc = %i\n", rc);
 455
 456         return 0;
 457 }
 458
 459 static struct shutdown_action __refdata ipl_action = {
 460         .name   = SHUTDOWN_ACTION_IPL_STR,
 461         .fn     = ipl_run,
 462         .init   = ipl_init,
 463 };
 464
 465 /*
 466  * reipl shutdown action: Reboot Linux on shutdown.
 467  */
 468
 469 /* VM IPL PARM attributes */
 470 static ssize_t reipl_generic_vmparm_show(struct ipl_parameter_block *ipb,
 471                                           char *page)
 472 {
 473         char vmparm[DIAG308_VMPARM_SIZE + 1] = {};
 474
 475         ipl_block_get_ascii_vmparm(vmparm, sizeof(vmparm), ipb);
 476         return sprintf(page, "%s\n", vmparm);
 477 }
 478
 479 static ssize_t reipl_generic_vmparm_store(struct ipl_parameter_block *ipb,
 480                                           size_t vmparm_max,
 481                                           const char *buf, size_t len)
 482 {
 483         int i, ip_len;
 484
 485         /* ignore trailing newline */
 486         ip_len = len;
 487         if ((len > 0) && (buf[len - 1] == '\n'))
 488                 ip_len--;
 489
 490         if (ip_len > vmparm_max)
 491                 return -EINVAL;
 492
 493         /* parm is used to store kernel options, check for common chars */
 494         for (i = 0; i < ip_len; i++)
 495                 if (!(isalnum(buf[i]) || isascii(buf[i]) || isprint(buf[i])))
 496                         return -EINVAL;
 497
 498         memset(ipb->ipl_info.ccw.vm_parm, 0, DIAG308_VMPARM_SIZE);
 499         ipb->ipl_info.ccw.vm_parm_len = ip_len;
 500         if (ip_len > 0) {
 501                 ipb->ipl_info.ccw.vm_flags |= DIAG308_VM_FLAGS_VP_VALID;
 502                 memcpy(ipb->ipl_info.ccw.vm_parm, buf, ip_len);
 503                 ASCEBC(ipb->ipl_info.ccw.vm_parm, ip_len);
 504         } else {
 505                 ipb->ipl_info.ccw.vm_flags &= ~DIAG308_VM_FLAGS_VP_VALID;
 506         }
 507
 508         return len;
 509 }
 510
 511 /* NSS wrapper */
 512 static ssize_t reipl_nss_vmparm_show(struct kobject *kobj,
 513                                      struct kobj_attribute *attr, char *page)
 514 {
 515         return reipl_generic_vmparm_show(reipl_block_nss, page);
 516 }
 517
 518 static ssize_t reipl_nss_vmparm_store(struct kobject *kobj,
 519                                       struct kobj_attribute *attr,
 520                                       const char *buf, size_t len)
 521 {
 522         return reipl_generic_vmparm_store(reipl_block_nss, 56, buf, len);
 523 }
 524
 525 /* CCW wrapper */
 526 static ssize_t reipl_ccw_vmparm_show(struct kobject *kobj,
 527                                      struct kobj_attribute *attr, char *page)
 528 {
 529         return reipl_generic_vmparm_show(reipl_block_ccw, page);
 530 }
 531
 532 static ssize_t reipl_ccw_vmparm_store(struct kobject *kobj,
 533                                       struct kobj_attribute *attr,
 534                                       const char *buf, size_t len)
 535 {
 536         return reipl_generic_vmparm_store(reipl_block_ccw, 64, buf, len);
 537 }
 538
 539 static struct kobj_attribute sys_reipl_nss_vmparm_attr =
 540         __ATTR(parm, S_IRUGO | S_IWUSR, reipl_nss_vmparm_show,
 541                                         reipl_nss_vmparm_store);
 542 static struct kobj_attribute sys_reipl_ccw_vmparm_attr =
 543         __ATTR(parm, S_IRUGO | S_IWUSR, reipl_ccw_vmparm_show,
 544                                         reipl_ccw_vmparm_store);
 545
 546 /* FCP reipl device attributes */
 547
 548 static ssize_t reipl_fcp_scpdata_read(struct file *filp, struct kobject *kobj,
 549                                       struct bin_attribute *attr,
 550                                       char *buf, loff_t off, size_t count)
 551 {
 552         size_t size = reipl_block_fcp->ipl_info.fcp.scp_data_len;
 553         void *scp_data = reipl_block_fcp->ipl_info.fcp.scp_data;
 554
 555         return memory_read_from_buffer(buf, count, &off, scp_data, size);
 556 }
 557
 558 static ssize_t reipl_fcp_scpdata_write(struct file *filp, struct kobject *kobj,
 559                                        struct bin_attribute *attr,
 560                                        char *buf, loff_t off, size_t count)
 561 {
 562         size_t scpdata_len = count;
 563         size_t padding;
 564
 565
 566         if (off)
 567                 return -EINVAL;
 568
 569         memcpy(reipl_block_fcp->ipl_info.fcp.scp_data, buf, count);
 570         if (scpdata_len % 8) {
 571                 padding = 8 - (scpdata_len % 8);
 572                 memset(reipl_block_fcp->ipl_info.fcp.scp_data + scpdata_len,
 573                        0, padding);
 574                 scpdata_len += padding;
 575         }
 576
 577         reipl_block_fcp->ipl_info.fcp.scp_data_len = scpdata_len;
 578         reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN + scpdata_len;
 579         reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN + scpdata_len;
 580
 581         return count;
 582 }
 583 static struct bin_attribute sys_reipl_fcp_scp_data_attr =
 584         __BIN_ATTR(scp_data, (S_IRUGO | S_IWUSR), reipl_fcp_scpdata_read,
 585                    reipl_fcp_scpdata_write, DIAG308_SCPDATA_SIZE);
 586
 587 static struct bin_attribute *reipl_fcp_bin_attrs[] = {
 588         &sys_reipl_fcp_scp_data_attr,
 589         NULL,
 590 };
 591
 592 DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%llx\n",
 593                    reipl_block_fcp->ipl_info.fcp.wwpn);
 594 DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%llx\n",
 595                    reipl_block_fcp->ipl_info.fcp.lun);
 596 DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
 597                    reipl_block_fcp->ipl_info.fcp.bootprog);
 598 DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
 599                    reipl_block_fcp->ipl_info.fcp.br_lba);
 600 DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
 601                    reipl_block_fcp->ipl_info.fcp.devno);
 602
 603 static void reipl_get_ascii_loadparm(char *loadparm,
 604                                      struct ipl_parameter_block *ibp)
 605 {
 606         memcpy(loadparm, ibp->hdr.loadparm, LOADPARM_LEN);
 607         EBCASC(loadparm, LOADPARM_LEN);
 608         loadparm[LOADPARM_LEN] = 0;
 609         strim(loadparm);
 610 }
 611
 612 static ssize_t reipl_generic_loadparm_show(struct ipl_parameter_block *ipb,
 613                                            char *page)
 614 {
 615         char buf[LOADPARM_LEN + 1];
 616
 617         reipl_get_ascii_loadparm(buf, ipb);
 618         return sprintf(page, "%s\n", buf);
 619 }
 620
 621 static ssize_t reipl_generic_loadparm_store(struct ipl_parameter_block *ipb,
 622                                             const char *buf, size_t len)
 623 {
 624         int i, lp_len;
 625
 626         /* ignore trailing newline */
 627         lp_len = len;
 628         if ((len > 0) && (buf[len - 1] == '\n'))
 629                 lp_len--;
 630         /* loadparm can have max 8 characters and must not start with a blank */
 631         if ((lp_len > LOADPARM_LEN) || ((lp_len > 0) && (buf[0] == ' ')))
 632                 return -EINVAL;
 633         /* loadparm can only contain "a-z,A-Z,0-9,SP,." */
 634         for (i = 0; i < lp_len; i++) {
 635                 if (isalpha(buf[i]) || isdigit(buf[i]) || (buf[i] == ' ') ||
 636                     (buf[i] == '.'))
 637                         continue;
 638                 return -EINVAL;
 639         }
 640         /* initialize loadparm with blanks */
 641         memset(ipb->hdr.loadparm, ' ', LOADPARM_LEN);
 642         /* copy and convert to ebcdic */
 643         memcpy(ipb->hdr.loadparm, buf, lp_len);
 644         ASCEBC(ipb->hdr.loadparm, LOADPARM_LEN);
 645         ipb->hdr.flags |= DIAG308_FLAGS_LP_VALID;
 646         return len;
 647 }
 648
 649 /* FCP wrapper */
 650 static ssize_t reipl_fcp_loadparm_show(struct kobject *kobj,
 651                                        struct kobj_attribute *attr, char *page)
 652 {
 653         return reipl_generic_loadparm_show(reipl_block_fcp, page);
 654 }
 655
 656 static ssize_t reipl_fcp_loadparm_store(struct kobject *kobj,
 657                                         struct kobj_attribute *attr,
 658                                         const char *buf, size_t len)
 659 {
 660         return reipl_generic_loadparm_store(reipl_block_fcp, buf, len);
 661 }
 662
 663 static struct kobj_attribute sys_reipl_fcp_loadparm_attr =
 664         __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_fcp_loadparm_show,
 665                                             reipl_fcp_loadparm_store);
 666
 667 static struct attribute *reipl_fcp_attrs[] = {
 668         &sys_reipl_fcp_device_attr.attr,
 669         &sys_reipl_fcp_wwpn_attr.attr,
 670         &sys_reipl_fcp_lun_attr.attr,
 671         &sys_reipl_fcp_bootprog_attr.attr,
 672         &sys_reipl_fcp_br_lba_attr.attr,
 673         &sys_reipl_fcp_loadparm_attr.attr,
 674         NULL,
 675 };
 676
 677 static struct attribute_group reipl_fcp_attr_group = {
 678         .attrs = reipl_fcp_attrs,
 679         .bin_attrs = reipl_fcp_bin_attrs,
 680 };
 681
 682 /* CCW reipl device attributes */
 683 DEFINE_IPL_CCW_ATTR_RW(reipl_ccw, device, reipl_block_ccw->ipl_info.ccw);
 684
 685 /* NSS wrapper */
 686 static ssize_t reipl_nss_loadparm_show(struct kobject *kobj,
 687                                        struct kobj_attribute *attr, char *page)
 688 {
 689         return reipl_generic_loadparm_show(reipl_block_nss, page);
 690 }
 691
 692 static ssize_t reipl_nss_loadparm_store(struct kobject *kobj,
 693                                         struct kobj_attribute *attr,
 694                                         const char *buf, size_t len)
 695 {
 696         return reipl_generic_loadparm_store(reipl_block_nss, buf, len);
 697 }
 698
 699 /* CCW wrapper */
 700 static ssize_t reipl_ccw_loadparm_show(struct kobject *kobj,
 701                                        struct kobj_attribute *attr, char *page)
 702 {
 703         return reipl_generic_loadparm_show(reipl_block_ccw, page);
 704 }
 705
 706 static ssize_t reipl_ccw_loadparm_store(struct kobject *kobj,
 707                                         struct kobj_attribute *attr,
 708                                         const char *buf, size_t len)
 709 {
 710         return reipl_generic_loadparm_store(reipl_block_ccw, buf, len);
 711 }
 712
 713 static struct kobj_attribute sys_reipl_ccw_loadparm_attr =
 714         __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_ccw_loadparm_show,
 715                                             reipl_ccw_loadparm_store);
 716
 717 static struct attribute *reipl_ccw_attrs_vm[] = {
 718         &sys_reipl_ccw_device_attr.attr,
 719         &sys_reipl_ccw_loadparm_attr.attr,
 720         &sys_reipl_ccw_vmparm_attr.attr,
 721         NULL,
 722 };
 723
 724 static struct attribute *reipl_ccw_attrs_lpar[] = {
 725         &sys_reipl_ccw_device_attr.attr,
 726         &sys_reipl_ccw_loadparm_attr.attr,
 727         NULL,
 728 };
 729
 730 static struct attribute_group reipl_ccw_attr_group_vm = {
 731         .name  = IPL_CCW_STR,
 732         .attrs = reipl_ccw_attrs_vm,
 733 };
 734
 735 static struct attribute_group reipl_ccw_attr_group_lpar = {
 736         .name  = IPL_CCW_STR,
 737         .attrs = reipl_ccw_attrs_lpar,
 738 };
 739
 740
 741 /* NSS reipl device attributes */
 742 static void reipl_get_ascii_nss_name(char *dst,
 743                                      struct ipl_parameter_block *ipb)
 744 {
 745         memcpy(dst, ipb->ipl_info.ccw.nss_name, NSS_NAME_SIZE);
 746         EBCASC(dst, NSS_NAME_SIZE);
 747         dst[NSS_NAME_SIZE] = 0;
 748 }
 749
 750 static ssize_t reipl_nss_name_show(struct kobject *kobj,
 751                                    struct kobj_attribute *attr, char *page)
 752 {
 753         char nss_name[NSS_NAME_SIZE + 1] = {};
 754
 755         reipl_get_ascii_nss_name(nss_name, reipl_block_nss);
 756         return sprintf(page, "%s\n", nss_name);
 757 }
 758
 759 static ssize_t reipl_nss_name_store(struct kobject *kobj,
 760                                     struct kobj_attribute *attr,
 761                                     const char *buf, size_t len)
 762 {
 763         int nss_len;
 764
 765         /* ignore trailing newline */
 766         nss_len = len;
 767         if ((len > 0) && (buf[len - 1] == '\n'))
 768                 nss_len--;
 769
 770         if (nss_len > NSS_NAME_SIZE)
 771                 return -EINVAL;
 772
 773         memset(reipl_block_nss->ipl_info.ccw.nss_name, 0x40, NSS_NAME_SIZE);
 774         if (nss_len > 0) {
 775                 reipl_block_nss->ipl_info.ccw.vm_flags |=
 776                         DIAG308_VM_FLAGS_NSS_VALID;
 777                 memcpy(reipl_block_nss->ipl_info.ccw.nss_name, buf, nss_len);
 778                 ASCEBC(reipl_block_nss->ipl_info.ccw.nss_name, nss_len);
 779                 EBC_TOUPPER(reipl_block_nss->ipl_info.ccw.nss_name, nss_len);
 780         } else {
 781                 reipl_block_nss->ipl_info.ccw.vm_flags &=
 782                         ~DIAG308_VM_FLAGS_NSS_VALID;
 783         }
 784
 785         return len;
 786 }
 787
 788 static struct kobj_attribute sys_reipl_nss_name_attr =
 789         __ATTR(name, S_IRUGO | S_IWUSR, reipl_nss_name_show,
 790                                         reipl_nss_name_store);
 791
 792 static struct kobj_attribute sys_reipl_nss_loadparm_attr =
 793         __ATTR(loadparm, S_IRUGO | S_IWUSR, reipl_nss_loadparm_show,
 794                                             reipl_nss_loadparm_store);
 795
 796 static struct attribute *reipl_nss_attrs[] = {
 797         &sys_reipl_nss_name_attr.attr,
 798         &sys_reipl_nss_loadparm_attr.attr,
 799         &sys_reipl_nss_vmparm_attr.attr,
 800         NULL,
 801 };
 802
 803 static struct attribute_group reipl_nss_attr_group = {
 804         .name  = IPL_NSS_STR,
 805         .attrs = reipl_nss_attrs,
 806 };
 807
 808 void set_os_info_reipl_block(void)
 809 {
 810         os_info_entry_add(OS_INFO_REIPL_BLOCK, reipl_block_actual,
 811                           reipl_block_actual->hdr.len);
 812 }
 813
 814 /* reipl type */
 815
 816 static int reipl_set_type(enum ipl_type type)
 817 {
 818         if (!(reipl_capabilities & type))
 819                 return -EINVAL;
 820
 821         switch(type) {
 822         case IPL_TYPE_CCW:
 823                 reipl_block_actual = reipl_block_ccw;
 824                 break;
 825         case IPL_TYPE_FCP:
 826                 reipl_block_actual = reipl_block_fcp;
 827                 break;
 828         case IPL_TYPE_NSS:
 829                 reipl_block_actual = reipl_block_nss;
 830                 break;
 831         default:
 832                 break;
 833         }
 834         reipl_type = type;
 835         return 0;
 836 }
 837
 838 static ssize_t reipl_type_show(struct kobject *kobj,
 839                                struct kobj_attribute *attr, char *page)
 840 {
 841         return sprintf(page, "%s\n", ipl_type_str(reipl_type));
 842 }
 843
 844 static ssize_t reipl_type_store(struct kobject *kobj,
 845                                 struct kobj_attribute *attr,
 846                                 const char *buf, size_t len)
 847 {
 848         int rc = -EINVAL;
 849
 850         if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
 851                 rc = reipl_set_type(IPL_TYPE_CCW);
 852         else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
 853                 rc = reipl_set_type(IPL_TYPE_FCP);
 854         else if (strncmp(buf, IPL_NSS_STR, strlen(IPL_NSS_STR)) == 0)
 855                 rc = reipl_set_type(IPL_TYPE_NSS);
 856         return (rc != 0) ? rc : len;
 857 }
 858
 859 static struct kobj_attribute reipl_type_attr =
 860         __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
 861
 862 static struct kset *reipl_kset;
 863 static struct kset *reipl_fcp_kset;
 864
 865 static void __reipl_run(void *unused)
 866 {
 867         switch (reipl_type) {
 868         case IPL_TYPE_CCW:
 869                 diag308(DIAG308_SET, reipl_block_ccw);
 870                 diag308(DIAG308_LOAD_CLEAR, NULL);
 871                 break;
 872         case IPL_TYPE_FCP:
 873                 diag308(DIAG308_SET, reipl_block_fcp);
 874                 diag308(DIAG308_LOAD_CLEAR, NULL);
 875                 break;
 876         case IPL_TYPE_NSS:
 877                 diag308(DIAG308_SET, reipl_block_nss);
 878                 diag308(DIAG308_LOAD_CLEAR, NULL);
 879                 break;
 880         case IPL_TYPE_UNKNOWN:
 881                 diag308(DIAG308_LOAD_CLEAR, NULL);
 882                 break;
 883         case IPL_TYPE_FCP_DUMP:
 884                 break;
 885         }
 886         disabled_wait((unsigned long) __builtin_return_address(0));
 887 }
 888
 889 static void reipl_run(struct shutdown_trigger *trigger)
 890 {
 891         smp_call_ipl_cpu(__reipl_run, NULL);
 892 }
 893
 894 static void reipl_block_ccw_init(struct ipl_parameter_block *ipb)
 895 {
 896         ipb->hdr.len = IPL_PARM_BLK_CCW_LEN;
 897         ipb->hdr.version = IPL_PARM_BLOCK_VERSION;
 898         ipb->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
 899         ipb->hdr.pbt = DIAG308_IPL_TYPE_CCW;
 900 }
 901
 902 static void reipl_block_ccw_fill_parms(struct ipl_parameter_block *ipb)
 903 {
 904         /* LOADPARM */
 905         /* check if read scp info worked and set loadparm */
 906         if (sclp_ipl_info.is_valid)
 907                 memcpy(ipb->hdr.loadparm, &sclp_ipl_info.loadparm, LOADPARM_LEN);
 908         else
 909                 /* read scp info failed: set empty loadparm (EBCDIC blanks) */
 910                 memset(ipb->hdr.loadparm, 0x40, LOADPARM_LEN);
 911         ipb->hdr.flags = DIAG308_FLAGS_LP_VALID;
 912
 913         /* VM PARM */
 914         if (MACHINE_IS_VM && ipl_block_valid &&
 915             (ipl_block.ipl_info.ccw.vm_flags & DIAG308_VM_FLAGS_VP_VALID)) {
 916
 917                 ipb->ipl_info.ccw.vm_flags |= DIAG308_VM_FLAGS_VP_VALID;
 918                 ipb->ipl_info.ccw.vm_parm_len =
 919                                         ipl_block.ipl_info.ccw.vm_parm_len;
 920                 memcpy(ipb->ipl_info.ccw.vm_parm,
 921                        ipl_block.ipl_info.ccw.vm_parm, DIAG308_VMPARM_SIZE);
 922         }
 923 }
 924
 925 static int __init reipl_nss_init(void)
 926 {
 927         int rc;
 928
 929         if (!MACHINE_IS_VM)
 930                 return 0;
 931
 932         reipl_block_nss = (void *) get_zeroed_page(GFP_KERNEL);
 933         if (!reipl_block_nss)
 934                 return -ENOMEM;
 935
 936         rc = sysfs_create_group(&reipl_kset->kobj, &reipl_nss_attr_group);
 937         if (rc)
 938                 return rc;
 939
 940         reipl_block_ccw_init(reipl_block_nss);
 941         reipl_capabilities |= IPL_TYPE_NSS;
 942         return 0;
 943 }
 944
 945 static int __init reipl_ccw_init(void)
 946 {
 947         int rc;
 948
 949         reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
 950         if (!reipl_block_ccw)
 951                 return -ENOMEM;
 952
 953         rc = sysfs_create_group(&reipl_kset->kobj,
 954                                 MACHINE_IS_VM ? &reipl_ccw_attr_group_vm
 955                                               : &reipl_ccw_attr_group_lpar);
 956         if (rc)
 957                 return rc;
 958
 959         reipl_block_ccw_init(reipl_block_ccw);
 960         if (ipl_info.type == IPL_TYPE_CCW) {
 961                 reipl_block_ccw->ipl_info.ccw.ssid = ipl_block.ipl_info.ccw.ssid;
 962                 reipl_block_ccw->ipl_info.ccw.devno = ipl_block.ipl_info.ccw.devno;
 963                 reipl_block_ccw_fill_parms(reipl_block_ccw);
 964         }
 965
 966         reipl_capabilities |= IPL_TYPE_CCW;
 967         return 0;
 968 }
 969
 970 static int __init reipl_fcp_init(void)
 971 {
 972         int rc;
 973
 974         reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
 975         if (!reipl_block_fcp)
 976                 return -ENOMEM;
 977
 978         /* sysfs: create fcp kset for mixing attr group and bin attrs */
 979         reipl_fcp_kset = kset_create_and_add(IPL_FCP_STR, NULL,
 980                                              &reipl_kset->kobj);
 981         if (!reipl_fcp_kset) {
 982                 free_page((unsigned long) reipl_block_fcp);
 983                 return -ENOMEM;
 984         }
 985
 986         rc = sysfs_create_group(&reipl_fcp_kset->kobj, &reipl_fcp_attr_group);
 987         if (rc) {
 988                 kset_unregister(reipl_fcp_kset);
 989                 free_page((unsigned long) reipl_block_fcp);
 990                 return rc;
 991         }
 992
 993         if (ipl_info.type == IPL_TYPE_FCP) {
 994                 memcpy(reipl_block_fcp, &ipl_block, sizeof(ipl_block));
 995                 /*
 996                  * Fix loadparm: There are systems where the (SCSI) LOADPARM
 997                  * is invalid in the SCSI IPL parameter block, so take it
 998                  * always from sclp_ipl_info.
 999                  */
1000                 memcpy(reipl_block_fcp->hdr.loadparm, sclp_ipl_info.loadparm,
1001                        LOADPARM_LEN);
1002         } else {
1003                 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
1004                 reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1005                 reipl_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
1006                 reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
1007                 reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL;
1008         }
1009         reipl_capabilities |= IPL_TYPE_FCP;
1010         return 0;
1011 }
1012
1013 static int __init reipl_type_init(void)
1014 {
1015         enum ipl_type reipl_type = ipl_info.type;
1016         struct ipl_parameter_block *reipl_block;
1017         unsigned long size;
1018
1019         reipl_block = os_info_old_entry(OS_INFO_REIPL_BLOCK, &size);
1020         if (!reipl_block)
1021                 goto out;
1022         /*
1023          * If we have an OS info reipl block, this will be used
1024          */
1025         if (reipl_block->hdr.pbt == DIAG308_IPL_TYPE_FCP) {
1026                 memcpy(reipl_block_fcp, reipl_block, size);
1027                 reipl_type = IPL_TYPE_FCP;
1028         } else if (reipl_block->hdr.pbt == DIAG308_IPL_TYPE_CCW) {
1029                 memcpy(reipl_block_ccw, reipl_block, size);
1030                 reipl_type = IPL_TYPE_CCW;
1031         }
1032 out:
1033         return reipl_set_type(reipl_type);
1034 }
1035
1036 static int __init reipl_init(void)
1037 {
1038         int rc;
1039
1040         reipl_kset = kset_create_and_add("reipl", NULL, firmware_kobj);
1041         if (!reipl_kset)
1042                 return -ENOMEM;
1043         rc = sysfs_create_file(&reipl_kset->kobj, &reipl_type_attr.attr);
1044         if (rc) {
1045                 kset_unregister(reipl_kset);
1046                 return rc;
1047         }
1048         rc = reipl_ccw_init();
1049         if (rc)
1050                 return rc;
1051         rc = reipl_fcp_init();
1052         if (rc)
1053                 return rc;
1054         rc = reipl_nss_init();
1055         if (rc)
1056                 return rc;
1057         return reipl_type_init();
1058 }
1059
1060 static struct shutdown_action __refdata reipl_action = {
1061         .name   = SHUTDOWN_ACTION_REIPL_STR,
1062         .fn     = reipl_run,
1063         .init   = reipl_init,
1064 };
1065
1066 /*
1067  * dump shutdown action: Dump Linux on shutdown.
1068  */
1069
1070 /* FCP dump device attributes */
1071
1072 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%llx\n",
1073                    dump_block_fcp->ipl_info.fcp.wwpn);
1074 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%llx\n",
1075                    dump_block_fcp->ipl_info.fcp.lun);
1076 DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
1077                    dump_block_fcp->ipl_info.fcp.bootprog);
1078 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
1079                    dump_block_fcp->ipl_info.fcp.br_lba);
1080 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
1081                    dump_block_fcp->ipl_info.fcp.devno);
1082
1083 static struct attribute *dump_fcp_attrs[] = {
1084         &sys_dump_fcp_device_attr.attr,
1085         &sys_dump_fcp_wwpn_attr.attr,
1086         &sys_dump_fcp_lun_attr.attr,
1087         &sys_dump_fcp_bootprog_attr.attr,
1088         &sys_dump_fcp_br_lba_attr.attr,
1089         NULL,
1090 };
1091
1092 static struct attribute_group dump_fcp_attr_group = {
1093         .name  = IPL_FCP_STR,
1094         .attrs = dump_fcp_attrs,
1095 };
1096
1097 /* CCW dump device attributes */
1098 DEFINE_IPL_CCW_ATTR_RW(dump_ccw, device, dump_block_ccw->ipl_info.ccw);
1099
1100 static struct attribute *dump_ccw_attrs[] = {
1101         &sys_dump_ccw_device_attr.attr,
1102         NULL,
1103 };
1104
1105 static struct attribute_group dump_ccw_attr_group = {
1106         .name  = IPL_CCW_STR,
1107         .attrs = dump_ccw_attrs,
1108 };
1109
1110 /* dump type */
1111
1112 static int dump_set_type(enum dump_type type)
1113 {
1114         if (!(dump_capabilities & type))
1115                 return -EINVAL;
1116         dump_type = type;
1117         return 0;
1118 }
1119
1120 static ssize_t dump_type_show(struct kobject *kobj,
1121                               struct kobj_attribute *attr, char *page)
1122 {
1123         return sprintf(page, "%s\n", dump_type_str(dump_type));
1124 }
1125
1126 static ssize_t dump_type_store(struct kobject *kobj,
1127                                struct kobj_attribute *attr,
1128                                const char *buf, size_t len)
1129 {
1130         int rc = -EINVAL;
1131
1132         if (strncmp(buf, DUMP_NONE_STR, strlen(DUMP_NONE_STR)) == 0)
1133                 rc = dump_set_type(DUMP_TYPE_NONE);
1134         else if (strncmp(buf, DUMP_CCW_STR, strlen(DUMP_CCW_STR)) == 0)
1135                 rc = dump_set_type(DUMP_TYPE_CCW);
1136         else if (strncmp(buf, DUMP_FCP_STR, strlen(DUMP_FCP_STR)) == 0)
1137                 rc = dump_set_type(DUMP_TYPE_FCP);
1138         return (rc != 0) ? rc : len;
1139 }
1140
1141 static struct kobj_attribute dump_type_attr =
1142         __ATTR(dump_type, 0644, dump_type_show, dump_type_store);
1143
1144 static struct kset *dump_kset;
1145
1146 static void diag308_dump(void *dump_block)
1147 {
1148         diag308(DIAG308_SET, dump_block);
1149         while (1) {
1150                 if (diag308(DIAG308_LOAD_NORMAL_DUMP, NULL) != 0x302)
1151                         break;
1152                 udelay_simple(USEC_PER_SEC);
1153         }
1154 }
1155
1156 static void __dump_run(void *unused)
1157 {
1158         switch (dump_type) {
1159         case DUMP_TYPE_CCW:
1160                 diag308_dump(dump_block_ccw);
1161                 break;
1162         case DUMP_TYPE_FCP:
1163                 diag308_dump(dump_block_fcp);
1164                 break;
1165         default:
1166                 break;
1167         }
1168 }
1169
1170 static void dump_run(struct shutdown_trigger *trigger)
1171 {
1172         if (dump_type == DUMP_TYPE_NONE)
1173                 return;
1174         smp_send_stop();
1175         smp_call_ipl_cpu(__dump_run, NULL);
1176 }
1177
1178 static int __init dump_ccw_init(void)
1179 {
1180         int rc;
1181
1182         dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
1183         if (!dump_block_ccw)
1184                 return -ENOMEM;
1185         rc = sysfs_create_group(&dump_kset->kobj, &dump_ccw_attr_group);
1186         if (rc) {
1187                 free_page((unsigned long)dump_block_ccw);
1188                 return rc;
1189         }
1190         dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
1191         dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
1192         dump_block_ccw->hdr.blk0_len = IPL_PARM_BLK0_CCW_LEN;
1193         dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
1194         dump_capabilities |= DUMP_TYPE_CCW;
1195         return 0;
1196 }
1197
1198 static int __init dump_fcp_init(void)
1199 {
1200         int rc;
1201
1202         if (!sclp_ipl_info.has_dump)
1203                 return 0; /* LDIPL DUMP is not installed */
1204         dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
1205         if (!dump_block_fcp)
1206                 return -ENOMEM;
1207         rc = sysfs_create_group(&dump_kset->kobj, &dump_fcp_attr_group);
1208         if (rc) {
1209                 free_page((unsigned long)dump_block_fcp);
1210                 return rc;
1211         }
1212         dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
1213         dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
1214         dump_block_fcp->hdr.blk0_len = IPL_PARM_BLK0_FCP_LEN;
1215         dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
1216         dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
1217         dump_capabilities |= DUMP_TYPE_FCP;
1218         return 0;
1219 }
1220
1221 static int __init dump_init(void)
1222 {
1223         int rc;
1224
1225         dump_kset = kset_create_and_add("dump", NULL, firmware_kobj);
1226         if (!dump_kset)
1227                 return -ENOMEM;
1228         rc = sysfs_create_file(&dump_kset->kobj, &dump_type_attr.attr);
1229         if (rc) {
1230                 kset_unregister(dump_kset);
1231                 return rc;
1232         }
1233         rc = dump_ccw_init();
1234         if (rc)
1235                 return rc;
1236         rc = dump_fcp_init();
1237         if (rc)
1238                 return rc;
1239         dump_set_type(DUMP_TYPE_NONE);
1240         return 0;
1241 }
1242
1243 static struct shutdown_action __refdata dump_action = {
1244         .name   = SHUTDOWN_ACTION_DUMP_STR,
1245         .fn     = dump_run,
1246         .init   = dump_init,
1247 };
1248
1249 static void dump_reipl_run(struct shutdown_trigger *trigger)
1250 {
1251         unsigned long ipib = (unsigned long) reipl_block_actual;
1252         unsigned int csum;
1253
1254         csum = (__force unsigned int)
1255                csum_partial(reipl_block_actual, reipl_block_actual->hdr.len, 0);
1256         mem_assign_absolute(S390_lowcore.ipib, ipib);
1257         mem_assign_absolute(S390_lowcore.ipib_checksum, csum);
1258         dump_run(trigger);
1259 }
1260
1261 static struct shutdown_action __refdata dump_reipl_action = {
1262         .name   = SHUTDOWN_ACTION_DUMP_REIPL_STR,
1263         .fn     = dump_reipl_run,
1264 };
1265
1266 /*
1267  * vmcmd shutdown action: Trigger vm command on shutdown.
1268  */
1269
1270 static char vmcmd_on_reboot[128];
1271 static char vmcmd_on_panic[128];
1272 static char vmcmd_on_halt[128];
1273 static char vmcmd_on_poff[128];
1274 static char vmcmd_on_restart[128];
1275
1276 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_reboot, "%s\n", "%s\n", vmcmd_on_reboot);
1277 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_panic, "%s\n", "%s\n", vmcmd_on_panic);
1278 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_halt, "%s\n", "%s\n", vmcmd_on_halt);
1279 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_poff, "%s\n", "%s\n", vmcmd_on_poff);
1280 DEFINE_IPL_ATTR_STR_RW(vmcmd, on_restart, "%s\n", "%s\n", vmcmd_on_restart);
1281
1282 static struct attribute *vmcmd_attrs[] = {
1283         &sys_vmcmd_on_reboot_attr.attr,
1284         &sys_vmcmd_on_panic_attr.attr,
1285         &sys_vmcmd_on_halt_attr.attr,
1286         &sys_vmcmd_on_poff_attr.attr,
1287         &sys_vmcmd_on_restart_attr.attr,
1288         NULL,
1289 };
1290
1291 static struct attribute_group vmcmd_attr_group = {
1292         .attrs = vmcmd_attrs,
1293 };
1294
1295 static struct kset *vmcmd_kset;
1296
1297 static void vmcmd_run(struct shutdown_trigger *trigger)
1298 {
1299         char *cmd;
1300
1301         if (strcmp(trigger->name, ON_REIPL_STR) == 0)
1302                 cmd = vmcmd_on_reboot;
1303         else if (strcmp(trigger->name, ON_PANIC_STR) == 0)
1304                 cmd = vmcmd_on_panic;
1305         else if (strcmp(trigger->name, ON_HALT_STR) == 0)
1306                 cmd = vmcmd_on_halt;
1307         else if (strcmp(trigger->name, ON_POFF_STR) == 0)
1308                 cmd = vmcmd_on_poff;
1309         else if (strcmp(trigger->name, ON_RESTART_STR) == 0)
1310                 cmd = vmcmd_on_restart;
1311         else
1312                 return;
1313
1314         if (strlen(cmd) == 0)
1315                 return;
1316         __cpcmd(cmd, NULL, 0, NULL);
1317 }
1318
1319 static int vmcmd_init(void)
1320 {
1321         if (!MACHINE_IS_VM)
1322                 return -EOPNOTSUPP;
1323         vmcmd_kset = kset_create_and_add("vmcmd", NULL, firmware_kobj);
1324         if (!vmcmd_kset)
1325                 return -ENOMEM;
1326         return sysfs_create_group(&vmcmd_kset->kobj, &vmcmd_attr_group);
1327 }
1328
1329 static struct shutdown_action vmcmd_action = {SHUTDOWN_ACTION_VMCMD_STR,
1330                                               vmcmd_run, vmcmd_init};
1331
1332 /*
1333  * stop shutdown action: Stop Linux on shutdown.
1334  */
1335
1336 static void stop_run(struct shutdown_trigger *trigger)
1337 {
1338         if (strcmp(trigger->name, ON_PANIC_STR) == 0 ||
1339             strcmp(trigger->name, ON_RESTART_STR) == 0)
1340                 disabled_wait((unsigned long) __builtin_return_address(0));
1341         smp_stop_cpu();
1342 }
1343
1344 static struct shutdown_action stop_action = {SHUTDOWN_ACTION_STOP_STR,
1345                                              stop_run, NULL};
1346
1347 /* action list */
1348
1349 static struct shutdown_action *shutdown_actions_list[] = {
1350         &ipl_action, &reipl_action, &dump_reipl_action, &dump_action,
1351         &vmcmd_action, &stop_action};
1352 #define SHUTDOWN_ACTIONS_COUNT (sizeof(shutdown_actions_list) / sizeof(void *))
1353
1354 /*
1355  * Trigger section
1356  */
1357
1358 static struct kset *shutdown_actions_kset;
1359
1360 static int set_trigger(const char *buf, struct shutdown_trigger *trigger,
1361                        size_t len)
1362 {
1363         int i;
1364
1365         for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) {
1366                 if (sysfs_streq(buf, shutdown_actions_list[i]->name)) {
1367                         if (shutdown_actions_list[i]->init_rc) {
1368                                 return shutdown_actions_list[i]->init_rc;
1369                         } else {
1370                                 trigger->action = shutdown_actions_list[i];
1371                                 return len;
1372                         }
1373                 }
1374         }
1375         return -EINVAL;
1376 }
1377
1378 /* on reipl */
1379
1380 static struct shutdown_trigger on_reboot_trigger = {ON_REIPL_STR,
1381                                                     &reipl_action};
1382
1383 static ssize_t on_reboot_show(struct kobject *kobj,
1384                               struct kobj_attribute *attr, char *page)
1385 {
1386         return sprintf(page, "%s\n", on_reboot_trigger.action->name);
1387 }
1388
1389 static ssize_t on_reboot_store(struct kobject *kobj,
1390                                struct kobj_attribute *attr,
1391                                const char *buf, size_t len)
1392 {
1393         return set_trigger(buf, &on_reboot_trigger, len);
1394 }
1395 static struct kobj_attribute on_reboot_attr = __ATTR_RW(on_reboot);
1396
1397 static void do_machine_restart(char *__unused)
1398 {
1399         smp_send_stop();
1400         on_reboot_trigger.action->fn(&on_reboot_trigger);
1401         reipl_run(NULL);
1402 }
1403 void (*_machine_restart)(char *command) = do_machine_restart;
1404
1405 /* on panic */
1406
1407 static struct shutdown_trigger on_panic_trigger = {ON_PANIC_STR, &stop_action};
1408
1409 static ssize_t on_panic_show(struct kobject *kobj,
1410                              struct kobj_attribute *attr, char *page)
1411 {
1412         return sprintf(page, "%s\n", on_panic_trigger.action->name);
1413 }
1414
1415 static ssize_t on_panic_store(struct kobject *kobj,
1416                               struct kobj_attribute *attr,
1417                               const char *buf, size_t len)
1418 {
1419         return set_trigger(buf, &on_panic_trigger, len);
1420 }
1421 static struct kobj_attribute on_panic_attr = __ATTR_RW(on_panic);
1422
1423 static void do_panic(void)
1424 {
1425         lgr_info_log();
1426         on_panic_trigger.action->fn(&on_panic_trigger);
1427         stop_run(&on_panic_trigger);
1428 }
1429
1430 /* on restart */
1431
1432 static struct shutdown_trigger on_restart_trigger = {ON_RESTART_STR,
1433         &stop_action};
1434
1435 static ssize_t on_restart_show(struct kobject *kobj,
1436                                struct kobj_attribute *attr, char *page)
1437 {
1438         return sprintf(page, "%s\n", on_restart_trigger.action->name);
1439 }
1440
1441 static ssize_t on_restart_store(struct kobject *kobj,
1442                                 struct kobj_attribute *attr,
1443                                 const char *buf, size_t len)
1444 {
1445         return set_trigger(buf, &on_restart_trigger, len);
1446 }
1447 static struct kobj_attribute on_restart_attr = __ATTR_RW(on_restart);
1448
1449 static void __do_restart(void *ignore)
1450 {
1451         __arch_local_irq_stosm(0x04); /* enable DAT */
1452         smp_send_stop();
1453 #ifdef CONFIG_CRASH_DUMP
1454         crash_kexec(NULL);
1455 #endif
1456         on_restart_trigger.action->fn(&on_restart_trigger);
1457         stop_run(&on_restart_trigger);
1458 }
1459
1460 void do_restart(void)
1461 {
1462         tracing_off();
1463         debug_locks_off();
1464         lgr_info_log();
1465         smp_call_online_cpu(__do_restart, NULL);
1466 }
1467
1468 /* on halt */
1469
1470 static struct shutdown_trigger on_halt_trigger = {ON_HALT_STR, &stop_action};
1471
1472 static ssize_t on_halt_show(struct kobject *kobj,
1473                             struct kobj_attribute *attr, char *page)
1474 {
1475         return sprintf(page, "%s\n", on_halt_trigger.action->name);
1476 }
1477
1478 static ssize_t on_halt_store(struct kobject *kobj,
1479                              struct kobj_attribute *attr,
1480                              const char *buf, size_t len)
1481 {
1482         return set_trigger(buf, &on_halt_trigger, len);
1483 }
1484 static struct kobj_attribute on_halt_attr = __ATTR_RW(on_halt);
1485
1486 static void do_machine_halt(void)
1487 {
1488         smp_send_stop();
1489         on_halt_trigger.action->fn(&on_halt_trigger);
1490         stop_run(&on_halt_trigger);
1491 }
1492 void (*_machine_halt)(void) = do_machine_halt;
1493
1494 /* on power off */
1495
1496 static struct shutdown_trigger on_poff_trigger = {ON_POFF_STR, &stop_action};
1497
1498 static ssize_t on_poff_show(struct kobject *kobj,
1499                             struct kobj_attribute *attr, char *page)
1500 {
1501         return sprintf(page, "%s\n", on_poff_trigger.action->name);
1502 }
1503
1504 static ssize_t on_poff_store(struct kobject *kobj,
1505                              struct kobj_attribute *attr,
1506                              const char *buf, size_t len)
1507 {
1508         return set_trigger(buf, &on_poff_trigger, len);
1509 }
1510 static struct kobj_attribute on_poff_attr = __ATTR_RW(on_poff);
1511
1512 static void do_machine_power_off(void)
1513 {
1514         smp_send_stop();
1515         on_poff_trigger.action->fn(&on_poff_trigger);
1516         stop_run(&on_poff_trigger);
1517 }
1518 void (*_machine_power_off)(void) = do_machine_power_off;
1519
1520 static struct attribute *shutdown_action_attrs[] = {
1521         &on_restart_attr.attr,
1522         &on_reboot_attr.attr,
1523         &on_panic_attr.attr,
1524         &on_halt_attr.attr,
1525         &on_poff_attr.attr,
1526         NULL,
1527 };
1528
1529 static struct attribute_group shutdown_action_attr_group = {
1530         .attrs = shutdown_action_attrs,
1531 };
1532
1533 static void __init shutdown_triggers_init(void)
1534 {
1535         shutdown_actions_kset = kset_create_and_add("shutdown_actions", NULL,
1536                                                     firmware_kobj);
1537         if (!shutdown_actions_kset)
1538                 goto fail;
1539         if (sysfs_create_group(&shutdown_actions_kset->kobj,
1540                                &shutdown_action_attr_group))
1541                 goto fail;
1542         return;
1543 fail:
1544         panic("shutdown_triggers_init failed\n");
1545 }
1546
1547 static void __init shutdown_actions_init(void)
1548 {
1549         int i;
1550
1551         for (i = 0; i < SHUTDOWN_ACTIONS_COUNT; i++) {
1552                 if (!shutdown_actions_list[i]->init)
1553                         continue;
1554                 shutdown_actions_list[i]->init_rc =
1555                         shutdown_actions_list[i]->init();
1556         }
1557 }
1558
1559 static int __init s390_ipl_init(void)
1560 {
1561         char str[8] = {0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40};
1562
1563         sclp_early_get_ipl_info(&sclp_ipl_info);
1564         /*
1565          * Fix loadparm: There are systems where the (SCSI) LOADPARM
1566          * returned by read SCP info is invalid (contains EBCDIC blanks)
1567          * when the system has been booted via diag308. In that case we use
1568          * the value from diag308, if available.
1569          *
1570          * There are also systems where diag308 store does not work in
1571          * case the system is booted from HMC. Fortunately in this case
1572          * READ SCP info provides the correct value.
1573          */
1574         if (memcmp(sclp_ipl_info.loadparm, str, sizeof(str)) == 0 && ipl_block_valid)
1575                 memcpy(sclp_ipl_info.loadparm, ipl_block.hdr.loadparm, LOADPARM_LEN);
1576         shutdown_actions_init();
1577         shutdown_triggers_init();
1578         return 0;
1579 }
1580
1581 __initcall(s390_ipl_init);
1582
1583 static void __init strncpy_skip_quote(char *dst, char *src, int n)
1584 {
1585         int sx, dx;
1586
1587         dx = 0;
1588         for (sx = 0; src[sx] != 0; sx++) {
1589                 if (src[sx] == '"')
1590                         continue;
1591                 dst[dx++] = src[sx];
1592                 if (dx >= n)
1593                         break;
1594         }
1595 }
1596
1597 static int __init vmcmd_on_reboot_setup(char *str)
1598 {
1599         if (!MACHINE_IS_VM)
1600                 return 1;
1601         strncpy_skip_quote(vmcmd_on_reboot, str, 127);
1602         vmcmd_on_reboot[127] = 0;
1603         on_reboot_trigger.action = &vmcmd_action;
1604         return 1;
1605 }
1606 __setup("vmreboot=", vmcmd_on_reboot_setup);
1607
1608 static int __init vmcmd_on_panic_setup(char *str)
1609 {
1610         if (!MACHINE_IS_VM)
1611                 return 1;
1612         strncpy_skip_quote(vmcmd_on_panic, str, 127);
1613         vmcmd_on_panic[127] = 0;
1614         on_panic_trigger.action = &vmcmd_action;
1615         return 1;
1616 }
1617 __setup("vmpanic=", vmcmd_on_panic_setup);
1618
1619 static int __init vmcmd_on_halt_setup(char *str)
1620 {
1621         if (!MACHINE_IS_VM)
1622                 return 1;
1623         strncpy_skip_quote(vmcmd_on_halt, str, 127);
1624         vmcmd_on_halt[127] = 0;
1625         on_halt_trigger.action = &vmcmd_action;
1626         return 1;
1627 }
1628 __setup("vmhalt=", vmcmd_on_halt_setup);
1629
1630 static int __init vmcmd_on_poff_setup(char *str)
1631 {
1632         if (!MACHINE_IS_VM)
1633                 return 1;
1634         strncpy_skip_quote(vmcmd_on_poff, str, 127);
1635         vmcmd_on_poff[127] = 0;
1636         on_poff_trigger.action = &vmcmd_action;
1637         return 1;
1638 }
1639 __setup("vmpoff=", vmcmd_on_poff_setup);
1640
1641 static int on_panic_notify(struct notifier_block *self,
1642                            unsigned long event, void *data)
1643 {
1644         do_panic();
1645         return NOTIFY_OK;
1646 }
1647
1648 static struct notifier_block on_panic_nb = {
1649         .notifier_call = on_panic_notify,
1650         .priority = INT_MIN,
1651 };
1652
1653 void __init setup_ipl(void)
1654 {
1655         BUILD_BUG_ON(sizeof(struct ipl_parameter_block) != PAGE_SIZE);
1656
1657         ipl_info.type = get_ipl_type();
1658         switch (ipl_info.type) {
1659         case IPL_TYPE_CCW:
1660                 ipl_info.data.ccw.dev_id.ssid = ipl_block.ipl_info.ccw.ssid;
1661                 ipl_info.data.ccw.dev_id.devno = ipl_block.ipl_info.ccw.devno;
1662                 break;
1663         case IPL_TYPE_FCP:
1664         case IPL_TYPE_FCP_DUMP:
1665                 ipl_info.data.fcp.dev_id.ssid = 0;
1666                 ipl_info.data.fcp.dev_id.devno = ipl_block.ipl_info.fcp.devno;
1667                 ipl_info.data.fcp.wwpn = ipl_block.ipl_info.fcp.wwpn;
1668                 ipl_info.data.fcp.lun = ipl_block.ipl_info.fcp.lun;
1669                 break;
1670         case IPL_TYPE_NSS:
1671         case IPL_TYPE_UNKNOWN:
1672                 /* We have no info to copy */
1673                 break;
1674         }
1675         atomic_notifier_chain_register(&panic_notifier_list, &on_panic_nb);
1676 }
1677
1678 void __init ipl_store_parameters(void)
1679 {
1680         if (early_ipl_block_valid) {
1681                 memcpy(&ipl_block, &early_ipl_block, sizeof(ipl_block));
1682                 ipl_block_valid = 1;
1683         }
1684 }
1685
1686 void s390_reset_system(void)
1687 {
1688         /* Disable prefixing */
1689         set_prefix(0);
1690
1691         /* Disable lowcore protection */
1692         __ctl_clear_bit(0, 28);
1693         diag308_reset();
1694 }