time: fix typo in comments
[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
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 = get_seconds();
61
62         if (tloc) {
63                 if (put_user(i,tloc))
64                         i = -EFAULT;
65         }
66         return i;
67 }
68
69 /*
70  * sys_stime() can be implemented in user-level using
71  * sys_settimeofday().  Is this for backwards compatibility?  If so,
72  * why not move it into the appropriate arch directory (for those
73  * architectures that need it).
74  */
75
76 asmlinkage long sys_stime(time_t __user *tptr)
77 {
78         struct timespec tv;
79         int err;
80
81         if (get_user(tv.tv_sec, tptr))
82                 return -EFAULT;
83
84         tv.tv_nsec = 0;
85
86         err = security_settime(&tv, NULL);
87         if (err)
88                 return err;
89
90         do_settimeofday(&tv);
91         return 0;
92 }
93
94 #endif /* __ARCH_WANT_SYS_TIME */
95
96 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
97 {
98         if (likely(tv != NULL)) {
99                 struct timeval ktv;
100                 do_gettimeofday(&ktv);
101                 if (copy_to_user(tv, &ktv, sizeof(ktv)))
102                         return -EFAULT;
103         }
104         if (unlikely(tz != NULL)) {
105                 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
106                         return -EFAULT;
107         }
108         return 0;
109 }
110
111 /*
112  * Adjust the time obtained from the CMOS to be UTC time instead of
113  * local time.
114  *
115  * This is ugly, but preferable to the alternatives.  Otherwise we
116  * would either need to write a program to do it in /etc/rc (and risk
117  * confusion if the program gets run more than once; it would also be
118  * hard to make the program warp the clock precisely n hours)  or
119  * compile in the timezone information into the kernel.  Bad, bad....
120  *
121  *                                              - TYT, 1992-01-01
122  *
123  * The best thing to do is to keep the CMOS clock in universal time (UTC)
124  * as real UNIX machines always do it. This avoids all headaches about
125  * daylight saving times and warping kernel clocks.
126  */
127 static inline void warp_clock(void)
128 {
129         write_seqlock_irq(&xtime_lock);
130         wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
131         xtime.tv_sec += sys_tz.tz_minuteswest * 60;
132         update_xtime_cache(0);
133         write_sequnlock_irq(&xtime_lock);
134         clock_was_set();
135 }
136
137 /*
138  * In case for some reason the CMOS clock has not already been running
139  * in UTC, but in some local time: The first time we set the timezone,
140  * we will warp the clock so that it is ticking UTC time instead of
141  * local time. Presumably, if someone is setting the timezone then we
142  * are running in an environment where the programs understand about
143  * timezones. This should be done at boot time in the /etc/rc script,
144  * as soon as possible, so that the clock can be set right. Otherwise,
145  * various programs will get confused when the clock gets warped.
146  */
147
148 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
149 {
150         static int firsttime = 1;
151         int error = 0;
152
153         if (tv && !timespec_valid(tv))
154                 return -EINVAL;
155
156         error = security_settime(tv, tz);
157         if (error)
158                 return error;
159
160         if (tz) {
161                 /* SMP safe, global irq locking makes it work. */
162                 sys_tz = *tz;
163                 update_vsyscall_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 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
202 {
203         struct timex txc;               /* Local copy of parameter */
204         int ret;
205
206         /* Copy the user data space into the kernel copy
207          * structure. But bear in mind that the structures
208          * may change
209          */
210         if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
211                 return -EFAULT;
212         ret = do_adjtimex(&txc);
213         return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
214 }
215
216 /**
217  * current_fs_time - Return FS time
218  * @sb: Superblock.
219  *
220  * Return the current time truncated to the time granularity supported by
221  * the fs.
222  */
223 struct timespec current_fs_time(struct super_block *sb)
224 {
225         struct timespec now = current_kernel_time();
226         return timespec_trunc(now, sb->s_time_gran);
227 }
228 EXPORT_SYMBOL(current_fs_time);
229
230 /*
231  * Convert jiffies to milliseconds and back.
232  *
233  * Avoid unnecessary multiplications/divisions in the
234  * two most common HZ cases:
235  */
236 unsigned int inline jiffies_to_msecs(const unsigned long j)
237 {
238 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
239         return (MSEC_PER_SEC / HZ) * j;
240 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
241         return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);
242 #else
243         return (j * MSEC_PER_SEC) / HZ;
244 #endif
245 }
246 EXPORT_SYMBOL(jiffies_to_msecs);
247
248 unsigned int inline jiffies_to_usecs(const unsigned long j)
249 {
250 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
251         return (USEC_PER_SEC / HZ) * j;
252 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
253         return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);
254 #else
255         return (j * USEC_PER_SEC) / HZ;
256 #endif
257 }
258 EXPORT_SYMBOL(jiffies_to_usecs);
259
260 /**
261  * timespec_trunc - Truncate timespec to a granularity
262  * @t: Timespec
263  * @gran: Granularity in ns.
264  *
265  * Truncate a timespec to a granularity. gran must be smaller than a second.
266  * Always rounds down.
267  *
268  * This function should be only used for timestamps returned by
269  * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
270  * it doesn't handle the better resolution of the latter.
271  */
272 struct timespec timespec_trunc(struct timespec t, unsigned gran)
273 {
274         /*
275          * Division is pretty slow so avoid it for common cases.
276          * Currently current_kernel_time() never returns better than
277          * jiffies resolution. Exploit that.
278          */
279         if (gran <= jiffies_to_usecs(1) * 1000) {
280                 /* nothing */
281         } else if (gran == 1000000000) {
282                 t.tv_nsec = 0;
283         } else {
284                 t.tv_nsec -= t.tv_nsec % gran;
285         }
286         return t;
287 }
288 EXPORT_SYMBOL(timespec_trunc);
289
290 #ifndef CONFIG_GENERIC_TIME
291 /*
292  * Simulate gettimeofday using do_gettimeofday which only allows a timeval
293  * and therefore only yields usec accuracy
294  */
295 void getnstimeofday(struct timespec *tv)
296 {
297         struct timeval x;
298
299         do_gettimeofday(&x);
300         tv->tv_sec = x.tv_sec;
301         tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
302 }
303 EXPORT_SYMBOL_GPL(getnstimeofday);
304 #endif
305
306 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
307  * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
308  * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
309  *
310  * [For the Julian calendar (which was used in Russia before 1917,
311  * Britain & colonies before 1752, anywhere else before 1582,
312  * and is still in use by some communities) leave out the
313  * -year/100+year/400 terms, and add 10.]
314  *
315  * This algorithm was first published by Gauss (I think).
316  *
317  * WARNING: this function will overflow on 2106-02-07 06:28:16 on
318  * machines where long is 32-bit! (However, as time_t is signed, we
319  * will already get problems at other places on 2038-01-19 03:14:08)
320  */
321 unsigned long
322 mktime(const unsigned int year0, const unsigned int mon0,
323        const unsigned int day, const unsigned int hour,
324        const unsigned int min, const unsigned int sec)
325 {
326         unsigned int mon = mon0, year = year0;
327
328         /* 1..12 -> 11,12,1..10 */
329         if (0 >= (int) (mon -= 2)) {
330                 mon += 12;      /* Puts Feb last since it has leap day */
331                 year -= 1;
332         }
333
334         return ((((unsigned long)
335                   (year/4 - year/100 + year/400 + 367*mon/12 + day) +
336                   year*365 - 719499
337             )*24 + hour /* now have hours */
338           )*60 + min /* now have minutes */
339         )*60 + sec; /* finally seconds */
340 }
341
342 EXPORT_SYMBOL(mktime);
343
344 /**
345  * set_normalized_timespec - set timespec sec and nsec parts and normalize
346  *
347  * @ts:         pointer to timespec variable to be set
348  * @sec:        seconds to set
349  * @nsec:       nanoseconds to set
350  *
351  * Set seconds and nanoseconds field of a timespec variable and
352  * normalize to the timespec storage format
353  *
354  * Note: The tv_nsec part is always in the range of
355  *      0 <= tv_nsec < NSEC_PER_SEC
356  * For negative values only the tv_sec field is negative !
357  */
358 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
359 {
360         while (nsec >= NSEC_PER_SEC) {
361                 nsec -= NSEC_PER_SEC;
362                 ++sec;
363         }
364         while (nsec < 0) {
365                 nsec += NSEC_PER_SEC;
366                 --sec;
367         }
368         ts->tv_sec = sec;
369         ts->tv_nsec = nsec;
370 }
371
372 /**
373  * ns_to_timespec - Convert nanoseconds to timespec
374  * @nsec:       the nanoseconds value to be converted
375  *
376  * Returns the timespec representation of the nsec parameter.
377  */
378 struct timespec ns_to_timespec(const s64 nsec)
379 {
380         struct timespec ts;
381
382         if (!nsec)
383                 return (struct timespec) {0, 0};
384
385         ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
386         if (unlikely(nsec < 0))
387                 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
388
389         return ts;
390 }
391 EXPORT_SYMBOL(ns_to_timespec);
392
393 /**
394  * ns_to_timeval - Convert nanoseconds to timeval
395  * @nsec:       the nanoseconds value to be converted
396  *
397  * Returns the timeval representation of the nsec parameter.
398  */
399 struct timeval ns_to_timeval(const s64 nsec)
400 {
401         struct timespec ts = ns_to_timespec(nsec);
402         struct timeval tv;
403
404         tv.tv_sec = ts.tv_sec;
405         tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
406
407         return tv;
408 }
409 EXPORT_SYMBOL(ns_to_timeval);
410
411 /*
412  * When we convert to jiffies then we interpret incoming values
413  * the following way:
414  *
415  * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET)
416  *
417  * - 'too large' values [that would result in larger than
418  *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
419  *
420  * - all other values are converted to jiffies by either multiplying
421  *   the input value by a factor or dividing it with a factor
422  *
423  * We must also be careful about 32-bit overflows.
424  */
425 unsigned long msecs_to_jiffies(const unsigned int m)
426 {
427         /*
428          * Negative value, means infinite timeout:
429          */
430         if ((int)m < 0)
431                 return MAX_JIFFY_OFFSET;
432
433 #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)
434         /*
435          * HZ is equal to or smaller than 1000, and 1000 is a nice
436          * round multiple of HZ, divide with the factor between them,
437          * but round upwards:
438          */
439         return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);
440 #elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)
441         /*
442          * HZ is larger than 1000, and HZ is a nice round multiple of
443          * 1000 - simply multiply with the factor between them.
444          *
445          * But first make sure the multiplication result cannot
446          * overflow:
447          */
448         if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
449                 return MAX_JIFFY_OFFSET;
450
451         return m * (HZ / MSEC_PER_SEC);
452 #else
453         /*
454          * Generic case - multiply, round and divide. But first
455          * check that if we are doing a net multiplication, that
456          * we wouldnt overflow:
457          */
458         if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
459                 return MAX_JIFFY_OFFSET;
460
461         return (m * HZ + MSEC_PER_SEC - 1) / MSEC_PER_SEC;
462 #endif
463 }
464 EXPORT_SYMBOL(msecs_to_jiffies);
465
466 unsigned long usecs_to_jiffies(const unsigned int u)
467 {
468         if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
469                 return MAX_JIFFY_OFFSET;
470 #if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
471         return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
472 #elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
473         return u * (HZ / USEC_PER_SEC);
474 #else
475         return (u * HZ + USEC_PER_SEC - 1) / USEC_PER_SEC;
476 #endif
477 }
478 EXPORT_SYMBOL(usecs_to_jiffies);
479
480 /*
481  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
482  * that a remainder subtract here would not do the right thing as the
483  * resolution values don't fall on second boundries.  I.e. the line:
484  * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
485  *
486  * Rather, we just shift the bits off the right.
487  *
488  * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
489  * value to a scaled second value.
490  */
491 unsigned long
492 timespec_to_jiffies(const struct timespec *value)
493 {
494         unsigned long sec = value->tv_sec;
495         long nsec = value->tv_nsec + TICK_NSEC - 1;
496
497         if (sec >= MAX_SEC_IN_JIFFIES){
498                 sec = MAX_SEC_IN_JIFFIES;
499                 nsec = 0;
500         }
501         return (((u64)sec * SEC_CONVERSION) +
502                 (((u64)nsec * NSEC_CONVERSION) >>
503                  (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
504
505 }
506 EXPORT_SYMBOL(timespec_to_jiffies);
507
508 void
509 jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
510 {
511         /*
512          * Convert jiffies to nanoseconds and separate with
513          * one divide.
514          */
515         u64 nsec = (u64)jiffies * TICK_NSEC;
516         value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
517 }
518 EXPORT_SYMBOL(jiffies_to_timespec);
519
520 /* Same for "timeval"
521  *
522  * Well, almost.  The problem here is that the real system resolution is
523  * in nanoseconds and the value being converted is in micro seconds.
524  * Also for some machines (those that use HZ = 1024, in-particular),
525  * there is a LARGE error in the tick size in microseconds.
526
527  * The solution we use is to do the rounding AFTER we convert the
528  * microsecond part.  Thus the USEC_ROUND, the bits to be shifted off.
529  * Instruction wise, this should cost only an additional add with carry
530  * instruction above the way it was done above.
531  */
532 unsigned long
533 timeval_to_jiffies(const struct timeval *value)
534 {
535         unsigned long sec = value->tv_sec;
536         long usec = value->tv_usec;
537
538         if (sec >= MAX_SEC_IN_JIFFIES){
539                 sec = MAX_SEC_IN_JIFFIES;
540                 usec = 0;
541         }
542         return (((u64)sec * SEC_CONVERSION) +
543                 (((u64)usec * USEC_CONVERSION + USEC_ROUND) >>
544                  (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
545 }
546 EXPORT_SYMBOL(timeval_to_jiffies);
547
548 void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
549 {
550         /*
551          * Convert jiffies to nanoseconds and separate with
552          * one divide.
553          */
554         u64 nsec = (u64)jiffies * TICK_NSEC;
555         long tv_usec;
556
557         value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &tv_usec);
558         tv_usec /= NSEC_PER_USEC;
559         value->tv_usec = tv_usec;
560 }
561 EXPORT_SYMBOL(jiffies_to_timeval);
562
563 /*
564  * Convert jiffies/jiffies_64 to clock_t and back.
565  */
566 clock_t jiffies_to_clock_t(long x)
567 {
568 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
569 # if HZ < USER_HZ
570         return x * (USER_HZ / HZ);
571 # else
572         return x / (HZ / USER_HZ);
573 # endif
574 #else
575         u64 tmp = (u64)x * TICK_NSEC;
576         do_div(tmp, (NSEC_PER_SEC / USER_HZ));
577         return (long)tmp;
578 #endif
579 }
580 EXPORT_SYMBOL(jiffies_to_clock_t);
581
582 unsigned long clock_t_to_jiffies(unsigned long x)
583 {
584 #if (HZ % USER_HZ)==0
585         if (x >= ~0UL / (HZ / USER_HZ))
586                 return ~0UL;
587         return x * (HZ / USER_HZ);
588 #else
589         u64 jif;
590
591         /* Don't worry about loss of precision here .. */
592         if (x >= ~0UL / HZ * USER_HZ)
593                 return ~0UL;
594
595         /* .. but do try to contain it here */
596         jif = x * (u64) HZ;
597         do_div(jif, USER_HZ);
598         return jif;
599 #endif
600 }
601 EXPORT_SYMBOL(clock_t_to_jiffies);
602
603 u64 jiffies_64_to_clock_t(u64 x)
604 {
605 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
606 # if HZ < USER_HZ
607         x *= USER_HZ;
608         do_div(x, HZ);
609 # elif HZ > USER_HZ
610         do_div(x, HZ / USER_HZ);
611 # else
612         /* Nothing to do */
613 # endif
614 #else
615         /*
616          * There are better ways that don't overflow early,
617          * but even this doesn't overflow in hundreds of years
618          * in 64 bits, so..
619          */
620         x *= TICK_NSEC;
621         do_div(x, (NSEC_PER_SEC / USER_HZ));
622 #endif
623         return x;
624 }
625 EXPORT_SYMBOL(jiffies_64_to_clock_t);
626
627 u64 nsec_to_clock_t(u64 x)
628 {
629 #if (NSEC_PER_SEC % USER_HZ) == 0
630         do_div(x, (NSEC_PER_SEC / USER_HZ));
631 #elif (USER_HZ % 512) == 0
632         x *= USER_HZ/512;
633         do_div(x, (NSEC_PER_SEC / 512));
634 #else
635         /*
636          * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
637          * overflow after 64.99 years.
638          * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
639          */
640         x *= 9;
641         do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2)) /
642                                   USER_HZ));
643 #endif
644         return x;
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 EXPORT_SYMBOL(get_jiffies_64);
660 #endif
661
662 EXPORT_SYMBOL(jiffies);