linux设备驱动--并发与竞态之原子操作

原子操作指的是在执行过程中不会被别的代码路径所中断的操作。

       linux下面有两类原子操作，一类是整形原子操作，一类是位原子操作。

       原子操作目前仅仅做个测试验证学习，至于原子操作在哪些场合适合用到，还需要今后更多的驱动以及内核代码的fuck。

       整形原子操作的函数说明：

[cpp]  view plain copy

1. void atomic_set(atomic_t *v, int i);  
2. atomic_t v = ATOMIC_INIT(0);  
3. Set the atomic variable v to the integer value i. You can also initialize atomic values  
4. at compile time with the ATOMIC_INIT macro.  
5. int atomic_read(atomic_t *v);  
6. Return the current value of v.  
7. void atomic_add(int i, atomic_t *v);  
8. Add i to the atomic variable pointed to by v. The return value is void, because  
9. there is an extra cost to returning the new value, and most of the time there’s no  
10. need to know it.  
11. void atomic_sub(int i, atomic_t *v);  
12. Subtract i from *v.  
13. void atomic_inc(atomic_t *v);  
14. void atomic_dec(atomic_t *v);  
15. Increment or decrement an atomic variable.  
16. int atomic_inc_and_test(atomic_t *v);  
17. int atomic_dec_and_test(atomic_t *v);  
18. int atomic_sub_and_test(int i, atomic_t *v);  
19. Perform the specified operation and test the result; if, after the operation, the  
20. atomic value is 0, then the return value is true; otherwise, it is false. Note that  
21. there is no atomic_add_and_test.  
22. int atomic_add_negative(int i, atomic_t *v);  
23. Add the integer variable i to v. The return value is true if the result is negative,  
24. false otherwise.  
25. int atomic_add_return(int i, atomic_t *v);  
26. int atomic_sub_return(int i, atomic_t *v);  
27. int atomic_inc_return(atomic_t *v);  
28. int atomic_dec_return(atomic_t *v);  
29. Behave just like atomic_add and friends, with the exception that they return the  
30. new value of the atomic variable to the caller.  

上面是从ldd3中摘录的关于atomic的操作函数。

我们可以利用整形原子操作来控制设备只能被一个进程打开。

还是利用scull的代码，这个代码也是linux设备模型之字符设备一文中分析的代码。

[cpp]  view plain copy

1. /* 
2.  * main.c -- the bare scull char module 
3.  * 
4.  * Copyright (C) 2001 Alessandro Rubini and Jonathan Corbet 
5.  * Copyright (C) 2001 O'Reilly & Associates 
6.  * 
7.  * The source code in this file can be freely used, adapted, 
8.  * and redistributed in source or binary form, so long as an 
9.  * acknowledgment appears in derived source files.  The citation 
10.  * should list that the code comes from the book "Linux Device 
11.  * Drivers" by Alessandro Rubini and Jonathan Corbet, published 
12.  * by O'Reilly & Associates.   No warranty is attached; 
13.  * we cannot take responsibility for errors or fitness for use. 
14.  * 
15.  */  
16.   
17. //#include <linux/config.h>  
18. #include <linux/module.h>  
19. #include <linux/moduleparam.h>  
20. #include <linux/init.h>  
21.   
22. #include <linux/kernel.h> /* printk() */  
23. #include <linux/slab.h>       /* kmalloc() */  
24. #include <linux/fs.h>     /* everything... */  
25. #include <linux/errno.h>  /* error codes */  
26. #include <linux/types.h>  /* size_t */  
27. #include <linux/proc_fs.h>  
28. #include <linux/fcntl.h>  /* O_ACCMODE */  
29. #include <linux/seq_file.h>  
30. #include <linux/cdev.h>  
31.   
32. #include <asm/system.h>       /* cli(), *_flags */  
33. #include <asm/uaccess.h>  /* copy_*_user */  
34.   
35. #include "myscull.h"        /* local definitions */  
36.   
37. /* 
38.  * Our parameters which can be set at load time. 
39.  */  
40.   
41. int scull_major =   SCULL_MAJOR;  
42. int scull_minor =   0;  
43. int scull_nr_devs = SCULL_NR_DEVS;  /* number of bare scull devices */  
44. int scull_quantum = SCULL_QUANTUM;  
45. int scull_qset =    SCULL_QSET;  
46.   
47. module_param(scull_major, int, S_IRUGO);  
48. module_param(scull_minor, int, S_IRUGO);  
49. module_param(scull_nr_devs, int, S_IRUGO);  
50. module_param(scull_quantum, int, S_IRUGO);  
51. module_param(scull_qset, int, S_IRUGO);  
52.   
53. MODULE_AUTHOR("Alessandro Rubini, Jonathan Corbet");  
54. MODULE_LICENSE("Dual BSD/GPL");  
55.   
56. struct scull_dev *scull_devices;    /* allocated in scull_init_module */  
57.   
58.   
59. /* 
60.  * Empty out the scull device; must be called with the device 
61.  * semaphore held. 
62.  */  
63. #ifdef SCULL_DEBUG /* use proc only if debugging */  
64. /* 
65.  * The proc filesystem: function to read and entry 
66.  */  
67.   
68.   
69.   
70. /* 
71.  * For now, the seq_file implementation will exist in parallel.  The 
72.  * older read_procmem function should maybe go away, though. 
73.  */  
74.   
75. /* 
76.  * Here are our sequence iteration methods.  Our "position" is 
77.  * simply the device number. 
78.  */  
79.   
80.   
81.       
82. /* 
83.  * Tie the sequence operators up. 
84.  */  
85.   
86. /* 
87.  * Now to implement the /proc file we need only make an open 
88.  * method which sets up the sequence operators. 
89.  */  
90.   
91. /* 
92.  * Create a set of file operations for our proc file. 
93.  */  
94. static struct file_operations scull_proc_ops = {  
95.     .owner   = THIS_MODULE,  
96.     .open    = scull_proc_open,  
97.     .read    = seq_read,  
98.     .llseek  = seq_lseek,  
99.     .release = seq_release  
100. };  
101.       
102.   
103. /* 
104.  * Actually create (and remove) the /proc file(s). 
105.  */  
106.   
107.   
108.   
109.   
110. #endif /* SCULL_DEBUG */  
111.   
112.   
113.   
114.   
115.   
116. /* 
117.  * Open and close 
118.  */  
119.   
120. int scull_open(struct inode *inode, struct file *filp)  
121. {  
122.     struct scull_dev *dev; /* device information */  
123.   
124.     dev = container_of(inode->i_cdev, struct scull_dev, cdev);  
125.     filp->private_data = dev; /* for other methods */  
126.   
127.     return 0;          /* success */  
128. }  
129.   
130. int scull_release(struct inode *inode, struct file *filp)  
131. {  
132.     return 0;  
133. }  
134. /* 
135.  * Follow the list 
136.  */  
137.   
138. /* 
139.  * Data management: read and write 
140.  */  
141.   
142. ssize_t scull_read(struct file *filp, char __user *buf, size_t count,  
143.                 loff_t *f_pos)  
144. {  
145.     unsigned long p = *f_pos;  
146.     int ret = 0;  
147.     struct scull_dev *dev = filp->private_data;  
148.     if(p >= SCULL_SIZE)  
149.         return count ? -ENXIO : 0 ;  
150.     if(count > SCULL_SIZE - p)  
151.         count = SCULL_SIZE - p;  
152.   
153.     if(copy_to_user(buf, (void *)(dev->mem + p), count))  
154.     {  
155.         ret = - EFAULT;  
156.     }  
157.     else  
158.     {  
159.         *f_pos += count;  
160.         ret = count;  
161.         printk(KERN_WARNING "read %d bytes from %d\n", count, p);  
162.     }  
163.     printk(KERN_WARNING "ret: %d\n",ret);  
164.     return ret;  
165. }  
166.   
167. ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,  
168.                 loff_t *f_pos)  
169. {  
170.     unsigned long p = *f_pos;  
171.     int ret = 0;  
172.     struct scull_dev *dev = filp->private_data;  
173.       
174.     if(p >= SCULL_SIZE )  
175.         return count ? -ENXIO : 0 ;  
176.     if(count > SCULL_SIZE - p)  
177.         count = SCULL_SIZE - p;  
178.   
179.     if(copy_from_user(dev->mem + p, buf, count))  
180.     {  
181.         ret = -EFAULT;  
182.     }  
183.     else  
184.     {  
185.         *f_pos += count;  
186.         ret = count;  
187.         printk(KERN_WARNING "write %d bytes to %d\n", count , p);  
188.     }  
189.   
190. }  
191.   
192. /* 
193.  * The ioctl() implementation 
194.  */  
195.   
196. int scull_ioctl(struct inode *inode, struct file *filp,  
197.                  unsigned int cmd, unsigned long arg)  
198. {  
199.     return 0;  
200.   
201. }  
202.   
203.   
204.   
205. /* 
206.  * The "extended" operations -- only seek 
207.  */  
208.   
209. loff_t scull_llseek(struct file *filp, loff_t off, int whence)  
210. {  
211.     loff_t ret;  
212.     struct scull_dev *dev = filp->private_data;  
213.   
214.     switch(whence) {  
215.       case 0: /* SEEK_SET */  
216.         if(off < 0)  
217.         {  
218.             ret = -EINVAL;  
219.             break;  
220.         }  
221.         if(off > SCULL_SIZE)  
222.         {  
223.             ret = -EINVAL;  
224.             break;  
225.         }  
226.         filp->f_pos = off;  
227.         ret = filp->f_pos;  
228.         break;  
229.   
230.       case 1: /* SEEK_CUR */  
231.         if((off + filp->f_pos) > SCULL_SIZE)  
232.         {  
233.             ret = -EINVAL;  
234.             break;  
235.         }  
236.         if((off + filp->f_pos) < 0)  
237.         {  
238.             ret = -EINVAL;  
239.             break;  
240.         }  
241.         filp->f_pos += off;  
242.         ret = filp->f_pos;  
243.         break;  
244.   
245.       case 2: /* SEEK_END */  
246.         if(off > 0)  
247.         {  
248.             ret = -EINVAL;  
249.             break;  
250.         }  
251.         if((off + SCULL_SIZE) < 0)  
252.         {  
253.             ret = -EINVAL;  
254.             break;  
255.         }  
256.         break;  
257.   
258.       default: /* can't happen */  
259.         return -EINVAL;  
260.     }  
261.       
262.     return ret;  
263. }  
264.   
265.   
266.   
267. struct file_operations scull_fops = {  
268.     .owner =    THIS_MODULE,  
269.     .llseek =   scull_llseek,  
270.     .read =     scull_read,  
271.     .write =    scull_write,  
272.     .ioctl =    scull_ioctl,  
273.     .open =     scull_open,  
274.     .release =  scull_release,  
275. };  
276.   
277. /* 
278.  * Finally, the module stuff 
279.  */  
280.   
281. /* 
282.  * The cleanup function is used to handle initialization failures as well. 
283.  * Thefore, it must be careful to work correctly even if some of the items 
284.  * have not been initialized 
285.  */  
286. void scull_cleanup_module(void)  
287. {  
288.     int i;  
289.     dev_t devno = MKDEV(scull_major, scull_minor);  
290.   
291.     /* Get rid of our char dev entries */  
292.     if (scull_devices) {  
293.         for (i = 0; i < scull_nr_devs; i++) {  
294.             cdev_del(&scull_devices[i].cdev);  
295.         }  
296.         kfree(scull_devices);  
297.     }  
298.   
299. #ifdef SCULL_DEBUG /* use proc only if debugging */  
300.     //scull_remove_proc();  
301. #endif  
302.   
303.     /* cleanup_module is never called if registering failed */  
304.     unregister_chrdev_region(devno, scull_nr_devs);  
305.   
306.     /* and call the cleanup functions for friend devices */  
307.     //scull_p_cleanup();  
308.     //scull_access_cleanup();  
309.   
310. }  
311.   
312.   
313. /* 
314.  * Set up the char_dev structure for this device. 
315.  */  
316. static void scull_setup_cdev(struct scull_dev *dev, int index)  
317. {  
318.     int err, devno = MKDEV(scull_major, scull_minor + index);  
319.       
320.     cdev_init(&dev->cdev, &scull_fops);  
321.     dev->cdev.owner = THIS_MODULE;  
322.     dev->cdev.ops = &scull_fops;  
323.     err = cdev_add (&dev->cdev, devno, 1);  
324.     /* Fail gracefully if need be */  
325.     if (err)  
326.         printk(KERN_NOTICE "Error %d adding scull%d", err, index);  
327. }  
328.   
329.   
330. int scull_init_module(void)  
331. {  
332.     int result, i;  
333.     dev_t dev = 0;  
334.   
335. /* 
336.  * Get a range of minor numbers to work with, asking for a dynamic 
337.  * major unless directed otherwise at load time. 
338.  */  
339.     if (scull_major) {  
340.         dev = MKDEV(scull_major, scull_minor);  
341.         result = register_chrdev_region(dev, scull_nr_devs, "scull");  
342.     } else {  
343.         result = alloc_chrdev_region(&dev, scull_minor, scull_nr_devs,  
344.                 "scull");  
345.         scull_major = MAJOR(dev);  
346.     }  
347.     if (result < 0) {  
348.         printk(KERN_WARNING "scull: can't get major %d\n", scull_major);  
349.         return result;  
350.     }  
351.   
352.         /*  
353.      * allocate the devices -- we can't have them static, as the number 
354.      * can be specified at load time 
355.      */  
356.     scull_devices = kmalloc(scull_nr_devs * sizeof(struct scull_dev), GFP_KERNEL);  
357.     if (!scull_devices) {  
358.         result = -ENOMEM;  
359.         goto fail;  /* Make this more graceful */  
360.     }  
361.     memset(scull_devices, 0, scull_nr_devs * sizeof(struct scull_dev));  
362.   
363.         /* Initialize each device. */  
364.     for (i = 0; i < scull_nr_devs; i++) {  
365.         scull_setup_cdev(&scull_devices[i], i);  
366.     }  
367.   
368.         /* At this point call the init function for any friend device */  
369.     dev = MKDEV(scull_major, scull_minor + scull_nr_devs);  
370.     //dev += scull_p_init(dev);  
371.     //dev += scull_access_init(dev);  
372.   
373. #ifdef SCULL_DEBUG /* only when debugging */  
374.     //scull_create_proc();  
375. #endif  
376.   
377.     return 0; /* succeed */  
378.   
379.   fail:  
380.     scull_cleanup_module();  
381.     return result;  
382. }  
383.   
384. module_init(scull_init_module);  
385. module_exit(scull_cleanup_module);  

为了实现设备只能被一个进程打开，从而避免竞态的出现。

做以下改动：

在文件开头定义并初始化一个整形原子变量，初始化为1。

[cpp]  view plain copy

1. static atomic_t scull_available = ATOMIC_INIT(1);  //init atomic  
2.   
3. 在scull_open 函数和scull_close函数中：  
4.   
5. int scull_open(struct inode *inode, struct file *filp)  
6. {  
7.     struct scull_dev *dev; /* device information */  
8.   
9.     dev = container_of(inode->i_cdev, struct scull_dev, cdev);  
10.     filp->private_data = dev; /* for other methods */  
11.     if(!atomic_dec_and_test(&scull_available)){  
12.         atomic_inc(&scull_available);  
13.         return -EBUSY;  
14.     }  
15.     return 0;          /* success */  
16. }  
17.   
18. int scull_release(struct inode *inode, struct file *filp)  
19. {  
20.     atomic_inc(&scull_available);  
21.     return 0;  
22. }  

在scull_open函数中，当第一个进程打开scull设备时，因为scull_available原子变量的初值为1，atomic_dec_and_test做自减后测试为0，返回true，所以open就成功。

那第二个进程打开scull设备时，原子变量已经减到0了，所以atomic_dec_and_test返回false，所以open返回EBUSY。

不管是第二个进程打开失败，还是第一个进程执行结束，都不要忘了恢复原子变量的值.(atomic_inc(&scull_available);)

在应用层写一个小的测试程序：

app.c：

[cpp]  view plain copy

1. #include <sys/types.h>  
2. #include <sys/stat.h>  
3. #include <fcntl.h>  
4. #include <stdio.h>  
5. #include <errno.h>  
6.   
7. #include <unistd.h>  
8. void main(void)  
9. {  
10.     int fd;  
11.     fd = open("/dev/scull",O_RDWR);  
12.     if( fd < 0 )  
13.     {  
14.         perror("open");  
15.         return;  
16.     }  
17.     sleep(10);  
18.     close(fd);  
19.     exit(0);  
20. }  

开始运行./app时是正常的，在./app &后我们立即再./app(手速够快，小于10s)，会有设备忙的提示。

如果在./app &后过了10s，我们再./app还是可以正常打开的。

这样看来，通过整形原子操作实现了设备只能被一个进程打开。

同样的道理，我们可以利用位操作来实现这一点：

[cpp]  view plain copy

1. static int i = 1;  
2. static void *addr = &i ;  
3.   
4. int scull_open(struct inode *inode, struct file *filp)  
5. {  
6.     struct scull_dev *dev; /* device information */  
7.   
8.     dev = container_of(inode->i_cdev, struct scull_dev, cdev);  
9.     filp->private_data = dev; /* for other methods */  
10.     if(test_and_set_bit(1,addr) != 0){  
11.         clear_bit(1,addr);  
12.         return -EBUSY;  
13.     }  
14.     return 0;          /* success */  
15. }  
16.   
17. int scull_release(struct inode *inode, struct file *filp)  
18. {  
19.     clear_bit(1,addr);  
20.     return 0;  
21. }  

利用app.c测试，效果一致。