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