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  * QEMUTimerList
 256  */
 257
 258 /**
 259  * timerlist_new:
 260  * @type: the clock type to associate with the timerlist
 261  * @cb: the callback to call on notification
 262  * @opaque: the opaque pointer to pass to the callback
 263  *
 264  * Create a new timerlist associated with the clock of
 265  * type @type.
 266  *
 267  * Returns: a pointer to the QEMUTimerList created
 268  */
 269 QEMUTimerList *timerlist_new(QEMUClockType type,
 270                              QEMUTimerListNotifyCB *cb, void *opaque);
 271
 272 /**
 273  * timerlist_free:
 274  * @timer_list: the timer list to free
 275  *
 276  * Frees a timer_list. It must have no active timers.
 277  */
 278 void timerlist_free(QEMUTimerList *timer_list);
 279
 280 /**
 281  * timerlist_has_timers:
 282  * @timer_list: the timer list to operate on
 283  *
 284  * Determine whether a timer list has active timers
 285  *
 286  * Note that this function should not be used when other threads also access
 287  * the timer list.  The return value may be outdated by the time it is acted
 288  * upon.
 289  *
 290  * Returns: true if the timer list has timers.
 291  */
 292 bool timerlist_has_timers(QEMUTimerList *timer_list);
 293
 294 /**
 295  * timerlist_expired:
 296  * @timer_list: the timer list to operate on
 297  *
 298  * Determine whether a timer list has any timers which
 299  * are expired.
 300  *
 301  * Returns: true if the timer list has timers which
 302  * have expired.
 303  */
 304 bool timerlist_expired(QEMUTimerList *timer_list);
 305
 306 /**
 307  * timerlist_deadline_ns:
 308  * @timer_list: the timer list to operate on
 309  *
 310  * Determine the deadline for a timer_list, i.e.
 311  * the number of nanoseconds until the first timer
 312  * expires. Return -1 if there are no timers.
 313  *
 314  * Returns: the number of nanoseconds until the earliest
 315  * timer expires -1 if none
 316  */
 317 int64_t timerlist_deadline_ns(QEMUTimerList *timer_list);
 318
 319 /**
 320  * timerlist_get_clock:
 321  * @timer_list: the timer list to operate on
 322  *
 323  * Determine the clock type associated with a timer list.
 324  *
 325  * Returns: the clock type associated with the
 326  * timer list.
 327  */
 328 QEMUClockType timerlist_get_clock(QEMUTimerList *timer_list);
 329
 330 /**
 331  * timerlist_run_timers:
 332  * @timer_list: the timer list to use
 333  *
 334  * Call all expired timers associated with the timer list.
 335  *
 336  * Returns: true if any timer expired
 337  */
 338 bool timerlist_run_timers(QEMUTimerList *timer_list);
 339
 340 /**
 341  * timerlist_notify:
 342  * @timer_list: the timer list to use
 343  *
 344  * call the notifier callback associated with the timer list.
 345  */
 346 void timerlist_notify(QEMUTimerList *timer_list);
 347
 348 /*
 349  * QEMUTimerListGroup
 350  */
 351
 352 /**
 353  * timerlistgroup_init:
 354  * @tlg: the timer list group
 355  * @cb: the callback to call when a notify is required
 356  * @opaque: the opaque pointer to be passed to the callback.
 357  *
 358  * Initialise a timer list group. This must already be
 359  * allocated in memory and zeroed. The notifier callback is
 360  * called whenever a clock in the timer list group is
 361  * reenabled or whenever a timer associated with any timer
 362  * list is modified. If @cb is specified as null, qemu_notify()
 363  * is used instead.
 364  */
 365 void timerlistgroup_init(QEMUTimerListGroup *tlg,
 366                          QEMUTimerListNotifyCB *cb, void *opaque);
 367
 368 /**
 369  * timerlistgroup_deinit:
 370  * @tlg: the timer list group
 371  *
 372  * Deinitialise a timer list group. This must already be
 373  * initialised. Note the memory is not freed.
 374  */
 375 void timerlistgroup_deinit(QEMUTimerListGroup *tlg);
 376
 377 /**
 378  * timerlistgroup_run_timers:
 379  * @tlg: the timer list group
 380  *
 381  * Run the timers associated with a timer list group.
 382  * This will run timers on multiple clocks.
 383  *
 384  * Returns: true if any timer callback ran
 385  */
 386 bool timerlistgroup_run_timers(QEMUTimerListGroup *tlg);
 387
 388 /**
 389  * timerlistgroup_deadline_ns:
 390  * @tlg: the timer list group
 391  *
 392  * Determine the deadline of the soonest timer to
 393  * expire associated with any timer list linked to
 394  * the timer list group. Only clocks suitable for
 395  * deadline calculation are included.
 396  *
 397  * Returns: the deadline in nanoseconds or -1 if no
 398  * timers are to expire.
 399  */
 400 int64_t timerlistgroup_deadline_ns(QEMUTimerListGroup *tlg);
 401
 402 /*
 403  * QEMUTimer
 404  */
 405
 406 /**
 407  * timer_init_tl:
 408  * @ts: the timer to be initialised
 409  * @timer_list: the timer list to attach the timer to
 410  * @scale: the scale value for the timer
 411  * @cb: the callback to be called when the timer expires
 412  * @opaque: the opaque pointer to be passed to the callback
 413  *
 414  * Initialise a new timer and associate it with @timer_list.
 415  * The caller is responsible for allocating the memory.
 416  *
 417  * You need not call an explicit deinit call. Simply make
 418  * sure it is not on a list with timer_del.
 419  */
 420 void timer_init_tl(QEMUTimer *ts,
 421                    QEMUTimerList *timer_list, int scale,
 422                    QEMUTimerCB *cb, void *opaque);
 423
 424 /**
 425  * timer_init:
 426  * @ts: the timer to be initialised
 427  * @type: the clock to associate with the timer
 428  * @scale: the scale value for the timer
 429  * @cb: the callback to call when the timer expires
 430  * @opaque: the opaque pointer to pass to the callback
 431  *
 432  * Initialize a timer with the given scale on the default timer list
 433  * associated with the clock.
 434  *
 435  * You need not call an explicit deinit call. Simply make
 436  * sure it is not on a list with timer_del.
 437  */
 438 static inline void timer_init(QEMUTimer *ts, QEMUClockType type, int scale,
 439                               QEMUTimerCB *cb, void *opaque)
 440 {
 441     timer_init_tl(ts, main_loop_tlg.tl[type], scale, cb, opaque);
 442 }
 443
 444 /**
 445  * timer_init_ns:
 446  * @ts: the timer to be initialised
 447  * @type: the clock to associate with the timer
 448  * @cb: the callback to call when the timer expires
 449  * @opaque: the opaque pointer to pass to the callback
 450  *
 451  * Initialize a timer with nanosecond scale on the default timer list
 452  * associated with the clock.
 453  *
 454  * You need not call an explicit deinit call. Simply make
 455  * sure it is not on a list with timer_del.
 456  */
 457 static inline void timer_init_ns(QEMUTimer *ts, QEMUClockType type,
 458                                  QEMUTimerCB *cb, void *opaque)
 459 {
 460     timer_init(ts, type, SCALE_NS, cb, opaque);
 461 }
 462
 463 /**
 464  * timer_init_us:
 465  * @ts: the timer to be initialised
 466  * @type: the clock to associate with the timer
 467  * @cb: the callback to call when the timer expires
 468  * @opaque: the opaque pointer to pass to the callback
 469  *
 470  * Initialize a timer with microsecond scale on the default timer list
 471  * associated with the clock.
 472  *
 473  * You need not call an explicit deinit call. Simply make
 474  * sure it is not on a list with timer_del.
 475  */
 476 static inline void timer_init_us(QEMUTimer *ts, QEMUClockType type,
 477                                  QEMUTimerCB *cb, void *opaque)
 478 {
 479     timer_init(ts, type, SCALE_US, cb, opaque);
 480 }
 481
 482 /**
 483  * timer_init_ms:
 484  * @ts: the timer to be initialised
 485  * @type: the clock to associate with the timer
 486  * @cb: the callback to call when the timer expires
 487  * @opaque: the opaque pointer to pass to the callback
 488  *
 489  * Initialize a timer with millisecond scale on the default timer list
 490  * associated with the clock.
 491  *
 492  * You need not call an explicit deinit call. Simply make
 493  * sure it is not on a list with timer_del.
 494  */
 495 static inline void timer_init_ms(QEMUTimer *ts, QEMUClockType type,
 496                                  QEMUTimerCB *cb, void *opaque)
 497 {
 498     timer_init(ts, type, SCALE_MS, cb, opaque);
 499 }
 500
 501 /**
 502  * timer_new_tl:
 503  * @timer_list: the timer list to attach the timer to
 504  * @scale: the scale value for the timer
 505  * @cb: the callback to be called when the timer expires
 506  * @opaque: the opaque pointer to be passed to the callback
 507  *
 508  * Create a new timer and associate it with @timer_list.
 509  * The memory is allocated by the function.
 510  *
 511  * This is not the preferred interface unless you know you
 512  * are going to call timer_free. Use timer_init instead.
 513  *
 514  * Returns: a pointer to the timer
 515  */
 516 static inline QEMUTimer *timer_new_tl(QEMUTimerList *timer_list,
 517                                       int scale,
 518                                       QEMUTimerCB *cb,
 519                                       void *opaque)
 520 {
 521     QEMUTimer *ts = g_malloc0(sizeof(QEMUTimer));
 522     timer_init_tl(ts, timer_list, scale, cb, opaque);
 523     return ts;
 524 }
 525
 526 /**
 527  * timer_new:
 528  * @type: the clock type to use
 529  * @scale: the scale value for the timer
 530  * @cb: the callback to be called when the timer expires
 531  * @opaque: the opaque pointer to be passed to the callback
 532  *
 533  * Create a new timer and associate it with the default
 534  * timer list for the clock type @type.
 535  *
 536  * The default timer list has one special feature: in icount mode,
 537  * %QEMU_CLOCK_VIRTUAL timers are run in the vCPU thread.  This is
 538  * not true of other timer lists, which are typically associated
 539  * with an AioContext---each of them runs its timer callbacks in its own
 540  * AioContext thread.
 541  *
 542  * Returns: a pointer to the timer
 543  */
 544 static inline QEMUTimer *timer_new(QEMUClockType type, int scale,
 545                                    QEMUTimerCB *cb, void *opaque)
 546 {
 547     return timer_new_tl(main_loop_tlg.tl[type], scale, cb, opaque);
 548 }
 549
 550 /**
 551  * timer_new_ns:
 552  * @type: the clock type to associate with the timer
 553  * @cb: the callback to call when the timer expires
 554  * @opaque: the opaque pointer to pass to the callback
 555  *
 556  * Create a new timer with nanosecond scale on the default timer list
 557  * associated with the clock.
 558  *
 559  * The default timer list has one special feature: in icount mode,
 560  * %QEMU_CLOCK_VIRTUAL timers are run in the vCPU thread.  This is
 561  * not true of other timer lists, which are typically associated
 562  * with an AioContext---each of them runs its timer callbacks in its own
 563  * AioContext thread.
 564  *
 565  * Returns: a pointer to the newly created timer
 566  */
 567 static inline QEMUTimer *timer_new_ns(QEMUClockType type, QEMUTimerCB *cb,
 568                                       void *opaque)
 569 {
 570     return timer_new(type, SCALE_NS, cb, opaque);
 571 }
 572
 573 /**
 574  * timer_new_us:
 575  * @type: the clock type to associate with the timer
 576  * @cb: the callback to call when the timer expires
 577  * @opaque: the opaque pointer to pass to the callback
 578  *
 579  * The default timer list has one special feature: in icount mode,
 580  * %QEMU_CLOCK_VIRTUAL timers are run in the vCPU thread.  This is
 581  * not true of other timer lists, which are typically associated
 582  * with an AioContext---each of them runs its timer callbacks in its own
 583  * AioContext thread.
 584  *
 585  * Create a new timer with microsecond scale on the default timer list
 586  * associated with the clock.
 587  *
 588  * Returns: a pointer to the newly created timer
 589  */
 590 static inline QEMUTimer *timer_new_us(QEMUClockType type, QEMUTimerCB *cb,
 591                                       void *opaque)
 592 {
 593     return timer_new(type, SCALE_US, cb, opaque);
 594 }
 595
 596 /**
 597  * timer_new_ms:
 598  * @type: the clock type to associate with the timer
 599  * @cb: the callback to call when the timer expires
 600  * @opaque: the opaque pointer to pass to the callback
 601  *
 602  * The default timer list has one special feature: in icount mode,
 603  * %QEMU_CLOCK_VIRTUAL timers are run in the vCPU thread.  This is
 604  * not true of other timer lists, which are typically associated
 605  * with an AioContext---each of them runs its timer callbacks in its own
 606  * AioContext thread.
 607  *
 608  * Create a new timer with millisecond scale on the default timer list
 609  * associated with the clock.
 610  *
 611  * Returns: a pointer to the newly created timer
 612  */
 613 static inline QEMUTimer *timer_new_ms(QEMUClockType type, QEMUTimerCB *cb,
 614                                       void *opaque)
 615 {
 616     return timer_new(type, SCALE_MS, cb, opaque);
 617 }
 618
 619 /**
 620  * timer_deinit:
 621  * @ts: the timer to be de-initialised
 622  *
 623  * Deassociate the timer from any timerlist.  You should
 624  * call timer_del before.  After this call, any further
 625  * timer_del call cannot cause dangling pointer accesses
 626  * even if the previously used timerlist is freed.
 627  */
 628 void timer_deinit(QEMUTimer *ts);
 629
 630 /**
 631  * timer_free:
 632  * @ts: the timer
 633  *
 634  * Free a timer (it must not be on the active list)
 635  */
 636 static inline void timer_free(QEMUTimer *ts)
 637 {
 638     g_free(ts);
 639 }
 640
 641 /**
 642  * timer_del:
 643  * @ts: the timer
 644  *
 645  * Delete a timer from the active list.
 646  *
 647  * This function is thread-safe but the timer and its timer list must not be
 648  * freed while this function is running.
 649  */
 650 void timer_del(QEMUTimer *ts);
 651
 652 /**
 653  * timer_mod_ns:
 654  * @ts: the timer
 655  * @expire_time: the expiry time in nanoseconds
 656  *
 657  * Modify a timer to expire at @expire_time
 658  *
 659  * This function is thread-safe but the timer and its timer list must not be
 660  * freed while this function is running.
 661  */
 662 void timer_mod_ns(QEMUTimer *ts, int64_t expire_time);
 663
 664 /**
 665  * timer_mod_anticipate_ns:
 666  * @ts: the timer
 667  * @expire_time: the expiry time in nanoseconds
 668  *
 669  * Modify a timer to expire at @expire_time or the current time,
 670  * whichever comes earlier.
 671  *
 672  * This function is thread-safe but the timer and its timer list must not be
 673  * freed while this function is running.
 674  */
 675 void timer_mod_anticipate_ns(QEMUTimer *ts, int64_t expire_time);
 676
 677 /**
 678  * timer_mod:
 679  * @ts: the timer
 680  * @expire_time: the expire time in the units associated with the timer
 681  *
 682  * Modify a timer to expiry at @expire_time, taking into
 683  * account the scale associated with the timer.
 684  *
 685  * This function is thread-safe but the timer and its timer list must not be
 686  * freed while this function is running.
 687  */
 688 void timer_mod(QEMUTimer *ts, int64_t expire_timer);
 689
 690 /**
 691  * timer_mod_anticipate:
 692  * @ts: the timer
 693  * @expire_time: the expiry time in nanoseconds
 694  *
 695  * Modify a timer to expire at @expire_time or the current time, whichever
 696  * comes earlier, taking into account the scale associated with the timer.
 697  *
 698  * This function is thread-safe but the timer and its timer list must not be
 699  * freed while this function is running.
 700  */
 701 void timer_mod_anticipate(QEMUTimer *ts, int64_t expire_time);
 702
 703 /**
 704  * timer_pending:
 705  * @ts: the timer
 706  *
 707  * Determines whether a timer is pending (i.e. is on the
 708  * active list of timers, whether or not it has not yet expired).
 709  *
 710  * Returns: true if the timer is pending
 711  */
 712 bool timer_pending(QEMUTimer *ts);
 713
 714 /**
 715  * timer_expired:
 716  * @ts: the timer
 717  * @current_time: the current time
 718  *
 719  * Determines whether a timer has expired.
 720  *
 721  * Returns: true if the timer has expired
 722  */
 723 bool timer_expired(QEMUTimer *timer_head, int64_t current_time);
 724
 725 /**
 726  * timer_expire_time_ns:
 727  * @ts: the timer
 728  *
 729  * Determine the expiry time of a timer
 730  *
 731  * Returns: the expiry time in nanoseconds
 732  */
 733 uint64_t timer_expire_time_ns(QEMUTimer *ts);
 734
 735 /**
 736  * timer_get:
 737  * @f: the file
 738  * @ts: the timer
 739  *
 740  * Read a timer @ts from a file @f
 741  */
 742 void timer_get(QEMUFile *f, QEMUTimer *ts);
 743
 744 /**
 745  * timer_put:
 746  * @f: the file
 747  * @ts: the timer
 748  */
 749 void timer_put(QEMUFile *f, QEMUTimer *ts);
 750
 751 /*
 752  * General utility functions
 753  */
 754
 755 /**
 756  * qemu_timeout_ns_to_ms:
 757  * @ns: nanosecond timeout value
 758  *
 759  * Convert a nanosecond timeout value (or -1) to
 760  * a millisecond value (or -1), always rounding up.
 761  *
 762  * Returns: millisecond timeout value
 763  */
 764 int qemu_timeout_ns_to_ms(int64_t ns);
 765
 766 /**
 767  * qemu_poll_ns:
 768  * @fds: Array of file descriptors
 769  * @nfds: number of file descriptors
 770  * @timeout: timeout in nanoseconds
 771  *
 772  * Perform a poll like g_poll but with a timeout in nanoseconds.
 773  * See g_poll documentation for further details.
 774  *
 775  * Returns: number of fds ready
 776  */
 777 int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout);
 778
 779 /**
 780  * qemu_soonest_timeout:
 781  * @timeout1: first timeout in nanoseconds (or -1 for infinite)
 782  * @timeout2: second timeout in nanoseconds (or -1 for infinite)
 783  *
 784  * Calculates the soonest of two timeout values. -1 means infinite, which
 785  * is later than any other value.
 786  *
 787  * Returns: soonest timeout value in nanoseconds (or -1 for infinite)
 788  */
 789 static inline int64_t qemu_soonest_timeout(int64_t timeout1, int64_t timeout2)
 790 {
 791     /* we can abuse the fact that -1 (which means infinite) is a maximal
 792      * value when cast to unsigned. As this is disgusting, it's kept in
 793      * one inline function.
 794      */
 795     return ((uint64_t) timeout1 < (uint64_t) timeout2) ? timeout1 : timeout2;
 796 }
 797
 798 /**
 799  * initclocks:
 800  *
 801  * Initialise the clock & timer infrastructure
 802  */
 803 void init_clocks(QEMUTimerListNotifyCB *notify_cb);
 804
 805 int64_t cpu_get_ticks(void);
 806 /* Caller must hold BQL */
 807 void cpu_enable_ticks(void);
 808 /* Caller must hold BQL */
 809 void cpu_disable_ticks(void);
 810
 811 static inline int64_t get_max_clock_jump(void)
 812 {
 813     /* This should be small enough to prevent excessive interrupts from being
 814      * generated by the RTC on clock jumps, but large enough to avoid frequent
 815      * unnecessary resets in idle VMs.
 816      */
 817     return 60 * NANOSECONDS_PER_SECOND;
 818 }
 819
 820 /*
 821  * Low level clock functions
 822  */
 823
 824 /* get host real time in nanosecond */
 825 static inline int64_t get_clock_realtime(void)
 826 {
 827     struct timeval tv;
 828
 829     gettimeofday(&tv, NULL);
 830     return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
 831 }
 832
 833 /* Warning: don't insert tracepoints into these functions, they are
 834    also used by simpletrace backend and tracepoints would cause
 835    an infinite recursion! */
 836 #ifdef _WIN32
 837 extern int64_t clock_freq;
 838
 839 static inline int64_t get_clock(void)
 840 {
 841     LARGE_INTEGER ti;
 842     QueryPerformanceCounter(&ti);
 843     return muldiv64(ti.QuadPart, NANOSECONDS_PER_SECOND, clock_freq);
 844 }
 845
 846 #else
 847
 848 extern int use_rt_clock;
 849
 850 static inline int64_t get_clock(void)
 851 {
 852 #ifdef CLOCK_MONOTONIC
 853     if (use_rt_clock) {
 854         struct timespec ts;
 855         clock_gettime(CLOCK_MONOTONIC, &ts);
 856         return ts.tv_sec * 1000000000LL + ts.tv_nsec;
 857     } else
 858 #endif
 859     {
 860         /* XXX: using gettimeofday leads to problems if the date
 861            changes, so it should be avoided. */
 862         return get_clock_realtime();
 863     }
 864 }
 865 #endif
 866
 867 /* icount */
 868 int64_t cpu_get_icount_raw(void);
 869 int64_t cpu_get_icount(void);
 870 int64_t cpu_get_clock(void);
 871 int64_t cpu_icount_to_ns(int64_t icount);
 872 void    cpu_update_icount(CPUState *cpu);
 873
 874 /*******************************************/
 875 /* host CPU ticks (if available) */
 876
 877 #if defined(_ARCH_PPC)
 878
 879 static inline int64_t cpu_get_host_ticks(void)
 880 {
 881     int64_t retval;
 882 #ifdef _ARCH_PPC64
 883     /* This reads timebase in one 64bit go and includes Cell workaround from:
 884        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
 885     */
 886     __asm__ __volatile__ ("mftb    %0\n\t"
 887                           "cmpwi   %0,0\n\t"
 888                           "beq-    $-8"
 889                           : "=r" (retval));
 890 #else
 891     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
 892     unsigned long junk;
 893     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
 894                           "mfspr   %L0,268\n\t" /* mftb */
 895                           "mfspr   %0,269\n\t"  /* mftbu */
 896                           "cmpw    %0,%1\n\t"
 897                           "bne     $-16"
 898                           : "=r" (retval), "=r" (junk));
 899 #endif
 900     return retval;
 901 }
 902
 903 #elif defined(__i386__)
 904
 905 static inline int64_t cpu_get_host_ticks(void)
 906 {
 907     int64_t val;
 908     asm volatile ("rdtsc" : "=A" (val));
 909     return val;
 910 }
 911
 912 #elif defined(__x86_64__)
 913
 914 static inline int64_t cpu_get_host_ticks(void)
 915 {
 916     uint32_t low,high;
 917     int64_t val;
 918     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 919     val = high;
 920     val <<= 32;
 921     val |= low;
 922     return val;
 923 }
 924
 925 #elif defined(__hppa__)
 926
 927 static inline int64_t cpu_get_host_ticks(void)
 928 {
 929     int val;
 930     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
 931     return val;
 932 }
 933
 934 #elif defined(__ia64)
 935
 936 static inline int64_t cpu_get_host_ticks(void)
 937 {
 938     int64_t val;
 939     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 940     return val;
 941 }
 942
 943 #elif defined(__s390__)
 944
 945 static inline int64_t cpu_get_host_ticks(void)
 946 {
 947     int64_t val;
 948     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 949     return val;
 950 }
 951
 952 #elif defined(__sparc__)
 953
 954 static inline int64_t cpu_get_host_ticks (void)
 955 {
 956 #if defined(_LP64)
 957     uint64_t        rval;
 958     asm volatile("rd %%tick,%0" : "=r"(rval));
 959     return rval;
 960 #else
 961     /* We need an %o or %g register for this.  For recent enough gcc
 962        there is an "h" constraint for that.  Don't bother with that.  */
 963     union {
 964         uint64_t i64;
 965         struct {
 966             uint32_t high;
 967             uint32_t low;
 968         }       i32;
 969     } rval;
 970     asm volatile("rd %%tick,%%g1; srlx %%g1,32,%0; mov %%g1,%1"
 971                  : "=r"(rval.i32.high), "=r"(rval.i32.low) : : "g1");
 972     return rval.i64;
 973 #endif
 974 }
 975
 976 #elif defined(__mips__) && \
 977     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
 978 /*
 979  * binutils wants to use rdhwr only on mips32r2
 980  * but as linux kernel emulate it, it's fine
 981  * to use it.
 982  *
 983  */
 984 #define MIPS_RDHWR(rd, value) {                         \
 985         __asm__ __volatile__ (".set   push\n\t"         \
 986                               ".set mips32r2\n\t"       \
 987                               "rdhwr  %0, "rd"\n\t"     \
 988                               ".set   pop"              \
 989                               : "=r" (value));          \
 990     }
 991
 992 static inline int64_t cpu_get_host_ticks(void)
 993 {
 994     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
 995     uint32_t count;
 996     static uint32_t cyc_per_count = 0;
 997
 998     if (!cyc_per_count) {
 999         MIPS_RDHWR("$3", cyc_per_count);
1000     }
1001
1002     MIPS_RDHWR("$2", count);
1003     return (int64_t)(count * cyc_per_count);
1004 }
1005
1006 #elif defined(__alpha__)
1007
1008 static inline int64_t cpu_get_host_ticks(void)
1009 {
1010     uint64_t cc;
1011     uint32_t cur, ofs;
1012
1013     asm volatile("rpcc %0" : "=r"(cc));
1014     cur = cc;
1015     ofs = cc >> 32;
1016     return cur - ofs;
1017 }
1018
1019 #else
1020 /* The host CPU doesn't have an easily accessible cycle counter.
1021    Just return a monotonically increasing value.  This will be
1022    totally wrong, but hopefully better than nothing.  */
1023 static inline int64_t cpu_get_host_ticks(void)
1024 {
1025     return get_clock();
1026 }
1027 #endif
1028
1029 #ifdef CONFIG_PROFILER
1030 static inline int64_t profile_getclock(void)
1031 {
1032     return get_clock();
1033 }
1034
1035 extern int64_t tcg_time;
1036 extern int64_t dev_time;
1037 #endif
1038
1039 #endif