Linux内核学习：手动编写模拟虚拟设备

最新推荐文章于 2024-01-17 13:57:37 发布
最新推荐文章于 2024-01-17 13:57:37 发布
阅读量1.1k 收藏 2
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Linux内核 计算机 计算机系统结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_32473685/article/details/103614721

目录

1 FIFO与虚拟设备

2 编写虚拟设备驱动

2.1 简单的虚拟设备驱动

2.2 编译字节驱动模块

2.3 插入到QEMU上的Linux内核中

2.4 写用户层测试代码测试插入的内核模块

3 KFIFO改进设备驱动

3.1 改进原因

3.2 带有KFIFO环形缓冲的虚拟驱动模块

3.3 写用户层测试代码测试插入的内核模块

4 阻塞I/O与非阻塞I/O

4.1 非阻塞I/O和阻塞I/O的概念

4.2 把虚拟设备驱动改成非阻塞模式

4.2.1 非阻塞模式下的虚拟设备驱动

4.2.2 编译非阻塞模式下的虚拟设备驱动

4.2.3  写用户层测试代码测试插入的内核模块

1 FIFO与虚拟设备

字符硬件设备内部有一个缓冲区（buffer），芯片内部提供了寄存器来访问这些FIFO，可以通过读寄存器把FIFO的内容读取出来，或者通过写寄存器把数据写入FIFO，或者通过寄存器写入FIFO，一般外设芯片支持中断模式，FIFO有数据到达时，外设芯片通过中断线告诉CPU。

下面做的实验就是模拟设备从用户空间写入内核空间FIFO，再从内核空间FIFO读数据到用户层读缓存区的。

2 编写虚拟设备驱动

2.1 简单的虚拟设备驱动

虚拟驱动代码如下：

#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/device.h>
#include <linux/slab.h>
 
#define DEMO_NAME "my_demo_dev"
static struct device *mydemodrv_device;
 
/*virtual FIFO device's buffer*/
static char *device_buffer;
#define MAX_DEVICE_BUFFER_SIZE 64
 
static int demodrv_open(struct inode *inode, struct file *file)
{
        int major = MAJOR(inode->i_rdev);
        int minor = MINOR(inode->i_rdev);
 
        printk("%s: major=%d, minor=%d\n", __func__, major, minor);
 
        return 0;
}
 
static int demodrv_release(struct inode *inode, struct file *file)
{
        return 0;
}
 
static ssize_t
demodrv_read(struct file *file, char __user *buf, size_t lbuf, loff_t *ppos)
{
        int actual_readed;
        int max_free;
        int need_read;
        int ret;
 
        printk("%s enter\n", __func__);
 
        max_free = MAX_DEVICE_BUFFER_SIZE - *ppos;
        need_read = max_free > lbuf ? lbuf : max_free;
        if (need_read == 0)
                dev_warn(mydemodrv_device, "no space for read");
 
        ret = copy_to_user(buf, device_buffer + *ppos, need_read);
        if (ret == need_read)
                return -EFAULT;
 
        actual_readed = need_read - ret;
        *ppos += actual_readed;
 
        printk("%s, actual_readed=%d, pos=%d\n",__func__, actual_readed, *ppos);
        return actual_readed;
}
 
static ssize_t
demodrv_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
        int actual_write;
        int free;
        int need_write;
        int ret;
 
        printk("%s enter\n", __func__);
 
        free = MAX_DEVICE_BUFFER_SIZE - *ppos;
        need_write = free > count ? count : free;
        if (need_write == 0)
                dev_warn(mydemodrv_device, "no space for write");
 
 
        ret = copy_from_user(device_buffer + *ppos, buf, need_write);
        if (ret == need_write)
                return -EFAULT;
 
        actual_write = need_write - ret;
        *ppos += actual_write;
        printk("%s: actual_write =%d, ppos=%d\n", __func__, actual_write, *ppos);
 
        return actual_write;
}
 
static const struct file_operations demodrv_fops = {
        .owner = THIS_MODULE,
        .open = demodrv_open,
        .release = demodrv_release,
        .read = demodrv_read,
        .write = demodrv_write
};
 
static struct miscdevice mydemodrv_misc_device = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = DEMO_NAME,
        .fops = &demodrv_fops,
};
 
static int __init simple_char_init(void)
{
        int ret;
 
        device_buffer = kmalloc(MAX_DEVICE_BUFFER_SIZE, GFP_KERNEL);
        if (!device_buffer)
                return -ENOMEM;
 
        ret = misc_register(&mydemodrv_misc_device);
        if (ret) {
                printk("failed register misc device\n");
                kfree(device_buffer);
                return ret;
        }
 
        mydemodrv_device = mydemodrv_misc_device.this_device;
 
        printk("succeeded register char device: %s\n", DEMO_NAME);
 
        return 0;
}
 
static void __exit simple_char_exit(void)
{
        printk("removing device\n");
 
        kfree(device_buffer);
        misc_deregister(&mydemodrv_misc_device);
}
 
module_init(simple_char_init);
module_exit(simple_char_exit);
 
MODULE_AUTHOR("Henry_Fordham");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("character device read & write");

2.2 编译字节驱动模块

这里要注意，我们需要在QEMU+ARM的环境下插入内核模块，那么就要在QEMU+ARM的环境下编译模块，为了节省时间，可以先下载一个基础环境，如下：

https://github.com/figozhang/runninglinuxkernel_4.0

直接git clone这个环境下来，下载按照README安装，安装完后，编写刚才内核模块的Makefile，注意第一行BASEINCLUDE刚才下载下来的runninglinuxkernel_4.0，Makefile如下。

BASEINCLUDE ?= ~/tools/runninglinuxkernel_4.0                                 
 
mytest-objs  :=my_demodev.o
obj-m  :=mydemo.o
 
all :
    $(MAKE) -C      $(BASEINCLUDE)  M=$(PWD)        modules;
clean:
    $(MAKE)  -C $(BASEINCLUDE)  SUBDIRS=$(PWD) clean;
    rm -f *.ko;

写完之后，make，可以看到my_demo.ko

2.3 插入到QEMU上的Linux内核中

首先，还是挂载一块ext4磁盘到Linux内核中，通过QEMU启动：

​qemu-system-arm -M vexpress-a9 -smp 4 \
 -m 1024M \
 -kernel arch/arm/boot/zImage \
 -append "rdinit=/linuxrc console=ttyAMA0 loglevel=8" \
 -dtb arch/arm/boot/dts/vexpress-v2p-ca9.dtb  \
 -nographic \
 -sd ext4.img

如果不知道怎么创建一个ext4的磁盘，还是参考第一篇文章。

挂载我们的ext4磁盘到QEMU的mnt：

mount -t ext4 /dev/mmcblk0 /mnt/

同时在主机上将ext4挂载到一个文件目录，使之同步。具体参考第一篇文章。

QEMU中mnt下将mydemo.ko插入进去：

/mnt # ls
lost+found  mydemo.ko
/mnt # insmod mydemo.ko
successed register char device : my_demo_dev
Major numbner =252,minor number =0

2.4 写用户层测试代码测试插入的内核模块

如下是用户级代码： test.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#define DEMO_DEV_NAME "/dev/my_demo_dev"

int main(){
    char buffer[64];
    int fd;
    int ret;
    size_t len;
    char message[] = "Testing the virtual FIFO device";
    char *read_buffer;
    len = sizeof(message);
    fd = open(DEMO_DEV_NAME, O_RDWR);
    if (fd < 0){
        printf("open device %s failed\n", DEMO_DEV_NAME);
        return -1;
    }

    ret = write(fd, message, len);
    if (ret != len){
        printf("cannot write on device %d, ret=%d", fd, ret);
        return -1;
    }

    read_buffer = malloc(2*len);
    memset(read_buffer, 0, 2*len);
    close(fd);
    fd = open(DEMO_DEV_NAME, O_RDWR);
    if (fd < 0){ 
        printf("open device %s failed\n", DEMO_DEV_NAME);
        return -1; 
    }
    ret = read(fd, read_buffer, 2*len);
    printf("read %d bytes\n", ret);
    printf("read buffer=%s\n",read_buffer);
    close(fd);
    return 0;
}

 编译：

arm-linux-gnueabi-gcc test.c -o test --static

得到一个可执行文件test，将这个文件还是同步到qemu的内核文件系统ext4.img中，然后执行：

Please press Enter to activate this console. 
/ # ls
bin      etc      mnt      sbin     tmp
dev      linuxrc  proc     sys      usr
/ # mount -t ext4 /dev/mmcblk0 /mnt/
EXT4-fs (mmcblk0): recovery complete
EXT4-fs (mmcblk0): mounted filesystem with ordered data mode. Opts: (null)
/ # cd mnt/
/mnt # ls
lost+found    mydemo.ko     test_virtual
/mnt # insmod  mydemo.ko 
succeeded register char device: my_demo_dev
/mnt # mknod /dev/demo_drv c 252 0
/mnt # ./test_virtual
random: nonblocking pool is initialized
demodrv_open: major=10, minor=58
demodrv_write enter
demodrv_write: actual_write =32, ppos=0
demodrv_open: major=10, minor=58
demodrv_read enter
demodrv_read, actual_readed=64, pos=0
read 64 bytes
read buffer=Testing the virtual FIFO device

可以看到，从用户层代码读取到了内核模块的信息。

3 KFIFO改进设备驱动

3.1 改进原因

可以从刚才的驱动程序代码中观察到，在读之前调用了一次open函数，在写之前也调用了一次open函数，这正是因为没有考虑到读和写的并行管理问题，所以在对应的测试程序中，需要重启设备将数据读出来。

所以如果要改进的地点就是能够并行的管理读和写进程。Linux内核实现了一个称为KFIFO的环形缓冲机制，它可以在一个读者线程和一个写者进程并发执行的场景下，无需使用额外的加锁来保证环形缓冲区的数据安全。KFIFO提供的接口函数定义在 include/linux/kfifo.h 文件中。

#define kfifo_from_user(fifo, from, len, copied)
#define kfifo_to_user(fifo, to, len, copied)

fifo表示使用的哪个环形缓存区。

from表示用户空间缓冲区的起始地址，len表示要复制多少个元素，copied保存了成功复制元素的数量。

to表示从fifo缓存空间读出到用户空间缓冲区的起始地址，其他不变。

所以，要改动的地方只有字符模块的 demodrv_read 和 demodrv_write 模块，将主要输入输出函数改为kfifo_from_user和kfifo_to_user。

3.2 带有KFIFO环形缓冲的虚拟驱动模块

带有KFIFO环形缓冲的虚拟驱动模块代码如下：

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

DEFINE_KFIFO(mydemo_fifo, char, 64);
#define DEMO_NAME "my_demo_dev"
static struct device *mydemodrv_device;
/*virtual FIFO device's buffer*/
static char *device_buffer;
#define MAX_DEVICE_BUFFER_SIZE 64

static int demodrv_open(struct inode *inode, struct file *file)
{
        int major = MAJOR(inode->i_rdev);
        int minor = MINOR(inode->i_rdev);

        printk("%s: major=%d, minor=%d\n", __func__, major, minor);

        return 0;
}

static int demodrv_release(struct inode *inode, struct file *file)
{
        return 0;
}


static ssize_t
demodrv_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
        int actual_readed;
        int ret;
        ret = kfifo_to_user(&mydemo_fifo, buf, count, &actual_readed);
        if (ret)
                return -EIO;

        printk("%s, actual_readed=%d, pos=%lld\n",__func__, actual_readed, *ppos);
        return actual_readed;
}

static ssize_t
demodrv_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
        unsigned int actual_write;
        int ret;
        ret = kfifo_from_user(&mydemo_fifo, buf, count, &actual_write);
        if (ret)
                return -EIO;

        printk("%s: actual_write =%d, ppos=%d\n", __func__, actual_write, *ppos);
        return actual_write;
}


static const struct file_operations demodrv_fops = {
        .owner = THIS_MODULE,
        .open = demodrv_open,
        .release = demodrv_release,
        .read = demodrv_read,
        .write = demodrv_write
};

static struct miscdevice mydemodrv_misc_device = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = DEMO_NAME,
        .fops = &demodrv_fops,
};

static int __init simple_char_init(void)
{
        int ret;

        device_buffer = kmalloc(MAX_DEVICE_BUFFER_SIZE, GFP_KERNEL);
        if (!device_buffer)
                return -ENOMEM;

        ret = misc_register(&mydemodrv_misc_device);
        if (ret) {
                printk("failed register misc device\n");
                kfree(device_buffer);
                return ret;
        }

        mydemodrv_device = mydemodrv_misc_device.this_device;
        printk("succeeded register char device: %s\n", DEMO_NAME);

        return 0;
}


static void __exit simple_char_exit(void)
{
        printk("removing device\n");

        kfree(device_buffer);
        misc_deregister(&mydemodrv_misc_device);
}

module_init(simple_char_init);
module_exit(simple_char_exit);

MODULE_AUTHOR("Henry_Fordham");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("character device read & write");

之后重新编译，make

3.3 写用户层测试代码测试插入的内核模块

如下是用户级代码： test_virtual.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#define DEMO_DEV_NAME "/dev/my_demo_dev"

int main(){
    char buffer[64];
    int fd;
    int ret;
    size_t len;
    char message[] = "Testing the virtual FIFO device";
    char *read_buffer;
    len = sizeof(message);
    fd = open(DEMO_DEV_NAME, O_RDWR);
    if (fd < 0){
        printf("open device %s failed\n", DEMO_DEV_NAME);
        return -1;
    }

    ret = write(fd, message, len);
    if (ret != len){
        printf("cannot write on device %d, ret=%d", fd, ret);
        return -1;
    }

    read_buffer = malloc(2*len);
    memset(read_buffer, 0, 2*len);
    close(fd);
    fd = open(DEMO_DEV_NAME, O_RDWR);
    if (fd < 0){ 
        printf("open device %s failed\n", DEMO_DEV_NAME);
        return -1; 
    }
    ret = read(fd, read_buffer, 2*len);
    printf("read %d bytes\n", ret);
    printf("read buffer=%s\n",read_buffer);
    close(fd);
    return 0;
}

 编译：

arm-linux-gnueabi-gcc test_virtual.c -o test --static

得到一个可执行文件test，将这个文件还是同步到qemu的内核文件系统ext4.img中，然后执行：

Please press Enter to activate this console. 
/ # ls
bin      etc      mnt      sbin     tmp
dev      linuxrc  proc     sys      usr
/ # mount -t ext4 /dev/mmcblk0 /mnt/
EXT4-fs (mmcblk0): recovery complete
EXT4-fs (mmcblk0): mounted filesystem with ordered data mode. Opts: (null)
/ # cd mnt/
/mnt # ls
lost+found    mydemo.ko     test_virtual
/mnt # insmod mydemo.ko 
succeeded register char device: my_demo_dev
/mnt # ./test_virtual 
random: nonblocking pool is initialized
demodrv_open: major=10, minor=58
demodrv_write: actual_write =32, ppos=0
demodrv_open: major=10, minor=58
demodrv_read, actual_readed=32, pos=0
read 32 bytes
read buffer=Testing the virtual FIFO device

4 阻塞I/O与非阻塞I/O

4.1 非阻塞I/O和阻塞I/O的概念

非阻塞：进程发起I/O系统调用后，如果设备驱动的缓冲区没有数据，那么进程会返回一个错误而不会被阻塞。如果驱动缓冲区有数据，那么设备驱动把数据直接返回给用户进程。

阻塞：进程发起I/O系统调用后，如果设备的缓冲区没有数据，那么需要到硬件I/O中重新获取数据，进程会被阻塞，也就是休眠等待。直到数据准备好，进程才会被唤醒，并重新把数据返回给用户空间。

4.2 把虚拟设备驱动改成非阻塞模式

4.2.1 非阻塞模式下的虚拟设备驱动

驱动代码如下：

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

DEFINE_KFIFO(mydemo_fifo, char, 64);
#define DEMO_NAME "my_demo_dev"
static struct device *mydemodrv_device;
/*virtual FIFO device's buffer*/
static char *device_buffer;
#define MAX_DEVICE_BUFFER_SIZE 64

static int demodrv_open(struct inode *inode, struct file *file)
{
        int major = MAJOR(inode->i_rdev);
        int minor = MINOR(inode->i_rdev);

        printk("%s: major=%d, minor=%d\n", __func__, major, minor);

        return 0;
}

static int demodrv_release(struct inode *inode, struct file *file)
{
        return 0;
}


static ssize_t
demodrv_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
        int actual_readed;
        int ret;
        if (kfifo_is_empty(&mydemo_fifo)){
            if (file->f_flags & O_NONBLOCK)
                return -EAGAIN;
        }
        ret = kfifo_to_user(&mydemo_fifo, buf, count, &actual_readed);
        if (ret)
                return -EIO;

        printk("%s, actual_readed=%d, pos=%lld\n",__func__, actual_readed, *ppos);
        return actual_readed;
}

static ssize_t
demodrv_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
        unsigned int actual_write;
        int ret;
        if (kfifo_is_full(&mydemo_fifo)){
            if (file->f_flags & O_NONBLOCK)
                return -EAGAIN;
        }
        ret = kfifo_from_user(&mydemo_fifo, buf, count, &actual_write);
        if (ret)
                return -EIO;

        printk("%s: actual_write =%d, ppos=%d\n", __func__, actual_write, *ppos);
        return actual_write;
}


static const struct file_operations demodrv_fops = {
        .owner = THIS_MODULE,
        .open = demodrv_open,
        .release = demodrv_release,
        .read = demodrv_read,
        .write = demodrv_write
};

static struct miscdevice mydemodrv_misc_device = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = DEMO_NAME,
        .fops = &demodrv_fops,
};

static int __init simple_char_init(void)
{
        int ret;

        device_buffer = kmalloc(MAX_DEVICE_BUFFER_SIZE, GFP_KERNEL);
        if (!device_buffer)
                return -ENOMEM;

        ret = misc_register(&mydemodrv_misc_device);
        if (ret) {
                printk("failed register misc device\n");
                kfree(device_buffer);
                return ret;
        }

        mydemodrv_device = mydemodrv_misc_device.this_device;
        printk("succeeded register char device: %s\n", DEMO_NAME);

        return 0;
}


static void __exit simple_char_exit(void)
{
        printk("removing device\n");

        kfree(device_buffer);
        misc_deregister(&mydemodrv_misc_device);
}

module_init(simple_char_init);
module_exit(simple_char_exit);

MODULE_AUTHOR("Henry_Fordham");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("character device read & write");

4.2.2 编译非阻塞模式下的虚拟设备驱动

这里要注意，我们需要在QEMU+ARM的环境下插入内核模块，那么就要在QEMU+ARM的环境下编译模块，为了节省时间，可以先下载一个基础环境，如下：

https://github.com/figozhang/runninglinuxkernel_4.0

直接git clone这个环境下来，下载按照README安装，安装完后，编写刚才内核模块的Makefile，注意第一行BASEINCLUDE刚才下载下来的runninglinuxkernel_4.0，Makefile如下。

BASEINCLUDE ?= ~/tools/runninglinuxkernel_4.0                                 
 
mytest-objs  :=my_demodev.o
obj-m  :=mydemo.o
 
all :
    $(MAKE) -C      $(BASEINCLUDE)  M=$(PWD)        modules;
clean:
    $(MAKE)  -C $(BASEINCLUDE)  SUBDIRS=$(PWD) clean;
    rm -f *.ko;

写完之后，make，可以看到my_demo.ko

4.2.3  写用户层测试代码测试插入的内核模块

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#define DEMO_DEV_NAME "/dev/my_demo_dev"

int main(){
    int fd; 
    int ret;
    size_t len;
    char message[] = "Testing the virtual FIFO device";
    char *read_buffer;
    len = sizeof(message);
    read_buffer = malloc(2*len);
    memset(read_buffer, 0, 2*len);

    fd = open(DEMO_DEV_NAME, O_RDWR | O_NONBLOCK);
    if (fd < 0){ 
        printf("open device %s failed\n", DEMO_DEV_NAME);
        return -1; 
    }   
    //First read the data
    ret = read(fd, read_buffer, 2*len);
    printf("read %d bytes\n", ret);
    printf("read buffer=%s\n", read_buffer);

    //Second, write to the device
    ret = write(fd, message, len);
    if (ret != len)
        printf("have write %d bytes\n", ret);

    //Third, write to the device
        ret = write(fd, message, len);
    if (ret != len)
        printf("have write %d bytes\n", ret);
    
    //First read the data
    ret = read(fd, read_buffer, 2*len);
    printf("read %d bytes\n", ret);
    printf("read buffer=%s\n", read_buffer);

    close(fd);
    return 0;
}

 编译：

arm-linux-gnueabi-gcc test_virtual.c -o test --static

得到一个可执行文件test，将这个文件还是同步到qemu的内核文件系统ext4.img中，然后执行：

Please press Enter to activate this console. 
/ # mount -t ext4 /dev/mmcblk0 /mnt/
EXT4-fs (mmcblk0): recovery complete
EXT4-fs (mmcblk0): mounted filesystem with ordered data mode. Opts: (null)
/ # cd mnt/
/mnt # ls
lost+found    mydemo.ko     test_virtual
/mnt # insmod mydemo.ko 
succeeded register char device: my_demo_dev
/mnt # ./test_virtual 
random: nonblocking pool is initialized
demodrv_open: major=10, minor=58
read -1 bytes
read buffer=
demodrv_write: actual_write =32, ppos=0
demodrv_write: actual_write =32, ppos=0
demodrv_read, actual_readed=64, pos=0
read 64 bytes
read buffer=Testing the virtual FIFO device
// mydemo.c
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/init.h>
#include <linux/miscdevice.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/kfifo.h>

DEFINE_KFIFO(mydemo_fifo, char, 64);
#define DEMO_NAME "my_demo_dev"
static struct device *mydemodrv_device;
/*virtual FIFO device's buffer*/
static char *device_buffer;
#define MAX_DEVICE_BUFFER_SIZE 64

struct mydemo_device {
    const char *name;
    struct device *dev;
    wait_queue_head_t read_queue;
    wait_queue_head_t write_queue;
};

struct mydemo_private_data {
        struct mydemo_device *device;
        char name[64];
};


static int demodrv_open(struct inode *inode, struct file *file)
{
        int major = MAJOR(inode->i_rdev);
        int minor = MINOR(inode->i_rdev);

        printk("%s: major=%d, minor=%d\n", __func__, major, minor);

        return 0;
}

static int demodrv_release(struct inode *inode, struct file *file)
{
        return 0;
}

static ssize_t
demodrv_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
    struct mydemo_private_data *data = file->private_data;
        struct mydemo_device *device = data->device;
        int actual_readed;
    int ret;
    if (kfifo_is_empty(&mydemo_fifo)){
        if (file->f_flags & O_NONBLOCK)
            return -EAGAIN;
        printk("%s pid=%d, going to sleep\n",__func__, current->pid);
        ret = wait_event_interruptible(device->read_queue,
                !kfifo_is_empty(&mydemo_fifo));
        if (ret)
            return ret;
    }
    
    ret = kfifo_to_user(&mydemo_fifo, buf, count, &actual_readed);
    if (ret)
                return -EIO;
    if (!kfifo_is_full(&mydemo_fifo)){
                wake_up_interruptible(&device->write_queue);
        }

        printk("%s, actual_readed=%d, pos=%lld\n",__func__, actual_readed, *ppos);
        return actual_readed;
}
static ssize_t
demodrv_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    struct mydemo_private_data *data = file->private_data;
        struct mydemo_device *device = data->device;
        unsigned int actual_write;
        int ret;
    if (kfifo_is_full(&mydemo_fifo)){
        if (file->f_flags & O_NONBLOCK)
            return -EAGAIN;
        printk("%s pid=%d, going to sleep\n",__func__, current->pid);
        ret = wait_event_interruptible(device->write_queue,
                  !kfifo_is_full(&mydemo_fifo));
        if (ret)
            return ret;
    }
        ret = kfifo_from_user(&mydemo_fifo, buf, count, &actual_write);
    if (ret)
                return -EIO;
    if (!kfifo_is_full(&mydemo_fifo)){
        wake_up_interruptible(&device->read_queue);
    }
        printk("%s: actual_write =%d, ppos=%lld\n", __func__, actual_write, *ppos);
        return actual_write;
}

static const struct file_operations demodrv_fops = {
        .owner = THIS_MODULE,
        .open = demodrv_open,
        .release = demodrv_release,
        .read = demodrv_read,
        .write = demodrv_write
};

static struct miscdevice mydemodrv_misc_device = {
        .minor = MISC_DYNAMIC_MINOR,
        .name = DEMO_NAME,
        .fops = &demodrv_fops,
};

static int __init simple_char_init(void)
{
    struct mydemo_device *device;
        int ret;

        device_buffer = kmalloc(MAX_DEVICE_BUFFER_SIZE, GFP_KERNEL);
        if (!device_buffer)
                return -ENOMEM;

        ret = misc_register(&mydemodrv_misc_device);
        if (ret) {
                printk("failed register misc device\n");
                kfree(device_buffer);
                return ret;
        }

        mydemodrv_device = mydemodrv_misc_device.this_device;
        printk("succeeded register char device: %s\n", DEMO_NAME);
        init_waitqueue_head(&device->read_queue);
        init_waitqueue_head(&device->write_queue);
        return 0;
}

static void __exit simple_char_exit(void)
{
        printk("removing device\n");

        kfree(device_buffer);
        misc_deregister(&mydemodrv_misc_device);
}

module_init(simple_char_init);
module_exit(simple_char_exit);

MODULE_AUTHOR("Henry_Fordham");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("character device read & write");

 

(九)添加虚拟设备节点以及驱动编写
m0_52555663的博客
01-15 1037
(九)添加虚拟设备节点以及驱动编写
虚拟输入设备Linux,Linux驱动编写之虚拟字符设备编写
weixin_42140846的博客
05-11 198
之前，我们说了一些简单模块编写方法(嵌入式Linux驱动编写入门篇，linux驱动的开发步骤)，但是终归没有涉及到设备的编写内容，今天我们就可以了解一下相关方面的内容，并且用一个实例来说明在Linux上面设备是如何编写的。很多做驱动的朋友吐槽认为自己的工作就是把代码拷贝来拷贝去，或者说是改来改去，没有什么技术含量。这主要还是因为他们对自己的工作缺少了解导致。如果有可能，我们可以问问自己这样几个问题...
内核模块-实现一个简单的设备
飞翔de刺猬
05-18 755
上一篇文章讲了如何实现基于内核模块的“helloworld”，相信大家通过这个例子对于内核模块有了一个基本的了解。当然，内核模块绝不仅仅只能实现这点功能，其最大的应用就是实现硬件的驱动程序。其实，linux内核中很大一部代码都是硬件处理相关的，比如，设备-总线-驱动框架，USB框架、spi框架、i2c框架等等，对应于各种不同的硬件设备，相应的就会有设备驱动程序，从最简单的按键、LED驱动，到十分复杂的USB子系统驱动，可以好不夸张的说，Linux内核可以适配绝大多数的硬件设备。 那这些驱动框架和驱动程序，一
Linux 伪/虚拟设备
weixin_43965970的博客
03-18 403
伪设备是 Linux设备模型中的一种特殊设备，这种类型的设备可以不对应一个真实的硬件实体，即表示成一种虚拟的设备。Linux常见的伪设备/虚拟设备包括：它是一个块设备循环器，可以将文件作为块设备挂载到文件系统中。/dev/loop[x] 是一个虚拟块设备，它允许将一个文件或其他块设备映射到一个挂载点上。通过这种方式，用户可以创建一个虚拟文件系统，其中的文件看起来像是一个真正的磁盘分区。使用 /dev/loop[x] 可以方便地创建和管理磁盘映像文件、安装镜像和虚拟机等。
Linux系统----伪设备
醉卧考场君莫笑
09-07 614
标准输入输出设备文件伪设备的挂载。
Linux内核学习：在QEMU上运行一个能够挂载Ext4文件的Linux内核
Henry_Fordham——一个姓雪的程序员小哥哥
12-03 3211
目录 0 写在前面的话 1 QEMU调试Linux内核 1.1 准备依赖包 1.2 编译最小文件系统 1.3 编译内核 1.4 运行QEMU上的linux 5.0内核 2 挂载一个ext4文件目录到Linux 5.0内核上 2.1 创建ext4文件系统分区 2.2重新编译内核 2.3挂载磁盘目录 2.4 共享主机文件 0 写在前面的话 最近在学习Linux内核的一些相...
Linux内核学习3——虚拟地址转换成物理地址
weixin_45730790的博客
11-19 9886
这里，我们讲解一下Linux是如何将虚拟地址转换成物理地址的 一、地址转换 在进程中，我们不直接对物理地址进行操作，CPU在运行时，指定的地址要经过MMU转换后才能访问到真正的物理内存。 地址转换的过程分为两部分，分段和分页。 分段机制简单的来说是将进程的代码、数据、栈分在不同的虚拟地址段上，从而避免进程间的互相影响。分段之前的地址我们称之为逻辑地址，它有两部分组成，高位的段选择符和低位的段内偏移。在分段时先用段选择符在相应的段描述符表中找到段描述符，也就是某一个段的基地址，再加上段内偏移量就得到了对应的
Linux内核揭秘：掌握企业级系统安全的5大秘诀
## Linux内核安全的重要性 Linux内核作为操作系统的核心部分，承载了系统的所有基本功能和服务。其安全性直接关系到整个系统的稳定运行和数据安全。随着网络攻击手段的不断进化，内核安全问题日益成为企业和个人...
Linux内核机制深度探究：掌握设备驱动编写与调试的必备技巧
[Linux内核机制深度探究：掌握设备驱动编写与调试的必备技巧](https://dz2cdn1.dzone.com/storage/temp/13170384-picture1.png) 参考资源链接：[《Linux设备驱动开发详解》第二版-宋宝华-高清PDF]...
Linux面试精华：设备访问、内核引导到网络管理
14. **系统交换空间**：交换分区是Linux模拟物理内存的虚拟存储区，用于在内存不足时临时交换数据。 15. **内核子系统**：Linux内核包含进程管理、文件管理、I/O管理和内存管理等多个子系统，协同处理系统资源。 ...
Linux 几种虚拟设备,Linux系统中虚拟设备文件的各种实用用法
weixin_42395002的博客
05-05 254
大家好，我是良许。大家知道，在 Linux 下，一切皆文件，对于设备文件也是如此。我们在工作的过程中，经常会看到/dev/null 这个玩意，那它到底是什么呢?专业地讲，/dev/null 是一个虚拟设备文件。而对程序而言，这些虚拟设备文件则会被当成真实的文件对待。程序可以向这种数据源请求数据，所得到的数据将由操作系统提供。但是，这些数据并不是从磁盘上读取到的，而是由操作系统动态生成的。虚拟设备...
Linux内核设计与实现——设备与模块
weixin_46006645的博客
04-07 550
Linux内核设计与实现——设备与模块
在qemu中增加pci设备并用linux驱动验证
热门推荐
XscKernel的专栏 记录工作中做的点滴
12-15 1万+
声明本文主要针对x86架构进行说明。 使用的qemu版本是：qemu-kvm-1.2.0-rc2 1)PCI结构简介 每个PCI设备都有一个配置空间和若干个地址空间，按照固定的顺序放置CPI的各种配置参数。关于详细的介绍可以在网上搜索相关的资料。 下面是在busybox下lspci -mk的输出内容说明： 00:00.0 "Class 0600" "8086" "1237"
如何mount ext4 分区
李子的备忘录
11-28 9221
mount  -t ext4       target_path/your.img           ./mount_dir  上面mount的时候有可能失败：  第一中,没有权限：  sudo  mount  -t ext4       target_path/your.img           ./mount_dir  第二中，由于你的your.img不是一个真正的分区后者设备：
使用qemu搭建ARM64调试环境，支持文件共享，支持gdb调试
科学边界
07-06 3951
环境 主机ubuntu版本: 20.04 qemu模拟处理器：ARM64 Linux内核版本：https://www.kernel.org/ 最新版 step1:安装编译工具链 sudo apt-get install gcc-aarch64-linux-gnu 查看版本号 leon@leon:~/work$ aarch64-linux-gnu-gcc -v Using built-in specs. COLLECT_GCC=aarch64-linux-gnu-gcc COLLECT_LTO_WRAPPE
正点原子imx6ull打印：random：nonblocking pool is initialized
最新发布
qq_39200110的博客
01-17 2317
开发板启动进入文件系统后，经常打印 random: nonblocking pool is initialized。
记一次坎坷的调试|Mosquitto通过TLS连接EMQ时阻塞的问题
飞翔de刺猬
08-01 2596
最近两天在调试一个关于嵌入式Linux系统环境时，在系统开机之后，Mosquitto通过tls连接MQTT服务器（EMQ）时，创建MQTT连接总是阻塞的问题，现记录一下调试过程及解决问题的步骤。先说下开发调试环境：linux系统开机之后，出现shell登录提示符之后，调用mosquitto_connect和EMQ建立基于TLS的连接，mosquitto_connect调用之后阻塞，大约90秒，该函数调用才会返回，并且报错。之后，mosquitto会触发重连机制，再次连接EMQ服务器，连接成功。这时，如果重新
Linux随机数nonblocking pool快速初始化
zjy900507的博客
01-09 2205
转载：https://blog.youkuaiyun.com/bc_vnetwork/article/details/53535476 在计算节点nova-compute运行裁剪Linux虚机提供OpenVPN服务端出现无法连接成功的情况，对Linux随机数进行初步的了解以定位分析问题原因 1994 年，美国软件工程师 Theodore Y. Ts'o 第一次在 Linux 内核中实现了随机数发生器，使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值