r4943: Smplified the events handling code a lot. The first source of

complexity was that events didn't automatically cleanup
themselves. This was because the events code was written before we had
talloc destructors, so you needed to call event_remove_XX() to clean
the event out of the event lists from every piece of code that used
events. I have now added automatic event destructors, which in turn
allowed me to simplify a lot of the calling code.

The 2nd source of complexity was caused by the ref_count, which was
needed to cope with event handlers destroying events while handling
them, which meant the linked lists became invalid, so the ref_count ws
used to mark events for later destruction.

The new system is much simpler. I now have a ev->destruction_count,
which is incremented in all event destructors. The event dispatch code
checks for changes to this and handles it.
(This used to be commit a3c7417cfeab429ffb22d5546b205818f531a7b4)

1 files changed, 11 insertions, 4 deletions

diff --git a/source4/include/events.h b/source4/include/events.h
index ae18bd8bc4..51a78306bb 100644
--- a/source4/include/events.h
+++ b/source4/include/events.h
@@ -25,41 +25,41 @@
 struct event_context {	
 	/* list of filedescriptor events */
 	struct fd_event {
+		struct event_context *event_ctx;
 		struct fd_event *next, *prev;
 		int fd;
 		uint16_t flags; /* see EVENT_FD_* flags */
 		void (*handler)(struct event_context *ev, struct fd_event *fde, 
 				struct timeval t, uint16_t flags);
 		void *private;
-		int ref_count;
 	} *fd_events;
 
 	/* list of timed events */
 	struct timed_event {
+		struct event_context *event_ctx;
 		struct timed_event *next, *prev;
 		struct timeval next_event;
 		void (*handler)(struct event_context *ev, struct timed_event *te, 
 				struct timeval t);
 		void *private;
-		int ref_count;
 	} *timed_events;
 
 	/* list of loop events - called on each select() */
 	struct loop_event {
+		struct event_context *event_ctx;
 		struct loop_event *next, *prev;
 		void (*handler)(struct event_context *ev, struct loop_event *le, 
 				struct timeval t);
 		void *private;
-		int ref_count;
 	} *loop_events;
 
 	/* list of signal events */
 	struct signal_event {
+		struct event_context *event_ctx;
 		struct signal_event *next, *prev;
 		int signum;
 		void (*handler)(struct event_context *ev, struct signal_event *se, int signum, void *sigarg);
 		void *private;
-		int ref_count;
 	} *signal_events;
 
 	/* the maximum file descriptor number in fd_events */
@@ -74,6 +74,13 @@ struct event_context {
 	/* This is the talloc parent for all concrete event structures in this
 	 * event context. This makes merging easy. */
 	void *events;
+
+	/* this is changed by the destructors for any event type. It
+	   is used to detect event destruction by event handlers,
+	   which means the code that is calling all event handles
+	   needs to assume that the linked list is no longer valid 
+	*/
+	uint32_t destruction_count;
 };