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.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/module.h>
31 #include <linux/timex.h>
32 #include <linux/capability.h>
33 #include <linux/clocksource.h>
34 #include <linux/errno.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.h>
37 #include <linux/fs.h>
38 #include <linux/slab.h>
39 #include <linux/math64.h>
40 #include <linux/ptrace.h>
41
42 #include <asm/uaccess.h>
43 #include <asm/unistd.h>
44
45 #include "timeconst.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 * Adjust the time obtained from the CMOS to be UTC time instead of
120 * local time.
121 *
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
124 * confusion if the program gets run more than once; it would also be
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 *
128 * - TYT, 1992-01-01
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 */
warp_clock(void)134 static inline void warp_clock(void)
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;
139 update_xtime_cache(0);
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
do_sys_settimeofday(struct timespec * tv,struct timezone * tz)155 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
156 {
157 static int firsttime = 1;
158 int error = 0;
159
160 if (tv && !timespec_valid(tv))
161 return -EINVAL;
162
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;
170 update_vsyscall_tz();
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
SYSCALL_DEFINE2(settimeofday,struct timeval __user *,tv,struct timezone __user *,tz)187 SYSCALL_DEFINE2(settimeofday, struct timeval __user *, tv,
188 struct timezone __user *, tz)
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
SYSCALL_DEFINE1(adjtimex,struct timex __user *,txc_p)208 SYSCALL_DEFINE1(adjtimex, struct timex __user *, txc_p)
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
223 /**
224 * current_fs_time - Return FS time
225 * @sb: Superblock.
226 *
227 * Return the current time truncated to the time granularity supported by
228 * the fs.
229 */
current_fs_time(struct super_block * sb)230 struct 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 }
235 EXPORT_SYMBOL(current_fs_time);
236
237 /*
238 * Convert jiffies to milliseconds and back.
239 *
240 * Avoid unnecessary multiplications/divisions in the
241 * two most common HZ cases:
242 */
jiffies_to_msecs(const unsigned long j)243 unsigned 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
250 # if BITS_PER_LONG == 32
251 return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;
252 # else
253 return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;
254 # endif
255 #endif
256 }
257 EXPORT_SYMBOL(jiffies_to_msecs);
258
jiffies_to_usecs(const unsigned long j)259 unsigned 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
266 # if BITS_PER_LONG == 32
267 return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;
268 # else
269 return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;
270 # endif
271 #endif
272 }
273 EXPORT_SYMBOL(jiffies_to_usecs);
274
275 /**
276 * timespec_trunc - Truncate timespec to a granularity
277 * @t: Timespec
278 * @gran: Granularity in ns.
279 *
280 * Truncate a timespec to a granularity. gran must be smaller than a second.
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
285 * it doesn't handle the better resolution of the latter.
286 */
timespec_trunc(struct timespec t,unsigned gran)287 struct 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 }
303 EXPORT_SYMBOL(timespec_trunc);
304
305 #ifndef CONFIG_GENERIC_TIME
306 /*
307 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
308 * and therefore only yields usec accuracy
309 */
getnstimeofday(struct timespec * tv)310 void 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 }
318 EXPORT_SYMBOL_GPL(getnstimeofday);
319 #endif
320
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
333 * machines where long is 32-bit! (However, as time_t is signed, we
334 * will already get problems at other places on 2038-01-19 03:14:08)
335 */
336 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)337 mktime(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)
340 {
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 */
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
357 EXPORT_SYMBOL(mktime);
358
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
370 * 0 <= tv_nsec < NSEC_PER_SEC
371 * For negative values only the tv_sec field is negative !
372 */
set_normalized_timespec(struct timespec * ts,time_t sec,long nsec)373 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
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 }
386 EXPORT_SYMBOL(set_normalized_timespec);
387
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 */
ns_to_timespec(const s64 nsec)394 struct timespec ns_to_timespec(const s64 nsec)
395 {
396 struct timespec ts;
397 s32 rem;
398
399 if (!nsec)
400 return (struct timespec) {0, 0};
401
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;
408
409 return ts;
410 }
411 EXPORT_SYMBOL(ns_to_timespec);
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 */
ns_to_timeval(const s64 nsec)419 struct timeval ns_to_timeval(const s64 nsec)
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 }
429 EXPORT_SYMBOL(ns_to_timeval);
430
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 */
msecs_to_jiffies(const unsigned int m)445 unsigned long msecs_to_jiffies(const unsigned int m)
446 {
447 /*
448 * Negative value, means infinite timeout:
449 */
450 if ((int)m < 0)
451 return MAX_JIFFY_OFFSET;
452
453 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
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 */
459 return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
460 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
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
471 return m * (HZ / MSEC_PER_SEC);
472 #else
473 /*
474 * Generic case - multiply, round and divide. But first
475 * check that if we are doing a net multiplication, that
476 * we wouldn't overflow:
477 */
478 if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
479 return MAX_JIFFY_OFFSET;
480
481 return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
482 >> MSEC_TO_HZ_SHR32;
483 #endif
484 }
485 EXPORT_SYMBOL(msecs_to_jiffies);
486
usecs_to_jiffies(const unsigned int u)487 unsigned 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
496 return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
497 >> USEC_TO_HZ_SHR32;
498 #endif
499 }
500 EXPORT_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 */
513 unsigned long
timespec_to_jiffies(const struct timespec * value)514 timespec_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 }
528 EXPORT_SYMBOL(timespec_to_jiffies);
529
530 void
jiffies_to_timespec(const unsigned long jiffies,struct timespec * value)531 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
532 {
533 /*
534 * Convert jiffies to nanoseconds and separate with
535 * one divide.
536 */
537 u32 rem;
538 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
539 NSEC_PER_SEC, &rem);
540 value->tv_nsec = rem;
541 }
542 EXPORT_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 */
556 unsigned long
timeval_to_jiffies(const struct timeval * value)557 timeval_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 }
570 EXPORT_SYMBOL(timeval_to_jiffies);
571
jiffies_to_timeval(const unsigned long jiffies,struct timeval * value)572 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
573 {
574 /*
575 * Convert jiffies to nanoseconds and separate with
576 * one divide.
577 */
578 u32 rem;
579
580 value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
581 NSEC_PER_SEC, &rem);
582 value->tv_usec = rem / NSEC_PER_USEC;
583 }
584 EXPORT_SYMBOL(jiffies_to_timeval);
585
586 /*
587 * Convert jiffies/jiffies_64 to clock_t and back.
588 */
jiffies_to_clock_t(long x)589 clock_t jiffies_to_clock_t(long x)
590 {
591 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
592 # if HZ < USER_HZ
593 return x * (USER_HZ / HZ);
594 # else
595 return x / (HZ / USER_HZ);
596 # endif
597 #else
598 return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
599 #endif
600 }
601 EXPORT_SYMBOL(jiffies_to_clock_t);
602
clock_t_to_jiffies(unsigned long x)603 unsigned 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
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 */
615 return div_u64((u64)x * HZ, USER_HZ);
616 #endif
617 }
618 EXPORT_SYMBOL(clock_t_to_jiffies);
619
jiffies_64_to_clock_t(u64 x)620 u64 jiffies_64_to_clock_t(u64 x)
621 {
622 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
623 # if HZ < USER_HZ
624 x = div_u64(x * USER_HZ, HZ);
625 # elif HZ > USER_HZ
626 x = div_u64(x, HZ / USER_HZ);
627 # else
628 /* Nothing to do */
629 # endif
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 */
636 x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
637 #endif
638 return x;
639 }
640 EXPORT_SYMBOL(jiffies_64_to_clock_t);
641
nsec_to_clock_t(u64 x)642 u64 nsec_to_clock_t(u64 x)
643 {
644 #if (NSEC_PER_SEC % USER_HZ) == 0
645 return div_u64(x, NSEC_PER_SEC / USER_HZ);
646 #elif (USER_HZ % 512) == 0
647 return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
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 */
654 return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
655 #endif
656 }
657
658 #if (BITS_PER_LONG < 64)
get_jiffies_64(void)659 u64 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 }
670 EXPORT_SYMBOL(get_jiffies_64);
671 #endif
672
673 EXPORT_SYMBOL(jiffies);
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 */
timespec_add_safe(const struct timespec lhs,const struct timespec rhs)679 struct 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 }
692