arch/s390/kernel/ipl.c

   1 /*
   2  *  arch/s390/kernel/ipl.c
   3  *    ipl/reipl/dump support for Linux on s390.
   4  *
   5  *    Copyright (C) IBM Corp. 2005,2006
   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/module.h>
  13 #include <linux/device.h>
  14 #include <linux/delay.h>
  15 #include <linux/reboot.h>
  16 #include <linux/ctype.h>
  17 #include <asm/smp.h>
  18 #include <asm/setup.h>
  19 #include <asm/cpcmd.h>
  20 #include <asm/cio.h>
  21 #include <asm/ebcdic.h>
  22 #include <asm/reset.h>
  23
  24 #define IPL_PARM_BLOCK_VERSION 0
  25 #define LOADPARM_LEN 8
  26
  27 extern char s390_readinfo_sccb[];
  28 #define SCCB_VALID (*((__u16*)&s390_readinfo_sccb[6]) == 0x0010)
  29 #define SCCB_LOADPARM (&s390_readinfo_sccb[24])
  30 #define SCCB_FLAG (s390_readinfo_sccb[91])
  31
  32 enum ipl_type {
  33         IPL_TYPE_NONE    = 1,
  34         IPL_TYPE_UNKNOWN = 2,
  35         IPL_TYPE_CCW     = 4,
  36         IPL_TYPE_FCP     = 8,
  37 };
  38
  39 #define IPL_NONE_STR     "none"
  40 #define IPL_UNKNOWN_STR  "unknown"
  41 #define IPL_CCW_STR      "ccw"
  42 #define IPL_FCP_STR      "fcp"
  43
  44 static char *ipl_type_str(enum ipl_type type)
  45 {
  46         switch (type) {
  47         case IPL_TYPE_NONE:
  48                 return IPL_NONE_STR;
  49         case IPL_TYPE_CCW:
  50                 return IPL_CCW_STR;
  51         case IPL_TYPE_FCP:
  52                 return IPL_FCP_STR;
  53         case IPL_TYPE_UNKNOWN:
  54         default:
  55                 return IPL_UNKNOWN_STR;
  56         }
  57 }
  58
  59 enum ipl_method {
  60         IPL_METHOD_NONE,
  61         IPL_METHOD_CCW_CIO,
  62         IPL_METHOD_CCW_DIAG,
  63         IPL_METHOD_CCW_VM,
  64         IPL_METHOD_FCP_RO_DIAG,
  65         IPL_METHOD_FCP_RW_DIAG,
  66         IPL_METHOD_FCP_RO_VM,
  67 };
  68
  69 enum shutdown_action {
  70         SHUTDOWN_REIPL,
  71         SHUTDOWN_DUMP,
  72         SHUTDOWN_STOP,
  73 };
  74
  75 #define SHUTDOWN_REIPL_STR "reipl"
  76 #define SHUTDOWN_DUMP_STR  "dump"
  77 #define SHUTDOWN_STOP_STR  "stop"
  78
  79 static char *shutdown_action_str(enum shutdown_action action)
  80 {
  81         switch (action) {
  82         case SHUTDOWN_REIPL:
  83                 return SHUTDOWN_REIPL_STR;
  84         case SHUTDOWN_DUMP:
  85                 return SHUTDOWN_DUMP_STR;
  86         case SHUTDOWN_STOP:
  87                 return SHUTDOWN_STOP_STR;
  88         default:
  89                 BUG();
  90         }
  91 }
  92
  93 enum diag308_subcode  {
  94         DIAG308_IPL   = 3,
  95         DIAG308_DUMP  = 4,
  96         DIAG308_SET   = 5,
  97         DIAG308_STORE = 6,
  98 };
  99
 100 enum diag308_ipl_type {
 101         DIAG308_IPL_TYPE_FCP = 0,
 102         DIAG308_IPL_TYPE_CCW = 2,
 103 };
 104
 105 enum diag308_opt {
 106         DIAG308_IPL_OPT_IPL  = 0x10,
 107         DIAG308_IPL_OPT_DUMP = 0x20,
 108 };
 109
 110 enum diag308_rc {
 111         DIAG308_RC_OK = 1,
 112 };
 113
 114 static int diag308_set_works = 0;
 115
 116 static int reipl_capabilities = IPL_TYPE_UNKNOWN;
 117 static enum ipl_type reipl_type = IPL_TYPE_UNKNOWN;
 118 static enum ipl_method reipl_method = IPL_METHOD_NONE;
 119 static struct ipl_parameter_block *reipl_block_fcp;
 120 static struct ipl_parameter_block *reipl_block_ccw;
 121
 122 static int dump_capabilities = IPL_TYPE_NONE;
 123 static enum ipl_type dump_type = IPL_TYPE_NONE;
 124 static enum ipl_method dump_method = IPL_METHOD_NONE;
 125 static struct ipl_parameter_block *dump_block_fcp;
 126 static struct ipl_parameter_block *dump_block_ccw;
 127
 128 static enum shutdown_action on_panic_action = SHUTDOWN_STOP;
 129
 130 static int diag308(unsigned long subcode, void *addr)
 131 {
 132         register unsigned long _addr asm("0") = (unsigned long) addr;
 133         register unsigned long _rc asm("1") = 0;
 134
 135         asm volatile(
 136                 "       diag    %0,%2,0x308\n"
 137                 "0:\n"
 138                 EX_TABLE(0b,0b)
 139                 : "+d" (_addr), "+d" (_rc)
 140                 : "d" (subcode) : "cc", "memory");
 141         return _rc;
 142 }
 143
 144 /* SYSFS */
 145
 146 #define DEFINE_IPL_ATTR_RO(_prefix, _name, _format, _value)             \
 147 static ssize_t sys_##_prefix##_##_name##_show(struct subsystem *subsys, \
 148                 char *page)                                             \
 149 {                                                                       \
 150         return sprintf(page, _format, _value);                          \
 151 }                                                                       \
 152 static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
 153         __ATTR(_name, S_IRUGO, sys_##_prefix##_##_name##_show, NULL);
 154
 155 #define DEFINE_IPL_ATTR_RW(_prefix, _name, _fmt_out, _fmt_in, _value)   \
 156 static ssize_t sys_##_prefix##_##_name##_show(struct subsystem *subsys, \
 157                 char *page)                                             \
 158 {                                                                       \
 159         return sprintf(page, _fmt_out,                                  \
 160                         (unsigned long long) _value);                   \
 161 }                                                                       \
 162 static ssize_t sys_##_prefix##_##_name##_store(struct subsystem *subsys,\
 163                 const char *buf, size_t len)                            \
 164 {                                                                       \
 165         unsigned long long value;                                       \
 166         if (sscanf(buf, _fmt_in, &value) != 1)                          \
 167                 return -EINVAL;                                         \
 168         _value = value;                                                 \
 169         return len;                                                     \
 170 }                                                                       \
 171 static struct subsys_attribute sys_##_prefix##_##_name##_attr =         \
 172         __ATTR(_name,(S_IRUGO | S_IWUSR),                               \
 173                         sys_##_prefix##_##_name##_show,                 \
 174                         sys_##_prefix##_##_name##_store);
 175
 176 static void make_attrs_ro(struct attribute **attrs)
 177 {
 178         while (*attrs) {
 179                 (*attrs)->mode = S_IRUGO;
 180                 attrs++;
 181         }
 182 }
 183
 184 /*
 185  * ipl section
 186  */
 187
 188 static enum ipl_type ipl_get_type(void)
 189 {
 190         struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
 191
 192         if (!(ipl_flags & IPL_DEVNO_VALID))
 193                 return IPL_TYPE_UNKNOWN;
 194         if (!(ipl_flags & IPL_PARMBLOCK_VALID))
 195                 return IPL_TYPE_CCW;
 196         if (ipl->hdr.version > IPL_MAX_SUPPORTED_VERSION)
 197                 return IPL_TYPE_UNKNOWN;
 198         if (ipl->hdr.pbt != DIAG308_IPL_TYPE_FCP)
 199                 return IPL_TYPE_UNKNOWN;
 200         return IPL_TYPE_FCP;
 201 }
 202
 203 static ssize_t ipl_type_show(struct subsystem *subsys, char *page)
 204 {
 205         return sprintf(page, "%s\n", ipl_type_str(ipl_get_type()));
 206 }
 207
 208 static struct subsys_attribute sys_ipl_type_attr = __ATTR_RO(ipl_type);
 209
 210 static ssize_t sys_ipl_device_show(struct subsystem *subsys, char *page)
 211 {
 212         struct ipl_parameter_block *ipl = IPL_PARMBLOCK_START;
 213
 214         switch (ipl_get_type()) {
 215         case IPL_TYPE_CCW:
 216                 return sprintf(page, "0.0.%04x\n", ipl_devno);
 217         case IPL_TYPE_FCP:
 218                 return sprintf(page, "0.0.%04x\n", ipl->ipl_info.fcp.devno);
 219         default:
 220                 return 0;
 221         }
 222 }
 223
 224 static struct subsys_attribute sys_ipl_device_attr =
 225         __ATTR(device, S_IRUGO, sys_ipl_device_show, NULL);
 226
 227 static ssize_t ipl_parameter_read(struct kobject *kobj, char *buf, loff_t off,
 228                                   size_t count)
 229 {
 230         unsigned int size = IPL_PARMBLOCK_SIZE;
 231
 232         if (off > size)
 233                 return 0;
 234         if (off + count > size)
 235                 count = size - off;
 236         memcpy(buf, (void *)IPL_PARMBLOCK_START + off, count);
 237         return count;
 238 }
 239
 240 static struct bin_attribute ipl_parameter_attr = {
 241         .attr = {
 242                 .name = "binary_parameter",
 243                 .mode = S_IRUGO,
 244                 .owner = THIS_MODULE,
 245         },
 246         .size = PAGE_SIZE,
 247         .read = &ipl_parameter_read,
 248 };
 249
 250 static ssize_t ipl_scp_data_read(struct kobject *kobj, char *buf, loff_t off,
 251         size_t count)
 252 {
 253         unsigned int size = IPL_PARMBLOCK_START->ipl_info.fcp.scp_data_len;
 254         void *scp_data = &IPL_PARMBLOCK_START->ipl_info.fcp.scp_data;
 255
 256         if (off > size)
 257                 return 0;
 258         if (off + count > size)
 259                 count = size - off;
 260         memcpy(buf, scp_data + off, count);
 261         return count;
 262 }
 263
 264 static struct bin_attribute ipl_scp_data_attr = {
 265         .attr = {
 266                 .name = "scp_data",
 267                 .mode = S_IRUGO,
 268                 .owner = THIS_MODULE,
 269         },
 270         .size = PAGE_SIZE,
 271         .read = &ipl_scp_data_read,
 272 };
 273
 274 /* FCP ipl device attributes */
 275
 276 DEFINE_IPL_ATTR_RO(ipl_fcp, wwpn, "0x%016llx\n", (unsigned long long)
 277                    IPL_PARMBLOCK_START->ipl_info.fcp.wwpn);
 278 DEFINE_IPL_ATTR_RO(ipl_fcp, lun, "0x%016llx\n", (unsigned long long)
 279                    IPL_PARMBLOCK_START->ipl_info.fcp.lun);
 280 DEFINE_IPL_ATTR_RO(ipl_fcp, bootprog, "%lld\n", (unsigned long long)
 281                    IPL_PARMBLOCK_START->ipl_info.fcp.bootprog);
 282 DEFINE_IPL_ATTR_RO(ipl_fcp, br_lba, "%lld\n", (unsigned long long)
 283                    IPL_PARMBLOCK_START->ipl_info.fcp.br_lba);
 284
 285 static struct attribute *ipl_fcp_attrs[] = {
 286         &sys_ipl_type_attr.attr,
 287         &sys_ipl_device_attr.attr,
 288         &sys_ipl_fcp_wwpn_attr.attr,
 289         &sys_ipl_fcp_lun_attr.attr,
 290         &sys_ipl_fcp_bootprog_attr.attr,
 291         &sys_ipl_fcp_br_lba_attr.attr,
 292         NULL,
 293 };
 294
 295 static struct attribute_group ipl_fcp_attr_group = {
 296         .attrs = ipl_fcp_attrs,
 297 };
 298
 299 /* CCW ipl device attributes */
 300
 301 static ssize_t ipl_ccw_loadparm_show(struct subsystem *subsys, char *page)
 302 {
 303         char loadparm[LOADPARM_LEN + 1] = {};
 304
 305         if (!SCCB_VALID)
 306                 return sprintf(page, "#unknown#\n");
 307         memcpy(loadparm, SCCB_LOADPARM, LOADPARM_LEN);
 308         EBCASC(loadparm, LOADPARM_LEN);
 309         strstrip(loadparm);
 310         return sprintf(page, "%s\n", loadparm);
 311 }
 312
 313 static struct subsys_attribute sys_ipl_ccw_loadparm_attr =
 314         __ATTR(loadparm, 0444, ipl_ccw_loadparm_show, NULL);
 315
 316 static struct attribute *ipl_ccw_attrs[] = {
 317         &sys_ipl_type_attr.attr,
 318         &sys_ipl_device_attr.attr,
 319         &sys_ipl_ccw_loadparm_attr.attr,
 320         NULL,
 321 };
 322
 323 static struct attribute_group ipl_ccw_attr_group = {
 324         .attrs = ipl_ccw_attrs,
 325 };
 326
 327 /* UNKNOWN ipl device attributes */
 328
 329 static struct attribute *ipl_unknown_attrs[] = {
 330         &sys_ipl_type_attr.attr,
 331         NULL,
 332 };
 333
 334 static struct attribute_group ipl_unknown_attr_group = {
 335         .attrs = ipl_unknown_attrs,
 336 };
 337
 338 static decl_subsys(ipl, NULL, NULL);
 339
 340 /*
 341  * reipl section
 342  */
 343
 344 /* FCP reipl device attributes */
 345
 346 DEFINE_IPL_ATTR_RW(reipl_fcp, wwpn, "0x%016llx\n", "%016llx\n",
 347                    reipl_block_fcp->ipl_info.fcp.wwpn);
 348 DEFINE_IPL_ATTR_RW(reipl_fcp, lun, "0x%016llx\n", "%016llx\n",
 349                    reipl_block_fcp->ipl_info.fcp.lun);
 350 DEFINE_IPL_ATTR_RW(reipl_fcp, bootprog, "%lld\n", "%lld\n",
 351                    reipl_block_fcp->ipl_info.fcp.bootprog);
 352 DEFINE_IPL_ATTR_RW(reipl_fcp, br_lba, "%lld\n", "%lld\n",
 353                    reipl_block_fcp->ipl_info.fcp.br_lba);
 354 DEFINE_IPL_ATTR_RW(reipl_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
 355                    reipl_block_fcp->ipl_info.fcp.devno);
 356
 357 static struct attribute *reipl_fcp_attrs[] = {
 358         &sys_reipl_fcp_device_attr.attr,
 359         &sys_reipl_fcp_wwpn_attr.attr,
 360         &sys_reipl_fcp_lun_attr.attr,
 361         &sys_reipl_fcp_bootprog_attr.attr,
 362         &sys_reipl_fcp_br_lba_attr.attr,
 363         NULL,
 364 };
 365
 366 static struct attribute_group reipl_fcp_attr_group = {
 367         .name  = IPL_FCP_STR,
 368         .attrs = reipl_fcp_attrs,
 369 };
 370
 371 /* CCW reipl device attributes */
 372
 373 DEFINE_IPL_ATTR_RW(reipl_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
 374         reipl_block_ccw->ipl_info.ccw.devno);
 375
 376 static void reipl_get_ascii_loadparm(char *loadparm)
 377 {
 378         memcpy(loadparm, &reipl_block_ccw->ipl_info.ccw.load_param,
 379                LOADPARM_LEN);
 380         EBCASC(loadparm, LOADPARM_LEN);
 381         loadparm[LOADPARM_LEN] = 0;
 382         strstrip(loadparm);
 383 }
 384
 385 static ssize_t reipl_ccw_loadparm_show(struct subsystem *subsys, char *page)
 386 {
 387         char buf[LOADPARM_LEN + 1];
 388
 389         reipl_get_ascii_loadparm(buf);
 390         return sprintf(page, "%s\n", buf);
 391 }
 392
 393 static ssize_t reipl_ccw_loadparm_store(struct subsystem *subsys,
 394                                         const char *buf, size_t len)
 395 {
 396         int i, lp_len;
 397
 398         /* ignore trailing newline */
 399         lp_len = len;
 400         if ((len > 0) && (buf[len - 1] == '\n'))
 401                 lp_len--;
 402         /* loadparm can have max 8 characters and must not start with a blank */
 403         if ((lp_len > LOADPARM_LEN) || ((lp_len > 0) && (buf[0] == ' ')))
 404                 return -EINVAL;
 405         /* loadparm can only contain "a-z,A-Z,0-9,SP,." */
 406         for (i = 0; i < lp_len; i++) {
 407                 if (isalpha(buf[i]) || isdigit(buf[i]) || (buf[i] == ' ') ||
 408                     (buf[i] == '.'))
 409                         continue;
 410                 return -EINVAL;
 411         }
 412         /* initialize loadparm with blanks */
 413         memset(&reipl_block_ccw->ipl_info.ccw.load_param, ' ', LOADPARM_LEN);
 414         /* copy and convert to ebcdic */
 415         memcpy(&reipl_block_ccw->ipl_info.ccw.load_param, buf, lp_len);
 416         ASCEBC(reipl_block_ccw->ipl_info.ccw.load_param, LOADPARM_LEN);
 417         return len;
 418 }
 419
 420 static struct subsys_attribute sys_reipl_ccw_loadparm_attr =
 421         __ATTR(loadparm, 0644, reipl_ccw_loadparm_show,
 422                reipl_ccw_loadparm_store);
 423
 424 static struct attribute *reipl_ccw_attrs[] = {
 425         &sys_reipl_ccw_device_attr.attr,
 426         &sys_reipl_ccw_loadparm_attr.attr,
 427         NULL,
 428 };
 429
 430 static struct attribute_group reipl_ccw_attr_group = {
 431         .name  = IPL_CCW_STR,
 432         .attrs = reipl_ccw_attrs,
 433 };
 434
 435 /* reipl type */
 436
 437 static int reipl_set_type(enum ipl_type type)
 438 {
 439         if (!(reipl_capabilities & type))
 440                 return -EINVAL;
 441
 442         switch(type) {
 443         case IPL_TYPE_CCW:
 444                 if (MACHINE_IS_VM)
 445                         reipl_method = IPL_METHOD_CCW_VM;
 446                 else
 447                         reipl_method = IPL_METHOD_CCW_CIO;
 448                 break;
 449         case IPL_TYPE_FCP:
 450                 if (diag308_set_works)
 451                         reipl_method = IPL_METHOD_FCP_RW_DIAG;
 452                 else if (MACHINE_IS_VM)
 453                         reipl_method = IPL_METHOD_FCP_RO_VM;
 454                 else
 455                         reipl_method = IPL_METHOD_FCP_RO_DIAG;
 456                 break;
 457         default:
 458                 reipl_method = IPL_METHOD_NONE;
 459         }
 460         reipl_type = type;
 461         return 0;
 462 }
 463
 464 static ssize_t reipl_type_show(struct subsystem *subsys, char *page)
 465 {
 466         return sprintf(page, "%s\n", ipl_type_str(reipl_type));
 467 }
 468
 469 static ssize_t reipl_type_store(struct subsystem *subsys, const char *buf,
 470                                 size_t len)
 471 {
 472         int rc = -EINVAL;
 473
 474         if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
 475                 rc = reipl_set_type(IPL_TYPE_CCW);
 476         else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
 477                 rc = reipl_set_type(IPL_TYPE_FCP);
 478         return (rc != 0) ? rc : len;
 479 }
 480
 481 static struct subsys_attribute reipl_type_attr =
 482                 __ATTR(reipl_type, 0644, reipl_type_show, reipl_type_store);
 483
 484 static decl_subsys(reipl, NULL, NULL);
 485
 486 /*
 487  * dump section
 488  */
 489
 490 /* FCP dump device attributes */
 491
 492 DEFINE_IPL_ATTR_RW(dump_fcp, wwpn, "0x%016llx\n", "%016llx\n",
 493                    dump_block_fcp->ipl_info.fcp.wwpn);
 494 DEFINE_IPL_ATTR_RW(dump_fcp, lun, "0x%016llx\n", "%016llx\n",
 495                    dump_block_fcp->ipl_info.fcp.lun);
 496 DEFINE_IPL_ATTR_RW(dump_fcp, bootprog, "%lld\n", "%lld\n",
 497                    dump_block_fcp->ipl_info.fcp.bootprog);
 498 DEFINE_IPL_ATTR_RW(dump_fcp, br_lba, "%lld\n", "%lld\n",
 499                    dump_block_fcp->ipl_info.fcp.br_lba);
 500 DEFINE_IPL_ATTR_RW(dump_fcp, device, "0.0.%04llx\n", "0.0.%llx\n",
 501                    dump_block_fcp->ipl_info.fcp.devno);
 502
 503 static struct attribute *dump_fcp_attrs[] = {
 504         &sys_dump_fcp_device_attr.attr,
 505         &sys_dump_fcp_wwpn_attr.attr,
 506         &sys_dump_fcp_lun_attr.attr,
 507         &sys_dump_fcp_bootprog_attr.attr,
 508         &sys_dump_fcp_br_lba_attr.attr,
 509         NULL,
 510 };
 511
 512 static struct attribute_group dump_fcp_attr_group = {
 513         .name  = IPL_FCP_STR,
 514         .attrs = dump_fcp_attrs,
 515 };
 516
 517 /* CCW dump device attributes */
 518
 519 DEFINE_IPL_ATTR_RW(dump_ccw, device, "0.0.%04llx\n", "0.0.%llx\n",
 520                    dump_block_ccw->ipl_info.ccw.devno);
 521
 522 static struct attribute *dump_ccw_attrs[] = {
 523         &sys_dump_ccw_device_attr.attr,
 524         NULL,
 525 };
 526
 527 static struct attribute_group dump_ccw_attr_group = {
 528         .name  = IPL_CCW_STR,
 529         .attrs = dump_ccw_attrs,
 530 };
 531
 532 /* dump type */
 533
 534 static int dump_set_type(enum ipl_type type)
 535 {
 536         if (!(dump_capabilities & type))
 537                 return -EINVAL;
 538         switch(type) {
 539         case IPL_TYPE_CCW:
 540                 if (MACHINE_IS_VM)
 541                         dump_method = IPL_METHOD_CCW_VM;
 542                 else
 543                         dump_method = IPL_METHOD_CCW_CIO;
 544                 break;
 545         case IPL_TYPE_FCP:
 546                 dump_method = IPL_METHOD_FCP_RW_DIAG;
 547                 break;
 548         default:
 549                 dump_method = IPL_METHOD_NONE;
 550         }
 551         dump_type = type;
 552         return 0;
 553 }
 554
 555 static ssize_t dump_type_show(struct subsystem *subsys, char *page)
 556 {
 557         return sprintf(page, "%s\n", ipl_type_str(dump_type));
 558 }
 559
 560 static ssize_t dump_type_store(struct subsystem *subsys, const char *buf,
 561                                size_t len)
 562 {
 563         int rc = -EINVAL;
 564
 565         if (strncmp(buf, IPL_NONE_STR, strlen(IPL_NONE_STR)) == 0)
 566                 rc = dump_set_type(IPL_TYPE_NONE);
 567         else if (strncmp(buf, IPL_CCW_STR, strlen(IPL_CCW_STR)) == 0)
 568                 rc = dump_set_type(IPL_TYPE_CCW);
 569         else if (strncmp(buf, IPL_FCP_STR, strlen(IPL_FCP_STR)) == 0)
 570                 rc = dump_set_type(IPL_TYPE_FCP);
 571         return (rc != 0) ? rc : len;
 572 }
 573
 574 static struct subsys_attribute dump_type_attr =
 575                 __ATTR(dump_type, 0644, dump_type_show, dump_type_store);
 576
 577 static decl_subsys(dump, NULL, NULL);
 578
 579 /*
 580  * Shutdown actions section
 581  */
 582
 583 static decl_subsys(shutdown_actions, NULL, NULL);
 584
 585 /* on panic */
 586
 587 static ssize_t on_panic_show(struct subsystem *subsys, char *page)
 588 {
 589         return sprintf(page, "%s\n", shutdown_action_str(on_panic_action));
 590 }
 591
 592 static ssize_t on_panic_store(struct subsystem *subsys, const char *buf,
 593                               size_t len)
 594 {
 595         if (strncmp(buf, SHUTDOWN_REIPL_STR, strlen(SHUTDOWN_REIPL_STR)) == 0)
 596                 on_panic_action = SHUTDOWN_REIPL;
 597         else if (strncmp(buf, SHUTDOWN_DUMP_STR,
 598                          strlen(SHUTDOWN_DUMP_STR)) == 0)
 599                 on_panic_action = SHUTDOWN_DUMP;
 600         else if (strncmp(buf, SHUTDOWN_STOP_STR,
 601                          strlen(SHUTDOWN_STOP_STR)) == 0)
 602                 on_panic_action = SHUTDOWN_STOP;
 603         else
 604                 return -EINVAL;
 605
 606         return len;
 607 }
 608
 609 static struct subsys_attribute on_panic_attr =
 610                 __ATTR(on_panic, 0644, on_panic_show, on_panic_store);
 611
 612 static void print_fcp_block(struct ipl_parameter_block *fcp_block)
 613 {
 614         printk(KERN_EMERG "wwpn:      %016llx\n",
 615                 (unsigned long long)fcp_block->ipl_info.fcp.wwpn);
 616         printk(KERN_EMERG "lun:       %016llx\n",
 617                 (unsigned long long)fcp_block->ipl_info.fcp.lun);
 618         printk(KERN_EMERG "bootprog:  %lld\n",
 619                 (unsigned long long)fcp_block->ipl_info.fcp.bootprog);
 620         printk(KERN_EMERG "br_lba:    %lld\n",
 621                 (unsigned long long)fcp_block->ipl_info.fcp.br_lba);
 622         printk(KERN_EMERG "device:    %llx\n",
 623                 (unsigned long long)fcp_block->ipl_info.fcp.devno);
 624         printk(KERN_EMERG "opt:       %x\n", fcp_block->ipl_info.fcp.opt);
 625 }
 626
 627 void do_reipl(void)
 628 {
 629         struct ccw_dev_id devid;
 630         static char buf[100];
 631         char loadparm[LOADPARM_LEN + 1];
 632
 633         switch (reipl_type) {
 634         case IPL_TYPE_CCW:
 635                 reipl_get_ascii_loadparm(loadparm);
 636                 printk(KERN_EMERG "reboot on ccw device: 0.0.%04x\n",
 637                         reipl_block_ccw->ipl_info.ccw.devno);
 638                 printk(KERN_EMERG "loadparm = '%s'\n", loadparm);
 639                 break;
 640         case IPL_TYPE_FCP:
 641                 printk(KERN_EMERG "reboot on fcp device:\n");
 642                 print_fcp_block(reipl_block_fcp);
 643                 break;
 644         default:
 645                 break;
 646         }
 647
 648         switch (reipl_method) {
 649         case IPL_METHOD_CCW_CIO:
 650                 devid.devno = reipl_block_ccw->ipl_info.ccw.devno;
 651                 if (ipl_get_type() == IPL_TYPE_CCW && devid.devno == ipl_devno)
 652                         diag308(DIAG308_IPL, NULL);
 653                 devid.ssid  = 0;
 654                 reipl_ccw_dev(&devid);
 655                 break;
 656         case IPL_METHOD_CCW_VM:
 657                 if (strlen(loadparm) == 0)
 658                         sprintf(buf, "IPL %X",
 659                                 reipl_block_ccw->ipl_info.ccw.devno);
 660                 else
 661                         sprintf(buf, "IPL %X LOADPARM '%s'",
 662                                 reipl_block_ccw->ipl_info.ccw.devno, loadparm);
 663                 __cpcmd(buf, NULL, 0, NULL);
 664                 break;
 665         case IPL_METHOD_CCW_DIAG:
 666                 diag308(DIAG308_SET, reipl_block_ccw);
 667                 diag308(DIAG308_IPL, NULL);
 668                 break;
 669         case IPL_METHOD_FCP_RW_DIAG:
 670                 diag308(DIAG308_SET, reipl_block_fcp);
 671                 diag308(DIAG308_IPL, NULL);
 672                 break;
 673         case IPL_METHOD_FCP_RO_DIAG:
 674                 diag308(DIAG308_IPL, NULL);
 675                 break;
 676         case IPL_METHOD_FCP_RO_VM:
 677                 __cpcmd("IPL", NULL, 0, NULL);
 678                 break;
 679         case IPL_METHOD_NONE:
 680         default:
 681                 if (MACHINE_IS_VM)
 682                         __cpcmd("IPL", NULL, 0, NULL);
 683                 diag308(DIAG308_IPL, NULL);
 684                 break;
 685         }
 686         printk(KERN_EMERG "reboot failed!\n");
 687         signal_processor(smp_processor_id(), sigp_stop_and_store_status);
 688 }
 689
 690 static void do_dump(void)
 691 {
 692         struct ccw_dev_id devid;
 693         static char buf[100];
 694
 695         switch (dump_type) {
 696         case IPL_TYPE_CCW:
 697                 printk(KERN_EMERG "Automatic dump on ccw device: 0.0.%04x\n",
 698                        dump_block_ccw->ipl_info.ccw.devno);
 699                 break;
 700         case IPL_TYPE_FCP:
 701                 printk(KERN_EMERG "Automatic dump on fcp device:\n");
 702                 print_fcp_block(dump_block_fcp);
 703                 break;
 704         default:
 705                 return;
 706         }
 707
 708         switch (dump_method) {
 709         case IPL_METHOD_CCW_CIO:
 710                 smp_send_stop();
 711                 devid.devno = dump_block_ccw->ipl_info.ccw.devno;
 712                 devid.ssid  = 0;
 713                 reipl_ccw_dev(&devid);
 714                 break;
 715         case IPL_METHOD_CCW_VM:
 716                 smp_send_stop();
 717                 sprintf(buf, "STORE STATUS");
 718                 __cpcmd(buf, NULL, 0, NULL);
 719                 sprintf(buf, "IPL %X", dump_block_ccw->ipl_info.ccw.devno);
 720                 __cpcmd(buf, NULL, 0, NULL);
 721                 break;
 722         case IPL_METHOD_CCW_DIAG:
 723                 diag308(DIAG308_SET, dump_block_ccw);
 724                 diag308(DIAG308_DUMP, NULL);
 725                 break;
 726         case IPL_METHOD_FCP_RW_DIAG:
 727                 diag308(DIAG308_SET, dump_block_fcp);
 728                 diag308(DIAG308_DUMP, NULL);
 729                 break;
 730         case IPL_METHOD_NONE:
 731         default:
 732                 return;
 733         }
 734         printk(KERN_EMERG "Dump failed!\n");
 735 }
 736
 737 /* init functions */
 738
 739 static int __init ipl_register_fcp_files(void)
 740 {
 741         int rc;
 742
 743         rc = sysfs_create_group(&ipl_subsys.kset.kobj,
 744                                 &ipl_fcp_attr_group);
 745         if (rc)
 746                 goto out;
 747         rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
 748                                    &ipl_parameter_attr);
 749         if (rc)
 750                 goto out_ipl_parm;
 751         rc = sysfs_create_bin_file(&ipl_subsys.kset.kobj,
 752                                    &ipl_scp_data_attr);
 753         if (!rc)
 754                 goto out;
 755
 756         sysfs_remove_bin_file(&ipl_subsys.kset.kobj, &ipl_parameter_attr);
 757
 758 out_ipl_parm:
 759         sysfs_remove_group(&ipl_subsys.kset.kobj, &ipl_fcp_attr_group);
 760 out:
 761         return rc;
 762 }
 763
 764 static int __init ipl_init(void)
 765 {
 766         int rc;
 767
 768         rc = firmware_register(&ipl_subsys);
 769         if (rc)
 770                 return rc;
 771         switch (ipl_get_type()) {
 772         case IPL_TYPE_CCW:
 773                 rc = sysfs_create_group(&ipl_subsys.kset.kobj,
 774                                         &ipl_ccw_attr_group);
 775                 break;
 776         case IPL_TYPE_FCP:
 777                 rc = ipl_register_fcp_files();
 778                 break;
 779         default:
 780                 rc = sysfs_create_group(&ipl_subsys.kset.kobj,
 781                                         &ipl_unknown_attr_group);
 782                 break;
 783         }
 784         if (rc)
 785                 firmware_unregister(&ipl_subsys);
 786         return rc;
 787 }
 788
 789 static void __init reipl_probe(void)
 790 {
 791         void *buffer;
 792
 793         buffer = (void *) get_zeroed_page(GFP_KERNEL);
 794         if (!buffer)
 795                 return;
 796         if (diag308(DIAG308_STORE, buffer) == DIAG308_RC_OK)
 797                 diag308_set_works = 1;
 798         free_page((unsigned long)buffer);
 799 }
 800
 801 static int __init reipl_ccw_init(void)
 802 {
 803         int rc;
 804
 805         reipl_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
 806         if (!reipl_block_ccw)
 807                 return -ENOMEM;
 808         rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_ccw_attr_group);
 809         if (rc) {
 810                 free_page((unsigned long)reipl_block_ccw);
 811                 return rc;
 812         }
 813         reipl_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
 814         reipl_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
 815         reipl_block_ccw->hdr.blk0_len = sizeof(reipl_block_ccw->ipl_info.ccw);
 816         reipl_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
 817         /* check if read scp info worked and set loadparm */
 818         if (SCCB_VALID)
 819                 memcpy(reipl_block_ccw->ipl_info.ccw.load_param,
 820                        SCCB_LOADPARM, LOADPARM_LEN);
 821         else
 822                 /* read scp info failed: set empty loadparm (EBCDIC blanks) */
 823                 memset(reipl_block_ccw->ipl_info.ccw.load_param, 0x40,
 824                        LOADPARM_LEN);
 825         /* FIXME: check for diag308_set_works when enabling diag ccw reipl */
 826         if (!MACHINE_IS_VM)
 827                 sys_reipl_ccw_loadparm_attr.attr.mode = S_IRUGO;
 828         if (ipl_get_type() == IPL_TYPE_CCW)
 829                 reipl_block_ccw->ipl_info.ccw.devno = ipl_devno;
 830         reipl_capabilities |= IPL_TYPE_CCW;
 831         return 0;
 832 }
 833
 834 static int __init reipl_fcp_init(void)
 835 {
 836         int rc;
 837
 838         if ((!diag308_set_works) && (ipl_get_type() != IPL_TYPE_FCP))
 839                 return 0;
 840         if ((!diag308_set_works) && (ipl_get_type() == IPL_TYPE_FCP))
 841                 make_attrs_ro(reipl_fcp_attrs);
 842
 843         reipl_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
 844         if (!reipl_block_fcp)
 845                 return -ENOMEM;
 846         rc = sysfs_create_group(&reipl_subsys.kset.kobj, &reipl_fcp_attr_group);
 847         if (rc) {
 848                 free_page((unsigned long)reipl_block_fcp);
 849                 return rc;
 850         }
 851         if (ipl_get_type() == IPL_TYPE_FCP) {
 852                 memcpy(reipl_block_fcp, IPL_PARMBLOCK_START, PAGE_SIZE);
 853         } else {
 854                 reipl_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
 855                 reipl_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
 856                 reipl_block_fcp->hdr.blk0_len =
 857                         sizeof(reipl_block_fcp->ipl_info.fcp);
 858                 reipl_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
 859                 reipl_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_IPL;
 860         }
 861         reipl_capabilities |= IPL_TYPE_FCP;
 862         return 0;
 863 }
 864
 865 static int __init reipl_init(void)
 866 {
 867         int rc;
 868
 869         rc = firmware_register(&reipl_subsys);
 870         if (rc)
 871                 return rc;
 872         rc = subsys_create_file(&reipl_subsys, &reipl_type_attr);
 873         if (rc) {
 874                 firmware_unregister(&reipl_subsys);
 875                 return rc;
 876         }
 877         rc = reipl_ccw_init();
 878         if (rc)
 879                 return rc;
 880         rc = reipl_fcp_init();
 881         if (rc)
 882                 return rc;
 883         rc = reipl_set_type(ipl_get_type());
 884         if (rc)
 885                 return rc;
 886         return 0;
 887 }
 888
 889 static int __init dump_ccw_init(void)
 890 {
 891         int rc;
 892
 893         dump_block_ccw = (void *) get_zeroed_page(GFP_KERNEL);
 894         if (!dump_block_ccw)
 895                 return -ENOMEM;
 896         rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_ccw_attr_group);
 897         if (rc) {
 898                 free_page((unsigned long)dump_block_ccw);
 899                 return rc;
 900         }
 901         dump_block_ccw->hdr.len = IPL_PARM_BLK_CCW_LEN;
 902         dump_block_ccw->hdr.version = IPL_PARM_BLOCK_VERSION;
 903         dump_block_ccw->hdr.blk0_len = sizeof(reipl_block_ccw->ipl_info.ccw);
 904         dump_block_ccw->hdr.pbt = DIAG308_IPL_TYPE_CCW;
 905         dump_capabilities |= IPL_TYPE_CCW;
 906         return 0;
 907 }
 908
 909 static int __init dump_fcp_init(void)
 910 {
 911         int rc;
 912
 913         if(!(SCCB_FLAG & 0x2) || !SCCB_VALID)
 914                 return 0; /* LDIPL DUMP is not installed */
 915         if (!diag308_set_works)
 916                 return 0;
 917         dump_block_fcp = (void *) get_zeroed_page(GFP_KERNEL);
 918         if (!dump_block_fcp)
 919                 return -ENOMEM;
 920         rc = sysfs_create_group(&dump_subsys.kset.kobj, &dump_fcp_attr_group);
 921         if (rc) {
 922                 free_page((unsigned long)dump_block_fcp);
 923                 return rc;
 924         }
 925         dump_block_fcp->hdr.len = IPL_PARM_BLK_FCP_LEN;
 926         dump_block_fcp->hdr.version = IPL_PARM_BLOCK_VERSION;
 927         dump_block_fcp->hdr.blk0_len = sizeof(dump_block_fcp->ipl_info.fcp);
 928         dump_block_fcp->hdr.pbt = DIAG308_IPL_TYPE_FCP;
 929         dump_block_fcp->ipl_info.fcp.opt = DIAG308_IPL_OPT_DUMP;
 930         dump_capabilities |= IPL_TYPE_FCP;
 931         return 0;
 932 }
 933
 934 #define SHUTDOWN_ON_PANIC_PRIO 0
 935
 936 static int shutdown_on_panic_notify(struct notifier_block *self,
 937                                     unsigned long event, void *data)
 938 {
 939         if (on_panic_action == SHUTDOWN_DUMP)
 940                 do_dump();
 941         else if (on_panic_action == SHUTDOWN_REIPL)
 942                 do_reipl();
 943         return NOTIFY_OK;
 944 }
 945
 946 static struct notifier_block shutdown_on_panic_nb = {
 947         .notifier_call = shutdown_on_panic_notify,
 948         .priority = SHUTDOWN_ON_PANIC_PRIO
 949 };
 950
 951 static int __init dump_init(void)
 952 {
 953         int rc;
 954
 955         rc = firmware_register(&dump_subsys);
 956         if (rc)
 957                 return rc;
 958         rc = subsys_create_file(&dump_subsys, &dump_type_attr);
 959         if (rc) {
 960                 firmware_unregister(&dump_subsys);
 961                 return rc;
 962         }
 963         rc = dump_ccw_init();
 964         if (rc)
 965                 return rc;
 966         rc = dump_fcp_init();
 967         if (rc)
 968                 return rc;
 969         dump_set_type(IPL_TYPE_NONE);
 970         return 0;
 971 }
 972
 973 static int __init shutdown_actions_init(void)
 974 {
 975         int rc;
 976
 977         rc = firmware_register(&shutdown_actions_subsys);
 978         if (rc)
 979                 return rc;
 980         rc = subsys_create_file(&shutdown_actions_subsys, &on_panic_attr);
 981         if (rc) {
 982                 firmware_unregister(&shutdown_actions_subsys);
 983                 return rc;
 984         }
 985         atomic_notifier_chain_register(&panic_notifier_list,
 986                                        &shutdown_on_panic_nb);
 987         return 0;
 988 }
 989
 990 static int __init s390_ipl_init(void)
 991 {
 992         int rc;
 993
 994         reipl_probe();
 995         rc = ipl_init();
 996         if (rc)
 997                 return rc;
 998         rc = reipl_init();
 999         if (rc)
1000                 return rc;
1001         rc = dump_init();
1002         if (rc)
1003                 return rc;
1004         rc = shutdown_actions_init();
1005         if (rc)
1006                 return rc;
1007         return 0;
1008 }
1009
1010 __initcall(s390_ipl_init);
1011
1012 static LIST_HEAD(rcall);
1013 static DEFINE_MUTEX(rcall_mutex);
1014
1015 void register_reset_call(struct reset_call *reset)
1016 {
1017         mutex_lock(&rcall_mutex);
1018         list_add(&reset->list, &rcall);
1019         mutex_unlock(&rcall_mutex);
1020 }
1021 EXPORT_SYMBOL_GPL(register_reset_call);
1022
1023 void unregister_reset_call(struct reset_call *reset)
1024 {
1025         mutex_lock(&rcall_mutex);
1026         list_del(&reset->list);
1027         mutex_unlock(&rcall_mutex);
1028 }
1029 EXPORT_SYMBOL_GPL(unregister_reset_call);
1030
1031 static void do_reset_calls(void)
1032 {
1033         struct reset_call *reset;
1034
1035         list_for_each_entry(reset, &rcall, list)
1036                 reset->fn();
1037 }
1038
1039 extern void reset_mcck_handler(void);
1040
1041 void s390_reset_system(void)
1042 {
1043         struct _lowcore *lc;
1044
1045         /* Stack for interrupt/machine check handler */
1046         lc = (struct _lowcore *)(unsigned long) store_prefix();
1047         lc->panic_stack = S390_lowcore.panic_stack;
1048
1049         /* Disable prefixing */
1050         set_prefix(0);
1051
1052         /* Disable lowcore protection */
1053         __ctl_clear_bit(0,28);
1054
1055         /* Set new machine check handler */
1056         S390_lowcore.mcck_new_psw.mask = PSW_KERNEL_BITS & ~PSW_MASK_MCHECK;
1057         S390_lowcore.mcck_new_psw.addr =
1058                 PSW_ADDR_AMODE | (unsigned long) &reset_mcck_handler;
1059         do_reset_calls();
1060 }