~ [ 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 #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         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 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  */
 49 static 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 
 57 extern 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  */
 64 extern struct timespec timespec_add_safe(const struct timespec lhs,
 65                                          const struct timespec rhs);
 66 
 67 
 68 static 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  */
 80 static 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  */
 92 static 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 
103 static 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 
113 static 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 
126 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
127 
128 #define CURRENT_TIME            (current_kernel_time())
129 #define CURRENT_TIME_SEC        ((struct timespec) { get_seconds(), 0 })
130 
131 /* Some architectures do not supply their own clocksource.
132  * This is mainly the case in architectures that get their
133  * inter-tick times by reading the counter on their interval
134  * timer. Since these timers wrap every tick, they're not really
135  * useful as clocksources. Wrapping them to act like one is possible
136  * but not very efficient. So we provide a callout these arches
137  * can implement for use with the jiffies clocksource to provide
138  * finer then tick granular time.
139  */
140 #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
141 extern u32 (*arch_gettimeoffset)(void);
142 #endif
143 
144 struct itimerval;
145 extern int do_setitimer(int which, struct itimerval *value,
146                         struct itimerval *ovalue);
147 extern int do_getitimer(int which, struct itimerval *value);
148 
149 extern unsigned int alarm_setitimer(unsigned int seconds);
150 
151 extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
152 
153 struct tms;
154 extern void do_sys_times(struct tms *);
155 
156 /*
157  * Similar to the struct tm in userspace <time.h>, but it needs to be here so
158  * that the kernel source is self contained.
159  */
160 struct tm {
161         /*
162          * the number of seconds after the minute, normally in the range
163          * 0 to 59, but can be up to 60 to allow for leap seconds
164          */
165         int tm_sec;
166         /* the number of minutes after the hour, in the range 0 to 59*/
167         int tm_min;
168         /* the number of hours past midnight, in the range 0 to 23 */
169         int tm_hour;
170         /* the day of the month, in the range 1 to 31 */
171         int tm_mday;
172         /* the number of months since January, in the range 0 to 11 */
173         int tm_mon;
174         /* the number of years since 1900 */
175         long tm_year;
176         /* the number of days since Sunday, in the range 0 to 6 */
177         int tm_wday;
178         /* the number of days since January 1, in the range 0 to 365 */
179         int tm_yday;
180 };
181 
182 void time_to_tm(time_t totalsecs, int offset, struct tm *result);
183 
184 /**
185  * timespec_to_ns - Convert timespec to nanoseconds
186  * @ts:         pointer to the timespec variable to be converted
187  *
188  * Returns the scalar nanosecond representation of the timespec
189  * parameter.
190  */
191 static inline s64 timespec_to_ns(const struct timespec *ts)
192 {
193         return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
194 }
195 
196 /**
197  * timeval_to_ns - Convert timeval to nanoseconds
198  * @ts:         pointer to the timeval variable to be converted
199  *
200  * Returns the scalar nanosecond representation of the timeval
201  * parameter.
202  */
203 static inline s64 timeval_to_ns(const struct timeval *tv)
204 {
205         return ((s64) tv->tv_sec * NSEC_PER_SEC) +
206                 tv->tv_usec * NSEC_PER_USEC;
207 }
208 
209 /**
210  * ns_to_timespec - Convert nanoseconds to timespec
211  * @nsec:       the nanoseconds value to be converted
212  *
213  * Returns the timespec representation of the nsec parameter.
214  */
215 extern struct timespec ns_to_timespec(const s64 nsec);
216 
217 /**
218  * ns_to_timeval - Convert nanoseconds to timeval
219  * @nsec:       the nanoseconds value to be converted
220  *
221  * Returns the timeval representation of the nsec parameter.
222  */
223 extern struct timeval ns_to_timeval(const s64 nsec);
224 
225 /**
226  * timespec_add_ns - Adds nanoseconds to a timespec
227  * @a:          pointer to timespec to be incremented
228  * @ns:         unsigned nanoseconds value to be added
229  *
230  * This must always be inlined because its used from the x86-64 vdso,
231  * which cannot call other kernel functions.
232  */
233 static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
234 {
235         a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
236         a->tv_nsec = ns;
237 }
238 
239 #endif
240 

~ [ 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