第六章字符设备

记录一下建立一个简单的字符设备的编码过程

前提准备：已经编译好的Linux内核

进入../drivers/char/目录

这里存放着这字符设备驱动

mkdir globalmem 创建一个我们新建驱动的目录并进入

新建globalmem.c文件，清单如下

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>

#define GLOBALMEM_SIZE 0x1000
#define MEM_CLEAR 0x1
#define GLOBALMEM_MAJOR 230

static int globalmem_major=GLOBALMEM_MAJOR;
module_param(globalmem_major,int,S_IRUGO);
struct globalmem_dev
{
    struct cdev cdev;
    unsigned char mem[GLOBALMEM_SIZE];
};
struct globalmem_dev *globalmem_devp;
static int globalmem_open(struct inode *inode,struct file *filep)
{
    filep->private_data = globalmem_devp;
    return 0;
}
static int globalmem_release(struct inode *inode,struct file *filep)
{
    return 0;
}
static long globalmem_ioctl(struct file *filep,unsigned int cmd,unsigned long arg)
{
    struct globalmem_dev *dev = filep->private_data;
    switch(cmd){
        case MEM_CLEAR:
            memset(dev->mem,0,GLOBALMEM_SIZE);
            printk(KERN_INFO "globalmem is set to zero\n");
            break;
        default:
            return -EINVAL;
    }
    return 0;
}
static ssize_t globalmem_read(struct file *filep,char __user * buf,size_t size,loff_t * ppos)
{
    unsigned long p = *ppos;
    unsigned int count=size;
    int ret = 0;
    struct globalmem_dev *dev = filep->private_data;
    if (p >=GLOBALMEM_SIZE)
    {
        return 0;
    }
    if(count>GLOBALMEM_SIZE-p)
    {
        count=GLOBALMEM_SIZE-p;
    }
    if(copy_to_user(buf,dev->mem+p,count))
    {
        ret=-EINVAL;
    }else{

        *ppos+=count;
        ret=count;
        printk(KERN_INFO "read %u bytes from %u\n",count,p);
    }
    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 0;
    if (count > GLOBALMEM_SIZE - p)
        count = GLOBALMEM_SIZE - p;

    if (copy_from_user(dev->mem + p, buf, count))
        ret = -EFAULT;
    else {
        *ppos += count;
        ret = count;

        printk(KERN_INFO "written %u bytes(s) from %lu\n", count, p);
    }

    return ret;
}
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,
    .unlocked_ioctl =globalmem_ioctl,
    .open = globalmem_open,
    .release = globalmem_release,
};
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;
    err = cdev_add(&dev->cdev,devno,1);
    if(err)
        printk(KERN_NOTICE "Error %d adding globalmem%d",err,index);
}
static int __init globalmem_init(void)
{
    int ret;
    dev_t devno =MKDEV(globalmem_major,0);
    if(globalmem_major)
        ret = register_chrdev_region(devno,1,"globalmem");
    else{
        ret = alloc_chrdev_region(&devno,0,1,"globalmem");
        globalmem_major=MAJOR(devno);
    }
    if(ret<0)
        return ret;
    globalmem_devp = kzalloc(sizeof(struct globalmem_dev),GFP_KERNEL);
    if(!globalmem_devp){
        ret = -ENOMEM;
        goto fail_malloc;
    }
    globalmem_setup_cdev(globalmem_devp,0);
    return 0;
    fail_malloc:
        unregister_chrdev_region(devno,1);
        return ret;
}
module_init(globalmem_init);
static void __exit globalmem_exit(void)
{
    cdev_del(&globalmem_devp->cdev);
    kfree(globalmem_devp);
    unregister_chrdev_region(MKDEV(globalmem_major,0),1);
}
module_exit(globalmem_exit);
MODULE_AUTHOR("ztt");
MODULE_LICENSE("GPL v2");

新建Makefile文件，清单如下：

CONFIG_MODULE_SIG=n
KVERS = $(shell uname -r)

# Kernel modules
obj-m += globalmem.o

build: kernel_modules

kernel_modules:
	make -C /lib/modules/$(KVERS)/build M=$(CURDIR) modules

clean:
	make -C /lib/modules/$(KVERS)/build M=$(CURDIR) clean

然后在创建的目录下执行命令 make

编译驱动，会在该目录下生成globalmem.ko文件

加载该模块 insmod globalmem.ko

执行 cat /proc/devices

可以看到新定义的字符设备驱动，主设备号为230

执行命令：mknod /dev/globalmem c 230 0

创建“/dev/globalmem”设备节点

通过执行：

echo "hello world" > /dev/globalmem 验证设备的写

cat /dev/globalmem 验证设备的读#输出hello world

进入/sys/module/可以找到globalmem目录使用tree命令可观察其目录结构

第六章 字符设备

猜你喜欢