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