Linux/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         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 
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 
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 
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  */
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  */
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 
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  */
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  */
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
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  */
373 void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)
374 {
375         while (nsec >= NSEC_PER_SEC) {
376                 /*
377                  * The following asm() prevents the compiler from
378                  * optimising this loop into a modulo operation. See
379                  * also __iter_div_u64_rem() in include/linux/time.h
380                  */
381                 asm("" : "+rm"(nsec));
382                 nsec -= NSEC_PER_SEC;
383                 ++sec;
384         }
385         while (nsec < 0) {
386                 asm("" : "+rm"(nsec));
387                 nsec += NSEC_PER_SEC;
388                 --sec;
389         }
390         ts->tv_sec = sec;
391         ts->tv_nsec = nsec;
392 }
393 EXPORT_SYMBOL(set_normalized_timespec);
394 
395 /**
396  * ns_to_timespec - Convert nanoseconds to timespec
397  * @nsec:       the nanoseconds value to be converted
398  *
399  * Returns the timespec representation of the nsec parameter.
400  */
401 struct timespec ns_to_timespec(const s64 nsec)
402 {
403         struct timespec ts;
404         s32 rem;
405 
406         if (!nsec)
407                 return (struct timespec) {0, 0};
408 
409         ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);
410         if (unlikely(rem < 0)) {
411                 ts.tv_sec--;
412                 rem += NSEC_PER_SEC;
413         }
414         ts.tv_nsec = rem;
415 
416         return ts;
417 }
418 EXPORT_SYMBOL(ns_to_timespec);
419 
420 /**
421  * ns_to_timeval - Convert nanoseconds to timeval
422  * @nsec:       the nanoseconds value to be converted
423  *
424  * Returns the timeval representation of the nsec parameter.
425  */
426 struct timeval ns_to_timeval(const s64 nsec)
427 {
428         struct timespec ts = ns_to_timespec(nsec);
429         struct timeval tv;
430 
431         tv.tv_sec = ts.tv_sec;
432         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
433 
434         return tv;
435 }
436 EXPORT_SYMBOL(ns_to_timeval);
437 
438 /*
439  * When we convert to jiffies then we interpret incoming values
440  * the following way:
441  *
442  * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
443  *
444  * - 'too large' values [that would result in larger than
445  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
446  *
447  * - all other values are converted to jiffies by either multiplying
448  *   the input value by a factor or dividing it with a factor
449  *
450  * We must also be careful about 32-bit overflows.
451  */
452 unsigned long msecs_to_jiffies(const unsigned int m)
453 {
454         /*
455          * Negative value, means infinite timeout:
456          */
457         if ((int)m < 0)
458                 return MAX_JIFFY_OFFSET;
459 
460 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
461         /*
462          * HZ is equal to or smaller than 1000, and 1000 is a nice
463          * round multiple of HZ, divide with the factor between them,
464          * but round upwards:
465          */
466         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
467 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
468         /*
469          * HZ is larger than 1000, and HZ is a nice round multiple of
470          * 1000 - simply multiply with the factor between them.
471          *
472          * But first make sure the multiplication result cannot
473          * overflow:
474          */
475         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
476                 return MAX_JIFFY_OFFSET;
477 
478         return m * (HZ / MSEC_PER_SEC);
479 #else
480         /*
481          * Generic case - multiply, round and divide. But first
482          * check that if we are doing a net multiplication, that
483          * we wouldn't overflow:
484          */
485         if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
486                 return MAX_JIFFY_OFFSET;
487 
488         return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)
489                 >> MSEC_TO_HZ_SHR32;
490 #endif
491 }
492 EXPORT_SYMBOL(msecs_to_jiffies);
493 
494 unsigned long usecs_to_jiffies(const unsigned int u)
495 {
496         if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
497                 return MAX_JIFFY_OFFSET;
498 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
499         return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
500 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
501         return u * (HZ / USEC_PER_SEC);
502 #else
503         return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
504                 >> USEC_TO_HZ_SHR32;
505 #endif
506 }
507 EXPORT_SYMBOL(usecs_to_jiffies);
508 
509 /*
510  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
511  * that a remainder subtract here would not do the right thing as the
512  * resolution values don't fall on second boundries.  I.e. the line:
513  * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
514  *
515  * Rather, we just shift the bits off the right.
516  *
517  * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
518  * value to a scaled second value.
519  */
520 unsigned long
521 timespec_to_jiffies(const struct timespec *value)
522 {
523         unsigned long sec = value->tv_sec;
524         long nsec = value->tv_nsec + TICK_NSEC - 1;
525 
526         if (sec >= MAX_SEC_IN_JIFFIES){
527                 sec = MAX_SEC_IN_JIFFIES;
528                 nsec = 0;
529         }
530         return (((u64)sec * SEC_CONVERSION) +
531                 (((u64)nsec * NSEC_CONVERSION) >>
532                  (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
533 
534 }
535 EXPORT_SYMBOL(timespec_to_jiffies);
536 
537 void
538 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
539 {
540         /*
541          * Convert jiffies to nanoseconds and separate with
542          * one divide.
543          */
544         u32 rem;
545         value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
546                                     NSEC_PER_SEC, &rem);
547         value->tv_nsec = rem;
548 }
549 EXPORT_SYMBOL(jiffies_to_timespec);
550 
551 /* Same for "timeval"
552  *
553  * Well, almost.  The problem here is that the real system resolution is
554  * in nanoseconds and the value being converted is in micro seconds.
555  * Also for some machines (those that use HZ = 1024, in-particular),
556  * there is a LARGE error in the tick size in microseconds.
557 
558  * The solution we use is to do the rounding AFTER we convert the
559  * microsecond part.  Thus the USEC_ROUND, the bits to be shifted off.
560  * Instruction wise, this should cost only an additional add with carry
561  * instruction above the way it was done above.
562  */
563 unsigned long
564 timeval_to_jiffies(const struct timeval *value)
565 {
566         unsigned long sec = value->tv_sec;
567         long usec = value->tv_usec;
568 
569         if (sec >= MAX_SEC_IN_JIFFIES){
570                 sec = MAX_SEC_IN_JIFFIES;
571                 usec = 0;
572         }
573         return (((u64)sec * SEC_CONVERSION) +
574                 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
575                  (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
576 }
577 EXPORT_SYMBOL(timeval_to_jiffies);
578 
579 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
580 {
581         /*
582          * Convert jiffies to nanoseconds and separate with
583          * one divide.
584          */
585         u32 rem;
586 
587         value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,
588                                     NSEC_PER_SEC, &rem);
589         value->tv_usec = rem / NSEC_PER_USEC;
590 }
591 EXPORT_SYMBOL(jiffies_to_timeval);
592 
593 /*
594  * Convert jiffies/jiffies_64 to clock_t and back.
595  */
596 clock_t jiffies_to_clock_t(long x)
597 {
598 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
599 # if HZ < USER_HZ
600         return x * (USER_HZ / HZ);
601 # else
602         return x / (HZ / USER_HZ);
603 # endif
604 #else
605         return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
606 #endif
607 }
608 EXPORT_SYMBOL(jiffies_to_clock_t);
609 
610 unsigned long clock_t_to_jiffies(unsigned long x)
611 {
612 #if (HZ % USER_HZ)==0
613         if (x >= ~0UL / (HZ / USER_HZ))
614                 return ~0UL;
615         return x * (HZ / USER_HZ);
616 #else
617         /* Don't worry about loss of precision here .. */
618         if (x >= ~0UL / HZ * USER_HZ)
619                 return ~0UL;
620 
621         /* .. but do try to contain it here */
622         return div_u64((u64)x * HZ, USER_HZ);
623 #endif
624 }
625 EXPORT_SYMBOL(clock_t_to_jiffies);
626 
627 u64 jiffies_64_to_clock_t(u64 x)
628 {
629 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
630 # if HZ < USER_HZ
631         x = div_u64(x * USER_HZ, HZ);
632 # elif HZ > USER_HZ
633         x = div_u64(x, HZ / USER_HZ);
634 # else
635         /* Nothing to do */
636 # endif
637 #else
638         /*
639          * There are better ways that don't overflow early,
640          * but even this doesn't overflow in hundreds of years
641          * in 64 bits, so..
642          */
643         x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
644 #endif
645         return x;
646 }
647 EXPORT_SYMBOL(jiffies_64_to_clock_t);
648 
649 u64 nsec_to_clock_t(u64 x)
650 {
651 #if (NSEC_PER_SEC % USER_HZ) == 0
652         return div_u64(x, NSEC_PER_SEC / USER_HZ);
653 #elif (USER_HZ % 512) == 0
654         return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
655 #else
656         /*
657          * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
658          * overflow after 64.99 years.
659          * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
660          */
661         return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
662 #endif
663 }
664 
665 /**
666  * nsecs_to_jiffies - Convert nsecs in u64 to jiffies
667  *
668  * @n:  nsecs in u64
669  *
670  * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.
671  * And this doesn't return MAX_JIFFY_OFFSET since this function is designed
672  * for scheduler, not for use in device drivers to calculate timeout value.
673  *
674  * note:
675  *   NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)
676  *   ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years
677  */
678 unsigned long nsecs_to_jiffies(u64 n)
679 {
680 #if (NSEC_PER_SEC % HZ) == 0
681         /* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */
682         return div_u64(n, NSEC_PER_SEC / HZ);
683 #elif (HZ % 512) == 0
684         /* overflow after 292 years if HZ = 1024 */
685         return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);
686 #else
687         /*
688          * Generic case - optimized for cases where HZ is a multiple of 3.
689          * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.
690          */
691         return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);
692 #endif
693 }
694 
695 #if (BITS_PER_LONG < 64)
696 u64 get_jiffies_64(void)
697 {
698         unsigned long seq;
699         u64 ret;
700 
701         do {
702                 seq = read_seqbegin(&xtime_lock);
703                 ret = jiffies_64;
704         } while (read_seqretry(&xtime_lock, seq));
705         return ret;
706 }
707 EXPORT_SYMBOL(get_jiffies_64);
708 #endif
709 
710 EXPORT_SYMBOL(jiffies);
711 
712 /*
713  * Add two timespec values and do a safety check for overflow.
714  * It's assumed that both values are valid (>= 0)
715  */
716 struct timespec timespec_add_safe(const struct timespec lhs,
717                                   const struct timespec rhs)
718 {
719         struct timespec res;
720 
721         set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,
722                                 lhs.tv_nsec + rhs.tv_nsec);
723 
724         if (res.tv_sec < lhs.tv_sec || res.tv_sec < rhs.tv_sec)
725                 res.tv_sec = TIME_T_MAX;
726 
727         return res;
728 }
729 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us