Branch data     Line data    Source code

       1                 :            : /*
       2                 :            :  *  include/linux/ktime.h
       3                 :            :  *
       4                 :            :  *  ktime_t - nanosecond-resolution time format.
       5                 :            :  *
       6                 :            :  *   Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
       7                 :            :  *   Copyright(C) 2005, Red Hat, Inc., Ingo Molnar
       8                 :            :  *
       9                 :            :  *  data type definitions, declarations, prototypes and macros.
      10                 :            :  *
      11                 :            :  *  Started by: Thomas Gleixner and Ingo Molnar
      12                 :            :  *
      13                 :            :  *  Credits:
      14                 :            :  *
      15                 :            :  *      Roman Zippel provided the ideas and primary code snippets of
      16                 :            :  *      the ktime_t union and further simplifications of the original
      17                 :            :  *      code.
      18                 :            :  *
      19                 :            :  *  For licencing details see kernel-base/COPYING
      20                 :            :  */
      21                 :            : #ifndef _LINUX_KTIME_H
      22                 :            : #define _LINUX_KTIME_H
      23                 :            : 
      24                 :            : #include <linux/time.h>
      25                 :            : #include <linux/jiffies.h>
      26                 :            : 
      27                 :            : /* Nanosecond scalar representation for kernel time values */
      28                 :            : typedef s64     ktime_t;
      29                 :            : 
      30                 :            : /**
      31                 :            :  * ktime_set - Set a ktime_t variable from a seconds/nanoseconds value
      32                 :            :  * @secs:       seconds to set
      33                 :            :  * @nsecs:      nanoseconds to set
      34                 :            :  *
      35                 :            :  * Return: The ktime_t representation of the value.
      36                 :            :  */
      37                 :            : static inline ktime_t ktime_set(const s64 secs, const unsigned long nsecs)
      38                 :            : {
      39                 :          3 :         if (unlikely(secs >= KTIME_SEC_MAX))
      40                 :            :                 return KTIME_MAX;
      41                 :            : 
      42                 :          3 :         return secs * NSEC_PER_SEC + (s64)nsecs;
      43                 :            : }
      44                 :            : 
      45                 :            : /* Subtract two ktime_t variables. rem = lhs -rhs: */
      46                 :            : #define ktime_sub(lhs, rhs)     ((lhs) - (rhs))
      47                 :            : 
      48                 :            : /* Add two ktime_t variables. res = lhs + rhs: */
      49                 :            : #define ktime_add(lhs, rhs)     ((lhs) + (rhs))
      50                 :            : 
      51                 :            : /*
      52                 :            :  * Same as ktime_add(), but avoids undefined behaviour on overflow; however,
      53                 :            :  * this means that you must check the result for overflow yourself.
      54                 :            :  */
      55                 :            : #define ktime_add_unsafe(lhs, rhs)      ((u64) (lhs) + (rhs))
      56                 :            : 
      57                 :            : /*
      58                 :            :  * Add a ktime_t variable and a scalar nanosecond value.
      59                 :            :  * res = kt + nsval:
      60                 :            :  */
      61                 :            : #define ktime_add_ns(kt, nsval)         ((kt) + (nsval))
      62                 :            : 
      63                 :            : /*
      64                 :            :  * Subtract a scalar nanosecod from a ktime_t variable
      65                 :            :  * res = kt - nsval:
      66                 :            :  */
      67                 :            : #define ktime_sub_ns(kt, nsval)         ((kt) - (nsval))
      68                 :            : 
      69                 :            : /* convert a timespec to ktime_t format: */
      70                 :            : static inline ktime_t timespec_to_ktime(struct timespec ts)
      71                 :            : {
      72                 :            :         return ktime_set(ts.tv_sec, ts.tv_nsec);
      73                 :            : }
      74                 :            : 
      75                 :            : /* convert a timespec64 to ktime_t format: */
      76                 :            : static inline ktime_t timespec64_to_ktime(struct timespec64 ts)
      77                 :            : {
      78                 :          3 :         return ktime_set(ts.tv_sec, ts.tv_nsec);
      79                 :            : }
      80                 :            : 
      81                 :            : /* convert a timeval to ktime_t format: */
      82                 :            : static inline ktime_t timeval_to_ktime(struct timeval tv)
      83                 :            : {
      84                 :          3 :         return ktime_set(tv.tv_sec, tv.tv_usec * NSEC_PER_USEC);
      85                 :            : }
      86                 :            : 
      87                 :            : /* Map the ktime_t to timespec conversion to ns_to_timespec function */
      88                 :            : #define ktime_to_timespec(kt)           ns_to_timespec((kt))
      89                 :            : 
      90                 :            : /* Map the ktime_t to timespec conversion to ns_to_timespec function */
      91                 :            : #define ktime_to_timespec64(kt)         ns_to_timespec64((kt))
      92                 :            : 
      93                 :            : /* Map the ktime_t to timeval conversion to ns_to_timeval function */
      94                 :            : #define ktime_to_timeval(kt)            ns_to_timeval((kt))
      95                 :            : 
      96                 :            : /* Convert ktime_t to nanoseconds */
      97                 :          3 : static inline s64 ktime_to_ns(const ktime_t kt)
      98                 :            : {
      99                 :          3 :         return kt;
     100                 :            : }
     101                 :            : 
     102                 :            : /**
     103                 :            :  * ktime_compare - Compares two ktime_t variables for less, greater or equal
     104                 :            :  * @cmp1:       comparable1
     105                 :            :  * @cmp2:       comparable2
     106                 :            :  *
     107                 :            :  * Return: ...
     108                 :            :  *   cmp1  < cmp2: return <0
     109                 :            :  *   cmp1 == cmp2: return 0
     110                 :            :  *   cmp1  > cmp2: return >0
     111                 :            :  */
     112                 :            : static inline int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
     113                 :            : {
     114                 :          3 :         if (cmp1 < cmp2)
     115                 :            :                 return -1;
     116                 :          3 :         if (cmp1 > cmp2)
     117                 :            :                 return 1;
     118                 :            :         return 0;
     119                 :            : }
     120                 :            : 
     121                 :            : /**
     122                 :            :  * ktime_after - Compare if a ktime_t value is bigger than another one.
     123                 :            :  * @cmp1:       comparable1
     124                 :            :  * @cmp2:       comparable2
     125                 :            :  *
     126                 :            :  * Return: true if cmp1 happened after cmp2.
     127                 :            :  */
     128                 :            : static inline bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)
     129                 :            : {
     130                 :          0 :         return ktime_compare(cmp1, cmp2) > 0;
     131                 :            : }
     132                 :            : 
     133                 :            : /**
     134                 :            :  * ktime_before - Compare if a ktime_t value is smaller than another one.
     135                 :            :  * @cmp1:       comparable1
     136                 :            :  * @cmp2:       comparable2
     137                 :            :  *
     138                 :            :  * Return: true if cmp1 happened before cmp2.
     139                 :            :  */
     140                 :            : static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
     141                 :            : {
     142                 :            :         return ktime_compare(cmp1, cmp2) < 0;
     143                 :            : }
     144                 :            : 
     145                 :            : #if BITS_PER_LONG < 64
     146                 :            : extern s64 __ktime_divns(const ktime_t kt, s64 div);
     147                 :          3 : static inline s64 ktime_divns(const ktime_t kt, s64 div)
     148                 :            : {
     149                 :            :         /*
     150                 :            :          * Negative divisors could cause an inf loop,
     151                 :            :          * so bug out here.
     152                 :            :          */
     153                 :          3 :         BUG_ON(div < 0);
     154                 :          3 :         if (__builtin_constant_p(div) && !(div >> 32)) {
     155                 :            :                 s64 ns = kt;
     156                 :          3 :                 u64 tmp = ns < 0 ? -ns : ns;
     157                 :            : 
     158                 :          3 :                 do_div(tmp, div);
     159                 :          3 :                 return ns < 0 ? -tmp : tmp;
     160                 :            :         } else {
     161                 :          3 :                 return __ktime_divns(kt, div);
     162                 :            :         }
     163                 :            : }
     164                 :            : #else /* BITS_PER_LONG < 64 */
     165                 :            : static inline s64 ktime_divns(const ktime_t kt, s64 div)
     166                 :            : {
     167                 :            :         /*
     168                 :            :          * 32-bit implementation cannot handle negative divisors,
     169                 :            :          * so catch them on 64bit as well.
     170                 :            :          */
     171                 :            :         WARN_ON(div < 0);
     172                 :            :         return kt / div;
     173                 :            : }
     174                 :            : #endif
     175                 :            : 
     176                 :            : static inline s64 ktime_to_us(const ktime_t kt)
     177                 :            : {
     178                 :          2 :         return ktime_divns(kt, NSEC_PER_USEC);
     179                 :            : }
     180                 :            : 
     181                 :            : static inline s64 ktime_to_ms(const ktime_t kt)
     182                 :            : {
     183                 :          1 :         return ktime_divns(kt, NSEC_PER_MSEC);
     184                 :            : }
     185                 :            : 
     186                 :            : static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
     187                 :            : {
     188                 :          0 :        return ktime_to_us(ktime_sub(later, earlier));
     189                 :            : }
     190                 :            : 
     191                 :            : static inline s64 ktime_ms_delta(const ktime_t later, const ktime_t earlier)
     192                 :            : {
     193                 :            :         return ktime_to_ms(ktime_sub(later, earlier));
     194                 :            : }
     195                 :            : 
     196                 :            : static inline ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
     197                 :            : {
     198                 :          3 :         return ktime_add_ns(kt, usec * NSEC_PER_USEC);
     199                 :            : }
     200                 :            : 
     201                 :            : static inline ktime_t ktime_add_ms(const ktime_t kt, const u64 msec)
     202                 :            : {
     203                 :          0 :         return ktime_add_ns(kt, msec * NSEC_PER_MSEC);
     204                 :            : }
     205                 :            : 
     206                 :            : static inline ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
     207                 :            : {
     208                 :            :         return ktime_sub_ns(kt, usec * NSEC_PER_USEC);
     209                 :            : }
     210                 :            : 
     211                 :            : static inline ktime_t ktime_sub_ms(const ktime_t kt, const u64 msec)
     212                 :            : {
     213                 :            :         return ktime_sub_ns(kt, msec * NSEC_PER_MSEC);
     214                 :            : }
     215                 :            : 
     216                 :            : extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);
     217                 :            : 
     218                 :            : /**
     219                 :            :  * ktime_to_timespec_cond - convert a ktime_t variable to timespec
     220                 :            :  *                          format only if the variable contains data
     221                 :            :  * @kt:         the ktime_t variable to convert
     222                 :            :  * @ts:         the timespec variable to store the result in
     223                 :            :  *
     224                 :            :  * Return: %true if there was a successful conversion, %false if kt was 0.
     225                 :            :  */
     226                 :            : static inline __must_check bool ktime_to_timespec_cond(const ktime_t kt,
     227                 :            :                                                        struct timespec *ts)
     228                 :            : {
     229                 :          0 :         if (kt) {
     230                 :          0 :                 *ts = ktime_to_timespec(kt);
     231                 :            :                 return true;
     232                 :            :         } else {
     233                 :            :                 return false;
     234                 :            :         }
     235                 :            : }
     236                 :            : 
     237                 :            : /**
     238                 :            :  * ktime_to_timespec64_cond - convert a ktime_t variable to timespec64
     239                 :            :  *                          format only if the variable contains data
     240                 :            :  * @kt:         the ktime_t variable to convert
     241                 :            :  * @ts:         the timespec variable to store the result in
     242                 :            :  *
     243                 :            :  * Return: %true if there was a successful conversion, %false if kt was 0.
     244                 :            :  */
     245                 :            : static inline __must_check bool ktime_to_timespec64_cond(const ktime_t kt,
     246                 :            :                                                        struct timespec64 *ts)
     247                 :            : {
     248                 :          0 :         if (kt) {
     249                 :          0 :                 *ts = ktime_to_timespec64(kt);
     250                 :            :                 return true;
     251                 :            :         } else {
     252                 :            :                 return false;
     253                 :            :         }
     254                 :            : }
     255                 :            : 
     256                 :            : /*
     257                 :            :  * The resolution of the clocks. The resolution value is returned in
     258                 :            :  * the clock_getres() system call to give application programmers an
     259                 :            :  * idea of the (in)accuracy of timers. Timer values are rounded up to
     260                 :            :  * this resolution values.
     261                 :            :  */
     262                 :            : #define LOW_RES_NSEC            TICK_NSEC
     263                 :            : #define KTIME_LOW_RES           (LOW_RES_NSEC)
     264                 :            : 
     265                 :            : static inline ktime_t ns_to_ktime(u64 ns)
     266                 :            : {
     267                 :          3 :         return ns;
     268                 :            : }
     269                 :            : 
     270                 :            : static inline ktime_t ms_to_ktime(u64 ms)
     271                 :            : {
     272                 :          0 :         return ms * NSEC_PER_MSEC;
     273                 :            : }
     274                 :            : 
     275                 :            : # include <linux/timekeeping.h>
     276                 :            : # include <linux/timekeeping32.h>
     277                 :            : 
     278                 :            : #endif