Commit 605c690b authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/kraxel/tags/pull-bootindex-20141015-1' into staging 



allow changing bootorder via monitor at runtime,
by making bootindex a writable qom property.

* remotes/kraxel/tags/pull-bootindex-20141015-1: (34 commits)
  bootindex: change fprintf to error_report
  bootindex: delete bootindex when device is removed
  bootindex: move calling add_boot_device_patch to bootindex setter function
  ide: add calling add_boot_device_patch in bootindex setter function
  nvma: ide: add bootindex to qom property
  usb-storage: add bootindex to qom property
  virtio-blk: alias bootindex property explicitly for virt-blk-pci/ccw/s390
  block: remove bootindex property from qdev to qom
  virtio-blk: add bootindex to qom property
  ide: add bootindex to qom property
  scsi: add bootindex to qom property
  isa-fdc: remove bootindexA/B property from qdev to qom
  redirect: remove bootindex property from qdev to qom
  vfio: remove bootindex property from qdev to qom
  pci-assign: remove bootindex property from qdev to qom
  host-libusb: remove bootindex property from qdev to qom
  virtio-net: alias bootindex property explicitly for virt-net-pci/ccw/s390
  net: remove bootindex property from qdev to qom
  usb-net: add bootindex to qom property
  vmxnet3: add bootindex to qom property
  ...

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents 89b516d8 54086fe5

Makefile.target

+1 −1
Original line number Diff line number Diff line
@@ -127,7 +127,7 @@ endif #CONFIG_BSD_USER 
# System emulator target

ifdef CONFIG_SOFTMMU

obj-y += arch_init.o cpus.o monitor.o gdbstub.o balloon.o ioport.o numa.o

obj-y += qtest.o

obj-y += qtest.o bootdevice.o

obj-y += hw/

obj-$(CONFIG_FDT) += device_tree.o

obj-$(CONFIG_KVM) += kvm-all.o

bootdevice.c

0 → 100644
+258 −0
Original line number Diff line number Diff line 
/*

 * QEMU Boot Device Implement

 *

 * Copyright (c) 2014 HUAWEI TECHNOLOGIES CO.,LTD.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

 * copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 * THE SOFTWARE.

 */



#include "sysemu/sysemu.h"

#include "qapi/visitor.h"

#include "qemu/error-report.h"



typedef struct FWBootEntry FWBootEntry;



struct FWBootEntry {

    QTAILQ_ENTRY(FWBootEntry) link;

    int32_t bootindex;

    DeviceState *dev;

    char *suffix;

};



static QTAILQ_HEAD(, FWBootEntry) fw_boot_order =

    QTAILQ_HEAD_INITIALIZER(fw_boot_order);



void check_boot_index(int32_t bootindex, Error **errp)

{

    FWBootEntry *i;



    if (bootindex >= 0) {

        QTAILQ_FOREACH(i, &fw_boot_order, link) {

            if (i->bootindex == bootindex) {

                error_setg(errp, "The bootindex %d has already been used",

                           bootindex);

                return;

            }

        }

    }

}



void del_boot_device_path(DeviceState *dev, const char *suffix)

{

    FWBootEntry *i;



    if (dev == NULL) {

        return;

    }



    QTAILQ_FOREACH(i, &fw_boot_order, link) {

        if ((!suffix || !g_strcmp0(i->suffix, suffix)) &&

             i->dev == dev) {

            QTAILQ_REMOVE(&fw_boot_order, i, link);

            g_free(i->suffix);

            g_free(i);



            break;

        }

    }

}



void add_boot_device_path(int32_t bootindex, DeviceState *dev,

                          const char *suffix)

{

    FWBootEntry *node, *i;



    if (bootindex < 0) {

        del_boot_device_path(dev, suffix);

        return;

    }



    assert(dev != NULL || suffix != NULL);



    del_boot_device_path(dev, suffix);



    node = g_malloc0(sizeof(FWBootEntry));

    node->bootindex = bootindex;

    node->suffix = g_strdup(suffix);

    node->dev = dev;



    QTAILQ_FOREACH(i, &fw_boot_order, link) {

        if (i->bootindex == bootindex) {

            error_report("Two devices with same boot index %d", bootindex);

            exit(1);

        } else if (i->bootindex < bootindex) {

            continue;

        }

        QTAILQ_INSERT_BEFORE(i, node, link);

        return;

    }

    QTAILQ_INSERT_TAIL(&fw_boot_order, node, link);

}



DeviceState *get_boot_device(uint32_t position)

{

    uint32_t counter = 0;

    FWBootEntry *i = NULL;

    DeviceState *res = NULL;



    if (!QTAILQ_EMPTY(&fw_boot_order)) {

        QTAILQ_FOREACH(i, &fw_boot_order, link) {

            if (counter == position) {

                res = i->dev;

                break;

            }

            counter++;

        }

    }

    return res;

}



/*

 * This function returns null terminated string that consist of new line

 * separated device paths.

 *

 * memory pointed by "size" is assigned total length of the array in bytes

 *

 */

char *get_boot_devices_list(size_t *size, bool ignore_suffixes)

{

    FWBootEntry *i;

    size_t total = 0;

    char *list = NULL;



    QTAILQ_FOREACH(i, &fw_boot_order, link) {

        char *devpath = NULL, *bootpath;

        size_t len;



        if (i->dev) {

            devpath = qdev_get_fw_dev_path(i->dev);

            assert(devpath);

        }



        if (i->suffix && !ignore_suffixes && devpath) {

            size_t bootpathlen = strlen(devpath) + strlen(i->suffix) + 1;



            bootpath = g_malloc(bootpathlen);

            snprintf(bootpath, bootpathlen, "%s%s", devpath, i->suffix);

            g_free(devpath);

        } else if (devpath) {

            bootpath = devpath;

        } else if (!ignore_suffixes) {

            assert(i->suffix);

            bootpath = g_strdup(i->suffix);

        } else {

            bootpath = g_strdup("");

        }



        if (total) {

            list[total-1] = '\n';

        }

        len = strlen(bootpath) + 1;

        list = g_realloc(list, total + len);

        memcpy(&list[total], bootpath, len);

        total += len;

        g_free(bootpath);

    }



    *size = total;



    if (boot_strict && *size > 0) {

        list[total-1] = '\n';

        list = g_realloc(list, total + 5);

        memcpy(&list[total], "HALT", 5);

        *size = total + 5;

    }

    return list;

}



typedef struct {

    int32_t *bootindex;

    const char *suffix;

    DeviceState *dev;

} BootIndexProperty;



static void device_get_bootindex(Object *obj, Visitor *v, void *opaque,

                                 const char *name, Error **errp)

{

    BootIndexProperty *prop = opaque;

    visit_type_int32(v, prop->bootindex, name, errp);

}



static void device_set_bootindex(Object *obj, Visitor *v, void *opaque,

                                 const char *name, Error **errp)

{

    BootIndexProperty *prop = opaque;

    int32_t boot_index;

    Error *local_err = NULL;



    visit_type_int32(v, &boot_index, name, &local_err);

    if (local_err) {

        goto out;

    }

    /* check whether bootindex is present in fw_boot_order list  */

    check_boot_index(boot_index, &local_err);

    if (local_err) {

        goto out;

    }

    /* change bootindex to a new one */

    *prop->bootindex = boot_index;



    add_boot_device_path(*prop->bootindex, prop->dev, prop->suffix);



out:

    if (local_err) {

        error_propagate(errp, local_err);

    }

}



static void property_release_bootindex(Object *obj, const char *name,

                                       void *opaque)



{

    BootIndexProperty *prop = opaque;



    del_boot_device_path(prop->dev, prop->suffix);

    g_free(prop);

}



void device_add_bootindex_property(Object *obj, int32_t *bootindex,

                                   const char *name, const char *suffix,

                                   DeviceState *dev, Error **errp)

{

    Error *local_err = NULL;

    BootIndexProperty *prop = g_malloc0(sizeof(*prop));



    prop->bootindex = bootindex;

    prop->suffix = suffix;

    prop->dev = dev;



    object_property_add(obj, name, "int32",

                        device_get_bootindex,

                        device_set_bootindex,

                        property_release_bootindex,

                        prop, &local_err);



    if (local_err) {

        error_propagate(errp, local_err);

        g_free(prop);

        return;

    }

    /* initialize devices' bootindex property to -1 */

    object_property_set_int(obj, -1, name, NULL);

}

hw/block/fdc.c

+13 −5
Original line number Diff line number Diff line
@@ -2216,9 +2216,6 @@ static void isabus_fdc_realize(DeviceState *dev, Error **errp) 
        error_propagate(errp, err);

        return;

    }



    add_boot_device_path(isa->bootindexA, dev, "/floppy@0");

    add_boot_device_path(isa->bootindexB, dev, "/floppy@1");

}



static void sysbus_fdc_initfn(Object *obj)
@@ -2291,8 +2288,6 @@ static Property isa_fdc_properties[] = { 
    DEFINE_PROP_UINT32("dma", FDCtrlISABus, dma, 2),

    DEFINE_PROP_DRIVE("driveA", FDCtrlISABus, state.drives[0].bs),

    DEFINE_PROP_DRIVE("driveB", FDCtrlISABus, state.drives[1].bs),

    DEFINE_PROP_INT32("bootindexA", FDCtrlISABus, bootindexA, -1),

    DEFINE_PROP_INT32("bootindexB", FDCtrlISABus, bootindexB, -1),

    DEFINE_PROP_BIT("check_media_rate", FDCtrlISABus, state.check_media_rate,

                    0, true),

    DEFINE_PROP_END_OF_LIST(),
@@ -2310,11 +2305,24 @@ static void isabus_fdc_class_init(ObjectClass *klass, void *data) 
    set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);

}



static void isabus_fdc_instance_init(Object *obj)

{

    FDCtrlISABus *isa = ISA_FDC(obj);



    device_add_bootindex_property(obj, &isa->bootindexA,

                                  "bootindexA", "/floppy@0",

                                  DEVICE(obj), NULL);

    device_add_bootindex_property(obj, &isa->bootindexB,

                                  "bootindexB", "/floppy@1",

                                  DEVICE(obj), NULL);

}



static const TypeInfo isa_fdc_info = {

    .name          = TYPE_ISA_FDC,

    .parent        = TYPE_ISA_DEVICE,

    .instance_size = sizeof(FDCtrlISABus),

    .class_init    = isabus_fdc_class_init,

    .instance_init = isabus_fdc_instance_init,

};



static const VMStateDescription vmstate_sysbus_fdc ={

hw/block/nvme.c

+44 −0
Original line number Diff line number Diff line
@@ -24,6 +24,8 @@ 
#include <hw/hw.h>

#include <hw/pci/msix.h>

#include <hw/pci/pci.h>

#include "sysemu/sysemu.h"

#include "qapi/visitor.h"



#include "nvme.h"
@@ -871,11 +873,53 @@ static void nvme_class_init(ObjectClass *oc, void *data) 
    dc->vmsd = &nvme_vmstate;

}



static void nvme_get_bootindex(Object *obj, Visitor *v, void *opaque,

                                  const char *name, Error **errp)

{

    NvmeCtrl *s = NVME(obj);



    visit_type_int32(v, &s->conf.bootindex, name, errp);

}



static void nvme_set_bootindex(Object *obj, Visitor *v, void *opaque,

                                  const char *name, Error **errp)

{

    NvmeCtrl *s = NVME(obj);

    int32_t boot_index;

    Error *local_err = NULL;



    visit_type_int32(v, &boot_index, name, &local_err);

    if (local_err) {

        goto out;

    }

    /* check whether bootindex is present in fw_boot_order list  */

    check_boot_index(boot_index, &local_err);

    if (local_err) {

        goto out;

    }

    /* change bootindex to a new one */

    s->conf.bootindex = boot_index;



out:

    if (local_err) {

        error_propagate(errp, local_err);

    }

}



static void nvme_instance_init(Object *obj)

{

    object_property_add(obj, "bootindex", "int32",

                        nvme_get_bootindex,

                        nvme_set_bootindex, NULL, NULL, NULL);

    object_property_set_int(obj, -1, "bootindex", NULL);

}



static const TypeInfo nvme_info = {

    .name          = "nvme",

    .parent        = TYPE_PCI_DEVICE,

    .instance_size = sizeof(NvmeCtrl),

    .class_init    = nvme_class_init,

    .instance_init = nvme_instance_init,

};



static void nvme_register_types(void)

hw/block/virtio-blk.c

+3 −2
Original line number Diff line number Diff line
@@ -768,8 +768,6 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) 
    bdrv_set_guest_block_size(s->bs, s->conf->logical_block_size);



    bdrv_iostatus_enable(s->bs);



    add_boot_device_path(s->conf->bootindex, dev, "/disk@0,0");

}



static void virtio_blk_device_unrealize(DeviceState *dev, Error **errp)
@@ -794,6 +792,9 @@ static void virtio_blk_instance_init(Object *obj) 
                             (Object **)&s->blk.iothread,

                             qdev_prop_allow_set_link_before_realize,

                             OBJ_PROP_LINK_UNREF_ON_RELEASE, NULL);

    device_add_bootindex_property(obj, &s->blk.conf.bootindex,

                                  "bootindex", "/disk@0,0",

                                  DEVICE(obj), NULL);

}



static Property virtio_blk_properties[] = {