X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=f2c9d52be375cf756ab904b4debce1e08db53f4b;hb=e84fc44c47b42651fef17405f5bc09e5079d4a72;hp=4b4472e54c0d801db1383d6d00202c209c1d5837;hpb=c3249e6aa03ef10494a2a4a170bbed0cfc38a83e;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index 4b4472e5..f2c9d52b 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,10 +17,17 @@ #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 @@ -29,7 +36,8 @@ #include #include -#ifndef NO_JOBS_WATCHDOG +#include "fdev.h" +#if HAS_WATCHDOG #include #endif @@ -37,16 +45,15 @@ #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) +struct thread; + /** Internal shortcut for callback */ typedef void (*job_cb_t)(int, void*); @@ -69,6 +76,8 @@ struct evloop 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 @@ -82,8 +91,8 @@ struct thread struct thread *upper; /**< upper same thread */ 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? */ }; /** @@ -123,6 +132,11 @@ 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 @@ -144,12 +158,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; } } @@ -255,6 +269,23 @@ 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 + */ +static struct fdev_epoll *get_fdevepoll() +{ + struct fdev_epoll *result; + + result = fdevepoll; + if (!result) + result = fdevepoll = fdev_epoll_create(); + + return result; +} +#endif + /** * Monitored normal callback for events. * This function is called by the monitor @@ -272,11 +303,15 @@ static void evloop_run(int signum, void *arg) 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); + __atomic_store_n(&el->holder, current_thread, __ATOMIC_RELAXED); se = el->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); @@ -300,6 +335,23 @@ static void evloop_run(int signum, void *arg) } +#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 fdev_epoll *fdev_epoll = arg; + if (!signum) { + fdev_epoll_wait_and_dispatch(fdev_epoll, -1); + } +} +#endif + /** * Main processing loop of threads processing jobs. * The loop must be called with the mutex locked @@ -311,7 +363,9 @@ static void thread_run(volatile struct thread *me) { struct thread **prv; struct job *job; +#if !defined(REMOVE_SYSTEMD_EVENT) struct evloop *el; +#endif /* initialize description of itself and link it in the list */ me->tid = pthread_self(); @@ -330,12 +384,13 @@ static void thread_run(volatile struct thread *me) while (!me->stop) { /* release the event loop */ if (current_evloop) { - __atomic_sub_fetch(¤t_evloop->state, EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_store_n(¤t_evloop->holder, NULL, __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 */ @@ -349,12 +404,14 @@ static void thread_run(volatile struct thread *me) /* release the run job */ job_release(job); +#if !defined(REMOVE_SYSTEMD_EVENT) } else { /* no job, check events */ el = &evloop[0]; if (el->sdev && !__atomic_load_n(&el->state, __ATOMIC_RELAXED)) { /* run the events */ __atomic_store_n(&el->state, EVLOOP_STATE_LOCK|EVLOOP_STATE_RUN|EVLOOP_STATE_WAIT, __ATOMIC_RELAXED); + __atomic_store_n(&el->holder, me, __ATOMIC_RELAXED); current_evloop = el; pthread_mutex_unlock(&mutex); sig_monitor(0, evloop_run, el); @@ -369,12 +426,31 @@ static void thread_run(volatile struct thread *me) me->waits = 0; 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 } } /* release the event loop */ if (current_evloop) { - __atomic_sub_fetch(¤t_evloop->state, EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_store_n(&el->holder, NULL, __ATOMIC_RELAXED); current_evloop = NULL; } @@ -565,7 +641,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( @@ -582,6 +658,41 @@ int jobs_enter( return do_sync(group, timeout, enter_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; +} + +/** + * unlock the event loop if needed by sending + * an event. + * @param el the event loop to unlock + * @param wait wait the unlocked state of the event loop + */ +static void unlock_evloop(struct evloop *el, int wait) +{ + /* wait for a modifiable event loop */ + while (__atomic_load_n(&el->state, __ATOMIC_RELAXED) & EVLOOP_STATE_WAIT) { + uint64_t x = 1; + write(el->efd, &x, sizeof x); + if (!wait) + break; + pthread_cond_wait(&el->cond, &mutex); + } +} + /** * Unlocks the execution flow designed by 'jobloop'. * @param jobloop indication of the flow to unlock @@ -590,6 +701,7 @@ int jobs_enter( int jobs_leave(struct jobloop *jobloop) { struct thread *t; + int i; pthread_mutex_lock(&mutex); t = threads; @@ -601,6 +713,15 @@ int jobs_leave(struct jobloop *jobloop) t->stop = 1; if (t->waits) pthread_cond_broadcast(&cond); + else { + i = (int)(sizeof evloop / sizeof *evloop); + while(i) { + if (evloop[--i].holder == t) { + unlock_evloop(&evloop[i], 0); + break; + } + } + } } pthread_mutex_unlock(&mutex); return -!t; @@ -634,21 +755,13 @@ int jobs_call( 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) +/* temporary hack */ +#if !defined(REMOVE_SYSTEMD_EVENT) +__attribute__((unused)) +#endif +static void evloop_callback(void *arg, uint32_t event, struct fdev *fdev) { - 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; + sig_monitor(0, evloop_run, arg); } /** @@ -658,7 +771,6 @@ static int on_evloop_efd(sd_event_source *s, int fd, uint32_t revents, void *use static struct sd_event *get_sd_event_locked() { struct evloop *el; - uint64_t x; int rc; /* creates the evloop on need */ @@ -682,6 +794,7 @@ static struct sd_event *get_sd_event_locked() 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: @@ -689,22 +802,40 @@ error2: 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_sub_fetch(¤t_evloop->state, EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + if (current_evloop) { + __atomic_and_fetch(¤t_evloop->state, ~EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_store_n(¤t_evloop->holder, NULL, __ATOMIC_RELAXED); + } current_evloop = el; - __atomic_add_fetch(&el->state, EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_or_fetch(&el->state, EVLOOP_STATE_LOCK, __ATOMIC_RELAXED); + __atomic_store_n(&el->holder, current_thread, __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); - } + unlock_evloop(el, 1); return el->sdev; } @@ -724,6 +855,23 @@ struct sd_event *jobs_get_sd_event() 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 result; +} +#endif + /** * Enter the jobs processing loop. * @param allowed_count Maximum count of thread for jobs including this one @@ -732,7 +880,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 signum)) +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; @@ -753,19 +901,13 @@ 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; running = 0; remains = waiter_count; -#ifndef NO_JOBS_WATCHDOG +#if HAS_WATCHDOG /* set the watchdog */ if (sd_watchdog_enabled(0, NULL)) sd_event_set_watchdog(get_sd_event_locked(), 1); @@ -782,7 +924,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); + job = job_create(NULL, 0, start, arg); if (!job) { ERROR("out of memory"); errno = ENOMEM; @@ -792,7 +934,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);