Line data Source code
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 :
9 : extern struct timezone sys_tz;
10 :
11 : #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
12 :
13 : static inline int timespec_equal(const struct timespec *a,
14 : const struct timespec *b)
15 : {
16 278710 : 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 : */
24 : static 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 :
33 : static 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 :
42 : extern 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 :
46 : extern 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 : */
53 : extern struct timespec timespec_add_safe(const struct timespec lhs,
54 : const struct timespec rhs);
55 :
56 :
57 : static 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 : */
69 : static 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 : */
81 : static 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 :
92 : static 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 :
102 : extern 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
117 : extern u32 (*arch_gettimeoffset)(void);
118 : #endif
119 :
120 : struct itimerval;
121 : extern int do_setitimer(int which, struct itimerval *value,
122 : struct itimerval *ovalue);
123 : extern int do_getitimer(int which, struct itimerval *value);
124 :
125 : extern unsigned int alarm_setitimer(unsigned int seconds);
126 :
127 : extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
128 :
129 : struct tms;
130 : extern 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 : */
136 : struct 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 :
158 : void 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 : */
167 : static 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 : */
179 : static 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 : */
191 : extern 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 : */
199 : extern 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 : */
209 : static __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
|
