The Tor Browser: ipc/chromium/src/third_party/libevent/evmap.c@6474c204b198 (annotated)

ipc/chromium/src/third_party/libevent/evmap.c@6474c204b198 (annotated)

ipc/chromium/src/third_party/libevent/evmap.c

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
  * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "event2/event-config.h"
 #ifdef WIN32
 #include <winsock2.h>
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #undef WIN32_LEAN_AND_MEAN
 #endif
 #include <sys/types.h>
 #if !defined(WIN32) && defined(_EVENT_HAVE_SYS_TIME_H)
 #include <sys/time.h>
 #endif
 #include <sys/queue.h>
 #include <stdio.h>
 #include <stdlib.h>
 #ifndef WIN32
 #include <unistd.h>
 #endif
 #include <errno.h>
 #include <signal.h>
 #include <string.h>
 #include <time.h>
 #include "event-internal.h"
 #include "evmap-internal.h"
 #include "mm-internal.h"
 #include "changelist-internal.h"
 /** An entry for an evmap_io list: notes all the events that want to read or
 	write on a given fd, and the number of each.
   */
 struct evmap_io {
 	struct event_list events;
 	ev_uint16_t nread;
 	ev_uint16_t nwrite;
 };
 /* An entry for an evmap_signal list: notes all the events that want to know
    when a signal triggers. */
 struct evmap_signal {
 	struct event_list events;
 };
 /* On some platforms, fds start at 0 and increment by 1 as they are
    allocated, and old numbers get used.  For these platforms, we
    implement io maps just like signal maps: as an array of pointers to
    struct evmap_io.  But on other platforms (windows), sockets are not
 -indexed, not necessarily consecutive, and not necessarily reused.
    There, we use a hashtable to implement evmap_io.
 */
 #ifdef EVMAP_USE_HT
 struct event_map_entry {
 	HT_ENTRY(event_map_entry) map_node;
 	evutil_socket_t fd;
 	union { /* This is a union in case we need to make more things that can
 			   be in the hashtable. */
 		struct evmap_io evmap_io;
 	} ent;
 };
 /* Helper used by the event_io_map hashtable code; tries to return a good hash
  * of the fd in e->fd. */
 static inline unsigned
 hashsocket(struct event_map_entry *e)
 {
 	/* On win32, in practice, the low 2-3 bits of a SOCKET seem not to
 	 * matter.  Our hashtable implementation really likes low-order bits,
 	 * though, so let's do the rotate-and-add trick. */
 	unsigned h = (unsigned) e->fd;
 	h += (h >> 2) | (h << 30);
 	return h;
 }
 /* Helper used by the event_io_map hashtable code; returns true iff e1 and e2
  * have the same e->fd. */
 static inline int
 eqsocket(struct event_map_entry *e1, struct event_map_entry *e2)
 {
 	return e1->fd == e2->fd;
 }
 HT_PROTOTYPE(event_io_map, event_map_entry, map_node, hashsocket, eqsocket)
 HT_GENERATE(event_io_map, event_map_entry, map_node, hashsocket, eqsocket,
 .5, mm_malloc, mm_realloc, mm_free)
 #define GET_IO_SLOT(x, map, slot, type)					\
 	do {								\
 		struct event_map_entry _key, *_ent;			\
 		_key.fd = slot;						\
 		_ent = HT_FIND(event_io_map, map, &_key);		\
 		(x) = _ent ? &_ent->ent.type : NULL;			\
 	} while (0);
 #define GET_IO_SLOT_AND_CTOR(x, map, slot, type, ctor, fdinfo_len)	\
 	do {								\
 		struct event_map_entry _key, *_ent;			\
 		_key.fd = slot;						\
 		_HT_FIND_OR_INSERT(event_io_map, map_node, hashsocket, map, \
 		    event_map_entry, &_key, ptr,			\
 		    {							\
 			    _ent = *ptr;				\
 		    },							\
 		    {							\
 			    _ent = mm_calloc(1,sizeof(struct event_map_entry)+fdinfo_len); \
 			    if (EVUTIL_UNLIKELY(_ent == NULL))		\
 				    return (-1);			\
 			    _ent->fd = slot;				\
 			    (ctor)(&_ent->ent.type);			\
 			    _HT_FOI_INSERT(map_node, map, &_key, _ent, ptr) \
 				});					\
 		(x) = &_ent->ent.type;					\
 	} while (0)
 void evmap_io_initmap(struct event_io_map *ctx)
 {
 	HT_INIT(event_io_map, ctx);
 }
 void evmap_io_clear(struct event_io_map *ctx)
 {
 	struct event_map_entry **ent, **next, *this;
 	for (ent = HT_START(event_io_map, ctx); ent; ent = next) {
 		this = *ent;
 		next = HT_NEXT_RMV(event_io_map, ctx, ent);
 		mm_free(this);
 	}
 	HT_CLEAR(event_io_map, ctx); /* remove all storage held by the ctx. */
 }
 #endif
 /* Set the variable 'x' to the field in event_map 'map' with fields of type
    'struct type *' corresponding to the fd or signal 'slot'.  Set 'x' to NULL
    if there are no entries for 'slot'.  Does no bounds-checking. */
 #define GET_SIGNAL_SLOT(x, map, slot, type)			\
 	(x) = (struct type *)((map)->entries[slot])
 /* As GET_SLOT, but construct the entry for 'slot' if it is not present,
    by allocating enough memory for a 'struct type', and initializing the new
    value by calling the function 'ctor' on it.  Makes the function
    return -1 on allocation failure.
  */
 #define GET_SIGNAL_SLOT_AND_CTOR(x, map, slot, type, ctor, fdinfo_len)	\
 	do {								\
 		if ((map)->entries[slot] == NULL) {			\
 			(map)->entries[slot] =				\
 			    mm_calloc(1,sizeof(struct type)+fdinfo_len); \
 			if (EVUTIL_UNLIKELY((map)->entries[slot] == NULL)) \
 				return (-1);				\
 			(ctor)((struct type *)(map)->entries[slot]);	\
 		}							\
 		(x) = (struct type *)((map)->entries[slot]);		\
 	} while (0)
 /* If we aren't using hashtables, then define the IO_SLOT macros and functions
    as thin aliases over the SIGNAL_SLOT versions. */
 #ifndef EVMAP_USE_HT
 #define GET_IO_SLOT(x,map,slot,type) GET_SIGNAL_SLOT(x,map,slot,type)
 #define GET_IO_SLOT_AND_CTOR(x,map,slot,type,ctor,fdinfo_len)	\
 	GET_SIGNAL_SLOT_AND_CTOR(x,map,slot,type,ctor,fdinfo_len)
 #define FDINFO_OFFSET sizeof(struct evmap_io)
 void
 evmap_io_initmap(struct event_io_map* ctx)
 {
 	evmap_signal_initmap(ctx);
 }
 void
 evmap_io_clear(struct event_io_map* ctx)
 {
 	evmap_signal_clear(ctx);
 }
 #endif
 /** Expand 'map' with new entries of width 'msize' until it is big enough
 	to store a value in 'slot'.
  */
 static int
 evmap_make_space(struct event_signal_map *map, int slot, int msize)
 {
 	if (map->nentries <= slot) {
 		int nentries = map->nentries ? map->nentries : 32;
 		void **tmp;
 		while (nentries <= slot)
 			nentries <<= 1;
 		tmp = (void **)mm_realloc(map->entries, nentries * msize);
 		if (tmp == NULL)
 			return (-1);
 		memset(&tmp[map->nentries], 0,
 		    (nentries - map->nentries) * msize);
 		map->nentries = nentries;
 		map->entries = tmp;
 	}
 	return (0);
 }
 void
 evmap_signal_initmap(struct event_signal_map *ctx)
 {
 	ctx->nentries = 0;
 	ctx->entries = NULL;
 }
 void
 evmap_signal_clear(struct event_signal_map *ctx)
 {
 	if (ctx->entries != NULL) {
 		int i;
 		for (i = 0; i < ctx->nentries; ++i) {
 			if (ctx->entries[i] != NULL)
 				mm_free(ctx->entries[i]);
 		}
 		mm_free(ctx->entries);
 		ctx->entries = NULL;
 	}
 	ctx->nentries = 0;
 }
 /* code specific to file descriptors */
 /** Constructor for struct evmap_io */
 static void
 evmap_io_init(struct evmap_io *entry)
 {
 	TAILQ_INIT(&entry->events);
 	entry->nread = 0;
 	entry->nwrite = 0;
 }
 /* return -1 on error, 0 on success if nothing changed in the event backend,
  * and 1 on success if something did. */
 int
 evmap_io_add(struct event_base *base, evutil_socket_t fd, struct event *ev)
 {
 	const struct eventop *evsel = base->evsel;
 	struct event_io_map *io = &base->io;
 	struct evmap_io *ctx = NULL;
 	int nread, nwrite, retval = 0;
 	short res = 0, old = 0;
 	struct event *old_ev;
 	EVUTIL_ASSERT(fd == ev->ev_fd);
 	if (fd < 0)
 		return 0;
 #ifndef EVMAP_USE_HT
 	if (fd >= io->nentries) {
 		if (evmap_make_space(io, fd, sizeof(struct evmap_io *)) == -1)
 			return (-1);
 	}
 #endif
 	GET_IO_SLOT_AND_CTOR(ctx, io, fd, evmap_io, evmap_io_init,
 						 evsel->fdinfo_len);
 	nread = ctx->nread;
 	nwrite = ctx->nwrite;
 	if (nread)
 		old |= EV_READ;
 	if (nwrite)
 		old |= EV_WRITE;
 	if (ev->ev_events & EV_READ) {
 		if (++nread == 1)
 			res |= EV_READ;
 	}
 	if (ev->ev_events & EV_WRITE) {
 		if (++nwrite == 1)
 			res |= EV_WRITE;
 	}
 	if (EVUTIL_UNLIKELY(nread > 0xffff || nwrite > 0xffff)) {
 		event_warnx("Too many events reading or writing on fd %d",
 		    (int)fd);
 		return -1;
 	}
 	if (EVENT_DEBUG_MODE_IS_ON() &&
 	    (old_ev = TAILQ_FIRST(&ctx->events)) &&
 	    (old_ev->ev_events&EV_ET) != (ev->ev_events&EV_ET)) {
 		event_warnx("Tried to mix edge-triggered and non-edge-triggered"
 		    " events on fd %d", (int)fd);
 		return -1;
 	}
 	if (res) {
 		void *extra = ((char*)ctx) + sizeof(struct evmap_io);
 		/* XXX(niels): we cannot mix edge-triggered and
 		 * level-triggered, we should probably assert on
 		 * this. */
 		if (evsel->add(base, ev->ev_fd,
 			old, (ev->ev_events & EV_ET) | res, extra) == -1)
 			return (-1);
 		retval = 1;
 	}
 	ctx->nread = (ev_uint16_t) nread;
 	ctx->nwrite = (ev_uint16_t) nwrite;
 	TAILQ_INSERT_TAIL(&ctx->events, ev, ev_io_next);
 	return (retval);
 }
 /* return -1 on error, 0 on success if nothing changed in the event backend,
  * and 1 on success if something did. */
 int
 evmap_io_del(struct event_base *base, evutil_socket_t fd, struct event *ev)
 {
 	const struct eventop *evsel = base->evsel;
 	struct event_io_map *io = &base->io;
 	struct evmap_io *ctx;
 	int nread, nwrite, retval = 0;
 	short res = 0, old = 0;
 	if (fd < 0)
 		return 0;
 	EVUTIL_ASSERT(fd == ev->ev_fd);
 #ifndef EVMAP_USE_HT
 	if (fd >= io->nentries)
 		return (-1);
 #endif
 	GET_IO_SLOT(ctx, io, fd, evmap_io);
 	nread = ctx->nread;
 	nwrite = ctx->nwrite;
 	if (nread)
 		old |= EV_READ;
 	if (nwrite)
 		old |= EV_WRITE;
 	if (ev->ev_events & EV_READ) {
 		if (--nread == 0)
 			res |= EV_READ;
 		EVUTIL_ASSERT(nread >= 0);
 	}
 	if (ev->ev_events & EV_WRITE) {
 		if (--nwrite == 0)
 			res |= EV_WRITE;
 		EVUTIL_ASSERT(nwrite >= 0);
 	}
 	if (res) {
 		void *extra = ((char*)ctx) + sizeof(struct evmap_io);
 		if (evsel->del(base, ev->ev_fd, old, res, extra) == -1)
 			return (-1);
 		retval = 1;
 	}
 	ctx->nread = nread;
 	ctx->nwrite = nwrite;
 	TAILQ_REMOVE(&ctx->events, ev, ev_io_next);
 	return (retval);
 }
 void
 evmap_io_active(struct event_base *base, evutil_socket_t fd, short events)
 {
 	struct event_io_map *io = &base->io;
 	struct evmap_io *ctx;
 	struct event *ev;
 #ifndef EVMAP_USE_HT
 	EVUTIL_ASSERT(fd < io->nentries);
 #endif
 	GET_IO_SLOT(ctx, io, fd, evmap_io);
 	EVUTIL_ASSERT(ctx);
 	TAILQ_FOREACH(ev, &ctx->events, ev_io_next) {
 		if (ev->ev_events & events)
 			event_active_nolock(ev, ev->ev_events & events, 1);
 	}
 }
 /* code specific to signals */
 static void
 evmap_signal_init(struct evmap_signal *entry)
 {
 	TAILQ_INIT(&entry->events);
 }
 int
 evmap_signal_add(struct event_base *base, int sig, struct event *ev)
 {
 	const struct eventop *evsel = base->evsigsel;
 	struct event_signal_map *map = &base->sigmap;
 	struct evmap_signal *ctx = NULL;
 	if (sig >= map->nentries) {
 		if (evmap_make_space(
 			map, sig, sizeof(struct evmap_signal *)) == -1)
 			return (-1);
 	}
 	GET_SIGNAL_SLOT_AND_CTOR(ctx, map, sig, evmap_signal, evmap_signal_init,
 	    base->evsigsel->fdinfo_len);
 	if (TAILQ_EMPTY(&ctx->events)) {
 		if (evsel->add(base, ev->ev_fd, 0, EV_SIGNAL, NULL)
 		    == -1)
 			return (-1);
 	}
 	TAILQ_INSERT_TAIL(&ctx->events, ev, ev_signal_next);
 	return (1);
 }
 int
 evmap_signal_del(struct event_base *base, int sig, struct event *ev)
 {
 	const struct eventop *evsel = base->evsigsel;
 	struct event_signal_map *map = &base->sigmap;
 	struct evmap_signal *ctx;
 	if (sig >= map->nentries)
 		return (-1);
 	GET_SIGNAL_SLOT(ctx, map, sig, evmap_signal);
 	if (TAILQ_FIRST(&ctx->events) == TAILQ_LAST(&ctx->events, event_list)) {
 		if (evsel->del(base, ev->ev_fd, 0, EV_SIGNAL, NULL) == -1)
 			return (-1);
 	}
 	TAILQ_REMOVE(&ctx->events, ev, ev_signal_next);
 	return (1);
 }
 void
 evmap_signal_active(struct event_base *base, evutil_socket_t sig, int ncalls)
 {
 	struct event_signal_map *map = &base->sigmap;
 	struct evmap_signal *ctx;
 	struct event *ev;
 	EVUTIL_ASSERT(sig < map->nentries);
 	GET_SIGNAL_SLOT(ctx, map, sig, evmap_signal);
 	TAILQ_FOREACH(ev, &ctx->events, ev_signal_next)
 		event_active_nolock(ev, EV_SIGNAL, ncalls);
 }
 void *
 evmap_io_get_fdinfo(struct event_io_map *map, evutil_socket_t fd)
 {
 	struct evmap_io *ctx;
 	GET_IO_SLOT(ctx, map, fd, evmap_io);
 	if (ctx)
 		return ((char*)ctx) + sizeof(struct evmap_io);
 	else
 		return NULL;
 }
 /** Per-fd structure for use with changelists.  It keeps track, for each fd or
  * signal using the changelist, of where its entry in the changelist is.
  */
 struct event_changelist_fdinfo {
 	int idxplus1; /* this is the index +1, so that memset(0) will make it
 		       * a no-such-element */
 };
 void
 event_changelist_init(struct event_changelist *changelist)
 {
 	changelist->changes = NULL;
 	changelist->changes_size = 0;
 	changelist->n_changes = 0;
 }
 /** Helper: return the changelist_fdinfo corresponding to a given change. */
 static inline struct event_changelist_fdinfo *
 event_change_get_fdinfo(struct event_base *base,
     const struct event_change *change)
 {
 	char *ptr;
 	if (change->read_change & EV_CHANGE_SIGNAL) {
 		struct evmap_signal *ctx;
 		GET_SIGNAL_SLOT(ctx, &base->sigmap, change->fd, evmap_signal);
 		ptr = ((char*)ctx) + sizeof(struct evmap_signal);
 	} else {
 		struct evmap_io *ctx;
 		GET_IO_SLOT(ctx, &base->io, change->fd, evmap_io);
 		ptr = ((char*)ctx) + sizeof(struct evmap_io);
 	}
 	return (void*)ptr;
 }
 #ifdef DEBUG_CHANGELIST
 /** Make sure that the changelist is consistent with the evmap structures. */
 static void
 event_changelist_check(struct event_base *base)
 {
 	int i;
 	struct event_changelist *changelist = &base->changelist;
 	EVUTIL_ASSERT(changelist->changes_size >= changelist->n_changes);
 	for (i = 0; i < changelist->n_changes; ++i) {
 		struct event_change *c = &changelist->changes[i];
 		struct event_changelist_fdinfo *f;
 		EVUTIL_ASSERT(c->fd >= 0);
 		f = event_change_get_fdinfo(base, c);
 		EVUTIL_ASSERT(f);
 		EVUTIL_ASSERT(f->idxplus1 == i + 1);
 	}
 	for (i = 0; i < base->io.nentries; ++i) {
 		struct evmap_io *io = base->io.entries[i];
 		struct event_changelist_fdinfo *f;
 		if (!io)
 			continue;
 		f = (void*)
 		    ( ((char*)io) + sizeof(struct evmap_io) );
 		if (f->idxplus1) {
 			struct event_change *c = &changelist->changes[f->idxplus1 - 1];
 			EVUTIL_ASSERT(c->fd == i);
 		}
 	}
 }
 #else
 #define event_changelist_check(base)  ((void)0)
 #endif
 void
 event_changelist_remove_all(struct event_changelist *changelist,
     struct event_base *base)
 {
 	int i;
 	event_changelist_check(base);
 	for (i = 0; i < changelist->n_changes; ++i) {
 		struct event_change *ch = &changelist->changes[i];
 		struct event_changelist_fdinfo *fdinfo =
 		    event_change_get_fdinfo(base, ch);
 		EVUTIL_ASSERT(fdinfo->idxplus1 == i + 1);
 		fdinfo->idxplus1 = 0;
 	}
 	changelist->n_changes = 0;
 	event_changelist_check(base);
 }
 void
 event_changelist_freemem(struct event_changelist *changelist)
 {
 	if (changelist->changes)
 		mm_free(changelist->changes);
 	event_changelist_init(changelist); /* zero it all out. */
 }
 /** Increase the size of 'changelist' to hold more changes. */
 static int
 event_changelist_grow(struct event_changelist *changelist)
 {
 	int new_size;
 	struct event_change *new_changes;
 	if (changelist->changes_size < 64)
 		new_size = 64;
 	else
 		new_size = changelist->changes_size * 2;
 	new_changes = mm_realloc(changelist->changes,
 	    new_size * sizeof(struct event_change));
 	if (EVUTIL_UNLIKELY(new_changes == NULL))
 		return (-1);
 	changelist->changes = new_changes;
 	changelist->changes_size = new_size;
 	return (0);
 }
 /** Return a pointer to the changelist entry for the file descriptor or signal
  * 'fd', whose fdinfo is 'fdinfo'.  If none exists, construct it, setting its
  * old_events field to old_events.
  */
 static struct event_change *
 event_changelist_get_or_construct(struct event_changelist *changelist,
     evutil_socket_t fd,
     short old_events,
     struct event_changelist_fdinfo *fdinfo)
 {
 	struct event_change *change;
 	if (fdinfo->idxplus1 == 0) {
 		int idx;
 		EVUTIL_ASSERT(changelist->n_changes <= changelist->changes_size);
 		if (changelist->n_changes == changelist->changes_size) {
 			if (event_changelist_grow(changelist) < 0)
 				return NULL;
 		}
 		idx = changelist->n_changes++;
 		change = &changelist->changes[idx];
 		fdinfo->idxplus1 = idx + 1;
 		memset(change, 0, sizeof(struct event_change));
 		change->fd = fd;
 		change->old_events = old_events;
 	} else {
 		change = &changelist->changes[fdinfo->idxplus1 - 1];
 		EVUTIL_ASSERT(change->fd == fd);
 	}
 	return change;
 }
 int
 event_changelist_add(struct event_base *base, evutil_socket_t fd, short old, short events,
     void *p)
 {
 	struct event_changelist *changelist = &base->changelist;
 	struct event_changelist_fdinfo *fdinfo = p;
 	struct event_change *change;
 	event_changelist_check(base);
 	change = event_changelist_get_or_construct(changelist, fd, old, fdinfo);
 	if (!change)
 		return -1;
 	/* An add replaces any previous delete, but doesn't result in a no-op,
 	 * since the delete might fail (because the fd had been closed since
 	 * the last add, for instance. */
 	if (events & (EV_READ|EV_SIGNAL)) {
 		change->read_change = EV_CHANGE_ADD |
 		    (events & (EV_ET|EV_PERSIST|EV_SIGNAL));
 	}
 	if (events & EV_WRITE) {
 		change->write_change = EV_CHANGE_ADD |
 		    (events & (EV_ET|EV_PERSIST|EV_SIGNAL));
 	}
 	event_changelist_check(base);
 	return (0);
 }
 int
 event_changelist_del(struct event_base *base, evutil_socket_t fd, short old, short events,
     void *p)
 {
 	struct event_changelist *changelist = &base->changelist;
 	struct event_changelist_fdinfo *fdinfo = p;
 	struct event_change *change;
 	event_changelist_check(base);
 	change = event_changelist_get_or_construct(changelist, fd, old, fdinfo);
 	event_changelist_check(base);
 	if (!change)
 		return -1;
 	/* A delete removes any previous add, rather than replacing it:
 	   on those platforms where "add, delete, dispatch" is not the same
 	   as "no-op, dispatch", we want the no-op behavior.
 	   As well as checking the current operation we should also check
 	   the original set of events to make sure were not ignoring
 	   the case where the add operation is present on an event that
 	   was already set.
 	   If we have a no-op item, we could remove it it from the list
 	   entirely, but really there's not much point: skipping the no-op
 	   change when we do the dispatch later is far cheaper than rejuggling
 	   the array now.
 	   As this stands, it also lets through deletions of events that are
 	   not currently set.
 	 */
 	if (events & (EV_READ|EV_SIGNAL)) {
 		if (!(change->old_events & (EV_READ | EV_SIGNAL)) &&
 		    (change->read_change & EV_CHANGE_ADD))
 			change->read_change = 0;
 		else
 			change->read_change = EV_CHANGE_DEL;
 	}
 	if (events & EV_WRITE) {
 		if (!(change->old_events & EV_WRITE) &&
 		    (change->write_change & EV_CHANGE_ADD))
 			change->write_change = 0;
 		else
 			change->write_change = EV_CHANGE_DEL;
 	}
 	event_changelist_check(base);
 	return (0);
 }
 void
 evmap_check_integrity(struct event_base *base)
 {
 #define EVLIST_X_SIGFOUND 0x1000
 #define EVLIST_X_IOFOUND 0x2000
 	evutil_socket_t i;
 	struct event *ev;
 	struct event_io_map *io = &base->io;
 	struct event_signal_map *sigmap = &base->sigmap;
 #ifdef EVMAP_USE_HT
 	struct event_map_entry **mapent;
 #endif
 	int nsignals, ntimers, nio;
 	nsignals = ntimers = nio = 0;
 	TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {
 		EVUTIL_ASSERT(ev->ev_flags & EVLIST_INSERTED);
 		EVUTIL_ASSERT(ev->ev_flags & EVLIST_INIT);
 		ev->ev_flags &= ~(EVLIST_X_SIGFOUND|EVLIST_X_IOFOUND);
 	}
 #ifdef EVMAP_USE_HT
 	HT_FOREACH(mapent, event_io_map, io) {
 		struct evmap_io *ctx = &(*mapent)->ent.evmap_io;
 		i = (*mapent)->fd;
 #else
 	for (i = 0; i < io->nentries; ++i) {
 		struct evmap_io *ctx = io->entries[i];
 		if (!ctx)
 			continue;
 #endif
 		TAILQ_FOREACH(ev, &ctx->events, ev_io_next) {
 			EVUTIL_ASSERT(!(ev->ev_flags & EVLIST_X_IOFOUND));
 			EVUTIL_ASSERT(ev->ev_fd == i);
 			ev->ev_flags |= EVLIST_X_IOFOUND;
 			nio++;
 		}
 	}
 	for (i = 0; i < sigmap->nentries; ++i) {
 		struct evmap_signal *ctx = sigmap->entries[i];
 		if (!ctx)
 			continue;
 		TAILQ_FOREACH(ev, &ctx->events, ev_signal_next) {
 			EVUTIL_ASSERT(!(ev->ev_flags & EVLIST_X_SIGFOUND));
 			EVUTIL_ASSERT(ev->ev_fd == i);
 			ev->ev_flags |= EVLIST_X_SIGFOUND;
 			nsignals++;
 		}
 	}
 	TAILQ_FOREACH(ev, &base->eventqueue, ev_next) {
 		if (ev->ev_events & (EV_READ|EV_WRITE)) {
 			EVUTIL_ASSERT(ev->ev_flags & EVLIST_X_IOFOUND);
 			--nio;
 		}
 		if (ev->ev_events & EV_SIGNAL) {
 			EVUTIL_ASSERT(ev->ev_flags & EVLIST_X_SIGFOUND);
 			--nsignals;
 		}
 	}
 	EVUTIL_ASSERT(nio == 0);
 	EVUTIL_ASSERT(nsignals == 0);
 	/* There is no "EVUTIL_ASSERT(ntimers == 0)": eventqueue is only for
 	 * pending signals and io events.
 	 */
 }

The Tor Browser / annotate

ipc/chromium/src/third_party/libevent/evmap.c@6474c204b198 (annotated)

ipc/chromium/src/third_party/libevent/evmap.c