Loading...
1#ifndef _LINUX_TIME_H
2#define _LINUX_TIME_H
3
4# include <linux/cache.h>
5# include <linux/seqlock.h>
6# include <linux/math64.h>
7# include <linux/time64.h>
8
9extern struct timezone sys_tz;
10
11#define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
12
13static 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 */
24static 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
33static 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
42extern 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}
56
57extern 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 */
64extern struct timespec timespec_add_safe(const struct timespec lhs,
65 const struct timespec rhs);
66
67
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
77/*
78 * 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/*
90 * Returns true if the timespec is norm, false if denorm:
91 */
92static 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
103static 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
113static 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
126extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
127
128/*
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
154#define CURRENT_TIME (current_kernel_time())
155#define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
156
157/* 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
167extern u32 (*arch_gettimeoffset)(void);
168#endif
169
170struct itimerval;
171extern int do_setitimer(int which, struct itimerval *value,
172 struct itimerval *ovalue);
173extern int do_getitimer(int which, struct itimerval *value);
174
175extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
176
177struct tms;
178extern void do_sys_times(struct tms *);
179
180/*
181 * Similar to the struct tm in userspace <time.h>, but it needs to be here so
182 * that the kernel source is self contained.
183 */
184struct tm {
185 /*
186 * the number of seconds after the minute, normally in the range
187 * 0 to 59, but can be up to 60 to allow for leap seconds
188 */
189 int tm_sec;
190 /* the number of minutes after the hour, in the range 0 to 59*/
191 int tm_min;
192 /* the number of hours past midnight, in the range 0 to 23 */
193 int tm_hour;
194 /* the day of the month, in the range 1 to 31 */
195 int tm_mday;
196 /* the number of months since January, in the range 0 to 11 */
197 int tm_mon;
198 /* the number of years since 1900 */
199 long tm_year;
200 /* the number of days since Sunday, in the range 0 to 6 */
201 int tm_wday;
202 /* the number of days since January 1, in the range 0 to 365 */
203 int tm_yday;
204};
205
206void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
207
208/**
209 * time_to_tm - converts the calendar time to local broken-down time
210 *
211 * @totalsecs the number of seconds elapsed since 00:00:00 on January 1, 1970,
212 * Coordinated Universal Time (UTC).
213 * @offset offset seconds adding to totalsecs.
214 * @result pointer to struct tm variable to receive broken-down time
215 */
216static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
217{
218 time64_to_tm(totalsecs, offset, result);
219}
220
221/**
222 * timespec_to_ns - Convert timespec to nanoseconds
223 * @ts: pointer to the timespec variable to be converted
224 *
225 * Returns the scalar nanosecond representation of the timespec
226 * parameter.
227 */
228static inline s64 timespec_to_ns(const struct timespec *ts)
229{
230 return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
231}
232
233/**
234 * timeval_to_ns - Convert timeval to nanoseconds
235 * @ts: pointer to the timeval variable to be converted
236 *
237 * Returns the scalar nanosecond representation of the timeval
238 * parameter.
239 */
240static inline s64 timeval_to_ns(const struct timeval *tv)
241{
242 return ((s64) tv->tv_sec * NSEC_PER_SEC) +
243 tv->tv_usec * NSEC_PER_USEC;
244}
245
246/**
247 * ns_to_timespec - Convert nanoseconds to timespec
248 * @nsec: the nanoseconds value to be converted
249 *
250 * Returns the timespec representation of the nsec parameter.
251 */
252extern struct timespec ns_to_timespec(const s64 nsec);
253
254/**
255 * ns_to_timeval - Convert nanoseconds to timeval
256 * @nsec: the nanoseconds value to be converted
257 *
258 * Returns the timeval representation of the nsec parameter.
259 */
260extern struct timeval ns_to_timeval(const s64 nsec);
261
262/**
263 * timespec_add_ns - Adds nanoseconds to a timespec
264 * @a: pointer to timespec to be incremented
265 * @ns: unsigned nanoseconds value to be added
266 *
267 * This must always be inlined because its used from the x86-64 vdso,
268 * which cannot call other kernel functions.
269 */
270static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
271{
272 a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
273 a->tv_nsec = ns;
274}
275
276#endif
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef _LINUX_TIME_H
3#define _LINUX_TIME_H
4
5# include <linux/cache.h>
6# include <linux/math64.h>
7# include <linux/time64.h>
8
9extern struct timezone sys_tz;
10
11int get_timespec64(struct timespec64 *ts,
12 const struct __kernel_timespec __user *uts);
13int put_timespec64(const struct timespec64 *ts,
14 struct __kernel_timespec __user *uts);
15int get_itimerspec64(struct itimerspec64 *it,
16 const struct __kernel_itimerspec __user *uit);
17int put_itimerspec64(const struct itimerspec64 *it,
18 struct __kernel_itimerspec __user *uit);
19
20extern time64_t mktime64(const unsigned int year, const unsigned int mon,
21 const unsigned int day, const unsigned int hour,
22 const unsigned int min, const unsigned int sec);
23
24#ifdef CONFIG_POSIX_TIMERS
25extern void clear_itimer(void);
26#else
27static inline void clear_itimer(void) {}
28#endif
29
30extern long do_utimes(int dfd, const char __user *filename, struct timespec64 *times, int flags);
31
32/*
33 * Similar to the struct tm in userspace <time.h>, but it needs to be here so
34 * that the kernel source is self contained.
35 */
36struct tm {
37 /*
38 * the number of seconds after the minute, normally in the range
39 * 0 to 59, but can be up to 60 to allow for leap seconds
40 */
41 int tm_sec;
42 /* the number of minutes after the hour, in the range 0 to 59*/
43 int tm_min;
44 /* the number of hours past midnight, in the range 0 to 23 */
45 int tm_hour;
46 /* the day of the month, in the range 1 to 31 */
47 int tm_mday;
48 /* the number of months since January, in the range 0 to 11 */
49 int tm_mon;
50 /* the number of years since 1900 */
51 long tm_year;
52 /* the number of days since Sunday, in the range 0 to 6 */
53 int tm_wday;
54 /* the number of days since January 1, in the range 0 to 365 */
55 int tm_yday;
56};
57
58void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
59
60# include <linux/time32.h>
61
62static inline bool itimerspec64_valid(const struct itimerspec64 *its)
63{
64 if (!timespec64_valid(&(its->it_interval)) ||
65 !timespec64_valid(&(its->it_value)))
66 return false;
67
68 return true;
69}
70
71/**
72 * time_after32 - compare two 32-bit relative times
73 * @a: the time which may be after @b
74 * @b: the time which may be before @a
75 *
76 * time_after32(a, b) returns true if the time @a is after time @b.
77 * time_before32(b, a) returns true if the time @b is before time @a.
78 *
79 * Similar to time_after(), compare two 32-bit timestamps for relative
80 * times. This is useful for comparing 32-bit seconds values that can't
81 * be converted to 64-bit values (e.g. due to disk format or wire protocol
82 * issues) when it is known that the times are less than 68 years apart.
83 */
84#define time_after32(a, b) ((s32)((u32)(b) - (u32)(a)) < 0)
85#define time_before32(b, a) time_after32(a, b)
86
87/**
88 * time_between32 - check if a 32-bit timestamp is within a given time range
89 * @t: the time which may be within [l,h]
90 * @l: the lower bound of the range
91 * @h: the higher bound of the range
92 *
93 * time_before32(t, l, h) returns true if @l <= @t <= @h. All operands are
94 * treated as 32-bit integers.
95 *
96 * Equivalent to !(time_before32(@t, @l) || time_after32(@t, @h)).
97 */
98#define time_between32(t, l, h) ((u32)(h) - (u32)(l) >= (u32)(t) - (u32)(l))
99
100# include <vdso/time.h>
101
102#endif