tevent: pass down handler_name and location to the backend layer

metze

8 files changed, 154 insertions, 102 deletions

diff --git a/lib/tevent/tevent.c b/lib/tevent/tevent.c
index fd44838a98..9319177646 100644
--- a/lib/tevent/tevent.c
+++ b/lib/tevent/tevent.c
@@ -220,7 +220,8 @@ struct tevent_fd *_tevent_add_fd(struct tevent_context *ev,
 				 const char *handler_name,
 				 const char *location)
 {
-	return ev->ops->add_fd(ev, mem_ctx, fd, flags, handler, private_data);
+	return ev->ops->add_fd(ev, mem_ctx, fd, flags, handler, private_data,
+			       handler_name, location);
 }
 
 /*
@@ -235,7 +236,8 @@ struct tevent_aio *_tevent_add_aio(struct tevent_context *ev,
 				   const char *location)
 {
 	if (ev->ops->add_aio == NULL) return NULL;
-	return ev->ops->add_aio(ev, mem_ctx, iocb, handler, private_data);
+	return ev->ops->add_aio(ev, mem_ctx, iocb, handler, private_data,
+				handler_name, location);
 }
 
 /*
@@ -268,7 +270,8 @@ struct tevent_timer *_tevent_add_timer(struct tevent_context *ev,
 				       const char *handler_name,
 				       const char *location)
 {
-	return ev->ops->add_timer(ev, mem_ctx, next_event, handler, private_data);
+	return ev->ops->add_timer(ev, mem_ctx, next_event, handler, private_data,
+				  handler_name, location);
 }
 
 /*
@@ -287,7 +290,8 @@ struct tevent_signal *_tevent_add_signal(struct tevent_context *ev,
 					 const char *handler_name,
 					 const char *location)
 {
-	return ev->ops->add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data);
+	return ev->ops->add_signal(ev, mem_ctx, signum, sa_flags, handler, private_data,
+				   handler_name, location);
 }
 
 /*
diff --git a/lib/tevent/tevent_aio.c b/lib/tevent/tevent_aio.c
index 8d25791bea..f3045fbf97 100644
--- a/lib/tevent/tevent_aio.c
+++ b/lib/tevent/tevent_aio.c
@@ -67,11 +67,11 @@ struct aio_event_context {
 	pid_t pid;
 };
 
-struct aio_event {
+struct tevent_aio {
 	struct tevent_context *event_ctx;
 	struct iocb iocb;
 	void *private_data;
-	event_aio_handler_t handler;
+	tevent_aio_handler_t handler;
 };
 
 /*
@@ -261,7 +261,7 @@ static int aio_event_loop(struct aio_event_context *aio_ev, struct timeval *tval
 	if (aio_ev->epoll_fd == -1) return -1;
 
 	if (aio_ev->ev->num_signal_handlers && 
-	    common_event_check_signal(aio_ev->ev)) {
+	    tevent_common_check_signal(aio_ev->ev)) {
 		return 0;
 	}
 
@@ -279,14 +279,14 @@ static int aio_event_loop(struct aio_event_context *aio_ev, struct timeval *tval
 
 	if (ret == -EINTR) {
 		if (aio_ev->ev->num_signal_handlers) {
-			common_event_check_signal(aio_ev->ev);
+			tevent_common_check_signal(aio_ev->ev);
 		}
 		return 0;
 	}
 
 	if (ret == 0 && tvalp) {
 		/* we don't care about a possible delay here */
-		common_event_loop_timer_delay(aio_ev->ev);
+		tevent_common_loop_timer_delay(aio_ev->ev);
 		return 0;
 	}
 
@@ -297,8 +297,8 @@ static int aio_event_loop(struct aio_event_context *aio_ev, struct timeval *tval
 		switch (finished->aio_lio_opcode) {
 		case IO_CMD_PWRITE:
 		case IO_CMD_PREAD: {
-			struct aio_event *ae = talloc_get_type(finished->data, 
-							       struct aio_event);
+			struct tevent_aio *ae = talloc_get_type(finished->data, 
+							       struct tevent_aio);
 			if (ae) {
 				talloc_set_destructor(ae, NULL);
 				ae->handler(ae->event_ctx, ae, 
@@ -412,9 +412,11 @@ static int aio_event_fd_destructor(struct tevent_fd *fde)
   return NULL on failure (memory allocation error)
 */
 static struct tevent_fd *aio_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-					 int fd, uint16_t flags,
-					 event_fd_handler_t handler,
-					 void *private_data)
+					  int fd, uint16_t flags,
+					  tevent_fd_handler_t handler,
+					  void *private_data,
+					  const char *handler_name,
+					  const char *location)
 {
 	struct aio_event_context *aio_ev = talloc_get_type(ev->additional_data,
 							   struct aio_event_context);
@@ -430,6 +432,8 @@ static struct tevent_fd *aio_event_add_fd(struct tevent_context *ev, TALLOC_CTX
 	fde->flags		= flags;
 	fde->handler		= handler;
 	fde->private_data	= private_data;
+	fde->handler_name	= handler_name;
+	fde->location		= location;
 	fde->additional_flags	= 0;
 	fde->additional_data	= NULL;
 
@@ -480,7 +484,7 @@ static int aio_event_loop_once(struct tevent_context *ev)
 		 					   struct aio_event_context);
 	struct timeval tval;
 
-	tval = common_event_loop_timer_delay(ev);
+	tval = tevent_common_loop_timer_delay(ev);
 	if (ev_timeval_is_zero(&tval)) {
 		return 0;
 	}
@@ -509,7 +513,7 @@ static int aio_event_loop_wait(struct tevent_context *ev)
 /*
   called when a disk IO event needs to be cancelled
 */
-static int aio_destructor(struct aio_event *ae)
+static int aio_destructor(struct tevent_aio *ae)
 {
 	struct tevent_context *ev = ae->event_ctx;
 	struct aio_event_context *aio_ev = talloc_get_type(ev->additional_data,
@@ -521,16 +525,18 @@ static int aio_destructor(struct aio_event *ae)
 }
 
 /* submit an aio disk IO event */
-static struct aio_event *aio_event_add_aio(struct tevent_context *ev, 
-					   TALLOC_CTX *mem_ctx,
-					   struct iocb *iocb,
-					   event_aio_handler_t handler,
-					   void *private_data)
+static struct tevent_aio *aio_event_add_aio(struct tevent_context *ev, 
+					    TALLOC_CTX *mem_ctx,
+					    struct iocb *iocb,
+					    tevent_aio_handler_t handler,
+					    void *private_data,
+					    const char *handler_name,
+					    const char *location)
 {
 	struct aio_event_context *aio_ev = talloc_get_type(ev->additional_data,
 							   struct aio_event_context);
 	struct iocb *iocbp;
-	struct aio_event *ae = talloc(mem_ctx?mem_ctx:ev, struct aio_event);
+	struct tevent_aio *ae = talloc(mem_ctx?mem_ctx:ev, struct tevent_aio);
 	if (ae == NULL) return NULL;
 
 	ae->event_ctx    = ev;
@@ -555,8 +561,8 @@ static const struct tevent_ops aio_event_ops = {
 	.add_aio        = aio_event_add_aio,
 	.get_fd_flags	= aio_event_get_fd_flags,
 	.set_fd_flags	= aio_event_set_fd_flags,
-	.add_timer	= common_event_add_timed,
-	.add_signal	= common_event_add_signal,
+	.add_timer	= tevent_common_add_timer,
+	.add_signal	= tevent_common_add_signal,
 	.loop_once	= aio_event_loop_once,
 	.loop_wait	= aio_event_loop_wait,
 };
diff --git a/lib/tevent/tevent_epoll.c b/lib/tevent/tevent_epoll.c
index 1f853e60f1..d2703eda6c 100644
--- a/lib/tevent/tevent_epoll.c
+++ b/lib/tevent/tevent_epoll.c
@@ -258,14 +258,14 @@ static int epoll_event_loop(struct epoll_event_context *epoll_ev, struct timeval
 	}
 
 	if (epoll_ev->ev->num_signal_handlers && 
-	    common_event_check_signal(epoll_ev->ev)) {
+	    tevent_common_check_signal(epoll_ev->ev)) {
 		return 0;
 	}
 
 	ret = epoll_wait(epoll_ev->epoll_fd, events, MAXEVENTS, timeout);
 
 	if (ret == -1 && errno == EINTR && epoll_ev->ev->num_signal_handlers) {
-		if (common_event_check_signal(epoll_ev->ev)) {
+		if (tevent_common_check_signal(epoll_ev->ev)) {
 			return 0;
 		}
 	}
@@ -277,7 +277,7 @@ static int epoll_event_loop(struct epoll_event_context *epoll_ev, struct timeval
 
 	if (ret == 0 && tvalp) {
 		/* we don't care about a possible delay here */
-		common_event_loop_timer_delay(epoll_ev->ev);
+		tevent_common_loop_timer_delay(epoll_ev->ev);
 		return 0;
 	}
 
@@ -371,9 +371,11 @@ static int epoll_event_fd_destructor(struct tevent_fd *fde)
   return NULL on failure (memory allocation error)
 */
 static struct tevent_fd *epoll_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-					 int fd, uint16_t flags,
-					 event_fd_handler_t handler,
-					 void *private_data)
+					    int fd, uint16_t flags,
+					    tevent_fd_handler_t handler,
+					    void *private_data,
+					    const char *handler_name,
+					    const char *location)
 {
 	struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
 							   struct epoll_event_context);
@@ -389,6 +391,8 @@ static struct tevent_fd *epoll_event_add_fd(struct tevent_context *ev, TALLOC_CT
 	fde->flags		= flags;
 	fde->handler		= handler;
 	fde->private_data	= private_data;
+	fde->handler_name	= handler_name;
+	fde->location		= location;
 	fde->additional_flags	= 0;
 	fde->additional_data	= NULL;
 
@@ -439,7 +443,7 @@ static int epoll_event_loop_once(struct tevent_context *ev)
 		 					   struct epoll_event_context);
 	struct timeval tval;
 
-	tval = common_event_loop_timer_delay(ev);
+	tval = tevent_common_loop_timer_delay(ev);
 	if (ev_timeval_is_zero(&tval)) {
 		return 0;
 	}
@@ -470,8 +474,8 @@ static const struct tevent_ops epoll_event_ops = {
 	.add_fd		= epoll_event_add_fd,
 	.get_fd_flags	= epoll_event_get_fd_flags,
 	.set_fd_flags	= epoll_event_set_fd_flags,
-	.add_timer	= common_event_add_timed,
-	.add_signal	= common_event_add_signal,
+	.add_timer	= tevent_common_add_timer,
+	.add_signal	= tevent_common_add_signal,
 	.loop_once	= epoll_event_loop_once,
 	.loop_wait	= epoll_event_loop_wait,
 };
diff --git a/lib/tevent/tevent_internal.h b/lib/tevent/tevent_internal.h
index b654e4b500..408136dc71 100644
--- a/lib/tevent/tevent_internal.h
+++ b/lib/tevent/tevent_internal.h
@@ -30,7 +30,9 @@ struct tevent_ops {
 				    TALLOC_CTX *mem_ctx,
 				    int fd, uint16_t flags,
 				    tevent_fd_handler_t handler,
-				    void *private_data);
+				    void *private_data,
+				    const char *handler_name,
+				    const char *location);
 	uint16_t (*get_fd_flags)(struct tevent_fd *fde);
 	void (*set_fd_flags)(struct tevent_fd *fde, uint16_t flags);
 
@@ -39,19 +41,25 @@ struct tevent_ops {
 					  TALLOC_CTX *mem_ctx,
 					  struct timeval next_event,
 					  tevent_timer_handler_t handler,
-					  void *private_data);
+					  void *private_data,
+					  const char *handler_name,
+					  const char *location);
 	/* disk aio event functions */
 	struct tevent_aio *(*add_aio)(struct tevent_context *ev,
 				      TALLOC_CTX *mem_ctx,
 				      struct iocb *iocb,
 				      tevent_aio_handler_t handler,
-				      void *private_data);
+				      void *private_data,
+				      const char *handler_name,
+				      const char *location);
 	/* signal functions */
 	struct tevent_signal *(*add_signal)(struct tevent_context *ev,
 					    TALLOC_CTX *mem_ctx,
 					    int signum, int sa_flags,
 					    tevent_signal_handler_t handler,
-					    void *private_data);
+					    void *private_data,
+					    const char *handler_name,
+					    const char *location);
 
 	/* loop functions */
 	int (*loop_once)(struct tevent_context *ev);
@@ -66,6 +74,9 @@ struct tevent_fd {
 	tevent_fd_handler_t handler;
 	/* this is private for the specific handler */
 	void *private_data;
+	/* this is for debugging only! */
+	const char *handler_name;
+	const char *location;
 	/* this is private for the events_ops implementation */
 	uint16_t additional_flags;
 	void *additional_data;
@@ -78,6 +89,9 @@ struct tevent_timer {
 	tevent_timer_handler_t handler;
 	/* this is private for the specific handler */
 	void *private_data;
+	/* this is for debugging only! */
+	const char *handler_name;
+	const char *location;
 	/* this is private for the events_ops implementation */
 	void *additional_data;
 };
@@ -85,10 +99,16 @@ struct tevent_timer {
 struct tevent_signal {
 	struct tevent_signal *prev, *next;
 	struct tevent_context *event_ctx;
-	tevent_signal_handler_t handler;
-	void *private_data;
 	int signum;
 	int sa_flags;
+	tevent_signal_handler_t handler;
+	/* this is private for the specific handler */
+	void *private_data;
+	/* this is for debugging only! */
+	const char *handler_name;
+	const char *location;
+	/* this is private for the events_ops implementation */
+	void *additional_data;
 };
 
 /* DEBUG */
@@ -135,21 +155,24 @@ struct tevent_context {
 bool tevent_register_backend(const char *name, const struct tevent_ops *ops);
 
 bool ev_timeval_is_zero(const struct timeval *tv);
-struct tevent_timer *common_event_add_timed(struct tevent_context *,
-					    TALLOC_CTX *,
-					    struct timeval,
-					    tevent_timer_handler_t,
-					    void *);
-struct timeval common_event_loop_timer_delay(struct tevent_context *);
-
-struct tevent_signal *common_event_add_signal(struct tevent_context *ev,
-					      TALLOC_CTX *mem_ctx,
-					      int signum,
-					      int sa_flags,
-					      tevent_signal_handler_t handler,
-					      void *private_data);
-int common_event_check_signal(struct tevent_context *ev);
-
+struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev,
+					     TALLOC_CTX *mem_ctx,
+					     struct timeval next_event,
+					     tevent_timer_handler_t handler,
+					     void *private_data,
+					     const char *handler_name,
+					     const char *location);
+struct timeval tevent_common_loop_timer_delay(struct tevent_context *);
+
+struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
+					       TALLOC_CTX *mem_ctx,
+					       int signum,
+					       int sa_flags,
+					       tevent_signal_handler_t handler,
+					       void *private_data,
+					       const char *handler_name,
+					       const char *location);
+int tevent_common_check_signal(struct tevent_context *ev);
 
 bool tevent_standard_init(void);
 bool tevent_select_init(void);
diff --git a/lib/tevent/tevent_select.c b/lib/tevent/tevent_select.c
index 103e5ac1fa..b082400a8e 100644
--- a/lib/tevent/tevent_select.c
+++ b/lib/tevent/tevent_select.c
@@ -116,9 +116,11 @@ static int select_event_fd_destructor(struct tevent_fd *fde)
   return NULL on failure (memory allocation error)
 */
 static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-					 int fd, uint16_t flags,
-					 event_fd_handler_t handler,
-					 void *private_data)
+					     int fd, uint16_t flags,
+					     tevent_fd_handler_t handler,
+					     void *private_data,
+					     const char *handler_name,
+					     const char *location)
 {
 	struct select_event_context *select_ev = talloc_get_type(ev->additional_data,
 							   struct select_event_context);
@@ -132,6 +134,8 @@ static struct tevent_fd *select_event_add_fd(struct tevent_context *ev, TALLOC_C
 	fde->flags		= flags;
 	fde->handler		= handler;
 	fde->private_data	= private_data;
+	fde->handler_name	= handler_name;
+	fde->location		= location;
 	fde->additional_flags	= 0;
 	fde->additional_data	= NULL;
 
@@ -198,7 +202,7 @@ static int select_event_loop_select(struct select_event_context *select_ev, stru
 	}
 
 	if (select_ev->ev->num_signal_handlers && 
-	    common_event_check_signal(select_ev->ev)) {
+	    tevent_common_check_signal(select_ev->ev)) {
 		return 0;
 	}
 
@@ -206,7 +210,7 @@ static int select_event_loop_select(struct select_event_context *select_ev, stru
 
 	if (selrtn == -1 && errno == EINTR && 
 	    select_ev->ev->num_signal_handlers) {
-		common_event_check_signal(select_ev->ev);
+		tevent_common_check_signal(select_ev->ev);
 		return 0;
 	}
 
@@ -224,7 +228,7 @@ static int select_event_loop_select(struct select_event_context *select_ev, stru
 
 	if (selrtn == 0 && tvalp) {
 		/* we don't care about a possible delay here */
-		common_event_loop_timer_delay(select_ev->ev);
+		tevent_common_loop_timer_delay(select_ev->ev);
 		return 0;
 	}
 
@@ -258,7 +262,7 @@ static int select_event_loop_once(struct tevent_context *ev)
 		 					   struct select_event_context);
 	struct timeval tval;
 
-	tval = common_event_loop_timer_delay(ev);
+	tval = tevent_common_loop_timer_delay(ev);
 	if (ev_timeval_is_zero(&tval)) {
 		return 0;
 	}
@@ -289,8 +293,8 @@ static const struct tevent_ops select_event_ops = {
 	.add_fd		= select_event_add_fd,
 	.get_fd_flags	= select_event_get_fd_flags,
 	.set_fd_flags	= select_event_set_fd_flags,
-	.add_timer	= common_event_add_timed,
-	.add_signal	= common_event_add_signal,
+	.add_timer	= tevent_common_add_timer,
+	.add_signal	= tevent_common_add_signal,
 	.loop_once	= select_event_loop_once,
 	.loop_wait	= select_event_loop_wait,
 };
diff --git a/lib/tevent/tevent_signal.c b/lib/tevent/tevent_signal.c
index fdd7070625..031845927b 100644
--- a/lib/tevent/tevent_signal.c
+++ b/lib/tevent/tevent_signal.c
@@ -45,7 +45,7 @@ struct sigcounter {
   the poor design of signals means that this table must be static global
 */
 static struct sig_state {
-	struct signal_event *sig_handlers[NUM_SIGNALS+1];
+	struct tevent_signal *sig_handlers[NUM_SIGNALS+1];
 	struct sigaction *oldact[NUM_SIGNALS+1];
 	struct sigcounter signal_count[NUM_SIGNALS+1];
 	struct sigcounter got_signal;
@@ -107,7 +107,7 @@ static void signal_handler_info(int signum, siginfo_t *info, void *uctx)
 /*
   destroy a signal event
 */
-static int signal_event_destructor(struct signal_event *se)
+static int tevent_signal_destructor(struct tevent_signal *se)
 {
 	se->event_ctx->num_signal_handlers--;
 	DLIST_REMOVE(sig_state->sig_handlers[se->signum], se);
@@ -140,14 +140,16 @@ static void signal_pipe_handler(struct tevent_context *ev, struct tevent_fd *fde
   add a signal event
   return NULL on failure (memory allocation error)
 */
-struct signal_event *common_event_add_signal(struct tevent_context *ev, 
-					     TALLOC_CTX *mem_ctx,
-					     int signum,
-					     int sa_flags,
-					     event_signal_handler_t handler, 
-					     void *private_data) 
+struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
+					       TALLOC_CTX *mem_ctx,
+					       int signum,
+					       int sa_flags,
+					       tevent_signal_handler_t handler,
+					       void *private_data,
+					       const char *handler_name,
+					       const char *location)
 {
-	struct signal_event *se;
+	struct tevent_signal *se;
 
 	if (signum >= NUM_SIGNALS) {
 		return NULL;
@@ -162,15 +164,18 @@ struct signal_event *common_event_add_signal(struct tevent_context *ev,
 		}
 	}
 
-	se = talloc(mem_ctx?mem_ctx:ev, struct signal_event);
+	se = talloc(mem_ctx?mem_ctx:ev, struct tevent_signal);
 	if (se == NULL) return NULL;
 
 	se->event_ctx		= ev;
-	se->handler		= handler;
-	se->private_data	= private_data;
 	se->signum              = signum;
 	se->sa_flags            = sa_flags;
-	
+	se->handler		= handler;
+	se->private_data	= private_data;
+	se->handler_name	= handler_name;
+	se->location		= location;
+	se->additional_data	= NULL;
+
 	/* Ensure, no matter the destruction order, that we always have a handle on the global sig_state */
 	if (!talloc_reference(se, sig_state)) {
 		return NULL;
@@ -208,7 +213,7 @@ struct signal_event *common_event_add_signal(struct tevent_context *ev,
 
 	DLIST_ADD(sig_state->sig_handlers[signum], se);
 
-	talloc_set_destructor(se, signal_event_destructor);
+	talloc_set_destructor(se, tevent_signal_destructor);
 
 	/* we need to setup the pipe hack handler if not already
 	   setup */
@@ -219,8 +224,8 @@ struct signal_event *common_event_add_signal(struct tevent_context *ev,
 			ev_set_blocking(sig_state->pipe_hack[0], false);
 			ev_set_blocking(sig_state->pipe_hack[1], false);
 		}
-		ev->pipe_fde = event_add_fd(ev, ev, sig_state->pipe_hack[0],
-					    EVENT_FD_READ, signal_pipe_handler, NULL);
+		ev->pipe_fde = tevent_add_fd(ev, ev, sig_state->pipe_hack[0],
+					     TEVENT_FD_READ, signal_pipe_handler, NULL);
 	}
 	ev->num_signal_handlers++;
 
@@ -232,7 +237,7 @@ struct signal_event *common_event_add_signal(struct tevent_context *ev,
   check if a signal is pending
   return != 0 if a signal was pending
 */
-int common_event_check_signal(struct tevent_context *ev)
+int tevent_common_check_signal(struct tevent_context *ev)
 {
 	int i;
 
@@ -241,7 +246,7 @@ int common_event_check_signal(struct tevent_context *ev)
 	}
 	
 	for (i=0;i<NUM_SIGNALS+1;i++) {
-		struct signal_event *se, *next;
+		struct tevent_signal *se, *next;
 		struct sigcounter counter = sig_state->signal_count[i];
 		uint32_t count = sig_count(counter);
 
diff --git a/lib/tevent/tevent_standard.c b/lib/tevent/tevent_standard.c
index 7abb695d89..05310a5864 100644
--- a/lib/tevent/tevent_standard.c
+++ b/lib/tevent/tevent_standard.c
@@ -266,14 +266,14 @@ static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tv
 	}
 
 	if (std_ev->ev->num_signal_handlers && 
-	    common_event_check_signal(std_ev->ev)) {
+	    tevent_common_check_signal(std_ev->ev)) {
 		return 0;
 	}
 
 	ret = epoll_wait(std_ev->epoll_fd, events, MAXEVENTS, timeout);
 
 	if (ret == -1 && errno == EINTR && std_ev->ev->num_signal_handlers) {
-		if (common_event_check_signal(std_ev->ev)) {
+		if (tevent_common_check_signal(std_ev->ev)) {
 			return 0;
 		}
 	}
@@ -285,7 +285,7 @@ static int epoll_event_loop(struct std_event_context *std_ev, struct timeval *tv
 
 	if (ret == 0 && tvalp) {
 		/* we don't care about a possible delay here */
-		common_event_loop_timer_delay(std_ev->ev);
+		tevent_common_loop_timer_delay(std_ev->ev);
 		return 0;
 	}
 
@@ -405,9 +405,11 @@ static int std_event_fd_destructor(struct tevent_fd *fde)
   return NULL on failure (memory allocation error)
 */
 static struct tevent_fd *std_event_add_fd(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-					 int fd, uint16_t flags,
-					 event_fd_handler_t handler,
-					 void *private_data)
+					  int fd, uint16_t flags,
+					  tevent_fd_handler_t handler,
+					  void *private_data,
+					  const char *handler_name,
+					  const char *location)
 {
 	struct std_event_context *std_ev = talloc_get_type(ev->additional_data,
 							   struct std_event_context);
@@ -496,7 +498,7 @@ static int std_event_loop_select(struct std_event_context *std_ev, struct timeva
 	}
 
 	if (std_ev->ev->num_signal_handlers && 
-	    common_event_check_signal(std_ev->ev)) {
+	    tevent_common_check_signal(std_ev->ev)) {
 		return 0;
 	}
 
@@ -504,7 +506,7 @@ static int std_event_loop_select(struct std_event_context *std_ev, struct timeva
 
 	if (selrtn == -1 && errno == EINTR && 
 	    std_ev->ev->num_signal_handlers) {
-		common_event_check_signal(std_ev->ev);
+		tevent_common_check_signal(std_ev->ev);
 		return 0;
 	}
 
@@ -522,7 +524,7 @@ static int std_event_loop_select(struct std_event_context *std_ev, struct timeva
 
 	if (selrtn == 0 && tvalp) {
 		/* we don't care about a possible delay here */
-		common_event_loop_timer_delay(std_ev->ev);
+		tevent_common_loop_timer_delay(std_ev->ev);
 		return 0;
 	}
 
@@ -556,7 +558,7 @@ static int std_event_loop_once(struct tevent_context *ev)
 		 					   struct std_event_context);
 	struct timeval tval;
 
-	tval = common_event_loop_timer_delay(ev);
+	tval = tevent_common_loop_timer_delay(ev);
 	if (ev_timeval_is_zero(&tval)) {
 		return 0;
 	}
@@ -593,8 +595,8 @@ static const struct tevent_ops std_event_ops = {
 	.add_fd		= std_event_add_fd,
 	.get_fd_flags	= std_event_get_fd_flags,
 	.set_fd_flags	= std_event_set_fd_flags,
-	.add_timer	= common_event_add_timed,
-	.add_signal	= common_event_add_signal,
+	.add_timer	= tevent_common_add_timer,
+	.add_signal	= tevent_common_add_signal,
 	.loop_once	= std_event_loop_once,
 	.loop_wait	= std_event_loop_wait,
 };
diff --git a/lib/tevent/tevent_timed.c b/lib/tevent/tevent_timed.c
index 4ad457221e..dadd360416 100644
--- a/lib/tevent/tevent_timed.c
+++ b/lib/tevent/tevent_timed.c
@@ -106,7 +106,7 @@ bool ev_timeval_is_zero(const struct timeval *tv)
 /*
   destroy a timed event
 */
-static int common_event_timed_destructor(struct tevent_timer *te)
+static int tevent_common_timed_destructor(struct tevent_timer *te)
 {
 	struct tevent_context *ev = talloc_get_type(te->event_ctx,
 						   struct tevent_context);
@@ -114,7 +114,7 @@ static int common_event_timed_destructor(struct tevent_timer *te)
 	return 0;
 }
 
-static int common_event_timed_deny_destructor(struct tevent_timer *te)
+static int tevent_common_timed_deny_destructor(struct tevent_timer *te)
 {
 	return -1;
 }
@@ -123,10 +123,12 @@ static int common_event_timed_deny_destructor(struct tevent_timer *te)
   add a timed event
   return NULL on failure (memory allocation error)
 */
-struct tevent_timer *common_event_add_timed(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
-					   struct timeval next_event, 
-					   event_timed_handler_t handler, 
-					   void *private_data) 
+struct tevent_timer *tevent_common_add_timer(struct tevent_context *ev, TALLOC_CTX *mem_ctx,
+					     struct timeval next_event,
+					     tevent_timer_handler_t handler,
+					     void *private_data,
+					     const char *handler_name,
+					     const char *location)
 {
 	struct tevent_timer *te, *last_te, *cur_te;
 
@@ -137,6 +139,8 @@ struct tevent_timer *common_event_add_timed(struct tevent_context *ev, TALLOC_CT
 	te->next_event		= next_event;
 	te->handler		= handler;
 	te->private_data	= private_data;
+	te->handler_name	= handler_name;
+	te->location		= location;
 	te->additional_data	= NULL;
 
 	/* keep the list ordered */
@@ -152,7 +156,7 @@ struct tevent_timer *common_event_add_timed(struct tevent_context *ev, TALLOC_CT
 
 	DLIST_ADD_AFTER(ev->timer_events, te, last_te);
 
-	talloc_set_destructor(te, common_event_timed_destructor);
+	talloc_set_destructor(te, tevent_common_timed_destructor);
 
 	return te;
 }
@@ -163,7 +167,7 @@ struct tevent_timer *common_event_add_timed(struct tevent_context *ev, TALLOC_CT
   return the delay untill the next timed event,
   or zero if a timed event was triggered
 */
-struct timeval common_event_loop_timer_delay(struct tevent_context *ev)
+struct timeval tevent_common_loop_timer_delay(struct tevent_context *ev)
 {
 	struct timeval current_time = ev_timeval_zero();
 	struct tevent_timer *te = ev->timer_events;
@@ -200,7 +204,7 @@ struct timeval common_event_loop_timer_delay(struct tevent_context *ev)
 	 */
 
 	/* deny the handler to free the event */
-	talloc_set_destructor(te, common_event_timed_deny_destructor);
+	talloc_set_destructor(te, tevent_common_timed_deny_destructor);
 
 	/* We need to remove the timer from the list before calling the
 	 * handler because in a semi-async inner event loop called from the