alpine/after.c

   1 #if !defined(lint) && !defined(DOS)
   2 static char rcsid[] = "$Id: after.c 138 2006-09-22 22:12:03Z mikes@u.washington.edu $";
   3 #endif
   4
   5 /* ========================================================================
   6  * Copyright 2013-2018 Eduardo Chappa
   7  * Copyright 2006-2007 University of Washington
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *     http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * ========================================================================
  16  */
  17
  18 /*======================================================================
  19      Implement asynchronous start_after() call
  20  ====*/
  21
  22
  23 #include <system.h>
  24 #include <general.h>
  25
  26 #include "../pith/debug.h"
  27 #include "../pith/osdep/err_desc.h"
  28
  29 #include "../pico/utf8stub.h"
  30
  31 #include "after.h"
  32
  33
  34 /* internal state */
  35 int      after_active;
  36
  37 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
  38 static pthread_t after_thread;
  39 static pthread_mutex_t status_message_mutex;
  40 #endif
  41
  42
  43 /* internal prototypes */
  44 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
  45 void    *do_after(void *);
  46 #else
  47 void    *cleanup_data;
  48 #endif
  49
  50 void     cleanup_after(void *);
  51
  52
  53 /*
  54  * start_after - pause and/or loop calling passed function
  55  *               without getting in the way of main thread
  56  *
  57  */
  58 void
  59 start_after(AFTER_S *a)
  60 {
  61     if(a){
  62 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
  63         pthread_attr_t attr;
  64         int rc;
  65         size_t stack;
  66
  67         if(after_active)
  68           stop_after(1);
  69
  70         /* Initialize and set thread detached attribute */
  71         pthread_attr_init(&attr);
  72         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
  73 #if     defined(PTHREAD_STACK_MIN)
  74         stack = PTHREAD_STACK_MIN + 0x10000;
  75         pthread_attr_setstacksize(&attr, stack);
  76 #endif
  77
  78         if((rc = pthread_create(&after_thread, &attr, do_after, (void *) a)) != 0){
  79             after_active = 0;
  80             dprint((1, "start_after: pthread_create failed %d (%d)", rc, errno));
  81         }
  82         else
  83           after_active = 1;
  84
  85         pthread_attr_destroy(&attr);
  86         dprint((9, "start_after() created %x: done", after_thread));
  87 #else /* !(defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)) */
  88         /*
  89          * Just call the first function
  90          */
  91         if(!a->delay)
  92           (void) (*a->f)(a->data);              /* do the thing */
  93
  94         cleanup_data = (void *) a;
  95         after_active = 1;
  96 #endif
  97     }
  98 }
  99
 100
 101 /*
 102  * stop_after - stop the thread
 103  */
 104 void
 105 stop_after(int join)
 106 {
 107 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
 108     int rv;
 109
 110     dprint((9, "stop_after(join=%d) tid=%x", join, pthread_self()));
 111
 112     if(after_active){
 113         if((rv = pthread_cancel(after_thread)) != 0){   /* tell thread to end */
 114             dprint((1, "pthread_cancel: %d (%s)\n", rv, error_description(errno)));
 115         }
 116
 117         if(join){
 118             if((rv = pthread_join(after_thread, NULL)) != 0){ /* wait for it to end */
 119                 dprint((1, "pthread_join: %d (%s)\n", rv, error_description(errno)));
 120             }
 121         }
 122         else if((rv = pthread_detach(after_thread)) != 0){ /* mark thread for deletion */
 123             dprint((1, "pthread_detach: %d (%s)\n", rv, error_description(errno)));
 124         }
 125     }
 126
 127     /* not literally true uless "join" set */
 128     after_active = 0;
 129
 130 #else   /* !(defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)) */
 131
 132     cleanup_after((void *) cleanup_data);
 133     cleanup_data = NULL;
 134     after_active = 0;
 135
 136 #endif
 137 }
 138
 139
 140 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
 141 /*
 142  * do_after - loop thru list of pause/loop functions
 143  */
 144 void *
 145 do_after(void *data)
 146 {
 147     AFTER_S         *a;
 148     struct timespec  ts;
 149     int              loop;
 150     sigset_t         sigs;
 151
 152 #if defined(SIGCHLD) || defined(SIGWINCH)
 153     sigemptyset(&sigs);
 154 #if defined(SIGCHLD)
 155     /* make sure we don't end up with SIGCHLD */
 156     sigaddset(&sigs, SIGCHLD);
 157 #endif  /* SIGCHLD */
 158 #if defined(SIGCHLD)
 159     /* or with SIGWINCH */
 160     sigaddset(&sigs, SIGWINCH);
 161 #endif  /* SIGWINCH */
 162     pthread_sigmask(SIG_BLOCK, &sigs, NULL);
 163 #endif
 164
 165     /* prepare for the finish */
 166     pthread_cleanup_push(cleanup_after, data);
 167     pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
 168     pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
 169
 170     /* and jump in */
 171     for(a  = (AFTER_S *) data; a != NULL && a->f != NULL; a = a->next){
 172         if(a->delay){
 173             ts.tv_sec  = a->delay / 100;        /* seconds */
 174             ts.tv_nsec = (a->delay % 100) * 10000000;
 175
 176             if(nanosleep(&ts, NULL))
 177               pthread_exit(NULL);               /* interrupted */
 178         }
 179
 180         while(1){
 181             /* after waking, make sure we're still wanted */
 182             pthread_testcancel();
 183
 184             loop = (*a->f)(a->data);            /* do the thing */
 185
 186             if(loop > 0){
 187                 ts.tv_sec  = loop / 100;
 188                 ts.tv_nsec = (loop % 100) * 10000000;
 189
 190                 if(nanosleep(&ts, NULL))
 191                   pthread_exit(NULL);           /* interrupted */
 192             }
 193             else
 194               break;
 195         }
 196     }
 197
 198     pthread_cleanup_pop(1);
 199     pthread_exit(NULL);
 200 }
 201
 202 #endif  /* defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP) */
 203
 204
 205 /*
 206  * cleanup_after - give start_after caller opportunity to clean up
 207  *                 their data, then free up AFTER_S list
 208  */
 209 void
 210 cleanup_after(void *data)
 211 {
 212     AFTER_S *a, *an;
 213
 214 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
 215     dprint((9, "cleanup_after() tid=%x", pthread_self()));
 216 #endif
 217
 218     /* free linked list of AFTER_S's */
 219     a = (AFTER_S *) data;
 220     while(a != NULL){
 221         an = a->next;
 222
 223         if(a->cf)
 224           (*a->cf)(a->data);
 225
 226         free((void *) a);
 227
 228         a = an;
 229     }
 230 }
 231
 232
 233 AFTER_S *
 234 new_afterstruct(void)
 235 {
 236     AFTER_S *a;
 237
 238     if((a = (AFTER_S *)malloc(sizeof(AFTER_S))) == NULL){
 239         fatal("Out of memory");
 240     }
 241
 242     memset((void *) a, 0, sizeof(AFTER_S));
 243
 244     return(a);
 245 }
 246
 247
 248 void
 249 status_message_lock_init(void)
 250 {
 251 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
 252     pthread_mutex_init(&status_message_mutex, NULL);
 253 #endif
 254 }
 255
 256
 257 int
 258 status_message_lock(void)
 259 {
 260 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
 261     return(pthread_mutex_lock(&status_message_mutex));
 262 #else
 263     return(0);
 264 #endif
 265 }
 266
 267
 268 int
 269 status_message_unlock(void)
 270 {
 271 #if     defined(HAVE_PTHREAD) && defined(HAVE_NANOSLEEP)
 272     return(pthread_mutex_unlock(&status_message_mutex));
 273 #else
 274     return(0);
 275 #endif
 276 }