Linux 字符设备驱动

时间：2021-12-01 17:55:02

字符设备驱动的结构

Linux 字符设备驱动

在Linux内核中使用cdev结构体描述一个字符设备：

// include/linux/cdev.h
struct cdev {
struct kobject kobj;
struct module *owner;
const struct file_operations *ops;
struct list_head list;
    dev_t dev;
unsigned int count;
};
  • dev_t成员定义了设备号(32位)，12位为主设备号，20位为次设备号.
  • file_operations 结构体中的成员函数是字符设备驱动程序设计的主体，这些函数实际会在应用程序进行Linux的open、write、read、close等系统调用时最终被内核调用.

globalmem虚拟设备示例

下面的示例用于创建一个全局内存读写设备，在globalmem字符设备驱动中会分配一片大小为4KB的内存空间，并在驱动中提供针对该内存的读写、控制和定位函数，以供用户空间的进程可以通过Linux系统调用获取或设置这片内存的内容。

【代码仓库】

#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 <linux/slab.h>
#include <asm/uaccess.h>

#define GLOBALMEM_SIZE 0x1000 /*全局内存最大4K字节*/
#define MEM_CLEAR 0x1 /*清0全局内存*/
#define GLOBALMEM_MAJOR 224 /*预设的globalmem的主设备号*/

static int globalmem_major = GLOBALMEM_MAJOR;

/*globalmem设备结构体*/
struct globalmem_dev                                     
{                                                        
struct cdev cdev; /*cdev结构体*/                       
unsigned char mem[GLOBALMEM_SIZE]; /*全局内存*/        
};

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:
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 *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 (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);
    }

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 (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);
    }

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,
    .compat_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);
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);

Makefile

KERNELDIR = /lib/modules/`uname -r`/build

#Kernel modules
obj-m += globalmem.o

#EXTRA_CFLAGS=-g -o0

all:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules

clean:
$(MAKE) -C $(KERNELDIR) M=$(PWD) clean

运行

$ make
$ insmod
$ cat /proc/devices
$ mknod /dev/globalmem c 224 0
$ echo "hello world" > /dev/globalmem
$ cat /dev/globalmem
hello world

相关说明

ioctl

设备类型 序列号 方向 数据尺寸
8位 8位 2位 13/14位 
#define _IOC_NRSHIFT 0
#define _IOC_TYPESHIFT (_IOC_NRSHIFT + _IOC_NRBITS)
#define _IOC_SIZESHIFT (_IOC_TYPESHIFT + _IOC_TYPEBITS)
#define _IOC_DIRSHIFT (_IOC_SIZESHIFT + _IOC_SIZEBITS)

#define _IOC_NONE 1U
#define _IOC_READ 2U
#define _IOC_WRITE 4U

#define _IOC(dir,type,nr,size) \
        (((dir)  << _IOC_DIRSHIFT) | \
         ((type) << _IOC_TYPESHIFT) | \
         ((nr)   << _IOC_NRSHIFT) | \
         ((size) << _IOC_SIZESHIFT))

#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_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))

# sample
#define GLOBALMEM_MAGIC 'c'
#define MEM_CLEAR _IO(GLOBALMEM_MAGIC, 0)

private_data

大多数Linux驱动遵循一个“潜规则”，那就是将文件的私有数据private_data指向设备结构体，再用read()、write()、ioctl()、llseek()等函数通过private_data访问设备结构体。私有数据的概念在Linux驱动的各个子系统中广泛存在，实际上体现了Linux的面向对象的设计思想。

学习资源
标签：

相关文章