LCOV - code coverage report
Current view: top level - include/linux - jiffies.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1 1 100.0 %
Date: 2017-01-25 Functions: 0 0 -

          Line data    Source code
       1             : #ifndef _LINUX_JIFFIES_H
       2             : #define _LINUX_JIFFIES_H
       3             : 
       4             : #include <linux/math64.h>
       5             : #include <linux/kernel.h>
       6             : #include <linux/types.h>
       7             : #include <linux/time.h>
       8             : #include <linux/timex.h>
       9             : #include <asm/param.h>                    /* for HZ */
      10             : 
      11             : /*
      12             :  * The following defines establish the engineering parameters of the PLL
      13             :  * model. The HZ variable establishes the timer interrupt frequency, 100 Hz
      14             :  * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the
      15             :  * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the
      16             :  * nearest power of two in order to avoid hardware multiply operations.
      17             :  */
      18             : #if HZ >= 12 && HZ < 24
      19             : # define SHIFT_HZ       4
      20             : #elif HZ >= 24 && HZ < 48
      21             : # define SHIFT_HZ       5
      22             : #elif HZ >= 48 && HZ < 96
      23             : # define SHIFT_HZ       6
      24             : #elif HZ >= 96 && HZ < 192
      25             : # define SHIFT_HZ       7
      26             : #elif HZ >= 192 && HZ < 384
      27             : # define SHIFT_HZ       8
      28             : #elif HZ >= 384 && HZ < 768
      29             : # define SHIFT_HZ       9
      30             : #elif HZ >= 768 && HZ < 1536
      31             : # define SHIFT_HZ       10
      32             : #elif HZ >= 1536 && HZ < 3072
      33             : # define SHIFT_HZ       11
      34             : #elif HZ >= 3072 && HZ < 6144
      35             : # define SHIFT_HZ       12
      36             : #elif HZ >= 6144 && HZ < 12288
      37             : # define SHIFT_HZ       13
      38             : #else
      39             : # error Invalid value of HZ.
      40             : #endif
      41             : 
      42             : /* LATCH is used in the interval timer and ftape setup. */
      43             : #define LATCH  ((CLOCK_TICK_RATE + HZ/2) / HZ)  /* For divider */
      44             : 
      45             : /* Suppose we want to devide two numbers NOM and DEN: NOM/DEN, then we can
      46             :  * improve accuracy by shifting LSH bits, hence calculating:
      47             :  *     (NOM << LSH) / DEN
      48             :  * This however means trouble for large NOM, because (NOM << LSH) may no
      49             :  * longer fit in 32 bits. The following way of calculating this gives us
      50             :  * some slack, under the following conditions:
      51             :  *   - (NOM / DEN) fits in (32 - LSH) bits.
      52             :  *   - (NOM % DEN) fits in (32 - LSH) bits.
      53             :  */
      54             : #define SH_DIV(NOM,DEN,LSH) (   (((NOM) / (DEN)) << (LSH))              \
      55             :                              + ((((NOM) % (DEN)) << (LSH)) + (DEN) / 2) / (DEN))
      56             : 
      57             : /* HZ is the requested value. ACTHZ is actual HZ ("<< 8" is for accuracy) */
      58             : #define ACTHZ (SH_DIV (CLOCK_TICK_RATE, LATCH, 8))
      59             : 
      60             : /* TICK_NSEC is the time between ticks in nsec assuming real ACTHZ */
      61             : #define TICK_NSEC (SH_DIV (1000000UL * 1000, ACTHZ, 8))
      62             : 
      63             : /* TICK_USEC is the time between ticks in usec assuming fake USER_HZ */
      64             : #define TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ)
      65             : 
      66             : /* TICK_USEC_TO_NSEC is the time between ticks in nsec assuming real ACTHZ and  */
      67             : /* a value TUSEC for TICK_USEC (can be set bij adjtimex)                */
      68             : #define TICK_USEC_TO_NSEC(TUSEC) (SH_DIV (TUSEC * USER_HZ * 1000, ACTHZ, 8))
      69             : 
      70             : /* some arch's have a small-data section that can be accessed register-relative
      71             :  * but that can only take up to, say, 4-byte variables. jiffies being part of
      72             :  * an 8-byte variable may not be correctly accessed unless we force the issue
      73             :  */
      74             : #define __jiffy_data  __attribute__((section(".data")))
      75             : 
      76             : /*
      77             :  * The 64-bit value is not atomic - you MUST NOT read it
      78             :  * without sampling the sequence number in xtime_lock.
      79             :  * get_jiffies_64() will do this for you as appropriate.
      80             :  */
      81             : extern u64 __jiffy_data jiffies_64;
      82             : extern unsigned long volatile __jiffy_data jiffies;
      83             : 
      84             : #if (BITS_PER_LONG < 64)
      85             : u64 get_jiffies_64(void);
      86             : #else
      87             : static inline u64 get_jiffies_64(void)
      88             : {
      89             :         return (u64)jiffies;
      90             : }
      91             : #endif
      92             : 
      93             : /*
      94             :  *      These inlines deal with timer wrapping correctly. You are 
      95             :  *      strongly encouraged to use them
      96             :  *      1. Because people otherwise forget
      97             :  *      2. Because if the timer wrap changes in future you won't have to
      98             :  *         alter your driver code.
      99             :  *
     100             :  * time_after(a,b) returns true if the time a is after time b.
     101             :  *
     102             :  * Do this with "<0" and ">=0" to only test the sign of the result. A
     103             :  * good compiler would generate better code (and a really good compiler
     104             :  * wouldn't care). Gcc is currently neither.
     105             :  */
     106             : #define time_after(a,b)         \
     107             :         (typecheck(unsigned long, a) && \
     108             :          typecheck(unsigned long, b) && \
     109             :          ((long)(b) - (long)(a) < 0))
     110             : #define time_before(a,b)        time_after(b,a)
     111             : 
     112             : #define time_after_eq(a,b)      \
     113             :         (typecheck(unsigned long, a) && \
     114             :          typecheck(unsigned long, b) && \
     115             :          ((long)(a) - (long)(b) >= 0))
     116             : #define time_before_eq(a,b)     time_after_eq(b,a)
     117             : 
     118             : /*
     119             :  * Calculate whether a is in the range of [b, c].
     120             :  */
     121             : #define time_in_range(a,b,c) \
     122             :         (time_after_eq(a,b) && \
     123             :          time_before_eq(a,c))
     124             : 
     125             : /*
     126             :  * Calculate whether a is in the range of [b, c).
     127             :  */
     128             : #define time_in_range_open(a,b,c) \
     129             :         (time_after_eq(a,b) && \
     130             :          time_before(a,c))
     131             : 
     132             : /* Same as above, but does so with platform independent 64bit types.
     133             :  * These must be used when utilizing jiffies_64 (i.e. return value of
     134             :  * get_jiffies_64() */
     135             : #define time_after64(a,b)       \
     136             :         (typecheck(__u64, a) && \
     137             :          typecheck(__u64, b) && \
     138             :          ((__s64)(b) - (__s64)(a) < 0))
     139             : #define time_before64(a,b)      time_after64(b,a)
     140             : 
     141             : #define time_after_eq64(a,b)    \
     142             :         (typecheck(__u64, a) && \
     143             :          typecheck(__u64, b) && \
     144             :          ((__s64)(a) - (__s64)(b) >= 0))
     145             : #define time_before_eq64(a,b)   time_after_eq64(b,a)
     146             : 
     147             : /*
     148             :  * These four macros compare jiffies and 'a' for convenience.
     149             :  */
     150             : 
     151             : /* time_is_before_jiffies(a) return true if a is before jiffies */
     152             : #define time_is_before_jiffies(a) time_after(jiffies, a)
     153             : 
     154             : /* time_is_after_jiffies(a) return true if a is after jiffies */
     155             : #define time_is_after_jiffies(a) time_before(jiffies, a)
     156             : 
     157             : /* time_is_before_eq_jiffies(a) return true if a is before or equal to jiffies*/
     158             : #define time_is_before_eq_jiffies(a) time_after_eq(jiffies, a)
     159             : 
     160             : /* time_is_after_eq_jiffies(a) return true if a is after or equal to jiffies*/
     161             : #define time_is_after_eq_jiffies(a) time_before_eq(jiffies, a)
     162             : 
     163             : /*
     164             :  * Have the 32 bit jiffies value wrap 5 minutes after boot
     165             :  * so jiffies wrap bugs show up earlier.
     166             :  */
     167             : #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
     168             : 
     169             : /*
     170             :  * Change timeval to jiffies, trying to avoid the
     171             :  * most obvious overflows..
     172             :  *
     173             :  * And some not so obvious.
     174             :  *
     175             :  * Note that we don't want to return LONG_MAX, because
     176             :  * for various timeout reasons we often end up having
     177             :  * to wait "jiffies+1" in order to guarantee that we wait
     178             :  * at _least_ "jiffies" - so "jiffies+1" had better still
     179             :  * be positive.
     180             :  */
     181             : #define MAX_JIFFY_OFFSET ((LONG_MAX >> 1)-1)
     182             : 
     183             : extern unsigned long preset_lpj;
     184             : 
     185             : /*
     186             :  * We want to do realistic conversions of time so we need to use the same
     187             :  * values the update wall clock code uses as the jiffies size.  This value
     188             :  * is: TICK_NSEC (which is defined in timex.h).  This
     189             :  * is a constant and is in nanoseconds.  We will use scaled math
     190             :  * with a set of scales defined here as SEC_JIFFIE_SC,  USEC_JIFFIE_SC and
     191             :  * NSEC_JIFFIE_SC.  Note that these defines contain nothing but
     192             :  * constants and so are computed at compile time.  SHIFT_HZ (computed in
     193             :  * timex.h) adjusts the scaling for different HZ values.
     194             : 
     195             :  * Scaled math???  What is that?
     196             :  *
     197             :  * Scaled math is a way to do integer math on values that would,
     198             :  * otherwise, either overflow, underflow, or cause undesired div
     199             :  * instructions to appear in the execution path.  In short, we "scale"
     200             :  * up the operands so they take more bits (more precision, less
     201             :  * underflow), do the desired operation and then "scale" the result back
     202             :  * by the same amount.  If we do the scaling by shifting we avoid the
     203             :  * costly mpy and the dastardly div instructions.
     204             : 
     205             :  * Suppose, for example, we want to convert from seconds to jiffies
     206             :  * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE.  The
     207             :  * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We
     208             :  * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we
     209             :  * might calculate at compile time, however, the result will only have
     210             :  * about 3-4 bits of precision (less for smaller values of HZ).
     211             :  *
     212             :  * So, we scale as follows:
     213             :  * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE);
     214             :  * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE;
     215             :  * Then we make SCALE a power of two so:
     216             :  * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE;
     217             :  * Now we define:
     218             :  * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE))
     219             :  * jiff = (sec * SEC_CONV) >> SCALE;
     220             :  *
     221             :  * Often the math we use will expand beyond 32-bits so we tell C how to
     222             :  * do this and pass the 64-bit result of the mpy through the ">> SCALE"
     223             :  * which should take the result back to 32-bits.  We want this expansion
     224             :  * to capture as much precision as possible.  At the same time we don't
     225             :  * want to overflow so we pick the SCALE to avoid this.  In this file,
     226             :  * that means using a different scale for each range of HZ values (as
     227             :  * defined in timex.h).
     228             :  *
     229             :  * For those who want to know, gcc will give a 64-bit result from a "*"
     230             :  * operator if the result is a long long AND at least one of the
     231             :  * operands is cast to long long (usually just prior to the "*" so as
     232             :  * not to confuse it into thinking it really has a 64-bit operand,
     233             :  * which, buy the way, it can do, but it takes more code and at least 2
     234             :  * mpys).
     235             : 
     236             :  * We also need to be aware that one second in nanoseconds is only a
     237             :  * couple of bits away from overflowing a 32-bit word, so we MUST use
     238             :  * 64-bits to get the full range time in nanoseconds.
     239             : 
     240             :  */
     241             : 
     242             : /*
     243             :  * Here are the scales we will use.  One for seconds, nanoseconds and
     244             :  * microseconds.
     245             :  *
     246             :  * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and
     247             :  * check if the sign bit is set.  If not, we bump the shift count by 1.
     248             :  * (Gets an extra bit of precision where we can use it.)
     249             :  * We know it is set for HZ = 1024 and HZ = 100 not for 1000.
     250             :  * Haven't tested others.
     251             : 
     252             :  * Limits of cpp (for #if expressions) only long (no long long), but
     253             :  * then we only need the most signicant bit.
     254             :  */
     255             : 
     256             : #define SEC_JIFFIE_SC (31 - SHIFT_HZ)
     257             : #if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000)
     258             : #undef SEC_JIFFIE_SC
     259             : #define SEC_JIFFIE_SC (32 - SHIFT_HZ)
     260             : #endif
     261             : #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29)
     262             : #define USEC_JIFFIE_SC (SEC_JIFFIE_SC + 19)
     263             : #define SEC_CONVERSION ((unsigned long)((((u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\
     264             :                                 TICK_NSEC -1) / (u64)TICK_NSEC))
     265             : 
     266             : #define NSEC_CONVERSION ((unsigned long)((((u64)1 << NSEC_JIFFIE_SC) +\
     267             :                                         TICK_NSEC -1) / (u64)TICK_NSEC))
     268             : #define USEC_CONVERSION  \
     269             :                     ((unsigned long)((((u64)NSEC_PER_USEC << USEC_JIFFIE_SC) +\
     270             :                                         TICK_NSEC -1) / (u64)TICK_NSEC))
     271             : /*
     272             :  * USEC_ROUND is used in the timeval to jiffie conversion.  See there
     273             :  * for more details.  It is the scaled resolution rounding value.  Note
     274             :  * that it is a 64-bit value.  Since, when it is applied, we are already
     275             :  * in jiffies (albit scaled), it is nothing but the bits we will shift
     276             :  * off.
     277             :  */
     278             : #define USEC_ROUND (u64)(((u64)1 << USEC_JIFFIE_SC) - 1)
     279             : /*
     280             :  * The maximum jiffie value is (MAX_INT >> 1).  Here we translate that
     281             :  * into seconds.  The 64-bit case will overflow if we are not careful,
     282             :  * so use the messy SH_DIV macro to do it.  Still all constants.
     283             :  */
     284             : #if BITS_PER_LONG < 64
     285             : # define MAX_SEC_IN_JIFFIES \
     286             :         (long)((u64)((u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC)
     287             : #else   /* take care of overflow on 64 bits machines */
     288             : # define MAX_SEC_IN_JIFFIES \
     289             :         (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1)
     290             : 
     291             : #endif
     292             : 
     293             : /*
     294             :  * Convert various time units to each other:
     295             :  */
     296             : extern unsigned int jiffies_to_msecs(const unsigned long j);
     297             : extern unsigned int jiffies_to_usecs(const unsigned long j);
     298             : extern unsigned long msecs_to_jiffies(const unsigned int m);
     299             : extern unsigned long usecs_to_jiffies(const unsigned int u);
     300             : extern unsigned long timespec_to_jiffies(const struct timespec *value);
     301             : extern void jiffies_to_timespec(const unsigned long jiffies,
     302             :                                 struct timespec *value);
     303             : extern unsigned long timeval_to_jiffies(const struct timeval *value);
     304             : extern void jiffies_to_timeval(const unsigned long jiffies,
     305             :                                struct timeval *value);
     306             : extern clock_t jiffies_to_clock_t(unsigned long x);
     307             : extern unsigned long clock_t_to_jiffies(unsigned long x);
     308             : extern u64 jiffies_64_to_clock_t(u64 x);
     309             : extern u64 nsec_to_clock_t(u64 x);
     310             : extern unsigned long nsecs_to_jiffies(u64 n);
     311           1 : 
     312             : #define TIMESTAMP_SIZE  30
     313             : 
     314             : #endif

Generated by: LCOV version 1.10