3. 实现Camera设备的基本打开与释放

任务说明

本案例实现Camera设备驱动的打开与释放接口，核心目标是：在camera_open中完成设备引用计数递增与资源分配，在camera_release中完成引用计数递减与资源释放，并保证多进程打开时资源管理的正确性。

核心实现

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

#define CAMERA_DEVICE_NAME "camera_dev"
#define CAMERA_CLASS_NAME  "camera_class"

struct camera_device {
    struct cdev cdev;
    struct device *dev;
    struct mutex lock;
    void *buffer;
    size_t buffer_size;
    int users;
};

static dev_t camera_dev_num;
static struct class *camera_class;
static struct camera_device *camera_dev;

static int camera_open(struct inode *inode, struct file *filp)
{
    struct camera_device *cam = container_of(inode->i_cdev,
                                             struct camera_device, cdev);
    int ret = 0;

    mutex_lock(&cam->lock);
    if (cam->users == 0) {
        /* 首次打开：分配资源 */
        cam->buffer_size = 4096;
        cam->buffer = kzalloc(cam->buffer_size, GFP_KERNEL);
        if (!cam->buffer) {
            ret = -ENOMEM;
            goto unlock;
        }
    }
    cam->users++;
    filp->private_data = cam;
    dev_info(cam->dev, "camera opened, users=%d\n", cam->users);

unlock:
    mutex_unlock(&cam->lock);
    return ret;
}

static int camera_release(struct inode *inode, struct file *filp)
{
    struct camera_device *cam = filp->private_data;

    mutex_lock(&cam->lock);
    cam->users--;
    if (cam->users == 0) {
        /* 最后一个用户关闭：释放资源 */
        kfree(cam->buffer);
        cam->buffer = NULL;
        cam->buffer_size = 0;
        dev_info(cam->dev, "camera released, resources freed\n");
    } else {
        dev_info(cam->dev, "camera released, users=%d\n", cam->users);
    }
    mutex_unlock(&cam->lock);
    return 0;
}

static const struct file_operations camera_fops = {
    .owner   = THIS_MODULE,
    .open    = camera_open,
    .release = camera_release,
};

static int __init camera_init(void)
{
    int ret;

    ret = alloc_chrdev_region(&camera_dev_num, 0, 1, CAMERA_DEVICE_NAME);
    if (ret < 0)
        return ret;

    camera_dev = kzalloc(sizeof(*camera_dev), GFP_KERNEL);
    if (!camera_dev) {
        ret = -ENOMEM;
        goto err_unregister_region;
    }

    mutex_init(&camera_dev->lock);
    cdev_init(&camera_dev->cdev, &camera_fops);
    camera_dev->cdev.owner = THIS_MODULE;

    ret = cdev_add(&camera_dev->cdev, camera_dev_num, 1);
    if (ret < 0)
        goto err_free_camera;

    camera_class = class_create(THIS_MODULE, CAMERA_CLASS_NAME);
    if (IS_ERR(camera_class)) {
        ret = PTR_ERR(camera_class);
        goto err_cdev_del;
    }

    camera_dev->dev = device_create(camera_class, NULL, camera_dev_num,
                                    NULL, CAMERA_DEVICE_NAME);
    if (IS_ERR(camera_dev->dev)) {
        ret = PTR_ERR(camera_dev->dev);
        goto err_class_destroy;
    }

    pr_info("camera driver initialized\n");
    return 0;

err_class_destroy:
    class_destroy(camera_class);
err_cdev_del:
    cdev_del(&camera_dev->cdev);
err_free_camera:
    kfree(camera_dev);
err_unregister_region:
    unregister_chrdev_region(camera_dev_num, 1);
    return ret;
}

static void __exit camera_exit(void)
{
    device_destroy(camera_class, camera_dev_num);
    class_destroy(camera_class);
    cdev_del(&camera_dev->cdev);
    kfree(camera_dev);
    unregister_chrdev_region(camera_dev_num, 1);
    pr_info("camera driver removed\n");
}

module_init(camera_init);
module_exit(camera_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Kernel Camera Course");
MODULE_DESCRIPTION("Camera device open/release with refcount and resource management");

编译与加载

# Makefile（与上述源码同目录）
obj-m := camera.o
KDIR := /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)

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

make
sudo insmod camera.ko
sudo chmod 666 /dev/camera_dev   # 便于普通用户测试

验证方法

使用以下用户态程序验证引用计数与资源释放逻辑：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    int fd1, fd2;

    fd1 = open("/dev/camera_dev", O_RDWR);
    if (fd1 < 0) { perror("open fd1"); return 1; }
    printf("fd1 opened\n");

    fd2 = open("/dev/camera_dev", O_RDWR);
    if (fd2 < 0) { perror("open fd2"); return 1; }
    printf("fd2 opened\n");

    close(fd1);
    printf("fd1 closed\n");

    /* 此时驱动日志应显示 users=1，资源未释放 */
    close(fd2);
    printf("fd2 closed\n");
    /* 此时驱动日志应显示 users=0，资源已释放 */

    return 0;
}

编译运行：gcc test.c -o test && ./test，同时用dmesg | tail观察内核日志。

通过条件

• insmod后/dev/camera_dev节点存在，无错误日志；
• 连续两次open成功，内核日志依次显示users=1、users=2；
• 关闭第一个fd后日志显示users=1，且无资源释放信息；
• 关闭第二个fd后日志显示users=0, resources freed；
• rmmod camera正常卸载，无内存泄漏警告。

关键说明

• 引用计数由users字段维护，mutex保证并发打开/关闭时的原子性；
• 资源分配仅在首次打开（users从0变为1）时执行，释放仅在最后一次关闭（users降为0）时执行，避免多进程共享时的重复分配与提前释放；
• 本案例聚焦open/release路径，未实现read/write等数据操作，属于最小可复现的驱动框架。