[qemu.git] / hw / s390x / s390-virtio-ccw.c

/*
 * virtio ccw machine
 *
 * Copyright 2012 IBM Corp.
 * Author(s): Cornelia Huck <[email protected]>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or (at
 * your option) any later version. See the COPYING file in the top-level
 * directory.
 */

#include "qemu/osdep.h"
#include "qapi/error.h"
#include "qemu-common.h"
#include "cpu.h"
#include "hw/boards.h"
#include "exec/address-spaces.h"
#include "s390-virtio.h"
#include "hw/s390x/sclp.h"
#include "hw/s390x/s390_flic.h"
#include "hw/s390x/ioinst.h"
#include "hw/s390x/css.h"
#include "virtio-ccw.h"
#include "qemu/config-file.h"
#include "s390-pci-bus.h"
#include "hw/s390x/storage-keys.h"
#include "hw/s390x/storage-attributes.h"
#include "hw/compat.h"
#include "ipl.h"
#include "hw/s390x/s390-virtio-ccw.h"
#include "hw/s390x/css-bridge.h"
#include "migration/register.h"
#include "cpu_models.h"

static const char *const reset_dev_types[] = {
    TYPE_VIRTUAL_CSS_BRIDGE,
    "s390-sclp-event-facility",
    "s390-flic",
    "diag288",
};

void subsystem_reset(void)
{
    DeviceState *dev;
    int i;

    for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) {
        dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL));
        if (dev) {
            qdev_reset_all(dev);
        }
    }
}

static int virtio_ccw_hcall_notify(const uint64_t *args)
{
    uint64_t subch_id = args[0];
    uint64_t queue = args[1];
    SubchDev *sch;
    int cssid, ssid, schid, m;

    if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
        return -EINVAL;
    }
    sch = css_find_subch(m, cssid, ssid, schid);
    if (!sch || !css_subch_visible(sch)) {
        return -EINVAL;
    }
    if (queue >= VIRTIO_QUEUE_MAX) {
        return -EINVAL;
    }
    virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
    return 0;

}

static int virtio_ccw_hcall_early_printk(const uint64_t *args)
{
    uint64_t mem = args[0];

    if (mem < ram_size) {
        /* Early printk */
        return 0;
    }
    return -EINVAL;
}

static void virtio_ccw_register_hcalls(void)
{
    s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
                                   virtio_ccw_hcall_notify);
    /* Tolerate early printk. */
    s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
                                   virtio_ccw_hcall_early_printk);
}

void s390_memory_init(ram_addr_t mem_size)
{
    MemoryRegion *sysmem = get_system_memory();
    MemoryRegion *ram = g_new(MemoryRegion, 1);

    /* allocate RAM for core */
    memory_region_allocate_system_memory(ram, NULL, "s390.ram", mem_size);
    memory_region_add_subregion(sysmem, 0, ram);

    /* Initialize storage key device */
    s390_skeys_init();
    /* Initialize storage attributes device */
    s390_stattrib_init();
}

static SaveVMHandlers savevm_gtod = {
    .save_state = gtod_save,
    .load_state = gtod_load,
};

static void ccw_init(MachineState *machine)
{
    int ret;
    VirtualCssBus *css_bus;
    DeviceState *dev;

    s390_sclp_init();
    s390_memory_init(machine->ram_size);

    /* init CPUs */
    s390_init_cpus(machine);

    s390_flic_init();

    /* get a BUS */
    css_bus = virtual_css_bus_init();
    s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
                      machine->initrd_filename, "s390-ccw.img",
                      "s390-netboot.img", true);

    dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
    object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
                              OBJECT(dev), NULL);
    qdev_init_nofail(dev);

    /* register hypercalls */
    virtio_ccw_register_hcalls();

    if (kvm_enabled()) {
        kvm_s390_enable_css_support(s390_cpu_addr2state(0));
    }
    /*
     * Non mcss-e enabled guests only see the devices from the default
     * css, which is determined by the value of the squash_mcss property.
     * Note: we must not squash non virtual devices to css 0xFE.
     */
    if (css_bus->squash_mcss) {
        ret = css_create_css_image(0, true);
    } else {
        ret = css_create_css_image(VIRTUAL_CSSID, true);
    }
    assert(ret == 0);

    /* Create VirtIO network adapters */
    s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");

    /* Register savevm handler for guest TOD clock */
    register_savevm_live(NULL, "todclock", 0, 1, &savevm_gtod, kvm_state);
}

static void s390_cpu_plug(HotplugHandler *hotplug_dev,
                        DeviceState *dev, Error **errp)
{
    gchar *name;
    S390CPU *cpu = S390_CPU(dev);
    CPUState *cs = CPU(dev);

    name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num);
    object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name,
                             errp);
    g_free(name);
}

static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
                                     DeviceState *dev, Error **errp)
{
    if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
        s390_cpu_plug(hotplug_dev, dev, errp);
    }
}

static HotplugHandler *s390_get_hotplug_handler(MachineState *machine,
                                                DeviceState *dev)
{
    if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
        return HOTPLUG_HANDLER(machine);
    }
    return NULL;
}

static void s390_hot_add_cpu(const int64_t id, Error **errp)
{
    MachineState *machine = MACHINE(qdev_get_machine());

    s390x_new_cpu(machine->cpu_model, id, errp);
}

static void ccw_machine_class_init(ObjectClass *oc, void *data)
{
    MachineClass *mc = MACHINE_CLASS(oc);
    NMIClass *nc = NMI_CLASS(oc);
    HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
    S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);

    s390mc->ri_allowed = true;
    s390mc->cpu_model_allowed = true;
    s390mc->css_migration_enabled = true;
    s390mc->gs_allowed = true;
    mc->init = ccw_init;
    mc->reset = s390_machine_reset;
    mc->hot_add_cpu = s390_hot_add_cpu;
    mc->block_default_type = IF_VIRTIO;
    mc->no_cdrom = 1;
    mc->no_floppy = 1;
    mc->no_serial = 1;
    mc->no_parallel = 1;
    mc->no_sdcard = 1;
    mc->use_sclp = 1;
    mc->max_cpus = 248;
    mc->get_hotplug_handler = s390_get_hotplug_handler;
    hc->plug = s390_machine_device_plug;
    nc->nmi_monitor_handler = s390_nmi;
}

static inline bool machine_get_aes_key_wrap(Object *obj, Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    return ms->aes_key_wrap;
}

static inline void machine_set_aes_key_wrap(Object *obj, bool value,
                                            Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    ms->aes_key_wrap = value;
}

static inline bool machine_get_dea_key_wrap(Object *obj, Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    return ms->dea_key_wrap;
}

static inline void machine_set_dea_key_wrap(Object *obj, bool value,
                                            Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    ms->dea_key_wrap = value;
}

static S390CcwMachineClass *current_mc;

static S390CcwMachineClass *get_machine_class(void)
{
    if (unlikely(!current_mc)) {
        /*
        * No s390 ccw machine was instantiated, we are likely to
        * be called for the 'none' machine. The properties will
        * have their after-initialization values.
        */
        current_mc = S390_MACHINE_CLASS(
                     object_class_by_name(TYPE_S390_CCW_MACHINE));
    }
    return current_mc;
}

bool ri_allowed(void)
{
    if (!kvm_enabled()) {
        return false;
    }
    /* for "none" machine this results in true */
    return get_machine_class()->ri_allowed;
}

bool cpu_model_allowed(void)
{
    /* for "none" machine this results in true */
    return get_machine_class()->cpu_model_allowed;
}

bool gs_allowed(void)
{
    if (kvm_enabled()) {
        MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
        if (object_class_dynamic_cast(OBJECT_CLASS(mc),
                                      TYPE_S390_CCW_MACHINE)) {
            S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);

            return s390mc->gs_allowed;
        }
        /* Make sure the "none" machine can have gs */
        return true;
    }
    return false;
}

static char *machine_get_loadparm(Object *obj, Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    return g_memdup(ms->loadparm, sizeof(ms->loadparm));
}

static void machine_set_loadparm(Object *obj, const char *val, Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
    int i;

    for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) {
        uint8_t c = toupper(val[i]); /* mimic HMC */

        if (('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '.') ||
            (c == ' ')) {
            ms->loadparm[i] = c;
        } else {
            error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
                       c, c);
            return;
        }
    }

    for (; i < sizeof(ms->loadparm); i++) {
        ms->loadparm[i] = ' '; /* pad right with spaces */
    }
}
static inline bool machine_get_squash_mcss(Object *obj, Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    return ms->s390_squash_mcss;
}

static inline void machine_set_squash_mcss(Object *obj, bool value,
                                           Error **errp)
{
    S390CcwMachineState *ms = S390_CCW_MACHINE(obj);

    ms->s390_squash_mcss = value;
}

static inline void s390_machine_initfn(Object *obj)
{
    object_property_add_bool(obj, "aes-key-wrap",
                             machine_get_aes_key_wrap,
                             machine_set_aes_key_wrap, NULL);
    object_property_set_description(obj, "aes-key-wrap",
            "enable/disable AES key wrapping using the CPACF wrapping key",
            NULL);
    object_property_set_bool(obj, true, "aes-key-wrap", NULL);

    object_property_add_bool(obj, "dea-key-wrap",
                             machine_get_dea_key_wrap,
                             machine_set_dea_key_wrap, NULL);
    object_property_set_description(obj, "dea-key-wrap",
            "enable/disable DEA key wrapping using the CPACF wrapping key",
            NULL);
    object_property_set_bool(obj, true, "dea-key-wrap", NULL);
    object_property_add_str(obj, "loadparm",
            machine_get_loadparm, machine_set_loadparm, NULL);
    object_property_set_description(obj, "loadparm",
            "Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
            " to upper case) to pass to machine loader, boot manager,"
            " and guest kernel",
            NULL);
    object_property_add_bool(obj, "s390-squash-mcss",
                             machine_get_squash_mcss,
                             machine_set_squash_mcss, NULL);
    object_property_set_description(obj, "s390-squash-mcss",
            "enable/disable squashing subchannels into the default css",
            NULL);
    object_property_set_bool(obj, false, "s390-squash-mcss", NULL);
}

static const TypeInfo ccw_machine_info = {
    .name          = TYPE_S390_CCW_MACHINE,
    .parent        = TYPE_MACHINE,
    .abstract      = true,
    .instance_size = sizeof(S390CcwMachineState),
    .instance_init = s390_machine_initfn,
    .class_size = sizeof(S390CcwMachineClass),
    .class_init    = ccw_machine_class_init,
    .interfaces = (InterfaceInfo[]) {
        { TYPE_NMI },
        { TYPE_HOTPLUG_HANDLER},
        { }
    },
};

bool css_migration_enabled(void)
{
    return get_machine_class()->css_migration_enabled;
}

#define DEFINE_CCW_MACHINE(suffix, verstr, latest)                            \
    static void ccw_machine_##suffix##_class_init(ObjectClass *oc,            \
                                                  void *data)                 \
    {                                                                         \
        MachineClass *mc = MACHINE_CLASS(oc);                                 \
        ccw_machine_##suffix##_class_options(mc);                             \
        mc->desc = "VirtIO-ccw based S390 machine v" verstr;                  \
        if (latest) {                                                         \
            mc->alias = "s390-ccw-virtio";                                    \
            mc->is_default = 1;                                               \
        }                                                                     \
    }                                                                         \
    static void ccw_machine_##suffix##_instance_init(Object *obj)             \
    {                                                                         \
        MachineState *machine = MACHINE(obj);                                 \
        current_mc = S390_MACHINE_CLASS(MACHINE_GET_CLASS(machine));          \
        ccw_machine_##suffix##_instance_options(machine);                     \
    }                                                                         \
    static const TypeInfo ccw_machine_##suffix##_info = {                     \
        .name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr),                 \
        .parent = TYPE_S390_CCW_MACHINE,                                      \
        .class_init = ccw_machine_##suffix##_class_init,                      \
        .instance_init = ccw_machine_##suffix##_instance_init,                \
    };                                                                        \
    static void ccw_machine_register_##suffix(void)                           \
    {                                                                         \
        type_register_static(&ccw_machine_##suffix##_info);                   \
    }                                                                         \
    type_init(ccw_machine_register_##suffix)

#define CCW_COMPAT_2_9 \
        HW_COMPAT_2_9 \
        {\
            .driver   = TYPE_S390_STATTRIB,\
            .property = "migration-enabled",\
            .value    = "off",\
        },

#define CCW_COMPAT_2_8 \
        HW_COMPAT_2_8 \
        {\
            .driver   = TYPE_S390_FLIC_COMMON,\
            .property = "adapter_routes_max_batch",\
            .value    = "64",\
        },

#define CCW_COMPAT_2_7 \
        HW_COMPAT_2_7

#define CCW_COMPAT_2_6 \
        HW_COMPAT_2_6 \
        {\
            .driver   = TYPE_S390_IPL,\
            .property = "iplbext_migration",\
            .value    = "off",\
        }, {\
            .driver   = TYPE_VIRTUAL_CSS_BRIDGE,\
            .property = "css_dev_path",\
            .value    = "off",\
        },

#define CCW_COMPAT_2_5 \
        HW_COMPAT_2_5

#define CCW_COMPAT_2_4 \
        HW_COMPAT_2_4 \
        {\
            .driver   = TYPE_S390_SKEYS,\
            .property = "migration-enabled",\
            .value    = "off",\
        },{\
            .driver   = "virtio-blk-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "virtio-balloon-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "virtio-serial-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "virtio-9p-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "virtio-rng-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "virtio-net-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "virtio-scsi-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },{\
            .driver   = "vhost-scsi-ccw",\
            .property = "max_revision",\
            .value    = "0",\
        },

static void ccw_machine_2_10_instance_options(MachineState *machine)
{
    if (css_migration_enabled()) {
        css_register_vmstate();
    }
}

static void ccw_machine_2_10_class_options(MachineClass *mc)
{
}
DEFINE_CCW_MACHINE(2_10, "2.10", true);

static void ccw_machine_2_9_instance_options(MachineState *machine)
{
    ccw_machine_2_10_instance_options(machine);
    s390_cpudef_featoff_greater(12, 1, S390_FEAT_ESOP);
    s390_cpudef_featoff_greater(12, 1, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2);
    s390_cpudef_featoff_greater(12, 1, S390_FEAT_ZPCI);
    s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_INT_SUPPRESSION);
    s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_EVENT_NOTIFICATION);
}

static void ccw_machine_2_9_class_options(MachineClass *mc)
{
    S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);

    s390mc->gs_allowed = false;
    ccw_machine_2_10_class_options(mc);
    SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9);
    s390mc->css_migration_enabled = false;
}
DEFINE_CCW_MACHINE(2_9, "2.9", false);

static void ccw_machine_2_8_instance_options(MachineState *machine)
{
    ccw_machine_2_9_instance_options(machine);
}

static void ccw_machine_2_8_class_options(MachineClass *mc)
{
    ccw_machine_2_9_class_options(mc);
    SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8);
}
DEFINE_CCW_MACHINE(2_8, "2.8", false);

static void ccw_machine_2_7_instance_options(MachineState *machine)
{
    ccw_machine_2_8_instance_options(machine);
}

static void ccw_machine_2_7_class_options(MachineClass *mc)
{
    S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);

    s390mc->cpu_model_allowed = false;
    ccw_machine_2_8_class_options(mc);
    SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7);
}
DEFINE_CCW_MACHINE(2_7, "2.7", false);

static void ccw_machine_2_6_instance_options(MachineState *machine)
{
    ccw_machine_2_7_instance_options(machine);
}

static void ccw_machine_2_6_class_options(MachineClass *mc)
{
    S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);

    s390mc->ri_allowed = false;
    ccw_machine_2_7_class_options(mc);
    SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6);
}
DEFINE_CCW_MACHINE(2_6, "2.6", false);

static void ccw_machine_2_5_instance_options(MachineState *machine)
{
    ccw_machine_2_6_instance_options(machine);
}

static void ccw_machine_2_5_class_options(MachineClass *mc)
{
    ccw_machine_2_6_class_options(mc);
    SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5);
}
DEFINE_CCW_MACHINE(2_5, "2.5", false);

static void ccw_machine_2_4_instance_options(MachineState *machine)
{
    ccw_machine_2_5_instance_options(machine);
}

static void ccw_machine_2_4_class_options(MachineClass *mc)
{
    ccw_machine_2_5_class_options(mc);
    SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4);
}
DEFINE_CCW_MACHINE(2_4, "2.4", false);

static void ccw_machine_register_types(void)
{
    type_register_static(&ccw_machine_info);
}

type_init(ccw_machine_register_types)
Commit	Line	Data
a5c95808 CH	1	/*
	2	* virtio ccw machine
	3	*
	4	* Copyright 2012 IBM Corp.
	5	* Author(s): Cornelia Huck <[email protected]>
	6	*
	7	* This work is licensed under the terms of the GNU GPL, version 2 or (at
	8	* your option) any later version. See the COPYING file in the top-level
	9	* directory.
	10	*/
	11
9615495a	12	#include "qemu/osdep.h"
da34e65c	13	#include "qapi/error.h"
4771d756 PB	14	#include "qemu-common.h"
4771d756 PB	15	#include "cpu.h"
a5c95808 CH	16	#include "hw/boards.h"
	17	#include "exec/address-spaces.h"
	18	#include "s390-virtio.h"
83c9f4ca	19	#include "hw/s390x/sclp.h"
3a553fc6	20	#include "hw/s390x/s390_flic.h"
bd3f16ac PB	21	#include "hw/s390x/ioinst.h"
bd3f16ac PB	22	#include "hw/s390x/css.h"
a5c95808	23	#include "virtio-ccw.h"
b6fe0124	24	#include "qemu/config-file.h"
8cba80c3	25	#include "s390-pci-bus.h"
0f5f6691	26	#include "hw/s390x/storage-keys.h"
903fd80b	27	#include "hw/s390x/storage-attributes.h"
54d8ec84	28	#include "hw/compat.h"
04ca4b92	29	#include "ipl.h"
8b8a61ad	30	#include "hw/s390x/s390-virtio-ccw.h"
dd70bd0d	31	#include "hw/s390x/css-bridge.h"
f2a8f0a6	32	#include "migration/register.h"
7223bcce	33	#include "cpu_models.h"
2eb1cd07	34
09c7f58c	35	static const char *const reset_dev_types[] = {
3f9e4859	36	TYPE_VIRTUAL_CSS_BRIDGE,
09c7f58c DH	37	"s390-sclp-event-facility",
	38	"s390-flic",
	39	"diag288",
	40	};
	41
d9f090ec	42	void subsystem_reset(void)
4e872a3f	43	{
09c7f58c DH	44	DeviceState *dev;
09c7f58c DH	45	int i;
4e872a3f	46
09c7f58c DH	47	for (i = 0; i < ARRAY_SIZE(reset_dev_types); i++) {
	48	dev = DEVICE(object_resolve_path_type("", reset_dev_types[i], NULL));
	49	if (dev) {
	50	qdev_reset_all(dev);
	51	}
0c7322cf	52	}
4e872a3f CB	53	}
4e872a3f CB	54
a5c95808 CH	55	static int virtio_ccw_hcall_notify(const uint64_t *args)
	56	{
	57	uint64_t subch_id = args[0];
	58	uint64_t queue = args[1];
	59	SubchDev *sch;
	60	int cssid, ssid, schid, m;
	61
	62	if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
	63	return -EINVAL;
	64	}
	65	sch = css_find_subch(m, cssid, ssid, schid);
	66	if (!sch \|\| !css_subch_visible(sch)) {
	67	return -EINVAL;
	68	}
b1914b82	69	if (queue >= VIRTIO_QUEUE_MAX) {
b57ed9bf CH	70	return -EINVAL;
b57ed9bf CH	71	}
a5c95808 CH	72	virtio_queue_notify(virtio_ccw_get_vdev(sch), queue);
	73	return 0;
	74
	75	}
	76
	77	static int virtio_ccw_hcall_early_printk(const uint64_t *args)
	78	{
	79	uint64_t mem = args[0];
	80
	81	if (mem < ram_size) {
	82	/* Early printk */
	83	return 0;
	84	}
	85	return -EINVAL;
	86	}
	87
	88	static void virtio_ccw_register_hcalls(void)
	89	{
	90	s390_register_virtio_hypercall(KVM_S390_VIRTIO_CCW_NOTIFY,
	91	virtio_ccw_hcall_notify);
	92	/* Tolerate early printk. */
	93	s390_register_virtio_hypercall(KVM_S390_VIRTIO_NOTIFY,
	94	virtio_ccw_hcall_early_printk);
	95	}
	96
80d23275	97	void s390_memory_init(ram_addr_t mem_size)
a5c95808	98	{
a5c95808 CH	99	MemoryRegion *sysmem = get_system_memory();
a5c95808 CH	100	MemoryRegion *ram = g_new(MemoryRegion, 1);
80d23275 DH	101
80d23275 DH	102	/* allocate RAM for core */
ae23a335	103	memory_region_allocate_system_memory(ram, NULL, "s390.ram", mem_size);
80d23275 DH	104	memory_region_add_subregion(sysmem, 0, ram);
	105
	106	/* Initialize storage key device */
	107	s390_skeys_init();
903fd80b CI	108	/* Initialize storage attributes device */
903fd80b CI	109	s390_stattrib_init();
80d23275 DH	110	}
80d23275 DH	111
1b6e7482 LV	112	static SaveVMHandlers savevm_gtod = {
	113	.save_state = gtod_save,
	114	.load_state = gtod_load,
	115	};
	116
80d23275 DH	117	static void ccw_init(MachineState *machine)
80d23275 DH	118	{
a5c95808 CH	119	int ret;
a5c95808 CH	120	VirtualCssBus *css_bus;
8cba80c3	121	DeviceState *dev;
b6fe0124	122
1cf065fb	123	s390_sclp_init();
80d23275	124	s390_memory_init(machine->ram_size);
a5c95808	125
3720d335 YMZ	126	/* init CPUs */
	127	s390_init_cpus(machine);
	128
c572d3f3 FL	129	s390_flic_init();
c572d3f3 FL	130
a5c95808 CH	131	/* get a BUS */
a5c95808 CH	132	css_bus = virtual_css_bus_init();
3ef96221	133	s390_init_ipl_dev(machine->kernel_filename, machine->kernel_cmdline,
5f31ade0 FA	134	machine->initrd_filename, "s390-ccw.img",
5f31ade0 FA	135	"s390-netboot.img", true);
a5c95808	136
8cba80c3 FB	137	dev = qdev_create(NULL, TYPE_S390_PCI_HOST_BRIDGE);
	138	object_property_add_child(qdev_get_machine(), TYPE_S390_PCI_HOST_BRIDGE,
	139	OBJECT(dev), NULL);
	140	qdev_init_nofail(dev);
	141
a5c95808 CH	142	/* register hypercalls */
	143	virtio_ccw_register_hcalls();
	144
a5c95808 CH	145	if (kvm_enabled()) {
	146	kvm_s390_enable_css_support(s390_cpu_addr2state(0));
	147	}
	148	/*
817d4a6b DJS	149	* Non mcss-e enabled guests only see the devices from the default
	150	* css, which is determined by the value of the squash_mcss property.
	151	* Note: we must not squash non virtual devices to css 0xFE.
a5c95808	152	*/
817d4a6b DJS	153	if (css_bus->squash_mcss) {
	154	ret = css_create_css_image(0, true);
	155	} else {
	156	ret = css_create_css_image(VIRTUAL_CSSID, true);
	157	}
a5c95808 CH	158	assert(ret == 0);
	159
	160	/* Create VirtIO network adapters */
	161	s390_create_virtio_net(BUS(css_bus), "virtio-net-ccw");
3f9e59bb JH	162
3f9e59bb JH	163	/* Register savevm handler for guest TOD clock */
1b6e7482	164	register_savevm_live(NULL, "todclock", 0, 1, &savevm_gtod, kvm_state);
a5c95808 CH	165	}
a5c95808 CH	166
502edbf8 MR	167	static void s390_cpu_plug(HotplugHandler *hotplug_dev,
	168	DeviceState dev, Error *errp)
	169	{
	170	gchar *name;
	171	S390CPU *cpu = S390_CPU(dev);
	172	CPUState *cs = CPU(dev);
	173
	174	name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num);
	175	object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs), name,
	176	errp);
	177	g_free(name);
	178	}
	179
	180	static void s390_machine_device_plug(HotplugHandler *hotplug_dev,
	181	DeviceState dev, Error *errp)
	182	{
	183	if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
	184	s390_cpu_plug(hotplug_dev, dev, errp);
	185	}
	186	}
	187
	188	static HotplugHandler s390_get_hotplug_handler(MachineState machine,
	189	DeviceState *dev)
	190	{
	191	if (object_dynamic_cast(OBJECT(dev), TYPE_CPU)) {
	192	return HOTPLUG_HANDLER(machine);
	193	}
	194	return NULL;
	195	}
	196
a006b67f MR	197	static void s390_hot_add_cpu(const int64_t id, Error **errp)
	198	{
	199	MachineState *machine = MACHINE(qdev_get_machine());
a006b67f	200
6b62d961	201	s390x_new_cpu(machine->cpu_model, id, errp);
a006b67f MR	202	}
a006b67f MR	203
d07aa7c7 AK	204	static void ccw_machine_class_init(ObjectClass oc, void data)
	205	{
	206	MachineClass *mc = MACHINE_CLASS(oc);
3dd7852f	207	NMIClass *nc = NMI_CLASS(oc);
502edbf8	208	HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
9700230b	209	S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
d07aa7c7	210
9700230b	211	s390mc->ri_allowed = true;
e73316d5	212	s390mc->cpu_model_allowed = true;
e996583e	213	s390mc->css_migration_enabled = true;
62deb62d	214	s390mc->gs_allowed = true;
d07aa7c7	215	mc->init = ccw_init;
db3b2566	216	mc->reset = s390_machine_reset;
a006b67f	217	mc->hot_add_cpu = s390_hot_add_cpu;
d07aa7c7 AK	218	mc->block_default_type = IF_VIRTIO;
	219	mc->no_cdrom = 1;
	220	mc->no_floppy = 1;
	221	mc->no_serial = 1;
	222	mc->no_parallel = 1;
	223	mc->no_sdcard = 1;
fb85b34d	224	mc->use_sclp = 1;
dcddc75e	225	mc->max_cpus = 248;
502edbf8 MR	226	mc->get_hotplug_handler = s390_get_hotplug_handler;
502edbf8 MR	227	hc->plug = s390_machine_device_plug;
3dd7852f	228	nc->nmi_monitor_handler = s390_nmi;
d07aa7c7 AK	229	}
d07aa7c7 AK	230
2eb1cd07 TK	231	static inline bool machine_get_aes_key_wrap(Object obj, Error *errp)
	232	{
	233	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	234
	235	return ms->aes_key_wrap;
	236	}
	237
	238	static inline void machine_set_aes_key_wrap(Object *obj, bool value,
	239	Error **errp)
	240	{
	241	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	242
	243	ms->aes_key_wrap = value;
	244	}
	245
	246	static inline bool machine_get_dea_key_wrap(Object obj, Error *errp)
	247	{
	248	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	249
	250	return ms->dea_key_wrap;
	251	}
	252
	253	static inline void machine_set_dea_key_wrap(Object *obj, bool value,
	254	Error **errp)
	255	{
	256	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	257
	258	ms->dea_key_wrap = value;
	259	}
	260
cec8bbf7	261	static S390CcwMachineClass *current_mc;
9700230b	262
cec8bbf7 HP	263	static S390CcwMachineClass *get_machine_class(void)
	264	{
	265	if (unlikely(!current_mc)) {
392529cb	266	/*
cec8bbf7 HP	267	* No s390 ccw machine was instantiated, we are likely to
	268	* be called for the 'none' machine. The properties will
	269	* have their after-initialization values.
	270	*/
	271	current_mc = S390_MACHINE_CLASS(
	272	object_class_by_name(TYPE_S390_CCW_MACHINE));
9700230b	273	}
cec8bbf7	274	return current_mc;
9700230b FZ	275	}
9700230b FZ	276
cec8bbf7	277	bool ri_allowed(void)
e73316d5	278	{
cec8bbf7 HP	279	if (!kvm_enabled()) {
cec8bbf7 HP	280	return false;
e73316d5	281	}
cec8bbf7 HP	282	/* for "none" machine this results in true */
	283	return get_machine_class()->ri_allowed;
	284	}
	285
	286	bool cpu_model_allowed(void)
	287	{
	288	/* for "none" machine this results in true */
	289	return get_machine_class()->cpu_model_allowed;
e73316d5 CB	290	}
e73316d5 CB	291
62deb62d FZ	292	bool gs_allowed(void)
	293	{
	294	if (kvm_enabled()) {
	295	MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
	296	if (object_class_dynamic_cast(OBJECT_CLASS(mc),
	297	TYPE_S390_CCW_MACHINE)) {
	298	S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
	299
	300	return s390mc->gs_allowed;
	301	}
	302	/* Make sure the "none" machine can have gs */
	303	return true;
	304	}
	305	return false;
	306	}
	307
7104bae9 FA	308	static char machine_get_loadparm(Object obj, Error **errp)
	309	{
	310	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	311
	312	return g_memdup(ms->loadparm, sizeof(ms->loadparm));
	313	}
	314
	315	static void machine_set_loadparm(Object obj, const char val, Error **errp)
	316	{
	317	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	318	int i;
	319
	320	for (i = 0; i < sizeof(ms->loadparm) && val[i]; i++) {
	321	uint8_t c = toupper(val[i]); /* mimic HMC */
	322
	323	if (('A' <= c && c <= 'Z') \|\| ('0' <= c && c <= '9') \|\| (c == '.') \|\|
	324	(c == ' ')) {
	325	ms->loadparm[i] = c;
	326	} else {
	327	error_setg(errp, "LOADPARM: invalid character '%c' (ASCII 0x%02x)",
	328	c, c);
	329	return;
	330	}
	331	}
	332
	333	for (; i < sizeof(ms->loadparm); i++) {
	334	ms->loadparm[i] = ' '; /* pad right with spaces */
	335	}
	336	}
274250c3 XFR	337	static inline bool machine_get_squash_mcss(Object obj, Error *errp)
	338	{
	339	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	340
	341	return ms->s390_squash_mcss;
	342	}
	343
	344	static inline void machine_set_squash_mcss(Object *obj, bool value,
	345	Error **errp)
	346	{
	347	S390CcwMachineState *ms = S390_CCW_MACHINE(obj);
	348
	349	ms->s390_squash_mcss = value;
	350	}
7104bae9	351
2eb1cd07 TK	352	static inline void s390_machine_initfn(Object *obj)
	353	{
	354	object_property_add_bool(obj, "aes-key-wrap",
	355	machine_get_aes_key_wrap,
	356	machine_set_aes_key_wrap, NULL);
	357	object_property_set_description(obj, "aes-key-wrap",
	358	"enable/disable AES key wrapping using the CPACF wrapping key",
	359	NULL);
	360	object_property_set_bool(obj, true, "aes-key-wrap", NULL);
	361
	362	object_property_add_bool(obj, "dea-key-wrap",
	363	machine_get_dea_key_wrap,
	364	machine_set_dea_key_wrap, NULL);
	365	object_property_set_description(obj, "dea-key-wrap",
	366	"enable/disable DEA key wrapping using the CPACF wrapping key",
	367	NULL);
	368	object_property_set_bool(obj, true, "dea-key-wrap", NULL);
7104bae9 FA	369	object_property_add_str(obj, "loadparm",
	370	machine_get_loadparm, machine_set_loadparm, NULL);
	371	object_property_set_description(obj, "loadparm",
	372	"Up to 8 chars in set of [A-Za-z0-9. ] (lower case chars converted"
	373	" to upper case) to pass to machine loader, boot manager,"
	374	" and guest kernel",
	375	NULL);
274250c3 XFR	376	object_property_add_bool(obj, "s390-squash-mcss",
	377	machine_get_squash_mcss,
	378	machine_set_squash_mcss, NULL);
	379	object_property_set_description(obj, "s390-squash-mcss",
	380	"enable/disable squashing subchannels into the default css",
	381	NULL);
	382	object_property_set_bool(obj, false, "s390-squash-mcss", NULL);
2eb1cd07 TK	383	}
2eb1cd07 TK	384
d07aa7c7 AK	385	static const TypeInfo ccw_machine_info = {
	386	.name = TYPE_S390_CCW_MACHINE,
	387	.parent = TYPE_MACHINE,
c4d3c0a2	388	.abstract = true,
2eb1cd07 TK	389	.instance_size = sizeof(S390CcwMachineState),
2eb1cd07 TK	390	.instance_init = s390_machine_initfn,
9700230b	391	.class_size = sizeof(S390CcwMachineClass),
d07aa7c7	392	.class_init = ccw_machine_class_init,
3dd7852f AK	393	.interfaces = (InterfaceInfo[]) {
3dd7852f AK	394	{ TYPE_NMI },
502edbf8	395	{ TYPE_HOTPLUG_HANDLER},
3dd7852f AK	396	{ }
3dd7852f AK	397	},
a5c95808 CH	398	};
a5c95808 CH	399
52629b3b HP	400	bool css_migration_enabled(void)
	401	{
	402	return get_machine_class()->css_migration_enabled;
	403	}
	404
4fca6548 JF	405	#define DEFINE_CCW_MACHINE(suffix, verstr, latest) \
	406	static void ccw_machine_##suffix##_class_init(ObjectClass *oc, \
	407	void *data) \
	408	{ \
	409	MachineClass *mc = MACHINE_CLASS(oc); \
	410	ccw_machine_##suffix##_class_options(mc); \
	411	mc->desc = "VirtIO-ccw based S390 machine v" verstr; \
	412	if (latest) { \
	413	mc->alias = "s390-ccw-virtio"; \
	414	mc->is_default = 1; \
	415	} \
	416	} \
	417	static void ccw_machine_##suffix##_instance_init(Object *obj) \
	418	{ \
	419	MachineState *machine = MACHINE(obj); \
cec8bbf7	420	current_mc = S390_MACHINE_CLASS(MACHINE_GET_CLASS(machine)); \
4fca6548 JF	421	ccw_machine_##suffix##_instance_options(machine); \
	422	} \
	423	static const TypeInfo ccw_machine_##suffix##_info = { \
	424	.name = MACHINE_TYPE_NAME("s390-ccw-virtio-" verstr), \
	425	.parent = TYPE_S390_CCW_MACHINE, \
	426	.class_init = ccw_machine_##suffix##_class_init, \
	427	.instance_init = ccw_machine_##suffix##_instance_init, \
	428	}; \
	429	static void ccw_machine_register_##suffix(void) \
	430	{ \
	431	type_register_static(&ccw_machine_##suffix##_info); \
	432	} \
0e6aac87	433	type_init(ccw_machine_register_##suffix)
4fca6548	434
10890873	435	#define CCW_COMPAT_2_9 \
903fd80b CI	436	HW_COMPAT_2_9 \
	437	{\
	438	.driver = TYPE_S390_STATTRIB,\
	439	.property = "migration-enabled",\
	440	.value = "off",\
	441	},
10890873	442
113725a6	443	#define CCW_COMPAT_2_8 \
069097da HP	444	HW_COMPAT_2_8 \
	445	{\
	446	.driver = TYPE_S390_FLIC_COMMON,\
	447	.property = "adapter_routes_max_batch",\
	448	.value = "64",\
	449	},
113725a6	450
61823988 CH	451	#define CCW_COMPAT_2_7 \
	452	HW_COMPAT_2_7
	453
946e55f3	454	#define CCW_COMPAT_2_6 \
04ca4b92 AY	455	HW_COMPAT_2_6 \
	456	{\
	457	.driver = TYPE_S390_IPL,\
	458	.property = "iplbext_migration",\
	459	.value = "off",\
2a79eb1a CH	460	}, {\
	461	.driver = TYPE_VIRTUAL_CSS_BRIDGE,\
	462	.property = "css_dev_path",\
	463	.value = "off",\
04ca4b92	464	},
946e55f3	465
cf87e0a3 SL	466	#define CCW_COMPAT_2_5 \
	467	HW_COMPAT_2_5
	468
9ef40173	469	#define CCW_COMPAT_2_4 \
54d8ec84	470	HW_COMPAT_2_4 \
9ef40173 JH	471	{\
	472	.driver = TYPE_S390_SKEYS,\
	473	.property = "migration-enabled",\
	474	.value = "off",\
542571d5 CH	475	},{\
	476	.driver = "virtio-blk-ccw",\
	477	.property = "max_revision",\
	478	.value = "0",\
	479	},{\
	480	.driver = "virtio-balloon-ccw",\
	481	.property = "max_revision",\
	482	.value = "0",\
	483	},{\
	484	.driver = "virtio-serial-ccw",\
	485	.property = "max_revision",\
	486	.value = "0",\
	487	},{\
	488	.driver = "virtio-9p-ccw",\
	489	.property = "max_revision",\
	490	.value = "0",\
	491	},{\
	492	.driver = "virtio-rng-ccw",\
	493	.property = "max_revision",\
	494	.value = "0",\
085b0b05 CH	495	},{\
	496	.driver = "virtio-net-ccw",\
	497	.property = "max_revision",\
	498	.value = "0",\
	499	},{\
	500	.driver = "virtio-scsi-ccw",\
	501	.property = "max_revision",\
	502	.value = "0",\
	503	},{\
	504	.driver = "vhost-scsi-ccw",\
	505	.property = "max_revision",\
	506	.value = "0",\
9ef40173 JH	507	},
9ef40173 JH	508
10890873 CH	509	static void ccw_machine_2_10_instance_options(MachineState *machine)
10890873 CH	510	{
e996583e HP	511	if (css_migration_enabled()) {
	512	css_register_vmstate();
	513	}
10890873 CH	514	}
	515
	516	static void ccw_machine_2_10_class_options(MachineClass *mc)
	517	{
	518	}
	519	DEFINE_CCW_MACHINE(2_10, "2.10", true);
	520
113725a6 CH	521	static void ccw_machine_2_9_instance_options(MachineState *machine)
113725a6 CH	522	{
10890873	523	ccw_machine_2_10_instance_options(machine);
7223bcce JH	524	s390_cpudef_featoff_greater(12, 1, S390_FEAT_ESOP);
7223bcce JH	525	s390_cpudef_featoff_greater(12, 1, S390_FEAT_SIDE_EFFECT_ACCESS_ESOP2);
3b00f702 YMZ	526	s390_cpudef_featoff_greater(12, 1, S390_FEAT_ZPCI);
	527	s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_INT_SUPPRESSION);
	528	s390_cpudef_featoff_greater(12, 1, S390_FEAT_ADAPTER_EVENT_NOTIFICATION);
113725a6 CH	529	}
	530
	531	static void ccw_machine_2_9_class_options(MachineClass *mc)
	532	{
52629b3b HP	533	S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
52629b3b HP	534
62deb62d	535	s390mc->gs_allowed = false;
10890873 CH	536	ccw_machine_2_10_class_options(mc);
10890873 CH	537	SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_9);
52629b3b	538	s390mc->css_migration_enabled = false;
113725a6	539	}
10890873	540	DEFINE_CCW_MACHINE(2_9, "2.9", false);
113725a6	541
61823988 CH	542	static void ccw_machine_2_8_instance_options(MachineState *machine)
61823988 CH	543	{
113725a6	544	ccw_machine_2_9_instance_options(machine);
61823988 CH	545	}
	546
	547	static void ccw_machine_2_8_class_options(MachineClass *mc)
	548	{
113725a6 CH	549	ccw_machine_2_9_class_options(mc);
113725a6 CH	550	SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_8);
61823988	551	}
113725a6	552	DEFINE_CCW_MACHINE(2_8, "2.8", false);
61823988	553
946e55f3 CH	554	static void ccw_machine_2_7_instance_options(MachineState *machine)
946e55f3 CH	555	{
61823988	556	ccw_machine_2_8_instance_options(machine);
946e55f3 CH	557	}
	558
	559	static void ccw_machine_2_7_class_options(MachineClass *mc)
	560	{
e73316d5 CB	561	S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
	562
	563	s390mc->cpu_model_allowed = false;
61823988 CH	564	ccw_machine_2_8_class_options(mc);
61823988 CH	565	SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_7);
946e55f3	566	}
61823988	567	DEFINE_CCW_MACHINE(2_7, "2.7", false);
946e55f3	568
4fca6548	569	static void ccw_machine_2_6_instance_options(MachineState *machine)
c4d3c0a2	570	{
946e55f3	571	ccw_machine_2_7_instance_options(machine);
c4d3c0a2 CB	572	}
c4d3c0a2 CB	573
4fca6548	574	static void ccw_machine_2_6_class_options(MachineClass *mc)
84b48ad6	575	{
9700230b FZ	576	S390CcwMachineClass *s390mc = S390_MACHINE_CLASS(mc);
	577
	578	s390mc->ri_allowed = false;
946e55f3 CH	579	ccw_machine_2_7_class_options(mc);
946e55f3 CH	580	SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_6);
84b48ad6	581	}
946e55f3	582	DEFINE_CCW_MACHINE(2_6, "2.6", false);
84b48ad6	583
4fca6548 JF	584	static void ccw_machine_2_5_instance_options(MachineState *machine)
4fca6548 JF	585	{
946e55f3	586	ccw_machine_2_6_instance_options(machine);
4fca6548	587	}
84b48ad6	588
4fca6548	589	static void ccw_machine_2_5_class_options(MachineClass *mc)
b21b7598	590	{
946e55f3	591	ccw_machine_2_6_class_options(mc);
4fca6548 JF	592	SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_5);
	593	}
	594	DEFINE_CCW_MACHINE(2_5, "2.5", false);
b21b7598	595
4fca6548 JF	596	static void ccw_machine_2_4_instance_options(MachineState *machine)
	597	{
	598	ccw_machine_2_5_instance_options(machine);
b21b7598 CH	599	}
b21b7598 CH	600
4fca6548 JF	601	static void ccw_machine_2_4_class_options(MachineClass *mc)
4fca6548 JF	602	{
946e55f3	603	ccw_machine_2_5_class_options(mc);
4fca6548 JF	604	SET_MACHINE_COMPAT(mc, CCW_COMPAT_2_4);
	605	}
	606	DEFINE_CCW_MACHINE(2_4, "2.4", false);
b21b7598	607
d07aa7c7	608	static void ccw_machine_register_types(void)
a5c95808	609	{
d07aa7c7	610	type_register_static(&ccw_machine_info);
a5c95808 CH	611	}
a5c95808 CH	612
d07aa7c7	613	type_init(ccw_machine_register_types)