[PATCH] hrtimer: deinline mktime and set_normalized_timespec
[linux-3.10.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 (unsigned int year, unsigned int mon,
603         unsigned int day, unsigned int hour,
604         unsigned int min, unsigned int sec)
605 {
606         if (0 >= (int) (mon -= 2)) {    /* 1..12 -> 11,12,1..10 */
607                 mon += 12;              /* Puts Feb last since it has leap day */
608                 year -= 1;
609         }
610
611         return ((((unsigned long)
612                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
613                   year*365 - 719499
614             )*24 + hour /* now have hours */
615           )*60 + min /* now have minutes */
616         )*60 + sec; /* finally seconds */
617 }
618
619 /**
620  * set_normalized_timespec - set timespec sec and nsec parts and normalize
621  *
622  * @ts:         pointer to timespec variable to be set
623  * @sec:        seconds to set
624  * @nsec:       nanoseconds to set
625  *
626  * Set seconds and nanoseconds field of a timespec variable and
627  * normalize to the timespec storage format
628  *
629  * Note: The tv_nsec part is always in the range of
630  *      0 <= tv_nsec < NSEC_PER_SEC
631  * For negative values only the tv_sec field is negative !
632  */
633 void set_normalized_timespec (struct timespec *ts, time_t sec, long nsec)
634 {
635         while (nsec >= NSEC_PER_SEC) {
636                 nsec -= NSEC_PER_SEC;
637                 ++sec;
638         }
639         while (nsec < 0) {
640                 nsec += NSEC_PER_SEC;
641                 --sec;
642         }
643         ts->tv_sec = sec;
644         ts->tv_nsec = nsec;
645 }
646
647 #if (BITS_PER_LONG < 64)
648 u64 get_jiffies_64(void)
649 {
650         unsigned long seq;
651         u64 ret;
652
653         do {
654                 seq = read_seqbegin(&xtime_lock);
655                 ret = jiffies_64;
656         } while (read_seqretry(&xtime_lock, seq));
657         return ret;
658 }
659
660 EXPORT_SYMBOL(get_jiffies_64);
661 #endif
662
663 EXPORT_SYMBOL(jiffies);