[mirror_ubuntu-artful-kernel.git] / include / linux / time.h

#ifndef _LINUX_TIME_H
#define _LINUX_TIME_H

# include <linux/cache.h>
# include <linux/seqlock.h>
# include <linux/math64.h>
# include <linux/time64.h>

extern struct timezone sys_tz;

int get_timespec64(struct timespec64 *ts,
		const struct timespec __user *uts);
int put_timespec64(const struct timespec64 *ts,
		struct timespec __user *uts);
int get_itimerspec64(struct itimerspec64 *it,
			const struct itimerspec __user *uit);
int put_itimerspec64(const struct itimerspec64 *it,
			struct itimerspec __user *uit);

#define TIME_T_MAX	(time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)

static inline int timespec_equal(const struct timespec *a,
                                 const struct timespec *b)
{
	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
}

/*
 * lhs < rhs:  return <0
 * lhs == rhs: return 0
 * lhs > rhs:  return >0
 */
static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
{
	if (lhs->tv_sec < rhs->tv_sec)
		return -1;
	if (lhs->tv_sec > rhs->tv_sec)
		return 1;
	return lhs->tv_nsec - rhs->tv_nsec;
}

static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
{
	if (lhs->tv_sec < rhs->tv_sec)
		return -1;
	if (lhs->tv_sec > rhs->tv_sec)
		return 1;
	return lhs->tv_usec - rhs->tv_usec;
}

extern time64_t mktime64(const unsigned int year, const unsigned int mon,
			const unsigned int day, const unsigned int hour,
			const unsigned int min, const unsigned int sec);

/**
 * Deprecated. Use mktime64().
 */
static inline unsigned long mktime(const unsigned int year,
			const unsigned int mon, const unsigned int day,
			const unsigned int hour, const unsigned int min,
			const unsigned int sec)
{
	return mktime64(year, mon, day, hour, min, sec);
}

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

/*
 * timespec_add_safe assumes both values are positive and checks
 * for overflow. It will return TIME_T_MAX if the reutrn would be
 * smaller then either of the arguments.
 */
extern struct timespec timespec_add_safe(const struct timespec lhs,
					 const struct timespec rhs);


static inline struct timespec timespec_add(struct timespec lhs,
						struct timespec rhs)
{
	struct timespec ts_delta;
	set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
				lhs.tv_nsec + rhs.tv_nsec);
	return ts_delta;
}

/*
 * sub = lhs - rhs, in normalized form
 */
static inline struct timespec timespec_sub(struct timespec lhs,
						struct timespec rhs)
{
	struct timespec ts_delta;
	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
				lhs.tv_nsec - rhs.tv_nsec);
	return ts_delta;
}

/*
 * Returns true if the timespec is norm, false if denorm:
 */
static inline bool timespec_valid(const struct timespec *ts)
{
	/* Dates before 1970 are bogus */
	if (ts->tv_sec < 0)
		return false;
	/* Can't have more nanoseconds then a second */
	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
		return false;
	return true;
}

static inline bool timespec_valid_strict(const struct timespec *ts)
{
	if (!timespec_valid(ts))
		return false;
	/* Disallow values that could overflow ktime_t */
	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
		return false;
	return true;
}

static inline bool timeval_valid(const struct timeval *tv)
{
	/* Dates before 1970 are bogus */
	if (tv->tv_sec < 0)
		return false;

	/* Can't have more microseconds then a second */
	if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
		return false;

	return true;
}

extern struct timespec timespec_trunc(struct timespec t, unsigned gran);

/*
 * Validates if a timespec/timeval used to inject a time offset is valid.
 * Offsets can be postive or negative. The value of the timeval/timespec
 * is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must
 * always be non-negative.
 */
static inline bool timeval_inject_offset_valid(const struct timeval *tv)
{
	/* We don't check the tv_sec as it can be positive or negative */

	/* Can't have more microseconds then a second */
	if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
		return false;
	return true;
}

static inline bool timespec_inject_offset_valid(const struct timespec *ts)
{
	/* We don't check the tv_sec as it can be positive or negative */

	/* Can't have more nanoseconds then a second */
	if (ts->tv_nsec < 0 || ts->tv_nsec >= NSEC_PER_SEC)
		return false;
	return true;
}

/* Some architectures do not supply their own clocksource.
 * This is mainly the case in architectures that get their
 * inter-tick times by reading the counter on their interval
 * timer. Since these timers wrap every tick, they're not really
 * useful as clocksources. Wrapping them to act like one is possible
 * but not very efficient. So we provide a callout these arches
 * can implement for use with the jiffies clocksource to provide
 * finer then tick granular time.
 */
#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
extern u32 (*arch_gettimeoffset)(void);
#endif

struct itimerval;
extern int do_setitimer(int which, struct itimerval *value,
			struct itimerval *ovalue);
extern int do_getitimer(int which, struct itimerval *value);

extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);

/*
 * Similar to the struct tm in userspace <time.h>, but it needs to be here so
 * that the kernel source is self contained.
 */
struct tm {
	/*
	 * the number of seconds after the minute, normally in the range
	 * 0 to 59, but can be up to 60 to allow for leap seconds
	 */
	int tm_sec;
	/* the number of minutes after the hour, in the range 0 to 59*/
	int tm_min;
	/* the number of hours past midnight, in the range 0 to 23 */
	int tm_hour;
	/* the day of the month, in the range 1 to 31 */
	int tm_mday;
	/* the number of months since January, in the range 0 to 11 */
	int tm_mon;
	/* the number of years since 1900 */
	long tm_year;
	/* the number of days since Sunday, in the range 0 to 6 */
	int tm_wday;
	/* the number of days since January 1, in the range 0 to 365 */
	int tm_yday;
};

void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);

/**
 * time_to_tm - converts the calendar time to local broken-down time
 *
 * @totalsecs	the number of seconds elapsed since 00:00:00 on January 1, 1970,
 *		Coordinated Universal Time (UTC).
 * @offset	offset seconds adding to totalsecs.
 * @result	pointer to struct tm variable to receive broken-down time
 */
static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
{
	time64_to_tm(totalsecs, offset, result);
}

/**
 * timespec_to_ns - Convert timespec to nanoseconds
 * @ts:		pointer to the timespec variable to be converted
 *
 * Returns the scalar nanosecond representation of the timespec
 * parameter.
 */
static inline s64 timespec_to_ns(const struct timespec *ts)
{
	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
}

/**
 * timeval_to_ns - Convert timeval to nanoseconds
 * @ts:		pointer to the timeval variable to be converted
 *
 * Returns the scalar nanosecond representation of the timeval
 * parameter.
 */
static inline s64 timeval_to_ns(const struct timeval *tv)
{
	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
		tv->tv_usec * NSEC_PER_USEC;
}

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

/**
 * ns_to_timeval - Convert nanoseconds to timeval
 * @nsec:	the nanoseconds value to be converted
 *
 * Returns the timeval representation of the nsec parameter.
 */
extern struct timeval ns_to_timeval(const s64 nsec);

/**
 * timespec_add_ns - Adds nanoseconds to a timespec
 * @a:		pointer to timespec to be incremented
 * @ns:		unsigned nanoseconds value to be added
 *
 * This must always be inlined because its used from the x86-64 vdso,
 * which cannot call other kernel functions.
 */
static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
{
	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
	a->tv_nsec = ns;
}

static inline bool itimerspec64_valid(const struct itimerspec64 *its)
{
	if (!timespec64_valid(&(its->it_interval)) ||
		!timespec64_valid(&(its->it_value)))
		return false;

	return true;
}

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _LINUX_TIME_H
	2	#define _LINUX_TIME_H
	3
82644459	4	# include <linux/cache.h>
57a55875	5	# include <linux/seqlock.h>
f595ec96	6	# include <linux/math64.h>
361a3bf0	7	# include <linux/time64.h>
1da177e4	8
b418da16 CH	9	extern struct timezone sys_tz;
b418da16 CH	10
f59dd9c8 DD	11	int get_timespec64(struct timespec64 *ts,
	12	const struct timespec __user *uts);
	13	int put_timespec64(const struct timespec64 *ts,
	14	struct timespec __user *uts);
d5b7ffbf DD	15	int get_itimerspec64(struct itimerspec64 *it,
	16	const struct itimerspec __user *uit);
	17	int put_itimerspec64(const struct itimerspec64 *it,
	18	struct itimerspec __user *uit);
f59dd9c8	19
df0cc053 TG	20	#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
df0cc053 TG	21
5b78cc9a JE	22	static inline int timespec_equal(const struct timespec *a,
5b78cc9a JE	23	const struct timespec *b)
57a55875	24	{
1da177e4	25	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
57a55875	26	}
1da177e4	27
643a6545 AM	28	/*
	29	* lhs < rhs: return <0
	30	* lhs == rhs: return 0
	31	* lhs > rhs: return >0
	32	*/
77adbfbf	33	static inline int timespec_compare(const struct timespec lhs, const struct timespec rhs)
643a6545 AM	34	{
	35	if (lhs->tv_sec < rhs->tv_sec)
	36	return -1;
	37	if (lhs->tv_sec > rhs->tv_sec)
	38	return 1;
	39	return lhs->tv_nsec - rhs->tv_nsec;
	40	}
	41
77adbfbf	42	static inline int timeval_compare(const struct timeval lhs, const struct timeval rhs)
643a6545 AM	43	{
	44	if (lhs->tv_sec < rhs->tv_sec)
	45	return -1;
	46	if (lhs->tv_sec > rhs->tv_sec)
	47	return 1;
	48	return lhs->tv_usec - rhs->tv_usec;
	49	}
	50
90b6ce9c	51	extern time64_t mktime64(const unsigned int year, const unsigned int mon,
	52	const unsigned int day, const unsigned int hour,
	53	const unsigned int min, const unsigned int sec);
	54
	55	/**
	56	* Deprecated. Use mktime64().
	57	*/
	58	static inline unsigned long mktime(const unsigned int year,
	59	const unsigned int mon, const unsigned int day,
	60	const unsigned int hour, const unsigned int min,
	61	const unsigned int sec)
	62	{
	63	return mktime64(year, mon, day, hour, min, sec);
	64	}
f4818900	65
12e09337	66	extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
ce3bf7ab JS	67
	68	/*
	69	* timespec_add_safe assumes both values are positive and checks
	70	* for overflow. It will return TIME_T_MAX if the reutrn would be
	71	* smaller then either of the arguments.
	72	*/
df0cc053 TG	73	extern struct timespec timespec_add_safe(const struct timespec lhs,
df0cc053 TG	74	const struct timespec rhs);
1da177e4	75
ce3bf7ab JS	76
	77	static inline struct timespec timespec_add(struct timespec lhs,
	78	struct timespec rhs)
	79	{
	80	struct timespec ts_delta;
	81	set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
	82	lhs.tv_nsec + rhs.tv_nsec);
	83	return ts_delta;
	84	}
	85
ca74e92b SN	86	/*
	87	* sub = lhs - rhs, in normalized form
	88	*/
	89	static inline struct timespec timespec_sub(struct timespec lhs,
	90	struct timespec rhs)
	91	{
	92	struct timespec ts_delta;
	93	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
	94	lhs.tv_nsec - rhs.tv_nsec);
	95	return ts_delta;
	96	}
	97
5f82b2b7 TG	98	/*
	99	* Returns true if the timespec is norm, false if denorm:
	100	*/
4e8b1452 JS	101	static inline bool timespec_valid(const struct timespec *ts)
	102	{
	103	/* Dates before 1970 are bogus */
	104	if (ts->tv_sec < 0)
	105	return false;
	106	/* Can't have more nanoseconds then a second */
	107	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
	108	return false;
cee58483 JS	109	return true;
	110	}
	111
	112	static inline bool timespec_valid_strict(const struct timespec *ts)
	113	{
	114	if (!timespec_valid(ts))
	115	return false;
4e8b1452 JS	116	/* Disallow values that could overflow ktime_t */
	117	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
	118	return false;
	119	return true;
	120	}
5f82b2b7	121
6ada1fc0 SL	122	static inline bool timeval_valid(const struct timeval *tv)
	123	{
	124	/* Dates before 1970 are bogus */
	125	if (tv->tv_sec < 0)
	126	return false;
	127
	128	/* Can't have more microseconds then a second */
	129	if (tv->tv_usec < 0 \|\| tv->tv_usec >= USEC_PER_SEC)
	130	return false;
	131
	132	return true;
	133	}
	134
8b094cd0	135	extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
1da177e4	136
37cf4dc3 JS	137	/*
	138	* Validates if a timespec/timeval used to inject a time offset is valid.
	139	* Offsets can be postive or negative. The value of the timeval/timespec
	140	* is the sum of its fields, but NOTE: the field tv_usec/tv_nsec must
	141	* always be non-negative.
	142	*/
	143	static inline bool timeval_inject_offset_valid(const struct timeval *tv)
	144	{
	145	/* We don't check the tv_sec as it can be positive or negative */
	146
	147	/* Can't have more microseconds then a second */
	148	if (tv->tv_usec < 0 \|\| tv->tv_usec >= USEC_PER_SEC)
	149	return false;
	150	return true;
	151	}
	152
	153	static inline bool timespec_inject_offset_valid(const struct timespec *ts)
	154	{
	155	/* We don't check the tv_sec as it can be positive or negative */
	156
	157	/* Can't have more nanoseconds then a second */
	158	if (ts->tv_nsec < 0 \|\| ts->tv_nsec >= NSEC_PER_SEC)
	159	return false;
	160	return true;
	161	}
	162
7d27558c JS	163	/* Some architectures do not supply their own clocksource.
	164	* This is mainly the case in architectures that get their
	165	* inter-tick times by reading the counter on their interval
	166	* timer. Since these timers wrap every tick, they're not really
	167	* useful as clocksources. Wrapping them to act like one is possible
	168	* but not very efficient. So we provide a callout these arches
	169	* can implement for use with the jiffies clocksource to provide
	170	* finer then tick granular time.
	171	*/
	172	#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
7b1f6207	173	extern u32 (*arch_gettimeoffset)(void);
7d27558c JS	174	#endif
7d27558c JS	175
1da177e4	176	struct itimerval;
57a55875 IM	177	extern int do_setitimer(int which, struct itimerval *value,
57a55875 IM	178	struct itimerval *ovalue);
1da177e4	179	extern int do_getitimer(int which, struct itimerval *value);
1da177e4	180
8b094cd0	181	extern long do_utimes(int dfd, const char __user filename, struct timespec times, int flags);
1da177e4	182
57f1f087 Z	183	/*
	184	* Similar to the struct tm in userspace <time.h>, but it needs to be here so
	185	* that the kernel source is self contained.
	186	*/
	187	struct tm {
	188	/*
	189	* the number of seconds after the minute, normally in the range
	190	* 0 to 59, but can be up to 60 to allow for leap seconds
	191	*/
	192	int tm_sec;
	193	/* the number of minutes after the hour, in the range 0 to 59*/
	194	int tm_min;
	195	/* the number of hours past midnight, in the range 0 to 23 */
	196	int tm_hour;
	197	/* the day of the month, in the range 1 to 31 */
	198	int tm_mday;
	199	/* the number of months since January, in the range 0 to 11 */
	200	int tm_mon;
	201	/* the number of years since 1900 */
	202	long tm_year;
	203	/* the number of days since Sunday, in the range 0 to 6 */
	204	int tm_wday;
	205	/* the number of days since January 1, in the range 0 to 365 */
	206	int tm_yday;
	207	};
	208
e6c2682a DD	209	void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
	210
	211	/**
	212	* time_to_tm - converts the calendar time to local broken-down time
	213	*
	214	* @totalsecs the number of seconds elapsed since 00:00:00 on January 1, 1970,
	215	* Coordinated Universal Time (UTC).
	216	* @offset offset seconds adding to totalsecs.
	217	* @result pointer to struct tm variable to receive broken-down time
	218	*/
	219	static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
	220	{
	221	time64_to_tm(totalsecs, offset, result);
	222	}
57f1f087	223
f8f46da3 TG	224	/**
	225	* timespec_to_ns - Convert timespec to nanoseconds
	226	* @ts: pointer to the timespec variable to be converted
	227	*
	228	* Returns the scalar nanosecond representation of the timespec
	229	* parameter.
	230	*/
df869b63	231	static inline s64 timespec_to_ns(const struct timespec *ts)
f8f46da3	232	{
df869b63	233	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
f8f46da3 TG	234	}
	235
	236	/**
	237	* timeval_to_ns - Convert timeval to nanoseconds
	238	* @ts: pointer to the timeval variable to be converted
	239	*
	240	* Returns the scalar nanosecond representation of the timeval
	241	* parameter.
	242	*/
df869b63	243	static inline s64 timeval_to_ns(const struct timeval *tv)
f8f46da3	244	{
df869b63	245	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
f8f46da3 TG	246	tv->tv_usec * NSEC_PER_USEC;
	247	}
	248
	249	/**
	250	* ns_to_timespec - Convert nanoseconds to timespec
	251	* @nsec: the nanoseconds value to be converted
	252	*
	253	* Returns the timespec representation of the nsec parameter.
	254	*/
df869b63	255	extern struct timespec ns_to_timespec(const s64 nsec);
f8f46da3 TG	256
	257	/**
	258	* ns_to_timeval - Convert nanoseconds to timeval
	259	* @nsec: the nanoseconds value to be converted
	260	*
	261	* Returns the timeval representation of the nsec parameter.
	262	*/
df869b63	263	extern struct timeval ns_to_timeval(const s64 nsec);
f8f46da3	264
cf3c769b JS	265	/**
	266	* timespec_add_ns - Adds nanoseconds to a timespec
	267	* @a: pointer to timespec to be incremented
	268	* @ns: unsigned nanoseconds value to be added
9412e286 JF	269	*
	270	* This must always be inlined because its used from the x86-64 vdso,
	271	* which cannot call other kernel functions.
cf3c769b	272	*/
9412e286	273	static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
cf3c769b	274	{
9412e286	275	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
cf3c769b JS	276	a->tv_nsec = ns;
cf3c769b JS	277	}
8b3d1cda	278
d5b7ffbf DD	279	static inline bool itimerspec64_valid(const struct itimerspec64 *its)
	280	{
	281	if (!timespec64_valid(&(its->it_interval)) \|\|
	282	!timespec64_valid(&(its->it_value)))
	283	return false;
	284
	285	return true;
	286	}
	287
1da177e4	288	#endif