linux - 创建/dev/fakeDevice支持读取，写入和ioctl

我有一个在嵌入式设备(x86，最近的linux)上运行的软件。为了简化开发，使用自动化测试等，我想在主机系统上运行它。通过对构建系统的一些调整，代码可以很好地编译。下一步将是创建“虚拟设备”。

该应用程序不使用任何类型的库，而是通过读取，写入和ioctl调用直接与多个设备通信。设备代表具有自定义协议(protocol)的自定义硬件。要创建虚拟环境，我需要响应此调用。一种可能的方式是:

为每个需要的设备(/dev/deviceA，/dev/deviceB，/dev/deviceC，...)创 build 备驱动程序

创建另一个设备驱动程序以与用户空间通信(例如/dev/deviceSimulation)

所有虚拟设备都会将每个调用转发到/dev/deviceSimulation

另一个用户空间应用程序与/dev/deviceSimulation进行交互，并跟踪模拟状态。

有没有更简单的方法来做到这一点，而无需往返Linux内核？

最佳答案

回到这个辅助项目并回答我自己的问题:是的，必须完成内核的往返操作。但是有一个图书馆正在做艰苦的工作:CUDA(感谢CL)。

文档感觉有点稀缺(或者我在找错地方)，并且提供的cuda示例充满了处理参数或缓冲区处理的其他方式。因此，这里是另一个示例(甚至减少了，在这里没有任何作用...):

设备“驱动程序”(cusetest.c):

#define FUSE_USE_VERSION 30
#define _FILE_OFFSET_BITS 64
#include <fuse/cuse_lowlevel.h>
#include <fuse/fuse_opt.h>

#include <stdio.h>

#define LOG(...) do { fprintf(stderr, __VA_ARGS__); puts(""); } while (0)

static void cusetest_open(fuse_req_t req, struct fuse_file_info *fi) {
    LOG("open");
    fuse_reply_open(req, fi);
}

static void cusetest_read(fuse_req_t req, size_t size, off_t off,
                         struct fuse_file_info *fi) {
    LOG("read");
    fuse_reply_buf(req, "Hello", size > 5 ? 5 : size);
}

static void cusetest_write(fuse_req_t req, const char *buf, size_t size,
                          off_t off, struct fuse_file_info *fi) {
    LOG("write (%u bytes)", size);
    fuse_reply_write(req, size);
}

static void cusetest_ioctl(fuse_req_t req, int cmd, void *arg,
                          struct fuse_file_info *fi, unsigned flags,
                          const void *in_buf, size_t in_bufsz, size_t out_bufsz) {
    LOG("ioctl %d: insize: %u outsize: %u", cmd, in_bufsz, out_bufsz);
    switch (cmd) {
    case 23:
        if (in_bufsz == 0) {
            struct iovec iov = { arg, sizeof(int) };
            fuse_reply_ioctl_retry(req, &iov, 1, NULL, 0);
        } else {
            LOG("  got value: %d", *((int*)in_buf));
            fuse_reply_ioctl(req, 0, NULL, 0);
        }
        break;
    case 42:
        if (out_bufsz == 0) {
            struct iovec iov = { arg, sizeof(int) };
            fuse_reply_ioctl_retry(req, NULL, 0, &iov, 1);
        } else {
            LOG("  write back value");
            int v = 42;
            fuse_reply_ioctl(req, 0, &v, sizeof(int));
        }
        break;
    }
}

static const struct cuse_lowlevel_ops cusetest_clop = {
        .open           = cusetest_open,
        .read           = cusetest_read,
        .write          = cusetest_write,
        .ioctl          = cusetest_ioctl,
};

int main(int argc, char** argv) {
    // -f: run in foreground, -d: debug ouput
    // Compile official example and use -h
    const char* cusearg[] = {"test", "-f", "-d"};
    const char* devarg[]  = {"DEVNAME=cusetest" };
    struct cuse_info ci;
    memset(&ci, 0x00, sizeof(ci));
    ci.flags = CUSE_UNRESTRICTED_IOCTL;
    ci.dev_info_argc=1;
    ci.dev_info_argv = devarg;

    return cuse_lowlevel_main(3, (char**) &cusearg, &ci, &cusetest_clop, NULL);
}

编译并运行:gcc -Wall -g -lfuse cusetest.c -o cusetest && sudo ./cusetest
测试程序(testcusetest.c):

#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <sys/ioctl.h>

int main() {
    int fd = open("/dev/cusetest", O_RDWR);

    const char* msg = "Fooooo";
    write(fd, msg, strlen(msg));

    int v = 63;
    ioctl(fd, 23, &v);
    fprintf(stderr, "value is now: %d\n", v);
    ioctl(fd, 42, &v);
    fprintf(stderr, "value is now: %d\n", v);
    close(fd);
    return 0;
}

编译并运行:gcc -Wall testcusetest.c -o testcusetest && ./testcusetest
它还有很多事情要做，但应该足以使人吃惊。陷阱是CUSE_UNRESTRICTED_IOCTL。如果输入缓冲区或输出缓冲区的长度为零，则需要使用fuse_reply_ioctl_retry()进行答复。将在填充了缓冲区的情况下再次调用该回调。

关于linux - 创建/dev/fakeDevice支持读取，写入和ioctl，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/23135589/