Subversion Repositories Kolibri OS

#include 

static __always_inline void data_access_exceeds_word_size(void)

#ifdef __compiletime_warning

__compiletime_warning("data access exceeds word size and won't be atomic")

#endif

;

static __always_inline void data_access_exceeds_word_size(void)

{

}

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();

		__builtin_memcpy((void *)res, (const void *)p, size);

		data_access_exceeds_word_size();

		barrier();

	}

}

static __always_inline void __assign_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;

	case 4: *(volatile __u32 *)p = *(__u32 *)res; break;

#ifdef CONFIG_64BIT

	case 8: *(volatile __u64 *)p = *(__u64 *)res; break;

#endif

	default:

		barrier();

		__builtin_memcpy((void *)p, (const void *)res, size);

		data_access_exceeds_word_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

 * 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.

 *

 * 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

 * 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

 * required ordering.

 */

#define READ_ONCE(x) \

	({ typeof(x) __val; __read_once_size(&x, &__val, sizeof(__val)); __val; })

#define ASSIGN_ONCE(val, x) \

	({ typeof(x) __val; __val = val; __assign_once_size(&x, &__val, sizeof(__val)); __val; })