]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - kernel/time.c
Merge branch 'sched-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[mirror_ubuntu-bionic-kernel.git] / kernel / time.c
CommitLineData
1da177e4
LT
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
6fa6c3b1 12 *
1da177e4 13 * 1993-09-02 Philip Gladstone
6fa6c3b1 14 * Created file with time related functions from sched.c and adjtimex()
1da177e4
LT
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/module.h>
31#include <linux/timex.h>
c59ede7b 32#include <linux/capability.h>
2c622148 33#include <linux/clocksource.h>
1da177e4 34#include <linux/errno.h>
1da177e4
LT
35#include <linux/syscalls.h>
36#include <linux/security.h>
37#include <linux/fs.h>
1aeb272c 38#include <linux/slab.h>
71abb3af 39#include <linux/math64.h>
e3d5a27d 40#include <linux/ptrace.h>
1da177e4
LT
41
42#include <asm/uaccess.h>
43#include <asm/unistd.h>
44
bdc80787
PA
45#include "timeconst.h"
46
6fa6c3b1 47/*
1da177e4
LT
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 */
51struct timezone sys_tz;
52
53EXPORT_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 */
58fd3aa2 63SYSCALL_DEFINE1(time, time_t __user *, tloc)
1da177e4 64{
f20bf612 65 time_t i = get_seconds();
1da177e4
LT
66
67 if (tloc) {
20082208 68 if (put_user(i,tloc))
e3d5a27d 69 return -EFAULT;
1da177e4 70 }
e3d5a27d 71 force_successful_syscall_return();
1da177e4
LT
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 */
6fa6c3b1 81
58fd3aa2 82SYSCALL_DEFINE1(stime, time_t __user *, tptr)
1da177e4
LT
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
58fd3aa2
HC
102SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
103 struct timezone __user *, tz)
1da177e4
LT
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 * Adjust the time obtained from the CMOS to be UTC time instead of
120 * local time.
6fa6c3b1 121 *
1da177e4
LT
122 * This is ugly, but preferable to the alternatives. Otherwise we
123 * would either need to write a program to do it in /etc/rc (and risk
6fa6c3b1 124 * confusion if the program gets run more than once; it would also be
1da177e4
LT
125 * hard to make the program warp the clock precisely n hours) or
126 * compile in the timezone information into the kernel. Bad, bad....
127 *
bdc80787 128 * - TYT, 1992-01-01
1da177e4
LT
129 *
130 * The best thing to do is to keep the CMOS clock in universal time (UTC)
131 * as real UNIX machines always do it. This avoids all headaches about
132 * daylight saving times and warping kernel clocks.
133 */
77933d72 134static inline void warp_clock(void)
1da177e4
LT
135{
136 write_seqlock_irq(&xtime_lock);
137 wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
138 xtime.tv_sec += sys_tz.tz_minuteswest * 60;
1001d0a9 139 update_xtime_cache(0);
1da177e4
LT
140 write_sequnlock_irq(&xtime_lock);
141 clock_was_set();
142}
143
144/*
145 * In case for some reason the CMOS clock has not already been running
146 * in UTC, but in some local time: The first time we set the timezone,
147 * we will warp the clock so that it is ticking UTC time instead of
148 * local time. Presumably, if someone is setting the timezone then we
149 * are running in an environment where the programs understand about
150 * timezones. This should be done at boot time in the /etc/rc script,
151 * as soon as possible, so that the clock can be set right. Otherwise,
152 * various programs will get confused when the clock gets warped.
153 */
154
155int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
156{
157 static int firsttime = 1;
158 int error = 0;
159
951069e3 160 if (tv && !timespec_valid(tv))
718bcceb
TG
161 return -EINVAL;
162
1da177e4
LT
163 error = security_settime(tv, tz);
164 if (error)
165 return error;
166
167 if (tz) {
168 /* SMP safe, global irq locking makes it work. */
169 sys_tz = *tz;
2c622148 170 update_vsyscall_tz();
1da177e4
LT
171 if (firsttime) {
172 firsttime = 0;
173 if (!tv)
174 warp_clock();
175 }
176 }
177 if (tv)
178 {
179 /* SMP safe, again the code in arch/foo/time.c should
180 * globally block out interrupts when it runs.
181 */
182 return do_settimeofday(tv);
183 }
184 return 0;
185}
186
58fd3aa2
HC
187SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
188 struct timezone __user *, tz)
1da177e4
LT
189{
190 struct timeval user_tv;
191 struct timespec new_ts;
192 struct timezone new_tz;
193
194 if (tv) {
195 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
196 return -EFAULT;
197 new_ts.tv_sec = user_tv.tv_sec;
198 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
199 }
200 if (tz) {
201 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
202 return -EFAULT;
203 }
204
205 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
206}
207
58fd3aa2 208SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
1da177e4
LT
209{
210 struct timex txc; /* Local copy of parameter */
211 int ret;
212
213 /* Copy the user data space into the kernel copy
214 * structure. But bear in mind that the structures
215 * may change
216 */
217 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
218 return -EFAULT;
219 ret = do_adjtimex(&txc);
220 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
221}
222
1da177e4
LT
223/**
224 * current_fs_time - Return FS time
225 * @sb: Superblock.
226 *
8ba8e95e 227 * Return the current time truncated to the time granularity supported by
1da177e4
LT
228 * the fs.
229 */
230struct timespec current_fs_time(struct super_block *sb)
231{
232 struct timespec now = current_kernel_time();
233 return timespec_trunc(now, sb->s_time_gran);
234}
235EXPORT_SYMBOL(current_fs_time);
236
753e9c5c
ED
237/*
238 * Convert jiffies to milliseconds and back.
239 *
240 * Avoid unnecessary multiplications/divisions in the
241 * two most common HZ cases:
242 */
243unsigned int inline jiffies_to_msecs(const unsigned long j)
244{
245#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
246 return (MSEC_PER_SEC / HZ) * j;
247#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
248 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
249#else
bdc80787 250# if BITS_PER_LONG == 32
b9095fd8 251 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
bdc80787
PA
252# else
253 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
254# endif
753e9c5c
ED
255#endif
256}
257EXPORT_SYMBOL(jiffies_to_msecs);
258
259unsigned int inline jiffies_to_usecs(const unsigned long j)
260{
261#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
262 return (USEC_PER_SEC / HZ) * j;
263#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
264 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
265#else
bdc80787 266# if BITS_PER_LONG == 32
b9095fd8 267 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
bdc80787
PA
268# else
269 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
270# endif
753e9c5c
ED
271#endif
272}
273EXPORT_SYMBOL(jiffies_to_usecs);
274
1da177e4 275/**
8ba8e95e 276 * timespec_trunc - Truncate timespec to a granularity
1da177e4 277 * @t: Timespec
8ba8e95e 278 * @gran: Granularity in ns.
1da177e4 279 *
8ba8e95e 280 * Truncate a timespec to a granularity. gran must be smaller than a second.
1da177e4
LT
281 * Always rounds down.
282 *
283 * This function should be only used for timestamps returned by
284 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
3eb05676 285 * it doesn't handle the better resolution of the latter.
1da177e4
LT
286 */
287struct timespec timespec_trunc(struct timespec t, unsigned gran)
288{
289 /*
290 * Division is pretty slow so avoid it for common cases.
291 * Currently current_kernel_time() never returns better than
292 * jiffies resolution. Exploit that.
293 */
294 if (gran <= jiffies_to_usecs(1) * 1000) {
295 /* nothing */
296 } else if (gran == 1000000000) {
297 t.tv_nsec = 0;
298 } else {
299 t.tv_nsec -= t.tv_nsec % gran;
300 }
301 return t;
302}
303EXPORT_SYMBOL(timespec_trunc);
304
cf3c769b 305#ifndef CONFIG_GENERIC_TIME
1da177e4
LT
306/*
307 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
308 * and therefore only yields usec accuracy
309 */
310void getnstimeofday(struct timespec *tv)
311{
312 struct timeval x;
313
314 do_gettimeofday(&x);
315 tv->tv_sec = x.tv_sec;
316 tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
317}
c6ecf7ed 318EXPORT_SYMBOL_GPL(getnstimeofday);
1da177e4
LT
319#endif
320
753be622
TG
321/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
322 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
323 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
324 *
325 * [For the Julian calendar (which was used in Russia before 1917,
326 * Britain & colonies before 1752, anywhere else before 1582,
327 * and is still in use by some communities) leave out the
328 * -year/100+year/400 terms, and add 10.]
329 *
330 * This algorithm was first published by Gauss (I think).
331 *
332 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
3eb05676 333 * machines where long is 32-bit! (However, as time_t is signed, we
753be622
TG
334 * will already get problems at other places on 2038-01-19 03:14:08)
335 */
336unsigned long
f4818900
IM
337mktime(const unsigned int year0, const unsigned int mon0,
338 const unsigned int day, const unsigned int hour,
339 const unsigned int min, const unsigned int sec)
753be622 340{
f4818900
IM
341 unsigned int mon = mon0, year = year0;
342
343 /* 1..12 -> 11,12,1..10 */
344 if (0 >= (int) (mon -= 2)) {
345 mon += 12; /* Puts Feb last since it has leap day */
753be622
TG
346 year -= 1;
347 }
348
349 return ((((unsigned long)
350 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
351 year*365 - 719499
352 )*24 + hour /* now have hours */
353 )*60 + min /* now have minutes */
354 )*60 + sec; /* finally seconds */
355}
356
199e7056
AM
357EXPORT_SYMBOL(mktime);
358
753be622
TG
359/**
360 * set_normalized_timespec - set timespec sec and nsec parts and normalize
361 *
362 * @ts: pointer to timespec variable to be set
363 * @sec: seconds to set
364 * @nsec: nanoseconds to set
365 *
366 * Set seconds and nanoseconds field of a timespec variable and
367 * normalize to the timespec storage format
368 *
369 * Note: The tv_nsec part is always in the range of
bdc80787 370 * 0 <= tv_nsec < NSEC_PER_SEC
753be622
TG
371 * For negative values only the tv_sec field is negative !
372 */
f4818900 373void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
753be622
TG
374{
375 while (nsec >= NSEC_PER_SEC) {
376 nsec -= NSEC_PER_SEC;
377 ++sec;
378 }
379 while (nsec < 0) {
380 nsec += NSEC_PER_SEC;
381 --sec;
382 }
383 ts->tv_sec = sec;
384 ts->tv_nsec = nsec;
385}
7c3f944e 386EXPORT_SYMBOL(set_normalized_timespec);
753be622 387
f8f46da3
TG
388/**
389 * ns_to_timespec - Convert nanoseconds to timespec
390 * @nsec: the nanoseconds value to be converted
391 *
392 * Returns the timespec representation of the nsec parameter.
393 */
df869b63 394struct timespec ns_to_timespec(const s64 nsec)
f8f46da3
TG
395{
396 struct timespec ts;
f8bd2258 397 s32 rem;
f8f46da3 398
88fc3897
GA
399 if (!nsec)
400 return (struct timespec) {0, 0};
401
f8bd2258
RZ
402 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
403 if (unlikely(rem < 0)) {
404 ts.tv_sec--;
405 rem += NSEC_PER_SEC;
406 }
407 ts.tv_nsec = rem;
f8f46da3
TG
408
409 return ts;
410}
85795d64 411EXPORT_SYMBOL(ns_to_timespec);
f8f46da3
TG
412
413/**
414 * ns_to_timeval - Convert nanoseconds to timeval
415 * @nsec: the nanoseconds value to be converted
416 *
417 * Returns the timeval representation of the nsec parameter.
418 */
df869b63 419struct timeval ns_to_timeval(const s64 nsec)
f8f46da3
TG
420{
421 struct timespec ts = ns_to_timespec(nsec);
422 struct timeval tv;
423
424 tv.tv_sec = ts.tv_sec;
425 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
426
427 return tv;
428}
b7aa0bf7 429EXPORT_SYMBOL(ns_to_timeval);
f8f46da3 430
41cf5445
IM
431/*
432 * When we convert to jiffies then we interpret incoming values
433 * the following way:
434 *
435 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
436 *
437 * - 'too large' values [that would result in larger than
438 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
439 *
440 * - all other values are converted to jiffies by either multiplying
441 * the input value by a factor or dividing it with a factor
442 *
443 * We must also be careful about 32-bit overflows.
444 */
8b9365d7
IM
445unsigned long msecs_to_jiffies(const unsigned int m)
446{
41cf5445
IM
447 /*
448 * Negative value, means infinite timeout:
449 */
450 if ((int)m < 0)
8b9365d7 451 return MAX_JIFFY_OFFSET;
41cf5445 452
8b9365d7 453#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
41cf5445
IM
454 /*
455 * HZ is equal to or smaller than 1000, and 1000 is a nice
456 * round multiple of HZ, divide with the factor between them,
457 * but round upwards:
458 */
8b9365d7
IM
459 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
460#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
41cf5445
IM
461 /*
462 * HZ is larger than 1000, and HZ is a nice round multiple of
463 * 1000 - simply multiply with the factor between them.
464 *
465 * But first make sure the multiplication result cannot
466 * overflow:
467 */
468 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
469 return MAX_JIFFY_OFFSET;
470
8b9365d7
IM
471 return m * (HZ / MSEC_PER_SEC);
472#else
41cf5445
IM
473 /*
474 * Generic case - multiply, round and divide. But first
475 * check that if we are doing a net multiplication, that
bdc80787 476 * we wouldn't overflow:
41cf5445
IM
477 */
478 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
479 return MAX_JIFFY_OFFSET;
480
b9095fd8 481 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
bdc80787 482 >> MSEC_TO_HZ_SHR32;
8b9365d7
IM
483#endif
484}
485EXPORT_SYMBOL(msecs_to_jiffies);
486
487unsigned long usecs_to_jiffies(const unsigned int u)
488{
489 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
490 return MAX_JIFFY_OFFSET;
491#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
492 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
493#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
494 return u * (HZ / USEC_PER_SEC);
495#else
b9095fd8 496 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
bdc80787 497 >> USEC_TO_HZ_SHR32;
8b9365d7
IM
498#endif
499}
500EXPORT_SYMBOL(usecs_to_jiffies);
501
502/*
503 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
504 * that a remainder subtract here would not do the right thing as the
505 * resolution values don't fall on second boundries. I.e. the line:
506 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
507 *
508 * Rather, we just shift the bits off the right.
509 *
510 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
511 * value to a scaled second value.
512 */
513unsigned long
514timespec_to_jiffies(const struct timespec *value)
515{
516 unsigned long sec = value->tv_sec;
517 long nsec = value->tv_nsec + TICK_NSEC - 1;
518
519 if (sec >= MAX_SEC_IN_JIFFIES){
520 sec = MAX_SEC_IN_JIFFIES;
521 nsec = 0;
522 }
523 return (((u64)sec * SEC_CONVERSION) +
524 (((u64)nsec * NSEC_CONVERSION) >>
525 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
526
527}
528EXPORT_SYMBOL(timespec_to_jiffies);
529
530void
531jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
532{
533 /*
534 * Convert jiffies to nanoseconds and separate with
535 * one divide.
536 */
f8bd2258
RZ
537 u32 rem;
538 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
539 NSEC_PER_SEC, &rem);
540 value->tv_nsec = rem;
8b9365d7
IM
541}
542EXPORT_SYMBOL(jiffies_to_timespec);
543
544/* Same for "timeval"
545 *
546 * Well, almost. The problem here is that the real system resolution is
547 * in nanoseconds and the value being converted is in micro seconds.
548 * Also for some machines (those that use HZ = 1024, in-particular),
549 * there is a LARGE error in the tick size in microseconds.
550
551 * The solution we use is to do the rounding AFTER we convert the
552 * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
553 * Instruction wise, this should cost only an additional add with carry
554 * instruction above the way it was done above.
555 */
556unsigned long
557timeval_to_jiffies(const struct timeval *value)
558{
559 unsigned long sec = value->tv_sec;
560 long usec = value->tv_usec;
561
562 if (sec >= MAX_SEC_IN_JIFFIES){
563 sec = MAX_SEC_IN_JIFFIES;
564 usec = 0;
565 }
566 return (((u64)sec * SEC_CONVERSION) +
567 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
568 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
569}
456a09dc 570EXPORT_SYMBOL(timeval_to_jiffies);
8b9365d7
IM
571
572void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
573{
574 /*
575 * Convert jiffies to nanoseconds and separate with
576 * one divide.
577 */
f8bd2258 578 u32 rem;
8b9365d7 579
f8bd2258
RZ
580 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
581 NSEC_PER_SEC, &rem);
582 value->tv_usec = rem / NSEC_PER_USEC;
8b9365d7 583}
456a09dc 584EXPORT_SYMBOL(jiffies_to_timeval);
8b9365d7
IM
585
586/*
587 * Convert jiffies/jiffies_64 to clock_t and back.
588 */
589clock_t jiffies_to_clock_t(long x)
590{
591#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
6ffc787a
DF
592# if HZ < USER_HZ
593 return x * (USER_HZ / HZ);
594# else
8b9365d7 595 return x / (HZ / USER_HZ);
6ffc787a 596# endif
8b9365d7 597#else
71abb3af 598 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
8b9365d7
IM
599#endif
600}
601EXPORT_SYMBOL(jiffies_to_clock_t);
602
603unsigned long clock_t_to_jiffies(unsigned long x)
604{
605#if (HZ % USER_HZ)==0
606 if (x >= ~0UL / (HZ / USER_HZ))
607 return ~0UL;
608 return x * (HZ / USER_HZ);
609#else
8b9365d7
IM
610 /* Don't worry about loss of precision here .. */
611 if (x >= ~0UL / HZ * USER_HZ)
612 return ~0UL;
613
614 /* .. but do try to contain it here */
71abb3af 615 return div_u64((u64)x * HZ, USER_HZ);
8b9365d7
IM
616#endif
617}
618EXPORT_SYMBOL(clock_t_to_jiffies);
619
620u64 jiffies_64_to_clock_t(u64 x)
621{
622#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
6ffc787a 623# if HZ < USER_HZ
71abb3af 624 x = div_u64(x * USER_HZ, HZ);
ec03d707 625# elif HZ > USER_HZ
71abb3af 626 x = div_u64(x, HZ / USER_HZ);
ec03d707
AM
627# else
628 /* Nothing to do */
6ffc787a 629# endif
8b9365d7
IM
630#else
631 /*
632 * There are better ways that don't overflow early,
633 * but even this doesn't overflow in hundreds of years
634 * in 64 bits, so..
635 */
71abb3af 636 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
8b9365d7
IM
637#endif
638 return x;
639}
8b9365d7
IM
640EXPORT_SYMBOL(jiffies_64_to_clock_t);
641
642u64 nsec_to_clock_t(u64 x)
643{
644#if (NSEC_PER_SEC % USER_HZ) == 0
71abb3af 645 return div_u64(x, NSEC_PER_SEC / USER_HZ);
8b9365d7 646#elif (USER_HZ % 512) == 0
71abb3af 647 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
8b9365d7
IM
648#else
649 /*
650 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
651 * overflow after 64.99 years.
652 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
653 */
71abb3af 654 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
8b9365d7 655#endif
8b9365d7
IM
656}
657
1da177e4
LT
658#if (BITS_PER_LONG < 64)
659u64 get_jiffies_64(void)
660{
661 unsigned long seq;
662 u64 ret;
663
664 do {
665 seq = read_seqbegin(&xtime_lock);
666 ret = jiffies_64;
667 } while (read_seqretry(&xtime_lock, seq));
668 return ret;
669}
1da177e4
LT
670EXPORT_SYMBOL(get_jiffies_64);
671#endif
672
673EXPORT_SYMBOL(jiffies);
df0cc053
TG
674
675/*
676 * Add two timespec values and do a safety check for overflow.
677 * It's assumed that both values are valid (>= 0)
678 */
679struct timespec timespec_add_safe(const struct timespec lhs,
680 const struct timespec rhs)
681{
682 struct timespec res;
683
684 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
685 lhs.tv_nsec + rhs.tv_nsec);
686
687 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
688 res.tv_sec = TIME_T_MAX;
689
690 return res;
691}