杂项设备与虚拟设备：简化驱动开发的神器

关注

原创最新推荐文章于 2026-11-07 23:06:45 发布 69 阅读 AI 写同款· GEO 优化 ›

Linux Swap 子系统：架构、内存管理与虚拟化 Swap Linux Swap机制通过将不活跃内存页移至磁盘或压缩内存，扩展系统有效内存容量，缓解内存压力。传统架构中，逻辑Swap槽与物理存储绑定，导致资源浪费，尤其在使用Zswap等压缩技术时。为此，Vswap与Xswap提出虚拟化方案：前者以XArray实现灵活映射，支持多后端迁移；后者采用稀疏映射，简化管理但容量固定。二者在架构设计、资源记账与动态扩展上各有权衡，反映了内核开发中对性能、可维护性与灵活性的深层考量。阅读详情

一、顶级架构一句话总结

misc设备(简化字符设备) + 虚拟设备(无硬件依赖) = 快速原型开发

杂项设备简化了字符设备的注册流程，虚拟设备则无需真实硬件支持。

二、杂项设备(miscdevice)

什么是杂项设备？

┌─────────────────────────────────────────────────────────┐
│                 杂项设备特点                             │
├─────────────────────────────────────────────────────────┤
│  1. 主设备号固定为10，自动分配次设备号                   │
│  2. 简化注册流程，无需手动创建cdev                       │
│  3. 自动创建设备节点                                     │
│  4. 适合简单字符设备                                     │
└─────────────────────────────────────────────────────────┘

miscdevice结构

struct miscdevice {
    int minor;                              // 次设备号
    const char *name;                       // 设备名称
    const struct file_operations *fops;     // 文件操作
    struct list_head list;
    struct device *parent;
    struct device *this_device;
    const struct attribute_group **groups;
    const char *nodename;
    umode_t mode;
};

// 预定义的次设备号
#define MISC_DYNAMIC_MINOR  255  // 动态分配
#define PSMOUSE_MINOR       1    // PS/2鼠标
#define MS_BUSMOUSE_MINOR   2    // 总线鼠标
#define ATIXL_BUSMOUSE_MINOR 3   // ATI总线鼠标
#define WATCHDOG_MINOR      130  // 看门狗
#define TEMP_MINOR          131  // 温度传感器

API函数

#include <linux/miscdevice.h>

// 注册杂项设备
int misc_register(struct miscdevice *misc);

// 注销杂项设备
void misc_deregister(struct miscdevice *misc);

完整示例：简单LED控制

#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/gpio/consumer.h>

struct led_misc_data {
    struct miscdevice misc;
    struct gpio_desc *led_gpio;
};

static int led_open(struct inode *inode, struct file *file)
{
    struct led_misc_data *data = container_of(file->private_data, struct led_misc_data, misc);
    file->private_data = data;
    return 0;
}

static ssize_t led_write(struct file *file, const char __user *buf,
                         size_t count, loff_t *ppos)
{
    struct led_misc_data *data = file->private_data;
    char kbuf[2];

    if (count > 2)
        count = 2;

    if (copy_from_user(kbuf, buf, count))
        return -EFAULT;

    // 控制LED
    if (kbuf[0] == '0')
        gpiod_set_value(data->led_gpio, 0);
    else if (kbuf[0] == '1')
        gpiod_set_value(data->led_gpio, 1);

    return count;
}

static ssize_t led_read(struct file *file, char __user *buf,
                        size_t count, loff_t *ppos)
{
    struct led_misc_data *data = file->private_data;
    char state;

    state = gpiod_get_value(data->led_gpio) ? '1' : '0';

    if (copy_to_user(buf, &state, 1))
        return -EFAULT;

    return 1;
}

static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct led_misc_data *data = file->private_data;

    switch (cmd) {
    case 0:
        gpiod_set_value(data->led_gpio, 0);
        break;
    case 1:
        gpiod_set_value(data->led_gpio, 1);
        break;
    case 2:
        gpiod_set_value(data->led_gpio, !gpiod_get_value(data->led_gpio));
        break;
    default:
        return -EINVAL;
    }

    return 0;
}

static const struct file_operations led_fops = {
    .owner = THIS_MODULE,
    .open = led_open,
    .read = led_read,
    .write = led_write,
    .unlocked_ioctl = led_ioctl,
};

static struct led_misc_data led_data = {
    .misc = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = "myled",
        .fops = &led_fops,
        .mode = 0666,
    },
};

static int __init led_init(void)
{
    int ret;

    // 获取GPIO
    led_data.led_gpio = gpiod_get(NULL, "led", GPIOD_OUT_LOW);
    if (IS_ERR(led_data.led_gpio))
        return PTR_ERR(led_data.led_gpio);

    // 注册杂项设备
    ret = misc_register(&led_data.misc);
    if (ret) {
        gpiod_put(led_data.led_gpio);
        return ret;
    }

    pr_info("LED misc device registered: /dev/%s\n", led_data.misc.name);
    return 0;
}

static void __exit led_exit(void)
{
    misc_deregister(&led_data.misc);
    gpiod_put(led_data.led_gpio);
    pr_info("LED misc device unregistered\n");
}

module_init(led_init);
module_exit(led_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Driver Developer");

三、虚拟设备示例

虚拟串口

#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/slab.h>

#define BUFFER_SIZE 4096

struct virtual_serial_data {
    struct miscdevice misc;
    char *buffer;
    int read_pos;
    int write_pos;
    struct mutex lock;
    wait_queue_head_t read_queue;
};

static int virtual_serial_open(struct inode *inode, struct file *file)
{
    struct virtual_serial_data *data = container_of(file->private_data, struct virtual_serial_data, misc);
    file->private_data = data;
    return 0;
}

static ssize_t virtual_serial_read(struct file *file, char __user *buf,
                                   size_t count, loff_t *ppos)
{
    struct virtual_serial_data *data = file->private_data;
    int available, ret;

    if (file->f_flags & O_NONBLOCK) {
        if (mutex_trylock(&data->lock) == 0)
            return -EAGAIN;
    } else {
        if (mutex_lock_interruptible(&data->lock))
            return -ERESTARTSYS;
    }

    while (data->read_pos == data->write_pos) {
        mutex_unlock(&data->lock);

        if (file->f_flags & O_NONBLOCK)
            return -EAGAIN;

        if (wait_event_interruptible(data->read_queue, data->read_pos != data->write_pos))
            return -ERESTARTSYS;

        if (mutex_lock_interruptible(&data->lock))
            return -ERESTARTSYS;
    }

    available = (data->write_pos - data->read_pos + BUFFER_SIZE) % BUFFER_SIZE;
    if (count > available)
        count = available;

    if (data->read_pos + count > BUFFER_SIZE) {
        int first_part = BUFFER_SIZE - data->read_pos;
        if (copy_to_user(buf, data->buffer + data->read_pos, first_part)) {
            ret = -EFAULT;
            goto out;
        }
        if (copy_to_user(buf + first_part, data->buffer, count - first_part)) {
            ret = -EFAULT;
            goto out;
        }
    } else {
        if (copy_to_user(buf, data->buffer + data->read_pos, count)) {
            ret = -EFAULT;
            goto out;
        }
    }

    data->read_pos = (data->read_pos + count) % BUFFER_SIZE;
    ret = count;

out:
    mutex_unlock(&data->lock);
    return ret;
}

static ssize_t virtual_serial_write(struct file *file, const char __user *buf,
                                    size_t count, loff_t *ppos)
{
    struct virtual_serial_data *data = file->private_data;
    int space, ret;

    if (mutex_lock_interruptible(&data->lock))
        return -ERESTARTSYS;

    space = (data->read_pos - data->write_pos - 1 + BUFFER_SIZE) % BUFFER_SIZE;
    if (count > space)
        count = space;

    if (data->write_pos + count > BUFFER_SIZE) {
        int first_part = BUFFER_SIZE - data->write_pos;
        if (copy_from_user(data->buffer + data->write_pos, buf, first_part)) {
            ret = -EFAULT;
            goto out;
        }
        if (copy_from_user(data->buffer, buf + first_part, count - first_part)) {
            ret = -EFAULT;
            goto out;
        }
    } else {
        if (copy_from_user(data->buffer + data->write_pos, buf, count)) {
            ret = -EFAULT;
            goto out;
        }
    }

    data->write_pos = (data->write_pos + count) % BUFFER_SIZE;
    wake_up_interruptible(&data->read_queue);
    ret = count;

out:
    mutex_unlock(&data->lock);
    return ret;
}

static const struct file_operations virtual_serial_fops = {
    .owner = THIS_MODULE,
    .open = virtual_serial_open,
    .read = virtual_serial_read,
    .write = virtual_serial_write,
};

static struct virtual_serial_data serial_data = {
    .misc = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = "vserial",
        .fops = &virtual_serial_fops,
    },
};

static int __init virtual_serial_init(void)
{
    int ret;

    serial_data.buffer = kzalloc(BUFFER_SIZE, GFP_KERNEL);
    if (!serial_data.buffer)
        return -ENOMEM;

    mutex_init(&serial_data.lock);
    init_waitqueue_head(&serial_data.read_queue);

    ret = misc_register(&serial_data.misc);
    if (ret) {
        kfree(serial_data.buffer);
        return ret;
    }

    pr_info("Virtual serial device registered: /dev/%s\n", serial_data.misc.name);
    return 0;
}

static void __exit virtual_serial_exit(void)
{
    misc_deregister(&serial_data.misc);
    kfree(serial_data.buffer);
    pr_info("Virtual serial device unregistered\n");
}

module_init(virtual_serial_init);
module_exit(virtual_serial_exit);

MODULE_LICENSE("GPL");

四、虚拟看门狗

#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/timer.h>

#define TIMEOUT_SEC 10

struct watchdog_data {
    struct miscdevice misc;
    struct timer_list timer;
    int timeout;
    bool enabled;
    struct mutex lock;
};

static void watchdog_timeout(struct timer_list *t)
{
    struct watchdog_data *data = from_timer(data, t, timer);

    pr_emerg("Watchdog timeout! System will reset.\n");
    // 实际产品中这里会触发系统重启
    // kernel_restart("watchdog timeout");
}

static int watchdog_open(struct inode *inode, struct file *file)
{
    struct watchdog_data *data = container_of(file->private_data, struct watchdog_data, misc);
    file->private_data = data;
    return 0;
}

static ssize_t watchdog_write(struct file *file, const char __user *buf,
                              size_t count, loff_t *ppos)
{
    struct watchdog_data *data = file->private_data;

    // 喂狗
    mutex_lock(&data->lock);
    if (data->enabled) {
        mod_timer(&data->timer, jiffies + data->timeout * HZ);
    }
    mutex_unlock(&data->lock);

    return count;
}

static long watchdog_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    struct watchdog_data *data = file->private_data;
    int ret = 0;

    mutex_lock(&data->lock);

    switch (cmd) {
    case WDIOC_GETSUPPORT:
        // 返回支持的功能
        break;
    case WDIOC_GETSTATUS:
        // 返回状态
        break;
    case WDIOC_KEEPALIVE:
        // 喂狗
        if (data->enabled) {
            mod_timer(&data->timer, jiffies + data->timeout * HZ);
        }
        break;
    case WDIOC_SETTIMEOUT:
        // 设置超时时间
        if (arg > 0 && arg <= 60) {
            data->timeout = arg;
            if (data->enabled) {
                mod_timer(&data->timer, jiffies + data->timeout * HZ);
            }
        } else {
            ret = -EINVAL;
        }
        break;
    case WDIOC_GETTIMEOUT:
        // 获取超时时间
        ret = data->timeout;
        break;
    default:
        ret = -ENOTTY;
    }

    mutex_unlock(&data->lock);
    return ret;
}

static int watchdog_release(struct inode *inode, struct file *file)
{
    struct watchdog_data *data = file->private_data;

    // 关闭时停止看门狗（或保持运行）
    mutex_lock(&data->lock);
    if (data->enabled) {
        del_timer(&data->timer);
        data->enabled = false;
    }
    mutex_unlock(&data->lock);

    return 0;
}

static const struct file_operations watchdog_fops = {
    .owner = THIS_MODULE,
    .open = watchdog_open,
    .write = watchdog_write,
    .unlocked_ioctl = watchdog_ioctl,
    .release = watchdog_release,
};

static struct watchdog_data watchdog_data = {
    .misc = {
        .minor = WATCHDOG_MINOR,
        .name = "watchdog",
        .fops = &watchdog_fops,
    },
    .timeout = TIMEOUT_SEC,
};

static int __init watchdog_init(void)
{
    int ret;

    mutex_init(&watchdog_data.lock);
    timer_setup(&watchdog_data.timer, watchdog_timeout, 0);

    ret = misc_register(&watchdog_data.misc);
    if (ret)
        return ret;

    pr_info("Watchdog device registered: /dev/%s\n", watchdog_data.misc.name);
    return 0;
}

static void __exit watchdog_exit(void)
{
    del_timer_sync(&watchdog_data.timer);
    misc_deregister(&watchdog_data.misc);
    pr_info("Watchdog device unregistered\n");
}

module_init(watchdog_init);
module_exit(watchdog_exit);

MODULE_LICENSE("GPL");

五、字符设备 vs 杂项设备对比

特性	字符设备	杂项设备
主设备号	需要申请	固定为10
注册复杂度	高	低
设备节点	需手动创建	自动创建
适用场景	复杂设备	简单设备

六、用户空间测试

# 查看杂项设备
ls /dev/ | grep -E "myled|vserial|watchdog"

# 测试LED
echo 1 > /dev/myled
echo 0 > /dev/myled

# 测试虚拟串口
cat /dev/vserial &
echo "hello" > /dev/vserial

# 测试看门狗
echo "keepalive" > /dev/watchdog