Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 1 | /* |
Jeff Dike | 4c9e138 | 2007-10-16 01:26:54 -0700 | [diff] [blame] | 2 | * Copyright (C) 2000 - 2007 Jeff Dike (jdike{addtoit,linux.intel}.com) |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 3 | * Licensed under the GPL |
| 4 | */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | |
Jeff Dike | 4c9e138 | 2007-10-16 01:26:54 -0700 | [diff] [blame] | 6 | #include <stddef.h> |
| 7 | #include <errno.h> |
| 8 | #include <signal.h> |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 9 | #include <time.h> |
| 10 | #include <sys/time.h> |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 11 | #include "kern_constants.h" |
| 12 | #include "os.h" |
Jeff Dike | 4c9e138 | 2007-10-16 01:26:54 -0700 | [diff] [blame] | 13 | #include "user.h" |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 14 | |
Jeff Dike | a2f018b | 2007-10-16 01:27:22 -0700 | [diff] [blame] | 15 | int set_interval(void) |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 16 | { |
Jeff Dike | 1a80521 | 2007-10-16 01:27:28 -0700 | [diff] [blame] | 17 | int usec = UM_USEC_PER_SEC / UM_HZ; |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 18 | struct itimerval interval = ((struct itimerval) { { 0, usec }, |
| 19 | { 0, usec } }); |
| 20 | |
Jeff Dike | a2f018b | 2007-10-16 01:27:22 -0700 | [diff] [blame] | 21 | if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) |
Jeff Dike | 537ae94 | 2006-09-25 23:33:05 -0700 | [diff] [blame] | 22 | return -errno; |
| 23 | |
| 24 | return 0; |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 25 | } |
| 26 | |
Jeff Dike | d2753a6 | 2007-10-16 01:27:25 -0700 | [diff] [blame] | 27 | int timer_one_shot(int ticks) |
| 28 | { |
Jeff Dike | 1a80521 | 2007-10-16 01:27:28 -0700 | [diff] [blame] | 29 | unsigned long usec = ticks * UM_USEC_PER_SEC / UM_HZ; |
| 30 | unsigned long sec = usec / UM_USEC_PER_SEC; |
Jeff Dike | d2753a6 | 2007-10-16 01:27:25 -0700 | [diff] [blame] | 31 | struct itimerval interval; |
| 32 | |
Jeff Dike | 1a80521 | 2007-10-16 01:27:28 -0700 | [diff] [blame] | 33 | usec %= UM_USEC_PER_SEC; |
Jeff Dike | d2753a6 | 2007-10-16 01:27:25 -0700 | [diff] [blame] | 34 | interval = ((struct itimerval) { { 0, 0 }, { sec, usec } }); |
| 35 | |
| 36 | if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) |
| 37 | return -errno; |
| 38 | |
| 39 | return 0; |
| 40 | } |
| 41 | |
Jeff Dike | 5f73461 | 2007-10-16 01:27:27 -0700 | [diff] [blame] | 42 | /** |
| 43 | * timeval_to_ns - Convert timeval to nanoseconds |
| 44 | * @ts: pointer to the timeval variable to be converted |
| 45 | * |
| 46 | * Returns the scalar nanosecond representation of the timeval |
| 47 | * parameter. |
| 48 | * |
| 49 | * Ripped from linux/time.h because it's a kernel header, and thus |
| 50 | * unusable from here. |
| 51 | */ |
| 52 | static inline long long timeval_to_ns(const struct timeval *tv) |
| 53 | { |
| 54 | return ((long long) tv->tv_sec * UM_NSEC_PER_SEC) + |
| 55 | tv->tv_usec * UM_NSEC_PER_USEC; |
| 56 | } |
| 57 | |
| 58 | long long disable_timer(void) |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 59 | { |
Jeff Dike | b160fb6 | 2007-10-16 01:27:26 -0700 | [diff] [blame] | 60 | struct itimerval time = ((struct itimerval) { { 0, 0 }, { 0, 0 } }); |
Jeff Dike | 4c9e138 | 2007-10-16 01:26:54 -0700 | [diff] [blame] | 61 | |
Jeff Dike | 364e3a3 | 2007-11-28 16:21:51 -0800 | [diff] [blame] | 62 | if (setitimer(ITIMER_VIRTUAL, &time, &time) < 0) |
Jeff Dike | 4c9e138 | 2007-10-16 01:26:54 -0700 | [diff] [blame] | 63 | printk(UM_KERN_ERR "disable_timer - setitimer failed, " |
| 64 | "errno = %d\n", errno); |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 65 | |
Jeff Dike | 5f73461 | 2007-10-16 01:27:27 -0700 | [diff] [blame] | 66 | return timeval_to_ns(&time.it_value); |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 67 | } |
| 68 | |
Jeff Dike | 5f73461 | 2007-10-16 01:27:27 -0700 | [diff] [blame] | 69 | long long os_nsecs(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | { |
| 71 | struct timeval tv; |
| 72 | |
| 73 | gettimeofday(&tv, NULL); |
Jeff Dike | d2753a6 | 2007-10-16 01:27:25 -0700 | [diff] [blame] | 74 | return timeval_to_ns(&tv); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 75 | } |
| 76 | |
Jeff Dike | 364e3a3 | 2007-11-28 16:21:51 -0800 | [diff] [blame] | 77 | #ifdef UML_CONFIG_NO_HZ |
| 78 | static int after_sleep_interval(struct timespec *ts) |
| 79 | { |
Jeff Dike | 0a76532 | 2007-12-01 12:16:29 -0800 | [diff] [blame^] | 80 | return 0; |
Jeff Dike | 364e3a3 | 2007-11-28 16:21:51 -0800 | [diff] [blame] | 81 | } |
| 82 | #else |
| 83 | static inline long long timespec_to_us(const struct timespec *ts) |
| 84 | { |
| 85 | return ((long long) ts->tv_sec * UM_USEC_PER_SEC) + |
| 86 | ts->tv_nsec / UM_NSEC_PER_USEC; |
| 87 | } |
| 88 | |
| 89 | static int after_sleep_interval(struct timespec *ts) |
| 90 | { |
| 91 | int usec = UM_USEC_PER_SEC / UM_HZ; |
| 92 | long long start_usecs = timespec_to_us(ts); |
| 93 | struct timeval tv; |
| 94 | struct itimerval interval; |
| 95 | |
| 96 | /* |
| 97 | * It seems that rounding can increase the value returned from |
| 98 | * setitimer to larger than the one passed in. Over time, |
| 99 | * this will cause the remaining time to be greater than the |
| 100 | * tick interval. If this happens, then just reduce the first |
| 101 | * tick to the interval value. |
| 102 | */ |
| 103 | if (start_usecs > usec) |
| 104 | start_usecs = usec; |
| 105 | tv = ((struct timeval) { .tv_sec = start_usecs / UM_USEC_PER_SEC, |
| 106 | .tv_usec = start_usecs % UM_USEC_PER_SEC }); |
| 107 | interval = ((struct itimerval) { { 0, usec }, tv }); |
| 108 | |
| 109 | if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) |
| 110 | return -errno; |
| 111 | |
| 112 | return 0; |
| 113 | } |
| 114 | #endif |
| 115 | |
Jeff Dike | b160fb6 | 2007-10-16 01:27:26 -0700 | [diff] [blame] | 116 | extern void alarm_handler(int sig, struct sigcontext *sc); |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 117 | |
Jeff Dike | b160fb6 | 2007-10-16 01:27:26 -0700 | [diff] [blame] | 118 | void idle_sleep(unsigned long long nsecs) |
| 119 | { |
Jeff Dike | 364e3a3 | 2007-11-28 16:21:51 -0800 | [diff] [blame] | 120 | struct timespec ts; |
| 121 | |
| 122 | /* |
| 123 | * nsecs can come in as zero, in which case, this starts a |
| 124 | * busy loop. To prevent this, reset nsecs to the tick |
| 125 | * interval if it is zero. |
| 126 | */ |
| 127 | if (nsecs == 0) |
| 128 | nsecs = UM_NSEC_PER_SEC / UM_HZ; |
| 129 | ts = ((struct timespec) { .tv_sec = nsecs / UM_NSEC_PER_SEC, |
| 130 | .tv_nsec = nsecs % UM_NSEC_PER_SEC }); |
Jeff Dike | b160fb6 | 2007-10-16 01:27:26 -0700 | [diff] [blame] | 131 | |
| 132 | if (nanosleep(&ts, &ts) == 0) |
| 133 | alarm_handler(SIGVTALRM, NULL); |
Jeff Dike | 364e3a3 | 2007-11-28 16:21:51 -0800 | [diff] [blame] | 134 | after_sleep_interval(&ts); |
Gennady Sharapov | cff65c4 | 2006-01-18 17:42:42 -0800 | [diff] [blame] | 135 | } |