linux驱动开发，file.private_data

在Linux内核中，设备驱动开发经常需要处理与设备相关的私有数据。file.private_data 是 Linux 内核中用于存储与文件描述符（file descriptor）相关的私有数据的机制之一。然而，更常见和推荐的方法是使用设备特定的结构体来存储私有数据，并将其与设备实例关联起来，而不是直接使用 file.private_data。

以下是一些关键点以及如何在设备驱动中使用私有数据的示例：

file.private_data 的基本用法

file 结构体代表一个打开的文件，而 private_data 是其成员之一，可以用来存储与该文件相关的私有数据。这个成员是一个 void* 类型的指针，可以指向任何数据。

在驱动的 open 函数中，你可以将私有数据指针赋值给 file->private_data，如下所示：

static int my_driver_open(struct inode *inode, struct file *file)  
{  
    struct my_device *device = &my_device_instance; // 假设这是你的设备实例  
    file->private_data = device;  
    // 其他初始化代码  
    return 0;  
}

然后在其他文件操作中，你可以通过 file->private_data 来访问这个私有数据：

static ssize_t my_driver_read(struct file *file, char __user *buf, size_t len, loff_t *offset)  
{  
    struct my_device *device = file->private_data;  
    // 使用 device 进行读取操作  
    return len; // 这是一个简化的例子  
}

推荐的实践：使用设备特定结构体

虽然可以直接使用 file.private_data，但更推荐的做法是定义一个设备特定的结构体，并将所有与设备相关的信息存储在这个结构体中。然后在 open 函数中将这个结构体与 file->private_data 关联起来。

struct my_device {  
    struct cdev cdev; // 字符设备结构体  
    // 其他设备相关的成员  
};  
  
static int my_driver_open(struct inode *inode, struct file *file)  
{  
    struct my_device *device = container_of(inode->i_cdev, struct my_device, cdev);  
    file->private_data = device;  
    // 其他初始化代码  
    return 0;  
}  
  
static ssize_t my_driver_read(struct file *file, char __user *buf, size_t len, loff_t *offset)  
{  
    struct my_device *device = file->private_data;  
    // 使用 device 进行读取操作  
    return len; // 这是一个简化的例子  
}

完整示例

以下是一个简单的字符设备驱动示例，展示了如何使用 file.private_data 来存储和访问设备私有数据：

#include <linux/module.h>  
#include <linux/kernel.h>  
#include <linux/fs.h>  
#include <linux/uaccess.h>  
#include <linux/cdev.h>  
#include <linux/slab.h>  
  
struct my_device {  
    struct cdev cdev;  
    char msg[100];  
    // 其他成员  
};  
  
static dev_t my_dev_number;  
static struct my_device *my_device_instance;  
  
static int my_driver_open(struct inode *inode, struct file *file)  
{  
    my_device_instance = container_of(inode->i_cdev, struct my_device, cdev);  
    file->private_data = my_device_instance;  
    printk(KERN_INFO "my_driver_open called\n");  
    return 0;  
}  
  
static int my_driver_release(struct inode *inode, struct file *file)  
{  
    printk(KERN_INFO "my_driver_release called\n");  
    return 0;  
}  
  
static ssize_t my_driver_read(struct file *file, char __user *buf, size_t len, loff_t *offset)  
{  
    struct my_device *device = file->private_data;  
    static int finished = 0;  
    if (finished) {  
        printk(KERN_INFO "Read: END\n");  
        return 0;  
    }  
  
    finished = 1;  
    copy_to_user(buf, device->msg, strlen(device->msg));  
    printk(KERN_INFO "Read: %s\n", device->msg);  
    return strlen(device->msg);  
}  
  
static const struct file_operations my_driver_fops = {  
    .owner = THIS_MODULE,  
    .open = my_driver_open,  
    .release = my_driver_release,  
    .read = my_driver_read,  
};  
  
static int __init my_driver_init(void)  
{  
    my_dev_number = MKDEV(240, 0); // 主设备号240，次设备号0  
    register_chrdev_region(my_dev_number, 1, "my_driver");  
  
    my_device_instance = kmalloc(sizeof(struct my_device), GFP_KERNEL);  
    if (!my_device_instance) {  
        return -ENOMEM;  
    }  
  
    cdev_init(&my_device_instance->cdev, &my_driver_fops);  
    my_device_instance->cdev.owner = THIS_MODULE;  
    cdev_add(&my_device_instance->cdev, my_dev_number, 1);  
  
    strcpy(my_device_instance->msg, "Hello, World!");  
      
    printk(KERN_INFO "my_driver_init called\n");  
    return 0;  
}  
  
static void __exit my_driver_exit(void)  
{  
    cdev_del(&my_device_instance->cdev);  
    kfree(my_device_instance);  
    unregister_chrdev_region(my_dev_number, 1);  
    printk(KERN_INFO "my_driver_exit called\n");  
}  
  
module_init(my_driver_init);  
module_exit(my_driver_exit);  
  
MODULE_LICENSE("GPL");  
MODULE_AUTHOR("Your Name");  
MODULE_DESCRIPTION("Simple Character Device Driver");

这个示例展示了如何分配和初始化设备结构体，将其与 file->private_data 关联，并在文件操作中访问这个私有数据。