X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fjobs.c;h=8725d00e6cdd4246e5014ab7b6124ad6bb74ca12;hb=b48b736097a222fdf8c6f1a33c922ee7d7bcd633;hp=03fe4254fba8704a504b33eea72949b36e7e4035;hpb=5fdbf43a0af039c7ad64b9de8038d5d7d9cd0c60;p=src%2Fapp-framework-binder.git diff --git a/src/jobs.c b/src/jobs.c index 03fe4254..8725d00e 100644 --- a/src/jobs.c +++ b/src/jobs.c @@ -18,6 +18,7 @@ #define _GNU_SOURCE #include +#include #include #include #include @@ -26,6 +27,8 @@ #include #include +#include + #include "jobs.h" #include "sig-monitor.h" #include "verbose.h" @@ -37,8 +40,11 @@ #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 @@ -46,26 +52,49 @@ struct job struct job *next; /**< link to the next job enqueued */ 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 ? */ }; +/** 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 job *job; /**< 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? */ + 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; @@ -75,6 +104,7 @@ 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 remains = 0; /** allowed count of waiting jobs */ +static int nevents = 0; /** count of events */ /* list of threads */ static struct thread *threads; @@ -82,7 +112,7 @@ static _Thread_local struct thread *current; /* queue of pending jobs */ static struct job *first_job; -static struct job *first_events; +static struct events *first_events; static struct job *free_jobs; /** @@ -90,18 +120,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, int timeout, job_cb_t callback, - void *arg1, - void *arg2, - void *arg3) + void *arg) { struct job *job; @@ -123,9 +149,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: @@ -133,59 +157,57 @@ end: } /** - * Adds 'job1' and 'job2' at the end of the list of jobs, marking it + * Adds 'job' at the end of the list of jobs, marking it * as blocked if an other job with the same group is pending. - * @param job1 the first job to add - * @param job2 the second job to add or NULL + * @param job the job to add */ -static void job_add2(struct job *job1, struct job *job2) +static void job_add(struct job *job) { - void *group1, *group2, *group; + void *group; struct job *ijob, **pjob; /* prepare to add */ - group1 = job1->group; - job1->next = job2; - if (!job2) - group2 = NULL; - else { - job2->next = NULL; - group2 = job2->group; - if (group2 && group2 == group1) - job2->blocked = 1; - } + group = job->group; + job->next = NULL; /* search end and blockers */ pjob = &first_job; ijob = first_job; while (ijob) { - group = ijob->group; - if (group) { - if (group == group1) - job1->blocked = 1; - if (group == group2) - job2->blocked = 1; - } + if (group && ijob->group == group) + job->blocked = 1; pjob = &ijob->next; ijob = ijob->next; } /* queue the jobs */ - *pjob = job1; + *pjob = job; } /** * Get the next job to process or NULL if none. - * @param job the head of the list to search. * @return the first job that isn't blocked or NULL */ -static inline struct job *job_get(struct job *job) +static inline struct job *job_get() { + struct job *job = first_job; while (job && job->blocked) job = job->next; 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 @@ -222,76 +244,36 @@ static inline void job_release(struct job *job) } /** - * Releases the events 'job': removes it - * from the list of events. - * @param job the event to release - */ -static inline void events_release(struct job *job) -{ - struct job *ijob, **pjob; - - /* first unqueue the job */ - pjob = &first_events; - ijob = first_events; - while (ijob != job) { - pjob = &ijob->next; - ijob = ijob->next; - } - *pjob = job->next; - - /* recycle the job */ - job->next = free_jobs; - free_jobs = job; -} - -/** - * Get the events of 'key' if existing. - * @param key the key to search - * @return the found events or NULL if none existing has key - */ -static inline struct job *events_of_key(void *key) -{ - struct job *job; - - if (!key) - job = NULL; - else { - job = first_events; - while (job && (job->dropped || job->group != key)) - job = job->next; - } - return job; -} - -/** - * Monitored normal callback for a job. + * Monitored cancel callback for a job. * This function is called by the monitor - * to run the job when the safe environment + * to cancel 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 + * flow, isn't used + * @param arg the job to run */ -static void job_call(int signum, void *arg) +static void job_cancel(int signum, void *arg) { struct job *job = arg; - job->callback(signum, job->arg1, job->arg2, job->arg3); + job->callback(SIGABRT, job->arg); } /** - * Monitored cancel callback for a job. + * Monitored normal callback for events. * This function is called by the monitor - * to cancel the job when the safe environment + * 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, isn't used - * @param arg the job to run + * flow + * @param arg the events to run */ -static void job_cancel(int signum, void *arg) +static void events_call(int signum, void *arg) { - job_call(SIGABRT, arg); + struct events *events = arg; + if (!signum) + sd_event_run(events->event, events->timeout); } /** @@ -301,10 +283,12 @@ static void job_cancel(int signum, void *arg) * @param me the description of the thread to use * TODO: how are timeout handled when reentering? */ -static void thread_run(struct thread *me) +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(); @@ -312,16 +296,20 @@ static void thread_run(struct thread *me) me->lowered = 0; me->waits = 0; me->upper = current; - if (current) + if (current) { current->lowered = 1; - else + evto = EVENT_TIMEOUT_CHILD; + } else { + started++; sig_monitor_init_timeouts(); - current = me; + evto = EVENT_TIMEOUT_TOP; + } me->next = threads; - threads = me; - started++; + threads = (struct thread*)me; + current = (struct thread*)me; /* loop until stopped */ + me->events = NULL; while (!me->stop) { /* get a job */ job = job_get(first_job); @@ -333,23 +321,31 @@ static void thread_run(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; + } } else { /* no job, check events */ - job = job_get(first_events); - if (job) { + events = events_get(); + if (events) { /* run the events */ - job->blocked = 1; + events->runs = 1; + events->timeout = evto; + me->events = events; pthread_mutex_unlock(&mutex); - sig_monitor(job->timeout, job_call, job); + sig_monitor(0, events_call, events); pthread_mutex_lock(&mutex); - job->blocked = 0; - if (job->dropped) - events_release(job); + events->runs = 0; + me->events = NULL; } else { /* no job and not events */ waiting++; @@ -362,16 +358,17 @@ static void thread_run(struct thread *me) } /* unlink the current thread and cleanup */ - started--; prv = &threads; while (*prv != me) prv = &(*prv)->next; *prv = me->next; current = me->upper; - if (current) + if (current) { current->lowered = 0; - else + } else { sig_monitor_clean_timeouts(); + started--; + } } /** @@ -408,29 +405,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 @@ -443,7 +418,7 @@ 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( @@ -451,64 +426,6 @@ int jobs_queue( 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; @@ -517,7 +434,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"; @@ -543,7 +460,7 @@ int jobs_queue3( /* queues the job */ remains--; - job_add2(job, NULL); + job_add(job); /* signal an existing job */ pthread_cond_signal(&cond); @@ -560,155 +477,245 @@ error: } /** - * Run a asynchronous job represented by 'callback' - * with the 'timeout' but only returns after job completion. - * @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 + * Internal helper function for 'jobs_enter'. + * @see jobs_enter, jobs_leave */ -int jobs_invoke0( - int timeout, - void (*callback)(int signum)) +static void enter_cb(int signum, void *closure) { - return jobs_invoke3(timeout, (job_cb_t)callback, NULL, NULL, NULL); + struct sync *sync = closure; + sync->enter(signum, sync->arg, (void*)&sync->thread); } /** - * Run a asynchronous job represented by 'callback' and 'arg1' - * with the 'timeout' but only returns after job completion. - * @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 arg1 The second argument for 'callback' - * @return 0 in case of success or -1 in case of error + * Internal helper function for 'jobs_call'. + * @see jobs_call */ -int jobs_invoke( +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( + void *group, int timeout, - void (*callback)(int, void*), - void *arg) + void (*sync_cb)(int signum, void *closure), + struct sync *sync +) { - return jobs_invoke3(timeout, (job_cb_t)callback, arg, NULL, NULL); + struct job *job; + + pthread_mutex_lock(&mutex); + + /* 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; + } + + /* queues the job */ + job_add(job); + + /* run until stopped */ + thread_run(&sync->thread); + pthread_mutex_unlock(&mutex); + return 0; } /** - * Run a asynchronous job represented by 'callback' and 'arg[12]' - * with the 'timeout' but only returns after job completion. - * @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 + * 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_invoke2( +int jobs_enter( + void *group, int timeout, - void (*callback)(int, void*, void*), - void *arg1, - void *arg2) + void (*callback)(int signum, void *closure, struct jobloop *jobloop), + void *closure +) { - return jobs_invoke3(timeout, (job_cb_t)callback, arg1, arg2, NULL); + struct sync sync; + + sync.enter = callback; + sync.arg = closure; + return do_sync(group, timeout, enter_cb, &sync); } /** - * Stops the thread pointed by 'arg1'. Used with - * invoke familly to return to the caller after completion. - * @param signum Unused - * @param arg1 The thread to stop - * @param arg2 Unused - * @param arg3 Unused + * 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 */ -static void unlock_invoker(int signum, void *arg1, void *arg2, void *arg3) +int jobs_leave(struct jobloop *jobloop) { - struct thread *t = arg1; + struct thread *t; + pthread_mutex_lock(&mutex); - t->stop = 1; - if (t->waits) - pthread_cond_broadcast(&cond); + t = threads; + while (t && t != (struct thread*)jobloop) + t = t->next; + if (!t) { + errno = EINVAL; + } else { + t->stop = 1; + if (t->waits) + pthread_cond_broadcast(&cond); + } pthread_mutex_unlock(&mutex); + return -!t; } /** - * Run a asynchronous job represented by 'callback' and 'arg[123]' - * with the 'timeout' but only returns after job completion. + * 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 parameters are the parameters 'arg[123]' + * The remaining parameter is the parameter 'arg1' * given here. - * @param arg1 The second argument for 'callback' - * @param arg2 The third argument for 'callback' - * @param arg3 The forth argument for 'callback' + * @param arg The second argument for 'callback' * @return 0 in case of success or -1 in case of error */ -int jobs_invoke3( +int jobs_call( + void *group, int timeout, - void (*callback)(int, void*, void *, void*), - void *arg1, - void *arg2, - void *arg3) + void (*callback)(int, void*), + void *arg) { - struct job *job1, *job2; - struct thread me; - + 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 + */ +struct sd_event *jobs_get_sd_event() +{ + struct events *events; + struct thread *me; + int rc; + pthread_mutex_lock(&mutex); - /* allocates the job */ - job1 = job_create(&me, timeout, callback, arg1, arg2, arg3); - job2 = job_create(&me, 0, unlock_invoker, &me, NULL, NULL); - if (!job1 || !job2) { - ERROR("out of memory"); - errno = ENOMEM; - if (job1) { - job1->next = free_jobs; - free_jobs = job1; + /* 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 (job2) { - job2->next = free_jobs; - free_jobs = job2; + if (events) { + /* */ + me = current; + if (me) { + events->runs = 1; + me->events = events; + } else { + WARNING("event returned for unknown thread!"); + } } - pthread_mutex_unlock(&mutex); - return -1; } - - /* queues the job */ - job_add2(job1, job2); - - /* run until stopped */ - thread_run(&me); pthread_mutex_unlock(&mutex); - return 0; + return events ? events->event : NULL; } /** - * Initialise the job stuff. - * @param allowed_count Maximum count of thread for jobs (can be 0, - * see 'jobs_add_me' for merging new threads) + * Enter the jobs processing loop. + * @param allowed_count Maximum count of thread for jobs including this one * @param start_count Count of thread to start now, must be lower. * @param waiter_count Maximum count of jobs that can be waiting. + * @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_init(int allowed_count, int start_count, int waiter_count) +int jobs_start(int allowed_count, int start_count, int waiter_count, void (*start)()) { int rc, launched; + struct thread me; + struct job *job; - assert(allowed_count >= 0); + assert(allowed_count >= 1); assert(start_count >= 0); assert(waiter_count > 0); assert(start_count <= allowed_count); + rc = -1; + pthread_mutex_lock(&mutex); + + /* check whether already running */ + if (current || 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; @@ -716,16 +723,30 @@ int jobs_init(int allowed_count, int start_count, int waiter_count) remains = waiter_count; /* start at least one thread */ - pthread_mutex_lock(&mutex); launched = 0; - while (launched < start_count && start_one_thread() == 0) + while ((launched + 1) < start_count) { + if (start_one_thread() != 0) { + ERROR("Not all threads can be started"); + goto error; + } launched++; - rc = -(launched != start_count); - pthread_mutex_unlock(&mutex); + } + + /* queue the start job */ + job = job_create(NULL, 0, (job_cb_t)start, NULL); + if (!job) { + ERROR("out of memory"); + errno = ENOMEM; + goto error; + } + job_add(job); + remains--; - /* end */ - if (rc) - ERROR("Not all threads can be started"); + /* run until end */ + thread_run(&me); + rc = 0; +error: + pthread_mutex_unlock(&mutex); return rc; } @@ -812,101 +833,3 @@ void jobs_terminate() pthread_mutex_unlock(&mutex); } -/** - * Adds the events waiter/dispatcher to the list of events waiters/dispatchers - * to monitor. - * @param key A key to register the events waiter/dispatcher (see - * 'jobs_del_events') - * @param timeout Timeout in second of the function or 0 if none - * @param events The callback, the first argument is 0 for normal - * flow or the signal number when normal flow failed - * @param closure The closure to give to the callback as secondd argument - * @return 0 in case of success or -1 in case of error - */ -int jobs_add_events(void *key, int timeout, void (*events)(int signum, void*), void *closure) -{ - struct job *job; - - pthread_mutex_lock(&mutex); - - /* look at an already existsing events for same key */ - job = events_of_key(key); - if (job) { - pthread_mutex_unlock(&mutex); - ERROR("events of key %p already exist", key); - errno = EEXIST; - return -1; - } - - /* creates the job */ - job = job_create(key, timeout, (job_cb_t)events, closure, NULL, NULL); - if (!job) { - pthread_mutex_unlock(&mutex); - ERROR("Can't create events, out of memory"); - errno = ENOMEM; - return -1; - } - - /* adds the loop */ - job->next = first_events; - first_events = job; - - /* signal the loop */ - if (waiting) - pthread_cond_signal(&cond); - pthread_mutex_unlock(&mutex); - return 0; -} - -/** - * Removes the events of 'key' - * @param key The key of the events to remove - * @return 0 in case of success or -1 in case of error - */ -int jobs_del_events(void *key) -{ - struct job *job; - - pthread_mutex_lock(&mutex); - job = events_of_key(key); - if (job) - if (job->blocked) - job->dropped = 1; - else - events_release(job); - pthread_mutex_unlock(&mutex); - if (!job) { - ERROR("events of key %p not found", key); - errno = ENOENT; - } - return -!job; -} - -/** - * Adds the current thread to the pool of threads - * processing the jobs. Returns normally when the threads are - * terminated or immediately with an error if the thread is - * already in the pool. - * @return 0 in case of success or -1 in case of error - */ -int jobs_add_me() -{ - struct thread me; - - /* check whether already running */ - if (current) { - ERROR("thread already running"); - errno = EINVAL; - return -1; - } - - /* allowed... */ - pthread_mutex_lock(&mutex); - allowed++; - thread_run(&me); - allowed--; - pthread_mutex_unlock(&mutex); - return 0; -} - -