Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #ifndef _LINUX_TIME64_H
  2. #define _LINUX_TIME64_H
  3.  
  4. #include <uapi/linux/time.h>
  5.  
  6. typedef __s64 time64_t;
  7.  
  8. /*
  9.  * This wants to go into uapi/linux/time.h once we agreed about the
  10.  * userspace interfaces.
  11.  */
  12. #if __BITS_PER_LONG == 64
  13. # define timespec64 timespec
  14. #else
  15. struct timespec64 {
  16.         time64_t        tv_sec;                 /* seconds */
  17.         long            tv_nsec;                /* nanoseconds */
  18. };
  19. #endif
  20.  
  21. /* Parameters used to convert the timespec values: */
  22. #define MSEC_PER_SEC    1000L
  23. #define USEC_PER_MSEC   1000L
  24. #define NSEC_PER_USEC   1000L
  25. #define NSEC_PER_MSEC   1000000L
  26. #define USEC_PER_SEC    1000000L
  27. #define NSEC_PER_SEC    1000000000L
  28. #define FSEC_PER_SEC    1000000000000000LL
  29.  
  30. /* Located here for timespec[64]_valid_strict */
  31. #define KTIME_MAX                       ((s64)~((u64)1 << 63))
  32. #define KTIME_SEC_MAX                   (KTIME_MAX / NSEC_PER_SEC)
  33.  
  34. #if __BITS_PER_LONG == 64
  35.  
  36. static inline struct timespec timespec64_to_timespec(const struct timespec64 ts64)
  37. {
  38.         return ts64;
  39. }
  40.  
  41. static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)
  42. {
  43.         return ts;
  44. }
  45.  
  46. # define timespec64_equal               timespec_equal
  47. # define timespec64_compare             timespec_compare
  48. # define set_normalized_timespec64      set_normalized_timespec
  49. # define timespec64_add_safe            timespec_add_safe
  50. # define timespec64_add                 timespec_add
  51. # define timespec64_sub                 timespec_sub
  52. # define timespec64_valid               timespec_valid
  53. # define timespec64_valid_strict        timespec_valid_strict
  54. # define timespec64_to_ns               timespec_to_ns
  55. # define ns_to_timespec64               ns_to_timespec
  56. # define timespec64_add_ns              timespec_add_ns
  57.  
  58. #else
  59.  
  60. static inline struct timespec timespec64_to_timespec(const struct timespec64 ts64)
  61. {
  62.         struct timespec ret;
  63.  
  64.         ret.tv_sec = (time_t)ts64.tv_sec;
  65.         ret.tv_nsec = ts64.tv_nsec;
  66.         return ret;
  67. }
  68.  
  69. static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)
  70. {
  71.         struct timespec64 ret;
  72.  
  73.         ret.tv_sec = ts.tv_sec;
  74.         ret.tv_nsec = ts.tv_nsec;
  75.         return ret;
  76. }
  77.  
  78. static inline int timespec64_equal(const struct timespec64 *a,
  79.                                    const struct timespec64 *b)
  80. {
  81.         return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
  82. }
  83.  
  84. /*
  85.  * lhs < rhs:  return <0
  86.  * lhs == rhs: return 0
  87.  * lhs > rhs:  return >0
  88.  */
  89. static inline int timespec64_compare(const struct timespec64 *lhs, const struct timespec64 *rhs)
  90. {
  91.         if (lhs->tv_sec < rhs->tv_sec)
  92.                 return -1;
  93.         if (lhs->tv_sec > rhs->tv_sec)
  94.                 return 1;
  95.         return lhs->tv_nsec - rhs->tv_nsec;
  96. }
  97.  
  98. extern void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);
  99.  
  100. /*
  101.  * timespec64_add_safe assumes both values are positive and checks for
  102.  * overflow. It will return TIME_T_MAX if the returned value would be
  103.  * smaller then either of the arguments.
  104.  */
  105. extern struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
  106.                                          const struct timespec64 rhs);
  107.  
  108.  
  109. static inline struct timespec64 timespec64_add(struct timespec64 lhs,
  110.                                                 struct timespec64 rhs)
  111. {
  112.         struct timespec64 ts_delta;
  113.         set_normalized_timespec64(&ts_delta, lhs.tv_sec + rhs.tv_sec,
  114.                                 lhs.tv_nsec + rhs.tv_nsec);
  115.         return ts_delta;
  116. }
  117.  
  118. /*
  119.  * sub = lhs - rhs, in normalized form
  120.  */
  121. static inline struct timespec64 timespec64_sub(struct timespec64 lhs,
  122.                                                 struct timespec64 rhs)
  123. {
  124.         struct timespec64 ts_delta;
  125.         set_normalized_timespec64(&ts_delta, lhs.tv_sec - rhs.tv_sec,
  126.                                 lhs.tv_nsec - rhs.tv_nsec);
  127.         return ts_delta;
  128. }
  129.  
  130. /*
  131.  * Returns true if the timespec64 is norm, false if denorm:
  132.  */
  133. static inline bool timespec64_valid(const struct timespec64 *ts)
  134. {
  135.         /* Dates before 1970 are bogus */
  136.         if (ts->tv_sec < 0)
  137.                 return false;
  138.         /* Can't have more nanoseconds then a second */
  139.         if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
  140.                 return false;
  141.         return true;
  142. }
  143.  
  144. static inline bool timespec64_valid_strict(const struct timespec64 *ts)
  145. {
  146.         if (!timespec64_valid(ts))
  147.                 return false;
  148.         /* Disallow values that could overflow ktime_t */
  149.         if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
  150.                 return false;
  151.         return true;
  152. }
  153.  
  154. /**
  155.  * timespec64_to_ns - Convert timespec64 to nanoseconds
  156.  * @ts:         pointer to the timespec64 variable to be converted
  157.  *
  158.  * Returns the scalar nanosecond representation of the timespec64
  159.  * parameter.
  160.  */
  161. static inline s64 timespec64_to_ns(const struct timespec64 *ts)
  162. {
  163.         return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
  164. }
  165.  
  166. /**
  167.  * ns_to_timespec64 - Convert nanoseconds to timespec64
  168.  * @nsec:       the nanoseconds value to be converted
  169.  *
  170.  * Returns the timespec64 representation of the nsec parameter.
  171.  */
  172. extern struct timespec64 ns_to_timespec64(const s64 nsec);
  173.  
  174. /**
  175.  * timespec64_add_ns - Adds nanoseconds to a timespec64
  176.  * @a:          pointer to timespec64 to be incremented
  177.  * @ns:         unsigned nanoseconds value to be added
  178.  *
  179.  * This must always be inlined because its used from the x86-64 vdso,
  180.  * which cannot call other kernel functions.
  181.  */
  182. static __always_inline void timespec64_add_ns(struct timespec64 *a, u64 ns)
  183. {
  184.         a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
  185.         a->tv_nsec = ns;
  186. }
  187.  
  188. #endif
  189.  
  190. #endif /* _LINUX_TIME64_H */
  191.