ia64/linux-2.6.18-xen.hg

view kernel/time.c @ 912:dd42cdb0ab89

[IA64] Build blktap2 driver by default in x86 builds.

add CONFIG_XEN_BLKDEV_TAP2=y to buildconfigs/linux-defconfig_xen_ia64.

Signed-off-by: Isaku Yamahata <yamahata@valinux.co.jp>
author Isaku Yamahata <yamahata@valinux.co.jp>
date Mon Jun 29 12:09:16 2009 +0900 (2009-06-29)
parents 831230e53067
children
line source
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 */
30 #include <linux/module.h>
31 #include <linux/timex.h>
32 #include <linux/capability.h>
33 #include <linux/errno.h>
34 #include <linux/smp_lock.h>
35 #include <linux/syscalls.h>
36 #include <linux/security.h>
37 #include <linux/fs.h>
38 #include <linux/module.h>
40 #include <asm/uaccess.h>
41 #include <asm/unistd.h>
43 /*
44 * The timezone where the local system is located. Used as a default by some
45 * programs who obtain this value by using gettimeofday.
46 */
47 struct timezone sys_tz;
49 EXPORT_SYMBOL(sys_tz);
51 #ifdef __ARCH_WANT_SYS_TIME
53 /*
54 * sys_time() can be implemented in user-level using
55 * sys_gettimeofday(). Is this for backwards compatibility? If so,
56 * why not move it into the appropriate arch directory (for those
57 * architectures that need it).
58 */
59 asmlinkage long sys_time(time_t __user * tloc)
60 {
61 time_t i;
62 struct timeval tv;
64 do_gettimeofday(&tv);
65 i = tv.tv_sec;
67 if (tloc) {
68 if (put_user(i,tloc))
69 i = -EFAULT;
70 }
71 return i;
72 }
74 /*
75 * sys_stime() can be implemented in user-level using
76 * sys_settimeofday(). Is this for backwards compatibility? If so,
77 * why not move it into the appropriate arch directory (for those
78 * architectures that need it).
79 */
81 asmlinkage long sys_stime(time_t __user *tptr)
82 {
83 struct timespec tv;
84 int err;
86 if (get_user(tv.tv_sec, tptr))
87 return -EFAULT;
89 tv.tv_nsec = 0;
91 err = security_settime(&tv, NULL);
92 if (err)
93 return err;
95 do_settimeofday(&tv);
96 return 0;
97 }
99 #endif /* __ARCH_WANT_SYS_TIME */
101 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
102 {
103 if (likely(tv != NULL)) {
104 struct timeval ktv;
105 do_gettimeofday(&ktv);
106 if (copy_to_user(tv, &ktv, sizeof(ktv)))
107 return -EFAULT;
108 }
109 if (unlikely(tz != NULL)) {
110 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
111 return -EFAULT;
112 }
113 return 0;
114 }
116 /*
117 * Adjust the time obtained from the CMOS to be UTC time instead of
118 * local time.
119 *
120 * This is ugly, but preferable to the alternatives. Otherwise we
121 * would either need to write a program to do it in /etc/rc (and risk
122 * confusion if the program gets run more than once; it would also be
123 * hard to make the program warp the clock precisely n hours) or
124 * compile in the timezone information into the kernel. Bad, bad....
125 *
126 * - TYT, 1992-01-01
127 *
128 * The best thing to do is to keep the CMOS clock in universal time (UTC)
129 * as real UNIX machines always do it. This avoids all headaches about
130 * daylight saving times and warping kernel clocks.
131 */
132 static inline void warp_clock(void)
133 {
134 write_seqlock_irq(&xtime_lock);
135 wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
136 xtime.tv_sec += sys_tz.tz_minuteswest * 60;
137 time_interpolator_reset();
138 write_sequnlock_irq(&xtime_lock);
139 clock_was_set();
140 }
142 /*
143 * In case for some reason the CMOS clock has not already been running
144 * in UTC, but in some local time: The first time we set the timezone,
145 * we will warp the clock so that it is ticking UTC time instead of
146 * local time. Presumably, if someone is setting the timezone then we
147 * are running in an environment where the programs understand about
148 * timezones. This should be done at boot time in the /etc/rc script,
149 * as soon as possible, so that the clock can be set right. Otherwise,
150 * various programs will get confused when the clock gets warped.
151 */
153 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
154 {
155 static int firsttime = 1;
156 int error = 0;
158 if (tv && !timespec_valid(tv))
159 return -EINVAL;
161 error = security_settime(tv, tz);
162 if (error)
163 return error;
165 if (tz) {
166 /* SMP safe, global irq locking makes it work. */
167 sys_tz = *tz;
168 if (firsttime) {
169 firsttime = 0;
170 if (!tv)
171 warp_clock();
172 }
173 }
174 if (tv)
175 {
176 /* SMP safe, again the code in arch/foo/time.c should
177 * globally block out interrupts when it runs.
178 */
179 return do_settimeofday(tv);
180 }
181 return 0;
182 }
184 asmlinkage long sys_settimeofday(struct timeval __user *tv,
185 struct timezone __user *tz)
186 {
187 struct timeval user_tv;
188 struct timespec new_ts;
189 struct timezone new_tz;
191 if (tv) {
192 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
193 return -EFAULT;
194 new_ts.tv_sec = user_tv.tv_sec;
195 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
196 }
197 if (tz) {
198 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
199 return -EFAULT;
200 }
202 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
203 }
205 /* we call this to notify the arch when the clock is being
206 * controlled. If no such arch routine, do nothing.
207 */
208 void __attribute__ ((weak)) notify_arch_cmos_timer(void)
209 {
210 return;
211 }
213 /* adjtimex mainly allows reading (and writing, if superuser) of
214 * kernel time-keeping variables. used by xntpd.
215 */
216 int do_adjtimex(struct timex *txc)
217 {
218 long ltemp, mtemp, save_adjust;
219 int result;
221 /* In order to modify anything, you gotta be super-user! */
222 if (txc->modes && !capable(CAP_SYS_TIME))
223 return -EPERM;
225 /* Now we validate the data before disabling interrupts */
227 if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
228 /* singleshot must not be used with any other mode bits */
229 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
230 return -EINVAL;
232 if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
233 /* adjustment Offset limited to +- .512 seconds */
234 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
235 return -EINVAL;
237 /* if the quartz is off by more than 10% something is VERY wrong ! */
238 if (txc->modes & ADJ_TICK)
239 if (txc->tick < 900000/USER_HZ ||
240 txc->tick > 1100000/USER_HZ)
241 return -EINVAL;
243 write_seqlock_irq(&xtime_lock);
244 result = time_state; /* mostly `TIME_OK' */
246 /* Save for later - semantics of adjtime is to return old value */
247 save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
249 #if 0 /* STA_CLOCKERR is never set yet */
250 time_status &= ~STA_CLOCKERR; /* reset STA_CLOCKERR */
251 #endif
252 /* If there are input parameters, then process them */
253 if (txc->modes)
254 {
255 if (txc->modes & ADJ_STATUS) /* only set allowed bits */
256 time_status = (txc->status & ~STA_RONLY) |
257 (time_status & STA_RONLY);
259 if (txc->modes & ADJ_FREQUENCY) { /* p. 22 */
260 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
261 result = -EINVAL;
262 goto leave;
263 }
264 time_freq = txc->freq;
265 }
267 if (txc->modes & ADJ_MAXERROR) {
268 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
269 result = -EINVAL;
270 goto leave;
271 }
272 time_maxerror = txc->maxerror;
273 }
275 if (txc->modes & ADJ_ESTERROR) {
276 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
277 result = -EINVAL;
278 goto leave;
279 }
280 time_esterror = txc->esterror;
281 }
283 if (txc->modes & ADJ_TIMECONST) { /* p. 24 */
284 if (txc->constant < 0) { /* NTP v4 uses values > 6 */
285 result = -EINVAL;
286 goto leave;
287 }
288 time_constant = txc->constant;
289 }
291 if (txc->modes & ADJ_OFFSET) { /* values checked earlier */
292 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
293 /* adjtime() is independent from ntp_adjtime() */
294 if ((time_next_adjust = txc->offset) == 0)
295 time_adjust = 0;
296 }
297 else if (time_status & STA_PLL) {
298 ltemp = txc->offset;
300 /*
301 * Scale the phase adjustment and
302 * clamp to the operating range.
303 */
304 if (ltemp > MAXPHASE)
305 time_offset = MAXPHASE << SHIFT_UPDATE;
306 else if (ltemp < -MAXPHASE)
307 time_offset = -(MAXPHASE << SHIFT_UPDATE);
308 else
309 time_offset = ltemp << SHIFT_UPDATE;
311 /*
312 * Select whether the frequency is to be controlled
313 * and in which mode (PLL or FLL). Clamp to the operating
314 * range. Ugly multiply/divide should be replaced someday.
315 */
317 if (time_status & STA_FREQHOLD || time_reftime == 0)
318 time_reftime = xtime.tv_sec;
319 mtemp = xtime.tv_sec - time_reftime;
320 time_reftime = xtime.tv_sec;
321 if (time_status & STA_FLL) {
322 if (mtemp >= MINSEC) {
323 ltemp = (time_offset / mtemp) << (SHIFT_USEC -
324 SHIFT_UPDATE);
325 time_freq += shift_right(ltemp, SHIFT_KH);
326 } else /* calibration interval too short (p. 12) */
327 result = TIME_ERROR;
328 } else { /* PLL mode */
329 if (mtemp < MAXSEC) {
330 ltemp *= mtemp;
331 time_freq += shift_right(ltemp,(time_constant +
332 time_constant +
333 SHIFT_KF - SHIFT_USEC));
334 } else /* calibration interval too long (p. 12) */
335 result = TIME_ERROR;
336 }
337 time_freq = min(time_freq, time_tolerance);
338 time_freq = max(time_freq, -time_tolerance);
339 } /* STA_PLL */
340 } /* txc->modes & ADJ_OFFSET */
341 if (txc->modes & ADJ_TICK) {
342 tick_usec = txc->tick;
343 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
344 }
345 } /* txc->modes */
346 leave: if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
347 result = TIME_ERROR;
349 if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
350 txc->offset = save_adjust;
351 else {
352 txc->offset = shift_right(time_offset, SHIFT_UPDATE);
353 }
354 txc->freq = time_freq;
355 txc->maxerror = time_maxerror;
356 txc->esterror = time_esterror;
357 txc->status = time_status;
358 txc->constant = time_constant;
359 txc->precision = time_precision;
360 txc->tolerance = time_tolerance;
361 txc->tick = tick_usec;
363 /* PPS is not implemented, so these are zero */
364 txc->ppsfreq = 0;
365 txc->jitter = 0;
366 txc->shift = 0;
367 txc->stabil = 0;
368 txc->jitcnt = 0;
369 txc->calcnt = 0;
370 txc->errcnt = 0;
371 txc->stbcnt = 0;
372 write_sequnlock_irq(&xtime_lock);
373 do_gettimeofday(&txc->time);
374 notify_arch_cmos_timer();
375 return(result);
376 }
378 asmlinkage long sys_adjtimex(struct timex __user *txc_p)
379 {
380 struct timex txc; /* Local copy of parameter */
381 int ret;
383 /* Copy the user data space into the kernel copy
384 * structure. But bear in mind that the structures
385 * may change
386 */
387 if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
388 return -EFAULT;
389 ret = do_adjtimex(&txc);
390 return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
391 }
393 inline struct timespec current_kernel_time(void)
394 {
395 struct timespec now;
396 unsigned long seq;
398 do {
399 seq = read_seqbegin(&xtime_lock);
401 now = xtime;
402 } while (read_seqretry(&xtime_lock, seq));
404 return now;
405 }
407 EXPORT_SYMBOL(current_kernel_time);
409 /**
410 * current_fs_time - Return FS time
411 * @sb: Superblock.
412 *
413 * Return the current time truncated to the time granularity supported by
414 * the fs.
415 */
416 struct timespec current_fs_time(struct super_block *sb)
417 {
418 struct timespec now = current_kernel_time();
419 return timespec_trunc(now, sb->s_time_gran);
420 }
421 EXPORT_SYMBOL(current_fs_time);
423 /**
424 * timespec_trunc - Truncate timespec to a granularity
425 * @t: Timespec
426 * @gran: Granularity in ns.
427 *
428 * Truncate a timespec to a granularity. gran must be smaller than a second.
429 * Always rounds down.
430 *
431 * This function should be only used for timestamps returned by
432 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
433 * it doesn't handle the better resolution of the later.
434 */
435 struct timespec timespec_trunc(struct timespec t, unsigned gran)
436 {
437 /*
438 * Division is pretty slow so avoid it for common cases.
439 * Currently current_kernel_time() never returns better than
440 * jiffies resolution. Exploit that.
441 */
442 if (gran <= jiffies_to_usecs(1) * 1000) {
443 /* nothing */
444 } else if (gran == 1000000000) {
445 t.tv_nsec = 0;
446 } else {
447 t.tv_nsec -= t.tv_nsec % gran;
448 }
449 return t;
450 }
451 EXPORT_SYMBOL(timespec_trunc);
453 #ifdef CONFIG_TIME_INTERPOLATION
454 void getnstimeofday (struct timespec *tv)
455 {
456 unsigned long seq,sec,nsec;
458 do {
459 seq = read_seqbegin(&xtime_lock);
460 sec = xtime.tv_sec;
461 nsec = xtime.tv_nsec+time_interpolator_get_offset();
462 } while (unlikely(read_seqretry(&xtime_lock, seq)));
464 while (unlikely(nsec >= NSEC_PER_SEC)) {
465 nsec -= NSEC_PER_SEC;
466 ++sec;
467 }
468 tv->tv_sec = sec;
469 tv->tv_nsec = nsec;
470 }
471 EXPORT_SYMBOL_GPL(getnstimeofday);
473 int do_settimeofday (struct timespec *tv)
474 {
475 time_t wtm_sec, sec = tv->tv_sec;
476 long wtm_nsec, nsec = tv->tv_nsec;
478 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
479 return -EINVAL;
481 write_seqlock_irq(&xtime_lock);
482 {
483 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
484 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
486 set_normalized_timespec(&xtime, sec, nsec);
487 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
489 time_adjust = 0; /* stop active adjtime() */
490 time_status |= STA_UNSYNC;
491 time_maxerror = NTP_PHASE_LIMIT;
492 time_esterror = NTP_PHASE_LIMIT;
493 time_interpolator_reset();
494 }
495 write_sequnlock_irq(&xtime_lock);
496 clock_was_set();
497 return 0;
498 }
499 EXPORT_SYMBOL(do_settimeofday);
501 void do_gettimeofday (struct timeval *tv)
502 {
503 unsigned long seq, nsec, usec, sec, offset;
504 do {
505 seq = read_seqbegin(&xtime_lock);
506 offset = time_interpolator_get_offset();
507 sec = xtime.tv_sec;
508 nsec = xtime.tv_nsec;
509 } while (unlikely(read_seqretry(&xtime_lock, seq)));
511 usec = (nsec + offset) / 1000;
513 while (unlikely(usec >= USEC_PER_SEC)) {
514 usec -= USEC_PER_SEC;
515 ++sec;
516 }
518 tv->tv_sec = sec;
519 tv->tv_usec = usec;
520 }
522 EXPORT_SYMBOL(do_gettimeofday);
525 #else
526 #ifndef CONFIG_GENERIC_TIME
527 /*
528 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
529 * and therefore only yields usec accuracy
530 */
531 void getnstimeofday(struct timespec *tv)
532 {
533 struct timeval x;
535 do_gettimeofday(&x);
536 tv->tv_sec = x.tv_sec;
537 tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
538 }
539 EXPORT_SYMBOL_GPL(getnstimeofday);
540 #endif
541 #endif
543 /* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
544 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
545 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
546 *
547 * [For the Julian calendar (which was used in Russia before 1917,
548 * Britain & colonies before 1752, anywhere else before 1582,
549 * and is still in use by some communities) leave out the
550 * -year/100+year/400 terms, and add 10.]
551 *
552 * This algorithm was first published by Gauss (I think).
553 *
554 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
555 * machines were long is 32-bit! (However, as time_t is signed, we
556 * will already get problems at other places on 2038-01-19 03:14:08)
557 */
558 unsigned long
559 mktime(const unsigned int year0, const unsigned int mon0,
560 const unsigned int day, const unsigned int hour,
561 const unsigned int min, const unsigned int sec)
562 {
563 unsigned int mon = mon0, year = year0;
565 /* 1..12 -> 11,12,1..10 */
566 if (0 >= (int) (mon -= 2)) {
567 mon += 12; /* Puts Feb last since it has leap day */
568 year -= 1;
569 }
571 return ((((unsigned long)
572 (year/4 - year/100 + year/400 + 367*mon/12 + day) +
573 year*365 - 719499
574 )*24 + hour /* now have hours */
575 )*60 + min /* now have minutes */
576 )*60 + sec; /* finally seconds */
577 }
579 EXPORT_SYMBOL(mktime);
581 /**
582 * set_normalized_timespec - set timespec sec and nsec parts and normalize
583 *
584 * @ts: pointer to timespec variable to be set
585 * @sec: seconds to set
586 * @nsec: nanoseconds to set
587 *
588 * Set seconds and nanoseconds field of a timespec variable and
589 * normalize to the timespec storage format
590 *
591 * Note: The tv_nsec part is always in the range of
592 * 0 <= tv_nsec < NSEC_PER_SEC
593 * For negative values only the tv_sec field is negative !
594 */
595 void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
596 {
597 while (nsec >= NSEC_PER_SEC) {
598 nsec -= NSEC_PER_SEC;
599 ++sec;
600 }
601 while (nsec < 0) {
602 nsec += NSEC_PER_SEC;
603 --sec;
604 }
605 ts->tv_sec = sec;
606 ts->tv_nsec = nsec;
607 }
609 /**
610 * ns_to_timespec - Convert nanoseconds to timespec
611 * @nsec: the nanoseconds value to be converted
612 *
613 * Returns the timespec representation of the nsec parameter.
614 */
615 struct timespec ns_to_timespec(const s64 nsec)
616 {
617 struct timespec ts;
619 if (!nsec)
620 return (struct timespec) {0, 0};
622 ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
623 if (unlikely(nsec < 0))
624 set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
626 return ts;
627 }
629 /**
630 * ns_to_timeval - Convert nanoseconds to timeval
631 * @nsec: the nanoseconds value to be converted
632 *
633 * Returns the timeval representation of the nsec parameter.
634 */
635 struct timeval ns_to_timeval(const s64 nsec)
636 {
637 struct timespec ts = ns_to_timespec(nsec);
638 struct timeval tv;
640 tv.tv_sec = ts.tv_sec;
641 tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
643 return tv;
644 }
646 #if (BITS_PER_LONG < 64)
647 u64 get_jiffies_64(void)
648 {
649 unsigned long seq;
650 u64 ret;
652 do {
653 seq = read_seqbegin(&xtime_lock);
654 ret = jiffies_64;
655 } while (read_seqretry(&xtime_lock, seq));
656 return ret;
657 }
659 EXPORT_SYMBOL(get_jiffies_64);
660 #endif
662 EXPORT_SYMBOL(jiffies);