#define ACPI_PCIHP_ADDR 0xae00
#define ACPI_PCIHP_SIZE 0x0014
-#define ACPI_PCIHP_LEGACY_SIZE 0x000f
#define PCI_UP_BASE 0x0000
#define PCI_DOWN_BASE 0x0004
#define PCI_EJ_BASE 0x0008
s->root= root_bus;
s->legacy_piix = !bridges_enabled;
- if (s->legacy_piix) {
- unsigned *bus_bsel = g_malloc(sizeof *bus_bsel);
-
- s->io_len = ACPI_PCIHP_LEGACY_SIZE;
-
- *bus_bsel = ACPI_PCIHP_BSEL_DEFAULT;
- object_property_add_uint32_ptr(OBJECT(root_bus), ACPI_PCIHP_PROP_BSEL,
- bus_bsel, NULL);
- }
-
memory_region_init_io(&s->io, owner, &acpi_pcihp_io_ops, s,
"acpi-pci-hotplug", s->io_len);
memory_region_add_subregion(address_space_io, s->io_base, &s->io);
{
PIIX4PMState *s = opaque;
+ /* pci_bus cannot outlive PIIX4PMState, because /machine keeps it alive
+ * and it's not hot-unpluggable */
qbus_set_hotplug_handler(BUS(pci_bus), DEVICE(s), &error_abort);
}
TYPE_HOTPLUG_HANDLER,
(Object **)&bus->hotplug_handler,
object_property_allow_set_link,
- OBJ_PROP_LINK_UNREF_ON_RELEASE,
+ 0,
NULL);
object_property_add_bool(obj, "realized",
bus_get_realized, bus_set_realized, NULL);
#include "qemu/host-utils.h"
#include "sysemu/replay.h"
#include "sysemu/qtest.h"
+#include "block/aio.h"
#define DELTA_ADJUST 1
#define DELTA_NO_ADJUST -1
s->policy_mask = policy_mask;
return s;
}
+
+void ptimer_free(ptimer_state *s)
+{
+ qemu_bh_delete(s->bh);
+ timer_free(s->timer);
+ g_free(s);
+}
*bus_bsel = (*bsel_alloc)++;
object_property_add_uint32_ptr(OBJECT(bus), ACPI_PCIHP_PROP_BSEL,
- bus_bsel, NULL);
+ bus_bsel, &error_abort);
}
return bsel_alloc;
static void acpi_set_pci_info(void)
{
PCIBus *bus = find_i440fx(); /* TODO: Q35 support */
- unsigned bsel_alloc = 0;
+ unsigned bsel_alloc = ACPI_PCIHP_BSEL_DEFAULT;
if (bus) {
/* Scan all PCI buses. Set property to enable acpi based hotplug. */
.load_request = usb_msd_load_request,
};
+static void usb_msd_unrealize_storage(USBDevice *dev, Error **errp)
+{
+ MSDState *s = USB_STORAGE_DEV(dev);
+
+ object_unref(OBJECT(&s->bus));
+}
+
static void usb_msd_realize_storage(USBDevice *dev, Error **errp)
{
MSDState *s = USB_STORAGE_DEV(dev);
s->scsi_dev = scsi_dev;
}
+static void usb_msd_unrealize_bot(USBDevice *dev, Error **errp)
+{
+ MSDState *s = USB_STORAGE_DEV(dev);
+
+ object_unref(OBJECT(&s->bus));
+}
+
static void usb_msd_realize_bot(USBDevice *dev, Error **errp)
{
MSDState *s = USB_STORAGE_DEV(dev);
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
uc->realize = usb_msd_realize_storage;
+ uc->unrealize = usb_msd_unrealize_storage;
dc->props = msd_properties;
}
USBDeviceClass *uc = USB_DEVICE_CLASS(klass);
uc->realize = usb_msd_realize_bot;
+ uc->unrealize = usb_msd_unrealize_bot;
uc->attached_settable = true;
}
UASDevice *uas = USB_UAS(dev);
qemu_bh_delete(uas->status_bh);
+
+ object_unref(OBJECT(&uas->bus));
}
static void usb_uas_realize(USBDevice *dev, Error **errp)
#define g_test_subprocess() (0)
#endif
+
+#if !GLIB_CHECK_VERSION(2, 34, 0)
+static inline void
+g_test_add_data_func_full(const char *path,
+ gpointer data,
+ gpointer fn,
+ gpointer data_free_func)
+{
+#if GLIB_CHECK_VERSION(2, 26, 0)
+ /* back-compat casts, remove this once we can require new-enough glib */
+ g_test_add_vtable(path, 0, data, NULL,
+ (GTestFixtureFunc)fn, (GTestFixtureFunc) data_free_func);
+#else
+ /* back-compat casts, remove this once we can require new-enough glib */
+ g_test_add_vtable(path, 0, data, NULL,
+ (void (*)(void)) fn, (void (*)(void)) data_free_func);
+#endif
+}
+#endif
+
+
#endif
typedef void (*ptimer_cb)(void *opaque);
ptimer_state *ptimer_init(QEMUBH *bh, uint8_t policy_mask);
+void ptimer_free(ptimer_state *s);
void ptimer_set_period(ptimer_state *s, int64_t period);
void ptimer_set_freq(ptimer_state *s, uint32_t freq);
uint64_t ptimer_get_limit(ptimer_state *s);
*
* Free a timer (it must not be on the active list)
*/
-void timer_free(QEMUTimer *ts);
+static inline void timer_free(QEMUTimer *ts)
+{
+ g_free(ts);
+}
/**
* timer_del:
va_start(ap, fmt);
buffer = g_strdup_vprintf(fmt, ap);
qtest_send(chr, buffer);
+ g_free(buffer);
va_end(ap);
}
g_free(temp->asl_file);
}
- g_array_free(data->tables, false);
+ g_array_free(data->tables, true);
}
static uint8_t acpi_checksum(const uint8_t *data, int len)
path = g_strdup_printf("e1000/%s", models[i]);
qtest_add_data_func(path, models[i], test_device);
+ g_free(path);
}
return g_test_run();
static void e1000e_pci_foreach_callback(QPCIDevice *dev, int devfn, void *data)
{
- *(QPCIDevice **) data = dev;
+ QPCIDevice **res = data;
+
+ g_assert_null(*res);
+ *res = dev;
}
static QPCIDevice *e1000e_device_find(QPCIBus *bus)
e1000e_device_clear(test_bus, d);
close(test_sockets[0]);
pc_alloc_uninit(test_alloc);
+ g_free(d->pci_dev);
qpci_free_pc(test_bus);
qtest_end();
}
path = g_strdup_printf("eepro100/%s", models[i]);
qtest_add_data_func(path, models[i], test_device);
+ g_free(path);
}
return g_test_run();
path = g_strdup_printf("endianness/%s",
test_cases[i].machine);
qtest_add_data_func(path, &test_cases[i], test_endianness);
+ g_free(path);
path = g_strdup_printf("endianness/split/%s",
test_cases[i].machine);
qtest_add_data_func(path, &test_cases[i], test_endianness_split);
+ g_free(path);
path = g_strdup_printf("endianness/combine/%s",
test_cases[i].machine);
qtest_add_data_func(path, &test_cases[i], test_endianness_combine);
+ g_free(path);
}
return g_test_run();
#include "qemu-common.h"
#include "libqtest.h"
+#define ARGV_SIZE 256
+
static char *create_test_img(int secs)
{
char *template = strdup("/tmp/qtest.XXXXXX");
},
};
-static const char *img_file_name[backend_last];
+static char *img_file_name[backend_last];
static const CHST *cur_ide[4];
*/
static void test_ide_none(void)
{
- char *argv[256];
-
- setup_common(argv, ARRAY_SIZE(argv));
- qtest_start(g_strjoinv(" ", argv));
+ char **argv = g_new0(char *, ARGV_SIZE);
+ char *args;
+
+ setup_common(argv, ARGV_SIZE);
+ args = g_strjoinv(" ", argv);
+ qtest_start(args);
+ g_strfreev(argv);
+ g_free(args);
test_cmos();
qtest_end();
}
static void test_ide_mbr(bool use_device, MBRcontents mbr)
{
- char *argv[256];
+ char **argv = g_new0(char *, ARGV_SIZE);
+ char *args;
int argc;
Backend i;
const char *dev;
- argc = setup_common(argv, ARRAY_SIZE(argv));
+ argc = setup_common(argv, ARGV_SIZE);
for (i = 0; i < backend_last; i++) {
cur_ide[i] = &hd_chst[i][mbr];
dev = use_device ? (is_hd(cur_ide[i]) ? "ide-hd" : "ide-cd") : NULL;
- argc = setup_ide(argc, argv, ARRAY_SIZE(argv), i, dev, i, mbr, "");
+ argc = setup_ide(argc, argv, ARGV_SIZE, i, dev, i, mbr, "");
}
- qtest_start(g_strjoinv(" ", argv));
+ args = g_strjoinv(" ", argv);
+ qtest_start(args);
+ g_strfreev(argv);
+ g_free(args);
test_cmos();
qtest_end();
}
static void test_ide_drive_user(const char *dev, bool trans)
{
- char *argv[256], *opts;
+ char **argv = g_new0(char *, ARGV_SIZE);
+ char *args, *opts;
int argc;
int secs = img_secs[backend_small];
const CHST expected_chst = { secs / (4 * 32) , 4, 32, trans };
- argc = setup_common(argv, ARRAY_SIZE(argv));
+ argc = setup_common(argv, ARGV_SIZE);
opts = g_strdup_printf("%s,%s%scyls=%d,heads=%d,secs=%d",
dev ?: "",
trans && dev ? "bios-chs-" : "",
expected_chst.cyls, expected_chst.heads,
expected_chst.secs);
cur_ide[0] = &expected_chst;
- argc = setup_ide(argc, argv, ARRAY_SIZE(argv),
+ argc = setup_ide(argc, argv, ARGV_SIZE,
0, dev ? opts : NULL, backend_small, mbr_chs,
dev ? "" : opts);
g_free(opts);
- qtest_start(g_strjoinv(" ", argv));
+ args = g_strjoinv(" ", argv);
+ qtest_start(args);
+ g_strfreev(argv);
+ g_free(args);
test_cmos();
qtest_end();
}
*/
static void test_ide_drive_cd_0(void)
{
- char *argv[256];
+ char **argv = g_new0(char *, ARGV_SIZE);
+ char *args;
int argc, ide_idx;
Backend i;
- argc = setup_common(argv, ARRAY_SIZE(argv));
+ argc = setup_common(argv, ARGV_SIZE);
for (i = 0; i <= backend_empty; i++) {
ide_idx = backend_empty - i;
cur_ide[ide_idx] = &hd_chst[i][mbr_blank];
- argc = setup_ide(argc, argv, ARRAY_SIZE(argv),
+ argc = setup_ide(argc, argv, ARGV_SIZE,
ide_idx, NULL, i, mbr_blank, "");
}
- qtest_start(g_strjoinv(" ", argv));
+ args = g_strjoinv(" ", argv);
+ qtest_start(args);
+ g_strfreev(argv);
+ g_free(args);
test_cmos();
qtest_end();
}
for (i = 0; i < backend_last; i++) {
if (img_file_name[i]) {
unlink(img_file_name[i]);
+ free(img_file_name[i]);
}
}
/* 3.2.26 */
g_assert_cmpint(qpci_config_readb(dev, 0x93), ==, 0x00); /* TRC */
+ g_free(dev);
+ qpci_free_pc(bus);
qtest_end();
}
/* Verify the area is not our new mask */
g_assert(!verify_area(pam_area[i].start, pam_area[i].end, 0x82));
}
+
+ g_free(dev);
+ qpci_free_pc(bus);
qtest_end();
}
g_assert(memcmp(buf, cmpbuf, len) == 0);
+ free_pci_device(dev);
g_free(buf);
g_free(cmpbuf);
}
prdt, ARRAY_SIZE(prdt), NULL);
g_assert_cmphex(status, ==, 0);
assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
+ free_pci_device(dev);
}
static void test_bmdma_one_sector_short_prdt(void)
prdt, ARRAY_SIZE(prdt), NULL);
g_assert_cmphex(status, ==, 0);
assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
+ free_pci_device(dev);
}
static void test_bmdma_long_prdt(void)
prdt, ARRAY_SIZE(prdt), NULL);
g_assert_cmphex(status, ==, BM_STS_INTR);
assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
+ free_pci_device(dev);
}
static void test_bmdma_no_busmaster(void)
* in practice. At least we want to be aware of any changes. */
g_assert_cmphex(status, ==, BM_STS_ACTIVE | BM_STS_INTR);
assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
+ free_pci_device(dev);
}
static void test_bmdma_setup(void)
assert_bit_set(buf[85], 0x20);
ide_test_quit();
+ free_pci_device(dev);
}
/*
assert_bit_clear(qpci_io_readb(dev, ide_bar, reg_status), DF | ERR);
g_free(buf);
+ free_pci_device(dev);
}
static void test_flush(void)
assert_bit_clear(data, BSY | DF | ERR | DRQ);
ide_test_quit();
+ free_pci_device(dev);
}
static void test_retry_flush(const char *machine)
assert_bit_clear(data, BSY | DF | ERR | DRQ);
ide_test_quit();
+ free_pci_device(dev);
}
static void test_flush_nodev(void)
/* Just testing that qemu doesn't crash... */
+ free_pci_device(dev);
ide_test_quit();
}
while (true) {
data = qpci_io_readb(dev, ide_bar, reg_status);
if (!(data & flag)) {
+ free_pci_device(dev);
return data;
}
if (difftime(time(NULL), st) > 5.0) {
g_free(pattern);
g_free(rx);
test_bmdma_teardown();
+ free_pci_device(dev);
}
static void test_cdrom_pio(void)
" -device ipmi-bmc-extern,chardev=ipmi0,id=bmc0"
" -device isa-ipmi-bt,bmc=bmc0", emu_port);
qtest_start(cmdline);
+ g_free(cmdline);
qtest_irq_intercept_in(global_qtest, "ioapic");
qtest_add_func("/ipmi/extern/connect", test_connect);
qtest_add_func("/ipmi/extern/bt_base", test_bt_base);
cmdline = g_strdup_printf("-device ipmi-bmc-sim,id=bmc0"
" -device isa-ipmi-kcs,bmc=bmc0");
qtest_start(cmdline);
+ g_free(cmdline);
qtest_irq_intercept_in(global_qtest, "ioapic");
qtest_add_func("/ipmi/local/kcs_base", test_kcs_base);
qtest_add_func("/ipmi/local/kcs_abort", test_kcs_abort);
hc->bar = qpci_iomap(hc->dev, bar, NULL);
}
+void uhci_deinit(struct qhc *hc)
+{
+ g_free(hc->dev);
+}
+
void uhci_port_test(struct qhc *hc, int port, uint16_t expect)
{
uint16_t value = qpci_io_readw(hc->dev, hc->bar, 0x10 + 2 * port);
g_assert(response);
g_assert(qdict_haskey(response, "event"));
g_assert(!strcmp(qdict_get_str(response, "event"), "DEVICE_DELETED"));
+ QDECREF(response);
}
void qusb_pci_init_one(QPCIBus *pcibus, struct qhc *hc,
uint32_t devfn, int bar);
void uhci_port_test(struct qhc *hc, int port, uint16_t expect);
+void uhci_deinit(struct qhc *hc);
void usb_test_hotplug(const char *bus_name, const int port,
void (*port_check)(void));
typedef struct QVirtioPCIForeachData {
void (*func)(QVirtioDevice *d, void *data);
uint16_t device_type;
+ bool has_slot;
+ int slot;
void *user_data;
} QVirtioPCIForeachData;
+void qvirtio_pci_device_free(QVirtioPCIDevice *dev)
+{
+ g_free(dev->pdev);
+ g_free(dev);
+}
+
static QVirtioPCIDevice *qpcidevice_to_qvirtiodevice(QPCIDevice *pdev)
{
QVirtioPCIDevice *vpcidev;
QVirtioPCIForeachData *d = data;
QVirtioPCIDevice *vpcidev = qpcidevice_to_qvirtiodevice(dev);
- if (vpcidev->vdev.device_type == d->device_type) {
+ if (vpcidev->vdev.device_type == d->device_type &&
+ (!d->has_slot || vpcidev->pdev->devfn == d->slot << 3)) {
d->func(&vpcidev->vdev, d->user_data);
} else {
- g_free(vpcidev);
+ qvirtio_pci_device_free(vpcidev);
}
}
static void qvirtio_pci_assign_device(QVirtioDevice *d, void *data)
{
QVirtioPCIDevice **vpcidev = data;
+ assert(!*vpcidev);
*vpcidev = (QVirtioPCIDevice *)d;
}
.virtqueue_kick = qvirtio_pci_virtqueue_kick,
};
-void qvirtio_pci_foreach(QPCIBus *bus, uint16_t device_type,
+static void qvirtio_pci_foreach(QPCIBus *bus, uint16_t device_type,
+ bool has_slot, int slot,
void (*func)(QVirtioDevice *d, void *data), void *data)
{
QVirtioPCIForeachData d = { .func = func,
.device_type = device_type,
+ .has_slot = has_slot,
+ .slot = slot,
.user_data = data };
qpci_device_foreach(bus, PCI_VENDOR_ID_REDHAT_QUMRANET, -1,
- qvirtio_pci_foreach_callback, &d);
+ qvirtio_pci_foreach_callback, &d);
}
QVirtioPCIDevice *qvirtio_pci_device_find(QPCIBus *bus, uint16_t device_type)
{
QVirtioPCIDevice *dev = NULL;
- qvirtio_pci_foreach(bus, device_type, qvirtio_pci_assign_device, &dev);
+
+ qvirtio_pci_foreach(bus, device_type, false, 0,
+ qvirtio_pci_assign_device, &dev);
+
+ dev->vdev.bus = &qvirtio_pci;
+
+ return dev;
+}
+
+QVirtioPCIDevice *qvirtio_pci_device_find_slot(QPCIBus *bus,
+ uint16_t device_type, int slot)
+{
+ QVirtioPCIDevice *dev = NULL;
+
+ qvirtio_pci_foreach(bus, device_type, true, slot,
+ qvirtio_pci_assign_device, &dev);
dev->vdev.bus = &qvirtio_pci;
extern const QVirtioBus qvirtio_pci;
-void qvirtio_pci_foreach(QPCIBus *bus, uint16_t device_type,
- void (*func)(QVirtioDevice *d, void *data), void *data);
QVirtioPCIDevice *qvirtio_pci_device_find(QPCIBus *bus, uint16_t device_type);
+QVirtioPCIDevice *qvirtio_pci_device_find_slot(QPCIBus *bus,
+ uint16_t device_type, int slot);
+void qvirtio_pci_device_free(QVirtioPCIDevice *dev);
+
void qvirtio_pci_device_enable(QVirtioPCIDevice *d);
void qvirtio_pci_device_disable(QVirtioPCIDevice *d);
GDestroyNotify data_free_func)
{
gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
-#if GLIB_CHECK_VERSION(2, 34, 0)
g_test_add_data_func_full(path, data, fn, data_free_func);
-#elif GLIB_CHECK_VERSION(2, 26, 0)
- /* back-compat casts, remove this once we can require new-enough glib */
- g_test_add_vtable(path, 0, data, NULL,
- (GTestFixtureFunc)fn, (GTestFixtureFunc) data_free_func);
-#else
- /* back-compat casts, remove this once we can require new-enough glib */
- g_test_add_vtable(path, 0, data, NULL,
- (void (*)(void)) fn, (void (*)(void)) data_free_func);
-#endif
g_free(path);
}
usleep(10 * 1000);
} while (dest_byte_a == dest_byte_b);
- qmp("{ 'execute' : 'stop'}");
+ qmp_discard_response("{ 'execute' : 'stop'}");
/* With it stopped, check nothing changes */
qtest_memread(to, start_address, &dest_byte_c, 1);
sleep(1);
return bh;
}
+void qemu_bh_delete(QEMUBH *bh)
+{
+ g_free(bh);
+}
+
void replay_bh_schedule_event(QEMUBH *bh)
{
bh->cb(bh->opaque);
ptimer_set_count(ptimer, 1000);
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 1000);
g_assert_false(triggered);
+ ptimer_free(ptimer);
}
static void check_set_limit(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 2000);
g_assert_cmpuint(ptimer_get_limit(ptimer), ==, 2000);
g_assert_false(triggered);
+ ptimer_free(ptimer);
}
static void check_oneshot(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);
g_assert_false(triggered);
+ ptimer_free(ptimer);
}
static void check_periodic(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==,
(no_round_down ? 8 : 7) + (wrap_policy ? 1 : 0));
g_assert_false(triggered);
+ ptimer_free(ptimer);
}
static void check_on_the_fly_mode_change(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);
g_assert_true(triggered);
+ ptimer_free(ptimer);
}
static void check_on_the_fly_period_change(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);
g_assert_true(triggered);
+ ptimer_free(ptimer);
}
static void check_on_the_fly_freq_change(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 0);
g_assert_true(triggered);
+ ptimer_free(ptimer);
}
static void check_run_with_period_0(gconstpointer arg)
g_assert_cmpuint(ptimer_get_count(ptimer), ==, 99);
g_assert_false(triggered);
+ ptimer_free(ptimer);
}
static void check_run_with_delta_0(gconstpointer arg)
g_assert_true(triggered);
ptimer_stop(ptimer);
+ ptimer_free(ptimer);
}
static void check_periodic_with_load_0(gconstpointer arg)
}
ptimer_stop(ptimer);
+ ptimer_free(ptimer);
}
static void check_oneshot_with_load_0(gconstpointer arg)
} else {
g_assert_false(triggered);
}
+
+ ptimer_free(ptimer);
}
static void add_ptimer_tests(uint8_t policy)
{
- uint8_t *ppolicy = g_malloc(1);
- char *policy_name = g_malloc0(256);
-
- *ppolicy = policy;
+ char policy_name[256] = "";
+ char *tmp;
if (policy == PTIMER_POLICY_DEFAULT) {
g_sprintf(policy_name, "default");
g_strlcat(policy_name, "no_counter_rounddown,", 256);
}
- g_test_add_data_func(
- g_strdup_printf("/ptimer/set_count policy=%s", policy_name),
- ppolicy, check_set_count);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/set_limit policy=%s", policy_name),
- ppolicy, check_set_limit);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/oneshot policy=%s", policy_name),
- ppolicy, check_oneshot);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/periodic policy=%s", policy_name),
- ppolicy, check_periodic);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/on_the_fly_mode_change policy=%s", policy_name),
- ppolicy, check_on_the_fly_mode_change);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/on_the_fly_period_change policy=%s", policy_name),
- ppolicy, check_on_the_fly_period_change);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/on_the_fly_freq_change policy=%s", policy_name),
- ppolicy, check_on_the_fly_freq_change);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/run_with_period_0 policy=%s", policy_name),
- ppolicy, check_run_with_period_0);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/run_with_delta_0 policy=%s", policy_name),
- ppolicy, check_run_with_delta_0);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/periodic_with_load_0 policy=%s", policy_name),
- ppolicy, check_periodic_with_load_0);
-
- g_test_add_data_func(
- g_strdup_printf("/ptimer/oneshot_with_load_0 policy=%s", policy_name),
- ppolicy, check_oneshot_with_load_0);
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/set_count policy=%s", policy_name),
+ g_memdup(&policy, 1), check_set_count, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/set_limit policy=%s", policy_name),
+ g_memdup(&policy, 1), check_set_limit, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/oneshot policy=%s", policy_name),
+ g_memdup(&policy, 1), check_oneshot, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/periodic policy=%s", policy_name),
+ g_memdup(&policy, 1), check_periodic, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/on_the_fly_mode_change policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_on_the_fly_mode_change, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/on_the_fly_period_change policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_on_the_fly_period_change, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/on_the_fly_freq_change policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_on_the_fly_freq_change, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/run_with_period_0 policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_run_with_period_0, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/run_with_delta_0 policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_run_with_delta_0, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/periodic_with_load_0 policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_periodic_with_load_0, g_free);
+ g_free(tmp);
+
+ g_test_add_data_func_full(
+ tmp = g_strdup_printf("/ptimer/oneshot_with_load_0 policy=%s",
+ policy_name),
+ g_memdup(&policy, 1), check_oneshot_with_load_0, g_free);
+ g_free(tmp);
}
static void add_all_ptimer_policies_comb_tests(void)
data = qdict_get_qdict(response, "data");
g_assert(qdict_haskey(data, "action"));
g_assert_cmpstr(qdict_get_str(data, "action"), ==, "pause");
+ QDECREF(response);
}
int main(int argc, char **argv)
g_assert(smram_test_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN) == false);
smram_set_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN, true);
g_assert(smram_test_bit(pcidev, MCH_HOST_BRIDGE_SMRAM_D_OPEN) == true);
+
+ g_free(pcidev);
+ qpci_free_pc(pcibus);
}
int main(int argc, char **argv)
bool noreboot;
QPCIDevice *dev;
QPCIBar tco_io_bar;
+ QPCIBus *bus;
} TestData;
+static void test_end(TestData *d)
+{
+ g_free(d->dev);
+ qpci_free_pc(d->bus);
+ qtest_end();
+}
+
static void test_init(TestData *d)
{
- QPCIBus *bus;
QTestState *qs;
char *s;
qtest_irq_intercept_in(qs, "ioapic");
g_free(s);
- bus = qpci_init_pc(NULL);
- d->dev = qpci_device_find(bus, QPCI_DEVFN(0x1f, 0x00));
+ d->bus = qpci_init_pc(NULL);
+ d->dev = qpci_device_find(d->bus, QPCI_DEVFN(0x1f, 0x00));
g_assert(d->dev != NULL);
qpci_device_enable(d->dev);
SW_IRQ_GEN_DEFAULT);
g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_bar, TCO_TMR), ==,
TCO_TMR_DEFAULT);
- qtest_end();
+ test_end(&d);
}
static void test_tco_timeout(void)
g_assert(ret == 1);
stop_tco(&d);
- qtest_end();
+ test_end(&d);
}
static void test_tco_max_timeout(void)
g_assert(ret == 1);
stop_tco(&d);
- qtest_end();
+ test_end(&d);
}
static QDict *get_watchdog_action(void)
QDECREF(ad);
stop_tco(&td);
- qtest_end();
+ test_end(&td);
}
static void test_tco_second_timeout_reset(void)
QDECREF(ad);
stop_tco(&td);
- qtest_end();
+ test_end(&td);
}
static void test_tco_second_timeout_shutdown(void)
QDECREF(ad);
stop_tco(&td);
- qtest_end();
+ test_end(&td);
}
static void test_tco_second_timeout_none(void)
QDECREF(ad);
stop_tco(&td);
- qtest_end();
+ test_end(&td);
}
static void test_tco_ticks_counter(void)
} while (!(qpci_io_readw(d.dev, d.tco_io_bar, TCO1_STS) & TCO_TIMEOUT));
stop_tco(&d);
- qtest_end();
+ test_end(&d);
}
static void test_tco1_control_bits(void)
qpci_io_writew(d.dev, d.tco_io_bar, TCO1_CNT, val);
g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_bar, TCO1_CNT), ==,
TCO_LOCK);
- qtest_end();
+ test_end(&d);
}
static void test_tco1_status_bits(void)
g_assert(ret == 1);
qpci_io_writew(d.dev, d.tco_io_bar, TCO1_STS, val);
g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_bar, TCO1_STS), ==, 0);
- qtest_end();
+ test_end(&d);
}
static void test_tco2_status_bits(void)
g_assert(ret == 1);
qpci_io_writew(d.dev, d.tco_io_bar, TCO2_STS, val);
g_assert_cmpint(qpci_io_readw(d.dev, d.tco_io_bar, TCO2_STS), ==, 0);
- qtest_end();
+ test_end(&d);
}
int main(int argc, char **argv)
};
/* send a qmp command to guarantee that 'connected' is setting to true. */
- qmp("{ 'execute' : 'query-status'}");
+ qmp_discard_response("{ 'execute' : 'query-status'}");
ret = iov_send(send_sock[0], iov, 2, 0, sizeof(size) + sizeof(send_buf));
g_assert_cmpint(ret, ==, sizeof(send_buf) + sizeof(size));
close(send_sock[0]);
g_assert_cmpint(recv_sock, !=, -1);
/* send a qmp command to guarantee that 'connected' is setting to true. */
- qmp("{ 'execute' : 'query-status'}");
+ qmp_discard_response("{ 'execute' : 'query-status'}");
struct iovec iov[] = {
{
send_sock = unix_connect(sock_path1, NULL);
g_assert_cmpint(send_sock, !=, -1);
/* send a qmp command to guarantee that 'connected' is setting to true. */
- qmp("{ 'execute' : 'query-status'}");
+ qmp_discard_response("{ 'execute' : 'query-status'}");
ret = iov_send(send_sock, iov, 2, 0, sizeof(size) + sizeof(send_buf));
g_assert_cmpint(ret, ==, sizeof(send_buf) + sizeof(size));
#define TEST_FIFO "tests/test-io-channel-command.fifo"
QIOChannel *src, *dst;
QIOChannelTest *test;
- char *srcfifo = g_strdup_printf("PIPE:%s,wronly", TEST_FIFO);
- char *dstfifo = g_strdup_printf("PIPE:%s,rdonly", TEST_FIFO);
+ const char *srcfifo = "PIPE:" TEST_FIFO ",wronly";
+ const char *dstfifo = "PIPE:" TEST_FIFO ",rdonly";
const char *srcargv[] = {
"/bin/socat", "-", srcfifo, NULL,
};
object_unref(OBJECT(src));
object_unref(OBJECT(dst));
- g_free(srcfifo);
- g_free(dstfifo);
unlink(TEST_FIFO);
}
/* tests */
-static void pci_init(void)
+static void test_init(void)
{
- if (pcibus) {
- return;
- }
pcibus = qpci_init_pc(NULL);
g_assert(pcibus != NULL);
qusb_pci_init_one(pcibus, &ehci1, QPCI_DEVFN(0x1d, 7), 0);
}
+static void test_deinit(void)
+{
+ uhci_deinit(&uhci1);
+ uhci_deinit(&uhci2);
+ uhci_deinit(&uhci3);
+ uhci_deinit(&ehci1);
+ qpci_free_pc(pcibus);
+}
+
static void pci_uhci_port_1(void)
{
g_assert(pcibus != NULL);
int ret;
g_test_init(&argc, &argv, NULL);
- qtest_add_func("/ehci/pci/init", pci_init);
+
qtest_add_func("/ehci/pci/uhci-port-1", pci_uhci_port_1);
qtest_add_func("/ehci/pci/ehci-port-1", pci_ehci_port_1);
qtest_add_func("/ehci/pci/ehci-config", pci_ehci_config);
"-drive if=none,id=usbcdrom,media=cdrom "
"-device usb-tablet,bus=ich9-ehci-1.0,port=1,usb_version=1 "
"-device usb-storage,bus=ich9-ehci-1.0,port=2,drive=usbcdrom ");
+
+ test_init();
ret = g_test_run();
+ test_deinit();
qtest_end();
g_assert(port > 0);
qusb_pci_init_one(qs->pcibus, &uhci, QPCI_DEVFN(0x1d, 0), 4);
uhci_port_test(&uhci, port - 1, UHCI_PORT_CCS);
+ uhci_deinit(&uhci);
}
static void test_port_1(void)
};
typedef struct TestServer {
+ QPCIBus *bus;
gchar *socket_path;
gchar *mig_path;
gchar *chr_name;
static void init_virtio_dev(TestServer *s)
{
- QPCIBus *bus;
QVirtioPCIDevice *dev;
uint32_t features;
- bus = qpci_init_pc(NULL);
- g_assert_nonnull(bus);
+ s->bus = qpci_init_pc(NULL);
+ g_assert_nonnull(s->bus);
- dev = qvirtio_pci_device_find(bus, VIRTIO_ID_NET);
+ dev = qvirtio_pci_device_find(s->bus, VIRTIO_ID_NET);
g_assert_nonnull(dev);
qvirtio_pci_device_enable(dev);
qvirtio_set_features(&dev->vdev, features);
qvirtio_set_driver_ok(&dev->vdev);
+ qvirtio_pci_device_free(dev);
}
static void wait_for_fds(TestServer *s)
g_free(server->mig_path);
g_free(server->chr_name);
+ qpci_free_pc(server->bus);
+
g_free(server);
return FALSE;
{
qvirtqueue_cleanup(v9p->dev->bus, v9p->vq, v9p->qs->alloc);
qvirtio_pci_device_disable(container_of(v9p->dev, QVirtioPCIDevice, vdev));
- g_free(v9p->dev);
+ qvirtio_pci_device_free((QVirtioPCIDevice *)v9p->dev);
qvirtio_9p_stop(v9p);
}
{
QVirtioPCIDevice *dev;
- dev = qvirtio_pci_device_find(bus, VIRTIO_ID_BLOCK);
+ dev = qvirtio_pci_device_find_slot(bus, VIRTIO_ID_BLOCK, slot);
g_assert(dev != NULL);
g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_BLOCK);
g_assert_cmphex(dev->pdev->devfn, ==, ((slot << 3) | PCI_FN));
/* End test */
qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
qvirtio_pci_device_disable(dev);
- g_free(dev);
+ qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
}
/* End test */
qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
qvirtio_pci_device_disable(dev);
- g_free(dev);
+ qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
}
qvirtio_set_driver_ok(&dev->vdev);
- qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
- " 'size': %d } }", n_size);
+ qmp_discard_response("{ 'execute': 'block_resize', "
+ " 'arguments': { 'device': 'drive0', "
+ " 'size': %d } }", n_size);
qvirtio_wait_config_isr(&dev->vdev, QVIRTIO_BLK_TIMEOUT_US);
capacity = qvirtio_config_readq(&dev->vdev, 0);
g_assert_cmpint(capacity, ==, n_size / 512);
qvirtio_pci_device_disable(dev);
- g_free(dev);
+ qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
}
qvirtio_set_driver_ok(&dev->vdev);
- qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
- " 'size': %d } }", n_size);
+ qmp_discard_response("{ 'execute': 'block_resize', "
+ " 'arguments': { 'device': 'drive0', "
+ " 'size': %d } }", n_size);
qvirtio_wait_config_isr(&dev->vdev, QVIRTIO_BLK_TIMEOUT_US);
qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
qpci_msix_disable(dev->pdev);
qvirtio_pci_device_disable(dev);
- g_free(dev);
+ qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
}
qvirtqueue_cleanup(dev->vdev.bus, &vqpci->vq, qs->alloc);
qpci_msix_disable(dev->pdev);
qvirtio_pci_device_disable(dev);
- g_free(dev);
+ qvirtio_pci_device_free(dev);
qtest_shutdown(qs);
}
dev = virtio_blk_pci_init(qs->pcibus, PCI_SLOT_HP);
g_assert(dev);
qvirtio_pci_device_disable(dev);
- g_free(dev);
+ qvirtio_pci_device_free(dev);
/* unplug secondary disk */
if (strcmp(arch, "i386") == 0 || strcmp(arch, "x86_64") == 0) {
test_basic(&dev->vdev, alloc, vq);
- qmp("{ 'execute': 'block_resize', 'arguments': { 'device': 'drive0', "
- " 'size': %d } }", n_size);
+ qmp_discard_response("{ 'execute': 'block_resize', "
+ " 'arguments': { 'device': 'drive0', "
+ " 'size': %d } }", n_size);
qvirtio_wait_queue_isr(&dev->vdev, vq, QVIRTIO_BLK_TIMEOUT_US);
qvirtqueue_cleanup(vs->dev->bus, vs->vq[i], vs->qs->alloc);
}
qvirtio_pci_device_disable(container_of(vs->dev, QVirtioPCIDevice, vdev));
- g_free(vs->dev);
+ qvirtio_pci_device_free((QVirtioPCIDevice *)vs->dev);
qvirtio_scsi_stop(vs->qs);
g_free(vs);
}
ts->timer_list = NULL;
}
-void timer_free(QEMUTimer *ts)
-{
- g_free(ts);
-}
-
static void timer_del_locked(QEMUTimerList *timer_list, QEMUTimer *ts)
{
QEMUTimer **pt, *t;
projects / mirror_qemu.git / commitdiff