select, pselect - 同期 I/O の多重化
select(2) 参照。
システムコール
select()
や
pselect()
を使うと、効率的に複数のファイルディスクリプターを監視し、
そのファイルディスクリプターのいずれかが
「ready
(準備ができた)」状態、つまり
I/O (入出力)
が可能になっているかや、
ファイルディスクリプターのいずれかが
「例外状態 (exceptional
condition)」が発生したか、を調べることができる。
This page provides background and tutorial information on the use of these
system calls. For details of the arguments and semantics of
select()
and
pselect(), see
select(2).
ファイルディスクリプターが
I/O
可能な状態になるのと同時に
シグナルも待ちたい場合には、
pselect() が便利である。
シグナルを受信するプログラムは、通常は、
シグナルハンドラーをグローバルなフラグを立てるためだけに使う。
このグローバルなフラグは、
そのイベントをプログラムのメインループで
処理しなければならないことを示す。
シグナルを受けると
select() (や
pselect()) は
errno に
EINTR
をセットして戻ることになる。
シグナルがプログラムのメインループで処理されるためにはこの動作が不可欠で、
これがないと
select()
は永遠に停止し続けることになる。
さて、メインループのどこかにこのグローバルフラグをチェックする
条件文があるとしよう。ここで少し考えてみないといけない。
「シグナルが条件文の後、しかし
select()
コールの前に到着したら
どうなるのか？」
答えは「その
select()
は、たとえ解決待ちのイベントがあったとしても、
永遠に停止する」である。
この競合状態は
pselect()
コールによって解決できる。
このコールを使うと、
pselect()
でのみ受信したいシグナルの集合をシグナルマスクに設定することができる。
例えば、問題となっているイベントが子プロセスの終了の場合を考えよう。
メインループが始まる前に、
SIGCHLD を
sigprocmask(2)
でブロックする。
pselect() コールでは
SIGCHLD
を、もともとのシグナルマスクを使って有効にするのだ。
このプログラムは次のようになる。
static volatile sig_atomic_t got_SIGCHLD = 0;
static void
child_sig_handler(int sig)
{
got_SIGCHLD = 1;
}
int
main(int argc, char *argv[])
{
sigset_t sigmask, empty_mask;
struct sigaction sa;
fd_set readfds, writefds, exceptfds;
int r;
sigemptyset(&sigmask);
sigaddset(&sigmask, SIGCHLD);
if (sigprocmask(SIG_BLOCK, &sigmask, NULL) == -1) {
perror("sigprocmask");
exit(EXIT_FAILURE);
}
sa.sa_flags = 0;
sa.sa_handler = child_sig_handler;
sigemptyset(&sa.sa_mask);
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction");
exit(EXIT_FAILURE);
}
sigemptyset(&empty_mask);
for (;;) { /* main loop */
/* Initialize readfds, writefds, and exceptfds
before the pselect() call. (Code omitted.) */
r = pselect(nfds, &readfds, &writefds, &exceptfds,
NULL, &empty_mask);
if (r == -1 && errno != EINTR) {
/* Handle error */
}
if (got_SIGCHLD) {
got_SIGCHLD = 0;
/* Handle signalled event here; e.g., wait() for all
terminated children. (Code omitted.) */
}
/* main body of program */
}
}
実際のところ
select()
の大事な点は何なのか？
ファイルディスクリプターは好きなときに読み書きできるんじゃないの？
select()
の重要なところは、複数のディスクリプターを同時に監視でき、
なんの動きもなければプロセスを適切にスリープ状態に移行するところにあるのだ。
UNIX プログラマは、
複数のファイルディスクリプターの入出力を同時に扱わねばならず、
しかもデータの流れは間欠的である、という状況によく出会う。
単に
read(2) や
write(2)
コールのシーケンスを作るだけでは、それらのコールのどれかが
ファイルディスクリプターからのデータを待ってブロックしており、
別のファイルディスクリプターには
I/O
が可能なのに使えない、
ということになってしまうだろう。
select()
を使うとこの状況に効果的に対処できる。
select()
を使おうとした多くの人は、理解しにくい挙動に出くわし、結果的に
できたものは移植性がないか、よくてもギリギリのものになってしまう。
例えば、上記のプログラムは、
集合に含まれるファイルディスクリプターを非停止
(nonblocking) モード
にしなくても、どこにもブロックが生じないよう注意して書かれている。
微妙な間違いによって、
select()
を使う利点は簡単に失われてしまう。
そこで、
select()
コールを使うときに注意すべき重要事項を列挙しておくことにする。
- 1.
-
select()
を使うときは、タイムアウトは設定すべきでない。
処理するデータが無いときには、
あなたのプログラムには何もすることは無いはずである。
タイムアウトに依存したコードは通常移植性がなく、
デバッグも難しくなる。
- 2.
- 上述したように、
効率的なプログラムを書くには
nfds
の値を適切に計算して与えなければならない。
- 3.
-
select()
コールの終了後に結果をチェックして、
適切に対応するつもりのないファイルディスクリプターは、
どの集合にも加えてはならない。
次のルールも参照。
- 4.
-
select()
から返った後には、全ての集合の全てのファイルディスクリプターについて
読み書き可能な状態になっているかをチェックすべきである。
- 5.
-
read(2), recv(2), write(2),
send(2)
といった関数は、こちらが要求した全データを読み書きする必要は
ない。
もし全データを読み書きするなら、それはトラフィックの負荷が小さく、
ストリームが速い場合だろう。この条件は常に満たされるとは限らない。
これらの関数が頑張っても
1
バイトしか送受信できないような場合も
考慮に入れてやらなければならない。
- 6.
- 処理するデータ量が小さいことがはっきりとわかっている場合を除いて、
一度に 1
バイトずつ読み書きするようなことはしてはならない。
バッファーの許すかぎりのデータをまとめて読み書きしないと、
非常に効率が悪い。下記の例ではバッファーは
1024
バイトにしているが、
このサイズを大きくするのは簡単だろう。
- 7.
- Calls to read(2), recv(2), write(2),
send(2), and select() can fail with the error EINTR,
and calls to read(2), recv(2) write(2), and
send(2) can fail with errno set to EAGAIN (
EWOULDBLOCK). These results must be properly managed (not done
properly above). If your program is not going to receive any signals, then
it is unlikely you will get EINTR. If your program does not set
nonblocking I/O, you will not get EAGAIN.
- 8.
- 決して、引数に長さ
0
のバッファーを指定して
read(2), recv(2), write(2), send(2)
を呼び出してはならない。
- 9.
-
read(2), recv(2), write(2),
send(2) が 7.
に示した以外のエラーで失敗した場合や、
入力系の関数の一つがファイル末尾を表す
0 を返した場合は、
そのファイルディスクリプターをもう一度
select に渡しては
ならない。
下記の例では、そのファイルディスクリプターをただちにクローズし、
そこには -1
をセットして、
それが集合に含まれ続けるのを許さないようにしている。
- 10.
- タイムアウトの値は
select()
を呼ぶたびに初期化すべきである。
OS によっては timeout
構造体が変更される場合があるからである。
但し、 pselect() は自分の
timeout
構造体を変更することはない。
- 11.
-
select()
はファイルディスクリプター集合を変更するので、
select()
がループの中で使用されている場合には、呼び出しを行う前に毎回
ディスクリプター集合を初期化し直さなければならない。
select(2) 参照。
一般的に言って、ソケットをサポートする全てのオペレーティングシステムは
select()
もサポートしている。
select()
を使うと、プログラマがスレッド、フォーク、IPC、シグナル、メモリー共有、
等々を使ってもっと複雑な方法で解決しようとする多くの問題が、
移植性がありかつ効率的な方法で解決できる。
poll(2) システムコールは
select()
と同じ機能を持っており、
まばらなファイルディスクリプター集合を監視する場合に
いくらか効率がよい。
現在では広く利用可能であるが、以前は
select()
より移植性の面で劣っていた。
Linux 独自の
epoll(7) API
は、多数のファイルディスクリプターを監視する場合に
select(2) や
poll(2)
よりも効率的なインターフェースを提供している。
select()
の本当に便利な点を示す、よい例を紹介する。
以下のリストは、ある
TCP
ポートから別のポートへ転送を行う
TCP
フォワードプログラムである。
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/select.h>
#include <string.h>
#include <signal.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
static int forward_port;
#undef max
#define max(x,y) ((x) > (y) ? (x) : (y))
static int
listen_socket(int listen_port)
{
struct sockaddr_in addr;
int lfd;
int yes;
lfd = socket(AF_INET, SOCK_STREAM, 0);
if (lfd == -1) {
perror("socket");
return -1;
}
yes = 1;
if (setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR,
&yes, sizeof(yes)) == -1) {
perror("setsockopt");
close(lfd);
return -1;
}
memset(&addr, 0, sizeof(addr));
addr.sin_port = htons(listen_port);
addr.sin_family = AF_INET;
if (bind(lfd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
perror("bind");
close(lfd);
return -1;
}
printf("accepting connections on port %d\n", listen_port);
listen(lfd, 10);
return lfd;
}
static int
connect_socket(int connect_port, char *address)
{
struct sockaddr_in addr;
int cfd;
cfd = socket(AF_INET, SOCK_STREAM, 0);
if (cfd == -1) {
perror("socket");
return -1;
}
memset(&addr, 0, sizeof(addr));
addr.sin_port = htons(connect_port);
addr.sin_family = AF_INET;
if (!inet_aton(address, (struct in_addr *) &addr.sin_addr.s_addr)) {
fprintf(stderr, "inet_aton(): bad IP address format\n");
close(cfd);
return -1;
}
if (connect(cfd, (struct sockaddr *) &addr, sizeof(addr)) == -1) {
perror("connect()");
shutdown(cfd, SHUT_RDWR);
close(cfd);
return -1;
}
return cfd;
}
#define SHUT_FD1 do { \
if (fd1 >= 0) { \
shutdown(fd1, SHUT_RDWR); \
close(fd1); \
fd1 = -1; \
} \
} while (0)
#define SHUT_FD2 do { \
if (fd2 >= 0) { \
shutdown(fd2, SHUT_RDWR); \
close(fd2); \
fd2 = -1; \
} \
} while (0)
#define BUF_SIZE 1024
int
main(int argc, char *argv[])
{
int h;
int fd1 = -1, fd2 = -1;
char buf1[BUF_SIZE], buf2[BUF_SIZE];
int buf1_avail = 0, buf1_written = 0;
int buf2_avail = 0, buf2_written = 0;
if (argc != 4) {
fprintf(stderr, "Usage\n\tfwd <listen-port> "
"<forward-to-port> <forward-to-ip-address>\n");
exit(EXIT_FAILURE);
}
signal(SIGPIPE, SIG_IGN);
forward_port = atoi(argv[2]);
h = listen_socket(atoi(argv[1]));
if (h == -1)
exit(EXIT_FAILURE);
for (;;) {
int ready, nfds = 0;
ssize_t nbytes;
fd_set readfds, writefds, exceptfds;
FD_ZERO(&readfds);
FD_ZERO(&writefds);
FD_ZERO(&exceptfds);
FD_SET(h, &readfds);
nfds = max(nfds, h);
if (fd1 > 0 && buf1_avail < BUF_SIZE)
FD_SET(fd1, &readfds);
/* Note: nfds is updated below, when fd1 is added to
exceptfds. */
if (fd2 > 0 && buf2_avail < BUF_SIZE)
FD_SET(fd2, &readfds);
if (fd1 > 0 && buf2_avail - buf2_written > 0)
FD_SET(fd1, &writefds);
if (fd2 > 0 && buf1_avail - buf1_written > 0)
FD_SET(fd2, &writefds);
if (fd1 > 0) {
FD_SET(fd1, &exceptfds);
nfds = max(nfds, fd1);
}
if (fd2 > 0) {
FD_SET(fd2, &exceptfds);
nfds = max(nfds, fd2);
}
ready = select(nfds + 1, &readfds, &writefds, &exceptfds, NULL);
if (ready == -1 && errno == EINTR)
continue;
if (ready == -1) {
perror("select()");
exit(EXIT_FAILURE);
}
if (FD_ISSET(h, &readfds)) {
socklen_t addrlen;
struct sockaddr_in client_addr;
int fd;
addrlen = sizeof(client_addr);
memset(&client_addr, 0, addrlen);
fd = accept(h, (struct sockaddr *) &client_addr, &addrlen);
if (fd == -1) {
perror("accept()");
} else {
SHUT_FD1;
SHUT_FD2;
buf1_avail = buf1_written = 0;
buf2_avail = buf2_written = 0;
fd1 = fd;
fd2 = connect_socket(forward_port, argv[3]);
if (fd2 == -1)
SHUT_FD1;
else
printf("connect from %s\n",
inet_ntoa(client_addr.sin_addr));
/* Skip any events on the old, closed file
descriptors. */
continue;
}
}
/* NB: read OOB data before normal reads */
if (fd1 > 0 && FD_ISSET(fd1, &exceptfds)) {
char c;
nbytes = recv(fd1, &c, 1, MSG_OOB);
if (nbytes < 1)
SHUT_FD1;
else
send(fd2, &c, 1, MSG_OOB);
}
if (fd2 > 0 && FD_ISSET(fd2, &exceptfds)) {
char c;
nbytes = recv(fd2, &c, 1, MSG_OOB);
if (nbytes < 1)
SHUT_FD2;
else
send(fd1, &c, 1, MSG_OOB);
}
if (fd1 > 0 && FD_ISSET(fd1, &readfds)) {
nbytes = read(fd1, buf1 + buf1_avail,
BUF_SIZE - buf1_avail);
if (nbytes < 1)
SHUT_FD1;
else
buf1_avail += nbytes;
}
if (fd2 > 0 && FD_ISSET(fd2, &readfds)) {
nbytes = read(fd2, buf2 + buf2_avail,
BUF_SIZE - buf2_avail);
if (nbytes < 1)
SHUT_FD2;
else
buf2_avail += nbytes;
}
if (fd1 > 0 && FD_ISSET(fd1, &writefds) && buf2_avail > 0) {
nbytes = write(fd1, buf2 + buf2_written,
buf2_avail - buf2_written);
if (nbytes < 1)
SHUT_FD1;
else
buf2_written += nbytes;
}
if (fd2 > 0 && FD_ISSET(fd2, &writefds) && buf1_avail > 0) {
nbytes = write(fd2, buf1 + buf1_written,
buf1_avail - buf1_written);
if (nbytes < 1)
SHUT_FD2;
else
buf1_written += nbytes;
}
/* Check if write data has caught read data */
if (buf1_written == buf1_avail)
buf1_written = buf1_avail = 0;
if (buf2_written == buf2_avail)
buf2_written = buf2_avail = 0;
/* One side has closed the connection, keep
writing to the other side until empty */
if (fd1 < 0 && buf1_avail - buf1_written == 0)
SHUT_FD2;
if (fd2 < 0 && buf2_avail - buf2_written == 0)
SHUT_FD1;
}
exit(EXIT_SUCCESS);
}
上記のプログラムは、ほとんどの種類の
TCP
接続をフォワードする。
telnet
サーバによって中継される
OOB
シグナルデータも扱える。
このプログラムは、データフローを双方向に同時に送るという、
ややこしい問題も処理できる。
fork(2)
コールを使って、各ストリームごとに専用のスレッドを用いるほうが効率的だ、
という人もいるかもしれない。しかし、これは考えているよりずっとややこしい。
あるいは、
fcntl(2)
を使って非ブロック I/O
をセットすれば良い、というアイデアもあるだろう。
これにも実際には問題があり、タイムアウトが非効率的に起こってしまう。
このプログラムは一度にひとつ以上の同時接続を扱うことはできないが、
その様に拡張するのは簡単で、バッファーのリンクリストを
(接続ごとにひとつずつ)
使えばよい。
現時点のものでは、新しい接続がくると古い接続は落ちてしまう。
accept(2),
connect(2),
poll(2),
read(2),
recv(2),
select(2),
send(2),
sigprocmask(2),
write(2),
epoll(7)
この man ページは Linux
man-pages
プロジェクトのリリース
5.10
の一部である。プロジェクトの説明とバグ報告に関する情報は
https://www.kernel.org/doc/man-pages/
に書かれている。