X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=83ca2ed4e11a23321837f96c6bd47efc36b86278;hb=d9de3cd38b17ad16fb6ad6f74e83f4700c5f2b49;hp=d06d24cfe008da0b51a85f712d6ca305d5b49569;hpb=fcd68bb0f872c65c4317377f787f5fdddea6e5d0;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index d06d24cf..83ca2ed4 100644 --- a/src/jobs.c +++ b/src/jobs.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2016, 2017, 2018 "IoT.bzh" + * Copyright (C) 2016-2019 "IoT.bzh" * Author José Bollo * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,12 +17,6 @@ #define _GNU_SOURCE -#if defined(NO_JOBS_WATCHDOG) -# define HAS_WATCHDOG 0 -#else -# define HAS_WATCHDOG 1 -#endif - #include #include #include @@ -36,14 +30,12 @@ #include #include -#include "fdev.h" -#if HAS_WATCHDOG -#include -#endif #include "jobs.h" +#include "evmgr.h" #include "sig-monitor.h" #include "verbose.h" +#include "systemd.h" #define EVENT_TIMEOUT_TOP ((uint64_t)-1) #define EVENT_TIMEOUT_CHILD ((uint64_t)10000) @@ -65,19 +57,6 @@ struct job unsigned dropped: 1; /**< is removed ? */ }; -/** Description of handled event loops */ -struct evloop -{ - unsigned state; /**< encoded state */ - int efd; /**< event notification */ - struct sd_event *sdev; /**< the systemd event loop */ - struct fdev *fdev; /**< handling of events */ - struct thread *holder; /**< holder of the evloop */ -}; - -#define EVLOOP_STATE_WAIT 1U -#define EVLOOP_STATE_RUN 2U - /** Description of threads */ struct thread { @@ -125,7 +104,7 @@ static struct job *first_job; static struct job *free_jobs; /* event loop */ -static struct evloop evloop; +static struct evmgr *evmgr; /** * Create a new job with the given parameters @@ -263,71 +242,14 @@ static void job_cancel(int signum, void *arg) job->callback(SIGABRT, job->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 - */ -static void evloop_run(int signum, void *arg) -{ - int rc; - struct sd_event *se; - - if (!signum) { - se = evloop.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)); - } - } - evloop.state = EVLOOP_STATE_RUN; - 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)); - } - } - } - } -} - -/** - * 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); - } + if (evmgr) + evmgr_wakeup(evmgr); } /** @@ -337,11 +259,13 @@ static void evloop_release() { struct thread *nh, *ct = current_thread; - if (ct && evloop.holder == ct) { + if (ct && evmgr && evmgr_release_if(evmgr, ct)) { nh = ct->nholder; - evloop.holder = nh; - if (nh) + ct->nholder = 0; + if (nh) { + evmgr_try_hold(evmgr, nh); pthread_cond_signal(nh->cwhold); + } } } @@ -350,14 +274,7 @@ static void evloop_release() */ static int evloop_get() { - struct thread *ct = current_thread; - - if (evloop.holder) - return evloop.holder == ct; - - ct->nholder = NULL; - evloop.holder = ct; - return 1; + return evmgr && evmgr_try_hold(evmgr, current_thread); } /** @@ -365,7 +282,7 @@ static int evloop_get() */ static void evloop_acquire() { - struct thread **pwait, *ct; + struct thread *pwait, *ct; pthread_cond_t cond; /* try to get the evloop */ @@ -377,10 +294,10 @@ static void evloop_acquire() pthread_cond_init(&cond, NULL); /* queue current thread in holder list */ - pwait = &evloop.holder; - while (*pwait) - pwait = &(*pwait)->nholder; - *pwait = ct; + pwait = evmgr_holder(evmgr); + while (pwait->nholder) + pwait = pwait->nholder; + pwait->nholder = ct; /* wake up the evloop */ evloop_wakeup(); @@ -402,6 +319,7 @@ static void thread_enter(volatile struct thread *me) me->tid = pthread_self(); me->stop = 0; me->waits = 0; + me->nholder = 0; me->upper = current_thread; me->next = threads; threads = (struct thread*)me; @@ -461,17 +379,15 @@ static void thread_run_internal(volatile struct thread *me) job_release(job); /* no job, check event loop wait */ } else if (evloop_get()) { - if (evloop.state != 0) { + if (!evmgr_can_run(evmgr)) { /* 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); + sig_monitor(0, (void(*)(int,void*))evmgr_job_run, evmgr); pthread_mutex_lock(&mutex); - evloop.state = 0; } else { /* no job and no event loop */ running--; @@ -761,67 +677,10 @@ int jobs_call( } /** - * 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) -{ - evloop_on_efd_event(); - return 1; -} - -/** - * Gets a sd_event item for the current thread. - * @return a sd_event or NULL in case of error - */ -static struct sd_event *get_sd_event_locked() -{ - int rc; - - /* creates the evloop on need */ - if (!evloop.sdev) { - /* start the creation */ - evloop.state = 0; - /* creates the eventfd for waking up polls */ - 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(&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(evloop.sdev, NULL, evloop.efd, EPOLLIN, on_evloop_efd, NULL); - if (rc < 0) { - ERROR("can't register eventfd"); - sd_event_unref(evloop.sdev); - evloop.sdev = NULL; -error2: - close(evloop.efd); -error1: - return NULL; - } - } - - /* acquire the event loop */ - evloop_acquire(); - - return evloop.sdev; -} - -/** - * 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 sd_event *result; struct thread lt; /* ensure an existing thread environment */ @@ -830,9 +689,18 @@ struct sd_event *jobs_get_sd_event() current_thread = < } - /* process */ + /* lock */ pthread_mutex_lock(&mutex); - result = get_sd_event_locked(); + + /* 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); /* release the faked thread environment if needed */ @@ -845,14 +713,12 @@ struct sd_event *jobs_get_sd_event() * 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!"); + 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; } - - return result; } /** @@ -889,12 +755,6 @@ int jobs_start(int allowed_count, int start_count, int waiter_count, void (*star 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: the current one */ launched = 1; while (launched < start_count) {