File:  [Qemu by Fabrice Bellard] / qemu / qemu-timer.h
Revision 1.1.1.5 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:56:50 2018 UTC (3 years, 1 month ago) by root
Branches: qemu, MAIN
CVS tags: qemu1000, qemu0151, HEAD
qemu 0.15.1

    1: #ifndef QEMU_TIMER_H
    2: #define QEMU_TIMER_H
    3: 
    4: #include "qemu-common.h"
    5: #include "notify.h"
    6: #include <time.h>
    7: #include <sys/time.h>
    8: 
    9: #ifdef _WIN32
   10: #include <windows.h>
   11: #endif
   12: 
   13: /* timers */
   14: 
   15: #define SCALE_MS 1000000
   16: #define SCALE_US 1000
   17: #define SCALE_NS 1
   18: 
   19: typedef struct QEMUClock QEMUClock;
   20: typedef void QEMUTimerCB(void *opaque);
   21: 
   22: /* The real time clock should be used only for stuff which does not
   23:    change the virtual machine state, as it is run even if the virtual
   24:    machine is stopped. The real time clock has a frequency of 1000
   25:    Hz. */
   26: extern QEMUClock *rt_clock;
   27: 
   28: /* The virtual clock is only run during the emulation. It is stopped
   29:    when the virtual machine is stopped. Virtual timers use a high
   30:    precision clock, usually cpu cycles (use ticks_per_sec). */
   31: extern QEMUClock *vm_clock;
   32: 
   33: /* The host clock should be use for device models that emulate accurate
   34:    real time sources. It will continue to run when the virtual machine
   35:    is suspended, and it will reflect system time changes the host may
   36:    undergo (e.g. due to NTP). The host clock has the same precision as
   37:    the virtual clock. */
   38: extern QEMUClock *host_clock;
   39: 
   40: int64_t qemu_get_clock_ns(QEMUClock *clock);
   41: void qemu_clock_enable(QEMUClock *clock, int enabled);
   42: void qemu_clock_warp(QEMUClock *clock);
   43: 
   44: void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier);
   45: void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
   46:                                           Notifier *notifier);
   47: 
   48: QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
   49:                           QEMUTimerCB *cb, void *opaque);
   50: void qemu_free_timer(QEMUTimer *ts);
   51: void qemu_del_timer(QEMUTimer *ts);
   52: void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
   53: int qemu_timer_pending(QEMUTimer *ts);
   54: int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
   55: 
   56: void qemu_run_all_timers(void);
   57: int qemu_alarm_pending(void);
   58: int64_t qemu_next_icount_deadline(void);
   59: void configure_alarms(char const *opt);
   60: void configure_icount(const char *option);
   61: int qemu_calculate_timeout(void);
   62: void init_clocks(void);
   63: int init_timer_alarm(void);
   64: void quit_timers(void);
   65: 
   66: int64_t cpu_get_ticks(void);
   67: void cpu_enable_ticks(void);
   68: void cpu_disable_ticks(void);
   69: 
   70: static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
   71:                                            void *opaque)
   72: {
   73:     return qemu_new_timer(clock, SCALE_NS, cb, opaque);
   74: }
   75: 
   76: static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
   77:                                            void *opaque)
   78: {
   79:     return qemu_new_timer(clock, SCALE_MS, cb, opaque);
   80: }
   81: 
   82: static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
   83: {
   84:     return qemu_get_clock_ns(clock) / SCALE_MS;
   85: }
   86: 
   87: static inline int64_t get_ticks_per_sec(void)
   88: {
   89:     return 1000000000LL;
   90: }
   91: 
   92: /* real time host monotonic timer */
   93: static inline int64_t get_clock_realtime(void)
   94: {
   95:     struct timeval tv;
   96: 
   97:     gettimeofday(&tv, NULL);
   98:     return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
   99: }
  100: 
  101: /* Warning: don't insert tracepoints into these functions, they are
  102:    also used by simpletrace backend and tracepoints would cause
  103:    an infinite recursion! */
  104: #ifdef _WIN32
  105: extern int64_t clock_freq;
  106: 
  107: static inline int64_t get_clock(void)
  108: {
  109:     LARGE_INTEGER ti;
  110:     QueryPerformanceCounter(&ti);
  111:     return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
  112: }
  113: 
  114: #else
  115: 
  116: extern int use_rt_clock;
  117: 
  118: static inline int64_t get_clock(void)
  119: {
  120: #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
  121:     || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
  122:     if (use_rt_clock) {
  123:         struct timespec ts;
  124:         clock_gettime(CLOCK_MONOTONIC, &ts);
  125:         return ts.tv_sec * 1000000000LL + ts.tv_nsec;
  126:     } else
  127: #endif
  128:     {
  129:         /* XXX: using gettimeofday leads to problems if the date
  130:            changes, so it should be avoided. */
  131:         return get_clock_realtime();
  132:     }
  133: }
  134: #endif
  135: 
  136: void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
  137: void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
  138: 
  139: /* ptimer.c */
  140: typedef struct ptimer_state ptimer_state;
  141: typedef void (*ptimer_cb)(void *opaque);
  142: 
  143: ptimer_state *ptimer_init(QEMUBH *bh);
  144: void ptimer_set_period(ptimer_state *s, int64_t period);
  145: void ptimer_set_freq(ptimer_state *s, uint32_t freq);
  146: void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
  147: uint64_t ptimer_get_count(ptimer_state *s);
  148: void ptimer_set_count(ptimer_state *s, uint64_t count);
  149: void ptimer_run(ptimer_state *s, int oneshot);
  150: void ptimer_stop(ptimer_state *s);
  151: 
  152: /* icount */
  153: int64_t qemu_icount_round(int64_t count);
  154: extern int64_t qemu_icount;
  155: extern int use_icount;
  156: extern int icount_time_shift;
  157: extern int64_t qemu_icount_bias;
  158: int64_t cpu_get_icount(void);
  159: 
  160: /*******************************************/
  161: /* host CPU ticks (if available) */
  162: 
  163: #if defined(_ARCH_PPC)
  164: 
  165: static inline int64_t cpu_get_real_ticks(void)
  166: {
  167:     int64_t retval;
  168: #ifdef _ARCH_PPC64
  169:     /* This reads timebase in one 64bit go and includes Cell workaround from:
  170:        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
  171:     */
  172:     __asm__ __volatile__ ("mftb    %0\n\t"
  173:                           "cmpwi   %0,0\n\t"
  174:                           "beq-    $-8"
  175:                           : "=r" (retval));
  176: #else
  177:     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
  178:     unsigned long junk;
  179:     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
  180:                           "mfspr   %L0,268\n\t" /* mftb */
  181:                           "mfspr   %0,269\n\t"  /* mftbu */
  182:                           "cmpw    %0,%1\n\t"
  183:                           "bne     $-16"
  184:                           : "=r" (retval), "=r" (junk));
  185: #endif
  186:     return retval;
  187: }
  188: 
  189: #elif defined(__i386__)
  190: 
  191: static inline int64_t cpu_get_real_ticks(void)
  192: {
  193:     int64_t val;
  194:     asm volatile ("rdtsc" : "=A" (val));
  195:     return val;
  196: }
  197: 
  198: #elif defined(__x86_64__)
  199: 
  200: static inline int64_t cpu_get_real_ticks(void)
  201: {
  202:     uint32_t low,high;
  203:     int64_t val;
  204:     asm volatile("rdtsc" : "=a" (low), "=d" (high));
  205:     val = high;
  206:     val <<= 32;
  207:     val |= low;
  208:     return val;
  209: }
  210: 
  211: #elif defined(__hppa__)
  212: 
  213: static inline int64_t cpu_get_real_ticks(void)
  214: {
  215:     int val;
  216:     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
  217:     return val;
  218: }
  219: 
  220: #elif defined(__ia64)
  221: 
  222: static inline int64_t cpu_get_real_ticks(void)
  223: {
  224:     int64_t val;
  225:     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
  226:     return val;
  227: }
  228: 
  229: #elif defined(__s390__)
  230: 
  231: static inline int64_t cpu_get_real_ticks(void)
  232: {
  233:     int64_t val;
  234:     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
  235:     return val;
  236: }
  237: 
  238: #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
  239: 
  240: static inline int64_t cpu_get_real_ticks (void)
  241: {
  242: #if defined(_LP64)
  243:     uint64_t        rval;
  244:     asm volatile("rd %%tick,%0" : "=r"(rval));
  245:     return rval;
  246: #else
  247:     union {
  248:         uint64_t i64;
  249:         struct {
  250:             uint32_t high;
  251:             uint32_t low;
  252:         }       i32;
  253:     } rval;
  254:     asm volatile("rd %%tick,%1; srlx %1,32,%0"
  255:                  : "=r"(rval.i32.high), "=r"(rval.i32.low));
  256:     return rval.i64;
  257: #endif
  258: }
  259: 
  260: #elif defined(__mips__) && \
  261:     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
  262: /*
  263:  * binutils wants to use rdhwr only on mips32r2
  264:  * but as linux kernel emulate it, it's fine
  265:  * to use it.
  266:  *
  267:  */
  268: #define MIPS_RDHWR(rd, value) {                         \
  269:         __asm__ __volatile__ (".set   push\n\t"         \
  270:                               ".set mips32r2\n\t"       \
  271:                               "rdhwr  %0, "rd"\n\t"     \
  272:                               ".set   pop"              \
  273:                               : "=r" (value));          \
  274:     }
  275: 
  276: static inline int64_t cpu_get_real_ticks(void)
  277: {
  278:     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
  279:     uint32_t count;
  280:     static uint32_t cyc_per_count = 0;
  281: 
  282:     if (!cyc_per_count) {
  283:         MIPS_RDHWR("$3", cyc_per_count);
  284:     }
  285: 
  286:     MIPS_RDHWR("$2", count);
  287:     return (int64_t)(count * cyc_per_count);
  288: }
  289: 
  290: #elif defined(__alpha__)
  291: 
  292: static inline int64_t cpu_get_real_ticks(void)
  293: {
  294:     uint64_t cc;
  295:     uint32_t cur, ofs;
  296: 
  297:     asm volatile("rpcc %0" : "=r"(cc));
  298:     cur = cc;
  299:     ofs = cc >> 32;
  300:     return cur - ofs;
  301: }
  302: 
  303: #else
  304: /* The host CPU doesn't have an easily accessible cycle counter.
  305:    Just return a monotonically increasing value.  This will be
  306:    totally wrong, but hopefully better than nothing.  */
  307: static inline int64_t cpu_get_real_ticks (void)
  308: {
  309:     static int64_t ticks = 0;
  310:     return ticks++;
  311: }
  312: #endif
  313: 
  314: #ifdef NEED_CPU_H
  315: /* Deterministic execution requires that IO only be performed on the last
  316:    instruction of a TB so that interrupts take effect immediately.  */
  317: static inline int can_do_io(CPUState *env)
  318: {
  319:     if (!use_icount)
  320:         return 1;
  321: 
  322:     /* If not executing code then assume we are ok.  */
  323:     if (!env->current_tb)
  324:         return 1;
  325: 
  326:     return env->can_do_io != 0;
  327: }
  328: #endif
  329: 
  330: #ifdef CONFIG_PROFILER
  331: static inline int64_t profile_getclock(void)
  332: {
  333:     return cpu_get_real_ticks();
  334: }
  335: 
  336: extern int64_t qemu_time, qemu_time_start;
  337: extern int64_t tlb_flush_time;
  338: extern int64_t dev_time;
  339: #endif
  340: 
  341: #endif

unix.superglobalmegacorp.com