blob: 297f09f23896d2db41cd90a0cad37746e6ed77aa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001#ifndef _LINUX_TIME_H
2#define _LINUX_TIME_H
3
Thomas Gleixner82644452007-07-21 04:37:37 -07004# include <linux/cache.h>
Ingo Molnar57a55872006-01-09 20:52:26 -08005# include <linux/seqlock.h>
Jeremy Fitzhardingef595ec92008-06-12 10:47:56 +02006# include <linux/math64.h>
John Stultz361a3bf2014-07-16 21:03:58 +00007# include <linux/time64.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
Christoph Hellwigb418da12008-10-15 22:02:06 -07009extern struct timezone sys_tz;
10
Thomas Gleixnerdf0cc052008-08-31 08:09:53 -070011#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
12
Jan Engelhardt5b78cc92007-07-17 04:03:53 -070013static inline int timespec_equal(const struct timespec *a,
14 const struct timespec *b)
Ingo Molnar57a55872006-01-09 20:52:26 -080015{
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
Ingo Molnar57a55872006-01-09 20:52:26 -080017}
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Andrew Morton643a6542006-02-11 17:55:52 -080019/*
20 * lhs < rhs: return <0
21 * lhs == rhs: return 0
22 * lhs > rhs: return >0
23 */
Rolf Eike Beer77adbfb2007-02-10 01:45:49 -080024static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
Andrew Morton643a6542006-02-11 17:55:52 -080025{
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
Rolf Eike Beer77adbfb2007-02-10 01:45:49 -080033static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
Andrew Morton643a6542006-02-11 17:55:52 -080034{
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
pang.xunlei90b6ce92014-11-18 19:15:18 +080042extern time64_t mktime64(const unsigned int year, const unsigned int mon,
43 const unsigned int day, const unsigned int hour,
44 const unsigned int min, const unsigned int sec);
45
46/**
47 * Deprecated. Use mktime64().
48 */
49static 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}
Ingo Molnarf4818902006-01-09 20:52:23 -080056
Thomas Gleixner12e09332009-09-14 23:37:40 +020057extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
John Stultzce3bf7a2010-07-13 17:56:19 -070058
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 */
Thomas Gleixnerdf0cc052008-08-31 08:09:53 -070064extern struct timespec timespec_add_safe(const struct timespec lhs,
65 const struct timespec rhs);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
John Stultzce3bf7a2010-07-13 17:56:19 -070067
68static 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
Thomas Gleixner5f82b2b2006-01-09 20:52:29 -080077/*
Shailabh Nagarca74e922006-07-14 00:24:36 -070078 * sub = lhs - rhs, in normalized form
79 */
80static 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/*
Thomas Gleixner5f82b2b2006-01-09 20:52:29 -080090 * Returns true if the timespec is norm, false if denorm:
91 */
John Stultz4e8b1452012-08-08 15:36:20 -040092static 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;
John Stultzcee58482012-08-31 13:30:06 -0400100 return true;
101}
102
103static inline bool timespec_valid_strict(const struct timespec *ts)
104{
105 if (!timespec_valid(ts))
106 return false;
John Stultz4e8b1452012-08-08 15:36:20 -0400107 /* 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}
Thomas Gleixner5f82b2b2006-01-09 20:52:29 -0800112
Sasha Levin6ada1fc2014-12-03 19:22:48 -0500113static 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;
124}
125
Thomas Gleixner8b094cd2014-07-16 21:04:02 +0000126extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127
John Stultz37cf4dc2015-12-03 22:09:31 -0500128/*
129 * Validates if a timespec/timeval used to inject a time offset is valid.
130 * Offsets can be postive or negative. The value of the timeval/timespec
131 * is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must
132 * always be non-negative.
133 */
134static inline bool timeval_inject_offset_valid(const struct timeval *tv)
135{
136 /* We don't check the tv_sec as it can be positive or negative */
137
138 /* Can't have more microseconds then a second */
139 if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
140 return false;
141 return true;
142}
143
144static inline bool timespec_inject_offset_valid(const struct timespec *ts)
145{
146 /* We don't check the tv_sec as it can be positive or negative */
147
148 /* Can't have more nanoseconds then a second */
149 if (ts->tv_nsec < 0 || ts->tv_nsec >= NSEC_PER_SEC)
150 return false;
151 return true;
152}
153
Ingo Molnar57a55872006-01-09 20:52:26 -0800154#define CURRENT_TIME (current_kernel_time())
john stultz2c6b47d2007-07-24 17:47:43 -0700155#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
john stultz7d275582009-05-01 13:10:26 -0700157/* Some architectures do not supply their own clocksource.
158 * This is mainly the case in architectures that get their
159 * inter-tick times by reading the counter on their interval
160 * timer. Since these timers wrap every tick, they're not really
161 * useful as clocksources. Wrapping them to act like one is possible
162 * but not very efficient. So we provide a callout these arches
163 * can implement for use with the jiffies clocksource to provide
164 * finer then tick granular time.
165 */
166#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
Stephen Warren7b1f6202012-11-07 17:58:54 -0700167extern u32 (*arch_gettimeoffset)(void);
john stultz7d275582009-05-01 13:10:26 -0700168#endif
169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170struct itimerval;
Ingo Molnar57a55872006-01-09 20:52:26 -0800171extern int do_setitimer(int which, struct itimerval *value,
172 struct itimerval *ovalue);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173extern int do_getitimer(int which, struct itimerval *value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Thomas Gleixner8b094cd2014-07-16 21:04:02 +0000175extern unsigned int alarm_setitimer(unsigned int seconds);
176
177extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
Frank Mayharf06febc2008-09-12 09:54:39 -0700179struct tms;
180extern void do_sys_times(struct tms *);
181
Zhaolei57f1f082009-09-23 15:56:10 -0700182/*
183 * Similar to the struct tm in userspace <time.h>, but it needs to be here so
184 * that the kernel source is self contained.
185 */
186struct tm {
187 /*
188 * the number of seconds after the minute, normally in the range
189 * 0 to 59, but can be up to 60 to allow for leap seconds
190 */
191 int tm_sec;
192 /* the number of minutes after the hour, in the range 0 to 59*/
193 int tm_min;
194 /* the number of hours past midnight, in the range 0 to 23 */
195 int tm_hour;
196 /* the day of the month, in the range 1 to 31 */
197 int tm_mday;
198 /* the number of months since January, in the range 0 to 11 */
199 int tm_mon;
200 /* the number of years since 1900 */
201 long tm_year;
202 /* the number of days since Sunday, in the range 0 to 6 */
203 int tm_wday;
204 /* the number of days since January 1, in the range 0 to 365 */
205 int tm_yday;
206};
207
208void time_to_tm(time_t totalsecs, int offset, struct tm *result);
209
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800210/**
211 * timespec_to_ns - Convert timespec to nanoseconds
212 * @ts: pointer to the timespec variable to be converted
213 *
214 * Returns the scalar nanosecond representation of the timespec
215 * parameter.
216 */
Roman Zippeldf869b62006-03-26 01:38:11 -0800217static inline s64 timespec_to_ns(const struct timespec *ts)
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800218{
Roman Zippeldf869b62006-03-26 01:38:11 -0800219 return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800220}
221
222/**
223 * timeval_to_ns - Convert timeval to nanoseconds
224 * @ts: pointer to the timeval variable to be converted
225 *
226 * Returns the scalar nanosecond representation of the timeval
227 * parameter.
228 */
Roman Zippeldf869b62006-03-26 01:38:11 -0800229static inline s64 timeval_to_ns(const struct timeval *tv)
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800230{
Roman Zippeldf869b62006-03-26 01:38:11 -0800231 return ((s64) tv->tv_sec * NSEC_PER_SEC) +
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800232 tv->tv_usec * NSEC_PER_USEC;
233}
234
235/**
236 * ns_to_timespec - Convert nanoseconds to timespec
237 * @nsec: the nanoseconds value to be converted
238 *
239 * Returns the timespec representation of the nsec parameter.
240 */
Roman Zippeldf869b62006-03-26 01:38:11 -0800241extern struct timespec ns_to_timespec(const s64 nsec);
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800242
243/**
244 * ns_to_timeval - Convert nanoseconds to timeval
245 * @nsec: the nanoseconds value to be converted
246 *
247 * Returns the timeval representation of the nsec parameter.
248 */
Roman Zippeldf869b62006-03-26 01:38:11 -0800249extern struct timeval ns_to_timeval(const s64 nsec);
Thomas Gleixnerf8f46da2006-01-09 20:52:30 -0800250
john stultzcf3c7692006-06-26 00:25:08 -0700251/**
252 * timespec_add_ns - Adds nanoseconds to a timespec
253 * @a: pointer to timespec to be incremented
254 * @ns: unsigned nanoseconds value to be added
Jeremy Fitzhardinge9412e2862008-06-12 10:48:00 +0200255 *
256 * This must always be inlined because its used from the x86-64 vdso,
257 * which cannot call other kernel functions.
john stultzcf3c7692006-06-26 00:25:08 -0700258 */
Jeremy Fitzhardinge9412e2862008-06-12 10:48:00 +0200259static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
john stultzcf3c7692006-06-26 00:25:08 -0700260{
Jeremy Fitzhardinge9412e2862008-06-12 10:48:00 +0200261 a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
john stultzcf3c7692006-06-26 00:25:08 -0700262 a->tv_nsec = ns;
263}
H. Peter Anvin8b3d1cd2012-02-07 21:09:05 -0800264
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265#endif