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