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