xref: /openbmc/qemu/hw/s390x/ipl.c (revision fbf32752)
1 /*
2  * bootloader support
3  *
4  * Copyright IBM, Corp. 2012
5  *
6  * Authors:
7  *  Christian Borntraeger <borntraeger@de.ibm.com>
8  *
9  * This work is licensed under the terms of the GNU GPL, version 2 or (at your
10  * option) any later version.  See the COPYING file in the top-level directory.
11  *
12  */
13 
14 #include "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "sysemu/sysemu.h"
17 #include "cpu.h"
18 #include "elf.h"
19 #include "hw/loader.h"
20 #include "hw/boards.h"
21 #include "hw/s390x/virtio-ccw.h"
22 #include "hw/s390x/css.h"
23 #include "hw/s390x/ebcdic.h"
24 #include "ipl.h"
25 #include "qemu/error-report.h"
26 #include "qemu/config-file.h"
27 #include "qemu/cutils.h"
28 #include "qemu/option.h"
29 
30 #define KERN_IMAGE_START                0x010000UL
31 #define KERN_PARM_AREA                  0x010480UL
32 #define INITRD_START                    0x800000UL
33 #define INITRD_PARM_START               0x010408UL
34 #define INITRD_PARM_SIZE                0x010410UL
35 #define PARMFILE_START                  0x001000UL
36 #define ZIPL_IMAGE_START                0x009000UL
37 #define IPL_PSW_MASK                    (PSW_MASK_32 | PSW_MASK_64)
38 
39 static bool iplb_extended_needed(void *opaque)
40 {
41     S390IPLState *ipl = S390_IPL(object_resolve_path(TYPE_S390_IPL, NULL));
42 
43     return ipl->iplbext_migration;
44 }
45 
46 static const VMStateDescription vmstate_iplb_extended = {
47     .name = "ipl/iplb_extended",
48     .version_id = 0,
49     .minimum_version_id = 0,
50     .needed = iplb_extended_needed,
51     .fields = (VMStateField[]) {
52         VMSTATE_UINT8_ARRAY(reserved_ext, IplParameterBlock, 4096 - 200),
53         VMSTATE_END_OF_LIST()
54     }
55 };
56 
57 static const VMStateDescription vmstate_iplb = {
58     .name = "ipl/iplb",
59     .version_id = 0,
60     .minimum_version_id = 0,
61     .fields = (VMStateField[]) {
62         VMSTATE_UINT8_ARRAY(reserved1, IplParameterBlock, 110),
63         VMSTATE_UINT16(devno, IplParameterBlock),
64         VMSTATE_UINT8_ARRAY(reserved2, IplParameterBlock, 88),
65         VMSTATE_END_OF_LIST()
66     },
67     .subsections = (const VMStateDescription*[]) {
68         &vmstate_iplb_extended,
69         NULL
70     }
71 };
72 
73 static const VMStateDescription vmstate_ipl = {
74     .name = "ipl",
75     .version_id = 0,
76     .minimum_version_id = 0,
77     .fields = (VMStateField[]) {
78         VMSTATE_UINT64(compat_start_addr, S390IPLState),
79         VMSTATE_UINT64(compat_bios_start_addr, S390IPLState),
80         VMSTATE_STRUCT(iplb, S390IPLState, 0, vmstate_iplb, IplParameterBlock),
81         VMSTATE_BOOL(iplb_valid, S390IPLState),
82         VMSTATE_UINT8(cssid, S390IPLState),
83         VMSTATE_UINT8(ssid, S390IPLState),
84         VMSTATE_UINT16(devno, S390IPLState),
85         VMSTATE_END_OF_LIST()
86      }
87 };
88 
89 static S390IPLState *get_ipl_device(void)
90 {
91     return S390_IPL(object_resolve_path_type("", TYPE_S390_IPL, NULL));
92 }
93 
94 static uint64_t bios_translate_addr(void *opaque, uint64_t srcaddr)
95 {
96     uint64_t dstaddr = *(uint64_t *) opaque;
97     /*
98      * Assuming that our s390-ccw.img was linked for starting at address 0,
99      * we can simply add the destination address for the final location
100      */
101     return srcaddr + dstaddr;
102 }
103 
104 static void s390_ipl_realize(DeviceState *dev, Error **errp)
105 {
106     S390IPLState *ipl = S390_IPL(dev);
107     uint64_t pentry = KERN_IMAGE_START;
108     int kernel_size;
109     Error *err = NULL;
110 
111     int bios_size;
112     char *bios_filename;
113 
114     /*
115      * Always load the bios if it was enforced,
116      * even if an external kernel has been defined.
117      */
118     if (!ipl->kernel || ipl->enforce_bios) {
119         uint64_t fwbase = (MIN(ram_size, 0x80000000U) - 0x200000) & ~0xffffUL;
120 
121         if (bios_name == NULL) {
122             bios_name = ipl->firmware;
123         }
124 
125         bios_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
126         if (bios_filename == NULL) {
127             error_setg(&err, "could not find stage1 bootloader");
128             goto error;
129         }
130 
131         bios_size = load_elf(bios_filename, bios_translate_addr, &fwbase,
132                              &ipl->bios_start_addr, NULL, NULL, 1,
133                              EM_S390, 0, 0);
134         if (bios_size > 0) {
135             /* Adjust ELF start address to final location */
136             ipl->bios_start_addr += fwbase;
137         } else {
138             /* Try to load non-ELF file */
139             bios_size = load_image_targphys(bios_filename, ZIPL_IMAGE_START,
140                                             4096);
141             ipl->bios_start_addr = ZIPL_IMAGE_START;
142         }
143         g_free(bios_filename);
144 
145         if (bios_size == -1) {
146             error_setg(&err, "could not load bootloader '%s'", bios_name);
147             goto error;
148         }
149 
150         /* default boot target is the bios */
151         ipl->start_addr = ipl->bios_start_addr;
152     }
153 
154     if (ipl->kernel) {
155         kernel_size = load_elf(ipl->kernel, NULL, NULL, &pentry, NULL,
156                                NULL, 1, EM_S390, 0, 0);
157         if (kernel_size < 0) {
158             kernel_size = load_image_targphys(ipl->kernel, 0, ram_size);
159         }
160         if (kernel_size < 0) {
161             error_setg(&err, "could not load kernel '%s'", ipl->kernel);
162             goto error;
163         }
164         /*
165          * Is it a Linux kernel (starting at 0x10000)? If yes, we fill in the
166          * kernel parameters here as well. Note: For old kernels (up to 3.2)
167          * we can not rely on the ELF entry point - it was 0x800 (the SALIPL
168          * loader) and it won't work. For this case we force it to 0x10000, too.
169          */
170         if (pentry == KERN_IMAGE_START || pentry == 0x800) {
171             ipl->start_addr = KERN_IMAGE_START;
172             /* Overwrite parameters in the kernel image, which are "rom" */
173             strcpy(rom_ptr(KERN_PARM_AREA), ipl->cmdline);
174         } else {
175             ipl->start_addr = pentry;
176         }
177 
178         if (ipl->initrd) {
179             ram_addr_t initrd_offset;
180             int initrd_size;
181 
182             initrd_offset = INITRD_START;
183             while (kernel_size + 0x100000 > initrd_offset) {
184                 initrd_offset += 0x100000;
185             }
186             initrd_size = load_image_targphys(ipl->initrd, initrd_offset,
187                                               ram_size - initrd_offset);
188             if (initrd_size == -1) {
189                 error_setg(&err, "could not load initrd '%s'", ipl->initrd);
190                 goto error;
191             }
192 
193             /*
194              * we have to overwrite values in the kernel image,
195              * which are "rom"
196              */
197             stq_p(rom_ptr(INITRD_PARM_START), initrd_offset);
198             stq_p(rom_ptr(INITRD_PARM_SIZE), initrd_size);
199         }
200     }
201     /*
202      * Don't ever use the migrated values, they could come from a different
203      * BIOS and therefore don't work. But still migrate the values, so
204      * QEMUs relying on it don't break.
205      */
206     ipl->compat_start_addr = ipl->start_addr;
207     ipl->compat_bios_start_addr = ipl->bios_start_addr;
208     qemu_register_reset(qdev_reset_all_fn, dev);
209 error:
210     error_propagate(errp, err);
211 }
212 
213 static Property s390_ipl_properties[] = {
214     DEFINE_PROP_STRING("kernel", S390IPLState, kernel),
215     DEFINE_PROP_STRING("initrd", S390IPLState, initrd),
216     DEFINE_PROP_STRING("cmdline", S390IPLState, cmdline),
217     DEFINE_PROP_STRING("firmware", S390IPLState, firmware),
218     DEFINE_PROP_STRING("netboot_fw", S390IPLState, netboot_fw),
219     DEFINE_PROP_BOOL("enforce_bios", S390IPLState, enforce_bios, false),
220     DEFINE_PROP_BOOL("iplbext_migration", S390IPLState, iplbext_migration,
221                      true),
222     DEFINE_PROP_END_OF_LIST(),
223 };
224 
225 static void s390_ipl_set_boot_menu(S390IPLState *ipl)
226 {
227     QemuOptsList *plist = qemu_find_opts("boot-opts");
228     QemuOpts *opts = QTAILQ_FIRST(&plist->head);
229     uint8_t *flags = &ipl->qipl.qipl_flags;
230     uint32_t *timeout = &ipl->qipl.boot_menu_timeout;
231     const char *tmp;
232     unsigned long splash_time = 0;
233 
234     if (!get_boot_device(0)) {
235         if (boot_menu) {
236             error_report("boot menu requires a bootindex to be specified for "
237                          "the IPL device");
238         }
239         return;
240     }
241 
242     switch (ipl->iplb.pbt) {
243     case S390_IPL_TYPE_CCW:
244         /* In the absence of -boot menu, use zipl parameters */
245         if (!qemu_opt_get(opts, "menu")) {
246             *flags |= QIPL_FLAG_BM_OPTS_ZIPL;
247             return;
248         }
249         break;
250     case S390_IPL_TYPE_QEMU_SCSI:
251         break;
252     default:
253         if (boot_menu) {
254             error_report("boot menu is not supported for this device type");
255         }
256         return;
257     }
258 
259     if (!boot_menu) {
260         return;
261     }
262 
263     *flags |= QIPL_FLAG_BM_OPTS_CMD;
264 
265     tmp = qemu_opt_get(opts, "splash-time");
266 
267     if (tmp && qemu_strtoul(tmp, NULL, 10, &splash_time)) {
268         error_report("splash-time is invalid, forcing it to 0");
269         *timeout = 0;
270         return;
271     }
272 
273     if (splash_time > 0xffffffff) {
274         error_report("splash-time is too large, forcing it to max value");
275         *timeout = 0xffffffff;
276         return;
277     }
278 
279     *timeout = cpu_to_be32(splash_time);
280 }
281 
282 static CcwDevice *s390_get_ccw_device(DeviceState *dev_st)
283 {
284     CcwDevice *ccw_dev = NULL;
285 
286     if (dev_st) {
287         VirtioCcwDevice *virtio_ccw_dev = (VirtioCcwDevice *)
288             object_dynamic_cast(OBJECT(qdev_get_parent_bus(dev_st)->parent),
289                                 TYPE_VIRTIO_CCW_DEVICE);
290         if (virtio_ccw_dev) {
291             ccw_dev = CCW_DEVICE(virtio_ccw_dev);
292         } else {
293             SCSIDevice *sd = (SCSIDevice *)
294                 object_dynamic_cast(OBJECT(dev_st),
295                                     TYPE_SCSI_DEVICE);
296             if (sd) {
297                 SCSIBus *bus = scsi_bus_from_device(sd);
298                 VirtIOSCSI *vdev = container_of(bus, VirtIOSCSI, bus);
299                 VirtIOSCSICcw *scsi_ccw = container_of(vdev, VirtIOSCSICcw,
300                                                        vdev);
301 
302                 ccw_dev = (CcwDevice *)object_dynamic_cast(OBJECT(scsi_ccw),
303                                                            TYPE_CCW_DEVICE);
304             }
305         }
306     }
307     return ccw_dev;
308 }
309 
310 static bool s390_gen_initial_iplb(S390IPLState *ipl)
311 {
312     DeviceState *dev_st;
313     CcwDevice *ccw_dev = NULL;
314 
315     dev_st = get_boot_device(0);
316     if (dev_st) {
317         ccw_dev = s390_get_ccw_device(dev_st);
318     }
319 
320     /*
321      * Currently allow IPL only from CCW devices.
322      */
323     if (ccw_dev) {
324         SCSIDevice *sd = (SCSIDevice *) object_dynamic_cast(OBJECT(dev_st),
325                                                             TYPE_SCSI_DEVICE);
326 
327         if (sd) {
328             ipl->iplb.len = cpu_to_be32(S390_IPLB_MIN_QEMU_SCSI_LEN);
329             ipl->iplb.blk0_len =
330                 cpu_to_be32(S390_IPLB_MIN_QEMU_SCSI_LEN - S390_IPLB_HEADER_LEN);
331             ipl->iplb.pbt = S390_IPL_TYPE_QEMU_SCSI;
332             ipl->iplb.scsi.lun = cpu_to_be32(sd->lun);
333             ipl->iplb.scsi.target = cpu_to_be16(sd->id);
334             ipl->iplb.scsi.channel = cpu_to_be16(sd->channel);
335             ipl->iplb.scsi.devno = cpu_to_be16(ccw_dev->sch->devno);
336             ipl->iplb.scsi.ssid = ccw_dev->sch->ssid & 3;
337         } else {
338             VirtIONet *vn = (VirtIONet *) object_dynamic_cast(OBJECT(dev_st),
339                                                               TYPE_VIRTIO_NET);
340 
341             ipl->iplb.len = cpu_to_be32(S390_IPLB_MIN_CCW_LEN);
342             ipl->iplb.blk0_len =
343                 cpu_to_be32(S390_IPLB_MIN_CCW_LEN - S390_IPLB_HEADER_LEN);
344             ipl->iplb.pbt = S390_IPL_TYPE_CCW;
345             ipl->iplb.ccw.devno = cpu_to_be16(ccw_dev->sch->devno);
346             ipl->iplb.ccw.ssid = ccw_dev->sch->ssid & 3;
347 
348             if (vn) {
349                 ipl->netboot = true;
350             }
351         }
352 
353         if (!s390_ipl_set_loadparm(ipl->iplb.loadparm)) {
354             ipl->iplb.flags |= DIAG308_FLAGS_LP_VALID;
355         }
356 
357         return true;
358     }
359 
360     return false;
361 }
362 
363 int s390_ipl_set_loadparm(uint8_t *loadparm)
364 {
365     MachineState *machine = MACHINE(qdev_get_machine());
366     char *lp = object_property_get_str(OBJECT(machine), "loadparm", NULL);
367 
368     if (lp) {
369         int i;
370 
371         /* lp is an uppercase string without leading/embedded spaces */
372         for (i = 0; i < 8 && lp[i]; i++) {
373             loadparm[i] = ascii2ebcdic[(uint8_t) lp[i]];
374         }
375 
376         g_free(lp);
377         return 0;
378     }
379 
380     return -1;
381 }
382 
383 static int load_netboot_image(Error **errp)
384 {
385     S390IPLState *ipl = get_ipl_device();
386     char *netboot_filename;
387     MemoryRegion *sysmem =  get_system_memory();
388     MemoryRegion *mr = NULL;
389     void *ram_ptr = NULL;
390     int img_size = -1;
391 
392     mr = memory_region_find(sysmem, 0, 1).mr;
393     if (!mr) {
394         error_setg(errp, "Failed to find memory region at address 0");
395         return -1;
396     }
397 
398     ram_ptr = memory_region_get_ram_ptr(mr);
399     if (!ram_ptr) {
400         error_setg(errp, "No RAM found");
401         goto unref_mr;
402     }
403 
404     netboot_filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, ipl->netboot_fw);
405     if (netboot_filename == NULL) {
406         error_setg(errp, "Could not find network bootloader '%s'",
407                    ipl->netboot_fw);
408         goto unref_mr;
409     }
410 
411     img_size = load_elf_ram(netboot_filename, NULL, NULL, &ipl->start_addr,
412                             NULL, NULL, 1, EM_S390, 0, 0, NULL, false);
413 
414     if (img_size < 0) {
415         img_size = load_image_size(netboot_filename, ram_ptr, ram_size);
416         ipl->start_addr = KERN_IMAGE_START;
417     }
418 
419     if (img_size < 0) {
420         error_setg(errp, "Failed to load network bootloader");
421     }
422 
423     g_free(netboot_filename);
424 
425 unref_mr:
426     memory_region_unref(mr);
427     return img_size;
428 }
429 
430 static bool is_virtio_ccw_device_of_type(IplParameterBlock *iplb,
431                                          int virtio_id)
432 {
433     uint8_t cssid;
434     uint8_t ssid;
435     uint16_t devno;
436     uint16_t schid;
437     SubchDev *sch = NULL;
438 
439     if (iplb->pbt != S390_IPL_TYPE_CCW) {
440         return false;
441     }
442 
443     devno = be16_to_cpu(iplb->ccw.devno);
444     ssid = iplb->ccw.ssid & 3;
445 
446     for (schid = 0; schid < MAX_SCHID; schid++) {
447         for (cssid = 0; cssid < MAX_CSSID; cssid++) {
448             sch = css_find_subch(1, cssid, ssid, schid);
449 
450             if (sch && sch->devno == devno) {
451                 return sch->id.cu_model == virtio_id;
452             }
453         }
454     }
455     return false;
456 }
457 
458 static bool is_virtio_net_device(IplParameterBlock *iplb)
459 {
460     return is_virtio_ccw_device_of_type(iplb, VIRTIO_ID_NET);
461 }
462 
463 static bool is_virtio_scsi_device(IplParameterBlock *iplb)
464 {
465     return is_virtio_ccw_device_of_type(iplb, VIRTIO_ID_SCSI);
466 }
467 
468 void s390_ipl_update_diag308(IplParameterBlock *iplb)
469 {
470     S390IPLState *ipl = get_ipl_device();
471 
472     ipl->iplb = *iplb;
473     ipl->iplb_valid = true;
474     ipl->netboot = is_virtio_net_device(iplb);
475 }
476 
477 IplParameterBlock *s390_ipl_get_iplb(void)
478 {
479     S390IPLState *ipl = get_ipl_device();
480 
481     if (!ipl->iplb_valid) {
482         return NULL;
483     }
484     return &ipl->iplb;
485 }
486 
487 void s390_reipl_request(void)
488 {
489     S390IPLState *ipl = get_ipl_device();
490 
491     ipl->reipl_requested = true;
492     if (ipl->iplb_valid &&
493         !ipl->netboot &&
494         ipl->iplb.pbt == S390_IPL_TYPE_CCW &&
495         is_virtio_scsi_device(&ipl->iplb)) {
496         CcwDevice *ccw_dev = s390_get_ccw_device(get_boot_device(0));
497 
498         if (ccw_dev &&
499             cpu_to_be16(ccw_dev->sch->devno) == ipl->iplb.ccw.devno &&
500             (ccw_dev->sch->ssid & 3) == ipl->iplb.ccw.ssid) {
501             /*
502              * this is the original boot device's SCSI
503              * so restore IPL parameter info from it
504              */
505             ipl->iplb_valid = s390_gen_initial_iplb(ipl);
506         }
507     }
508     qemu_system_reset_request(SHUTDOWN_CAUSE_GUEST_RESET);
509 }
510 
511 static void s390_ipl_prepare_qipl(S390CPU *cpu)
512 {
513     S390IPLState *ipl = get_ipl_device();
514     uint8_t *addr;
515     uint64_t len = 4096;
516 
517     addr = cpu_physical_memory_map(cpu->env.psa, &len, 1);
518     if (!addr || len < QIPL_ADDRESS + sizeof(QemuIplParameters)) {
519         error_report("Cannot set QEMU IPL parameters");
520         return;
521     }
522     memcpy(addr + QIPL_ADDRESS, &ipl->qipl, sizeof(QemuIplParameters));
523     cpu_physical_memory_unmap(addr, len, 1, len);
524 }
525 
526 void s390_ipl_prepare_cpu(S390CPU *cpu)
527 {
528     S390IPLState *ipl = get_ipl_device();
529     Error *err = NULL;
530 
531     cpu->env.psw.addr = ipl->start_addr;
532     cpu->env.psw.mask = IPL_PSW_MASK;
533 
534     if (!ipl->kernel || ipl->iplb_valid) {
535         cpu->env.psw.addr = ipl->bios_start_addr;
536         if (!ipl->iplb_valid) {
537             ipl->iplb_valid = s390_gen_initial_iplb(ipl);
538         }
539     }
540     if (ipl->netboot) {
541         if (load_netboot_image(&err) < 0) {
542             error_report_err(err);
543             exit(1);
544         }
545         ipl->qipl.netboot_start_addr = cpu_to_be64(ipl->start_addr);
546     }
547     s390_ipl_set_boot_menu(ipl);
548     s390_ipl_prepare_qipl(cpu);
549 }
550 
551 static void s390_ipl_reset(DeviceState *dev)
552 {
553     S390IPLState *ipl = S390_IPL(dev);
554 
555     if (!ipl->reipl_requested) {
556         ipl->iplb_valid = false;
557         memset(&ipl->iplb, 0, sizeof(IplParameterBlock));
558     }
559     ipl->reipl_requested = false;
560 }
561 
562 static void s390_ipl_class_init(ObjectClass *klass, void *data)
563 {
564     DeviceClass *dc = DEVICE_CLASS(klass);
565 
566     dc->realize = s390_ipl_realize;
567     dc->props = s390_ipl_properties;
568     dc->reset = s390_ipl_reset;
569     dc->vmsd = &vmstate_ipl;
570     set_bit(DEVICE_CATEGORY_MISC, dc->categories);
571     /* Reason: Loads the ROMs and thus can only be used one time - internally */
572     dc->user_creatable = false;
573 }
574 
575 static const TypeInfo s390_ipl_info = {
576     .class_init = s390_ipl_class_init,
577     .parent = TYPE_DEVICE,
578     .name  = TYPE_S390_IPL,
579     .instance_size  = sizeof(S390IPLState),
580 };
581 
582 static void s390_ipl_register_types(void)
583 {
584     type_register_static(&s390_ipl_info);
585 }
586 
587 type_init(s390_ipl_register_types)
588