Annotation of qemu/qemu-timer.h, revision 1.1.1.2

1.1       root        1: #ifndef QEMU_TIMER_H
                      2: #define QEMU_TIMER_H
                      3: 
                      4: /* timers */
                      5: 
                      6: typedef struct QEMUClock QEMUClock;
                      7: typedef void QEMUTimerCB(void *opaque);
                      8: 
                      9: /* The real time clock should be used only for stuff which does not
                     10:    change the virtual machine state, as it is run even if the virtual
                     11:    machine is stopped. The real time clock has a frequency of 1000
                     12:    Hz. */
                     13: extern QEMUClock *rt_clock;
                     14: 
                     15: /* The virtual clock is only run during the emulation. It is stopped
                     16:    when the virtual machine is stopped. Virtual timers use a high
                     17:    precision clock, usually cpu cycles (use ticks_per_sec). */
                     18: extern QEMUClock *vm_clock;
                     19: 
1.1.1.2 ! root       20: /* The host clock should be use for device models that emulate accurate
        !            21:    real time sources. It will continue to run when the virtual machine
        !            22:    is suspended, and it will reflect system time changes the host may
        !            23:    undergo (e.g. due to NTP). The host clock has the same precision as
        !            24:    the virtual clock. */
        !            25: extern QEMUClock *host_clock;
        !            26: 
1.1       root       27: int64_t qemu_get_clock(QEMUClock *clock);
                     28: 
                     29: QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
                     30: void qemu_free_timer(QEMUTimer *ts);
                     31: void qemu_del_timer(QEMUTimer *ts);
                     32: void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
                     33: int qemu_timer_pending(QEMUTimer *ts);
1.1.1.2 ! root       34: int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
1.1       root       35: 
1.1.1.2 ! root       36: static inline int64_t get_ticks_per_sec(void)
        !            37: {
        !            38:     return 1000000000LL;
        !            39: }
1.1       root       40: 
                     41: void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
                     42: void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
                     43: 
                     44: /* ptimer.c */
                     45: typedef struct ptimer_state ptimer_state;
                     46: typedef void (*ptimer_cb)(void *opaque);
                     47: 
                     48: ptimer_state *ptimer_init(QEMUBH *bh);
                     49: void ptimer_set_period(ptimer_state *s, int64_t period);
                     50: void ptimer_set_freq(ptimer_state *s, uint32_t freq);
                     51: void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
                     52: uint64_t ptimer_get_count(ptimer_state *s);
                     53: void ptimer_set_count(ptimer_state *s, uint64_t count);
                     54: void ptimer_run(ptimer_state *s, int oneshot);
                     55: void ptimer_stop(ptimer_state *s);
                     56: void qemu_put_ptimer(QEMUFile *f, ptimer_state *s);
                     57: void qemu_get_ptimer(QEMUFile *f, ptimer_state *s);
                     58: 
                     59: #endif

unix.superglobalmegacorp.com