include/linux/time32.h

   1 #ifndef _LINUX_TIME32_H
   2 #define _LINUX_TIME32_H
   3 /*
   4  * These are all interfaces based on the old time_t definition
   5  * that overflows in 2038 on 32-bit architectures. New code
   6  * should use the replacements based on time64_t and timespec64.
   7  *
   8  * Any interfaces in here that become unused as we migrate
   9  * code to time64_t should get removed.
  10  */
  11
  12 #include <linux/time64.h>
  13
  14 #define TIME_T_MAX      (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
  15
  16 #if __BITS_PER_LONG == 64
  17
  18 /* timespec64 is defined as timespec here */
  19 static inline struct timespec timespec64_to_timespec(const struct timespec64 ts64)
  20 {
  21         return ts64;
  22 }
  23
  24 static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)
  25 {
  26         return ts;
  27 }
  28
  29 # define timespec_equal                 timespec64_equal
  30 # define timespec_compare               timespec64_compare
  31 # define set_normalized_timespec        set_normalized_timespec64
  32 # define timespec_add                   timespec64_add
  33 # define timespec_sub                   timespec64_sub
  34 # define timespec_valid                 timespec64_valid
  35 # define timespec_valid_strict          timespec64_valid_strict
  36 # define timespec_to_ns                 timespec64_to_ns
  37 # define ns_to_timespec                 ns_to_timespec64
  38 # define timespec_add_ns                timespec64_add_ns
  39
  40 #else
  41 static inline struct timespec timespec64_to_timespec(const struct timespec64 ts64)
  42 {
  43         struct timespec ret;
  44
  45         ret.tv_sec = (time_t)ts64.tv_sec;
  46         ret.tv_nsec = ts64.tv_nsec;
  47         return ret;
  48 }
  49
  50 static inline struct timespec64 timespec_to_timespec64(const struct timespec ts)
  51 {
  52         struct timespec64 ret;
  53
  54         ret.tv_sec = ts.tv_sec;
  55         ret.tv_nsec = ts.tv_nsec;
  56         return ret;
  57 }
  58
  59 static inline int timespec_equal(const struct timespec *a,
  60                                  const struct timespec *b)
  61 {
  62         return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
  63 }
  64
  65 /*
  66  * lhs < rhs:  return <0
  67  * lhs == rhs: return 0
  68  * lhs > rhs:  return >0
  69  */
  70 static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs)
  71 {
  72         if (lhs->tv_sec < rhs->tv_sec)
  73                 return -1;
  74         if (lhs->tv_sec > rhs->tv_sec)
  75                 return 1;
  76         return lhs->tv_nsec - rhs->tv_nsec;
  77 }
  78
  79 extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);
  80
  81 static inline struct timespec timespec_add(struct timespec lhs,
  82                                                 struct timespec rhs)
  83 {
  84         struct timespec ts_delta;
  85
  86         set_normalized_timespec(&ts_delta, lhs.tv_sec + rhs.tv_sec,
  87                                 lhs.tv_nsec + rhs.tv_nsec);
  88         return ts_delta;
  89 }
  90
  91 /*
  92  * sub = lhs - rhs, in normalized form
  93  */
  94 static inline struct timespec timespec_sub(struct timespec lhs,
  95                                                 struct timespec rhs)
  96 {
  97         struct timespec ts_delta;
  98
  99         set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec,
 100                                 lhs.tv_nsec - rhs.tv_nsec);
 101         return ts_delta;
 102 }
 103
 104 /*
 105  * Returns true if the timespec is norm, false if denorm:
 106  */
 107 static inline bool timespec_valid(const struct timespec *ts)
 108 {
 109         /* Dates before 1970 are bogus */
 110         if (ts->tv_sec < 0)
 111                 return false;
 112         /* Can't have more nanoseconds then a second */
 113         if ((unsigned long)ts->tv_nsec >= NSEC_PER_SEC)
 114                 return false;
 115         return true;
 116 }
 117
 118 static inline bool timespec_valid_strict(const struct timespec *ts)
 119 {
 120         if (!timespec_valid(ts))
 121                 return false;
 122         /* Disallow values that could overflow ktime_t */
 123         if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
 124                 return false;
 125         return true;
 126 }
 127
 128 /**
 129  * timespec_to_ns - Convert timespec to nanoseconds
 130  * @ts:         pointer to the timespec variable to be converted
 131  *
 132  * Returns the scalar nanosecond representation of the timespec
 133  * parameter.
 134  */
 135 static inline s64 timespec_to_ns(const struct timespec *ts)
 136 {
 137         return ((s64) ts->tv_sec * NSEC_PER_SEC) + ts->tv_nsec;
 138 }
 139
 140 /**
 141  * ns_to_timespec - Convert nanoseconds to timespec
 142  * @nsec:       the nanoseconds value to be converted
 143  *
 144  * Returns the timespec representation of the nsec parameter.
 145  */
 146 extern struct timespec ns_to_timespec(const s64 nsec);
 147
 148 /**
 149  * timespec_add_ns - Adds nanoseconds to a timespec
 150  * @a:          pointer to timespec to be incremented
 151  * @ns:         unsigned nanoseconds value to be added
 152  *
 153  * This must always be inlined because its used from the x86-64 vdso,
 154  * which cannot call other kernel functions.
 155  */
 156 static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
 157 {
 158         a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, NSEC_PER_SEC, &ns);
 159         a->tv_nsec = ns;
 160 }
 161
 162 #endif
 163
 164 /**
 165  * time_to_tm - converts the calendar time to local broken-down time
 166  *
 167  * @totalsecs   the number of seconds elapsed since 00:00:00 on January 1, 1970,
 168  *              Coordinated Universal Time (UTC).
 169  * @offset      offset seconds adding to totalsecs.
 170  * @result      pointer to struct tm variable to receive broken-down time
 171  */
 172 static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
 173 {
 174         time64_to_tm(totalsecs, offset, result);
 175 }
 176
 177 static inline unsigned long mktime(const unsigned int year,
 178                         const unsigned int mon, const unsigned int day,
 179                         const unsigned int hour, const unsigned int min,
 180                         const unsigned int sec)
 181 {
 182         return mktime64(year, mon, day, hour, min, sec);
 183 }
 184
 185 static inline bool timeval_valid(const struct timeval *tv)
 186 {
 187         /* Dates before 1970 are bogus */
 188         if (tv->tv_sec < 0)
 189                 return false;
 190
 191         /* Can't have more microseconds then a second */
 192         if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
 193                 return false;
 194
 195         return true;
 196 }
 197
 198 extern struct timespec timespec_trunc(struct timespec t, unsigned int gran);
 199
 200 /**
 201  * timeval_to_ns - Convert timeval to nanoseconds
 202  * @ts:         pointer to the timeval variable to be converted
 203  *
 204  * Returns the scalar nanosecond representation of the timeval
 205  * parameter.
 206  */
 207 static inline s64 timeval_to_ns(const struct timeval *tv)
 208 {
 209         return ((s64) tv->tv_sec * NSEC_PER_SEC) +
 210                 tv->tv_usec * NSEC_PER_USEC;
 211 }
 212
 213 /**
 214  * ns_to_timeval - Convert nanoseconds to timeval
 215  * @nsec:       the nanoseconds value to be converted
 216  *
 217  * Returns the timeval representation of the nsec parameter.
 218  */
 219 extern struct timeval ns_to_timeval(const s64 nsec);
 220
 221 #endif