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