ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/iom.C
(Generate patch)

Comparing rxvt-unicode/src/iom.C (file contents):
Revision 1.11 by pcg, Mon Jan 19 17:26:43 2004 UTC vs.
Revision 1.39 by root, Thu Oct 25 12:42:00 2007 UTC

1/* 1/*
2 iom.C -- generic I/O multiplexor 2 iom.C -- generic I/O multiplexer
3 Copyright (C) 2003, 2004 Marc Lehmann <pcg@goof.com> 3 Copyright (C) 2003-2006 Marc Lehmann <gvpe@schmorp.de>
4 4
5 This file is part of GVPE.
6
5 This program is free software; you can redistribute it and/or modify 7 GVPE is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by 8 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 9 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version. 10 (at your option) any later version.
9 11
10 This program is distributed in the hope that it will be useful, 12 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details. 15 GNU General Public License for more details.
14 16
15 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software 18 along with gvpe; if not, write to the Free Software
17 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18*/ 20*/
21
22#include "iom.h"
19 23
20#include <cstdio> 24#include <cstdio>
21#include <cstdlib> 25#include <cstdlib>
22#include <cerrno> 26#include <cerrno>
27#include <cassert>
23 28
29#include <sys/types.h>
24#include <sys/time.h> 30#include <sys/time.h>
25 31
26#if 1 // older unices need these includes for select(2) 32#if 1 // older unices need these includes for select (2)
27# include <unistd.h> 33# include <unistd.h>
34# include <time.h>
35#endif
36
37#if IOM_CHILD
28# include <sys/types.h> 38# include <sys/wait.h>
39#endif
40
41#if IOM_SIG
42# include <csignal>
43# include <fcntl.h>
29#endif 44#endif
30 45
31// if the BSDs would at least be marginally POSIX-compatible.. *sigh* 46// if the BSDs would at least be marginally POSIX-compatible.. *sigh*
32// until that happens, sys/select.h must come last 47// until that happens, sys/select.h must come last
33#include <sys/select.h> 48#include <sys/select.h>
34 49
35#include "iom.h" 50#define TIMEVAL timeval
51#define TV_FRAC tv_usec
52#define TV_MULT 1000000L
36 53
37// TSTAMP_MAX must still fit into a positive struct timeval 54#if IOM_CHECK
38#define TSTAMP_MAX (double)(1UL<<31) 55static io_manager_vec<check_watcher> cw;
56#endif
57#if IOM_IDLE
58static io_manager_vec<idle_watcher> iw;
59#endif
39 60
61#if IOM_SIG
62static int sigpipe[2]; // signal signalling pipe
63static sigset_t sigs;
64struct sig_vec : io_manager_vec<sig_watcher> {
65 int pending;
66 sig_vec ()
67 : pending (false)
68 { }
69};
70static vector<sig_vec *> sw;
71#endif
72
73#if IOM_CHILD
74static io_manager_vec<child_watcher> pw;
75#endif
76
77#ifdef IOM_LIBEVENT
78static bool need_set_now; // need to set_now in callback
79#else
80 #if IOM_IO
81 static io_manager_vec<io_watcher> iow;
82 #endif
83 #if IOM_TIME
84 static io_manager_vec<time_watcher> tw;
85 #endif
86#endif
87
88#if IOM_TIME
89tstamp io_manager::now ()
90{
91 struct timeval tv;
92
93 gettimeofday (&tv, 0);
94 return (tstamp)tv.tv_sec + (tstamp)tv.tv_usec / 1000000.;
95}
96
97void io_manager::set_now ()
98{
99 NOW = now ();
100 #ifdef IOM_LIBEVENT
101 need_set_now = false;
102 #endif
103}
104#endif
105
106#ifndef IOM_LIBEVENT
40// this is a dummy time watcher to ensure that the first 107// this is a dummy time watcher to ensure that the first
41// time watcher is _always_ valid, this gets rid of a lot 108// time watcher is _always_ valid, this gets rid of a lot
42// of null-pointer-checks 109// of null-pointer-checks
43// (must come _before_ iom is being defined) 110// (must come _before_ iom is being defined)
44static struct tw0 : time_watcher { 111static struct tw0 : time_watcher
112{
45 void cb (time_watcher &w) 113 void cb (time_watcher &w)
46 { 114 {
47 // should never get called 115 // should never get called
48 // reached end-of-time, or tstamp has a bogus definition, 116 // reached end-of-time, or tstamp has a bogus definition,
49 // or compiler initilization order broken, or somethine else :) 117 // or compiler initialisation order broken, or something else :)
50 abort (); 118 abort ();
51 } 119 }
52 120
53 tw0() 121 tw0 ()
54 : time_watcher (this, &tw0::cb) 122 : time_watcher (this, &tw0::cb)
55 { } 123 { }
56} tw0; 124} tw0;
125#endif
57 126
58tstamp NOW; 127tstamp NOW;
128
129#if IOM_CHILD
130// sig_watcher for child signal(s)
131static struct sw0 : sig_watcher
132{
133 void cb (sig_watcher &w)
134 {
135 // SIGCHLD, call corresponding watchera
136 pid_t pid;
137 int status;
138
139 while ((pid = waitpid (-1, &status, WNOHANG)) > 0)
140 for (int i = pw.size (); i--; )
141 {
142 child_watcher *w = pw[i];
143
144 if (!w)
145 pw.erase_unordered (i);
146 else if (w->pid == pid)
147 {
148 io_manager::unreg (*w);
149 w->call (*w, status);
150 }
151 }
152 }
153
154 sw0 ()
155 : sig_watcher (this, &sw0::cb)
156 { }
157} sw0;
158#endif
159
59static bool iom_valid; 160static bool iom_valid;
60io_manager iom; 161
162// used for initialisation only
163static struct init {
164 init ()
165 {
166 #ifdef IOM_PREINIT
167 { IOM_PREINIT }
168 #endif
169
170 #ifdef IOM_LIBEVENT
171 event_init ();
172 #endif
173 iom_valid = true;
174
175 #if IOM_SIG
176 sigemptyset (&sigs);
177
178 if (pipe (sigpipe))
179 {
180 perror ("io_manager: unable to create signal pipe, aborting.");
181 abort ();
182 }
183
184 fcntl (sigpipe[0], F_SETFL, O_NONBLOCK); fcntl (sigpipe[0], F_SETFD, FD_CLOEXEC);
185 fcntl (sigpipe[1], F_SETFL, O_NONBLOCK); fcntl (sigpipe[1], F_SETFD, FD_CLOEXEC);
186 #endif
187
188 #if IOM_CHILD
189 sw0.start (SIGCHLD);
190 #endif
191
192 #if IOM_TIME
193 io_manager::set_now ();
194
195 #ifndef IOM_LIBEVENT
196 tw0.start (TSTAMP_MAX);
197 #endif
198 #endif
199
200 #ifdef IOM_POSTINIT
201 { IOM_POSTINIT }
202 #endif
203 }
204
205 ~init ()
206 {
207 iom_valid = false;
208 }
209
210 static void required ();
211} init;
212
213void
214init::required ()
215{
216 if (!iom_valid)
217 {
218 write (2, "io_manager: early registration attempt, aborting.\n",
219 sizeof ("io_manager: early registration attempt, aborting.\n") - 1);
220 abort ();
221 }
222}
61 223
62template<class watcher> 224template<class watcher>
63void io_manager::reg (watcher *w, io_manager_vec<watcher> &queue) 225void io_manager::reg (watcher &w, io_manager_vec<watcher> &queue)
64{ 226{
65 if (!iom_valid) 227 init::required ();
66 abort ();
67 228
68 if (!w->active) 229 if (!w.active)
69 { 230 {
70 queue.push_back (w); 231 queue.push_back (&w);
71 w->active = queue.size (); 232 w.active = queue.size ();
72 } 233 }
73} 234}
74 235
75template<class watcher> 236template<class watcher>
76void io_manager::unreg (watcher *w, io_manager_vec<watcher> &queue) 237void io_manager::unreg (watcher &w, io_manager_vec<watcher> &queue)
77{ 238{
78 if (!iom_valid) 239 if (!iom_valid)
79 return; 240 return;
80 241
81 if (w->active) 242 if (w.active)
82 { 243 {
83 queue [w->active - 1] = 0; 244 queue [w.active - 1] = 0;
84 w->active = 0; 245 w.active = 0;
85 } 246 }
86} 247}
87 248
88#if IOM_TIME 249#if IOM_TIME
250 #ifdef IOM_LIBEVENT
251 void iom_time_c_callback (int fd, short events, void *data)
252 {
253 if (need_set_now) io_manager::set_now ();
254 time_watcher *w = static_cast<time_watcher *>(data);
255 w->call (*w);
256 }
257
258 void time_watcher::start ()
259 {
260 stop ();
261 evtimer_set (&ev, iom_time_c_callback, (void *)this);
262 struct timeval tv;
263 tv.tv_sec = (long)at;
264 tv.tv_usec = (long)((at - (tstamp)tv.tv_sec) * 1000000.);
265 evtimer_add (&ev, &tv);
266 active = 1;
267 }
268 #else
269 void io_manager::reg (time_watcher &w) { io_manager::reg (w, tw); }
270 void io_manager::unreg (time_watcher &w) { io_manager::unreg (w, tw); }
271 #endif
272
89void time_watcher::trigger () 273 void time_watcher::trigger ()
90{ 274 {
91 call (*this); 275 call (*this);
92 276 start ();
93 iom.reg (this); 277 }
94}
95
96void io_manager::reg (time_watcher *w) { reg (w, tw); }
97void io_manager::unreg (time_watcher *w) { unreg (w, tw); }
98#endif 278#endif
99 279
100#if IOM_IO 280#if IOM_IO
281 #ifdef IOM_LIBEVENT
282 void iom_io_c_callback (int fd, short events, void *data)
283 {
284 if (need_set_now) io_manager::set_now ();
285 io_watcher *w = static_cast<io_watcher *>(data);
286 w->call (*w, events);
287 }
288
289 void io_watcher::set (int fd_, short events_)
290 {
291 if (active) event_del (&ev);
292 fd = fd_;
293 events = events_;
294 event_set (&ev, fd_, events_ | EV_PERSIST, iom_io_c_callback, (void *)this);
295 if (active) event_add (&ev, 0);
296 }
297 #else
101void io_manager::reg (io_watcher *w) { reg (w, iow); } 298 void io_manager::reg (io_watcher &w) { io_manager::reg (w, iow); }
102void io_manager::unreg (io_watcher *w) { unreg (w, iow); } 299 void io_manager::unreg (io_watcher &w) { io_manager::unreg (w, iow); }
300 #endif
103#endif 301#endif
104 302
105#if IOM_CHECK 303#if IOM_CHECK
106void io_manager::reg (check_watcher *w) { reg (w, cw); } 304void io_manager::reg (check_watcher &w) { io_manager::reg (w, cw); }
107void io_manager::unreg (check_watcher *w) { unreg (w, cw); } 305void io_manager::unreg (check_watcher &w) { io_manager::unreg (w, cw); }
108#endif 306#endif
109 307
110#if IOM_IDLE 308#if IOM_IDLE
111void io_manager::reg (idle_watcher *w) { reg (w, iw); } 309void io_manager::reg (idle_watcher &w) { io_manager::reg (w, iw); }
112void io_manager::unreg (idle_watcher *w) { unreg (w, iw); } 310void io_manager::unreg (idle_watcher &w) { io_manager::unreg (w, iw); }
113#endif 311#endif
114 312
115#if IOM_TIME 313#if IOM_SIG
116inline void set_now (void) 314static void
315sighandler (int signum)
117{ 316{
118 struct timeval tv; 317 sw [signum - 1]->pending = true;
119 318
120 gettimeofday (&tv, 0); 319 // we use a pipe for signal notifications, as most current
121 320 // OSes (Linux...) do not implement pselect correctly. ugh.
122 NOW = (tstamp)tv.tv_sec + (tstamp)tv.tv_usec / 1000000; 321 char ch = signum; // actual content not used
123#endif 322 write (sigpipe[1], &ch, 1);
124} 323}
324
325void io_manager::reg (sig_watcher &w)
326{
327 init::required ();
328
329 assert (0 < w.signum);
330
331 sw.reserve (w.signum);
332
333 while (sw.size () < w.signum) // pathetic
334 sw.push_back (0);
335
336 sig_vec *&sv = sw[w.signum - 1];
337
338 if (!sv)
339 {
340 sv = new sig_vec;
341
342 sigaddset (&sigs, w.signum);
343 sigprocmask (SIG_BLOCK, &sigs, NULL);
344
345 struct sigaction sa;
346 sa.sa_handler = sighandler;
347 sigfillset (&sa.sa_mask);
348 sa.sa_flags = SA_RESTART;
349
350 if (sigaction (w.signum, &sa, 0))
351 {
352 perror ("io_manager: error while installing signal handler, ignoring.");
353 abort ();
354 }
355
356 }
357
358 io_manager::reg (w, *sv);
359}
360
361void io_manager::unreg (sig_watcher &w)
362{
363 if (!w.active || !iom_valid)
364 return;
365
366 assert (0 < w.signum && w.signum <= sw.size ());
367
368 io_manager::unreg (w, *sw[w.signum - 1]);
369}
370
371void sig_watcher::start (int signum)
372{
373 stop ();
374 this->signum = signum;
375 io_manager::reg (*this);
376}
377#endif
378
379#if IOM_CHILD
380void io_manager::reg (child_watcher &w) { io_manager::reg (w, pw); }
381void io_manager::unreg (child_watcher &w) { io_manager::unreg (w, pw); }
382#endif
125 383
126void io_manager::loop () 384void io_manager::loop ()
127{ 385{
386 init::required ();
387
128#if IOM_TIME 388 #if IOM_TIME
129 set_now (); 389 set_now ();
130#endif 390 #endif
131 391
132 for (;;) 392 for (;;)
133 { 393 {
394 #ifndef IOM_LIBEVENT
395 #if IOM_TIME
396 // call pending time watchers
397 {
398 bool activity;
399
400 do
401 {
402 activity = false;
403
404 for (int i = tw.size (); i--; )
405 if (!tw[i])
406 tw.erase_unordered (i);
407 else if (tw[i]->at <= NOW)
408 {
409 time_watcher &w = *tw[i];
410
411 unreg (w);
412 w.call (w);
413
414 activity = true;
415 }
416 }
417 while (activity);
418 }
419 #endif
420 #endif
421
422 #if IOM_CHECK
423 // call all check watchers
424 for (int i = cw.size (); i--; )
425 if (!cw[i])
426 cw.erase_unordered (i);
427 else
428 cw[i]->call (*cw[i]);
429 #endif
430
134 struct timeval *to = 0; 431 struct TIMEVAL *to = 0;
135 struct timeval tval; 432 struct TIMEVAL tval;
136 433
137#if IOM_IDLE 434#if IOM_IDLE
138 if (iw.size ()) 435 if (iw.size ())
139 { 436 {
140 tval.tv_sec = 0; 437 tval.tv_sec = 0;
141 tval.tv_usec = 0; 438 tval.TV_FRAC = 0;
142 to = &tval; 439 to = &tval;
143 } 440 }
144 else 441 else
145#endif 442#endif
146 { 443 {
147#if IOM_TIME 444 #ifndef IOM_LIBEVENT
148 time_watcher *next; 445 #if IOM_TIME
446 // find earliest active watcher
447 time_watcher *next = tw[0]; // the first time-watcher must exist at ALL times
149 448
150 for (;;) 449 for (io_manager_vec<time_watcher>::const_iterator i = tw.end (); i-- > tw.begin (); )
450 if (*i && (*i)->at < next->at)
451 next = *i;
452
453 if (next->at > NOW && next != tw[0])
151 { 454 {
152 next = tw[0]; // the first time-watcher must exist at ALL times 455 double diff = next->at - NOW;
456 tval.tv_sec = (int)diff;
457 tval.TV_FRAC = (int) ((diff - tval.tv_sec) * TV_MULT);
458 to = &tval;
459 }
460 #endif
461 #endif
462 }
153 463
154 for (int i = tw.size (); i--; ) 464 #ifndef IOM_LIBEVENT
465 #if IOM_IO || IOM_SIG
466 fd_set rfd, wfd;
467
468 FD_ZERO (&rfd);
469 FD_ZERO (&wfd);
470
471 int fds = 0;
472
473 #if IOM_IO
474 for (io_manager_vec<io_watcher>::const_iterator i = iow.end (); i-- > iow.begin (); )
155 if (!tw[i]) 475 if (*i)
156 tw.erase_unordered (i);
157 else if (tw[i]->at < next->at)
158 next = tw[i];
159
160 if (next->at > NOW)
161 { 476 {
162 if (next != tw[0]) 477 if ((*i)->events & EVENT_READ ) FD_SET ((*i)->fd, &rfd);
163 { 478 if ((*i)->events & EVENT_WRITE) FD_SET ((*i)->fd, &wfd);
164 double diff = next->at - NOW; 479
165 tval.tv_sec = (int)diff; 480 if ((*i)->fd >= fds) fds = (*i)->fd + 1;
166 tval.tv_usec = (int)((diff - tval.tv_sec) * 1000000);
167 to = &tval;
168 }
169 break;
170 } 481 }
171 else 482 #endif
483
484 if (!to && !fds) //TODO: also check idle_watchers and check_watchers?
485 break; // no events
486
487 #if IOM_SIG
488 FD_SET (sigpipe[0], &rfd);
489 if (sigpipe[0] >= fds) fds = sigpipe[0] + 1;
490 #endif
491
492 #if IOM_SIG
493 // there is no race, as we use a pipe for signals, so select
494 // will return if a signal is caught.
495 sigprocmask (SIG_UNBLOCK, &sigs, NULL);
496 #endif
497 fds = select (fds, &rfd, &wfd, NULL, to);
498 #if IOM_SIG
499 sigprocmask (SIG_BLOCK, &sigs, NULL);
500 #endif
501 #elif IOM_TIME
502 if (!to)
503 break;
504
505 select (0, 0, 0, 0, to);
506 #endif
507
508 #if IOM_TIME
509 {
510 // update time, try to compensate for gross non-monotonic time changes
511 tstamp diff = NOW;
512 set_now ();
513 diff = NOW - diff;
514
515 if (diff < 0)
516 for (io_manager_vec<time_watcher>::const_iterator i = tw.end (); i-- > tw.begin (); )
517 if (*i)
518 (*i)->at += diff;
519 }
520 #endif
521
522 if (fds > 0)
523 {
524 #if IOM_SIG
525 if (FD_ISSET (sigpipe[0], &rfd))
172 { 526 {
173 unreg (next); 527 char ch;
174 next->call (*next); 528
529 while (read (sigpipe[0], &ch, 1) > 0)
530 ;
531
532 for (vector<sig_vec *>::iterator svp = sw.end (); svp-- > sw.begin (); )
533 if (*svp && (*svp)->pending)
534 {
535 sig_vec &sv = **svp;
536 for (int i = sv.size (); i--; )
537 if (!sv[i])
538 sv.erase_unordered (i);
539 else
540 sv[i]->call (*sv[i]);
541
542 sv.pending = false;
543 }
175 } 544 }
545 #endif
546
547 #if IOM_IO
548 for (int i = iow.size (); i--; )
549 if (!iow[i])
550 iow.erase_unordered (i);
551 else
552 {
553 io_watcher &w = *iow[i];
554 short revents = w.events;
555
556 if (!FD_ISSET (w.fd, &rfd)) revents &= ~EVENT_READ;
557 if (!FD_ISSET (w.fd, &wfd)) revents &= ~EVENT_WRITE;
558
559 if (revents)
560 w.call (w, revents);
561 }
562 #endif
176 } 563 }
177#endif 564 else if (fds < 0 && errno != EINTR)
565 {
566 perror ("io_manager: fatal error while waiting for I/O or time event, aborting.");
567 abort ();
178 } 568 }
179 569#if IOM_IDLE
180#if IOM_CHECK
181 for (int i = cw.size (); i--; )
182 if (!cw[i])
183 cw.erase_unordered (i);
184 else 570 else
185 cw[i]->call (*cw[i]);
186#endif
187
188#if IOM_IO
189 fd_set rfd, wfd, efd;
190
191 FD_ZERO (&rfd);
192 FD_ZERO (&wfd);
193
194 int fds = 0;
195
196 for (io_manager_vec<io_watcher>::iterator i = iow.end (); i-- > iow.begin (); )
197 if (*i)
198 {
199 if ((*i)->events & EVENT_READ ) FD_SET ((*i)->fd, &rfd);
200 if ((*i)->events & EVENT_WRITE) FD_SET ((*i)->fd, &wfd);
201
202 if ((*i)->fd >= fds) fds = (*i)->fd + 1;
203 }
204
205 if (!to && !fds) //TODO: also check idle_watchers and check_watchers
206 break; // no events
207
208 fds = select (fds, &rfd, &wfd, &efd, to);
209# if IOM_TIME
210 set_now ();
211# endif
212
213 if (fds > 0)
214 for (int i = iow.size (); i--; )
215 if (!iow[i])
216 iow.erase_unordered (i);
217 else
218 {
219 short revents = iow[i]->events;
220
221 if (!FD_ISSET (iow[i]->fd, &rfd)) revents &= ~EVENT_READ;
222 if (!FD_ISSET (iow[i]->fd, &wfd)) revents &= ~EVENT_WRITE;
223
224 if (revents)
225 iow[i]->call (*iow[i], revents);
226 }
227 else if (fds < 0 && errno != EINTR)
228 {
229 perror ("Error while waiting for I/O or time event");
230 abort ();
231 }
232#if IOM_IDLE
233 else
234 for (int i = iw.size (); i--; ) 571 for (int i = iw.size (); i--; )
235 if (!iw[i]) 572 if (!iw[i])
236 iw.erase_unordered (i); 573 iw.erase_unordered (i);
237 else 574 else
238 iw[i]->call (*iw[i]); 575 iw[i]->call (*iw[i]);
239#endif 576#endif
240 577
241#elif IOM_TIME 578 #else
579 need_set_now = true;
580
242 if (!to) 581 if (to)
243 break; 582 event_loop (EVLOOP_NONBLOCK);
583 else
584 event_loop (EVLOOP_ONCE);
244 585
245 select (0, 0, 0, 0, &to); 586 if (need_set_now) set_now ();
246 set_now (); 587 #endif
247#else 588 //TODO: IOM_IDLE
248 break;
249#endif
250 } 589 }
251} 590}
252 591
253io_manager::io_manager ()
254{
255 iom_valid = true;
256
257#if IOM_TIME
258 set_now ();
259
260 tw0.start (TSTAMP_MAX);
261#endif
262}
263
264io_manager::~io_manager ()
265{
266 iom_valid = false;
267}
268

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines