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