第三章驱动file_operations

3.1 字符设备驱动

在讨论file_operations的作用之前，我们先讨论Linux字符设备驱动。 Linux 字符驱动（Character Driver）允许用户通过字符设备文件与硬件进行交互。字符设备是一种按字节读写数据的设备，像键盘、串口、终端等，都属于字符设备。与之对应的是块设备（Block Device），如硬盘，它们按块（通常是512字节或更大）进行读写。

字符驱动就是告诉 Linux 内核，如何跟某个字符设备（比如键盘或串口）沟通。当应用程序需要与设备通信时，它会通过字符驱动来进行。例如，你输入一个字符，驱动程序会将这个信息转发给相应的设备，然后设备会执行相应的操作。

3.2 如何注册字符设备驱动

创建一个字符驱动代码文件fileop.c，内容如下：

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


MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linx Zhang");
MODULE_DESCRIPTION("A simple LKM without file operations");

#define DEVICE_NAME   "fopdev"
#define CLASS_NAME    "demo_fops_class"

static int major;                                // major device number
static struct class* demo_fops_class = NULL;     // device class structure
static struct cdev* demo_fops_device = NULL;     // character device structure

// Initialize the driver
static int __init fops_init(void) {
    dev_t dev_num;  // device number (major and minor)

    // 1. Allocate a device number
    if (alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME) < 0) {
        printk(KERN_ALERT "Failed to allocate major number\n");
        return -1;
    }
    major = MAJOR(dev_num);  // Get the major device number

    // 2. Create the device class
    demo_fops_class = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(demo_fops_class)) {
        unregister_chrdev_region(dev_num, 1);
        return PTR_ERR(demo_fops_class);
    }

    // 3. Allocate memory for the cdev structure and initialize it
    demo_fops_device = cdev_alloc();  // Allocate memory for the cdev structure
    if (!demo_fops_device) {
        class_destroy(demo_fops_class);
        unregister_chrdev_region(dev_num, 1);
        return -1;
    }
    
    cdev_init(demo_fops_device, NULL);  // Not using file_operations
    demo_fops_device->owner = THIS_MODULE;

    // 4. Add the character device to the system
    if (cdev_add(demo_fops_device, dev_num, 1) < 0) {
        kfree(demo_fops_device);  // Free allocated memory for cdev
        class_destroy(demo_fops_class);
        unregister_chrdev_region(dev_num, 1);
        return -1;
    }

    // 5. Create a device node in /dev
    if (device_create(demo_fops_class, NULL, dev_num, NULL, DEVICE_NAME) == NULL) {
        cdev_del(demo_fops_device);
        class_destroy(demo_fops_class);
        unregister_chrdev_region(dev_num, 1);
        return -1;
    }

    printk(KERN_INFO "Device registered with major number %d\n", major);
    return 0;
}

// Exit function to clean up the driver
static void __exit fops_exit(void) {
    dev_t dev_num = MKDEV(major, 0);

    device_destroy(demo_fops_class, dev_num);  // Remove the device node
    class_destroy(demo_fops_class);            // Remove the device class
    cdev_del(demo_fops_device);                // Unregister the character device
    unregister_chrdev_region(dev_num, 1);      // Release the device number

    kfree(demo_fops_device);                   // Free allocated memory for the cdev structure
    printk(KERN_INFO "Goodbye!\n");
}

module_init(fops_init);
module_exit(fops_exit);

1.）设备号分配

使用 alloc_chrdev_region() 分配一个动态的主设备号，并将其保存在 major 变量中。

2.）设备节点的创建

(1). 使用 `class_create()` 创建一个设备类。

class_create 函数用于动态创建设备的逻辑类，并完成部分字段的初始化，然后将其添加到 Linux 内核系统中。这个函数的执行效果是在 /sys/class 目录下创建一个新的文件夹，文件夹的名字为函数的第二个输入参数。

struct class *class_create(struct module *owner, const char *name);

• owner: 指向模块的指针，通常为 THIS_MODULE。

• name: 类的名称，用于在 /sys/class 下创建相应的目录。
上面驱动编译并加载驱动后，有如下：

neardi@LPA3588:~/fileop$ ls /sys/class/demo_fops_class/
fopdev

(2). device_create

device_create 函数用于动态创建逻辑设备，并对新的逻辑设备类进行相应的初始化，将其与指定的逻辑类关联起来，然后将此逻辑设备添加到 Linux 内核系统的设备驱动程序模型中。这个函数能够自动在 /sys/devices/virtual 目录下创建新的逻辑设备目录，并在 /dev 目录下创建与逻辑类对应的设备文件。

加载驱动后，在/dev有生成如下节点：

neardi@LPA3588:~/fileop$ ls /dev/fopdev  -l
crw------- 1 root root 234, 0 Oct 17 14:01 /dev/fopdev

上面的234, 0对应：

234：主设备号（Major Number）。主设备号用来标识设备驱动程序。主设备号 234 代表与该设备文件相关的驱动程序。设备驱动在注册时会分配或静态定义一个主设备号，内核通过该号将设备文件与相应的驱动关联。
0：次设备号（Minor Number）。次设备号用于区分由同一个驱动程序控制的不同设备。次设备号 0 表示这是该设备驱动的第一个实例，可能还有其他次设备号对应其他设备。

3.）字符设备的初始化和注册

使用 cdev_init() 初始化 cdev 结构体，将它与 file_operations 结构体关联。
使用 cdev_add() 将字符设备添加到系统中。

4.）模块加载与卸载

fops_init()：在加载模块时，分配设备号、初始化字符设备、创建设备节点。
fops_exit()：在卸载模块时，删除设备节点、注销字符设备、释放设备号。

3.2.1 测试驱动

编写一个test.cpp测试文件，内容与 3.7.1一致。编译及运行有如下结果：

neardi@LPA3588:~/fileop$ sudo ./test
Failed to open the device

这里可以看出，打开/dev/fopdev设备失败，就是因为fopdev.c驱动没有对file_operations的支持。

3.3 file_operations

在Linux设备驱动程序中，file_operations结构体是非常重要的，因为它定义了驱动程序如何处理文件操作。这些操作包括应用层打开、读取、写入和关闭设备文件。

file_operations结构体定义在kernel的linux/fs.h头文件里，主要内容如下：

static struct file_operations fops = {
    .open    = device_open,
    .read    = device_read,
    .write   = device_write,
    .release = device_release,
};

• open: 打开设备文件时调用。

• read: 从设备文件读取数据。

• write: 向设备文件写入数据。

• release: 关闭设备文件时调用。

3.4 为什么需要file_operations？

• 提供统一的接口

file_operations结构体为用户空间应用程序提供了一个统一的接口，使得它们可以通过标准的文件操作函数（如open、read、write和close）与设备进行交互。这种统一的接口简化了应用程序的开发，因为开发者不需要了解设备的具体实现细节。

• 管理设备访问

通过实现file_operations中的函数，驱动程序可以控制设备的访问权限。例如，可以在open函数中检查设备是否已经被其他进程打开，从而防止多个进程同时访问同一个设备，导致数据冲突或设备损坏。

• 数据传输

read和write函数允许用户空间应用程序与设备进行数据传输。read函数从设备读取数据并传输到用户空间，而write函数则将用户空间的数据写入设备。这些函数确保数据在用户空间和内核空间之间安全传输。

• 处理设备特定操作

不同的设备可能需要特定的操作，例如配置设备参数或处理中断。通过实现file_operations中的函数，驱动程序可以处理这些特定操作。例如，可以在ioctl函数中实现设备的配置操作。

• 资源管理

file_operations中的函数还可以用于管理设备的资源。例如，在release函数中，可以释放设备在open函数中分配的资源，确保系统资源得到有效管理，避免资源泄漏。

• 提高系统稳定性

通过实现file_operations中的函数，驱动程序可以处理错误情况并提供适当的错误信息。这有助于提高系统的稳定性和可靠性。例如，如果设备在读取过程中出现错误，read函数可以返回适当的错误代码，通知用户空间应用程序处理错误。

3.5 file_operations驱动代码

在第二章的基础上，添加file_operations的函数，如下：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/uaccess.h>  // for copy_to_user and copy_from_user

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Linx Zhang");
MODULE_DESCRIPTION("A simple LKM with file operations");

#define DEVICE_NAME   "fopdev"
#define CLASS_NAME    "demo_fops_class"
#define BUFFER_SIZE   1024  // Buffer size for read/write

static int major;                                // major device number
static struct class* demo_fops_class = NULL;     // device class structure
static struct cdev demo_fops_device;             // character device structure
static char device_buffer[BUFFER_SIZE] = {0};    // Buffer for data storage
static int open_count = 0;                       // Counter for how many times the device has been opened

// Prototype functions for file operations
static int dev_open(struct inode *, struct file *);
static int dev_release(struct inode *, struct file *);
static ssize_t dev_read(struct file *, char *, size_t, loff_t *);
static ssize_t dev_write(struct file *, const char *, size_t, loff_t *);

// Define file_operations structure
static struct file_operations fops = {
    .open = dev_open,
    .read = dev_read,
    .write = dev_write,
    .release = dev_release,
};

// Open function
static int dev_open(struct inode *inodep, struct file *filep) {
    open_count++;
    printk(KERN_INFO "fopdev: Device has been opened %d times\n", open_count);
    return 0;
}

// Release (close) function
static int dev_release(struct inode *inodep, struct file *filep) {
    printk(KERN_INFO "fopdev: Device successfully closed\n");
    return 0;
}

// Read function
static ssize_t dev_read(struct file *filep, char *buffer, size_t len, loff_t *offset) {
    int bytes_read = len < BUFFER_SIZE ? len : BUFFER_SIZE;

    if (copy_to_user(buffer, device_buffer, bytes_read) != 0) {
        return -EFAULT;
    }
    
    printk(KERN_INFO "fopdev: Sent %d characters to the user\n", bytes_read);
    return bytes_read;
}

// Write function
static ssize_t dev_write(struct file *filep, const char *buffer, size_t len, loff_t *offset) {
    int bytes_to_write = len < BUFFER_SIZE ? len : BUFFER_SIZE;

    if (copy_from_user(device_buffer, buffer, bytes_to_write) != 0) {
        return -EFAULT;
    }

    printk(KERN_INFO "fopdev: Received %zu characters from the user\n", len);
    return bytes_to_write;
}

// Initialize the driver
static int __init fops_init(void) {
    dev_t dev_num;  // device number (major and minor)

    // 1. Allocate a device number
    if (alloc_chrdev_region(&dev_num, 0, 1, DEVICE_NAME) < 0) {
        printk(KERN_ALERT "Failed to allocate major number\n");
        return -1;
    }
    major = MAJOR(dev_num);  // Get the major device number

    // 2. Create the device class
    demo_fops_class = class_create(THIS_MODULE, CLASS_NAME);
    if (IS_ERR(demo_fops_class)) {
        unregister_chrdev_region(dev_num, 1);
        return PTR_ERR(demo_fops_class);
    }

    // 3. Initialize and register the character device with file_operations
    cdev_init(&demo_fops_device, &fops);
    demo_fops_device.owner = THIS_MODULE;

    // 4. Add the character device to the system
    if (cdev_add(&demo_fops_device, dev_num, 1) < 0) {
        class_destroy(demo_fops_class);
        unregister_chrdev_region(dev_num, 1);
        return -1;
    }

    // 5. Create a device node in /dev
    if (device_create(demo_fops_class, NULL, dev_num, NULL, DEVICE_NAME) == NULL) {
        cdev_del(&demo_fops_device);
        class_destroy(demo_fops_class);
        unregister_chrdev_region(dev_num, 1);
        return -1;
    }

    printk(KERN_INFO "fopdev: Device registered with major number %d\n", major);
    return 0;
}

// Exit function to clean up the driver
static void __exit fops_exit(void) {
    dev_t dev_num = MKDEV(major, 0);

    device_destroy(demo_fops_class, dev_num);  // Remove the device node
    class_destroy(demo_fops_class);            // Remove the device class
    cdev_del(&demo_fops_device);               // Unregister the character device
    unregister_chrdev_region(dev_num, 1);      // Release the device number

    printk(KERN_INFO "fopdev: Goodbye!\n");
}

module_init(fops_init);
module_exit(fops_exit);

3.6 编译及加载驱动

3.6.1 Makefile

Makefile与第二章里的2.4节一样，在此不再赘述。

3.6.2 编译

neardi@LPA3588:~/fileop$ make
make -C /lib/modules/5.10.110/build M=/home/neardi/fileop modules
make[1]: Entering directory '/usr/src/linux-headers-5.10.110'
  CC [M]  /home/neardi/fileop/fileop.o
  MODPOST /home/neardi/fileop/Module.symvers
  CC [M]  /home/neardi/fileop/fileop.mod.o
  LD [M]  /home/neardi/fileop/fileop.ko
make[1]: Leaving directory '/usr/src/linux-headers-5.10.110'

3.6.3 加载驱动

neardi@LPA3588:~/fileop$ sudo insmod fileop.ko
neardi@LPA3588:~/fileop$ dmesg
[20686.519675] fopdev: Device registered with major number 234
neardi@LPA3588:~/fileop$

驱动加载成功后，在/dev/下面有如下节点：

可以看出，此设备的主设备号及次设备号分别是： 234和0.

3.7 测试驱动

接下来设计一个应用程序来测试驱动file_operations里的函数： open/read/write/relase。

3.7.1 APP测试代码

新建一个test.cpp文件，内容如下：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>

#define DEVICE_PATH "/dev/fopdev"
#define BUFFER_SIZE 1024

int main() {
    int fd;
    char write_buf[BUFFER_SIZE] = "Hello, Kernel!";
    char read_buf[BUFFER_SIZE];

    // open this device
    fd = open(DEVICE_PATH, O_RDWR);
    if (fd < 0) {
	std::cout << "Failed to open the device" << std::endl;
	return EXIT_FAILURE;
    }

    // write data to device
    if (write(fd, write_buf, strlen(write_buf)) < 0) {
	std::cout << "Failed to write to the device" << std::endl;
	close(fd);
	return EXIT_FAILURE;
    }

    // read data from device
    if (read(fd, read_buf, BUFFER_SIZE) < 0) {
	std::cout << "Failed to read from the device" << std::endl;
	close(fd);
	return EXIT_FAILURE;
    }

    std::cout << "Read from device: " << read_buf << std::endl;

    // close the device
    close(fd);
    return EXIT_SUCCESS;
}

此处open、read、write及close都是Linux系统里标准的API。

3.7.2 编译APP

在test.cpp相同的路径，确保安装了gcc(sudo apt install build-essential), 执行如下命令：

neardi@LPA3588:~/fileop$ aarch64-linux-gnu-g++ -o test test.cpp
neardi@LPA3588:~/fileop$ ls test -lh
-rwxrwxr-x 1 neardi neardi 15K Oct 17 15:03 test

上面也就编译成功，并生成了test测试程序。

3.7.3 运行APP

直接在命令行执行即可，如下：

neardi@LPA3588:~/fileop$ sudo ./test
Read from device: Hello, Kernel!
neardi@LPA3588:~/fileop$ dmesg
[20686.519675] fopdev: Device registered with major number 234
[21942.935538] fopdev: Device has been opened 1 times
[21942.935561] fopdev: Received 14 characters from the user
[21942.935572] fopdev: Sent 1024 characters to the user
[21942.935728] fopdev: Device successfully closed

3.8 卸载驱动

执行sudo rmmod fileop 即可卸载驱动, 如下：

neardi@LPA3588:~/fileop$ lsmod
Module                  Size  Used by
fileop                 16384  0
neardi@LPA3588:~/fileop$ sudo rmmod fileop
neardi@LPA3588:~/fileop$ dmesg
[20686.519675] fopdev: Device registered with major number 234
[21942.935538] fopdev: Device has been opened 1 times
[21942.935561] fopdev: Received 14 characters from the user
[21942.935572] fopdev: Sent 1024 characters to the user
[21942.935728] fopdev: Device successfully closed
[21998.556572] fopdev: Goodbye!

3.9 APP调用驱动的流程

3.9.1 应用层调用系统调用

在用户空间，应用程序通过系统调用与设备文件进行交互。最常用的系统调用包括：

open("/dev/xxx", O_RDWR)：打开设备文件。
read(fd, buf, count)：从设备读取数据。
write(fd, buf, count)：向设备写入数据。
ioctl(fd, command, arg)：对设备进行控制操作。

这些系统调用通过系统调用接口进入内核空间。

3.9.2 系统调用syscall进入内核

当应用程序调用 open, read, write 等系统调用时，控制权从用户态切换到内核态，进入 Linux 内核。具体步骤如下：

1.）中断（软件中断陷入）

每个系统调用都有一个系统调用号（syscall number）。当应用程序调用系统调用时，会通过 syscall 指令或 SVC 指令（在 ARM64 上）触发中断，并将控制权交给内核。

2.）系统调用入口函数

内核根据系统调用号查找系统调用表（ sys_call_table[]，在kernel代码arch/arm64/kernel/syscall.c）。例如，如果是 open 系统调用，它会调用内核中的 sys_open 函数。

3.） VFS（虚拟文件系统）层

sys_open 函数进入虚拟文件系统（VFS）层，VFS 是内核中的一个抽象层，用于处理不同文件系统的调用。VFS 查找与设备文件 /dev/xxx 对应的 inode 节点。

4.）设备文件和驱动程序绑定

VFS 会根据设备文件的主设备号（major number）找到与设备相关的驱动程序。主设备号由设备驱动注册时决定，使用函数如 register_chrdev() 来注册字符设备驱动（内核有设备与驱动对应表来保存）。找到相应驱动后，VFS 会调用与设备关联的 file_operations 结构体

3.9.3 驱动的注册与查找

在编写驱动时，通常需要通过 register_chrdev() 或 misc_register() 函数注册设备驱动，并指定主设备号。如果是动态分配主设备号，驱动程序会使用 alloc_chrdev_region() 来分配。

设备号：设备文件 /dev/xxx 的主设备号决定了内核如何找到对应的驱动程序。每个驱动都有一个唯一的主设备号。
驱动与设备的绑定：通过设备树（Device Tree）或 ACPI 表格，内核可以自动将驱动与硬件设备进行绑定，尤其是在嵌入式系统或 ARM64 平台上。这些配置文件告诉内核设备的物理地址、IRQ 等资源信息。

3.9.4 驱动的 file_operations 结构体

设备驱动通过实现 file_operations 结构体中的函数来响应应用层的调用。

当应用程序调用 open("/dev/xxx")，内核通过 sys_open 和 VFS，最终调用 file_operations 中的 open 函数。
类似的，read(fd) 对应 file_operations 中的 read 函数，write(fd) 对应 write 函数，ioctl(fd) 对应 unlocked_ioctl 函数。

3.9.5 驱动返回调用结果

驱动程序处理完请求后，将结果返回给内核，内核再将结果返回给用户空间的应用程序。

3.10 小结

在本章节中，我们扩展了Hello World驱动程序，添加了基本的文件操作功能。通过这些操作，应用程序可以与驱动程序进行交互，读取和写入数据。