1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "qemu/osdep.h"
16#include "qemu-common.h"
17#include "qemu/datadir.h"
18#include "qapi/error.h"
19#include "sysemu/reset.h"
20#include "sysemu/runstate.h"
21#include "sysemu/tcg.h"
22#include "elf.h"
23#include "hw/loader.h"
24#include "hw/qdev-properties.h"
25#include "hw/boards.h"
26#include "hw/s390x/virtio-ccw.h"
27#include "hw/s390x/vfio-ccw.h"
28#include "hw/s390x/css.h"
29#include "hw/s390x/ebcdic.h"
30#include "hw/s390x/pv.h"
31#include "ipl.h"
32#include "qemu/error-report.h"
33#include "qemu/config-file.h"
34#include "qemu/cutils.h"
35#include "qemu/option.h"
36#include "exec/exec-all.h"
37
38#define KERN_IMAGE_START 0x010000UL
39#define LINUX_MAGIC_ADDR 0x010008UL
40#define KERN_PARM_AREA_SIZE_ADDR 0x010430UL
41#define KERN_PARM_AREA 0x010480UL
42#define LEGACY_KERN_PARM_AREA_SIZE 0x000380UL
43#define INITRD_START 0x800000UL
44#define INITRD_PARM_START 0x010408UL
45#define PARMFILE_START 0x001000UL
46#define ZIPL_IMAGE_START 0x009000UL
47#define IPL_PSW_MASK (PSW_MASK_32 | PSW_MASK_64)
48
49static bool iplb_extended_needed(void *opaque)
50{
51 S390IPLState *ipl = S390_IPL(object_resolve_path(TYPE_S390_IPL, NULL));
52
53 return ipl->iplbext_migration;
54}
55
56static const VMStateDescription vmstate_iplb_extended = {
57 .name = "ipl/iplb_extended",
58 .version_id = 0,
59 .minimum_version_id = 0,
60 .needed = iplb_extended_needed,
61 .fields = (VMStateField[]) {
62 VMSTATE_UINT8_ARRAY(reserved_ext, IplParameterBlock, 4096 - 200),
63 VMSTATE_END_OF_LIST()
64 }
65};
66
67static const VMStateDescription vmstate_iplb = {
68 .name = "ipl/iplb",
69 .version_id = 0,
70 .minimum_version_id = 0,
71 .fields = (VMStateField[]) {
72 VMSTATE_UINT8_ARRAY(reserved1, IplParameterBlock, 110),
73 VMSTATE_UINT16(devno, IplParameterBlock),
74 VMSTATE_UINT8_ARRAY(reserved2, IplParameterBlock, 88),
75 VMSTATE_END_OF_LIST()
76 },
77 .subsections = (const VMStateDescription*[]) {
78 &vmstate_iplb_extended,
79 NULL
80 }
81};
82
83static const VMStateDescription vmstate_ipl = {
84 .name = "ipl",
85 .version_id = 0,
86 .minimum_version_id = 0,
87 .fields = (VMStateField[]) {
88 VMSTATE_UINT64(compat_start_addr, S390IPLState),
89 VMSTATE_UINT64(compat_bios_start_addr, S390IPLState),
90 VMSTATE_STRUCT(iplb, S390IPLState, 0, vmstate_iplb, IplParameterBlock),
91 VMSTATE_BOOL(iplb_valid, S390IPLState),
92 VMSTATE_UINT8(cssid, S390IPLState),
93 VMSTATE_UINT8(ssid, S390IPLState),
94 VMSTATE_UINT16(devno, S390IPLState),
95 VMSTATE_END_OF_LIST()
96 }
97};
98
99static S390IPLState *get_ipl_device(void)
100{
101 return S390_IPL(object_resolve_path_type("", TYPE_S390_IPL, NULL));
102}
103
104static uint64_t bios_translate_addr(void *opaque, uint64_t srcaddr)
105{
106 uint64_t dstaddr = *(uint64_t *) opaque;
107
108
109
110
111 return srcaddr + dstaddr;
112}
113
114static uint64_t get_max_kernel_cmdline_size(void)
115{
116 uint64_t *size_ptr = rom_ptr(KERN_PARM_AREA_SIZE_ADDR, sizeof(*size_ptr));
117
118 if (size_ptr) {
119 uint64_t size;
120
121 size = be64_to_cpu(*size_ptr);
122 if (size) {
123 return size;
124 }
125 }
126 return LEGACY_KERN_PARM_AREA_SIZE;
127}
128
129static void s390_ipl_realize(DeviceState *dev, Error **errp)
130{
131 MachineState *ms = MACHINE(qdev_get_machine());
132 S390IPLState *ipl = S390_IPL(dev);
133 uint32_t *ipl_psw;
134 uint64_t pentry;
135 char *magic;
136 int kernel_size;
137
138 int bios_size;
139 char *bios_filename;
140
141
142
143
144
145 if (!ipl->kernel || ipl->enforce_bios) {
146 uint64_t fwbase = (MIN(ms->ram_size, 0x80000000U) - 0x200000) & ~0xffffUL;
147
148 bios_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, ipl->firmware);
149 if (bios_filename == NULL) {
150 error_setg(errp, "could not find stage1 bootloader");
151 return;
152 }
153
154 bios_size = load_elf(bios_filename, NULL,
155 bios_translate_addr, &fwbase,
156 &ipl->bios_start_addr, NULL, NULL, NULL, 1,
157 EM_S390, 0, 0);
158 if (bios_size > 0) {
159
160 ipl->bios_start_addr += fwbase;
161 } else {
162
163 bios_size = load_image_targphys(bios_filename, ZIPL_IMAGE_START,
164 4096);
165 ipl->bios_start_addr = ZIPL_IMAGE_START;
166 }
167 g_free(bios_filename);
168
169 if (bios_size == -1) {
170 error_setg(errp, "could not load bootloader '%s'", ipl->firmware);
171 return;
172 }
173
174
175 ipl->start_addr = ipl->bios_start_addr;
176 }
177
178 if (ipl->kernel) {
179 kernel_size = load_elf(ipl->kernel, NULL, NULL, NULL,
180 &pentry, NULL,
181 NULL, NULL, 1, EM_S390, 0, 0);
182 if (kernel_size < 0) {
183 kernel_size = load_image_targphys(ipl->kernel, 0, ms->ram_size);
184 if (kernel_size < 0) {
185 error_setg(errp, "could not load kernel '%s'", ipl->kernel);
186 return;
187 }
188
189 magic = rom_ptr(LINUX_MAGIC_ADDR, 6);
190 if (magic && !memcmp(magic, "S390EP", 6)) {
191 pentry = KERN_IMAGE_START;
192 } else {
193
194 ipl_psw = rom_ptr(4, 4);
195 if (ipl_psw) {
196 pentry = be32_to_cpu(*ipl_psw) & PSW_MASK_SHORT_ADDR;
197 } else {
198 error_setg(errp, "Could not get IPL PSW");
199 return;
200 }
201 }
202 }
203
204
205
206
207
208
209 if (pentry == KERN_IMAGE_START || pentry == 0x800) {
210 size_t cmdline_size = strlen(ipl->cmdline) + 1;
211 char *parm_area = rom_ptr(KERN_PARM_AREA, cmdline_size);
212
213 ipl->start_addr = KERN_IMAGE_START;
214
215 if (parm_area) {
216 uint64_t max_cmdline_size = get_max_kernel_cmdline_size();
217
218 if (cmdline_size > max_cmdline_size) {
219 error_setg(errp,
220 "kernel command line exceeds maximum size:"
221 " %zu > %" PRIu64,
222 cmdline_size, max_cmdline_size);
223 return;
224 }
225
226 strcpy(parm_area, ipl->cmdline);
227 }
228 } else {
229 ipl->start_addr = pentry;
230 }
231
232 if (ipl->initrd) {
233 ram_addr_t initrd_offset;
234 int initrd_size;
235 uint64_t *romptr;
236
237 initrd_offset = INITRD_START;
238 while (kernel_size + 0x100000 > initrd_offset) {
239 initrd_offset += 0x100000;
240 }
241 initrd_size = load_image_targphys(ipl->initrd, initrd_offset,
242 ms->ram_size - initrd_offset);
243 if (initrd_size == -1) {
244 error_setg(errp, "could not load initrd '%s'", ipl->initrd);
245 return;
246 }
247
248
249
250
251
252 romptr = rom_ptr(INITRD_PARM_START, 16);
253 if (romptr) {
254 stq_p(romptr, initrd_offset);
255 stq_p(romptr + 1, initrd_size);
256 }
257 }
258 }
259
260
261
262
263
264 ipl->compat_start_addr = ipl->start_addr;
265 ipl->compat_bios_start_addr = ipl->bios_start_addr;
266
267
268
269
270
271
272
273
274 qemu_register_reset(resettable_cold_reset_fn, dev);
275}
276
277static Property s390_ipl_properties[] = {
278 DEFINE_PROP_STRING("kernel", S390IPLState, kernel),
279 DEFINE_PROP_STRING("initrd", S390IPLState, initrd),
280 DEFINE_PROP_STRING("cmdline", S390IPLState, cmdline),
281 DEFINE_PROP_STRING("firmware", S390IPLState, firmware),
282 DEFINE_PROP_STRING("netboot_fw", S390IPLState, netboot_fw),
283 DEFINE_PROP_BOOL("enforce_bios", S390IPLState, enforce_bios, false),
284 DEFINE_PROP_BOOL("iplbext_migration", S390IPLState, iplbext_migration,
285 true),
286 DEFINE_PROP_END_OF_LIST(),
287};
288
289static void s390_ipl_set_boot_menu(S390IPLState *ipl)
290{
291 QemuOptsList *plist = qemu_find_opts("boot-opts");
292 QemuOpts *opts = QTAILQ_FIRST(&plist->head);
293 const char *tmp;
294 unsigned long splash_time = 0;
295
296 if (!get_boot_device(0)) {
297 if (boot_menu) {
298 error_report("boot menu requires a bootindex to be specified for "
299 "the IPL device");
300 }
301 return;
302 }
303
304 switch (ipl->iplb.pbt) {
305 case S390_IPL_TYPE_CCW:
306
307 if (!qemu_opt_get(opts, "menu")) {
308 ipl->qipl.qipl_flags |= QIPL_FLAG_BM_OPTS_ZIPL;
309 return;
310 }
311 break;
312 case S390_IPL_TYPE_QEMU_SCSI:
313 break;
314 default:
315 if (boot_menu) {
316 error_report("boot menu is not supported for this device type");
317 }
318 return;
319 }
320
321 if (!boot_menu) {
322 return;
323 }
324
325 ipl->qipl.qipl_flags |= QIPL_FLAG_BM_OPTS_CMD;
326
327 tmp = qemu_opt_get(opts, "splash-time");
328
329 if (tmp && qemu_strtoul(tmp, NULL, 10, &splash_time)) {
330 error_report("splash-time is invalid, forcing it to 0");
331 ipl->qipl.boot_menu_timeout = 0;
332 return;
333 }
334
335 if (splash_time > 0xffffffff) {
336 error_report("splash-time is too large, forcing it to max value");
337 ipl->qipl.boot_menu_timeout = 0xffffffff;
338 return;
339 }
340
341 ipl->qipl.boot_menu_timeout = cpu_to_be32(splash_time);
342}
343
344#define CCW_DEVTYPE_NONE 0x00
345#define CCW_DEVTYPE_VIRTIO 0x01
346#define CCW_DEVTYPE_VIRTIO_NET 0x02
347#define CCW_DEVTYPE_SCSI 0x03
348#define CCW_DEVTYPE_VFIO 0x04
349
350static CcwDevice *s390_get_ccw_device(DeviceState *dev_st, int *devtype)
351{
352 CcwDevice *ccw_dev = NULL;
353 int tmp_dt = CCW_DEVTYPE_NONE;
354
355 if (dev_st) {
356 VirtIONet *virtio_net_dev = (VirtIONet *)
357 object_dynamic_cast(OBJECT(dev_st), TYPE_VIRTIO_NET);
358 VirtioCcwDevice *virtio_ccw_dev = (VirtioCcwDevice *)
359 object_dynamic_cast(OBJECT(qdev_get_parent_bus(dev_st)->parent),
360 TYPE_VIRTIO_CCW_DEVICE);
361 VFIOCCWDevice *vfio_ccw_dev = (VFIOCCWDevice *)
362 object_dynamic_cast(OBJECT(dev_st), TYPE_VFIO_CCW);
363
364 if (virtio_ccw_dev) {
365 ccw_dev = CCW_DEVICE(virtio_ccw_dev);
366 if (virtio_net_dev) {
367 tmp_dt = CCW_DEVTYPE_VIRTIO_NET;
368 } else {
369 tmp_dt = CCW_DEVTYPE_VIRTIO;
370 }
371 } else if (vfio_ccw_dev) {
372 ccw_dev = CCW_DEVICE(vfio_ccw_dev);
373 tmp_dt = CCW_DEVTYPE_VFIO;
374 } else {
375 SCSIDevice *sd = (SCSIDevice *)
376 object_dynamic_cast(OBJECT(dev_st),
377 TYPE_SCSI_DEVICE);
378 if (sd) {
379 SCSIBus *bus = scsi_bus_from_device(sd);
380 VirtIOSCSI *vdev = container_of(bus, VirtIOSCSI, bus);
381 VirtIOSCSICcw *scsi_ccw = container_of(vdev, VirtIOSCSICcw,
382 vdev);
383
384 ccw_dev = (CcwDevice *)object_dynamic_cast(OBJECT(scsi_ccw),
385 TYPE_CCW_DEVICE);
386 tmp_dt = CCW_DEVTYPE_SCSI;
387 }
388 }
389 }
390 if (devtype) {
391 *devtype = tmp_dt;
392 }
393 return ccw_dev;
394}
395
396static bool s390_gen_initial_iplb(S390IPLState *ipl)
397{
398 DeviceState *dev_st;
399 CcwDevice *ccw_dev = NULL;
400 SCSIDevice *sd;
401 int devtype;
402
403 dev_st = get_boot_device(0);
404 if (dev_st) {
405 ccw_dev = s390_get_ccw_device(dev_st, &devtype);
406 }
407
408
409
410
411 if (ccw_dev) {
412 switch (devtype) {
413 case CCW_DEVTYPE_SCSI:
414 sd = SCSI_DEVICE(dev_st);
415 ipl->iplb.len = cpu_to_be32(S390_IPLB_MIN_QEMU_SCSI_LEN);
416 ipl->iplb.blk0_len =
417 cpu_to_be32(S390_IPLB_MIN_QEMU_SCSI_LEN - S390_IPLB_HEADER_LEN);
418 ipl->iplb.pbt = S390_IPL_TYPE_QEMU_SCSI;
419 ipl->iplb.scsi.lun = cpu_to_be32(sd->lun);
420 ipl->iplb.scsi.target = cpu_to_be16(sd->id);
421 ipl->iplb.scsi.channel = cpu_to_be16(sd->channel);
422 ipl->iplb.scsi.devno = cpu_to_be16(ccw_dev->sch->devno);
423 ipl->iplb.scsi.ssid = ccw_dev->sch->ssid & 3;
424 break;
425 case CCW_DEVTYPE_VFIO:
426 ipl->iplb.len = cpu_to_be32(S390_IPLB_MIN_CCW_LEN);
427 ipl->iplb.pbt = S390_IPL_TYPE_CCW;
428 ipl->iplb.ccw.devno = cpu_to_be16(ccw_dev->sch->devno);
429 ipl->iplb.ccw.ssid = ccw_dev->sch->ssid & 3;
430 break;
431 case CCW_DEVTYPE_VIRTIO_NET:
432 ipl->netboot = true;
433
434 case CCW_DEVTYPE_VIRTIO:
435 ipl->iplb.len = cpu_to_be32(S390_IPLB_MIN_CCW_LEN);
436 ipl->iplb.blk0_len =
437 cpu_to_be32(S390_IPLB_MIN_CCW_LEN - S390_IPLB_HEADER_LEN);
438 ipl->iplb.pbt = S390_IPL_TYPE_CCW;
439 ipl->iplb.ccw.devno = cpu_to_be16(ccw_dev->sch->devno);
440 ipl->iplb.ccw.ssid = ccw_dev->sch->ssid & 3;
441 break;
442 }
443
444 if (!s390_ipl_set_loadparm(ipl->iplb.loadparm)) {
445 ipl->iplb.flags |= DIAG308_FLAGS_LP_VALID;
446 }
447
448 return true;
449 }
450
451 return false;
452}
453
454int s390_ipl_set_loadparm(uint8_t *loadparm)
455{
456 MachineState *machine = MACHINE(qdev_get_machine());
457 char *lp = object_property_get_str(OBJECT(machine), "loadparm", NULL);
458
459 if (lp) {
460 int i;
461
462
463 for (i = 0; i < 8 && lp[i]; i++) {
464 loadparm[i] = ascii2ebcdic[(uint8_t) lp[i]];
465 }
466
467 if (i < 8) {
468 memset(loadparm + i, 0x40, 8 - i);
469 }
470
471 g_free(lp);
472 return 0;
473 }
474
475 return -1;
476}
477
478static int load_netboot_image(Error **errp)
479{
480 MachineState *ms = MACHINE(qdev_get_machine());
481 S390IPLState *ipl = get_ipl_device();
482 char *netboot_filename;
483 MemoryRegion *sysmem = get_system_memory();
484 MemoryRegion *mr = NULL;
485 void *ram_ptr = NULL;
486 int img_size = -1;
487
488 mr = memory_region_find(sysmem, 0, 1).mr;
489 if (!mr) {
490 error_setg(errp, "Failed to find memory region at address 0");
491 return -1;
492 }
493
494 ram_ptr = memory_region_get_ram_ptr(mr);
495 if (!ram_ptr) {
496 error_setg(errp, "No RAM found");
497 goto unref_mr;
498 }
499
500 netboot_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, ipl->netboot_fw);
501 if (netboot_filename == NULL) {
502 error_setg(errp, "Could not find network bootloader '%s'",
503 ipl->netboot_fw);
504 goto unref_mr;
505 }
506
507 img_size = load_elf_ram(netboot_filename, NULL, NULL, NULL,
508 &ipl->start_addr,
509 NULL, NULL, NULL, 1, EM_S390, 0, 0, NULL,
510 false);
511
512 if (img_size < 0) {
513 img_size = load_image_size(netboot_filename, ram_ptr, ms->ram_size);
514 ipl->start_addr = KERN_IMAGE_START;
515 }
516
517 if (img_size < 0) {
518 error_setg(errp, "Failed to load network bootloader");
519 }
520
521 g_free(netboot_filename);
522
523unref_mr:
524 memory_region_unref(mr);
525 return img_size;
526}
527
528static bool is_virtio_ccw_device_of_type(IplParameterBlock *iplb,
529 int virtio_id)
530{
531 uint8_t cssid;
532 uint8_t ssid;
533 uint16_t devno;
534 uint16_t schid;
535 SubchDev *sch = NULL;
536
537 if (iplb->pbt != S390_IPL_TYPE_CCW) {
538 return false;
539 }
540
541 devno = be16_to_cpu(iplb->ccw.devno);
542 ssid = iplb->ccw.ssid & 3;
543
544 for (schid = 0; schid < MAX_SCHID; schid++) {
545 for (cssid = 0; cssid < MAX_CSSID; cssid++) {
546 sch = css_find_subch(1, cssid, ssid, schid);
547
548 if (sch && sch->devno == devno) {
549 return sch->id.cu_model == virtio_id;
550 }
551 }
552 }
553 return false;
554}
555
556static bool is_virtio_net_device(IplParameterBlock *iplb)
557{
558 return is_virtio_ccw_device_of_type(iplb, VIRTIO_ID_NET);
559}
560
561static bool is_virtio_scsi_device(IplParameterBlock *iplb)
562{
563 return is_virtio_ccw_device_of_type(iplb, VIRTIO_ID_SCSI);
564}
565
566static void update_machine_ipl_properties(IplParameterBlock *iplb)
567{
568 Object *machine = qdev_get_machine();
569 Error *err = NULL;
570
571
572 if (iplb->flags & DIAG308_FLAGS_LP_VALID) {
573 uint8_t *ebcdic_loadparm = iplb->loadparm;
574 char ascii_loadparm[9];
575 int i;
576
577 for (i = 0; i < 8 && ebcdic_loadparm[i]; i++) {
578 ascii_loadparm[i] = ebcdic2ascii[(uint8_t) ebcdic_loadparm[i]];
579 }
580 ascii_loadparm[i] = 0;
581 object_property_set_str(machine, "loadparm", ascii_loadparm, &err);
582 } else {
583 object_property_set_str(machine, "loadparm", "", &err);
584 }
585 if (err) {
586 warn_report_err(err);
587 }
588}
589
590void s390_ipl_update_diag308(IplParameterBlock *iplb)
591{
592 S390IPLState *ipl = get_ipl_device();
593
594
595
596
597
598 if (iplb->pbt == S390_IPL_TYPE_PV) {
599 ipl->iplb_pv = *iplb;
600 ipl->iplb_valid_pv = true;
601 } else {
602 ipl->iplb = *iplb;
603 ipl->iplb_valid = true;
604 }
605 ipl->netboot = is_virtio_net_device(iplb);
606 update_machine_ipl_properties(iplb);
607}
608
609IplParameterBlock *s390_ipl_get_iplb_pv(void)
610{
611 S390IPLState *ipl = get_ipl_device();
612
613 if (!ipl->iplb_valid_pv) {
614 return NULL;
615 }
616 return &ipl->iplb_pv;
617}
618
619IplParameterBlock *s390_ipl_get_iplb(void)
620{
621 S390IPLState *ipl = get_ipl_device();
622
623 if (!ipl->iplb_valid) {
624 return NULL;
625 }
626 return &ipl->iplb;
627}
628
629void s390_ipl_reset_request(CPUState *cs, enum s390_reset reset_type)
630{
631 S390IPLState *ipl = get_ipl_device();
632
633 if (reset_type == S390_RESET_EXTERNAL || reset_type == S390_RESET_REIPL) {
634
635 ipl->reset_cpu_index = 0;
636 } else {
637 ipl->reset_cpu_index = cs->cpu_index;
638 }
639 ipl->reset_type = reset_type;
640
641 if (reset_type == S390_RESET_REIPL &&
642 ipl->iplb_valid &&
643 !ipl->netboot &&
644 ipl->iplb.pbt == S390_IPL_TYPE_CCW &&
645 is_virtio_scsi_device(&ipl->iplb)) {
646 CcwDevice *ccw_dev = s390_get_ccw_device(get_boot_device(0), NULL);
647
648 if (ccw_dev &&
649 cpu_to_be16(ccw_dev->sch->devno) == ipl->iplb.ccw.devno &&
650 (ccw_dev->sch->ssid & 3) == ipl->iplb.ccw.ssid) {
651
652
653
654
655 ipl->iplb_valid = s390_gen_initial_iplb(ipl);
656 }
657 }
658 if (reset_type == S390_RESET_MODIFIED_CLEAR ||
659 reset_type == S390_RESET_LOAD_NORMAL ||
660 reset_type == S390_RESET_PV) {
661
662 qemu_system_reset_request(SHUTDOWN_CAUSE_SUBSYSTEM_RESET);
663 } else {
664 qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
665 }
666
667 if (tcg_enabled()) {
668 cpu_loop_exit(cs);
669 }
670}
671
672void s390_ipl_get_reset_request(CPUState **cs, enum s390_reset *reset_type)
673{
674 S390IPLState *ipl = get_ipl_device();
675
676 *cs = qemu_get_cpu(ipl->reset_cpu_index);
677 if (!*cs) {
678
679 *cs = first_cpu;
680 }
681 *reset_type = ipl->reset_type;
682}
683
684void s390_ipl_clear_reset_request(void)
685{
686 S390IPLState *ipl = get_ipl_device();
687
688 ipl->reset_type = S390_RESET_EXTERNAL;
689
690 ipl->reset_cpu_index = 0;
691}
692
693static void s390_ipl_prepare_qipl(S390CPU *cpu)
694{
695 S390IPLState *ipl = get_ipl_device();
696 uint8_t *addr;
697 uint64_t len = 4096;
698
699 addr = cpu_physical_memory_map(cpu->env.psa, &len, true);
700 if (!addr || len < QIPL_ADDRESS + sizeof(QemuIplParameters)) {
701 error_report("Cannot set QEMU IPL parameters");
702 return;
703 }
704 memcpy(addr + QIPL_ADDRESS, &ipl->qipl, sizeof(QemuIplParameters));
705 cpu_physical_memory_unmap(addr, len, 1, len);
706}
707
708int s390_ipl_prepare_pv_header(void)
709{
710 IplParameterBlock *ipib = s390_ipl_get_iplb_pv();
711 IPLBlockPV *ipib_pv = &ipib->pv;
712 void *hdr = g_malloc(ipib_pv->pv_header_len);
713 int rc;
714
715 cpu_physical_memory_read(ipib_pv->pv_header_addr, hdr,
716 ipib_pv->pv_header_len);
717 rc = s390_pv_set_sec_parms((uintptr_t)hdr,
718 ipib_pv->pv_header_len);
719 g_free(hdr);
720 return rc;
721}
722
723int s390_ipl_pv_unpack(void)
724{
725 IplParameterBlock *ipib = s390_ipl_get_iplb_pv();
726 IPLBlockPV *ipib_pv = &ipib->pv;
727 int i, rc = 0;
728
729 for (i = 0; i < ipib_pv->num_comp; i++) {
730 rc = s390_pv_unpack(ipib_pv->components[i].addr,
731 TARGET_PAGE_ALIGN(ipib_pv->components[i].size),
732 ipib_pv->components[i].tweak_pref);
733 if (rc) {
734 break;
735 }
736 }
737 return rc;
738}
739
740void s390_ipl_prepare_cpu(S390CPU *cpu)
741{
742 S390IPLState *ipl = get_ipl_device();
743
744 cpu->env.psw.addr = ipl->start_addr;
745 cpu->env.psw.mask = IPL_PSW_MASK;
746
747 if (!ipl->kernel || ipl->iplb_valid) {
748 cpu->env.psw.addr = ipl->bios_start_addr;
749 if (!ipl->iplb_valid) {
750 ipl->iplb_valid = s390_gen_initial_iplb(ipl);
751 }
752 }
753 if (ipl->netboot) {
754 load_netboot_image(&error_fatal);
755 ipl->qipl.netboot_start_addr = cpu_to_be64(ipl->start_addr);
756 }
757 s390_ipl_set_boot_menu(ipl);
758 s390_ipl_prepare_qipl(cpu);
759}
760
761static void s390_ipl_reset(DeviceState *dev)
762{
763 S390IPLState *ipl = S390_IPL(dev);
764
765 if (ipl->reset_type != S390_RESET_REIPL) {
766 ipl->iplb_valid = false;
767 memset(&ipl->iplb, 0, sizeof(IplParameterBlock));
768 }
769}
770
771static void s390_ipl_class_init(ObjectClass *klass, void *data)
772{
773 DeviceClass *dc = DEVICE_CLASS(klass);
774
775 dc->realize = s390_ipl_realize;
776 device_class_set_props(dc, s390_ipl_properties);
777 dc->reset = s390_ipl_reset;
778 dc->vmsd = &vmstate_ipl;
779 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
780
781 dc->user_creatable = false;
782}
783
784static const TypeInfo s390_ipl_info = {
785 .class_init = s390_ipl_class_init,
786 .parent = TYPE_DEVICE,
787 .name = TYPE_S390_IPL,
788 .instance_size = sizeof(S390IPLState),
789};
790
791static void s390_ipl_register_types(void)
792{
793 type_register_static(&s390_ipl_info);
794}
795
796type_init(s390_ipl_register_types)
797
