X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=b7d161120b250c7647fe481ac41c814ff253d821;hb=7ffecab08bf91e26ffedb393d9b8cb6151e2b836;hp=cf1bb550b63113206f94ae5edbe37fbe95403793;hpb=e3a5ff981c25dcb609fe8cc5396a50b81138ee63;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index cf1bb550..b7d16112 100644 --- a/src/jobs.c +++ b/src/jobs.c @@ -18,6 +18,7 @@ #define _GNU_SOURCE #include +#include #include #include #include @@ -39,18 +40,19 @@ #define sig_monitor(to,cb,arg) (cb(0,arg)) #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 ? */ @@ -61,7 +63,12 @@ struct events { struct events *next; struct sd_event *event; - unsigned runs: 1; + uint64_t timeout; + enum { + Available, + Modifiable, + Locked + } state; }; /** Description of threads */ @@ -70,13 +77,26 @@ 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? */ }; +/** + * Description of synchonous callback + */ +struct sync +{ + 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; @@ -90,7 +110,8 @@ 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 events *current_events; /* queue of pending jobs */ static struct job *first_job; @@ -102,18 +123,14 @@ static struct job *free_jobs; * @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; @@ -135,9 +152,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: @@ -151,7 +166,7 @@ end: */ static void job_add(struct job *job) { - void *group; + const void *group; struct job *ijob, **pjob; /* prepare to add */ @@ -191,7 +206,7 @@ static inline struct job *job_get() static inline struct events *events_get() { struct events *events = first_events; - while (events && events->runs) + while (events && events->state != Available) events = events->next; return events; } @@ -205,7 +220,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; @@ -231,22 +246,6 @@ static inline void job_release(struct job *job) free_jobs = job; } -/** - * Monitored normal callback for a job. - * This function is called by the monitor - * to run 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 - */ -static void job_call(int signum, void *arg) -{ - struct job *job = arg; - job->callback(signum, job->arg1, job->arg2, job->arg3); -} - /** * Monitored cancel callback for a job. * This function is called by the monitor @@ -259,7 +258,8 @@ static void job_call(int signum, void *arg) */ static void job_cancel(int signum, void *arg) { - job_call(SIGABRT, arg); + struct job *job = arg; + job->callback(SIGABRT, job->arg); } /** @@ -274,9 +274,34 @@ static void job_cancel(int signum, void *arg) */ static void events_call(int signum, void *arg) { + int rc; + struct sd_event *se; struct events *events = arg; - if (!signum) - sd_event_run(events->event, (uint64_t) -1); + + if (!signum) { + se = events->event; + rc = sd_event_prepare(se); + if (rc < 0) { + errno = -rc; + ERROR("sd_event_prepare returned an error (state: %d): %m", sd_event_get_state(events->event)); + } else { + if (rc == 0) { + rc = sd_event_wait(se, events->timeout); + if (rc < 0) { + errno = -rc; + ERROR("sd_event_wait returned an error (state: %d): %m", sd_event_get_state(events->event)); + } + } + + 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(events->event)); + } + } + } + } } /** @@ -291,26 +316,25 @@ static void thread_run(volatile struct thread *me) struct thread **prv; struct job *job; struct events *events; + uint64_t evto; /* 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; - else + me->upper = current_thread; + if (current_thread) { + evto = EVENT_TIMEOUT_CHILD; + } else { + started++; sig_monitor_init_timeouts(); - current = (struct thread*)me; + evto = EVENT_TIMEOUT_TOP; + } me->next = threads; threads = (struct thread*)me; - started++; - - 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) { /* get a job */ job = job_get(first_job); @@ -322,30 +346,35 @@ 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; + events = current_events; + if (events && events->state == Modifiable) { + current_events = NULL; + events->state = Available; } + + /* release the run job */ + job_release(job); } else { /* no job, check events */ - events = events_get(); + events = current_events; + if (!events) + events = events_get(); + else if (events->state == Locked) + events = 0; if (events) { /* run the events */ - events->runs = 1; - me->events = events; + events->state = Locked; + events->timeout = evto; + current_events = events; pthread_mutex_unlock(&mutex); sig_monitor(0, events_call, events); pthread_mutex_lock(&mutex); - events->runs = 0; - me->events = NULL; + current_events = NULL; + events->state = Available; } else { /* no job and not events */ waiting++; @@ -356,19 +385,17 @@ static void thread_run(volatile struct thread *me) } } } - NOTICE("job thread stoping %d(/%d) %s", started, allowed, me->upper ? "child" : "parent"); /* unlink the current thread and cleanup */ - started--; 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--; + } } /** @@ -405,29 +432,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 @@ -440,72 +445,14 @@ int jobs_queue0( * or the signal number that broke the normal flow. * The remaining parameter is the parameter 'arg1' * given here. - * @param arg1 The second argument for 'callback' + * @param arg The second argument for 'callback' * @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; @@ -514,7 +461,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"; @@ -557,23 +504,45 @@ error: } /** - * Enter a synchronisation point: activates the job given by 'callback' - * @param group the gro + * 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; @@ -585,16 +554,50 @@ 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 arg 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 + * @return 0 in case of success of -1 on error + */ int jobs_leave(struct jobloop *jobloop) { struct thread *t; - pthread_mutex_lock(&mutex); + pthread_mutex_lock(&mutex); t = threads; while (t && t != (struct thread*)jobloop) t = t->next; @@ -609,6 +612,34 @@ int jobs_leave(struct jobloop *jobloop) return -!t; } +/** + * Calls synchronously the job represented by 'callback' and 'arg1' + * for the 'group' and the 'timeout' and waits for its completion. + * @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 parameter is the parameter 'arg1' + * given here. + * @param arg The second argument for 'callback' + * @return 0 in case of success or -1 in case of error + */ +int jobs_call( + const void *group, + int timeout, + void (*callback)(int, void*), + void *arg) +{ + struct sync sync; + + sync.callback = callback; + sync.arg = arg; + + return do_sync(group, timeout, call_cb, &sync); +} + /** * Gets a sd_event item for the current thread. * @return a sd_event or NULL in case of error @@ -616,19 +647,13 @@ int jobs_leave(struct jobloop *jobloop) struct sd_event *jobs_get_sd_event() { struct events *events; - struct thread *me; 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 { + events = current_events; + if (!events) { /* search an available events */ events = events_get(); if (!events) { @@ -640,7 +665,7 @@ struct sd_event *jobs_get_sd_event() events = malloc(sizeof *events); if (events && (rc = sd_event_new(&events->event)) >= 0) { if (nevents < started || start_one_thread() >= 0) { - events->runs = 0; + events->state = Available; events->next = first_events; first_events = events; } else { @@ -658,19 +683,15 @@ struct sd_event *jobs_get_sd_event() ERROR("creation of sd_event failed: %m"); events = NULL; errno = -rc; - } + } } } } if (events) { - /* */ - me = current; - if (me) { - events->runs = 1; - me->events = events; - } else { + events->state = Modifiable; + if (!current_thread) WARNING("event returned for unknown thread!"); - } + current_events = events; } } pthread_mutex_unlock(&mutex); @@ -685,7 +706,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)) { int rc, launched; struct thread me; @@ -700,7 +721,7 @@ 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; @@ -729,7 +750,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, (job_cb_t)start, NULL); if (!job) { ERROR("out of memory"); errno = ENOMEM; @@ -807,7 +828,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) {