7--1linux设备驱动中的并发控制

共享资源-> 竞态

自旋锁 信号量 是对 共享数据的保护，而不是对代码的保护。

感觉：

       只要 掌握 自旋锁 spin_lock  这个 锁， 和 信号量 down_interruptible(&sem)这连个最常用的就可以了。

***********************************************************

信号量（semephore）是用于保护临界区的一种常用方法。他的使用方法与自旋锁类似。

相同之处：只有得到信号量的进程才能进入执行临界区代码。

不同之处：当获取不到信号量时，进程不会原地打转，而是进入 休眠  等待状 态。

获得信号量：

int down_interruptible(struct semaphore *sem);

该函数功能与down（）类似，不同之处为，因为down（）而进入睡眠状态的进程不能被信号打断，

而因为down_interruptible()而进入睡眠状态的进程能被信号打断，信号也会导致该函数返回，这时候函数的返回值非0

。。。。

if(down_interruptilble(&sem))

{

     return -ERESTARTSYS;

}

。。。。

自己的理解:

               首先执行  down_interruptible();

               如果立即 获得信号量，则跳过if(),,向下继续执行。。

               如果没有立即获得信号量，则进程进入睡眠等待状态，在进程睡眠等待的时候，可以响应中断，如果进程被信号打断，那么

函数down_interruptible(&sem) 返回一个非 0 的值，

               -ERESTRATSYS,重新执行该系统调用（相当于重新启动）

互斥体：

         int fastcall mutex_lock(struct mutex *lock)

***************************************************************************

当参数个数多于一个时，按照什么顺序把参数压入堆栈
函数调用后，由谁来把堆栈恢复原装     内存 还是 寄存器
在高级语言中，通过函数调用约定来说明这两个问题。常见的调用约定有：

stdcall
cdecl
fastcall
thiscall
naked call

fastcall
fastcall调用约定和stdcall类似，它意味着：

函数的第一个和第二个DWORD参数（或者尺寸更小的）通过ecx和edx传递，其他参数通过
从右向左的顺序压栈
被调用函数清理堆栈
函数名修改规则同stdcall
其声明语法为：int fastcall function(int a,int b)

fastcall
1）参数压栈顺序从右到左。
2）如果可能使用寄存器（register）来传递参数。使用寄存器做参数比将参数压入堆栈（堆栈就是内存）快得多，所以叫fastcall。

http://tieba.baidu.com/f?kz=87050749  资料来源

***************************************************************************

**********************网上关于fastcall解答***************************************

最近在阅读Linux内核源代码的时候，发现有很多__attribute__其中有一个宏FASTCALL（x）或者fastcall用的就比较多，定 义如下：
#define FASTCALL（x）x __attribute__((regparm(3)))
#define fastcall __attribute__((regparm(3)))
意思是,最多可以使用3个寄存器(或许是eax,edx,ecx)来传送前3个参数,其他参数则压入栈中,而一般来说，函数的调用是基于栈的。
#define asmlinkage CPP_ASMLINKAGE __attribute__((regparm(0)))
意思就是使用0个寄存器来进行参数传递,顾名思义它是想使得调用这个函数时的所有参数都压入栈中,相对于FASTCALL的使用方式当然是要慢一些了

 ***************************the end************************************************    

[root@EmbedSky /xiangjie]# ls 4_book.ko globalmem_two.ko hello.txt globalmem_lock.ko hello [root@EmbedSky /xiangjie]# insmod globalmem_lock.ko [root@EmbedSky /xiangjie]# cat /proc/devices Character devices: 1 mem 4 /dev/vc/0 4 tty 5 /dev/tty 5 /dev/console 5 /dev/ptmx 7 vcs 10 misc 13 input 14 sound 29 fb 81 video4linux 89 i2c 90 mtd 116 alsa 128 ptm 136 pts 180 usb 188 ttyUSB 189 usb_device 204 tq2440_serial 244 globalmem 253 usb_endpoint 254 rtc Block devices: 259 blkext 7 loop 31 mtdblock 179 mmc [root@EmbedSky /xiangjie]# mknod /dev/globalmem c 244 0 [root@EmbedSky /xiangjie]# echo 'i love arm i love linux i lover linux device' > /dev/globalmem written 45 bytes(s) from 0 [root@EmbedSky /xiangjie]# cat /dev/globalmem read 4096 bytes(s) from 0 i love arm i love linux i lover linux device cat: read error: No such device or address [root@EmbedSky /xiangjie]#

/*====================================================================== A globalmem driver as an example of char device drivers This example is to introduce how to use locks to avoid race conditions The initial developer of the original code is Baohua Song <author@linuxdriver.cn>. All Rights Reserved. ======================================================================*/ #include <linux/module.h> #include <linux/types.h> #include <linux/fs.h> #include <linux/errno.h> #include <linux/mm.h> #include <linux/sched.h> #include <linux/init.h> #include <linux/cdev.h> #include <asm/io.h> #include <asm/system.h> #include <asm/uaccess.h> #define GLOBALMEM_SIZE 0x1000 /*全局内存最大4K字节*/ #define MEM_CLEAR 0x1 /*清0全局内存*/ #define GLOBALMEM_MAJOR 254 /*预设的globalmem的主设备号*/ static int globalmem_major = GLOBALMEM_MAJOR; /*globalmem设备结构体*/ struct globalmem_dev { struct cdev cdev; /*cdev结构体*/ unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/ struct semaphore sem; /*并发控制用的信号量*/ }; struct globalmem_dev *globalmem_devp; /*设备结构体指针*/ /*文件打开函数*/ int globalmem_open(struct inode *inode, struct file *filp) { /*将设备结构体指针赋值给文件私有数据指针*/ filp->private_data = globalmem_devp; return 0; } /*文件释放函数*/ int globalmem_release(struct inode *inode, struct file *filp) { return 0; } /* ioctl设备控制函数 */ static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned int cmd, unsigned long arg) { struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/ switch (cmd) { case MEM_CLEAR: if (down_interruptible(&dev->sem)) { return - ERESTARTSYS; } memset(dev->mem, 0, GLOBALMEM_SIZE); up(&dev->sem); //释放信号量 printk(KERN_INFO "globalmem is set to zero/n"); break; default: return - EINVAL; } return 0; } /*读函数*/ static ssize_t globalmem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos) { unsigned long p = *ppos; unsigned int count = size; int ret = 0; struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/ /*分析和获取有效的写长度*/ if (p >= GLOBALMEM_SIZE) return count ? - ENXIO: 0; if (count > GLOBALMEM_SIZE - p) count = GLOBALMEM_SIZE - p; if (down_interruptible(&dev->sem)) { return - ERESTARTSYS; } /*内核空间->用户空间*/ if (copy_to_user(buf, (void*)(dev->mem + p), count)) { ret = - EFAULT; } else { *ppos += count; ret = count; printk(KERN_INFO "read %d bytes(s) from %d/n", count, p); } up(&dev->sem); //释放信号量 return ret; } /*写函数*/ static ssize_t globalmem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos) { unsigned long p = *ppos; unsigned int count = size; int ret = 0; struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针*/ /*分析和获取有效的写长度*/ if (p >= GLOBALMEM_SIZE) return count ? - ENXIO: 0; if (count > GLOBALMEM_SIZE - p) count = GLOBALMEM_SIZE - p; if (down_interruptible(&dev->sem))//获得信号量 { return - ERESTARTSYS; } /*用户空间->内核空间*/ if (copy_from_user(dev->mem + p, buf, count)) ret = - EFAULT; else { *ppos += count; ret = count; printk(KERN_INFO "written %d bytes(s) from %d/n", count, p); } up(&dev->sem); //释放信号量 return ret; } /* seek文件定位函数 */ static loff_t globalmem_llseek(struct file *filp, loff_t offset, int orig) { loff_t ret = 0; switch (orig) { case 0: /*相对文件开始位置偏移*/ if (offset < 0) { ret = - EINVAL; break; } if ((unsigned int)offset > GLOBALMEM_SIZE) { ret = - EINVAL; break; } filp->f_pos = (unsigned int)offset; ret = filp->f_pos; break; case 1: /*相对文件当前位置偏移*/ if ((filp->f_pos + offset) > GLOBALMEM_SIZE) { ret = - EINVAL; break; } if ((filp->f_pos + offset) < 0) { ret = - EINVAL; break; } filp->f_pos += offset; ret = filp->f_pos; break; default: ret = - EINVAL; break; } return ret; } /*文件操作结构体*/ static const struct file_operations globalmem_fops = { .owner = THIS_MODULE, .llseek = globalmem_llseek, .read = globalmem_read, .write = globalmem_write, .ioctl = globalmem_ioctl, .open = globalmem_open, .release = globalmem_release, }; /*初始化并注册cdev*/ static void globalmem_setup_cdev(struct globalmem_dev *dev, int index) { int err, devno = MKDEV(globalmem_major, index); cdev_init(&dev->cdev, &globalmem_fops); dev->cdev.owner = THIS_MODULE; dev->cdev.ops = &globalmem_fops; err = cdev_add(&dev->cdev, devno, 1); if (err) printk(KERN_NOTICE "Error %d adding LED%d", err, index); } /*设备驱动模块加载函数*/ int globalmem_init(void) { int result; dev_t devno = MKDEV(globalmem_major, 0); /* 申请设备号*/ if (globalmem_major) result = register_chrdev_region(devno, 1, "globalmem"); else /* 动态申请设备号 */ { result = alloc_chrdev_region(&devno, 0, 1, "globalmem"); globalmem_major = MAJOR(devno); } if (result < 0) return result; /* 动态申请设备结构体的内存*/ globalmem_devp = kmalloc(sizeof(struct globalmem_dev), GFP_KERNEL); if (!globalmem_devp) /*申请失败*/ { result = - ENOMEM; goto fail_malloc; } memset(globalmem_devp, 0, sizeof(struct globalmem_dev)); globalmem_setup_cdev(globalmem_devp, 0); init_MUTEX(&globalmem_devp->sem); /*初始化信号量*/ return 0; fail_malloc: unregister_chrdev_region(devno, 1); return result; } /*模块卸载函数*/ void globalmem_exit(void) { cdev_del(&globalmem_devp->cdev); /*注销cdev*/ kfree(globalmem_devp); /*释放设备结构体内存*/ unregister_chrdev_region(MKDEV(globalmem_major, 0), 1); /*释放设备号*/ } MODULE_AUTHOR("Song Baohua"); MODULE_LICENSE("Dual BSD/GPL"); module_param(globalmem_major, int, S_IRUGO); module_init(globalmem_init); module_exit(globalmem_exit);