467aef8678a2a02cda7a2b987bf073ee1280495f
[dana/urxvt.git] / src / iom.C
1 /*
2     iom.C -- generic I/O multiplexer
3     Copyright (C) 2003, 2004 Marc Lehmann <pcg@goof.com>
4  
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.
9  
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.
14  
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
18 */
19
20 #include "iom.h"
21
22 #include <cstdio>
23 #include <cstdlib>
24 #include <cerrno>
25
26 #include <sys/time.h>
27
28 #include <assert.h>
29
30 #if 1 // older unices need these includes for select (2)
31 # include <unistd.h>
32 # include <sys/types.h>
33 # include <time.h>
34 #endif
35
36 // for IOM_SIG
37 #if IOM_SIG
38 # include <csignal>
39 # include <fcntl.h>
40 #endif
41
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>
45
46 // TSTAMP_MAX must still fit into a positive struct timeval
47 #define TSTAMP_MAX (double)(1UL<<31)
48
49 #define TIMEVAL timeval
50 #define TV_FRAC tv_usec
51 #define TV_MULT 1000000L
52
53 #if IOM_IO
54 static io_manager_vec<io_watcher>    iow;
55 #endif
56 #if IOM_CHECK
57 static io_manager_vec<check_watcher> cw;
58 #endif
59 #if IOM_TIME
60 static io_manager_vec<time_watcher>  tw;
61 #endif
62 #if IOM_IDLE
63 static io_manager_vec<idle_watcher>  iw;
64 #endif
65 #if IOM_SIG
66 static int sigpipe[2]; // signal signalling pipe
67 static sigset_t sigs;
68 struct sig_vec : io_manager_vec<sig_watcher> {
69   int pending;
70   sig_vec ()
71     : pending (false)
72     { }
73 };
74 static vector<sig_vec *> sw;
75 #endif
76
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
82   {
83     void cb (time_watcher &w)
84     {
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 :)
88       abort ();
89     }
90
91     tw0 ()
92       : time_watcher (this, &tw0::cb)
93       { }
94   } tw0;
95
96 tstamp NOW;
97
98 #if IOM_TIME
99 tstamp io_manager::now ()
100 {
101   struct timeval tv;
102
103   gettimeofday (&tv, 0);
104   return (tstamp)tv.tv_sec + (tstamp)tv.tv_usec / 1000000.;
105 }
106
107 void io_manager::set_now ()
108 {
109   NOW = now ();
110 }
111 #endif
112
113 static bool iom_valid;
114
115 // used for initialisation only
116 static struct init {
117   init ()
118   {
119 #if IOM_SIG
120     sigemptyset (&sigs);
121
122     if (pipe (sigpipe))
123       {
124         perror ("io_manager: unable to create signal pipe, aborting.");
125         abort ();
126       }
127
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);
130 #endif
131
132     iom_valid = true;
133
134 #if IOM_TIME
135     io_manager::set_now ();
136
137     tw0.start (TSTAMP_MAX);
138 #endif
139   }
140
141   static void required ();
142 } init;
143
144 void
145 init::required ()
146 {
147   if (!iom_valid)
148     {
149       write (2, "io_manager: early registration attempt, aborting.\n",
150                 sizeof ("io_manager: early registration attempt, aborting.\n") - 1);
151       abort ();
152     }
153 }
154
155 template<class watcher>
156 void io_manager::reg (watcher &w, io_manager_vec<watcher> &queue)
157 {
158   init::required ();
159
160   if (!w.active)
161     {
162       queue.push_back (&w);
163       w.active = queue.size ();
164     }
165 }
166
167 template<class watcher>
168 void io_manager::unreg (watcher &w, io_manager_vec<watcher> &queue)
169 {
170   if (!iom_valid)
171     return;
172
173   if (w.active)
174     {
175       queue [w.active - 1] = 0;
176       w.active = 0;
177     }
178 }
179
180 #if IOM_TIME
181 void time_watcher::trigger ()
182 {
183   call (*this);
184   io_manager::reg (*this);
185 }
186
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); }
189 #endif
190
191 #if IOM_IO
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); }
194 #endif
195
196 #if IOM_CHECK
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); }
199 #endif
200
201 #if IOM_IDLE
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); }
204 #endif
205
206 #if IOM_SIG
207 static void
208 sighandler (int signum)
209 {
210   sw [signum - 1]->pending = true;
211
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);
216 }
217
218 void io_manager::reg (sig_watcher &w)
219 {
220   assert (0 < w.signum);
221
222   sw.reserve (w.signum);
223
224   while (sw.size () < w.signum) // pathetic
225     sw.push_back (0);
226
227   sig_vec *&sv = sw[w.signum - 1];
228
229   if (!sv)
230     {
231       sv = new sig_vec;
232
233       sigaddset (&sigs, w.signum);
234       sigprocmask (SIG_BLOCK, &sigs, NULL);
235
236       struct sigaction sa;
237       sa.sa_handler = sighandler;
238       sigfillset (&sa.sa_mask);
239       sa.sa_flags = SA_RESTART;
240
241       if (sigaction (w.signum, &sa, 0))
242         {
243           perror ("io_manager: error while installing signal handler, ignoring.");
244           abort ();
245         }
246
247     }
248
249   io_manager::reg (w, *sv);
250 }
251
252 void io_manager::unreg (sig_watcher &w)
253 {
254   if (!w.active)
255     return;
256
257   assert (0 < w.signum && w.signum <= sw.size ());
258   
259   io_manager::unreg (w, *sw[w.signum - 1]);
260 }
261
262 void sig_watcher::start (int signum)
263 {
264   stop ();
265   this->signum = signum;
266   io_manager::reg (*this);
267 }
268 #endif
269
270 void io_manager::loop ()
271 {
272   init::required ();
273
274 #if IOM_TIME
275   set_now ();
276 #endif
277
278   for (;;)
279     {
280
281 #if IOM_TIME
282       // call pending time watchers
283       {
284         bool activity;
285
286         do
287           {
288             activity = false;
289
290             for (int i = tw.size (); i--; )
291               if (!tw[i])
292                 tw.erase_unordered (i);
293               else if (tw[i]->at <= NOW)
294                 {
295                   time_watcher &w = *tw[i];
296                   
297                   unreg (w);
298                   w.call (w);
299
300                   activity = true;
301                 }
302           }
303         while (activity);
304       }
305 #endif
306
307 #if IOM_CHECK
308       // call all check watchers
309       for (int i = cw.size (); i--; )
310         if (!cw[i])
311           cw.erase_unordered (i);
312         else
313           cw[i]->call (*cw[i]);
314 #endif
315
316       struct TIMEVAL *to = 0;
317       struct TIMEVAL tval;
318
319 #if IOM_IDLE
320       if (iw.size ())
321         {
322           tval.tv_sec  = 0;
323           tval.TV_FRAC = 0;
324           to = &tval;
325         }
326       else
327 #endif
328         {
329 #if IOM_TIME
330           // find earliest active watcher
331           time_watcher *next = tw[0]; // the first time-watcher must exist at ALL times
332
333           for (io_manager_vec<time_watcher>::const_iterator i = tw.end (); i-- > tw.begin (); )
334             if (*i && (*i)->at < next->at)
335               next = *i;
336
337           if (next->at > NOW && next != tw[0])
338             {
339               double diff = next->at - NOW;
340               tval.tv_sec  = (int)diff;
341               tval.TV_FRAC = (int) ((diff - tval.tv_sec) * TV_MULT);
342               to = &tval;
343             }
344         }
345 #endif
346
347 #if IOM_IO || IOM_SIG
348       fd_set rfd, wfd;
349
350       FD_ZERO (&rfd);
351       FD_ZERO (&wfd);
352
353       int fds = 0;
354
355 # if IOM_IO
356       for (io_manager_vec<io_watcher>::const_iterator i = iow.end (); i-- > iow.begin (); )
357         if (*i)
358           {
359             if ((*i)->events & EVENT_READ ) FD_SET ((*i)->fd, &rfd);
360             if ((*i)->events & EVENT_WRITE) FD_SET ((*i)->fd, &wfd);
361
362             if ((*i)->fd >= fds) fds = (*i)->fd + 1;
363           }
364 # endif
365
366       if (!to && !fds) //TODO: also check idle_watchers and check_watchers?
367         break; // no events
368
369 # if IOM_SIG
370       FD_SET (sigpipe[0], &rfd);
371       if (sigpipe[0] >= fds) fds = sigpipe[0] + 1;
372 # endif
373
374 # if IOM_SIG
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);
378 # endif
379       fds = select (fds, &rfd, &wfd, NULL, to);
380 # if IOM_SIG
381       sigprocmask (SIG_BLOCK, &sigs, NULL);
382 # endif
383
384 # if IOM_TIME
385       {
386         // update time, try to compensate for gross non-monotonic time changes
387         tstamp diff = NOW;
388         set_now ();
389         diff = NOW - diff;
390
391         if (diff < 0)
392           for (io_manager_vec<time_watcher>::const_iterator i = tw.end (); i-- > tw.begin (); )
393             if (*i)
394               (*i)->at += diff;
395       }
396 # endif
397
398       if (fds > 0)
399         {
400 # if IOM_SIG
401           if (FD_ISSET (sigpipe[0], &rfd))
402             {
403               char ch;
404
405               while (read (sigpipe[0], &ch, 1) > 0)
406                 ;
407
408               for (vector<sig_vec *>::iterator svp = sw.end (); svp-- > sw.begin (); )
409                 if (*svp && (*svp)->pending)
410                   {
411                     sig_vec &sv = **svp;
412                     for (int i = sv.size (); i--; )
413                       if (!sv[i])
414                         sv.erase_unordered (i);
415                       else
416                         sv[i]->call (*sv[i]);
417
418                     sv.pending = false;
419                   }
420             }
421 # endif
422
423 # if IOM_IO
424           for (int i = iow.size (); i--; )
425             if (!iow[i])
426               iow.erase_unordered (i);
427             else
428               {
429                 io_watcher &w = *iow[i];
430                 short revents = w.events;
431
432                 if (!FD_ISSET (w.fd, &rfd)) revents &= ~EVENT_READ;
433                 if (!FD_ISSET (w.fd, &wfd)) revents &= ~EVENT_WRITE;
434
435                 if (revents)
436                   w.call (w, revents);
437               }
438 #endif
439         }
440       else if (fds < 0 && errno != EINTR)
441         {
442           perror ("io_manager: fatal error while waiting for I/O or time event, aborting.");
443           abort ();
444         }
445 #if IOM_IDLE
446       else
447         for (int i = iw.size (); i--; )
448           if (!iw[i])
449             iw.erase_unordered (i);
450           else
451             iw[i]->call (*iw[i]);
452 #endif
453
454 #elif IOM_TIME
455       if (!to)
456         break;
457
458       select (0, 0, 0, 0, &to);
459       set_now ();
460 #else
461       break;
462 #endif
463     }
464 }
465