1 /*
2 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /*
27 * This file contains implementations of NET_... functions. The NET_.. functions are
28 * wrappers for common file- and socket functions plus provisions for non-blocking IO.
29 *
30 * (basically, the layers remember all file descriptors waiting for a particular fd;
31 * all threads waiting on a certain fd can be woken up by sending them a signal; this
32 * is done e.g. when the fd is closed.)
33 *
34 * This was originally copied from the linux_close.c implementation.
35 *
36 * Side Note: This coding needs initialization. Under Linux this is done
37 * automatically via __attribute((constructor)), on AIX this is done manually
38 * (see aix_close_init).
39 *
40 */
41
42 /*
43 AIX needs a workaround for I/O cancellation, see:
44 http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/close.htm
45 ...
46 The close subroutine is blocked until all subroutines which use the file
47 descriptor return to usr space. For example, when a thread is calling close
48 and another thread is calling select with the same file descriptor, the
49 close subroutine does not return until the select call returns.
50 ...
51 */
52
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include <signal.h>
56 #include <pthread.h>
57 #include <sys/types.h>
58 #include <sys/socket.h>
59 #include <sys/time.h>
60 #include <sys/resource.h>
61 #include <sys/uio.h>
62 #include <unistd.h>
63 #include <errno.h>
64 #include <sys/poll.h>
65
66 /*
67 * Stack allocated by thread when doing blocking operation
68 */
69 typedef struct threadEntry {
70 pthread_t thr; /* this thread */
71 struct threadEntry *next; /* next thread */
72 int intr; /* interrupted */
73 } threadEntry_t;
74
75 /*
76 * Heap allocated during initialized - one entry per fd
77 */
78 typedef struct {
79 pthread_mutex_t lock; /* fd lock */
80 threadEntry_t *threads; /* threads blocked on fd */
81 } fdEntry_t;
82
83 /*
84 * Signal to unblock thread
85 */
86 static int sigWakeup = (SIGRTMAX - 1);
87
88 /*
89 * The fd table and the number of file descriptors
90 */
91 static fdEntry_t *fdTable = NULL;
92 static int fdCount = 0;
93
94 /*
95 * Null signal handler
96 */
97 static void sig_wakeup(int sig) {
98 }
99
100 /*
101 * Initialization routine (executed when library is loaded)
102 * Allocate fd tables and sets up signal handler.
103 *
104 * On AIX we don't have __attribute((constructor)) so we need to initialize
105 * manually (from JNI_OnLoad() in 'src/share/native/java/net/net_util.c')
106 */
107 void aix_close_init() {
108 struct rlimit nbr_files;
109 sigset_t sigset;
110 struct sigaction sa;
111
112 /* Check already initialized */
113 if (fdCount > 0 && fdTable != NULL) {
114 return;
115 }
116
117 /*
118 * Allocate table based on the maximum number of
119 * file descriptors.
120 */
121 if (-1 == getrlimit(RLIMIT_NOFILE, &nbr_files)) {
122 fprintf(stderr, "library initialization failed - "
123 "unable to get max # of allocated fds\n");
124 abort();
125 }
126 fdCount = nbr_files.rlim_max;
127 /*
128 * We have a conceptual problem here, when the number of files is
129 * unlimited. As a kind of workaround, we ensure the table is big
130 * enough for handle even a large number of files. Since SAP itself
131 * recommends a limit of 32000 files, we just use 64000 as 'infinity'.
132 */
133 if (nbr_files.rlim_max == RLIM_INFINITY) {
134 fdCount = 64000;
135 }
136 fdTable = (fdEntry_t *)calloc(fdCount, sizeof(fdEntry_t));
137 if (fdTable == NULL) {
138 fprintf(stderr, "library initialization failed - "
139 "unable to allocate file descriptor table - out of memory");
140 abort();
141 }
142
143 {
144 int i;
145 for (i=0; i < fdCount; i++) {
146 pthread_mutex_init(&fdTable[i].lock, NULL);
147 }
148 }
149
150 /*
151 * Setup the signal handler
152 */
153 sa.sa_handler = sig_wakeup;
154 sa.sa_flags = 0;
155 sigemptyset(&sa.sa_mask);
156 sigaction(sigWakeup, &sa, NULL);
157
158 sigemptyset(&sigset);
159 sigaddset(&sigset, sigWakeup);
160 sigprocmask(SIG_UNBLOCK, &sigset, NULL);
161 }
162
163 /*
164 * Return the fd table for this fd or NULL is fd out
165 * of range.
166 */
167 static inline fdEntry_t *getFdEntry(int fd)
168 {
169 if (fd < 0 || fd >= fdCount) {
170 return NULL;
171 }
172 return &fdTable[fd];
173 }
174
175 /*
176 * Start a blocking operation :-
177 * Insert thread onto thread list for the fd.
178 */
179 static inline void startOp(fdEntry_t *fdEntry, threadEntry_t *self)
180 {
181 self->thr = pthread_self();
182 self->intr = 0;
183
184 pthread_mutex_lock(&(fdEntry->lock));
185 {
186 self->next = fdEntry->threads;
187 fdEntry->threads = self;
188 }
189 pthread_mutex_unlock(&(fdEntry->lock));
190 }
191
192 /*
193 * End a blocking operation :-
194 * Remove thread from thread list for the fd
195 * If fd has been interrupted then set errno to EBADF
196 */
197 static inline void endOp
198 (fdEntry_t *fdEntry, threadEntry_t *self)
199 {
200 int orig_errno = errno;
201 pthread_mutex_lock(&(fdEntry->lock));
202 {
203 threadEntry_t *curr, *prev=NULL;
204 curr = fdEntry->threads;
205 while (curr != NULL) {
206 if (curr == self) {
207 if (curr->intr) {
208 orig_errno = EBADF;
209 }
210 if (prev == NULL) {
211 fdEntry->threads = curr->next;
212 } else {
213 prev->next = curr->next;
214 }
215 break;
216 }
217 prev = curr;
218 curr = curr->next;
219 }
220 }
221 pthread_mutex_unlock(&(fdEntry->lock));
222 errno = orig_errno;
223 }
224
225 /*
226 * Close or dup2 a file descriptor ensuring that all threads blocked on
227 * the file descriptor are notified via a wakeup signal.
228 *
229 * fd1 < 0 => close(fd2)
230 * fd1 >= 0 => dup2(fd1, fd2)
231 *
232 * Returns -1 with errno set if operation fails.
233 */
234 static int closefd(int fd1, int fd2) {
235 int rv, orig_errno;
236 fdEntry_t *fdEntry = getFdEntry(fd2);
237 if (fdEntry == NULL) {
238 errno = EBADF;
239 return -1;
240 }
241
242 /*
243 * Lock the fd to hold-off additional I/O on this fd.
244 */
245 pthread_mutex_lock(&(fdEntry->lock));
246
247 {
248 /* On fast machines we see that we enter dup2 before the
249 * accepting thread had a chance to get and process the signal.
250 * So in case we woke a thread up, give it some time to cope.
251 * Also see https://bugs.openjdk.java.net/browse/JDK-8006395 */
252 int num_woken = 0;
253
254 /*
255 * Send a wakeup signal to all threads blocked on this
256 * file descriptor.
257 */
258 threadEntry_t *curr = fdEntry->threads;
259 while (curr != NULL) {
260 curr->intr = 1;
261 pthread_kill( curr->thr, sigWakeup );
262 num_woken ++;
263 curr = curr->next;
264 }
265
266 if (num_woken > 0) {
267 usleep(num_woken * 50);
268 }
269
270 /*
271 * And close/dup the file descriptor
272 * (restart if interrupted by signal)
273 */
274 do {
275 if (fd1 < 0) {
276 rv = close(fd2);
277 } else {
278 rv = dup2(fd1, fd2);
279 }
280 } while (rv == -1 && errno == EINTR);
281 }
282
283 /*
284 * Unlock without destroying errno
285 */
286 orig_errno = errno;
287 pthread_mutex_unlock(&(fdEntry->lock));
288 errno = orig_errno;
289
290 return rv;
291 }
292
293 /*
294 * Wrapper for dup2 - same semantics as dup2 system call except
295 * that any threads blocked in an I/O system call on fd2 will be
296 * preempted and return -1/EBADF;
297 */
298 int NET_Dup2(int fd, int fd2) {
299 if (fd < 0) {
300 errno = EBADF;
301 return -1;
302 }
303 return closefd(fd, fd2);
304 }
305
306 /*
307 * Wrapper for close - same semantics as close system call
308 * except that any threads blocked in an I/O on fd will be
309 * preempted and the I/O system call will return -1/EBADF.
310 */
311 int NET_SocketClose(int fd) {
312 return closefd(-1, fd);
313 }
314
315 /************** Basic I/O operations here ***************/
316
317 /*
318 * Macro to perform a blocking IO operation. Restarts
319 * automatically if interrupted by signal (other than
320 * our wakeup signal)
321 */
322 #define BLOCKING_IO_RETURN_INT(FD, FUNC) { \
323 int ret; \
324 threadEntry_t self; \
325 fdEntry_t *fdEntry = getFdEntry(FD); \
326 if (fdEntry == NULL) { \
327 errno = EBADF; \
328 return -1; \
329 } \
330 do { \
331 startOp(fdEntry, &self); \
332 ret = FUNC; \
333 endOp(fdEntry, &self); \
334 } while (ret == -1 && errno == EINTR); \
335 return ret; \
336 }
337
338 int NET_Read(int s, void* buf, size_t len) {
339 BLOCKING_IO_RETURN_INT( s, recv(s, buf, len, 0) );
340 }
341
342 int NET_ReadV(int s, const struct iovec * vector, int count) {
343 BLOCKING_IO_RETURN_INT( s, readv(s, vector, count) );
344 }
345
346 int NET_RecvFrom(int s, void *buf, int len, unsigned int flags,
347 struct sockaddr *from, int *fromlen) {
348 socklen_t socklen = *fromlen;
349 BLOCKING_IO_RETURN_INT( s, recvfrom(s, buf, len, flags, from, &socklen) );
350 *fromlen = socklen;
351 }
352
353 int NET_Send(int s, void *msg, int len, unsigned int flags) {
354 BLOCKING_IO_RETURN_INT( s, send(s, msg, len, flags) );
355 }
356
357 int NET_WriteV(int s, const struct iovec * vector, int count) {
358 BLOCKING_IO_RETURN_INT( s, writev(s, vector, count) );
359 }
360
361 int NET_SendTo(int s, const void *msg, int len, unsigned int
362 flags, const struct sockaddr *to, int tolen) {
363 BLOCKING_IO_RETURN_INT( s, sendto(s, msg, len, flags, to, tolen) );
364 }
365
366 int NET_Accept(int s, struct sockaddr *addr, int *addrlen) {
367 socklen_t socklen = *addrlen;
368 BLOCKING_IO_RETURN_INT( s, accept(s, addr, &socklen) );
369 *addrlen = socklen;
370 }
371
372 int NET_Connect(int s, struct sockaddr *addr, int addrlen) {
373 int crc = -1, prc = -1;
374 threadEntry_t self;
375 fdEntry_t* fdEntry = getFdEntry(s);
376
377 if (fdEntry == NULL) {
378 errno = EBADF;
379 return -1;
380 }
381
382 /* On AIX, when the system call connect() is interrupted, the connection
383 * is not aborted and it will be established asynchronously by the kernel.
384 * Hence, no need to restart connect() when EINTR is received
385 */
386 startOp(fdEntry, &self);
387 crc = connect(s, addr, addrlen);
388 endOp(fdEntry, &self);
389
390 if (crc == -1 && errno == EINTR) {
391 struct pollfd s_pollfd;
392 int sockopt_arg = 0;
393 socklen_t len;
394
395 s_pollfd.fd = s;
396 s_pollfd.events = POLLOUT | POLLERR;
397
398 /* poll the file descriptor */
399 do {
400 startOp(fdEntry, &self);
401 prc = poll(&s_pollfd, 1, -1);
402 endOp(fdEntry, &self);
403 } while (prc == -1 && errno == EINTR);
404
405 if (prc < 0)
406 return prc;
407
408 len = sizeof(sockopt_arg);
409
410 /* Check whether the connection has been established */
411 if (getsockopt(s, SOL_SOCKET, SO_ERROR, &sockopt_arg, &len) == -1)
412 return -1;
413
414 if (sockopt_arg != 0 ) {
415 errno = sockopt_arg;
416 return -1;
417 }
418 } else {
419 return crc;
420 }
421
422 /* At this point, fd is connected. Set successful return code */
423 return 0;
424 }
425
426 int NET_Poll(struct pollfd *ufds, unsigned int nfds, int timeout) {
427 BLOCKING_IO_RETURN_INT( ufds[0].fd, poll(ufds, nfds, timeout) );
428 }
429
430 /*
431 * Wrapper for poll(s, timeout).
432 * Auto restarts with adjusted timeout if interrupted by
433 * signal other than our wakeup signal.
434 */
435 int NET_Timeout(int s, long timeout) {
436 long prevtime = 0, newtime;
437 struct timeval t;
438 fdEntry_t *fdEntry = getFdEntry(s);
439
440 /*
441 * Check that fd hasn't been closed.
442 */
443 if (fdEntry == NULL) {
444 errno = EBADF;
445 return -1;
446 }
447
448 /*
449 * Pick up current time as may need to adjust timeout
450 */
451 if (timeout > 0) {
452 gettimeofday(&t, NULL);
453 prevtime = t.tv_sec * 1000 + t.tv_usec / 1000;
454 }
455
456 for(;;) {
457 struct pollfd pfd;
458 int rv;
459 threadEntry_t self;
460
461 /*
462 * Poll the fd. If interrupted by our wakeup signal
463 * errno will be set to EBADF.
464 */
465 pfd.fd = s;
466 pfd.events = POLLIN | POLLERR;
467
468 startOp(fdEntry, &self);
469 rv = poll(&pfd, 1, timeout);
470 endOp(fdEntry, &self);
471
472 /*
473 * If interrupted then adjust timeout. If timeout
474 * has expired return 0 (indicating timeout expired).
475 */
476 if (rv < 0 && errno == EINTR) {
477 if (timeout > 0) {
478 gettimeofday(&t, NULL);
479 newtime = t.tv_sec * 1000 + t.tv_usec / 1000;
480 timeout -= newtime - prevtime;
481 if (timeout <= 0) {
482 return 0;
483 }
484 prevtime = newtime;
485 }
486 } else {
487 return rv;
488 }
489
490 }
491 }