--- libaitsched/src/tasks.c 2012/05/31 14:17:59 1.8.2.1 +++ libaitsched/src/tasks.c 2012/08/02 12:58:02 1.10.2.10 @@ -3,7 +3,7 @@ * by Michael Pounov * * $Author: misho $ -* $Id: tasks.c,v 1.8.2.1 2012/05/31 14:17:59 misho Exp $ +* $Id: tasks.c,v 1.10.2.10 2012/08/02 12:58:02 misho Exp $ * ************************************************************************** The ELWIX and AITNET software is distributed under the following @@ -74,6 +74,8 @@ _sched_useTask(sched_root_task_t * __restrict root) } } + memset(task, 0, sizeof(sched_task_t)); + task->task_id = (uintptr_t) task; return task; } @@ -85,7 +87,7 @@ _sched_unuseTask(sched_task_t * __restrict task) #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&TASK_ROOT(task)->root_mtx[taskUNUSE]); #endif - TAILQ_INSERT_TAIL(&TASK_ROOT(task)->root_unuse, task, task_node); + TAILQ_INSERT_TAIL(&TASK_ROOT(task)->root_unuse, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&TASK_ROOT(task)->root_mtx[taskUNUSE]); #endif @@ -122,9 +124,6 @@ schedRead(sched_root_task_t * __restrict root, sched_t if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskREAD; TASK_ROOT(task) = root; @@ -144,7 +143,7 @@ schedRead(sched_root_task_t * __restrict root, sched_t #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskREAD]); #endif - TAILQ_INSERT_TAIL(&root->root_read, task, task_node); + TAILQ_INSERT_TAIL(&root->root_read, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskREAD]); #endif @@ -179,9 +178,6 @@ schedWrite(sched_root_task_t * __restrict root, sched_ if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskWRITE; TASK_ROOT(task) = root; @@ -201,7 +197,7 @@ schedWrite(sched_root_task_t * __restrict root, sched_ #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskWRITE]); #endif - TAILQ_INSERT_TAIL(&root->root_write, task, task_node); + TAILQ_INSERT_TAIL(&root->root_write, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskWRITE]); #endif @@ -236,9 +232,6 @@ schedNode(sched_root_task_t * __restrict root, sched_t if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskNODE; TASK_ROOT(task) = root; @@ -258,7 +251,7 @@ schedNode(sched_root_task_t * __restrict root, sched_t #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskNODE]); #endif - TAILQ_INSERT_TAIL(&root->root_node, task, task_node); + TAILQ_INSERT_TAIL(&root->root_node, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskNODE]); #endif @@ -293,9 +286,6 @@ schedProc(sched_root_task_t * __restrict root, sched_t if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskPROC; TASK_ROOT(task) = root; @@ -315,7 +305,7 @@ schedProc(sched_root_task_t * __restrict root, sched_t #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskPROC]); #endif - TAILQ_INSERT_TAIL(&root->root_proc, task, task_node); + TAILQ_INSERT_TAIL(&root->root_proc, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskPROC]); #endif @@ -333,13 +323,17 @@ schedProc(sched_root_task_t * __restrict root, sched_t * @arg = 1st func argument * @id = Trigger ID * @opt_data = Optional data - * @opt_dlen = Optional data length + * @opt_dlen = Optional user's trigger flags * return: NULL error or !=NULL new queued task */ sched_task_t * schedUser(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id, void *opt_data, size_t opt_dlen) { +#ifndef EVFILT_USER + sched_SetErr(ENOTSUP, "Not supported kevent() filter"); + return NULL; +#else sched_task_t *task; void *ptr; @@ -350,9 +344,6 @@ schedUser(sched_root_task_t * __restrict root, sched_t if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskUSER; TASK_ROOT(task) = root; @@ -372,7 +363,7 @@ schedUser(sched_root_task_t * __restrict root, sched_t #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskUSER]); #endif - TAILQ_INSERT_TAIL(&root->root_user, task, task_node); + TAILQ_INSERT_TAIL(&root->root_user, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskUSER]); #endif @@ -380,6 +371,7 @@ schedUser(sched_root_task_t * __restrict root, sched_t task = _sched_unuseTask(task); return task; +#endif } /* @@ -407,9 +399,6 @@ schedSignal(sched_root_task_t * __restrict root, sched if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskSIGNAL; TASK_ROOT(task) = root; @@ -429,7 +418,7 @@ schedSignal(sched_root_task_t * __restrict root, sched #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskSIGNAL]); #endif - TAILQ_INSERT_TAIL(&root->root_signal, task, task_node); + TAILQ_INSERT_TAIL(&root->root_signal, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskSIGNAL]); #endif @@ -464,9 +453,6 @@ schedAlarm(sched_root_task_t * __restrict root, sched_ if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskALARM; TASK_ROOT(task) = root; @@ -486,7 +472,7 @@ schedAlarm(sched_root_task_t * __restrict root, sched_ #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskALARM]); #endif - TAILQ_INSERT_TAIL(&root->root_alarm, task, task_node); + TAILQ_INSERT_TAIL(&root->root_alarm, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskALARM]); #endif @@ -496,7 +482,309 @@ schedAlarm(sched_root_task_t * __restrict root, sched_ return task; } +#ifdef AIO_SUPPORT /* + * schedAIO() - Add AIO task to scheduler queue + * + * @root = root task + * @func = task execution function + * @arg = 1st func argument + * @acb = AIO cb structure address + * @opt_data = Optional data + * @opt_dlen = Optional data length + * return: NULL error or !=NULL new queued task + */ +sched_task_t * +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) +{ + sched_task_t *task; + void *ptr; + + if (!root || !func || !acb || !opt_dlen) + return NULL; + + /* get new task */ + if (!(task = _sched_useTask(root))) + return NULL; + + task->task_func = func; + TASK_TYPE(task) = taskAIO; + TASK_ROOT(task) = root; + + TASK_ARG(task) = arg; + TASK_VAL(task) = (u_long) acb; + + TASK_DATA(task) = opt_data; + TASK_DATLEN(task) = opt_dlen; + + if (root->root_hooks.hook_add.aio) + ptr = root->root_hooks.hook_add.aio(task, NULL); + else + ptr = NULL; + + if (!ptr) { +#ifdef HAVE_LIBPTHREAD + pthread_mutex_lock(&root->root_mtx[taskAIO]); +#endif + TAILQ_INSERT_TAIL(&root->root_aio, TASK_ID(task), task_node); +#ifdef HAVE_LIBPTHREAD + pthread_mutex_unlock(&root->root_mtx[taskAIO]); +#endif + } else + task = _sched_unuseTask(task); + + return task; +} + +/* + * schedAIORead() - Add AIO read task to scheduler queue + * + * @root = root task + * @func = task execution function + * @arg = 1st func argument + * @fd = file descriptor + * @buffer = Buffer + * @buflen = Buffer length + * @offset = Offset from start of file, if =-1 from current position + * return: NULL error or !=NULL new queued task + */ +inline sched_task_t * +schedAIORead(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, + void *buffer, size_t buflen, off_t offset) +{ + struct aiocb *acb; + off_t off; + + if (!root || !func || !buffer || !buflen) + 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)))) { + LOGERR; + return NULL; + } else + memset(acb, 0, sizeof(struct aiocb)); + + acb->aio_fildes = fd; + acb->aio_nbytes = buflen; + acb->aio_buf = buffer; + acb->aio_offset = off; + acb->aio_sigevent.sigev_notify = SIGEV_KEVENT; + acb->aio_sigevent.sigev_notify_kqueue = root->root_kq; + acb->aio_sigevent.sigev_value.sival_ptr = acb; + + if (aio_read(acb)) { + LOGERR; + free(acb); + return NULL; + } + + return schedAIO(root, func, arg, acb, buffer, buflen); +} + +/* + * schedAIOWrite() - Add AIO write task to scheduler queue + * + * @root = root task + * @func = task execution function + * @arg = 1st func argument + * @fd = file descriptor + * @buffer = Buffer + * @buflen = Buffer length + * @offset = Offset from start of file, if =-1 from current position + * return: NULL error or !=NULL new queued task + */ +inline sched_task_t * +schedAIOWrite(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, int fd, + void *buffer, size_t buflen, off_t offset) +{ + struct aiocb *acb; + off_t off; + + if (!root || !func || !buffer || !buflen) + 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)))) { + LOGERR; + return NULL; + } else + memset(acb, 0, sizeof(struct aiocb)); + + acb->aio_fildes = fd; + acb->aio_nbytes = buflen; + acb->aio_buf = buffer; + acb->aio_offset = off; + acb->aio_sigevent.sigev_notify = SIGEV_KEVENT; + acb->aio_sigevent.sigev_notify_kqueue = root->root_kq; + acb->aio_sigevent.sigev_value.sival_ptr = acb; + + if (aio_write(acb)) { + LOGERR; + free(acb); + return NULL; + } + + return schedAIO(root, func, arg, acb, buffer, buflen); +} + +#ifdef EVFILT_LIO +/* + * schedLIORead() - Add list of AIO read tasks to scheduler queue + * + * @root = root task + * @func = task execution function + * @arg = 1st func argument + * @fd = file descriptor + * @bufs = Buffer's list + * @nbufs = Number of Buffers + * @offset = Offset from start of file, if =-1 from current position + * return: NULL error or !=NULL new queued task + */ +sched_task_t * +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 sigevent sig; + struct aiocb **acb; + off_t off; + register int i; + + if (!root || !func || !bufs || !nbufs) + return NULL; + + if (offset == (off_t) -1) { + off = lseek(fd, 0, SEEK_CUR); + if (off == -1) { + LOGERR; + return NULL; + } + } else + off = offset; + + if (!(acb = calloc(sizeof(void*), nbufs))) { + LOGERR; + return NULL; + } else + memset(acb, 0, sizeof(void*) * nbufs); + for (i = 0; i < nbufs; off += bufs[i++].iov_len) { + acb[i] = malloc(sizeof(struct aiocb)); + if (!acb[i]) { + LOGERR; + for (i = 0; i < nbufs; i++) + if (acb[i]) + free(acb[i]); + free(acb); + return NULL; + } else + memset(acb[i], 0, sizeof(struct aiocb)); + acb[i]->aio_fildes = fd; + acb[i]->aio_nbytes = bufs[i].iov_len; + acb[i]->aio_buf = bufs[i].iov_base; + acb[i]->aio_offset = off; + acb[i]->aio_lio_opcode = LIO_READ; + } + memset(&sig, 0, sizeof sig); + sig.sigev_notify = SIGEV_KEVENT; + sig.sigev_notify_kqueue = root->root_kq; + sig.sigev_value.sival_ptr = acb; + + if (lio_listio(LIO_NOWAIT, acb, nbufs, &sig)) { + LOGERR; + return NULL; + } + + return schedAIO(root, func, arg, (void*) acb, bufs, nbufs); +} + +/* + * schedLIOWrite() - Add list of AIO write tasks to scheduler queue + * + * @root = root task + * @func = task execution function + * @arg = 1st func argument + * @fd = file descriptor + * @bufs = Buffer's list + * @nbufs = Number of Buffers + * @offset = Offset from start of file, if =-1 from current position + * return: NULL error or !=NULL new queued task + */ +inline sched_task_t * +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 sigevent sig; + struct aiocb **acb; + off_t off; + register int i; + + if (!root || !func || !bufs || !nbufs) + return NULL; + + if (offset == (off_t) -1) { + off = lseek(fd, 0, SEEK_CUR); + if (off == -1) { + LOGERR; + return NULL; + } + } else + off = offset; + + if (!(acb = calloc(sizeof(void*), nbufs))) { + LOGERR; + return NULL; + } else + memset(acb, 0, sizeof(void*) * nbufs); + for (i = 0; i < nbufs; off += bufs[i++].iov_len) { + acb[i] = malloc(sizeof(struct aiocb)); + if (!acb[i]) { + LOGERR; + for (i = 0; i < nbufs; i++) + if (acb[i]) + free(acb[i]); + free(acb); + return NULL; + } else + memset(acb[i], 0, sizeof(struct aiocb)); + acb[i]->aio_fildes = fd; + acb[i]->aio_nbytes = bufs[i].iov_len; + acb[i]->aio_buf = bufs[i].iov_base; + acb[i]->aio_offset = off; + acb[i]->aio_lio_opcode = LIO_WRITE; + } + memset(&sig, 0, sizeof sig); + sig.sigev_notify = SIGEV_KEVENT; + sig.sigev_notify_kqueue = root->root_kq; + sig.sigev_value.sival_ptr = acb; + + if (lio_listio(LIO_NOWAIT, acb, nbufs, &sig)) { + LOGERR; + return NULL; + } + + return schedAIO(root, func, arg, (void*) acb, bufs, nbufs); +} +#endif /* EVFILT_LIO */ +#endif /* AIO_SUPPORT */ + +/* * schedTimer() - Add TIMER task to scheduler queue * * @root = root task @@ -511,7 +799,7 @@ sched_task_t * schedTimer(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, struct timespec ts, void *opt_data, size_t opt_dlen) { - sched_task_t *task, *t = NULL; + sched_task_t *task, *tmp, *t = NULL; void *ptr; struct timespec now; @@ -522,9 +810,6 @@ schedTimer(sched_root_task_t * __restrict root, sched_ if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskTIMER; TASK_ROOT(task) = root; @@ -557,15 +842,15 @@ schedTimer(sched_root_task_t * __restrict root, sched_ pthread_mutex_lock(&root->root_mtx[taskTIMER]); #endif #ifdef TIMER_WITHOUT_SORT - TAILQ_INSERT_TAIL(&root->root_timer, task, task_node); + TAILQ_INSERT_TAIL(&root->root_timer, TASK_ID(task), task_node); #else - TAILQ_FOREACH(t, &root->root_timer, task_node) + TAILQ_FOREACH_SAFE(t, &root->root_timer, task_node, tmp) if (sched_timespeccmp(&TASK_TS(task), &TASK_TS(t), -) < 1) break; if (!t) - TAILQ_INSERT_TAIL(&root->root_timer, task, task_node); + TAILQ_INSERT_TAIL(&root->root_timer, TASK_ID(task), task_node); else - TAILQ_INSERT_BEFORE(t, task, task_node); + TAILQ_INSERT_BEFORE(t, TASK_ID(task), task_node); #endif #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskTIMER]); @@ -601,9 +886,6 @@ schedEvent(sched_root_task_t * __restrict root, sched_ if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskEVENT; TASK_ROOT(task) = root; @@ -623,7 +905,7 @@ schedEvent(sched_root_task_t * __restrict root, sched_ #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskEVENT]); #endif - TAILQ_INSERT_TAIL(&root->root_event, task, task_node); + TAILQ_INSERT_TAIL(&root->root_event, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskEVENT]); #endif @@ -659,9 +941,6 @@ schedEventLo(sched_root_task_t * __restrict root, sche if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskEVENT; TASK_ROOT(task) = root; @@ -681,7 +960,7 @@ schedEventLo(sched_root_task_t * __restrict root, sche #ifdef HAVE_LIBPTHREAD pthread_mutex_lock(&root->root_mtx[taskEVENTLO]); #endif - TAILQ_INSERT_TAIL(&root->root_eventlo, task, task_node); + TAILQ_INSERT_TAIL(&root->root_eventlo, TASK_ID(task), task_node); #ifdef HAVE_LIBPTHREAD pthread_mutex_unlock(&root->root_mtx[taskEVENTLO]); #endif @@ -692,6 +971,60 @@ schedEventLo(sched_root_task_t * __restrict root, sche } /* + * schedSuspend() - Add Suspended task to scheduler queue + * + * @root = root task + * @func = task execution function + * @arg = 1st func argument + * @id = Trigger ID + * @opt_data = Optional data + * @opt_dlen = Optional data length + * return: NULL error or !=NULL new queued task + */ +sched_task_t * +schedSuspend(sched_root_task_t * __restrict root, sched_task_func_t func, void *arg, u_long id, + void *opt_data, size_t opt_dlen) +{ + sched_task_t *task; + void *ptr; + + if (!root || !func) + return NULL; + + /* get new task */ + if (!(task = _sched_useTask(root))) + return NULL; + + task->task_func = func; + TASK_TYPE(task) = taskSUSPEND; + TASK_ROOT(task) = root; + + TASK_ARG(task) = arg; + TASK_VAL(task) = id; + + TASK_DATA(task) = opt_data; + TASK_DATLEN(task) = opt_dlen; + + if (root->root_hooks.hook_add.suspend) + ptr = root->root_hooks.hook_add.suspend(task, NULL); + else + ptr = NULL; + + if (!ptr) { +#ifdef HAVE_LIBPTHREAD + pthread_mutex_lock(&root->root_mtx[taskSUSPEND]); +#endif + TAILQ_INSERT_TAIL(&root->root_suspend, TASK_ID(task), task_node); +#ifdef HAVE_LIBPTHREAD + pthread_mutex_unlock(&root->root_mtx[taskSUSPEND]); +#endif + } else + task = _sched_unuseTask(task); + + return task; +} + +/* * schedCallOnce() - Call once from scheduler * * @root = root task @@ -716,9 +1049,6 @@ schedCallOnce(sched_root_task_t * __restrict root, sch if (!(task = _sched_useTask(root))) return NULL; - memset(task, 0, sizeof(sched_task_t)); - task->task_id = 0; - task->task_lock = 0; task->task_func = func; TASK_TYPE(task) = taskEVENT; TASK_ROOT(task) = root;