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