Add READ_ONCE and WRITE_ONCE (XCC)
[akaros.git] / kern / include / ros / common.h
index eda5dab..bb23ca2 100644 (file)
@@ -40,36 +40,6 @@ typedef unsigned long uintreg_t;
 
 #define COUNT_OF(x) (sizeof((x))/sizeof((x)[0]))
 
-// Efficient min and max operations
-#ifdef ROS_KERNEL /* Glibc or other user libs have their own */
-#define MIN(_a, _b)                                            \
-({                                                             \
-       typeof(_a) __a = (_a);                                  \
-       typeof(_b) __b = (_b);                                  \
-       __a <= __b ? __a : __b;                                 \
-})
-#define MAX(_a, _b)                                            \
-({                                                             \
-       typeof(_a) __a = (_a);                                  \
-       typeof(_b) __b = (_b);                                  \
-       __a >= __b ? __a : __b;                                 \
-})
-
-/* Other kernel-only includes */
-
-/* Test for alignment, e.g. 2^6 */
-#define ALIGNED(p, a)  (!(((uintptr_t)(p)) & ((a)-1)))
-/* Aligns x up to the mask, e.g. (2^6 - 1) (round up if any mask bits are set)*/
-#define __ALIGN_MASK(x, mask) (((uintptr_t)(x) + (mask)) & ~(mask))
-/* Aligns x up to the alignment, e.g. 2^6. */
-#define ALIGN(x, a) ((typeof(x)) __ALIGN_MASK(x, (a) - 1))
-/* Will return false for 0.  Debatable, based on what you want. */
-#define IS_PWR2(x) ((x) && !((x) & (x - 1)))
-
-#define ARRAY_SIZE(x) COUNT_OF(x)
-
-#endif
-
 #define ZERO_DATA(s) memset(&(s), 0, sizeof(s))
 
 /* Rounding operations (efficient when n is a power of 2)
@@ -150,9 +120,11 @@ static inline bool mult_will_overflow_u64(uint64_t a, uint64_t b)
        (type*)((char*)ptr - offsetof(type, member));                             \
 })
 
-/* Force the reading exactly once of x.  You may still need mbs().  See
+/* Force the reading/writing exactly once of x.  You may still need mbs().  See
  * http://lwn.net/Articles/508991/ for more info. */
 #define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
+#define READ_ONCE(x) ACCESS_ONCE(x)
+#define WRITE_ONCE(x, val) ((*(volatile typeof(x) *)&(x)) = val)
 
 /* Makes sure func is run exactly once.  Can handle concurrent callers, and
  * other callers spin til the func is complete. */
@@ -185,16 +157,4 @@ do {                                                                           \
        }                                                                          \
 } while (0)
 
-/* Aborts with 'retcmd' if this function has already been called.  Compared to
- * run_once, this is put at the top of a function that can be called from
- * multiple sources but should only execute once. */
-#define init_once_racy(retcmd)                                                 \
-do {                                                                           \
-       static bool initialized = FALSE;                                           \
-       if (initialized) {                                                         \
-               retcmd;                                                                \
-       }                                                                          \
-       initialized = TRUE;                                                        \
-} while (0)
-
 #endif /* __ASSEMBLER__ */