KVM: Timer event should not unconditionally unhalt vcpu.
[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         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, 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  */
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  */
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  */
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
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
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
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
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
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  */
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
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
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
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)
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  */
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 }