1 /*
2 * linux/kernel/time.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * This file contains the interface functions for the various
7 * time related system calls: time, stime, gettimeofday, settimeofday,
8 * adjtime
9 */
10 /*
11 * Modification history kernel/time.c
12 *
13 * 1993-09-02 Philip Gladstone
14 * Created file with time related functions from sched/core.c and adjtimex()
15 * 1993-10-08 Torsten Duwe
16 * adjtime interface update and CMOS clock write code
17 * 1995-08-13 Torsten Duwe
18 * kernel PLL updated to 1994-12-13 specs (rfc-1589)
19 * 1999-01-16 Ulrich Windl
20 * Introduced error checking for many cases in adjtimex().
21 * Updated NTP code according to technical memorandum Jan '96
22 * "A Kernel Model for Precision Timekeeping" by Dave Mills
23 * Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10)
24 * (Even though the technical memorandum forbids it)
25 * 2004-07-14 Christoph Lameter
26 * Added getnstimeofday to allow the posix timer functions to return
27 * with nanosecond accuracy
28 */
29
30 #include <linux/export.h>
31 #include <linux/timex.h>
32 #include <linux/capability.h>
33 #include <linux/timekeeper_internal.h>
34 #include <linux/errno.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.h>
37 #include <linux/fs.h>
38 #include <linux/math64.h>
39 #include <linux/ptrace.h>
40
41 #include <asm/uaccess.h>
42 #include <asm/unistd.h>
43
44 #include "timeconst.h"
45 #include "timekeeping.h"
46
47 /*
48 * The timezone where the local system is located. Used as a default by some
49 * programs who obtain this value by using gettimeofday.
50 */
51 struct timezone sys_tz;
52
53 EXPORT_SYMBOL(sys_tz);
54
55 #ifdef __ARCH_WANT_SYS_TIME
56
57 /*
58 * sys_time() can be implemented in user-level using
59 * sys_gettimeofday(). Is this for backwards compatibility? If so,
60 * why not move it into the appropriate arch directory (for those
61 * architectures that need it).
62 */
SYSCALL_DEFINE1(time,time_t __user *,tloc)63 SYSCALL_DEFINE1(time, time_t __user *, tloc)
64 {
65 time_t i = get_seconds();
66
67 if (tloc) {
68 if (put_user(i,tloc))
69 return -EFAULT;
70 }
71 force_successful_syscall_return();
72 return i;
73 }
74
75 /*
76 * sys_stime() can be implemented in user-level using
77 * sys_settimeofday(). Is this for backwards compatibility? If so,
78 * why not move it into the appropriate arch directory (for those
79 * architectures that need it).
80 */
81
SYSCALL_DEFINE1(stime,time_t __user *,tptr)82 SYSCALL_DEFINE1(stime, time_t __user *, tptr)
83 {
84 struct timespec tv;
85 int err;
86
87 if (get_user(tv.tv_sec, tptr))
88 return -EFAULT;
89
90 tv.tv_nsec = 0;
91
92 err = security_settime(&tv, NULL);
93 if (err)
94 return err;
95
96 do_settimeofday(&tv);
97 return 0;
98 }
99
100 #endif /* __ARCH_WANT_SYS_TIME */
101
SYSCALL_DEFINE2(gettimeofday,struct timeval __user *,tv,struct timezone __user *,tz)102 SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
103 struct timezone __user *, tz)
104 {
105 if (likely(tv != NULL)) {
106 struct timeval ktv;
107 do_gettimeofday(&ktv);
108 if (copy_to_user(tv, &ktv, sizeof(ktv)))
109 return -EFAULT;
110 }
111 if (unlikely(tz != NULL)) {
112 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
113 return -EFAULT;
114 }
115 return 0;
116 }
117
118 /*
119 * Indicates if there is an offset between the system clock and the hardware
120 * clock/persistent clock/rtc.
121 */
122 int persistent_clock_is_local;
123
124 /*
125 * Adjust the time obtained from the CMOS to be UTC time instead of
126 * local time.
127 *
128 * This is ugly, but preferable to the alternatives. Otherwise we
129 * would either need to write a program to do it in /etc/rc (and risk
130 * confusion if the program gets run more than once; it would also be
131 * hard to make the program warp the clock precisely n hours) or
132 * compile in the timezone information into the kernel. Bad, bad....
133 *
134 * - TYT, 1992-01-01
135 *
136 * The best thing to do is to keep the CMOS clock in universal time (UTC)
137 * as real UNIX machines always do it. This avoids all headaches about
138 * daylight saving times and warping kernel clocks.
139 */
warp_clock(void)140 static inline void warp_clock(void)
141 {
142 if (sys_tz.tz_minuteswest != 0) {
143 struct timespec adjust;
144
145 persistent_clock_is_local = 1;
146 adjust.tv_sec = sys_tz.tz_minuteswest * 60;
147 adjust.tv_nsec = 0;
148 timekeeping_inject_offset(&adjust);
149 }
150 }
151
152 /*
153 * In case for some reason the CMOS clock has not already been running
154 * in UTC, but in some local time: The first time we set the timezone,
155 * we will warp the clock so that it is ticking UTC time instead of
156 * local time. Presumably, if someone is setting the timezone then we
157 * are running in an environment where the programs understand about
158 * timezones. This should be done at boot time in the /etc/rc script,
159 * as soon as possible, so that the clock can be set right. Otherwise,
160 * various programs will get confused when the clock gets warped.
161 */
162
do_sys_settimeofday(const struct timespec * tv,const struct timezone * tz)163 int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz)
164 {
165 static int firsttime = 1;
166 int error = 0;
167
168 if (tv && !timespec_valid(tv))
169 return -EINVAL;
170
171 error = security_settime(tv, tz);
172 if (error)
173 return error;
174
175 if (tz) {
176 sys_tz = *tz;
177 update_vsyscall_tz();
178 if (firsttime) {
179 firsttime = 0;
180 if (!tv)
181 warp_clock();
182 }
183 }
184 if (tv)
185 return do_settimeofday(tv);
186 return 0;
187 }
188
SYSCALL_DEFINE2(settimeofday,struct timeval __user *,tv,struct timezone __user *,tz)189 SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
190 struct timezone __user *, tz)
191 {
192 struct timeval user_tv;
193 struct timespec new_ts;
194 struct timezone new_tz;
195
196 if (tv) {
197 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
198 return -EFAULT;
199
200 if (!timeval_valid(&user_tv))
201 return -EINVAL;
202
203 new_ts.tv_sec = user_tv.tv_sec;
204 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
205 }
206 if (tz) {
207 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
208 return -EFAULT;
209 }
210
211 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
212 }
213
SYSCALL_DEFINE1(adjtimex,struct timex __user *,txc_p)214 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
215 {
216 struct timex txc; /* Local copy of parameter */
217 int ret;
218
219 /* Copy the user data space into the kernel copy
220 * structure. But bear in mind that the structures
221 * may change
222 */
223 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
224 return -EFAULT;
225 ret = do_adjtimex(&txc);
226 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
227 }
228
229 /**
230 * current_fs_time - Return FS time
231 * @sb: Superblock.
232 *
233 * Return the current time truncated to the time granularity supported by
234 * the fs.
235 */
current_fs_time(struct super_block * sb)236 struct timespec current_fs_time(struct super_block *sb)
237 {
238 struct timespec now = current_kernel_time();
239 return timespec_trunc(now, sb->s_time_gran);
240 }
241 EXPORT_SYMBOL(current_fs_time);
242
243 /*
244 * Convert jiffies to milliseconds and back.
245 *
246 * Avoid unnecessary multiplications/divisions in the
247 * two most common HZ cases:
248 */
jiffies_to_msecs(const unsigned long j)249 unsigned int jiffies_to_msecs(const unsigned long j)
250 {
251 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
252 return (MSEC_PER_SEC / HZ) * j;
253 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
254 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
255 #else
256 # if BITS_PER_LONG == 32
257 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
258 # else
259 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
260 # endif
261 #endif
262 }
263 EXPORT_SYMBOL(jiffies_to_msecs);
264
jiffies_to_usecs(const unsigned long j)265 unsigned int jiffies_to_usecs(const unsigned long j)
266 {
267 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
268 return (USEC_PER_SEC / HZ) * j;
269 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
270 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
271 #else
272 # if BITS_PER_LONG == 32
273 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
274 # else
275 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
276 # endif
277 #endif
278 }
279 EXPORT_SYMBOL(jiffies_to_usecs);
280
281 /**
282 * timespec_trunc - Truncate timespec to a granularity
283 * @t: Timespec
284 * @gran: Granularity in ns.
285 *
286 * Truncate a timespec to a granularity. gran must be smaller than a second.
287 * Always rounds down.
288 *
289 * This function should be only used for timestamps returned by
290 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
291 * it doesn't handle the better resolution of the latter.
292 */
timespec_trunc(struct timespec t,unsigned gran)293 struct timespec timespec_trunc(struct timespec t, unsigned gran)
294 {
295 /*
296 * Division is pretty slow so avoid it for common cases.
297 * Currently current_kernel_time() never returns better than
298 * jiffies resolution. Exploit that.
299 */
300 if (gran <= jiffies_to_usecs(1) * 1000) {
301 /* nothing */
302 } else if (gran == 1000000000) {
303 t.tv_nsec = 0;
304 } else {
305 t.tv_nsec -= t.tv_nsec % gran;
306 }
307 return t;
308 }
309 EXPORT_SYMBOL(timespec_trunc);
310
311 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
312 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
313 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
314 *
315 * [For the Julian calendar (which was used in Russia before 1917,
316 * Britain & colonies before 1752, anywhere else before 1582,
317 * and is still in use by some communities) leave out the
318 * -year/100+year/400 terms, and add 10.]
319 *
320 * This algorithm was first published by Gauss (I think).
321 *
322 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
323 * machines where long is 32-bit! (However, as time_t is signed, we
324 * will already get problems at other places on 2038-01-19 03:14:08)
325 */
326 unsigned long
mktime(const unsigned int year0,const unsigned int mon0,const unsigned int day,const unsigned int hour,const unsigned int min,const unsigned int sec)327 mktime(const unsigned int year0, const unsigned int mon0,
328 const unsigned int day, const unsigned int hour,
329 const unsigned int min, const unsigned int sec)
330 {
331 unsigned int mon = mon0, year = year0;
332
333 /* 1..12 -> 11,12,1..10 */
334 if (0 >= (int) (mon -= 2)) {
335 mon += 12; /* Puts Feb last since it has leap day */
336 year -= 1;
337 }
338
339 return ((((unsigned long)
340 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
341 year*365 - 719499
342 )*24 + hour /* now have hours */
343 )*60 + min /* now have minutes */
344 )*60 + sec; /* finally seconds */
345 }
346
347 EXPORT_SYMBOL(mktime);
348
349 /**
350 * set_normalized_timespec - set timespec sec and nsec parts and normalize
351 *
352 * @ts: pointer to timespec variable to be set
353 * @sec: seconds to set
354 * @nsec: nanoseconds to set
355 *
356 * Set seconds and nanoseconds field of a timespec variable and
357 * normalize to the timespec storage format
358 *
359 * Note: The tv_nsec part is always in the range of
360 * 0 <= tv_nsec < NSEC_PER_SEC
361 * For negative values only the tv_sec field is negative !
362 */
set_normalized_timespec(struct timespec * ts,time_t sec,s64 nsec)363 void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
364 {
365 while (nsec >= NSEC_PER_SEC) {
366 /*
367 * The following asm() prevents the compiler from
368 * optimising this loop into a modulo operation. See
369 * also __iter_div_u64_rem() in include/linux/time.h
370 */
371 asm("" : "+rm"(nsec));
372 nsec -= NSEC_PER_SEC;
373 ++sec;
374 }
375 while (nsec < 0) {
376 asm("" : "+rm"(nsec));
377 nsec += NSEC_PER_SEC;
378 --sec;
379 }
380 ts->tv_sec = sec;
381 ts->tv_nsec = nsec;
382 }
383 EXPORT_SYMBOL(set_normalized_timespec);
384
385 /**
386 * ns_to_timespec - Convert nanoseconds to timespec
387 * @nsec: the nanoseconds value to be converted
388 *
389 * Returns the timespec representation of the nsec parameter.
390 */
ns_to_timespec(const s64 nsec)391 struct timespec ns_to_timespec(const s64 nsec)
392 {
393 struct timespec ts;
394 s32 rem;
395
396 if (!nsec)
397 return (struct timespec) {0, 0};
398
399 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
400 if (unlikely(rem < 0)) {
401 ts.tv_sec--;
402 rem += NSEC_PER_SEC;
403 }
404 ts.tv_nsec = rem;
405
406 return ts;
407 }
408 EXPORT_SYMBOL(ns_to_timespec);
409
410 /**
411 * ns_to_timeval - Convert nanoseconds to timeval
412 * @nsec: the nanoseconds value to be converted
413 *
414 * Returns the timeval representation of the nsec parameter.
415 */
ns_to_timeval(const s64 nsec)416 struct timeval ns_to_timeval(const s64 nsec)
417 {
418 struct timespec ts = ns_to_timespec(nsec);
419 struct timeval tv;
420
421 tv.tv_sec = ts.tv_sec;
422 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
423
424 return tv;
425 }
426 EXPORT_SYMBOL(ns_to_timeval);
427
428 #if BITS_PER_LONG == 32
429 /**
430 * set_normalized_timespec - set timespec sec and nsec parts and normalize
431 *
432 * @ts: pointer to timespec variable to be set
433 * @sec: seconds to set
434 * @nsec: nanoseconds to set
435 *
436 * Set seconds and nanoseconds field of a timespec variable and
437 * normalize to the timespec storage format
438 *
439 * Note: The tv_nsec part is always in the range of
440 * 0 <= tv_nsec < NSEC_PER_SEC
441 * For negative values only the tv_sec field is negative !
442 */
set_normalized_timespec64(struct timespec64 * ts,time64_t sec,s64 nsec)443 void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
444 {
445 while (nsec >= NSEC_PER_SEC) {
446 /*
447 * The following asm() prevents the compiler from
448 * optimising this loop into a modulo operation. See
449 * also __iter_div_u64_rem() in include/linux/time.h
450 */
451 asm("" : "+rm"(nsec));
452 nsec -= NSEC_PER_SEC;
453 ++sec;
454 }
455 while (nsec < 0) {
456 asm("" : "+rm"(nsec));
457 nsec += NSEC_PER_SEC;
458 --sec;
459 }
460 ts->tv_sec = sec;
461 ts->tv_nsec = nsec;
462 }
463 EXPORT_SYMBOL(set_normalized_timespec64);
464
465 /**
466 * ns_to_timespec64 - Convert nanoseconds to timespec64
467 * @nsec: the nanoseconds value to be converted
468 *
469 * Returns the timespec64 representation of the nsec parameter.
470 */
ns_to_timespec64(const s64 nsec)471 struct timespec64 ns_to_timespec64(const s64 nsec)
472 {
473 struct timespec64 ts;
474 s32 rem;
475
476 if (!nsec)
477 return (struct timespec64) {0, 0};
478
479 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
480 if (unlikely(rem < 0)) {
481 ts.tv_sec--;
482 rem += NSEC_PER_SEC;
483 }
484 ts.tv_nsec = rem;
485
486 return ts;
487 }
488 EXPORT_SYMBOL(ns_to_timespec64);
489 #endif
490 /*
491 * When we convert to jiffies then we interpret incoming values
492 * the following way:
493 *
494 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
495 *
496 * - 'too large' values [that would result in larger than
497 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
498 *
499 * - all other values are converted to jiffies by either multiplying
500 * the input value by a factor or dividing it with a factor
501 *
502 * We must also be careful about 32-bit overflows.
503 */
msecs_to_jiffies(const unsigned int m)504 unsigned long msecs_to_jiffies(const unsigned int m)
505 {
506 /*
507 * Negative value, means infinite timeout:
508 */
509 if ((int)m < 0)
510 return MAX_JIFFY_OFFSET;
511
512 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
513 /*
514 * HZ is equal to or smaller than 1000, and 1000 is a nice
515 * round multiple of HZ, divide with the factor between them,
516 * but round upwards:
517 */
518 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
519 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
520 /*
521 * HZ is larger than 1000, and HZ is a nice round multiple of
522 * 1000 - simply multiply with the factor between them.
523 *
524 * But first make sure the multiplication result cannot
525 * overflow:
526 */
527 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
528 return MAX_JIFFY_OFFSET;
529
530 return m * (HZ / MSEC_PER_SEC);
531 #else
532 /*
533 * Generic case - multiply, round and divide. But first
534 * check that if we are doing a net multiplication, that
535 * we wouldn't overflow:
536 */
537 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
538 return MAX_JIFFY_OFFSET;
539
540 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
541 >> MSEC_TO_HZ_SHR32;
542 #endif
543 }
544 EXPORT_SYMBOL(msecs_to_jiffies);
545
usecs_to_jiffies(const unsigned int u)546 unsigned long usecs_to_jiffies(const unsigned int u)
547 {
548 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
549 return MAX_JIFFY_OFFSET;
550 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
551 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
552 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
553 return u * (HZ / USEC_PER_SEC);
554 #else
555 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
556 >> USEC_TO_HZ_SHR32;
557 #endif
558 }
559 EXPORT_SYMBOL(usecs_to_jiffies);
560
561 /*
562 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
563 * that a remainder subtract here would not do the right thing as the
564 * resolution values don't fall on second boundries. I.e. the line:
565 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
566 * Note that due to the small error in the multiplier here, this
567 * rounding is incorrect for sufficiently large values of tv_nsec, but
568 * well formed timespecs should have tv_nsec < NSEC_PER_SEC, so we're
569 * OK.
570 *
571 * Rather, we just shift the bits off the right.
572 *
573 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
574 * value to a scaled second value.
575 */
576 static unsigned long
__timespec_to_jiffies(unsigned long sec,long nsec)577 __timespec_to_jiffies(unsigned long sec, long nsec)
578 {
579 nsec = nsec + TICK_NSEC - 1;
580
581 if (sec >= MAX_SEC_IN_JIFFIES){
582 sec = MAX_SEC_IN_JIFFIES;
583 nsec = 0;
584 }
585 return (((u64)sec * SEC_CONVERSION) +
586 (((u64)nsec * NSEC_CONVERSION) >>
587 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
588
589 }
590
591 unsigned long
timespec_to_jiffies(const struct timespec * value)592 timespec_to_jiffies(const struct timespec *value)
593 {
594 return __timespec_to_jiffies(value->tv_sec, value->tv_nsec);
595 }
596
597 EXPORT_SYMBOL(timespec_to_jiffies);
598
599 void
jiffies_to_timespec(const unsigned long jiffies,struct timespec * value)600 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
601 {
602 /*
603 * Convert jiffies to nanoseconds and separate with
604 * one divide.
605 */
606 u32 rem;
607 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
608 NSEC_PER_SEC, &rem);
609 value->tv_nsec = rem;
610 }
611 EXPORT_SYMBOL(jiffies_to_timespec);
612
613 /*
614 * We could use a similar algorithm to timespec_to_jiffies (with a
615 * different multiplier for usec instead of nsec). But this has a
616 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the
617 * usec value, since it's not necessarily integral.
618 *
619 * We could instead round in the intermediate scaled representation
620 * (i.e. in units of 1/2^(large scale) jiffies) but that's also
621 * perilous: the scaling introduces a small positive error, which
622 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1
623 * units to the intermediate before shifting) leads to accidental
624 * overflow and overestimates.
625 *
626 * At the cost of one additional multiplication by a constant, just
627 * use the timespec implementation.
628 */
629 unsigned long
timeval_to_jiffies(const struct timeval * value)630 timeval_to_jiffies(const struct timeval *value)
631 {
632 return __timespec_to_jiffies(value->tv_sec,
633 value->tv_usec * NSEC_PER_USEC);
634 }
635 EXPORT_SYMBOL(timeval_to_jiffies);
636
jiffies_to_timeval(const unsigned long jiffies,struct timeval * value)637 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
638 {
639 /*
640 * Convert jiffies to nanoseconds and separate with
641 * one divide.
642 */
643 u32 rem;
644
645 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
646 NSEC_PER_SEC, &rem);
647 value->tv_usec = rem / NSEC_PER_USEC;
648 }
649 EXPORT_SYMBOL(jiffies_to_timeval);
650
651 /*
652 * Convert jiffies/jiffies_64 to clock_t and back.
653 */
jiffies_to_clock_t(unsigned long x)654 clock_t jiffies_to_clock_t(unsigned long x)
655 {
656 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
657 # if HZ < USER_HZ
658 return x * (USER_HZ / HZ);
659 # else
660 return x / (HZ / USER_HZ);
661 # endif
662 #else
663 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
664 #endif
665 }
666 EXPORT_SYMBOL(jiffies_to_clock_t);
667
clock_t_to_jiffies(unsigned long x)668 unsigned long clock_t_to_jiffies(unsigned long x)
669 {
670 #if (HZ % USER_HZ)==0
671 if (x >= ~0UL / (HZ / USER_HZ))
672 return ~0UL;
673 return x * (HZ / USER_HZ);
674 #else
675 /* Don't worry about loss of precision here .. */
676 if (x >= ~0UL / HZ * USER_HZ)
677 return ~0UL;
678
679 /* .. but do try to contain it here */
680 return div_u64((u64)x * HZ, USER_HZ);
681 #endif
682 }
683 EXPORT_SYMBOL(clock_t_to_jiffies);
684
jiffies_64_to_clock_t(u64 x)685 u64 jiffies_64_to_clock_t(u64 x)
686 {
687 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
688 # if HZ < USER_HZ
689 x = div_u64(x * USER_HZ, HZ);
690 # elif HZ > USER_HZ
691 x = div_u64(x, HZ / USER_HZ);
692 # else
693 /* Nothing to do */
694 # endif
695 #else
696 /*
697 * There are better ways that don't overflow early,
698 * but even this doesn't overflow in hundreds of years
699 * in 64 bits, so..
700 */
701 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
702 #endif
703 return x;
704 }
705 EXPORT_SYMBOL(jiffies_64_to_clock_t);
706
nsec_to_clock_t(u64 x)707 u64 nsec_to_clock_t(u64 x)
708 {
709 #if (NSEC_PER_SEC % USER_HZ) == 0
710 return div_u64(x, NSEC_PER_SEC / USER_HZ);
711 #elif (USER_HZ % 512) == 0
712 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
713 #else
714 /*
715 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
716 * overflow after 64.99 years.
717 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
718 */
719 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
720 #endif
721 }
722
723 /**
724 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
725 *
726 * @n: nsecs in u64
727 *
728 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
729 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
730 * for scheduler, not for use in device drivers to calculate timeout value.
731 *
732 * note:
733 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
734 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
735 */
nsecs_to_jiffies64(u64 n)736 u64 nsecs_to_jiffies64(u64 n)
737 {
738 #if (NSEC_PER_SEC % HZ) == 0
739 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
740 return div_u64(n, NSEC_PER_SEC / HZ);
741 #elif (HZ % 512) == 0
742 /* overflow after 292 years if HZ = 1024 */
743 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
744 #else
745 /*
746 * Generic case - optimized for cases where HZ is a multiple of 3.
747 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
748 */
749 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
750 #endif
751 }
752
753 /**
754 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
755 *
756 * @n: nsecs in u64
757 *
758 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
759 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
760 * for scheduler, not for use in device drivers to calculate timeout value.
761 *
762 * note:
763 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
764 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
765 */
nsecs_to_jiffies(u64 n)766 unsigned long nsecs_to_jiffies(u64 n)
767 {
768 return (unsigned long)nsecs_to_jiffies64(n);
769 }
770 EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
771
772 /*
773 * Add two timespec values and do a safety check for overflow.
774 * It's assumed that both values are valid (>= 0)
775 */
timespec_add_safe(const struct timespec lhs,const struct timespec rhs)776 struct timespec timespec_add_safe(const struct timespec lhs,
777 const struct timespec rhs)
778 {
779 struct timespec res;
780
781 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
782 lhs.tv_nsec + rhs.tv_nsec);
783
784 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
785 res.tv_sec = TIME_T_MAX;
786
787 return res;
788 }
789