如何识别字符驱动客户端？Linux带标签MUX驱动开发疑问

我正在编写一款实现“带标签MUX”功能的Linux字符驱动，用于向特殊硬件链路写入数据，但遇到了关键概念问题。

用户通过open打开设备，使用ioctl设置与数据类型关联的ID，此后写入对应文件描述符的数据会被加上该ID前缀，按硬件链路要求格式化后发送。多用户可来自同一用户态进程或不同进程，例如单进程场景：

int alarmFd = open("/dev/tagmux", O_WRONLY);
ioctl(alarmFd, SET_ID, 123);

int dataFd = open("/dev/tagmux", O_WRONLY);
ioctl(dataFd, SET_ID, 456);

void onAlarm()
{
  data = // 告警相关的特定二进制数据...
  write(alarmFd, data, dataLen);
}

void onMeas()
{
  data = // 测量相关的特定二进制数据...
  write(dataFd, data, dataLen);
}

在以下驱动代码框架中，我无法区分不同客户端：写入alarmFd的数据需将hwSetFrameId设为"123"，写入dataFd的数据需设为"456"。该如何实现？

const struct file_operations muxFops =
{
    .owner = THIS_MODULE,
    .open = muxOpen,
    .read = NULL,
    .write = muxWrite,
    .release = muxRelease,
    .unlocked_ioctl = muxIoctl
};

void muxOpen(struct inode *pInode, struct file *pFile)
{
  // 将该客户端记录到列表中
}

static long muxIoctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
    uint32_t __user *userPtr = (uint32_t __user *) arg;

    switch (cmd)
    {
    case MUX_SET_ID:
        result = get_user(tagValue, userPtr);
        clientId = // 在此处获取客户端ID
        tagList[clientId] = tagValue;
    }
}

static ssize_t
muxWrite(struct file *file, const char  __user *buf, size_t nBytes, loff_t *ppos)
{
    clientId = // 在此处获取客户端ID
    tagValue = tagList[clientId];
    hwSetFrameId(tagValue);
    hwSetFrameData(buf, nBytes);
    hwTriggerTx();
}

解决方案 #

Linux字符驱动中，每个open调用都会生成独立的struct file实例，直接利用该结构体的private_data字段存储每个客户端的标签ID即可，无需额外维护tagList和clientId，具体实现如下：

1. 定义客户端上下文结构体 #

创建结构体存储每个客户端的专属数据：

struct mux_client {
    uint32_t tag_id; // 存储当前客户端的标签ID
    // 若需其他关联数据，可在此扩展
};

2. 在open中初始化上下文 #

每次打开设备时，分配并绑定客户端上下文到struct file：

int muxOpen(struct inode *pInode, struct file *pFile)
{
    struct mux_client *client = kmalloc(sizeof(struct mux_client), GFP_KERNEL);
    if (!client)
        return -ENOMEM;
    
    client->tag_id = 0; // 初始化默认值，可根据需求调整
    pFile->private_data = client;
    return 0;
}

3. 在ioctl中设置标签ID #

通过filep->private_data直接获取当前客户端上下文，写入用户设置的ID：

static long muxIoctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
    int result;
    uint32_t tagValue;
    struct mux_client *client = filep->private_data;

    if (cmd != MUX_SET_ID)
        return -ENOTTY;

    result = get_user(tagValue, (uint32_t __user *)arg);
    if (result)
        return result;

    client->tag_id = tagValue;
    return 0;
}

4. 在write中获取标签ID并发送数据 #

从file->private_data拿到当前客户端的标签ID，完成硬件帧设置与发送：

static ssize_t muxWrite(struct file *file, const char __user *buf, size_t nBytes, loff_t *ppos)
{
    struct mux_client *client = file->private_data;
    char *kernel_buf;

    // 可选：校验标签ID是否已设置
    if (client->tag_id == 0)
        return -EINVAL;

    // 拷贝用户数据到内核空间（必须操作，避免直接访问用户态内存）
    kernel_buf = kmalloc(nBytes, GFP_KERNEL);
    if (!kernel_buf)
        return -ENOMEM;
    if (copy_from_user(kernel_buf, buf, nBytes)) {
        kfree(kernel_buf);
        return -EFAULT;
    }

    // 硬件操作
    hwSetFrameId(client->tag_id);
    hwSetFrameData(kernel_buf, nBytes);
    hwTriggerTx();

    kfree(kernel_buf);
    return nBytes;
}

5. 在release中释放资源 #

设备关闭时，回收之前分配的客户端上下文：

int muxRelease(struct inode *pInode, struct file *pFile)
{
    struct mux_client *client = pFile->private_data;
    kfree(client);
    pFile->private_data = NULL;
    return 0;
}

关键说明 #

• 每个open对应独立的struct file实例，因此private_data可以安全区分不同客户端，无论是否来自同一进程。
• 必须通过copy_from_user完成用户态到内核态的数据拷贝，直接访问用户态内存会引发内核错误。
• 可根据需求添加标签ID的合法性校验，比如限制ID范围或禁止默认值。

内容的提问来源于stack exchange，提问作者Danny