X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=417f7eac1fab792720c9e1a9acba6f1a19436ba1;hb=e9c6530ee21bb3345741044e8bf87fc6a73252e9;hp=9c81700a54f84535a3b6900ca54488603c353ae3;hpb=cab05ba72abeb335b456b0820e053c94b91986e7;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index 9c81700a..417f7eac 100644 --- a/src/jobs.c +++ b/src/jobs.c @@ -42,20 +42,18 @@ #endif #include "jobs.h" -#include "fdev-epoll.h" #include "sig-monitor.h" #include "verbose.h" -#if 0 -#define _alert_ "do you really want to remove signal 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) +struct thread; + /** Internal shortcut for callback */ typedef void (*job_cb_t)(int, void*); @@ -77,27 +75,28 @@ struct evloop 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 */ + struct thread *holder; /**< holder of the evloop */ }; #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 thread *nholder;/**< next holder for evloop */ + pthread_cond_t *cwhold;/**< condition wait for holding */ struct job *job; /**< currently processed job */ pthread_t tid; /**< the thread id */ - unsigned stop: 1; /**< stop requested */ - unsigned waits: 1; /**< is waiting? */ + volatile unsigned stop: 1; /**< stop requested */ + volatile unsigned waits: 1; /**< is waiting? */ }; /** - * Description of synchonous callback + * Description of synchronous callback */ struct sync { @@ -124,16 +123,18 @@ static int remains = 0; /** allowed count of waiting jobs */ /* list of threads */ static struct thread *threads; 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 job *free_jobs; /* event loop */ -static struct evloop evloop[1]; +static struct evloop evloop; + +#if defined(REMOVE_SYSTEMD_EVENT) static struct fdev_epoll *fdevepoll; static int waitevt; +#endif /** * Create a new job with the given parameters @@ -161,7 +162,7 @@ static struct job *job_create( job = malloc(sizeof *job); pthread_mutex_lock(&mutex); if (!job) { - errno = -ENOMEM; + errno = ENOMEM; goto end; } } @@ -267,6 +268,7 @@ static void job_cancel(int signum, void *arg) job->callback(SIGABRT, job->arg); } +#if defined(REMOVE_SYSTEMD_EVENT) /** * Gets a fdev_epoll item. * @return a fdev_epoll or NULL in case of error @@ -281,6 +283,7 @@ static struct fdev_epoll *get_fdevepoll() return result; } +#endif /** * Monitored normal callback for events. @@ -296,16 +299,14 @@ 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; + se = evloop.sdev; rc = sd_event_prepare(se); if (rc < 0) { errno = -rc; - ERROR("sd_event_prepare returned an error (state: %d): %m", sd_event_get_state(se)); + 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); @@ -314,8 +315,7 @@ static void evloop_run(int signum, void *arg) 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); - + evloop.state = EVLOOP_STATE_RUN; if (rc > 0) { rc = sd_event_dispatch(se); if (rc < 0) { @@ -325,10 +325,95 @@ static void evloop_run(int signum, void *arg) } } } - __atomic_and_fetch(&el->state, ~(EVLOOP_STATE_WAIT|EVLOOP_STATE_RUN), __ATOMIC_RELAXED); } +/** + * Internal callback for evloop management. + * The effect of this function is hidden: it exits + * the waiting poll if any. + */ +static void evloop_on_efd_event() +{ + uint64_t x; + read(evloop.efd, &x, sizeof x); +} + +/** + * wakeup the event loop if needed by sending + * an event. + */ +static void evloop_wakeup() +{ + uint64_t x; + + if (evloop.state & EVLOOP_STATE_WAIT) { + x = 1; + write(evloop.efd, &x, sizeof x); + } +} +/** + * Release the currently held event loop + */ +static void evloop_release() +{ + struct thread *nh, *ct = current_thread; + + if (evloop.holder == ct) { + nh = ct->nholder; + evloop.holder = nh; + if (nh) + pthread_cond_signal(nh->cwhold); + } +} + +/** + * get the eventloop for the current thread + */ +static int evloop_get() +{ + struct thread *ct = current_thread; + + if (evloop.holder) + return evloop.holder == ct; + + ct->nholder = NULL; + evloop.holder = ct; + return 1; +} + +/** + * acquire the eventloop for the current thread + */ +static void evloop_acquire() +{ + struct thread **pwait, *ct; + pthread_cond_t cond; + + /* try to get the evloop */ + if (!evloop_get()) { + /* failed, init waiting state */ + ct = current_thread; + ct->nholder = NULL; + ct->cwhold = &cond; + pthread_cond_init(&cond, NULL); + + /* queue current thread in holder list */ + pwait = &evloop.holder; + while (*pwait) + pwait = &(*pwait)->nholder; + *pwait = ct; + + /* wake up the evloop */ + evloop_wakeup(); + + /* wait to acquire the evloop */ + pthread_cond_wait(&cond, &mutex); + pthread_cond_destroy(&cond); + } +} + +#if defined(REMOVE_SYSTEMD_EVENT) /** * Monitored normal loop for waiting events. * @param signum 0 on normal flow or the number @@ -343,6 +428,7 @@ static void monitored_wait_and_dispatch(int signum, void *arg) fdev_epoll_wait_and_dispatch(fdev_epoll, -1); } } +#endif /** * Main processing loop of threads processing jobs. @@ -371,14 +457,11 @@ static void thread_run(volatile struct thread *me) /* loop until stopped */ while (!me->stop) { - /* release the event loop */ - if (current_evloop) { - __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); - current_evloop = NULL; - } + /* release the current event loop */ + evloop_release(); /* 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 */ @@ -392,6 +475,33 @@ static void thread_run(volatile struct thread *me) /* release the run job */ job_release(job); +#if !defined(REMOVE_SYSTEMD_EVENT) + + + + /* no job, check event loop wait */ + } else if (evloop_get()) { + if (evloop.state != 0) { + /* busy ? */ + CRITICAL("Can't enter dispatch while in dispatch!"); + abort(); + } + /* run the events */ + evloop.state = EVLOOP_STATE_RUN|EVLOOP_STATE_WAIT; + pthread_mutex_unlock(&mutex); + sig_monitor(0, evloop_run, NULL); + pthread_mutex_lock(&mutex); + evloop.state = 0; + } else { + /* no job and no event loop */ + running--; + if (!running) + ERROR("Entering job deep sleep! Check your bindings."); + me->waits = 1; + pthread_cond_wait(&cond, &mutex); + me->waits = 0; + running++; +#else } else if (waitevt) { /* no job and not events */ running--; @@ -408,14 +518,12 @@ static void thread_run(volatile struct thread *me) sig_monitor(0, monitored_wait_and_dispatch, get_fdevepoll()); pthread_mutex_lock(&mutex); waitevt = 0; +#endif } } /* release the event loop */ - if (current_evloop) { - __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); - current_evloop = NULL; - } + evloop_release(); /* unlink the current thread and cleanup */ prv = &threads; @@ -604,7 +712,7 @@ static int do_sync( * 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 arg the argument to the callback + * @param closure the argument to the callback * @return 0 on success or -1 in case of error */ int jobs_enter( @@ -640,6 +748,8 @@ int jobs_leave(struct jobloop *jobloop) t->stop = 1; if (t->waits) pthread_cond_broadcast(&cond); + else + evloop_wakeup(); } pthread_mutex_unlock(&mutex); return -!t; @@ -681,16 +791,14 @@ int jobs_call( */ 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); + evloop_on_efd_event(); 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); @@ -702,66 +810,61 @@ static void evloop_callback(void *arg, uint32_t event, struct fdev *fdev) */ static struct sd_event *get_sd_event_locked() { - struct evloop *el; - uint64_t x; int rc; /* creates the evloop on need */ - el = &evloop[0]; - if (!el->sdev) { + if (!evloop.sdev) { /* start the creation */ - el->state = 0; + evloop.state = 0; /* creates the eventfd for waking up polls */ - el->efd = eventfd(0, EFD_CLOEXEC); - if (el->efd < 0) { + evloop.efd = eventfd(0, EFD_CLOEXEC|EFD_SEMAPHORE); + if (evloop.efd < 0) { ERROR("can't make eventfd for events"); goto error1; } /* create the systemd event loop */ - rc = sd_event_new(&el->sdev); + rc = sd_event_new(&evloop.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); + rc = sd_event_add_io(evloop.sdev, NULL, evloop.efd, EPOLLIN, on_evloop_efd, NULL); if (rc < 0) { ERROR("can't register eventfd"); +#if !defined(REMOVE_SYSTEMD_EVENT) + sd_event_unref(evloop.sdev); + evloop.sdev = NULL; +error2: + close(evloop.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) { + evloop.fdev = fdev_epoll_add(get_fdevepoll(), sd_event_get_fd(evloop.sdev)); + if (!evloop.fdev) { ERROR("can't create fdev"); error3: - sd_event_unref(el->sdev); + sd_event_unref(evloop.sdev); error2: - close(el->efd); + close(evloop.efd); error1: - memset(el, 0, sizeof *el); + memset(&evloop, 0, sizeof evloop); return NULL; } - fdev_set_autoclose(el->fdev, 0); - fdev_set_events(el->fdev, EPOLLIN); - fdev_set_callback(el->fdev, evloop_callback, el); - } - - /* 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); + fdev_set_autoclose(evloop.fdev, 0); + fdev_set_events(evloop.fdev, EPOLLIN); + fdev_set_callback(evloop.fdev, evloop_callback, NULL); +#endif } - /* 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); - } + /* acquire the event loop */ + evloop_acquire(); - return el->sdev; + return evloop.sdev; } /** @@ -771,14 +874,40 @@ error1: struct sd_event *jobs_get_sd_event() { struct sd_event *result; + struct thread lt; + /* ensure an existing thread environment */ + if (!current_thread) { + memset(<, 0, sizeof lt); + current_thread = < + } + + /* process */ pthread_mutex_lock(&mutex); result = get_sd_event_locked(); pthread_mutex_unlock(&mutex); + /* release the faked thread environment if needed */ + if (current_thread == <) { + /* + * Releasing it is needed because there is no way to guess + * when it has to be released really. But here is where it is + * hazardous: if the caller modifies the eventloop when it + * is waiting, there is no way to make the change effective. + * A workaround to achieve that goal is for the caller to + * require the event loop a second time after having modified it. + */ + NOTICE("Requiring sd_event loop out of binder callbacks is hazardous!"); + if (verbose_wants(Log_Level_Info)) + sig_monitor_dumpstack(); + evloop_release(); + current_thread = NULL; + } + return result; } +#if defined(REMOVE_SYSTEMD_EVENT) /** * Gets the fdev_epoll item. * @return a fdev_epoll or NULL in case of error @@ -793,6 +922,7 @@ struct fdev_epoll *jobs_get_fdev_epoll() return result; } +#endif /** * Enter the jobs processing loop. @@ -823,12 +953,6 @@ int jobs_start(int allowed_count, int start_count, int waiter_count, void (*star 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; @@ -862,7 +986,9 @@ int jobs_start(int allowed_count, int start_count, int waiter_count, void (*star remains--; /* run until end */ + running++; thread_run(&me); + running--; rc = 0; error: pthread_mutex_unlock(&mutex);