[BACK]Return to tasks.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitsched / src

Diff for /libaitsched/src/tasks.c between versions 1.16.6.3 and 1.23

version 1.16.6.3, 2013/08/15 18:40:39 version 1.23, 2014/01/28 13:17:33
Line 12  terms: Line 12  terms:
 All of the documentation and software included in the ELWIX and AITNET  All of the documentation and software included in the ELWIX and AITNET
 Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>  Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
   
Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013Copyright 2004 - 2014
         by Michael Pounov <misho@elwix.org>.  All rights reserved.          by Michael Pounov <misho@elwix.org>.  All rights reserved.
   
 Redistribution and use in source and binary forms, with or without  Redistribution and use in source and binary forms, with or without
Line 115  _sched_threadCleanup(sched_task_t *t) Line 115  _sched_threadCleanup(sched_task_t *t)
         if (!t || !TASK_ROOT(t))          if (!t || !TASK_ROOT(t))
                 return;                  return;
   
         if (TASK_FLAG(t) == PTHREAD_CREATE_JOINABLE)  
                 pthread_detach(pthread_self());  
   
         pthread_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);          pthread_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
         TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);          TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);
         pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);          pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
   
         sched_unuseTask(t);          sched_unuseTask(t);
 }  }
 void *  void *
 _sched_threadWrapper(sched_task_t *t)  _sched_threadWrapper(sched_task_t *t)
 {  {
         void *ret = NULL;          void *ret = NULL;
         sem_t *s = NULL;  
   
         if (!t || !TASK_ROOT(t) || !TASK_RET(t))  
                 pthread_exit(ret);  
         else  
                 s = (sem_t*) TASK_RET(t);  
   
         pthread_cleanup_push((void (*)(void*)) _sched_threadCleanup, t);          pthread_cleanup_push((void (*)(void*)) _sched_threadCleanup, t);
   
           if (!t || !TASK_ROOT(t))
                   pthread_exit(ret);
   
         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);          pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
           /*
         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);          pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
           */
   
         /* notify parent, thread is ready for execution */          /* notify parent, thread is ready for execution */
         sem_post(s);  
         pthread_testcancel();          pthread_testcancel();
   
        ret = TASK_FUNC(t)(t);        ret = schedCall(t);
   
         pthread_cleanup_pop(42);          pthread_cleanup_pop(42);
         TASK_ROOT(t)->root_ret = ret;          TASK_ROOT(t)->root_ret = ret;
Line 152  _sched_threadWrapper(sched_task_t *t) Line 146  _sched_threadWrapper(sched_task_t *t)
 }  }
 #endif  #endif
   
   #if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
   void *
   _sched_rtcWrapper(sched_task_t *t)
   {
           sched_task_func_t func;
           sched_task_t *task;
           sched_root_task_t *r;
   
           if (!t || !TASK_ROOT(t) || !TASK_DATA(t))
                   return NULL;
           else {
                   r = TASK_ROOT(t);
                   task = (sched_task_t*) TASK_DATA(t);
                   func = TASK_FUNC(task);
           }
   
   #ifdef HAVE_LIBPTHREAD
           pthread_mutex_lock(&r->root_mtx[taskRTC]);
   #endif
           TAILQ_REMOVE(&r->root_rtc, task, task_node);
   #ifdef HAVE_LIBPTHREAD
           pthread_mutex_unlock(&r->root_mtx[taskRTC]);
   #endif
           sched_unuseTask(task);
   
           timer_delete((timer_t) TASK_DATLEN(t));
   
           return schedCall(task);
   }
   #endif
   
 #pragma GCC visibility pop  #pragma GCC visibility pop
   
 /*  /*
Line 298  sched_task_t * Line 323  sched_task_t *
 schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,   schedNode(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 335  schedNode(sched_root_task_t * __restrict root, sched_t Line 364  schedNode(sched_root_task_t * __restrict root, sched_t
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 352  sched_task_t * Line 382  sched_task_t *
 schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long pid,   schedProc(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long pid, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 389  schedProc(sched_root_task_t * __restrict root, sched_t Line 423  schedProc(sched_root_task_t * __restrict root, sched_t
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 406  sched_task_t * Line 441  sched_task_t *
 schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id,   schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
 #ifndef EVFILT_USER  #ifndef EVFILT_USER
         sched_SetErr(ENOTSUP, "Not supported kevent() filter");          sched_SetErr(ENOTSUP, "Not supported kevent() filter");
         return NULL;          return NULL;
Line 447  schedUser(sched_root_task_t * __restrict root, sched_t Line 486  schedUser(sched_root_task_t * __restrict root, sched_t
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
#endif#endif  /* EVFILT_USER */
 #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 465  sched_task_t * Line 505  sched_task_t *
 schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long sig,   schedSignal(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long sig, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 502  schedSignal(sched_root_task_t * __restrict root, sched Line 546  schedSignal(sched_root_task_t * __restrict root, sched
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 519  sched_task_t * Line 564  sched_task_t *
 schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,   schedAlarm(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 556  schedAlarm(sched_root_task_t * __restrict root, sched_ Line 605  schedAlarm(sched_root_task_t * __restrict root, sched_
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #endif  /* KQ_DISABLE */
 }  }
   
 #ifdef AIO_SUPPORT  #ifdef AIO_SUPPORT
Line 574  sched_task_t * Line 624  sched_task_t *
 schedAIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,   schedAIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
                 struct aiocb * __restrict acb, void *opt_data, size_t opt_dlen)                  struct aiocb * __restrict acb, void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 611  schedAIO(sched_root_task_t * __restrict root, sched_ta Line 665  schedAIO(sched_root_task_t * __restrict root, sched_ta
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 629  sched_task_t * Line 684  sched_task_t *
 schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,   schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 void *buffer, size_t buflen, off_t offset)                  void *buffer, size_t buflen, off_t offset)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         struct aiocb *acb;          struct aiocb *acb;
         off_t off;          off_t off;
   
Line 665  schedAIORead(sched_root_task_t * __restrict root, sche Line 724  schedAIORead(sched_root_task_t * __restrict root, sche
         }          }
   
         return schedAIO(root, func, arg, acb, buffer, buflen);          return schedAIO(root, func, arg, acb, buffer, buflen);
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 683  sched_task_t * Line 743  sched_task_t *
 schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,   schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 void *buffer, size_t buflen, off_t offset)                  void *buffer, size_t buflen, off_t offset)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         struct aiocb *acb;          struct aiocb *acb;
         off_t off;          off_t off;
   
Line 719  schedAIOWrite(sched_root_task_t * __restrict root, sch Line 783  schedAIOWrite(sched_root_task_t * __restrict root, sch
         }          }
   
         return schedAIO(root, func, arg, acb, buffer, buflen);          return schedAIO(root, func, arg, acb, buffer, buflen);
   #endif  /* KQ_DISABLE */
 }  }
   
 #ifdef EVFILT_LIO  #ifdef EVFILT_LIO
Line 737  sched_task_t * Line 802  sched_task_t *
 schedLIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg,   schedLIO(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
                 struct aiocb ** __restrict acbs, void *opt_data, size_t opt_dlen)                  struct aiocb ** __restrict acbs, void *opt_data, size_t opt_dlen)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 774  schedLIO(sched_root_task_t * __restrict root, sched_ta Line 843  schedLIO(sched_root_task_t * __restrict root, sched_ta
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 792  sched_task_t * Line 862  sched_task_t *
 schedLIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,   schedLIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 struct iovec *bufs, size_t nbufs, off_t offset)                  struct iovec *bufs, size_t nbufs, off_t offset)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         struct sigevent sig;          struct sigevent sig;
         struct aiocb **acb;          struct aiocb **acb;
         off_t off;          off_t off;
Line 846  schedLIORead(sched_root_task_t * __restrict root, sche Line 920  schedLIORead(sched_root_task_t * __restrict root, sche
         }          }
   
         return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);          return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
   #endif  /* KQ_DISABLE */
 }  }
   
 /*  /*
Line 864  sched_task_t * Line 939  sched_task_t *
 schedLIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd,   schedLIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, 
                 struct iovec *bufs, size_t nbufs, off_t offset)                  struct iovec *bufs, size_t nbufs, off_t offset)
 {  {
   #ifdef KQ_DISABLE
           sched_SetErr(ENOTSUP, "disabled kqueue support");
           return NULL;
   #else
         struct sigevent sig;          struct sigevent sig;
         struct aiocb **acb;          struct aiocb **acb;
         off_t off;          off_t off;
Line 918  schedLIOWrite(sched_root_task_t * __restrict root, sch Line 997  schedLIOWrite(sched_root_task_t * __restrict root, sch
         }          }
   
         return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);          return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
   #endif  /* KQ_DISABLE */
 }  }
 #endif  /* EVFILT_LIO */  #endif  /* EVFILT_LIO */
 #endif  /* AIO_SUPPORT */  #endif  /* AIO_SUPPORT */
Line 1215  schedCallOnce(sched_root_task_t * __restrict root, sch Line 1295  schedCallOnce(sched_root_task_t * __restrict root, sch
  * @root = root task   * @root = root task
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
  * @detach = Detach thread from scheduler, if !=0  
  * @ss = stack size   * @ss = stack size
  * @opt_data = Optional data   * @opt_data = Optional data
  * @opt_dlen = Optional data length   * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
schedThread(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int detach, schedThread(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, 
                 size_t ss, void *opt_data, size_t opt_dlen)                  size_t ss, void *opt_data, size_t opt_dlen)
 {  {
 #ifndef HAVE_LIBPTHREAD  #ifndef HAVE_LIBPTHREAD
Line 1230  schedThread(sched_root_task_t * __restrict root, sched Line 1309  schedThread(sched_root_task_t * __restrict root, sched
         return NULL;          return NULL;
 #endif  #endif
         sched_task_t *task;          sched_task_t *task;
         void *ptr;  
         pthread_attr_t attr;          pthread_attr_t attr;
         sem_t *s = NULL;  
   
         if (!root || !func)          if (!root || !func)
                 return NULL;                  return NULL;
         else {  
                 /* normalizing stack size & detach state */  
                 if (ss)  
                         ss &= 0x7FFFFFFF;  
                 detach = detach ? PTHREAD_CREATE_DETACHED : PTHREAD_CREATE_JOINABLE;  
         }  
   
         if (!(s = (sem_t*) malloc(sizeof(sem_t)))) {  
                 LOGERR;  
                 return NULL;  
         }  
         if (sem_init(s, 0, 1)) {  
                 LOGERR;  
                 free(s);  
                 return NULL;  
         }  
   
         /* get new task */          /* get new task */
         if (!(task = sched_useTask(root))) {          if (!(task = sched_useTask(root))) {
                 sem_destroy(s);  
                 free(s);  
   
                 return NULL;                  return NULL;
         }          }
Line 1266  schedThread(sched_root_task_t * __restrict root, sched Line 1325  schedThread(sched_root_task_t * __restrict root, sched
         TASK_ROOT(task) = root;          TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
         TASK_FLAG(task) = detach;  
         TASK_RET(task) = (intptr_t) s;  
   
         TASK_DATA(task) = opt_data;          TASK_DATA(task) = opt_data;
         TASK_DATLEN(task) = opt_dlen;          TASK_DATLEN(task) = opt_dlen;
   
         pthread_attr_init(&attr);          pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr, detach);        pthread_attr_setdetachstate(&attr, PTHREAD_DETACHED);
         if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {          if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {
                 LOGERR;                  LOGERR;
                 pthread_attr_destroy(&attr);                  pthread_attr_destroy(&attr);
                 sem_destroy(s);  
                 free(s);  
                 return sched_unuseTask(task);                  return sched_unuseTask(task);
         }          }
         if ((errno = pthread_attr_getstacksize(&attr, &ss))) {          if ((errno = pthread_attr_getstacksize(&attr, &ss))) {
                 LOGERR;                  LOGERR;
                 pthread_attr_destroy(&attr);                  pthread_attr_destroy(&attr);
                 sem_destroy(s);  
                 free(s);  
                 return sched_unuseTask(task);                  return sched_unuseTask(task);
         } else          } else
                TASK_FLAG(task) |= (ss << 1);                TASK_FLAG(task) = ss;
         if ((errno = pthread_attr_setguardsize(&attr, ss))) {          if ((errno = pthread_attr_setguardsize(&attr, ss))) {
                 LOGERR;                  LOGERR;
                 pthread_attr_destroy(&attr);                  pthread_attr_destroy(&attr);
                 sem_destroy(s);  
                 free(s);  
                 return sched_unuseTask(task);                  return sched_unuseTask(task);
         }          }
 #ifdef SCHED_RR  #ifdef SCHED_RR
Line 1301  schedThread(sched_root_task_t * __restrict root, sched Line 1352  schedThread(sched_root_task_t * __restrict root, sched
 #else  #else
         pthread_attr_setschedpolicy(&attr, SCHED_OTHER);          pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
 #endif  #endif
         if (root->root_hooks.hook_add.thread)  
                 ptr = root->root_hooks.hook_add.thread(task, &attr);  
         else  
                 ptr = NULL;  
         pthread_attr_destroy(&attr);  
   
        if (!ptr) {        pthread_mutex_lock(&root->root_mtx[taskTHREAD]);
                pthread_mutex_lock(&root->root_mtx[taskTHREAD]);        TAILQ_INSERT_TAIL(&root->root_thread, TASK_ID(task), task_node);
                TAILQ_INSERT_TAIL(&root->root_thread, TASK_ID(task), task_node);        pthread_mutex_unlock(&root->root_mtx[taskTHREAD]);
                pthread_mutex_unlock(&root->root_mtx[taskTHREAD]); 
   
                /* wait for init thread actions */        if (root->root_hooks.hook_add.thread)
                sem_wait(s);                if (root->root_hooks.hook_add.thread(task, &attr)) {
        } else                        schedCancel(task);
                task = sched_unuseTask(task);                        task = NULL;
                }
        sem_destroy(s);        pthread_attr_destroy(&attr);
        free(s); 
         return task;          return task;
 }  }
   
Line 1330  schedThread(sched_root_task_t * __restrict root, sched Line 1374  schedThread(sched_root_task_t * __restrict root, sched
  * @arg = 1st func argument   * @arg = 1st func argument
  * @ts = timeout argument structure, minimum alarm timer resolution is 1msec!   * @ts = timeout argument structure, minimum alarm timer resolution is 1msec!
  * @opt_data = Optional RTC ID   * @opt_data = Optional RTC ID
 * @opt_dlen = Optional Signal No. * @opt_dlen = Optional data length
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 sched_task_t *  sched_task_t *
 schedRTC(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts,   schedRTC(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
   #if defined(HAVE_TIMER_CREATE) && defined(HAVE_TIMER_SETTIME)
         sched_task_t *task;          sched_task_t *task;
         void *ptr;          void *ptr;
   
Line 1374  schedRTC(sched_root_task_t * __restrict root, sched_ta Line 1419  schedRTC(sched_root_task_t * __restrict root, sched_ta
                 task = sched_unuseTask(task);                  task = sched_unuseTask(task);
   
         return task;          return task;
   #else
           sched_SetErr(ENOTSUP, "Not supported realtime clock extensions");
           return NULL;
   #endif
 }  }
Removed from v.1.16.6.3  
changed lines
  Added in v.1.23

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>