]>
git.proxmox.com Git - qemu.git/blob - tests/libqtest.c
4 * Copyright IBM, Corp. 2012
5 * Copyright Red Hat, Inc. 2012
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Paolo Bonzini <pbonzini@redhat.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
18 #include <sys/types.h>
19 #include <sys/socket.h>
29 #include "qemu/compiler.h"
30 #include "qemu/osdep.h"
34 QTestState
*global_qtest
;
40 bool irq_level
[MAX_IRQ
];
42 gchar
*pid_file
; /* QEMU PID file */
43 int child_pid
; /* Child process created to execute QEMU */
44 char *socket_path
, *qmp_socket_path
;
47 #define g_assert_no_errno(ret) do { \
48 g_assert_cmpint(ret, !=, -1); \
51 static int init_socket(const char *socket_path
)
53 struct sockaddr_un addr
;
57 sock
= socket(PF_UNIX
, SOCK_STREAM
, 0);
58 g_assert_no_errno(sock
);
60 addr
.sun_family
= AF_UNIX
;
61 snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s", socket_path
);
62 qemu_set_cloexec(sock
);
65 ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
));
66 } while (ret
== -1 && errno
== EINTR
);
67 g_assert_no_errno(ret
);
73 static int socket_accept(int sock
)
75 struct sockaddr_un addr
;
79 addrlen
= sizeof(addr
);
81 ret
= accept(sock
, (struct sockaddr
*)&addr
, &addrlen
);
82 } while (ret
== -1 && errno
== EINTR
);
83 g_assert_no_errno(ret
);
89 static pid_t
qtest_qemu_pid(QTestState
*s
)
95 f
= fopen(s
->pid_file
, "r");
97 if (fgets(buffer
, sizeof(buffer
), f
)) {
105 QTestState
*qtest_init(const char *extra_args
)
108 int sock
, qmpsock
, ret
, i
;
111 const char *qemu_binary
;
114 qemu_binary
= getenv("QTEST_QEMU_BINARY");
115 g_assert(qemu_binary
!= NULL
);
117 s
= g_malloc(sizeof(*s
));
119 s
->socket_path
= g_strdup_printf("/tmp/qtest-%d.sock", getpid());
120 s
->qmp_socket_path
= g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
121 pid_file
= g_strdup_printf("/tmp/qtest-%d.pid", getpid());
123 sock
= init_socket(s
->socket_path
);
124 qmpsock
= init_socket(s
->qmp_socket_path
);
128 command
= g_strdup_printf("%s "
129 "-qtest unix:%s,nowait "
130 "-qtest-log /dev/null "
131 "-qmp unix:%s,nowait "
133 "-machine accel=qtest "
134 "%s", qemu_binary
, s
->socket_path
,
135 s
->qmp_socket_path
, pid_file
,
138 ret
= system(command
);
143 s
->fd
= socket_accept(sock
);
144 s
->qmp_fd
= socket_accept(qmpsock
);
146 s
->rx
= g_string_new("");
147 s
->pid_file
= pid_file
;
149 for (i
= 0; i
< MAX_IRQ
; i
++) {
150 s
->irq_level
[i
] = false;
153 /* Read the QMP greeting and then do the handshake */
155 qtest_qmp(s
, "{ 'execute': 'qmp_capabilities' }");
157 if (getenv("QTEST_STOP")) {
158 kill(qtest_qemu_pid(s
), SIGSTOP
);
164 void qtest_quit(QTestState
*s
)
168 pid_t pid
= qtest_qemu_pid(s
);
170 /* kill QEMU, but wait for the child created by us to run system() */
172 waitpid(s
->child_pid
, &status
, 0);
176 unlink(s
->socket_path
);
177 unlink(s
->qmp_socket_path
);
179 g_free(s
->socket_path
);
180 g_free(s
->qmp_socket_path
);
183 static void socket_sendf(int fd
, const char *fmt
, va_list ap
)
188 str
= g_strdup_vprintf(fmt
, ap
);
192 while (offset
< size
) {
195 len
= write(fd
, str
+ offset
, size
- offset
);
196 if (len
== -1 && errno
== EINTR
) {
200 g_assert_no_errno(len
);
201 g_assert_cmpint(len
, >, 0);
207 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState
*s
, const char *fmt
, ...)
212 socket_sendf(s
->fd
, fmt
, ap
);
216 static GString
*qtest_recv_line(QTestState
*s
)
222 while ((eol
= strchr(s
->rx
->str
, '\n')) == NULL
) {
226 len
= read(s
->fd
, buffer
, sizeof(buffer
));
227 if (len
== -1 && errno
== EINTR
) {
231 if (len
== -1 || len
== 0) {
232 fprintf(stderr
, "Broken pipe\n");
236 g_string_append_len(s
->rx
, buffer
, len
);
239 offset
= eol
- s
->rx
->str
;
240 line
= g_string_new_len(s
->rx
->str
, offset
);
241 g_string_erase(s
->rx
, 0, offset
+ 1);
246 static gchar
**qtest_rsp(QTestState
*s
, int expected_args
)
253 line
= qtest_recv_line(s
);
254 words
= g_strsplit(line
->str
, " ", 0);
255 g_string_free(line
, TRUE
);
257 if (strcmp(words
[0], "IRQ") == 0) {
260 g_assert(words
[1] != NULL
);
261 g_assert(words
[2] != NULL
);
263 irq
= strtoul(words
[2], NULL
, 0);
264 g_assert_cmpint(irq
, >=, 0);
265 g_assert_cmpint(irq
, <, MAX_IRQ
);
267 if (strcmp(words
[1], "raise") == 0) {
268 s
->irq_level
[irq
] = true;
270 s
->irq_level
[irq
] = false;
277 g_assert(words
[0] != NULL
);
278 g_assert_cmpstr(words
[0], ==, "OK");
281 for (i
= 0; i
< expected_args
; i
++) {
282 g_assert(words
[i
] != NULL
);
291 void qtest_qmp(QTestState
*s
, const char *fmt
, ...)
294 bool has_reply
= false;
297 /* Send QMP request */
299 socket_sendf(s
->qmp_fd
, fmt
, ap
);
303 while (!has_reply
|| nesting
> 0) {
307 len
= read(s
->qmp_fd
, &c
, 1);
308 if (len
== -1 && errno
== EINTR
) {
312 if (len
== -1 || len
== 0) {
313 fprintf(stderr
, "Broken pipe\n");
329 const char *qtest_get_arch(void)
331 const char *qemu
= getenv("QTEST_QEMU_BINARY");
332 const char *end
= strrchr(qemu
, '/');
334 return end
+ strlen("/qemu-system-");
337 bool qtest_get_irq(QTestState
*s
, int num
)
339 /* dummy operation in order to make sure irq is up to date */
342 return s
->irq_level
[num
];
345 static int64_t qtest_clock_rsp(QTestState
*s
)
349 words
= qtest_rsp(s
, 2);
350 clock
= g_ascii_strtoll(words
[1], NULL
, 0);
355 int64_t qtest_clock_step_next(QTestState
*s
)
357 qtest_sendf(s
, "clock_step\n");
358 return qtest_clock_rsp(s
);
361 int64_t qtest_clock_step(QTestState
*s
, int64_t step
)
363 qtest_sendf(s
, "clock_step %"PRIi64
"\n", step
);
364 return qtest_clock_rsp(s
);
367 int64_t qtest_clock_set(QTestState
*s
, int64_t val
)
369 qtest_sendf(s
, "clock_set %"PRIi64
"\n", val
);
370 return qtest_clock_rsp(s
);
373 void qtest_irq_intercept_out(QTestState
*s
, const char *qom_path
)
375 qtest_sendf(s
, "irq_intercept_out %s\n", qom_path
);
379 void qtest_irq_intercept_in(QTestState
*s
, const char *qom_path
)
381 qtest_sendf(s
, "irq_intercept_in %s\n", qom_path
);
385 static void qtest_out(QTestState
*s
, const char *cmd
, uint16_t addr
, uint32_t value
)
387 qtest_sendf(s
, "%s 0x%x 0x%x\n", cmd
, addr
, value
);
391 void qtest_outb(QTestState
*s
, uint16_t addr
, uint8_t value
)
393 qtest_out(s
, "outb", addr
, value
);
396 void qtest_outw(QTestState
*s
, uint16_t addr
, uint16_t value
)
398 qtest_out(s
, "outw", addr
, value
);
401 void qtest_outl(QTestState
*s
, uint16_t addr
, uint32_t value
)
403 qtest_out(s
, "outl", addr
, value
);
406 static uint32_t qtest_in(QTestState
*s
, const char *cmd
, uint16_t addr
)
411 qtest_sendf(s
, "%s 0x%x\n", cmd
, addr
);
412 args
= qtest_rsp(s
, 2);
413 value
= strtoul(args
[1], NULL
, 0);
419 uint8_t qtest_inb(QTestState
*s
, uint16_t addr
)
421 return qtest_in(s
, "inb", addr
);
424 uint16_t qtest_inw(QTestState
*s
, uint16_t addr
)
426 return qtest_in(s
, "inw", addr
);
429 uint32_t qtest_inl(QTestState
*s
, uint16_t addr
)
431 return qtest_in(s
, "inl", addr
);
434 static int hex2nib(char ch
)
436 if (ch
>= '0' && ch
<= '9') {
438 } else if (ch
>= 'a' && ch
<= 'f') {
439 return 10 + (ch
- 'a');
440 } else if (ch
>= 'A' && ch
<= 'F') {
441 return 10 + (ch
- 'a');
447 void qtest_memread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
453 qtest_sendf(s
, "read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
454 args
= qtest_rsp(s
, 2);
456 for (i
= 0; i
< size
; i
++) {
457 ptr
[i
] = hex2nib(args
[1][2 + (i
* 2)]) << 4;
458 ptr
[i
] |= hex2nib(args
[1][2 + (i
* 2) + 1]);
464 void qtest_add_func(const char *str
, void (*fn
))
466 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
467 g_test_add_func(path
, fn
);
470 void qtest_memwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
472 const uint8_t *ptr
= data
;
475 qtest_sendf(s
, "write 0x%" PRIx64
" 0x%zx 0x", addr
, size
);
476 for (i
= 0; i
< size
; i
++) {
477 qtest_sendf(s
, "%02x", ptr
[i
]);
479 qtest_sendf(s
, "\n");