tests/libqtest.h

   1 /*
   2  * QTest
   3  *
   4  * Copyright IBM, Corp. 2012
   5  * Copyright Red Hat, Inc. 2012
   6  * Copyright SUSE LINUX Products GmbH 2013
   7  *
   8  * Authors:
   9  *  Anthony Liguori   <aliguori@us.ibm.com>
  10  *  Paolo Bonzini     <pbonzini@redhat.com>
  11  *  Andreas Färber    <afaerber@suse.de>
  12  *
  13  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  14  * See the COPYING file in the top-level directory.
  15  *
  16  */
  17 #ifndef LIBQTEST_H
  18 #define LIBQTEST_H
  19
  20 typedef struct QTestState QTestState;
  21
  22 extern QTestState *global_qtest;
  23
  24 /**
  25  * qtest_initf:
  26  * @fmt...: Format for creating other arguments to pass to QEMU, formatted
  27  * like sprintf().
  28  *
  29  * Convenience wrapper around qtest_start().
  30  *
  31  * Returns: #QTestState instance.
  32  */
  33 QTestState *qtest_initf(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
  34
  35 /**
  36  * qtest_vinitf:
  37  * @fmt: Format for creating other arguments to pass to QEMU, formatted
  38  * like vsprintf().
  39  * @ap: Format arguments.
  40  *
  41  * Convenience wrapper around qtest_start().
  42  *
  43  * Returns: #QTestState instance.
  44  */
  45 QTestState *qtest_vinitf(const char *fmt, va_list ap) GCC_FMT_ATTR(1, 0);
  46
  47 /**
  48  * qtest_init:
  49  * @extra_args: other arguments to pass to QEMU.  CAUTION: these
  50  * arguments are subject to word splitting and shell evaluation.
  51  *
  52  * Returns: #QTestState instance.
  53  */
  54 QTestState *qtest_init(const char *extra_args);
  55
  56 /**
  57  * qtest_init_without_qmp_handshake:
  58  * @use_oob: true to have the server advertise OOB support
  59  * @extra_args: other arguments to pass to QEMU.  CAUTION: these
  60  * arguments are subject to word splitting and shell evaluation.
  61  *
  62  * Returns: #QTestState instance.
  63  */
  64 QTestState *qtest_init_without_qmp_handshake(bool use_oob,
  65                                              const char *extra_args);
  66
  67 /**
  68  * qtest_quit:
  69  * @s: #QTestState instance to operate on.
  70  *
  71  * Shut down the QEMU process associated to @s.
  72  */
  73 void qtest_quit(QTestState *s);
  74
  75 /**
  76  * qtest_qmp:
  77  * @s: #QTestState instance to operate on.
  78  * @fmt...: QMP message to send to qemu, formatted like
  79  * qobject_from_jsonf_nofail().  See parse_escape() for what's
  80  * supported after '%'.
  81  *
  82  * Sends a QMP message to QEMU and returns the response.
  83  */
  84 QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
  85     GCC_FMT_ATTR(2, 3);
  86
  87 /**
  88  * qtest_qmp_send:
  89  * @s: #QTestState instance to operate on.
  90  * @fmt...: QMP message to send to qemu, formatted like
  91  * qobject_from_jsonf_nofail().  See parse_escape() for what's
  92  * supported after '%'.
  93  *
  94  * Sends a QMP message to QEMU and leaves the response in the stream.
  95  */
  96 void qtest_qmp_send(QTestState *s, const char *fmt, ...)
  97     GCC_FMT_ATTR(2, 3);
  98
  99 /**
 100  * qtest_qmp_send_raw:
 101  * @s: #QTestState instance to operate on.
 102  * @fmt...: text to send, formatted like sprintf()
 103  *
 104  * Sends text to the QMP monitor verbatim.  Need not be valid JSON;
 105  * this is useful for negative tests.
 106  */
 107 void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...)
 108     GCC_FMT_ATTR(2, 3);
 109
 110 /**
 111  * qtest_qmpv:
 112  * @s: #QTestState instance to operate on.
 113  * @fmt: QMP message to send to QEMU, formatted like
 114  * qobject_from_jsonf_nofail().  See parse_escape() for what's
 115  * supported after '%'.
 116  * @ap: QMP message arguments
 117  *
 118  * Sends a QMP message to QEMU and returns the response.
 119  */
 120 QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap)
 121     GCC_FMT_ATTR(2, 0);
 122
 123 /**
 124  * qtest_qmp_vsend:
 125  * @s: #QTestState instance to operate on.
 126  * @fmt: QMP message to send to QEMU, formatted like
 127  * qobject_from_jsonf_nofail().  See parse_escape() for what's
 128  * supported after '%'.
 129  * @ap: QMP message arguments
 130  *
 131  * Sends a QMP message to QEMU and leaves the response in the stream.
 132  */
 133 void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap)
 134     GCC_FMT_ATTR(2, 0);
 135
 136 /**
 137  * qtest_receive:
 138  * @s: #QTestState instance to operate on.
 139  *
 140  * Reads a QMP message from QEMU and returns the response.
 141  */
 142 QDict *qtest_qmp_receive(QTestState *s);
 143
 144 /**
 145  * qtest_qmp_eventwait:
 146  * @s: #QTestState instance to operate on.
 147  * @s: #event event to wait for.
 148  *
 149  * Continuously polls for QMP responses until it receives the desired event.
 150  */
 151 void qtest_qmp_eventwait(QTestState *s, const char *event);
 152
 153 /**
 154  * qtest_qmp_eventwait_ref:
 155  * @s: #QTestState instance to operate on.
 156  * @s: #event event to wait for.
 157  *
 158  * Continuously polls for QMP responses until it receives the desired event.
 159  * Returns a copy of the event for further investigation.
 160  */
 161 QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event);
 162
 163 /**
 164  * qtest_qmp_receive_success:
 165  * @s: #QTestState instance to operate on
 166  * @event_cb: Event callback
 167  * @opaque: Argument for @event_cb
 168  *
 169  * Poll QMP messages until a command success response is received.
 170  * If @event_cb, call it for each event received, passing @opaque,
 171  * the event's name and data.
 172  * Return the success response's "return" member.
 173  */
 174 QDict *qtest_qmp_receive_success(QTestState *s,
 175                                  void (*event_cb)(void *opaque,
 176                                                   const char *name,
 177                                                   QDict *data),
 178                                  void *opaque);
 179
 180 /**
 181  * qtest_hmp:
 182  * @s: #QTestState instance to operate on.
 183  * @fmt...: HMP command to send to QEMU, formats arguments like sprintf().
 184  *
 185  * Send HMP command to QEMU via QMP's human-monitor-command.
 186  * QMP events are discarded.
 187  *
 188  * Returns: the command's output.  The caller should g_free() it.
 189  */
 190 char *qtest_hmp(QTestState *s, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
 191
 192 /**
 193  * qtest_hmpv:
 194  * @s: #QTestState instance to operate on.
 195  * @fmt: HMP command to send to QEMU, formats arguments like vsprintf().
 196  * @ap: HMP command arguments
 197  *
 198  * Send HMP command to QEMU via QMP's human-monitor-command.
 199  * QMP events are discarded.
 200  *
 201  * Returns: the command's output.  The caller should g_free() it.
 202  */
 203 char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap)
 204     GCC_FMT_ATTR(2, 0);
 205
 206 /**
 207  * qtest_get_irq:
 208  * @s: #QTestState instance to operate on.
 209  * @num: Interrupt to observe.
 210  *
 211  * Returns: The level of the @num interrupt.
 212  */
 213 bool qtest_get_irq(QTestState *s, int num);
 214
 215 /**
 216  * qtest_irq_intercept_in:
 217  * @s: #QTestState instance to operate on.
 218  * @string: QOM path of a device.
 219  *
 220  * Associate qtest irqs with the GPIO-in pins of the device
 221  * whose path is specified by @string.
 222  */
 223 void qtest_irq_intercept_in(QTestState *s, const char *string);
 224
 225 /**
 226  * qtest_irq_intercept_out:
 227  * @s: #QTestState instance to operate on.
 228  * @string: QOM path of a device.
 229  *
 230  * Associate qtest irqs with the GPIO-out pins of the device
 231  * whose path is specified by @string.
 232  */
 233 void qtest_irq_intercept_out(QTestState *s, const char *string);
 234
 235 /**
 236  * qtest_outb:
 237  * @s: #QTestState instance to operate on.
 238  * @addr: I/O port to write to.
 239  * @value: Value being written.
 240  *
 241  * Write an 8-bit value to an I/O port.
 242  */
 243 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value);
 244
 245 /**
 246  * qtest_outw:
 247  * @s: #QTestState instance to operate on.
 248  * @addr: I/O port to write to.
 249  * @value: Value being written.
 250  *
 251  * Write a 16-bit value to an I/O port.
 252  */
 253 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value);
 254
 255 /**
 256  * qtest_outl:
 257  * @s: #QTestState instance to operate on.
 258  * @addr: I/O port to write to.
 259  * @value: Value being written.
 260  *
 261  * Write a 32-bit value to an I/O port.
 262  */
 263 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value);
 264
 265 /**
 266  * qtest_inb:
 267  * @s: #QTestState instance to operate on.
 268  * @addr: I/O port to read from.
 269  *
 270  * Returns an 8-bit value from an I/O port.
 271  */
 272 uint8_t qtest_inb(QTestState *s, uint16_t addr);
 273
 274 /**
 275  * qtest_inw:
 276  * @s: #QTestState instance to operate on.
 277  * @addr: I/O port to read from.
 278  *
 279  * Returns a 16-bit value from an I/O port.
 280  */
 281 uint16_t qtest_inw(QTestState *s, uint16_t addr);
 282
 283 /**
 284  * qtest_inl:
 285  * @s: #QTestState instance to operate on.
 286  * @addr: I/O port to read from.
 287  *
 288  * Returns a 32-bit value from an I/O port.
 289  */
 290 uint32_t qtest_inl(QTestState *s, uint16_t addr);
 291
 292 /**
 293  * qtest_writeb:
 294  * @s: #QTestState instance to operate on.
 295  * @addr: Guest address to write to.
 296  * @value: Value being written.
 297  *
 298  * Writes an 8-bit value to memory.
 299  */
 300 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value);
 301
 302 /**
 303  * qtest_writew:
 304  * @s: #QTestState instance to operate on.
 305  * @addr: Guest address to write to.
 306  * @value: Value being written.
 307  *
 308  * Writes a 16-bit value to memory.
 309  */
 310 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value);
 311
 312 /**
 313  * qtest_writel:
 314  * @s: #QTestState instance to operate on.
 315  * @addr: Guest address to write to.
 316  * @value: Value being written.
 317  *
 318  * Writes a 32-bit value to memory.
 319  */
 320 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value);
 321
 322 /**
 323  * qtest_writeq:
 324  * @s: #QTestState instance to operate on.
 325  * @addr: Guest address to write to.
 326  * @value: Value being written.
 327  *
 328  * Writes a 64-bit value to memory.
 329  */
 330 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value);
 331
 332 /**
 333  * qtest_readb:
 334  * @s: #QTestState instance to operate on.
 335  * @addr: Guest address to read from.
 336  *
 337  * Reads an 8-bit value from memory.
 338  *
 339  * Returns: Value read.
 340  */
 341 uint8_t qtest_readb(QTestState *s, uint64_t addr);
 342
 343 /**
 344  * qtest_readw:
 345  * @s: #QTestState instance to operate on.
 346  * @addr: Guest address to read from.
 347  *
 348  * Reads a 16-bit value from memory.
 349  *
 350  * Returns: Value read.
 351  */
 352 uint16_t qtest_readw(QTestState *s, uint64_t addr);
 353
 354 /**
 355  * qtest_readl:
 356  * @s: #QTestState instance to operate on.
 357  * @addr: Guest address to read from.
 358  *
 359  * Reads a 32-bit value from memory.
 360  *
 361  * Returns: Value read.
 362  */
 363 uint32_t qtest_readl(QTestState *s, uint64_t addr);
 364
 365 /**
 366  * qtest_readq:
 367  * @s: #QTestState instance to operate on.
 368  * @addr: Guest address to read from.
 369  *
 370  * Reads a 64-bit value from memory.
 371  *
 372  * Returns: Value read.
 373  */
 374 uint64_t qtest_readq(QTestState *s, uint64_t addr);
 375
 376 /**
 377  * qtest_memread:
 378  * @s: #QTestState instance to operate on.
 379  * @addr: Guest address to read from.
 380  * @data: Pointer to where memory contents will be stored.
 381  * @size: Number of bytes to read.
 382  *
 383  * Read guest memory into a buffer.
 384  */
 385 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size);
 386
 387 /**
 388  * qtest_rtas_call:
 389  * @s: #QTestState instance to operate on.
 390  * @name: name of the command to call.
 391  * @nargs: Number of args.
 392  * @args: Guest address to read args from.
 393  * @nret: Number of return value.
 394  * @ret: Guest address to write return values to.
 395  *
 396  * Call an RTAS function
 397  */
 398 uint64_t qtest_rtas_call(QTestState *s, const char *name,
 399                          uint32_t nargs, uint64_t args,
 400                          uint32_t nret, uint64_t ret);
 401
 402 /**
 403  * qtest_bufread:
 404  * @s: #QTestState instance to operate on.
 405  * @addr: Guest address to read from.
 406  * @data: Pointer to where memory contents will be stored.
 407  * @size: Number of bytes to read.
 408  *
 409  * Read guest memory into a buffer and receive using a base64 encoding.
 410  */
 411 void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size);
 412
 413 /**
 414  * qtest_memwrite:
 415  * @s: #QTestState instance to operate on.
 416  * @addr: Guest address to write to.
 417  * @data: Pointer to the bytes that will be written to guest memory.
 418  * @size: Number of bytes to write.
 419  *
 420  * Write a buffer to guest memory.
 421  */
 422 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size);
 423
 424 /**
 425  * qtest_bufwrite:
 426  * @s: #QTestState instance to operate on.
 427  * @addr: Guest address to write to.
 428  * @data: Pointer to the bytes that will be written to guest memory.
 429  * @size: Number of bytes to write.
 430  *
 431  * Write a buffer to guest memory and transmit using a base64 encoding.
 432  */
 433 void qtest_bufwrite(QTestState *s, uint64_t addr,
 434                     const void *data, size_t size);
 435
 436 /**
 437  * qtest_memset:
 438  * @s: #QTestState instance to operate on.
 439  * @addr: Guest address to write to.
 440  * @patt: Byte pattern to fill the guest memory region with.
 441  * @size: Number of bytes to write.
 442  *
 443  * Write a pattern to guest memory.
 444  */
 445 void qtest_memset(QTestState *s, uint64_t addr, uint8_t patt, size_t size);
 446
 447 /**
 448  * qtest_clock_step_next:
 449  * @s: #QTestState instance to operate on.
 450  *
 451  * Advance the QEMU_CLOCK_VIRTUAL to the next deadline.
 452  *
 453  * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds.
 454  */
 455 int64_t qtest_clock_step_next(QTestState *s);
 456
 457 /**
 458  * qtest_clock_step:
 459  * @s: QTestState instance to operate on.
 460  * @step: Number of nanoseconds to advance the clock by.
 461  *
 462  * Advance the QEMU_CLOCK_VIRTUAL by @step nanoseconds.
 463  *
 464  * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds.
 465  */
 466 int64_t qtest_clock_step(QTestState *s, int64_t step);
 467
 468 /**
 469  * qtest_clock_set:
 470  * @s: QTestState instance to operate on.
 471  * @val: Nanoseconds value to advance the clock to.
 472  *
 473  * Advance the QEMU_CLOCK_VIRTUAL to @val nanoseconds since the VM was launched.
 474  *
 475  * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds.
 476  */
 477 int64_t qtest_clock_set(QTestState *s, int64_t val);
 478
 479 /**
 480  * qtest_big_endian:
 481  * @s: QTestState instance to operate on.
 482  *
 483  * Returns: True if the architecture under test has a big endian configuration.
 484  */
 485 bool qtest_big_endian(QTestState *s);
 486
 487 /**
 488  * qtest_get_arch:
 489  *
 490  * Returns: The architecture for the QEMU executable under test.
 491  */
 492 const char *qtest_get_arch(void);
 493
 494 /**
 495  * qtest_add_func:
 496  * @str: Test case path.
 497  * @fn: Test case function
 498  *
 499  * Add a GTester testcase with the given name and function.
 500  * The path is prefixed with the architecture under test, as
 501  * returned by qtest_get_arch().
 502  */
 503 void qtest_add_func(const char *str, void (*fn)(void));
 504
 505 /**
 506  * qtest_add_data_func:
 507  * @str: Test case path.
 508  * @data: Test case data
 509  * @fn: Test case function
 510  *
 511  * Add a GTester testcase with the given name, data and function.
 512  * The path is prefixed with the architecture under test, as
 513  * returned by qtest_get_arch().
 514  */
 515 void qtest_add_data_func(const char *str, const void *data,
 516                          void (*fn)(const void *));
 517
 518 /**
 519  * qtest_add_data_func_full:
 520  * @str: Test case path.
 521  * @data: Test case data
 522  * @fn: Test case function
 523  * @data_free_func: GDestroyNotify for data
 524  *
 525  * Add a GTester testcase with the given name, data and function.
 526  * The path is prefixed with the architecture under test, as
 527  * returned by qtest_get_arch().
 528  *
 529  * @data is passed to @data_free_func() on test completion.
 530  */
 531 void qtest_add_data_func_full(const char *str, void *data,
 532                               void (*fn)(const void *),
 533                               GDestroyNotify data_free_func);
 534
 535 /**
 536  * qtest_add:
 537  * @testpath: Test case path
 538  * @Fixture: Fixture type
 539  * @tdata: Test case data
 540  * @fsetup: Test case setup function
 541  * @ftest: Test case function
 542  * @fteardown: Test case teardown function
 543  *
 544  * Add a GTester testcase with the given name, data and functions.
 545  * The path is prefixed with the architecture under test, as
 546  * returned by qtest_get_arch().
 547  */
 548 #define qtest_add(testpath, Fixture, tdata, fsetup, ftest, fteardown) \
 549     do { \
 550         char *path = g_strdup_printf("/%s/%s", qtest_get_arch(), testpath); \
 551         g_test_add(path, Fixture, tdata, fsetup, ftest, fteardown); \
 552         g_free(path); \
 553     } while (0)
 554
 555 void qtest_add_abrt_handler(GHookFunc fn, const void *data);
 556
 557 /**
 558  * qtest_start:
 559  * @args: other arguments to pass to QEMU
 560  *
 561  * Start QEMU and assign the resulting #QTestState to a global variable.
 562  * The global variable is used by "shortcut" functions documented below.
 563  *
 564  * Returns: #QTestState instance.
 565  */
 566 static inline QTestState *qtest_start(const char *args)
 567 {
 568     global_qtest = qtest_init(args);
 569     return global_qtest;
 570 }
 571
 572 /**
 573  * qtest_end:
 574  *
 575  * Shut down the QEMU process started by qtest_start().
 576  */
 577 static inline void qtest_end(void)
 578 {
 579     qtest_quit(global_qtest);
 580     global_qtest = NULL;
 581 }
 582
 583 /**
 584  * qmp:
 585  * @fmt...: QMP message to send to qemu, formatted like
 586  * qobject_from_jsonf_nofail().  See parse_escape() for what's
 587  * supported after '%'.
 588  *
 589  * Sends a QMP message to QEMU and returns the response.
 590  */
 591 QDict *qmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 592
 593 /**
 594  * qmp_send:
 595  * @fmt...: QMP message to send to qemu, formatted like
 596  * qobject_from_jsonf_nofail().  See parse_escape() for what's
 597  * supported after '%'.
 598  *
 599  * Sends a QMP message to QEMU and leaves the response in the stream.
 600  */
 601 void qmp_send(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 602
 603 /**
 604  * qmp_receive:
 605  *
 606  * Reads a QMP message from QEMU and returns the response.
 607  */
 608 static inline QDict *qmp_receive(void)
 609 {
 610     return qtest_qmp_receive(global_qtest);
 611 }
 612
 613 /**
 614  * qmp_eventwait:
 615  * @s: #event event to wait for.
 616  *
 617  * Continuously polls for QMP responses until it receives the desired event.
 618  */
 619 static inline void qmp_eventwait(const char *event)
 620 {
 621     return qtest_qmp_eventwait(global_qtest, event);
 622 }
 623
 624 /**
 625  * qmp_eventwait_ref:
 626  * @s: #event event to wait for.
 627  *
 628  * Continuously polls for QMP responses until it receives the desired event.
 629  * Returns a copy of the event for further investigation.
 630  */
 631 static inline QDict *qmp_eventwait_ref(const char *event)
 632 {
 633     return qtest_qmp_eventwait_ref(global_qtest, event);
 634 }
 635
 636 /**
 637  * hmp:
 638  * @fmt...: HMP command to send to QEMU, formats arguments like sprintf().
 639  *
 640  * Send HMP command to QEMU via QMP's human-monitor-command.
 641  *
 642  * Returns: the command's output.  The caller should g_free() it.
 643  */
 644 char *hmp(const char *fmt, ...) GCC_FMT_ATTR(1, 2);
 645
 646 /**
 647  * get_irq:
 648  * @num: Interrupt to observe.
 649  *
 650  * Returns: The level of the @num interrupt.
 651  */
 652 static inline bool get_irq(int num)
 653 {
 654     return qtest_get_irq(global_qtest, num);
 655 }
 656
 657 /**
 658  * irq_intercept_in:
 659  * @string: QOM path of a device.
 660  *
 661  * Associate qtest irqs with the GPIO-in pins of the device
 662  * whose path is specified by @string.
 663  */
 664 static inline void irq_intercept_in(const char *string)
 665 {
 666     qtest_irq_intercept_in(global_qtest, string);
 667 }
 668
 669 /**
 670  * qtest_irq_intercept_out:
 671  * @string: QOM path of a device.
 672  *
 673  * Associate qtest irqs with the GPIO-out pins of the device
 674  * whose path is specified by @string.
 675  */
 676 static inline void irq_intercept_out(const char *string)
 677 {
 678     qtest_irq_intercept_out(global_qtest, string);
 679 }
 680
 681 /**
 682  * outb:
 683  * @addr: I/O port to write to.
 684  * @value: Value being written.
 685  *
 686  * Write an 8-bit value to an I/O port.
 687  */
 688 static inline void outb(uint16_t addr, uint8_t value)
 689 {
 690     qtest_outb(global_qtest, addr, value);
 691 }
 692
 693 /**
 694  * outw:
 695  * @addr: I/O port to write to.
 696  * @value: Value being written.
 697  *
 698  * Write a 16-bit value to an I/O port.
 699  */
 700 static inline void outw(uint16_t addr, uint16_t value)
 701 {
 702     qtest_outw(global_qtest, addr, value);
 703 }
 704
 705 /**
 706  * outl:
 707  * @addr: I/O port to write to.
 708  * @value: Value being written.
 709  *
 710  * Write a 32-bit value to an I/O port.
 711  */
 712 static inline void outl(uint16_t addr, uint32_t value)
 713 {
 714     qtest_outl(global_qtest, addr, value);
 715 }
 716
 717 /**
 718  * inb:
 719  * @addr: I/O port to read from.
 720  *
 721  * Reads an 8-bit value from an I/O port.
 722  *
 723  * Returns: Value read.
 724  */
 725 static inline uint8_t inb(uint16_t addr)
 726 {
 727     return qtest_inb(global_qtest, addr);
 728 }
 729
 730 /**
 731  * inw:
 732  * @addr: I/O port to read from.
 733  *
 734  * Reads a 16-bit value from an I/O port.
 735  *
 736  * Returns: Value read.
 737  */
 738 static inline uint16_t inw(uint16_t addr)
 739 {
 740     return qtest_inw(global_qtest, addr);
 741 }
 742
 743 /**
 744  * inl:
 745  * @addr: I/O port to read from.
 746  *
 747  * Reads a 32-bit value from an I/O port.
 748  *
 749  * Returns: Value read.
 750  */
 751 static inline uint32_t inl(uint16_t addr)
 752 {
 753     return qtest_inl(global_qtest, addr);
 754 }
 755
 756 /**
 757  * writeb:
 758  * @addr: Guest address to write to.
 759  * @value: Value being written.
 760  *
 761  * Writes an 8-bit value to guest memory.
 762  */
 763 static inline void writeb(uint64_t addr, uint8_t value)
 764 {
 765     qtest_writeb(global_qtest, addr, value);
 766 }
 767
 768 /**
 769  * writew:
 770  * @addr: Guest address to write to.
 771  * @value: Value being written.
 772  *
 773  * Writes a 16-bit value to guest memory.
 774  */
 775 static inline void writew(uint64_t addr, uint16_t value)
 776 {
 777     qtest_writew(global_qtest, addr, value);
 778 }
 779
 780 /**
 781  * writel:
 782  * @addr: Guest address to write to.
 783  * @value: Value being written.
 784  *
 785  * Writes a 32-bit value to guest memory.
 786  */
 787 static inline void writel(uint64_t addr, uint32_t value)
 788 {
 789     qtest_writel(global_qtest, addr, value);
 790 }
 791
 792 /**
 793  * writeq:
 794  * @addr: Guest address to write to.
 795  * @value: Value being written.
 796  *
 797  * Writes a 64-bit value to guest memory.
 798  */
 799 static inline void writeq(uint64_t addr, uint64_t value)
 800 {
 801     qtest_writeq(global_qtest, addr, value);
 802 }
 803
 804 /**
 805  * readb:
 806  * @addr: Guest address to read from.
 807  *
 808  * Reads an 8-bit value from guest memory.
 809  *
 810  * Returns: Value read.
 811  */
 812 static inline uint8_t readb(uint64_t addr)
 813 {
 814     return qtest_readb(global_qtest, addr);
 815 }
 816
 817 /**
 818  * readw:
 819  * @addr: Guest address to read from.
 820  *
 821  * Reads a 16-bit value from guest memory.
 822  *
 823  * Returns: Value read.
 824  */
 825 static inline uint16_t readw(uint64_t addr)
 826 {
 827     return qtest_readw(global_qtest, addr);
 828 }
 829
 830 /**
 831  * readl:
 832  * @addr: Guest address to read from.
 833  *
 834  * Reads a 32-bit value from guest memory.
 835  *
 836  * Returns: Value read.
 837  */
 838 static inline uint32_t readl(uint64_t addr)
 839 {
 840     return qtest_readl(global_qtest, addr);
 841 }
 842
 843 /**
 844  * readq:
 845  * @addr: Guest address to read from.
 846  *
 847  * Reads a 64-bit value from guest memory.
 848  *
 849  * Returns: Value read.
 850  */
 851 static inline uint64_t readq(uint64_t addr)
 852 {
 853     return qtest_readq(global_qtest, addr);
 854 }
 855
 856 /**
 857  * memread:
 858  * @addr: Guest address to read from.
 859  * @data: Pointer to where memory contents will be stored.
 860  * @size: Number of bytes to read.
 861  *
 862  * Read guest memory into a buffer.
 863  */
 864 static inline void memread(uint64_t addr, void *data, size_t size)
 865 {
 866     qtest_memread(global_qtest, addr, data, size);
 867 }
 868
 869 /**
 870  * bufread:
 871  * @addr: Guest address to read from.
 872  * @data: Pointer to where memory contents will be stored.
 873  * @size: Number of bytes to read.
 874  *
 875  * Read guest memory into a buffer, receive using a base64 encoding.
 876  */
 877 static inline void bufread(uint64_t addr, void *data, size_t size)
 878 {
 879     qtest_bufread(global_qtest, addr, data, size);
 880 }
 881
 882 /**
 883  * memwrite:
 884  * @addr: Guest address to write to.
 885  * @data: Pointer to the bytes that will be written to guest memory.
 886  * @size: Number of bytes to write.
 887  *
 888  * Write a buffer to guest memory.
 889  */
 890 static inline void memwrite(uint64_t addr, const void *data, size_t size)
 891 {
 892     qtest_memwrite(global_qtest, addr, data, size);
 893 }
 894
 895 /**
 896  * bufwrite:
 897  * @addr: Guest address to write to.
 898  * @data: Pointer to the bytes that will be written to guest memory.
 899  * @size: Number of bytes to write.
 900  *
 901  * Write a buffer to guest memory, transmit using a base64 encoding.
 902  */
 903 static inline void bufwrite(uint64_t addr, const void *data, size_t size)
 904 {
 905     qtest_bufwrite(global_qtest, addr, data, size);
 906 }
 907
 908 /**
 909  * qmemset:
 910  * @addr: Guest address to write to.
 911  * @patt: Byte pattern to fill the guest memory region with.
 912  * @size: Number of bytes to write.
 913  *
 914  * Write a pattern to guest memory.
 915  */
 916 static inline void qmemset(uint64_t addr, uint8_t patt, size_t size)
 917 {
 918     qtest_memset(global_qtest, addr, patt, size);
 919 }
 920
 921 /**
 922  * clock_step_next:
 923  *
 924  * Advance the QEMU_CLOCK_VIRTUAL to the next deadline.
 925  *
 926  * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds.
 927  */
 928 static inline int64_t clock_step_next(void)
 929 {
 930     return qtest_clock_step_next(global_qtest);
 931 }
 932
 933 /**
 934  * clock_step:
 935  * @step: Number of nanoseconds to advance the clock by.
 936  *
 937  * Advance the QEMU_CLOCK_VIRTUAL by @step nanoseconds.
 938  *
 939  * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds.
 940  */
 941 static inline int64_t clock_step(int64_t step)
 942 {
 943     return qtest_clock_step(global_qtest, step);
 944 }
 945
 946 /**
 947  * clock_set:
 948  * @val: Nanoseconds value to advance the clock to.
 949  *
 950  * Advance the QEMU_CLOCK_VIRTUAL to @val nanoseconds since the VM was launched.
 951  *
 952  * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds.
 953  */
 954 static inline int64_t clock_set(int64_t val)
 955 {
 956     return qtest_clock_set(global_qtest, val);
 957 }
 958
 959 QDict *qmp_fd_receive(int fd);
 960 void qmp_fd_vsend(int fd, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0);
 961 void qmp_fd_send(int fd, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
 962 void qmp_fd_send_raw(int fd, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
 963 void qmp_fd_vsend_raw(int fd, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0);
 964 QDict *qmp_fdv(int fd, const char *fmt, va_list ap) GCC_FMT_ATTR(2, 0);
 965 QDict *qmp_fd(int fd, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
 966
 967 /**
 968  * qtest_cb_for_every_machine:
 969  * @cb: Pointer to the callback function
 970  * @skip_old_versioned: true if versioned old machine types should be skipped
 971  *
 972  *  Call a callback function for every name of all available machines.
 973  */
 974 void qtest_cb_for_every_machine(void (*cb)(const char *machine),
 975                                 bool skip_old_versioned);
 976
 977 /**
 978  * qtest_qmp_device_add:
 979  * @driver: Name of the device that should be added
 980  * @id: Identification string
 981  * @fmt...: QMP message to send to qemu, formatted like
 982  * qobject_from_jsonf_nofail().  See parse_escape() for what's
 983  * supported after '%'.
 984  *
 985  * Generic hot-plugging test via the device_add QMP command.
 986  */
 987 void qtest_qmp_device_add(const char *driver, const char *id, const char *fmt,
 988                           ...) GCC_FMT_ATTR(3, 4);
 989
 990 /**
 991  * qtest_qmp_device_del:
 992  * @id: Identification string
 993  *
 994  * Generic hot-unplugging test via the device_del QMP command.
 995  */
 996 void qtest_qmp_device_del(const char *id);
 997
 998 /**
 999  * qmp_rsp_is_err:
1000  * @rsp: QMP response to check for error
1001  *
1002  * Test @rsp for error and discard @rsp.
1003  * Returns 'true' if there is error in @rsp and 'false' otherwise.
1004  */
1005 bool qmp_rsp_is_err(QDict *rsp);
1006
1007 /**
1008  * qmp_assert_error_class:
1009  * @rsp: QMP response to check for error
1010  * @class: an error class
1011  *
1012  * Assert the response has the given error class and discard @rsp.
1013  */
1014 void qmp_assert_error_class(QDict *rsp, const char *class);
1015
1016 #endif