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

1.1       root        1: #ifndef QEMU_TIMER_H
                      2: #define QEMU_TIMER_H
                      3: 
1.1.1.3 ! root        4: #include "qemu-common.h"
        !             5: 
1.1       root        6: /* timers */
                      7: 
                      8: typedef struct QEMUClock QEMUClock;
                      9: typedef void QEMUTimerCB(void *opaque);
                     10: 
                     11: /* The real time clock should be used only for stuff which does not
                     12:    change the virtual machine state, as it is run even if the virtual
                     13:    machine is stopped. The real time clock has a frequency of 1000
                     14:    Hz. */
                     15: extern QEMUClock *rt_clock;
                     16: 
                     17: /* The virtual clock is only run during the emulation. It is stopped
                     18:    when the virtual machine is stopped. Virtual timers use a high
                     19:    precision clock, usually cpu cycles (use ticks_per_sec). */
                     20: extern QEMUClock *vm_clock;
                     21: 
1.1.1.2   root       22: /* The host clock should be use for device models that emulate accurate
                     23:    real time sources. It will continue to run when the virtual machine
                     24:    is suspended, and it will reflect system time changes the host may
                     25:    undergo (e.g. due to NTP). The host clock has the same precision as
                     26:    the virtual clock. */
                     27: extern QEMUClock *host_clock;
                     28: 
1.1       root       29: int64_t qemu_get_clock(QEMUClock *clock);
1.1.1.3 ! root       30: int64_t qemu_get_clock_ns(QEMUClock *clock);
        !            31: void qemu_clock_enable(QEMUClock *clock, int enabled);
1.1       root       32: 
                     33: QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
                     34: void qemu_free_timer(QEMUTimer *ts);
                     35: void qemu_del_timer(QEMUTimer *ts);
                     36: void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
                     37: int qemu_timer_pending(QEMUTimer *ts);
1.1.1.2   root       38: int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
1.1       root       39: 
1.1.1.3 ! root       40: void qemu_run_all_timers(void);
        !            41: int qemu_alarm_pending(void);
        !            42: int64_t qemu_next_deadline(void);
        !            43: void configure_alarms(char const *opt);
        !            44: void configure_icount(const char *option);
        !            45: int qemu_calculate_timeout(void);
        !            46: void init_clocks(void);
        !            47: int init_timer_alarm(void);
        !            48: void quit_timers(void);
        !            49: 
1.1.1.2   root       50: static inline int64_t get_ticks_per_sec(void)
                     51: {
                     52:     return 1000000000LL;
                     53: }
1.1       root       54: 
1.1.1.3 ! root       55: 
1.1       root       56: void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
                     57: void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
                     58: 
                     59: /* ptimer.c */
                     60: typedef struct ptimer_state ptimer_state;
                     61: typedef void (*ptimer_cb)(void *opaque);
                     62: 
                     63: ptimer_state *ptimer_init(QEMUBH *bh);
                     64: void ptimer_set_period(ptimer_state *s, int64_t period);
                     65: void ptimer_set_freq(ptimer_state *s, uint32_t freq);
                     66: void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
                     67: uint64_t ptimer_get_count(ptimer_state *s);
                     68: void ptimer_set_count(ptimer_state *s, uint64_t count);
                     69: void ptimer_run(ptimer_state *s, int oneshot);
                     70: void ptimer_stop(ptimer_state *s);
                     71: void qemu_put_ptimer(QEMUFile *f, ptimer_state *s);
                     72: void qemu_get_ptimer(QEMUFile *f, ptimer_state *s);
                     73: 
1.1.1.3 ! root       74: /* icount */
        !            75: int64_t qemu_icount_round(int64_t count);
        !            76: extern int64_t qemu_icount;
        !            77: extern int use_icount;
        !            78: extern int icount_time_shift;
        !            79: extern int64_t qemu_icount_bias;
        !            80: int64_t cpu_get_icount(void);
        !            81: 
        !            82: /*******************************************/
        !            83: /* host CPU ticks (if available) */
        !            84: 
        !            85: #if defined(_ARCH_PPC)
        !            86: 
        !            87: static inline int64_t cpu_get_real_ticks(void)
        !            88: {
        !            89:     int64_t retval;
        !            90: #ifdef _ARCH_PPC64
        !            91:     /* This reads timebase in one 64bit go and includes Cell workaround from:
        !            92:        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
        !            93:     */
        !            94:     __asm__ __volatile__ ("mftb    %0\n\t"
        !            95:                           "cmpwi   %0,0\n\t"
        !            96:                           "beq-    $-8"
        !            97:                           : "=r" (retval));
        !            98: #else
        !            99:     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
        !           100:     unsigned long junk;
        !           101:     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
        !           102:                           "mfspr   %L0,268\n\t" /* mftb */
        !           103:                           "mfspr   %0,269\n\t"  /* mftbu */
        !           104:                           "cmpw    %0,%1\n\t"
        !           105:                           "bne     $-16"
        !           106:                           : "=r" (retval), "=r" (junk));
        !           107: #endif
        !           108:     return retval;
        !           109: }
        !           110: 
        !           111: #elif defined(__i386__)
        !           112: 
        !           113: static inline int64_t cpu_get_real_ticks(void)
        !           114: {
        !           115:     int64_t val;
        !           116:     asm volatile ("rdtsc" : "=A" (val));
        !           117:     return val;
        !           118: }
        !           119: 
        !           120: #elif defined(__x86_64__)
        !           121: 
        !           122: static inline int64_t cpu_get_real_ticks(void)
        !           123: {
        !           124:     uint32_t low,high;
        !           125:     int64_t val;
        !           126:     asm volatile("rdtsc" : "=a" (low), "=d" (high));
        !           127:     val = high;
        !           128:     val <<= 32;
        !           129:     val |= low;
        !           130:     return val;
        !           131: }
        !           132: 
        !           133: #elif defined(__hppa__)
        !           134: 
        !           135: static inline int64_t cpu_get_real_ticks(void)
        !           136: {
        !           137:     int val;
        !           138:     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
        !           139:     return val;
        !           140: }
        !           141: 
        !           142: #elif defined(__ia64)
        !           143: 
        !           144: static inline int64_t cpu_get_real_ticks(void)
        !           145: {
        !           146:     int64_t val;
        !           147:     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
        !           148:     return val;
        !           149: }
        !           150: 
        !           151: #elif defined(__s390__)
        !           152: 
        !           153: static inline int64_t cpu_get_real_ticks(void)
        !           154: {
        !           155:     int64_t val;
        !           156:     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
        !           157:     return val;
        !           158: }
        !           159: 
        !           160: #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
        !           161: 
        !           162: static inline int64_t cpu_get_real_ticks (void)
        !           163: {
        !           164: #if defined(_LP64)
        !           165:     uint64_t        rval;
        !           166:     asm volatile("rd %%tick,%0" : "=r"(rval));
        !           167:     return rval;
        !           168: #else
        !           169:     union {
        !           170:         uint64_t i64;
        !           171:         struct {
        !           172:             uint32_t high;
        !           173:             uint32_t low;
        !           174:         }       i32;
        !           175:     } rval;
        !           176:     asm volatile("rd %%tick,%1; srlx %1,32,%0"
        !           177:                  : "=r"(rval.i32.high), "=r"(rval.i32.low));
        !           178:     return rval.i64;
        !           179: #endif
        !           180: }
        !           181: 
        !           182: #elif defined(__mips__) && \
        !           183:     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
        !           184: /*
        !           185:  * binutils wants to use rdhwr only on mips32r2
        !           186:  * but as linux kernel emulate it, it's fine
        !           187:  * to use it.
        !           188:  *
        !           189:  */
        !           190: #define MIPS_RDHWR(rd, value) {                         \
        !           191:         __asm__ __volatile__ (".set   push\n\t"         \
        !           192:                               ".set mips32r2\n\t"       \
        !           193:                               "rdhwr  %0, "rd"\n\t"     \
        !           194:                               ".set   pop"              \
        !           195:                               : "=r" (value));          \
        !           196:     }
        !           197: 
        !           198: static inline int64_t cpu_get_real_ticks(void)
        !           199: {
        !           200:     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
        !           201:     uint32_t count;
        !           202:     static uint32_t cyc_per_count = 0;
        !           203: 
        !           204:     if (!cyc_per_count) {
        !           205:         MIPS_RDHWR("$3", cyc_per_count);
        !           206:     }
        !           207: 
        !           208:     MIPS_RDHWR("$2", count);
        !           209:     return (int64_t)(count * cyc_per_count);
        !           210: }
        !           211: 
        !           212: #elif defined(__alpha__)
        !           213: 
        !           214: static inline int64_t cpu_get_real_ticks(void)
        !           215: {
        !           216:     uint64_t cc;
        !           217:     uint32_t cur, ofs;
        !           218: 
        !           219:     asm volatile("rpcc %0" : "=r"(cc));
        !           220:     cur = cc;
        !           221:     ofs = cc >> 32;
        !           222:     return cur - ofs;
        !           223: }
        !           224: 
        !           225: #else
        !           226: /* The host CPU doesn't have an easily accessible cycle counter.
        !           227:    Just return a monotonically increasing value.  This will be
        !           228:    totally wrong, but hopefully better than nothing.  */
        !           229: static inline int64_t cpu_get_real_ticks (void)
        !           230: {
        !           231:     static int64_t ticks = 0;
        !           232:     return ticks++;
        !           233: }
        !           234: #endif
        !           235: 
        !           236: #ifdef NEED_CPU_H
        !           237: /* Deterministic execution requires that IO only be performed on the last
        !           238:    instruction of a TB so that interrupts take effect immediately.  */
        !           239: static inline int can_do_io(CPUState *env)
        !           240: {
        !           241:     if (!use_icount)
        !           242:         return 1;
        !           243: 
        !           244:     /* If not executing code then assume we are ok.  */
        !           245:     if (!env->current_tb)
        !           246:         return 1;
        !           247: 
        !           248:     return env->can_do_io != 0;
        !           249: }
        !           250: #endif
        !           251: 
        !           252: #ifdef CONFIG_PROFILER
        !           253: static inline int64_t profile_getclock(void)
        !           254: {
        !           255:     return cpu_get_real_ticks();
        !           256: }
        !           257: 
        !           258: extern int64_t qemu_time, qemu_time_start;
        !           259: extern int64_t tlb_flush_time;
        !           260: extern int64_t dev_time;
        !           261: #endif
        !           262: 
1.1       root      263: #endif

unix.superglobalmegacorp.com