1
0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
samba-mirror/lib/pthreadpool/pthreadpool_tevent.c
Stefan Metzmacher f68b5ee75f pthreadpool: reset monitor_fd after calling tevent_fd_set_auto_close()
This tries to convince Coverity that we don't have a resource leak:

CID 1438157:    (RESOURCE_LEAK)
Handle variable "monitor_fd" going out of scope leaks the handle.

Signed-off-by: Stefan Metzmacher <metze@samba.org>
Reviewed-by: Volker Lendecke <vl@samba.org>
2018-07-31 11:26:16 +02:00

1351 lines
32 KiB
C

/*
* Unix SMB/CIFS implementation.
* threadpool implementation based on pthreads
* Copyright (C) Volker Lendecke 2009,2011
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "replace.h"
#include "system/select.h"
#include "system/threads.h"
#include "system/filesys.h"
#include "pthreadpool_tevent.h"
#include "pthreadpool.h"
#include "lib/util/tevent_unix.h"
#include "lib/util/dlinklist.h"
#include "lib/util/attr.h"
/*
* We try to give some hints to helgrind/drd
*
* Note ANNOTATE_BENIGN_RACE_SIZED(address, size, describtion)
* takes an memory address range that ignored by helgrind/drd
* 'description' is just ignored...
*
*
* Note that ANNOTATE_HAPPENS_*(unique_uintptr)
* just takes a DWORD/(void *) as unique key
* for the barrier.
*/
#ifdef HAVE_VALGRIND_HELGRIND_H
#include <valgrind/helgrind.h>
#endif
#ifndef ANNOTATE_BENIGN_RACE_SIZED
#define ANNOTATE_BENIGN_RACE_SIZED(address, size, describtion)
#endif
#ifndef ANNOTATE_HAPPENS_BEFORE
#define ANNOTATE_HAPPENS_BEFORE(unique_uintptr)
#endif
#ifndef ANNOTATE_HAPPENS_AFTER
#define ANNOTATE_HAPPENS_AFTER(unique_uintptr)
#endif
#ifndef ANNOTATE_HAPPENS_BEFORE_FORGET_ALL
#define ANNOTATE_HAPPENS_BEFORE_FORGET_ALL(unique_uintptr)
#endif
#define PTHREAD_TEVENT_JOB_THREAD_FENCE_INIT(__job) do { \
_UNUSED_ const struct pthreadpool_tevent_job *__j = __job; \
ANNOTATE_BENIGN_RACE_SIZED(&__j->needs_fence, \
sizeof(__j->needs_fence), \
"race by design, protected by fence"); \
} while(0);
#ifdef WITH_PTHREADPOOL
/*
* configure checked we have pthread and atomic_thread_fence() available
*/
#define __PTHREAD_TEVENT_JOB_THREAD_FENCE(__order) do { \
atomic_thread_fence(__order); \
} while(0)
#else
/*
* we're using lib/pthreadpool/pthreadpool_sync.c ...
*/
#define __PTHREAD_TEVENT_JOB_THREAD_FENCE(__order) do { } while(0)
#ifndef HAVE___THREAD
#define __thread
#endif
#endif
#define PTHREAD_TEVENT_JOB_THREAD_FENCE(__job) do { \
_UNUSED_ const struct pthreadpool_tevent_job *__j = __job; \
ANNOTATE_HAPPENS_BEFORE(&__job->needs_fence); \
__PTHREAD_TEVENT_JOB_THREAD_FENCE(memory_order_seq_cst); \
ANNOTATE_HAPPENS_AFTER(&__job->needs_fence); \
} while(0);
#define PTHREAD_TEVENT_JOB_THREAD_FENCE_FINI(__job) do { \
_UNUSED_ const struct pthreadpool_tevent_job *__j = __job; \
ANNOTATE_HAPPENS_BEFORE_FORGET_ALL(&__job->needs_fence); \
} while(0);
struct pthreadpool_tevent_job_state;
/*
* We need one pthreadpool_tevent_glue object per unique combintaion of tevent
* contexts and pthreadpool_tevent objects. Maintain a list of used tevent
* contexts in a pthreadpool_tevent.
*/
struct pthreadpool_tevent_glue {
struct pthreadpool_tevent_glue *prev, *next;
struct pthreadpool_tevent *pool; /* back-pointer to owning object. */
/* Tuple we are keeping track of in this list. */
struct tevent_context *ev;
struct tevent_threaded_context *tctx;
/* recheck monitor fd event */
struct tevent_fd *fde;
/* Pointer to link object owned by *ev. */
struct pthreadpool_tevent_glue_ev_link *ev_link;
/* active jobs */
struct pthreadpool_tevent_job_state *states;
};
/*
* The pthreadpool_tevent_glue_ev_link and its destructor ensure we remove the
* tevent context from our list of active event contexts if the event context
* is destroyed.
* This structure is talloc()'ed from the struct tevent_context *, and is a
* back-pointer allowing the related struct pthreadpool_tevent_glue object
* to be removed from the struct pthreadpool_tevent glue list if the owning
* tevent_context is talloc_free()'ed.
*/
struct pthreadpool_tevent_glue_ev_link {
struct pthreadpool_tevent_glue *glue;
};
struct pthreadpool_tevent_wrapper {
struct pthreadpool_tevent *main_tp;
struct pthreadpool_tevent *wrap_tp;
const struct pthreadpool_tevent_wrapper_ops *ops;
void *private_state;
bool force_per_thread_cwd;
};
struct pthreadpool_tevent {
struct pthreadpool_tevent *prev, *next;
struct pthreadpool *pool;
struct pthreadpool_tevent_glue *glue_list;
struct pthreadpool_tevent_job *jobs;
struct {
/*
* This is used on the main context
*/
struct pthreadpool_tevent *list;
/*
* This is used on the wrapper context
*/
struct pthreadpool_tevent_wrapper *ctx;
} wrapper;
};
struct pthreadpool_tevent_job_state {
struct pthreadpool_tevent_job_state *prev, *next;
struct pthreadpool_tevent_glue *glue;
struct tevent_context *ev;
struct tevent_req *req;
struct pthreadpool_tevent_job *job;
};
struct pthreadpool_tevent_job {
struct pthreadpool_tevent_job *prev, *next;
struct pthreadpool_tevent *pool;
struct pthreadpool_tevent_wrapper *wrapper;
struct pthreadpool_tevent_job_state *state;
struct tevent_immediate *im;
void (*fn)(void *private_data);
void *private_data;
/*
* Coordination between threads
*
* There're only one side writing each element
* either the main process or the job thread.
*
* The coordination is done by a full memory
* barrier using atomic_thread_fence(memory_order_seq_cst)
* wrapped in PTHREAD_TEVENT_JOB_THREAD_FENCE()
*/
struct {
/*
* 'maycancel'
* set when tevent_req_cancel() is called.
* (only written by main thread!)
*/
bool maycancel;
/*
* 'orphaned'
* set when talloc_free is called on the job request,
* tevent_context or pthreadpool_tevent.
* (only written by main thread!)
*/
bool orphaned;
/*
* 'started'
* set when the job is picked up by a worker thread
* (only written by job thread!)
*/
bool started;
/*
* 'wrapper'
* set before calling the wrapper before_job() or
* after_job() hooks.
* unset again check the hook finished.
* (only written by job thread!)
*/
bool wrapper;
/*
* 'executed'
* set once the job function returned.
* (only written by job thread!)
*/
bool executed;
/*
* 'finished'
* set when pthreadpool_tevent_job_signal() is entered
* (only written by job thread!)
*/
bool finished;
/*
* 'dropped'
* set when pthreadpool_tevent_job_signal() leaves with
* orphaned already set.
* (only written by job thread!)
*/
bool dropped;
/*
* 'signaled'
* set when pthreadpool_tevent_job_signal() leaves normal
* and the immediate event was scheduled.
* (only written by job thread!)
*/
bool signaled;
/*
* 'exit_thread'
* maybe set during pthreadpool_tevent_job_fn()
* if some wrapper related code generated an error
* and the environment isn't safe anymore.
*
* In such a case pthreadpool_tevent_job_signal()
* will pick this up and therminate the current
* worker thread by returning -1.
*/
bool exit_thread; /* only written/read by job thread! */
} needs_fence;
bool per_thread_cwd;
};
static int pthreadpool_tevent_destructor(struct pthreadpool_tevent *pool);
static void pthreadpool_tevent_job_orphan(struct pthreadpool_tevent_job *job);
static struct pthreadpool_tevent_job *orphaned_jobs;
void pthreadpool_tevent_cleanup_orphaned_jobs(void)
{
struct pthreadpool_tevent_job *job = NULL;
struct pthreadpool_tevent_job *njob = NULL;
for (job = orphaned_jobs; job != NULL; job = njob) {
njob = job->next;
/*
* The job destructor keeps the job alive
* (and in the list) or removes it from the list.
*/
TALLOC_FREE(job);
}
}
static int pthreadpool_tevent_job_signal(int jobid,
void (*job_fn)(void *private_data),
void *job_private_data,
void *private_data);
int pthreadpool_tevent_init(TALLOC_CTX *mem_ctx, unsigned max_threads,
struct pthreadpool_tevent **presult)
{
struct pthreadpool_tevent *pool;
int ret;
pthreadpool_tevent_cleanup_orphaned_jobs();
pool = talloc_zero(mem_ctx, struct pthreadpool_tevent);
if (pool == NULL) {
return ENOMEM;
}
ret = pthreadpool_init(max_threads, &pool->pool,
pthreadpool_tevent_job_signal, pool);
if (ret != 0) {
TALLOC_FREE(pool);
return ret;
}
talloc_set_destructor(pool, pthreadpool_tevent_destructor);
*presult = pool;
return 0;
}
static struct pthreadpool_tevent *pthreadpool_tevent_unwrap(
struct pthreadpool_tevent *pool)
{
struct pthreadpool_tevent_wrapper *wrapper = pool->wrapper.ctx;
if (wrapper != NULL) {
return wrapper->main_tp;
}
return pool;
}
size_t pthreadpool_tevent_max_threads(struct pthreadpool_tevent *pool)
{
pool = pthreadpool_tevent_unwrap(pool);
if (pool->pool == NULL) {
return 0;
}
return pthreadpool_max_threads(pool->pool);
}
size_t pthreadpool_tevent_queued_jobs(struct pthreadpool_tevent *pool)
{
pool = pthreadpool_tevent_unwrap(pool);
if (pool->pool == NULL) {
return 0;
}
return pthreadpool_queued_jobs(pool->pool);
}
bool pthreadpool_tevent_per_thread_cwd(struct pthreadpool_tevent *pool)
{
struct pthreadpool_tevent_wrapper *wrapper = pool->wrapper.ctx;
if (wrapper != NULL && wrapper->force_per_thread_cwd) {
return true;
}
pool = pthreadpool_tevent_unwrap(pool);
if (pool->pool == NULL) {
return false;
}
return pthreadpool_per_thread_cwd(pool->pool);
}
static int pthreadpool_tevent_destructor(struct pthreadpool_tevent *pool)
{
struct pthreadpool_tevent_job *job = NULL;
struct pthreadpool_tevent_job *njob = NULL;
struct pthreadpool_tevent *wrap_tp = NULL;
struct pthreadpool_tevent *nwrap_tp = NULL;
struct pthreadpool_tevent_glue *glue = NULL;
int ret;
if (pool->wrapper.ctx != NULL) {
struct pthreadpool_tevent_wrapper *wrapper = pool->wrapper.ctx;
pool->wrapper.ctx = NULL;
pool = wrapper->main_tp;
DLIST_REMOVE(pool->wrapper.list, wrapper->wrap_tp);
for (job = pool->jobs; job != NULL; job = njob) {
njob = job->next;
if (job->wrapper != wrapper) {
continue;
}
/*
* This removes the job from the list
*
* Note that it waits in case
* the wrapper hooks are currently
* executing on the job.
*/
pthreadpool_tevent_job_orphan(job);
}
/*
* At this point we're sure that no job
* still references the pthreadpool_tevent_wrapper
* structure, so we can free it.
*/
TALLOC_FREE(wrapper);
pthreadpool_tevent_cleanup_orphaned_jobs();
return 0;
}
if (pool->pool == NULL) {
/*
* A dangling wrapper without main_tp.
*/
return 0;
}
ret = pthreadpool_stop(pool->pool);
if (ret != 0) {
return ret;
}
/*
* orphan all jobs (including wrapper jobs)
*/
for (job = pool->jobs; job != NULL; job = njob) {
njob = job->next;
/*
* The job this removes it from the list
*
* Note that it waits in case
* the wrapper hooks are currently
* executing on the job (thread).
*/
pthreadpool_tevent_job_orphan(job);
}
/*
* cleanup all existing wrappers, remember we just orphaned
* all jobs (including the once of the wrappers).
*
* So we just mark as broken, so that
* pthreadpool_tevent_job_send() won't accept new jobs.
*/
for (wrap_tp = pool->wrapper.list; wrap_tp != NULL; wrap_tp = nwrap_tp) {
nwrap_tp = wrap_tp->next;
/*
* Just mark them as broken, so that we can't
* get more jobs.
*/
TALLOC_FREE(wrap_tp->wrapper.ctx);
DLIST_REMOVE(pool->wrapper.list, wrap_tp);
}
/*
* Delete all the registered
* tevent_context/tevent_threaded_context
* pairs.
*/
for (glue = pool->glue_list; glue != NULL; glue = pool->glue_list) {
/* The glue destructor removes it from the list */
TALLOC_FREE(glue);
}
pool->glue_list = NULL;
ret = pthreadpool_destroy(pool->pool);
if (ret != 0) {
return ret;
}
pool->pool = NULL;
pthreadpool_tevent_cleanup_orphaned_jobs();
return 0;
}
struct pthreadpool_tevent *_pthreadpool_tevent_wrapper_create(
struct pthreadpool_tevent *main_tp,
TALLOC_CTX *mem_ctx,
const struct pthreadpool_tevent_wrapper_ops *ops,
void *pstate,
size_t psize,
const char *type,
const char *location)
{
void **ppstate = (void **)pstate;
struct pthreadpool_tevent *wrap_tp = NULL;
struct pthreadpool_tevent_wrapper *wrapper = NULL;
pthreadpool_tevent_cleanup_orphaned_jobs();
if (main_tp->wrapper.ctx != NULL) {
/*
* stacking of wrappers is not supported
*/
errno = EINVAL;
return NULL;
}
if (main_tp->pool == NULL) {
/*
* The pool is no longer valid,
* most likely it was a wrapper context
* where the main pool was destroyed.
*/
errno = EINVAL;
return NULL;
}
wrap_tp = talloc_zero(mem_ctx, struct pthreadpool_tevent);
if (wrap_tp == NULL) {
return NULL;
}
wrapper = talloc_zero(wrap_tp, struct pthreadpool_tevent_wrapper);
if (wrapper == NULL) {
TALLOC_FREE(wrap_tp);
return NULL;
}
wrapper->main_tp = main_tp;
wrapper->wrap_tp = wrap_tp;
wrapper->ops = ops;
wrapper->private_state = talloc_zero_size(wrapper, psize);
if (wrapper->private_state == NULL) {
TALLOC_FREE(wrap_tp);
return NULL;
}
talloc_set_name_const(wrapper->private_state, type);
wrap_tp->wrapper.ctx = wrapper;
DLIST_ADD_END(main_tp->wrapper.list, wrap_tp);
talloc_set_destructor(wrap_tp, pthreadpool_tevent_destructor);
*ppstate = wrapper->private_state;
return wrap_tp;
}
void pthreadpool_tevent_force_per_thread_cwd(struct pthreadpool_tevent *pool,
const void *private_state)
{
struct pthreadpool_tevent_wrapper *wrapper = pool->wrapper.ctx;
if (wrapper == NULL) {
abort();
}
if (wrapper->private_state != private_state) {
abort();
}
wrapper->force_per_thread_cwd = true;
}
static int pthreadpool_tevent_glue_destructor(
struct pthreadpool_tevent_glue *glue)
{
struct pthreadpool_tevent_job_state *state = NULL;
struct pthreadpool_tevent_job_state *nstate = NULL;
TALLOC_FREE(glue->fde);
for (state = glue->states; state != NULL; state = nstate) {
nstate = state->next;
/* The job this removes it from the list */
pthreadpool_tevent_job_orphan(state->job);
}
if (glue->pool->glue_list != NULL) {
DLIST_REMOVE(glue->pool->glue_list, glue);
}
/* Ensure the ev_link destructor knows we're gone */
glue->ev_link->glue = NULL;
TALLOC_FREE(glue->ev_link);
TALLOC_FREE(glue->tctx);
return 0;
}
/*
* Destructor called either explicitly from
* pthreadpool_tevent_glue_destructor(), or indirectly
* when owning tevent_context is destroyed.
*
* When called from pthreadpool_tevent_glue_destructor()
* ev_link->glue is already NULL, so this does nothing.
*
* When called from talloc_free() of the owning
* tevent_context we must ensure we also remove the
* linked glue object from the list inside
* struct pthreadpool_tevent.
*/
static int pthreadpool_tevent_glue_link_destructor(
struct pthreadpool_tevent_glue_ev_link *ev_link)
{
TALLOC_FREE(ev_link->glue);
return 0;
}
static void pthreadpool_tevent_glue_monitor(struct tevent_context *ev,
struct tevent_fd *fde,
uint16_t flags,
void *private_data)
{
struct pthreadpool_tevent_glue *glue =
talloc_get_type_abort(private_data,
struct pthreadpool_tevent_glue);
struct pthreadpool_tevent_job *job = NULL;
struct pthreadpool_tevent_job *njob = NULL;
int ret = -1;
ret = pthreadpool_restart_check_monitor_drain(glue->pool->pool);
if (ret != 0) {
TALLOC_FREE(glue->fde);
}
ret = pthreadpool_restart_check(glue->pool->pool);
if (ret == 0) {
/*
* success...
*/
goto done;
}
/*
* There's a problem and the pool
* has not a single thread available
* for pending jobs, so we can only
* stop the jobs and return an error.
* This is similar to a failure from
* pthreadpool_add_job().
*/
for (job = glue->pool->jobs; job != NULL; job = njob) {
njob = job->next;
tevent_req_defer_callback(job->state->req,
job->state->ev);
tevent_req_error(job->state->req, ret);
}
done:
if (glue->states == NULL) {
/*
* If the glue doesn't have any pending jobs
* we remove the glue.
*
* In order to remove the fd event.
*/
TALLOC_FREE(glue);
}
}
static int pthreadpool_tevent_register_ev(
struct pthreadpool_tevent *pool,
struct pthreadpool_tevent_job_state *state)
{
struct tevent_context *ev = state->ev;
struct pthreadpool_tevent_glue *glue = NULL;
struct pthreadpool_tevent_glue_ev_link *ev_link = NULL;
int monitor_fd = -1;
/*
* See if this tevent_context was already registered by
* searching the glue object list. If so we have nothing
* to do here - we already have a tevent_context/tevent_threaded_context
* pair.
*/
for (glue = pool->glue_list; glue != NULL; glue = glue->next) {
if (glue->ev == state->ev) {
state->glue = glue;
DLIST_ADD_END(glue->states, state);
return 0;
}
}
/*
* Event context not yet registered - create a new glue
* object containing a tevent_context/tevent_threaded_context
* pair and put it on the list to remember this registration.
* We also need a link object to ensure the event context
* can't go away without us knowing about it.
*/
glue = talloc_zero(pool, struct pthreadpool_tevent_glue);
if (glue == NULL) {
return ENOMEM;
}
*glue = (struct pthreadpool_tevent_glue) {
.pool = pool,
.ev = ev,
};
talloc_set_destructor(glue, pthreadpool_tevent_glue_destructor);
monitor_fd = pthreadpool_restart_check_monitor_fd(pool->pool);
if (monitor_fd == -1 && errno != ENOSYS) {
int saved_errno = errno;
TALLOC_FREE(glue);
return saved_errno;
}
if (monitor_fd != -1) {
glue->fde = tevent_add_fd(ev,
glue,
monitor_fd,
TEVENT_FD_READ,
pthreadpool_tevent_glue_monitor,
glue);
if (glue->fde == NULL) {
close(monitor_fd);
TALLOC_FREE(glue);
return ENOMEM;
}
tevent_fd_set_auto_close(glue->fde);
monitor_fd = -1;
}
/*
* Now allocate the link object to the event context. Note this
* is allocated OFF THE EVENT CONTEXT ITSELF, so if the event
* context is freed we are able to cleanup the glue object
* in the link object destructor.
*/
ev_link = talloc_zero(ev, struct pthreadpool_tevent_glue_ev_link);
if (ev_link == NULL) {
TALLOC_FREE(glue);
return ENOMEM;
}
ev_link->glue = glue;
talloc_set_destructor(ev_link, pthreadpool_tevent_glue_link_destructor);
glue->ev_link = ev_link;
#ifdef HAVE_PTHREAD
glue->tctx = tevent_threaded_context_create(glue, ev);
if (glue->tctx == NULL) {
TALLOC_FREE(ev_link);
TALLOC_FREE(glue);
return ENOMEM;
}
#endif
state->glue = glue;
DLIST_ADD_END(glue->states, state);
DLIST_ADD(pool->glue_list, glue);
return 0;
}
static void pthreadpool_tevent_job_fn(void *private_data);
static void pthreadpool_tevent_job_done(struct tevent_context *ctx,
struct tevent_immediate *im,
void *private_data);
static bool pthreadpool_tevent_job_cancel(struct tevent_req *req);
static int pthreadpool_tevent_job_destructor(struct pthreadpool_tevent_job *job)
{
/*
* We should never be called with needs_fence.orphaned == false.
* Only pthreadpool_tevent_job_orphan() will call TALLOC_FREE(job)
* after detaching from the request state, glue and pool list.
*/
if (!job->needs_fence.orphaned) {
abort();
}
/*
* If the job is not finished (job->im still there)
* and it's still attached to the pool,
* we try to cancel it (before it was starts)
*/
if (job->im != NULL && job->pool != NULL) {
size_t num;
num = pthreadpool_cancel_job(job->pool->pool, 0,
pthreadpool_tevent_job_fn,
job);
if (num != 0) {
/*
* It was not too late to cancel the request.
*
* We can remove job->im, as it will never be used.
*/
TALLOC_FREE(job->im);
}
}
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.dropped) {
/*
* The signal function saw job->needs_fence.orphaned
* before it started the signaling via the immediate
* event. So we'll never geht triggered and can
* remove job->im and let the whole job go...
*/
TALLOC_FREE(job->im);
}
/*
* TODO?: We could further improve this by adjusting
* tevent_threaded_schedule_immediate_destructor()
* and allow TALLOC_FREE() during its time
* in the main_ev->scheduled_immediates list.
*
* PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
* if (state->needs_fence.signaled) {
* *
* * The signal function is completed
* * in future we may be allowed
* * to call TALLOC_FREE(job->im).
* *
* TALLOC_FREE(job->im);
* }
*/
/*
* pthreadpool_tevent_job_orphan() already removed
* it from pool->jobs. And we don't need try
* pthreadpool_cancel_job() again.
*/
job->pool = NULL;
if (job->im != NULL) {
/*
* state->im still there means, we need to wait for the
* immediate event to be triggered or just leak the memory.
*
* Move it to the orphaned list, if it's not already there.
*/
return -1;
}
/*
* Finally remove from the orphaned_jobs list
* and let talloc destroy us.
*/
DLIST_REMOVE(orphaned_jobs, job);
PTHREAD_TEVENT_JOB_THREAD_FENCE_FINI(job);
return 0;
}
static void pthreadpool_tevent_job_orphan(struct pthreadpool_tevent_job *job)
{
job->needs_fence.orphaned = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
/*
* We're the only function that sets
* job->state = NULL;
*/
if (job->state == NULL) {
abort();
}
/*
* Once we marked the request as 'orphaned'
* we spin/loop if 'wrapper' is marked as active.
*
* We need to wait until the wrapper hook finished
* before we can set job->wrapper = NULL.
*
* This is some kind of spinlock, but with
* 1 millisecond sleeps in between, in order
* to give the thread more cpu time to finish.
*/
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
while (job->needs_fence.wrapper) {
(void)poll(NULL, 0, 1);
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
}
job->wrapper = NULL;
/*
* Once we marked the request as 'orphaned'
* we spin/loop if it's already marked
* as 'finished' (which means that
* pthreadpool_tevent_job_signal() was entered.
* If it saw 'orphaned' it will exit after setting
* 'dropped', otherwise it dereferences
* job->state->glue->{tctx,ev} until it exited
* after setting 'signaled'.
*
* We need to close this potential gab before
* we can set job->state = NULL.
*
* This is some kind of spinlock, but with
* 1 millisecond sleeps in between, in order
* to give the thread more cpu time to finish.
*/
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
while (job->needs_fence.finished) {
if (job->needs_fence.dropped) {
break;
}
if (job->needs_fence.signaled) {
break;
}
(void)poll(NULL, 0, 1);
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
}
/*
* Once the gab is closed, we can remove
* the glue link.
*/
DLIST_REMOVE(job->state->glue->states, job->state);
job->state->glue = NULL;
/*
* We need to reparent to a long term context.
* And detach from the request state.
* Maybe the destructor will keep the memory
* and leak it for now.
*/
(void)talloc_reparent(job->state, NULL, job);
job->state->job = NULL;
job->state = NULL;
/*
* job->pool will only be set to NULL
* in the first destructur run.
*/
if (job->pool == NULL) {
abort();
}
/*
* Dettach it from the pool.
*
* The job might still be running,
* so we keep job->pool.
* The destructor will set it to NULL
* after trying pthreadpool_cancel_job()
*/
DLIST_REMOVE(job->pool->jobs, job);
/*
* Add it to the list of orphaned jobs,
* which may be cleaned up later.
*
* The destructor removes it from the list
* when possible or it denies the free
* and keep it in the list.
*/
DLIST_ADD_END(orphaned_jobs, job);
TALLOC_FREE(job);
}
static void pthreadpool_tevent_job_cleanup(struct tevent_req *req,
enum tevent_req_state req_state)
{
struct pthreadpool_tevent_job_state *state =
tevent_req_data(req,
struct pthreadpool_tevent_job_state);
if (state->job == NULL) {
/*
* The job request is not scheduled in the pool
* yet or anymore.
*/
if (state->glue != NULL) {
DLIST_REMOVE(state->glue->states, state);
state->glue = NULL;
}
return;
}
/*
* We need to reparent to a long term context.
* Maybe the destructor will keep the memory
* and leak it for now.
*/
pthreadpool_tevent_job_orphan(state->job);
state->job = NULL; /* not needed but looks better */
return;
}
struct tevent_req *pthreadpool_tevent_job_send(
TALLOC_CTX *mem_ctx, struct tevent_context *ev,
struct pthreadpool_tevent *pool,
void (*fn)(void *private_data), void *private_data)
{
struct tevent_req *req = NULL;
struct pthreadpool_tevent_job_state *state = NULL;
struct pthreadpool_tevent_job *job = NULL;
int ret;
struct pthreadpool_tevent *caller_pool = pool;
struct pthreadpool_tevent_wrapper *wrapper = pool->wrapper.ctx;
pthreadpool_tevent_cleanup_orphaned_jobs();
if (wrapper != NULL) {
pool = wrapper->main_tp;
}
req = tevent_req_create(mem_ctx, &state,
struct pthreadpool_tevent_job_state);
if (req == NULL) {
return NULL;
}
state->ev = ev;
state->req = req;
tevent_req_set_cleanup_fn(req, pthreadpool_tevent_job_cleanup);
if (pool == NULL) {
tevent_req_error(req, EINVAL);
return tevent_req_post(req, ev);
}
if (pool->pool == NULL) {
tevent_req_error(req, EINVAL);
return tevent_req_post(req, ev);
}
ret = pthreadpool_tevent_register_ev(pool, state);
if (tevent_req_error(req, ret)) {
return tevent_req_post(req, ev);
}
job = talloc_zero(state, struct pthreadpool_tevent_job);
if (tevent_req_nomem(job, req)) {
return tevent_req_post(req, ev);
}
job->pool = pool;
job->wrapper = wrapper;
job->fn = fn;
job->private_data = private_data;
job->im = tevent_create_immediate(state->job);
if (tevent_req_nomem(job->im, req)) {
return tevent_req_post(req, ev);
}
PTHREAD_TEVENT_JOB_THREAD_FENCE_INIT(job);
job->per_thread_cwd = pthreadpool_tevent_per_thread_cwd(caller_pool);
talloc_set_destructor(job, pthreadpool_tevent_job_destructor);
DLIST_ADD_END(job->pool->jobs, job);
job->state = state;
state->job = job;
ret = pthreadpool_add_job(job->pool->pool, 0,
pthreadpool_tevent_job_fn,
job);
if (tevent_req_error(req, ret)) {
return tevent_req_post(req, ev);
}
tevent_req_set_cancel_fn(req, pthreadpool_tevent_job_cancel);
return req;
}
static __thread struct pthreadpool_tevent_job *current_job;
bool pthreadpool_tevent_current_job_canceled(void)
{
if (current_job == NULL) {
/*
* Should only be called from within
* the job function.
*/
abort();
return false;
}
PTHREAD_TEVENT_JOB_THREAD_FENCE(current_job);
return current_job->needs_fence.maycancel;
}
bool pthreadpool_tevent_current_job_orphaned(void)
{
if (current_job == NULL) {
/*
* Should only be called from within
* the job function.
*/
abort();
return false;
}
PTHREAD_TEVENT_JOB_THREAD_FENCE(current_job);
return current_job->needs_fence.orphaned;
}
bool pthreadpool_tevent_current_job_continue(void)
{
if (current_job == NULL) {
/*
* Should only be called from within
* the job function.
*/
abort();
return false;
}
PTHREAD_TEVENT_JOB_THREAD_FENCE(current_job);
if (current_job->needs_fence.maycancel) {
return false;
}
PTHREAD_TEVENT_JOB_THREAD_FENCE(current_job);
if (current_job->needs_fence.orphaned) {
return false;
}
return true;
}
bool pthreadpool_tevent_current_job_per_thread_cwd(void)
{
if (current_job == NULL) {
/*
* Should only be called from within
* the job function.
*/
abort();
return false;
}
return current_job->per_thread_cwd;
}
static void pthreadpool_tevent_job_fn(void *private_data)
{
struct pthreadpool_tevent_job *job =
talloc_get_type_abort(private_data,
struct pthreadpool_tevent_job);
struct pthreadpool_tevent_wrapper *wrapper = NULL;
current_job = job;
job->needs_fence.started = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.orphaned) {
current_job = NULL;
return;
}
wrapper = job->wrapper;
if (wrapper != NULL) {
bool ok;
job->needs_fence.wrapper = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.orphaned) {
job->needs_fence.wrapper = false;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
current_job = NULL;
return;
}
ok = wrapper->ops->before_job(wrapper->wrap_tp,
wrapper->private_state,
wrapper->main_tp,
__location__);
job->needs_fence.wrapper = false;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (!ok) {
job->needs_fence.exit_thread = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
current_job = NULL;
return;
}
}
job->fn(job->private_data);
job->needs_fence.executed = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (wrapper != NULL) {
bool ok;
job->needs_fence.wrapper = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.orphaned) {
job->needs_fence.wrapper = false;
job->needs_fence.exit_thread = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
current_job = NULL;
return;
}
ok = wrapper->ops->after_job(wrapper->wrap_tp,
wrapper->private_state,
wrapper->main_tp,
__location__);
job->needs_fence.wrapper = false;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (!ok) {
job->needs_fence.exit_thread = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
current_job = NULL;
return;
}
}
current_job = NULL;
}
static int pthreadpool_tevent_job_signal(int jobid,
void (*job_fn)(void *private_data),
void *job_private_data,
void *private_data)
{
struct pthreadpool_tevent_job *job =
talloc_get_type_abort(job_private_data,
struct pthreadpool_tevent_job);
job->needs_fence.finished = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.orphaned) {
/* Request already gone */
job->needs_fence.dropped = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.exit_thread) {
/*
* A problem with the wrapper the current job/worker
* thread needs to terminate.
*
* The pthreadpool_tevent is already gone.
*/
return -1;
}
return 0;
}
/*
* state and state->glue are valid,
* see the job->needs_fence.finished
* "spinlock" loop in
* pthreadpool_tevent_job_orphan()
*/
if (job->state->glue->tctx != NULL) {
/* with HAVE_PTHREAD */
tevent_threaded_schedule_immediate(job->state->glue->tctx,
job->im,
pthreadpool_tevent_job_done,
job);
} else {
/* without HAVE_PTHREAD */
tevent_schedule_immediate(job->im,
job->state->glue->ev,
pthreadpool_tevent_job_done,
job);
}
job->needs_fence.signaled = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.exit_thread) {
/*
* A problem with the wrapper the current job/worker
* thread needs to terminate.
*
* The pthreadpool_tevent is already gone.
*/
return -1;
}
return 0;
}
static void pthreadpool_tevent_job_done(struct tevent_context *ctx,
struct tevent_immediate *im,
void *private_data)
{
struct pthreadpool_tevent_job *job =
talloc_get_type_abort(private_data,
struct pthreadpool_tevent_job);
struct pthreadpool_tevent_job_state *state = job->state;
TALLOC_FREE(job->im);
if (state == NULL) {
/* Request already gone */
TALLOC_FREE(job);
return;
}
/*
* pthreadpool_tevent_job_cleanup()
* (called by tevent_req_done() or
* tevent_req_error()) will destroy the job.
*/
if (job->needs_fence.executed) {
tevent_req_done(state->req);
return;
}
tevent_req_error(state->req, ENOEXEC);
return;
}
static bool pthreadpool_tevent_job_cancel(struct tevent_req *req)
{
struct pthreadpool_tevent_job_state *state =
tevent_req_data(req,
struct pthreadpool_tevent_job_state);
struct pthreadpool_tevent_job *job = state->job;
size_t num;
if (job == NULL) {
return false;
}
job->needs_fence.maycancel = true;
PTHREAD_TEVENT_JOB_THREAD_FENCE(job);
if (job->needs_fence.started) {
/*
* It was too late to cancel the request.
*
* The job still has the chance to look
* at pthreadpool_tevent_current_job_canceled()
* or pthreadpool_tevent_current_job_continue()
*/
return false;
}
num = pthreadpool_cancel_job(job->pool->pool, 0,
pthreadpool_tevent_job_fn,
job);
if (num == 0) {
/*
* It was too late to cancel the request.
*/
return false;
}
/*
* It was not too late to cancel the request.
*
* We can remove job->im, as it will never be used.
*/
TALLOC_FREE(job->im);
/*
* pthreadpool_tevent_job_cleanup()
* will destroy the job.
*/
tevent_req_defer_callback(req, state->ev);
tevent_req_error(req, ECANCELED);
return true;
}
int pthreadpool_tevent_job_recv(struct tevent_req *req)
{
return tevent_req_simple_recv_unix(req);
}