1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1988 AT&T */
28 /* All Rights Reserved */
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /*
33 * Emulation of select() system call using poll() system call.
34 *
35 * Assumptions:
36 * polling for input only is most common.
37 * polling for exceptional conditions is very rare.
38 *
39 * Note that is it not feasible to emulate all error conditions,
40 * in particular conditions that would return EFAULT are far too
41 * difficult to check for in a library routine.
42 */
43
44 #pragma weak _select = select
45
46 #include "lint.h"
47 #include <values.h>
48 #include <pthread.h>
49 #include <errno.h>
50 #include <sys/time.h>
51 #include <sys/types.h>
52 #include <sys/select.h>
53 #include <sys/poll.h>
54 #include <alloca.h>
55 #include "libc.h"
56
57 int
58 pselect(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0,
59 const timespec_t *tsp, const sigset_t *sigmask)
60 {
61 long *in, *out, *ex;
62 ulong_t m; /* bit mask */
63 int j; /* loop counter */
64 ulong_t b; /* bits to test */
65 int n, rv;
66 struct pollfd *pfd;
67 struct pollfd *p;
68 int lastj = -1;
69
70 /* "zero" is read-only, it could go in the text segment */
71 static fd_set zero = { 0 };
72
73 /*
74 * Check for invalid conditions at outset.
75 * Required for spec1170.
76 * SUSV3: We must behave as a cancellation point even if we fail early.
77 */
78 if (nfds < 0 || nfds > FD_SETSIZE) {
79 pthread_testcancel();
80 errno = EINVAL;
81 return (-1);
82 }
83 p = pfd = (struct pollfd *)alloca(nfds * sizeof (struct pollfd));
84
85 if (tsp != NULL) {
86 /* check timespec validity */
87 if (tsp->tv_nsec < 0 || tsp->tv_nsec >= NANOSEC ||
88 tsp->tv_sec < 0) {
89 pthread_testcancel();
90 errno = EINVAL;
91 return (-1);
92 }
93 }
94
95 /*
96 * If any input args are null, point them at the null array.
97 */
98 if (in0 == NULL)
99 in0 = &zero;
100 if (out0 == NULL)
101 out0 = &zero;
102 if (ex0 == NULL)
103 ex0 = &zero;
104
105 /*
106 * For each fd, if any bits are set convert them into
107 * the appropriate pollfd struct.
108 */
109 in = (long *)in0->fds_bits;
110 out = (long *)out0->fds_bits;
111 ex = (long *)ex0->fds_bits;
112 for (n = 0; n < nfds; n += NFDBITS) {
113 b = (ulong_t)(*in | *out | *ex);
114 for (j = 0, m = 1; b != 0; j++, b >>= 1, m <<= 1) {
115 if (b & 1) {
116 p->fd = n + j;
117 if (p->fd >= nfds)
118 goto done;
119 p->events = 0;
120 if (*in & m)
121 p->events |= POLLRDNORM;
122 if (*out & m)
123 p->events |= POLLWRNORM;
124 if (*ex & m)
125 p->events |= POLLRDBAND;
126 p++;
127 }
128 }
129 in++;
130 out++;
131 ex++;
132 }
133 done:
134 /*
135 * Now do the poll.
136 */
137 n = (int)(p - pfd); /* number of pollfd's */
138 do {
139 rv = _pollsys(pfd, (nfds_t)n, tsp, sigmask);
140 } while (rv < 0 && errno == EAGAIN);
141
142 if (rv < 0) /* no need to set bit masks */
143 return (rv);
144
145 if (rv == 0) {
146 /*
147 * Clear out bit masks, just in case.
148 * On the assumption that usually only
149 * one bit mask is set, use three loops.
150 */
151 if (in0 != &zero) {
152 in = (long *)in0->fds_bits;
153 for (n = 0; n < nfds; n += NFDBITS)
154 *in++ = 0;
155 }
156 if (out0 != &zero) {
157 out = (long *)out0->fds_bits;
158 for (n = 0; n < nfds; n += NFDBITS)
159 *out++ = 0;
160 }
161 if (ex0 != &zero) {
162 ex = (long *)ex0->fds_bits;
163 for (n = 0; n < nfds; n += NFDBITS)
164 *ex++ = 0;
165 }
166 return (0);
167 }
168
169 /*
170 * Check for EINVAL error case first to avoid changing any bits
171 * if we're going to return an error.
172 */
173 for (p = pfd, j = n; j-- > 0; p++) {
174 /*
175 * select will return EBADF immediately if any fd's
176 * are bad. poll will complete the poll on the
177 * rest of the fd's and include the error indication
178 * in the returned bits. This is a rare case so we
179 * accept this difference and return the error after
180 * doing more work than select would've done.
181 */
182 if (p->revents & POLLNVAL) {
183 errno = EBADF;
184 return (-1);
185 }
186 /*
187 * We would like to make POLLHUP available to select,
188 * checking to see if we have pending data to be read.
189 * BUT until we figure out how not to break Xsun's
190 * dependencies on select's existing features...
191 * This is what we _thought_ would work ... sigh!
192 */
193 /*
194 * if ((p->revents & POLLHUP) &&
195 * !(p->revents & (POLLRDNORM|POLLRDBAND))) {
196 * errno = EINTR;
197 * return (-1);
198 * }
199 */
200 }
201
202 /*
203 * Convert results of poll back into bits
204 * in the argument arrays.
205 *
206 * We assume POLLRDNORM, POLLWRNORM, and POLLRDBAND will only be set
207 * on return from poll if they were set on input, thus we don't
208 * worry about accidentally setting the corresponding bits in the
209 * zero array if the input bit masks were null.
210 *
211 * Must return number of bits set, not number of ready descriptors
212 * (as the man page says, and as poll() does).
213 */
214 rv = 0;
215 for (p = pfd; n-- > 0; p++) {
216 j = (int)(p->fd / NFDBITS);
217 /* have we moved into another word of the bit mask yet? */
218 if (j != lastj) {
219 /* clear all output bits to start with */
220 in = (long *)&in0->fds_bits[j];
221 out = (long *)&out0->fds_bits[j];
222 ex = (long *)&ex0->fds_bits[j];
223 /*
224 * In case we made "zero" read-only (e.g., with
225 * cc -R), avoid actually storing into it.
226 */
227 if (in0 != &zero)
228 *in = 0;
229 if (out0 != &zero)
230 *out = 0;
231 if (ex0 != &zero)
232 *ex = 0;
233 lastj = j;
234 }
235 if (p->revents) {
236 m = 1L << (p->fd % NFDBITS);
237 if (p->revents & POLLRDNORM) {
238 *in |= m;
239 rv++;
240 }
241 if (p->revents & POLLWRNORM) {
242 *out |= m;
243 rv++;
244 }
245 if (p->revents & POLLRDBAND) {
246 *ex |= m;
247 rv++;
248 }
249 /*
250 * Only set this bit on return if we asked about
251 * input conditions.
252 */
253 if ((p->revents & (POLLHUP|POLLERR)) &&
254 (p->events & POLLRDNORM)) {
255 if ((*in & m) == 0)
256 rv++; /* wasn't already set */
257 *in |= m;
258 }
259 /*
260 * Only set this bit on return if we asked about
261 * output conditions.
262 */
263 if ((p->revents & (POLLHUP|POLLERR)) &&
264 (p->events & POLLWRNORM)) {
265 if ((*out & m) == 0)
266 rv++; /* wasn't already set */
267 *out |= m;
268 }
269 /*
270 * Only set this bit on return if we asked about
271 * output conditions.
272 */
273 if ((p->revents & (POLLHUP|POLLERR)) &&
274 (p->events & POLLRDBAND)) {
275 if ((*ex & m) == 0)
276 rv++; /* wasn't already set */
277 *ex |= m;
278 }
279 }
280 }
281 return (rv);
282 }
283
284 int
285 select(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0, struct timeval *tv)
286 {
287 timespec_t ts;
288 timespec_t *tsp;
289
290 if (tv == NULL)
291 tsp = NULL;
292 else {
293 /* check timeval validity */
294 if (tv->tv_usec < 0 || tv->tv_usec >= MICROSEC) {
295 errno = EINVAL;
296 return (-1);
297 }
298 /*
299 * Convert timeval to timespec.
300 * To preserve compatibility with past behavior,
301 * when select was built upon poll(2), which has a
302 * minimum non-zero timeout of 1 millisecond, force
303 * a minimum non-zero timeout of 500 microseconds.
304 */
305 ts.tv_sec = tv->tv_sec;
306 ts.tv_nsec = tv->tv_usec * 1000;
307 if (ts.tv_nsec != 0 && ts.tv_nsec < 500000)
308 ts.tv_nsec = 500000;
309 tsp = &ts;
310 }
311
312 return (pselect(nfds, in0, out0, ex0, tsp, NULL));
313 }