linux设备驱动归纳总结（三）：6.poll和sellct

朴灿烈づ我的快乐病毒、 2022-03-20 19:39 180阅读 0赞

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

接下来会讲系统调用select在驱动中的实现，如果对系统调用select不太懂的话，建议先看书补习一下。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、系统调用select的简介

简单来说，select这个系统调用的作用就是在应用层调用驱动函数中的poll来检测指定的文件的状态（读、写和异常）。如果某个状态满足，select函数调用成功后返回，应用程序就可以通过指定的函数来判断现在的文件状态。注意的是：select可以指定判断的时间，指定时间内，应用程序会阻塞在select函数，直到状态满足或者超时。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、驱动函数poll的实现

先上代码：

9 \#include <linux/poll.h>

11 \#include <asm/uaccess.h>

12 \#include <linux/errno.h>

。。。。。。省略。。。。。。

23 struct \_test\_t\{

24 char kbuf\[DEV\_SIZE\];

25 unsigned int major;

26 unsigned int minor;

27 unsigned int cur\_size;

28 dev\_t devno;

29 struct cdev test\_cdev;

30 wait\_queue\_head\_t test\_queue;

31 wait\_queue\_head\_t read\_queue; //定义等待队列

32 \};

。。。。。。省略。。。。。。。

70 ssize\_t test\_write(struct file \*filp, const char \_\_user \*buf, size\_t count, loff\_t \*offset)

71 \{

72 int ret;

73 struct \_test\_t \*dev = filp->private\_data;

75 if(copy\_from\_user(dev->kbuf, buf, count))\{

76 ret = - EFAULT;

77 \}else\{

78 ret = count;

79 dev->cur\_size += count;

80 P\_DEBUG("write %d bytes, cur\_size:\[%d\]\\n", count, dev->cur\_size);

81 P\_DEBUG("kbuf is \[%s\]\\n", dev->kbuf);

82 wake\_up\_interruptible(&dev->test\_queue);

83 wake\_up\_interruptible(&dev->read\_queue); //唤醒等待队列

84 \}

86 return ret; //返回实际写入的字节数或错误号

87 \}

88 /\*poll的实现\*/

89 unsigned int test\_poll (struct file \*filp, struct poll\_table\_struct \*table)

90 \{

91 struct \_test\_t \*dev = filp->private\_data;

92 unsigned int mask = 0;

94 poll\_wait(filp, &dev->read\_queue, table);

96 if(dev->cur\_size > 0) //设备可读

97 mask |= POLLIN;

99 P\_DEBUG("\*\*\*maks\[%d\]\*\*\*\\n", mask);

100 return mask;

101 \}

102

103 struct file\_operations test\_fops = \{

104 .open = test\_open,

105 .release = test\_close,

106 .write = test\_write,

107 .read = test\_read,

108 .poll = test\_poll, //切记要添加，不然多牛X的代码都不能执行

109 \};

110

111 struct \_test\_t my\_dev;

112

113 static int \_\_init test\_init(void) //模块初始化函数

114 \{

115 int result = 0;

116 my\_dev.cur\_size = 0;

117 my\_dev.major = 0;

118 my\_dev.minor = 0;

119

120 if(my\_dev.major)\{

121 my\_dev.devno = MKDEV(my\_dev.major, my\_dev.minor);

122 result = register\_chrdev\_region(my\_dev.devno, 1, "test new driver") ;

123 \}else\{

124 result = alloc\_chrdev\_region(&my\_dev.devno, my\_dev.minor, 1, "test alloc diver");

125 my\_dev.major = MAJOR(my\_dev.devno);

126 my\_dev.minor = MINOR(my\_dev.devno);

127 \}

128

129 if(result < 0)\{

130 P\_DEBUG("register devno errno!\\n");

131 goto err0;

132 \}

133

134 printk("major\[%d\] minor\[%d\]\\n", my\_dev.major, my\_dev.minor);

135

136 cdev\_init(&my\_dev.test\_cdev, &test\_fops);

137 my\_dev.test\_cdev.owner = THIS\_MODULE;

138 /\*初始化等待队列头，注意函数调用的位置\*/

139 init\_waitqueue\_head(&my\_dev.test\_queue);

140 init\_waitqueue\_head(&my\_dev.read\_queue);

141

142 result = cdev\_add(&my\_dev.test\_cdev, my\_dev.devno, 1);

143 if(result < 0)\{

144 P\_DEBUG("cdev\_add errno!\\n");

145 goto err1;

146 \}

147

148 printk("hello kernel\\n");

149 return 0;

150

151 err1:

152 unregister\_chrdev\_region(my\_dev.devno, 1);

153 err0:

154 return result;

155 \}

。。。。。省略。。。。。

poll函数的实现同样需要使用等待队列，在这里没有把上节阻塞型IO代码注释掉，主要是想说明一个问题，它们两个的功能是不一样的，并不会冲突。后面会具体讲述。

上面的函数其实也就三部：

1定义并初始化等待队列头；

2实现test\_poll；

3唤醒等待队列。

接下来先对照程序说一下poll函数的实现：

1）定义等待队列头：

poll\_wait函数里面的操作需要用到等待队列，所以需要定义并初始化等待队列头。

2）test\_poll的实现：

test\_poll的实现有两个步骤：

2.1）调同poll\_wait，将进程添加到指定的等待队列（注意，仅仅是添加，没有休眠）。

poll\_wait的原型是：

unsigned int test\_poll (struct file \*filp, struct poll\_table\_struct \*table)

注意：这里的两个参数都不是用户传给它的，全部都是有内核传的。可以这样说，poll没有做实际的什么操作，只是返回些信息给内核来操作。

来个代码来分析poll\_wait究竟干了什么：

/\*include/linux/poll.h \*/

31 typedef void (\*poll\_queue\_proc)(struct file \*, wait\_queue\_head\_t \*, struct poll\_table\_struct \*);

33 typedef struct poll\_table\_struct \{ //poll\_table\_struct的原型

34 poll\_queue\_proc qproc;

35 \} poll\_table;

37 static inline void poll\_wait(struct file \* filp, wait\_queue\_head\_t \* wait\_address, poll\_table \*p)

38 \{

39 if (p && wait\_address)

40 p->qproc(filp, wait\_address, p); //这里就断了线索

41 \}

43 static inline void init\_poll\_funcptr(poll\_table \*pt, poll\_queue\_proc qproc)

44 \{

45 pt->qproc = qproc;

46 \}

48 struct poll\_table\_entry \{

49 struct file \*filp;

50 wait\_queue\_t wait;

51 wait\_queue\_head\_t \*wait\_address;

52 \};

。。。。。省略。。。。。

57 struct poll\_wqueues \{

58 poll\_table pt;

59 struct poll\_table\_page \*table;

60 struct task\_struct \*polling\_task;

61 int triggered;

62 int error;

63 int inline\_index;

64 struct poll\_table\_entry inline\_entries\[N\_INLINE\_POLL\_ENTRIES\];

65 \};

poll\_wait执行了一个函数，但没找出函数是做什么的。在另外的文件我找到一点线索：

/\*fs/select.c\*/

85 struct poll\_table\_page \{

86 struct poll\_table\_page \* next;

87 struct poll\_table\_entry \* entry;

88 struct poll\_table\_entry entries\[0\];

89 \};

。。。。。。。。

198 /\* Add a new entry \*/

199 static void \_\_pollwait(struct file \*filp, wait\_queue\_head\_t \*wait\_address,

200 poll\_table \*p)

201 \{

202 struct poll\_wqueues \*pwq = container\_of(p, struct poll\_wqueues, pt);

203 struct poll\_table\_entry \*entry = poll\_get\_entry(pwq);

204 if (!entry)

205 return;

206 get\_file(filp);

207 entry->filp = filp;

208 entry->wait\_address = wait\_address;

209 init\_waitqueue\_func\_entry(&entry->wait, pollwake);

210 entry->wait.private = pwq;

211 add\_wait\_queue(wait\_address, &entry->wait);

212 \}

因为函数的传参和名字都差不多，我猜想内核是调用该函数的。

从上面的代码和《设备驱动程序》我得出来一下的结论：

1.应用层调用函数select，内核为了管理等待队列（有时候不止一个等待队列，因为select函数可以检测多个文件的状态），建立了一个poll\_table\_struct结构体（一个select系统调用对应一个结构体）。

2.poll\_wait函数的调用，将三个参数传给了内核。内核中，通过结构体poll\_table\_struct找到另一个结构体poll\_table\_page，上面的代码可以看出来，这个结构体是一个维护多个poll\_table\_entry结构体的内存页链表，poll\_wait函数的参数就是传到poll\_table\_entry结构体中。

3.再看一下poll\_table\_entry里面的成员，第一个成员srutct file是poll\_wait的第一个参数，第二个成员就是定义了一个wait\_queue\_t的结构体，而这个结构体是正要添加到等待队列头中，也就是从poll\_wait传来的第二个参数。

4.现在重头戏了，poll\_wait的调用实际上调用了\_\_pollwiat。看一下大概的操作：

4.1使用container\_of函数，通过poll\_table（即poll\_table\_struct）找到poll\_wqueues，一看名字就猜到，它是存放等待队列的！poll\_wqueues包含成员poll\_table\_page。

4.2通过传入的filp和等待队列头两个参数，新建一个poll\_table\_enter并添加到poll\_table\_page中。

2.2）对应设备的状态，返回相应的掩码。那就是说，如果设备可读，那就返回可读的掩码。

什么是掩码？有什么掩码？

<table> 
 <tbody> 
 <tr> 
 <td style="line-height:1.5"> 掩码 </td> 
 <td style="line-height:1.5"> 含义 </td> 
 </tr> 
 <tr> 
 <td style="line-height:1.5"> POLLIN </td> 
 <td style="line-height:1.5"> 设备可读。 </td> 
 </tr> 
 <tr> 
 <td style="line-height:1.5"> POLLRDNORM </td> 
 <td style="line-height:1.5"> 数据可读。一般的，驱动可读，返回(POLLIN|POLLRDNORM)，当然，只返回POLLIN也行，因为意思其实都可不多 </td> 
 </tr> 
 <tr> 
 <td style="line-height:1.5"> POLLOUT </td> 
 <td style="line-height:1.5"> 设备可写 </td> 
 </tr> 
 <tr> 
 <td style="line-height:1.5"> POLLWRNORM </td> 
 <td style="line-height:1.5"> 数据可写。一般的，驱动可写，返回(POLLOUT|POLLWRNORM)，当然，只返回POLLOUT也行，因为意思其实都可不多 </td> 
 </tr> 
 </tbody> 
</table>

当然，还有其他的掩码，我这里就不意义介绍。

3）唤醒等待队列

其实一开始我也很奇怪为什么需要唤醒，毕竟poll\_wait函数并不会导致休眠。为什么要唤醒？在哪里唤醒？

我上面的驱动函数，test\_poll返回掩码，如果掩码为0，则表示设备不可读，这时，内核接到返回的掩码，知道设备不可读，此时select函数就会阻塞，进程休眠，等待有数据时被唤醒。所以，在写入数据后，需要唤醒等待队列头read\_queue。此时设备可读了，就会再次调用test\_poll函数，返回掩码POLLIN，select调用成功。

所以，这里得出两个结论：

1.test\_poll并不会导致休眠，进程阻塞是系统调用select搞的鬼。

2.系统调用select的阻塞会导致test\_poll被调用多次。

既然大概知道了函数怎么写的。那就验证一下程序吧。应用程序我就不贴了。在app目录下，直接来结果：

现象一：先写后读

\[root: 1st\]\# insmod test.ko

major\[253\] minor\[0\]

hello kernel

\[root: 1st\]\# mknod /dev/test c 253 0

\[root: app\]\# ./monitor& //1.先后台运行检测程序monitor

<kernel>\[test\_poll\]\*\*\*maks\[0\]\*\*\* //2.在我还没写之前，test\_poll被调度了两遍后阻塞

<kernel>\[test\_poll\]\*\*\*maks\[0\]\*\*\*

\[root: app\]\# ./app\_write //3过了一段时间，我写入数据

<kernel>\[test\_write\]write 10 bytes, cur\_size:\[10\]

<kernel>\[test\_write\]kbuf is \[xiao bai\]

<kernel>\[test\_poll\]\*\*\*maks\[1\]\*\*\* //4.test\_poll再次被调用，掩码改变了！

<app>monitor:\[device readable\]

\[root: app\]\# <kernel>\[test\_poll\]\*\*\*maks\[1\]\*\*\*

<app>monitor:\[device readable\] //5select隔四秒就调用一遍，没有被阻塞

<kernel>\[test\_poll\]\*\*\*maks\[1\]\*\*\*

<app>monitor:\[device readable\]

<kernel>\[test\_poll\]\*\*\*maks\[1\]\*\*\*

<app>monitor:\[device readable\]

<kernel>\[test\_poll\]\*\*\*maks\[1\]\*\*\*

<app>monitor:\[device readable\]

\[root: app\]\# ./app\_read //6我读数据

<kernel>\[test\_read\]read data.....

<kernel>\[test\_read\]read 10 bytes, cur\_size:\[0\]

<app\_read>\[xiao bai\]

\[root: app\]\# <kernel>\[test\_poll\]\*\*\*maks\[0\]\*\*\* //7读完他又阻塞了。

现象二：先写后读

\[root: app\]\# ./monitor& //1.先后台运行检测程序monitor

<kernel>\[test\_poll\]\*\*\*maks\[0\]\*\*\* //2.在我还没写之前，test\_poll被调度了两遍后阻塞

<kernel>\[test\_poll\]\*\*\*maks\[0\]\*\*\*

\[root: app\]\# ./app\_read& //3.再后台运行read

\[root: app\]\# <kernel>\[test\_read\]read data..... //4.它阻塞了，这里不关poll的原因，这是因为上节说的阻塞型IO

\[root: app\]\# ./app\_write//5.再写数据

<kernel>\[test\_write\]write 10 bytes, cur\_size:\[10\]

<kernel>\[test\_write\]kbuf is \[xiao bai\]

<kernel>\[test\_poll\]\*\*\*maks\[1\]\*\*\* //select被唤醒，返回可读掩码

<kernel>\[test\_read\]read 10 bytes, cur\_size:\[0\] //test\_read被唤醒，读取数据

<app>monitor:\[device readable\]

<app\_read>\[xiao bai\]

\[2\] + Done ./app\_read

\[root: app\]\# <kernel>\[test\_poll\]\*\*\*maks\[0\]\*\*\* //没数据，select又阻塞了

注：上面的驱动程序使用了两个等待队列头，细心可以发现，其实只要一个等待队列头，就可以实现阻塞型IO和poll了。具体就不讲解了，程序在3rd\_char\_6/and，很简单的改动。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、poll同时检测可读和可写两个状态：

也很简单，直接上程序

/\*3rd\_char\_6/2st/test.c\*/

23 struct \_test\_t\{

24 char kbuf\[DEV\_SIZE\];

25 unsigned int major;

26 unsigned int minor;

27 unsigned int cur\_size;

28 dev\_t devno;

29 struct cdev test\_cdev;

30 wait\_queue\_head\_t test\_queue;

31 wait\_queue\_head\_t read\_queue; //定义两个等待队列

32 wait\_queue\_head\_t write\_queue;

33 \};

。。。。。。省略。。。。。。。

48 ssize\_t test\_read(struct file \*filp, char \_\_user \*buf, size\_t count, loff\_t \*offset)

49 \{

50 int ret;

51 struct \_test\_t \*dev = filp->private\_data;

53 if(filp->f\_flags & O\_NONBLOCK)

54 return - EAGAIN;

56 P\_DEBUG("read data.....\\n");

57 if(wait\_event\_interruptible(dev->test\_queue, dev->cur\_size > 0))

58 return - ERESTARTSYS;

60 if (copy\_to\_user(buf, dev->kbuf, count))\{

61 ret = - EFAULT;

62 \}else\{

63 ret = count;

64 dev->cur\_size -= count;

65 P\_DEBUG("read %d bytes, cur\_size:\[%d\]\\n", count, dev->cur\_size);

66 wake\_up\_interruptible(&dev->write\_queue);

67 \}

69 return ret; //返回实际写入的字节数或错误号

70 \}

72 ssize\_t test\_write(struct file \*filp, const char \_\_user \*buf, size\_t count, loff\_t \*offset)

73 \{

74 int ret;

75 struct \_test\_t \*dev = filp->private\_data;

77 if(copy\_from\_user(dev->kbuf, buf, count))\{

78 ret = - EFAULT;

79 \}else\{

80 ret = count;

81 dev->cur\_size += count;

82 P\_DEBUG("write %d bytes, cur\_size:\[%d\]\\n", count, dev->cur\_size);

83 P\_DEBUG("kbuf is \[%s\]\\n", dev->kbuf);

84 wake\_up\_interruptible(&dev->test\_queue);

85 wake\_up\_interruptible(&dev->read\_queue);

86 \}

88 return ret; //返回实际写入的字节数或错误号

89 \}

91 unsigned int test\_poll (struct file \*filp, struct poll\_table\_struct \*table)

92 \{

93 struct \_test\_t \*dev = filp->private\_data;

94 unsigned int mask = 0;

96 poll\_wait(filp, &dev->read\_queue, table);

97 poll\_wait(filp, &dev->write\_queue, table);

99 if(dev->cur\_size > 0) //设备可读

100 mask |= POLLIN;

101 if(dev->cur\_size < DEV\_SIZE) //设备可写

102 mask |= POLLOUT;

103

104 P\_DEBUG("\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\\n");

105 return mask;

106 \}

107

108 struct file\_operations test\_fops = \{

109 .open = test\_open,

110 .release = test\_close,

111 .write = test\_write,

112 .read = test\_read,

113 .poll = test\_poll,

114 \};

115

116 struct \_test\_t my\_dev;

117

118 static int \_\_init test\_init(void) //模块初始化函数

119 \{

120 int result = 0;

121 my\_dev.cur\_size = 0;

122 my\_dev.major = 0;

123 my\_dev.minor = 0;

124

125 if(my\_dev.major)\{

126 my\_dev.devno = MKDEV(my\_dev.major, my\_dev.minor);

127 result = register\_chrdev\_region(my\_dev.devno, 1, "test new driver") ;

128 \}else\{

129 result = alloc\_chrdev\_region(&my\_dev.devno, my\_dev.minor, 1, "test alloc diver");

130 my\_dev.major = MAJOR(my\_dev.devno);

131 my\_dev.minor = MINOR(my\_dev.devno);

132 \}

133

134 if(result < 0)\{

135 P\_DEBUG("register devno errno!\\n");

136 goto err0;

137 \}

138

139 printk("major\[%d\] minor\[%d\]\\n", my\_dev.major, my\_dev.minor);

140

141 cdev\_init(&my\_dev.test\_cdev, &test\_fops);

142 my\_dev.test\_cdev.owner = THIS\_MODULE;

143 /\*初始化等待队列头，注意函数调用的位置\*/

144 init\_waitqueue\_head(&my\_dev.test\_queue);

145 init\_waitqueue\_head(&my\_dev.read\_queue);

146 init\_waitqueue\_head(&my\_dev.write\_queue);

147

148 result = cdev\_add(&my\_dev.test\_cdev, my\_dev.devno, 1);

149 if(result < 0)\{

150 P\_DEBUG("cdev\_add errno!\\n");

151 goto err1;

152 \}

153

154 printk("hello kernel\\n");

155 return 0;

156

157 err1:

158 unregister\_chrdev\_region(my\_dev.devno, 1);

159 err0:

160 return result;

161 \}

。。。。。。。省略。。。。。。。

验证一下：注意的是，这次的select并没有阻塞，原因很简单，要不就可读要不就可写，肯定有掩码返回，根本不用阻塞。

\[root: app\]\# ./monitor& //1.执行建材程序

\[root: app\]\# <kernel>\[test\_poll\]\*\*\*mask\[4\]\*\*\*//2每个四秒调用一次select,没阻塞

<app>monitor:\[device writeable\]

<kernel>\[test\_poll\]\*\*\*mask\[4\]\*\*\*

<app>monitor:\[device writeable\]

<kernel>\[test\_poll\]\*\*\*mask\[4\]\*\*\*

<app>monitor:\[device writeable\]

\[root: app\]\# ./app\_write //3写入数据

<kernel>\[test\_write\]write 10 bytes, cur\_size:\[10\]

<kernel>\[test\_write\]kbuf is \[xiao bai\]

\[root: app\]\# <kernel>\[test\_poll\]\*\*\*mask\[5\]\*\*\*

<app>monitor:\[device readable\] //4掩码改变，但没有阻塞

<app>monitor:\[device writeable\]

<kernel>\[test\_poll\]\*\*\*mask\[5\]\*\*\*

<app>monitor:\[device readable\]

<app>monitor:\[device writeable\]

<kernel>\[test\_poll\]\*\*\*mask\[5\]\*\*\*

<app>monitor:\[device readable\]

<app>monitor:\[device writeable\]

\[root: app\]\# ./app\_read //5读取数据

<kernel>\[test\_read\]read data.....

<kernel>\[test\_read\]read 10 bytes, cur\_size:\[0\]

<app\_read>\[xiao bai\]

\[root: app\]\# <kernel>\[test\_poll\]\*\*\*mask\[4\]\*\*\*

<app>monitor:\[device writeable\] //6掩码改变，但没有阻塞

<kernel>\[test\_poll\]\*\*\*mask\[4\]\*\*\*

<app>monitor:\[device writeable\]

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、select的阻塞操作

上面说了select会造成休眠，接下来简单的谈谈。select里面会调用函数do\_select。

贴上程序，并附上大致的运行顺序：

/\*fs/select.c\*/

365 int do\_select(int n, fd\_set\_bits \*fds, struct timespec \*end\_time)

366 \{

367 ktime\_t expire, \*to = NULL;

368 struct poll\_wqueues table; //1.这个就是前面说用来方等待队列的poll\_wqueues

。。。。省略。。。。

380

381 poll\_initwait(&table);

382 wait = &table.pt;

383 if (end\_time && !end\_time->tv\_sec && !end\_time->tv\_nsec) \{

384 wait = NULL;

385 timed\_out = 1;

386 \}

387

388 if (end\_time && !timed\_out)

389 slack = estimate\_accuracy(end\_time);

390

391 retval = 0;

392 for (;;) \{ //2.注意这个大循环，如果条件不成立休眠后，唤醒正在这个大循环里

393 unsigned long \*rinp, \*routp, \*rexp, \*inp, \*outp, \*exp;

394

395 inp = fds->in; outp = fds->out; exp = fds->ex;

396 rinp = fds->res\_in; routp = fds->res\_out; rexp = fds->res\_ex;

397

398 for (i = 0; i < n; ++rinp, ++routp, ++rexp) \{

。。。。。省略。。。。。

411 for (j = 0; j < \_\_NFDBITS; ++j, ++i, bit <<= 1) \{

412 int fput\_needed;

413 if (i >= n)

414 break;

415 if (!(bit & all\_bits))

416 continue;

417 file = fget\_light(i, &fput\_needed);

418 if (file) \{ //3.循环里面里边所有所有被检测的filp

419 f\_op = file->f\_op;

420 mask = DEFAULT\_POLLMASK;

421 if (f\_op && f\_op->poll) //4.调用我们实现的poll函数，这也是poll被多次调用的原因，以为他在循环里面。

422 mask = (\*f\_op->poll)(file, retval ? NULL : wait);

423 fput\_light(file, fput\_needed);

424 if ((mask & POLLIN\_SET) && (in & bit)) \{ //5.判断poll返回的掩码，只要掩码不是0，下面的起码有一个条件会实现。retval++。

425 res\_in |= bit;

426 retval++;

427 \}

428 if ((mask & POLLOUT\_SET) && (out & bit)) \{

429 res\_out |= bit;

430 retval++;

431 \}

432 if ((mask & POLLEX\_SET) && (ex & bit)) \{

433 res\_ex |= bit;

434 retval++;

435 \}

436 \}

437 \}

438 if (res\_in)

439 \*rinp = res\_in;

440 if (res\_out)

441 \*routp = res\_out;

442 if (res\_ex)

443 \*rexp = res\_ex;

444 cond\_resched();

445 \}

446 wait = NULL;

447 if (retval || timed\_out || signal\_pending(current))//6.如果条件成立或者 延时或者被中断

448 break; //7.调用break跳出大循环，do\_select调用完毕

449 if (table.error) \{

450 retval = table.error;

451 break;

452 \}

453

454 /\*

455 \* If this is the first loop and we have a timeout

456 \* given, then we convert to ktime\_t and set the to

457 \* pointer to the expiry value.

458 \*/

459 if (end\_time && !to) \{

460 expire = timespec\_to\_ktime(\*end\_time);

461 to = &expire;

462 \}

463 /\*8如果上面的条件没有成立，走到这里，进程状态改变有TASK\_INTERRUPTIBLE，并加入指定的等待队列头，让出CPU，进程休眠，等待唤醒\*/

464 if (!poll\_schedule\_timeout(&table, TASK\_INTERRUPTIBLE,

465 to, slack))

466 timed\_out = 1;

467 \}

468

469 poll\_freewait(&table);

470

471 return retval;

472 \}

上面只是想说明：poll只是做了一个判断工作，真正的阻塞在select中。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五、总结：

今天内容有讲完了，讲了以下内容：

1、poll的实现：

1.1调用poll\_wait

1.2返回掩码。

2.poll\_wait的实现。

3.select中的阻塞。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

linux设备驱动归纳总结（三）：6.poll和sellct

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 linux设备驱动归纳总结（三）：7.异步通知fasync

相关 linux设备驱动归纳总结（三）：6.poll和sellct

相关 linux设备驱动归纳总结（三）：5.阻塞型IO实现

相关 linux设备驱动归纳总结（三）：4.ioctl的实现

相关 linux设备驱动归纳总结（三）：3.设备驱动面向对象思想和lseek的实现

相关 linux设备驱动归纳总结（三）：1.字符型设备之设备申请

相关 linux设备驱动归纳总结（十）：1.udev&misc

相关 linux设备驱动归纳总结（九）：1.platform总线的设备和驱动

相关 linux设备驱动归纳总结（八）：2.总线、设备和驱动的关系

相关 linux设备驱动归纳总结（八）：1.总线、设备和驱动