内核同步方法之原子操作

   原子操作可以保证指令以原子的方式执行，执行过程不被打断。

  内核提供了两组原子操作接口：一组针对整数进行操作，另一组针对单独的位进行操作。大多数体系结构要么本来就支持简单的原子操作，要么就为单步执行提供了锁内存总线的指令。

• 原子整数操作
  针对整数的原子操作只能对atomic_t类型的数据进行处理。引入该类型的原因：

首先，让原子函数只接收atomic_t类型的操作数，可以确保原子操作只与这种特殊类型数据一起使用。保证了该类型数据不会被传递给其他任何非原子函数。

其次，使用atomic_t类型确保编译器不对相应的值进行访问优化，这使得原子操作最终接收到正确的内存地址而不是一个别名。

最后，在不同的体系结构上实现原子操作的时候，使用atomic_t类型可以屏蔽其间的差异。例如：

 

1. 在《Atomic.h(asm-i386)》中
2. /*
3.  * Make sure gcc doesn't try to be clever and move things around
4.  * on us. We need to use _exactly_ the address the user gave us,
5.  * not some alias that contains the same information.
6.  */
7. typedef struct { int counter; } atomic_t;
9. 在《Atomic.h(asm-sparc)》中
10. typedef struct { volatile int counter; } atomic_t;
12. /* This is the old 24-bit implementation.  It's still used internally
13.  * by some sparc-specific code, notably the semaphore implementation.
14.  */
15. typedef struct { volatile int counter; } atomic24_t;

the old 24-bit implementation：

在SPARC体系结构上，原子操作的实现不同于其他体系结构：32位int类型的低8位嵌入一个锁，因为SPARC体系结构对原子操作缺乏指令级的支持，所以只能利用该锁来避免对原子类型数据的并发访问。

 

1. 在<Atomic.h(asm-sparc)>中
2. /* This is the old 24-bit implementation.  It's still used internally
3.  * by some sparc-specific code, notably the semaphore implementation.
4.  */
5. typedef struct { volatile int counter; } atomic24_t;
7. #ifndef CONFIG_SMP 
9. #define ATOMIC24_INIT(i)  { (i) } 
10. #define atomic24_read(v)          ((v)->counter) 
11. #define atomic24_set(v, i)        (((v)->counter) = i) 
13. #else 
14. /* We do the bulk of the actual work out of line in two common
15.  * routines in assembler, see arch/sparc/lib/atomic.S for the
16.  * "fun" details.
17.  *
18.  * For SMP the trick is you embed the spin lock byte within
19.  * the word, use the low byte so signedness is easily retained
20.  * via a quick arithmetic shift.  It looks like this:
21.  *
22.  *  ----------------------------------------
23.  *  | signed 24-bit counter value |  lock  |  atomic_t
24.  *  ----------------------------------------
25.  *   31                                      8 7      0
26.  */
28. #define ATOMIC24_INIT(i)    { ((i) << 8) }

相关操作：

 

知道什么叫欲哭无泪吗？我现在就是。早上写了上面的部分并保存，下午继续把这篇笔记写完了。但是可恶的CSDN不知道为啥只能发表上面的部分，下午写的都没有了！！我现在是一肚子悔恨啊，我已经不是第一次遇到这样的情况了，但是我居然只是拷贝没有把写好的粘贴到word里，后来有拷贝了其他东西到缓冲区就把写好的东西清空了，呜呜，现在不得不再重新写一次！！我的肠子现在都悔青了！！！

 

 

1. 在<Atomic.h(include/asm-i386)>
2. /*
3.  * Atomic operations that C can't guarantee us.  Useful for
4.  * resource counting etc..
5.  */
7. /*
8.  * Make sure gcc doesn't try to be clever and move things around
9.  * on us. We need to use _exactly_ the address the user gave us,
10.  * not some alias that contains the same information.
11.  */
12. typedef struct { int counter; } atomic_t;
14. #define ATOMIC_INIT(i)  { (i) }
16. /**
17.  * atomic_read - read atomic variable
18.  * @v: pointer of type atomic_t
19.  * 
20.  * Atomically reads the value of @v.
21.  */ 
22. #define atomic_read(v)      ((v)->counter)
24. /**
25.  * atomic_set - set atomic variable
26.  * @v: pointer of type atomic_t
27.  * @i: required value
28.  * 
29.  * Atomically sets the value of @v to @i.
30.  */ 
31. #define atomic_set(v,i)     (((v)->counter) = (i))
33. /**
34.  * atomic_add - add integer to atomic variable
35.  * @i: integer value to add
36.  * @v: pointer of type atomic_t
37.  * 
38.  * Atomically adds @i to @v.
39.  */
40. static __inline__ void atomic_add(int i, atomic_t *v)
41. {
42.     __asm__ __volatile__(
43.         LOCK_PREFIX "addl %1,%0"
44.         :"+m" (v->counter)
45.         :"ir" (i));
46. }
48. /**
49.  * atomic_sub - subtract the atomic variable
50.  * @i: integer value to subtract
51.  * @v: pointer of type atomic_t
52.  * 
53.  * Atomically subtracts @i from @v.
54.  */
55. static __inline__ void atomic_sub(int i, atomic_t *v)
56. {
57.     __asm__ __volatile__(
58.         LOCK_PREFIX "subl %1,%0"
59.         :"+m" (v->counter)
60.         :"ir" (i));
61. }
63. /**
64.  * atomic_sub_and_test - subtract value from variable and test result
65.  * @i: integer value to subtract
66.  * @v: pointer of type atomic_t
67.  * 
68.  * Atomically subtracts @i from @v and returns
69.  * true if the result is zero, or false for all
70.  * other cases.
71.  */
72. static __inline__ int atomic_sub_and_test(int i, atomic_t *v)
73. {
74.     unsigned char c;
76.     __asm__ __volatile__(
77.         LOCK_PREFIX "subl %2,%0; sete %1"
78.         :"+m" (v->counter), "=qm" (c)
79.         :"ir" (i) : "memory");
80.     return c;
81. }
83. /**
84.  * atomic_inc - increment atomic variable
85.  * @v: pointer of type atomic_t
86.  * 
87.  * Atomically increments @v by 1.
88.  */ 
89. static __inline__ void atomic_inc(atomic_t *v)
90. {
91.     __asm__ __volatile__(
92.         LOCK_PREFIX "incl %0"
93.         :"+m" (v->counter));
94. }
96. /**
97.  * atomic_dec - decrement atomic variable
98.  * @v: pointer of type atomic_t
99.  * 
100.  * Atomically decrements @v by 1.
101.  */ 
102. static __inline__ void atomic_dec(atomic_t *v)
103. {
104.     __asm__ __volatile__(
105.         LOCK_PREFIX "decl %0"
106.         :"+m" (v->counter));
107. }
109. /**
110.  * atomic_dec_and_test - decrement and test
111.  * @v: pointer of type atomic_t
112.  * 
113.  * Atomically decrements @v by 1 and
114.  * returns true if the result is 0, or false for all other
115.  * cases.
116.  */ 
117. static __inline__ int atomic_dec_and_test(atomic_t *v)
118. {
119.     unsigned char c;
121.     __asm__ __volatile__(
122.         LOCK_PREFIX "decl %0; sete %1"
123.         :"+m" (v->counter), "=qm" (c)
124.         : : "memory");
125.     return c != 0;
126. }
128. /**
129.  * atomic_inc_and_test - increment and test 
130.  * @v: pointer of type atomic_t
131.  * 
132.  * Atomically increments @v by 1
133.  * and returns true if the result is zero, or false for all
134.  * other cases.
135.  */ 
136. static __inline__ int atomic_inc_and_test(atomic_t *v)
137. {
138.     unsigned char c;
140.     __asm__ __volatile__(
141.         LOCK_PREFIX "incl %0; sete %1"
142.         :"+m" (v->counter), "=qm" (c)
143.         : : "memory");
144.     return c != 0;
145. }
147. /**
148.  * atomic_add_negative - add and test if negative
149.  * @v: pointer of type atomic_t
150.  * @i: integer value to add
151.  * 
152.  * Atomically adds @i to @v and returns true
153.  * if the result is negative, or false when
154.  * result is greater than or equal to zero.
155.  */ 
156. static __inline__ int atomic_add_negative(int i, atomic_t *v)
157. {
158.     unsigned char c;
160.     __asm__ __volatile__(
161.         LOCK_PREFIX "addl %2,%0; sets %1"
162.         :"+m" (v->counter), "=qm" (c)
163.         :"ir" (i) : "memory");
164.     return c;
165. }

原子整数操作最常见的用途就是实现计数器。使用锁机制来保护一个单纯的计数器是笨拙的，开发者最好使用atomic_dec()和atmic_inc()。

原子操作通常是内联函数，往往是通过内嵌汇编指令来实现的。关于内嵌汇编指令的说明请参看：

http://blog.csdn.net/zdfonline/archive/2005/03/17/321904.aspx

如果某个函数本来就是原子的，那么它往往会被定义成一个宏。

• 原子性与顺序性

原子性确保指令执行期间不被打断，要么全部执行完，要么根本不执行。一个字长的读取总是原子地发生，决不可能对同一个字交错地进行写；读总是返回一个完整的字。

顺序性确保即使两条或多条指令出现在独立的执行线程中，甚至独立的处理器上，但它们本该的执行顺序依然要保持。顺序性通过屏障(barrier)指令来实施。

 

• 原子位操作

位操作函数是对普通的内存地址进行操作的。它的参数是一个指针和一个位号，第0位是给定地址的最低有效位（LSB）。在32位机上，第31位是给定地址的最高有效位而第32位是下一个字的最低有效位（LSB）。即

 bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).

使用原子位操作在多数情况下是对益而高字长的内存进行访问，因而位号该位于0~31之间，但是对位号的范围并没有限制。

由于原子位操作是对普通的指针进行的操作，所以不像原子整形对应atomic_t，这里没有特殊的数据类型。只要指针指向了任何数据，就可以对它进行操作。

相关操作：

 

1. 在<Bitops.h(include/i386)>中
2. /*
3.  * These have to be done with inline assembly: that way the bit-setting
4.  * is guaranteed to be atomic. All bit operations return 0 if the bit
5.  * was cleared before the operation and != 0 if it was not.
6.  *
7.  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
8.  */
10. #define ADDR (*(volatile long *) addr)
11. /**
12.  * set_bit - Atomically set a bit in memory
13.  * @nr: the bit to set
14.  * @addr: the address to start counting from
15.  *
16.  * This function is atomic and may not be reordered.  See __set_bit()
17.  * if you do not require the atomic guarantees.
18.  *
19.  * Note: there are no guarantees that this function will not be reordered
20.  * on non x86 architectures, so if you are writting portable code,
21.  * make sure not to rely on its reordering guarantees.
22.  *
23.  * Note that @nr may be almost arbitrarily large; this function is not
24.  * restricted to acting on a single-word quantity.
25.  */
26. static inline void set_bit(int nr, volatile unsigned long * addr)
27. {
28.     __asm__ __volatile__( LOCK_PREFIX
29.         "btsl %1,%0"
30.         :"+m" (ADDR)
31.         :"Ir" (nr));
32. }
33. /**
34.  * clear_bit - Clears a bit in memory
35.  * @nr: Bit to clear
36.  * @addr: Address to start counting from
37.  *
38.  * clear_bit() is atomic and may not be reordered.  However, it does
39.  * not contain a memory barrier, so if it is used for locking purposes,
40.  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
41.  * in order to ensure changes are visible on other processors.
42.  */
43. static inline void clear_bit(int nr, volatile unsigned long * addr)
44. {
45.     __asm__ __volatile__( LOCK_PREFIX
46.         "btrl %1,%0"
47.         :"+m" (ADDR)
48.         :"Ir" (nr));
49. }
50. /**
51.  * change_bit - Toggle a bit in memory
52.  * @nr: Bit to change
53.  * @addr: Address to start counting from
54.  *
55.  * change_bit() is atomic and may not be reordered. It may be
56.  * reordered on other architectures than x86.
57.  * Note that @nr may be almost arbitrarily large; this function is not
58.  * restricted to acting on a single-word quantity.
59.  */
60. static inline void change_bit(int nr, volatile unsigned long * addr)
61. {
62.     __asm__ __volatile__( LOCK_PREFIX
63.         "btcl %1,%0"
64.         :"+m" (ADDR)
65.         :"Ir" (nr));
66. }
68. /**
69.  * test_and_set_bit - Set a bit and return its old value
70.  * @nr: Bit to set
71.  * @addr: Address to count from
72.  *
73.  * This operation is atomic and cannot be reordered.  
74.  * It may be reordered on other architectures than x86.
75.  * It also implies a memory barrier.
76.  */
77. static inline int test_and_set_bit(int nr, volatile unsigned long * addr)
78. {
79.     int oldbit;
81.     __asm__ __volatile__( LOCK_PREFIX
82.         "btsl %2,%1/n/tsbbl %0,%0"
83.         :"=r" (oldbit),"+m" (ADDR)
84.         :"Ir" (nr) : "memory");
85.     return oldbit;
86. }
88. /**
89.  * test_and_clear_bit - Clear a bit and return its old value
90.  * @nr: Bit to clear
91.  * @addr: Address to count from
92.  *
93.  * This operation is atomic and cannot be reordered.
94.  * It can be reorderdered on other architectures other than x86.
95.  * It also implies a memory barrier.
96.  */
97. static inline int test_and_clear_bit(int nr, volatile unsigned long * addr)
98. {
99.     int oldbit;
101.     __asm__ __volatile__( LOCK_PREFIX
102.         "btrl %2,%1/n/tsbbl %0,%0"
103.         :"=r" (oldbit),"+m" (ADDR)
104.         :"Ir" (nr) : "memory");
105.     return oldbit;
106. }
107. /**
108.  * test_and_change_bit - Change a bit and return its old value
109.  * @nr: Bit to change
110.  * @addr: Address to count from
111.  *
112.  * This operation is atomic and cannot be reordered.  
113.  * It also implies a memory barrier.
114.  */
115. static inline int test_and_change_bit(int nr, volatile unsigned long* addr)
116. {
117.     int oldbit;
119.     __asm__ __volatile__( LOCK_PREFIX
120.         "btcl %2,%1/n/tsbbl %0,%0"
121.         :"=r" (oldbit),"+m" (ADDR)
122.         :"Ir" (nr) : "memory");
123.     return oldbit;
124. }

为了方便，内核还提供了一组与上述操作相对应的非原子位函数。非原子位函数与原子位函数的操作完全相同，但是前者不保证原子性，代码里没有LOCK_PREFIX，其名字前缀多了两个下划线：

 

2. /**
3.  * __set_bit - Set a bit in memory
4.  * @nr: the bit to set
5.  * @addr: the address to start counting from
6.  *
7.  * Unlike set_bit(), this function is non-atomic and may be reordered.
8.  * If it's called on the same region of memory simultaneously, the effect
9.  * may be that only one operation succeeds.
10.  */
11. static inline void __set_bit(int nr, volatile unsigned long * addr)
12. {
13.     __asm__(
14.         "btsl %1,%0"
15.         :"+m" (ADDR)
16.         :"Ir" (nr));
17. }
18. 在<Alternative.h>中
19. /*
20.  * Alternative inline assembly for SMP.
21.  *
22.  * The LOCK_PREFIX macro defined here replaces the LOCK and
23.  * LOCK_PREFIX macros used everywhere in the source tree.
24.  *
25.  * SMP alternatives use the same data structures as the other
26.  * alternatives and the X86_FEATURE_UP flag to indicate the case of a
27.  * UP system running a SMP kernel.  The existing apply_alternatives()
28.  * works fine for patching a SMP kernel for UP.
29.  *
30.  * The SMP alternative tables can be kept after boot and contain both
31.  * UP and SMP versions of the instructions to allow switching back to
32.  * SMP at runtime, when hotplugging in a new CPU, which is especially
33.  * useful in virtualized environments.
34.  *
35.  * The very common lock prefix is handled as special case in a
36.  * separate table which is a pure address list without replacement ptr
37.  * and size information.  That keeps the table sizes small.
38.  */
40. #ifdef CONFIG_SMP
41. #define LOCK_PREFIX /
42.         ".section .smp_locks,/"a/"/n"   /
43.         "  .align 4/n"          /
44.         "  .long 661f/n" /* address */  /
45.         ".previous/n"           /
46.             "661:/n/tlock; "
48. #else /* ! CONFIG_SMP */
49. #define LOCK_PREFIX ""
50. #endif

如果不需要原子性操作（可能你已经使用锁保护了数据，代码本身避免了竞争条件），非原子的位函数要比原子的位函数执行要快些。

 终于重新写完了T_T