1: /* Guts of both `select' and `poll' for Hurd.
    2:    Copyright (C) 1991,92,93,94,95,96,97,98,99,2001
    3:         Free Software Foundation, Inc.
    4:    This file is part of the GNU C Library.
    5: 
    6:    The GNU C Library is free software; you can redistribute it and/or
    7:    modify it under the terms of the GNU Lesser General Public
    8:    License as published by the Free Software Foundation; either
    9:    version 2.1 of the License, or (at your option) any later version.
   10: 
   11:    The GNU C Library is distributed in the hope that it will be useful,
   12:    but WITHOUT ANY WARRANTY; without even the implied warranty of
   13:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   14:    Lesser General Public License for more details.
   15: 
   16:    You should have received a copy of the GNU Lesser General Public
   17:    License along with the GNU C Library; if not, write to the Free
   18:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   19:    02111-1307 USA.  */
   20: 
   21: #include <sys/types.h>
   22: #include <sys/poll.h>
   23: #include <hurd.h>
   24: #include <hurd/fd.h>
   25: #include <stdlib.h>
   26: #include <string.h>
   27: #include <assert.h>
   28: #include <stdint.h>
   29: 
   30: /* All user select types.  */
   31: #define SELECT_ALL (SELECT_READ | SELECT_WRITE | SELECT_URG)
   32: 
   33: /* Used to record that a particular select rpc returned.  Must be distinct
   34:    from SELECT_ALL (which better not have the high bit set).  */
   35: #define SELECT_RETURNED ((SELECT_ALL << 1) & ~SELECT_ALL)
   36: 
   37: /* Check the first NFDS descriptors either in POLLFDS (if nonnnull) or in
   38:    each of READFDS, WRITEFDS, EXCEPTFDS that is nonnull.  If TIMEOUT is not
   39:    NULL, time out after waiting the interval specified therein.  Returns
   40:    the number of ready descriptors, or -1 for errors.  */
   41: int
   42: _hurd_select (int nfds,
   43:               struct pollfd *pollfds,
   44:               fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
   45:               const struct timespec *timeout, const sigset_t *sigmask)
   46: {
   47:   int i;
   48:   mach_port_t portset;
   49:   int got;
   50:   error_t err;
   51:   fd_set rfds, wfds, xfds;
   52:   int firstfd, lastfd;
   53:   mach_msg_timeout_t to = (timeout != NULL ?
   54:                            (timeout->tv_sec * 1000 +
   55:                             timeout->tv_nsec / 1000000) :
   56:                            0);
   57:   struct
   58:     {
   59:       struct hurd_userlink ulink;
   60:       struct hurd_fd *cell;
   61:       mach_port_t io_port;
   62:       int type;
   63:       mach_port_t reply_port;
   64:     } d[nfds];
   65:   sigset_t oset;
   66: 
   67:   union typeword                /* Use this to avoid unkosher casts.  */
   68:     {
   69:       mach_msg_type_t type;
   70:       uint32_t word;
   71:     };
   72:   assert (sizeof (union typeword) == sizeof (mach_msg_type_t));
   73:   assert (sizeof (uint32_t) == sizeof (mach_msg_type_t));
   74: 
   75:   if (sigmask && __sigprocmask (SIG_SETMASK, sigmask, &oset))
   76:     return -1;
   77: 
   78:   if (pollfds)
   79:     {
   80:       /* Collect interesting descriptors from the user's `pollfd' array.
   81:          We do a first pass that reads the user's array before taking
   82:          any locks.  The second pass then only touches our own stack,
   83:          and gets the port references.  */
   84: 
   85:       for (i = 0; i < nfds; ++i)
   86:         if (pollfds[i].fd >= 0)
   87:           {
   88:             int type = 0;
   89:             if (pollfds[i].events & POLLIN)
   90:               type |= SELECT_READ;
   91:             if (pollfds[i].events & POLLOUT)
   92:               type |= SELECT_WRITE;
   93:             if (pollfds[i].events & POLLPRI)
   94:               type |= SELECT_URG;
   95: 
   96:             d[i].io_port = pollfds[i].fd;
   97:             d[i].type = type;
   98:           }
   99:         else
  100:           d[i].type = 0;
  101: 
  102:       HURD_CRITICAL_BEGIN;
  103:       __mutex_lock (&_hurd_dtable_lock);
  104: 
  105:       for (i = 0; i < nfds; ++i)
  106:         if (d[i].type != 0)
  107:           {
  108:             const int fd = (int) d[i].io_port;
  109: 
  110:             if (fd < _hurd_dtablesize)
  111:               {
  112:                 d[i].cell = _hurd_dtable[fd];
  113:                 d[i].io_port = _hurd_port_get (&d[i].cell->port, &d[i].ulink);
  114:                 if (d[i].io_port != MACH_PORT_NULL)
  115:                   continue;
  116:               }
  117: 
  118:             /* If one descriptor is bogus, we fail completely.  */
  119:             while (i-- > 0)
  120:               if (d[i].type != 0)
  121:                 _hurd_port_free (&d[i].cell->port,
  122:                                  &d[i].ulink, d[i].io_port);
  123:             break;
  124:           }
  125: 
  126:       __mutex_unlock (&_hurd_dtable_lock);
  127:       HURD_CRITICAL_END;
  128: 
  129:       if (i < nfds)
  130:         {
  131:           if (sigmask)
  132:             __sigprocmask (SIG_SETMASK, &oset, NULL);
  133:           errno = EBADF;
  134:           return -1;
  135:         }
  136: 
  137:       lastfd = i - 1;
  138:       firstfd = i == 0 ? lastfd : 0;
  139:     }
  140:   else
  141:     {
  142:       /* Collect interested descriptors from the user's fd_set arguments.
  143:          Use local copies so we can't crash from user bogosity.  */
  144: 
  145:       if (readfds == NULL)
  146:         FD_ZERO (&rfds);
  147:       else
  148:         rfds = *readfds;
  149:       if (writefds == NULL)
  150:         FD_ZERO (&wfds);
  151:       else
  152:         wfds = *writefds;
  153:       if (exceptfds == NULL)
  154:         FD_ZERO (&xfds);
  155:       else
  156:         xfds = *exceptfds;
  157: 
  158:       HURD_CRITICAL_BEGIN;
  159:       __mutex_lock (&_hurd_dtable_lock);
  160: 
  161:       if (nfds > _hurd_dtablesize)
  162:         nfds = _hurd_dtablesize;
  163: 
  164:       /* Collect the ports for interesting FDs.  */
  165:       firstfd = lastfd = -1;
  166:       for (i = 0; i < nfds; ++i)
  167:         {
  168:           int type = 0;
  169:           if (readfds != NULL && FD_ISSET (i, &rfds))
  170:             type |= SELECT_READ;
  171:           if (writefds != NULL && FD_ISSET (i, &wfds))
  172:             type |= SELECT_WRITE;
  173:           if (exceptfds != NULL && FD_ISSET (i, &xfds))
  174:             type |= SELECT_URG;
  175:           d[i].type = type;
  176:           if (type)
  177:             {
  178:               d[i].cell = _hurd_dtable[i];
  179:               d[i].io_port = _hurd_port_get (&d[i].cell->port, &d[i].ulink);
  180:               if (d[i].io_port == MACH_PORT_NULL)
  181:                 {
  182:                   /* If one descriptor is bogus, we fail completely.  */
  183:                   while (i-- > 0)
  184:                     if (d[i].type != 0)
  185:                       _hurd_port_free (&d[i].cell->port, &d[i].ulink,
  186:                                        d[i].io_port);
  187:                   break;
  188:                 }
  189:               lastfd = i;
  190:               if (firstfd == -1)
  191:                 firstfd = i;
  192:             }
  193:         }
  194: 
  195:       __mutex_unlock (&_hurd_dtable_lock);
  196:       HURD_CRITICAL_END;
  197: 
  198:       if (i < nfds)
  199:         {
  200:           if (sigmask)
  201:             __sigprocmask (SIG_SETMASK, &oset, NULL);
  202:           errno = EBADF;
  203:           return -1;
  204:         }
  205:     }
  206: 
  207: 
  208:   err = 0;
  209:   got = 0;
  210: 
  211:   /* Send them all io_select request messages.  */
  212: 
  213:   if (firstfd == -1)
  214:     /* But not if there were no ports to deal with at all.
  215:        We are just a pure timeout.  */
  216:     portset = __mach_reply_port ();
  217:   else
  218:     {
  219:       portset = MACH_PORT_NULL;
  220: 
  221:       for (i = firstfd; i <= lastfd; ++i)
  222:         if (d[i].type)
  223:           {
  224:             int type = d[i].type;
  225:             d[i].reply_port = __mach_reply_port ();
  226:             err = __io_select (d[i].io_port, d[i].reply_port,
  227:                                /* Poll only if there's a single descriptor.  */
  228:                                (firstfd == lastfd) ? to : 0,
  229:                                &type);
  230:             switch (err)
  231:               {
  232:               case MACH_RCV_TIMED_OUT:
  233:                 /* No immediate response.  This is normal.  */
  234:                 err = 0;
  235:                 if (firstfd == lastfd)
  236:                   /* When there's a single descriptor, we don't need a
  237:                      portset, so just pretend we have one, but really
  238:                      use the single reply port.  */
  239:                   portset = d[i].reply_port;
  240:                 else if (got == 0)
  241:                   /* We've got multiple reply ports, so we need a port set to
  242:                      multiplex them.  */
  243:                   {
  244:                     /* We will wait again for a reply later.  */
  245:                     if (portset == MACH_PORT_NULL)
  246:                       /* Create the portset to receive all the replies on.  */
  247:                       err = __mach_port_allocate (__mach_task_self (),
  248:                                                   MACH_PORT_RIGHT_PORT_SET,
  249:                                                   &portset);
  250:                     if (! err)
  251:                       /* Put this reply port in the port set.  */
  252:                       __mach_port_move_member (__mach_task_self (),
  253:                                                d[i].reply_port, portset);
  254:                   }
  255:                 break;
  256: 
  257:               default:
  258:                 /* No other error should happen.  Callers of select
  259:                    don't expect to see errors, so we simulate
  260:                    readiness of the erring object and the next call
  261:                    hopefully will get the error again.  */
  262:                 type = SELECT_ALL;
  263:                 /* FALLTHROUGH */
  264: 
  265:               case 0:
  266:                 /* We got an answer.  */
  267:                 if ((type & SELECT_ALL) == 0)
  268:                   /* Bogus answer; treat like an error, as a fake positive.  */
  269:                   type = SELECT_ALL;
  270: 
  271:                 /* This port is already ready already.  */
  272:                 d[i].type &= type;
  273:                 d[i].type |= SELECT_RETURNED;
  274:                 ++got;
  275:                 break;
  276:               }
  277:             _hurd_port_free (&d[i].cell->port, &d[i].ulink, d[i].io_port);
  278:           }
  279:     }
  280: 
  281:   /* Now wait for reply messages.  */
  282:   if (!err && got == 0)
  283:     {
  284:       /* Now wait for io_select_reply messages on PORT,
  285:          timing out as appropriate.  */
  286: 
  287:       union
  288:         {
  289:           mach_msg_header_t head;
  290: #ifdef MACH_MSG_TRAILER_MINIMUM_SIZE
  291:           struct
  292:             {
  293:               mach_msg_header_t head;
  294:               NDR_record_t ndr;
  295:               error_t err;
  296:             } error;
  297:           struct
  298:             {
  299:               mach_msg_header_t head;
  300:               NDR_record_t ndr;
  301:               error_t err;
  302:               int result;
  303:               mach_msg_trailer_t trailer;
  304:             } success;
  305: #else
  306:           struct
  307:             {
  308:               mach_msg_header_t head;
  309:               union typeword err_type;
  310:               error_t err;
  311:             } error;
  312:           struct
  313:             {
  314:               mach_msg_header_t head;
  315:               union typeword err_type;
  316:               error_t err;
  317:               union typeword result_type;
  318:               int result;
  319:             } success;
  320: #endif
  321:         } msg;
  322:       mach_msg_option_t options = (timeout == NULL ? 0 : MACH_RCV_TIMEOUT);
  323:       error_t msgerr;
  324:       while ((msgerr = __mach_msg (&msg.head,
  325:                                    MACH_RCV_MSG | options,
  326:                                    0, sizeof msg, portset, to,
  327:                                    MACH_PORT_NULL)) == MACH_MSG_SUCCESS)
  328:         {
  329:           /* We got a message.  Decode it.  */
  330: #define IO_SELECT_REPLY_MSGID (21012 + 100) /* XXX */
  331: #ifdef MACH_MSG_TYPE_BIT
  332:           const union typeword inttype =
  333:           { type:
  334:             { MACH_MSG_TYPE_INTEGER_T, sizeof (integer_t) * 8, 1, 1, 0, 0 }
  335:           };
  336: #endif
  337:           if (msg.head.msgh_id == IO_SELECT_REPLY_MSGID &&
  338:               msg.head.msgh_size >= sizeof msg.error &&
  339:               !(msg.head.msgh_bits & MACH_MSGH_BITS_COMPLEX) &&
  340: #ifdef MACH_MSG_TYPE_BIT
  341:               msg.error.err_type.word == inttype.word
  342: #endif
  343:               )
  344:             {
  345:               /* This is a properly formatted message so far.
  346:                  See if it is a success or a failure.  */
  347:               if (msg.error.err == EINTR &&
  348:                   msg.head.msgh_size == sizeof msg.error)
  349:                 {
  350:                   /* EINTR response; poll for further responses
  351:                      and then return quickly.  */
  352:                   err = EINTR;
  353:                   goto poll;
  354:                 }
  355:               if (msg.error.err ||
  356:                   msg.head.msgh_size != sizeof msg.success ||
  357: #ifdef MACH_MSG_TYPE_BIT
  358:                   msg.success.result_type.word != inttype.word ||
  359: #endif
  360:                   (msg.success.result & SELECT_ALL) == 0)
  361:                 {
  362:                   /* Error or bogus reply.  Simulate readiness.  */
  363:                   __mach_msg_destroy (&msg.head);
  364:                   msg.success.result = SELECT_ALL;
  365:                 }
  366: 
  367:               /* Look up the respondent's reply port and record its
  368:                  readiness.  */
  369:               {
  370:                 int had = got;
  371:                 if (firstfd != -1)
  372:                   for (i = firstfd; i <= lastfd; ++i)
  373:                     if (d[i].type
  374:                         && d[i].reply_port == msg.head.msgh_local_port)
  375:                       {
  376:                         d[i].type &= msg.success.result;
  377:                         d[i].type |= SELECT_RETURNED;
  378:                         ++got;
  379:                       }
  380:                 assert (got > had);
  381:               }
  382:             }
  383: 
  384:           if (msg.head.msgh_remote_port != MACH_PORT_NULL)
  385:             __mach_port_deallocate (__mach_task_self (),
  386:                                     msg.head.msgh_remote_port);
  387: 
  388:           if (got)
  389:           poll:
  390:             {
  391:               /* Poll for another message.  */
  392:               to = 0;
  393:               options |= MACH_RCV_TIMEOUT;
  394:             }
  395:         }
  396: 
  397:       if (err == MACH_RCV_TIMED_OUT)
  398:         /* This is the normal value for ERR.  We might have timed out and
  399:            read no messages.  Otherwise, after receiving the first message,
  400:            we poll for more messages.  We receive with a timeout of 0 to
  401:            effect a poll, so ERR is MACH_RCV_TIMED_OUT when the poll finds no
  402:            message waiting.  */
  403:         err = 0;
  404: 
  405:       if (got)
  406:         /* At least one descriptor is known to be ready now, so we will
  407:            return success.  */
  408:         err = 0;
  409:     }
  410: 
  411:   if (firstfd != -1)
  412:     for (i = firstfd; i <= lastfd; ++i)
  413:       if (d[i].type)
  414:         __mach_port_destroy (__mach_task_self (), d[i].reply_port);
  415:   if (firstfd == -1 || (firstfd != lastfd && portset != MACH_PORT_NULL))
  416:     /* Destroy PORTSET, but only if it's not actually the reply port for a
  417:        single descriptor (in which case it's destroyed in the previous loop;
  418:        not doing it here is just a bit more efficient).  */
  419:     __mach_port_destroy (__mach_task_self (), portset);
  420: 
  421:   if (err)
  422:     {
  423:       if (sigmask)
  424:         __sigprocmask (SIG_SETMASK, &oset, NULL);
  425:       return __hurd_fail (err);
  426:     }
  427: 
  428:   if (pollfds)
  429:     /* Fill in the `revents' members of the user's array.  */
  430:     for (i = 0; i < nfds; ++i)
  431:       {
  432:         int type = d[i].type;
  433:         int_fast16_t revents = 0;
  434: 
  435:         if (type & SELECT_RETURNED)
  436:           {
  437:             if (type & SELECT_READ)
  438:               revents |= POLLIN;
  439:             if (type & SELECT_WRITE)
  440:               revents |= POLLOUT;
  441:             if (type & SELECT_URG)
  442:               revents |= POLLPRI;
  443:           }
  444: 
  445:         pollfds[i].revents = revents;
  446:       }
  447:   else
  448:     {
  449:       /* Below we recalculate GOT to include an increment for each operation
  450:          allowed on each fd.  */
  451:       got = 0;
  452: 
  453:       /* Set the user bitarrays.  We only ever have to clear bits, as all
  454:          desired ones are initially set.  */
  455:       if (firstfd != -1)
  456:         for (i = firstfd; i <= lastfd; ++i)
  457:           {
  458:             int type = d[i].type;
  459: 
  460:             if ((type & SELECT_RETURNED) == 0)
  461:               type = 0;
  462: 
  463:             if (type & SELECT_READ)
  464:               got++;
  465:             else if (readfds)
  466:               FD_CLR (i, readfds);
  467:             if (type & SELECT_WRITE)
  468:               got++;
  469:             else if (writefds)
  470:               FD_CLR (i, writefds);
  471:             if (type & SELECT_URG)
  472:               got++;
  473:             else if (exceptfds)
  474:               FD_CLR (i, exceptfds);
  475:           }
  476:     }
  477: 
  478:   if (sigmask && __sigprocmask (SIG_SETMASK, &oset, NULL))
  479:     return -1;
  480: 
  481:   return got;
  482: }