如何在工作队列(linux，内核)中使用copy_to_user？

unsigned long copy_to_user(void __user *to, const void *from, unsigned long n);

#include <linux/module.h>
#include <linux/kernel.h>
#include #include <linux/workqueue.h>
#include <linux/slab.h>

// 定义一个工作队列
static struct workqueue_struct *my_workqueue;

// 定义一个工作结构体
struct my_work {
    struct work_struct work;
    char *data;
};

// 工作队列的处理函数
static void my_work_handler(struct work_struct *work) {
    struct my_work *my_work = container_of(work, struct my_work, work);
    char *data = my_work->data;
    int data_len = strlen(data) + 1;
    char *user_buffer = kmalloc(data_len, GFP_KERNEL);

    // 将数据复制到用户空间
    if (copy_to_user(user_buffer, data, data_len)) {
        printk(KERN_ERR "Failed to copy data to user space\n");
    } else {
        printk(KERN_INFO "Data copied to user space: %s\n", user_buffer);
    }

    kfree(user_buffer);
    kfree(my_work->data);
    kfree(my_work);
}

// 模块初始化函数
static int __init my_module_init(void) {
    struct my_work *my_work;

    // 创建工作队列
    my_workqueue = create_workqueue("my_workqueue");
    if (!my_workqueue) {
        printk(KERN_ERR "Failed to create workqueue\n");
        return -ENOMEM;
    }

    // 创建并初始化工作结构体
    my_work = kmalloc(sizeof(struct my_work), GFP_KERNEL);
    if (!my_work) {
        printk(KERN_ERR "Failed to allocate memory for work\n");
        destroy_workqueue(my_workqueue);
        return -ENOMEM;
    }
    INIT_WORK(&my_work->work, my_work_handler);
    my_work->data = kmalloc(20, GFP_KERNEL);
    strcpy(my_work->data, "Hello, world!");

    // 将工作添加到工作队列中
    queue_work(my_workqueue, &my_work->work);

    return 0;
}

// 模块退出函数
static void __exit my_module_exit(void) {
    // 销毁工作队列
    flush_workqueue(my_workqueue);
    destroy_workqueue(my_workqueue);
}

module_init(my_module_init);
module_exit(my_module_exit);