[PATCH] hrtimer: validate timespec of do_sys_settimeofday
[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/errno.h>
33 #include <linux/smp_lock.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 (!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 long pps_offset;                /* pps time offset (us) */
205 long pps_jitter = MAXTIME;      /* time dispersion (jitter) (us) */
206
207 long pps_freq;                  /* frequency offset (scaled ppm) */
208 long pps_stabil = MAXFREQ;      /* frequency dispersion (scaled ppm) */
209
210 long pps_valid = PPS_VALID;     /* pps signal watchdog counter */
211
212 int pps_shift = PPS_SHIFT;      /* interval duration (s) (shift) */
213
214 long pps_jitcnt;                /* jitter limit exceeded */
215 long pps_calcnt;                /* calibration intervals */
216 long pps_errcnt;                /* calibration errors */
217 long pps_stbcnt;                /* stability limit exceeded */
218
219 /* hook for a loadable hardpps kernel module */
220 void (*hardpps_ptr)(struct timeval *);
221
222 /* we call this to notify the arch when the clock is being
223  * controlled.  If no such arch routine, do nothing.
224  */
225 void __attribute__ ((weak)) notify_arch_cmos_timer(void)
226 {
227         return;
228 }
229
230 /* adjtimex mainly allows reading (and writing, if superuser) of
231  * kernel time-keeping variables. used by xntpd.
232  */
233 int do_adjtimex(struct timex *txc)
234 {
235         long ltemp, mtemp, save_adjust;
236         int result;
237
238         /* In order to modify anything, you gotta be super-user! */
239         if (txc->modes && !capable(CAP_SYS_TIME))
240                 return -EPERM;
241                 
242         /* Now we validate the data before disabling interrupts */
243
244         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
245           /* singleshot must not be used with any other mode bits */
246                 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
247                         return -EINVAL;
248
249         if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
250           /* adjustment Offset limited to +- .512 seconds */
251                 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
252                         return -EINVAL; 
253
254         /* if the quartz is off by more than 10% something is VERY wrong ! */
255         if (txc->modes & ADJ_TICK)
256                 if (txc->tick <  900000/USER_HZ ||
257                     txc->tick > 1100000/USER_HZ)
258                         return -EINVAL;
259
260         write_seqlock_irq(&xtime_lock);
261         result = time_state;    /* mostly `TIME_OK' */
262
263         /* Save for later - semantics of adjtime is to return old value */
264         save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
265
266 #if 0   /* STA_CLOCKERR is never set yet */
267         time_status &= ~STA_CLOCKERR;           /* reset STA_CLOCKERR */
268 #endif
269         /* If there are input parameters, then process them */
270         if (txc->modes)
271         {
272             if (txc->modes & ADJ_STATUS)        /* only set allowed bits */
273                 time_status =  (txc->status & ~STA_RONLY) |
274                               (time_status & STA_RONLY);
275
276             if (txc->modes & ADJ_FREQUENCY) {   /* p. 22 */
277                 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
278                     result = -EINVAL;
279                     goto leave;
280                 }
281                 time_freq = txc->freq - pps_freq;
282             }
283
284             if (txc->modes & ADJ_MAXERROR) {
285                 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
286                     result = -EINVAL;
287                     goto leave;
288                 }
289                 time_maxerror = txc->maxerror;
290             }
291
292             if (txc->modes & ADJ_ESTERROR) {
293                 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
294                     result = -EINVAL;
295                     goto leave;
296                 }
297                 time_esterror = txc->esterror;
298             }
299
300             if (txc->modes & ADJ_TIMECONST) {   /* p. 24 */
301                 if (txc->constant < 0) {        /* NTP v4 uses values > 6 */
302                     result = -EINVAL;
303                     goto leave;
304                 }
305                 time_constant = txc->constant;
306             }
307
308             if (txc->modes & ADJ_OFFSET) {      /* values checked earlier */
309                 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
310                     /* adjtime() is independent from ntp_adjtime() */
311                     if ((time_next_adjust = txc->offset) == 0)
312                          time_adjust = 0;
313                 }
314                 else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
315                     ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
316                             (STA_PPSTIME | STA_PPSSIGNAL) ?
317                             pps_offset : txc->offset;
318
319                     /*
320                      * Scale the phase adjustment and
321                      * clamp to the operating range.
322                      */
323                     if (ltemp > MAXPHASE)
324                         time_offset = MAXPHASE << SHIFT_UPDATE;
325                     else if (ltemp < -MAXPHASE)
326                         time_offset = -(MAXPHASE << SHIFT_UPDATE);
327                     else
328                         time_offset = ltemp << SHIFT_UPDATE;
329
330                     /*
331                      * Select whether the frequency is to be controlled
332                      * and in which mode (PLL or FLL). Clamp to the operating
333                      * range. Ugly multiply/divide should be replaced someday.
334                      */
335
336                     if (time_status & STA_FREQHOLD || time_reftime == 0)
337                         time_reftime = xtime.tv_sec;
338                     mtemp = xtime.tv_sec - time_reftime;
339                     time_reftime = xtime.tv_sec;
340                     if (time_status & STA_FLL) {
341                         if (mtemp >= MINSEC) {
342                             ltemp = (time_offset / mtemp) << (SHIFT_USEC -
343                                                               SHIFT_UPDATE);
344                             time_freq += shift_right(ltemp, SHIFT_KH);
345                         } else /* calibration interval too short (p. 12) */
346                                 result = TIME_ERROR;
347                     } else {    /* PLL mode */
348                         if (mtemp < MAXSEC) {
349                             ltemp *= mtemp;
350                             time_freq += shift_right(ltemp,(time_constant +
351                                                        time_constant +
352                                                        SHIFT_KF - SHIFT_USEC));
353                         } else /* calibration interval too long (p. 12) */
354                                 result = TIME_ERROR;
355                     }
356                     time_freq = min(time_freq, time_tolerance);
357                     time_freq = max(time_freq, -time_tolerance);
358                 } /* STA_PLL || STA_PPSTIME */
359             } /* txc->modes & ADJ_OFFSET */
360             if (txc->modes & ADJ_TICK) {
361                 tick_usec = txc->tick;
362                 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
363             }
364         } /* txc->modes */
365 leave:  if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
366             || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
367                 && (time_status & STA_PPSSIGNAL) == 0)
368             /* p. 24, (b) */
369             || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
370                 == (STA_PPSTIME|STA_PPSJITTER))
371             /* p. 24, (c) */
372             || ((time_status & STA_PPSFREQ) != 0
373                 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
374             /* p. 24, (d) */
375                 result = TIME_ERROR;
376         
377         if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
378             txc->offset    = save_adjust;
379         else {
380             txc->offset = shift_right(time_offset, SHIFT_UPDATE);
381         }
382         txc->freq          = time_freq + pps_freq;
383         txc->maxerror      = time_maxerror;
384         txc->esterror      = time_esterror;
385         txc->status        = time_status;
386         txc->constant      = time_constant;
387         txc->precision     = time_precision;
388         txc->tolerance     = time_tolerance;
389         txc->tick          = tick_usec;
390         txc->ppsfreq       = pps_freq;
391         txc->jitter        = pps_jitter >> PPS_AVG;
392         txc->shift         = pps_shift;
393         txc->stabil        = pps_stabil;
394         txc->jitcnt        = pps_jitcnt;
395         txc->calcnt        = pps_calcnt;
396         txc->errcnt        = pps_errcnt;
397         txc->stbcnt        = pps_stbcnt;
398         write_sequnlock_irq(&xtime_lock);
399         do_gettimeofday(&txc->time);
400         notify_arch_cmos_timer();
401         return(result);
402 }
403
404 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
405 {
406         struct timex txc;               /* Local copy of parameter */
407         int ret;
408
409         /* Copy the user data space into the kernel copy
410          * structure. But bear in mind that the structures
411          * may change
412          */
413         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
414                 return -EFAULT;
415         ret = do_adjtimex(&txc);
416         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
417 }
418
419 inline struct timespec current_kernel_time(void)
420 {
421         struct timespec now;
422         unsigned long seq;
423
424         do {
425                 seq = read_seqbegin(&xtime_lock);
426                 
427                 now = xtime;
428         } while (read_seqretry(&xtime_lock, seq));
429
430         return now; 
431 }
432
433 EXPORT_SYMBOL(current_kernel_time);
434
435 /**
436  * current_fs_time - Return FS time
437  * @sb: Superblock.
438  *
439  * Return the current time truncated to the time granuality supported by
440  * the fs.
441  */
442 struct timespec current_fs_time(struct super_block *sb)
443 {
444         struct timespec now = current_kernel_time();
445         return timespec_trunc(now, sb->s_time_gran);
446 }
447 EXPORT_SYMBOL(current_fs_time);
448
449 /**
450  * timespec_trunc - Truncate timespec to a granuality
451  * @t: Timespec
452  * @gran: Granuality in ns.
453  *
454  * Truncate a timespec to a granuality. gran must be smaller than a second.
455  * Always rounds down.
456  *
457  * This function should be only used for timestamps returned by
458  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
459  * it doesn't handle the better resolution of the later.
460  */
461 struct timespec timespec_trunc(struct timespec t, unsigned gran)
462 {
463         /*
464          * Division is pretty slow so avoid it for common cases.
465          * Currently current_kernel_time() never returns better than
466          * jiffies resolution. Exploit that.
467          */
468         if (gran <= jiffies_to_usecs(1) * 1000) {
469                 /* nothing */
470         } else if (gran == 1000000000) {
471                 t.tv_nsec = 0;
472         } else {
473                 t.tv_nsec -= t.tv_nsec % gran;
474         }
475         return t;
476 }
477 EXPORT_SYMBOL(timespec_trunc);
478
479 #ifdef CONFIG_TIME_INTERPOLATION
480 void getnstimeofday (struct timespec *tv)
481 {
482         unsigned long seq,sec,nsec;
483
484         do {
485                 seq = read_seqbegin(&xtime_lock);
486                 sec = xtime.tv_sec;
487                 nsec = xtime.tv_nsec+time_interpolator_get_offset();
488         } while (unlikely(read_seqretry(&xtime_lock, seq)));
489
490         while (unlikely(nsec >= NSEC_PER_SEC)) {
491                 nsec -= NSEC_PER_SEC;
492                 ++sec;
493         }
494         tv->tv_sec = sec;
495         tv->tv_nsec = nsec;
496 }
497 EXPORT_SYMBOL_GPL(getnstimeofday);
498
499 int do_settimeofday (struct timespec *tv)
500 {
501         time_t wtm_sec, sec = tv->tv_sec;
502         long wtm_nsec, nsec = tv->tv_nsec;
503
504         if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
505                 return -EINVAL;
506
507         write_seqlock_irq(&xtime_lock);
508         {
509                 wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
510                 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
511
512                 set_normalized_timespec(&xtime, sec, nsec);
513                 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
514
515                 time_adjust = 0;                /* stop active adjtime() */
516                 time_status |= STA_UNSYNC;
517                 time_maxerror = NTP_PHASE_LIMIT;
518                 time_esterror = NTP_PHASE_LIMIT;
519                 time_interpolator_reset();
520         }
521         write_sequnlock_irq(&xtime_lock);
522         clock_was_set();
523         return 0;
524 }
525 EXPORT_SYMBOL(do_settimeofday);
526
527 void do_gettimeofday (struct timeval *tv)
528 {
529         unsigned long seq, nsec, usec, sec, offset;
530         do {
531                 seq = read_seqbegin(&xtime_lock);
532                 offset = time_interpolator_get_offset();
533                 sec = xtime.tv_sec;
534                 nsec = xtime.tv_nsec;
535         } while (unlikely(read_seqretry(&xtime_lock, seq)));
536
537         usec = (nsec + offset) / 1000;
538
539         while (unlikely(usec >= USEC_PER_SEC)) {
540                 usec -= USEC_PER_SEC;
541                 ++sec;
542         }
543
544         tv->tv_sec = sec;
545         tv->tv_usec = usec;
546 }
547
548 EXPORT_SYMBOL(do_gettimeofday);
549
550
551 #else
552 /*
553  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
554  * and therefore only yields usec accuracy
555  */
556 void getnstimeofday(struct timespec *tv)
557 {
558         struct timeval x;
559
560         do_gettimeofday(&x);
561         tv->tv_sec = x.tv_sec;
562         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
563 }
564 EXPORT_SYMBOL_GPL(getnstimeofday);
565 #endif
566
567 void getnstimestamp(struct timespec *ts)
568 {
569         unsigned int seq;
570         struct timespec wall2mono;
571
572         /* synchronize with settimeofday() changes */
573         do {
574                 seq = read_seqbegin(&xtime_lock);
575                 getnstimeofday(ts);
576                 wall2mono = wall_to_monotonic;
577         } while(unlikely(read_seqretry(&xtime_lock, seq)));
578
579         /* adjust to monotonicaly-increasing values */
580         ts->tv_sec += wall2mono.tv_sec;
581         ts->tv_nsec += wall2mono.tv_nsec;
582         while (unlikely(ts->tv_nsec >= NSEC_PER_SEC)) {
583                 ts->tv_nsec -= NSEC_PER_SEC;
584                 ts->tv_sec++;
585         }
586 }
587 EXPORT_SYMBOL_GPL(getnstimestamp);
588
589 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
590  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
591  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
592  *
593  * [For the Julian calendar (which was used in Russia before 1917,
594  * Britain & colonies before 1752, anywhere else before 1582,
595  * and is still in use by some communities) leave out the
596  * -year/100+year/400 terms, and add 10.]
597  *
598  * This algorithm was first published by Gauss (I think).
599  *
600  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
601  * machines were long is 32-bit! (However, as time_t is signed, we
602  * will already get problems at other places on 2038-01-19 03:14:08)
603  */
604 unsigned long
605 mktime(const unsigned int year0, const unsigned int mon0,
606        const unsigned int day, const unsigned int hour,
607        const unsigned int min, const unsigned int sec)
608 {
609         unsigned int mon = mon0, year = year0;
610
611         /* 1..12 -> 11,12,1..10 */
612         if (0 >= (int) (mon -= 2)) {
613                 mon += 12;      /* Puts Feb last since it has leap day */
614                 year -= 1;
615         }
616
617         return ((((unsigned long)
618                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
619                   year*365 - 719499
620             )*24 + hour /* now have hours */
621           )*60 + min /* now have minutes */
622         )*60 + sec; /* finally seconds */
623 }
624
625 EXPORT_SYMBOL(mktime);
626
627 /**
628  * set_normalized_timespec - set timespec sec and nsec parts and normalize
629  *
630  * @ts:         pointer to timespec variable to be set
631  * @sec:        seconds to set
632  * @nsec:       nanoseconds to set
633  *
634  * Set seconds and nanoseconds field of a timespec variable and
635  * normalize to the timespec storage format
636  *
637  * Note: The tv_nsec part is always in the range of
638  *      0 <= tv_nsec < NSEC_PER_SEC
639  * For negative values only the tv_sec field is negative !
640  */
641 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
642 {
643         while (nsec >= NSEC_PER_SEC) {
644                 nsec -= NSEC_PER_SEC;
645                 ++sec;
646         }
647         while (nsec < 0) {
648                 nsec += NSEC_PER_SEC;
649                 --sec;
650         }
651         ts->tv_sec = sec;
652         ts->tv_nsec = nsec;
653 }
654
655 #if (BITS_PER_LONG < 64)
656 u64 get_jiffies_64(void)
657 {
658         unsigned long seq;
659         u64 ret;
660
661         do {
662                 seq = read_seqbegin(&xtime_lock);
663                 ret = jiffies_64;
664         } while (read_seqretry(&xtime_lock, seq));
665         return ret;
666 }
667
668 EXPORT_SYMBOL(get_jiffies_64);
669 #endif
670
671 EXPORT_SYMBOL(jiffies);