DragonFlyBSD

static int 	doselect(int nd, fd_set *in, fd_set *ou, fd_set *ex,

			struct timeval *tv, int *res);

	struct timeval ktv;

	struct timeval *ktvp;

	int error;

	/*

	 * Get timeout if any.

	 */

	if (uap->tv != NULL) {

		error = copyin(uap->tv, &ktv, sizeof (ktv));

		if (error)

			return (error);

		error = itimerfix(&ktv);

		if (error)

			return (error);

		ktvp = &ktv;

	} else {

		ktvp = NULL;

	}

	/*

	 * Do real work.

	 */

	error = doselect(uap->nd, uap->in, uap->ou, uap->ex, ktvp,

			&uap->sysmsg_result);

	/*

	 * XXX write back updated timeout value to userland if any.

	 */

	return (error);

}

/*

 * Pselect system call.

 */

int

sys_pselect(struct pselect_args *uap)

{

	struct timespec kts;

	struct timeval ktv;

	struct timeval *ktvp;

	sigset_t sigmask;

	sigset_t osigmask;

	int error;

	/*

	 * Get timeout if any and convert it.

	 * Round up during conversion to avoid timeout going off early.

	 */

	if (uap->ts != NULL) {

		error = copyin(uap->ts, &kts, sizeof (kts));

		if (error)

			return (error);

		ktv.tv_sec = kts.tv_sec;

		ktv.tv_usec = (kts.tv_nsec + 999) / 1000;

		error = itimerfix(&ktv);

		if (error)

			return (error);

		ktvp = &ktv;

	} else {

		ktvp = NULL;

	}

	/*

	 * Install temporary signal mask if any.

	 */

	if (uap->sigmask != NULL) {

		error = copyin(uap->sigmask, &sigmask, sizeof(sigmask));

		if (error)

			return (error);

		(void) kern_sigprocmask(SIG_SETMASK, &sigmask, &osigmask);

	}

	/*

	 * Do real job.

	 */

	error = doselect(uap->nd, uap->in, uap->ou, uap->ex, ktvp,

			&uap->sysmsg_result);

	/*

	 * Restore previous signal mask if necessary.

	 */

	if (uap->sigmask != NULL) {

		(void) kern_sigprocmask(SIG_SETMASK, &osigmask, NULL);

	}

	return (error);

}

/*

 * Common code for sys_select() and sys_pselect().

 *

 * in, out and ex are userland pointers.  tv must point to validated

 * kernel-side timeout value or NULL for infinite timeout.  res must

 * point to syscall return value.

 */

static int

doselect(int nd, fd_set *in, fd_set *ou, fd_set *ex, struct timeval *tv,

		int *res)

{

	if (nd < 0)

	if (nd > p->p_fd->fd_nfiles)

		nd = p->p_fd->fd_nfiles;   /* forgiving; slightly wrong */

	nfdbits = roundup(nd, NFDBITS);

	if (in != NULL)

	if (ou != NULL)

	if (ex != NULL)

		if (name == NULL)					\

			error = copyin(name, ibits[x], ncpbytes);	\

	if (tv != NULL) {

		atv = *tv;

	error = selscan(p, ibits, obits, nd, res);

	if (error || *res)

		if (timevalcmp(&rtv, &atv, >=))

	if (name && (error2 = copyout(obits[x], name, ncpbytes))) \

499	STD	BSD	{ int pselect(int nd, fd_set *in, fd_set *ou, \

			    fd_set *ex, const struct timespec *ts,    \

			    const sigset_t *sigmask); }

struct timespec;			/* pselect(2) */

int	 pselect(int, fd_set * __restrict, fd_set * __restrict,

		fd_set * __restrict, const struct timespec * __restrict,

		const sigset_t * __restrict);

struct timespec;

int	 pselect(int, fd_set * __restrict, fd_set * __restrict,

		fd_set * __restrict, const struct timespec * __restrict,

		const sigset_t * __restrict);

extern int	__sys_pselect(int, fd_set *, fd_set *, fd_set *,

__pselect(int count, fd_set *rfds, fd_set *wfds, fd_set *efds,

	ret = __sys_pselect(count, rfds, wfds, efds, timo, mask);

__strong_reference(__pselect, pselect);

int

pselect(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,

	const struct timespec *timeout, const sigset_t *mask)

{

	sigset_t omask;

	struct timeval tv;

	struct timeval *tvp;

	int ret;

	_thread_enter_cancellation_point();

	if (timeout != NULL) {

		tv.tv_sec = timeout->tv_sec;

		tv.tv_usec = (timeout->tv_nsec + 999) / 1000;

		tvp = &tv;

	} else {

		tvp = NULL;

	}

	/*

	 * XXX The masking/select/unmasking sequence below is not atomic.  See

	 * man page.

	 *

	 * The Right Thing would be to mask/unmask signals kernel-side.  We do

	 * this for single-threaded and libthread_xu processes but this is far

	 * from trivial for libc_r because select() is actually a poll()

	 * wrapper there and not using poll() would involve complex changes in

	 * the user thread scheduler.  We're deprecating libc_r in favor of

	 * libthread_xu so the usefulness of such a change is questionable.

	 */

	if (mask != NULL)

		(void) sigprocmask(SIG_SETMASK, mask, &omask);

	ret = _select(numfds, readfds, writefds, exceptfds, tvp);

	if (mask != NULL)

		(void) sigprocmask(SIG_SETMASK, &omask, NULL);

	_thread_leave_cancellation_point();

	return ret;

}

	unlink.2 utimes.2 upc_register.2 usched_set.2 uuidgen.2 vfork.2 \

	wait.2 write.2 pselect.2

.\"

.\" Copyright 2002 Massachusetts Institute of Technology

.\"

.\" Permission to use, copy, modify, and distribute this software and

.\" its documentation for any purpose and without fee is hereby

.\" granted, provided that both the above copyright notice and this

.\" permission notice appear in all copies, that both the above

.\" copyright notice and this permission notice appear in all

.\" supporting documentation, and that the name of M.I.T. not be used

.\" in advertising or publicity pertaining to distribution of the

.\" software without specific, written prior permission.  M.I.T. makes

.\" no representations about the suitability of this software for any

.\" purpose.  It is provided "as is" without express or implied

.\" warranty.

.\"

.\" THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS

.\" ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,

.\" INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

.\" MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT

.\" SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

.\" SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

.\" LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

.\" USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

.\" ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

.\" OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

.\" OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

.\" SUCH DAMAGE.

.\"

.\" $FreeBSD: src/lib/libc/gen/pselect.3,v 1.4 2002/12/18 10:13:54 ru Exp $

.\"

.Dd December 24, 2007

.Dt PSELECT 2

.Os

.Sh NAME

.Nm pselect

.Nd synchronous I/O multiplexing a la POSIX.1g

.Sh LIBRARY

.Lb libc

.Sh SYNOPSIS

.In sys/select.h

.Ft int

.Fo pselect

.Fa "int nfds"

.Fa "fd_set * restrict readfds"

.Fa "fd_set * restrict writefds"

.Fa "fd_set * restrict exceptfds"

.Fa "const struct timespec * restrict timeout"

.Fa "const sigset_t * restrict newsigmask"

.Fc

.Sh DESCRIPTION

The

.Fn pselect

function was introduced by

.St -p1003.1g-2000

as a slightly stronger version of

.Xr select 2 .

The

.Fa nfds , readfds , writefds ,

and

.Fa exceptfds

arguments are all identical to the analogous arguments of

.Fn select .

The

.Fa timeout

argument in

.Fn pselect

points to a

.Vt "const struct timespec"

rather than the (modifiable)

.Vt "struct timeval"

used by

.Fn select ;

as in

.Fn select ,

a null pointer may be passed to indicate that

.Fn pselect

should wait indefinitely.

Finally,

.Fa newsigmask

specifies a signal mask which is set while waiting for input.

When

.Fn pselect

returns, the original signal mask is restored.

.Pp

See

.Xr select 2

for a more detailed discussion of the semantics of this interface, and

for macros used to manipulate the

.Vt "fd_set"

data type.

.Sh RETURN VALUES

The

.Fn pselect

function returns the same values and under the same conditions as

.Fn select .

.Sh ERRORS

The

.Fn pselect

function may fail for any of the reasons documented for

.Xr select 2

and (if a signal mask is provided)

.Xr sigprocmask 2 .

.Sh SEE ALSO

.Xr kqueue 2 ,

.Xr poll 2 ,

.Xr select 2 ,

.Xr sigprocmask 2

.Sh STANDARDS

The

.Fn pselect

function conforms to

.St -p1003.1-2001 .

.Sh BUGS

The

.Fn pselect

implementation in libc_r (user multi-threading) does not mask signals, calls

.Fn select ,

and restores the original signal mask atomically.  A calling user thread

using

.Fn pselect

to block until either a signal occurs or some descriptor changes may therefore

block forever.

The

.Fn pselect

implementations in libthread_xu (kernel multi-threading) and libc

(single-threading) operate atomically and are therefore race-free.

.Sh HISTORY

The

.Fn pselect

function first appeared in

.Dx 1.11 .

.Sh AUTHORS

This manual page was originally written by

.An Garrett Wollman Aq wollman@FreeBSD.org

for FreeBSD and later modified for DragonFly.