2 iom.C -- generic I/O multiplexer
3 Copyright (C) 2003, 2004 Marc Lehmann <pcg@goof.com>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 #if 1 // older unices need these includes for select (2)
32 # include <sys/types.h>
42 // if the BSDs would at least be marginally POSIX-compatible.. *sigh*
43 // until that happens, sys/select.h must come last
44 #include <sys/select.h>
46 // TSTAMP_MAX must still fit into a positive struct timeval
47 #define TSTAMP_MAX (double)(1UL<<31)
49 #define TIMEVAL timeval
50 #define TV_FRAC tv_usec
51 #define TV_MULT 1000000L
54 static io_manager_vec<io_watcher> iow;
57 static io_manager_vec<check_watcher> cw;
60 static io_manager_vec<time_watcher> tw;
63 static io_manager_vec<idle_watcher> iw;
66 static int sigpipe[2]; // signal signalling pipe
68 struct sig_vec : io_manager_vec<sig_watcher> {
74 static vector<sig_vec *> sw;
77 // this is a dummy time watcher to ensure that the first
78 // time watcher is _always_ valid, this gets rid of a lot
79 // of null-pointer-checks
80 // (must come _before_ iom is being defined)
81 static struct tw0 : time_watcher
83 void cb (time_watcher &w)
85 // should never get called
86 // reached end-of-time, or tstamp has a bogus definition,
87 // or compiler initialisation order broken, or something else :)
92 : time_watcher (this, &tw0::cb)
99 tstamp io_manager::now ()
103 gettimeofday (&tv, 0);
104 return (tstamp)tv.tv_sec + (tstamp)tv.tv_usec / 1000000.;
107 void io_manager::set_now ()
113 static bool iom_valid;
115 // used for initialisation only
124 perror ("io_manager: unable to create signal pipe, aborting.");
128 fcntl (sigpipe[0], F_SETFL, O_NONBLOCK); fcntl (sigpipe[0], F_SETFD, FD_CLOEXEC);
129 fcntl (sigpipe[1], F_SETFL, O_NONBLOCK); fcntl (sigpipe[1], F_SETFD, FD_CLOEXEC);
135 io_manager::set_now ();
137 tw0.start (TSTAMP_MAX);
141 static void required ();
149 write (2, "io_manager: early registration attempt, aborting.\n",
150 sizeof ("io_manager: early registration attempt, aborting.\n") - 1);
155 template<class watcher>
156 void io_manager::reg (watcher &w, io_manager_vec<watcher> &queue)
162 queue.push_back (&w);
163 w.active = queue.size ();
167 template<class watcher>
168 void io_manager::unreg (watcher &w, io_manager_vec<watcher> &queue)
175 queue [w.active - 1] = 0;
181 void time_watcher::trigger ()
184 io_manager::reg (*this);
187 void io_manager::reg (time_watcher &w) { io_manager::reg (w, tw); }
188 void io_manager::unreg (time_watcher &w) { io_manager::unreg (w, tw); }
192 void io_manager::reg (io_watcher &w) { io_manager::reg (w, iow); }
193 void io_manager::unreg (io_watcher &w) { io_manager::unreg (w, iow); }
197 void io_manager::reg (check_watcher &w) { io_manager::reg (w, cw); }
198 void io_manager::unreg (check_watcher &w) { io_manager::unreg (w, cw); }
202 void io_manager::reg (idle_watcher &w) { io_manager::reg (w, iw); }
203 void io_manager::unreg (idle_watcher &w) { io_manager::unreg (w, iw); }
208 sighandler (int signum)
210 sw [signum - 1]->pending = true;
212 // we use a pipe for signal notifications, as most current
213 // OSes (Linux...) do not implement pselect correctly. ugh.
214 char ch = signum; // actual content not used
215 write (sigpipe[1], &ch, 1);
218 void io_manager::reg (sig_watcher &w)
220 assert (0 < w.signum);
222 sw.reserve (w.signum);
224 while (sw.size () < w.signum) // pathetic
227 sig_vec *&sv = sw[w.signum - 1];
233 sigaddset (&sigs, w.signum);
234 sigprocmask (SIG_BLOCK, &sigs, NULL);
237 sa.sa_handler = sighandler;
238 sigfillset (&sa.sa_mask);
239 sa.sa_flags = SA_RESTART;
241 if (sigaction (w.signum, &sa, 0))
243 perror ("io_manager: error while installing signal handler, ignoring.");
249 io_manager::reg (w, *sv);
252 void io_manager::unreg (sig_watcher &w)
257 assert (0 < w.signum && w.signum <= sw.size ());
259 io_manager::unreg (w, *sw[w.signum - 1]);
262 void sig_watcher::start (int signum)
265 this->signum = signum;
266 io_manager::reg (*this);
270 void io_manager::loop ()
282 // call pending time watchers
290 for (int i = tw.size (); i--; )
292 tw.erase_unordered (i);
293 else if (tw[i]->at <= NOW)
295 time_watcher &w = *tw[i];
308 // call all check watchers
309 for (int i = cw.size (); i--; )
311 cw.erase_unordered (i);
313 cw[i]->call (*cw[i]);
316 struct TIMEVAL *to = 0;
330 // find earliest active watcher
331 time_watcher *next = tw[0]; // the first time-watcher must exist at ALL times
333 for (io_manager_vec<time_watcher>::const_iterator i = tw.end (); i-- > tw.begin (); )
334 if (*i && (*i)->at < next->at)
337 if (next->at > NOW && next != tw[0])
339 double diff = next->at - NOW;
340 tval.tv_sec = (int)diff;
341 tval.TV_FRAC = (int) ((diff - tval.tv_sec) * TV_MULT);
347 #if IOM_IO || IOM_SIG
356 for (io_manager_vec<io_watcher>::const_iterator i = iow.end (); i-- > iow.begin (); )
359 if ((*i)->events & EVENT_READ ) FD_SET ((*i)->fd, &rfd);
360 if ((*i)->events & EVENT_WRITE) FD_SET ((*i)->fd, &wfd);
362 if ((*i)->fd >= fds) fds = (*i)->fd + 1;
366 if (!to && !fds) //TODO: also check idle_watchers and check_watchers?
370 FD_SET (sigpipe[0], &rfd);
371 if (sigpipe[0] >= fds) fds = sigpipe[0] + 1;
375 // there is no race, as we use a pipe for signals, so select
376 // will return if a signal is caught.
377 sigprocmask (SIG_UNBLOCK, &sigs, NULL);
379 fds = select (fds, &rfd, &wfd, NULL, to);
381 sigprocmask (SIG_BLOCK, &sigs, NULL);
386 // update time, try to compensate for gross non-monotonic time changes
392 for (io_manager_vec<time_watcher>::const_iterator i = tw.end (); i-- > tw.begin (); )
401 if (FD_ISSET (sigpipe[0], &rfd))
405 while (read (sigpipe[0], &ch, 1) > 0)
408 for (vector<sig_vec *>::iterator svp = sw.end (); svp-- > sw.begin (); )
409 if (*svp && (*svp)->pending)
412 for (int i = sv.size (); i--; )
414 sv.erase_unordered (i);
416 sv[i]->call (*sv[i]);
424 for (int i = iow.size (); i--; )
426 iow.erase_unordered (i);
429 io_watcher &w = *iow[i];
430 short revents = w.events;
432 if (!FD_ISSET (w.fd, &rfd)) revents &= ~EVENT_READ;
433 if (!FD_ISSET (w.fd, &wfd)) revents &= ~EVENT_WRITE;
440 else if (fds < 0 && errno != EINTR)
442 perror ("io_manager: fatal error while waiting for I/O or time event, aborting.");
447 for (int i = iw.size (); i--; )
449 iw.erase_unordered (i);
451 iw[i]->call (*iw[i]);
458 select (0, 0, 0, 0, &to);