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