include/qemu/timer.h

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