1 /* $NetBSD: subr_time.c,v 1.19 2017/01/05 23:29:14 pgoyette Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)kern_clock.c 8.5 (Berkeley) 1/21/94 32 * @(#)kern_time.c 8.4 (Berkeley) 5/26/95 33 */ 34 35 #include <sys/cdefs.h> 36 __KERNEL_RCSID(0, "$NetBSD: subr_time.c,v 1.19 2017/01/05 23:29:14 pgoyette Exp $"); 37 38 #include <sys/param.h> 39 #include <sys/kernel.h> 40 #include <sys/proc.h> 41 #include <sys/kauth.h> 42 #include <sys/lwp.h> 43 #include <sys/timex.h> 44 #include <sys/time.h> 45 #include <sys/timetc.h> 46 #include <sys/intr.h> 47 48 #ifdef DEBUG_STICKS 49 #define DPRINTF(a) uprintf a 50 #else 51 #define DPRINTF(a) 52 #endif 53 54 /* 55 * Compute number of hz until specified time. Used to compute second 56 * argument to callout_reset() from an absolute time. 57 */ 58 int 59 tvhzto(const struct timeval *tvp) 60 { 61 struct timeval now, tv; 62 63 tv = *tvp; /* Don't modify original tvp. */ 64 getmicrotime(&now); 65 timersub(&tv, &now, &tv); 66 return tvtohz(&tv); 67 } 68 69 /* 70 * Compute number of ticks in the specified amount of time. 71 */ 72 int 73 tvtohz(const struct timeval *tv) 74 { 75 unsigned long ticks; 76 long sec, usec; 77 78 /* 79 * If the number of usecs in the whole seconds part of the time 80 * difference fits in a long, then the total number of usecs will 81 * fit in an unsigned long. Compute the total and convert it to 82 * ticks, rounding up and adding 1 to allow for the current tick 83 * to expire. Rounding also depends on unsigned long arithmetic 84 * to avoid overflow. 85 * 86 * Otherwise, if the number of ticks in the whole seconds part of 87 * the time difference fits in a long, then convert the parts to 88 * ticks separately and add, using similar rounding methods and 89 * overflow avoidance. This method would work in the previous 90 * case, but it is slightly slower and assumes that hz is integral. 91 * 92 * Otherwise, round the time difference down to the maximum 93 * representable value. 94 * 95 * If ints are 32-bit, then the maximum value for any timeout in 96 * 10ms ticks is 248 days. 97 */ 98 sec = tv->tv_sec; 99 usec = tv->tv_usec; 100 101 KASSERT(usec >= 0 && usec < 1000000); 102 103 /* catch overflows in conversion time_t->int */ 104 if (tv->tv_sec > INT_MAX) 105 return INT_MAX; 106 if (tv->tv_sec < 0) 107 return 0; 108 109 if (sec < 0 || (sec == 0 && usec == 0)) { 110 /* 111 * Would expire now or in the past. Return 0 ticks. 112 * This is different from the legacy tvhzto() interface, 113 * and callers need to check for it. 114 */ 115 ticks = 0; 116 } else if (sec <= (LONG_MAX / 1000000)) 117 ticks = (((sec * 1000000) + (unsigned long)usec + (tick - 1)) 118 / tick) + 1; 119 else if (sec <= (LONG_MAX / hz)) 120 ticks = (sec * hz) + 121 (((unsigned long)usec + (tick - 1)) / tick) + 1; 122 else 123 ticks = LONG_MAX; 124 125 if (ticks > INT_MAX) 126 ticks = INT_MAX; 127 128 return ((int)ticks); 129 } 130 131 int 132 tshzto(const struct timespec *tsp) 133 { 134 struct timespec now, ts; 135 136 ts = *tsp; /* Don't modify original tsp. */ 137 getnanotime(&now); 138 timespecsub(&ts, &now, &ts); 139 return tstohz(&ts); 140 } 141 142 int 143 tshztoup(const struct timespec *tsp) 144 { 145 struct timespec now, ts; 146 147 ts = *tsp; /* Don't modify original tsp. */ 148 getnanouptime(&now); 149 timespecsub(&ts, &now, &ts); 150 return tstohz(&ts); 151 } 152 153 /* 154 * Compute number of ticks in the specified amount of time. 155 */ 156 int 157 tstohz(const struct timespec *ts) 158 { 159 struct timeval tv; 160 161 /* 162 * usec has great enough resolution for hz, so convert to a 163 * timeval and use tvtohz() above. 164 */ 165 TIMESPEC_TO_TIMEVAL(&tv, ts); 166 return tvtohz(&tv); 167 } 168 169 /* 170 * Check that a proposed value to load into the .it_value or 171 * .it_interval part of an interval timer is acceptable, and 172 * fix it to have at least minimal value (i.e. if it is less 173 * than the resolution of the clock, round it up.). We don't 174 * timeout the 0,0 value because this means to disable the 175 * timer or the interval. 176 */ 177 int 178 itimerfix(struct timeval *tv) 179 { 180 181 if (tv->tv_usec < 0 || tv->tv_usec >= 1000000) 182 return EINVAL; 183 if (tv->tv_sec < 0) 184 return ETIMEDOUT; 185 if (tv->tv_sec == 0 && tv->tv_usec != 0 && tv->tv_usec < tick) 186 tv->tv_usec = tick; 187 return 0; 188 } 189 190 int 191 itimespecfix(struct timespec *ts) 192 { 193 194 if (ts->tv_nsec < 0 || ts->tv_nsec >= 1000000000) 195 return EINVAL; 196 if (ts->tv_sec < 0) 197 return ETIMEDOUT; 198 if (ts->tv_sec == 0 && ts->tv_nsec != 0 && ts->tv_nsec < tick * 1000) 199 ts->tv_nsec = tick * 1000; 200 return 0; 201 } 202 203 int 204 inittimeleft(struct timespec *ts, struct timespec *sleepts) 205 { 206 207 if (itimespecfix(ts)) { 208 return -1; 209 } 210 getnanouptime(sleepts); 211 return 0; 212 } 213 214 int 215 gettimeleft(struct timespec *ts, struct timespec *sleepts) 216 { 217 struct timespec sleptts; 218 219 /* 220 * Reduce ts by elapsed time based on monotonic time scale. 221 */ 222 getnanouptime(&sleptts); 223 timespecadd(ts, sleepts, ts); 224 timespecsub(ts, &sleptts, ts); 225 *sleepts = sleptts; 226 227 return tstohz(ts); 228 } 229 230 static void 231 ticks2ts(uint64_t ticks, struct timespec *ts) 232 { 233 ts->tv_sec = ticks / hz; 234 uint64_t sticks = ticks - ts->tv_sec * hz; 235 if (sticks > BINTIME_SCALE_MS) /* floor(2^64 / 1000) */ 236 ts->tv_nsec = sticks / hz * 1000000000LL; 237 else if (sticks > BINTIME_SCALE_US) /* floor(2^64 / 1000000) */ 238 ts->tv_nsec = sticks * 1000LL / hz * 1000000LL; 239 else 240 ts->tv_nsec = sticks * 1000000000LL / hz; 241 DPRINTF(("%s: %ju/%ju -> %ju.%ju\n", __func__, 242 (uintmax_t)ticks, (uintmax_t)sticks, 243 (uintmax_t)ts->tv_sec, (uintmax_t)ts->tv_nsec)); 244 } 245 246 int 247 clock_gettime1(clockid_t clock_id, struct timespec *ts) 248 { 249 int error; 250 uint64_t ticks; 251 struct proc *p; 252 253 #define CPUCLOCK_ID_MASK (~(CLOCK_THREAD_CPUTIME_ID|CLOCK_PROCESS_CPUTIME_ID)) 254 if (clock_id & CLOCK_PROCESS_CPUTIME_ID) { 255 pid_t pid = clock_id & CPUCLOCK_ID_MASK; 256 257 mutex_enter(proc_lock); 258 p = pid == 0 ? curproc : proc_find(pid); 259 if (p == NULL) { 260 mutex_exit(proc_lock); 261 return ESRCH; 262 } 263 ticks = p->p_uticks + p->p_sticks + p->p_iticks; 264 DPRINTF(("%s: u=%ju, s=%ju, i=%ju\n", __func__, 265 (uintmax_t)p->p_uticks, (uintmax_t)p->p_sticks, 266 (uintmax_t)p->p_iticks)); 267 mutex_exit(proc_lock); 268 269 // XXX: Perhaps create a special kauth type 270 error = kauth_authorize_process(curlwp->l_cred, 271 KAUTH_PROCESS_PTRACE, p, 272 KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_ENTRY), NULL, NULL); 273 if (error) 274 return error; 275 } else if (clock_id & CLOCK_THREAD_CPUTIME_ID) { 276 struct lwp *l; 277 lwpid_t lid = clock_id & CPUCLOCK_ID_MASK; 278 p = curproc; 279 mutex_enter(p->p_lock); 280 l = lid == 0 ? curlwp : lwp_find(p, lid); 281 if (l == NULL) { 282 mutex_exit(p->p_lock); 283 return ESRCH; 284 } 285 ticks = l->l_rticksum + l->l_slpticksum; 286 DPRINTF(("%s: r=%ju, s=%ju\n", __func__, 287 (uintmax_t)l->l_rticksum, (uintmax_t)l->l_slpticksum)); 288 mutex_exit(p->p_lock); 289 } else 290 ticks = (uint64_t)-1; 291 292 if (ticks != (uint64_t)-1) { 293 ticks2ts(ticks, ts); 294 return 0; 295 } 296 297 switch (clock_id) { 298 case CLOCK_REALTIME: 299 nanotime(ts); 300 break; 301 case CLOCK_MONOTONIC: 302 nanouptime(ts); 303 break; 304 default: 305 return EINVAL; 306 } 307 308 return 0; 309 } 310 311 /* 312 * Calculate delta and convert from struct timespec to the ticks. 313 */ 314 int 315 ts2timo(clockid_t clock_id, int flags, struct timespec *ts, 316 int *timo, struct timespec *start) 317 { 318 int error; 319 struct timespec tsd; 320 321 flags &= TIMER_ABSTIME; 322 if (start == NULL) 323 start = &tsd; 324 325 if (flags || start != &tsd) 326 if ((error = clock_gettime1(clock_id, start)) != 0) 327 return error; 328 329 if (flags) 330 timespecsub(ts, start, ts); 331 332 if ((error = itimespecfix(ts)) != 0) 333 return error; 334 335 if (ts->tv_sec == 0 && ts->tv_nsec == 0) 336 return ETIMEDOUT; 337 338 *timo = tstohz(ts); 339 KASSERT(*timo > 0); 340 341 return 0; 342 } 343