memdev.ko --- 字符设备驱动程序-优快云博客

本文链接：https://blog.youkuaiyun.com/lamdoc/article/details/7780930

1. memdev.c

#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/io.h>
#include <asm/system.h>
#include <linux/uaccess.h>
#include <linux/slab.h>

#include "memdev.h"

static int mem_major = MEMDEV_MAJOR;
static int mem_minor = MEMDEV_MINOR;

module_param(mem_major, int, S_IRUGO);

struct mem_dev *mem_devp;  //声明全局结构体指针
struct cdev cdev; //静态定义的结构，就不需要分配内存空间

int mem_open(struct inode *inode, struct file *filp)
{
    struct mem_dev *dev;
    printk(KERN_INFO "xxha: --- mem_open\n");

    int num = MINOR(inode -> i_rdev); //num（即次设备号）表示有多少个同类设备。

    if (num >= MEMDEV_NR_DEVS)
        return -ENODEV;
    dev = &mem_devp[num];  //指定一个设备

    filp->private_data = dev; //将设备内容赋给 filp->private_data, 供read, write 使用。

    return 0;
}

int mem_release(struct inode *inode, struct file *filp)
{
    return 0;
}

static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos) //这函数的参数不能变，只有函数名可
以变
                                                                                        //__user 表示用户空间
{
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct mem_dev *dev = filp->private_data; //获得open中赋值的filp->private_data设备结构体指针

    if (p >= MEMDEV_SIZE)  //判断读位置是否有效，即是否在设备内存内部
        return 0;
    if (count > MEMDEV_SIZE - p) //需要读的长度，如果大于可以读的长度
        count = MEMDEV_SIZE -p;

    if (copy_to_user(buf, (void*)(dev->data + p), count)) { //读设备内容到 buf 缓存。
                                                            //从 (void*)(dev->data + p) 地址开始读取
                                                            //读取count个字节

        ret = -EFAULT;  //若copy_to_user()出错，返回-EFAULT；
    } else {            //若copy_to_user()没有出错;
        *ppos += count;   //更改读指针的位置
        ret = count;      //返回count，读取的字节数
        printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
    }
    return ret;
}

static ssize_t mem_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 mem_dev *dev = filp->private_data;  //获得设备结构体指针

    if (p >= MEMDEV_SIZE)
        return 0;
    if (count > MEMDEV_SIZE - p)
        count = MEMDEV_SIZE - p;

    if (copy_from_user(dev->data + p, buf, count))  //把用户空间地址buf中的数据，写入dev->data + p 内核空间地址。
                                                    //写入count个字节
        ret = -EFAULT;     //若出错，返回错误
    else {                 //若copy_from_user()没出错，则返回0，也就是运行else部分。
        *ppos += count;    //调整当前指针。
        ret = count;       //返回写入的字节数。
        printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
    }
    return ret;
}

static loff_t mem_llseek(struct file *filp, loff_t offset, int whence) //whence --- 从哪开始偏移
                                                                       //offset --- 偏移量
{
    loff_t newpos;

    switch(whence){
        case 0:  //SEEK_SET --- 头位置
            newpos = offset;
            break;
        case 1:  //SEEK_CUR --- 当前位置
            newpos = filp->f_pos + offset;   //filp->f_pos --- 文件描述符中当前文件指针位置
            break;
        case 2:  //SEEK_END --- 尾位置
            newpos = MEMDEV_SIZE -1 + offset;
            break;
        default: //cannot happen
            return -EINVAL;
    }
    if ((newpos < 0) || (newpos > MEMDEV_SIZE))
        return -EINVAL;

    filp->f_pos = newpos; //改变文件的读写位置
    return newpos;
}

static const struct file_operations mem_fops =
{
    .owner = THIS_MODULE,
    .llseek = mem_llseek,
    .read = mem_read,
    .write = mem_write,
    .open = mem_open,
    .release = mem_release,
};

//加载设备驱动
static int memdev_init(void)
{
    int result;
    int i;

    printk(KERN_INFO "xxha: ---  memdev_init\n");
    dev_t devno = MKDEV(mem_major, 0); //利用主设备号和次设备号，获得设备号

    if (mem_major){
        printk(KERN_INFO "xxha: ---  mem_major != 0, static cahr devno\n");
        printk(KERN_INFO "xxha: ---  devno = %d\n", devno);
        result = register_chrdev_region(devno, 2, "memdev"); //静态分配设备号， 一共分配2个设备
    } else {
        printk(KERN_INFO "xxha: ---  mem_major = 0, alloc char devno\n");
        result = alloc_chrdev_region(&devno, 0, 2, "memdev"); //如果mem_major = 0, 则使用动态分配设备号，
                                                              //获得设备号devno，也是2个设备，次设备号从0开始。
        printk(KERN_INFO "xxha: ---  devno = %d\n", devno);
        mem_major = MAJOR(devno);
        mem_minor = MINOR(devno);
        printk(KERN_INFO "xxha: ---  dev major = %d\n", mem_major);
        printk(KERN_INFO "xxha: ---  dev minor = %d\n", mem_minor);
    }

    if(result < 0){
        printk(KERN_INFO "xxha: --- dev no alloc failed\n");
        return result;
    }

    printk(KERN_INFO "xxha: ---  cdev_init\n");
    cdev_init(&cdev, &mem_fops);  //初始化cdev
    cdev.owner = THIS_MODULE;
    cdev.ops = &mem_fops;

    printk(KERN_INFO "xxha: ---  cdev_add\n");
//  result = cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);  //注册cdev驱动程序进入内核。
    result = cdev_add(&cdev, devno, MEMDEV_NR_DEVS);  //注册cdev驱动程序进入内核。
    if(result){
        printk(KERN_INFO "xxha: --- cdev_add failed\n");
        return result;
    }

    //为设备的描述结构mem_devp分配内存
    mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
    if (!mem_devp){
        result = - ENOMEM;
        goto fail_malloc;
    }
    memset(mem_devp, 0, sizeof(struct mem_dev));

    //为设备分配内存
    for(i = 0; i < MEMDEV_NR_DEVS; i++){
        mem_devp[i].size = MEMDEV_SIZE; //内存设备大小
        mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL); //为设备分配内存
        memset(mem_devp[i].data, 0, MEMDEV_SIZE); //清空设备内存
    }

    printk(KERN_INFO "xxha: ---  module_init finished\n");
    return 0;

fail_malloc:
    unregister_chrdev_region(devno, 1);
    return result;
}

//卸载模块
static void memdev_exit(void)
{
    cdev_del(&cdev); //从内核中注消字符设备
    kfree(mem_devp); //释放设备结构体内存
    unregister_chrdev_region(MKDEV(mem_major, 0), 2); //释放设备号

}

MODULE_AUTHOR("Lamdoc Xu");
MODULE_LICENSE("GPL");

module_init(memdev_init);
module_exit(memdev_exit);

2. memdev.h 头文件

#ifndef _MEMDEV_H_
#define _MEMDEV_H_

#ifndef MEMDEV_MAJOR
#define MEMDEV_MAJOR 0
#endif

#ifndef MEMDEV_MINOR
#define MEMDEV_MINOR 0
#endif

#ifndef MEMDEV_NR_DEVS
#define MEMDEV_NR_DEVS 1
#endif

#ifndef MEMDEV_SIZE
#define MEMDEV_SIZE 4096
#endif

//mem设备描述结构体
struct mem_dev {
    char *data;  //内存地址
    unsigned long size; //内存设备大小
};

#endif  //_MEMDEV_H_

3. Makefile，用来make 成 .ko 文件，编译完成后，需要chmod 777 memdev.ko, 才能用来 sudo insmod memdev.ko,加载驱动。

KERNELDIR ?= /lib/modules/3.0.0-12-generic/build/
PWD := $(shell pwd)
obj-m := memdev.o
default:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
    rm *.o *.ko *.mod.c *.symvers *.order

4. app-mem.c //应用程序，测试驱动的应用程序

#include <stdio.h>


int main()
{
    FILE *fp0 = NULL;
    char Buf[4096];

    strcpy(Buf, "Mem is char dev!");
    printf("Buf： %s\n", Buf);

    fp0 = fopen("/dev/memdev0", "r+");
    if (fp0 == NULL)
    {
        printf("Open Memdev0 Error!\n");
        return -1;
    }

    fwrite(Buf, sizeof(Buf), 1, fp0);

    fseek(fp0, 0 , SEEK_SET);

    strcpy(Buf, "Buf is NULL!");
    printf("BUF seek : %s\n", Buf);

    fread(Buf, sizeof(Buf), 1, fp0);
    printf("BUF read: %s\n", Buf);

    return 0;
}