[thirdparty/qemu.git] / bootdevice.c

/*
 * 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 "qemu/osdep.h"
#include "qapi/error.h"
#include "sysemu/sysemu.h"
#include "qapi/visitor.h"
#include "qemu/error-report.h"
#include "sysemu/reset.h"
#include "hw/qdev-core.h"
#include "hw/boards.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);
static QEMUBootSetHandler *boot_set_handler;
static void *boot_set_opaque;

void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
{
    boot_set_handler = func;
    boot_set_opaque = opaque;
}

void qemu_boot_set(const char *boot_order, Error **errp)
{
    Error *local_err = NULL;

    if (!boot_set_handler) {
        error_setg(errp, "no function defined to set boot device list for"
                         " this architecture");
        return;
    }

    validate_bootdevices(boot_order, &local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
    }

    boot_set_handler(boot_set_opaque, boot_order, errp);
}

void validate_bootdevices(const char *devices, Error **errp)
{
    /* We just do some generic consistency checks */
    const char *p;
    int bitmap = 0;

    for (p = devices; *p != '\0'; p++) {
        /* Allowed boot devices are:
         * a-b: floppy disk drives
         * c-f: IDE disk drives
         * g-m: machine implementation dependent drives
         * n-p: network devices
         * It's up to each machine implementation to check if the given boot
         * devices match the actual hardware implementation and firmware
         * features.
         */
        if (*p < 'a' || *p > 'p') {
            error_setg(errp, "Invalid boot device '%c'", *p);
            return;
        }
        if (bitmap & (1 << (*p - 'a'))) {
            error_setg(errp, "Boot device '%c' was given twice", *p);
            return;
        }
        bitmap |= 1 << (*p - 'a');
    }
}

void restore_boot_order(void *opaque)
{
    char *normal_boot_order = opaque;
    static int first = 1;

    /* Restore boot order and remove ourselves after the first boot */
    if (first) {
        first = 0;
        return;
    }

    if (boot_set_handler) {
        qemu_boot_set(normal_boot_order, &error_abort);
    }

    qemu_unregister_reset(restore_boot_order, normal_boot_order);
    g_free(normal_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;
}

static char *get_boot_device_path(DeviceState *dev, bool ignore_suffixes,
                                  const char *suffix)
{
    char *devpath = NULL, *s = NULL, *d, *bootpath;

    if (dev) {
        devpath = qdev_get_fw_dev_path(dev);
        assert(devpath);
    }

    if (!ignore_suffixes) {
        if (dev) {
            d = qdev_get_own_fw_dev_path_from_handler(dev->parent_bus, dev);
            if (d) {
                assert(!suffix);
                s = d;
            } else {
                s = g_strdup(suffix);
            }
        } else {
            s = g_strdup(suffix);
        }
    }

    bootpath = g_strdup_printf("%s%s",
                               devpath ? devpath : "",
                               s ? s : "");
    g_free(devpath);
    g_free(s);

    return bootpath;
}

/*
 * 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)
{
    FWBootEntry *i;
    size_t total = 0;
    char *list = NULL;
    MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
    bool ignore_suffixes = mc->ignore_boot_device_suffixes;

    QTAILQ_FOREACH(i, &fw_boot_order, link) {
        char *bootpath;
        size_t len;

        bootpath = get_boot_device_path(i->dev, ignore_suffixes, i->suffix);

        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, const char *name,
                                 void *opaque, Error **errp)
{
    BootIndexProperty *prop = opaque;
    visit_type_int32(v, name, prop->bootindex, errp);
}

static void device_set_bootindex(Object *obj, Visitor *v, const char *name,
                                 void *opaque, Error **errp)
{
    BootIndexProperty *prop = opaque;
    int32_t boot_index;
    Error *local_err = NULL;

    visit_type_int32(v, name, &boot_index, &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:
    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);
}

typedef struct FWLCHSEntry FWLCHSEntry;

struct FWLCHSEntry {
    QTAILQ_ENTRY(FWLCHSEntry) link;
    DeviceState *dev;
    char *suffix;
    uint32_t lcyls;
    uint32_t lheads;
    uint32_t lsecs;
};

static QTAILQ_HEAD(, FWLCHSEntry) fw_lchs =
    QTAILQ_HEAD_INITIALIZER(fw_lchs);

void add_boot_device_lchs(DeviceState *dev, const char *suffix,
                          uint32_t lcyls, uint32_t lheads, uint32_t lsecs)
{
    FWLCHSEntry *node;

    if (!lcyls && !lheads && !lsecs) {
        return;
    }

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

    node = g_malloc0(sizeof(FWLCHSEntry));
    node->suffix = g_strdup(suffix);
    node->dev = dev;
    node->lcyls = lcyls;
    node->lheads = lheads;
    node->lsecs = lsecs;

    QTAILQ_INSERT_TAIL(&fw_lchs, node, link);
}

void del_boot_device_lchs(DeviceState *dev, const char *suffix)
{
    FWLCHSEntry *i;

    if (dev == NULL) {
        return;
    }

    QTAILQ_FOREACH(i, &fw_lchs, link) {
        if ((!suffix || !g_strcmp0(i->suffix, suffix)) &&
             i->dev == dev) {
            QTAILQ_REMOVE(&fw_lchs, i, link);
            g_free(i->suffix);
            g_free(i);

            break;
        }
    }
}

char *get_boot_devices_lchs_list(size_t *size)
{
    FWLCHSEntry *i;
    size_t total = 0;
    char *list = NULL;

    QTAILQ_FOREACH(i, &fw_lchs, link) {
        char *bootpath;
        char *chs_string;
        size_t len;

        bootpath = get_boot_device_path(i->dev, false, i->suffix);
        chs_string = g_strdup_printf("%s %" PRIu32 " %" PRIu32 " %" PRIu32,
                                     bootpath, i->lcyls, i->lheads, i->lsecs);

        if (total) {
            list[total - 1] = '\n';
        }
        len = strlen(chs_string) + 1;
        list = g_realloc(list, total + len);
        memcpy(&list[total], chs_string, len);
        total += len;
        g_free(chs_string);
        g_free(bootpath);
    }

    *size = total;

    return list;
}
Commit	Line	Data
bc74112f GA	1	/*
	2	* QEMU Boot Device Implement
	3	*
fe75270c	4	* Copyright (c) 2014 HUAWEI TECHNOLOGIES CO., LTD.
bc74112f GA	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
d38ea87a	25	#include "qemu/osdep.h"
da34e65c	26	#include "qapi/error.h"
bc74112f	27	#include "sysemu/sysemu.h"
12da3097	28	#include "qapi/visitor.h"
54086fe5	29	#include "qemu/error-report.h"
5ddc6482	30	#include "sysemu/reset.h"
3b3d2648	31	#include "hw/qdev-core.h"
907aac2f	32	#include "hw/boards.h"
bc74112f GA	33
	34	typedef struct FWBootEntry FWBootEntry;
	35
	36	struct FWBootEntry {
	37	QTAILQ_ENTRY(FWBootEntry) link;
	38	int32_t bootindex;
	39	DeviceState *dev;
	40	char *suffix;
	41	};
	42
	43	static QTAILQ_HEAD(, FWBootEntry) fw_boot_order =
	44	QTAILQ_HEAD_INITIALIZER(fw_boot_order);
9816833d GA	45	static QEMUBootSetHandler *boot_set_handler;
	46	static void *boot_set_opaque;
	47
	48	void qemu_register_boot_set(QEMUBootSetHandler func, void opaque)
	49	{
	50	boot_set_handler = func;
	51	boot_set_opaque = opaque;
	52	}
	53
f1839938	54	void qemu_boot_set(const char boot_order, Error *errp)
9816833d	55	{
3b08098b GA	56	Error *local_err = NULL;
3b08098b GA	57
9816833d	58	if (!boot_set_handler) {
f1839938 GA	59	error_setg(errp, "no function defined to set boot device list for"
	60	" this architecture");
	61	return;
	62	}
	63
3b08098b GA	64	validate_bootdevices(boot_order, &local_err);
	65	if (local_err) {
	66	error_propagate(errp, local_err);
	67	return;
	68	}
	69
ddcd5531	70	boot_set_handler(boot_set_opaque, boot_order, errp);
9816833d GA	71	}
9816833d GA	72
703008e8	73	void validate_bootdevices(const char devices, Error *errp)
9816833d GA	74	{
	75	/* We just do some generic consistency checks */
	76	const char *p;
	77	int bitmap = 0;
	78
	79	for (p = devices; *p != '\0'; p++) {
	80	/* Allowed boot devices are:
	81	* a-b: floppy disk drives
	82	* c-f: IDE disk drives
	83	* g-m: machine implementation dependent drives
	84	* n-p: network devices
	85	* It's up to each machine implementation to check if the given boot
	86	* devices match the actual hardware implementation and firmware
	87	* features.
	88	*/
	89	if (p < 'a' \|\| p > 'p') {
703008e8 GA	90	error_setg(errp, "Invalid boot device '%c'", *p);
703008e8 GA	91	return;
9816833d GA	92	}
9816833d GA	93	if (bitmap & (1 << (*p - 'a'))) {
703008e8 GA	94	error_setg(errp, "Boot device '%c' was given twice", *p);
703008e8 GA	95	return;
9816833d GA	96	}
	97	bitmap \|= 1 << (*p - 'a');
	98	}
	99	}
	100
	101	void restore_boot_order(void *opaque)
	102	{
	103	char *normal_boot_order = opaque;
	104	static int first = 1;
	105
	106	/* Restore boot order and remove ourselves after the first boot */
	107	if (first) {
	108	first = 0;
	109	return;
	110	}
	111
76349f5b GA	112	if (boot_set_handler) {
	113	qemu_boot_set(normal_boot_order, &error_abort);
	114	}
9816833d GA	115
	116	qemu_unregister_reset(restore_boot_order, normal_boot_order);
	117	g_free(normal_boot_order);
	118	}
bc74112f	119
694fb857 GA	120	void check_boot_index(int32_t bootindex, Error **errp)
	121	{
	122	FWBootEntry *i;
	123
	124	if (bootindex >= 0) {
	125	QTAILQ_FOREACH(i, &fw_boot_order, link) {
	126	if (i->bootindex == bootindex) {
	127	error_setg(errp, "The bootindex %d has already been used",
	128	bootindex);
	129	return;
	130	}
	131	}
	132	}
	133	}
	134
9d27572d GA	135	void del_boot_device_path(DeviceState dev, const char suffix)
	136	{
	137	FWBootEntry *i;
	138
	139	if (dev == NULL) {
	140	return;
	141	}
	142
	143	QTAILQ_FOREACH(i, &fw_boot_order, link) {
	144	if ((!suffix \|\| !g_strcmp0(i->suffix, suffix)) &&
	145	i->dev == dev) {
	146	QTAILQ_REMOVE(&fw_boot_order, i, link);
	147	g_free(i->suffix);
	148	g_free(i);
	149
	150	break;
	151	}
	152	}
	153	}
	154
bc74112f GA	155	void add_boot_device_path(int32_t bootindex, DeviceState *dev,
	156	const char *suffix)
	157	{
	158	FWBootEntry node, i;
	159
	160	if (bootindex < 0) {
a598f2ff	161	del_boot_device_path(dev, suffix);
bc74112f GA	162	return;
	163	}
	164
	165	assert(dev != NULL \|\| suffix != NULL);
	166
e614b54b GA	167	del_boot_device_path(dev, suffix);
e614b54b GA	168
bc74112f GA	169	node = g_malloc0(sizeof(FWBootEntry));
	170	node->bootindex = bootindex;
	171	node->suffix = g_strdup(suffix);
	172	node->dev = dev;
	173
	174	QTAILQ_FOREACH(i, &fw_boot_order, link) {
	175	if (i->bootindex == bootindex) {
54086fe5	176	error_report("Two devices with same boot index %d", bootindex);
bc74112f GA	177	exit(1);
	178	} else if (i->bootindex < bootindex) {
	179	continue;
	180	}
	181	QTAILQ_INSERT_BEFORE(i, node, link);
	182	return;
	183	}
	184	QTAILQ_INSERT_TAIL(&fw_boot_order, node, link);
	185	}
	186
	187	DeviceState *get_boot_device(uint32_t position)
	188	{
	189	uint32_t counter = 0;
	190	FWBootEntry *i = NULL;
	191	DeviceState *res = NULL;
	192
	193	if (!QTAILQ_EMPTY(&fw_boot_order)) {
	194	QTAILQ_FOREACH(i, &fw_boot_order, link) {
	195	if (counter == position) {
	196	res = i->dev;
	197	break;
	198	}
	199	counter++;
	200	}
	201	}
	202	return res;
	203	}
	204
42f06801 SE	205	static char get_boot_device_path(DeviceState dev, bool ignore_suffixes,
	206	const char *suffix)
	207	{
	208	char devpath = NULL, s = NULL, d, bootpath;
	209
	210	if (dev) {
	211	devpath = qdev_get_fw_dev_path(dev);
	212	assert(devpath);
	213	}
	214
	215	if (!ignore_suffixes) {
	216	if (dev) {
	217	d = qdev_get_own_fw_dev_path_from_handler(dev->parent_bus, dev);
	218	if (d) {
	219	assert(!suffix);
	220	s = d;
	221	} else {
	222	s = g_strdup(suffix);
	223	}
	224	} else {
	225	s = g_strdup(suffix);
	226	}
	227	}
	228
	229	bootpath = g_strdup_printf("%s%s",
	230	devpath ? devpath : "",
	231	s ? s : "");
	232	g_free(devpath);
	233	g_free(s);
	234
	235	return bootpath;
	236	}
	237
bc74112f GA	238	/*
	239	* This function returns null terminated string that consist of new line
	240	* separated device paths.
	241	*
	242	* memory pointed by "size" is assigned total length of the array in bytes
	243	*
	244	*/
907aac2f	245	char get_boot_devices_list(size_t size)
bc74112f GA	246	{
	247	FWBootEntry *i;
	248	size_t total = 0;
	249	char *list = NULL;
907aac2f MCA	250	MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
907aac2f MCA	251	bool ignore_suffixes = mc->ignore_boot_device_suffixes;
bc74112f GA	252
bc74112f GA	253	QTAILQ_FOREACH(i, &fw_boot_order, link) {
0be63901	254	char *bootpath;
bc74112f GA	255	size_t len;
bc74112f GA	256
42f06801	257	bootpath = get_boot_device_path(i->dev, ignore_suffixes, i->suffix);
0be63901	258
bc74112f GA	259	if (total) {
	260	list[total-1] = '\n';
	261	}
	262	len = strlen(bootpath) + 1;
	263	list = g_realloc(list, total + len);
	264	memcpy(&list[total], bootpath, len);
	265	total += len;
	266	g_free(bootpath);
	267	}
	268
	269	*size = total;
	270
	271	if (boot_strict && *size > 0) {
	272	list[total-1] = '\n';
	273	list = g_realloc(list, total + 5);
	274	memcpy(&list[total], "HALT", 5);
	275	*size = total + 5;
	276	}
	277	return list;
	278	}
12da3097 GA	279
	280	typedef struct {
	281	int32_t *bootindex;
	282	const char *suffix;
	283	DeviceState *dev;
	284	} BootIndexProperty;
	285
d7bce999 EB	286	static void device_get_bootindex(Object obj, Visitor v, const char *name,
d7bce999 EB	287	void opaque, Error *errp)
12da3097 GA	288	{
12da3097 GA	289	BootIndexProperty *prop = opaque;
51e72bc1	290	visit_type_int32(v, name, prop->bootindex, errp);
12da3097 GA	291	}
12da3097 GA	292
d7bce999 EB	293	static void device_set_bootindex(Object obj, Visitor v, const char *name,
d7bce999 EB	294	void opaque, Error *errp)
12da3097 GA	295	{
	296	BootIndexProperty *prop = opaque;
	297	int32_t boot_index;
	298	Error *local_err = NULL;
	299
51e72bc1	300	visit_type_int32(v, name, &boot_index, &local_err);
12da3097 GA	301	if (local_err) {
	302	goto out;
	303	}
	304	/* check whether bootindex is present in fw_boot_order list */
	305	check_boot_index(boot_index, &local_err);
	306	if (local_err) {
	307	goto out;
	308	}
	309	/* change bootindex to a new one */
	310	*prop->bootindex = boot_index;
	311
d749e10c GA	312	add_boot_device_path(*prop->bootindex, prop->dev, prop->suffix);
d749e10c GA	313
12da3097	314	out:
621ff94d	315	error_propagate(errp, local_err);
12da3097 GA	316	}
	317
	318	static void property_release_bootindex(Object obj, const char name,
	319	void *opaque)
	320
	321	{
	322	BootIndexProperty *prop = opaque;
4aca8a81 GA	323
4aca8a81 GA	324	del_boot_device_path(prop->dev, prop->suffix);
12da3097 GA	325	g_free(prop);
	326	}
	327
	328	void device_add_bootindex_property(Object obj, int32_t bootindex,
	329	const char name, const char suffix,
	330	DeviceState dev, Error *errp)
	331	{
	332	Error *local_err = NULL;
	333	BootIndexProperty prop = g_malloc0(sizeof(prop));
	334
	335	prop->bootindex = bootindex;
	336	prop->suffix = suffix;
	337	prop->dev = dev;
	338
	339	object_property_add(obj, name, "int32",
	340	device_get_bootindex,
	341	device_set_bootindex,
	342	property_release_bootindex,
	343	prop, &local_err);
	344
	345	if (local_err) {
	346	error_propagate(errp, local_err);
	347	g_free(prop);
	348	return;
	349	}
	350	/* initialize devices' bootindex property to -1 */
	351	object_property_set_int(obj, -1, name, NULL);
	352	}
f7209ea1 SE	353
	354	typedef struct FWLCHSEntry FWLCHSEntry;
	355
	356	struct FWLCHSEntry {
	357	QTAILQ_ENTRY(FWLCHSEntry) link;
	358	DeviceState *dev;
	359	char *suffix;
	360	uint32_t lcyls;
	361	uint32_t lheads;
	362	uint32_t lsecs;
	363	};
	364
	365	static QTAILQ_HEAD(, FWLCHSEntry) fw_lchs =
	366	QTAILQ_HEAD_INITIALIZER(fw_lchs);
	367
	368	void add_boot_device_lchs(DeviceState dev, const char suffix,
	369	uint32_t lcyls, uint32_t lheads, uint32_t lsecs)
	370	{
	371	FWLCHSEntry *node;
	372
	373	if (!lcyls && !lheads && !lsecs) {
	374	return;
	375	}
	376
	377	assert(dev != NULL \|\| suffix != NULL);
	378
	379	node = g_malloc0(sizeof(FWLCHSEntry));
	380	node->suffix = g_strdup(suffix);
	381	node->dev = dev;
	382	node->lcyls = lcyls;
	383	node->lheads = lheads;
	384	node->lsecs = lsecs;
	385
	386	QTAILQ_INSERT_TAIL(&fw_lchs, node, link);
	387	}
	388
	389	void del_boot_device_lchs(DeviceState dev, const char suffix)
	390	{
	391	FWLCHSEntry *i;
	392
	393	if (dev == NULL) {
	394	return;
	395	}
	396
	397	QTAILQ_FOREACH(i, &fw_lchs, link) {
	398	if ((!suffix \|\| !g_strcmp0(i->suffix, suffix)) &&
	399	i->dev == dev) {
	400	QTAILQ_REMOVE(&fw_lchs, i, link);
	401	g_free(i->suffix);
	402	g_free(i);
	403
	404	break;
	405	}
	406	}
	407	}
aea60a13 SE	408
	409	char get_boot_devices_lchs_list(size_t size)
	410	{
	411	FWLCHSEntry *i;
	412	size_t total = 0;
	413	char *list = NULL;
	414
	415	QTAILQ_FOREACH(i, &fw_lchs, link) {
	416	char *bootpath;
	417	char *chs_string;
	418	size_t len;
	419
	420	bootpath = get_boot_device_path(i->dev, false, i->suffix);
	421	chs_string = g_strdup_printf("%s %" PRIu32 " %" PRIu32 " %" PRIu32,
	422	bootpath, i->lcyls, i->lheads, i->lsecs);
	423
	424	if (total) {
	425	list[total - 1] = '\n';
	426	}
	427	len = strlen(chs_string) + 1;
	428	list = g_realloc(list, total + len);
	429	memcpy(&list[total], chs_string, len);
	430	total += len;
	431	g_free(chs_string);
	432	g_free(bootpath);
	433	}
	434
	435	*size = total;
	436
	437	return list;
	438	}