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