V4l2loopback实现笔记（二）:字符设备交互

/* Function prototypes */
static int v4l2_char_open(struct inode *, struct file *);
static int v4l2_char_release(struct inode *, struct file *);
static ssize_t v4l2_char_read(struct file *, char *, size_t, loff_t *);
static ssize_t v4l2_char_write(struct file *, const char *, size_t, loff_t *);

/* File operations structure */
static struct file_operations fops = {
    .open = v4l2_char_open,
    .read = v4l2_char_read,
    .write = v4l2_char_write,
    .release = v4l2_char_release,
};

major_number = register_chrdev(0, DEVICE_NAME, &fops);

static int v4l2_char_open(struct inode *inodep, struct file *filep)
{
    struct v4l2_char_private_data *private_data;

    /* Increment open count */
    open_count++;
    printk(KERN_INFO "v4l2char: Device opened %d time(s)\n", open_count);

    /* Allocate private data for this file descriptor */
    private_data = kmalloc(sizeof(struct v4l2_char_private_data), GFP_KERNEL);
    if (!private_data) {
        printk(KERN_ERR "v4l2char: Failed to allocate private data\n");
        return -ENOMEM;
    }

    /* Allocate buffer for this instance */
    private_data->buffer = kmalloc(buffer_size, GFP_KERNEL);
    if (!private_data->buffer) {
        printk(KERN_ERR "v4l2char: Failed to allocate buffer\n");
        kfree(private_data);
        return -ENOMEM;
    }

    private_data->buffer_size = buffer_size;
    private_data->data_length = 0;

    /* Store private data in file pointer */
    filep->private_data = private_data;

    return 0;
}

/* Release function */
static int v4l2_char_release(struct inode *inodep, struct file *filep)
{
    struct v4l2_char_private_data *private_data = (struct v4l2_char_private_data *)filep->private_data;

    /* Free the allocated buffer and private data */
    if (private_data) {
        if (private_data->buffer) {
            kfree(private_data->buffer);
        }
        kfree(private_data);
    }

    open_count--;
    printk(KERN_INFO "v4l2char: Device closed, %d user(s) still connected\n", open_count);
    return 0;
}

static ssize_t v4l2_char_read(struct file *filep, char *buffer, size_t len, loff_t *offset)
{
    struct v4l2_char_private_data *private_data = (struct v4l2_char_private_data *)filep->private_data;
    int bytes_to_read;
    int error_count = 0;

    /* Acquire mutex for synchronized access */
    if (mutex_lock_interruptible(&buffer_mutex)) {
        return -ERESTARTSYS;
    }

    /* Determine how many bytes to read */
    bytes_to_read = private_data->data_length - *offset;
    if (bytes_to_read <= 0) {
        mutex_unlock(&buffer_mutex);
        return 0;  // End of file
    }
    if (bytes_to_read > len) {
        bytes_to_read = len;
    }

    /* Copy data to user space */
    error_count = copy_to_user(buffer, &(private_data->buffer[*offset]), bytes_to_read);

    mutex_unlock(&buffer_mutex);

    if (error_count == 0) {
        *offset += bytes_to_read;
        printk(KERN_INFO "v4l2char: Sent %d characters to user\n", bytes_to_read);
        return bytes_to_read;
    } else {
        printk(KERN_ERR "v4l2char: Failed to send %d characters to user\n", error_count);
        return -EFAULT;  // Error sending data to user
    }
}

static ssize_t v4l2_char_write(struct file *filep, const char *buffer, size_t len, loff_t *offset)
{
    struct v4l2_char_private_data *private_data = (struct v4l2_char_private_data *)filep->private_data;
    int space_left;
    int error_count = 0;

    /* Acquire mutex for synchronized access */
    if (mutex_lock_interruptible(&buffer_mutex)) {
        return -ERESTARTSYS;
    }

    /* Calculate available space */
    space_left = private_data->buffer_size - private_data->data_length;

    if (space_left <= 0) {
        mutex_unlock(&buffer_mutex);
        return -ENOSPC;  // No space left
    }

    /* Limit write to available space */
    if (len > space_left) {
        len = space_left;
    }

    /* Copy data from user space */
    error_count = copy_from_user(&(private_data->buffer[private_data->data_length]), buffer, len);

    if (error_count == 0) {
        private_data->data_length += len;
        mutex_unlock(&buffer_mutex);
        printk(KERN_INFO "v4l2char: Received %zu characters from user\n", len);
        return len;
    } else {
        mutex_unlock(&buffer_mutex);
        printk(KERN_ERR "v4l2char: Failed to receive %d characters from user\n", error_count);
        return -EFAULT;  // Error getting data from user
    }
}

/*
 * test_char_device.c - 字符设备测试程序
 */
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <time.h>

#define DEVICE_PATH "/dev/v4l2char"

int main() {
    int fd;
    char write_msg[256];
    char read_buffer[256];
    int ret;

    printf("Testing character device: %s\n", DEVICE_PATH);

    // 1. 打开设备：触发内核中的 v4l2_char_open
    fd = open(DEVICE_PATH, O_RDWR);
    if (fd < 0) {
        perror("Failed to open device");
        return -1;
    }
    printf("Device opened successfully\n");

    // 2. 写入数据：触发 v4l2_char_write
    // 我们在消息中加入时间戳，以便区分多次运行的结果
    snprintf(write_msg, sizeof(write_msg), "Hello from userspace! Timestamp: %ld", time(NULL));
    ret = write(fd, write_msg, strlen(write_msg));
    if (ret < 0) {
        perror("Failed to write to device");
        close(fd);
        return -1;
    }
    printf("Wrote %d bytes: %s\n", ret, write_msg);

    // 3. 重置偏移量：为了能从头读取刚才写入的内容
    // 这一步会改变 filep->f_pos，影响 read 函数中的 offset 参数
    lseek(fd, 0, SEEK_SET);

    // 4. 读取数据：触发 v4l2_char_read
    memset(read_buffer, 0, sizeof(read_buffer));
    ret = read(fd, read_buffer, sizeof(read_buffer) - 1);
    if (ret < 0) {
        perror("Failed to read from device");
        close(fd);
        return -1;
    }
    printf("Read %d bytes: %s\n", ret, read_buffer);

    // 5. 关闭设备：触发 v4l2_char_release
    close(fd);
    printf("Device closed\n");

    return 0;
}