Overhaul lock_test.R
[akaros.git] / kern / include / common.h
1 #pragma once
2
3 #include <ros/common.h>
4 #include <compiler.h>
5
6 #ifndef __ASSEMBLER__
7 #include <sys/types.h>
8 #include <linux/overflow.h>
9 #endif
10
11 /* Force a rebuild of the whole kernel if 64BIT-ness changed */
12 #ifdef CONFIG_64BIT
13 #endif
14
15 #define PASTE_THEM(x, y) x ## y
16 #define PASTE(x, y) PASTE_THEM(x, y)
17
18 // Efficient min and max operations
19 #define MIN(_a, _b)                                             \
20 ({                                                              \
21         typeof(_a) __a = (_a);                                  \
22         typeof(_b) __b = (_b);                                  \
23         __a <= __b ? __a : __b;                                 \
24 })
25 #define MAX(_a, _b)                                             \
26 ({                                                              \
27         typeof(_a) __a = (_a);                                  \
28         typeof(_b) __b = (_b);                                  \
29         __a >= __b ? __a : __b;                                 \
30 })
31
32 /* Test for alignment, e.g. 2^6 */
33 #define ALIGNED(p, a)   (!(((uintptr_t)(p)) & ((a)-1)))
34 /* Aligns x up to the mask, e.g. (2^6 - 1) (round up if any mask bits are set)*/
35 #define __ALIGN_MASK(x, mask) (((uintptr_t)(x) + (mask)) & ~(mask))
36 /* Aligns x up to the alignment, e.g. 2^6. */
37 #define ALIGN(x, a) ((typeof(x)) __ALIGN_MASK(x, (a) - 1))
38 /* Aligns x down to the mask, e.g. (2^6 - 1)
39  * (round down if any mask bits are set)*/
40 #define __ALIGN_MASK_DOWN(x, mask) ((uintptr_t)(x) & ~(mask))
41 /* Aligns x down to the alignment, e.g. 2^6. */
42 #define ALIGN_DOWN(x, a) ((typeof(x)) __ALIGN_MASK_DOWN(x, (a) - 1))
43 /* Will return false for 0.  Debatable, based on what you want. */
44 #define IS_PWR2(x) ((x) && !((x) & (x - 1)))
45
46 #define ARRAY_SIZE(x) COUNT_OF(x)
47
48 /* Makes sure func is run exactly once.  Can handle concurrent callers, and
49  * other callers spin til the func is complete. */
50 #define run_once(func)                                                         \
51 do {                                                                           \
52         static bool ran_once = FALSE;                                          \
53         static bool is_running = FALSE;                                        \
54         if (!ran_once) {                                                       \
55                 /* fetch and set TRUE, w/o a header or test_and_set weirdness*/\
56                 if (!__sync_fetch_and_or(&is_running, TRUE)) {                 \
57                         /* we won the race and get to run the func */          \
58                         func;                                                  \
59                         /* don't let the ran_once write pass previous writes */\
60                         wmb();                                                 \
61                         ran_once = TRUE;                                       \
62                 } else {                                                       \
63                         /* someone else won */                                 \
64                         while (!ran_once)                                      \
65                                 cpu_relax();                                   \
66                 }                                                              \
67         }                                                                      \
68 } while (0)
69
70 /* Unprotected, single-threaded version, makes sure func is run exactly once */
71 #define run_once_racy(func)                                                    \
72 do {                                                                           \
73         static bool ran_once = FALSE;                                          \
74         if (!ran_once) {                                                       \
75                 func;                                                          \
76                 ran_once = TRUE;                                               \
77         }                                                                      \
78 } while (0)
79
80 #ifndef __ASSEMBLER__
81
82 /* Returns the least common multiple of x and p2; p2 is a power of 2.  Returns 0
83  * on error, including non-power-of-2, overflow, or a 0 input. */
84 static inline unsigned long LCM_PWR2(unsigned long x, unsigned long p2)
85 {
86         /* All multiples of p2, which has exactly one bit set, will have zeros
87          * for the bits below its set bit.  The LCM will be x, shifted left as
88          * little as possible, such that it has no bits below p2's set bit.
89          * Each shift is a multiplication by 2, which is the only prime factor
90          * if p2. */
91         int p2_bit, x_first_bit;
92         unsigned long ret;
93
94         if (!x || !IS_PWR2(p2))
95                 return 0;
96         p2_bit = __builtin_ffsl(p2);
97         x_first_bit = __builtin_ffsl(x);
98         if (x_first_bit >= p2_bit)
99                 return x;
100         if (check_shl_overflow(x, p2_bit - x_first_bit, &ret))
101                 return 0;
102         return ret;
103 }
104
105 static inline uint32_t low32(uint64_t val)
106 {
107         return val & 0xffffffff;
108 }
109
110 static inline uint32_t high32(uint64_t val)
111 {
112         return val >> 32;
113 }
114
115 #endif /* !__ASSEMBLER__ */