1 /* 2 * Copyright (C) 2000 - 2007 Jeff Dike (jdike{addtoit,linux.intel}.com) 3 * Licensed under the GPL 4 */ 5 6 #include <stddef.h> 7 #include <errno.h> 8 #include <signal.h> 9 #include <time.h> 10 #include <sys/time.h> 11 #include "kern_constants.h" 12 #include "kern_util.h" 13 #include "os.h" 14 #include "process.h" 15 #include "user.h" 16 17 int set_interval(void) 18 { 19 int usec = UM_USEC_PER_SEC / UM_HZ; 20 struct itimerval interval = ((struct itimerval) { { 0, usec }, 21 { 0, usec } }); 22 23 if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) 24 return -errno; 25 26 return 0; 27 } 28 29 int timer_one_shot(int ticks) 30 { 31 unsigned long usec = ticks * UM_USEC_PER_SEC / UM_HZ; 32 unsigned long sec = usec / UM_USEC_PER_SEC; 33 struct itimerval interval; 34 35 usec %= UM_USEC_PER_SEC; 36 interval = ((struct itimerval) { { 0, 0 }, { sec, usec } }); 37 38 if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) 39 return -errno; 40 41 return 0; 42 } 43 44 /** 45 * timeval_to_ns - Convert timeval to nanoseconds 46 * @ts: pointer to the timeval variable to be converted 47 * 48 * Returns the scalar nanosecond representation of the timeval 49 * parameter. 50 * 51 * Ripped from linux/time.h because it's a kernel header, and thus 52 * unusable from here. 53 */ 54 static inline long long timeval_to_ns(const struct timeval *tv) 55 { 56 return ((long long) tv->tv_sec * UM_NSEC_PER_SEC) + 57 tv->tv_usec * UM_NSEC_PER_USEC; 58 } 59 60 long long disable_timer(void) 61 { 62 struct itimerval time = ((struct itimerval) { { 0, 0 }, { 0, 0 } }); 63 int remain, max = UM_NSEC_PER_SEC / UM_HZ; 64 65 if (setitimer(ITIMER_VIRTUAL, &time, &time) < 0) 66 printk(UM_KERN_ERR "disable_timer - setitimer failed, " 67 "errno = %d\n", errno); 68 69 remain = timeval_to_ns(&time.it_value); 70 if (remain > max) 71 remain = max; 72 73 return remain; 74 } 75 76 long long os_nsecs(void) 77 { 78 struct timeval tv; 79 80 gettimeofday(&tv, NULL); 81 return timeval_to_ns(&tv); 82 } 83 84 #ifdef UML_CONFIG_NO_HZ 85 static int after_sleep_interval(struct timespec *ts) 86 { 87 return 0; 88 } 89 90 static void deliver_alarm(void) 91 { 92 alarm_handler(SIGVTALRM, NULL); 93 } 94 95 static unsigned long long sleep_time(unsigned long long nsecs) 96 { 97 return nsecs; 98 } 99 100 #else 101 unsigned long long last_tick; 102 unsigned long long skew; 103 104 static void deliver_alarm(void) 105 { 106 unsigned long long this_tick = os_nsecs(); 107 int one_tick = UM_NSEC_PER_SEC / UM_HZ; 108 109 if (last_tick == 0) 110 last_tick = this_tick - one_tick; 111 112 skew += this_tick - last_tick; 113 114 while (skew >= one_tick) { 115 alarm_handler(SIGVTALRM, NULL); 116 skew -= one_tick; 117 } 118 119 last_tick = this_tick; 120 } 121 122 static unsigned long long sleep_time(unsigned long long nsecs) 123 { 124 return nsecs > skew ? nsecs - skew : 0; 125 } 126 127 static inline long long timespec_to_us(const struct timespec *ts) 128 { 129 return ((long long) ts->tv_sec * UM_USEC_PER_SEC) + 130 ts->tv_nsec / UM_NSEC_PER_USEC; 131 } 132 133 static int after_sleep_interval(struct timespec *ts) 134 { 135 int usec = UM_USEC_PER_SEC / UM_HZ; 136 long long start_usecs = timespec_to_us(ts); 137 struct timeval tv; 138 struct itimerval interval; 139 140 /* 141 * It seems that rounding can increase the value returned from 142 * setitimer to larger than the one passed in. Over time, 143 * this will cause the remaining time to be greater than the 144 * tick interval. If this happens, then just reduce the first 145 * tick to the interval value. 146 */ 147 if (start_usecs > usec) 148 start_usecs = usec; 149 150 start_usecs -= skew / UM_NSEC_PER_USEC; 151 tv = ((struct timeval) { .tv_sec = start_usecs / UM_USEC_PER_SEC, 152 .tv_usec = start_usecs % UM_USEC_PER_SEC }); 153 interval = ((struct itimerval) { { 0, usec }, tv }); 154 155 if (setitimer(ITIMER_VIRTUAL, &interval, NULL) == -1) 156 return -errno; 157 158 return 0; 159 } 160 #endif 161 162 void idle_sleep(unsigned long long nsecs) 163 { 164 struct timespec ts; 165 166 /* 167 * nsecs can come in as zero, in which case, this starts a 168 * busy loop. To prevent this, reset nsecs to the tick 169 * interval if it is zero. 170 */ 171 if (nsecs == 0) 172 nsecs = UM_NSEC_PER_SEC / UM_HZ; 173 174 nsecs = sleep_time(nsecs); 175 ts = ((struct timespec) { .tv_sec = nsecs / UM_NSEC_PER_SEC, 176 .tv_nsec = nsecs % UM_NSEC_PER_SEC }); 177 178 if (nanosleep(&ts, &ts) == 0) 179 deliver_alarm(); 180 after_sleep_interval(&ts); 181 } 182