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