jcs.org / qemu
qemu with hax to log dma reads & writes jcs.org/2018/11/12/vfio
fork atom

libqtest: Add qtest_[v]startf()

We have several callers that were formatting the argument strings
themselves; consolidate this effort by adding new convenience
functions directly in libqtest, and update some call-sites that
can benefit from it.

Note that the new functions qtest_startf() and qtest_vstartf()
behave more like qtest_init() (the caller must assign global_qtest
after the fact, rather than getting it implicitly set). This helps
us prepare for future patches that get rid of the global variable,
by explicitly highlighting which tests still depend on it now.

Signed-off-by: Eric Blake <eblake@redhat.com>
[thuth: Dropped the hunks that do not apply cleanly to qemu master
yet and added the missing g_free(args) in qtest_vstartf()]
Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <1508336428-20511-2-git-send-email-thuth@redhat.com>
Acked-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Cornelia Huck <cohuck@redhat.com>

authored by

Eric Blake and committed by
Cornelia Huck 78b27bad 6bb6f194

+128 -138
+4 -7
tests/boot-order-test.c
··· 28 28 uint64_t expected_boot, 29 29 uint64_t expected_reboot) 30 30 { 31 - char *args; 32 31 uint64_t actual; 33 32 34 - args = g_strdup_printf("-nodefaults%s%s %s", 35 - machine ? " -M " : "", 36 - machine ?: "", 37 - test_args); 38 - qtest_start(args); 33 + global_qtest = qtest_startf("-nodefaults%s%s %s", 34 + machine ? " -M " : "", 35 + machine ?: "", 36 + test_args); 39 37 actual = read_boot_order(); 40 38 g_assert_cmphex(actual, ==, expected_boot); 41 39 qmp_discard_response("{ 'execute': 'system_reset' }"); ··· 47 45 actual = read_boot_order(); 48 46 g_assert_cmphex(actual, ==, expected_reboot); 49 47 qtest_quit(global_qtest); 50 - g_free(args); 51 48 } 52 49 53 50 static void test_boot_orders(const char *machine,
+4 -8
tests/boot-serial-test.c
··· 71 71 static void test_machine(const void *data) 72 72 { 73 73 const testdef_t *test = data; 74 - char *args; 75 74 char tmpname[] = "/tmp/qtest-boot-serial-XXXXXX"; 76 75 int fd; 77 76 ··· 82 81 * Make sure that this test uses tcg if available: It is used as a 83 82 * fast-enough smoketest for that. 84 83 */ 85 - args = g_strdup_printf("-M %s,accel=tcg:kvm " 86 - "-chardev file,id=serial0,path=%s " 87 - "-no-shutdown -serial chardev:serial0 %s", 88 - test->machine, tmpname, test->extra); 89 - 90 - qtest_start(args); 84 + global_qtest = qtest_startf("-M %s,accel=tcg:kvm " 85 + "-chardev file,id=serial0,path=%s " 86 + "-no-shutdown -serial chardev:serial0 %s", 87 + test->machine, tmpname, test->extra); 91 88 unlink(tmpname); 92 89 93 90 check_guest_output(test, fd); 94 91 qtest_quit(global_qtest); 95 92 96 - g_free(args); 97 93 close(fd); 98 94 } 99 95
+12 -21
tests/endianness-test.c
··· 114 114 static void test_endianness(gconstpointer data) 115 115 { 116 116 const TestCase *test = data; 117 - char *args; 118 117 119 - args = g_strdup_printf("-M %s%s%s -device pc-testdev", 120 - test->machine, 121 - test->superio ? " -device " : "", 122 - test->superio ?: ""); 123 - qtest_start(args); 118 + global_qtest = qtest_startf("-M %s%s%s -device pc-testdev", 119 + test->machine, 120 + test->superio ? " -device " : "", 121 + test->superio ?: ""); 124 122 isa_outl(test, 0xe0, 0x87654321); 125 123 g_assert_cmphex(isa_inl(test, 0xe0), ==, 0x87654321); 126 124 g_assert_cmphex(isa_inw(test, 0xe2), ==, 0x8765); ··· 183 181 g_assert_cmphex(isa_inb(test, 0xe1), ==, 0x43); 184 182 g_assert_cmphex(isa_inb(test, 0xe0), ==, 0x21); 185 183 qtest_quit(global_qtest); 186 - g_free(args); 187 184 } 188 185 189 186 static void test_endianness_split(gconstpointer data) 190 187 { 191 188 const TestCase *test = data; 192 - char *args; 193 189 194 - args = g_strdup_printf("-M %s%s%s -device pc-testdev", 195 - test->machine, 196 - test->superio ? " -device " : "", 197 - test->superio ?: ""); 198 - qtest_start(args); 190 + global_qtest = qtest_startf("-M %s%s%s -device pc-testdev", 191 + test->machine, 192 + test->superio ? " -device " : "", 193 + test->superio ?: ""); 199 194 isa_outl(test, 0xe8, 0x87654321); 200 195 g_assert_cmphex(isa_inl(test, 0xe0), ==, 0x87654321); 201 196 g_assert_cmphex(isa_inw(test, 0xe2), ==, 0x8765); ··· 230 225 g_assert_cmphex(isa_inw(test, 0xe2), ==, 0x8765); 231 226 g_assert_cmphex(isa_inw(test, 0xe0), ==, 0x4321); 232 227 qtest_quit(global_qtest); 233 - g_free(args); 234 228 } 235 229 236 230 static void test_endianness_combine(gconstpointer data) 237 231 { 238 232 const TestCase *test = data; 239 - char *args; 240 233 241 - args = g_strdup_printf("-M %s%s%s -device pc-testdev", 242 - test->machine, 243 - test->superio ? " -device " : "", 244 - test->superio ?: ""); 245 - qtest_start(args); 234 + global_qtest = qtest_startf("-M %s%s%s -device pc-testdev", 235 + test->machine, 236 + test->superio ? " -device " : "", 237 + test->superio ?: ""); 246 238 isa_outl(test, 0xe0, 0x87654321); 247 239 g_assert_cmphex(isa_inl(test, 0xe8), ==, 0x87654321); 248 240 g_assert_cmphex(isa_inw(test, 0xea), ==, 0x8765); ··· 277 269 g_assert_cmphex(isa_inw(test, 0xea), ==, 0x8765); 278 270 g_assert_cmphex(isa_inw(test, 0xe8), ==, 0x4321); 279 271 qtest_quit(global_qtest); 280 - g_free(args); 281 272 } 282 273 283 274 int main(int argc, char **argv)
+4 -7
tests/ipmi-bt-test.c
··· 401 401 int main(int argc, char **argv) 402 402 { 403 403 const char *arch = qtest_get_arch(); 404 - char *cmdline; 405 404 int ret; 406 405 407 406 /* Check architecture */ ··· 415 414 /* Run the tests */ 416 415 g_test_init(&argc, &argv, NULL); 417 416 418 - cmdline = g_strdup_printf( 419 - " -chardev socket,id=ipmi0,host=localhost,port=%d,reconnect=10" 420 - " -device ipmi-bmc-extern,chardev=ipmi0,id=bmc0" 421 - " -device isa-ipmi-bt,bmc=bmc0", emu_port); 422 - qtest_start(cmdline); 423 - g_free(cmdline); 417 + global_qtest = qtest_startf( 418 + " -chardev socket,id=ipmi0,host=localhost,port=%d,reconnect=10" 419 + " -device ipmi-bmc-extern,chardev=ipmi0,id=bmc0" 420 + " -device isa-ipmi-bt,bmc=bmc0", emu_port); 424 421 qtest_irq_intercept_in(global_qtest, "ioapic"); 425 422 qtest_add_func("/ipmi/extern/connect", test_connect); 426 423 qtest_add_func("/ipmi/extern/bt_base", test_bt_base);
+22
tests/libqtest.c
··· 244 244 return s; 245 245 } 246 246 247 + QTestState *qtest_vstartf(const char *fmt, va_list ap) 248 + { 249 + char *args = g_strdup_vprintf(fmt, ap); 250 + QTestState *s; 251 + 252 + s = qtest_start(args); 253 + g_free(args); 254 + global_qtest = NULL; 255 + return s; 256 + } 257 + 258 + QTestState *qtest_startf(const char *fmt, ...) 259 + { 260 + va_list ap; 261 + QTestState *s; 262 + 263 + va_start(ap, fmt); 264 + s = qtest_vstartf(fmt, ap); 265 + va_end(ap); 266 + return s; 267 + } 268 + 247 269 void qtest_quit(QTestState *s) 248 270 { 249 271 g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s));
+25
tests/libqtest.h
··· 24 24 extern QTestState *global_qtest; 25 25 26 26 /** 27 + * qtest_startf: 28 + * @fmt...: Format for creating other arguments to pass to QEMU, formatted 29 + * like sprintf(). 30 + * 31 + * Start QEMU and return the resulting #QTestState (but unlike qtest_start(), 32 + * #global_qtest is left at NULL). 33 + * 34 + * Returns: #QTestState instance. 35 + */ 36 + QTestState *qtest_startf(const char *fmt, ...) GCC_FMT_ATTR(1, 2); 37 + 38 + /** 39 + * qtest_vstartf: 40 + * @fmt: Format for creating other arguments to pass to QEMU, formatted 41 + * like vsprintf(). 42 + * @ap: Format arguments. 43 + * 44 + * Start QEMU and return the resulting #QTestState (but unlike qtest_start(), 45 + * #global_qtest is left at NULL). 46 + * 47 + * Returns: #QTestState instance. 48 + */ 49 + QTestState *qtest_vstartf(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0); 50 + 51 + /** 27 52 * qtest_init: 28 53 * @extra_args: other arguments to pass to QEMU. 29 54 *
+3 -6
tests/m25p80-test.c
··· 354 354 { 355 355 int ret; 356 356 int fd; 357 - char *args; 358 357 359 358 g_test_init(&argc, &argv, NULL); 360 359 ··· 364 363 g_assert(ret == 0); 365 364 close(fd); 366 365 367 - args = g_strdup_printf("-m 256 -machine palmetto-bmc " 368 - "-drive file=%s,format=raw,if=mtd", 369 - tmp_path); 370 - qtest_start(args); 366 + global_qtest = qtest_startf("-m 256 -machine palmetto-bmc " 367 + "-drive file=%s,format=raw,if=mtd", 368 + tmp_path); 371 369 372 370 qtest_add_func("/m25p80/read_jedec", test_read_jedec); 373 371 qtest_add_func("/m25p80/erase_sector", test_erase_sector); ··· 380 378 381 379 qtest_quit(global_qtest); 382 380 unlink(tmp_path); 383 - g_free(args); 384 381 return ret; 385 382 }
+4 -12
tests/pnv-xscom-test.c
··· 81 81 82 82 static void test_cfam_id(const void *data) 83 83 { 84 - char *args; 85 84 const PnvChip *chip = data; 86 85 87 - args = g_strdup_printf("-M powernv,accel=tcg -cpu %s", chip->cpu_model); 88 - 89 - qtest_start(args); 86 + global_qtest = qtest_startf("-M powernv,accel=tcg -cpu %s", 87 + chip->cpu_model); 90 88 test_xscom_cfam_id(chip); 91 89 qtest_quit(global_qtest); 92 - 93 - g_free(args); 94 90 } 95 91 96 92 #define PNV_XSCOM_EX_CORE_BASE(chip, i) \ ··· 109 105 110 106 static void test_core(const void *data) 111 107 { 112 - char *args; 113 108 const PnvChip *chip = data; 114 109 115 - args = g_strdup_printf("-M powernv,accel=tcg -cpu %s", chip->cpu_model); 116 - 117 - qtest_start(args); 110 + global_qtest = qtest_startf("-M powernv,accel=tcg -cpu %s", 111 + chip->cpu_model); 118 112 test_xscom_core(chip); 119 113 qtest_quit(global_qtest); 120 - 121 - g_free(args); 122 114 } 123 115 124 116 static void add_test(const char *name, void (*test)(const void *data))
+5 -8
tests/prom-env-test.c
··· 44 44 45 45 static void test_machine(const void *machine) 46 46 { 47 - char *args; 48 47 const char *extra_args; 49 48 50 49 /* The pseries firmware boots much faster without the default devices */ 51 50 extra_args = strcmp(machine, "pseries") == 0 ? "-nodefaults" : ""; 52 51 53 - args = g_strdup_printf("-M %s,accel=tcg %s -prom-env 'use-nvramrc?=true' " 54 - "-prom-env 'nvramrc=%x %x l!' ", 55 - (const char *)machine, extra_args, MAGIC, ADDRESS); 56 - 57 - qtest_start(args); 52 + global_qtest = qtest_startf("-M %s,accel=tcg %s " 53 + "-prom-env 'use-nvramrc?=true' " 54 + "-prom-env 'nvramrc=%x %x l!' ", 55 + (const char *)machine, extra_args, 56 + MAGIC, ADDRESS); 58 57 check_guest_memory(); 59 58 qtest_quit(global_qtest); 60 - 61 - g_free(args); 62 59 } 63 60 64 61 static void add_tests(const char *machines[])
+4 -6
tests/tco-test.c
··· 55 55 static void test_init(TestData *d) 56 56 { 57 57 QTestState *qs; 58 - char *s; 59 58 60 - s = g_strdup_printf("-machine q35 %s %s", 61 - d->noreboot ? "" : "-global ICH9-LPC.noreboot=false", 62 - !d->args ? "" : d->args); 63 - qs = qtest_start(s); 59 + qs = qtest_startf("-machine q35 %s %s", 60 + d->noreboot ? "" : "-global ICH9-LPC.noreboot=false", 61 + !d->args ? "" : d->args); 62 + global_qtest = qs; 64 63 qtest_irq_intercept_in(qs, "ioapic"); 65 - g_free(s); 66 64 67 65 d->bus = qpci_init_pc(NULL); 68 66 d->dev = qpci_device_find(d->bus, QPCI_DEVFN(0x1f, 0x00));
+6 -8
tests/test-filter-mirror.c
··· 18 18 static void test_mirror(void) 19 19 { 20 20 int send_sock[2], recv_sock; 21 - char *cmdline; 22 21 uint32_t ret = 0, len = 0; 23 22 char send_buf[] = "Hello! filter-mirror~"; 24 23 char sock_path[] = "filter-mirror.XXXXXX"; ··· 37 36 ret = mkstemp(sock_path); 38 37 g_assert_cmpint(ret, !=, -1); 39 38 40 - cmdline = g_strdup_printf("-netdev socket,id=qtest-bn0,fd=%d " 41 - "-device %s,netdev=qtest-bn0,id=qtest-e0 " 42 - "-chardev socket,id=mirror0,path=%s,server,nowait " 43 - "-object filter-mirror,id=qtest-f0,netdev=qtest-bn0,queue=tx,outdev=mirror0 " 44 - , send_sock[1], devstr, sock_path); 45 - qtest_start(cmdline); 46 - g_free(cmdline); 39 + global_qtest = qtest_startf( 40 + "-netdev socket,id=qtest-bn0,fd=%d " 41 + "-device %s,netdev=qtest-bn0,id=qtest-e0 " 42 + "-chardev socket,id=mirror0,path=%s,server,nowait " 43 + "-object filter-mirror,id=qtest-f0,netdev=qtest-bn0,queue=tx,outdev=mirror0 " 44 + , send_sock[1], devstr, sock_path); 47 45 48 46 recv_sock = unix_connect(sock_path, NULL); 49 47 g_assert_cmpint(recv_sock, !=, -1);
+26 -30
tests/test-filter-redirector.c
··· 70 70 static void test_redirector_tx(void) 71 71 { 72 72 int backend_sock[2], recv_sock; 73 - char *cmdline; 74 73 uint32_t ret = 0, len = 0; 75 74 char send_buf[] = "Hello!!"; 76 75 char sock_path0[] = "filter-redirector0.XXXXXX"; ··· 87 86 ret = mkstemp(sock_path1); 88 87 g_assert_cmpint(ret, !=, -1); 89 88 90 - cmdline = g_strdup_printf("-netdev socket,id=qtest-bn0,fd=%d " 91 - "-device %s,netdev=qtest-bn0,id=qtest-e0 " 92 - "-chardev socket,id=redirector0,path=%s,server,nowait " 93 - "-chardev socket,id=redirector1,path=%s,server,nowait " 94 - "-chardev socket,id=redirector2,path=%s,nowait " 95 - "-object filter-redirector,id=qtest-f0,netdev=qtest-bn0," 96 - "queue=tx,outdev=redirector0 " 97 - "-object filter-redirector,id=qtest-f1,netdev=qtest-bn0," 98 - "queue=tx,indev=redirector2 " 99 - "-object filter-redirector,id=qtest-f2,netdev=qtest-bn0," 100 - "queue=tx,outdev=redirector1 ", backend_sock[1], get_devstr(), 101 - sock_path0, sock_path1, sock_path0); 102 - qtest_start(cmdline); 103 - g_free(cmdline); 89 + global_qtest = qtest_startf( 90 + "-netdev socket,id=qtest-bn0,fd=%d " 91 + "-device %s,netdev=qtest-bn0,id=qtest-e0 " 92 + "-chardev socket,id=redirector0,path=%s,server,nowait " 93 + "-chardev socket,id=redirector1,path=%s,server,nowait " 94 + "-chardev socket,id=redirector2,path=%s,nowait " 95 + "-object filter-redirector,id=qtest-f0,netdev=qtest-bn0," 96 + "queue=tx,outdev=redirector0 " 97 + "-object filter-redirector,id=qtest-f1,netdev=qtest-bn0," 98 + "queue=tx,indev=redirector2 " 99 + "-object filter-redirector,id=qtest-f2,netdev=qtest-bn0," 100 + "queue=tx,outdev=redirector1 ", backend_sock[1], get_devstr(), 101 + sock_path0, sock_path1, sock_path0); 104 102 105 103 recv_sock = unix_connect(sock_path1, NULL); 106 104 g_assert_cmpint(recv_sock, !=, -1); ··· 141 139 static void test_redirector_rx(void) 142 140 { 143 141 int backend_sock[2], send_sock; 144 - char *cmdline; 145 142 uint32_t ret = 0, len = 0; 146 143 char send_buf[] = "Hello!!"; 147 144 char sock_path0[] = "filter-redirector0.XXXXXX"; ··· 158 155 ret = mkstemp(sock_path1); 159 156 g_assert_cmpint(ret, !=, -1); 160 157 161 - cmdline = g_strdup_printf("-netdev socket,id=qtest-bn0,fd=%d " 162 - "-device %s,netdev=qtest-bn0,id=qtest-e0 " 163 - "-chardev socket,id=redirector0,path=%s,server,nowait " 164 - "-chardev socket,id=redirector1,path=%s,server,nowait " 165 - "-chardev socket,id=redirector2,path=%s,nowait " 166 - "-object filter-redirector,id=qtest-f0,netdev=qtest-bn0," 167 - "queue=rx,indev=redirector0 " 168 - "-object filter-redirector,id=qtest-f1,netdev=qtest-bn0," 169 - "queue=rx,outdev=redirector2 " 170 - "-object filter-redirector,id=qtest-f2,netdev=qtest-bn0," 171 - "queue=rx,indev=redirector1 ", backend_sock[1], get_devstr(), 172 - sock_path0, sock_path1, sock_path0); 173 - qtest_start(cmdline); 174 - g_free(cmdline); 158 + global_qtest = qtest_startf( 159 + "-netdev socket,id=qtest-bn0,fd=%d " 160 + "-device %s,netdev=qtest-bn0,id=qtest-e0 " 161 + "-chardev socket,id=redirector0,path=%s,server,nowait " 162 + "-chardev socket,id=redirector1,path=%s,server,nowait " 163 + "-chardev socket,id=redirector2,path=%s,nowait " 164 + "-object filter-redirector,id=qtest-f0,netdev=qtest-bn0," 165 + "queue=rx,indev=redirector0 " 166 + "-object filter-redirector,id=qtest-f1,netdev=qtest-bn0," 167 + "queue=rx,outdev=redirector2 " 168 + "-object filter-redirector,id=qtest-f2,netdev=qtest-bn0," 169 + "queue=rx,indev=redirector1 ", backend_sock[1], get_devstr(), 170 + sock_path0, sock_path1, sock_path0); 175 171 176 172 struct iovec iov[] = { 177 173 {
+1 -4
tests/virtio-blk-test.c
··· 84 84 85 85 static void arm_test_start(void) 86 86 { 87 - char *cmdline; 88 87 char *tmp_path; 89 88 90 89 tmp_path = drive_create(); 91 90 92 - cmdline = g_strdup_printf("-machine virt " 91 + global_qtest = qtest_startf("-machine virt " 93 92 "-drive if=none,id=drive0,file=%s,format=raw " 94 93 "-device virtio-blk-device,drive=drive0", 95 94 tmp_path); 96 - qtest_start(cmdline); 97 95 unlink(tmp_path); 98 96 g_free(tmp_path); 99 - g_free(cmdline); 100 97 } 101 98 102 99 static void test_end(void)
+8 -21
tests/vmgenid-test.c
··· 130 130 131 131 static char disk[] = "tests/vmgenid-test-disk-XXXXXX"; 132 132 133 - static char *guid_cmd_strdup(const char *guid) 134 - { 135 - return g_strdup_printf("-machine accel=kvm:tcg " 136 - "-device vmgenid,id=testvgid,guid=%s " 137 - "-drive id=hd0,if=none,file=%s,format=raw " 138 - "-device ide-hd,drive=hd0 ", 139 - guid, disk); 140 - } 141 - 133 + #define GUID_CMD(guid) \ 134 + "-machine accel=kvm:tcg " \ 135 + "-device vmgenid,id=testvgid,guid=%s " \ 136 + "-drive id=hd0,if=none,file=%s,format=raw " \ 137 + "-device ide-hd,drive=hd0 ", guid, disk 142 138 143 139 static void vmgenid_set_guid_test(void) 144 140 { 145 141 QemuUUID expected, measured; 146 - gchar *cmd; 147 142 148 143 g_assert(qemu_uuid_parse(VGID_GUID, &expected) == 0); 149 144 150 - cmd = guid_cmd_strdup(VGID_GUID); 151 - qtest_start(cmd); 145 + global_qtest = qtest_startf(GUID_CMD(VGID_GUID)); 152 146 153 147 /* Read the GUID from accessing guest memory */ 154 148 read_guid_from_memory(&measured); 155 149 g_assert(memcmp(measured.data, expected.data, sizeof(measured.data)) == 0); 156 150 157 151 qtest_quit(global_qtest); 158 - g_free(cmd); 159 152 } 160 153 161 154 static void vmgenid_set_guid_auto_test(void) 162 155 { 163 - char *cmd; 164 156 QemuUUID measured; 165 157 166 - cmd = guid_cmd_strdup("auto"); 167 - qtest_start(cmd); 158 + global_qtest = qtest_startf(GUID_CMD("auto")); 168 159 169 160 read_guid_from_memory(&measured); 170 161 ··· 172 163 g_assert(!qemu_uuid_is_null(&measured)); 173 164 174 165 qtest_quit(global_qtest); 175 - g_free(cmd); 176 166 } 177 167 178 168 static void vmgenid_query_monitor_test(void) 179 169 { 180 170 QemuUUID expected, measured; 181 - gchar *cmd; 182 171 183 172 g_assert(qemu_uuid_parse(VGID_GUID, &expected) == 0); 184 173 185 - cmd = guid_cmd_strdup(VGID_GUID); 186 - qtest_start(cmd); 174 + global_qtest = qtest_startf(GUID_CMD(VGID_GUID)); 187 175 188 176 /* Read the GUID via the monitor */ 189 177 read_guid_from_monitor(&measured); 190 178 g_assert(memcmp(measured.data, expected.data, sizeof(measured.data)) == 0); 191 179 192 180 qtest_quit(global_qtest); 193 - g_free(cmd); 194 181 } 195 182 196 183 int main(int argc, char **argv)