ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.261 by root, Mon Sep 29 03:31:14 2008 UTC vs.
Revision 1.269 by root, Wed Oct 29 06:32:48 2008 UTC

… …
286# include <sys/select.h> 286# include <sys/select.h>
287# endif 287# endif
288#endif 288#endif
289 289
290#if EV_USE_INOTIFY 290#if EV_USE_INOTIFY
291# include <sys/utsname.h>
291# include <sys/inotify.h> 292# include <sys/inotify.h>
293/* some very old inotify.h headers don't have IN_DONT_FOLLOW */
294# ifndef IN_DONT_FOLLOW
295# undef EV_USE_INOTIFY
296# define EV_USE_INOTIFY 0
297# endif
292#endif 298#endif
293 299
294#if EV_SELECT_IS_WINSOCKET 300#if EV_SELECT_IS_WINSOCKET
295# include <winsock.h> 301# include <winsock.h>
296#endif 302#endif
… …
382{ 388{
383 syserr_cb = cb; 389 syserr_cb = cb;
384} 390}
385 391
386static void noinline 392static void noinline
387syserr (const char *msg) 393ev_syserr (const char *msg)
388{ 394{
389 if (!msg) 395 if (!msg)
390 msg = "(libev) system error"; 396 msg = "(libev) system error";
391 397
392 if (syserr_cb) 398 if (syserr_cb)
… …
443typedef struct 449typedef struct
444{ 450{
445 WL head; 451 WL head;
446 unsigned char events; 452 unsigned char events;
447 unsigned char reify; 453 unsigned char reify;
454 unsigned char emask; /* the epoll backend stores the actual kernel mask in here */
455 unsigned char unused;
456#if EV_USE_EPOLL
457 unsigned int egen; /* generation counter to counter epoll bugs */
458#endif
448#if EV_SELECT_IS_WINSOCKET 459#if EV_SELECT_IS_WINSOCKET
449 SOCKET handle; 460 SOCKET handle;
450#endif 461#endif
451} ANFD; 462} ANFD;
452 463
… …
605{ 616{
606 *cur = array_nextsize (elem, *cur, cnt); 617 *cur = array_nextsize (elem, *cur, cnt);
607 return ev_realloc (base, elem * *cur); 618 return ev_realloc (base, elem * *cur);
608} 619}
609 620
621#define array_init_zero(base,count) \
622 memset ((void *)(base), 0, sizeof (*(base)) * (count))
623
610#define array_needsize(type,base,cur,cnt,init) \ 624#define array_needsize(type,base,cur,cnt,init) \
611 if (expect_false ((cnt) > (cur))) \ 625 if (expect_false ((cnt) > (cur))) \
612 { \ 626 { \
613 int ocur_ = (cur); \ 627 int ocur_ = (cur); \
614 (base) = (type *)array_realloc \ 628 (base) = (type *)array_realloc \
… …
656 for (i = 0; i < eventcnt; ++i) 670 for (i = 0; i < eventcnt; ++i)
657 ev_feed_event (EV_A_ events [i], type); 671 ev_feed_event (EV_A_ events [i], type);
658} 672}
659 673
660/*****************************************************************************/ 674/*****************************************************************************/
661
662void inline_size
663anfds_init (ANFD *base, int count)
664{
665 while (count--)
666 {
667 base->head = 0;
668 base->events = EV_NONE;
669 base->reify = 0;
670
671 ++base;
672 }
673}
674 675
675void inline_speed 676void inline_speed
676fd_event (EV_P_ int fd, int revents) 677fd_event (EV_P_ int fd, int revents)
677{ 678{
678 ANFD *anfd = anfds + fd; 679 ANFD *anfd = anfds + fd;
… …
808 809
809 for (fd = 0; fd < anfdmax; ++fd) 810 for (fd = 0; fd < anfdmax; ++fd)
810 if (anfds [fd].events) 811 if (anfds [fd].events)
811 { 812 {
812 anfds [fd].events = 0; 813 anfds [fd].events = 0;
814 anfds [fd].emask = 0;
813 fd_change (EV_A_ fd, EV_IOFDSET | 1); 815 fd_change (EV_A_ fd, EV_IOFDSET | 1);
814 } 816 }
815} 817}
816 818
817/*****************************************************************************/ 819/*****************************************************************************/
… …
969static ANSIG *signals; 971static ANSIG *signals;
970static int signalmax; 972static int signalmax;
971 973
972static EV_ATOMIC_T gotsig; 974static EV_ATOMIC_T gotsig;
973 975
974void inline_size
975signals_init (ANSIG *base, int count)
976{
977 while (count--)
978 {
979 base->head = 0;
980 base->gotsig = 0;
981
982 ++base;
983 }
984}
985
986/*****************************************************************************/ 976/*****************************************************************************/
987 977
988void inline_speed 978void inline_speed
989fd_intern (int fd) 979fd_intern (int fd)
990{ 980{
… …
1011 } 1001 }
1012 else 1002 else
1013#endif 1003#endif
1014 { 1004 {
1015 while (pipe (evpipe)) 1005 while (pipe (evpipe))
1016 syserr ("(libev) error creating signal/async pipe"); 1006 ev_syserr ("(libev) error creating signal/async pipe");
1017 1007
1018 fd_intern (evpipe [0]); 1008 fd_intern (evpipe [0]);
1019 fd_intern (evpipe [1]); 1009 fd_intern (evpipe [1]);
1020 ev_io_set (&pipeev, evpipe [0], EV_READ); 1010 ev_io_set (&pipeev, evpipe [0], EV_READ);
1021 } 1011 }
… …
1652{ 1642{
1653#if EV_MULTIPLICITY 1643#if EV_MULTIPLICITY
1654 struct ev_loop *loop = ev_default_loop_ptr; 1644 struct ev_loop *loop = ev_default_loop_ptr;
1655#endif 1645#endif
1656 1646
1647 ev_default_loop_ptr = 0;
1648
1657#ifndef _WIN32 1649#ifndef _WIN32
1658 ev_ref (EV_A); /* child watcher */ 1650 ev_ref (EV_A); /* child watcher */
1659 ev_signal_stop (EV_A_ &childev); 1651 ev_signal_stop (EV_A_ &childev);
1660#endif 1652#endif
1661 1653
… …
1667{ 1659{
1668#if EV_MULTIPLICITY 1660#if EV_MULTIPLICITY
1669 struct ev_loop *loop = ev_default_loop_ptr; 1661 struct ev_loop *loop = ev_default_loop_ptr;
1670#endif 1662#endif
1671 1663
1672 if (backend) 1664 ev_loop_fork (EV_A);
1673 postfork = 1; /* must be in line with ev_loop_fork */
1674} 1665}
1675 1666
1676/*****************************************************************************/ 1667/*****************************************************************************/
1677 1668
1678void 1669void
… …
2133 2124
2134 if (expect_false (ev_is_active (w))) 2125 if (expect_false (ev_is_active (w)))
2135 return; 2126 return;
2136 2127
2137 assert (("ev_io_start called with negative fd", fd >= 0)); 2128 assert (("ev_io_start called with negative fd", fd >= 0));
2129 assert (("ev_io start called with illegal event mask", !(w->events & ~(EV_IOFDSET | EV_READ | EV_WRITE))));
2138 2130
2139 EV_FREQUENT_CHECK; 2131 EV_FREQUENT_CHECK;
2140 2132
2141 ev_start (EV_A_ (W)w, 1); 2133 ev_start (EV_A_ (W)w, 1);
2142 array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init); 2134 array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
2143 wlist_add (&anfds[fd].head, (WL)w); 2135 wlist_add (&anfds[fd].head, (WL)w);
2144 2136
2145 fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1); 2137 fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1);
2146 w->events &= ~EV_IOFDSET; 2138 w->events &= ~EV_IOFDSET;
2147 2139
… …
2339 sigset_t full, prev; 2331 sigset_t full, prev;
2340 sigfillset (&full); 2332 sigfillset (&full);
2341 sigprocmask (SIG_SETMASK, &full, &prev); 2333 sigprocmask (SIG_SETMASK, &full, &prev);
2342#endif 2334#endif
2343 2335
2344 array_needsize (ANSIG, signals, signalmax, w->signum, signals_init); 2336 array_needsize (ANSIG, signals, signalmax, w->signum, array_init_zero);
2345 2337
2346#ifndef _WIN32 2338#ifndef _WIN32
2347 sigprocmask (SIG_SETMASK, &prev, 0); 2339 sigprocmask (SIG_SETMASK, &prev, 0);
2348#endif 2340#endif
2349 } 2341 }
… …
2491 2483
2492static void noinline 2484static void noinline
2493infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev) 2485infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
2494{ 2486{
2495 if (slot < 0) 2487 if (slot < 0)
2496 /* overflow, need to check for all hahs slots */ 2488 /* overflow, need to check for all hash slots */
2497 for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot) 2489 for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
2498 infy_wd (EV_A_ slot, wd, ev); 2490 infy_wd (EV_A_ slot, wd, ev);
2499 else 2491 else
2500 { 2492 {
2501 WL w_; 2493 WL w_;
… …
2535infy_init (EV_P) 2527infy_init (EV_P)
2536{ 2528{
2537 if (fs_fd != -2) 2529 if (fs_fd != -2)
2538 return; 2530 return;
2539 2531
2532 /* kernels < 2.6.25 are borked
2533 * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
2534 */
2535 {
2536 struct utsname buf;
2537 int major, minor, micro;
2538
2539 fs_fd = -1;
2540
2541 if (uname (&buf))
2542 return;
2543
2544 if (sscanf (buf.release, "%d.%d.%d", &major, &minor, &micro) != 3)
2545 return;
2546
2547 if (major < 2
2548 || (major == 2 && minor < 6)
2549 || (major == 2 && minor == 6 && micro < 25))
2550 return;
2551 }
2552
2540 fs_fd = inotify_init (); 2553 fs_fd = inotify_init ();
2541 2554
2542 if (fs_fd >= 0) 2555 if (fs_fd >= 0)
2543 { 2556 {
2544 ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ); 2557 ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
… …
2573 if (fs_fd >= 0) 2586 if (fs_fd >= 0)
2574 infy_add (EV_A_ w); /* re-add, no matter what */ 2587 infy_add (EV_A_ w); /* re-add, no matter what */
2575 else 2588 else
2576 ev_timer_start (EV_A_ &w->timer); 2589 ev_timer_start (EV_A_ &w->timer);
2577 } 2590 }
2578
2579 } 2591 }
2580} 2592}
2581 2593
2582#endif 2594#endif
2583 2595
… …
2619 || w->prev.st_atime != w->attr.st_atime 2631 || w->prev.st_atime != w->attr.st_atime
2620 || w->prev.st_mtime != w->attr.st_mtime 2632 || w->prev.st_mtime != w->attr.st_mtime
2621 || w->prev.st_ctime != w->attr.st_ctime 2633 || w->prev.st_ctime != w->attr.st_ctime
2622 ) { 2634 ) {
2623 #if EV_USE_INOTIFY 2635 #if EV_USE_INOTIFY
2636 if (fs_fd >= 0)
2637 {
2624 infy_del (EV_A_ w); 2638 infy_del (EV_A_ w);
2625 infy_add (EV_A_ w); 2639 infy_add (EV_A_ w);
2626 ev_stat_stat (EV_A_ w); /* avoid race... */ 2640 ev_stat_stat (EV_A_ w); /* avoid race... */
2641 }
2627 #endif 2642 #endif
2628 2643
2629 ev_feed_event (EV_A_ w, EV_STAT); 2644 ev_feed_event (EV_A_ w, EV_STAT);
2630 } 2645 }
2631} 2646}
… …
3012} 3027}
3013 3028
3014static void 3029static void
3015once_cb_io (EV_P_ ev_io *w, int revents) 3030once_cb_io (EV_P_ ev_io *w, int revents)
3016{ 3031{
3017 once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents); 3032 struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io));
3033
3034 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->to));
3018} 3035}
3019 3036
3020static void 3037static void
3021once_cb_to (EV_P_ ev_timer *w, int revents) 3038once_cb_to (EV_P_ ev_timer *w, int revents)
3022{ 3039{
3023 once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents); 3040 struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to));
3041
3042 once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
3024} 3043}
3025 3044
3026void 3045void
3027ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) 3046ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
3028{ 3047{

Diff Legend

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