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

Diff for /libaitsched/src/hooks.c between versions 1.30 and 1.37.2.2

version 1.30, 2015/07/02 23:27:06 version 1.37.2.2, 2022/11/28 23:29:59
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 - 2015Copyright 2004 - 2022
         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 156  sched_hook_init(void *root, void *arg __unused) Line 156  sched_hook_init(void *root, void *arg __unused)
         }          }
 #else  #else
         r->root_kq ^= r->root_kq;          r->root_kq ^= r->root_kq;
   #endif
   
         FD_ZERO(&r->root_fds[0]);          FD_ZERO(&r->root_fds[0]);
         FD_ZERO(&r->root_fds[1]);          FD_ZERO(&r->root_fds[1]);
#endif        FD_ZERO(&r->root_fds[2]);
   
         return NULL;          return NULL;
 }  }
Line 184  sched_hook_fini(void *root, void *arg __unused) Line 186  sched_hook_fini(void *root, void *arg __unused)
                 r->root_kq = 0;                  r->root_kq = 0;
         }          }
 #else  #else
         FD_ZERO(&r->root_fds[1]);  
         FD_ZERO(&r->root_fds[0]);  
         r->root_kq ^= r->root_kq;          r->root_kq ^= r->root_kq;
 #endif  #endif
   
           FD_ZERO(&r->root_fds[2]);
           FD_ZERO(&r->root_fds[1]);
           FD_ZERO(&r->root_fds[0]);
   
         return NULL;          return NULL;
 }  }
   
Line 204  sched_hook_cancel(void *task, void *arg __unused) Line 208  sched_hook_cancel(void *task, void *arg __unused)
 {  {
         sched_task_t *t = task, *tmp, *tt;          sched_task_t *t = task, *tmp, *tt;
         sched_root_task_t *r = NULL;          sched_root_task_t *r = NULL;
        int flg;        int flg = 0;
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
         struct kevent chg[1];          struct kevent chg[1];
         struct timespec timeout = { 0, 0 };          struct timespec timeout = { 0, 0 };
Line 229  sched_hook_cancel(void *task, void *arg __unused) Line 233  sched_hook_cancel(void *task, void *arg __unused)
         switch (TASK_TYPE(t)) {          switch (TASK_TYPE(t)) {
                 case taskREAD:                  case taskREAD:
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_read, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_read, task_node, tmp)
                                if (TASK_FD(tt) != TASK_FD(t))                                if (TASK_FD(tt) == TASK_FD(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
 #ifdef __NetBSD__  #ifdef __NetBSD__
Line 245  sched_hook_cancel(void *task, void *arg __unused) Line 246  sched_hook_cancel(void *task, void *arg __unused)
 #endif  #endif
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
                         ee.data.fd = TASK_FD(t);                          ee.data.fd = TASK_FD(t);
                           ee.events ^= ee.events;
                         if (FD_ISSET(TASK_FD(t), &r->root_fds[1]))                          if (FD_ISSET(TASK_FD(t), &r->root_fds[1]))
                                ee.events = EPOLLOUT;                                ee.events |= EPOLLOUT;
   
                        if (flg < 2)                        if (flg < 2) {
                                 FD_CLR(TASK_FD(t), &r->root_fds[0]);                                  FD_CLR(TASK_FD(t), &r->root_fds[0]);
                        else                                FD_CLR(TASK_FD(t), &r->root_fds[2]);
                                ee.events |= (EPOLLIN | EPOLLPRI | EPOLLRDHUP);                        } else {
                                 if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))
                                         ee.events |= EPOLLIN;
                                 if (FD_ISSET(TASK_FD(t), &r->root_fds[2]))
                                         ee.events |= EPOLLPRI;
                         }
 #else  #else
                         if (flg < 2) {                          if (flg < 2) {
                                 FD_CLR(TASK_FD(t), &r->root_fds[0]);                                  FD_CLR(TASK_FD(t), &r->root_fds[0]);
                                   FD_CLR(TASK_FD(t), &r->root_fds[2]);
   
                                 /* optimize select */                                  /* optimize select */
                                for (i = r->root_kq - 1; i > 2; i--)                                for (i = r->root_kq - 1; i >= 0; i--)
                                        if (FD_ISSET(i, &r->root_fds[0]) || FD_ISSET(i, &r->root_fds[1]))                                        if (FD_ISSET(i, &r->root_fds[0]) || 
                                                         FD_ISSET(i, &r->root_fds[1]) || 
                                                         FD_ISSET(i, &r->root_fds[2]))
                                                 break;                                                  break;
                                if (i > 2)                                r->root_kq = i + 1;
                                        r->root_kq = i + 1; 
                         }                          }
 #endif  #endif
                         break;                          break;
                 case taskWRITE:                  case taskWRITE:
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_write, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_write, task_node, tmp)
                                if (TASK_FD(tt) != TASK_FD(t))                                if (TASK_FD(tt) == TASK_FD(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
 #ifdef __NetBSD__  #ifdef __NetBSD__
Line 283  sched_hook_cancel(void *task, void *arg __unused) Line 289  sched_hook_cancel(void *task, void *arg __unused)
 #endif  #endif
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
                         ee.data.fd = TASK_FD(t);                          ee.data.fd = TASK_FD(t);
                           ee.events ^= ee.events;
                         if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))                          if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))
                                ee.events = EPOLLIN | EPOLLPRI | EPOLLRDHUP;                                ee.events |= EPOLLIN;
                         if (FD_ISSET(TASK_FD(t), &r->root_fds[2]))
                                 ee.events |= EPOLLPRI;
   
                         if (flg < 2)                          if (flg < 2)
                                 FD_CLR(TASK_FD(t), &r->root_fds[1]);                                  FD_CLR(TASK_FD(t), &r->root_fds[1]);
Line 295  sched_hook_cancel(void *task, void *arg __unused) Line 304  sched_hook_cancel(void *task, void *arg __unused)
                                 FD_CLR(TASK_FD(t), &r->root_fds[1]);                                  FD_CLR(TASK_FD(t), &r->root_fds[1]);
   
                                 /* optimize select */                                  /* optimize select */
                                for (i = r->root_kq - 1; i > 2; i--)                                for (i = r->root_kq - 1; i >= 0; i--)
                                        if (FD_ISSET(i, &r->root_fds[0]) || FD_ISSET(i, &r->root_fds[1]))                                        if (FD_ISSET(i, &r->root_fds[0]) || 
                                                         FD_ISSET(i, &r->root_fds[1]) || 
                                                         FD_ISSET(i, &r->root_fds[2]))
                                                 break;                                                  break;
                                if (i > 2)                                r->root_kq = i + 1;
                                        r->root_kq = i + 1; 
                         }                          }
 #endif  #endif
                         break;                          break;
                 case taskALARM:                  case taskALARM:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_alarm, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_alarm, task_node, tmp)
                                if (TASK_DATA(tt) != TASK_DATA(t))                                if (TASK_DATA(tt) == TASK_DATA(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], (uintptr_t) TASK_DATA(t), EVFILT_TIMER, flg < 2 ? EV_DELETE : 0, 
Line 324  sched_hook_cancel(void *task, void *arg __unused) Line 331  sched_hook_cancel(void *task, void *arg __unused)
                 case taskNODE:                  case taskNODE:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_node, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_node, task_node, tmp)
                                if (TASK_FD(tt) != TASK_FD(t))                                if (TASK_FD(tt) == TASK_FD(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, flg < 2 ? EV_DELETE : 0, 
Line 342  sched_hook_cancel(void *task, void *arg __unused) Line 346  sched_hook_cancel(void *task, void *arg __unused)
                 case taskPROC:                  case taskPROC:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_proc, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_proc, task_node, tmp)
                                if (TASK_VAL(tt) != TASK_VAL(t))                                if (TASK_VAL(tt) == TASK_VAL(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], TASK_VAL(t), EVFILT_PROC, flg < 2 ? EV_DELETE : 0, 
Line 360  sched_hook_cancel(void *task, void *arg __unused) Line 361  sched_hook_cancel(void *task, void *arg __unused)
                 case taskSIGNAL:                  case taskSIGNAL:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_signal, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_signal, task_node, tmp)
                                if (TASK_VAL(tt) != TASK_VAL(t))                                if (TASK_VAL(tt) == TASK_VAL(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], TASK_VAL(t), EVFILT_SIGNAL, flg < 2 ? EV_DELETE : 0, 
Line 382  sched_hook_cancel(void *task, void *arg __unused) Line 380  sched_hook_cancel(void *task, void *arg __unused)
                 case taskAIO:                  case taskAIO:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_aio, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_aio, task_node, tmp)
                                if (TASK_VAL(tt) != TASK_VAL(t))                                if (TASK_VAL(tt) == TASK_VAL(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], TASK_VAL(t), EVFILT_AIO, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], TASK_VAL(t), EVFILT_AIO, flg < 2 ? EV_DELETE : 0, 
Line 399  sched_hook_cancel(void *task, void *arg __unused) Line 394  sched_hook_cancel(void *task, void *arg __unused)
                         if (acb) {                          if (acb) {
                                 if (aio_cancel(acb->aio_fildes, acb) == AIO_CANCELED)                                  if (aio_cancel(acb->aio_fildes, acb) == AIO_CANCELED)
                                         aio_return(acb);                                          aio_return(acb);
                                free(acb);                                e_free(acb);
                                 TASK_VAL(t) = 0;                                  TASK_VAL(t) = 0;
                         }                          }
 #endif  #endif
Line 408  sched_hook_cancel(void *task, void *arg __unused) Line 403  sched_hook_cancel(void *task, void *arg __unused)
                 case taskLIO:                  case taskLIO:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_lio, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_lio, task_node, tmp)
                                if (TASK_VAL(tt) != TASK_VAL(t))                                if (TASK_VAL(tt) == TASK_VAL(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], TASK_VAL(t), EVFILT_LIO, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], TASK_VAL(t), EVFILT_LIO, flg < 2 ? EV_DELETE : 0, 
Line 426  sched_hook_cancel(void *task, void *arg __unused) Line 418  sched_hook_cancel(void *task, void *arg __unused)
                                 for (i = 0; i < TASK_DATLEN(t); i++) {                                  for (i = 0; i < TASK_DATLEN(t); i++) {
                                         if (aio_cancel(acbs[i]->aio_fildes, acbs[i]) == AIO_CANCELED)                                          if (aio_cancel(acbs[i]->aio_fildes, acbs[i]) == AIO_CANCELED)
                                                 aio_return(acbs[i]);                                                  aio_return(acbs[i]);
                                        free(acbs[i]);                                        e_free(acbs[i]);
                                 }                                  }
                                free(acbs);                                e_free(acbs);
                                 TASK_VAL(t) = 0;                                  TASK_VAL(t) = 0;
                         }                          }
 #endif  #endif
Line 439  sched_hook_cancel(void *task, void *arg __unused) Line 431  sched_hook_cancel(void *task, void *arg __unused)
                 case taskUSER:                  case taskUSER:
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_user, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_user, task_node, tmp)
                                if (TASK_VAL(tt) != TASK_VAL(t))                                if (TASK_VAL(tt) == TASK_VAL(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
 #ifdef __NetBSD__  #ifdef __NetBSD__
                         EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, flg < 2 ? EV_DELETE : 0,                           EV_SET(&chg[0], TASK_VAL(t), EVFILT_USER, flg < 2 ? EV_DELETE : 0, 
Line 475  sched_hook_cancel(void *task, void *arg __unused) Line 464  sched_hook_cancel(void *task, void *arg __unused)
                         schedCancel((sched_task_t*) TASK_RET(t));                          schedCancel((sched_task_t*) TASK_RET(t));
 #else  #else
                         /* check for multi subscribers */                          /* check for multi subscribers */
                         flg = 0;  
                         TAILQ_FOREACH_SAFE(tt, &r->root_rtc, task_node, tmp)                          TAILQ_FOREACH_SAFE(tt, &r->root_rtc, task_node, tmp)
                                if (TASK_DATA(tt) != TASK_DATA(t))                                if (TASK_DATA(tt) == TASK_DATA(t))
                                        continue; 
                                else 
                                         flg++;                                          flg++;
   
                         /* restore signal */                          /* restore signal */
Line 495  sched_hook_cancel(void *task, void *arg __unused) Line 481  sched_hook_cancel(void *task, void *arg __unused)
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
         kevent(r->root_kq, chg, 1, NULL, 0, &timeout);          kevent(r->root_kq, chg, 1, NULL, 0, &timeout);
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
        epoll_ctl(r->root_kq, ee.events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, ee.data.fd, &ee);        if (TASK_TYPE(t) == taskREAD || TASK_TYPE(t) == taskWRITE) {
                 epoll_ctl(r->root_kq, ee.events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, ee.data.fd, &ee);
         }
 #endif  #endif
         return NULL;          return NULL;
 }  }
Line 545  sched_hook_thread(void *task, void *arg) Line 533  sched_hook_thread(void *task, void *arg)
  * return: <0 errors and 0 ok   * return: <0 errors and 0 ok
  */   */
 void *  void *
sched_hook_read(void *task, void *arg __unused)sched_hook_read(void *task, void *arg)
 {  {
         sched_task_t *t = task;          sched_task_t *t = task;
         sched_root_task_t *r = NULL;          sched_root_task_t *r = NULL;
           uintptr_t mask = (uintptr_t) arg;
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
         struct kevent chg[1];          struct kevent chg[1];
         struct timespec timeout = { 0, 0 };          struct timespec timeout = { 0, 0 };
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
        struct epoll_event ee = { .events = EPOLLIN | EPOLLPRI | EPOLLRDHUP, .data.fd = 0 };        struct epoll_event ee;
         int flg = 0;          int flg = 0;
 #endif  #endif
   
Line 576  sched_hook_read(void *task, void *arg __unused) Line 565  sched_hook_read(void *task, void *arg __unused)
                 return (void*) -1;                  return (void*) -1;
         }          }
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
        if (FD_ISSET(TASK_FD(t), &r->root_fds[0]))        if (!mask)
                 mask = EPOLLIN | EPOLLPRI;
         ee.data.fd = TASK_FD(t);
         ee.events = mask;
         if (FD_ISSET(TASK_FD(t), &r->root_fds[2])) {
                 flg |= 4;
                 ee.events |= EPOLLPRI;
         }
         if (FD_ISSET(TASK_FD(t), &r->root_fds[0])) {
                 flg |= 1;                  flg |= 1;
                   ee.events |= EPOLLIN;
           }
         if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {          if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {
                 flg |= 2;                  flg |= 2;
                 ee.events |= EPOLLOUT;                  ee.events |= EPOLLOUT;
         }          }
   
         ee.data.fd = TASK_FD(t);  
         if (epoll_ctl(r->root_kq, flg ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, TASK_FD(t), &ee) == -1) {          if (epoll_ctl(r->root_kq, flg ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, TASK_FD(t), &ee) == -1) {
                 if (r->root_hooks.hook_exec.exception)                  if (r->root_hooks.hook_exec.exception)
                         r->root_hooks.hook_exec.exception(r, NULL);                          r->root_hooks.hook_exec.exception(r, NULL);
                 else                  else
                         LOGERR;                          LOGERR;
                 return (void*) -1;                  return (void*) -1;
        } else        } else {
                FD_SET(TASK_FD(t), &r->root_fds[0]);                if (mask & EPOLLIN)
                         FD_SET(TASK_FD(t), &r->root_fds[0]);
                 if (mask & EPOLLPRI)
                         FD_SET(TASK_FD(t), &r->root_fds[2]);
         }
 #else  #else
        FD_SET(TASK_FD(t), &r->root_fds[0]);        if (!mask) {
                 FD_SET(TASK_FD(t), &r->root_fds[0]);
                 FD_SET(TASK_FD(t), &r->root_fds[2]);
         } else {
                 if (mask & 1)
                         FD_SET(TASK_FD(t), &r->root_fds[0]);
                 if (mask & 2)
                         FD_SET(TASK_FD(t), &r->root_fds[2]);
         }
 
         if (TASK_FD(t) >= r->root_kq)          if (TASK_FD(t) >= r->root_kq)
                 r->root_kq = TASK_FD(t) + 1;                  r->root_kq = TASK_FD(t) + 1;
 #endif  #endif
Line 617  sched_hook_write(void *task, void *arg __unused) Line 628  sched_hook_write(void *task, void *arg __unused)
         struct kevent chg[1];          struct kevent chg[1];
         struct timespec timeout = { 0, 0 };          struct timespec timeout = { 0, 0 };
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
        struct epoll_event ee = { .events = EPOLLOUT, .data.fd = 0 };        struct epoll_event ee;
         int flg = 0;          int flg = 0;
 #endif  #endif
   
Line 640  sched_hook_write(void *task, void *arg __unused) Line 651  sched_hook_write(void *task, void *arg __unused)
                 return (void*) -1;                  return (void*) -1;
         }          }
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
           ee.data.fd = TASK_FD(t);
           ee.events = EPOLLOUT;
   
           if (FD_ISSET(TASK_FD(t), &r->root_fds[2])) {
                   flg |= 4;
                   ee.events |= EPOLLPRI;
           }
         if (FD_ISSET(TASK_FD(t), &r->root_fds[0])) {          if (FD_ISSET(TASK_FD(t), &r->root_fds[0])) {
                 flg |= 1;                  flg |= 1;
                ee.events |= EPOLLIN | EPOLLPRI | EPOLLRDHUP;                ee.events |= EPOLLIN;
         }          }
        if (FD_ISSET(TASK_FD(t), &r->root_fds[1]))        if (FD_ISSET(TASK_FD(t), &r->root_fds[1])) {
                 flg |= 2;                  flg |= 2;
           }
   
         ee.data.fd = TASK_FD(t);  
         if (epoll_ctl(r->root_kq, flg ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, TASK_FD(t), &ee) == -1) {          if (epoll_ctl(r->root_kq, flg ? EPOLL_CTL_MOD : EPOLL_CTL_ADD, TASK_FD(t), &ee) == -1) {
                 if (r->root_hooks.hook_exec.exception)                  if (r->root_hooks.hook_exec.exception)
                         r->root_hooks.hook_exec.exception(r, NULL);                          r->root_hooks.hook_exec.exception(r, NULL);
Line 658  sched_hook_write(void *task, void *arg __unused) Line 676  sched_hook_write(void *task, void *arg __unused)
                 FD_SET(TASK_FD(t), &r->root_fds[1]);                  FD_SET(TASK_FD(t), &r->root_fds[1]);
 #else  #else
         FD_SET(TASK_FD(t), &r->root_fds[1]);          FD_SET(TASK_FD(t), &r->root_fds[1]);
   
         if (TASK_FD(t) >= r->root_kq)          if (TASK_FD(t) >= r->root_kq)
                 r->root_kq = TASK_FD(t) + 1;                  r->root_kq = TASK_FD(t) + 1;
 #endif  #endif
Line 708  sched_hook_alarm(void *task, void *arg __unused) Line 727  sched_hook_alarm(void *task, void *arg __unused)
  * sched_hook_node() - Default NODE hook   * sched_hook_node() - Default NODE hook
  *   *
  * @task = current task   * @task = current task
 * @arg = unused * @arg = if arg == 42 then waiting for all events
  * return: <0 errors and 0 ok   * return: <0 errors and 0 ok
  */   */
 void *  void *
sched_hook_node(void *task, void *arg __unused)sched_hook_node(void *task, void *arg)
 {  {
 #if SUP_ENABLE == KQ_SUPPORT  #if SUP_ENABLE == KQ_SUPPORT
         sched_task_t *t = task;          sched_task_t *t = task;
         struct kevent chg[1];          struct kevent chg[1];
         struct timespec timeout = { 0, 0 };          struct timespec timeout = { 0, 0 };
           u_int addflags = (u_int) (uintptr_t) arg;
   
         if (!t || !TASK_ROOT(t))          if (!t || !TASK_ROOT(t))
                 return (void*) -1;                  return (void*) -1;
Line 725  sched_hook_node(void *task, void *arg __unused) Line 745  sched_hook_node(void *task, void *arg __unused)
 #ifdef __NetBSD__  #ifdef __NetBSD__
         EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD | EV_CLEAR,           EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD | EV_CLEAR, 
                         NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB |                           NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | 
                        NOTE_LINK | NOTE_RENAME | NOTE_REVOKE, 0, (intptr_t) TASK_FD(t));                        NOTE_LINK | NOTE_RENAME | NOTE_REVOKE | addflags, 0, (intptr_t) TASK_FD(t));
 #else  #else
         EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD | EV_CLEAR,           EV_SET(&chg[0], TASK_FD(t), EVFILT_VNODE, EV_ADD | EV_CLEAR, 
                         NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB |                           NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | 
                        NOTE_LINK | NOTE_RENAME | NOTE_REVOKE, 0, (void*) TASK_FD(t));                        NOTE_LINK | NOTE_RENAME | NOTE_REVOKE | addflags, 0, (void*) TASK_FD(t));
 #endif  #endif
         if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {          if (kevent(TASK_ROOT(t)->root_kq, chg, 1, NULL, 0, &timeout) == -1) {
                 if (TASK_ROOT(t)->root_hooks.hook_exec.exception)                  if (TASK_ROOT(t)->root_hooks.hook_exec.exception)
Line 861  static inline void  Line 881  static inline void 
 fetch_hook_kevent_proceed(int en, struct kevent *res, sched_root_task_t *r)  fetch_hook_kevent_proceed(int en, struct kevent *res, sched_root_task_t *r)
 {  {
         struct kevent evt[1];          struct kevent evt[1];
        register int i;        register int i, flg;
         sched_task_t *task, *tmp;          sched_task_t *task, *tmp;
         struct timespec now = { 0, 0 };          struct timespec now = { 0, 0 };
 #ifdef AIO_SUPPORT  #ifdef AIO_SUPPORT
Line 869  fetch_hook_kevent_proceed(int en, struct kevent *res,  Line 889  fetch_hook_kevent_proceed(int en, struct kevent *res, 
         struct aiocb *acb;          struct aiocb *acb;
 #ifdef EVFILT_LIO  #ifdef EVFILT_LIO
         int l;          int l;
         register int j;  
         off_t off;          off_t off;
         struct aiocb **acbs;          struct aiocb **acbs;
         struct iovec *iv;          struct iovec *iv;
Line 880  fetch_hook_kevent_proceed(int en, struct kevent *res,  Line 899  fetch_hook_kevent_proceed(int en, struct kevent *res, 
                 memcpy(evt, &res[i], sizeof evt);                  memcpy(evt, &res[i], sizeof evt);
                 evt->flags = EV_DELETE;                  evt->flags = EV_DELETE;
                 /* Put read/write task to ready queue */                  /* Put read/write task to ready queue */
                   flg = 0;
                 switch (res[i].filter) {                  switch (res[i].filter) {
                         case EVFILT_READ:                          case EVFILT_READ:
                                 TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {
                                        if (TASK_FD(task) != ((intptr_t) res[i].udata))                                        if (TASK_FD(task) == ((intptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags; 
                                        } 
                                        /* remove read handle */ 
                                        remove_task_from(task, &r->root_read); 
   
                                        if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {                                                        /* remove read handle */
                                                if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {                                                        remove_task_from(task, &r->root_read);
                                                        task->task_type = taskUNUSE;
                                                        insert_task_to(task, &r->root_unuse);                                                        if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {
                                                } else {                                                                if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {
                                                        task->task_type = taskREADY;                                                                        task->task_type = taskUNUSE;
                                                        insert_task_to(task, &r->root_ready);                                                                        insert_task_to(task, &r->root_unuse);
                                                                 } else {
                                                                         task->task_type = taskREADY;
                                                                         insert_task_to(task, &r->root_ready);
                                                                 }
                                                         } else {
                                                                 task->task_type = taskREADY;
                                                                 insert_task_to(task, &r->root_ready);
                                                         }
                                                 }                                                  }
                                        } else {                                                flg++;
                                                task->task_type = taskREADY; 
                                                insert_task_to(task, &r->root_ready); 
                                         }                                          }
                                 }                                  }
                                 break;                                  break;
                         case EVFILT_WRITE:                          case EVFILT_WRITE:
                                 TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {
                                        if (TASK_FD(task) != ((intptr_t) res[i].udata))                                        if (TASK_FD(task) == ((intptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags; 
                                        } 
                                        /* remove write handle */ 
                                        remove_task_from(task, &r->root_write); 
   
                                        if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {                                                        /* remove write handle */
                                                if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {                                                        remove_task_from(task, &r->root_write);
                                                        task->task_type = taskUNUSE;
                                                        insert_task_to(task, &r->root_unuse);                                                        if (r->root_hooks.hook_exec.exception && res[i].flags & EV_EOF) {
                                                } else {                                                                if (r->root_hooks.hook_exec.exception(r, (void*) EV_EOF)) {
                                                        task->task_type = taskREADY;                                                                        task->task_type = taskUNUSE;
                                                        insert_task_to(task, &r->root_ready);                                                                        insert_task_to(task, &r->root_unuse);
                                                                 } else {
                                                                         task->task_type = taskREADY;
                                                                         insert_task_to(task, &r->root_ready);
                                                                 }
                                                         } else {
                                                                 task->task_type = taskREADY;
                                                                 insert_task_to(task, &r->root_ready);
                                                         }
                                                 }                                                  }
                                        } else {                                                flg++;
                                                task->task_type = taskREADY; 
                                                insert_task_to(task, &r->root_ready); 
                                         }                                          }
                                 }                                  }
                                 break;                                  break;
                         case EVFILT_TIMER:                          case EVFILT_TIMER:
                                 TAILQ_FOREACH_SAFE(task, &r->root_alarm, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_alarm, task_node, tmp) {
                                        if ((uintptr_t) TASK_DATA(task) != ((uintptr_t) res[i].udata))                                        if ((uintptr_t) TASK_DATA(task) == ((uintptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags;
                                                         /* remove alarm handle */
                                                         transit_task2ready(task, &r->root_alarm);
                                                 }
                                                 flg++;
                                         }                                          }
                                         /* remove alarm handle */  
                                         transit_task2ready(task, &r->root_alarm);  
                                 }                                  }
                                 break;                                  break;
                         case EVFILT_VNODE:                          case EVFILT_VNODE:
                                 TAILQ_FOREACH_SAFE(task, &r->root_node, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_node, task_node, tmp) {
                                        if (TASK_FD(task) != ((intptr_t) res[i].udata))                                        if (TASK_FD(task) == ((intptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags;
                                                         /* remove node handle */
                                                         transit_task2ready(task, &r->root_node);
                                                 }
                                                 flg++;
                                         }                                          }
                                         /* remove node handle */  
                                         transit_task2ready(task, &r->root_node);  
                                 }                                  }
                                 break;                                  break;
                         case EVFILT_PROC:                          case EVFILT_PROC:
                                 TAILQ_FOREACH_SAFE(task, &r->root_proc, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_proc, task_node, tmp) {
                                        if (TASK_VAL(task) != ((uintptr_t) res[i].udata))                                        if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags;
                                                         /* remove proc handle */
                                                         transit_task2ready(task, &r->root_proc);
                                                 }
                                                 flg++;
                                         }                                          }
                                         /* remove proc handle */  
                                         transit_task2ready(task, &r->root_proc);  
                                 }                                  }
                                 break;                                  break;
                         case EVFILT_SIGNAL:                          case EVFILT_SIGNAL:
                                 TAILQ_FOREACH_SAFE(task, &r->root_signal, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_signal, task_node, tmp) {
                                        if (TASK_VAL(task) != ((uintptr_t) res[i].udata))                                        if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags;
                                                         /* remove signal handle */
                                                         transit_task2ready(task, &r->root_signal);
                                                 }
                                                 flg++;
                                         }                                          }
                                         /* remove signal handle */  
                                         transit_task2ready(task, &r->root_signal);  
                                 }                                  }
                                 break;                                  break;
 #ifdef AIO_SUPPORT  #ifdef AIO_SUPPORT
                         case EVFILT_AIO:                          case EVFILT_AIO:
                                 TAILQ_FOREACH_SAFE(task, &r->root_aio, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_aio, task_node, tmp) {
                                         acb = (struct aiocb*) TASK_VAL(task);                                          acb = (struct aiocb*) TASK_VAL(task);
                                        if (acb != ((struct aiocb*) res[i].udata))                                        if (acb == ((struct aiocb*) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags; 
                                        } 
                                        /* remove user handle */ 
                                        transit_task2ready(task, &r->root_aio); 
   
                                        fd = acb->aio_fildes;                                                        /* remove user handle */
                                        if ((len = aio_return(acb)) != -1) {                                                        transit_task2ready(task, &r->root_aio);
                                                if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
                                                        LOGERR;                                                        fd = acb->aio_fildes;
                                        } else                                                        if ((len = aio_return(acb)) != -1) {
                                                LOGERR;                                                                if (lseek(fd, acb->aio_offset + len, SEEK_CUR) == -1)
                                        free(acb);                                                                        LOGERR;
                                        TASK_DATLEN(task) = (u_long) len;                                                        } else
                                        TASK_FD(task) = fd;                                                                LOGERR;
                                                         e_free(acb);
                                                         TASK_DATLEN(task) = (u_long) len;
                                                         TASK_FD(task) = fd;
                                                 }
                                                 flg++;
                                         }
                                 }                                  }
                                 break;                                  break;
 #ifdef EVFILT_LIO  #ifdef EVFILT_LIO
                         case EVFILT_LIO:                          case EVFILT_LIO:
                                 TAILQ_FOREACH_SAFE(task, &r->root_lio, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_lio, task_node, tmp) {
                                         acbs = (struct aiocb**) TASK_VAL(task);                                          acbs = (struct aiocb**) TASK_VAL(task);
                                        if (acbs != ((struct aiocb**) res[i].udata))                                        if (acbs == ((struct aiocb**) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags; 
                                        } 
                                        /* remove user handle */ 
                                        transit_task2ready(task, &r->root_lio); 
   
                                        iv = (struct iovec*) TASK_DATA(task);                                                        /* remove user handle */
                                        fd = acbs[0]->aio_fildes;                                                        transit_task2ready(task, &r->root_lio);
                                        off = acbs[0]->aio_offset; 
                                        for (j = len = 0; i < TASK_DATLEN(task); len += l, i++) { 
                                                if ((iv[i].iov_len = aio_return(acbs[i])) == -1) 
                                                        l = 0; 
                                                else 
                                                        l = iv[i].iov_len; 
                                                free(acbs[i]); 
                                        } 
                                        free(acbs); 
                                        TASK_DATLEN(task) = (u_long) len; 
                                        TASK_FD(task) = fd; 
   
                                        if (lseek(fd, off + len, SEEK_CUR) == -1)                                                        iv = (struct iovec*) TASK_DATA(task);
                                                LOGERR;                                                        fd = acbs[0]->aio_fildes;
                                                         off = acbs[0]->aio_offset;
                                                         for (len = 0; i < TASK_DATLEN(task); len += l, i++) {
                                                                 if ((iv[i].iov_len = aio_return(acbs[i])) == -1)
                                                                         l = 0;
                                                                 else
                                                                         l = iv[i].iov_len;
                                                                 e_free(acbs[i]);
                                                         }
                                                         e_free(acbs);
                                                         TASK_DATLEN(task) = (u_long) len;
                                                         TASK_FD(task) = fd;
 
                                                         if (lseek(fd, off + len, SEEK_CUR) == -1)
                                                                 LOGERR;
                                                 }
                                                 flg++;
                                         }
                                 }                                  }
                                 break;                                  break;
 #endif  /* EVFILT_LIO */  #endif  /* EVFILT_LIO */
Line 1039  fetch_hook_kevent_proceed(int en, struct kevent *res,  Line 1075  fetch_hook_kevent_proceed(int en, struct kevent *res, 
 #ifdef EVFILT_USER  #ifdef EVFILT_USER
                         case EVFILT_USER:                          case EVFILT_USER:
                                 TAILQ_FOREACH_SAFE(task, &r->root_user, task_node, tmp) {                                  TAILQ_FOREACH_SAFE(task, &r->root_user, task_node, tmp) {
                                        if (TASK_VAL(task) != ((uintptr_t) res[i].udata))                                        if (TASK_VAL(task) == ((uintptr_t) res[i].udata)) {
                                                continue;                                                if (!flg) {
                                        else {                                                        TASK_RET(task) = res[i].data;
                                                TASK_RET(task) = res[i].data;                                                        TASK_FLAG(task) = (u_long) res[i].fflags;
                                                TASK_FLAG(task) = (u_long) res[i].fflags;
                                                         /* remove user handle */
                                                         transit_task2ready(task, &r->root_user);
                                                 }
                                                 flg++;
                                         }                                          }
                                         /* remove user handle */  
                                         transit_task2ready(task, &r->root_user);  
                                 }                                  }
                                 break;                                  break;
 #endif  /* EVFILT_USER */  #endif  /* EVFILT_USER */
                 }                  }
   
                   if (flg > 1)
                           evt->flags &= ~EV_DELETE;
   
                 if (kevent(r->root_kq, evt, 1, NULL, 0, &now) == -1) {                  if (kevent(r->root_kq, evt, 1, NULL, 0, &now) == -1) {
                         if (r->root_hooks.hook_exec.exception)                          if (r->root_hooks.hook_exec.exception)
                                 r->root_hooks.hook_exec.exception(r, NULL);                                  r->root_hooks.hook_exec.exception(r, NULL);
Line 1066  fetch_hook_kevent_proceed(int en, struct kevent *res,  Line 1107  fetch_hook_kevent_proceed(int en, struct kevent *res, 
 static inline void  static inline void
 fetch_hook_epoll_proceed(int en, struct epoll_event *res, sched_root_task_t *r)  fetch_hook_epoll_proceed(int en, struct epoll_event *res, sched_root_task_t *r)
 {  {
        register int i, flg;        register int i, rflg, wflg;
         int ops = EPOLL_CTL_DEL;          int ops = EPOLL_CTL_DEL;
        sched_task_t *task, *tmp;        sched_task_t *t, *tmp, *task;
         struct epoll_event evt[1];          struct epoll_event evt[1];
   
         for (i = 0; i < en; i++) {          for (i = 0; i < en; i++) {
                 memcpy(evt, &res[i], sizeof evt);                  memcpy(evt, &res[i], sizeof evt);
                   evt->events ^= evt->events;
                   rflg = wflg = 0;
   
                if (evt->events & (EPOLLIN | EPOLLPRI | EPOLLET)) {                if (res[i].events & (EPOLLIN | EPOLLPRI)) {
                        flg = 0;                        task = NULL;
                        TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {                        TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
                                if (TASK_FD(task) != evt->data.fd)                                if (TASK_FD(t) == evt->data.fd) {
                                        continue;                                        if (!task)
                                else {                                                task = t;
                                        flg++;                                        rflg++;
                                        FD_CLR(TASK_FD(task), &r->root_fds[0]); 
                                        TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task)); 
 
                                        evt->events &= ~(EPOLLIN | EPOLLPRI | EPOLLET | EPOLLRDHUP); 
                                        if (FD_ISSET(TASK_FD(task), &r->root_fds[1])) { 
                                                ops = EPOLL_CTL_MOD; 
                                                evt->events |= EPOLLOUT; 
                                        } 
                                 }                                  }
                           }
   
                           if (task) {
                                   TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));
                                 /* remove read handle */                                  /* remove read handle */
                                 remove_task_from(task, &r->root_read);                                  remove_task_from(task, &r->root_read);
   
Line 1106  fetch_hook_epoll_proceed(int en, struct epoll_event *r Line 1145  fetch_hook_epoll_proceed(int en, struct epoll_event *r
                                         task->task_type = taskREADY;                                          task->task_type = taskREADY;
                                         insert_task_to(task, &r->root_ready);                                          insert_task_to(task, &r->root_ready);
                                 }                                  }
   
                                   if (!(res[i].events & EPOLLOUT) && FD_ISSET(evt->data.fd, &r->root_fds[1])) {
                                           evt->events |= EPOLLOUT;
                                           wflg = 42;
                                   }
                                   if (rflg > 1) {
                                           if (FD_ISSET(evt->data.fd, &r->root_fds[0]))
                                                   evt->events |= EPOLLIN;
                                           if (FD_ISSET(evt->data.fd, &r->root_fds[2]))
                                                   evt->events |= EPOLLPRI;
                                   } else {
                                           FD_CLR(evt->data.fd, &r->root_fds[0]);
                                           FD_CLR(evt->data.fd, &r->root_fds[2]);
                                   }
                         }                          }
                         if (flg > 1)  
                                 ops = EPOLL_CTL_MOD;  
                 }                  }
                if (res[i].events & EPOLLOUT) {
                if (evt->events & EPOLLOUT) {                        task = NULL;
                        flg = 0;                        TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {
                        TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {                                if (TASK_FD(t) == evt->data.fd) {
                                if (TASK_FD(task) != evt->data.fd)                                        if (!task)
                                        continue;                                                task = t;
                                else {                                        wflg++;
                                        flg++; 
                                        FD_CLR(TASK_FD(task), &r->root_fds[1]); 
                                        TASK_FLAG(task) = ioctl(TASK_FD(task),  
                                                        FIONWRITE, &TASK_RET(task)); 
 
                                        evt->events &= ~EPOLLOUT; 
                                        if (FD_ISSET(TASK_FD(task), &r->root_fds[0])) { 
                                                ops = EPOLL_CTL_MOD; 
                                                evt->events |= EPOLLIN | EPOLLPRI | EPOLLRDHUP; 
                                        } 
                                 }                                  }
                           }
   
                           if (task) {
                                   TASK_FLAG(task) = ioctl(TASK_FD(task), FIONWRITE, &TASK_RET(task));
                                 /* remove write handle */                                  /* remove write handle */
                                 remove_task_from(task, &r->root_write);                                  remove_task_from(task, &r->root_write);
   
Line 1144  fetch_hook_epoll_proceed(int en, struct epoll_event *r Line 1189  fetch_hook_epoll_proceed(int en, struct epoll_event *r
                                         task->task_type = taskREADY;                                          task->task_type = taskREADY;
                                         insert_task_to(task, &r->root_ready);                                          insert_task_to(task, &r->root_ready);
                                 }                                  }
   
                                   if (!(res[i].events & EPOLLIN) && FD_ISSET(evt->data.fd, &r->root_fds[0])) {
                                           evt->events |= EPOLLIN;
                                           rflg = 42;
                                   }
                                   if (!(res[i].events & EPOLLPRI) && FD_ISSET(evt->data.fd, &r->root_fds[2])) {
                                           evt->events |= EPOLLPRI;
                                           rflg = 42;
                                   }
                                   if (wflg > 1)
                                           evt->events |= EPOLLOUT;
                                   else
                                           FD_CLR(evt->data.fd, &r->root_fds[1]);
                         }                          }
                         if (flg > 1)  
                                 ops = EPOLL_CTL_MOD;  
                 }                  }
   
                   if (rflg > 1 || wflg > 1)
                           ops = EPOLL_CTL_MOD;
   
                 if (epoll_ctl(r->root_kq, ops, evt->data.fd, evt) == -1) {                  if (epoll_ctl(r->root_kq, ops, evt->data.fd, evt) == -1) {
                         if (r->root_hooks.hook_exec.exception) {                          if (r->root_hooks.hook_exec.exception) {
                                 r->root_hooks.hook_exec.exception(r, NULL);                                  r->root_hooks.hook_exec.exception(r, NULL);
Line 1163  fetch_hook_epoll_proceed(int en, struct epoll_event *r Line 1222  fetch_hook_epoll_proceed(int en, struct epoll_event *r
 static inline void   static inline void 
 fetch_hook_select_proceed(int en, fd_set rfd, fd_set wfd, fd_set xfd, sched_root_task_t *r)  fetch_hook_select_proceed(int en, fd_set rfd, fd_set wfd, fd_set xfd, sched_root_task_t *r)
 {  {
        register int i, flg;        register int i, rflg, wflg;
        sched_task_t *task, *tmp;        sched_task_t *t, *tmp, *task;
   
         /* skip select check if return value from select is zero */          /* skip select check if return value from select is zero */
         if (!en)          if (!en)
                 return;                  return;
   
         for (i = 0; i < r->root_kq; i++) {          for (i = 0; i < r->root_kq; i++) {
                   if (!FD_ISSET(i, &r->root_fds[0]) && 
                                   !FD_ISSET(i, &r->root_fds[1]) && 
                                   !FD_ISSET(i, &r->root_fds[2]))
                           continue;
   
                   rflg = wflg = 0;
   
                 if (FD_ISSET(i, &rfd) || FD_ISSET(i, &xfd)) {                  if (FD_ISSET(i, &rfd) || FD_ISSET(i, &xfd)) {
                        flg = 0;                        task = NULL;
                        TAILQ_FOREACH_SAFE(task, &r->root_read, task_node, tmp) {                        TAILQ_FOREACH_SAFE(t, &r->root_read, task_node, tmp) {
                                if (TASK_FD(task) != i)                                if (TASK_FD(t) == i) {
                                        continue;                                        if (!task)
                                else {                                                task = t;
                                        flg++;                                        rflg++;
                                        TASK_FLAG(task) = ioctl(TASK_FD(task),  
                                                        FIONREAD, &TASK_RET(task)); 
                                 }                                  }
                           }
   
                           if (task) {
                                   TASK_FLAG(task) = ioctl(TASK_FD(task), FIONREAD, &TASK_RET(task));
   
                                 /* remove read handle */                                  /* remove read handle */
                                 remove_task_from(task, &r->root_read);                                  remove_task_from(task, &r->root_read);
   
Line 1196  fetch_hook_select_proceed(int en, fd_set rfd, fd_set w Line 1265  fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
                                         task->task_type = taskREADY;                                          task->task_type = taskREADY;
                                         insert_task_to(task, &r->root_ready);                                          insert_task_to(task, &r->root_ready);
                                 }                                  }
   
                                   /* remove resouce */
                                   if (rflg == 1) {
                                           FD_CLR(i, &r->root_fds[0]);
                                           FD_CLR(i, &r->root_fds[2]);
                                   }
                         }                          }
                         /* remove resouce */  
                         if (flg)  
                                 FD_CLR(i, &r->root_fds[0]);  
                 }                  }
   
                 if (FD_ISSET(i, &wfd)) {                  if (FD_ISSET(i, &wfd)) {
                        flg = 0;                        task = NULL;
                        TAILQ_FOREACH_SAFE(task, &r->root_write, task_node, tmp) {                        TAILQ_FOREACH_SAFE(t, &r->root_write, task_node, tmp) {
                                if (TASK_FD(task) != i)                                if (TASK_FD(t) == i) {
                                        continue;                                        if (!task)
                                else {                                                task = t;
                                        flg++;                                        wflg++;
                                        TASK_FLAG(task) = ioctl(TASK_FD(task),  
                                                        FIONWRITE, &TASK_RET(task)); 
                                 }                                  }
                           }
   
                           if (task) {
                                   TASK_FLAG(task) = ioctl(TASK_FD(task), FIONWRITE, &TASK_RET(task));
   
                                 /* remove write handle */                                  /* remove write handle */
                                 remove_task_from(task, &r->root_write);                                  remove_task_from(task, &r->root_write);
   
Line 1227  fetch_hook_select_proceed(int en, fd_set rfd, fd_set w Line 1301  fetch_hook_select_proceed(int en, fd_set rfd, fd_set w
                                         task->task_type = taskREADY;                                          task->task_type = taskREADY;
                                         insert_task_to(task, &r->root_ready);                                          insert_task_to(task, &r->root_ready);
                                 }                                  }
   
                                   /* remove resouce */
                                   if (wflg == 1)
                                           FD_CLR(i, &r->root_fds[1]);
                         }                          }
                         /* remove resouce */  
                         if (flg)  
                                 FD_CLR(i, &r->root_fds[1]);  
                 }                  }
         }          }
   
         /* optimize select */          /* optimize select */
        for (i = r->root_kq - 1; i > 2; i--)        for (i = r->root_kq - 1; i >= 0; i--)
                if (FD_ISSET(i, &r->root_fds[0]) || FD_ISSET(i, &r->root_fds[1]))                if (FD_ISSET(i, &r->root_fds[0]) || 
                                 FD_ISSET(i, &r->root_fds[1]) || 
                                 FD_ISSET(i, &r->root_fds[2]))
                         break;                          break;
        if (i > 2)        r->root_kq = i + 1;
                r->root_kq = i + 1; 
 }  }
 #endif  #endif
   
Line 1281  sched_hook_fetch(void *root, void *arg __unused) Line 1357  sched_hook_fetch(void *root, void *arg __unused)
                 return task;                  return task;
         }          }
   
           /* if present member of task, set NOWAIT */
           if (!TAILQ_FIRST(&r->root_task)) {
                   /* timer tasks */
 #ifdef TIMER_WITHOUT_SORT  #ifdef TIMER_WITHOUT_SORT
        clock_gettime(CLOCK_MONOTONIC, &now);                clock_gettime(CLOCK_MONOTONIC, &now);
   
        sched_timespecclear(&r->root_wait);                sched_timespecclear(&r->root_wait);
        TAILQ_FOREACH(task, &r->root_timer, task_node) {                TAILQ_FOREACH(task, &r->root_timer, task_node) {
                if (!sched_timespecisset(&r->root_wait))                        if (!sched_timespecisset(&r->root_wait))
                        r->root_wait = TASK_TS(task);                                r->root_wait = TASK_TS(task);
                else if (sched_timespeccmp(&TASK_TS(task), &r->root_wait, -) < 0)                        else if (sched_timespeccmp(&TASK_TS(task), &r->root_wait, -) < 0)
                        r->root_wait = TASK_TS(task);                                r->root_wait = TASK_TS(task);
        }                }
   
        if (TAILQ_FIRST(&r->root_timer)) {                if (TAILQ_FIRST(&r->root_timer)) {
                m = r->root_wait;                        m = r->root_wait;
                sched_timespecsub(&m, &now, &mtmp);                        sched_timespecsub(&m, &now, &mtmp);
                r->root_wait = mtmp;                        r->root_wait = mtmp;
        } else {                } else {
                /* set wait INFTIM */                        /* set wait INFTIM */
                sched_timespecinf(&r->root_wait);                        sched_timespecinf(&r->root_wait);
        }                }
 #else   /* ! TIMER_WITHOUT_SORT */  #else   /* ! TIMER_WITHOUT_SORT */
        if (!TAILQ_FIRST(&r->root_task) && (task = TAILQ_FIRST(&r->root_timer))) {                if ((task = TAILQ_FIRST(&r->root_timer))) {
                clock_gettime(CLOCK_MONOTONIC, &now);                        clock_gettime(CLOCK_MONOTONIC, &now);
   
                m = TASK_TS(task);                        m = TASK_TS(task);
                sched_timespecsub(&m, &now, &mtmp);                        sched_timespecsub(&m, &now, &mtmp);
                r->root_wait = mtmp;                        r->root_wait = mtmp;
        } else {                } else {
                /* set wait INFTIM */                        /* set wait INFTIM */
                sched_timespecinf(&r->root_wait);                        sched_timespecinf(&r->root_wait);
        }                }
 #endif  /* TIMER_WITHOUT_SORT */  #endif  /* TIMER_WITHOUT_SORT */
        /* if present member of task, set NOWAIT */        } else  /* no waiting for event, because we have ready task */
        if (TAILQ_FIRST(&r->root_task)) 
                 sched_timespecclear(&r->root_wait);                  sched_timespecclear(&r->root_wait);
   
         if (r->root_wait.tv_sec != -1 && r->root_wait.tv_nsec != -1) {          if (r->root_wait.tv_sec != -1 && r->root_wait.tv_nsec != -1) {
Line 1347  sched_hook_fetch(void *root, void *arg __unused) Line 1425  sched_hook_fetch(void *root, void *arg __unused)
 #elif SUP_ENABLE == EP_SUPPORT  #elif SUP_ENABLE == EP_SUPPORT
         if ((en = epoll_wait(r->root_kq, res, KQ_EVENTS, timeout)) == -1) {          if ((en = epoll_wait(r->root_kq, res, KQ_EVENTS, timeout)) == -1) {
 #else  #else
        rfd = xfd = r->root_fds[0];        xfd = r->root_fds[2];
         rfd = r->root_fds[0];
         wfd = r->root_fds[1];          wfd = r->root_fds[1];
         if ((en = select(r->root_kq, &rfd, &wfd, &xfd, timeout)) == -1) {          if ((en = select(r->root_kq, &rfd, &wfd, &xfd, timeout)) == -1) {
 #endif  /* KQ_SUPPORT */  #endif  /* KQ_SUPPORT */
Removed from v.1.30  
changed lines
  Added in v.1.37.2.2

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