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 /* 31 * Emulation of select() system call using poll() system call. 32 * 33 * Assumptions: 34 * polling for input only is most common. 35 * polling for exceptional conditions is very rare. 36 * 37 * Note that is it not feasible to emulate all error conditions, 38 * in particular conditions that would return EFAULT are far too 39 * difficult to check for in a library routine. 40 */ 41 42 #pragma weak _select = select 43 44 #include "lint.h" 45 #include <values.h> 46 #include <pthread.h> 47 #include <errno.h> 48 #include <stdlib.h> 49 #include <sys/time.h> 50 #include <sys/types.h> 51 #include <sys/select.h> 52 #include <sys/poll.h> 53 #include <alloca.h> 54 #include "libc.h" 55 56 /* 57 * STACK_PFD_LIM 58 * 59 * The limit at which pselect allocates pollfd structures in the heap, 60 * rather than on the stack. These limits match the historical behaviour 61 * with the * _large_fdset implementations. 62 * 63 * BULK_ALLOC_LIM 64 * 65 * The limit below which we'll just allocate nfds pollfds, rather than 66 * counting how many we actually need. 67 */ 68 #if defined(_LP64) 69 #define STACK_PFD_LIM FD_SETSIZE 70 #define BULK_ALLOC_LIM 8192 71 #else 72 #define STACK_PFD_LIM 1024 73 #define BULK_ALLOC_LIM 1024 74 #endif 75 76 /* 77 * The previous _large_fdset implementations are, unfortunately, baked into 78 * the ABI. 79 */ 80 #pragma weak select_large_fdset = select 81 #pragma weak pselect_large_fdset = pselect 82 83 #define fd_set_size(nfds) (((nfds) + (NFDBITS - 1)) / NFDBITS) 84 85 static nfds_t 86 fd_sets_count(int limit, fd_set *in, fd_set *out, fd_set *ex) 87 { 88 nfds_t total = 0; 89 90 if (limit <= 0) 91 return (0); 92 93 for (int i = 0; i < fd_set_size(limit); i++) { 94 long v = (in->fds_bits[i] | out->fds_bits[i] | ex->fds_bits[i]); 95 96 while (v != 0) { 97 v &= v - 1; 98 total++; 99 } 100 } 101 102 return (total); 103 } 104 105 int 106 pselect(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0, 107 const timespec_t *tsp, const sigset_t *sigmask) 108 { 109 long *in, *out, *ex; 110 ulong_t m; /* bit mask */ 111 int j; /* loop counter */ 112 ulong_t b; /* bits to test */ 113 int n, rv; 114 struct pollfd *pfd; 115 struct pollfd *p; 116 int lastj = -1; 117 nfds_t npfds = 0; 118 boolean_t heap_pfds = B_FALSE; 119 120 /* "zero" is read-only, it could go in the text segment */ 121 static fd_set zero = { 0 }; 122 123 /* 124 * Check for invalid conditions at outset. 125 * Required for spec1170. 126 * SUSV3: We must behave as a cancellation point even if we fail early. 127 */ 128 if (nfds < 0 || nfds > FD_SETSIZE) { 129 pthread_testcancel(); 130 errno = EINVAL; 131 return (-1); 132 } 133 134 if (tsp != NULL) { 135 /* check timespec validity */ 136 if (tsp->tv_nsec < 0 || tsp->tv_nsec >= NANOSEC || 137 tsp->tv_sec < 0) { 138 pthread_testcancel(); 139 errno = EINVAL; 140 return (-1); 141 } 142 } 143 144 /* 145 * If any input args are null, point them at the null array. 146 */ 147 if (in0 == NULL) 148 in0 = &zero; 149 if (out0 == NULL) 150 out0 = &zero; 151 if (ex0 == NULL) 152 ex0 = &zero; 153 154 if (nfds <= BULK_ALLOC_LIM) { 155 p = pfd = alloca(nfds * sizeof (struct pollfd)); 156 } else { 157 npfds = fd_sets_count(nfds, in0, out0, ex0); 158 159 if (npfds > STACK_PFD_LIM) { 160 p = pfd = malloc(npfds * sizeof (struct pollfd)); 161 if (p == NULL) 162 return (-1); 163 heap_pfds = B_TRUE; 164 } else { 165 p = pfd = alloca(npfds * sizeof (struct pollfd)); 166 } 167 } 168 169 /* 170 * For each fd, if any bits are set convert them into 171 * the appropriate pollfd struct. 172 */ 173 in = (long *)in0->fds_bits; 174 out = (long *)out0->fds_bits; 175 ex = (long *)ex0->fds_bits; 176 for (n = 0; n < nfds; n += NFDBITS) { 177 b = (ulong_t)(*in | *out | *ex); 178 for (j = 0, m = 1; b != 0; j++, b >>= 1, m <<= 1) { 179 if (b & 1) { 180 p->fd = n + j; 181 if (p->fd >= nfds) 182 goto done; 183 p->events = 0; 184 if (*in & m) 185 p->events |= POLLRDNORM; 186 if (*out & m) 187 p->events |= POLLWRNORM; 188 if (*ex & m) 189 p->events |= POLLRDBAND; 190 p++; 191 } 192 } 193 in++; 194 out++; 195 ex++; 196 } 197 done: 198 /* 199 * Now do the poll. 200 */ 201 npfds = (int)(p - pfd); 202 do { 203 rv = _pollsys(pfd, npfds, tsp, sigmask); 204 } while (rv < 0 && errno == EAGAIN); 205 206 if (rv < 0) /* no need to set bit masks */ 207 goto out; 208 209 if (rv == 0) { 210 /* 211 * Clear out bit masks, just in case. 212 * On the assumption that usually only 213 * one bit mask is set, use three loops. 214 */ 215 if (in0 != &zero) { 216 in = (long *)in0->fds_bits; 217 for (n = 0; n < nfds; n += NFDBITS) 218 *in++ = 0; 219 } 220 if (out0 != &zero) { 221 out = (long *)out0->fds_bits; 222 for (n = 0; n < nfds; n += NFDBITS) 223 *out++ = 0; 224 } 225 if (ex0 != &zero) { 226 ex = (long *)ex0->fds_bits; 227 for (n = 0; n < nfds; n += NFDBITS) 228 *ex++ = 0; 229 } 230 rv = 0; 231 goto out; 232 } 233 234 /* 235 * Check for EINVAL error case first to avoid changing any bits 236 * if we're going to return an error. 237 */ 238 for (p = pfd, n = npfds; n-- > 0; p++) { 239 /* 240 * select will return EBADF immediately if any fd's 241 * are bad. poll will complete the poll on the 242 * rest of the fd's and include the error indication 243 * in the returned bits. This is a rare case so we 244 * accept this difference and return the error after 245 * doing more work than select would've done. 246 */ 247 if (p->revents & POLLNVAL) { 248 errno = EBADF; 249 rv = -1; 250 goto out; 251 } 252 /* 253 * We would like to make POLLHUP available to select, 254 * checking to see if we have pending data to be read. 255 * BUT until we figure out how not to break Xsun's 256 * dependencies on select's existing features... 257 * This is what we _thought_ would work ... sigh! 258 */ 259 /* 260 * if ((p->revents & POLLHUP) && 261 * !(p->revents & (POLLRDNORM|POLLRDBAND))) { 262 * errno = EINTR; 263 * rv = -1; 264 * goto out; 265 * } 266 */ 267 } 268 269 /* 270 * Convert results of poll back into bits 271 * in the argument arrays. 272 * 273 * We assume POLLRDNORM, POLLWRNORM, and POLLRDBAND will only be set 274 * on return from poll if they were set on input, thus we don't 275 * worry about accidentally setting the corresponding bits in the 276 * zero array if the input bit masks were null. 277 * 278 * Must return number of bits set, not number of ready descriptors 279 * (as the man page says, and as poll() does). 280 */ 281 rv = 0; 282 for (p = pfd, n = npfds; n-- > 0; p++) { 283 j = (int)(p->fd / NFDBITS); 284 /* have we moved into another word of the bit mask yet? */ 285 if (j != lastj) { 286 /* clear all output bits to start with */ 287 in = (long *)&in0->fds_bits[j]; 288 out = (long *)&out0->fds_bits[j]; 289 ex = (long *)&ex0->fds_bits[j]; 290 /* 291 * In case we made "zero" read-only (e.g., with 292 * cc -R), avoid actually storing into it. 293 */ 294 if (in0 != &zero) 295 *in = 0; 296 if (out0 != &zero) 297 *out = 0; 298 if (ex0 != &zero) 299 *ex = 0; 300 lastj = j; 301 } 302 if (p->revents) { 303 m = 1L << (p->fd % NFDBITS); 304 if (p->revents & POLLRDNORM) { 305 *in |= m; 306 rv++; 307 } 308 if (p->revents & POLLWRNORM) { 309 *out |= m; 310 rv++; 311 } 312 if (p->revents & POLLRDBAND) { 313 *ex |= m; 314 rv++; 315 } 316 /* 317 * Only set this bit on return if we asked about 318 * input conditions. 319 */ 320 if ((p->revents & (POLLHUP|POLLERR)) && 321 (p->events & POLLRDNORM)) { 322 if ((*in & m) == 0) 323 rv++; /* wasn't already set */ 324 *in |= m; 325 } 326 /* 327 * Only set this bit on return if we asked about 328 * output conditions. 329 */ 330 if ((p->revents & (POLLHUP|POLLERR)) && 331 (p->events & POLLWRNORM)) { 332 if ((*out & m) == 0) 333 rv++; /* wasn't already set */ 334 *out |= m; 335 } 336 /* 337 * Only set this bit on return if we asked about 338 * output conditions. 339 */ 340 if ((p->revents & (POLLHUP|POLLERR)) && 341 (p->events & POLLRDBAND)) { 342 if ((*ex & m) == 0) 343 rv++; /* wasn't already set */ 344 *ex |= m; 345 } 346 } 347 } 348 out: 349 if (heap_pfds) 350 free(pfd); 351 return (rv); 352 } 353 354 int 355 select(int nfds, fd_set *in0, fd_set *out0, fd_set *ex0, struct timeval *tv) 356 { 357 timespec_t ts; 358 timespec_t *tsp; 359 360 if (tv == NULL) 361 tsp = NULL; 362 else { 363 /* check timeval validity */ 364 if (tv->tv_usec < 0 || tv->tv_usec >= MICROSEC) { 365 errno = EINVAL; 366 return (-1); 367 } 368 /* 369 * Convert timeval to timespec. 370 * To preserve compatibility with past behavior, 371 * when select was built upon poll(2), which has a 372 * minimum non-zero timeout of 1 millisecond, force 373 * a minimum non-zero timeout of 500 microseconds. 374 */ 375 ts.tv_sec = tv->tv_sec; 376 ts.tv_nsec = tv->tv_usec * 1000; 377 if (ts.tv_nsec != 0 && ts.tv_nsec < 500000) 378 ts.tv_nsec = 500000; 379 tsp = &ts; 380 } 381 382 return (pselect(nfds, in0, out0, ex0, tsp, NULL)); 383 } 384