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