/* *  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/clocksource.h>#include <linux/errno.h>#include <linux/syscalls.h>#include <linux/security.h>#include <linux/fs.h>#include <linux/slab.h>#include <linux/math64.h> #include <asm/uaccess.h>#include <asm/unistd.h> #include "timeconst.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 = get_seconds(); 	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;	update_xtime_cache(0);	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;		update_vsyscall_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);} 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;} /** * current_fs_time - Return FS time * @sb: Superblock. * * Return the current time truncated to the time granularity 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); /* * Convert jiffies to milliseconds and back. * * Avoid unnecessary multiplications/divisions in the * two most common HZ cases: */unsigned int inline jiffies_to_msecs(const unsigned long j){#if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)	return (MSEC_PER_SEC / HZ) * j;#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)	return (j + (HZ / MSEC_PER_SEC) - 1)/(HZ / MSEC_PER_SEC);#else# if BITS_PER_LONG == 32	return (HZ_TO_MSEC_MUL32 * j) >> HZ_TO_MSEC_SHR32;# else	return (j * HZ_TO_MSEC_NUM) / HZ_TO_MSEC_DEN;# endif#endif}EXPORT_SYMBOL(jiffies_to_msecs); unsigned int inline jiffies_to_usecs(const unsigned long j){#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)	return (USEC_PER_SEC / HZ) * j;#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)	return (j + (HZ / USEC_PER_SEC) - 1)/(HZ / USEC_PER_SEC);#else# if BITS_PER_LONG == 32	return (HZ_TO_USEC_MUL32 * j) >> HZ_TO_USEC_SHR32;# else	return (j * HZ_TO_USEC_NUM) / HZ_TO_USEC_DEN;# endif#endif}EXPORT_SYMBOL(jiffies_to_usecs); /** * timespec_trunc - Truncate timespec to a granularity * @t: Timespec * @gran: Granularity in ns. * * Truncate a timespec to a granularity. 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 latter. */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); #ifndef CONFIG_GENERIC_TIME/* * 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 where 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 longmktime(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;}EXPORT_SYMBOL(set_normalized_timespec); /** * 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 s64 nsec){	struct timespec ts;	s32 rem; 	if (!nsec)		return (struct timespec) {0, 0}; 	ts.tv_sec = div_s64_rem(nsec, NSEC_PER_SEC, &rem);	if (unlikely(rem < 0)) {		ts.tv_sec--;		rem += NSEC_PER_SEC;	}	ts.tv_nsec = rem; 	return ts;}EXPORT_SYMBOL(ns_to_timespec); /** * 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 s64 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;}EXPORT_SYMBOL(ns_to_timeval); /* * When we convert to jiffies then we interpret incoming values * the following way: * * - negative values mean 'infinite timeout' (MAX_JIFFY_OFFSET) * * - 'too large' values [that would result in larger than *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too. * * - all other values are converted to jiffies by either multiplying *   the input value by a factor or dividing it with a factor * * We must also be careful about 32-bit overflows. */unsigned long msecs_to_jiffies(const unsigned int m){	/*	 * Negative value, means infinite timeout:	 */	if ((int)m < 0)		return MAX_JIFFY_OFFSET; #if HZ <= MSEC_PER_SEC && !(MSEC_PER_SEC % HZ)	/*	 * HZ is equal to or smaller than 1000, and 1000 is a nice	 * round multiple of HZ, divide with the factor between them,	 * but round upwards:	 */	return (m + (MSEC_PER_SEC / HZ) - 1) / (MSEC_PER_SEC / HZ);#elif HZ > MSEC_PER_SEC && !(HZ % MSEC_PER_SEC)	/*	 * HZ is larger than 1000, and HZ is a nice round multiple of	 * 1000 - simply multiply with the factor between them.	 *	 * But first make sure the multiplication result cannot	 * overflow:	 */	if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))		return MAX_JIFFY_OFFSET; 	return m * (HZ / MSEC_PER_SEC);#else	/*	 * Generic case - multiply, round and divide. But first	 * check that if we are doing a net multiplication, that	 * we wouldn't overflow:	 */	if (HZ > MSEC_PER_SEC && m > jiffies_to_msecs(MAX_JIFFY_OFFSET))		return MAX_JIFFY_OFFSET; 	return (MSEC_TO_HZ_MUL32 * m + MSEC_TO_HZ_ADJ32)		>> MSEC_TO_HZ_SHR32;#endif}EXPORT_SYMBOL(msecs_to_jiffies); unsigned long usecs_to_jiffies(const unsigned int u){	if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))		return MAX_JIFFY_OFFSET;#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)	return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)	return u * (HZ / USEC_PER_SEC);#else	return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)		>> USEC_TO_HZ_SHR32;#endif}EXPORT_SYMBOL(usecs_to_jiffies); /*

Lines 1–500 of 689. Load more