WebSVN – Kolibri OS – Diff – /drivers/include/linux/compiler.h

 # define __releases(x)	__attribute__((context(x,1,0)))
 # define __acquire(x)	__context__(x,1)
 # define __release(x)	__context__(x,-1)
 # define __cond_lock(x,c)	((c) ? ({ __acquire(x); 1; }) : 0)
 # define __percpu	__attribute__((noderef, address_space(3)))
+# define __pmem		__attribute__((noderef, address_space(5)))
 #ifdef CONFIG_SPARSE_RCU_POINTER
 # define __rcu		__attribute__((noderef, address_space(4)))
 #else
 # define __rcu
 #endif
 # define __acquire(x) (void)0
 # define __release(x) (void)0
 # define __cond_lock(x,c) (c)
 # define __percpu
 # define __rcu
+# define __pmem
 #endif
 /* Indirect macros required for expanded argument pasting, eg. __LINE__. */
 #define ___PASTE(a,b) a##b
 #ifdef __GNUC__
 #include
+#endif
+#if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__)
-#endif
+#define notrace __attribute__((hotpatch(0,0)))
+#else
 #define notrace __attribute__((no_instrument_function))
-#define notrace __attribute__((no_instrument_function))
+#endif
 /* Intel compiler defines __GNUC__. So we will overwrite implementations
 /* Optimization barrier */
 #ifndef barrier
 # define barrier() __memory_barrier()
 #endif
+#ifndef barrier_data
+# define barrier_data(ptr) barrier()
+#endif
 /* Unreachable code */
 #ifndef unreachable
 # define unreachable() do { } while (1)
 # define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __LINE__)
 #endif
+#include
+#define __READ_ONCE_SIZE						\
+({									\
-#include
+	switch (size) {							\
+	case 1: *(__u8 *)res = *(volatile __u8 *)p; break;		\
+	case 2: *(__u16 *)res = *(volatile __u16 *)p; break;		\
+	case 4: *(__u32 *)res = *(volatile __u32 *)p; break;		\
+	case 8: *(__u64 *)res = *(volatile __u64 *)p; break;		\
-static __always_inline void data_access_exceeds_word_size(void)
+	default:							\
+		barrier();						\
-#ifdef __compiletime_warning
+		__builtin_memcpy((void *)res, (const void *)p, size);	\
-__compiletime_warning("data access exceeds word size and won't be atomic")
+		barrier();						\
+	}								\
-#endif
+})
+static __always_inline
 void __read_once_size(const volatile void *p, void *res, int size)
+{
+	__READ_ONCE_SIZE;
+}
+#ifdef CONFIG_KASAN
+/*
+ * This function is not 'inline' because __no_sanitize_address confilcts
+ * with inlining. Attempt to inline it may cause a build failure.
-static __always_inline void data_access_exceeds_word_size(void)
+ * 	https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
  * '__maybe_unused' allows us to avoid defined-but-not-used warnings.
-}
-static __always_inline void __read_once_size(volatile void *p, void *res, int size)
-{
-	switch (size) {
+ */
-	case 1: *(__u8 *)res = *(volatile __u8 *)p; break;
-	case 2: *(__u16 *)res = *(volatile __u16 *)p; break;
-	case 4: *(__u32 *)res = *(volatile __u32 *)p; break;
-#ifdef CONFIG_64BIT
-	case 8: *(__u64 *)res = *(volatile __u64 *)p; break;
-#endif
-	default:
-		barrier();
+static __no_sanitize_address __maybe_unused
+void __read_once_size_nocheck(const volatile void *p, void *res, int size)
+{
+	__READ_ONCE_SIZE;
+}
+#else
-		__builtin_memcpy((void *)res, (const void *)p, size);
+static __always_inline
+void __read_once_size_nocheck(const volatile void *p, void *res, int size)
-		data_access_exceeds_word_size();
+{
-		barrier();
+	__READ_ONCE_SIZE;
+}
 #endif
-static __always_inline void __assign_once_size(volatile void *p, void *res, int size)
+static __always_inline void __write_once_size(volatile void *p, void *res, int size)
-{
 	switch (size) {
-	case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
-	case 2: *(volatile __u16 *)p = *(__u16 *)res; break;
+	switch (size) {
-	case 4: *(volatile __u32 *)p = *(__u32 *)res; break;
+	case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
-#ifdef CONFIG_64BIT
+	case 2: *(volatile __u16 *)p = *(__u16 *)res; break;
-	case 8: *(volatile __u64 *)p = *(__u64 *)res; break;
-#endif
+	case 4: *(volatile __u32 *)p = *(__u32 *)res; break;
-	default:
+	case 8: *(volatile __u64 *)p = *(__u64 *)res; break;
-		barrier();
+	default:
-		__builtin_memcpy((void *)p, (const void *)res, size);
+		barrier();
-		data_access_exceeds_word_size();
+		__builtin_memcpy((void *)p, (const void *)res, size);
 		barrier();
 	}
+}
 /*
  * Prevent the compiler from merging or refetching reads or writes. The
  * compiler is also forbidden from reordering successive instances of
- * READ_ONCE, ASSIGN_ONCE and ACCESS_ONCE (see below), but only when the
+ * READ_ONCE, WRITE_ONCE and ACCESS_ONCE (see below), but only when the
  * compiler is aware of some particular ordering.  One way to make the
  * compiler aware of ordering is to put the two invocations of READ_ONCE,
- * ASSIGN_ONCE or ACCESS_ONCE() in different C statements.
+ * WRITE_ONCE or ACCESS_ONCE() in different C statements.
+ *
  * In contrast to ACCESS_ONCE these two macros will also work on aggregate
  * data types like structs or unions. If the size of the accessed data
  * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
- * READ_ONCE() and ASSIGN_ONCE()  will fall back to memcpy and print a
+ * READ_ONCE() and WRITE_ONCE()  will fall back to memcpy and print a
  * compile-time warning.
+ *
  * Their two major use cases are: (1) Mediating communication between
  * process-level code and irq/NMI handlers, all running on the same CPU,
+ * and (2) Ensuring that the compiler does not  fold, spindle, or otherwise
+ * mutilate accesses that either do not require ordering or that interact
+ * with an explicit memory barrier or atomic instruction that provides the
- * and (2) Ensuring that the compiler does not  fold, spindle, or otherwise
+ * required ordering.
+ */
+#define __READ_ONCE(x, check)						\
+({									\
+	union { typeof(x) __val; char __c[1]; } __u;			\
+	if (check)							\
+		__read_once_size(&(x), __u.__c, sizeof(x));		\
+	else								\
+		__read_once_size_nocheck(&(x), __u.__c, sizeof(x));	\
+	__u.__val;							\
+})
- * mutilate accesses that either do not require ordering or that interact
+#define READ_ONCE(x) __READ_ONCE(x, 1)
+/*
+ * Use READ_ONCE_NOCHECK() instead of READ_ONCE() if you need
- * with an explicit memory barrier or atomic instruction that provides the
+ * to hide memory access from KASAN.
+ */
+#define READ_ONCE_NOCHECK(x) __READ_ONCE(x, 0)
  * required ordering.
- */
+#define WRITE_ONCE(x, val) \
 #ifndef __visible
 #define __visible
+#endif
+/*
+ * Assume alignment of return value.
+ */
+#ifndef __assume_aligned
+#define __assume_aligned(a, ...)
+#endif
 #endif
 /* Are two types/vars the same type (ignoring qualifiers)? */
 #ifndef __same_type
 # define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
 #endif
 /* Is this type a native word size -- useful for atomic operations */
 #ifndef __native_word
-# define __native_word(t) (sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
+# define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
 #endif
  * is also forbidden from reordering successive instances of ACCESS_ONCE(),
  * but only when the compiler is aware of some particular ordering.  One way
  * to make the compiler aware of ordering is to put the two invocations of
  * ACCESS_ONCE() in different C statements.
+ *
+ * ACCESS_ONCE will only work on scalar types. For union types, ACCESS_ONCE
- * This macro does absolutely -nothing- to prevent the CPU from reordering,
+ * on a union member will work as long as the size of the member matches the
- * merging, or refetching absolutely anything at any time.  Its main intended
+ * size of the union and the size is smaller than word size.
+ *
- * use is to mediate communication between process-level code and irq/NMI
+ * The major use cases of ACCESS_ONCE used to be (1) Mediating communication
- * handlers, all running on the same CPU.
+ * between process-level code and irq/NMI handlers, all running on the same CPU,
+ * and (2) Ensuring that the compiler does not  fold, spindle, or otherwise
+ * mutilate accesses that either do not require ordering or that interact
+ * with an explicit memory barrier or atomic instruction that provides the
+ * required ordering.
+ *
+ * If possible use READ_ONCE()/WRITE_ONCE() instead.
+ */
+#define __ACCESS_ONCE(x) ({ \
+	 __maybe_unused typeof(x) __var = (__force typeof(x)) 0; \
+	(volatile typeof(x) *)&(x); })
+#define ACCESS_ONCE(x) (*__ACCESS_ONCE(x))
+/**
+ * lockless_dereference() - safely load a pointer for later dereference
+ * @p: The pointer to load
+ *
+ * Similar to rcu_dereference(), but for situations where the pointed-to
+ * object's lifetime is managed by something other than RCU.  That
+ * "something other" might be reference counting or simple immortality.
  */
-#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
+#define lockless_dereference(p) \
+({ \
+	typeof(p) _________p1 = READ_ONCE(p); \
+	smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
+	(_________p1); \
+})
 /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */
 #ifdef CONFIG_KPROBES
 # define __kprobes	__attribute__((__section__(".kprobes.text")))

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/compiler.h – Rev 5270 → 6082