X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=9768f269e503e4895cf353479aae139d503ad71f;hb=72385abda940862a920442a330fb6aa82673400f;hp=17deb88eaeb4924a6ecd7032490b438992a9cf0f;hpb=c186dfbdbd43f5b51a67812ad48e1df1eacf131e;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index 17deb88e..9768f269 100644 --- a/src/jobs.c +++ b/src/jobs.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2016, 2017 "IoT.bzh" + * Copyright (C) 2016, 2017, 2018 "IoT.bzh" * Author José Bollo * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,69 +17,79 @@ #define _GNU_SOURCE +#if defined(NO_JOBS_WATCHDOG) +# define HAS_WATCHDOG 0 +#else +# define HAS_WATCHDOG 1 +#endif + #include #include #include #include +#include #include #include #include #include #include +#include #include +#include "fdev.h" +#if HAS_WATCHDOG +#include +#endif #include "jobs.h" #include "sig-monitor.h" #include "verbose.h" -#if 0 -#define _alert_ "do you really want to remove monitoring?" -#define sig_monitor_init_timeouts() ((void)0) -#define sig_monitor_clean_timeouts() ((void)0) -#define sig_monitor(to,cb,arg) (cb(0,arg)) +#if defined(REMOVE_SYSTEMD_EVENT) +#include "fdev-epoll.h" #endif #define EVENT_TIMEOUT_TOP ((uint64_t)-1) #define EVENT_TIMEOUT_CHILD ((uint64_t)10000) /** Internal shortcut for callback */ -typedef void (*job_cb_t)(int, void*, void *, void*); +typedef void (*job_cb_t)(int, void*); /** Description of a pending job */ struct job { struct job *next; /**< link to the next job enqueued */ - void *group; /**< group of the request */ + const void *group; /**< group of the request */ job_cb_t callback; /**< processing callback */ - void *arg1; /**< first arg */ - void *arg2; /**< second arg */ - void *arg3; /**< third arg */ + void *arg; /**< argument */ int timeout; /**< timeout in second for processing the request */ unsigned blocked: 1; /**< is an other request blocking this one ? */ unsigned dropped: 1; /**< is removed ? */ }; /** Description of handled event loops */ -struct events +struct evloop { - struct events *next; - struct sd_event *event; - uint64_t timeout; - unsigned runs: 1; + unsigned state; /**< encoded state */ + int efd; /**< event notification */ + struct sd_event *sdev; /**< the systemd event loop */ + pthread_cond_t cond; /**< condition */ + struct fdev *fdev; /**< handling of events */ }; +#define EVLOOP_STATE_WAIT 1U +#define EVLOOP_STATE_RUN 2U +#define EVLOOP_STATE_LOCK 4U + /** Description of threads */ struct thread { struct thread *next; /**< next thread of the list */ struct thread *upper; /**< upper same thread */ struct job *job; /**< currently processed job */ - struct events *events; /**< currently processed job */ pthread_t tid; /**< the thread id */ - unsigned stop: 1; /**< stop requested */ - unsigned lowered: 1; /**< has a lower same thread */ - unsigned waits: 1; /**< is waiting? */ + volatile unsigned stop: 1; /**< stop requested */ + volatile unsigned waits: 1; /**< is waiting? */ }; /** @@ -87,47 +97,56 @@ struct thread */ struct sync { - void (*callback)(int, void*); /**< the synchrnous callback */ - void *arg; /**< the argument of the callback */ + struct thread thread; /**< thread loop data */ + union { + void (*callback)(int, void*); /**< the synchronous callback */ + void (*enter)(int signum, void *closure, struct jobloop *jobloop); + /**< the entering synchronous routine */ + }; + void *arg; /**< the argument of the callback */ }; + /* synchronisation of threads */ static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; -/* count allowed, started and waiting threads */ +/* count allowed, started and running threads */ static int allowed = 0; /** allowed count of threads */ static int started = 0; /** started count of threads */ -static int waiting = 0; /** waiting count of threads */ +static int running = 0; /** running count of threads */ static int remains = 0; /** allowed count of waiting jobs */ -static int nevents = 0; /** count of events */ /* list of threads */ static struct thread *threads; -static _Thread_local struct thread *current; +static _Thread_local struct thread *current_thread; +static _Thread_local struct evloop *current_evloop; /* queue of pending jobs */ static struct job *first_job; -static struct events *first_events; static struct job *free_jobs; +/* event loop */ +static struct evloop evloop[1]; + +#if defined(REMOVE_SYSTEMD_EVENT) +static struct fdev_epoll *fdevepoll; +static int waitevt; +#endif + /** * Create a new job with the given parameters * @param group the group of the job * @param timeout the timeout of the job (0 if none) * @param callback the function that achieves the job - * @param arg1 the first argument of the callback - * @param arg2 the second argument of the callback - * @param arg3 the third argument of the callback + * @param arg the argument of the callback * @return the created job unblock or NULL when no more memory */ static struct job *job_create( - void *group, + const void *group, int timeout, job_cb_t callback, - void *arg1, - void *arg2, - void *arg3) + void *arg) { struct job *job; @@ -136,12 +155,12 @@ static struct job *job_create( if (job) free_jobs = job->next; else { - /* allocation without blocking */ + /* allocation without blocking */ pthread_mutex_unlock(&mutex); job = malloc(sizeof *job); pthread_mutex_lock(&mutex); if (!job) { - errno = -ENOMEM; + errno = ENOMEM; goto end; } } @@ -149,9 +168,7 @@ static struct job *job_create( job->group = group; job->timeout = timeout; job->callback = callback; - job->arg1 = arg1; - job->arg2 = arg2; - job->arg3 = arg3; + job->arg = arg; job->blocked = 0; job->dropped = 0; end: @@ -165,7 +182,7 @@ end: */ static void job_add(struct job *job) { - void *group; + const void *group; struct job *ijob, **pjob; /* prepare to add */ @@ -198,18 +215,6 @@ static inline struct job *job_get() return job; } -/** - * Get the next events to process or NULL if none. - * @return the first events that isn't running or NULL - */ -static inline struct events *events_get() -{ - struct events *events = first_events; - while (events && events->runs) - events = events->next; - return events; -} - /** * Releases the processed 'job': removes it * from the list of jobs and unblock the first @@ -219,7 +224,7 @@ static inline struct events *events_get() static inline void job_release(struct job *job) { struct job *ijob, **pjob; - void *group; + const void *group; /* first unqueue the job */ pjob = &first_job; @@ -246,35 +251,37 @@ static inline void job_release(struct job *job) } /** - * Monitored normal callback for a job. + * Monitored cancel callback for a job. * This function is called by the monitor - * to run the job when the safe environment + * to cancel the job when the safe environment * is set. * @param signum 0 on normal flow or the number * of the signal that interrupted the normal - * flow - * @param arg the job to run + * flow, isn't used + * @param arg the job to run */ -static void job_call(int signum, void *arg) +static void job_cancel(int signum, void *arg) { struct job *job = arg; - job->callback(signum, job->arg1, job->arg2, job->arg3); + job->callback(SIGABRT, job->arg); } +#if defined(REMOVE_SYSTEMD_EVENT) /** - * Monitored cancel callback for a job. - * This function is called by the monitor - * to cancel the job when the safe environment - * is set. - * @param signum 0 on normal flow or the number - * of the signal that interrupted the normal - * flow, isn't used - * @param arg the job to run + * Gets a fdev_epoll item. + * @return a fdev_epoll or NULL in case of error */ -static void job_cancel(int signum, void *arg) +static struct fdev_epoll *get_fdevepoll() { - job_call(SIGABRT, arg); + struct fdev_epoll *result; + + result = fdevepoll; + if (!result) + result = fdevepoll = fdev_epoll_create(); + + return result; } +#endif /** * Monitored normal callback for events. @@ -286,12 +293,60 @@ static void job_cancel(int signum, void *arg) * flow * @param arg the events to run */ -static void events_call(int signum, void *arg) +static void evloop_run(int signum, void *arg) +{ + int rc; + struct sd_event *se; + struct evloop *el = arg; + + if (!signum) { + current_evloop = el; + __atomic_store_n(&el->state, EVLOOP_STATE_LOCK|EVLOOP_STATE_RUN|EVLOOP_STATE_WAIT, __ATOMIC_RELAXED); + se = el->sdev; + rc = sd_event_prepare(se); + if (rc < 0) { + errno = -rc; + CRITICAL("sd_event_prepare returned an error (state: %d): %m", sd_event_get_state(se)); + abort(); + } else { + if (rc == 0) { + rc = sd_event_wait(se, (uint64_t)(int64_t)-1); + if (rc < 0) { + errno = -rc; + ERROR("sd_event_wait returned an error (state: %d): %m", sd_event_get_state(se)); + } + } + __atomic_and_fetch(&el->state, ~(EVLOOP_STATE_WAIT), __ATOMIC_RELAXED); + + if (rc > 0) { + rc = sd_event_dispatch(se); + if (rc < 0) { + errno = -rc; + ERROR("sd_event_dispatch returned an error (state: %d): %m", sd_event_get_state(se)); + } + } + } + } + __atomic_and_fetch(&el->state, ~(EVLOOP_STATE_WAIT|EVLOOP_STATE_RUN), __ATOMIC_RELAXED); +} + + +#if defined(REMOVE_SYSTEMD_EVENT) +/** + * Monitored normal loop for waiting events. + * @param signum 0 on normal flow or the number + * of the signal that interrupted the normal + * flow + * @param arg the events to run + */ +static void monitored_wait_and_dispatch(int signum, void *arg) { - struct events *events = arg; - if (!signum) - sd_event_run(events->event, events->timeout); + struct fdev_epoll *fdev_epoll = arg; + if (!signum) { + fdev_epoll_wait_and_dispatch(fdev_epoll, -1); + } } +#endif /** * Main processing loop of threads processing jobs. @@ -304,34 +359,33 @@ static void thread_run(volatile struct thread *me) { struct thread **prv; struct job *job; - struct events *events; - uint64_t evto; +#if !defined(REMOVE_SYSTEMD_EVENT) + struct evloop *el; +#endif /* initialize description of itself and link it in the list */ me->tid = pthread_self(); me->stop = 0; - me->lowered = 0; me->waits = 0; - me->upper = current; - if (current) { - current->lowered = 1; - evto = EVENT_TIMEOUT_CHILD; - } else { + me->upper = current_thread; + if (!current_thread) { started++; sig_monitor_init_timeouts(); - evto = EVENT_TIMEOUT_TOP; } me->next = threads; threads = (struct thread*)me; - current = (struct thread*)me; - - NOTICE("job thread starting %d(/%d) %s", started, allowed, me->upper ? "child" : "parent"); + current_thread = (struct thread*)me; /* loop until stopped */ - me->events = NULL; while (!me->stop) { + /* release the event loop */ + if (current_evloop) { + __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + current_evloop = NULL; + } + /* get a job */ - job = job_get(first_job); + job = job_get(); if (job) { /* prepare running the job */ remains++; /* increases count of job that can wait */ @@ -340,52 +394,66 @@ static void thread_run(volatile struct thread *me) /* run the job */ pthread_mutex_unlock(&mutex); - sig_monitor(job->timeout, job_call, job); + sig_monitor(job->timeout, job->callback, job->arg); pthread_mutex_lock(&mutex); /* release the run job */ job_release(job); - - /* release event if any */ - events = me->events; - if (events) { - events->runs = 0; - me->events = NULL; - } +#if !defined(REMOVE_SYSTEMD_EVENT) } else { /* no job, check events */ - events = events_get(); - if (events) { + el = &evloop[0]; + if (el->sdev && !__atomic_load_n(&el->state, __ATOMIC_RELAXED)) { /* run the events */ - events->runs = 1; - events->timeout = evto; - me->events = events; + __atomic_store_n(&el->state, EVLOOP_STATE_LOCK|EVLOOP_STATE_RUN|EVLOOP_STATE_WAIT, __ATOMIC_RELAXED); + current_evloop = el; pthread_mutex_unlock(&mutex); - sig_monitor(0, events_call, events); + sig_monitor(0, evloop_run, el); pthread_mutex_lock(&mutex); - events->runs = 0; - me->events = NULL; } else { /* no job and not events */ - waiting++; + running--; + if (!running) + ERROR("Entering job deep sleep! Check your bindings."); me->waits = 1; pthread_cond_wait(&cond, &mutex); me->waits = 0; - waiting--; + running++; } +#else + } else if (waitevt) { + /* no job and not events */ + running--; + if (!running) + ERROR("Entering job deep sleep! Check your bindings."); + me->waits = 1; + pthread_cond_wait(&cond, &mutex); + me->waits = 0; + running++; + } else { + /* wait for events */ + waitevt = 1; + pthread_mutex_unlock(&mutex); + sig_monitor(0, monitored_wait_and_dispatch, get_fdevepoll()); + pthread_mutex_lock(&mutex); + waitevt = 0; +#endif } } - NOTICE("job thread stoping %d(/%d) %s", started, allowed, me->upper ? "child" : "parent"); + + /* release the event loop */ + if (current_evloop) { + __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + current_evloop = NULL; + } /* unlink the current thread and cleanup */ prv = &threads; while (*prv != me) prv = &(*prv)->next; *prv = me->next; - current = me->upper; - if (current) { - current->lowered = 0; - } else { + current_thread = me->upper; + if (!current_thread) { sig_monitor_clean_timeouts(); started--; } @@ -401,7 +469,9 @@ static void *thread_main(void *data) struct thread me; pthread_mutex_lock(&mutex); + running++; thread_run(&me); + running--; pthread_mutex_unlock(&mutex); return NULL; } @@ -425,29 +495,7 @@ static int start_one_thread() } /** - * Queues a new asynchronous job represented by 'callback' - * for the 'group' and the 'timeout'. - * Jobs are queued FIFO and are possibly executed in parallel - * concurrently except for job of the same group that are - * executed sequentially in FIFO order. - * @param group The group of the job or NULL when no group. - * @param timeout The maximum execution time in seconds of the job - * or 0 for unlimited time. - * @param callback The function to execute for achieving the job. - * Its first parameter is either 0 on normal flow - * or the signal number that broke the normal flow. - * @return 0 in case of success or -1 in case of error - */ -int jobs_queue0( - void *group, - int timeout, - void (*callback)(int signum)) -{ - return jobs_queue3(group, timeout, (job_cb_t)callback, NULL, NULL, NULL); -} - -/** - * Queues a new asynchronous job represented by 'callback' and 'arg1' + * Queues a new asynchronous job represented by 'callback' and 'arg' * for the 'group' and the 'timeout'. * Jobs are queued FIFO and are possibly executed in parallel * concurrently except for job of the same group that are @@ -464,68 +512,10 @@ int jobs_queue0( * @return 0 in case of success or -1 in case of error */ int jobs_queue( - void *group, + const void *group, int timeout, void (*callback)(int, void*), void *arg) -{ - return jobs_queue3(group, timeout, (job_cb_t)callback, arg, NULL, NULL); -} - -/** - * Queues a new asynchronous job represented by 'callback' and 'arg[12]' - * for the 'group' and the 'timeout'. - * Jobs are queued FIFO and are possibly executed in parallel - * concurrently except for job of the same group that are - * executed sequentially in FIFO order. - * @param group The group of the job or NULL when no group. - * @param timeout The maximum execution time in seconds of the job - * or 0 for unlimited time. - * @param callback The function to execute for achieving the job. - * Its first parameter is either 0 on normal flow - * or the signal number that broke the normal flow. - * The remaining parameters are the parameters 'arg[12]' - * given here. - * @param arg1 The second argument for 'callback' - * @param arg2 The third argument for 'callback' - * @return 0 in case of success or -1 in case of error - */ -int jobs_queue2( - void *group, - int timeout, - void (*callback)(int, void*, void*), - void *arg1, - void *arg2) -{ - return jobs_queue3(group, timeout, (job_cb_t)callback, arg1, arg2, NULL); -} - -/** - * Queues a new asynchronous job represented by 'callback' and 'arg[123]' - * for the 'group' and the 'timeout'. - * Jobs are queued FIFO and are possibly executed in parallel - * concurrently except for job of the same group that are - * executed sequentially in FIFO order. - * @param group The group of the job or NULL when no group. - * @param timeout The maximum execution time in seconds of the job - * or 0 for unlimited time. - * @param callback The function to execute for achieving the job. - * Its first parameter is either 0 on normal flow - * or the signal number that broke the normal flow. - * The remaining parameters are the parameters 'arg[123]' - * given here. - * @param arg1 The second argument for 'callback' - * @param arg2 The third argument for 'callback' - * @param arg3 The forth argument for 'callback' - * @return 0 in case of success or -1 in case of error - */ -int jobs_queue3( - void *group, - int timeout, - void (*callback)(int, void*, void *, void*), - void *arg1, - void *arg2, - void *arg3) { const char *info; struct job *job; @@ -534,7 +524,7 @@ int jobs_queue3( pthread_mutex_lock(&mutex); /* allocates the job */ - job = job_create(group, timeout, callback, arg1, arg2, arg3); + job = job_create(group, timeout, callback, arg); if (!job) { errno = ENOMEM; info = "out of memory"; @@ -549,7 +539,7 @@ int jobs_queue3( } /* start a thread if needed */ - if (waiting == 0 && started < allowed) { + if (running == started && started < allowed) { /* all threads are busy and a new can be started */ rc = start_one_thread(); if (rc < 0 && started == 0) { @@ -577,35 +567,45 @@ error: } /** - * Enter a synchronisation point: activates the job given by 'callback' - * and 'closure' using 'group' and 'timeout' to control sequencing and - * execution time. - * @param group the group for sequencing jobs - * @param timeout the time in seconds allocated to the job - * @param callback the callback that will handle the job. - * it receives 3 parameters: 'signum' that will be 0 - * on normal flow or the catched signal number in case - * of interrupted flow, the context 'closure' as given and - * a 'jobloop' reference that must be used when the job is - * terminated to unlock the current execution flow. - * @param closure the context completion closure for the callback - * @return 0 on success or -1 in case of error + * Internal helper function for 'jobs_enter'. + * @see jobs_enter, jobs_leave */ -int jobs_enter( - void *group, +static void enter_cb(int signum, void *closure) +{ + struct sync *sync = closure; + sync->enter(signum, sync->arg, (void*)&sync->thread); +} + +/** + * Internal helper function for 'jobs_call'. + * @see jobs_call + */ +static void call_cb(int signum, void *closure) +{ + struct sync *sync = closure; + sync->callback(signum, sync->arg); + jobs_leave((void*)&sync->thread); +} + +/** + * Internal helper for synchronous jobs. It enters + * a new thread loop for evaluating the given job + * as recorded by the couple 'sync_cb' and 'sync'. + * @see jobs_call, jobs_enter, jobs_leave + */ +static int do_sync( + const void *group, int timeout, - void (*callback)(int signum, void *closure, struct jobloop *jobloop), - void *closure + void (*sync_cb)(int signum, void *closure), + struct sync *sync ) { - struct job *job; - struct thread me; pthread_mutex_lock(&mutex); /* allocates the job */ - job = job_create(group, timeout, (job_cb_t)callback, closure, &me, NULL); + job = job_create(group, timeout, sync_cb, sync); if (!job) { ERROR("out of memory"); errno = ENOMEM; @@ -617,11 +617,40 @@ int jobs_enter( job_add(job); /* run until stopped */ - thread_run(&me); + thread_run(&sync->thread); pthread_mutex_unlock(&mutex); return 0; } +/** + * Enter a synchronisation point: activates the job given by 'callback' + * and 'closure' using 'group' and 'timeout' to control sequencing and + * execution time. + * @param group the group for sequencing jobs + * @param timeout the time in seconds allocated to the job + * @param callback the callback that will handle the job. + * it receives 3 parameters: 'signum' that will be 0 + * on normal flow or the catched signal number in case + * of interrupted flow, the context 'closure' as given and + * a 'jobloop' reference that must be used when the job is + * terminated to unlock the current execution flow. + * @param closure the argument to the callback + * @return 0 on success or -1 in case of error + */ +int jobs_enter( + const void *group, + int timeout, + void (*callback)(int signum, void *closure, struct jobloop *jobloop), + void *closure +) +{ + struct sync sync; + + sync.enter = callback; + sync.arg = closure; + return do_sync(group, timeout, enter_cb, &sync); +} + /** * Unlocks the execution flow designed by 'jobloop'. * @param jobloop indication of the flow to unlock @@ -646,17 +675,6 @@ int jobs_leave(struct jobloop *jobloop) return -!t; } -/** - * Internal helper function for 'jobs_call'. - * @see jobs_call, jobs_enter, jobs_leave - */ -static void call_cb(int signum, void *closure, struct jobloop *jobloop) -{ - struct sync *sync = closure; - sync->callback(signum, sync->arg); - jobs_leave(jobloop); -} - /** * Calls synchronously the job represented by 'callback' and 'arg1' * for the 'group' and the 'timeout' and waits for its completion. @@ -672,7 +690,7 @@ static void call_cb(int signum, void *closure, struct jobloop *jobloop) * @return 0 in case of success or -1 in case of error */ int jobs_call( - void *group, + const void *group, int timeout, void (*callback)(int, void*), void *arg) @@ -681,76 +699,145 @@ int jobs_call( sync.callback = callback; sync.arg = arg; - return jobs_enter(group, timeout, call_cb, &sync); + + return do_sync(group, timeout, call_cb, &sync); +} + +/** + * Internal callback for evloop management. + * The effect of this function is hidden: it exits + * the waiting poll if any. Then it wakes up a thread + * awaiting the evloop using signal. + */ +static int on_evloop_efd(sd_event_source *s, int fd, uint32_t revents, void *userdata) +{ + uint64_t x; + struct evloop *evloop = userdata; + read(evloop->efd, &x, sizeof x); + pthread_mutex_lock(&mutex); + pthread_cond_broadcast(&evloop->cond); + pthread_mutex_unlock(&mutex); + return 1; +} + +/* temporary hack */ +#if !defined(REMOVE_SYSTEMD_EVENT) +__attribute__((unused)) +#endif +static void evloop_callback(void *arg, uint32_t event, struct fdev *fdev) +{ + sig_monitor(0, evloop_run, arg); } /** * Gets a sd_event item for the current thread. * @return a sd_event or NULL in case of error */ -struct sd_event *jobs_get_sd_event() +static struct sd_event *get_sd_event_locked() { - struct events *events; - struct thread *me; + struct evloop *el; + uint64_t x; int rc; - pthread_mutex_lock(&mutex); - - /* search events on stack */ - me = current; - while (me && !me->events) - me = me->upper; - if (me) - /* return the stacked events */ - events = me->events; - else { - /* search an available events */ - events = events_get(); - if (!events) { - /* not found, check if creation possible */ - if (nevents >= allowed) { - ERROR("not possible to add a new event"); - events = NULL; - } else { - events = malloc(sizeof *events); - if (events && (rc = sd_event_new(&events->event)) >= 0) { - if (nevents < started || start_one_thread() >= 0) { - events->runs = 0; - events->next = first_events; - first_events = events; - } else { - ERROR("can't start thread for events"); - sd_event_unref(events->event); - free(events); - events = NULL; - } - } else { - if (!events) { - ERROR("out of memory"); - errno = ENOMEM; - } else { - free(events); - ERROR("creation of sd_event failed: %m"); - events = NULL; - errno = -rc; - } - } - } + /* creates the evloop on need */ + el = &evloop[0]; + if (!el->sdev) { + /* start the creation */ + el->state = 0; + /* creates the eventfd for waking up polls */ + el->efd = eventfd(0, EFD_CLOEXEC); + if (el->efd < 0) { + ERROR("can't make eventfd for events"); + goto error1; } - if (events) { - /* */ - me = current; - if (me) { - events->runs = 1; - me->events = events; - } else { - WARNING("event returned for unknown thread!"); - } + /* create the systemd event loop */ + rc = sd_event_new(&el->sdev); + if (rc < 0) { + ERROR("can't make new event loop"); + goto error2; } + /* put the eventfd in the event loop */ + rc = sd_event_add_io(el->sdev, NULL, el->efd, EPOLLIN, on_evloop_efd, el); + if (rc < 0) { + ERROR("can't register eventfd"); +#if !defined(REMOVE_SYSTEMD_EVENT) + sd_event_unref(el->sdev); + el->sdev = NULL; +error2: + close(el->efd); +error1: + return NULL; + } +#else + goto error3; + } + /* handle the event loop */ + el->fdev = fdev_epoll_add(get_fdevepoll(), sd_event_get_fd(el->sdev)); + if (!el->fdev) { + ERROR("can't create fdev"); +error3: + sd_event_unref(el->sdev); +error2: + close(el->efd); +error1: + memset(el, 0, sizeof *el); + return NULL; + } + fdev_set_autoclose(el->fdev, 0); + fdev_set_events(el->fdev, EPOLLIN); + fdev_set_callback(el->fdev, evloop_callback, el); +#endif } + + /* attach the event loop to the current thread */ + if (current_evloop != el) { + if (current_evloop) + __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + current_evloop = el; + __atomic_or_fetch(&el->state, EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + } + + /* wait for a modifiable event loop */ + while (__atomic_load_n(&el->state, __ATOMIC_RELAXED) & EVLOOP_STATE_WAIT) { + x = 1; + write(el->efd, &x, sizeof x); + pthread_cond_wait(&el->cond, &mutex); + } + + return el->sdev; +} + +/** + * Gets a sd_event item for the current thread. + * @return a sd_event or NULL in case of error + */ +struct sd_event *jobs_get_sd_event() +{ + struct sd_event *result; + + pthread_mutex_lock(&mutex); + result = get_sd_event_locked(); + pthread_mutex_unlock(&mutex); + + return result; +} + +#if defined(REMOVE_SYSTEMD_EVENT) +/** + * Gets the fdev_epoll item. + * @return a fdev_epoll or NULL in case of error + */ +struct fdev_epoll *jobs_get_fdev_epoll() +{ + struct fdev_epoll *result; + + pthread_mutex_lock(&mutex); + result = get_fdevepoll(); pthread_mutex_unlock(&mutex); - return events ? events->event : NULL; + + return result; } +#endif /** * Enter the jobs processing loop. @@ -760,7 +847,7 @@ struct sd_event *jobs_get_sd_event() * @param start The start routine to activate (can't be NULL) * @return 0 in case of success or -1 in case of error. */ -int jobs_start(int allowed_count, int start_count, int waiter_count, void (*start)()) +int jobs_start(int allowed_count, int start_count, int waiter_count, void (*start)(int signum, void* arg), void *arg) { int rc, launched; struct thread me; @@ -775,24 +862,24 @@ int jobs_start(int allowed_count, int start_count, int waiter_count, void (*star pthread_mutex_lock(&mutex); /* check whether already running */ - if (current || allowed) { + if (current_thread || allowed) { ERROR("thread already started"); errno = EINVAL; goto error; } - /* start */ - if (sig_monitor_init() < 0) { - ERROR("failed to initialise signal handlers"); - goto error; - } - /* records the allowed count */ allowed = allowed_count; started = 0; - waiting = 0; + running = 0; remains = waiter_count; +#if HAS_WATCHDOG + /* set the watchdog */ + if (sd_watchdog_enabled(0, NULL)) + sd_event_set_watchdog(get_sd_event_locked(), 1); +#endif + /* start at least one thread */ launched = 0; while ((launched + 1) < start_count) { @@ -804,7 +891,7 @@ int jobs_start(int allowed_count, int start_count, int waiter_count, void (*star } /* queue the start job */ - job = job_create(NULL, 0, (job_cb_t)start, NULL, NULL, NULL); + job = job_create(NULL, 0, start, arg); if (!job) { ERROR("out of memory"); errno = ENOMEM; @@ -882,7 +969,7 @@ void jobs_terminate() head = job->next; /* search if job is stacked for current */ - t = current; + t = current_thread; while (t && t->job != job) t = t->upper; if (t) {