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