I/O Multiplexing: select and poll

I/O Multiplexing: select and poll
•Introduction
•I/O models
•select function
•Rewrite str_cli function
•Supporting batch input with shutdown function
•Rewrite concurrent TCP echo server with select
•pselect function: avoiding signal loss in race condition
•poll function: polling more specific conditions than
select
•Rewrite concurrent TCP echo server with poll
1
Some materials in these slides are taken from Prof. Ying-Dar Lin with his permission of usage

Introduction
•I/O multiplexing: to be notified, by kernel, if one or
more I/O conditions are ready.
•Scenarios in networking applications:
–a client handling multiple descriptors (stdio/socket)
–a client handling multiple sockets
–a TCP server handling a listening socket and its
connected sockets ( 兩 件 事 都 自 己 來 )
–a server handling both TCP and UDP
–a server handling multiple services and protocols
2

I/O 動 作 如 何 進 行
• 一 般 process 無 法 直 接 對 I/O 裝 置 下 命 令 , 必 須
透 過 system call 請 求 kernel 幫 忙 進 行 I/O 動 作
•kernel 會 對 每 個 I/O 裝 置 維 護 一 個 buffer
wait
copy
I/O Device Kernel’s buffer Process
• 對 輸 入 而 言 , 等 待 (wait) 資 料 輸 入 至 buffer 需 要
時 間 , 從 buffer 搬 移 (copy) 資 料 也 需 要 時 間 。
• 根 據 等 待 模 式 不 同 ,I/O 動 作 可 分 為 五 種 模 式
3

Five I/O Models
•blocking I/O: blocked all the way
•nonblocking I/O: if no data in buffer, immediate
returns EWOULDBLOCK
•I/O multiplexing (select and poll): blocked
separately in wait and copy
•signal driven I/O (SIGIO): nonblocked in wait
but blocked in copy (signaled when I/O can be
initiated)
•asynchronous I/O (aio_): nonblocked all the way
(signaled when I/O is complete)
4

Comparison of Five I/O Models
blocking nonblocking I/O multiplexing signal-driven asynchronous
initiate check check establish initiate
check SIGIO specify
check handler signal/handler
check
check
check ready notification
initiate initiate
blocked
blocked
blocked
wait for data copy data
blocked
blocked
complete complete complete complete notification
synchronous I/O
asynchronous I/O
5

I/O Multiplexing: 使 用 select
• 本 章 要 做 的 是 I/O Multiplexing( 第 三 種 I/O
model): 使 用 select system call
•select 要 求 kernel 測 試 某 裝 置 是 否 滿 足
我 們 設 定 的 條 件 。 若 滿 足 則 return, 否 則
等 待 至 此 條 件 滿 足 時 為 止 (select 會 被
block)
•select 呼 叫 可 以 指 定 等 待 的 時 間 上 限
•select 呼 叫 可 以 指 定 測 試 多 個 I/O 裝 置
6

對 輸 入 裝 置 使 用 select
• 對 輸 入 裝 置 而 言 , 可 以 使 用 select 要 求
kernel 測 試 某 裝 置 是 否 ready for reading
• 當 此 裝 置 的 buffer 中 已 有 相 當 數 量 ( 可 設
定 ) 的 輸 入 資 料 時 , 此 裝 置 即 是 ready for
reading
•select return 後 , 由 我 們 的 程 式 自 行 呼
叫 其 它 的 system call 將 buffer 中 的 資 料 搬
回 來 。
7

對 輸 出 裝 置 使 用 select
• 對 輸 出 裝 置 而 言 , 可 以 使 用 select 要 求
kernel 測 試 某 裝 置 是 否 ready for writing
• 當 此 裝 置 的 buffer 中 已 有 相 當 空 間 ( 可 設
定 ) 可 放 置 輸 出 資 料 時 , 此 裝 置 即 是 ready
for writing
•select return 後 , 由 我 們 的 程 式 自 行 呼
叫 其 它 的 system call 將 欲 輸 出 資 料 搬 入
buffer 中 。
8

select Function
#include
#include
int select (int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset,
const struct timeval *timeout);
returns: positive count of ready descriptors, 0 on timeout, -1 on error
struct timeval { (null: wait forever; 0: do not wait)
long tv_sec; /*second */
long tv_usec; /* microsecond */
};
readset, writeset, and exceptset specify the descriptors that
we want the kernel to test for reading, writing, and
exception conditions, respectively.
maxfdp1 is the maximum descriptor to be tested plus one.
9

select Fucntion
OR
•We can call select and tell the kernel to
return only when
–any descriptor in {1, 4, 5} is ready for
reading (buffer 中 已 有 資 料 )
–any descriptor in {2, 7} is ready for writing
–any descriptor in {1, 4} has an exception
condition pending
–after 10.2 seconds have elapsed
Buffer
中 已 有
空 間
裝 置 有 例
外 狀 況
10

Specifying Descriptor Values
•We need to declare variables of data type fd_set and
use macros to manipulate these variables.
fd_set --- implementation dependent
four macros: void FD_ZERO(fd_set *fdset);
void FD_SET(int fd, fd_set *fdset);
void FD_CLR(int fd, fd_set *fdset);
int FD_ISSET(int fd, fd_set *fdset);
fd_set rset;
FD_ZERO(&rset);
FD_SET(1, &rset);
FD_SET(4, &rset);
FD_SET(5, &rset);
maxfdp1 = 6
Turn on bits for
descriptors 1, 4, and 5
11

Socket Ready Conditions for select
Condition readable writeable Exception
enough data to read x
read-half closed x
new connection ready x
writing space available
x
write-half closed
x
pending error x x
TCP out-of-band data
x
Low-water mark (enough data/space to read/write in
socket receive/send buffer): default is 1/2048, may be set by
SO_RCVLOWAT/SO_SNDLOWAT socket option
Maximum number of descriptors for select
Redefine FD_SETSIZE and recompile kernel
12

Low-Water Mark ( 低 水 位 )
• 對 socket receive buffer 而 言
– 如 收 到 data 量 不 足 low-water mark, socket is
not ready for reading
–Default = 1 byte
• 對 socket send buffer 而 言
– 如 可 用 空 間 (available space) 不 足 low-water
mark, socket is not ready for writing
–Default = 2048 byte
13

用 select 改 寫 str_cli
• 上 一 章 的 str_cli 用 兩 個 system calls 分 別
取 得 input
–fgets 用 於 stdin 的 user input
–readline 用 於 socket input
均 為 Blocking I/O
• 這 樣 沒 有 辦 法 同 時 等 待 兩 個 inputs。 因 此
當 client 等 在 fgets 時 , 無 法 同 時 取 得
socket input 進 來 的 資 料
• 本 章 改 用 select 來 同 時 等 待 兩 個 inputs
14

Ch. 5
兩 個 版 本 的 比 較
Ch. 6
return
呼 叫 fgets 從 stdin
讀 取 使 用 者 的 輸 入
yes
EOF
呼 叫 writen 將 輸 入
資 料 輸 出 至 socket
呼 叫 readline 從
socket 讀 取 資 料
no
呼 叫 fputs 將 讀 取 的
資 料 輸 出 至 stdout
socket is
readable
呼 叫 readline 從
socket 讀 取 資 料
呼 叫 fputs 將 讀 取 的
資 料 輸 出 至 stdout
呼 叫 select 同 時 等
待 socket 及 stdin
return
stdin is
readable
呼 叫 fgets 從 stdin
讀 取 使 用 者 的 輸 入
yes
EOF
呼 叫 writen 將 輸 入
資 料 輸 出 至 socket
15
no

Rewrite str_cli Function with select
data or EOF
TCP
stdin
error
client
socket
EOF
select for readability
on either stdin or socket
用 select 同 時 等 待 stdio 及
socket input. 當 任 一 裝 置
ready for reading 時 select
會 return
當 select return 時 怎 知 道 是 哪
些 裝 置 ready for reading 呢
RST data FIN
用 FD_ISSET 測 試 傳 回 值
readset, writeset, 和 exceptset 是 雙 向 變 數
可 得 知 那 些 裝 置 是 ready
(value-result argemnets)
16

Rewrite str_cli Function with select
#include
"unp.h"
select/strcliselect01.c
void
str_cli(FILE *fp, int sockfd)
{
int maxfdp1;
fd_set rset;
char sendline[MAXLINE], recvline[MAXLINE];
FD_ZERO(&rset);
for ( ; ; ) {
放 在
loop 內
Why
傳 回 檔 案 指 標 fp
的 descriptor no
FD_SET(fileno(fp), &rset);
FD_SET(sockfd, &rset);
maxfdp1 = max(fileno(fp), sockfd) + 1;
Select(maxfdp1, &rset, NULL, NULL, NULL);
只 測 試 read
17

}
}
if (FD_ISSET(sockfd, &rset)) { /* socket is readable */
}
if (Readline(sockfd, recvline, MAXLINE) == 0)
err_quit("str_cli: server terminated prematurely");
Fputs(recvline, stdout);
if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */
}
用 FD_ISSET 測 試
裝 置 是 否 ready
用 FD_ISSET 測 試
裝 置 是 否 ready
if (Fgets(sendline, MAXLINE, fp) == NULL)
return; /* all done */
Writen(sockfd, sendline, strlen(sendline));
select/strcliselect01.c
User 按 了
Ctrl+D
18

使 用 select 函 數 常 犯 的 兩 個 錯 誤
‧ 忘 記 maxfdp1 是 descriptor 的 最 大 值 加 1
‧ 忘 記 readset, writeset, 和 exceptset 是 雙 向
變 數
–select return 時 會 改 變 它 們 的 值
– 因 此 再 次 呼 叫 select 時 別 忘 了 要 重 新 設 定
這 些 變 數 的 內 容
19

Redirecting Input on UNIX
Systems
•Standard I/O - keyboard and screen
•Input Redirection symbol (

Stop-and-Wait (Interactive) Mode
• 原 來 版 本 的 str_cli 強 制 輪 流 處 理 stdin 輸 入
與 socket 輸 入
client
keyin
keyin
socket
in
提 早 輸 入 並 不
會 提 早 處 理
socket
in
keyin
不 管 多 晚 輸
入 都 會 等 待
socket
in
server
time
21

Batch Mode
• 在 新 版 str_cli 使 用 input redirection
client
不 需
等 待
server
tcpcli04 206.62.226.35 < file1.txt
lines
…
EOF
…
…
time
檔 案 最 後 的 EOF
會 使 fgets 傳 回
NULL,str_cli
會 因 此 return
main 會 close 掉
TCP connection,
導 致 server 尚 未 回
傳 的 資 料 遺 失
將 stdin 重 導
至 file1.txt
就 算 不
用 輸 入
重 導 向
也 有 此
問 題 ,
只 是 較
不 嚴 重
22

Solution: UseShutdown Instead
ofClose
•In str_cli, close write-half of TCP
connection, by shutdown, while leaving
read-half open.
先 關 client 至 server 方 向 的 connection
server 至 client 方 向 的 connection 暫 時 不 要 關
等 到 server 的 資 料 全 部 送 回 來
後 再 關 掉 server 至 client 方 向 的
connection
23

Function shutdown
#include
int shutdown(int sockfd, int howto);
howto: SHUT_RD, SHUT_WR, SHUT_RDWR
returns: 0 if OK, -1 on error
•initiates TCP normal termination
regardless of descriptor’s reference
count
•selectively closes one direction of the
connection (SHUT_RD or SHUT_WR)
24

Rewrite str_cli with select and shutdown
#include
"unp.h"
select/strcliselect02.c
void
str_cli(FILE *fp, int sockfd)
{
int
fd_set rset;
char
maxfdp1, stdineof;
判 斷 client 至 server 方 向 連
結 是 否 已 斷 的 旗 標 變 數
sendline[MAXLINE], recvline[MAXLINE];
stdineof = 0;
FD_ZERO(&rset);
當 client 至 server 方 向 連 結
for ( ; ; ) {
未 斷 時 才 要 test stdin
if (stdineof == 0)
FD_SET(fileno(fp), &rset);
FD_SET(sockfd, &rset);
maxfdp1 = max(fileno(fp), sockfd) + 1;
Select(maxfdp1, &rset, NULL, NULL, NULL);
25

}
client 至 server
方 向 連 結 已 斷
}
if (FD_ISSET(sockfd, &rset)) { /* socket is readable */
if (Readline(sockfd, recvline, MAXLINE) == 0) {
if (stdineof == 1)
return; /* normal termination */
else
err_quit("str_cli: server terminated prematurely");
}
Fputs(recvline, stdout);
}
if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */
if (Fgets(sendline, MAXLINE, fp) == NULL) {
stdineof = 1;
Shutdown(sockfd, SHUT_WR); /* send FIN */
}
FD_CLR(fileno(fp), &rset);
continue;
}
Writen(sockfd, sendline, strlen(sendline));
select/strcliselect02.c
只 斷 client 至
server 方 向 連 結
26

Concurrent TCP Echo Server with select
•A single server process using select to handle
any number of clients ( 不 fork child process)
•Need to keep track of the clients by client[ ]
(client descriptor array) and rset (read descriptor set)
client[ ]
[0] -1
[1] 5
[2] -1
[FD_SETSIZE-1] -1
maxi
not
used
rset
儲 存 已 open socket 的 descriptor
stdin/stdout/stderr
listening socket
terminated client
fd0 fd1 fd2 fd3 fd4 fd5
0 0 0 1 0 1
maxfd +1 = 6
用 於 呼 叫 select
existing client
27

Rewrite Concurrent TCP Echo Server with select
Initialization
#include "unp.h"
int main(int argc, char **argv)
tcpcliserv/tcpservselect01.c
{
int
i, maxi, maxfd, listenfd, connfd, sockfd;
int
nready, client[FD_SETSIZE];
ssize_t n;
fd_set
rset, allset;
char
line[MAXLINE];
socklen_t
clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
28

Initialization (cont.)
tcpcliserv/tcpservselect01.c
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
maxfd = listenfd;/* initialize */
maxi = -1;/* index into client[] array */
for (i = 0; i < FD_SETSIZE; i++)
client[i] = -1;/* -1 indicates available entry */
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
測 試 listening socket 是
否 ready for reading
29

Loop
for ( ; ; ) {
select 的 傳 回 值 是 ready 的 裝 置 數 目
rset = allset; /* structure assignment */
nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
if (FD_ISSET(listenfd, &rset)) { /* new client connection */
新
連
結
放 入 第 一 個
找 到 的 空 格
如 果 沒 有 其
它 ready 的
descriptor
}
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
for (i = 0; i < FD_SETSIZE; i++)
if (client[i] < 0) {
client[i] = connfd; /* save descriptor */
break;
}
if (i == FD_SETSIZE)
err_quit("too many clients");
tcpcliserv/tcpservselect01.c
加 進 select 要 test
的 descriptor set
不 會 block
FD_SET(connfd, &allset); /* add new descriptor to set */
if (connfd > maxfd)
maxfd = connfd; /* for select */
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready

Loop (cont.)
tcpcliserv/tcpservselect01.c
}
}
}
for (i = 0; i

前 頁 程 式 的 潛 在 問 題
•select 在 socket 的 input buffer 有 資
料 可 讀 時 即 會 return 此 socket 已 ready
for reading
•Readline 被 設 計 成 要 讀 到 以 換 行 字 元
結 束 的 一 列 文 字 ( 或 是 socket 被 結 束 掉 ) 才
會 return
• 有 心 人 士 可 能 利 用 這 項 弱 點 進 行 攻 擊
32

Denial of Service Attacks
• 問 題 出 在 Server 程 式 可 能 block 在 Readline 中
•Attack scenario:
–a malicious client sends 1 byte of data (other
than a newline) and sleep
–server hangs until the malicious client either
sends a newline or terminates
–(server 要 讀 到 newline, Readline 才 能 return)
33

Solutions to the Attack
•When a server is handling multiple
clients the server can never block in a
function call related to a single client
•Possible solutions:
–Use nonblocking I/O (Ch. 15)
–separate thread/process for each client
–timeout on I/O operations (Sec. 13.2)
34

poll Function: polling more specific
conditions than select
結 構 陣 列 儲 存 位 址
陣 列 中 的 資 料 數 目
微 秒
#include
int poll (struct pollfd *fdarray, unsigned long ndfs, int timeout);
returns: count of ready descriptors, 0 on timeout, -1 on error
每 個 descriptor 要 test 的 條 件 是 用 pollfd 結 構 來 表 示
這 些 pollfd 結 構 集 合 成 一 個 陣 列
struct pollfd { 要 測 的 file descriptor number; -1 表 此 結 構 無 效
int fd; /* a descriptor to poll */
short events; /* events of interested fd, value argument */
short revents; /* events that occurred on fd, result argument */
};
要 測 試 的 條 件
真 正 測 到 的 事 件
35

poll 函 數 中 的 事 件 設 定
•events 與 revents 由 下 列 bit flag 組 成
Constant events revents Description
POLLIN x x normal or priority band to read
POLLRDNORM x x normal data to read
POLLRDBAND x x priority band data to read
POLLPRI x x high-priority data to read
POLLOUT x x normal data can be written
POLLWRNORM x x normal data can be written
POLLWRBAND x x priority band data can be written
POLLERR x an error has occurred
POLLHUP x hangup has occurred
POLLNVAL x descriptor is not an open file
36

設 定 events 與 測 試 revents
‧ 設 定 events: 使 用 bitwise OR
struct pollfd client[OPEN_MAX];
…
client[0].events = POLLRDNORM | POLLRDBAND;
‧ 測 試 revents: 使 用 bitwise AND
struct pollfd client[OPEN_MAX];
…
if (client[0].revents & POLLRDNORM)
…
37

Three Classes of Data Identified
by poll
•normal, priority band, and high priority
normal priority band high priority
All regular TCP data x
All UDP data
x
TCP’s out-of-band data
x
Half-closed TCP x
Error for TCP
x (or POLLERR)
New connection x x
38

Concurrent TCP Echo Server with poll
•When using select, the server maintains array client[ ]
and descriptor set rset. When using poll, the server
maintains array client of pollfd structure.
•Program flow:
–allocate array of pollfd structures
–initialize (listening socket: first entry in client)
(set POLLRDNORM in events)
–call poll; check for new connection
(check, in revents, and set, in events, POLLRDNORM)
–check for data on an existing connection
(check POLLRDNORM or POLLERR in revents)
39

Rewrite Concurrent TCP Echo Server
with poll
Initialization
tcpcliserv/tcpservpoll01.c
#include "unp.h"
#include /* for OPEN_MAX */
int main(int argc, char **argv)
{
int
i, maxi, listenfd, connfd, sockfd;
int
nready;
ssize_t n;
char
line[MAXLINE];
結 構 陣 列
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
40

tcpcliserv/tcpservpoll01.c
Initialization (cont.)
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
client[0].fd = listenfd;
client[0].events = POLLRDNORM;
for (i = 1; i < OPEN_MAX; i++)
第 0 個 元 素 放
listening socket
client[i].fd = -1; /* -1 indicates available entry */
maxi = 0; /* max index into client[] array */
41

Loop
for ( ; ; ) {
nready = Poll(client, maxi+1, INFTIM);
放 入 第 一 個
找 到 的 空 格
if (client[0].revents & POLLRDNORM) { /* new client connection */
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
for (i = 1; i < OPEN_MAX; i++)
if (client[i].fd < 0) {
client[i].fd = connfd; /* save descriptor */
break;
}
}
bitwise AND
tcpcliserv/tcpservpoll01.c
wait forever
不 會 block
if (i == OPEN_MAX)
for data socket
err_quit("too many clients");
client[i].events = POLLRDNORM;
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready

tcpcliserv/tcpservpoll01.c
for (i = 1; i

Conclusion
• 本 章 介 紹 如 何 用 I/O Multiplexing 來 取 代
blocking I/O, 以 同 時 等 待 兩 個 以 上 的 I/O
裝 置
•I/O Multiplexing 可 用 select 或 poll 來
達 成
• 為 何 不 使 用 nonblocking I/O 呢 就 算
Buffer 中 沒 資 料 也 可 立 即 return 耶 …
return 後 要 做 啥
44