1 #ifndef QEMU_TIMER_H 2 #define QEMU_TIMER_H 3 4 #include "qemu-common.h" 5 #include "qemu/bitops.h" 6 #include "qemu/notify.h" 7 #include "qemu/host-utils.h" 8 9 #define NANOSECONDS_PER_SECOND 1000000000LL 10 11 /* timers */ 12 13 #define SCALE_MS 1000000 14 #define SCALE_US 1000 15 #define SCALE_NS 1 16 17 /** 18 * QEMUClockType: 19 * 20 * The following clock types are available: 21 * 22 * @QEMU_CLOCK_REALTIME: Real time clock 23 * 24 * The real time clock should be used only for stuff which does not 25 * change the virtual machine state, as it runs even if the virtual 26 * machine is stopped. 27 * 28 * @QEMU_CLOCK_VIRTUAL: virtual clock 29 * 30 * The virtual clock only runs during the emulation. It stops 31 * when the virtual machine is stopped. 32 * 33 * @QEMU_CLOCK_HOST: host clock 34 * 35 * The host clock should be used for device models that emulate accurate 36 * real time sources. It will continue to run when the virtual machine 37 * is suspended, and it will reflect system time changes the host may 38 * undergo (e.g. due to NTP). 39 * 40 * @QEMU_CLOCK_VIRTUAL_RT: realtime clock used for icount warp 41 * 42 * Outside icount mode, this clock is the same as @QEMU_CLOCK_VIRTUAL. 43 * In icount mode, this clock counts nanoseconds while the virtual 44 * machine is running. It is used to increase @QEMU_CLOCK_VIRTUAL 45 * while the CPUs are sleeping and thus not executing instructions. 46 */ 47 48 typedef enum { 49 QEMU_CLOCK_REALTIME = 0, 50 QEMU_CLOCK_VIRTUAL = 1, 51 QEMU_CLOCK_HOST = 2, 52 QEMU_CLOCK_VIRTUAL_RT = 3, 53 QEMU_CLOCK_MAX 54 } QEMUClockType; 55 56 /** 57 * QEMU Timer attributes: 58 * 59 * An individual timer may be given one or multiple attributes when initialized. 60 * Each attribute corresponds to one bit. Attributes modify the processing 61 * of timers when they fire. 62 * 63 * The following attributes are available: 64 * 65 * QEMU_TIMER_ATTR_EXTERNAL: drives external subsystem 66 * 67 * Timers with this attribute do not recorded in rr mode, therefore it could be 68 * used for the subsystems that operate outside the guest core. Applicable only 69 * with virtual clock type. 70 */ 71 72 #define QEMU_TIMER_ATTR_EXTERNAL BIT(0) 73 74 typedef struct QEMUTimerList QEMUTimerList; 75 76 struct QEMUTimerListGroup { 77 QEMUTimerList *tl[QEMU_CLOCK_MAX]; 78 }; 79 80 typedef void QEMUTimerCB(void *opaque); 81 typedef void QEMUTimerListNotifyCB(void *opaque, QEMUClockType type); 82 83 struct QEMUTimer { 84 int64_t expire_time; /* in nanoseconds */ 85 QEMUTimerList *timer_list; 86 QEMUTimerCB *cb; 87 void *opaque; 88 QEMUTimer *next; 89 int attributes; 90 int scale; 91 }; 92 93 extern QEMUTimerListGroup main_loop_tlg; 94 95 /* 96 * qemu_clock_get_ns; 97 * @type: the clock type 98 * 99 * Get the nanosecond value of a clock with 100 * type @type 101 * 102 * Returns: the clock value in nanoseconds 103 */ 104 int64_t qemu_clock_get_ns(QEMUClockType type); 105 106 /** 107 * qemu_clock_get_ms; 108 * @type: the clock type 109 * 110 * Get the millisecond value of a clock with 111 * type @type 112 * 113 * Returns: the clock value in milliseconds 114 */ 115 static inline int64_t qemu_clock_get_ms(QEMUClockType type) 116 { 117 return qemu_clock_get_ns(type) / SCALE_MS; 118 } 119 120 /** 121 * qemu_clock_get_us; 122 * @type: the clock type 123 * 124 * Get the microsecond value of a clock with 125 * type @type 126 * 127 * Returns: the clock value in microseconds 128 */ 129 static inline int64_t qemu_clock_get_us(QEMUClockType type) 130 { 131 return qemu_clock_get_ns(type) / SCALE_US; 132 } 133 134 /** 135 * qemu_clock_has_timers: 136 * @type: the clock type 137 * 138 * Determines whether a clock's default timer list 139 * has timers attached 140 * 141 * Note that this function should not be used when other threads also access 142 * the timer list. The return value may be outdated by the time it is acted 143 * upon. 144 * 145 * Returns: true if the clock's default timer list 146 * has timers attached 147 */ 148 bool qemu_clock_has_timers(QEMUClockType type); 149 150 /** 151 * qemu_clock_expired: 152 * @type: the clock type 153 * 154 * Determines whether a clock's default timer list 155 * has an expired timer. 156 * 157 * Returns: true if the clock's default timer list has 158 * an expired timer 159 */ 160 bool qemu_clock_expired(QEMUClockType type); 161 162 /** 163 * qemu_clock_use_for_deadline: 164 * @type: the clock type 165 * 166 * Determine whether a clock should be used for deadline 167 * calculations. Some clocks, for instance vm_clock with 168 * use_icount set, do not count in nanoseconds. Such clocks 169 * are not used for deadline calculations, and are presumed 170 * to interrupt any poll using qemu_notify/aio_notify 171 * etc. 172 * 173 * Returns: true if the clock runs in nanoseconds and 174 * should be used for a deadline. 175 */ 176 bool qemu_clock_use_for_deadline(QEMUClockType type); 177 178 /** 179 * qemu_clock_deadline_ns_all: 180 * @type: the clock type 181 * 182 * Calculate the deadline across all timer lists associated 183 * with a clock (as opposed to just the default one) 184 * in nanoseconds, or -1 if no timer is set to expire. 185 * 186 * Returns: time until expiry in nanoseconds or -1 187 */ 188 int64_t qemu_clock_deadline_ns_all(QEMUClockType type); 189 190 /** 191 * qemu_clock_get_main_loop_timerlist: 192 * @type: the clock type 193 * 194 * Return the default timer list associated with a clock. 195 * 196 * Returns: the default timer list 197 */ 198 QEMUTimerList *qemu_clock_get_main_loop_timerlist(QEMUClockType type); 199 200 /** 201 * qemu_clock_nofify: 202 * @type: the clock type 203 * 204 * Call the notifier callback connected with the default timer 205 * list linked to the clock, or qemu_notify() if none. 206 */ 207 void qemu_clock_notify(QEMUClockType type); 208 209 /** 210 * qemu_clock_enable: 211 * @type: the clock type 212 * @enabled: true to enable, false to disable 213 * 214 * Enable or disable a clock 215 * Disabling the clock will wait for related timerlists to stop 216 * executing qemu_run_timers. Thus, this functions should not 217 * be used from the callback of a timer that is based on @clock. 218 * Doing so would cause a deadlock. 219 * 220 * Caller should hold BQL. 221 */ 222 void qemu_clock_enable(QEMUClockType type, bool enabled); 223 224 /** 225 * qemu_start_warp_timer: 226 * 227 * Starts a timer for virtual clock update 228 */ 229 void qemu_start_warp_timer(void); 230 231 /** 232 * qemu_clock_register_reset_notifier: 233 * @type: the clock type 234 * @notifier: the notifier function 235 * 236 * Register a notifier function to call when the clock 237 * concerned is reset. 238 */ 239 void qemu_clock_register_reset_notifier(QEMUClockType type, 240 Notifier *notifier); 241 242 /** 243 * qemu_clock_unregister_reset_notifier: 244 * @type: the clock type 245 * @notifier: the notifier function 246 * 247 * Unregister a notifier function to call when the clock 248 * concerned is reset. 249 */ 250 void qemu_clock_unregister_reset_notifier(QEMUClockType type, 251 Notifier *notifier); 252 253 /** 254 * qemu_clock_run_timers: 255 * @type: clock on which to operate 256 * 257 * Run all the timers associated with the default timer list 258 * of a clock. 259 * 260 * Returns: true if any timer ran. 261 */ 262 bool qemu_clock_run_timers(QEMUClockType type); 263 264 /** 265 * qemu_clock_run_all_timers: 266 * 267 * Run all the timers associated with the default timer list 268 * of every clock. 269 * 270 * Returns: true if any timer ran. 271 */ 272 bool qemu_clock_run_all_timers(void); 273 274 /** 275 * qemu_clock_get_last: 276 * 277 * Returns last clock query time. 278 */ 279 uint64_t qemu_clock_get_last(QEMUClockType type); 280 /** 281 * qemu_clock_set_last: 282 * 283 * Sets last clock query time. 284 */ 285 void qemu_clock_set_last(QEMUClockType type, uint64_t last); 286 287 288 /* 289 * QEMUTimerList 290 */ 291 292 /** 293 * timerlist_new: 294 * @type: the clock type to associate with the timerlist 295 * @cb: the callback to call on notification 296 * @opaque: the opaque pointer to pass to the callback 297 * 298 * Create a new timerlist associated with the clock of 299 * type @type. 300 * 301 * Returns: a pointer to the QEMUTimerList created 302 */ 303 QEMUTimerList *timerlist_new(QEMUClockType type, 304 QEMUTimerListNotifyCB *cb, void *opaque); 305 306 /** 307 * timerlist_free: 308 * @timer_list: the timer list to free 309 * 310 * Frees a timer_list. It must have no active timers. 311 */ 312 void timerlist_free(QEMUTimerList *timer_list); 313 314 /** 315 * timerlist_has_timers: 316 * @timer_list: the timer list to operate on 317 * 318 * Determine whether a timer list has active timers 319 * 320 * Note that this function should not be used when other threads also access 321 * the timer list. The return value may be outdated by the time it is acted 322 * upon. 323 * 324 * Returns: true if the timer list has timers. 325 */ 326 bool timerlist_has_timers(QEMUTimerList *timer_list); 327 328 /** 329 * timerlist_expired: 330 * @timer_list: the timer list to operate on 331 * 332 * Determine whether a timer list has any timers which 333 * are expired. 334 * 335 * Returns: true if the timer list has timers which 336 * have expired. 337 */ 338 bool timerlist_expired(QEMUTimerList *timer_list); 339 340 /** 341 * timerlist_deadline_ns: 342 * @timer_list: the timer list to operate on 343 * 344 * Determine the deadline for a timer_list, i.e. 345 * the number of nanoseconds until the first timer 346 * expires. Return -1 if there are no timers. 347 * 348 * Returns: the number of nanoseconds until the earliest 349 * timer expires -1 if none 350 */ 351 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list); 352 353 /** 354 * timerlist_get_clock: 355 * @timer_list: the timer list to operate on 356 * 357 * Determine the clock type associated with a timer list. 358 * 359 * Returns: the clock type associated with the 360 * timer list. 361 */ 362 QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list); 363 364 /** 365 * timerlist_run_timers: 366 * @timer_list: the timer list to use 367 * 368 * Call all expired timers associated with the timer list. 369 * 370 * Returns: true if any timer expired 371 */ 372 bool timerlist_run_timers(QEMUTimerList *timer_list); 373 374 /** 375 * timerlist_notify: 376 * @timer_list: the timer list to use 377 * 378 * call the notifier callback associated with the timer list. 379 */ 380 void timerlist_notify(QEMUTimerList *timer_list); 381 382 /* 383 * QEMUTimerListGroup 384 */ 385 386 /** 387 * timerlistgroup_init: 388 * @tlg: the timer list group 389 * @cb: the callback to call when a notify is required 390 * @opaque: the opaque pointer to be passed to the callback. 391 * 392 * Initialise a timer list group. This must already be 393 * allocated in memory and zeroed. The notifier callback is 394 * called whenever a clock in the timer list group is 395 * reenabled or whenever a timer associated with any timer 396 * list is modified. If @cb is specified as null, qemu_notify() 397 * is used instead. 398 */ 399 void timerlistgroup_init(QEMUTimerListGroup *tlg, 400 QEMUTimerListNotifyCB *cb, void *opaque); 401 402 /** 403 * timerlistgroup_deinit: 404 * @tlg: the timer list group 405 * 406 * Deinitialise a timer list group. This must already be 407 * initialised. Note the memory is not freed. 408 */ 409 void timerlistgroup_deinit(QEMUTimerListGroup *tlg); 410 411 /** 412 * timerlistgroup_run_timers: 413 * @tlg: the timer list group 414 * 415 * Run the timers associated with a timer list group. 416 * This will run timers on multiple clocks. 417 * 418 * Returns: true if any timer callback ran 419 */ 420 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg); 421 422 /** 423 * timerlistgroup_deadline_ns: 424 * @tlg: the timer list group 425 * 426 * Determine the deadline of the soonest timer to 427 * expire associated with any timer list linked to 428 * the timer list group. Only clocks suitable for 429 * deadline calculation are included. 430 * 431 * Returns: the deadline in nanoseconds or -1 if no 432 * timers are to expire. 433 */ 434 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg); 435 436 /* 437 * QEMUTimer 438 */ 439 440 /** 441 * timer_init_full: 442 * @ts: the timer to be initialised 443 * @timer_list_group: (optional) the timer list group to attach the timer to 444 * @type: the clock type to use 445 * @scale: the scale value for the timer 446 * @attributes: 0, or one or more OR'ed QEMU_TIMER_ATTR_<id> values 447 * @cb: the callback to be called when the timer expires 448 * @opaque: the opaque pointer to be passed to the callback 449 * 450 * Initialise a timer with the given scale and attributes, 451 * and associate it with timer list for given clock @type in @timer_list_group 452 * (or default timer list group, if NULL). 453 * The caller is responsible for allocating the memory. 454 * 455 * You need not call an explicit deinit call. Simply make 456 * sure it is not on a list with timer_del. 457 */ 458 void timer_init_full(QEMUTimer *ts, 459 QEMUTimerListGroup *timer_list_group, QEMUClockType type, 460 int scale, int attributes, 461 QEMUTimerCB *cb, void *opaque); 462 463 /** 464 * timer_init: 465 * @ts: the timer to be initialised 466 * @type: the clock to associate with the timer 467 * @scale: the scale value for the timer 468 * @cb: the callback to call when the timer expires 469 * @opaque: the opaque pointer to pass to the callback 470 * 471 * Initialize a timer with the given scale on the default timer list 472 * associated with the clock. 473 * See timer_init_full for details. 474 */ 475 static inline void timer_init(QEMUTimer *ts, QEMUClockType type, int scale, 476 QEMUTimerCB *cb, void *opaque) 477 { 478 timer_init_full(ts, NULL, type, scale, 0, cb, opaque); 479 } 480 481 /** 482 * timer_init_ns: 483 * @ts: the timer to be initialised 484 * @type: the clock to associate with the timer 485 * @cb: the callback to call when the timer expires 486 * @opaque: the opaque pointer to pass to the callback 487 * 488 * Initialize a timer with nanosecond scale on the default timer list 489 * associated with the clock. 490 * See timer_init_full for details. 491 */ 492 static inline void timer_init_ns(QEMUTimer *ts, QEMUClockType type, 493 QEMUTimerCB *cb, void *opaque) 494 { 495 timer_init(ts, type, SCALE_NS, cb, opaque); 496 } 497 498 /** 499 * timer_init_us: 500 * @ts: the timer to be initialised 501 * @type: the clock to associate with the timer 502 * @cb: the callback to call when the timer expires 503 * @opaque: the opaque pointer to pass to the callback 504 * 505 * Initialize a timer with microsecond scale on the default timer list 506 * associated with the clock. 507 * See timer_init_full for details. 508 */ 509 static inline void timer_init_us(QEMUTimer *ts, QEMUClockType type, 510 QEMUTimerCB *cb, void *opaque) 511 { 512 timer_init(ts, type, SCALE_US, cb, opaque); 513 } 514 515 /** 516 * timer_init_ms: 517 * @ts: the timer to be initialised 518 * @type: the clock to associate with the timer 519 * @cb: the callback to call when the timer expires 520 * @opaque: the opaque pointer to pass to the callback 521 * 522 * Initialize a timer with millisecond scale on the default timer list 523 * associated with the clock. 524 * See timer_init_full for details. 525 */ 526 static inline void timer_init_ms(QEMUTimer *ts, QEMUClockType type, 527 QEMUTimerCB *cb, void *opaque) 528 { 529 timer_init(ts, type, SCALE_MS, cb, opaque); 530 } 531 532 /** 533 * timer_new_full: 534 * @timer_list_group: (optional) the timer list group to attach the timer to 535 * @type: the clock type to use 536 * @scale: the scale value for the timer 537 * @attributes: 0, or one or more OR'ed QEMU_TIMER_ATTR_<id> values 538 * @cb: the callback to be called when the timer expires 539 * @opaque: the opaque pointer to be passed to the callback 540 * 541 * Create a new timer with the given scale and attributes, 542 * and associate it with timer list for given clock @type in @timer_list_group 543 * (or default timer list group, if NULL). 544 * The memory is allocated by the function. 545 * 546 * This is not the preferred interface unless you know you 547 * are going to call timer_free. Use timer_init or timer_init_full instead. 548 * 549 * The default timer list has one special feature: in icount mode, 550 * %QEMU_CLOCK_VIRTUAL timers are run in the vCPU thread. This is 551 * not true of other timer lists, which are typically associated 552 * with an AioContext---each of them runs its timer callbacks in its own 553 * AioContext thread. 554 * 555 * Returns: a pointer to the timer 556 */ 557 static inline QEMUTimer *timer_new_full(QEMUTimerListGroup *timer_list_group, 558 QEMUClockType type, 559 int scale, int attributes, 560 QEMUTimerCB *cb, void *opaque) 561 { 562 QEMUTimer *ts = g_malloc0(sizeof(QEMUTimer)); 563 timer_init_full(ts, timer_list_group, type, scale, attributes, cb, opaque); 564 return ts; 565 } 566 567 /** 568 * timer_new: 569 * @type: the clock type to use 570 * @scale: the scale value for the timer 571 * @cb: the callback to be called when the timer expires 572 * @opaque: the opaque pointer to be passed to the callback 573 * 574 * Create a new timer with the given scale, 575 * and associate it with the default timer list for the clock type @type. 576 * See timer_new_full for details. 577 * 578 * Returns: a pointer to the timer 579 */ 580 static inline QEMUTimer *timer_new(QEMUClockType type, int scale, 581 QEMUTimerCB *cb, void *opaque) 582 { 583 return timer_new_full(NULL, type, scale, 0, cb, opaque); 584 } 585 586 /** 587 * timer_new_ns: 588 * @type: the clock type to associate with the timer 589 * @cb: the callback to call when the timer expires 590 * @opaque: the opaque pointer to pass to the callback 591 * 592 * Create a new timer with nanosecond scale on the default timer list 593 * associated with the clock. 594 * See timer_new_full for details. 595 * 596 * Returns: a pointer to the newly created timer 597 */ 598 static inline QEMUTimer *timer_new_ns(QEMUClockType type, QEMUTimerCB *cb, 599 void *opaque) 600 { 601 return timer_new(type, SCALE_NS, cb, opaque); 602 } 603 604 /** 605 * timer_new_us: 606 * @type: the clock type to associate with the timer 607 * @cb: the callback to call when the timer expires 608 * @opaque: the opaque pointer to pass to the callback 609 * 610 * Create a new timer with microsecond scale on the default timer list 611 * associated with the clock. 612 * See timer_new_full for details. 613 * 614 * Returns: a pointer to the newly created timer 615 */ 616 static inline QEMUTimer *timer_new_us(QEMUClockType type, QEMUTimerCB *cb, 617 void *opaque) 618 { 619 return timer_new(type, SCALE_US, cb, opaque); 620 } 621 622 /** 623 * timer_new_ms: 624 * @type: the clock type to associate with the timer 625 * @cb: the callback to call when the timer expires 626 * @opaque: the opaque pointer to pass to the callback 627 * 628 * Create a new timer with millisecond scale on the default timer list 629 * associated with the clock. 630 * See timer_new_full for details. 631 * 632 * Returns: a pointer to the newly created timer 633 */ 634 static inline QEMUTimer *timer_new_ms(QEMUClockType type, QEMUTimerCB *cb, 635 void *opaque) 636 { 637 return timer_new(type, SCALE_MS, cb, opaque); 638 } 639 640 /** 641 * timer_deinit: 642 * @ts: the timer to be de-initialised 643 * 644 * Deassociate the timer from any timerlist. You should 645 * call timer_del before. After this call, any further 646 * timer_del call cannot cause dangling pointer accesses 647 * even if the previously used timerlist is freed. 648 */ 649 void timer_deinit(QEMUTimer *ts); 650 651 /** 652 * timer_free: 653 * @ts: the timer 654 * 655 * Free a timer (it must not be on the active list) 656 */ 657 static inline void timer_free(QEMUTimer *ts) 658 { 659 g_free(ts); 660 } 661 662 /** 663 * timer_del: 664 * @ts: the timer 665 * 666 * Delete a timer from the active list. 667 * 668 * This function is thread-safe but the timer and its timer list must not be 669 * freed while this function is running. 670 */ 671 void timer_del(QEMUTimer *ts); 672 673 /** 674 * timer_mod_ns: 675 * @ts: the timer 676 * @expire_time: the expiry time in nanoseconds 677 * 678 * Modify a timer to expire at @expire_time 679 * 680 * This function is thread-safe but the timer and its timer list must not be 681 * freed while this function is running. 682 */ 683 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time); 684 685 /** 686 * timer_mod_anticipate_ns: 687 * @ts: the timer 688 * @expire_time: the expiry time in nanoseconds 689 * 690 * Modify a timer to expire at @expire_time or the current time, 691 * whichever comes earlier. 692 * 693 * This function is thread-safe but the timer and its timer list must not be 694 * freed while this function is running. 695 */ 696 void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time); 697 698 /** 699 * timer_mod: 700 * @ts: the timer 701 * @expire_time: the expire time in the units associated with the timer 702 * 703 * Modify a timer to expiry at @expire_time, taking into 704 * account the scale associated with the timer. 705 * 706 * This function is thread-safe but the timer and its timer list must not be 707 * freed while this function is running. 708 */ 709 void timer_mod(QEMUTimer *ts, int64_t expire_timer); 710 711 /** 712 * timer_mod_anticipate: 713 * @ts: the timer 714 * @expire_time: the expiry time in nanoseconds 715 * 716 * Modify a timer to expire at @expire_time or the current time, whichever 717 * comes earlier, taking into account the scale associated with the timer. 718 * 719 * This function is thread-safe but the timer and its timer list must not be 720 * freed while this function is running. 721 */ 722 void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time); 723 724 /** 725 * timer_pending: 726 * @ts: the timer 727 * 728 * Determines whether a timer is pending (i.e. is on the 729 * active list of timers, whether or not it has not yet expired). 730 * 731 * Returns: true if the timer is pending 732 */ 733 bool timer_pending(QEMUTimer *ts); 734 735 /** 736 * timer_expired: 737 * @ts: the timer 738 * @current_time: the current time 739 * 740 * Determines whether a timer has expired. 741 * 742 * Returns: true if the timer has expired 743 */ 744 bool timer_expired(QEMUTimer *timer_head, int64_t current_time); 745 746 /** 747 * timer_expire_time_ns: 748 * @ts: the timer 749 * 750 * Determine the expiry time of a timer 751 * 752 * Returns: the expiry time in nanoseconds 753 */ 754 uint64_t timer_expire_time_ns(QEMUTimer *ts); 755 756 /** 757 * timer_get: 758 * @f: the file 759 * @ts: the timer 760 * 761 * Read a timer @ts from a file @f 762 */ 763 void timer_get(QEMUFile *f, QEMUTimer *ts); 764 765 /** 766 * timer_put: 767 * @f: the file 768 * @ts: the timer 769 */ 770 void timer_put(QEMUFile *f, QEMUTimer *ts); 771 772 /* 773 * General utility functions 774 */ 775 776 /** 777 * qemu_timeout_ns_to_ms: 778 * @ns: nanosecond timeout value 779 * 780 * Convert a nanosecond timeout value (or -1) to 781 * a millisecond value (or -1), always rounding up. 782 * 783 * Returns: millisecond timeout value 784 */ 785 int qemu_timeout_ns_to_ms(int64_t ns); 786 787 /** 788 * qemu_poll_ns: 789 * @fds: Array of file descriptors 790 * @nfds: number of file descriptors 791 * @timeout: timeout in nanoseconds 792 * 793 * Perform a poll like g_poll but with a timeout in nanoseconds. 794 * See g_poll documentation for further details. 795 * 796 * Returns: number of fds ready 797 */ 798 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout); 799 800 /** 801 * qemu_soonest_timeout: 802 * @timeout1: first timeout in nanoseconds (or -1 for infinite) 803 * @timeout2: second timeout in nanoseconds (or -1 for infinite) 804 * 805 * Calculates the soonest of two timeout values. -1 means infinite, which 806 * is later than any other value. 807 * 808 * Returns: soonest timeout value in nanoseconds (or -1 for infinite) 809 */ 810 static inline int64_t qemu_soonest_timeout(int64_t timeout1, int64_t timeout2) 811 { 812 /* we can abuse the fact that -1 (which means infinite) is a maximal 813 * value when cast to unsigned. As this is disgusting, it's kept in 814 * one inline function. 815 */ 816 return ((uint64_t) timeout1 < (uint64_t) timeout2) ? timeout1 : timeout2; 817 } 818 819 /** 820 * initclocks: 821 * 822 * Initialise the clock & timer infrastructure 823 */ 824 void init_clocks(QEMUTimerListNotifyCB *notify_cb); 825 826 int64_t cpu_get_ticks(void); 827 /* Caller must hold BQL */ 828 void cpu_enable_ticks(void); 829 /* Caller must hold BQL */ 830 void cpu_disable_ticks(void); 831 832 static inline int64_t get_max_clock_jump(void) 833 { 834 /* This should be small enough to prevent excessive interrupts from being 835 * generated by the RTC on clock jumps, but large enough to avoid frequent 836 * unnecessary resets in idle VMs. 837 */ 838 return 60 * NANOSECONDS_PER_SECOND; 839 } 840 841 /* 842 * Low level clock functions 843 */ 844 845 /* get host real time in nanosecond */ 846 static inline int64_t get_clock_realtime(void) 847 { 848 struct timeval tv; 849 850 gettimeofday(&tv, NULL); 851 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000); 852 } 853 854 /* Warning: don't insert tracepoints into these functions, they are 855 also used by simpletrace backend and tracepoints would cause 856 an infinite recursion! */ 857 #ifdef _WIN32 858 extern int64_t clock_freq; 859 860 static inline int64_t get_clock(void) 861 { 862 LARGE_INTEGER ti; 863 QueryPerformanceCounter(&ti); 864 return muldiv64(ti.QuadPart, NANOSECONDS_PER_SECOND, clock_freq); 865 } 866 867 #else 868 869 extern int use_rt_clock; 870 871 static inline int64_t get_clock(void) 872 { 873 #ifdef CLOCK_MONOTONIC 874 if (use_rt_clock) { 875 struct timespec ts; 876 clock_gettime(CLOCK_MONOTONIC, &ts); 877 return ts.tv_sec * 1000000000LL + ts.tv_nsec; 878 } else 879 #endif 880 { 881 /* XXX: using gettimeofday leads to problems if the date 882 changes, so it should be avoided. */ 883 return get_clock_realtime(); 884 } 885 } 886 #endif 887 888 /* icount */ 889 int64_t cpu_get_icount_raw(void); 890 int64_t cpu_get_icount(void); 891 int64_t cpu_get_clock(void); 892 int64_t cpu_icount_to_ns(int64_t icount); 893 void cpu_update_icount(CPUState *cpu); 894 895 /*******************************************/ 896 /* host CPU ticks (if available) */ 897 898 #if defined(_ARCH_PPC) 899 900 static inline int64_t cpu_get_host_ticks(void) 901 { 902 int64_t retval; 903 #ifdef _ARCH_PPC64 904 /* This reads timebase in one 64bit go and includes Cell workaround from: 905 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html 906 */ 907 __asm__ __volatile__ ("mftb %0\n\t" 908 "cmpwi %0,0\n\t" 909 "beq- $-8" 910 : "=r" (retval)); 911 #else 912 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */ 913 unsigned long junk; 914 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */ 915 "mfspr %L0,268\n\t" /* mftb */ 916 "mfspr %0,269\n\t" /* mftbu */ 917 "cmpw %0,%1\n\t" 918 "bne $-16" 919 : "=r" (retval), "=r" (junk)); 920 #endif 921 return retval; 922 } 923 924 #elif defined(__i386__) 925 926 static inline int64_t cpu_get_host_ticks(void) 927 { 928 int64_t val; 929 asm volatile ("rdtsc" : "=A" (val)); 930 return val; 931 } 932 933 #elif defined(__x86_64__) 934 935 static inline int64_t cpu_get_host_ticks(void) 936 { 937 uint32_t low,high; 938 int64_t val; 939 asm volatile("rdtsc" : "=a" (low), "=d" (high)); 940 val = high; 941 val <<= 32; 942 val |= low; 943 return val; 944 } 945 946 #elif defined(__hppa__) 947 948 static inline int64_t cpu_get_host_ticks(void) 949 { 950 int val; 951 asm volatile ("mfctl %%cr16, %0" : "=r"(val)); 952 return val; 953 } 954 955 #elif defined(__s390__) 956 957 static inline int64_t cpu_get_host_ticks(void) 958 { 959 int64_t val; 960 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc"); 961 return val; 962 } 963 964 #elif defined(__sparc__) 965 966 static inline int64_t cpu_get_host_ticks (void) 967 { 968 #if defined(_LP64) 969 uint64_t rval; 970 asm volatile("rd %%tick,%0" : "=r"(rval)); 971 return rval; 972 #else 973 /* We need an %o or %g register for this. For recent enough gcc 974 there is an "h" constraint for that. Don't bother with that. */ 975 union { 976 uint64_t i64; 977 struct { 978 uint32_t high; 979 uint32_t low; 980 } i32; 981 } rval; 982 asm volatile("rd %%tick,%%g1; srlx %%g1,32,%0; mov %%g1,%1" 983 : "=r"(rval.i32.high), "=r"(rval.i32.low) : : "g1"); 984 return rval.i64; 985 #endif 986 } 987 988 #elif defined(__mips__) && \ 989 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__)) 990 /* 991 * binutils wants to use rdhwr only on mips32r2 992 * but as linux kernel emulate it, it's fine 993 * to use it. 994 * 995 */ 996 #define MIPS_RDHWR(rd, value) { \ 997 __asm__ __volatile__ (".set push\n\t" \ 998 ".set mips32r2\n\t" \ 999 "rdhwr %0, "rd"\n\t" \ 1000 ".set pop" \ 1001 : "=r" (value)); \ 1002 } 1003 1004 static inline int64_t cpu_get_host_ticks(void) 1005 { 1006 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */ 1007 uint32_t count; 1008 static uint32_t cyc_per_count = 0; 1009 1010 if (!cyc_per_count) { 1011 MIPS_RDHWR("$3", cyc_per_count); 1012 } 1013 1014 MIPS_RDHWR("$2", count); 1015 return (int64_t)(count * cyc_per_count); 1016 } 1017 1018 #elif defined(__alpha__) 1019 1020 static inline int64_t cpu_get_host_ticks(void) 1021 { 1022 uint64_t cc; 1023 uint32_t cur, ofs; 1024 1025 asm volatile("rpcc %0" : "=r"(cc)); 1026 cur = cc; 1027 ofs = cc >> 32; 1028 return cur - ofs; 1029 } 1030 1031 #else 1032 /* The host CPU doesn't have an easily accessible cycle counter. 1033 Just return a monotonically increasing value. This will be 1034 totally wrong, but hopefully better than nothing. */ 1035 static inline int64_t cpu_get_host_ticks(void) 1036 { 1037 return get_clock(); 1038 } 1039 #endif 1040 1041 #ifdef CONFIG_PROFILER 1042 static inline int64_t profile_getclock(void) 1043 { 1044 return get_clock(); 1045 } 1046 1047 extern int64_t dev_time; 1048 #endif 1049 1050 #endif 1051