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


#ifndef _LINUX_TIME_H
#define _LINUX_TIME_H
 
# include 
# include 
# include 
# include 
 
extern struct timezone sys_tz;
 
#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);
 
#define CURRENT_TIME		(current_kernel_time())
#define CURRENT_TIME_SEC	((struct timespec) { get_seconds(), 0 })
 
/* 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 unsigned int alarm_setitimer(unsigned int seconds);
 
extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
 
struct tms;
extern void do_sys_times(struct tms *);
 
/*
 * Similar to the struct tm in userspace , 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 time_to_tm(time_t totalsecs, int offset, struct tm *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;
}
 
#endif
>

Subversion Repositories Kolibri OS

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

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