#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全局内存*/不推荐使用0x01 会导致不同设备的驱动拥有相同的命令号,命令号不能重复
#define GLOBALMEM_MAJOR 254 /*预设的globalmem的主设备号*/
#define GLOBALMEM_MAGIC 'm'定义幻数 正好8位
static int globalmem_major = GLOBALMEM_MAJOR;
static int count=0; //用于定义文件打开的次数,
spinlock_t lock;
/*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;
或者:如果不只包含一个设备,而是同时包含两个以上的设备时:采用以下写法:
struct globalmem_dev *dev;
//通过结构体成员的指针找到对应结构体的指针
dev=container_of(inode->i_cdev,struct globalmem_dev,cdev);
filp->private_data=dev;
spinlock(&lock); //加锁
if(count)//已经打开,只能被一个进程打开
{
spin_unlock(&lock);
return -BUSY;
}
count++;
spin_unlock(&lock);//解锁
return 0;
}
/*文件释放函数*/
int globalmem_release(struct inode *inode, struct file *filp)
{
spinlock(&lock);
count--;
spin_unlock(&lock);
return 0;
}
/* ioctl设备控制函数 */
static int globalmem_ioctl(struct inode *inodep, struct file *filp, unsigned //inodep 表示物理上的信息。filp 打开的设备文件
int cmd, unsigned long arg) //arg 可选的参数
{
struct globalmem_dev *dev = filp->private_data;/*获得设备结构体指针*/
if(_IOC_TYPE(cmd)!=GLOBALMEM_MAGIC)
return -EINVAL;
if(_IOC_NR(cmd)>MAX)
return -EINVAL;
if(_IOC_DIR(cmd)&_IOC_READ)
err=!access_ok()
switch (cmd)
{
case MEM_CLEAR:
//LINUX 建议统一采用 ioctl()命令生成方式 命令由 设备类型(8bit)序列号也叫命令的编号(8bit)参数传递方向即是读写数据方向(2bit)用户数据大小(13bit)
在ioctl.h中使用宏来辅助生成命令
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0) _IOC_NONE 无数据传输
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size)) _IOC_READ 读 type 设备类型 nr序列号 sizeof(size) 数据尺寸
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))
由此 可以定义MEM_CLEAR _IO(GLOBALMEM_MAGIC,0)
内核中也会预定义一些命令,当用户命令与它冲突时,被当成内核命令例如:
#define FIOCLEX _IO('f', 1) 通知内核当exec调用结束时自动关闭打开的文件
#define FIONCLEX _IO('f', 2)
#define FIOASYNC _IOW('f', 125, int)
#define FIONBIO _IOW('f', 126, int)
if (down_interruptible(&dev->sem))//获得信号量
{
return - ERESTARTSYS;
}
memset(dev->mem, 0, GLOBALMEM_SIZE); //除读写之外,这里对mem的操作也会引起混乱。
up(&dev->sem); //释放信号量
printk(KERN_INFO "globalmem is set to zero\n");
break;
default:
return - EINVAL;//对于不支持的命令,应该返回-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; /*获得设备结构体指针,读也是读private_data*/
/*分析和获取有效的写长度*/
if (p >= GLOBALMEM_SIZE)
return count ? - ENXIO: 0;
if (count > GLOBALMEM_SIZE - p)
count = GLOBALMEM_SIZE - p;
if (down_interruptible(&dev->sem))//获得信号量。对并发控制后的驱动读写控制。如果非0 down_interruptible立即返回,意味着在其获得信号量之前已被打断。
{
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)//ppos 相对于文件开头的偏移
{
unsigned long p = *ppos;
unsigned int count = size;
int ret = 0;
struct globalmem_dev *dev = filp->private_data; /*获得设备结构体指针,
一般规则是 将文件的私有数据指向设备结构体即通过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)//主要移动f_pos
{
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:struct cdev {
struct kobject kobj;
struct module *owner;
const struct file_operations *ops;
struct list_head list;
dev_t dev;
unsigned int count;
}; 用于描述一个设备*/
static void globalmem_setup_cdev(struct globalmem_dev *dev, int index)
{
int err, devno = MKDEV(globalmem_major, index);
cdev_init(&dev->cdev, &globalmem_fops);
/* void cdev_init(struct cdev *cdev, const struct file_operations *fops)
{
memset(cdev, 0, sizeof *cdev);
INIT_LIST_HEAD(&cdev->list);
kobject_init(&cdev->kobj, &ktype_cdev_default);
cdev->ops = fops; 建立globalmem_fops和cdev联系
}*/
dev->cdev.owner = THIS_MODULE;
dev->cdev.ops = &globalmem_fops;//建立起file_operations和cdev之间的联系
err = cdev_add(&dev->cdev, devno, 1);//向系统添加一个cdev
if (err)
printk(KERN_NOTICE "Error %d adding LED%d", err, index);
}
/*设备驱动模块加载函数*/
int globalmem_init(void)
{
int result;
//通过主设备号globalmem_major 和次设备号0生成dev_t ,主设备号:用于连接设备文件和设备驱动,次设备号:用于多个设备区分是哪个设备
dev_t devno = MKDEV(globalmem_major, 0);
MAJOR(dev_t devno)//获得主设备号
MINOR(dev_t devno) //获取次设备号
/* 申请设备号 register_chrdev_region 用于已知设备号的情况下*/
if (globalmem_major)
result = register_chrdev_region(devno, 1, "globalmem");
else /* 动态申请设备号 alloc_chrdev_region 用于未知设备号,避开冲突*/
{
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);
自旋锁与信号量"类似而不类",类似说的是它们功能上的相似性,"不类"指代它们在本质和实现机理上完全不一样,不属于一类。
自旋锁不会引起调用者睡眠,如果自旋锁已经被别的执行单元保持,调用者就一直循环查看是否该自旋锁的保持者已经释放了锁,"自旋"就是"在原地打转"。而信号量则引起调用者睡眠,它把进程从运行队列上拖出去,除非获得锁。这就是它们的"不类"。
但是,无论是信号量,还是自旋锁,在任何时刻,最多只能有一个保持者,即在任何时刻最多只能有一个执行单元获得锁。这就是它们的"类似"。
鉴于自旋锁与信号量的上述特点,一般而言,自旋锁适合于保持时间非常短的情况,它可以在任何上下文使用;信号量适合于保持时间较长的情况,会只能在进程上下文使用。如果被保护的共享资源只在进程上下文访问,则可以以信号量来保护该共享资源,如果对共享资源的访问时间非常短,自旋锁也是好的选择。但是,如果被保护的共享资源需要在中断上下文访问(包括底半部即中断处理句柄和顶半部即软中断),就必须使用自旋锁。
spin_lock_init(&lock);//初始化自旋锁
init_MUTEX(&globalmem_devp->sem); /*初始化信号量*/
return 0;
//以下是申请两个以上的设备:/* 动态申请2个设备结构体的内存*/
globalmem_devp = kmalloc(2*sizeof(struct globalmem_dev), GFP_KERNEL);
if (!globalmem_devp) /*申请失败*/
{
result = - ENOMEM;
goto fail_malloc;
}
memset(globalmem_devp, 0, 2*sizeof(struct globalmem_dev));
globalmem_setup_cdev(&globalmem_devp[0], 0);
globalmem_setup_cdev(&globalmem_devp[1], 1);
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); /*释放设备号*/
//以下是申请两个以上的设备
cdev_del(&(globalmem_devp[0].cdev));
cdev_del(&(globalmem_devp[1].cdev)); /*注销cdev*/
kfree(globalmem_devp); /*释放设备结构体内存*/
unregister_chrdev_region( (globalmem_major, 0), 2); /*释放设备号*/
}
MODULE_AUTHOR("Song Baohua");
MODULE_LICENSE("Dual BSD/GPL");
module_param(globalmem_major, int, S_IRUGO);
module_init(globalmem_init);
module_exit(globalmem_exit);
使用 insmod 挂载之后。cat /proc/devices
mknod /dev/globalmem c 250 0 创建设备节点
echo "hello world" > /dev/globalmem 写数据到设备
cat /dev/globalmem
linux中的驱动中的总线和设备模型都可以在 /sys(sysfs文件系统)目录下找到对应的节点
sysfs文件系统 :是一个虚拟的文件系统把系统上的设备和总线构成一个分级的文件
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("Dual BSD/GPL");
int add_integar(int a,int b)
{
return a+b;
}
int sub_integar(int a,int b)
{
return a-b;
}
EXPORT_SYMBOL(add_integar);
EXPORT_SYMBOL(sub_integar);