~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/time.h

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 int get_timespec64(struct timespec64 *ts,
 12                 const struct timespec __user *uts);
 13 int put_timespec64(const struct timespec64 *ts,
 14                 struct timespec __user *uts);
 15 int get_itimerspec64(struct itimerspec64 *it,
 16                         const struct itimerspec __user *uit);
 17 int put_itimerspec64(const struct itimerspec64 *it,
 18                         struct itimerspec __user *uit);
 19 
 20 #define TIME_T_MAX      (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
 21 
 22 static inline int timespec_equal(const struct timespec *a,
 23                                  const struct timespec *b)
 24 {
 25         return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
 26 }
 27 
 28 /*
 29  * lhs < rhs:  return <0
 30  * lhs == rhs: return 0
 31  * lhs > rhs:  return >0
 32  */
 33 static inline int timespec_compare(const struct timespec *lhs, const struct timespec *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_nsec - rhs->tv_nsec;
 40 }
 41 
 42 static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
 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 
 51 extern time64_t mktime64(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 
 55 /**
 56  * Deprecated. Use mktime64().
 57  */
 58 static inline unsigned long mktime(const unsigned int year,
 59                         const unsigned int mon, const unsigned int day,
 60                         const unsigned int hour, const unsigned int min,
 61                         const unsigned int sec)
 62 {
 63         return mktime64(year, mon, day, hour, min, sec);
 64 }
 65 
 66 extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
 67 
 68 /*
 69  * timespec_add_safe assumes both values are positive and checks
 70  * for overflow. It will return TIME_T_MAX if the reutrn would be
 71  * smaller then either of the arguments.
 72  */
 73 extern struct timespec timespec_add_safe(const struct timespec lhs,
 74                                          const struct timespec rhs);
 75 
 76 
 77 static inline struct timespec timespec_add(struct timespec lhs,
 78                                                 struct timespec rhs)
 79 {
 80         struct timespec ts_delta;
 81         set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
 82                                 lhs.tv_nsec + rhs.tv_nsec);
 83         return ts_delta;
 84 }
 85 
 86 /*
 87  * sub = lhs - rhs, in normalized form
 88  */
 89 static inline struct timespec timespec_sub(struct timespec lhs,
 90                                                 struct timespec rhs)
 91 {
 92         struct timespec ts_delta;
 93         set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
 94                                 lhs.tv_nsec - rhs.tv_nsec);
 95         return ts_delta;
 96 }
 97 
 98 /*
 99  * Returns true if the timespec is norm, false if denorm:
100  */
101 static inline bool timespec_valid(const struct timespec *ts)
102 {
103         /* Dates before 1970 are bogus */
104         if (ts->tv_sec < 0)
105                 return false;
106         /* Can't have more nanoseconds then a second */
107         if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
108                 return false;
109         return true;
110 }
111 
112 static inline bool timespec_valid_strict(const struct timespec *ts)
113 {
114         if (!timespec_valid(ts))
115                 return false;
116         /* Disallow values that could overflow ktime_t */
117         if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
118                 return false;
119         return true;
120 }
121 
122 static inline bool timeval_valid(const struct timeval *tv)
123 {
124         /* Dates before 1970 are bogus */
125         if (tv->tv_sec < 0)
126                 return false;
127 
128         /* Can't have more microseconds then a second */
129         if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
130                 return false;
131 
132         return true;
133 }
134 
135 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
136 
137 /*
138  * Validates if a timespec/timeval used to inject a time offset is valid.
139  * Offsets can be postive or negative. The value of the timeval/timespec
140  * is the sum of its fields, but *NOTE*: the field tv_usec/tv_nsec must
141  * always be non-negative.
142  */
143 static inline bool timeval_inject_offset_valid(const struct timeval *tv)
144 {
145         /* We don't check the tv_sec as it can be positive or negative */
146 
147         /* Can't have more microseconds then a second */
148         if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
149                 return false;
150         return true;
151 }
152 
153 static inline bool timespec_inject_offset_valid(const struct timespec *ts)
154 {
155         /* We don't check the tv_sec as it can be positive or negative */
156 
157         /* Can't have more nanoseconds then a second */
158         if (ts->tv_nsec < 0 || ts->tv_nsec >= NSEC_PER_SEC)
159                 return false;
160         return true;
161 }
162 
163 /* Some architectures do not supply their own clocksource.
164  * This is mainly the case in architectures that get their
165  * inter-tick times by reading the counter on their interval
166  * timer. Since these timers wrap every tick, they're not really
167  * useful as clocksources. Wrapping them to act like one is possible
168  * but not very efficient. So we provide a callout these arches
169  * can implement for use with the jiffies clocksource to provide
170  * finer then tick granular time.
171  */
172 #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
173 extern u32 (*arch_gettimeoffset)(void);
174 #endif
175 
176 struct itimerval;
177 extern int do_setitimer(int which, struct itimerval *value,
178                         struct itimerval *ovalue);
179 extern int do_getitimer(int which, struct itimerval *value);
180 
181 extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
182 
183 /*
184  * Similar to the struct tm in userspace <time.h>, but it needs to be here so
185  * that the kernel source is self contained.
186  */
187 struct tm {
188         /*
189          * the number of seconds after the minute, normally in the range
190          * 0 to 59, but can be up to 60 to allow for leap seconds
191          */
192         int tm_sec;
193         /* the number of minutes after the hour, in the range 0 to 59*/
194         int tm_min;
195         /* the number of hours past midnight, in the range 0 to 23 */
196         int tm_hour;
197         /* the day of the month, in the range 1 to 31 */
198         int tm_mday;
199         /* the number of months since January, in the range 0 to 11 */
200         int tm_mon;
201         /* the number of years since 1900 */
202         long tm_year;
203         /* the number of days since Sunday, in the range 0 to 6 */
204         int tm_wday;
205         /* the number of days since January 1, in the range 0 to 365 */
206         int tm_yday;
207 };
208 
209 void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
210 
211 /**
212  * time_to_tm - converts the calendar time to local broken-down time
213  *
214  * @totalsecs   the number of seconds elapsed since 00:00:00 on January 1, 1970,
215  *              Coordinated Universal Time (UTC).
216  * @offset      offset seconds adding to totalsecs.
217  * @result      pointer to struct tm variable to receive broken-down time
218  */
219 static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
220 {
221         time64_to_tm(totalsecs, offset, result);
222 }
223 
224 /**
225  * timespec_to_ns - Convert timespec to nanoseconds
226  * @ts:         pointer to the timespec variable to be converted
227  *
228  * Returns the scalar nanosecond representation of the timespec
229  * parameter.
230  */
231 static inline s64 timespec_to_ns(const struct timespec *ts)
232 {
233         return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
234 }
235 
236 /**
237  * timeval_to_ns - Convert timeval to nanoseconds
238  * @ts:         pointer to the timeval variable to be converted
239  *
240  * Returns the scalar nanosecond representation of the timeval
241  * parameter.
242  */
243 static inline s64 timeval_to_ns(const struct timeval *tv)
244 {
245         return ((s64) tv->tv_sec * NSEC_PER_SEC) +
246                 tv->tv_usec * NSEC_PER_USEC;
247 }
248 
249 /**
250  * ns_to_timespec - Convert nanoseconds to timespec
251  * @nsec:       the nanoseconds value to be converted
252  *
253  * Returns the timespec representation of the nsec parameter.
254  */
255 extern struct timespec ns_to_timespec(const s64 nsec);
256 
257 /**
258  * ns_to_timeval - Convert nanoseconds to timeval
259  * @nsec:       the nanoseconds value to be converted
260  *
261  * Returns the timeval representation of the nsec parameter.
262  */
263 extern struct timeval ns_to_timeval(const s64 nsec);
264 
265 /**
266  * timespec_add_ns - Adds nanoseconds to a timespec
267  * @a:          pointer to timespec to be incremented
268  * @ns:         unsigned nanoseconds value to be added
269  *
270  * This must always be inlined because its used from the x86-64 vdso,
271  * which cannot call other kernel functions.
272  */
273 static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
274 {
275         a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
276         a->tv_nsec = ns;
277 }
278 
279 static inline bool itimerspec64_valid(const struct itimerspec64 *its)
280 {
281         if (!timespec64_valid(&(its->it_interval)) ||
282                 !timespec64_valid(&(its->it_value)))
283                 return false;
284 
285         return true;
286 }
287 
288 #endif
289 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp