Linux驱动编程 step-by-step （九）

最新推荐文章于 2024-05-23 17:02:04 发布
最新推荐文章于 2024-05-23 17:02:04 发布
阅读量3.9k 收藏 4
点赞数 3
分类专栏： C/C++ Linux 文章标签： linux 编程 buffer user semaphore struct
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jshazk1989/article/details/7024657
版权
Linux 同时被 2 个专栏收录
23 篇文章 0 订阅
订阅专栏
C/C++
11 篇文章 0 订阅
订阅专栏

字符设备模拟pipe的驱动程序

让我们用一个”pipe“的设备驱动去结束简单字符设备吧（这里所说的pipe并非标准的pipe只是模拟了一个从一端写入从另一端写入的设备）

测试代码1      测试代码2

设计思路

用一个图来说明（可是画了很久哟）

简单说来就是一个进程写入缓冲区，另一个进程可以读出，读出后原buffer中的数据被置为无效值，

自定义一个结构

#define MAX_SIMPLE_LEN 1024	//buffer 数据长度
struct simple_dev{
    char *data;			//指向数据的头部
    char *datard;		//读指针
    char *datawr;		//写指针
    char *dataend;		//指向缓冲区的结尾
    wait_queue_head_t inq;	//读取等待队列头
    wait_queue_head_t outq;	//写入等待队列头
    struct cdev cdev;		//字符设备结构
    struct semaphore semp;	//结构体信号量
};

申请设备号

 之前有介绍，不再赘述

为自定义结构体分配区内存

    D("alloc simple_dev struct \n");
    char7_dev = kmalloc(DEV_COUNT*sizeof(struct simple_dev), GFP_KERNEL);
    if( char7_dev == NULL)
    {
        printk(KERN_ERR "kmalloc simple_dev err no memory");
        unregister_chrdev_region(dev, DEV_COUNT);
        return -ENOMEM;
    }

使用kmalloc 给设备结构他分配内存，因为系统可能因为暂时不能分配到内存（虽然很少见），所以在分配到内存后需要检测是否分配成功，在检测到成功分配内存后还需要将所分配的内存区清零，以免以后出现奇怪的错误难以调试（一定要记住）

 memset(char7_dev, 0, DEV_COUNT*sizeof(struct simple_dev));

为缓冲区申请内存

在为自定义结构他申请好内存后，我们需要为每个结构体内的buffer申请内存，使用相同的方法，分配并清零

 for( index = 0 ; index < DEV_COUNT ; ++index )
 {
     //char7_dev[index].count = 0
     if(( char7_dev[index].data = kmalloc(MAX_SIMPLE_LEN, GFP_KERNEL) )!= NULL )
     {
         memset(char7_dev[index].data, 0, MAX_SIMPLE_LEN);
         D("kmalloc the data space OK! \n");
     }
     else{
        for( --index ; index >= 0 ; --index )
        {
             kfree(char7_dev[index].data);
        } 
        printk(KERN_ERR "kmalloc simple_dev data number err no memory");
        kfree(char7_dev);
        unregister_chrdev_region(dev, DEV_COUNT);
        return -ENOMEM;
    }
}

这里需要注意的一点是 在申请某个buffer缓冲区失败时候，需要将已经成功申请的内存释放掉（else中做了这个工作）

初始化结构体中的各数据指针、信号量、等待队列头

在申请好设备及各设备buffer内存后，我们需要对结构中的一些变量进行初始化，

初始化数据指针

将data指向buffer起始位置， datawr,datard 初始化也指向起始位置（表示空buffer）,dataend 指向buffer末尾一个无效位置，用于判断读写位置是否合法

初始化信号量以及读写队列头

 for( index = 0 ; index < DEV_COUNT ; ++index )
    {                 
        /*init the data ptr*/ 
        char7_dev[index].datard = char7_dev[index].data;
        char7_dev[index].datawr = char7_dev[index].data;
        char7_dev[index].dataend = char7_dev[index].data + MAX_SIMPLE_LEN;                                

        /*init semaphore, waitqueue_head and so on*/
        sema_init(&(char7_dev[index].semp), 1);
        init_waitqueue_head(&(char7_dev[index].inq));
        init_waitqueue_head(&(char7_dev[index].outq));
    }

初始化字符设备添加字符设备

逐个设备初始化（注册）并添加（告知内核） 
    for( index = 0 ; index < DEV_COUNT ; ++index )
    {
        cdev_init(&(char7_dev[index].cdev), &simple_fops);
        char7_dev[index].cdev.owner = THIS_MODULE;

        err = cdev_add(&(char7_dev[index].cdev), dev, 1);
        if(err < 0)
        {
            printk(KERN_ERR "add cdev err \n");
            goto error1;
        }
        else
        {   
            D( "add %d char dev OK!\n", index+1);
        }

    }


字符设备操作

struct file_operations simple_fops={
    .owner   = THIS_MODULE,
    .open    = simple_open,
    .release = simple_close,
    .read    = simple_read,
    .write   = simple_write,
    .llseek  = simple_llseek,
//  .ioctl   = simple_ioctl,
    .poll    = simple_poll,
    .mmap    = simple_mmap,
};

因为2.6.35之后文件操作已经没有ioctl方法，所以不在介绍了

打开及关闭操作

打开关闭函数于之前的设备驱动没有差异，故不叙述

读写操作

首先获取信号量（读写操作都一样）

 if(down_interruptible(&dev->semp) < 0)
    {
        printk(KERN_ERR "[%s]get the mutex lock error %d, %s",
                current->comm, __LINE__, __func__);
        return -ERESTARTSYS;
    }
    else
    {
        D("have get the mutex %d\n", __LINE__);
    }

读操作

对于读操作需要检测buffer中是否有数据
 if(dev->datawr == dev->datard) //empty buffer
     {              
  
        while(dev->datawr == dev->datard)//循环检测是否buffer中是否已经有数据
        {
            up(&dev->semp);//释放信号量 
            if(filp->f_flags & O_NONBLOCK) //检测用户是否是非阻塞打开
            {
                D("set NONBLOCK mask %d\n", __LINE__);
                return -EAGAIN;
            }
            D("[%s] reading going to sleep!", current->comm); 
            /*将当调用进程加到写等待队列*/
            if(wait_event_interruptible(dev->inq, dev->datard != dev->datawr))
            {
                return -ERESTARTSYS;
            }             
            if(down_interruptible(&dev->semp) < 0)//wait_wvent_interrupt返回，获取信号量
            {
                printk(KERN_ERR "[%s]get the mutex lock error %d, %s",
                        current->comm, __LINE__, __func__);
                return -ERESTARTSYS;
            }
            else
            {
                D("have get the mutex %d\n", __LINE__);
            }
        }
    }

看到这里你可能已经知道上边的流程图有一些错误（up 和 down 操作应该在while循环中去做，而不是在整个if 中）由于时间问题上图就不做修改了

计算buffer 剩余的数据

如果读指针在写指针之后（datard > datawr）则buffer中的数据就从读位置到buffer结尾，又buffer开头转到写位置

    if(dev->datawr < dev->datard)
    {
        data_remain = (dev->dataend - dev->datard)
                    + (dev->datawr-dev->data);
    }
    else
    {
        data_remain = dev->datawr - dev->datard;
    }
如果有一些不理解 你可以参照下边的示意图，应该很容易就理解上述计算buffer内数据长度的

判断数据长度的合法性并计算能够写入用户空间的长度

    if(data_remain < 0)
    {
        printk(KERN_ERR "the remain data we calculate is wrong check! %d \n", __LINE__);
    }
    else if(count > data_remain)
    {
        WAR("the data is less than the user want to read\n");
        D("we can only copy %d bytes to user\n", data_remain);
        count = data_remain;
    }
    else
    {
    }

向用户空间传入数据

1、当读取操作不会读到buffer尾部时候，直接将数据copy给用户，调整读指针， 唤醒睡眠在写队列上的进程，释放信号量，相用户返回已经读取的数据长度

    if(( dev->datawr > dev->datard ) || (dev->datard + count <= dev->dataend))
    {
        err = copy_to_user(userstr, dev->datard, count);
        if(err != 0)
        {
            printk(KERN_ERR "an error occured when copy data to user:%d\n", __LINE__);
            up(&dev->semp);
            return err;
        }
        else
        {
            D("data copy to user OK\n");
            dev->datard = dev->datard + count;            
            if(dev->datard == dataend)
                 dev->datard = dev->data;
            wake_up_interruptible(&dev->outq);
            up(&dev->semp);
            return count;
        }
    }


2、如果读到buffer末尾还需要绕回来从数据头部再读取

则先读取read 指针到buffer末尾的数据

然后再从头部读取相应长度的数据

同样在成功读取后需要唤醒写等待队列， 调整读指针， 释放信号量

        else
        {
            data_remain= (dev->dataend -dev->datard ); 

            /*读取从当前位置到buffer结尾的数据长度*/
            err = copy_to_user(userstr, dev->datard+1, data_remain);
            if(err != 0)
            {
                printk(KERN_ERR "an error occured when copy data to user:%d\n", __LINE__);
                up(&dev->semp);
                return err;
            }
            else
            {
                D("data copy to user OK\n");
            //  up(&dev->semp);
            }           
             
          
            /*从buffer头部读取剩余的长度*/       
            err = copy_to_user(userstr+data_remain, dev->data, count-data_remain);
            if(err != 0)
            {
                printk(KERN_ERR "an error occured when copy data to user:%d\n", __LINE__);
                up(&dev->semp);
                return err;
            }
            else
            {
                D("data copy to user OK\n");
                dev->datard = dev->data+(count-data_remain);
                wake_up_interruptible(&dev->outq);
                up(&dev->semp);
                return count;
            }
        }

写操作

与读操作类似

获取即将写入的位置

检测buffer是否已经满需要检测下即将写入的地址是否有效（是否已经到了尾部位置），如果数据已经写到buffer的结尾则需要调整写

    if (dev->datawr+1 == dev->dataend)//即将写入的位置是buffer尾部
        next_ptr = dev->data;         //调整写入指针的指向
    else
        next_ptr = dev->datawr + 1;

判断buffer是否已满
当即将写入的位置 正好是读指针指向的位置则表示buffer已满需要等待读进程 

    if( next_ptr == dev->datard )
    {
        while(next_ptr == dev->datard)
        {
            up(&dev->semp);
            if(filp->f_flags & O_NONBLOCK)
            {
                D("set NONBLOCK mask %d\n", __LINE__);
                return -EAGAIN;
            }
            D("[%s] writing going to sleep!", current->comm);

            if(wait_event_interruptible(dev->outq, next_ptr != dev->datard))
            {
                return -ERESTARTSYS;
            }

            if(down_interruptible(&dev->semp) < 0)
            {
                printk(KERN_ERR "[%s]get the mutex lock error %d, %s",
                        current->comm, __LINE__, __func__);
                return -ERESTARTSYS;
            }
            else
            {
                D("have get the mutex %d\n", __LINE__);
            }
        }
    }

计算buffer剩余长度（可以写入的数据的长度）
同样需要分两种情况，可以参照上图 

    if(dev->datawr >= dev->datard)
    {
        remain_space = (dev->dataend - dev->datawr-1)
                    + (dev->datard - dev->data);
    }
    else
    {
        remain_space = dev->datard - dev->datawr - 1;
    }

向buffer写入数据调整读写指针
    if( (dev->datawr < dev->datard) || (dev->datawr + count < dev->dataend) )
    {
        err = copy_from_user(dev->datawr, userstr, count);
        if(err != 0)
        {
            printk(KERN_ERR "error occured when copy data from user %d\n", __LINE__);
            up(&dev->semp);
            return err;
        }
        else
        {
            D("data copy from user OK\n");
            dev->datawr = dev->datawr + count ;
            wake_up_interruptible(&dev->inq);
            up(&dev->semp);
            return count;
        }
    }

    else
    {
        remain_space = dev->dataend - dev->datawr ;
        err = copy_from_user(dev->datawr, userstr, remain_space);
        if(err != 0)
        {
            printk(KERN_ERR "error occured when copy data from user %d\n", __LINE__);
            up(&dev->semp);
            return err;
        }
        else 
        {
           D("copy part of the data from user\n");
        }
        err = copy_from_user(dev->data, userstr+remain_space, count-remain_space);
        if(err != 0)
        {
            printk(KERN_ERR "error occured when copy data from user %d\n", __LINE__);
            up(&dev->semp);
            return err;
       }
       else{
           D("data copy from user OK\n");
           dev->datawr = dev->data + (count-remain_space);
           wake_up_interruptible(&dev->inq);
           up(&dev->semp);
           return count;
      }
  }

poll方法

在等待队列上调用poll_wait

    poll_wait(filp, &dev->inq, wait);
    poll_wait(filp, &dev->outq, wait);

检测文件是否可读或者可写

    if(dev->datard != dev->datawr)
    {
        mask |= POLLIN | POLLRDNORM;   //can be read
    }

    if(dev->datawr+1 == dev->dataend)
        next_ptr = dev->data;
    else
        next_ptr = dev->datawr+1;

    if(next_ptr != dev->datard)
    {
        mask |= POLLOUT | POLLWRNORM; //can be write
    }

jshazk1989
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
linux内核pipe机制实现
05-24
在驱动程序内部，阻塞在read调用的进程在数据到达时被唤醒；通常硬件会发一个中断来通知这个事件，然后作为中断程序处理的一部分驱动程序会唤醒等待进程。当没有硬件或中断处理程序时（如示例scull字符设备模拟程序）我们可以使用一个缓冲区和另一个进程写进程来产生数据并唤醒读取进程；类似的，阻塞在缓冲区write调用上的写进程也可以有另一读进程唤醒。这就是实现类管道设备的一种特殊设备驱动。请将示例scull设备驱动改造为这种管道类设备驱动程序。
linux字符驱动实现pipe
weixin_42561936的博客
06-11 422
初探linux设备驱动：字符设备驱动编写实现多通道pipe基本步骤驱动需求细节代码Makefile执行效果观察卸载调试要点 基本步骤 驱动所需结构体定制，驱动基本操作函数映射（struct file_operations)，xx_init(), xx_exit(), _open(), xx _release()…,最后要用module_init(),module_exit(),指明函数入出口，再...
Linux设备驱动模型之字符设备
chengwei_peng
09-16 174
Linux的字符设备
【Linux driver】一个简单的字符设备虚拟驱动
最新发布
TakakiTohno的博客
05-23 602
本文章只是记录一下，怎么写一个简单的字符设备驱动。
用字符设备实现一个pipe
如是我闻
11-01 652
/****************************************************************************** *Name: memdev.c *Desc: 字符设备驱动程序的框架结构 *Parameter: *Return: *Author: derek *Date: 2013-6-4 ************************
Assembly Language Step-By-Step - (Wiley, 2009, 0470497025).pdf
04-21
《Assembly Language Step-by-Step: Programming with Linux》（第三版）是一本深入讲解汇编语言及其在Linux环境下的应用的专业书籍。本书由Jeff Duntemann编写，并于2009年由Wiley出版社出版。该书不仅适合初学者...
Assembly.Language.Step-by-Step.-.Programming.with.Linux,.3rd.Edition.Oct.2009
04-12
《Assembly Language Step-by-Step: Programming with Linux, 3rd Edition》是一本深入浅出地讲解汇编语言编程的专业书籍，由Jeff Duntemann撰写，于2009年10月由Wiley Publishing, Inc.出版。这本书是汇编语言学习...
Zynq-7000-for-Hardware-Engineers.rar_ZYNQ 教程_step by step_zynq_z
07-13
软件开发则涵盖了嵌入式Linux的配置、驱动程序编写以及应用程序开发。通过实际操作，学习者将能掌握如何在Zynq-7000上实现软硬件协同设计。 在Zynq-7000的可扩展处理平台设计中，重要的一环是如何利用Vivado工具...
Assembly.Language.Step-by-Step
07-30
《汇编语言步步深入》是一本专注于探讨汇编语言、CPU工作原理以及内存管理的经典教程。...通过《汇编语言步步深入》这本书，读者可以逐步掌握汇编语言的精髓，为后续的系统编程、驱动开发或者性能优化打下坚实基础。
Linux简单字符设备测试例子
05-30
Linux简单字符设备测试例子，很久前写的，有兴趣可到www.latelee.org上看看。
操作系统虚拟字符设备
12-14
<span style="font-family: Microsoft YaHei;">/* * This struct defines a memory VMM memory area. There is color: black; background-color: #a0ffff;">vm_area_struct { struct mm_struct * vm_mm; /* VM area parameters */ unsigned long vm_start; unsigned long vm_end; /* linked list of VM areas per task, sorted by address */ struct vm_area_struct *vm_next; pgprot_t vm_page_prot; unsigned long vm_flags; /* AVL tree of VM areas per task, sorted by address */ short vm_avl_height; struct vm_area_struct * vm_avl_left; struct vm_area_struct * vm_avl_right; /* For areas with an address space and backing store, * font-size: 10px;">vm_area_struct *vm_next_share; struct vm_area_struct **vm_pprev_share; struct vm_operations_struct * vm_ops; unsigned long vm_pgoff; /* offset in PAGE_SIZE units, *not* PAGE_CACHE_SIZE */ struct file * vm_file; unsigned long vm_raend; void * vm_private_data; /* was vm_pte (shared mem) */ }; </span>
Windows下模拟linux pipe
张利 的博客
08-07 347
linux下的管道可以通过select来捕获事件，在某些场景下非常有用，但Windows下提供的管道就不具备这种特性，为了在Windows环境下也可以实现类似的功能特性，可以用socket模拟pipe实现。代码如下： from http://www.cppblog.com/isware/archive/2011/06/30/149807.html int pipe(int fildes[2]) { int tcp1, tcp2; sockaddr_in name; memset(&name, 0,
高级字符驱动程序操作
bindingfly的博客
08-05 826
通过读/写来实现数据传输，但除了数据传输之外，还有请求设备锁门、弹出介质、报告错误信息等。 休眠：当一个进程所需要的资源得不到满足时，会标记为一种特殊状态，该状态就可以理解为休眠，休眠中的进程会被搁置在一边，等待将来的某个事件发生。 对于休眠需要记住三天规则： 1）、永远不要在原子上下文中进入休眠（原子上下文是指：执行多个步骤时，不能有任何的并发访问）； 2）、当我们被唤醒时，我们永远无法
Pulseaudio之pa_simple_write流(十九)
Android系统攻城狮
09-28 730
PulseAudio是一个声音服务器，一个后台进程从一个或多个音源（进程或输入设备）接受声音输入 然后重定向声音到一个或多个槽（声卡，远程网络PulseAudio服务，或其他进程）。 PulseAudio的一个目的通过它是重定向所有声音流，包括那些试图访问硬件的进程（像那些遗留的基于OSS的软件）。PulseAudio通过提供适配器给那些使用不同的声音系统，像aRts和ESounD。 在Linux下的典型方案，用户提供配置ALSA来使用PulseAudio提供的虚拟设备。尽管应用使用ALSA会将输出的声
Linux GPU系列-05-MESA架构 [转载]
maze的专栏
10-19 3362
代码分析本应该自下而上的，但是GPU的主要驱动主要在用户态，所以这次从用户态先开始。 而且Frame怎么画出来的，也是由用户设置state和调用draw call产生的。 下图是从DirectX Spec官网来的： MESA MESA源码里面有2套架构，现在驱动主要基于Gallium架构。 Gallium架构 MESA其实实现了很多API接口，不只是上图的OpenGL、GLX、还有OpenGL ES、OpenVG、OpenCL、VDPAU和OpenMAX等。 当前MESA驱动实现状..
NIO学习：使用Channel、Buffer写入文件
Mybooks1016的博客
08-18 255
NIO的效率要高于标准IO，因为NIO将最耗时的IO操作（填充和提取缓冲区）转移会操作系统。NIO以块为单位传输数据，相比标准IO的以字节为单位效率要高很多。 通道和缓冲时NIO的核心对象，每个NIO操作都要使用到它们。 通道是对流的模拟，但与流不同，通道的传输是双向的，一个通道可以同时用于读和写。 缓冲区是一个容器，它包含将要写入或者刚读出的数据。使用通道进行读写时都要经过缓冲区...
wpa_cli P2P 连接相关调试命令
热门推荐
随风 linux android
10-24 1万+
最近在一个客户那边调试基于p2p的wifi display， 一半都是在Android上去调这个，所以之前也没有过多研究整个p2p连接流程， 而客户现在用的是非Android平台架构， 很多东西需要协助客户debug         之前debug wifi 连接时用到了wpa_cli 来协助调试连接，那p2p怎么去调试呢？ 可以用wpa_cli协助调试吗？         查看了代码有了肯定
西门子STEP-7-V5.1编程使用手册详解
STEP-7-V5.1编程使用手册是西门子PLC编程的技术资料，提供了详细的编程使用手册，帮助用户快速掌握STEP-7-V5.1编程的技术。 STEP-7-V5.1编程使用手册的主要内容包括： 1. 安装及授权：介绍了STEP-7-V5.1编程的安装...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值