2 * QEMU S390 virtio target
4 * Copyright (c) 2009 Alexander Graf <agraf@suse.de>
5 * Copyright IBM Corp 2012
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * Contributions after 2012-10-29 are licensed under the terms of the
18 * GNU GPL, version 2 or (at your option) any later version.
20 * You should have received a copy of the GNU (Lesser) General Public
21 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
25 #include "qapi/qmp/qerror.h"
26 #include "qemu/error-report.h"
27 #include "sysemu/block-backend.h"
28 #include "sysemu/blockdev.h"
29 #include "sysemu/sysemu.h"
31 #include "hw/boards.h"
32 #include "hw/loader.h"
33 #include "hw/virtio/virtio.h"
34 #include "hw/sysbus.h"
35 #include "sysemu/kvm.h"
36 #include "exec/address-spaces.h"
38 #include "hw/s390x/s390-virtio-bus.h"
39 #include "hw/s390x/sclp.h"
40 #include "hw/s390x/s390_flic.h"
41 #include "hw/s390x/s390-virtio.h"
42 #include "hw/s390x/storage-keys.h"
48 #define DPRINTF(fmt, ...) \
49 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
51 #define DPRINTF(fmt, ...) \
55 #define MAX_BLK_DEVS 10
56 #define ZIPL_FILENAME "s390-zipl.rom"
57 #define S390_MACHINE "s390-virtio"
58 #define TYPE_S390_MACHINE MACHINE_TYPE_NAME(S390_MACHINE)
60 #define S390_TOD_CLOCK_VALUE_MISSING 0x00
61 #define S390_TOD_CLOCK_VALUE_PRESENT 0x01
63 static VirtIOS390Bus
*s390_bus
;
64 static S390CPU
**ipi_states
;
66 S390CPU
*s390_cpu_addr2state(uint16_t cpu_addr
)
68 if (cpu_addr
>= smp_cpus
) {
72 return ipi_states
[cpu_addr
];
75 static int s390_virtio_hcall_notify(const uint64_t *args
)
77 uint64_t mem
= args
[0];
81 VirtIOS390Device
*dev
= s390_virtio_bus_find_vring(s390_bus
, mem
, &i
);
84 * Older kernels will use the virtqueue before setting DRIVER_OK.
85 * In this case the feature bits are not yet up to date, meaning
86 * that several funny things can happen, e.g. the guest thinks
87 * EVENT_IDX is on and QEMU thinks it is off. Let's force a feature
90 if (!(dev
->vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
91 s390_virtio_device_update_status(dev
);
93 virtio_queue_notify(dev
->vdev
, i
);
103 static int s390_virtio_hcall_reset(const uint64_t *args
)
105 uint64_t mem
= args
[0];
106 VirtIOS390Device
*dev
;
108 dev
= s390_virtio_bus_find_mem(s390_bus
, mem
);
112 virtio_reset(dev
->vdev
);
113 address_space_stb(&address_space_memory
,
114 dev
->dev_offs
+ VIRTIO_DEV_OFFS_STATUS
, 0,
115 MEMTXATTRS_UNSPECIFIED
, NULL
);
116 s390_virtio_device_sync(dev
);
117 s390_virtio_reset_idx(dev
);
122 static int s390_virtio_hcall_set_status(const uint64_t *args
)
124 uint64_t mem
= args
[0];
126 VirtIOS390Device
*dev
;
128 dev
= s390_virtio_bus_find_mem(s390_bus
, mem
);
130 s390_virtio_device_update_status(dev
);
137 static void s390_virtio_register_hcalls(void)
139 s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY
,
140 s390_virtio_hcall_notify
);
141 s390_register_virtio_hypercall(KVM_S390_VIRTIO_RESET
,
142 s390_virtio_hcall_reset
);
143 s390_register_virtio_hypercall(KVM_S390_VIRTIO_SET_STATUS
,
144 s390_virtio_hcall_set_status
);
147 void s390_init_ipl_dev(const char *kernel_filename
,
148 const char *kernel_cmdline
,
149 const char *initrd_filename
,
150 const char *firmware
,
155 dev
= qdev_create(NULL
, "s390-ipl");
156 if (kernel_filename
) {
157 qdev_prop_set_string(dev
, "kernel", kernel_filename
);
159 if (initrd_filename
) {
160 qdev_prop_set_string(dev
, "initrd", initrd_filename
);
162 qdev_prop_set_string(dev
, "cmdline", kernel_cmdline
);
163 qdev_prop_set_string(dev
, "firmware", firmware
);
164 qdev_prop_set_bit(dev
, "enforce_bios", enforce_bios
);
165 object_property_add_child(qdev_get_machine(), "s390-ipl",
167 qdev_init_nofail(dev
);
170 void s390_init_cpus(const char *cpu_model
)
174 if (cpu_model
== NULL
) {
178 ipi_states
= g_malloc(sizeof(S390CPU
*) * smp_cpus
);
180 for (i
= 0; i
< smp_cpus
; i
++) {
184 cpu
= cpu_s390x_init(cpu_model
);
189 cs
->exception_index
= EXCP_HLT
;
194 void s390_create_virtio_net(BusState
*bus
, const char *name
)
198 for (i
= 0; i
< nb_nics
; i
++) {
199 NICInfo
*nd
= &nd_table
[i
];
203 nd
->model
= g_strdup("virtio");
206 if (strcmp(nd
->model
, "virtio")) {
207 fprintf(stderr
, "S390 only supports VirtIO nics\n");
211 dev
= qdev_create(bus
, name
);
212 qdev_set_nic_properties(dev
, nd
);
213 qdev_init_nofail(dev
);
217 void gtod_save(QEMUFile
*f
, void *opaque
)
223 r
= s390_get_clock(&tod_high
, &tod_low
);
225 fprintf(stderr
, "WARNING: Unable to get guest clock for migration. "
226 "Error code %d. Guest clock will not be migrated "
227 "which could cause the guest to hang.\n", r
);
228 qemu_put_byte(f
, S390_TOD_CLOCK_VALUE_MISSING
);
232 qemu_put_byte(f
, S390_TOD_CLOCK_VALUE_PRESENT
);
233 qemu_put_byte(f
, tod_high
);
234 qemu_put_be64(f
, tod_low
);
237 int gtod_load(QEMUFile
*f
, void *opaque
, int version_id
)
243 if (qemu_get_byte(f
) == S390_TOD_CLOCK_VALUE_MISSING
) {
244 fprintf(stderr
, "WARNING: Guest clock was not migrated. This could "
245 "cause the guest to hang.\n");
249 tod_high
= qemu_get_byte(f
);
250 tod_low
= qemu_get_be64(f
);
252 r
= s390_set_clock(&tod_high
, &tod_low
);
254 fprintf(stderr
, "WARNING: Unable to set guest clock value. "
255 "s390_get_clock returned error %d. This could cause "
256 "the guest to hang.\n", r
);
262 /* PC hardware initialisation */
263 static void s390_init(MachineState
*machine
)
265 ram_addr_t my_ram_size
;
267 hwaddr virtio_region_len
;
268 hwaddr virtio_region_start
;
270 if (machine
->ram_slots
) {
271 error_report("Memory hotplug not supported by the selected machine.");
275 my_ram_size
= machine
->ram_size
;
278 s390_bus
= s390_virtio_bus_init(&my_ram_size
);
279 s390_init_ipl_dev(machine
->kernel_filename
, machine
->kernel_cmdline
,
280 machine
->initrd_filename
, ZIPL_FILENAME
, false);
283 /* register hypercalls */
284 s390_virtio_register_hcalls();
287 s390_memory_init(my_ram_size
);
289 /* clear virtio region */
290 virtio_region_len
= my_ram_size
- ram_size
;
291 virtio_region_start
= ram_size
;
292 virtio_region
= cpu_physical_memory_map(virtio_region_start
,
293 &virtio_region_len
, true);
294 memset(virtio_region
, 0, virtio_region_len
);
295 cpu_physical_memory_unmap(virtio_region
, virtio_region_len
, 1,
299 s390_init_cpus(machine
->cpu_model
);
301 /* Create VirtIO network adapters */
302 s390_create_virtio_net((BusState
*)s390_bus
, "virtio-net-s390");
304 /* Register savevm handler for guest TOD clock */
305 register_savevm(NULL
, "todclock", 0, 1, gtod_save
, gtod_load
, NULL
);
308 void s390_nmi(NMIState
*n
, int cpu_index
, Error
**errp
)
310 CPUState
*cs
= qemu_get_cpu(cpu_index
);
312 if (s390_cpu_restart(S390_CPU(cs
))) {
313 error_setg(errp
, QERR_UNSUPPORTED
);
317 static void s390_machine_class_init(ObjectClass
*oc
, void *data
)
319 MachineClass
*mc
= MACHINE_CLASS(oc
);
320 NMIClass
*nc
= NMI_CLASS(oc
);
323 mc
->desc
= "VirtIO based S390 machine";
324 mc
->init
= s390_init
;
325 mc
->block_default_type
= IF_VIRTIO
;
333 nc
->nmi_monitor_handler
= s390_nmi
;
336 static const TypeInfo s390_machine_info
= {
337 .name
= TYPE_S390_MACHINE
,
338 .parent
= TYPE_MACHINE
,
339 .class_init
= s390_machine_class_init
,
340 .interfaces
= (InterfaceInfo
[]) {
346 static void s390_machine_register_types(void)
348 type_register_static(&s390_machine_info
);
351 type_init(s390_machine_register_types
)