[deliverable/linux.git] / 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/capability.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.
 */
static inline 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;

	if (tv && !timespec_valid(tv))
		return -EINVAL;

	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);
			    time_freq += shift_right(ltemp, SHIFT_KH);
			} else /* calibration interval too short (p. 12) */
				result = TIME_ERROR;
		    } else {	/* PLL mode */
		        if (mtemp < MAXSEC) {
			    ltemp *= mtemp;
			    time_freq += shift_right(ltemp,(time_constant +
						       time_constant +
						       SHIFT_KF - SHIFT_USEC));
			} else /* calibration interval too long (p. 12) */
				result = TIME_ERROR;
		    }
		    time_freq = min(time_freq, time_tolerance);
		    time_freq = max(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 {
	    txc->offset = shift_right(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;
}
EXPORT_SYMBOL(do_settimeofday);

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;
}
EXPORT_SYMBOL_GPL(getnstimeofday);
#endif

/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 *
 * [For the Julian calendar (which was used in Russia before 1917,
 * Britain & colonies before 1752, anywhere else before 1582,
 * and is still in use by some communities) leave out the
 * -year/100+year/400 terms, and add 10.]
 *
 * This algorithm was first published by Gauss (I think).
 *
 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 * machines were long is 32-bit! (However, as time_t is signed, we
 * will already get problems at other places on 2038-01-19 03:14:08)
 */
unsigned long
mktime(const unsigned int year0, const unsigned int mon0,
       const unsigned int day, const unsigned int hour,
       const unsigned int min, const unsigned int sec)
{
	unsigned int mon = mon0, year = year0;

	/* 1..12 -> 11,12,1..10 */
	if (0 >= (int) (mon -= 2)) {
		mon += 12;	/* Puts Feb last since it has leap day */
		year -= 1;
	}

	return ((((unsigned long)
		  (year/4 - year/100 + year/400 + 367*mon/12 + day) +
		  year*365 - 719499
	    )*24 + hour /* now have hours */
	  )*60 + min /* now have minutes */
	)*60 + sec; /* finally seconds */
}

EXPORT_SYMBOL(mktime);

/**
 * set_normalized_timespec - set timespec sec and nsec parts and normalize
 *
 * @ts:		pointer to timespec variable to be set
 * @sec:	seconds to set
 * @nsec:	nanoseconds to set
 *
 * Set seconds and nanoseconds field of a timespec variable and
 * normalize to the timespec storage format
 *
 * Note: The tv_nsec part is always in the range of
 * 	0 <= tv_nsec < NSEC_PER_SEC
 * For negative values only the tv_sec field is negative !
 */
void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
{
	while (nsec >= NSEC_PER_SEC) {
		nsec -= NSEC_PER_SEC;
		++sec;
	}
	while (nsec < 0) {
		nsec += NSEC_PER_SEC;
		--sec;
	}
	ts->tv_sec = sec;
	ts->tv_nsec = nsec;
}

/**
 * ns_to_timespec - Convert nanoseconds to timespec
 * @nsec:       the nanoseconds value to be converted
 *
 * Returns the timespec representation of the nsec parameter.
 */
struct timespec ns_to_timespec(const nsec_t nsec)
{
	struct timespec ts;

	if (!nsec)
		return (struct timespec) {0, 0};

	ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
	if (unlikely(nsec < 0))
		set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);

	return ts;
}

/**
 * ns_to_timeval - Convert nanoseconds to timeval
 * @nsec:       the nanoseconds value to be converted
 *
 * Returns the timeval representation of the nsec parameter.
 */
struct timeval ns_to_timeval(const nsec_t nsec)
{
	struct timespec ts = ns_to_timespec(nsec);
	struct timeval tv;

	tv.tv_sec = ts.tv_sec;
	tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;

	return tv;
}

#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);
Commit	Line	Data
	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/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>
	39
	40	#include <asm/uaccess.h>
	41	#include <asm/unistd.h>
	42
	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;
	48
	49	EXPORT_SYMBOL(sys_tz);
	50
	51	#ifdef __ARCH_WANT_SYS_TIME
	52
	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;
	63
	64	do_gettimeofday(&tv);
	65	i = tv.tv_sec;
	66
	67	if (tloc) {
	68	if (put_user(i,tloc))
	69	i = -EFAULT;
	70	}
	71	return i;
	72	}
	73
	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	*/
	80
	81	asmlinkage long sys_stime(time_t __user *tptr)
	82	{
	83	struct timespec tv;
	84	int err;
	85
	86	if (get_user(tv.tv_sec, tptr))
	87	return -EFAULT;
	88
	89	tv.tv_nsec = 0;
	90
	91	err = security_settime(&tv, NULL);
	92	if (err)
	93	return err;
	94
	95	do_settimeofday(&tv);
	96	return 0;
	97	}
	98
	99	#endif /* __ARCH_WANT_SYS_TIME */
	100
	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	}
	115
	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	}
	141
	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	*/
	152
	153	int do_sys_settimeofday(struct timespec tv, struct timezone tz)
	154	{
	155	static int firsttime = 1;
	156	int error = 0;
	157
	158	if (tv && !timespec_valid(tv))
	159	return -EINVAL;
	160
	161	error = security_settime(tv, tz);
	162	if (error)
	163	return error;
	164
	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	}
	183
	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;
	190
	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	}
	201
	202	return do_sys_settimeofday(tv ? &new_ts : NULL, tz ? &new_tz : NULL);
	203	}
	204
	205	long pps_offset; /* pps time offset (us) */
	206	long pps_jitter = MAXTIME; /* time dispersion (jitter) (us) */
	207
	208	long pps_freq; /* frequency offset (scaled ppm) */
	209	long pps_stabil = MAXFREQ; /* frequency dispersion (scaled ppm) */
	210
	211	long pps_valid = PPS_VALID; /* pps signal watchdog counter */
	212
	213	int pps_shift = PPS_SHIFT; /* interval duration (s) (shift) */
	214
	215	long pps_jitcnt; /* jitter limit exceeded */
	216	long pps_calcnt; /* calibration intervals */
	217	long pps_errcnt; /* calibration errors */
	218	long pps_stbcnt; /* stability limit exceeded */
	219
	220	/* hook for a loadable hardpps kernel module */
	221	void (hardpps_ptr)(struct timeval );
	222
	223	/* we call this to notify the arch when the clock is being
	224	* controlled. If no such arch routine, do nothing.
	225	*/
	226	void __attribute__ ((weak)) notify_arch_cmos_timer(void)
	227	{
	228	return;
	229	}
	230
	231	/* adjtimex mainly allows reading (and writing, if superuser) of
	232	* kernel time-keeping variables. used by xntpd.
	233	*/
	234	int do_adjtimex(struct timex *txc)
	235	{
	236	long ltemp, mtemp, save_adjust;
	237	int result;
	238
	239	/* In order to modify anything, you gotta be super-user! */
	240	if (txc->modes && !capable(CAP_SYS_TIME))
	241	return -EPERM;
	242
	243	/* Now we validate the data before disabling interrupts */
	244
	245	if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
	246	/* singleshot must not be used with any other mode bits */
	247	if (txc->modes != ADJ_OFFSET_SINGLESHOT)
	248	return -EINVAL;
	249
	250	if (txc->modes != ADJ_OFFSET_SINGLESHOT && (txc->modes & ADJ_OFFSET))
	251	/* adjustment Offset limited to +- .512 seconds */
	252	if (txc->offset <= - MAXPHASE \|\| txc->offset >= MAXPHASE )
	253	return -EINVAL;
	254
	255	/* if the quartz is off by more than 10% something is VERY wrong ! */
	256	if (txc->modes & ADJ_TICK)
	257	if (txc->tick < 900000/USER_HZ \|\|
	258	txc->tick > 1100000/USER_HZ)
	259	return -EINVAL;
	260
	261	write_seqlock_irq(&xtime_lock);
	262	result = time_state; /* mostly `TIME_OK' */
	263
	264	/* Save for later - semantics of adjtime is to return old value */
	265	save_adjust = time_next_adjust ? time_next_adjust : time_adjust;
	266
	267	#if 0 /* STA_CLOCKERR is never set yet */
	268	time_status &= ~STA_CLOCKERR; /* reset STA_CLOCKERR */
	269	#endif
	270	/* If there are input parameters, then process them */
	271	if (txc->modes)
	272	{
	273	if (txc->modes & ADJ_STATUS) /* only set allowed bits */
	274	time_status = (txc->status & ~STA_RONLY) \|
	275	(time_status & STA_RONLY);
	276
	277	if (txc->modes & ADJ_FREQUENCY) { /* p. 22 */
	278	if (txc->freq > MAXFREQ \|\| txc->freq < -MAXFREQ) {
	279	result = -EINVAL;
	280	goto leave;
	281	}
	282	time_freq = txc->freq - pps_freq;
	283	}
	284
	285	if (txc->modes & ADJ_MAXERROR) {
	286	if (txc->maxerror < 0 \|\| txc->maxerror >= NTP_PHASE_LIMIT) {
	287	result = -EINVAL;
	288	goto leave;
	289	}
	290	time_maxerror = txc->maxerror;
	291	}
	292
	293	if (txc->modes & ADJ_ESTERROR) {
	294	if (txc->esterror < 0 \|\| txc->esterror >= NTP_PHASE_LIMIT) {
	295	result = -EINVAL;
	296	goto leave;
	297	}
	298	time_esterror = txc->esterror;
	299	}
	300
	301	if (txc->modes & ADJ_TIMECONST) { /* p. 24 */
	302	if (txc->constant < 0) { /* NTP v4 uses values > 6 */
	303	result = -EINVAL;
	304	goto leave;
	305	}
	306	time_constant = txc->constant;
	307	}
	308
	309	if (txc->modes & ADJ_OFFSET) { /* values checked earlier */
	310	if (txc->modes == ADJ_OFFSET_SINGLESHOT) {
	311	/* adjtime() is independent from ntp_adjtime() */
	312	if ((time_next_adjust = txc->offset) == 0)
	313	time_adjust = 0;
	314	}
	315	else if ( time_status & (STA_PLL \| STA_PPSTIME) ) {
	316	ltemp = (time_status & (STA_PPSTIME \| STA_PPSSIGNAL)) ==
	317	(STA_PPSTIME \| STA_PPSSIGNAL) ?
	318	pps_offset : txc->offset;
	319
	320	/*
	321	* Scale the phase adjustment and
	322	* clamp to the operating range.
	323	*/
	324	if (ltemp > MAXPHASE)
	325	time_offset = MAXPHASE << SHIFT_UPDATE;
	326	else if (ltemp < -MAXPHASE)
	327	time_offset = -(MAXPHASE << SHIFT_UPDATE);
	328	else
	329	time_offset = ltemp << SHIFT_UPDATE;
	330
	331	/*
	332	* Select whether the frequency is to be controlled
	333	* and in which mode (PLL or FLL). Clamp to the operating
	334	* range. Ugly multiply/divide should be replaced someday.
	335	*/
	336
	337	if (time_status & STA_FREQHOLD \|\| time_reftime == 0)
	338	time_reftime = xtime.tv_sec;
	339	mtemp = xtime.tv_sec - time_reftime;
	340	time_reftime = xtime.tv_sec;
	341	if (time_status & STA_FLL) {
	342	if (mtemp >= MINSEC) {
	343	ltemp = (time_offset / mtemp) << (SHIFT_USEC -
	344	SHIFT_UPDATE);
	345	time_freq += shift_right(ltemp, SHIFT_KH);
	346	} else /* calibration interval too short (p. 12) */
	347	result = TIME_ERROR;
	348	} else { /* PLL mode */
	349	if (mtemp < MAXSEC) {
	350	ltemp *= mtemp;
	351	time_freq += shift_right(ltemp,(time_constant +
	352	time_constant +
	353	SHIFT_KF - SHIFT_USEC));
	354	} else /* calibration interval too long (p. 12) */
	355	result = TIME_ERROR;
	356	}
	357	time_freq = min(time_freq, time_tolerance);
	358	time_freq = max(time_freq, -time_tolerance);
	359	} /* STA_PLL \|\| STA_PPSTIME */
	360	} /* txc->modes & ADJ_OFFSET */
	361	if (txc->modes & ADJ_TICK) {
	362	tick_usec = txc->tick;
	363	tick_nsec = TICK_USEC_TO_NSEC(tick_usec);
	364	}
	365	} /* txc->modes */
	366	leave: if ((time_status & (STA_UNSYNC\|STA_CLOCKERR)) != 0
	367	\|\| ((time_status & (STA_PPSFREQ\|STA_PPSTIME)) != 0
	368	&& (time_status & STA_PPSSIGNAL) == 0)
	369	/* p. 24, (b) */
	370	\|\| ((time_status & (STA_PPSTIME\|STA_PPSJITTER))
	371	== (STA_PPSTIME\|STA_PPSJITTER))
	372	/* p. 24, (c) */
	373	\|\| ((time_status & STA_PPSFREQ) != 0
	374	&& (time_status & (STA_PPSWANDER\|STA_PPSERROR)) != 0))
	375	/* p. 24, (d) */
	376	result = TIME_ERROR;
	377
	378	if ((txc->modes & ADJ_OFFSET_SINGLESHOT) == ADJ_OFFSET_SINGLESHOT)
	379	txc->offset = save_adjust;
	380	else {
	381	txc->offset = shift_right(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	notify_arch_cmos_timer();
	402	return(result);
	403	}
	404
	405	asmlinkage long sys_adjtimex(struct timex __user *txc_p)
	406	{
	407	struct timex txc; /* Local copy of parameter */
	408	int ret;
	409
	410	/* Copy the user data space into the kernel copy
	411	* structure. But bear in mind that the structures
	412	* may change
	413	*/
	414	if(copy_from_user(&txc, txc_p, sizeof(struct timex)))
	415	return -EFAULT;
	416	ret = do_adjtimex(&txc);
	417	return copy_to_user(txc_p, &txc, sizeof(struct timex)) ? -EFAULT : ret;
	418	}
	419
	420	inline struct timespec current_kernel_time(void)
	421	{
	422	struct timespec now;
	423	unsigned long seq;
	424
	425	do {
	426	seq = read_seqbegin(&xtime_lock);
	427
	428	now = xtime;
	429	} while (read_seqretry(&xtime_lock, seq));
	430
	431	return now;
	432	}
	433
	434	EXPORT_SYMBOL(current_kernel_time);
	435
	436	/**
	437	* current_fs_time - Return FS time
	438	* @sb: Superblock.
	439	*
	440	* Return the current time truncated to the time granuality supported by
	441	* the fs.
	442	*/
	443	struct timespec current_fs_time(struct super_block *sb)
	444	{
	445	struct timespec now = current_kernel_time();
	446	return timespec_trunc(now, sb->s_time_gran);
	447	}
	448	EXPORT_SYMBOL(current_fs_time);
	449
	450	/**
	451	* timespec_trunc - Truncate timespec to a granuality
	452	* @t: Timespec
	453	* @gran: Granuality in ns.
	454	*
	455	* Truncate a timespec to a granuality. gran must be smaller than a second.
	456	* Always rounds down.
	457	*
	458	* This function should be only used for timestamps returned by
	459	* current_kernel_time() or CURRENT_TIME, not with do_gettimeofday() because
	460	* it doesn't handle the better resolution of the later.
	461	*/
	462	struct timespec timespec_trunc(struct timespec t, unsigned gran)
	463	{
	464	/*
	465	* Division is pretty slow so avoid it for common cases.
	466	* Currently current_kernel_time() never returns better than
	467	* jiffies resolution. Exploit that.
	468	*/
	469	if (gran <= jiffies_to_usecs(1) * 1000) {
	470	/* nothing */
	471	} else if (gran == 1000000000) {
	472	t.tv_nsec = 0;
	473	} else {
	474	t.tv_nsec -= t.tv_nsec % gran;
	475	}
	476	return t;
	477	}
	478	EXPORT_SYMBOL(timespec_trunc);
	479
	480	#ifdef CONFIG_TIME_INTERPOLATION
	481	void getnstimeofday (struct timespec *tv)
	482	{
	483	unsigned long seq,sec,nsec;
	484
	485	do {
	486	seq = read_seqbegin(&xtime_lock);
	487	sec = xtime.tv_sec;
	488	nsec = xtime.tv_nsec+time_interpolator_get_offset();
	489	} while (unlikely(read_seqretry(&xtime_lock, seq)));
	490
	491	while (unlikely(nsec >= NSEC_PER_SEC)) {
	492	nsec -= NSEC_PER_SEC;
	493	++sec;
	494	}
	495	tv->tv_sec = sec;
	496	tv->tv_nsec = nsec;
	497	}
	498	EXPORT_SYMBOL_GPL(getnstimeofday);
	499
	500	int do_settimeofday (struct timespec *tv)
	501	{
	502	time_t wtm_sec, sec = tv->tv_sec;
	503	long wtm_nsec, nsec = tv->tv_nsec;
	504
	505	if ((unsigned long)tv->tv_nsec >= NSEC_PER_SEC)
	506	return -EINVAL;
	507
	508	write_seqlock_irq(&xtime_lock);
	509	{
	510	wtm_sec = wall_to_monotonic.tv_sec + (xtime.tv_sec - sec);
	511	wtm_nsec = wall_to_monotonic.tv_nsec + (xtime.tv_nsec - nsec);
	512
	513	set_normalized_timespec(&xtime, sec, nsec);
	514	set_normalized_timespec(&wall_to_monotonic, wtm_sec, wtm_nsec);
	515
	516	time_adjust = 0; /* stop active adjtime() */
	517	time_status \|= STA_UNSYNC;
	518	time_maxerror = NTP_PHASE_LIMIT;
	519	time_esterror = NTP_PHASE_LIMIT;
	520	time_interpolator_reset();
	521	}
	522	write_sequnlock_irq(&xtime_lock);
	523	clock_was_set();
	524	return 0;
	525	}
	526	EXPORT_SYMBOL(do_settimeofday);
	527
	528	void do_gettimeofday (struct timeval *tv)
	529	{
	530	unsigned long seq, nsec, usec, sec, offset;
	531	do {
	532	seq = read_seqbegin(&xtime_lock);
	533	offset = time_interpolator_get_offset();
	534	sec = xtime.tv_sec;
	535	nsec = xtime.tv_nsec;
	536	} while (unlikely(read_seqretry(&xtime_lock, seq)));
	537
	538	usec = (nsec + offset) / 1000;
	539
	540	while (unlikely(usec >= USEC_PER_SEC)) {
	541	usec -= USEC_PER_SEC;
	542	++sec;
	543	}
	544
	545	tv->tv_sec = sec;
	546	tv->tv_usec = usec;
	547	}
	548
	549	EXPORT_SYMBOL(do_gettimeofday);
	550
	551
	552	#else
	553	/*
	554	* Simulate gettimeofday using do_gettimeofday which only allows a timeval
	555	* and therefore only yields usec accuracy
	556	*/
	557	void getnstimeofday(struct timespec *tv)
	558	{
	559	struct timeval x;
	560
	561	do_gettimeofday(&x);
	562	tv->tv_sec = x.tv_sec;
	563	tv->tv_nsec = x.tv_usec * NSEC_PER_USEC;
	564	}
	565	EXPORT_SYMBOL_GPL(getnstimeofday);
	566	#endif
	567
	568	/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
	569	* Assumes input in normal date format, i.e. 1980-12-31 23:59:59
	570	* => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
	571	*
	572	* [For the Julian calendar (which was used in Russia before 1917,
	573	* Britain & colonies before 1752, anywhere else before 1582,
	574	* and is still in use by some communities) leave out the
	575	* -year/100+year/400 terms, and add 10.]
	576	*
	577	* This algorithm was first published by Gauss (I think).
	578	*
	579	* WARNING: this function will overflow on 2106-02-07 06:28:16 on
	580	* machines were long is 32-bit! (However, as time_t is signed, we
	581	* will already get problems at other places on 2038-01-19 03:14:08)
	582	*/
	583	unsigned long
	584	mktime(const unsigned int year0, const unsigned int mon0,
	585	const unsigned int day, const unsigned int hour,
	586	const unsigned int min, const unsigned int sec)
	587	{
	588	unsigned int mon = mon0, year = year0;
	589
	590	/* 1..12 -> 11,12,1..10 */
	591	if (0 >= (int) (mon -= 2)) {
	592	mon += 12; /* Puts Feb last since it has leap day */
	593	year -= 1;
	594	}
	595
	596	return ((((unsigned long)
	597	(year/4 - year/100 + year/400 + 367*mon/12 + day) +
	598	year*365 - 719499
	599	)24 + hour / now have hours */
	600	)60 + min / now have minutes */
	601	)60 + sec; / finally seconds */
	602	}
	603
	604	EXPORT_SYMBOL(mktime);
	605
	606	/**
	607	* set_normalized_timespec - set timespec sec and nsec parts and normalize
	608	*
	609	* @ts: pointer to timespec variable to be set
	610	* @sec: seconds to set
	611	* @nsec: nanoseconds to set
	612	*
	613	* Set seconds and nanoseconds field of a timespec variable and
	614	* normalize to the timespec storage format
	615	*
	616	* Note: The tv_nsec part is always in the range of
	617	* 0 <= tv_nsec < NSEC_PER_SEC
	618	* For negative values only the tv_sec field is negative !
	619	*/
	620	void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec)
	621	{
	622	while (nsec >= NSEC_PER_SEC) {
	623	nsec -= NSEC_PER_SEC;
	624	++sec;
	625	}
	626	while (nsec < 0) {
	627	nsec += NSEC_PER_SEC;
	628	--sec;
	629	}
	630	ts->tv_sec = sec;
	631	ts->tv_nsec = nsec;
	632	}
	633
	634	/**
	635	* ns_to_timespec - Convert nanoseconds to timespec
	636	* @nsec: the nanoseconds value to be converted
	637	*
	638	* Returns the timespec representation of the nsec parameter.
	639	*/
	640	struct timespec ns_to_timespec(const nsec_t nsec)
	641	{
	642	struct timespec ts;
	643
	644	if (!nsec)
	645	return (struct timespec) {0, 0};
	646
	647	ts.tv_sec = div_long_long_rem_signed(nsec, NSEC_PER_SEC, &ts.tv_nsec);
	648	if (unlikely(nsec < 0))
	649	set_normalized_timespec(&ts, ts.tv_sec, ts.tv_nsec);
	650
	651	return ts;
	652	}
	653
	654	/**
	655	* ns_to_timeval - Convert nanoseconds to timeval
	656	* @nsec: the nanoseconds value to be converted
	657	*
	658	* Returns the timeval representation of the nsec parameter.
	659	*/
	660	struct timeval ns_to_timeval(const nsec_t nsec)
	661	{
	662	struct timespec ts = ns_to_timespec(nsec);
	663	struct timeval tv;
	664
	665	tv.tv_sec = ts.tv_sec;
	666	tv.tv_usec = (suseconds_t) ts.tv_nsec / 1000;
	667
	668	return tv;
	669	}
	670
	671	#if (BITS_PER_LONG < 64)
	672	u64 get_jiffies_64(void)
	673	{
	674	unsigned long seq;
	675	u64 ret;
	676
	677	do {
	678	seq = read_seqbegin(&xtime_lock);
	679	ret = jiffies_64;
	680	} while (read_seqretry(&xtime_lock, seq));
	681	return ret;
	682	}
	683
	684	EXPORT_SYMBOL(get_jiffies_64);
	685	#endif
	686
	687	EXPORT_SYMBOL(jiffies);