]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - include/linux/time.h
Merge tag 'writeback-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/wfg...
[mirror_ubuntu-bionic-kernel.git] / include / linux / time.h
CommitLineData
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>
607ca46e 7#include <uapi/linux/time.h>
1da177e4 8
b418da16
CH
9extern struct timezone sys_tz;
10
57a55875 11/* Parameters used to convert the timespec values: */
05ebb761
VP
12#define MSEC_PER_SEC 1000L
13#define USEC_PER_MSEC 1000L
14#define NSEC_PER_USEC 1000L
15#define NSEC_PER_MSEC 1000000L
16#define USEC_PER_SEC 1000000L
17#define NSEC_PER_SEC 1000000000L
4936a3b9 18#define FSEC_PER_SEC 1000000000000000LL
1da177e4 19
df0cc053
TG
20#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
21
5b78cc9a
JE
22static inline int timespec_equal(const struct timespec *a,
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 33static 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 42static 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
f4818900
IM
51extern unsigned long mktime(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
12e09337 55extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
ce3bf7ab
JS
56
57/*
58 * timespec_add_safe assumes both values are positive and checks
59 * for overflow. It will return TIME_T_MAX if the reutrn would be
60 * smaller then either of the arguments.
61 */
df0cc053
TG
62extern struct timespec timespec_add_safe(const struct timespec lhs,
63 const struct timespec rhs);
1da177e4 64
ce3bf7ab
JS
65
66static inline struct timespec timespec_add(struct timespec lhs,
67 struct timespec rhs)
68{
69 struct timespec ts_delta;
70 set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
71 lhs.tv_nsec + rhs.tv_nsec);
72 return ts_delta;
73}
74
ca74e92b
SN
75/*
76 * sub = lhs - rhs, in normalized form
77 */
78static inline struct timespec timespec_sub(struct timespec lhs,
79 struct timespec rhs)
80{
81 struct timespec ts_delta;
82 set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
83 lhs.tv_nsec - rhs.tv_nsec);
84 return ts_delta;
85}
86
4e8b1452
JS
87#define KTIME_MAX ((s64)~((u64)1 << 63))
88#if (BITS_PER_LONG == 64)
89# define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
90#else
91# define KTIME_SEC_MAX LONG_MAX
92#endif
93
5f82b2b7
TG
94/*
95 * Returns true if the timespec is norm, false if denorm:
96 */
4e8b1452
JS
97static inline bool timespec_valid(const struct timespec *ts)
98{
99 /* Dates before 1970 are bogus */
100 if (ts->tv_sec < 0)
101 return false;
102 /* Can't have more nanoseconds then a second */
103 if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
104 return false;
cee58483
JS
105 return true;
106}
107
108static inline bool timespec_valid_strict(const struct timespec *ts)
109{
110 if (!timespec_valid(ts))
111 return false;
4e8b1452
JS
112 /* Disallow values that could overflow ktime_t */
113 if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
114 return false;
115 return true;
116}
5f82b2b7 117
31ade306 118extern bool persistent_clock_exist;
05ad717c 119
31ade306
FT
120static inline bool has_persistent_clock(void)
121{
122 return persistent_clock_exist;
123}
124
d4f587c6 125extern void read_persistent_clock(struct timespec *ts);
23970e38 126extern void read_boot_clock(struct timespec *ts);
84e345e4 127extern int persistent_clock_is_local;
82644459 128extern int update_persistent_clock(struct timespec now);
ad596171 129void timekeeping_init(void);
1c5745aa 130extern int timekeeping_suspended;
ad596171 131
17c38b74 132unsigned long get_seconds(void);
1da177e4 133struct timespec current_kernel_time(void);
8ab4351a 134struct timespec __current_kernel_time(void); /* does not take xtime_lock */
da15cfda 135struct timespec get_monotonic_coarse(void);
314ac371
JS
136void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
137 struct timespec *wtom, struct timespec *sleep);
304529b1 138void timekeeping_inject_sleeptime(struct timespec *delta);
1da177e4 139
57a55875 140#define CURRENT_TIME (current_kernel_time())
2c6b47de 141#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
1da177e4 142
7d27558c
JS
143/* Some architectures do not supply their own clocksource.
144 * This is mainly the case in architectures that get their
145 * inter-tick times by reading the counter on their interval
146 * timer. Since these timers wrap every tick, they're not really
147 * useful as clocksources. Wrapping them to act like one is possible
148 * but not very efficient. So we provide a callout these arches
149 * can implement for use with the jiffies clocksource to provide
150 * finer then tick granular time.
151 */
152#ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
7b1f6207 153extern u32 (*arch_gettimeoffset)(void);
7d27558c
JS
154#endif
155
1da177e4 156extern void do_gettimeofday(struct timeval *tv);
1e6d7679
RC
157extern int do_settimeofday(const struct timespec *tv);
158extern int do_sys_settimeofday(const struct timespec *tv,
159 const struct timezone *tz);
becf8b5d 160#define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
c7887325 161extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
1da177e4 162struct itimerval;
57a55875
IM
163extern int do_setitimer(int which, struct itimerval *value,
164 struct itimerval *ovalue);
c08b8a49 165extern unsigned int alarm_setitimer(unsigned int seconds);
1da177e4 166extern int do_getitimer(int which, struct itimerval *value);
1e817fb6 167extern int __getnstimeofday(struct timespec *tv);
57a55875 168extern void getnstimeofday(struct timespec *tv);
2d42244a 169extern void getrawmonotonic(struct timespec *ts);
e2c18e49
AG
170extern void getnstime_raw_and_real(struct timespec *ts_raw,
171 struct timespec *ts_real);
7c3f1a57
TJ
172extern void getboottime(struct timespec *ts);
173extern void monotonic_to_bootbased(struct timespec *ts);
abb3a4ea 174extern void get_monotonic_boottime(struct timespec *ts);
1da177e4
LT
175
176extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
cf4fc6cb 177extern int timekeeping_valid_for_hres(void);
98962465 178extern u64 timekeeping_max_deferment(void);
c528f7c6 179extern int timekeeping_inject_offset(struct timespec *ts);
cc244dda
JS
180extern s32 timekeeping_get_tai_offset(void);
181extern void timekeeping_set_tai_offset(s32 tai_offset);
1ff3c967 182extern void timekeeping_clocktai(struct timespec *ts);
1da177e4 183
f06febc9
FM
184struct tms;
185extern void do_sys_times(struct tms *);
186
57f1f087
Z
187/*
188 * Similar to the struct tm in userspace <time.h>, but it needs to be here so
189 * that the kernel source is self contained.
190 */
191struct tm {
192 /*
193 * the number of seconds after the minute, normally in the range
194 * 0 to 59, but can be up to 60 to allow for leap seconds
195 */
196 int tm_sec;
197 /* the number of minutes after the hour, in the range 0 to 59*/
198 int tm_min;
199 /* the number of hours past midnight, in the range 0 to 23 */
200 int tm_hour;
201 /* the day of the month, in the range 1 to 31 */
202 int tm_mday;
203 /* the number of months since January, in the range 0 to 11 */
204 int tm_mon;
205 /* the number of years since 1900 */
206 long tm_year;
207 /* the number of days since Sunday, in the range 0 to 6 */
208 int tm_wday;
209 /* the number of days since January 1, in the range 0 to 365 */
210 int tm_yday;
211};
212
213void time_to_tm(time_t totalsecs, int offset, struct tm *result);
214
f8f46da3
TG
215/**
216 * timespec_to_ns - Convert timespec to nanoseconds
217 * @ts: pointer to the timespec variable to be converted
218 *
219 * Returns the scalar nanosecond representation of the timespec
220 * parameter.
221 */
df869b63 222static inline s64 timespec_to_ns(const struct timespec *ts)
f8f46da3 223{
df869b63 224 return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
f8f46da3
TG
225}
226
227/**
228 * timeval_to_ns - Convert timeval to nanoseconds
229 * @ts: pointer to the timeval variable to be converted
230 *
231 * Returns the scalar nanosecond representation of the timeval
232 * parameter.
233 */
df869b63 234static inline s64 timeval_to_ns(const struct timeval *tv)
f8f46da3 235{
df869b63 236 return ((s64) tv->tv_sec * NSEC_PER_SEC) +
f8f46da3
TG
237 tv->tv_usec * NSEC_PER_USEC;
238}
239
240/**
241 * ns_to_timespec - Convert nanoseconds to timespec
242 * @nsec: the nanoseconds value to be converted
243 *
244 * Returns the timespec representation of the nsec parameter.
245 */
df869b63 246extern struct timespec ns_to_timespec(const s64 nsec);
f8f46da3
TG
247
248/**
249 * ns_to_timeval - Convert nanoseconds to timeval
250 * @nsec: the nanoseconds value to be converted
251 *
252 * Returns the timeval representation of the nsec parameter.
253 */
df869b63 254extern struct timeval ns_to_timeval(const s64 nsec);
f8f46da3 255
cf3c769b
JS
256/**
257 * timespec_add_ns - Adds nanoseconds to a timespec
258 * @a: pointer to timespec to be incremented
259 * @ns: unsigned nanoseconds value to be added
9412e286
JF
260 *
261 * This must always be inlined because its used from the x86-64 vdso,
262 * which cannot call other kernel functions.
cf3c769b 263 */
9412e286 264static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
cf3c769b 265{
9412e286 266 a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
cf3c769b
JS
267 a->tv_nsec = ns;
268}
8b3d1cda 269
1da177e4 270#endif