Subversion Repositories Kolibri OS

/*

 *  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/core.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 

#include 

# define USER_HZ        100

/*

 *

 * Avoid unnecessary multiplications/divisions in the

 * two most common HZ cases:

EXPORT_SYMBOL(jiffies_to_msecs);

EXPORT_SYMBOL(jiffies_to_usecs);

/**

 * timespec_trunc - Truncate timespec to a granularity

 * @t: Timespec

 * @gran: Granularity in ns.

 *

 * Truncate a timespec to a granularity. Always rounds down. gran must

 * not be 0 nor greater than a second (NSEC_PER_SEC, or 10^9 ns).

 */

struct timespec timespec_trunc(struct timespec t, unsigned gran)

{

	/* Avoid division in the common cases 1 ns and 1 s. */

	if (gran == 1) {

		/* nothing */

	} else if (gran == NSEC_PER_SEC) {

		t.tv_nsec = 0;

	} else if (gran > 1 && gran < NSEC_PER_SEC) {

		t.tv_nsec -= t.tv_nsec % gran;

	} else {

		WARN(1, "illegal file time granularity: %u", gran);

	}

	return t;

}

/*

 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.

 *

 * Britain & colonies before 1752, anywhere else before 1582,

 *

 * This algorithm was first published by Gauss (I think).

 */

time64_t mktime64(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;

	if (0 >= (int) (mon -= 2)) {

		mon += 12;	/* Puts Feb last since it has leap day */

		year -= 1;

	}

	return ((((time64_t)

		  (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(mktime64);

 * set_normalized_timespec - set timespec sec and nsec parts and normalize

 *

 * @ts:		pointer to timespec variable to be set

 * @sec:	seconds to set

 *

 * Note: The tv_nsec part is always in the range of

void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec)

	while (nsec >= NSEC_PER_SEC) {

		/*

		 * also __iter_div_u64_rem() in include/linux/time.h

		 */

		asm("" : "+rm"(nsec));

		nsec -= NSEC_PER_SEC;

	}

		asm("" : "+rm"(nsec));

		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;

		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;

/**

 *

 * 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);

#if BITS_PER_LONG == 32

/**

 * set_normalized_timespec - set timespec sec and nsec parts and normalize

 *

 * @ts:		pointer to timespec variable to be set

 * @nsec:	nanoseconds to set

 *

 * Set seconds and nanoseconds field of a timespec variable and

 *

 * 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 !

 */

{

		/*

		 * The following asm() prevents the compiler from

		 * optimising this loop into a modulo operation. See

		 * also __iter_div_u64_rem() in include/linux/time.h

		 */

		asm("" : "+rm"(nsec));

		nsec -= NSEC_PER_SEC;

		++sec;

	}

	while (nsec < 0) {

		asm("" : "+rm"(nsec));

		nsec += NSEC_PER_SEC;

		--sec;

	}

	ts->tv_sec = sec;

	ts->tv_nsec = nsec;

}

EXPORT_SYMBOL(set_normalized_timespec64);

 * Returns the timespec64 representation of the nsec parameter.

struct timespec64 ns_to_timespec64(const s64 nsec)

{

	struct timespec64 ts;

	s32 rem;

	if (!nsec)

		return (struct timespec64) {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_timespec64);

#endif

/**

 * msecs_to_jiffies: - convert milliseconds to jiffies

 * @m:	time in milliseconds

 *

 * conversion is done as follows:

 *

 * - 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 and

 *   handling any 32-bit overflows.

 *   for the details see __msecs_to_jiffies()

 *

 * msecs_to_jiffies() checks for the passed in value being a constant

 * via __builtin_constant_p() allowing gcc to eliminate most of the

 * code, __msecs_to_jiffies() is called if the value passed does not

 * allow constant folding and the actual conversion must be done at

 * runtime.

 * the _msecs_to_jiffies helpers are the HZ dependent conversion

{

	return __timespec64_to_jiffies((u64)sec, nsec);

}

unsigned long

	value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,

				    NSEC_PER_SEC, &rem);

	value->tv_nsec = rem;

}

EXPORT_SYMBOL(jiffies_to_timespec64);

/*

 * We could use a similar algorithm to timespec_to_jiffies (with a

 * different multiplier for usec instead of nsec). But this has a

 * problem with rounding: we can't exactly add TICK_NSEC - 1 to the

 * usec value, since it's not necessarily integral.

 *

 * We could instead round in the intermediate scaled representation

 * (i.e. in units of 1/2^(large scale) jiffies) but that's also

 * perilous: the scaling introduces a small positive error, which

 * combined with a division-rounding-upward (i.e. adding 2^(scale) - 1

 * units to the intermediate before shifting) leads to accidental

 * overflow and overestimates.

 *

 * At the cost of one additional multiplication by a constant, just

 * use the timespec implementation.

 */

unsigned long

timeval_to_jiffies(const struct timeval *value)

{

	return __timespec_to_jiffies(value->tv_sec,

				     value->tv_usec * NSEC_PER_USEC);

}

EXPORT_SYMBOL(timeval_to_jiffies);

void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)

{

	/*

	 * Convert jiffies to nanoseconds and separate with

	 * one divide.

	 */

	u32 rem;

	value->tv_sec = div_u64_rem((u64)jiffies * TICK_NSEC,

				    NSEC_PER_SEC, &rem);

	value->tv_usec = rem / NSEC_PER_USEC;

}

EXPORT_SYMBOL(jiffies_to_timeval);

/*

 * Convert jiffies/jiffies_64 to clock_t and back.

 */

clock_t jiffies_to_clock_t(unsigned long x)

{

#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0

# if HZ < USER_HZ

	return x * (USER_HZ / HZ);

# else

	return x / (HZ / USER_HZ);

# endif

#else

	return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);

#endif

}

EXPORT_SYMBOL(jiffies_to_clock_t);

unsigned long clock_t_to_jiffies(unsigned long x)

{

#if (HZ % USER_HZ)==0

	if (x >= ~0UL / (HZ / USER_HZ))

		return ~0UL;

	return x * (HZ / USER_HZ);

#else

	/* Don't worry about loss of precision here .. */

	if (x >= ~0UL / HZ * USER_HZ)

		return ~0UL;

	/* .. but do try to contain it here */

	return div_u64((u64)x * HZ, USER_HZ);

#endif

}

EXPORT_SYMBOL(clock_t_to_jiffies);

u64 jiffies_64_to_clock_t(u64 x)

{

#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0

# if HZ < USER_HZ

	x = div_u64(x * USER_HZ, HZ);

# elif HZ > USER_HZ

	x = div_u64(x, HZ / USER_HZ);

# else

	/* Nothing to do */

# endif

#else

	/*

	 * There are better ways that don't overflow early,

	 * but even this doesn't overflow in hundreds of years

	 * in 64 bits, so..

	 */

	x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));

#endif

	return x;

}

EXPORT_SYMBOL(jiffies_64_to_clock_t);

u64 nsec_to_clock_t(u64 x)

{

#if (NSEC_PER_SEC % USER_HZ) == 0

	return div_u64(x, NSEC_PER_SEC / USER_HZ);

#elif (USER_HZ % 512) == 0

	return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);

#else

	/*

         * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,

         * overflow after 64.99 years.

         * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...

         */

	return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);

#endif

}

/**

 * nsecs_to_jiffies64 - Convert nsecs in u64 to jiffies64

 *

 * @n:	nsecs in u64

 *

 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.

 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed

 * for scheduler, not for use in device drivers to calculate timeout value.

 *

 * note:

 *   NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)

 *   ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years

 */

u64 nsecs_to_jiffies64(u64 n)

{

#if (NSEC_PER_SEC % HZ) == 0

	/* Common case, HZ = 100, 128, 200, 250, 256, 500, 512, 1000 etc. */

	return div_u64(n, NSEC_PER_SEC / HZ);

#elif (HZ % 512) == 0

	/* overflow after 292 years if HZ = 1024 */

	return div_u64(n * HZ / 512, NSEC_PER_SEC / 512);

#else

	/*

	 * Generic case - optimized for cases where HZ is a multiple of 3.

	 * overflow after 64.99 years, exact for HZ = 60, 72, 90, 120 etc.

	 */

	return div_u64(n * 9, (9ull * NSEC_PER_SEC + HZ / 2) / HZ);

#endif

}

EXPORT_SYMBOL(nsecs_to_jiffies64);

/**

 * nsecs_to_jiffies - Convert nsecs in u64 to jiffies

 *

 * @n:	nsecs in u64

 *

 * Unlike {m,u}secs_to_jiffies, type of input is not unsigned int but u64.

 * And this doesn't return MAX_JIFFY_OFFSET since this function is designed

 * for scheduler, not for use in device drivers to calculate timeout value.

 *

 * note:

 *   NSEC_PER_SEC = 10^9 = (5^9 * 2^9) = (1953125 * 512)

 *   ULLONG_MAX ns = 18446744073.709551615 secs = about 584 years

 */

unsigned long nsecs_to_jiffies(u64 n)

{

	return (unsigned long)nsecs_to_jiffies64(n);

}

EXPORT_SYMBOL_GPL(nsecs_to_jiffies);

/*

 * Add two timespec values and do a safety check for overflow.

 * It's assumed that both values are valid (>= 0)

 */

struct timespec timespec_add_safe(const struct timespec lhs,

				  const struct timespec rhs)

{

	struct timespec res;

	set_normalized_timespec(&res, lhs.tv_sec + rhs.tv_sec,

				lhs.tv_nsec + rhs.tv_nsec);