ca8ebfaf47e6960e8ac67282fde2f19e35950170
[akaros.git] / kern / arch / x86 / atomic.h
1 /* Copyright (c) 2009-2011 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * x86 atomics and locking functions. */
6
7 #pragma once
8
9 #include <ros/common.h>
10 #include <ros/arch/membar.h>
11 #include <arch/x86.h>
12 #include <arch/arch.h>
13
14 static inline void atomic_andb(volatile uint8_t *number, uint8_t mask);
15 static inline void atomic_orb(volatile uint8_t *number, uint8_t mask);
16
17 /* Inlined functions declared above */
18 static inline void atomic_init(atomic_t *number, long val)
19 {
20         asm volatile("mov %1,%0" : "=m"(*number) : "r"(val));
21 }
22
23 static inline long atomic_read(atomic_t *number)
24 {
25         long val;
26         asm volatile("mov %1,%0" : "=r"(val) : "m"(*number));
27         return val;
28 }
29
30 static inline void atomic_set(atomic_t *number, long val)
31 {
32         asm volatile("mov %1,%0" : "=m"(*number) : "r"(val));
33 }
34
35 static inline void atomic_add(atomic_t *number, long val)
36 {
37         __sync_fetch_and_add(number, val);
38 }
39
40 static inline void atomic_inc(atomic_t *number)
41 {
42         __sync_fetch_and_add(number, 1);
43 }
44
45 static inline void atomic_dec(atomic_t *number)
46 {
47         __sync_fetch_and_sub(number, 1);
48 }
49
50 static inline long atomic_fetch_and_add(atomic_t *number, long val)
51 {
52         return (long)__sync_fetch_and_add(number, val);
53 }
54
55 static inline void atomic_and(atomic_t *number, long mask)
56 {
57         __sync_fetch_and_and(number, mask);
58 }
59
60 static inline void atomic_or(atomic_t *number, long mask)
61 {
62         __sync_fetch_and_or(number, mask);
63 }
64
65 static inline long atomic_swap(atomic_t *addr, long val)
66 {
67         /* This poorly named function does an xchg */
68         return (long)__sync_lock_test_and_set(addr, val);
69 }
70
71 static inline bool atomic_cas(atomic_t *addr, long exp_val, long new_val)
72 {
73         return __sync_bool_compare_and_swap(addr, exp_val, new_val);
74 }
75
76 static inline bool atomic_cas_ptr(void **addr, void *exp_val, void *new_val)
77 {
78         return __sync_bool_compare_and_swap(addr, exp_val, new_val);
79 }
80
81 static inline bool atomic_cas_u32(uint32_t *addr, uint32_t exp_val,
82                                   uint32_t new_val)
83 {
84         return __sync_bool_compare_and_swap(addr, exp_val, new_val);
85 }
86
87 /* Adds val to number, so long as number was not zero.  Returns TRUE if the
88  * operation succeeded (added, not zero), returns FALSE if number is zero. */
89 static inline bool atomic_add_not_zero(atomic_t *number, long val)
90 {
91         long old_num, new_num;
92         do {
93                 old_num = atomic_read(number);
94                 if (!old_num)
95                         return FALSE;
96                 new_num = old_num + val;
97         } while (!atomic_cas(number, old_num, new_num));
98         return TRUE;
99 }
100
101 /* Subtracts val from number, returning True if the new value is 0. */
102 static inline bool atomic_sub_and_test(atomic_t *number, long val)
103 {
104         bool b;
105         asm volatile("lock sub %2,%1; setz %0" : "=q"(b), "=m"(*number)
106                                                : "r"(val), "m"(*number)
107                                                : "cc" );
108         return b;
109 }
110
111 static inline void atomic_andb(volatile uint8_t *number, uint8_t mask)
112 {
113         __sync_fetch_and_and(number, mask);
114 }
115
116 static inline void atomic_orb(volatile uint8_t *number, uint8_t mask)
117 {
118         __sync_fetch_and_or(number, mask);
119 }
120
121 static inline bool spin_locked(spinlock_t *lock)
122 {
123         // the lock status is the lowest byte of the lock
124         return lock->rlock & 0xff;
125 }
126
127 static inline void __spin_lock_raw(volatile uint32_t *rlock)
128 {
129         uint8_t dicks = 0;
130         asm volatile(
131                         "1:                       "
132                         "       cmpb $0, %0;          "
133                         "       je 2f;                "
134                         "       pause;                "
135                         "       jmp 1b;               "
136                         "2:                       "
137                         "       movb $1, %1;          "
138                         "       xchgb %1, %0;         "
139                         "       cmpb $0, %1;          "
140                         "       jne 1b;               "
141                 : : "m"(*rlock), "r"(dicks) : "cc");
142         cmb();  /* need cmb(), the CPU mb() was handled by the xchg */
143 }
144
145 static inline void __spin_lock(spinlock_t *lock)
146 {
147         __spin_lock_raw(&lock->rlock);
148 }
149
150 static inline bool __spin_trylock(spinlock_t *lock)
151 {
152         /* since this is an or, we're not going to clobber the top bytes (if that
153          * matters) */
154         return !__sync_fetch_and_or(&lock->rlock, 1);
155 }
156
157 static inline void __spin_unlock(spinlock_t *lock)
158 {
159         /* Need to prevent the compiler from reordering older stores. */
160         wmb();
161         rwmb(); /* x86 makes both of these a cmb() */
162         lock->rlock = 0;
163 }
164
165 static inline void __spinlock_init(spinlock_t *lock)
166 {
167         lock->rlock = 0;
168 }