X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=83ca2ed4e11a23321837f96c6bd47efc36b86278;hb=d9de3cd38b17ad16fb6ad6f74e83f4700c5f2b49;hp=8725d00e6cdd4246e5014ab7b6124ad6bb74ca12;hpb=b48b736097a222fdf8c6f1a33c922ee7d7bcd633;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index 8725d00e..83ca2ed4 100644 --- a/src/jobs.c +++ b/src/jobs.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2016, 2017 "IoT.bzh" + * Copyright (C) 2016-2019 "IoT.bzh" * Author José Bollo * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,28 +21,27 @@ #include #include #include +#include #include #include #include #include #include +#include #include #include "jobs.h" +#include "evmgr.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)) -#endif +#include "systemd.h" #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*); @@ -50,7 +49,7 @@ typedef void (*job_cb_t)(int, void*); 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 *arg; /**< argument */ int timeout; /**< timeout in second for processing the request */ @@ -58,30 +57,21 @@ struct job unsigned dropped: 1; /**< is removed ? */ }; -/** Description of handled event loops */ -struct events -{ - struct events *next; - struct sd_event *event; - uint64_t timeout; - unsigned runs: 1; -}; - /** 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 */ - 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? */ }; /** - * Description of synchonous callback + * Description of synchronous callback */ struct sync { @@ -99,22 +89,23 @@ struct sync 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; /* queue of pending jobs */ static struct job *first_job; -static struct events *first_events; static struct job *free_jobs; +/* event loop */ +static struct evmgr *evmgr; + /** * Create a new job with the given parameters * @param group the group of the job @@ -124,7 +115,7 @@ static struct job *free_jobs; * @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 *arg) @@ -136,12 +127,13 @@ 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; + ERROR("out of memory"); + errno = ENOMEM; goto end; } } @@ -163,7 +155,7 @@ end: */ static void job_add(struct job *job) { - void *group; + const void *group; struct job *ijob, **pjob; /* prepare to add */ @@ -182,6 +174,7 @@ static void job_add(struct job *job) /* queue the jobs */ *pjob = job; + remains--; } /** @@ -193,21 +186,11 @@ static inline struct job *job_get() struct job *job = first_job; while (job && job->blocked) job = job->next; + if (job) + remains++; 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 @@ -217,7 +200,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; @@ -260,62 +243,130 @@ static void job_cancel(int signum, void *arg) } /** - * Monitored normal callback for events. - * This function is called by the monitor - * to run the event loop 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 events to run + * wakeup the event loop if needed by sending + * an event. */ -static void events_call(int signum, void *arg) +static void evloop_wakeup() { - struct events *events = arg; - if (!signum) - sd_event_run(events->event, events->timeout); + if (evmgr) + evmgr_wakeup(evmgr); } /** - * Main processing loop of threads processing jobs. - * The loop must be called with the mutex locked - * and it returns with the mutex locked. - * @param me the description of the thread to use - * TODO: how are timeout handled when reentering? + * Release the currently held event loop */ -static void thread_run(volatile struct thread *me) +static void evloop_release() { - struct thread **prv; - struct job *job; - struct events *events; - uint64_t evto; + struct thread *nh, *ct = current_thread; + + if (ct && evmgr && evmgr_release_if(evmgr, ct)) { + nh = ct->nholder; + ct->nholder = 0; + if (nh) { + evmgr_try_hold(evmgr, nh); + pthread_cond_signal(nh->cwhold); + } + } +} + +/** + * get the eventloop for the current thread + */ +static int evloop_get() +{ + return evmgr && evmgr_try_hold(evmgr, current_thread); +} +/** + * 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 = evmgr_holder(evmgr); + while (pwait->nholder) + pwait = pwait->nholder; + pwait->nholder = ct; + + /* wake up the evloop */ + evloop_wakeup(); + + /* wait to acquire the evloop */ + pthread_cond_wait(&cond, &mutex); + pthread_cond_destroy(&cond); + } +} + +/** + * Enter the thread + * @param me the description of the thread to enter + */ +static void thread_enter(volatile struct thread *me) +{ + evloop_release(); /* 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 { - started++; - sig_monitor_init_timeouts(); - evto = EVENT_TIMEOUT_TOP; - } + me->nholder = 0; + me->upper = current_thread; me->next = threads; threads = (struct thread*)me; - current = (struct thread*)me; + current_thread = (struct thread*)me; +} + +/** + * leave the thread + * @param me the description of the thread to leave + */ +static void thread_leave() +{ + struct thread **prv, *me; + + /* unlink the current thread and cleanup */ + me = current_thread; + prv = &threads; + while (*prv != me) + prv = &(*prv)->next; + *prv = me->next; + + current_thread = me->upper; +} + +/** + * Main processing loop of internal threads with processing jobs. + * The loop must be called with the mutex locked + * and it returns with the mutex locked. + * @param me the description of the thread to use + * TODO: how are timeout handled when reentering? + */ +static void thread_run_internal(volatile struct thread *me) +{ + struct job *job; + + /* enter thread */ + thread_enter(me); /* loop until stopped */ - me->events = NULL; while (!me->stop) { + /* 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 */ job->blocked = 1; /* mark job as blocked */ me->job = job; /* record the job (only for terminate) */ @@ -326,49 +377,66 @@ static void thread_run(volatile struct thread *me) /* release the run job */ job_release(job); - - /* release event if any */ - events = me->events; - if (events) { - events->runs = 0; - me->events = NULL; + /* no job, check event loop wait */ + } else if (evloop_get()) { + if (!evmgr_can_run(evmgr)) { + /* busy ? */ + CRITICAL("Can't enter dispatch while in dispatch!"); + abort(); } + /* run the events */ + pthread_mutex_unlock(&mutex); + sig_monitor(0, (void(*)(int,void*))evmgr_job_run, evmgr); + pthread_mutex_lock(&mutex); } else { - /* no job, check events */ - events = events_get(); - if (events) { - /* run the events */ - events->runs = 1; - events->timeout = evto; - me->events = events; - pthread_mutex_unlock(&mutex); - sig_monitor(0, events_call, events); - pthread_mutex_lock(&mutex); - events->runs = 0; - me->events = NULL; - } else { - /* no job and not events */ - waiting++; - me->waits = 1; - pthread_cond_wait(&cond, &mutex); - me->waits = 0; - waiting--; - } + /* 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++; } } + /* cleanup */ + evloop_release(); + thread_leave(); +} - /* 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 { - sig_monitor_clean_timeouts(); - started--; - } +/** + * Main processing loop of external threads. + * The loop must be called with the mutex locked + * and it returns with the mutex locked. + * @param me the description of the thread to use + */ +static void thread_run_external(volatile struct thread *me) +{ + /* enter thread */ + thread_enter(me); + + /* loop until stopped */ + me->waits = 1; + while (!me->stop) + pthread_cond_wait(&cond, &mutex); + me->waits = 0; + thread_leave(); +} + +/** + * Root for created threads. + */ +static void thread_main() +{ + struct thread me; + + running++; + started++; + sig_monitor_init_timeouts(); + thread_run_internal(&me); + sig_monitor_clean_timeouts(); + started--; + running--; } /** @@ -376,12 +444,10 @@ static void thread_run(volatile struct thread *me) * @param data not used * @return NULL */ -static void *thread_main(void *data) +static void *thread_starter(void *data) { - struct thread me; - pthread_mutex_lock(&mutex); - thread_run(&me); + thread_main(); pthread_mutex_unlock(&mutex); return NULL; } @@ -395,7 +461,7 @@ static int start_one_thread() pthread_t tid; int rc; - rc = pthread_create(&tid, NULL, thread_main, NULL); + rc = pthread_create(&tid, NULL, thread_starter, NULL); if (rc != 0) { /* errno = rc; */ WARNING("not able to start thread: %m"); @@ -422,12 +488,11 @@ static int start_one_thread() * @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) { - const char *info; struct job *job; int rc; @@ -435,31 +500,27 @@ int jobs_queue( /* allocates the job */ job = job_create(group, timeout, callback, arg); - if (!job) { - errno = ENOMEM; - info = "out of memory"; + if (!job) goto error; - } /* check availability */ - if (remains == 0) { + if (remains <= 0) { + ERROR("can't process job with threads: too many jobs"); errno = EBUSY; - info = "too many jobs"; goto error2; } /* 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) { - info = "can't start first thread"; + ERROR("can't start initial thread: %m"); goto error2; } } /* queues the job */ - remains--; job_add(job); /* signal an existing job */ @@ -471,7 +532,6 @@ error2: job->next = free_jobs; free_jobs = job; error: - ERROR("can't process job with threads: %s, %m", info); pthread_mutex_unlock(&mutex); return -1; } @@ -504,7 +564,7 @@ static void call_cb(int signum, void *closure) * @see jobs_call, jobs_enter, jobs_leave */ static int do_sync( - void *group, + const void *group, int timeout, void (*sync_cb)(int signum, void *closure), struct sync *sync @@ -517,8 +577,6 @@ static int do_sync( /* allocates the job */ job = job_create(group, timeout, sync_cb, sync); if (!job) { - ERROR("out of memory"); - errno = ENOMEM; pthread_mutex_unlock(&mutex); return -1; } @@ -527,7 +585,10 @@ static int do_sync( job_add(job); /* run until stopped */ - thread_run(&sync->thread); + if (current_thread) + thread_run_internal(&sync->thread); + else + thread_run_external(&sync->thread); pthread_mutex_unlock(&mutex); return 0; } @@ -544,11 +605,11 @@ 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( - void *group, + const void *group, int timeout, void (*callback)(int signum, void *closure, struct jobloop *jobloop), void *closure @@ -580,6 +641,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; @@ -600,7 +663,7 @@ int jobs_leave(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) @@ -614,71 +677,48 @@ int jobs_call( } /** - * Gets a sd_event item for the current thread. - * @return a sd_event or NULL in case of error + * Ensure that the current running thread can control the event loop. */ -struct sd_event *jobs_get_sd_event() +void jobs_acquire_event_manager() { - struct events *events; - struct thread *me; - int rc; + struct thread lt; + + /* ensure an existing thread environment */ + if (!current_thread) { + memset(<, 0, sizeof lt); + current_thread = < + } + /* lock */ 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; - } - } - } - } - if (events) { - /* */ - me = current; - if (me) { - events->runs = 1; - me->events = events; - } else { - WARNING("event returned for unknown thread!"); - } - } - } + /* creates the evloop on need */ + if (!evmgr) + evmgr_create(&evmgr); + + /* acquire the event loop under lock */ + if (evmgr) + evloop_acquire(); + + /* unlock */ pthread_mutex_unlock(&mutex); - return events ? events->event : NULL; + + /* 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 event manager/loop from outside of binder's callback is hazardous!"); + if (verbose_wants(Log_Level_Info)) + sig_monitor_dumpstack(); + evloop_release(); + current_thread = NULL; + } } /** @@ -689,10 +729,9 @@ 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; struct job *job; assert(allowed_count >= 1); @@ -704,27 +743,21 @@ 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; - /* start at least one thread */ - launched = 0; - while ((launched + 1) < start_count) { + /* start at least one thread: the current one */ + launched = 1; + while (launched < start_count) { if (start_one_thread() != 0) { ERROR("Not all threads can be started"); goto error; @@ -733,17 +766,13 @@ 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); - if (!job) { - ERROR("out of memory"); - errno = ENOMEM; + job = job_create(NULL, 0, start, arg); + if (!job) goto error; - } job_add(job); - remains--; /* run until end */ - thread_run(&me); + thread_main(); rc = 0; error: pthread_mutex_unlock(&mutex); @@ -811,7 +840,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) {