port/gen/select.c

	select.c revision 7257d1b4d25bfac0c802847390e98a464fd787ac
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*  Copyright (c) 1988 AT&T */
/*    All Rights Reserved   */

#pragma ident   "%Z%%M% %I% %E% SMI"

/*
 * Emulation of select() system call using poll() system call.
 *
 * Assumptions:
 *  polling for input only is most common.
 *  polling for exceptional conditions is very rare.
 *
 * Note that is it not feasible to emulate all error conditions,
 * in particular conditions that would return EFAULT are far too
 * difficult to check for in a library routine.
 */

#pragma weak _select = select

#include "lint.h"
#include <values.h>
#include <pthread.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <alloca.h>
#include "libc.h"

int
pselect(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0,
    const timespec_t *tsp, const sigset_t *sigmask)
{
    long *in, *out, *ex;
    ulong_t m;  /* bit mask */
    int j;      /* loop counter */
    ulong_t b;  /* bits to test */
    int n, rv;
    struct pollfd *pfd;
    struct pollfd *p;
    int lastj = -1;

    /* "zero" is read-only, it could go in the text segment */
    static fd_set zero = { 0 };

    /*
     * Check for invalid conditions at outset.
     * Required for spec1170.
     * SUSV3: We must behave as a cancellation point even if we fail early.
     */
    if (nfds < 0 || nfds > FD_SETSIZE) {
        pthread_testcancel();
        errno = EINVAL;
        return (-1);
    }
    p = pfd = (struct pollfd *)alloca(nfds * sizeof (struct pollfd));

    if (tsp != NULL) {
        /* check timespec validity */
        if (tsp->tv_nsec < 0 || tsp->tv_nsec >= NANOSEC ||
            tsp->tv_sec < 0) {
            pthread_testcancel();
            errno = EINVAL;
            return (-1);
        }
    }

    /*
     * If any input args are null, point them at the null array.
     */
    if (in0 == NULL)
        in0 = &zero;
    if (out0 == NULL)
        out0 = &zero;
    if (ex0 == NULL)
        ex0 = &zero;

    /*
     * For each fd, if any bits are set convert them into
     * the appropriate pollfd struct.
     */
    in = (long *)in0->fds_bits;
    out = (long *)out0->fds_bits;
    ex = (long *)ex0->fds_bits;
    for (n = 0; n < nfds; n += NFDBITS) {
        b = (ulong_t)(*in | *out | *ex);
        for (j = 0, m = 1; b != 0; j++, b >>= 1, m <<= 1) {
            if (b & 1) {
                p->fd = n + j;
                if (p->fd >= nfds)
                    goto done;
                p->events = 0;
                if (*in & m)
                    p->events |= POLLRDNORM;
                if (*out & m)
                    p->events |= POLLWRNORM;
                if (*ex & m)
                    p->events |= POLLRDBAND;
                p++;
            }
        }
        in++;
        out++;
        ex++;
    }
done:
    /*
     * Now do the poll.
     */
    n = (int)(p - pfd);     /* number of pollfd's */
    do {
        rv = _pollsys(pfd, (nfds_t)n, tsp, sigmask);
    } while (rv < 0 && errno == EAGAIN);

    if (rv < 0)     /* no need to set bit masks */
        return (rv);

    if (rv == 0) {
        /*
         * Clear out bit masks, just in case.
         * On the assumption that usually only
         * one bit mask is set, use three loops.
         */
        if (in0 != &zero) {
            in = (long *)in0->fds_bits;
            for (n = 0; n < nfds; n += NFDBITS)
                *in++ = 0;
        }
        if (out0 != &zero) {
            out = (long *)out0->fds_bits;
            for (n = 0; n < nfds; n += NFDBITS)
                *out++ = 0;
        }
        if (ex0 != &zero) {
            ex = (long *)ex0->fds_bits;
            for (n = 0; n < nfds; n += NFDBITS)
                *ex++ = 0;
        }
        return (0);
    }

    /*
     * Check for EINVAL error case first to avoid changing any bits
     * if we're going to return an error.
     */
    for (p = pfd, j = n; j-- > 0; p++) {
        /*
         * select will return EBADF immediately if any fd's
         * are bad.  poll will complete the poll on the
         * rest of the fd's and include the error indication
         * in the returned bits.  This is a rare case so we
         * accept this difference and return the error after
         * doing more work than select would've done.
         */
        if (p->revents & POLLNVAL) {
            errno = EBADF;
            return (-1);
        }
        /*
         * We would like to make POLLHUP available to select,
         * checking to see if we have pending data to be read.
         * BUT until we figure out how not to break Xsun's
         * dependencies on select's existing features...
         * This is what we _thought_ would work ... sigh!
         */
        /*
         * if ((p->revents & POLLHUP) &&
         *  !(p->revents & (POLLRDNORM|POLLRDBAND))) {
         *  errno = EINTR;
         *  return (-1);
         * }
         */
    }

    /*
     * Convert results of poll back into bits
     * in the argument arrays.
     *
     * We assume POLLRDNORM, POLLWRNORM, and POLLRDBAND will only be set
     * on return from poll if they were set on input, thus we don't
     * worry about accidentally setting the corresponding bits in the
     * zero array if the input bit masks were null.
     *
     * Must return number of bits set, not number of ready descriptors
     * (as the man page says, and as poll() does).
     */
    rv = 0;
    for (p = pfd; n-- > 0; p++) {
        j = (int)(p->fd / NFDBITS);
        /* have we moved into another word of the bit mask yet? */
        if (j != lastj) {
            /* clear all output bits to start with */
            in = (long *)&in0->fds_bits[j];
            out = (long *)&out0->fds_bits[j];
            ex = (long *)&ex0->fds_bits[j];
            /*
             * In case we made "zero" read-only (e.g., with
             * cc -R), avoid actually storing into it.
             */
            if (in0 != &zero)
                *in = 0;
            if (out0 != &zero)
                *out = 0;
            if (ex0 != &zero)
                *ex = 0;
            lastj = j;
        }
        if (p->revents) {
            m = 1L << (p->fd % NFDBITS);
            if (p->revents & POLLRDNORM) {
                *in |= m;
                rv++;
            }
            if (p->revents & POLLWRNORM) {
                *out |= m;
                rv++;
            }
            if (p->revents & POLLRDBAND) {
                *ex |= m;
                rv++;
            }
            /*
             * Only set this bit on return if we asked about
             * input conditions.
             */
            if ((p->revents & (POLLHUP|POLLERR)) &&
                (p->events & POLLRDNORM)) {
                if ((*in & m) == 0)
                    rv++;   /* wasn't already set */
                *in |= m;
            }
            /*
             * Only set this bit on return if we asked about
             * output conditions.
             */
            if ((p->revents & (POLLHUP|POLLERR)) &&
                (p->events & POLLWRNORM)) {
                if ((*out & m) == 0)
                    rv++;   /* wasn't already set */
                *out |= m;
            }
            /*
             * Only set this bit on return if we asked about
             * output conditions.
             */
            if ((p->revents & (POLLHUP|POLLERR)) &&
                (p->events & POLLRDBAND)) {
                if ((*ex & m) == 0)
                    rv++;   /* wasn't already set */
                *ex |= m;
            }
        }
    }
    return (rv);
}

int
select(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0, struct timeval *tv)
{
    timespec_t ts;
    timespec_t *tsp;

    if (tv == NULL)
        tsp = NULL;
    else {
        /* check timeval validity */
        if (tv->tv_usec < 0 || tv->tv_usec >= MICROSEC) {
            errno = EINVAL;
            return (-1);
        }
        /*
         * Convert timeval to timespec.
         * To preserve compatibility with past behavior,
         * when select was built upon poll(2), which has a
         * minimum non-zero timeout of 1 millisecond, force
         * a minimum non-zero timeout of 500 microseconds.
         */
        ts.tv_sec = tv->tv_sec;
        ts.tv_nsec = tv->tv_usec * 1000;
        if (ts.tv_nsec != 0 && ts.tv_nsec < 500000)
            ts.tv_nsec = 500000;
        tsp = &ts;
    }

    return (pselect(nfds, in0, out0, ex0, tsp, NULL));
}