WebSVN – Kolibri OS – Blame – /drivers/include/linux/time.h

Rev	Author	Line No.	Line
4065	Serge	1	#ifndef _LINUX_TIME_H
		2	#define _LINUX_TIME_H
		3
5270	serge	4	# include
		5	# include
4065	Serge	6	# include
5270	serge	7	# include
4065	Serge	8
		9	extern struct timezone sys_tz;
		10
		11	#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
		12
		13	static inline int timespec_equal(const struct timespec *a,
		14	const struct timespec *b)
		15	{
		16	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
		17	}
		18
		19	/*
		20	* lhs < rhs: return <0
		21	* lhs == rhs: return 0
		22	* lhs > rhs: return >0
		23	*/
		24	static inline int timespec_compare(const struct timespec lhs, const struct timespec rhs)
		25	{
		26	if (lhs->tv_sec < rhs->tv_sec)
		27	return -1;
		28	if (lhs->tv_sec > rhs->tv_sec)
		29	return 1;
		30	return lhs->tv_nsec - rhs->tv_nsec;
		31	}
		32
		33	static inline int timeval_compare(const struct timeval lhs, const struct timeval rhs)
		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_usec - rhs->tv_usec;
		40	}
		41
5270	serge	42	extern time64_t mktime64(const unsigned int year, const unsigned int mon,
4065	Serge	43	const unsigned int day, const unsigned int hour,
		44	const unsigned int min, const unsigned int sec);
		45
5270	serge	46	/**
		47	* Deprecated. Use mktime64().
		48	*/
		49	static inline unsigned long mktime(const unsigned int year,
		50	const unsigned int mon, const unsigned int day,
		51	const unsigned int hour, const unsigned int min,
		52	const unsigned int sec)
		53	{
		54	return mktime64(year, mon, day, hour, min, sec);
		55	}
		56
4065	Serge	57	extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
		58
		59	/*
		60	* timespec_add_safe assumes both values are positive and checks
		61	* for overflow. It will return TIME_T_MAX if the reutrn would be
		62	* smaller then either of the arguments.
		63	*/
		64	extern struct timespec timespec_add_safe(const struct timespec lhs,
		65	const struct timespec rhs);
		66
		67
		68	static inline struct timespec timespec_add(struct timespec lhs,
		69	struct timespec rhs)
		70	{
		71	struct timespec ts_delta;
		72	set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
		73	lhs.tv_nsec + rhs.tv_nsec);
		74	return ts_delta;
		75	}
		76
		77	/*
		78	* sub = lhs - rhs, in normalized form
		79	*/
		80	static inline struct timespec timespec_sub(struct timespec lhs,
		81	struct timespec rhs)
		82	{
		83	struct timespec ts_delta;
		84	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
		85	lhs.tv_nsec - rhs.tv_nsec);
		86	return ts_delta;
		87	}
		88
		89	/*
		90	* Returns true if the timespec is norm, false if denorm:
		91	*/
		92	static inline bool timespec_valid(const struct timespec *ts)
		93	{
		94	/* Dates before 1970 are bogus */
		95	if (ts->tv_sec < 0)
		96	return false;
		97	/* Can't have more nanoseconds then a second */
		98	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
		99	return false;
		100	return true;
		101	}
		102
		103	static inline bool timespec_valid_strict(const struct timespec *ts)
		104	{
		105	if (!timespec_valid(ts))
		106	return false;
		107	/* Disallow values that could overflow ktime_t */
		108	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
		109	return false;
		110	return true;
		111	}
		112
5270	serge	113	extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
4065	Serge	114
		115	#define CURRENT_TIME (current_kernel_time())
		116	#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
		117
		118	/* Some architectures do not supply their own clocksource.
		119	* This is mainly the case in architectures that get their
		120	* inter-tick times by reading the counter on their interval
		121	* timer. Since these timers wrap every tick, they're not really
		122	* useful as clocksources. Wrapping them to act like one is possible
		123	* but not very efficient. So we provide a callout these arches
		124	* can implement for use with the jiffies clocksource to provide
		125	* finer then tick granular time.
		126	*/
		127	#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
		128	extern u32 (*arch_gettimeoffset)(void);
		129	#endif
		130
		131	struct itimerval;
		132	extern int do_setitimer(int which, struct itimerval *value,
		133	struct itimerval *ovalue);
		134	extern int do_getitimer(int which, struct itimerval *value);
		135
5270	serge	136	extern unsigned int alarm_setitimer(unsigned int seconds);
4065	Serge	137
5270	serge	138	extern long do_utimes(int dfd, const char __user filename, struct timespec times, int flags);
		139
4065	Serge	140	struct tms;
		141	extern void do_sys_times(struct tms *);
		142
		143	/*
		144	* Similar to the struct tm in userspace , but it needs to be here so
		145	* that the kernel source is self contained.
		146	*/
		147	struct tm {
		148	/*
		149	* the number of seconds after the minute, normally in the range
		150	* 0 to 59, but can be up to 60 to allow for leap seconds
		151	*/
		152	int tm_sec;
		153	/* the number of minutes after the hour, in the range 0 to 59*/
		154	int tm_min;
		155	/* the number of hours past midnight, in the range 0 to 23 */
		156	int tm_hour;
		157	/* the day of the month, in the range 1 to 31 */
		158	int tm_mday;
		159	/* the number of months since January, in the range 0 to 11 */
		160	int tm_mon;
		161	/* the number of years since 1900 */
		162	long tm_year;
		163	/* the number of days since Sunday, in the range 0 to 6 */
		164	int tm_wday;
		165	/* the number of days since January 1, in the range 0 to 365 */
		166	int tm_yday;
		167	};
		168
		169	void time_to_tm(time_t totalsecs, int offset, struct tm *result);
		170
		171	/**
		172	* timespec_to_ns - Convert timespec to nanoseconds
		173	* @ts: pointer to the timespec variable to be converted
		174	*
		175	* Returns the scalar nanosecond representation of the timespec
		176	* parameter.
		177	*/
		178	static inline s64 timespec_to_ns(const struct timespec *ts)
		179	{
		180	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
		181	}
		182
		183	/**
		184	* timeval_to_ns - Convert timeval to nanoseconds
		185	* @ts: pointer to the timeval variable to be converted
		186	*
		187	* Returns the scalar nanosecond representation of the timeval
		188	* parameter.
		189	*/
		190	static inline s64 timeval_to_ns(const struct timeval *tv)
		191	{
		192	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
		193	tv->tv_usec * NSEC_PER_USEC;
		194	}
		195
		196	/**
		197	* ns_to_timespec - Convert nanoseconds to timespec
		198	* @nsec: the nanoseconds value to be converted
		199	*
		200	* Returns the timespec representation of the nsec parameter.
		201	*/
		202	extern struct timespec ns_to_timespec(const s64 nsec);
		203
		204	/**
		205	* ns_to_timeval - Convert nanoseconds to timeval
		206	* @nsec: the nanoseconds value to be converted
		207	*
		208	* Returns the timeval representation of the nsec parameter.
		209	*/
		210	extern struct timeval ns_to_timeval(const s64 nsec);
		211
		212	/**
		213	* timespec_add_ns - Adds nanoseconds to a timespec
		214	* @a: pointer to timespec to be incremented
		215	* @ns: unsigned nanoseconds value to be added
		216	*
		217	* This must always be inlined because its used from the x86-64 vdso,
		218	* which cannot call other kernel functions.
		219	*/
		220	static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
		221	{
		222	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
		223	a->tv_nsec = ns;
		224	}
		225
		226	#endif

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/time.h – Rev 5270