blob: f0294ba14634345b604ebf88ca5b5977fadfad17 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Daniel Walker6fa6c3b2007-10-18 03:06:03 -070012 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * 1993-09-02 Philip Gladstone
Viresh Kumar0a0fca92013-06-04 13:10:24 +053014 * Created file with time related functions from sched/core.c and adjtimex()
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 * 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
Paul Gortmaker9984de12011-05-23 14:51:41 -040030#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <linux/timex.h>
Randy.Dunlapc59ede72006-01-11 12:17:46 -080032#include <linux/capability.h>
John Stultz189374a2012-09-04 15:27:48 -040033#include <linux/timekeeper_internal.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/syscalls.h>
36#include <linux/security.h>
37#include <linux/fs.h>
Roman Zippel71abb3a2008-05-01 04:34:26 -070038#include <linux/math64.h>
Paul Mackerrase3d5a272009-01-06 14:41:02 -080039#include <linux/ptrace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#include <asm/uaccess.h>
42#include <asm/unistd.h>
43
H. Peter Anvinbdc80782008-02-08 04:21:26 -080044#include "timeconst.h"
Thomas Gleixner8b094cd2014-07-16 21:04:02 +000045#include "timekeeping.h"
H. Peter Anvinbdc80782008-02-08 04:21:26 -080046
Daniel Walker6fa6c3b2007-10-18 03:06:03 -070047/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 * 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 */
Heiko Carstens58fd3aa2009-01-14 14:14:03 +010063SYSCALL_DEFINE1(time, time_t __user *, tloc)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
Ingo Molnarf20bf612007-10-16 16:09:20 +020065 time_t i = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
67 if (tloc) {
Linus Torvalds20082202007-07-20 13:28:54 -070068 if (put_user(i,tloc))
Paul Mackerrase3d5a272009-01-06 14:41:02 -080069 return -EFAULT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 }
Paul Mackerrase3d5a272009-01-06 14:41:02 -080071 force_successful_syscall_return();
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 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 */
Daniel Walker6fa6c3b2007-10-18 03:06:03 -070081
Heiko Carstens58fd3aa2009-01-14 14:14:03 +010082SYSCALL_DEFINE1(stime, time_t __user *, tptr)
Linus Torvalds1da177e2005-04-16 15:20:36 -070083{
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
Heiko Carstens58fd3aa2009-01-14 14:14:03 +0100102SYSCALL_DEFINE2(gettimeofday, struct timeval __user *, tv,
103 struct timezone __user *, tz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104{
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/*
Prarit Bhargava84e345e2013-02-08 17:59:53 -0500119 * Indicates if there is an offset between the system clock and the hardware
120 * clock/persistent clock/rtc.
121 */
122int persistent_clock_is_local;
123
124/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 * Adjust the time obtained from the CMOS to be UTC time instead of
126 * local time.
Daniel Walker6fa6c3b2007-10-18 03:06:03 -0700127 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 * 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
Daniel Walker6fa6c3b2007-10-18 03:06:03 -0700130 * confusion if the program gets run more than once; it would also be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 * hard to make the program warp the clock precisely n hours) or
132 * compile in the timezone information into the kernel. Bad, bad....
133 *
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800134 * - TYT, 1992-01-01
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 *
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 */
Jesper Juhl77933d72005-07-27 11:46:09 -0700140static inline void warp_clock(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141{
Dong Zhuc30bd092012-12-06 22:03:34 +0800142 if (sys_tz.tz_minuteswest != 0) {
143 struct timespec adjust;
Thomas Gleixnerbd45b7a2010-05-23 08:14:45 +0200144
Prarit Bhargava84e345e2013-02-08 17:59:53 -0500145 persistent_clock_is_local = 1;
John Stultz7859e402013-02-22 12:33:29 -0800146 adjust.tv_sec = sys_tz.tz_minuteswest * 60;
147 adjust.tv_nsec = 0;
148 timekeeping_inject_offset(&adjust);
Dong Zhuc30bd092012-12-06 22:03:34 +0800149 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150}
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
Richard Cochran1e6d7672011-02-01 13:50:58 +0000163int do_sys_settimeofday(const struct timespec *tv, const struct timezone *tz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164{
165 static int firsttime = 1;
166 int error = 0;
167
Linus Torvalds951069e2006-01-31 10:16:55 -0800168 if (tv && !timespec_valid(tv))
Thomas Gleixner718bcce2006-01-09 20:52:29 -0800169 return -EINVAL;
170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 error = security_settime(tv, tz);
172 if (error)
173 return error;
174
175 if (tz) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 sys_tz = *tz;
Tony Breeds2c622142007-10-18 03:04:57 -0700177 update_vsyscall_tz();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 if (firsttime) {
179 firsttime = 0;
180 if (!tv)
181 warp_clock();
182 }
183 }
184 if (tv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 return do_settimeofday(tv);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 return 0;
187}
188
Heiko Carstens58fd3aa2009-01-14 14:14:03 +0100189SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
190 struct timezone __user *, tz)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191{
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 new_ts.tv_sec = user_tv.tv_sec;
200 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
201 }
202 if (tz) {
203 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
204 return -EFAULT;
205 }
206
207 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
208}
209
Heiko Carstens58fd3aa2009-01-14 14:14:03 +0100210SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
212 struct timex txc; /* Local copy of parameter */
213 int ret;
214
215 /* Copy the user data space into the kernel copy
216 * structure. But bear in mind that the structures
217 * may change
218 */
219 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
220 return -EFAULT;
221 ret = do_adjtimex(&txc);
222 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
223}
224
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225/**
226 * current_fs_time - Return FS time
227 * @sb: Superblock.
228 *
Kalin KOZHUHAROV8ba8e952006-04-01 01:41:22 +0200229 * Return the current time truncated to the time granularity supported by
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 * the fs.
231 */
232struct timespec current_fs_time(struct super_block *sb)
233{
234 struct timespec now = current_kernel_time();
235 return timespec_trunc(now, sb->s_time_gran);
236}
237EXPORT_SYMBOL(current_fs_time);
238
Eric Dumazet753e9c52007-05-08 00:25:32 -0700239/*
240 * Convert jiffies to milliseconds and back.
241 *
242 * Avoid unnecessary multiplications/divisions in the
243 * two most common HZ cases:
244 */
Greg Kroah-Hartmanaf3b5622013-02-21 16:42:40 -0800245unsigned int jiffies_to_msecs(const unsigned long j)
Eric Dumazet753e9c52007-05-08 00:25:32 -0700246{
247#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
248 return (MSEC_PER_SEC / HZ) * j;
249#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
250 return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
251#else
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800252# if BITS_PER_LONG == 32
H. Peter Anvinb9095fd2008-05-02 16:18:42 -0700253 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800254# else
255 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
256# endif
Eric Dumazet753e9c52007-05-08 00:25:32 -0700257#endif
258}
259EXPORT_SYMBOL(jiffies_to_msecs);
260
Greg Kroah-Hartmanaf3b5622013-02-21 16:42:40 -0800261unsigned int jiffies_to_usecs(const unsigned long j)
Eric Dumazet753e9c52007-05-08 00:25:32 -0700262{
263#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
264 return (USEC_PER_SEC / HZ) * j;
265#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
266 return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
267#else
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800268# if BITS_PER_LONG == 32
H. Peter Anvinb9095fd2008-05-02 16:18:42 -0700269 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800270# else
271 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
272# endif
Eric Dumazet753e9c52007-05-08 00:25:32 -0700273#endif
274}
275EXPORT_SYMBOL(jiffies_to_usecs);
276
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277/**
Kalin KOZHUHAROV8ba8e952006-04-01 01:41:22 +0200278 * timespec_trunc - Truncate timespec to a granularity
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 * @t: Timespec
Kalin KOZHUHAROV8ba8e952006-04-01 01:41:22 +0200280 * @gran: Granularity in ns.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 *
Kalin KOZHUHAROV8ba8e952006-04-01 01:41:22 +0200282 * Truncate a timespec to a granularity. gran must be smaller than a second.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 * Always rounds down.
284 *
285 * This function should be only used for timestamps returned by
286 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
Li Zefan3eb05672008-02-08 04:19:25 -0800287 * it doesn't handle the better resolution of the latter.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 */
289struct timespec timespec_trunc(struct timespec t, unsigned gran)
290{
291 /*
292 * Division is pretty slow so avoid it for common cases.
293 * Currently current_kernel_time() never returns better than
294 * jiffies resolution. Exploit that.
295 */
296 if (gran <= jiffies_to_usecs(1) * 1000) {
297 /* nothing */
298 } else if (gran == 1000000000) {
299 t.tv_nsec = 0;
300 } else {
301 t.tv_nsec -= t.tv_nsec % gran;
302 }
303 return t;
304}
305EXPORT_SYMBOL(timespec_trunc);
306
Thomas Gleixner753be622006-01-09 20:52:22 -0800307/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
308 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
309 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
310 *
311 * [For the Julian calendar (which was used in Russia before 1917,
312 * Britain & colonies before 1752, anywhere else before 1582,
313 * and is still in use by some communities) leave out the
314 * -year/100+year/400 terms, and add 10.]
315 *
316 * This algorithm was first published by Gauss (I think).
317 *
318 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
Li Zefan3eb05672008-02-08 04:19:25 -0800319 * machines where long is 32-bit! (However, as time_t is signed, we
Thomas Gleixner753be622006-01-09 20:52:22 -0800320 * will already get problems at other places on 2038-01-19 03:14:08)
321 */
322unsigned long
Ingo Molnarf4818902006-01-09 20:52:23 -0800323mktime(const unsigned int year0, const unsigned int mon0,
324 const unsigned int day, const unsigned int hour,
325 const unsigned int min, const unsigned int sec)
Thomas Gleixner753be622006-01-09 20:52:22 -0800326{
Ingo Molnarf4818902006-01-09 20:52:23 -0800327 unsigned int mon = mon0, year = year0;
328
329 /* 1..12 -> 11,12,1..10 */
330 if (0 >= (int) (mon -= 2)) {
331 mon += 12; /* Puts Feb last since it has leap day */
Thomas Gleixner753be622006-01-09 20:52:22 -0800332 year -= 1;
333 }
334
335 return ((((unsigned long)
336 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
337 year*365 - 719499
338 )*24 + hour /* now have hours */
339 )*60 + min /* now have minutes */
340 )*60 + sec; /* finally seconds */
341}
342
Andrew Morton199e7052006-01-09 20:52:24 -0800343EXPORT_SYMBOL(mktime);
344
Thomas Gleixner753be622006-01-09 20:52:22 -0800345/**
346 * set_normalized_timespec - set timespec sec and nsec parts and normalize
347 *
348 * @ts: pointer to timespec variable to be set
349 * @sec: seconds to set
350 * @nsec: nanoseconds to set
351 *
352 * Set seconds and nanoseconds field of a timespec variable and
353 * normalize to the timespec storage format
354 *
355 * Note: The tv_nsec part is always in the range of
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800356 * 0 <= tv_nsec < NSEC_PER_SEC
Thomas Gleixner753be622006-01-09 20:52:22 -0800357 * For negative values only the tv_sec field is negative !
358 */
Thomas Gleixner12e09332009-09-14 23:37:40 +0200359void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
Thomas Gleixner753be622006-01-09 20:52:22 -0800360{
361 while (nsec >= NSEC_PER_SEC) {
Thomas Gleixner12e09332009-09-14 23:37:40 +0200362 /*
363 * The following asm() prevents the compiler from
364 * optimising this loop into a modulo operation. See
365 * also __iter_div_u64_rem() in include/linux/time.h
366 */
367 asm("" : "+rm"(nsec));
Thomas Gleixner753be622006-01-09 20:52:22 -0800368 nsec -= NSEC_PER_SEC;
369 ++sec;
370 }
371 while (nsec < 0) {
Thomas Gleixner12e09332009-09-14 23:37:40 +0200372 asm("" : "+rm"(nsec));
Thomas Gleixner753be622006-01-09 20:52:22 -0800373 nsec += NSEC_PER_SEC;
374 --sec;
375 }
376 ts->tv_sec = sec;
377 ts->tv_nsec = nsec;
378}
YOSHIFUJI Hideaki7c3f9442008-04-21 19:45:12 -0700379EXPORT_SYMBOL(set_normalized_timespec);
Thomas Gleixner753be622006-01-09 20:52:22 -0800380
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800381/**
382 * ns_to_timespec - Convert nanoseconds to timespec
383 * @nsec: the nanoseconds value to be converted
384 *
385 * Returns the timespec representation of the nsec parameter.
386 */
Roman Zippeldf869b62006-03-26 01:38:11 -0800387struct timespec ns_to_timespec(const s64 nsec)
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800388{
389 struct timespec ts;
Roman Zippelf8bd2252008-05-01 04:34:31 -0700390 s32 rem;
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800391
George Anzinger88fc3892006-02-03 03:04:20 -0800392 if (!nsec)
393 return (struct timespec) {0, 0};
394
Roman Zippelf8bd2252008-05-01 04:34:31 -0700395 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
396 if (unlikely(rem < 0)) {
397 ts.tv_sec--;
398 rem += NSEC_PER_SEC;
399 }
400 ts.tv_nsec = rem;
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800401
402 return ts;
403}
Stephen Hemminger85795d62007-03-24 21:35:33 -0700404EXPORT_SYMBOL(ns_to_timespec);
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800405
406/**
407 * ns_to_timeval - Convert nanoseconds to timeval
408 * @nsec: the nanoseconds value to be converted
409 *
410 * Returns the timeval representation of the nsec parameter.
411 */
Roman Zippeldf869b62006-03-26 01:38:11 -0800412struct timeval ns_to_timeval(const s64 nsec)
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800413{
414 struct timespec ts = ns_to_timespec(nsec);
415 struct timeval tv;
416
417 tv.tv_sec = ts.tv_sec;
418 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
419
420 return tv;
421}
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -0700422EXPORT_SYMBOL(ns_to_timeval);
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800423
John Stultz49cd6f82014-07-16 21:03:59 +0000424#if BITS_PER_LONG == 32
425/**
426 * set_normalized_timespec - set timespec sec and nsec parts and normalize
427 *
428 * @ts: pointer to timespec variable to be set
429 * @sec: seconds to set
430 * @nsec: nanoseconds to set
431 *
432 * Set seconds and nanoseconds field of a timespec variable and
433 * normalize to the timespec storage format
434 *
435 * Note: The tv_nsec part is always in the range of
436 * 0 <= tv_nsec < NSEC_PER_SEC
437 * For negative values only the tv_sec field is negative !
438 */
439void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec)
440{
441 while (nsec >= NSEC_PER_SEC) {
442 /*
443 * The following asm() prevents the compiler from
444 * optimising this loop into a modulo operation. See
445 * also __iter_div_u64_rem() in include/linux/time.h
446 */
447 asm("" : "+rm"(nsec));
448 nsec -= NSEC_PER_SEC;
449 ++sec;
450 }
451 while (nsec < 0) {
452 asm("" : "+rm"(nsec));
453 nsec += NSEC_PER_SEC;
454 --sec;
455 }
456 ts->tv_sec = sec;
457 ts->tv_nsec = nsec;
458}
459EXPORT_SYMBOL(set_normalized_timespec64);
460
461/**
462 * ns_to_timespec64 - Convert nanoseconds to timespec64
463 * @nsec: the nanoseconds value to be converted
464 *
465 * Returns the timespec64 representation of the nsec parameter.
466 */
467struct timespec64 ns_to_timespec64(const s64 nsec)
468{
469 struct timespec64 ts;
470 s32 rem;
471
472 if (!nsec)
473 return (struct timespec64) {0, 0};
474
475 ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
476 if (unlikely(rem < 0)) {
477 ts.tv_sec--;
478 rem += NSEC_PER_SEC;
479 }
480 ts.tv_nsec = rem;
481
482 return ts;
483}
484EXPORT_SYMBOL(ns_to_timespec64);
485#endif
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800486/*
Ingo Molnar41cf5442007-02-16 01:27:28 -0800487 * When we convert to jiffies then we interpret incoming values
488 * the following way:
489 *
490 * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
491 *
492 * - 'too large' values [that would result in larger than
493 * MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
494 *
495 * - all other values are converted to jiffies by either multiplying
496 * the input value by a factor or dividing it with a factor
497 *
498 * We must also be careful about 32-bit overflows.
499 */
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800500unsigned long msecs_to_jiffies(const unsigned int m)
501{
Ingo Molnar41cf5442007-02-16 01:27:28 -0800502 /*
503 * Negative value, means infinite timeout:
504 */
505 if ((int)m < 0)
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800506 return MAX_JIFFY_OFFSET;
Ingo Molnar41cf5442007-02-16 01:27:28 -0800507
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800508#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
Ingo Molnar41cf5442007-02-16 01:27:28 -0800509 /*
510 * HZ is equal to or smaller than 1000, and 1000 is a nice
511 * round multiple of HZ, divide with the factor between them,
512 * but round upwards:
513 */
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800514 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
515#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
Ingo Molnar41cf5442007-02-16 01:27:28 -0800516 /*
517 * HZ is larger than 1000, and HZ is a nice round multiple of
518 * 1000 - simply multiply with the factor between them.
519 *
520 * But first make sure the multiplication result cannot
521 * overflow:
522 */
523 if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
524 return MAX_JIFFY_OFFSET;
525
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800526 return m * (HZ / MSEC_PER_SEC);
527#else
Ingo Molnar41cf5442007-02-16 01:27:28 -0800528 /*
529 * Generic case - multiply, round and divide. But first
530 * check that if we are doing a net multiplication, that
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800531 * we wouldn't overflow:
Ingo Molnar41cf5442007-02-16 01:27:28 -0800532 */
533 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
534 return MAX_JIFFY_OFFSET;
535
H. Peter Anvinb9095fd2008-05-02 16:18:42 -0700536 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800537 >> MSEC_TO_HZ_SHR32;
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800538#endif
539}
540EXPORT_SYMBOL(msecs_to_jiffies);
541
542unsigned long usecs_to_jiffies(const unsigned int u)
543{
544 if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
545 return MAX_JIFFY_OFFSET;
546#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
547 return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
548#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
549 return u * (HZ / USEC_PER_SEC);
550#else
H. Peter Anvinb9095fd2008-05-02 16:18:42 -0700551 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
H. Peter Anvinbdc80782008-02-08 04:21:26 -0800552 >> USEC_TO_HZ_SHR32;
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800553#endif
554}
555EXPORT_SYMBOL(usecs_to_jiffies);
556
557/*
558 * The TICK_NSEC - 1 rounds up the value to the next resolution. Note
559 * that a remainder subtract here would not do the right thing as the
560 * resolution values don't fall on second boundries. I.e. the line:
561 * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
562 *
563 * Rather, we just shift the bits off the right.
564 *
565 * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
566 * value to a scaled second value.
567 */
568unsigned long
569timespec_to_jiffies(const struct timespec *value)
570{
571 unsigned long sec = value->tv_sec;
572 long nsec = value->tv_nsec + TICK_NSEC - 1;
573
574 if (sec >= MAX_SEC_IN_JIFFIES){
575 sec = MAX_SEC_IN_JIFFIES;
576 nsec = 0;
577 }
578 return (((u64)sec * SEC_CONVERSION) +
579 (((u64)nsec * NSEC_CONVERSION) >>
580 (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
581
582}
583EXPORT_SYMBOL(timespec_to_jiffies);
584
585void
586jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
587{
588 /*
589 * Convert jiffies to nanoseconds and separate with
590 * one divide.
591 */
Roman Zippelf8bd2252008-05-01 04:34:31 -0700592 u32 rem;
593 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
594 NSEC_PER_SEC, &rem);
595 value->tv_nsec = rem;
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800596}
597EXPORT_SYMBOL(jiffies_to_timespec);
598
599/* Same for "timeval"
600 *
601 * Well, almost. The problem here is that the real system resolution is
602 * in nanoseconds and the value being converted is in micro seconds.
603 * Also for some machines (those that use HZ = 1024, in-particular),
604 * there is a LARGE error in the tick size in microseconds.
605
606 * The solution we use is to do the rounding AFTER we convert the
607 * microsecond part. Thus the USEC_ROUND, the bits to be shifted off.
608 * Instruction wise, this should cost only an additional add with carry
609 * instruction above the way it was done above.
610 */
611unsigned long
612timeval_to_jiffies(const struct timeval *value)
613{
614 unsigned long sec = value->tv_sec;
615 long usec = value->tv_usec;
616
617 if (sec >= MAX_SEC_IN_JIFFIES){
618 sec = MAX_SEC_IN_JIFFIES;
619 usec = 0;
620 }
621 return (((u64)sec * SEC_CONVERSION) +
622 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
623 (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
624}
Thomas Bittermann456a09d2007-04-04 22:20:54 +0200625EXPORT_SYMBOL(timeval_to_jiffies);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800626
627void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
628{
629 /*
630 * Convert jiffies to nanoseconds and separate with
631 * one divide.
632 */
Roman Zippelf8bd2252008-05-01 04:34:31 -0700633 u32 rem;
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800634
Roman Zippelf8bd2252008-05-01 04:34:31 -0700635 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
636 NSEC_PER_SEC, &rem);
637 value->tv_usec = rem / NSEC_PER_USEC;
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800638}
Thomas Bittermann456a09d2007-04-04 22:20:54 +0200639EXPORT_SYMBOL(jiffies_to_timeval);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800640
641/*
642 * Convert jiffies/jiffies_64 to clock_t and back.
643 */
hankcbbc7192011-09-20 13:53:39 -0700644clock_t jiffies_to_clock_t(unsigned long x)
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800645{
646#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
David Fries6ffc7872008-02-06 01:38:04 -0800647# if HZ < USER_HZ
648 return x * (USER_HZ / HZ);
649# else
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800650 return x / (HZ / USER_HZ);
David Fries6ffc7872008-02-06 01:38:04 -0800651# endif
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800652#else
Roman Zippel71abb3a2008-05-01 04:34:26 -0700653 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800654#endif
655}
656EXPORT_SYMBOL(jiffies_to_clock_t);
657
658unsigned long clock_t_to_jiffies(unsigned long x)
659{
660#if (HZ % USER_HZ)==0
661 if (x >= ~0UL / (HZ / USER_HZ))
662 return ~0UL;
663 return x * (HZ / USER_HZ);
664#else
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800665 /* Don't worry about loss of precision here .. */
666 if (x >= ~0UL / HZ * USER_HZ)
667 return ~0UL;
668
669 /* .. but do try to contain it here */
Roman Zippel71abb3a2008-05-01 04:34:26 -0700670 return div_u64((u64)x * HZ, USER_HZ);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800671#endif
672}
673EXPORT_SYMBOL(clock_t_to_jiffies);
674
675u64 jiffies_64_to_clock_t(u64 x)
676{
677#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
David Fries6ffc7872008-02-06 01:38:04 -0800678# if HZ < USER_HZ
Roman Zippel71abb3a2008-05-01 04:34:26 -0700679 x = div_u64(x * USER_HZ, HZ);
Andrew Mortonec03d702008-02-06 01:38:06 -0800680# elif HZ > USER_HZ
Roman Zippel71abb3a2008-05-01 04:34:26 -0700681 x = div_u64(x, HZ / USER_HZ);
Andrew Mortonec03d702008-02-06 01:38:06 -0800682# else
683 /* Nothing to do */
David Fries6ffc7872008-02-06 01:38:04 -0800684# endif
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800685#else
686 /*
687 * There are better ways that don't overflow early,
688 * but even this doesn't overflow in hundreds of years
689 * in 64 bits, so..
690 */
Roman Zippel71abb3a2008-05-01 04:34:26 -0700691 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800692#endif
693 return x;
694}
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800695EXPORT_SYMBOL(jiffies_64_to_clock_t);
696
697u64 nsec_to_clock_t(u64 x)
698{
699#if (NSEC_PER_SEC % USER_HZ) == 0
Roman Zippel71abb3a2008-05-01 04:34:26 -0700700 return div_u64(x, NSEC_PER_SEC / USER_HZ);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800701#elif (USER_HZ % 512) == 0
Roman Zippel71abb3a2008-05-01 04:34:26 -0700702 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800703#else
704 /*
705 * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
706 * overflow after 64.99 years.
707 * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
708 */
Roman Zippel71abb3a2008-05-01 04:34:26 -0700709 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800710#endif
Ingo Molnar8b9365d2007-02-16 01:27:27 -0800711}
712
Hidetoshi Setob7b20df92009-11-26 14:49:27 +0900713/**
Venkatesh Pallipadia1dabb62010-12-21 17:09:01 -0800714 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64
Hidetoshi Setob7b20df92009-11-26 14:49:27 +0900715 *
716 * @n: nsecs in u64
717 *
718 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
719 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
720 * for scheduler, not for use in device drivers to calculate timeout value.
721 *
722 * note:
723 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
724 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
725 */
Venkatesh Pallipadia1dabb62010-12-21 17:09:01 -0800726u64 nsecs_to_jiffies64(u64 n)
Hidetoshi Setob7b20df92009-11-26 14:49:27 +0900727{
728#if (NSEC_PER_SEC % HZ) == 0
729 /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
730 return div_u64(n, NSEC_PER_SEC / HZ);
731#elif (HZ % 512) == 0
732 /* overflow after 292 years if HZ = 1024 */
733 return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
734#else
735 /*
736 * Generic case - optimized for cases where HZ is a multiple of 3.
737 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
738 */
739 return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
740#endif
741}
742
Venkatesh Pallipadia1dabb62010-12-21 17:09:01 -0800743/**
744 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
745 *
746 * @n: nsecs in u64
747 *
748 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
749 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
750 * for scheduler, not for use in device drivers to calculate timeout value.
751 *
752 * note:
753 * NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
754 * ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
755 */
756unsigned long nsecs_to_jiffies(u64 n)
757{
758 return (unsigned long)nsecs_to_jiffies64(n);
759}
Thomas Gleixnerd560fed2014-07-16 21:04:31 +0000760EXPORT_SYMBOL_GPL(nsecs_to_jiffies);
Venkatesh Pallipadia1dabb62010-12-21 17:09:01 -0800761
Thomas Gleixnerdf0cc052008-08-31 08:09:53 -0700762/*
763 * Add two timespec values and do a safety check for overflow.
764 * It's assumed that both values are valid (>= 0)
765 */
766struct timespec timespec_add_safe(const struct timespec lhs,
767 const struct timespec rhs)
768{
769 struct timespec res;
770
771 set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
772 lhs.tv_nsec + rhs.tv_nsec);
773
774 if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
775 res.tv_sec = TIME_T_MAX;
776
777 return res;
778}