[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.10.2.6 and 1.15

version 1.10.2.6, 2012/08/02 09:19:31 version 1.15, 2012/09/10 15:07:53
Line 46  SUCH DAMAGE. Line 46  SUCH DAMAGE.
 #include "global.h"  #include "global.h"
   
   
#pragma GCC visibility push(hidden)/*
 * sched_useTask() - Get and init new task
  *
  * @root = root task
  * return: NULL error or !=NULL prepared task
  */
 inline sched_task_t *  inline sched_task_t *
_sched_useTask(sched_root_task_t * __restrict root)sched_useTask(sched_root_task_t * __restrict root)
 {  {
         sched_task_t *task, *tmp;          sched_task_t *task, *tmp;
   
         TAILQ_FOREACH_SAFE(task, &root->root_unuse, task_node, tmp) {  
                 if (!TASK_ISLOCKED(task)) {  
 #ifdef HAVE_LIBPTHREAD  #ifdef HAVE_LIBPTHREAD
                        pthread_mutex_lock(&root->root_mtx[taskUNUSE]);        pthread_mutex_lock(&root->root_mtx[taskUNUSE]);
 #endif  #endif
           TAILQ_FOREACH_SAFE(task, &root->root_unuse, task_node, tmp) {
                   if (!TASK_ISLOCKED(task)) {
                         TAILQ_REMOVE(&root->root_unuse, task, task_node);                          TAILQ_REMOVE(&root->root_unuse, task, task_node);
 #ifdef HAVE_LIBPTHREAD  
                         pthread_mutex_unlock(&root->root_mtx[taskUNUSE]);  
 #endif  
                         break;                          break;
                 }                  }
         }          }
   #ifdef HAVE_LIBPTHREAD
           pthread_mutex_unlock(&root->root_mtx[taskUNUSE]);
   #endif
   
         if (!task) {          if (!task) {
                 task = malloc(sizeof(sched_task_t));                  task = malloc(sizeof(sched_task_t));
Line 79  _sched_useTask(sched_root_task_t * __restrict root) Line 83  _sched_useTask(sched_root_task_t * __restrict root)
         return task;          return task;
 }  }
   
   /*
    * sched_unuseTask() - Unlock and put task to unuse queue
    *
    * @task = task
    * return: always is NULL
    */
 inline sched_task_t *  inline sched_task_t *
_sched_unuseTask(sched_task_t * __restrict task)sched_unuseTask(sched_task_t * __restrict task)
 {  {
         TASK_UNLOCK(task);          TASK_UNLOCK(task);
         TASK_TYPE(task) = taskUNUSE;          TASK_TYPE(task) = taskUNUSE;
Line 96  _sched_unuseTask(sched_task_t * __restrict task) Line 106  _sched_unuseTask(sched_task_t * __restrict task)
         return task;          return task;
 }  }
   
   #pragma GCC visibility push(hidden)
   
   #ifdef HAVE_LIBPTHREAD
   static void
   _sched_threadCleanup(sched_task_t *t)
   {
           if (!t || !TASK_ROOT(t))
                   return;
   
           if (TASK_FLAG(t) == PTHREAD_CREATE_JOINABLE)
                   pthread_detach(pthread_self());
   
           pthread_mutex_lock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
           TAILQ_REMOVE(&TASK_ROOT(t)->root_thread, t, task_node);
           pthread_mutex_unlock(&TASK_ROOT(t)->root_mtx[taskTHREAD]);
   
           sched_unuseTask(t);
   }
   void *
   _sched_threadWrapper(sched_task_t *t)
   {
           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_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
           pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
   
           /* notify parent, thread is ready for execution */
           sem_post(s);
           pthread_testcancel();
   
           ret = TASK_FUNC(t)(t);
   
           pthread_cleanup_pop(42);
           TASK_ROOT(t)->root_ret = ret;
           pthread_exit(ret);
   }
   #endif
   
 #pragma GCC visibility pop  #pragma GCC visibility pop
   
   /*
    * sched_taskExit() - Exit routine for scheduler task, explicit required for thread tasks
    *
    * @task = current task
    * @retcode = return code
    * return: return code
    */
   inline void *
   sched_taskExit(sched_task_t *task, intptr_t retcode)
   {
           if (!task || !TASK_ROOT(task))
                   return (void*) -1;
   
           if (TASK_ROOT(task)->root_hooks.hook_exec.exit)
                   TASK_ROOT(task)->root_hooks.hook_exec.exit(task, (void*) retcode);
   
           TASK_ROOT(task)->root_ret = (void*) retcode;
           return (void*) retcode;
   }
   
   
 /*  /*
  * schedRead() - Add READ I/O task to scheduler queue   * schedRead() - Add READ I/O task to scheduler queue
  *   *
Line 121  schedRead(sched_root_task_t * __restrict root, sched_t Line 197  schedRead(sched_root_task_t * __restrict root, sched_t
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 148  schedRead(sched_root_task_t * __restrict root, sched_t Line 224  schedRead(sched_root_task_t * __restrict root, sched_t
                 pthread_mutex_unlock(&root->root_mtx[taskREAD]);                  pthread_mutex_unlock(&root->root_mtx[taskREAD]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 175  schedWrite(sched_root_task_t * __restrict root, sched_ Line 251  schedWrite(sched_root_task_t * __restrict root, sched_
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 202  schedWrite(sched_root_task_t * __restrict root, sched_ Line 278  schedWrite(sched_root_task_t * __restrict root, sched_
                 pthread_mutex_unlock(&root->root_mtx[taskWRITE]);                  pthread_mutex_unlock(&root->root_mtx[taskWRITE]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 229  schedNode(sched_root_task_t * __restrict root, sched_t Line 305  schedNode(sched_root_task_t * __restrict root, sched_t
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 256  schedNode(sched_root_task_t * __restrict root, sched_t Line 332  schedNode(sched_root_task_t * __restrict root, sched_t
                 pthread_mutex_unlock(&root->root_mtx[taskNODE]);                  pthread_mutex_unlock(&root->root_mtx[taskNODE]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 283  schedProc(sched_root_task_t * __restrict root, sched_t Line 359  schedProc(sched_root_task_t * __restrict root, sched_t
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 310  schedProc(sched_root_task_t * __restrict root, sched_t Line 386  schedProc(sched_root_task_t * __restrict root, sched_t
                 pthread_mutex_unlock(&root->root_mtx[taskPROC]);                  pthread_mutex_unlock(&root->root_mtx[taskPROC]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 341  schedUser(sched_root_task_t * __restrict root, sched_t Line 417  schedUser(sched_root_task_t * __restrict root, sched_t
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 368  schedUser(sched_root_task_t * __restrict root, sched_t Line 444  schedUser(sched_root_task_t * __restrict root, sched_t
                 pthread_mutex_unlock(&root->root_mtx[taskUSER]);                  pthread_mutex_unlock(&root->root_mtx[taskUSER]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 #endif  #endif
Line 396  schedSignal(sched_root_task_t * __restrict root, sched Line 472  schedSignal(sched_root_task_t * __restrict root, sched
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 423  schedSignal(sched_root_task_t * __restrict root, sched Line 499  schedSignal(sched_root_task_t * __restrict root, sched
                 pthread_mutex_unlock(&root->root_mtx[taskSIGNAL]);                  pthread_mutex_unlock(&root->root_mtx[taskSIGNAL]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 450  schedAlarm(sched_root_task_t * __restrict root, sched_ Line 526  schedAlarm(sched_root_task_t * __restrict root, sched_
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 477  schedAlarm(sched_root_task_t * __restrict root, sched_ Line 553  schedAlarm(sched_root_task_t * __restrict root, sched_
                 pthread_mutex_unlock(&root->root_mtx[taskALARM]);                  pthread_mutex_unlock(&root->root_mtx[taskALARM]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
   
#ifdef EVFILT_AIO#ifdef AIO_SUPPORT
 /*  /*
  * schedAIO() - Add AIO task to scheduler queue   * schedAIO() - Add AIO task to scheduler queue
  *   *
Line 505  schedAIO(sched_root_task_t * __restrict root, sched_ta Line 581  schedAIO(sched_root_task_t * __restrict root, sched_ta
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 532  schedAIO(sched_root_task_t * __restrict root, sched_ta Line 608  schedAIO(sched_root_task_t * __restrict root, sched_ta
                 pthread_mutex_unlock(&root->root_mtx[taskAIO]);                  pthread_mutex_unlock(&root->root_mtx[taskAIO]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 546  schedAIO(sched_root_task_t * __restrict root, sched_ta Line 622  schedAIO(sched_root_task_t * __restrict root, sched_ta
  * @fd = file descriptor   * @fd = file descriptor
  * @buffer = Buffer   * @buffer = Buffer
  * @buflen = Buffer length   * @buflen = Buffer length
    * @offset = Offset from start of file, if =-1 from current position
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 inline sched_task_t *  inline 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)                void *buffer, size_t buflen, off_t offset)
 {  {
         struct aiocb *acb;          struct aiocb *acb;
        off_t off = 0;        off_t off;
   
         if (!root || !func || !buffer || !buflen)          if (!root || !func || !buffer || !buflen)
                 return NULL;                  return NULL;
         else  
                 memset(buffer, 0, buflen);  
   
           if (offset == (off_t) -1) {
                   off = lseek(fd, 0, SEEK_CUR);
                   if (off == -1) {
                           LOGERR;
                           return NULL;
                   }
           } else
                   off = offset;
   
         if (!(acb = malloc(sizeof(struct aiocb)))) {          if (!(acb = malloc(sizeof(struct aiocb)))) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 569  schedAIORead(sched_root_task_t * __restrict root, sche Line 653  schedAIORead(sched_root_task_t * __restrict root, sche
         acb->aio_fildes = fd;          acb->aio_fildes = fd;
         acb->aio_nbytes = buflen;          acb->aio_nbytes = buflen;
         acb->aio_buf = buffer;          acb->aio_buf = buffer;
        off = lseek(fd, 0, SEEK_CUR);        acb->aio_offset = off;
        if (off == -1) { 
                LOGERR; 
                free(acb); 
                return NULL; 
        } else 
                acb->aio_offset = off; 
         acb->aio_sigevent.sigev_notify = SIGEV_KEVENT;          acb->aio_sigevent.sigev_notify = SIGEV_KEVENT;
         acb->aio_sigevent.sigev_notify_kqueue = root->root_kq;          acb->aio_sigevent.sigev_notify_kqueue = root->root_kq;
         acb->aio_sigevent.sigev_value.sival_ptr = acb;          acb->aio_sigevent.sigev_value.sival_ptr = acb;
Line 598  schedAIORead(sched_root_task_t * __restrict root, sche Line 676  schedAIORead(sched_root_task_t * __restrict root, sche
  * @fd = file descriptor   * @fd = file descriptor
  * @buffer = Buffer   * @buffer = Buffer
  * @buflen = Buffer length   * @buflen = Buffer length
    * @offset = Offset from start of file, if =-1 from current position
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 inline sched_task_t *  inline 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)                void *buffer, size_t buflen, off_t offset)
 {  {
         struct aiocb *acb;          struct aiocb *acb;
        off_t off = 0;        off_t off;
   
         if (!root || !func || !buffer || !buflen)          if (!root || !func || !buffer || !buflen)
                 return NULL;                  return NULL;
   
           if (offset == (off_t) -1) {
                   off = lseek(fd, 0, SEEK_CUR);
                   if (off == -1) {
                           LOGERR;
                           return NULL;
                   }
           } else
                   off = offset;
   
         if (!(acb = malloc(sizeof(struct aiocb)))) {          if (!(acb = malloc(sizeof(struct aiocb)))) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 619  schedAIOWrite(sched_root_task_t * __restrict root, sch Line 707  schedAIOWrite(sched_root_task_t * __restrict root, sch
         acb->aio_fildes = fd;          acb->aio_fildes = fd;
         acb->aio_nbytes = buflen;          acb->aio_nbytes = buflen;
         acb->aio_buf = buffer;          acb->aio_buf = buffer;
        off = lseek(fd, 0, SEEK_CUR);        acb->aio_offset = off;
        if (off == -1) { 
                LOGERR; 
                free(acb); 
                return NULL; 
        } else 
                acb->aio_offset = off; 
         acb->aio_sigevent.sigev_notify = SIGEV_KEVENT;          acb->aio_sigevent.sigev_notify = SIGEV_KEVENT;
         acb->aio_sigevent.sigev_notify_kqueue = root->root_kq;          acb->aio_sigevent.sigev_notify_kqueue = root->root_kq;
         acb->aio_sigevent.sigev_value.sival_ptr = acb;          acb->aio_sigevent.sigev_value.sival_ptr = acb;
Line 641  schedAIOWrite(sched_root_task_t * __restrict root, sch Line 723  schedAIOWrite(sched_root_task_t * __restrict root, sch
   
 #ifdef EVFILT_LIO  #ifdef EVFILT_LIO
 /*  /*
    * schedLIO() - Add AIO bulk tasks to scheduler queue
    *
    * @root = root task
    * @func = task execution function
    * @arg = 1st func argument
    * @acbs = AIO cb structure addresses
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
    * return: NULL error or !=NULL new queued task
    */
   sched_task_t *
   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)
   {
           sched_task_t *task;
           void *ptr;
   
           if (!root || !func || !acbs || !opt_dlen)
                   return NULL;
   
           /* get new task */
           if (!(task = sched_useTask(root)))
                   return NULL;
   
           task->task_func = func;
           TASK_TYPE(task) = taskLIO;
           TASK_ROOT(task) = root;
   
           TASK_ARG(task) = arg;
           TASK_VAL(task) = (u_long) acbs;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
           if (root->root_hooks.hook_add.lio)
                   ptr = root->root_hooks.hook_add.lio(task, NULL);
           else
                   ptr = NULL;
   
           if (!ptr) {
   #ifdef HAVE_LIBPTHREAD
                   pthread_mutex_lock(&root->root_mtx[taskLIO]);
   #endif
                   TAILQ_INSERT_TAIL(&root->root_lio, TASK_ID(task), task_node);
   #ifdef HAVE_LIBPTHREAD
                   pthread_mutex_unlock(&root->root_mtx[taskLIO]);
   #endif
           } else
                   task = sched_unuseTask(task);
   
           return task;
   }
   
   /*
  * schedLIORead() - Add list of AIO read tasks to scheduler queue   * schedLIORead() - Add list of AIO read tasks to scheduler queue
  *   *
  * @root = root task   * @root = root task
Line 649  schedAIOWrite(sched_root_task_t * __restrict root, sch Line 785  schedAIOWrite(sched_root_task_t * __restrict root, sch
  * @fd = file descriptor   * @fd = file descriptor
  * @bufs = Buffer's list   * @bufs = Buffer's list
  * @nbufs = Number of Buffers   * @nbufs = Number of Buffers
    * @offset = Offset from start of file, if =-1 from current position
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
inline sched_task_t *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)                struct iovec *bufs, size_t nbufs, off_t offset)
 {  {
         struct sigevent sig;          struct sigevent sig;
         struct aiocb **acb;          struct aiocb **acb;
Line 663  schedLIORead(sched_root_task_t * __restrict root, sche Line 800  schedLIORead(sched_root_task_t * __restrict root, sche
         if (!root || !func || !bufs || !nbufs)          if (!root || !func || !bufs || !nbufs)
                 return NULL;                  return NULL;
   
        off = lseek(fd, 0, SEEK_CUR);        if (offset == (off_t) -1) {
        if (off == -1) {                off = lseek(fd, 0, SEEK_CUR);
                LOGERR;                if (off == -1) {
                return NULL;                        LOGERR;
        }                        return NULL;
                 }
         } else
                 off = offset;
   
         if (!(acb = calloc(sizeof(void*), nbufs))) {          if (!(acb = calloc(sizeof(void*), nbufs))) {
                 LOGERR;                  LOGERR;
Line 681  schedLIORead(sched_root_task_t * __restrict root, sche Line 821  schedLIORead(sched_root_task_t * __restrict root, sche
                         for (i = 0; i < nbufs; i++)                          for (i = 0; i < nbufs; i++)
                                 if (acb[i])                                  if (acb[i])
                                         free(acb[i]);                                          free(acb[i]);
                                free(acb);                        free(acb);
                         return NULL;                          return NULL;
                 } else                  } else
                         memset(acb[i], 0, sizeof(struct aiocb));                          memset(acb[i], 0, sizeof(struct aiocb));
Line 698  schedLIORead(sched_root_task_t * __restrict root, sche Line 838  schedLIORead(sched_root_task_t * __restrict root, sche
   
         if (lio_listio(LIO_NOWAIT, acb, nbufs, &sig)) {          if (lio_listio(LIO_NOWAIT, acb, nbufs, &sig)) {
                 LOGERR;                  LOGERR;
                   for (i = 0; i < nbufs; i++)
                           if (acb[i])
                                   free(acb[i]);
                   free(acb);
                 return NULL;                  return NULL;
         }          }
   
        return schedAIO(root, func, arg, (void*) acb, bufs, nbufs);        return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
 }  }
   
 /*  /*
Line 713  schedLIORead(sched_root_task_t * __restrict root, sche Line 857  schedLIORead(sched_root_task_t * __restrict root, sche
  * @fd = file descriptor   * @fd = file descriptor
  * @bufs = Buffer's list   * @bufs = Buffer's list
  * @nbufs = Number of Buffers   * @nbufs = Number of Buffers
    * @offset = Offset from start of file, if =-1 from current position
  * return: NULL error or !=NULL new queued task   * return: NULL error or !=NULL new queued task
  */   */
 inline sched_task_t *  inline 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)                struct iovec *bufs, size_t nbufs, off_t offset)
 {  {
         struct sigevent sig;          struct sigevent sig;
         struct aiocb **acb;          struct aiocb **acb;
Line 727  schedLIOWrite(sched_root_task_t * __restrict root, sch Line 872  schedLIOWrite(sched_root_task_t * __restrict root, sch
         if (!root || !func || !bufs || !nbufs)          if (!root || !func || !bufs || !nbufs)
                 return NULL;                  return NULL;
   
        off = lseek(fd, 0, SEEK_CUR);        if (offset == (off_t) -1) {
        if (off == -1) {                off = lseek(fd, 0, SEEK_CUR);
                LOGERR;                if (off == -1) {
                return NULL;                        LOGERR;
        }                        return NULL;
                 }
         } else
                 off = offset;
   
         if (!(acb = calloc(sizeof(void*), nbufs))) {          if (!(acb = calloc(sizeof(void*), nbufs))) {
                 LOGERR;                  LOGERR;
Line 745  schedLIOWrite(sched_root_task_t * __restrict root, sch Line 893  schedLIOWrite(sched_root_task_t * __restrict root, sch
                         for (i = 0; i < nbufs; i++)                          for (i = 0; i < nbufs; i++)
                                 if (acb[i])                                  if (acb[i])
                                         free(acb[i]);                                          free(acb[i]);
                                free(acb);                        free(acb);
                         return NULL;                          return NULL;
                 } else                  } else
                         memset(acb[i], 0, sizeof(struct aiocb));                          memset(acb[i], 0, sizeof(struct aiocb));
Line 762  schedLIOWrite(sched_root_task_t * __restrict root, sch Line 910  schedLIOWrite(sched_root_task_t * __restrict root, sch
   
         if (lio_listio(LIO_NOWAIT, acb, nbufs, &sig)) {          if (lio_listio(LIO_NOWAIT, acb, nbufs, &sig)) {
                 LOGERR;                  LOGERR;
                   for (i = 0; i < nbufs; i++)
                           if (acb[i])
                                   free(acb[i]);
                   free(acb);
                 return NULL;                  return NULL;
         }          }
   
        return schedAIO(root, func, arg, (void*) acb, bufs, nbufs);        return schedLIO(root, func, arg, (void*) acb, bufs, nbufs);
 }  }
 #endif  /* EVFILT_LIO */  #endif  /* EVFILT_LIO */
#endif  /* EVFILT_AIO */#endif  /* AIO_SUPPORT */
   
 /*  /*
  * schedTimer() - Add TIMER task to scheduler queue   * schedTimer() - Add TIMER task to scheduler queue
Line 793  schedTimer(sched_root_task_t * __restrict root, sched_ Line 945  schedTimer(sched_root_task_t * __restrict root, sched_
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 842  schedTimer(sched_root_task_t * __restrict root, sched_ Line 994  schedTimer(sched_root_task_t * __restrict root, sched_
                 pthread_mutex_unlock(&root->root_mtx[taskTIMER]);                  pthread_mutex_unlock(&root->root_mtx[taskTIMER]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 869  schedEvent(sched_root_task_t * __restrict root, sched_ Line 1021  schedEvent(sched_root_task_t * __restrict root, sched_
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 896  schedEvent(sched_root_task_t * __restrict root, sched_ Line 1048  schedEvent(sched_root_task_t * __restrict root, sched_
                 pthread_mutex_unlock(&root->root_mtx[taskEVENT]);                  pthread_mutex_unlock(&root->root_mtx[taskEVENT]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
   
   
 /*  /*
 * schedEventLo() - Add EVENT_Lo task to scheduler queue * schedTask() - Add regular task to scheduler queue
  *   *
  * @root = root task   * @root = root task
  * @func = task execution function   * @func = task execution function
  * @arg = 1st func argument   * @arg = 1st func argument
 * @val = additional func argument * @prio = regular task priority, 0 is hi priority for regular tasks
  * @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 *
schedEventLo(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long val, schedTask(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long prio, 
                 void *opt_data, size_t opt_dlen)                  void *opt_data, size_t opt_dlen)
 {  {
        sched_task_t *task;        sched_task_t *task, *tmp, *t = NULL;
         void *ptr;          void *ptr;
   
         if (!root || !func)          if (!root || !func)
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
        TASK_TYPE(task) = taskEVENT;        TASK_TYPE(task) = taskTASK;
         TASK_ROOT(task) = root;          TASK_ROOT(task) = root;
   
         TASK_ARG(task) = arg;          TASK_ARG(task) = arg;
        TASK_VAL(task) = val;        TASK_VAL(task) = prio;
   
         TASK_DATA(task) = opt_data;          TASK_DATA(task) = opt_data;
         TASK_DATLEN(task) = opt_dlen;          TASK_DATLEN(task) = opt_dlen;
   
        if (root->root_hooks.hook_add.eventlo)        if (root->root_hooks.hook_add.task)
                ptr = root->root_hooks.hook_add.eventlo(task, NULL);                ptr = root->root_hooks.hook_add.task(task, NULL);
         else          else
                 ptr = NULL;                  ptr = NULL;
   
         if (!ptr) {          if (!ptr) {
 #ifdef HAVE_LIBPTHREAD  #ifdef HAVE_LIBPTHREAD
                pthread_mutex_lock(&root->root_mtx[taskEVENTLO]);                pthread_mutex_lock(&root->root_mtx[taskTASK]);
 #endif  #endif
                TAILQ_INSERT_TAIL(&root->root_eventlo, TASK_ID(task), task_node);                TAILQ_FOREACH_SAFE(t, &root->root_task, task_node, tmp)
                         if (TASK_VAL(task) < TASK_VAL(t))
                                 break;
                 if (!t)
                         TAILQ_INSERT_TAIL(&root->root_task, TASK_ID(task), task_node);
                 else
                         TAILQ_INSERT_BEFORE(t, TASK_ID(task), task_node);
 #ifdef HAVE_LIBPTHREAD  #ifdef HAVE_LIBPTHREAD
                pthread_mutex_unlock(&root->root_mtx[taskEVENTLO]);                pthread_mutex_unlock(&root->root_mtx[taskTASK]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 978  schedSuspend(sched_root_task_t * __restrict root, sche Line 1136  schedSuspend(sched_root_task_t * __restrict root, sche
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 1005  schedSuspend(sched_root_task_t * __restrict root, sche Line 1163  schedSuspend(sched_root_task_t * __restrict root, sche
                 pthread_mutex_unlock(&root->root_mtx[taskSUSPEND]);                  pthread_mutex_unlock(&root->root_mtx[taskSUSPEND]);
 #endif  #endif
         } else          } else
                task = _sched_unuseTask(task);                task = sched_unuseTask(task);
   
         return task;          return task;
 }  }
Line 1032  schedCallOnce(sched_root_task_t * __restrict root, sch Line 1190  schedCallOnce(sched_root_task_t * __restrict root, sch
                 return NULL;                  return NULL;
   
         /* get new task */          /* get new task */
        if (!(task = _sched_useTask(root)))        if (!(task = sched_useTask(root)))
                 return NULL;                  return NULL;
   
         task->task_func = func;          task->task_func = func;
Line 1047  schedCallOnce(sched_root_task_t * __restrict root, sch Line 1205  schedCallOnce(sched_root_task_t * __restrict root, sch
   
         ret = schedCall(task);          ret = schedCall(task);
   
        _sched_unuseTask(task);        sched_unuseTask(task);
         return ret;          return ret;
 }  }
   
   /*
    * schedThread() - Add thread task to scheduler queue
    *
    * @root = root task
    * @func = task execution function
    * @arg = 1st func argument
    * @detach = Detach thread from scheduler, if !=0
    * @ss = stack size
    * @opt_data = Optional data
    * @opt_dlen = Optional data length
    * return: NULL error or !=NULL new queued task
    */
   sched_task_t *
   schedThread(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int detach, 
                   size_t ss, void *opt_data, size_t opt_dlen)
   {
   #ifndef HAVE_LIBPTHREAD
           sched_SetErr(ENOTSUP, "Not supported thread tasks");
           return NULL;
   #endif
           sched_task_t *task;
           void *ptr;
           pthread_attr_t attr;
           sem_t *s = NULL;
   
           if (!root || !func)
                   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 */
           if (!(task = sched_useTask(root))) {
                   sem_destroy(s);
                   free(s);
   
                   return NULL;
           }
   
           task->task_func = func;
           TASK_TYPE(task) = taskTHREAD;
           TASK_ROOT(task) = root;
   
           TASK_ARG(task) = arg;
           TASK_FLAG(task) = detach;
           TASK_RET(task) = (intptr_t) s;
   
           TASK_DATA(task) = opt_data;
           TASK_DATLEN(task) = opt_dlen;
   
           pthread_attr_init(&attr);
           pthread_attr_setdetachstate(&attr, detach);
           if (ss && (errno = pthread_attr_setstacksize(&attr, ss))) {
                   LOGERR;
                   pthread_attr_destroy(&attr);
                   sem_destroy(s);
                   free(s);
                   return sched_unuseTask(task);
           }
           if ((errno = pthread_attr_getstacksize(&attr, &ss))) {
                   LOGERR;
                   pthread_attr_destroy(&attr);
                   sem_destroy(s);
                   free(s);
                   return sched_unuseTask(task);
           } else
                   TASK_FLAG(task) |= (ss << 1);
           if ((errno = pthread_attr_setguardsize(&attr, ss))) {
                   LOGERR;
                   pthread_attr_destroy(&attr);
                   sem_destroy(s);
                   free(s);
                   return sched_unuseTask(task);
           }
   #ifdef SCHED_RR
           pthread_attr_setschedpolicy(&attr, SCHED_RR);
   #else
           pthread_attr_setschedpolicy(&attr, SCHED_OTHER);
   #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]);
                   TAILQ_INSERT_TAIL(&root->root_thread, TASK_ID(task), task_node);
                   pthread_mutex_unlock(&root->root_mtx[taskTHREAD]);
   
                   /* wait for init thread actions */
                   sem_wait(s);
           } else
                   task = sched_unuseTask(task);
   
           sem_destroy(s);
           free(s);
           return task;
   }
   
Removed from v.1.10.2.6  
changed lines
  Added in v.1.15

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