LDD3源码学习日记<八>

最新推荐文章于 2018-08-13 22:39:49 发布
最新推荐文章于 2018-08-13 22:39:49 发布
阅读量617 收藏
点赞数
分类专栏： Linux 文章标签： LDD3 POLL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cp562090732/article/details/13168463
版权

一、用户空间的poll和select测试函数

在使用者两个函数之前，需要先安装scullpipe设备，下面是他们的测试代码和注释：

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <fcntl.h>  
#include <unistd.h>  
#include <linux/poll.h>  
#include <sys/time.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
  
int main(int argc, char *argv[])  
{  
    int fd0, fd1, fd2, fd3;  
    struct pollfd poll_fd[4];  
    char buf[100];  
    int retval;  
    /*如果没有指定参数，或者参数不等于read和wtite，打印提示信息*/
    if(argc != 2 || ((strcmp(argv[1], "read") != 0) && (strcmp(argv[1], "write") != 0)))  
    {  
        printf("usage: ./poll_test read|write\n");  
        return -1;  
    }  
  
    fd0 = open("/dev/scullpipe0", O_RDWR);  //打开设备scullpipe0
    if ( fd0 < 0)  
    {  
        printf("open scullpipe0 error\n");  
        return -1;  
    }  
      
    fd1 = open("/dev/scullpipe1", O_RDWR);  //打开设备scullpipe1
    if ( fd1 < 0)  
    {  
        printf("open scullpipe1 error\n");  
        return -1;  
    }  
      
    fd2 = open("/dev/scullpipe2", O_RDWR);  //打开设备scullpipe2
    if ( fd2 < 0)  
    {  
        printf("open scullpipe2 error\n");  
        return -1;  
    }  
      
    fd3 = open("/dev/scullpipe3", O_RDWR);  //打开设备scullpipe3
    if ( fd3 < 0)  
    {  
        printf("open scullpipe3 error\n");  
        return -1;  
    }  
  
    if(strcmp(argv[1], "read") == 0)  	//如果是read
    {  
        poll_fd[0].fd = fd0;  		
        poll_fd[1].fd = fd1;  
        poll_fd[2].fd = fd2;  
        poll_fd[3].fd = fd3;  
  
        poll_fd[0].events = POLLIN | POLLRDNORM;  	//检查是否可读，一般为固定搭配
        poll_fd[1].events = POLLIN | POLLRDNORM;  
        poll_fd[2].events = POLLIN | POLLRDNORM;  
        poll_fd[3].events = POLLIN | POLLRDNORM;  
  
        retval = poll(poll_fd, 4, 10000); 		//监测poll_fd数组里面的4个文件，并设置超时时间为10，000毫秒 
    }  
    else  
    {  
        poll_fd[0].fd = fd0;  
        poll_fd[1].fd = fd1;  
        poll_fd[2].fd = fd2;  
        poll_fd[3].fd = fd3;  
  
        poll_fd[0].events = POLLOUT | POLLWRNORM;  	//检查是否可写
        poll_fd[1].events = POLLOUT | POLLWRNORM;  
        poll_fd[2].events = POLLOUT | POLLWRNORM;  
        poll_fd[3].events = POLLOUT | POLLWRNORM;  
          
        retval = poll(poll_fd, 4, 10000);  
    }  
  
    if (retval == -1)  					//poll返回一个负数，说明poll调用出错
    {  
        printf("poll error!\n");  
        return -1;  
    }  
    else if (retval)  					//poll函数如果返回一个正数，代表内核返回了状态(保存在pollfd.revents中)的文件描述符的个数
    {  
        if(strcmp(argv[1], "read") == 0)  
        {  
            if(poll_fd[0].revents & (POLLIN | POLLRDNORM))  
            {  
                printf("/dev/scullpipe0 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd0, buf, 100);  
                printf("%s\n", buf);  
            }  
  
            if(poll_fd[1].revents & (POLLIN | POLLRDNORM))  
            {  
                printf("/dev/scullpipe1 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd1, buf, 100);  
                printf("%s\n", buf);  
            }  
  
            if(poll_fd[2].revents & (POLLIN | POLLRDNORM))  
            {  
                printf("/dev/scullpipe2 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd2, buf, 100);  
                printf("%s\n", buf);  
            }  
  
            if(poll_fd[3].revents & (POLLIN | POLLRDNORM))  
            {  
                printf("/dev/scullpipe3 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd3, buf, 100);  
                printf("%s\n", buf);  
            }  
        }  
        else  							
        {  
            if(poll_fd[0].revents & (POLLOUT | POLLWRNORM))  
            {  
                printf("/dev/scullpipe0 is writable!\n");  
            }  
  
            if(poll_fd[1].revents & (POLLOUT | POLLWRNORM))  
            {  
                printf("/dev/scullpipe1 is writable!\n");  
            }  
  
            if(poll_fd[2].revents & (POLLOUT | POLLWRNORM))  
            {  
                printf("/dev/scullpipe2 is writable!\n");  
            }  
  
            if(poll_fd[3].revents & (POLLOUT | POLLWRNORM))  
            {  
                printf("/dev/scullpipe3 is writable!\n");  
            }  
        }  
    }  
    else  //如果poll返回0，表明是因为超时而返回的
    {  
        if(strcmp(argv[1], "read") == 0)  
        {  
            printf("No data within ten seconds.\n");  
        }  
        else  
        {  
            printf("Can not write within ten seconds.\n");  
        }  
    }  
  
    return 0;  
}  

#include <stdio.h>  
#include <stdlib.h>  
#include <string.h>  
#include <fcntl.h>  
#include <unistd.h>  
#include <sys/time.h>  
#include <sys/types.h>  
#include <sys/stat.h>  
  
int main(int argc, char *argv[])  
{  
    fd_set rfds, wfds;  
    int fd0, fd1, fd2, fd3;  
    char buf[100];  
    int retval;      
  
    /* Wait up to ten seconds. */  
    struct timeval tv;  
    tv.tv_sec = 10;  
    tv.tv_usec = 0;  
  
    if(argc != 2 || ((strcmp(argv[1], "read") != 0) && (strcmp(argv[1], "write") != 0)))  
    {  
        printf("usage: ./select_test read|write\n");  
        return -1;  
    }  
  
    fd0 = open("/dev/scullpipe0", O_RDWR);  
    if ( fd0 < 0)  
    {  
        printf("open scullpipe0 error\n");  
        return -1;  
    }  
      
    fd1 = open("/dev/scullpipe1", O_RDWR);  
    if ( fd1 < 0)  
    {  
        printf("open scullpipe1 error\n");  
        return -1;  
    }  
      
    fd2 = open("/dev/scullpipe2", O_RDWR);  
    if ( fd2 < 0)  
    {  
        printf("open scullpipe2 error\n");  
        return -1;  
    }  
      
    fd3 = open("/dev/scullpipe3", O_RDWR);  
    if ( fd3 < 0)  
    {  
        printf("open scullpipe3 error\n");  
        return -1;  
    }  
  
    if(strcmp(argv[1], "read") == 0)  
    {  
        FD_ZERO(&rfds);  
        FD_SET(fd0, &rfds);  
        FD_SET(fd1, &rfds);  
        FD_SET(fd2, &rfds);  
        FD_SET(fd3, &rfds);  
        retval = select(fd3 + 1, &rfds, NULL, NULL, &tv);  
    }  
    else  
    {  
        FD_ZERO(&wfds);  
        FD_SET(fd0, &wfds);  
        FD_SET(fd1, &wfds);  
        FD_SET(fd2, &wfds);  
        FD_SET(fd3, &wfds);  
        retval = select(fd3 + 1, NULL, &wfds, NULL, &tv);  
    }  
  
    if (retval == -1)  
    {  
        printf("select error!\n");  
        return -1;  
    }  
    else if (retval)  
    {  
        if(strcmp(argv[1], "read") == 0)  
        {  
            if(FD_ISSET(fd0, &rfds))  
            {  
                printf("/dev/scullpipe0 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd0, buf, 100);  
                printf("%s\n", buf);  
            }  
  
            if(FD_ISSET(fd1, &rfds))  
            {  
                printf("/dev/scullpipe1 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd1, buf, 100);  
                printf("%s\n", buf);  
            }  
  
            if(FD_ISSET(fd2, &rfds))  
            {  
                printf("/dev/scullpipe2 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd2, buf, 100);  
                printf("%s\n", buf);  
            }  
  
            if(FD_ISSET(fd3, &rfds))  
            {  
                printf("/dev/scullpipe3 is readable!\n");  
                memset(buf, 0, 100);  
                read(fd3, buf, 100);  
                printf("%s\n", buf);  
            }  
        }  
        else  
        {  
            if(FD_ISSET(fd0, &wfds))  
            {  
                printf("/dev/scullpipe0 is writable!\n");  
            }  
  
            if(FD_ISSET(fd1, &wfds))  
            {  
                printf("/dev/scullpipe1 is writable!\n");  
            }  
  
            if(FD_ISSET(fd2, &wfds))  
            {  
                printf("/dev/scullpipe2 is writable!\n");  
            }  
  
            if(FD_ISSET(fd3, &wfds))  
            {  
                printf("/dev/scullpipe3 is writable!\n");  
            }  
        }  
    }  
    else  
    {  
        if(strcmp(argv[1], "read") == 0)  
        {  
            printf("No data within ten seconds.\n");  
        }  
        else  
        {  
            printf("Can not write within ten seconds.\n");  
        }  
    }  
  
    return 0;  
}
下面是测试结果图：


二、驱动程序的poll

用户空间的poll和select都会调用到驱动程序的poll，下面是scullpipe驱动程序的poll实现

/*****************************************************************************************/
/*poll函数应该实现两个功能：

一是把能标志轮询状态变化的等待队列加入到poll_table中，这通过调用poll_wait函数实现。

二是返回指示能进行的I/O操作的标志位。

poll函数的第二个参数poll_table，是内核中用来实现poll，select系统调用的结构体，对于驱动开发者来说，
不必关心其具体内容，可以把poll_table看成是不透明的结构体，只要拿过来使用就可以了。驱动程序通过poll_wait函数，
把能够唤醒进程，改变轮询状态的等待队列加入到poll_table中。该函数定义如下：
void poll_wait (struct file *, wait_queue_head_t *, poll_table *); 
对于poll函数的第二个功能，返回的标志位与用户空间相对应，最常用的标志位是POLLIN | POLLRDNORM和POLLOUT | POLLWRNORM，
分别标志可进行非阻塞的读和写操作。*/
/*******************************************************************************************/

static unsigned int scull_p_poll(struct file *filp, poll_table *wait)
{
	struct scull_pipe *dev = filp->private_data;
	unsigned int mask = 0;

	/*
	 * The buffer is circular; it is considered full
	 * if "wp" is right behind "rp" and empty if the
	 * two are equal.
	 */
	down(&dev->sem);
	/*调用poll_wait函数将读等待队列加入到poll_table中*/
	poll_wait(filp, &dev->inq,  wait);
	/*调用poll_wait函数将写等待队列加入到poll_table中*/
	poll_wait(filp, &dev->outq, wait);
	/*如果有内容可读，设置可读标志位**/
	if (dev->rp != dev->wp)
		mask |= POLLIN | POLLRDNORM;	/* readable */
	if (spacefree(dev))
	/*如果有空间可写，设置可写标志位*/
		mask |= POLLOUT | POLLWRNORM;	/* writable */
	up(&dev->sem);
	/*将标志位返回*/
	return mask;
}
参考博客：http://blog.csdn.net/liuhaoyutz/article/details/7401418


捧灰
关注
专栏目录
c++:错误：undefined reference to `std::__cxx11::basic_string＜char, std::char_traits＜char＞,
mzhan017的博客
11-19 6981
编译出错的命令 g++ thread.cpp 代码 #include <iostream> #include <thread> using namespace std; int main(); class abc { friend int print(); protected: string m_string; public: string get(); }; string abc::get() { return m_string; }
ldd3 example
02-27
ldd3 example ldd3 example
LDD3_EXAMPLE
11-05
This is the examples of the linux device driver 3 edition. everyone may download it but the author has no responsibity for what may result.
ldd3 examples
linmy24的专栏
08-13 503
下载地址： https://github.com/ZhuXiaolin1986/LDD3-examples 已移植至 linux-4.15，可在Ubuntu 16.04 / 18.04上编译、测试。
Example code for LDD3
RichardYSteven的专栏
11-15 1223
作者的ftp ftp://ar.linux.it/pub/ldd3/
LDD3 example runs on arm11 based on linux-2.6.31 (1)
Lanttor的技术博文
06-15 1034
<br /> <!-- @page { margin: 0.79in } TD P { margin-bottom: 0in } P { margin-bottom: 0.08in } --> <br />LDD3 driver example run on ARM platform (1)<br /> <br />平台： i.mx31 3-stack (arm11)<br />内核版本 : Linux-2.6.31<br /> <br />
LDD3源码学习日记<五>
Just
10-26 727
这篇是关于ioctl的，全篇就这一个知识点。 首先看函数原型：int (*ioctl)(struct inode *inode, struct file *filp,unsigned int cmd, unsigned long arg); 其中，cmd是预先定义好的一些命令编号，对应要求ioctl执行的命令。arg是与cmd配合使用的参数。ioctl的实现一般是通过一个大的switch语句，
LDD3配套源码
08-19
LDD3配套源码是学习这本书的关键辅助材料，通过实践这些源码，读者可以更直观地理解书中的理论知识，进一步提升驱动开发能力。 本套源码包含了与LDD3书中各个章节相对应的示例代码，主要针对驱动开发中的核心概念和...
ldd3所有源码与示例
11-16
这个压缩包“ldd3源码”包含了书中所有的示例代码，是学习和研究Linux设备驱动程序的宝贵资源。 Linux设备驱动程序是连接硬件和操作系统内核的桥梁，它们负责管理和控制硬件资源，使得操作系统能够有效地与硬件进行...
ldd3 源码(已修改)
06-29
由于ldd3 源码是基于linux-2.6.10编写的，最新内核接口以及数据结构都有变化，因此对于新手来说，书中源码无法编译正常通过，给学习增加了不少难度，本源码是结合网上修改以及个人整理的，能够在linux-2.6.32-21，...
linux设备驱动 第三版 ldd3 源码
11-02
该书的源码包“ldd3_examples”包含了书中所涉及的所有示例代码，是学习和实践Linux设备驱动开发的重要资源。 在Linux设备驱动程序开发中，我们首先需要理解设备驱动的基本概念。设备驱动是操作系统和硬件之间的...
LDD3
菩提本無樹
02-12 1206
ldd3: Linux Device Drivers 3 examples updated to work with recent kernels About ----- Linux Device Drivers 3 (http://lwn.net/Kernel/LDD3/) book is now a few years old and most of the examp
ldd3测试代码
liu0808的专栏
12-07 509
http://blog.chinaunix.net/uid-14753126-id-93946.html scull驱动模拟设备。编写读写设备的控制文件testscull.c向scull发送和接收数据。 1 安装scull.ko   在ldd3驱动源码文件夹中，进入scull文件夹，make,生成scull.ko，运行其中的shell文件:scull_load,完成s
LDD3源码分析之poll分析
Linux/Android开发记录
03-27 5546
作者：刘昊昱  博客：http://blog.csdn.net/liuhaoyutz 编译环境：Ubuntu 10.10 内核版本：2.6.32-38-generic-pae LDD3源码路径：examples/scull/pipe.c  examples/scull/main.c   本文分析LDD3第6章的poll(轮询)操作。要理解驱动程序中poll函数的作用和实现，必须先
ldd3学习之九：与硬件通信
科学边界
03-29 295
1.I/O 端口和 I/O 内存每种外设都是通过读写寄存器来进行控制。在硬件层，内存区和 I/O 区域没有概念上的区别: 它们都是通过向在地址总线和控制总线发出电平信号来进行访问，再通过数据总线读写数据。因为外设要与I\O总线匹配，而大部分流行的 I/O 总线是基于个人计算机模型（主要是 x86 家族：它为读和写 I/O 端口提供了独立的线路和特殊的 CPU 指令），所以即便那些没有单独I/O 端
树莓派系统启动:PANIC: VFS Unable to mount root fs on unknown-block(179,2)
热门推荐
Just
06-24 1万+
树莓派驱动过程中，内核报错： KERNEL PANIC: VFS Unable to mount root fs on unknown-block(179,2) 原因是sd卡中的内容被不小心修改，主要是mmcblk0p2分区，将系统sd卡取下，插入到ubuntu中， 执行： sudo fsck -f -v -r /dev/sdb2 即可修复。重启，一切正常
树莓派实现自己的Qt HTTPserver
Just
05-16 2928
1. 目标本文以树莓派为硬件，搭建一个本地的httpserver，用于产品中的各种测试。树莓派有了httpserver后，可以跨平台访问，实现了跨平台访问硬件的目标。2. 清单这里列举所需要的清单: 2016-9-28 jessie-lite树莓派系统镜像 Qt5+boost+opencv xvfb,实现后台运行带窗口的界面 daemontool管理后台服务器 wifi-access-point脚本
LDD3源码学习日记<七>
Just
10-27 1215
这篇是学习关于阻塞IO的源码内容，源代码在examples/scull/pipe.c  examples/scull/main.c中，下面开始分析源代码： 一、代码分析 scullpipe使用一个进程来产生数据并唤醒读取进程，类似的，利用读取进程来唤醒等待缓冲区可用的写入进程，scullpipe的主体实现在examples/scull/pipe.c中，但是也利用了examples/scull/
LDD3经典教程例程源码解析与学习指南
根据提供的文件描述，“LDD3-examples_felltrz_linux_”中的例子源码被认为是非常不错的学习材料。这意味着，例子代码经过精心设计，能够覆盖广泛的主题，并且质量较高，能够有效地辅助学习者掌握Linux设备驱动开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值