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
|