4 Copyright (C) Jeremy Allison 2015
6 ** NOTE! The following LGPL license applies to the tevent
7 ** library. This does NOT imply that all of Samba is released
10 This library is free software; you can redistribute it and/or
11 modify it under the terms of the GNU Lesser General Public
12 License as published by the Free Software Foundation; either
13 version 3 of the License, or (at your option) any later version.
15 This library is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 Lesser General Public License for more details.
20 You should have received a copy of the GNU Lesser General Public
21 License along with this library; if not, see <http://www.gnu.org/licenses/>.
25 #include "system/filesys.h"
28 #include "tevent_internal.h"
29 #include "tevent_util.h"
31 #if defined(HAVE_PTHREAD)
34 struct tevent_immediate_list
{
35 struct tevent_immediate_list
*next
, *prev
;
36 tevent_immediate_handler_t handler
;
37 struct tevent_immediate
*im
;
41 struct tevent_thread_proxy
{
42 pthread_mutex_t mutex
;
43 struct tevent_context
*dest_ev_ctx
;
46 struct tevent_fd
*pipe_read_fde
;
47 /* Pending events list. */
48 struct tevent_immediate_list
*im_list
;
49 /* Completed events list. */
50 struct tevent_immediate_list
*tofree_im_list
;
51 struct tevent_immediate
*free_im
;
54 static void free_im_list(struct tevent_immediate_list
**pp_list_head
)
56 struct tevent_immediate_list
*im_entry
= NULL
;
57 struct tevent_immediate_list
*im_next
= NULL
;
59 for (im_entry
= *pp_list_head
; im_entry
; im_entry
= im_next
) {
60 im_next
= im_entry
->next
;
61 DLIST_REMOVE(*pp_list_head
, im_entry
);
62 TALLOC_FREE(im_entry
);
66 static void free_list_handler(struct tevent_context
*ev
,
67 struct tevent_immediate
*im
,
70 struct tevent_thread_proxy
*tp
=
71 talloc_get_type_abort(private_ptr
, struct tevent_thread_proxy
);
74 ret
= pthread_mutex_lock(&tp
->mutex
);
81 free_im_list(&tp
->tofree_im_list
);
83 ret
= pthread_mutex_unlock(&tp
->mutex
);
91 static void schedule_immediate_functions(struct tevent_thread_proxy
*tp
)
93 struct tevent_immediate_list
*im_entry
= NULL
;
94 struct tevent_immediate_list
*im_next
= NULL
;
96 for (im_entry
= tp
->im_list
; im_entry
; im_entry
= im_next
) {
97 im_next
= im_entry
->next
;
98 DLIST_REMOVE(tp
->im_list
, im_entry
);
100 tevent_schedule_immediate(im_entry
->im
,
103 im_entry
->private_ptr
);
105 /* Move from pending list to free list. */
106 DLIST_ADD(tp
->tofree_im_list
, im_entry
);
108 if (tp
->tofree_im_list
!= NULL
) {
110 * Once the current immediate events
111 * are processed, we need to reshedule
112 * ourselves to free them. This works
113 * as tevent_schedule_immediate()
114 * always adds events to the *END* of
115 * the immediate events list.
117 tevent_schedule_immediate(tp
->free_im
,
124 static void pipe_read_handler(struct tevent_context
*ev
,
125 struct tevent_fd
*fde
,
129 struct tevent_thread_proxy
*tp
=
130 talloc_get_type_abort(private_ptr
, struct tevent_thread_proxy
);
134 ret
= pthread_mutex_lock(&tp
->mutex
);
142 * Clear out all data in the pipe. We
143 * don't really care if this returns -1.
147 len
= read(tp
->read_fd
, buf
, 64);
150 schedule_immediate_functions(tp
);
152 ret
= pthread_mutex_unlock(&tp
->mutex
);
160 static int tevent_thread_proxy_destructor(struct tevent_thread_proxy
*tp
)
164 ret
= pthread_mutex_lock(&tp
->mutex
);
171 TALLOC_FREE(tp
->pipe_read_fde
);
173 if (tp
->read_fd
!= -1) {
174 (void)close(tp
->read_fd
);
177 if (tp
->write_fd
!= -1) {
178 (void)close(tp
->write_fd
);
182 /* Hmmm. It's probably an error if we get here with
183 any non-NULL immediate entries.. */
185 free_im_list(&tp
->im_list
);
186 free_im_list(&tp
->tofree_im_list
);
188 TALLOC_FREE(tp
->free_im
);
190 ret
= pthread_mutex_unlock(&tp
->mutex
);
197 ret
= pthread_mutex_destroy(&tp
->mutex
);
208 * Create a struct that can be passed to other threads
209 * to allow them to signal the struct tevent_context *
213 struct tevent_thread_proxy
*tevent_thread_proxy_create(
214 struct tevent_context
*dest_ev_ctx
)
218 struct tevent_thread_proxy
*tp
;
220 tp
= talloc_zero(dest_ev_ctx
, struct tevent_thread_proxy
);
225 ret
= pthread_mutex_init(&tp
->mutex
, NULL
);
230 tp
->dest_ev_ctx
= dest_ev_ctx
;
234 talloc_set_destructor(tp
, tevent_thread_proxy_destructor
);
241 tp
->read_fd
= pipefds
[0];
242 tp
->write_fd
= pipefds
[1];
244 ret
= ev_set_blocking(pipefds
[0], false);
248 ret
= ev_set_blocking(pipefds
[1], false);
252 if (!ev_set_close_on_exec(pipefds
[0])) {
255 if (!ev_set_close_on_exec(pipefds
[1])) {
259 tp
->pipe_read_fde
= tevent_add_fd(dest_ev_ctx
,
265 if (tp
->pipe_read_fde
== NULL
) {
270 * Create an immediate event to free
273 tp
->free_im
= tevent_create_immediate(tp
);
274 if (tp
->free_im
== NULL
) {
287 * This function schedules an immediate event to be called with argument
288 * *pp_private in the thread context of dest_ev_ctx. Caller doesn't
289 * wait for activation to take place, this is simply fire-and-forget.
291 * pp_im must be a pointer to an immediate event talloced on
292 * a context owned by the calling thread, or the NULL context.
293 * Ownership of *pp_im will be transfered to the tevent library.
295 * pp_private can be null, or contents of *pp_private must be
296 * talloc'ed memory on a context owned by the calling thread
297 * or the NULL context. If non-null, ownership of *pp_private will
298 * be transfered to the tevent library.
300 * If you want to return a message, have the destination use the
301 * same function call to send back to the caller.
305 void tevent_thread_proxy_schedule(struct tevent_thread_proxy
*tp
,
306 struct tevent_immediate
**pp_im
,
307 tevent_immediate_handler_t handler
,
308 void *pp_private_data
)
310 struct tevent_immediate_list
*im_entry
;
314 ret
= pthread_mutex_lock(&tp
->mutex
);
321 if (tp
->write_fd
== -1) {
322 /* In the process of being destroyed. Ignore. */
326 /* Create a new immediate_list entry. MUST BE ON THE NULL CONTEXT */
327 im_entry
= talloc_zero(NULL
, struct tevent_immediate_list
);
328 if (im_entry
== NULL
) {
332 im_entry
->handler
= handler
;
333 im_entry
->im
= talloc_move(im_entry
, pp_im
);
335 if (pp_private_data
!= NULL
) {
336 void **pptr
= (void **)pp_private_data
;
337 im_entry
->private_ptr
= talloc_move(im_entry
, pptr
);
340 DLIST_ADD(tp
->im_list
, im_entry
);
342 /* And notify the dest_ev_ctx to wake up. */
344 (void)write(tp
->write_fd
, &c
, 1);
348 ret
= pthread_mutex_unlock(&tp
->mutex
);
356 struct tevent_thread_proxy
*tevent_thread_proxy_create(
357 struct tevent_context
*dest_ev_ctx
)
363 void tevent_thread_proxy_schedule(struct tevent_thread_proxy
*tp
,
364 struct tevent_immediate
**pp_im
,
365 tevent_immediate_handler_t handler
,
366 void *pp_private_data
)