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
38 #include <asm/uaccess.h>
39 #include <asm/unistd.h>
40
41 /*
42 * The timezone where the local system is located. Used as a default by some
43 * programs who obtain this value by using gettimeofday.
44 */
45 struct timezone sys_tz;
46
47 EXPORT_SYMBOL(sys_tz);
48
49 #ifdef __ARCH_WANT_SYS_TIME
50
51 /*
52 * sys_time() can be implemented in user-level using
53 * sys_gettimeofday(). Is this for backwards compatibility? If so,
54 * why not move it into the appropriate arch directory (for those
55 * architectures that need it).
56 */
57 asmlinkage long sys_time(time_t __user * tloc)
58 {
59 time_t i;
60 struct timeval tv;
61
62 do_gettimeofday(&tv);
63 i = tv.tv_sec;
64
65 if (tloc) {
66 if (put_user(i,tloc))
67 i = -EFAULT;
68 }
69 return i;
70 }
71
72 /*
73 * sys_stime() can be implemented in user-level using
74 * sys_settimeofday(). Is this for backwards compatibility? If so,
75 * why not move it into the appropriate arch directory (for those
76 * architectures that need it).
77 */
78
79 asmlinkage long sys_stime(time_t __user *tptr)
80 {
81 struct timespec tv;
82 int err;
83
84 if (get_user(tv.tv_sec, tptr))
85 return -EFAULT;
86
87 tv.tv_nsec = 0;
88
89 err = security_settime(&tv, NULL);
90 if (err)
91 return err;
92
93 do_settimeofday(&tv);
94 return 0;
95 }
96
97 #endif /* __ARCH_WANT_SYS_TIME */
98
99 asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
100 {
101 if (likely(tv != NULL)) {
102 struct timeval ktv;
103 do_gettimeofday(&ktv);
104 if (copy_to_user(tv, &ktv, sizeof(ktv)))
105 return -EFAULT;
106 }
107 if (unlikely(tz != NULL)) {
108 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
109 return -EFAULT;
110 }
111 return 0;
112 }
113
114 /*
115 * Adjust the time obtained from the CMOS to be UTC time instead of
116 * local time.
117 *
118 * This is ugly, but preferable to the alternatives. Otherwise we
119 * would either need to write a program to do it in /etc/rc (and risk
120 * confusion if the program gets run more than once; it would also be
121 * hard to make the program warp the clock precisely n hours) or
122 * compile in the timezone information into the kernel. Bad, bad....
123 *
124 * - TYT, 1992-01-01
125 *
126 * The best thing to do is to keep the CMOS clock in universal time (UTC)
127 * as real UNIX machines always do it. This avoids all headaches about
128 * daylight saving times and warping kernel clocks.
129 */
130 inline static void warp_clock(void)
131 {
132 write_seqlock_irq(&xtime_lock);
133 wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
134 xtime.tv_sec += sys_tz.tz_minuteswest * 60;
135 time_interpolator_reset();
136 write_sequnlock_irq(&xtime_lock);
137 clock_was_set();
138 }
139
140 /*
141 * In case for some reason the CMOS clock has not already been running
142 * in UTC, but in some local time: The first time we set the timezone,
143 * we will warp the clock so that it is ticking UTC time instead of
144 * local time. Presumably, if someone is setting the timezone then we
145 * are running in an environment where the programs understand about
146 * timezones. This should be done at boot time in the /etc/rc script,
147 * as soon as possible, so that the clock can be set right. Otherwise,
148 * various programs will get confused when the clock gets warped.
149 */
150
151 int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
152 {
153 static int firsttime = 1;
154 int error = 0;
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 if (firsttime) {
164 firsttime = 0;
165 if (!tv)
166 warp_clock();
167 }
168 }
169 if (tv)
170 {
171 /* SMP safe, again the code in arch/foo/time.c should
172 * globally block out interrupts when it runs.
173 */
174 return do_settimeofday(tv);
175 }
176 return 0;
177 }
178
179 asmlinkage long sys_settimeofday(struct timeval __user *tv,
180 struct timezone __user *tz)
181 {
182 struct timeval user_tv;
183 struct timespec new_ts;
184 struct timezone new_tz;
185
186 if (tv) {
187 if (copy_from_user(&user_tv, tv, sizeof(*tv)))
188 return -EFAULT;
189 new_ts.tv_sec = user_tv.tv_sec;
190 new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
191 }
192 if (tz) {
193 if (copy_from_user(&new_tz, tz, sizeof(*tz)))
194 return -EFAULT;
195 }
196
197 return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
198 }
199
200 long pps_offset; /* pps time offset (us) */
201 long pps_jitter = MAXTIME; /* time dispersion (jitter) (us) */
202
203 long pps_freq; /* frequency offset (scaled ppm) */
204 long pps_stabil = MAXFREQ; /* frequency dispersion (scaled ppm) */
205
206 long pps_valid = PPS_VALID; /* pps signal watchdog counter */
207
208 int pps_shift = PPS_SHIFT; /* interval duration (s) (shift) */
209
210 long pps_jitcnt; /* jitter limit exceeded */
211 long pps_calcnt; /* calibration intervals */
212 long pps_errcnt; /* calibration errors */
213 long pps_stbcnt; /* stability limit exceeded */
214
215 /* hook for a loadable hardpps kernel module */
216 void (*hardpps_ptr)(struct timeval *);
217
218 /* adjtimex mainly allows reading (and writing, if superuser) of
219 * kernel time-keeping variables. used by xntpd.
220 */
221 int do_adjtimex(struct timex *txc)
222 {
223 long ltemp, mtemp, save_adjust;
224 int result;
225
226 /* In order to modify anything, you gotta be super-user! */
227 if (txc->modes && !capable(CAP_SYS_TIME))
228 return -EPERM;
229
230 /* Now we validate the data before disabling interrupts */
231
232 if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
233 /* singleshot must not be used with any other mode bits */
234 if (txc->modes != ADJ_OFFSET_SINGLESHOT)
235 return -EINVAL;
236
237 if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
238 /* adjustment Offset limited to +- .512 seconds */
239 if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
240 return -EINVAL;
241
242 /* if the quartz is off by more than 10% something is VERY wrong ! */
243 if (txc->modes & ADJ_TICK)
244 if (txc->tick < 900000/USER_HZ ||
245 txc->tick > 1100000/USER_HZ)
246 return -EINVAL;
247
248 write_seqlock_irq(&xtime_lock);
249 result = time_state; /* mostly `TIME_OK' */
250
251 /* Save for later - semantics of adjtime is to return old value */
252 save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
253
254 #if 0 /* STA_CLOCKERR is never set yet */
255 time_status &= ~STA_CLOCKERR; /* reset STA_CLOCKERR */
256 #endif
257 /* If there are input parameters, then process them */
258 if (txc->modes)
259 {
260 if (txc->modes & ADJ_STATUS) /* only set allowed bits */
261 time_status = (txc->status & ~STA_RONLY) |
262 (time_status & STA_RONLY);
263
264 if (txc->modes & ADJ_FREQUENCY) { /* p. 22 */
265 if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
266 result = -EINVAL;
267 goto leave;
268 }
269 time_freq = txc->freq - pps_freq;
270 }
271
272 if (txc->modes & ADJ_MAXERROR) {
273 if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
274 result = -EINVAL;
275 goto leave;
276 }
277 time_maxerror = txc->maxerror;
278 }
279
280 if (txc->modes & ADJ_ESTERROR) {
281 if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
282 result = -EINVAL;
283 goto leave;
284 }
285 time_esterror = txc->esterror;
286 }
287
288 if (txc->modes & ADJ_TIMECONST) { /* p. 24 */
289 if (txc->constant < 0) { /* NTP v4 uses values > 6 */
290 result = -EINVAL;
291 goto leave;
292 }
293 time_constant = txc->constant;
294 }
295
296 if (txc->modes & ADJ_OFFSET) { /* values checked earlier */
297 if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
298 /* adjtime() is independent from ntp_adjtime() */
299 if ((time_next_adjust = txc->offset) == 0)
300 time_adjust = 0;
301 }
302 else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
303 ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
304 (STA_PPSTIME | STA_PPSSIGNAL) ?
305 pps_offset : txc->offset;
306
307 /*
308 * Scale the phase adjustment and
309 * clamp to the operating range.
310 */
311 if (ltemp > MAXPHASE)
312 time_offset = MAXPHASE << SHIFT_UPDATE;
313 else if (ltemp < -MAXPHASE)
314 time_offset = -(MAXPHASE << SHIFT_UPDATE);
315 else
316 time_offset = ltemp << SHIFT_UPDATE;
317
318 /*
319 * Select whether the frequency is to be controlled
320 * and in which mode (PLL or FLL). Clamp to the operating
321 * range. Ugly multiply/divide should be replaced someday.
322 */
323
324 if (time_status & STA_FREQHOLD || time_reftime == 0)
325 time_reftime = xtime.tv_sec;
326 mtemp = xtime.tv_sec - time_reftime;
327 time_reftime = xtime.tv_sec;
328 if (time_status & STA_FLL) {
329 if (mtemp >= MINSEC) {
330 ltemp = (time_offset / mtemp) << (SHIFT_USEC -
331 SHIFT_UPDATE);
332 if (ltemp < 0)
333 time_freq -= -ltemp >> SHIFT_KH;
334 else
335 time_freq += ltemp >> SHIFT_KH;
336 } else /* calibration interval too short (p. 12) */
337 result = TIME_ERROR;
338 } else { /* PLL mode */
339 if (mtemp < MAXSEC) {
340 ltemp *= mtemp;
341 if (ltemp < 0)
342 time_freq -= -ltemp >> (time_constant +
343 time_constant +
344 SHIFT_KF - SHIFT_USEC);
345 else
346 time_freq += ltemp >> (time_constant +
347 time_constant +
348 SHIFT_KF - SHIFT_USEC);
349 } else /* calibration interval too long (p. 12) */
350 result = TIME_ERROR;
351 }
352 if (time_freq > time_tolerance)
353 time_freq = time_tolerance;
354 else if (time_freq < -time_tolerance)
355 time_freq = -time_tolerance;
356 } /* STA_PLL || STA_PPSTIME */
357 } /* txc->modes & ADJ_OFFSET */
358 if (txc->modes & ADJ_TICK) {
359 tick_usec = txc->tick;
360 tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
361 }
362 } /* txc->modes */
363 leave: if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
364 || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
365 && (time_status & STA_PPSSIGNAL) == 0)
366 /* p. 24, (b) */
367 || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
368 == (STA_PPSTIME|STA_PPSJITTER))
369 /* p. 24, (c) */
370 || ((time_status & STA_PPSFREQ) != 0
371 && (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
372 /* p. 24, (d) */
373 result = TIME_ERROR;
374
375 if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
376 txc->offset = save_adjust;
377 else {
378 if (time_offset < 0)
379 txc->offset = -(-time_offset >> SHIFT_UPDATE);
380 else
381 txc->offset = time_offset >> SHIFT_UPDATE;
382 }
383 txc->freq = time_freq + pps_freq;
384 txc->maxerror = time_maxerror;
385 txc->esterror = time_esterror;
386 txc->status = time_status;
387 txc->constant = time_constant;
388 txc->precision = time_precision;
389 txc->tolerance = time_tolerance;
390 txc->tick = tick_usec;
391 txc->ppsfreq = pps_freq;
392 txc->jitter = pps_jitter >> PPS_AVG;
393 txc->shift = pps_shift;
394 txc->stabil = pps_stabil;
395 txc->jitcnt = pps_jitcnt;
396 txc->calcnt = pps_calcnt;
397 txc->errcnt = pps_errcnt;
398 txc->stbcnt = pps_stbcnt;
399 write_sequnlock_irq(&xtime_lock);
400 do_gettimeofday(&txc->time);
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
498 int do_settimeofday (struct timespec *tv)
499 {
500 time_t wtm_sec, sec = tv->tv_sec;
501 long wtm_nsec, nsec = tv->tv_nsec;
502
503 if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
504 return -EINVAL;
505
506 write_seqlock_irq(&xtime_lock);
507 {
508 /*
509 * This is revolting. We need to set "xtime" correctly. However, the value
510 * in this location is the value at the most recent update of wall time.
511 * Discover what correction gettimeofday would have done, and then undo
512 * it!
513 */
514 nsec -= time_interpolator_get_offset();
515
516 wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
517 wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
518
519 set_normalized_timespec(&xtime, sec, nsec);
520 set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
521
522 time_adjust = 0; /* stop active adjtime() */
523 time_status |= STA_UNSYNC;
524 time_maxerror = NTP_PHASE_LIMIT;
525 time_esterror = NTP_PHASE_LIMIT;
526 time_interpolator_reset();
527 }
528 write_sequnlock_irq(&xtime_lock);
529 clock_was_set();
530 return 0;
531 }
532
533 void do_gettimeofday (struct timeval *tv)
534 {
535 unsigned long seq, nsec, usec, sec, offset;
536 do {
537 seq = read_seqbegin(&xtime_lock);
538 offset = time_interpolator_get_offset();
539 sec = xtime.tv_sec;
540 nsec = xtime.tv_nsec;
541 } while (unlikely(read_seqretry(&xtime_lock, seq)));
542
543 usec = (nsec + offset) / 1000;
544
545 while (unlikely(usec >= USEC_PER_SEC)) {
546 usec -= USEC_PER_SEC;
547 ++sec;
548 }
549
550 tv->tv_sec = sec;
551 tv->tv_usec = usec;
552 }
553
554 EXPORT_SYMBOL(do_gettimeofday);
555
556
557 #else
558 /*
559 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
560 * and therefore only yields usec accuracy
561 */
562 void getnstimeofday(struct timespec *tv)
563 {
564 struct timeval x;
565
566 do_gettimeofday(&x);
567 tv->tv_sec = x.tv_sec;
568 tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
569 }
570 #endif
571
572 #if (BITS_PER_LONG < 64)
573 u64 get_jiffies_64(void)
574 {
575 unsigned long seq;
576 u64 ret;
577
578 do {
579 seq = read_seqbegin(&xtime_lock);
580 ret = jiffies_64;
581 } while (read_seqretry(&xtime_lock, seq));
582 return ret;
583 }
584
585 EXPORT_SYMBOL(get_jiffies_64);
586 #endif
587
588 EXPORT_SYMBOL(jiffies);
589
|
This page was automatically generated by the
LXR engine.
|