time.h 9.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345
  1. #ifndef _LINUX_TIME_H
  2. #define _LINUX_TIME_H
  3. #include <linux/types.h>
  4. #ifdef __KERNEL__
  5. # include <linux/cache.h>
  6. # include <linux/seqlock.h>
  7. # include <linux/math64.h>
  8. #endif
  9. #ifndef _STRUCT_TIMESPEC
  10. #define _STRUCT_TIMESPEC
  11. struct timespec {
  12. __kernel_time_t tv_sec; /* seconds */
  13. long tv_nsec; /* nanoseconds */
  14. };
  15. #endif
  16. struct timeval {
  17. __kernel_time_t tv_sec; /* seconds */
  18. __kernel_suseconds_t tv_usec; /* microseconds */
  19. };
  20. struct timezone {
  21. int tz_minuteswest; /* minutes west of Greenwich */
  22. int tz_dsttime; /* type of dst correction */
  23. };
  24. #ifdef __KERNEL__
  25. extern struct timezone sys_tz;
  26. /* Parameters used to convert the timespec values: */
  27. #define MSEC_PER_SEC 1000L
  28. #define USEC_PER_MSEC 1000L
  29. #define NSEC_PER_USEC 1000L
  30. #define NSEC_PER_MSEC 1000000L
  31. #define USEC_PER_SEC 1000000L
  32. #define NSEC_PER_SEC 1000000000L
  33. #define FSEC_PER_SEC 1000000000000000LL
  34. #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
  35. static inline int timespec_equal(const struct timespec *a,
  36. const struct timespec *b)
  37. {
  38. return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
  39. }
  40. /*
  41. * lhs < rhs: return <0
  42. * lhs == rhs: return 0
  43. * lhs > rhs: return >0
  44. */
  45. static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
  46. {
  47. if (lhs->tv_sec < rhs->tv_sec)
  48. return -1;
  49. if (lhs->tv_sec > rhs->tv_sec)
  50. return 1;
  51. return lhs->tv_nsec - rhs->tv_nsec;
  52. }
  53. static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs)
  54. {
  55. if (lhs->tv_sec < rhs->tv_sec)
  56. return -1;
  57. if (lhs->tv_sec > rhs->tv_sec)
  58. return 1;
  59. return lhs->tv_usec - rhs->tv_usec;
  60. }
  61. extern unsigned long mktime(const unsigned int year, const unsigned int mon,
  62. const unsigned int day, const unsigned int hour,
  63. const unsigned int min, const unsigned int sec);
  64. extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
  65. /*
  66. * timespec_add_safe assumes both values are positive and checks
  67. * for overflow. It will return TIME_T_MAX if the reutrn would be
  68. * smaller then either of the arguments.
  69. */
  70. extern struct timespec timespec_add_safe(const struct timespec lhs,
  71. const struct timespec rhs);
  72. static inline struct timespec timespec_add(struct timespec lhs,
  73. struct timespec rhs)
  74. {
  75. struct timespec ts_delta;
  76. set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
  77. (s64)lhs.tv_nsec + rhs.tv_nsec);
  78. return ts_delta;
  79. }
  80. /*
  81. * sub = lhs - rhs, in normalized form
  82. */
  83. static inline struct timespec timespec_sub(struct timespec lhs,
  84. struct timespec rhs)
  85. {
  86. struct timespec ts_delta;
  87. set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
  88. (s64)lhs.tv_nsec - rhs.tv_nsec);
  89. return ts_delta;
  90. }
  91. #define KTIME_MAX ((s64)~((u64)1 << 63))
  92. #if (BITS_PER_LONG == 64)
  93. # define KTIME_SEC_MAX (KTIME_MAX / NSEC_PER_SEC)
  94. #else
  95. # define KTIME_SEC_MAX LONG_MAX
  96. #endif
  97. /*
  98. * Returns true if the timespec is norm, false if denorm:
  99. */
  100. static inline bool timespec_valid(const struct timespec *ts)
  101. {
  102. /* Dates before 1970 are bogus */
  103. if (ts->tv_sec < 0)
  104. return false;
  105. /* Can't have more nanoseconds then a second */
  106. if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
  107. return false;
  108. return true;
  109. }
  110. static inline bool timespec_valid_strict(const struct timespec *ts)
  111. {
  112. if (!timespec_valid(ts))
  113. return false;
  114. /* Disallow values that could overflow ktime_t */
  115. if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
  116. return false;
  117. return true;
  118. }
  119. extern void read_persistent_clock(struct timespec *ts);
  120. extern void read_boot_clock(struct timespec *ts);
  121. extern int update_persistent_clock(struct timespec now);
  122. void timekeeping_init(void);
  123. extern int timekeeping_suspended;
  124. unsigned long get_seconds(void);
  125. struct timespec current_kernel_time(void);
  126. struct timespec __current_kernel_time(void); /* does not take xtime_lock */
  127. struct timespec get_monotonic_coarse(void);
  128. void get_xtime_and_monotonic_and_sleep_offset(struct timespec *xtim,
  129. struct timespec *wtom, struct timespec *sleep);
  130. void timekeeping_inject_sleeptime(struct timespec *delta);
  131. #define CURRENT_TIME (current_kernel_time())
  132. #define CURRENT_TIME_SEC ((struct timespec) { get_seconds(), 0 })
  133. /* Some architectures do not supply their own clocksource.
  134. * This is mainly the case in architectures that get their
  135. * inter-tick times by reading the counter on their interval
  136. * timer. Since these timers wrap every tick, they're not really
  137. * useful as clocksources. Wrapping them to act like one is possible
  138. * but not very efficient. So we provide a callout these arches
  139. * can implement for use with the jiffies clocksource to provide
  140. * finer then tick granular time.
  141. */
  142. #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
  143. extern u32 arch_gettimeoffset(void);
  144. #else
  145. static inline u32 arch_gettimeoffset(void) { return 0; }
  146. #endif
  147. extern void do_gettimeofday(struct timeval *tv);
  148. extern int do_settimeofday(const struct timespec *tv);
  149. extern int do_sys_settimeofday(const struct timespec *tv,
  150. const struct timezone *tz);
  151. #define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
  152. extern long do_utimes(int dfd, const char __user *filename, struct timespec *times, int flags);
  153. struct itimerval;
  154. extern int do_setitimer(int which, struct itimerval *value,
  155. struct itimerval *ovalue);
  156. extern unsigned int alarm_setitimer(unsigned int seconds);
  157. extern int do_getitimer(int which, struct itimerval *value);
  158. extern void getnstimeofday(struct timespec *tv);
  159. extern void getrawmonotonic(struct timespec *ts);
  160. extern void getnstime_raw_and_real(struct timespec *ts_raw,
  161. struct timespec *ts_real);
  162. extern void getboottime(struct timespec *ts);
  163. extern void monotonic_to_bootbased(struct timespec *ts);
  164. extern void get_monotonic_boottime(struct timespec *ts);
  165. static inline bool timeval_valid(const struct timeval *tv)
  166. {
  167. /* Dates before 1970 are bogus */
  168. if (tv->tv_sec < 0)
  169. return false;
  170. /* Can't have more microseconds then a second */
  171. if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
  172. return false;
  173. return true;
  174. }
  175. extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
  176. extern int timekeeping_valid_for_hres(void);
  177. extern u64 timekeeping_max_deferment(void);
  178. extern void timekeeping_leap_insert(int leapsecond);
  179. extern int timekeeping_inject_offset(struct timespec *ts);
  180. struct tms;
  181. extern void do_sys_times(struct tms *);
  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. void time_to_tm(time_t totalsecs, int offset, struct tm *result);
  208. /**
  209. * timespec_to_ns - Convert timespec to nanoseconds
  210. * @ts: pointer to the timespec variable to be converted
  211. *
  212. * Returns the scalar nanosecond representation of the timespec
  213. * parameter.
  214. */
  215. static inline s64 timespec_to_ns(const struct timespec *ts)
  216. {
  217. return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
  218. }
  219. /**
  220. * timeval_to_ns - Convert timeval to nanoseconds
  221. * @ts: pointer to the timeval variable to be converted
  222. *
  223. * Returns the scalar nanosecond representation of the timeval
  224. * parameter.
  225. */
  226. static inline s64 timeval_to_ns(const struct timeval *tv)
  227. {
  228. return ((s64) tv->tv_sec * NSEC_PER_SEC) +
  229. tv->tv_usec * NSEC_PER_USEC;
  230. }
  231. /**
  232. * ns_to_timespec - Convert nanoseconds to timespec
  233. * @nsec: the nanoseconds value to be converted
  234. *
  235. * Returns the timespec representation of the nsec parameter.
  236. */
  237. extern struct timespec ns_to_timespec(const s64 nsec);
  238. /**
  239. * ns_to_timeval - Convert nanoseconds to timeval
  240. * @nsec: the nanoseconds value to be converted
  241. *
  242. * Returns the timeval representation of the nsec parameter.
  243. */
  244. extern struct timeval ns_to_timeval(const s64 nsec);
  245. /**
  246. * timespec_add_ns - Adds nanoseconds to a timespec
  247. * @a: pointer to timespec to be incremented
  248. * @ns: unsigned nanoseconds value to be added
  249. *
  250. * This must always be inlined because its used from the x86-64 vdso,
  251. * which cannot call other kernel functions.
  252. */
  253. static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
  254. {
  255. a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
  256. a->tv_nsec = ns;
  257. }
  258. #endif /* __KERNEL__ */
  259. /*
  260. * Names of the interval timers, and structure
  261. * defining a timer setting:
  262. */
  263. #define ITIMER_REAL 0
  264. #define ITIMER_VIRTUAL 1
  265. #define ITIMER_PROF 2
  266. struct itimerspec {
  267. struct timespec it_interval; /* timer period */
  268. struct timespec it_value; /* timer expiration */
  269. };
  270. struct itimerval {
  271. struct timeval it_interval; /* timer interval */
  272. struct timeval it_value; /* current value */
  273. };
  274. /*
  275. * The IDs of the various system clocks (for POSIX.1b interval timers):
  276. */
  277. #define CLOCK_REALTIME 0
  278. #define CLOCK_MONOTONIC 1
  279. #define CLOCK_PROCESS_CPUTIME_ID 2
  280. #define CLOCK_THREAD_CPUTIME_ID 3
  281. #define CLOCK_MONOTONIC_RAW 4
  282. #define CLOCK_REALTIME_COARSE 5
  283. #define CLOCK_MONOTONIC_COARSE 6
  284. #define CLOCK_BOOTTIME 7
  285. #define CLOCK_REALTIME_ALARM 8
  286. #define CLOCK_BOOTTIME_ALARM 9
  287. /*
  288. * The IDs of various hardware clocks:
  289. */
  290. #define CLOCK_SGI_CYCLE 10
  291. #define MAX_CLOCKS 16
  292. #define CLOCKS_MASK (CLOCK_REALTIME | CLOCK_MONOTONIC)
  293. #define CLOCKS_MONO CLOCK_MONOTONIC
  294. /*
  295. * The various flags for setting POSIX.1b interval timers:
  296. */
  297. #define TIMER_ABSTIME 0x01
  298. #endif