select_tut - システムコールの説明 - Linux コマンド集 一覧表

select, pselect, FD_CLR, FD_ISSET, FD_SET, FD_ZERO - 同期 I/O の多重化

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
int select(int nfds , fd_set * readfds , fd_set * writefds , fd_set * exceptfds , struct timeval * utimeout );
int pselect(int nfds , fd_set * readfds , fd_set * writefds , fd_set * exceptfds , const struct timespec * ntimeout , sigset_t * sigmask );
FD_CLR(int fd , fd_set * set );
FD_ISSET(int fd , fd_set * set );
FD_SET(int fd , fd_set * set );
FD_ZERO(fd_set * set );

select ()(や pselect ())は、同時に複数のファイルディスクリプタ (やソケットハンドル) を効率的に扱おうとする C プログラムで、要となる関数である。 この関数の主要な引き数は、3種類のファイルディスクリプタの配列 readfds , writefds , exceptfds である。 select () の通常の使われ方は、ひとつまたは複数のファイルディスクリプタの 「状態の変化」を待っている間、停止 (block) することである。 「状態の変化」とは、以下のいずれかの場合である: (1) ファイルディスクリプタから取得できる文字が増えた場合、 (2) ファイルディスクリプタに書き込むための カーネルの内部バッファ内に使用できる空間ができた場合、 (3) ファイルディスクリプタがエラーになった場合 (ソケットやパイプの場合は、これは接続の他端がクローズされた場合)。
要約すると、select () は複数のファイルディスクリプタの監視を行うだけのもので、 それを行うための標準的な Unix コールである。
ファイルディスクリプタの配列は ファイルディスクリプタ集合 (file descriptor set) と呼ばれる。各々の集合は fd_set として宣言され、その内容は FD_CLR (), FD_ISSET (), FD_SET (), FD_ZERO () といったマクロによって変更できる。 新しいディスクリプタ集合に対しては、通常 FD_ZERO () を最初に使う。 その後で、監視対象としたいファイルディスクリプタを一つ一つ FD_SET () で追加する。 select ()はこれらの集合の内容を、以降に述べる規則に従って修正する。 select ()を呼んだ後、ファイルディスクリプタがまだ集合に存在しているかどうかは、 FD_ISSET () マクロによって調べることができる。 FD_ISSET () はそのディスクリプタが集合に存在していれば 0 以外の値を返し、 存在していなければ 0 を返す。 FD_CLR () は集合からのファイルディスクリプタの削除を行う。

readfds

この集合に含まれるいずれかのファイルディスクリプタで データの読み込みが可能になったかどうかを監視する。 select () から戻る時に、readfds のうち、 recv () (ソケットの場合) や read () (パイプ、ファイル、ソケットの場合) によって直ちに読み込み可能なファイルディスクリプタ以外は 集合から削除される。

writefds

この集合に含まれるいずれかのファイルディスクリプタで データを書き込むスペースがあるかどうかを監視する。 select () から戻る時に、writefds のうち、 send () (ソケットの場合) や write () (パイプ、ファイル、ソケットの場合) によって直ちに書き込み可能なファイルディスクリプタ以外は 集合から削除される。

exceptfds

この集合に含まれるいずれかのファイルディスクリプタで 例外やエラーが生じているかどうかを監視する。 しかし、これはただの噂に過ぎず、 実際に exceptfds で監視しているものは 帯域外 (out-of-band: OOB) データなのだ。 OOB データはソケットで MSG_OOB フラグを用いると送信される。 従って、実際には exceptfds はソケットにしか適用できない。 この詳細については   recv (2) と   send (2) を見よ。select () から戻る時に、exceptfds のうち、 OOB データの読み込みが可能になっているディスクリプタ以外は 集合から削除される。 OOB データの読み込み (recv () で行う) は 1 バイトだけしかできないが、 OOB データの書き込み (send () で行う) はいつでもでき、 停止 (block) されることもない。 従って、ソケットに OOB データの書き込みが可能であるかどうかをチェックする 4 番目の集合は必要ないのである。

nfds

全ての集合に含まれるファイルディスクリプタのうち、 値が最大のものに 1 を足した整数である。 すなわち、ファイルディスクリプタを集合に加える作業の途中で、 全てのファイルディスクリプタを見て最大値を求め、 それに 1 を加えて nfds として select () に渡さないといけない、ということだ。

utimeout

(何も起こらなかった場合に) select () が戻る前に待つ最大時間である。 この値に NULL を渡すと、 select () は何らかのイベントを待ちつづけてずっと停止する。 utimeout は 0 秒にすることもでき、 この場合 select () は直ちに戻る。 構造体 struct timeval は次のように定義されている:

struct timeval {
    time_t tv_sec;    /* seconds */
    long tv_usec;     /* microseconds */
};

ntimeout

この引き数は utimeout と同じ意味を持つが、 struct timespec は次に示すようにナノ秒の精度を持つ。

struct timespec {
    long tv_sec;    /* seconds */
    long tv_nsec;   /* nanoseconds */
};

sigmask

この引き数は pselect () コールの実行中に許可される シグナルの集合を保持する ( sigaddset (3)および   sigprocmask (2) を参照)。これには NULL を渡すこともでき、 その場合はこの関数へ入るとき・出るときに許可シグナルの集合を変更しない。 その後は select () と全く同様の動作をする。

ファイルディスクリプタから、データだけでなくシグナルも待ちたいときには pselect () を使う必要がある。シグナルをイベントとして受信するプログラムは、 大抵シグナルハンドラをグローバルなフラグを立てるためだけに使う。 このグローバルなフラグは、 そのイベントをプログラムのメインループで 処理しなければならないことを示す。 シグナルを受けると select () (や pselect ()) は errno に EINTR をセットして戻ることになる。 シグナルがプログラムのメインループで処理されるためにはこの動作が不可欠で、 これがないと select () は永遠に停止し続けることになる。 さて、メインループのどこかにこのグローバルフラグをチェックする 条件文があるとしよう。ここで少し考えてみないといけない。 「シグナルが条件文の後、しかし select () コールの前に到着したら どうなるのか？」 答えは「その select () は、たとえ解決待ちのイベントがあったとしても、 永遠に停止する」である。 この競合状態は pselect () コールによって解決できる。 pselect () コールは、自分自身の内部以外では受信したくないシグナルを マスクして除外するのに使用できる。 例えば、問題となっているイベントが子プロセスの終了の場合を考えよう。 メインループが始まる前に、 SIGCHLD を sigprocmask () でブロックする。 pselect () コールでは SIGCHLD を、もともとのシグナルマスクを 使って有効にするのだ。このプログラムは次のようになる。

int child_events = 0;



void child_sig_handler (int x) {
    child_events++;
    signal (SIGCHLD, child_sig_handler);
}



int main (int argc, char **argv) {
    sigset_t sigmask, orig_sigmask;



    sigemptyset (&sigmask);
    sigaddset (&sigmask, SIGCHLD);
    sigprocmask (SIG_BLOCK, &sigmask,
                                &orig_sigmask);



    signal (SIGCHLD, child_sig_handler);



    for (;;) { /* main loop */
        for (; child_events > 0; child_events--) {
            /* do event work here */
        }
        r = pselect (nfds, &rd, &wr, &er, 0, &orig_sigmask);



        /* main body of program */
    }
}

実際のところ select ()の大事な点は何なのか？ ディスクリプタは好きなときに読み書きできるんじゃないの？ select () の重要なところは、複数のディスクリプタを同時に監視でき、 なんの動きもなければプロセスを適切にスリープ状態に移行するところにあるのだ。 select () を用いれば、複数のパイプやソケットを同時に扱いながら これが行える。Unix プログラマは、 複数のファイルディスクリプタの入出力を同時に扱わねばならず、 しかもデータの流れは間欠的である、という状況によく出会う。 単に read () や write () コールのシーケンスを作るだけでは、それらのコールのどれかが ファイルディスクリプタからのデータを待ってブロックしており、 他のファイルディスクリプタにはデータが到着しているのに使えない、 ということになってしまうだろう。 select ()を使うとこの状況に効果的に対処できる。
select ()を使った簡単な例が   select (2) のマニュアルページに書かれている。

select ()の本当に便利な点を示す、よい例を紹介する。 以下のリストは、ある TCP ポートから別のポートへ転送を行う TCP フォワードプログラムである。

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.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 a;
    int s;
    int yes;
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
        perror ("socket");
        return -1;
    }
    yes = 1;
    if (setsockopt
        (s, SOL_SOCKET, SO_REUSEADDR,
         (char *) &yes, sizeof (yes)) < 0) {
        perror ("setsockopt");
        close (s);
        return -1;
    }
    memset (&a, 0, sizeof (a));
    a.sin_port = htons (listen_port);
    a.sin_family = AF_INET;
    if (bind
        (s, (struct sockaddr *) &a, sizeof (a)) < 0) {
        perror ("bind");
        close (s);
        return -1;
    }
    printf ("accepting connections on port %d\n",
            (int) listen_port);
    listen (s, 10);
    return s;
}



static int connect_socket (int connect_port,
                           char *address) {
    struct sockaddr_in a;
    int s;
    if ((s = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
        perror ("socket");
        close (s);
        return -1;
    }



    memset (&a, 0, sizeof (a));
    a.sin_port = htons (connect_port);
    a.sin_family = AF_INET;



    if (!inet_aton
        (address,
         (struct in_addr *) &a.sin_addr.s_addr)) {
        perror ("bad IP address format");
        close (s);
        return -1;
    }



    if (connect
        (s, (struct sockaddr *) &a,
         sizeof (a)) < 0) {
        perror ("connect()");
        shutdown (s, SHUT_RDWR);
        close (s);
        return -1;
    }
    return s;
}



#define SHUT_FD1 {                      \
        if (fd1 >= 0) {                 \
            shutdown (fd1, SHUT_RDWR);  \
            close (fd1);                \
            fd1 = -1;                   \
        }                               \
    }



#define SHUT_FD2 {                      \
        if (fd2 >= 0) {                 \
            shutdown (fd2, SHUT_RDWR);  \
            close (fd2);                \
            fd2 = -1;                   \
        }                               \
    }



#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, buf1_written;
    int buf2_avail, buf2_written;



    if (argc != 4) {
        fprintf (stderr,
                 "Usage\n\tfwd <listen-port> \
<forward-to-port> <forward-to-ip-address>\n");
        exit (1);
    }



    signal (SIGPIPE, SIG_IGN);



    forward_port = atoi (argv[2]);



    h = listen_socket (atoi (argv[1]));
    if (h < 0)
        exit (1);



    for (;;) {
        int r, nfds = 0;
        fd_set rd, wr, er;
        FD_ZERO (&rd);
        FD_ZERO (&wr);
        FD_ZERO (&er);
        FD_SET (h, &rd);
        nfds = max (nfds, h);
        if (fd1 > 0 && buf1_avail < BUF_SIZE) {
            FD_SET (fd1, &rd);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0 && buf2_avail < BUF_SIZE) {
            FD_SET (fd2, &rd);
            nfds = max (nfds, fd2);
        }
        if (fd1 > 0
            && buf2_avail - buf2_written > 0) {
            FD_SET (fd1, &wr);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0
            && buf1_avail - buf1_written > 0) {
            FD_SET (fd2, &wr);
            nfds = max (nfds, fd2);
        }
        if (fd1 > 0) {
            FD_SET (fd1, &er);
            nfds = max (nfds, fd1);
        }
        if (fd2 > 0) {
            FD_SET (fd2, &er);
            nfds = max (nfds, fd2);
        }



        r = select (nfds + 1, &rd, &wr, &er, NULL);



        if (r == -1 && errno == EINTR)
            continue;
        if (r < 0) {
            perror ("select()");
            exit (1);
        }
        if (FD_ISSET (h, &rd)) {
            unsigned int l;
            struct sockaddr_in client_address;
            memset (&client_address, 0, l =
                    sizeof (client_address));
            r = accept (h, (struct sockaddr *)
                        &client_address, &l);
            if (r < 0) {
                perror ("accept()");
            } else {
                SHUT_FD1;
                SHUT_FD2;
                buf1_avail = buf1_written = 0;
                buf2_avail = buf2_written = 0;
                fd1 = r;
                fd2 =
                    connect_socket (forward_port,
                                    argv[3]);
                if (fd2 < 0) {
                    SHUT_FD1;
                } else
                    printf ("connect from %s\n",
                            inet_ntoa
                            (client_address.sin_addr));
            }
        }
/* NB: read oob data before normal reads */
        if (fd1 > 0)
            if (FD_ISSET (fd1, &er)) {
                char c;
                errno = 0;
                r = recv (fd1, &c, 1, MSG_OOB);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    send (fd2, &c, 1, MSG_OOB);
            }
        if (fd2 > 0)
            if (FD_ISSET (fd2, &er)) {
                char c;
                errno = 0;
                r = recv (fd2, &c, 1, MSG_OOB);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    send (fd1, &c, 1, MSG_OOB);
            }
        if (fd1 > 0)
            if (FD_ISSET (fd1, &rd)) {
                r =
                    read (fd1, buf1 + buf1_avail,
                          BUF_SIZE - buf1_avail);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    buf1_avail += r;
            }
        if (fd2 > 0)
            if (FD_ISSET (fd2, &rd)) {
                r =
                    read (fd2, buf2 + buf2_avail,
                          BUF_SIZE - buf2_avail);
                if (r < 1) {
                    SHUT_FD2;
                } else
                    buf2_avail += r;
            }
        if (fd1 > 0)
            if (FD_ISSET (fd1, &wr)) {
                r =
                    write (fd1,
                           buf2 + buf2_written,
                           buf2_avail -
                           buf2_written);
                if (r < 1) {
                    SHUT_FD1;
                } else
                    buf2_written += r;
            }
        if (fd2 > 0)
            if (FD_ISSET (fd2, &wr)) {
                r =
                    write (fd2,
                           buf1 + buf1_written,
                           buf1_avail -
                           buf1_written);
                if (r < 1) {
                    SHUT_FD2;
                } else
                    buf1_written += r;
            }
/* 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;
        }
    }
    return 0;
}

上記のプログラムは、ほとんどの種類の TCP 接続をフォワードする。 telnet サーバによって中継される OOB シグナルデータも扱える。 このプログラムは、データフローを双方向に同時に送るという、 ややこしい問題も処理できる。 fork ()コールを使って、各ストリームごとに専用のスレッドを用いるほうが効率的だ、 という人もいるかもしれない。しかし、これは考えているよりずっとややこしい。 あるいは、 ioctl ()コールを使って非ブロック I/O をセットすれば良い、というアイデアもあるだろう。 これにも実際には問題があり、タイムアウトが非効率的に起こってしまう。
このプログラムは一度にひとつ以上の同時接続を扱うことはできないが、 その様に拡張するのは簡単で、バッファのリンクリストを (接続ごとにひとつずつ) 使えばよい。 現時点のものでは、新しい接続がくると古い接続は落ちてしまう。

select ()を使おうとした多くの人は、理解しにくい挙動に出くわし、結果的に できたものは移植性がないか、よくてもギリギリのものになってしまう。 例えば、上記のプログラムは、 集合に含まれるファイルディスクリプタを非ブロックモード ( ioctl (2)参照) にしなくても、どこにもブロックが生じないよう注意して書かれている。 微妙な間違いによって、 select ()を使う利点は簡単に失われてしまう。 そこでここでは、 select ()コールを使うときに注意すべき重要事項をリストしようと思う。

1.

select ()を使うときは、タイムアウトは設定すべきでない。 処理するデータが無いときには、 あなたのプログラムには何もすることは無いはずである。 タイムアウトに依存したコードは通常移植性がなく、 デバッグも難しくなる。

2.

上述したように、 効率的なプログラムを書くには nfds の値を適切に計算して与えなければならない。

3.

select ()コールの終了後に結果をチェックして、 適切に対応するつもりのないファイルディスクリプタは、 どの集合にも加えてはならない。 次のルールも参照。

4.

select ()から返った後には、全ての集合の全てのファイルディスクリプタについて 読み書き可能な状態になっているかをチェックすべきである。

5.

read (), recv (), write (), send () といった関数は、こちらが要求した全データを読み書きする必要はない 。 もし全データを読み書きするなら、それはトラフィックの負荷が小さく、 ストリームが速い場合だろう。この条件は常に満たされるとは限らない。 これらの関数が頑張っても 1 バイトしか送受信できないような場合も 考慮に入れてやらなければならない。

6.

処理するデータ量が小さいことがはっきりとわかっている場合を除いて、 一度に 1 バイトずつ読み書きするようなことはしてはならない。 バッファの許すかぎりのデータをまとめて読み書きしないと、 非常に効率が悪い。上記の例ではバッファは 1024 バイトにしているが、 このサイズを大きくするのは簡単だろう。

7.

read (), recv (), write (), send () などの関数や select ()コールは、 errno を EINTR " や " EAGAIN ( EWOULDBLOCK )にして -1 を返すことがある。 このような結果に対して適切に対応してやらなければならない (上記の例ではしていない)。 書いているプログラムがシグナルを受ける予定がなければ、 EINTR が返されることはあまり考えられない。 書いているプログラムで非ブロック I/O をセットしていない場合は、 EAGAIN が返されることはないだろう。それでもなお、 完全を期するならば、これらのエラーを考慮に入れる必要がある。

8.

決して、引き数に長さ 0 のバッファを指定して read (), recv (), write (), send () を呼び出してはならない。

9.

read (), recv (), write (), send () が 7. に示した以外のエラーで失敗した場合や、 入力系の関数の一つがファイル末尾を表す 0 を返した場合は、 そのディスクリプタをもう一度 select に渡してはならない 。 上記の例では、そのディスクリプタをただちにクローズし、 そこには -1 をセットして、 それが集合に含まれ続けるのを許さないようにしている。

10.

タイムアウトの値は select ()を呼ぶたびに初期化すべきである。 OS によっては timeout 構造体が変更される場合があるからである。 但し、 pselect ()は自分の timeout 構造体を変更することはない。

11.

聞いたところでは、Windows のソケット層は OOB データを正しく処理しないらしい。 また、ファイルディスクリプタが全くセットされていないような select ()コールも正しく処理しないらしい。 ファイルディスクリプタを一切設定しないで timeout を使うやり方は、 1 秒以下の精度でプロセスをスリープさせるには便利な方法なのだが (続きを見よ)。

usleep () 関数を持たないシステムでは、 有限のタイムアウトを指定し、ファイルディスクリプタを全くセットせずに select () を呼び出すことで、これを代用できる。 以下のようにする。

    struct timeval tv;
    tv.tv_sec = 0;
    tv.tv_usec = 200000;  /* 0.2 seconds */
    select (0, NULL, NULL, NULL, &tv);

但し、これが動くと保証されているのは Unix システムに限られる。

成功すると、 select ()はファイルディスクリプタ集合に残っている ファイルディスクリプタの総数を返す。
select ()がタイムアウトすると、返り値は 0 になる。 その時、ファイルディスクリプタ集合はすべて空である (しかしそうならないシステムもある)。
返り値が -1 の場合はエラーを意味し、 errno が適切にセットされる。エラーが起こった場合、 返された集合や timeout 構造体の内容は未定義となっているので、 使うべきではない。 しかし pselect ()は決して ntimeout を変更しない。

一般的に言って、ソケットをサポートする全てのオペレーティングシステムは select ()もサポートしている。 select ()を使わないとものすごく複雑になってしまうプログラムが多い。 select ()を使うと、プログラマがスレッド、フォーク、IPC、シグナル、メモリ共有、 等々を使ってもっと複雑な方法で解決しようとする多くの問題が、 移植性がありかつ効率的な方法で解決できる。

  poll (2) システムコールは select () と同じ機能を持っており、 まばらなファイルディスクリプタ集合を監視する場合に いくらか効率がよい。 現在では広く利用可能であるが、以前は select () より移植性の面で劣っていた。

Linux 独自の   epoll (7) API は、多数のファイルディスクリプタを監視する場合に   select (2) や   poll (2) よりも効率的なインタフェースを提供している。

  accept (2),   connect (2),   ioctl (2),   poll (2),   read (2),   recv (2),   select (2),   send (2),   sigprocmask (2),   write (2),  sigaddset (3), sigdelset (3), sigemptyset (3), sigfillset (3), sigismember (3),  epoll (7)