kernel26-2.6.12-alx-r9/kernel/time.c

/*
 *  linux/kernel/time.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  This file contains the interface functions for the various
 *  time related system calls: time, stime, gettimeofday, settimeofday,
 *			       adjtime
 */
/*
 * Modification history kernel/time.c
 * 
 * 1993-09-02    Philip Gladstone
 *      Created file with time related functions from sched.c and adjtimex() 
 * 1993-10-08    Torsten Duwe
 *      adjtime interface update and CMOS clock write code
 * 1995-08-13    Torsten Duwe
 *      kernel PLL updated to 1994-12-13 specs (rfc-1589)
 * 1999-01-16    Ulrich Windl
 *	Introduced error checking for many cases in adjtimex().
 *	Updated NTP code according to technical memorandum Jan '96
 *	"A Kernel Model for Precision Timekeeping" by Dave Mills
 *	Allow time_constant larger than MAXTC(6) for NTP v4 (MAXTC == 10)
 *	(Even though the technical memorandum forbids it)
 * 2004-07-14	 Christoph Lameter
 *	Added getnstimeofday to allow the posix timer functions to return
 *	with nanosecond accuracy
 */

#include <linux/module.h>
#include <linux/timex.h>
#include <linux/errno.h>
#include <linux/smp_lock.h>
#include <linux/syscalls.h>
#include <linux/security.h>
#include <linux/fs.h>
#include <linux/module.h>

#include <asm/uaccess.h>
#include <asm/unistd.h>

/* 
 * The timezone where the local system is located.  Used as a default by some
 * programs who obtain this value by using gettimeofday.
 */
struct timezone sys_tz;

EXPORT_SYMBOL(sys_tz);

#ifdef __ARCH_WANT_SYS_TIME

/*
 * sys_time() can be implemented in user-level using
 * sys_gettimeofday().  Is this for backwards compatibility?  If so,
 * why not move it into the appropriate arch directory (for those
 * architectures that need it).
 */
asmlinkage long sys_time(time_t __user * tloc)
{
	time_t i;
	struct timeval tv;

	do_gettimeofday(&tv);
	i = tv.tv_sec;

	if (tloc) {
		if (put_user(i,tloc))
			i = -EFAULT;
	}
	return i;
}

/*
 * sys_stime() can be implemented in user-level using
 * sys_settimeofday().  Is this for backwards compatibility?  If so,
 * why not move it into the appropriate arch directory (for those
 * architectures that need it).
 */
 
asmlinkage long sys_stime(time_t __user *tptr)
{
	struct timespec tv;
	int err;

	if (get_user(tv.tv_sec, tptr))
		return -EFAULT;

	tv.tv_nsec = 0;

	err = security_settime(&tv, NULL);
	if (err)
		return err;

	do_settimeofday(&tv);
	return 0;
}

#endif /* __ARCH_WANT_SYS_TIME */

asmlinkage long sys_gettimeofday(struct timeval __user *tv, struct timezone __user *tz)
{
	if (likely(tv != NULL)) {
		struct timeval ktv;
		do_gettimeofday(&ktv);
		if (copy_to_user(tv, &ktv, sizeof(ktv)))
			return -EFAULT;
	}
	if (unlikely(tz != NULL)) {
		if (copy_to_user(tz, &sys_tz, sizeof(sys_tz)))
			return -EFAULT;
	}
	return 0;
}

/*
 * Adjust the time obtained from the CMOS to be UTC time instead of
 * local time.
 * 
 * This is ugly, but preferable to the alternatives.  Otherwise we
 * would either need to write a program to do it in /etc/rc (and risk
 * confusion if the program gets run more than once; it would also be 
 * hard to make the program warp the clock precisely n hours)  or
 * compile in the timezone information into the kernel.  Bad, bad....
 *
 *              				- TYT, 1992-01-01
 *
 * The best thing to do is to keep the CMOS clock in universal time (UTC)
 * as real UNIX machines always do it. This avoids all headaches about
 * daylight saving times and warping kernel clocks.
 */
inline static void warp_clock(void)
{
	write_seqlock_irq(&xtime_lock);
	wall_to_monotonic.tv_sec -= sys_tz.tz_minuteswest * 60;
	xtime.tv_sec += sys_tz.tz_minuteswest * 60;
	time_interpolator_reset();
	write_sequnlock_irq(&xtime_lock);
	clock_was_set();
}

/*
 * In case for some reason the CMOS clock has not already been running
 * in UTC, but in some local time: The first time we set the timezone,
 * we will warp the clock so that it is ticking UTC time instead of
 * local time. Presumably, if someone is setting the timezone then we
 * are running in an environment where the programs understand about
 * timezones. This should be done at boot time in the /etc/rc script,
 * as soon as possible, so that the clock can be set right. Otherwise,
 * various programs will get confused when the clock gets warped.
 */

int do_sys_settimeofday(struct timespec *tv, struct timezone *tz)
{
	static int firsttime = 1;
	int error = 0;

	error = security_settime(tv, tz);
	if (error)
		return error;

	if (tz) {
		/* SMP safe, global irq locking makes it work. */
		sys_tz = *tz;
		if (firsttime) {
			firsttime = 0;
			if (!tv)
				warp_clock();
		}
	}
	if (tv)
	{
		/* SMP safe, again the code in arch/foo/time.c should
		 * globally block out interrupts when it runs.
		 */
		return do_settimeofday(tv);
	}
	return 0;
}

asmlinkage long sys_settimeofday(struct timeval __user *tv,
				struct timezone __user *tz)
{
	struct timeval user_tv;
	struct timespec	new_ts;
	struct timezone new_tz;

	if (tv) {
		if (copy_from_user(&user_tv, tv, sizeof(*tv)))
			return -EFAULT;
		new_ts.tv_sec = user_tv.tv_sec;
		new_ts.tv_nsec = user_tv.tv_usec * NSEC_PER_USEC;
	}
	if (tz) {
		if (copy_from_user(&new_tz, tz, sizeof(*tz)))
			return -EFAULT;
	}

	return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
}

long pps_offset;		/* pps time offset (us) */
long pps_jitter = MAXTIME;	/* time dispersion (jitter) (us) */

long pps_freq;			/* frequency offset (scaled ppm) */
long pps_stabil = MAXFREQ;	/* frequency dispersion (scaled ppm) */

long pps_valid = PPS_VALID;	/* pps signal watchdog counter */

int pps_shift = PPS_SHIFT;	/* interval duration (s) (shift) */

long pps_jitcnt;		/* jitter limit exceeded */
long pps_calcnt;		/* calibration intervals */
long pps_errcnt;		/* calibration errors */
long pps_stbcnt;		/* stability limit exceeded */

/* hook for a loadable hardpps kernel module */
void (*hardpps_ptr)(struct timeval *);

/* we call this to notify the arch when the clock is being
 * controlled.  If no such arch routine, do nothing.
 */
void __attribute__ ((weak)) notify_arch_cmos_timer(void)
{
	return;
}

/* adjtimex mainly allows reading (and writing, if superuser) of
 * kernel time-keeping variables. used by xntpd.
 */
int do_adjtimex(struct timex *txc)
{
        long ltemp, mtemp, save_adjust;
	int result;

	/* In order to modify anything, you gotta be super-user! */
	if (txc->modes && !capable(CAP_SYS_TIME))
		return -EPERM;
		
	/* Now we validate the data before disabling interrupts */

	if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
	  /* singleshot must not be used with any other mode bits */
		if (txc->modes != ADJ_OFFSET_SINGLESHOT)
			return -EINVAL;

	if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
	  /* adjustment Offset limited to +- .512 seconds */
		if (txc->offset <= - MAXPHASE || txc->offset >= MAXPHASE )
			return -EINVAL;	

	/* if the quartz is off by more than 10% something is VERY wrong ! */
	if (txc->modes & ADJ_TICK)
		if (txc->tick <  900000/USER_HZ ||
		    txc->tick > 1100000/USER_HZ)
			return -EINVAL;

	write_seqlock_irq(&xtime_lock);
	result = time_state;	/* mostly `TIME_OK' */

	/* Save for later - semantics of adjtime is to return old value */
	save_adjust = time_next_adjust ? time_next_adjust : time_adjust;

#if 0	/* STA_CLOCKERR is never set yet */
	time_status &= ~STA_CLOCKERR;		/* reset STA_CLOCKERR */
#endif
	/* If there are input parameters, then process them */
	if (txc->modes)
	{
	    if (txc->modes & ADJ_STATUS)	/* only set allowed bits */
		time_status =  (txc->status & ~STA_RONLY) |
			      (time_status & STA_RONLY);

	    if (txc->modes & ADJ_FREQUENCY) {	/* p. 22 */
		if (txc->freq > MAXFREQ || txc->freq < -MAXFREQ) {
		    result = -EINVAL;
		    goto leave;
		}
		time_freq = txc->freq - pps_freq;
	    }

	    if (txc->modes & ADJ_MAXERROR) {
		if (txc->maxerror < 0 || txc->maxerror >= NTP_PHASE_LIMIT) {
		    result = -EINVAL;
		    goto leave;
		}
		time_maxerror = txc->maxerror;
	    }

	    if (txc->modes & ADJ_ESTERROR) {
		if (txc->esterror < 0 || txc->esterror >= NTP_PHASE_LIMIT) {
		    result = -EINVAL;
		    goto leave;
		}
		time_esterror = txc->esterror;
	    }

	    if (txc->modes & ADJ_TIMECONST) {	/* p. 24 */
		if (txc->constant < 0) {	/* NTP v4 uses values > 6 */
		    result = -EINVAL;
		    goto leave;
		}
		time_constant = txc->constant;
	    }

	    if (txc->modes & ADJ_OFFSET) {	/* values checked earlier */
		if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
		    /* adjtime() is independent from ntp_adjtime() */
		    if ((time_next_adjust = txc->offset) == 0)
			 time_adjust = 0;
		}
		else if ( time_status & (STA_PLL | STA_PPSTIME) ) {
		    ltemp = (time_status & (STA_PPSTIME | STA_PPSSIGNAL)) ==
		            (STA_PPSTIME | STA_PPSSIGNAL) ?
		            pps_offset : txc->offset;

		    /*
		     * Scale the phase adjustment and
		     * clamp to the operating range.
		     */
		    if (ltemp > MAXPHASE)
		        time_offset = MAXPHASE << SHIFT_UPDATE;
		    else if (ltemp < -MAXPHASE)
			time_offset = -(MAXPHASE << SHIFT_UPDATE);
		    else
		        time_offset = ltemp << SHIFT_UPDATE;

		    /*
		     * Select whether the frequency is to be controlled
		     * and in which mode (PLL or FLL). Clamp to the operating
		     * range. Ugly multiply/divide should be replaced someday.
		     */

		    if (time_status & STA_FREQHOLD || time_reftime == 0)
		        time_reftime = xtime.tv_sec;
		    mtemp = xtime.tv_sec - time_reftime;
		    time_reftime = xtime.tv_sec;
		    if (time_status & STA_FLL) {
		        if (mtemp >= MINSEC) {
			    ltemp = (time_offset / mtemp) << (SHIFT_USEC -
							      SHIFT_UPDATE);
			    if (ltemp < 0)
			        time_freq -= -ltemp >> SHIFT_KH;
			    else
			        time_freq += ltemp >> SHIFT_KH;
			} else /* calibration interval too short (p. 12) */
				result = TIME_ERROR;
		    } else {	/* PLL mode */
		        if (mtemp < MAXSEC) {
			    ltemp *= mtemp;
			    if (ltemp < 0)
			        time_freq -= -ltemp >> (time_constant +
							time_constant +
							SHIFT_KF - SHIFT_USEC);
			    else
			        time_freq += ltemp >> (time_constant +
						       time_constant +
						       SHIFT_KF - SHIFT_USEC);
			} else /* calibration interval too long (p. 12) */
				result = TIME_ERROR;
		    }
		    if (time_freq > time_tolerance)
		        time_freq = time_tolerance;
		    else if (time_freq < -time_tolerance)
		        time_freq = -time_tolerance;
		} /* STA_PLL || STA_PPSTIME */
	    } /* txc->modes & ADJ_OFFSET */
	    if (txc->modes & ADJ_TICK) {
		tick_usec = txc->tick;
		tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
	    }
	} /* txc->modes */
leave:	if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0
	    || ((time_status & (STA_PPSFREQ|STA_PPSTIME)) != 0
		&& (time_status & STA_PPSSIGNAL) == 0)
	    /* p. 24, (b) */
	    || ((time_status & (STA_PPSTIME|STA_PPSJITTER))
		== (STA_PPSTIME|STA_PPSJITTER))
	    /* p. 24, (c) */
	    || ((time_status & STA_PPSFREQ) != 0
		&& (time_status & (STA_PPSWANDER|STA_PPSERROR)) != 0))
	    /* p. 24, (d) */
		result = TIME_ERROR;
	
	if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
	    txc->offset	   = save_adjust;
	else {
	    if (time_offset < 0)
		txc->offset = -(-time_offset >> SHIFT_UPDATE);
	    else
		txc->offset = time_offset >> SHIFT_UPDATE;
	}
	txc->freq	   = time_freq + pps_freq;
	txc->maxerror	   = time_maxerror;
	txc->esterror	   = time_esterror;
	txc->status	   = time_status;
	txc->constant	   = time_constant;
	txc->precision	   = time_precision;
	txc->tolerance	   = time_tolerance;
	txc->tick	   = tick_usec;
	txc->ppsfreq	   = pps_freq;
	txc->jitter	   = pps_jitter >> PPS_AVG;
	txc->shift	   = pps_shift;
	txc->stabil	   = pps_stabil;
	txc->jitcnt	   = pps_jitcnt;
	txc->calcnt	   = pps_calcnt;
	txc->errcnt	   = pps_errcnt;
	txc->stbcnt	   = pps_stbcnt;
	write_sequnlock_irq(&xtime_lock);
	do_gettimeofday(&txc->time);
	notify_arch_cmos_timer();
	return(result);
}

asmlinkage long sys_adjtimex(struct timex __user *txc_p)
{
	struct timex txc;		/* Local copy of parameter */
	int ret;

	/* Copy the user data space into the kernel copy
	 * structure. But bear in mind that the structures
	 * may change
	 */
	if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
		return -EFAULT;
	ret = do_adjtimex(&txc);
	return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
}

inline struct timespec current_kernel_time(void)
{
        struct timespec now;
        unsigned long seq;

	do {
		seq = read_seqbegin(&xtime_lock);
		
		now = xtime;
	} while (read_seqretry(&xtime_lock, seq));

	return now; 
}

EXPORT_SYMBOL(current_kernel_time);

/**
 * current_fs_time - Return FS time
 * @sb: Superblock.
 *
 * Return the current time truncated to the time granuality supported by
 * the fs.
 */
struct timespec current_fs_time(struct super_block *sb)
{
	struct timespec now = current_kernel_time();
	return timespec_trunc(now, sb->s_time_gran);
}
EXPORT_SYMBOL(current_fs_time);

/**
 * timespec_trunc - Truncate timespec to a granuality
 * @t: Timespec
 * @gran: Granuality in ns.
 *
 * Truncate a timespec to a granuality. gran must be smaller than a second.
 * Always rounds down.
 *
 * This function should be only used for timestamps returned by
 * current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
 * it doesn't handle the better resolution of the later.
 */
struct timespec timespec_trunc(struct timespec t, unsigned gran)
{
	/*
	 * Division is pretty slow so avoid it for common cases.
	 * Currently current_kernel_time() never returns better than
	 * jiffies resolution. Exploit that.
	 */
	if (gran <= jiffies_to_usecs(1) * 1000) {
		/* nothing */
	} else if (gran == 1000000000) {
		t.tv_nsec = 0;
	} else {
		t.tv_nsec -= t.tv_nsec % gran;
	}
	return t;
}
EXPORT_SYMBOL(timespec_trunc);

#ifdef CONFIG_TIME_INTERPOLATION
void getnstimeofday (struct timespec *tv)
{
	unsigned long seq,sec,nsec;

	do {
		seq = read_seqbegin(&xtime_lock);
		sec = xtime.tv_sec;
		nsec = xtime.tv_nsec+time_interpolator_get_offset();
	} while (unlikely(read_seqretry(&xtime_lock, seq)));

	while (unlikely(nsec >= NSEC_PER_SEC)) {
		nsec -= NSEC_PER_SEC;
		++sec;
	}
	tv->tv_sec = sec;
	tv->tv_nsec = nsec;
}
EXPORT_SYMBOL_GPL(getnstimeofday);

int do_settimeofday (struct timespec *tv)
{
	time_t wtm_sec, sec = tv->tv_sec;
	long wtm_nsec, nsec = tv->tv_nsec;

	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
		return -EINVAL;

	write_seqlock_irq(&xtime_lock);
	{
		wtm_sec  = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
		wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);

		set_normalized_timespec(&xtime, sec, nsec);
		set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);

		time_adjust = 0;		/* stop active adjtime() */
		time_status |= STA_UNSYNC;
		time_maxerror = NTP_PHASE_LIMIT;
		time_esterror = NTP_PHASE_LIMIT;
		time_interpolator_reset();
	}
	write_sequnlock_irq(&xtime_lock);
	clock_was_set();
	return 0;
}

void do_gettimeofday (struct timeval *tv)
{
	unsigned long seq, nsec, usec, sec, offset;
	do {
		seq = read_seqbegin(&xtime_lock);
		offset = time_interpolator_get_offset();
		sec = xtime.tv_sec;
		nsec = xtime.tv_nsec;
	} while (unlikely(read_seqretry(&xtime_lock, seq)));

	usec = (nsec + offset) / 1000;

	while (unlikely(usec >= USEC_PER_SEC)) {
		usec -= USEC_PER_SEC;
		++sec;
	}

	tv->tv_sec = sec;
	tv->tv_usec = usec;
}

EXPORT_SYMBOL(do_gettimeofday);


#else
/*
 * Simulate gettimeofday using do_gettimeofday which only allows a timeval
 * and therefore only yields usec accuracy
 */
void getnstimeofday(struct timespec *tv)
{
	struct timeval x;

	do_gettimeofday(&x);
	tv->tv_sec = x.tv_sec;
	tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
}
#endif

#if (BITS_PER_LONG < 64)
u64 get_jiffies_64(void)
{
	unsigned long seq;
	u64 ret;

	do {
		seq = read_seqbegin(&xtime_lock);
		ret = jiffies_64;
	} while (read_seqretry(&xtime_lock, seq));
	return ret;
}

EXPORT_SYMBOL(get_jiffies_64);
#endif

EXPORT_SYMBOL(jiffies);
1	niro	628	/*
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			inline static 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			if (ltemp < 0)
342			time_freq -= -ltemp >> SHIFT_KH;
343			else
344			time_freq += ltemp >> SHIFT_KH;
345			} else /* calibration interval too short (p. 12) */
346			result = TIME_ERROR;
347			} else { /* PLL mode */
348			if (mtemp < MAXSEC) {
349			ltemp *= mtemp;
350			if (ltemp < 0)
351			time_freq -= -ltemp >> (time_constant +
352			time_constant +
353			SHIFT_KF - SHIFT_USEC);
354			else
355			time_freq += ltemp >> (time_constant +
356			time_constant +
357			SHIFT_KF - SHIFT_USEC);
358			} else /* calibration interval too long (p. 12) */
359			result = TIME_ERROR;
360			}
361			if (time_freq > time_tolerance)
362			time_freq = time_tolerance;
363			else if (time_freq < -time_tolerance)
364			time_freq = -time_tolerance;
365			} /* STA_PLL \|\| STA_PPSTIME */
366			} /* txc->modes & ADJ_OFFSET */
367			if (txc->modes & ADJ_TICK) {
368			tick_usec = txc->tick;
369			tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
370			}
371			} /* txc->modes */
372			leave: if ((time_status & (STA_UNSYNC\|STA_CLOCKERR)) != 0
373			\|\| ((time_status & (STA_PPSFREQ\|STA_PPSTIME)) != 0
374			&& (time_status & STA_PPSSIGNAL) == 0)
375			/* p. 24, (b) */
376			\|\| ((time_status & (STA_PPSTIME\|STA_PPSJITTER))
377			== (STA_PPSTIME\|STA_PPSJITTER))
378			/* p. 24, (c) */
379			\|\| ((time_status & STA_PPSFREQ) != 0
380			&& (time_status & (STA_PPSWANDER\|STA_PPSERROR)) != 0))
381			/* p. 24, (d) */
382			result = TIME_ERROR;
383
384			if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
385			txc->offset = save_adjust;
386			else {
387			if (time_offset < 0)
388			txc->offset = -(-time_offset >> SHIFT_UPDATE);
389			else
390			txc->offset = time_offset >> SHIFT_UPDATE;
391			}
392			txc->freq = time_freq + pps_freq;
393			txc->maxerror = time_maxerror;
394			txc->esterror = time_esterror;
395			txc->status = time_status;
396			txc->constant = time_constant;
397			txc->precision = time_precision;
398			txc->tolerance = time_tolerance;
399			txc->tick = tick_usec;
400			txc->ppsfreq = pps_freq;
401			txc->jitter = pps_jitter >> PPS_AVG;
402			txc->shift = pps_shift;
403			txc->stabil = pps_stabil;
404			txc->jitcnt = pps_jitcnt;
405			txc->calcnt = pps_calcnt;
406			txc->errcnt = pps_errcnt;
407			txc->stbcnt = pps_stbcnt;
408			write_sequnlock_irq(&xtime_lock);
409			do_gettimeofday(&txc->time);
410			notify_arch_cmos_timer();
411			return(result);
412			}
413
414			asmlinkage long sys_adjtimex(struct timex __user *txc_p)
415			{
416			struct timex txc; /* Local copy of parameter */
417			int ret;
418
419			/* Copy the user data space into the kernel copy
420			* structure. But bear in mind that the structures
421			* may change
422			*/
423			if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
424			return -EFAULT;
425			ret = do_adjtimex(&txc);
426			return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
427			}
428
429			inline struct timespec current_kernel_time(void)
430			{
431			struct timespec now;
432			unsigned long seq;
433
434			do {
435			seq = read_seqbegin(&xtime_lock);
436
437			now = xtime;
438			} while (read_seqretry(&xtime_lock, seq));
439
440			return now;
441			}
442
443			EXPORT_SYMBOL(current_kernel_time);
444
445			/**
446			* current_fs_time - Return FS time
447			* @sb: Superblock.
448			*
449			* Return the current time truncated to the time granuality supported by
450			* the fs.
451			*/
452			struct timespec current_fs_time(struct super_block *sb)
453			{
454			struct timespec now = current_kernel_time();
455			return timespec_trunc(now, sb->s_time_gran);
456			}
457			EXPORT_SYMBOL(current_fs_time);
458
459			/**
460			* timespec_trunc - Truncate timespec to a granuality
461			* @t: Timespec
462			* @gran: Granuality in ns.
463			*
464			* Truncate a timespec to a granuality. gran must be smaller than a second.
465			* Always rounds down.
466			*
467			* This function should be only used for timestamps returned by
468			* current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
469			* it doesn't handle the better resolution of the later.
470			*/
471			struct timespec timespec_trunc(struct timespec t, unsigned gran)
472			{
473			/*
474			* Division is pretty slow so avoid it for common cases.
475			* Currently current_kernel_time() never returns better than
476			* jiffies resolution. Exploit that.
477			*/
478			if (gran <= jiffies_to_usecs(1) * 1000) {
479			/* nothing */
480			} else if (gran == 1000000000) {
481			t.tv_nsec = 0;
482			} else {
483			t.tv_nsec -= t.tv_nsec % gran;
484			}
485			return t;
486			}
487			EXPORT_SYMBOL(timespec_trunc);
488
489			#ifdef CONFIG_TIME_INTERPOLATION
490			void getnstimeofday (struct timespec *tv)
491			{
492			unsigned long seq,sec,nsec;
493
494			do {
495			seq = read_seqbegin(&xtime_lock);
496			sec = xtime.tv_sec;
497			nsec = xtime.tv_nsec+time_interpolator_get_offset();
498			} while (unlikely(read_seqretry(&xtime_lock, seq)));
499
500			while (unlikely(nsec >= NSEC_PER_SEC)) {
501			nsec -= NSEC_PER_SEC;
502			++sec;
503			}
504			tv->tv_sec = sec;
505			tv->tv_nsec = nsec;
506			}
507			EXPORT_SYMBOL_GPL(getnstimeofday);
508
509			int do_settimeofday (struct timespec *tv)
510			{
511			time_t wtm_sec, sec = tv->tv_sec;
512			long wtm_nsec, nsec = tv->tv_nsec;
513
514			if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
515			return -EINVAL;
516
517			write_seqlock_irq(&xtime_lock);
518			{
519			wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
520			wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
521
522			set_normalized_timespec(&xtime, sec, nsec);
523			set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
524
525			time_adjust = 0; /* stop active adjtime() */
526			time_status \|= STA_UNSYNC;
527			time_maxerror = NTP_PHASE_LIMIT;
528			time_esterror = NTP_PHASE_LIMIT;
529			time_interpolator_reset();
530			}
531			write_sequnlock_irq(&xtime_lock);
532			clock_was_set();
533			return 0;
534			}
535
536			void do_gettimeofday (struct timeval *tv)
537			{
538			unsigned long seq, nsec, usec, sec, offset;
539			do {
540			seq = read_seqbegin(&xtime_lock);
541			offset = time_interpolator_get_offset();
542			sec = xtime.tv_sec;
543			nsec = xtime.tv_nsec;
544			} while (unlikely(read_seqretry(&xtime_lock, seq)));
545
546			usec = (nsec + offset) / 1000;
547
548			while (unlikely(usec >= USEC_PER_SEC)) {
549			usec -= USEC_PER_SEC;
550			++sec;
551			}
552
553			tv->tv_sec = sec;
554			tv->tv_usec = usec;
555			}
556
557			EXPORT_SYMBOL(do_gettimeofday);
558
559
560			#else
561			/*
562			* Simulate gettimeofday using do_gettimeofday which only allows a timeval
563			* and therefore only yields usec accuracy
564			*/
565			void getnstimeofday(struct timespec *tv)
566			{
567			struct timeval x;
568
569			do_gettimeofday(&x);
570			tv->tv_sec = x.tv_sec;
571			tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
572			}
573			#endif
574
575			#if (BITS_PER_LONG < 64)
576			u64 get_jiffies_64(void)
577			{
578			unsigned long seq;
579			u64 ret;
580
581			do {
582			seq = read_seqbegin(&xtime_lock);
583			ret = jiffies_64;
584			} while (read_seqretry(&xtime_lock, seq));
585			return ret;
586			}
587
588			EXPORT_SYMBOL(get_jiffies_64);
589			#endif
590
591			EXPORT_SYMBOL(jiffies);