On Wed, 14 Sep 2016 01:55:42 -0300 Gustavo Sverzut Barbieri <barbi...@gmail.com> said:
as per the thread. i dislike this due to lack of portability and due to the major amounts of complexity there is in having a premeptable cacnel that can just interrupt ANY code ANYWHERE. imagine you are inside a malloc() when ptr has yet to be returned but the libc malloc impl is busy messing with the heap state to get a piece of memory ready. REALLY bad. basically you cant use this feature if anything in the thread runs any code that changes any state... this makes this largely useless. you cannot even use it to break gethostbyname because this MAY be doing allocations internally. this is a bad bad bad idea imho. using it at all is a bad idea for reasons above, and add to that portability and such an amazing ability to shoot yourself in the foot when using this... let's just not have it. :) > HEADS UP -- BINDINGS: > > If you wish to expose the new "cancellable" property, or cope with > naughty users or 3rd party deps that may call > pthread_setcancelstate(PTHREAD_CANCEL_ENABLE), please register your > cleanup functions with: > > EINA_THREAD_CLEANUP_PUSH(cb, ctx); // will call cb() on > pthread_cancel()/ecore_thread_cancel()/eina_thread_cancel() > call_user(); > EINA_THREAD_CLEANUP_POP(EINA_TRUE); // will call cb() on clean exit > > If different functions are desired: > > EINA_THREAD_CLEANUP_PUSH(cb, ctx); // will call cb() on > pthread_cancel()/ecore_thread_cancel()/eina_thread_cancel() > call_user(); > EINA_THREAD_CLEANUP_POP(EINA_FALSE); // will NOT call cb() on clean exit > another_cb(ctx); > > This is recommended if you expose ecore_thread to your users. If you > don't, then you do not need to do anything. > > > > > On Wed, Sep 14, 2016 at 1:47 AM, Gustavo Sverzut Barbieri > <barbi...@gmail.com> wrote: > > barbieri pushed a commit to branch master. > > > > http://git.enlightenment.org/core/efl.git/commit/?id=960e1a1d168ba0044544ca22b05cbf505941f150 > > > > commit 960e1a1d168ba0044544ca22b05cbf505941f150 > > Author: Gustavo Sverzut Barbieri <barbi...@profusion.mobi> > > Date: Wed Sep 14 01:38:58 2016 -0300 > > > > eina/ecore: allow threads to be canceled, use in ecore_con. > > > > As discussed in the mailing list, many people will use worker threads > > to execute blocking syscalls and mandating ecore_thread_check() for > > voluntary preemption reduces the ecore_thread usefulness a lot. > > > > A clear example is ecore_con usage of connect() and getaddrinfo() in > > threads. If the connect timeout expires, the thread will be cancelled, > > but it was blocked on syscalls and they will hang around for long > > time. If the application exits, ecore will print an error saying it > > can SEGV. > > > > Then enable access to pthread_setcancelstate(PTHREAD_CANCEL_ENABLE) > > via eina_thread_cancellable_set(EINA_TRUE), to pthread_cancel() via > > eina_thread_cancel(), to pthread_cleanup_push()/pthread_cleanup_pop() > > via EINA_THREAD_CLEANUP_PUSH()/EINA_THREAD_CLEANUP_POP() and so on. > > > > Ecore threads will enforce non-cancellable threads on its own code, > > but the user may decide to enable that and allow cancellation, that's > > not an issue since ecore_thread now plays well and use cleanup > > functions. > > > > Ecore con connect/resolve make use of that and enable cancellable > > state, efl_net_dialer_tcp benefits a lot from that. > > > > A good comparison of the benefit is to run: > > > > ./src/examples/ecore/efl_io_copier_example > > tcp://google.com:1234 :stdout: > > > > before and after. It will timeout after 30s and with this patch the > > thread is gone, no ecore error is printed about possible SEGV. > > --- > > src/lib/ecore/Ecore_Common.h | 12 +++ > > src/lib/ecore/ecore_thread.c | 108 +++++++++++++++------ > > src/lib/ecore_con/ecore_con.c | 41 +++++--- > > src/lib/eina/Eina.h | 2 +- > > src/lib/eina/eina_thread.c | 32 ++++++ > > src/lib/eina/eina_thread.h | 219 +++++++++++++++++++++++++++++++++++++++ > > +++ 6 files changed, 373 insertions(+), 41 deletions(-) > > > > diff --git a/src/lib/ecore/Ecore_Common.h b/src/lib/ecore/Ecore_Common.h > > index 5404438..22da9ab 100644 > > --- a/src/lib/ecore/Ecore_Common.h > > +++ b/src/lib/ecore/Ecore_Common.h > > @@ -1794,6 +1794,17 @@ EAPI Ecore_Thread *ecore_thread_feedback_run > > (Ecore_Thread_Cb func_heavy, Ecore_T > > * ecore_thread_reschedule(). > > * @li The function is prepared to leave early by checking if > > * ecore_thread_check() returns @c EINA_TRUE. > > + > > + * @li The function marks the thread as cancellable using > > + * eina_thread_cancellable_set(), allowing the thread to be terminated > > + * at explicit cancellation points defined with > > + * eina_thread_cancel_checkpoint() or with syscalls mentioned at > > + * man:pthreads(7). This allows blocking operations such as network or > > + * disk access to be stopped without polling > > + * ecore_thread_check(). Note that a cancelled thread may leak > > + * resources if no cleanup function is registered with > > + * EINA_THREAD_CLEANUP_PUSH(). Consider running such code using > > + * eina_thread_cancellable_run(). > > * > > * The user function can cancel itself by calling ecore_thread_cancel(), > > but > > * it should always use the ::Ecore_Thread handle passed to it and never > > @@ -1804,6 +1815,7 @@ EAPI Ecore_Thread *ecore_thread_feedback_run > > (Ecore_Thread_Cb func_heavy, Ecore_T > > * returns @c EINA_TRUE or after the @c func_cancel callback returns. > > * > > * @see ecore_thread_check() > > + * @see eina_thread_cancellable_run() > > */ > > EAPI Eina_Bool ecore_thread_cancel(Ecore_Thread *thread); > > > > diff --git a/src/lib/ecore/ecore_thread.c b/src/lib/ecore/ecore_thread.c > > index 6a68d6b..6a10164 100644 > > --- a/src/lib/ecore/ecore_thread.c > > +++ b/src/lib/ecore/ecore_thread.c > > @@ -202,6 +202,7 @@ _ecore_thread_data_free(void *data) > > static void > > _ecore_thread_join(PH(thread)) > > { > > + DBG("joining thread=%" PRIu64, (uint64_t)thread); > > PHJ(thread); > > } > > > > @@ -320,6 +321,31 @@ _ecore_message_notify_handler(void *data) > > } > > > > static void > > +_ecore_short_job_cleanup(void *data) > > +{ > > + Ecore_Pthread_Worker *work = data; > > + > > + DBG("cleanup work=%p, thread=%" PRIu64, work, (uint64_t)work->self); > > + > > + SLKL(_ecore_running_job_mutex); > > + _ecore_running_job = eina_list_remove(_ecore_running_job, work); > > + SLKU(_ecore_running_job_mutex); > > + > > + if (work->reschedule) > > + { > > + work->reschedule = EINA_FALSE; > > + > > + SLKL(_ecore_pending_job_threads_mutex); > > + _ecore_pending_job_threads = eina_list_append > > (_ecore_pending_job_threads, work); > > + SLKU(_ecore_pending_job_threads_mutex); > > + } > > + else > > + { > > + ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, > > work); > > + } > > +} > > + > > +static void > > _ecore_short_job(PH(thread)) > > { > > Ecore_Pthread_Worker *work; > > @@ -346,19 +372,31 @@ _ecore_short_job(PH(thread)) > > cancel = work->cancel; > > SLKU(work->cancel_mutex); > > work->self = thread; > > + > > + EINA_THREAD_CLEANUP_PUSH(_ecore_short_job_cleanup, work); > > if (!cancel) > > work->u.short_run.func_blocking((void *) work->data, (Ecore_Thread*) > > work); > > + eina_thread_cancellable_set(EINA_FALSE, NULL); > > + EINA_THREAD_CLEANUP_POP(EINA_TRUE); > > +} > > + > > +static void > > +_ecore_feedback_job_cleanup(void *data) > > +{ > > + Ecore_Pthread_Worker *work = data; > > + > > + DBG("cleanup work=%p, thread=%" PRIu64, work, (uint64_t)work->self); > > > > SLKL(_ecore_running_job_mutex); > > _ecore_running_job = eina_list_remove(_ecore_running_job, work); > > SLKU(_ecore_running_job_mutex); > > - > > + > > if (work->reschedule) > > { > > work->reschedule = EINA_FALSE; > > - > > + > > SLKL(_ecore_pending_job_threads_mutex); > > - _ecore_pending_job_threads = eina_list_append > > (_ecore_pending_job_threads, work); > > + _ecore_pending_job_threads_feedback = eina_list_append > > (_ecore_pending_job_threads_feedback, work); SLKU > > (_ecore_pending_job_threads_mutex); } > > else > > @@ -393,52 +431,69 @@ _ecore_feedback_job(PH(thread)) > > cancel = work->cancel; > > SLKU(work->cancel_mutex); > > work->self = thread; > > + > > + EINA_THREAD_CLEANUP_PUSH(_ecore_feedback_job_cleanup, work); > > if (!cancel) > > work->u.feedback_run.func_heavy((void *) work->data, (Ecore_Thread *) > > work); > > + eina_thread_cancellable_set(EINA_FALSE, NULL); > > + EINA_THREAD_CLEANUP_POP(EINA_TRUE); > > +} > > > > - SLKL(_ecore_running_job_mutex); > > - _ecore_running_job = eina_list_remove(_ecore_running_job, work); > > - SLKU(_ecore_running_job_mutex); > > +static void > > +_ecore_direct_worker_cleanup(void *data) > > +{ > > + Ecore_Pthread_Worker *work = data; > > > > - if (work->reschedule) > > - { > > - work->reschedule = EINA_FALSE; > > - > > - SLKL(_ecore_pending_job_threads_mutex); > > - _ecore_pending_job_threads_feedback = eina_list_append > > (_ecore_pending_job_threads_feedback, work); > > - SLKU(_ecore_pending_job_threads_mutex); > > - } > > - else > > - { > > - ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, > > work); > > - } > > + DBG("cleanup work=%p, thread=%" PRIu64 " (should join)", work, > > (uint64_t)work->self); + > > + ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, work); > > + > > + ecore_main_loop_thread_safe_call_async((Ecore_Cb) _ecore_thread_join, > > + (void*)(intptr_t)PHS()); > > } > > > > static void * > > _ecore_direct_worker(Ecore_Pthread_Worker *work) > > { > > + eina_thread_cancellable_set(EINA_FALSE, NULL); > > eina_thread_name_set(eina_thread_self(), "Ethread-feedback"); > > work->self = PHS(); > > + > > + EINA_THREAD_CLEANUP_PUSH(_ecore_direct_worker_cleanup, work); > > if (work->message_run) > > work->u.message_run.func_main((void *) work->data, (Ecore_Thread *) > > work); else > > work->u.feedback_run.func_heavy((void *) work->data, (Ecore_Thread *) > > work); - > > - ecore_main_loop_thread_safe_call_async(_ecore_thread_handler, work); > > - > > - ecore_main_loop_thread_safe_call_async((Ecore_Cb) _ecore_thread_join, > > - (void*)(intptr_t)PHS()); > > + eina_thread_cancellable_set(EINA_FALSE, NULL); > > + EINA_THREAD_CLEANUP_POP(EINA_TRUE); > > > > return NULL; > > } > > > > +static void > > +_ecore_thread_worker_cleanup(void *data EINA_UNUSED) > > +{ > > + DBG("cleanup thread=%" PRIu64 " (should join)", PHS()); > > + SLKL(_ecore_pending_job_threads_mutex); > > + _ecore_thread_count--; > > + SLKU(_ecore_pending_job_threads_mutex); > > + ecore_main_loop_thread_safe_call_async((Ecore_Cb) _ecore_thread_join, > > + (void*)(intptr_t)PHS()); > > +} > > + > > static void * > > _ecore_thread_worker(void *data EINA_UNUSED) > > { > > + eina_thread_cancellable_set(EINA_FALSE, NULL); > > + EINA_THREAD_CLEANUP_PUSH(_ecore_thread_worker_cleanup, NULL); > > restart: > > + > > + /* these 2 are cancellation points as user cb may enable */ > > _ecore_short_job(PHS()); > > _ecore_feedback_job(PHS()); > > > > + /* from here on, cancellations are guaranteed to be disabled */ > > + > > /* FIXME: Check if there is feedback running task todo, and switch to > > feedback run handler. */ eina_thread_name_set(eina_thread_self(), > > "Ethread-worker"); > > > > @@ -463,12 +518,10 @@ restart: > > SLKU(_ecore_pending_job_threads_mutex); > > goto restart; > > } > > - _ecore_thread_count--; > > - > > - ecore_main_loop_thread_safe_call_async((Ecore_Cb) _ecore_thread_join, > > - (void*)(intptr_t)PHS()); > > SLKU(_ecore_pending_job_threads_mutex); > > > > + EINA_THREAD_CLEANUP_POP(EINA_TRUE); > > + > > return NULL; > > } > > > > @@ -728,6 +781,7 @@ ecore_thread_cancel(Ecore_Thread *thread) > > > > /* Delay the destruction */ > > on_exit: > > + eina_thread_cancel(work->self); /* noop unless > > eina_thread_cancellable_set() was used by user */ SLKL(work->cancel_mutex); > > work->cancel = EINA_TRUE; > > SLKU(work->cancel_mutex); > > diff --git a/src/lib/ecore_con/ecore_con.c b/src/lib/ecore_con/ecore_con.c > > index 63f2c8e..4efcb2a 100644 > > --- a/src/lib/ecore_con/ecore_con.c > > +++ b/src/lib/ecore_con/ecore_con.c > > @@ -3126,11 +3126,19 @@ typedef struct _Efl_Net_Resolve_Async_Data > > } Efl_Net_Resolve_Async_Data; > > > > static void > > -_efl_net_resolve_async_run(void *data, Ecore_Thread *thread) > > +_efl_net_resolve_async_run(void *data, Ecore_Thread *thread EINA_UNUSED) > > { > > Efl_Net_Resolve_Async_Data *d = data; > > > > - while (!ecore_thread_check(thread)) > > + /* allows ecore_thread_cancel() to cancel at some points, see > > + * man:pthreads(7). > > + * > > + * no need to set cleanup functions since the main thread will > > + * handle that with _efl_net_resolve_async_cancel(). > > + */ > > + eina_thread_cancellable_set(EINA_TRUE, NULL); > > + > > + while (EINA_TRUE) > > { > > DBG("resolving host='%s' port='%s'", d->host, d->port); > > d->gai_error = getaddrinfo(d->host, d->port, d->hints, &d->result); > > @@ -3141,6 +3149,8 @@ _efl_net_resolve_async_run(void *data, Ecore_Thread > > *thread) break; > > } > > > > + eina_thread_cancellable_set(EINA_FALSE, NULL); > > + > > if (eina_log_domain_level_check(_ecore_con_log_dom, EINA_LOG_LEVEL_DBG)) > > { > > char buf[INET6_ADDRSTRLEN + sizeof("[]:65536")] = ""; > > @@ -3235,12 +3245,20 @@ typedef struct _Efl_Net_Connect_Async_Data > > } Efl_Net_Connect_Async_Data; > > > > static void > > -_efl_net_connect_async_run(void *data, Ecore_Thread *thread) > > +_efl_net_connect_async_run(void *data, Ecore_Thread *thread EINA_UNUSED) > > { > > Efl_Net_Connect_Async_Data *d = data; > > char buf[INET6_ADDRSTRLEN + sizeof("[]:65536")] = ""; > > int r; > > > > + /* allows ecore_thread_cancel() to cancel at some points, see > > + * man:pthreads(7). > > + * > > + * no need to set cleanup functions since the main thread will > > + * handle that with _efl_net_connect_async_cancel(). > > + */ > > + eina_thread_cancellable_set(EINA_TRUE, NULL); > > + > > d->error = 0; > > > > d->sockfd = efl_net_socket4(d->addr->sa_family, d->type, d->protocol, > > d->close_on_exec); @@ -3251,14 +3269,6 @@ _efl_net_connect_async_run(void > > *data, Ecore_Thread *thread) return; > > } > > > > - if (ecore_thread_check(thread)) > > - { > > - d->error = ECANCELED; > > - close(d->sockfd); > > - d->sockfd = -1; > > - return; > > - } > > - > > if (eina_log_domain_level_check(_ecore_con_log_dom, EINA_LOG_LEVEL_DBG)) > > efl_net_ip_port_fmt(buf, sizeof(buf), d->addr); > > > > @@ -3267,10 +3277,15 @@ _efl_net_connect_async_run(void *data, Ecore_Thread > > *thread) r = connect(d->sockfd, d->addr, d->addrlen); > > if (r < 0) > > { > > + int fd = d->sockfd; > > d->error = errno; > > - close(d->sockfd); > > d->sockfd = -1; > > - DBG("connect(%d, %s) failed: %s", d->sockfd, buf, strerror(errno)); > > + /* close() is a cancellation point, thus unset sockfd before > > + * closing, so the main thread _efl_net_connect_async_cancel() > > + * won't close it again. > > + */ > > + close(fd); > > + DBG("connect(%d, %s) failed: %s", fd, buf, strerror(errno)); > > return; > > } > > > > diff --git a/src/lib/eina/Eina.h b/src/lib/eina/Eina.h > > index f57cc62..a7a364f 100644 > > --- a/src/lib/eina/Eina.h > > +++ b/src/lib/eina/Eina.h > > @@ -243,7 +243,6 @@ extern "C" { > > #include <eina_cpu.h> > > #include <eina_sched.h> > > #include <eina_tiler.h> > > -#include <eina_thread.h> > > #include <eina_hamster.h> > > #include <eina_matrixsparse.h> > > #include <eina_str.h> > > @@ -254,6 +253,7 @@ extern "C" { > > #include <eina_quadtree.h> > > #include <eina_simple_xml_parser.h> > > #include <eina_lock.h> > > +#include <eina_thread.h> /* after eina_lock.h since it will include > > pthread.h with proper flags */ > > #include <eina_prefix.h> > > #include <eina_refcount.h> > > #include <eina_mmap.h> > > diff --git a/src/lib/eina/eina_thread.c b/src/lib/eina/eina_thread.c > > index 52cbc39..d40073a 100644 > > --- a/src/lib/eina/eina_thread.c > > +++ b/src/lib/eina/eina_thread.c > > @@ -23,6 +23,7 @@ > > #include <stdlib.h> > > > > #include "eina_config.h" > > +#include "eina_lock.h" /* it will include pthread.h with proper flags */ > > #include "eina_thread.h" > > #include "eina_sched.h" > > #include "eina_cpu.h" > > @@ -226,6 +227,37 @@ eina_thread_name_set(Eina_Thread t, const char *name) > > return EINA_FALSE; > > } > > > > +EAPI Eina_Bool > > +eina_thread_cancel(Eina_Thread t) > > +{ > > + return pthread_cancel((pthread_t)t) == 0; > > +} > > + > > +EAPI Eina_Bool > > +eina_thread_cancellable_set(Eina_Bool cancellable, Eina_Bool > > *was_cancellable) +{ > > + int state = cancellable ? PTHREAD_CANCEL_ENABLE : > > PTHREAD_CANCEL_DISABLE; > > + int old = 0; > > + int r; > > + > > + /* enforce deferred in case users changed to asynchronous themselves */ > > + pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &old); > > + > > + r = pthread_setcancelstate(state, &old); > > + if (was_cancellable && r == 0) > > + *was_cancellable = (old == PTHREAD_CANCEL_ENABLE); > > + > > + return r == 0; > > +} > > + > > +EAPI void > > +eina_thread_cancel_checkpoint(void) > > +{ > > + pthread_testcancel(); > > +} > > + > > +EAPI const void *EINA_THREAD_JOIN_CANCELED = PTHREAD_CANCELED; > > + > > Eina_Bool > > eina_thread_init(void) > > { > > diff --git a/src/lib/eina/eina_thread.h b/src/lib/eina/eina_thread.h > > index 6a2c26d..07ecec3 100644 > > --- a/src/lib/eina/eina_thread.h > > +++ b/src/lib/eina/eina_thread.h > > @@ -100,6 +100,20 @@ EAPI Eina_Bool eina_thread_create(Eina_Thread *t, > > Eina_Thread_Cb func, const void *data) > > EINA_ARG_NONNULL(1, 4) EINA_WARN_UNUSED_RESULT; > > > > /** > > + * The return value of eina_thread_join() if it was canceled with > > + * eina_thread_cancel(). > > + * > > + * A thread must be explicitly flagged as cancellable with > > + * eina_thread_cancellable_set(), by default it's not and this value > > + * shouldn't be returned. > > + * > > + * @see eina_thread_join() > > + * > > + * @since 1.19 > > + */ > > +EAPI extern const void *EINA_THREAD_JOIN_CANCELED; > > + > > +/** > > * Join a currently running thread, waiting until it finishes. > > * > > * This function will block the current thread until @a t > > @@ -110,6 +124,8 @@ EAPI Eina_Bool eina_thread_create(Eina_Thread *t, > > * @param t thread identifier to wait. > > * @return value returned by @a t creation function @c func() or > > * @c NULL on errors. Check error with @ref Eina_Error_Group. > > + * If the thread was canceled, it will return > > + * EINA_THREAD_JOIN_CANCELED. > > * @since 1.8 > > */ > > EAPI void *eina_thread_join(Eina_Thread t); > > @@ -132,6 +148,209 @@ EAPI void *eina_thread_join(Eina_Thread t); > > EAPI Eina_Bool eina_thread_name_set(Eina_Thread t, const char *name); > > > > /** > > + * Attempt to cancel a running thread. > > + * > > + * This function sends a cancellation request to the thread, however > > + * that request is only fulfilled if the thread is cancellable > > + * (eina_thread_cancellable_set() with EINA_TRUE as first paramter) > > + * and it will wait for a cancellation point, be > > + * eina_thread_cancel_checkpoint() or some syscall as defined in > > + * man:pthreads(7). > > + * > > + * A thread that was canceled will return EINA_THREAD_JOIN_CANCELED > > + * when eina_thread_join() is called. > > + * > > + * @param t thread to cancel. > > + * > > + * @return EINA_FALSE if thread was not running, EINA_TRUE > > + * otherwise. Note that if a thread is not cancellable and it > > + * is running, this function will return EINA_TRUE! > > + * > > + * @since 1.19 > > + */ > > +EAPI Eina_Bool eina_thread_cancel(Eina_Thread t); > > + > > +/** > > + * Enable or disable if the current thread can be canceled. > > + * > > + * By default eina_thread_create() will return a thread with > > + * cancellation disabled. One can enable the cancellation by using > > + * EINA_TRUE in @a cancellable. > > + * > > + * Eina threads follow pthread_setcanceltype() > > + * PTHREAD_CANCEL_DEFERRED, that is, the actual termination will wait > > + * for a cancellation point, usually a syscall defined in > > + * man:pthreads(7) or an explicit cancellation point defined with > > + * eina_thread_cancel_checkpoint(). > > + * > > + * In order to provide cleanup around critical blocks use > > + * EINA_THREAD_CLEANUP_PUSH() and EINA_THREAD_CLEANUP_POP() macros > > + * (which maps to pthread_cleanup_push() and pthread_cleanup_pop()), > > + * or the helper function eina_thread_cancellable_run() which does the > > + * pair for you. > > + * > > + * @param cancellable if EINA_TRUE, this thread will be accept > > + * cancellation requests. If EINA_FALSE -- the default, it will > > + * ignore cancellation requests. > > + * @param was_cancellable if non-NULL, will return the previous state, > > + * shall you want to restore. > > + * > > + * @return EINA_TRUE if it succeeds in setting the cancellable state > > + * or EINA_FALSE otherwise. > > + * > > + * @see eina_thread_cancel_checkpoint() > > + * @see EINA_THREAD_CLEANUP_PUSH() > > + * @see EINA_THREAD_CLEANUP_POP() > > + * @see eina_thread_cancellable_run() > > + * @see eina_thread_cancel() > > + * > > + * @since 1.19 > > + */ > > +EAPI Eina_Bool eina_thread_cancellable_set(Eina_Bool cancellable, > > Eina_Bool *was_cancellable); + > > +/** > > + * If the current thread is cancellable, this introduces a > > + * cancellation check point. Otherwise it's a no-operation. > > + * > > + * Eina threads follow pthread_setcanceltype() > > + * PTHREAD_CANCEL_DEFERRED, that is, the actual termination will wait > > + * for a cancellation point, usually a syscall defined in > > + * man:pthreads(7) or an explicit cancellation point defined with this > > + * function. > > + * > > + * @see eina_thread_cancel_checkpoint() > > + * > > + * @since 1.19 > > + */ > > +EAPI void eina_thread_cancel_checkpoint(void); > > + > > +/** > > + * @def EINA_THREAD_CLEANUP_PUSH(cleanup, data) > > + * > > + * @brief Push a cleanup function to be executed when the thread is > > + * canceled. > > + * > > + * This macro will schedule a function cleanup(data) to be executed if > > + * the thread is canceled with eina_thread_cancel() and the thread > > + * was previously marked as cancellable with > > + * eina_thread_cancellable_set(). > > + * > > + * It @b must be paired with EINA_THREAD_CLEANUP_POP() in the same > > + * code block as they will expand to do {} while ()! > > + * > > + * The cleanup function may also be executed if > > + * EINA_THREAD_CLEANUP_POP(EINA_TRUE) is used. > > + * > > + * @note If the block within EINA_THREAD_CLEANUP_PUSH() and > > + * EINA_THREAD_CLEANUP_POP() returns, the cleanup callback will > > + * @b not be executed! To avoid problems prefer to use > > + * eina_thread_cancellable_run()! > > + * > > + * @param cleanup the function to execute on cancellation. > > + * @param data the context to give to cleanup function. > > + * > > + * @see eina_thread_cancellable_run() > > + * > > + * @since 1.19 > > + */ > > +#define EINA_THREAD_CLEANUP_PUSH(cleanup, data) \ > > + pthread_cleanup_push(cleanup, data) > > + > > +/** > > + * @def EINA_THREAD_CLEANUP_POP(exec_cleanup) > > + * > > + * @brief Pop a cleanup function to be executed when the thread is > > + * canceled. > > + * > > + * This macro will remove a previously pushed cleanup function, thus > > + * if the thread is canceled with eina_thread_cancel() and the thread > > + * was previously marked as cancellable with > > + * eina_thread_cancellable_set(), that cleanup won't be executed > > + * anymore. > > + * > > + * It @b must be paired with EINA_THREAD_CLEANUP_PUSH() in the same > > + * code block as they will expand to do {} while ()! > > + * > > + * @note If the block within EINA_THREAD_CLEANUP_PUSH() and > > + * EINA_THREAD_CLEANUP_POP() returns, the cleanup callback will > > + * @b not be executed even if exec_cleanup is EINA_TRUE! To > > + * avoid problems prefer to use eina_thread_cancellable_run()! > > + * > > + * @param exec_cleanup if EINA_TRUE, the function registered with > > + * EINA_THREAD_CLEANUP_PUSH() will be executed. > > + * > > + * @see eina_thread_cancellable_run() > > + * > > + * @since 1.19 > > + */ > > +#define EINA_THREAD_CLEANUP_POP(exec_cleanup) \ > > + pthread_cleanup_pop(exec_cleanup) > > + > > +/** > > + * @typedef Eina_Thread_Cancellable_Run_Cb > > + * Type for the definition of a cancellable callback to run. > > + * > > + * @since 1.19 > > + */ > > +typedef void *(*Eina_Thread_Cancellable_Run_Cb)(void *data); > > + > > +/** > > + * This function will setup cleanup callback, turn the thread > > + * cancellable, execute the given callback, reset the cancellable > > + * state to its old value, run the cleanup callback and then return > > + * the callback return value. > > + * > > + * @note cleanup_cb is configured @b before the thread is made > > + * cancellable, thus it @b will be executed while @a cb may not > > + * in the case the thread was already canceled and that was > > + * pending. > > + * > > + * This helper does exactly the following code. Shall you need a > > + * slightly different behavior, use the base calls yourself. > > + * > > + * @code > > + * Eina_Bool old = EINA_FALSE; > > + * void *ret; > > + * > > + * EINA_THREAD_CLEANUP_PUSH(cleanup_cb, data); > > + * eina_thread_cancellable_set(EINA_TRUE, &old); // is a cancellation > > point > > + * ret = cb(data); // may not run if was previously canceled > > + * EINA_THREAD_CLEANUP_POP(EINA_TRUE); > > + * eina_thread_cancellable_set(old, NULL); > > + * return ret; > > + * @endcode > > + * > > + * @param cb a cancellable callback to possibly run. The callback @b > > + * may not be executed if the thread had a pending cancellation > > + * request. During its execution the callback may be canceled > > + * at explicit cancellation points using > > + * eina_thread_cancel_checkpoint(), as well as some syscalls > > + * defined in man:pthreads(7). > > + * @param cleanup_cb a cleanup callback to be executed regardless of > > + * the thread being canceled or not. This function will be > > + * executed even if @a cb wasn't. > > + * @param data context to give to both @a cb and @a cleanup_cb. > > + * > > + * @return the return value of @a cb. If the thread was canceled, > > + * this function will not return. > > + * > > + * @since 1.19 > > + */ > > +static inline void * > > +eina_thread_cancellable_run(Eina_Thread_Cancellable_Run_Cb cb, > > Eina_Free_Cb cleanup_cb, void *data) +{ > > + Eina_Bool old = EINA_FALSE; > > + void *ret; > > + > > + EINA_THREAD_CLEANUP_PUSH(cleanup_cb, data); > > + eina_thread_cancellable_set(EINA_TRUE, &old); // is a cancellation point > > + ret = cb(data); // may not run if was previously canceled > > + EINA_THREAD_CLEANUP_POP(EINA_TRUE); > > + eina_thread_cancellable_set(old, NULL); > > + return ret; > > +} > > + > > +/** > > * @} > > */ > > > > > > -- > > > > > > > > -- > Gustavo Sverzut Barbieri > -------------------------------------- > Mobile: +55 (16) 99354-9890 > > ------------------------------------------------------------------------------ > _______________________________________________ > enlightenment-devel mailing list > enlightenment-devel@lists.sourceforge.net > https://lists.sourceforge.net/lists/listinfo/enlightenment-devel > -- ------------- Codito, ergo sum - "I code, therefore I am" -------------- The Rasterman (Carsten Haitzler) ras...@rasterman.com ------------------------------------------------------------------------------ _______________________________________________ enlightenment-devel mailing list enlightenment-devel@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/enlightenment-devel
