[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / time.h

#ifndef _LINUX_TIME_H
#define _LINUX_TIME_H

#include <linux/types.h>

#ifdef __KERNEL__
# include <linux/cache.h>
# include <linux/seqlock.h>
# include <linux/math64.h>
#endif

#ifndef _STRUCT_TIMESPEC
#define _STRUCT_TIMESPEC
struct timespec {
	__kernel_time_t	tv_sec;			/* seconds */
	long		tv_nsec;		/* nanoseconds */
};
#endif

struct timeval {
	__kernel_time_t		tv_sec;		/* seconds */
	__kernel_suseconds_t	tv_usec;	/* microseconds */
};

struct timezone {
	int	tz_minuteswest;	/* minutes west of Greenwich */
	int	tz_dsttime;	/* type of dst correction */
};

#ifdef __KERNEL__

extern struct timezone sys_tz;

/* Parameters used to convert the timespec values: */
#define MSEC_PER_SEC	1000L
#define USEC_PER_MSEC	1000L
#define NSEC_PER_USEC	1000L
#define NSEC_PER_MSEC	1000000L
#define USEC_PER_SEC	1000000L
#define NSEC_PER_SEC	1000000000L
#define FSEC_PER_SEC	1000000000000000LL

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

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;
}

#define KTIME_MAX			((s64)~((u64)1 << 63))
#if (BITS_PER_LONG == 64)
# define KTIME_SEC_MAX			(KTIME_MAX / NSEC_PER_SEC)
#else
# define KTIME_SEC_MAX			LONG_MAX
#endif

/*
 * 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;
}

extern void read_persistent_clock(struct timespec *ts);
extern void read_boot_clock(struct timespec *ts);
extern int update_persistent_clock(struct timespec now);
void timekeeping_init(void);
extern int timekeeping_suspended;

unsigned long get_seconds(void);
struct timespec current_kernel_time(void);
struct timespec __current_kernel_time(void); /* does not take xtime_lock */
struct timespec get_monotonic_coarse(void);
void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
				struct timespec *wtom, struct timespec *sleep);
void timekeeping_inject_sleeptime(struct timespec *delta);

#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);
#else
static inline u32 arch_gettimeoffset(void) { return 0; }
#endif

extern void do_gettimeofday(struct timeval *tv);
extern int do_settimeofday(const struct timespec *tv);
extern int do_sys_settimeofday(const struct timespec *tv,
			       const struct timezone *tz);
#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
struct itimerval;
extern int do_setitimer(int which, struct itimerval *value,
			struct itimerval *ovalue);
extern unsigned int alarm_setitimer(unsigned int seconds);
extern int do_getitimer(int which, struct itimerval *value);
extern void getnstimeofday(struct timespec *tv);
extern void getrawmonotonic(struct timespec *ts);
extern void getnstime_raw_and_real(struct timespec *ts_raw,
		struct timespec *ts_real);
extern void getboottime(struct timespec *ts);
extern void monotonic_to_bootbased(struct timespec *ts);
extern void get_monotonic_boottime(struct timespec *ts);

extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
extern int timekeeping_valid_for_hres(void);
extern u64 timekeeping_max_deferment(void);
extern int timekeeping_inject_offset(struct timespec *ts);

struct tms;
extern void do_sys_times(struct tms *);

/*
 * 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 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 /* __KERNEL__ */

/*
 * Names of the interval timers, and structure
 * defining a timer setting:
 */
#define	ITIMER_REAL		0
#define	ITIMER_VIRTUAL		1
#define	ITIMER_PROF		2

struct itimerspec {
	struct timespec it_interval;	/* timer period */
	struct timespec it_value;	/* timer expiration */
};

struct itimerval {
	struct timeval it_interval;	/* timer interval */
	struct timeval it_value;	/* current value */
};

/*
 * The IDs of the various system clocks (for POSIX.1b interval timers):
 */
#define CLOCK_REALTIME			0
#define CLOCK_MONOTONIC			1
#define CLOCK_PROCESS_CPUTIME_ID	2
#define CLOCK_THREAD_CPUTIME_ID		3
#define CLOCK_MONOTONIC_RAW		4
#define CLOCK_REALTIME_COARSE		5
#define CLOCK_MONOTONIC_COARSE		6
#define CLOCK_BOOTTIME			7
#define CLOCK_REALTIME_ALARM		8
#define CLOCK_BOOTTIME_ALARM		9

/*
 * The IDs of various hardware clocks:
 */
#define CLOCK_SGI_CYCLE			10
#define MAX_CLOCKS			16
#define CLOCKS_MASK			(CLOCK_REALTIME | CLOCK_MONOTONIC)
#define CLOCKS_MONO			CLOCK_MONOTONIC

/*
 * The various flags for setting POSIX.1b interval timers:
 */
#define TIMER_ABSTIME			0x01

#endif
Commit	Line	Data
1da177e4 LT	1	#ifndef _LINUX_TIME_H
	2	#define _LINUX_TIME_H
	3
	4	#include <linux/types.h>
	5
	6	#ifdef __KERNEL__
82644459	7	# include <linux/cache.h>
57a55875	8	# include <linux/seqlock.h>
f595ec96	9	# include <linux/math64.h>
1da177e4 LT	10	#endif
	11
	12	#ifndef _STRUCT_TIMESPEC
	13	#define _STRUCT_TIMESPEC
	14	struct timespec {
85efde6f AB	15	__kernel_time_t tv_sec; /* seconds */
85efde6f AB	16	long tv_nsec; /* nanoseconds */
1da177e4	17	};
57a55875	18	#endif
1da177e4 LT	19
1da177e4 LT	20	struct timeval {
85efde6f AB	21	__kernel_time_t tv_sec; /* seconds */
85efde6f AB	22	__kernel_suseconds_t tv_usec; /* microseconds */
1da177e4 LT	23	};
	24
	25	struct timezone {
	26	int tz_minuteswest; /* minutes west of Greenwich */
	27	int tz_dsttime; /* type of dst correction */
	28	};
	29
	30	#ifdef __KERNEL__
	31
b418da16 CH	32	extern struct timezone sys_tz;
b418da16 CH	33
57a55875	34	/* Parameters used to convert the timespec values: */
05ebb761 VP	35	#define MSEC_PER_SEC 1000L
	36	#define USEC_PER_MSEC 1000L
	37	#define NSEC_PER_USEC 1000L
	38	#define NSEC_PER_MSEC 1000000L
	39	#define USEC_PER_SEC 1000000L
	40	#define NSEC_PER_SEC 1000000000L
4936a3b9	41	#define FSEC_PER_SEC 1000000000000000LL
1da177e4	42
df0cc053 TG	43	#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
df0cc053 TG	44
5b78cc9a JE	45	static inline int timespec_equal(const struct timespec *a,
5b78cc9a JE	46	const struct timespec *b)
57a55875	47	{
1da177e4	48	return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
57a55875	49	}
1da177e4	50
643a6545 AM	51	/*
	52	* lhs < rhs: return <0
	53	* lhs == rhs: return 0
	54	* lhs > rhs: return >0
	55	*/
77adbfbf	56	static inline int timespec_compare(const struct timespec lhs, const struct timespec rhs)
643a6545 AM	57	{
	58	if (lhs->tv_sec < rhs->tv_sec)
	59	return -1;
	60	if (lhs->tv_sec > rhs->tv_sec)
	61	return 1;
	62	return lhs->tv_nsec - rhs->tv_nsec;
	63	}
	64
77adbfbf	65	static inline int timeval_compare(const struct timeval lhs, const struct timeval rhs)
643a6545 AM	66	{
	67	if (lhs->tv_sec < rhs->tv_sec)
	68	return -1;
	69	if (lhs->tv_sec > rhs->tv_sec)
	70	return 1;
	71	return lhs->tv_usec - rhs->tv_usec;
	72	}
	73
f4818900 IM	74	extern unsigned long mktime(const unsigned int year, const unsigned int mon,
	75	const unsigned int day, const unsigned int hour,
	76	const unsigned int min, const unsigned int sec);
	77
12e09337	78	extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
ce3bf7ab JS	79
	80	/*
	81	* timespec_add_safe assumes both values are positive and checks
	82	* for overflow. It will return TIME_T_MAX if the reutrn would be
	83	* smaller then either of the arguments.
	84	*/
df0cc053 TG	85	extern struct timespec timespec_add_safe(const struct timespec lhs,
df0cc053 TG	86	const struct timespec rhs);
1da177e4	87
ce3bf7ab JS	88
	89	static inline struct timespec timespec_add(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
ca74e92b SN	98	/*
	99	* sub = lhs - rhs, in normalized form
	100	*/
	101	static inline struct timespec timespec_sub(struct timespec lhs,
	102	struct timespec rhs)
	103	{
	104	struct timespec ts_delta;
	105	set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
	106	lhs.tv_nsec - rhs.tv_nsec);
	107	return ts_delta;
	108	}
	109
4e8b1452 JS	110	#define KTIME_MAX ((s64)~((u64)1 << 63))
	111	#if (BITS_PER_LONG == 64)
	112	# define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
	113	#else
	114	# define KTIME_SEC_MAX LONG_MAX
	115	#endif
	116
5f82b2b7 TG	117	/*
	118	* Returns true if the timespec is norm, false if denorm:
	119	*/
4e8b1452 JS	120	static inline bool timespec_valid(const struct timespec *ts)
	121	{
	122	/* Dates before 1970 are bogus */
	123	if (ts->tv_sec < 0)
	124	return false;
	125	/* Can't have more nanoseconds then a second */
	126	if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
	127	return false;
cee58483 JS	128	return true;
	129	}
	130
	131	static inline bool timespec_valid_strict(const struct timespec *ts)
	132	{
	133	if (!timespec_valid(ts))
	134	return false;
4e8b1452 JS	135	/* Disallow values that could overflow ktime_t */
	136	if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
	137	return false;
	138	return true;
	139	}
5f82b2b7	140
d4f587c6	141	extern void read_persistent_clock(struct timespec *ts);
23970e38	142	extern void read_boot_clock(struct timespec *ts);
82644459	143	extern int update_persistent_clock(struct timespec now);
ad596171	144	void timekeeping_init(void);
1c5745aa	145	extern int timekeeping_suspended;
ad596171	146
17c38b74	147	unsigned long get_seconds(void);
1da177e4	148	struct timespec current_kernel_time(void);
8ab4351a	149	struct timespec __current_kernel_time(void); /* does not take xtime_lock */
da15cfda	150	struct timespec get_monotonic_coarse(void);
314ac371 JS	151	void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
314ac371 JS	152	struct timespec wtom, struct timespec sleep);
304529b1	153	void timekeeping_inject_sleeptime(struct timespec *delta);
1da177e4	154
57a55875	155	#define CURRENT_TIME (current_kernel_time())
2c6b47de	156	#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
1da177e4	157
7d27558c JS	158	/* Some architectures do not supply their own clocksource.
	159	* This is mainly the case in architectures that get their
	160	* inter-tick times by reading the counter on their interval
	161	* timer. Since these timers wrap every tick, they're not really
	162	* useful as clocksources. Wrapping them to act like one is possible
	163	* but not very efficient. So we provide a callout these arches
	164	* can implement for use with the jiffies clocksource to provide
	165	* finer then tick granular time.
	166	*/
	167	#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
	168	extern u32 arch_gettimeoffset(void);
	169	#else
	170	static inline u32 arch_gettimeoffset(void) { return 0; }
	171	#endif
	172
1da177e4	173	extern void do_gettimeofday(struct timeval *tv);
1e6d7679 RC	174	extern int do_settimeofday(const struct timespec *tv);
	175	extern int do_sys_settimeofday(const struct timespec *tv,
	176	const struct timezone *tz);
becf8b5d	177	#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
c7887325	178	extern long do_utimes(int dfd, const char __user filename, struct timespec times, int flags);
1da177e4	179	struct itimerval;
57a55875 IM	180	extern int do_setitimer(int which, struct itimerval *value,
57a55875 IM	181	struct itimerval *ovalue);
c08b8a49	182	extern unsigned int alarm_setitimer(unsigned int seconds);
1da177e4	183	extern int do_getitimer(int which, struct itimerval *value);
57a55875	184	extern void getnstimeofday(struct timespec *tv);
2d42244a	185	extern void getrawmonotonic(struct timespec *ts);
e2c18e49 AG	186	extern void getnstime_raw_and_real(struct timespec *ts_raw,
e2c18e49 AG	187	struct timespec *ts_real);
7c3f1a57 TJ	188	extern void getboottime(struct timespec *ts);
7c3f1a57 TJ	189	extern void monotonic_to_bootbased(struct timespec *ts);
abb3a4ea	190	extern void get_monotonic_boottime(struct timespec *ts);
1da177e4 LT	191
1da177e4 LT	192	extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
cf4fc6cb	193	extern int timekeeping_valid_for_hres(void);
98962465	194	extern u64 timekeeping_max_deferment(void);
c528f7c6	195	extern int timekeeping_inject_offset(struct timespec *ts);
1da177e4	196
f06febc9 FM	197	struct tms;
	198	extern void do_sys_times(struct tms *);
	199
57f1f087 Z	200	/*
	201	* Similar to the struct tm in userspace <time.h>, but it needs to be here so
	202	* that the kernel source is self contained.
	203	*/
	204	struct tm {
	205	/*
	206	* the number of seconds after the minute, normally in the range
	207	* 0 to 59, but can be up to 60 to allow for leap seconds
	208	*/
	209	int tm_sec;
	210	/* the number of minutes after the hour, in the range 0 to 59*/
	211	int tm_min;
	212	/* the number of hours past midnight, in the range 0 to 23 */
	213	int tm_hour;
	214	/* the day of the month, in the range 1 to 31 */
	215	int tm_mday;
	216	/* the number of months since January, in the range 0 to 11 */
	217	int tm_mon;
	218	/* the number of years since 1900 */
	219	long tm_year;
	220	/* the number of days since Sunday, in the range 0 to 6 */
	221	int tm_wday;
	222	/* the number of days since January 1, in the range 0 to 365 */
	223	int tm_yday;
	224	};
	225
	226	void time_to_tm(time_t totalsecs, int offset, struct tm *result);
	227
f8f46da3 TG	228	/**
	229	* timespec_to_ns - Convert timespec to nanoseconds
	230	* @ts: pointer to the timespec variable to be converted
	231	*
	232	* Returns the scalar nanosecond representation of the timespec
	233	* parameter.
	234	*/
df869b63	235	static inline s64 timespec_to_ns(const struct timespec *ts)
f8f46da3	236	{
df869b63	237	return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
f8f46da3 TG	238	}
	239
	240	/**
	241	* timeval_to_ns - Convert timeval to nanoseconds
	242	* @ts: pointer to the timeval variable to be converted
	243	*
	244	* Returns the scalar nanosecond representation of the timeval
	245	* parameter.
	246	*/
df869b63	247	static inline s64 timeval_to_ns(const struct timeval *tv)
f8f46da3	248	{
df869b63	249	return ((s64) tv->tv_sec * NSEC_PER_SEC) +
f8f46da3 TG	250	tv->tv_usec * NSEC_PER_USEC;
	251	}
	252
	253	/**
	254	* ns_to_timespec - Convert nanoseconds to timespec
	255	* @nsec: the nanoseconds value to be converted
	256	*
	257	* Returns the timespec representation of the nsec parameter.
	258	*/
df869b63	259	extern struct timespec ns_to_timespec(const s64 nsec);
f8f46da3 TG	260
	261	/**
	262	* ns_to_timeval - Convert nanoseconds to timeval
	263	* @nsec: the nanoseconds value to be converted
	264	*
	265	* Returns the timeval representation of the nsec parameter.
	266	*/
df869b63	267	extern struct timeval ns_to_timeval(const s64 nsec);
f8f46da3	268
cf3c769b JS	269	/**
	270	* timespec_add_ns - Adds nanoseconds to a timespec
	271	* @a: pointer to timespec to be incremented
	272	* @ns: unsigned nanoseconds value to be added
9412e286 JF	273	*
	274	* This must always be inlined because its used from the x86-64 vdso,
	275	* which cannot call other kernel functions.
cf3c769b	276	*/
9412e286	277	static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
cf3c769b	278	{
9412e286	279	a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
cf3c769b JS	280	a->tv_nsec = ns;
cf3c769b JS	281	}
8b3d1cda	282
1da177e4 LT	283	#endif /* __KERNEL__ */
1da177e4 LT	284
1da177e4 LT	285	/*
1da177e4 LT	286	* Names of the interval timers, and structure
57a55875	287	* defining a timer setting:
1da177e4	288	*/
57a55875 IM	289	#define ITIMER_REAL 0
	290	#define ITIMER_VIRTUAL 1
	291	#define ITIMER_PROF 2
1da177e4	292
57a55875 IM	293	struct itimerspec {
	294	struct timespec it_interval; /* timer period */
	295	struct timespec it_value; /* timer expiration */
1da177e4 LT	296	};
1da177e4 LT	297
57a55875 IM	298	struct itimerval {
	299	struct timeval it_interval; /* timer interval */
	300	struct timeval it_value; /* current value */
1da177e4 LT	301	};
1da177e4 LT	302
1da177e4	303	/*
57a55875	304	* The IDs of the various system clocks (for POSIX.1b interval timers):
1da177e4	305	*/
1ad106ca IM	306	#define CLOCK_REALTIME 0
	307	#define CLOCK_MONOTONIC 1
	308	#define CLOCK_PROCESS_CPUTIME_ID 2
	309	#define CLOCK_THREAD_CPUTIME_ID 3
2d42244a	310	#define CLOCK_MONOTONIC_RAW 4
da15cfda JS	311	#define CLOCK_REALTIME_COARSE 5
da15cfda JS	312	#define CLOCK_MONOTONIC_COARSE 6
70a08cca	313	#define CLOCK_BOOTTIME 7
9a7adcf5 JS	314	#define CLOCK_REALTIME_ALARM 8
9a7adcf5 JS	315	#define CLOCK_BOOTTIME_ALARM 9
1da177e4 LT	316
1da177e4 LT	317	/*
57a55875	318	* The IDs of various hardware clocks:
1da177e4	319	*/
1ad106ca IM	320	#define CLOCK_SGI_CYCLE 10
	321	#define MAX_CLOCKS 16
	322	#define CLOCKS_MASK (CLOCK_REALTIME \| CLOCK_MONOTONIC)
	323	#define CLOCKS_MONO CLOCK_MONOTONIC
1da177e4 LT	324
1da177e4 LT	325	/*
57a55875	326	* The various flags for setting POSIX.1b interval timers:
1da177e4	327	*/
1ad106ca	328	#define TIMER_ABSTIME 0x01
1da177e4 LT	329
1da177e4 LT	330	#endif