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 #include <stdio.h>
42 #include <stdlib.h>
43 #include <signal.h>
44 #include <pthread.h>
45 #include <sys/types.h>
46 #include <sys/socket.h>
47 #include <sys/time.h>
48 #include <sys/resource.h>
49 #include <sys/uio.h>
50 #include <unistd.h>
51 #include <errno.h>
52
53 #include <sys/poll.h>
54
55 /*
56 * Stack allocated by thread when doing blocking operation
57 */
58 typedef struct threadEntry {
59 pthread_t thr; /* this thread */
60 struct threadEntry *next; /* next thread */
61 int intr; /* interrupted */
62 } threadEntry_t;
63
64 /*
65 * Heap allocated during initialized - one entry per fd
66 */
67 typedef struct {
68 pthread_mutex_t lock; /* fd lock */
69 threadEntry_t *threads; /* threads blocked on fd */
70 } fdEntry_t;
71
72 /*
73 * Signal to unblock thread
74 */
75 static int sigWakeup = (SIGRTMAX - 1);
76
77 /*
78 * The fd table and the number of file descriptors
79 */
80 static fdEntry_t *fdTable = NULL;
81 static int fdCount = 0;
82
83 /*
84 * Null signal handler
85 */
86 static void sig_wakeup(int sig) {
87 }
88
89 /*
90 * Initialization routine (executed when library is loaded)
91 * Allocate fd tables and sets up signal handler.
92 *
93 * On AIX we don't have __attribute((constructor)) so we need to initialize
94 * manually (from JNI_OnLoad() in 'src/share/native/java/net/net_util.c')
95 */
96 void aix_close_init() {
97 struct rlimit nbr_files;
98 sigset_t sigset;
99 struct sigaction sa;
100
101 /* Check already initialized */
102 if (fdCount > 0 && fdTable != NULL) {
103 return;
104 }
105
106 /*
107 * Allocate table based on the maximum number of
108 * file descriptors.
109 */
110 if (-1 == getrlimit(RLIMIT_NOFILE, &nbr_files)) {
111 fprintf(stderr, "library initialization failed - "
112 "unable to get max # of allocated fds\n");
113 abort();
114 }
115 fdCount = nbr_files.rlim_max;
116 /*
117 * We have a conceptual problem here, when the number of files is
118 * unlimited. As a kind of workaround, we ensure the table is big
119 * enough for handle even a large number of files. Since SAP itself
120 * recommends a limit of 32000 files, we just use 64000 as 'infinity'.
121 */
122 if (nbr_files.rlim_max == RLIM_INFINITY) {
123 fdCount = 64000;
124 }
125 fdTable = (fdEntry_t *)calloc(fdCount, sizeof(fdEntry_t));
126 if (fdTable == NULL) {
127 fprintf(stderr, "library initialization failed - "
128 "unable to allocate file descriptor table - out of memory");
129 abort();
130 }
131
132 {
133 int i;
134 for (i=0; i < fdCount; i++) {
135 pthread_mutex_init(&fdTable[i].lock, NULL);
136 }
137 }
138
139 /*
140 * Setup the signal handler
141 */
142 sa.sa_handler = sig_wakeup;
143 sa.sa_flags = 0;
144 sigemptyset(&sa.sa_mask);
145 sigaction(sigWakeup, &sa, NULL);
146
147 sigemptyset(&sigset);
148 sigaddset(&sigset, sigWakeup);
149 sigprocmask(SIG_UNBLOCK, &sigset, NULL);
150 }
151
152 /*
153 * Return the fd table for this fd or NULL is fd out
154 * of range.
155 */
156 static inline fdEntry_t *getFdEntry(int fd)
157 {
158 if (fd < 0 || fd >= fdCount) {
159 return NULL;
160 }
161 return &fdTable[fd];
162 }
163
164 /*
165 * Start a blocking operation :-
166 * Insert thread onto thread list for the fd.
167 */
168 static inline void startOp(fdEntry_t *fdEntry, threadEntry_t *self)
169 {
170 self->thr = pthread_self();
171 self->intr = 0;
172
173 pthread_mutex_lock(&(fdEntry->lock));
174 {
175 self->next = fdEntry->threads;
176 fdEntry->threads = self;
177 }
178 pthread_mutex_unlock(&(fdEntry->lock));
179 }
180
181 /*
182 * End a blocking operation :-
183 * Remove thread from thread list for the fd
184 * If fd has been interrupted then set errno to EBADF
185 */
186 static inline void endOp
187 (fdEntry_t *fdEntry, threadEntry_t *self)
188 {
189 int orig_errno = errno;
190 pthread_mutex_lock(&(fdEntry->lock));
191 {
192 threadEntry_t *curr, *prev=NULL;
193 curr = fdEntry->threads;
194 while (curr != NULL) {
195 if (curr == self) {
196 if (curr->intr) {
197 orig_errno = EBADF;
198 }
199 if (prev == NULL) {
200 fdEntry->threads = curr->next;
201 } else {
202 prev->next = curr->next;
203 }
204 break;
205 }
206 prev = curr;
207 curr = curr->next;
208 }
209 }
210 pthread_mutex_unlock(&(fdEntry->lock));
211 errno = orig_errno;
212 }
213
214 /*
215 * Close or dup2 a file descriptor ensuring that all threads blocked on
216 * the file descriptor are notified via a wakeup signal.
217 *
218 * fd1 < 0 => close(fd2)
219 * fd1 >= 0 => dup2(fd1, fd2)
220 *
221 * Returns -1 with errno set if operation fails.
222 */
223 static int closefd(int fd1, int fd2) {
224 int rv, orig_errno;
225 fdEntry_t *fdEntry = getFdEntry(fd2);
226 if (fdEntry == NULL) {
227 errno = EBADF;
228 return -1;
229 }
230
231 /*
232 * Lock the fd to hold-off additional I/O on this fd.
233 */
234 pthread_mutex_lock(&(fdEntry->lock));
235
236 {
237 /*
238 * And close/dup the file descriptor
239 * (restart if interrupted by signal)
240 */
241 do {
242 if (fd1 < 0) {
243 rv = close(fd2);
244 } else {
245 rv = dup2(fd1, fd2);
246 }
247 } while (rv == -1 && errno == EINTR);
248
249 /*
250 * Send a wakeup signal to all threads blocked on this
251 * file descriptor.
252 */
253 threadEntry_t *curr = fdEntry->threads;
254 while (curr != NULL) {
255 curr->intr = 1;
256 pthread_kill( curr->thr, sigWakeup );
257 curr = curr->next;
258 }
259 }
260
261 /*
262 * Unlock without destroying errno
263 */
264 orig_errno = errno;
265 pthread_mutex_unlock(&(fdEntry->lock));
266 errno = orig_errno;
267
268 return rv;
269 }
270
271 /*
272 * Wrapper for dup2 - same semantics as dup2 system call except
273 * that any threads blocked in an I/O system call on fd2 will be
274 * preempted and return -1/EBADF;
275 */
276 int NET_Dup2(int fd, int fd2) {
277 if (fd < 0) {
278 errno = EBADF;
279 return -1;
280 }
281 return closefd(fd, fd2);
282 }
283
284 /*
285 * Wrapper for close - same semantics as close system call
286 * except that any threads blocked in an I/O on fd will be
287 * preempted and the I/O system call will return -1/EBADF.
288 */
289 int NET_SocketClose(int fd) {
290 return closefd(-1, fd);
291 }
292
293 /************** Basic I/O operations here ***************/
294
295 /*
296 * Macro to perform a blocking IO operation. Restarts
297 * automatically if interrupted by signal (other than
298 * our wakeup signal)
299 */
300 #define BLOCKING_IO_RETURN_INT(FD, FUNC) { \
301 int ret; \
302 threadEntry_t self; \
303 fdEntry_t *fdEntry = getFdEntry(FD); \
304 if (fdEntry == NULL) { \
305 errno = EBADF; \
306 return -1; \
307 } \
308 do { \
309 startOp(fdEntry, &self); \
310 ret = FUNC; \
311 endOp(fdEntry, &self); \
312 } while (ret == -1 && errno == EINTR); \
313 return ret; \
314 }
315
316 int NET_Read(int s, void* buf, size_t len) {
317 BLOCKING_IO_RETURN_INT( s, recv(s, buf, len, 0) );
318 }
319
320 int NET_ReadV(int s, const struct iovec * vector, int count) {
321 BLOCKING_IO_RETURN_INT( s, readv(s, vector, count) );
322 }
323
324 int NET_RecvFrom(int s, void *buf, int len, unsigned int flags,
325 struct sockaddr *from, int *fromlen) {
326 socklen_t socklen = *fromlen;
327 BLOCKING_IO_RETURN_INT( s, recvfrom(s, buf, len, flags, from, &socklen) );
328 *fromlen = socklen;
329 }
330
331 int NET_Send(int s, void *msg, int len, unsigned int flags) {
332 BLOCKING_IO_RETURN_INT( s, send(s, msg, len, flags) );
333 }
334
335 int NET_WriteV(int s, const struct iovec * vector, int count) {
336 BLOCKING_IO_RETURN_INT( s, writev(s, vector, count) );
337 }
338
339 int NET_SendTo(int s, const void *msg, int len, unsigned int
340 flags, const struct sockaddr *to, int tolen) {
341 BLOCKING_IO_RETURN_INT( s, sendto(s, msg, len, flags, to, tolen) );
342 }
343
344 int NET_Accept(int s, struct sockaddr *addr, int *addrlen) {
345 socklen_t socklen = *addrlen;
346 BLOCKING_IO_RETURN_INT( s, accept(s, addr, &socklen) );
347 *addrlen = socklen;
348 }
349
350 int NET_Connect(int s, struct sockaddr *addr, int addrlen) {
351 BLOCKING_IO_RETURN_INT( s, connect(s, addr, addrlen) );
352 }
353
354 #ifndef USE_SELECT
355 int NET_Poll(struct pollfd *ufds, unsigned int nfds, int timeout) {
356 BLOCKING_IO_RETURN_INT( ufds[0].fd, poll(ufds, nfds, timeout) );
357 }
358 #else
359 int NET_Select(int s, fd_set *readfds, fd_set *writefds,
360 fd_set *exceptfds, struct timeval *timeout) {
361 BLOCKING_IO_RETURN_INT( s-1,
362 select(s, readfds, writefds, exceptfds, timeout) );
363 }
364 #endif
365
366 /*
367 * Wrapper for poll(s, timeout).
368 * Auto restarts with adjusted timeout if interrupted by
369 * signal other than our wakeup signal.
370 */
371 int NET_Timeout(int s, long timeout) {
372 long prevtime = 0, newtime;
373 struct timeval t;
374 fdEntry_t *fdEntry = getFdEntry(s);
375
376 /*
377 * Check that fd hasn't been closed.
378 */
379 if (fdEntry == NULL) {
380 errno = EBADF;
381 return -1;
382 }
383
384 /*
385 * Pick up current time as may need to adjust timeout
386 */
387 if (timeout > 0) {
388 gettimeofday(&t, NULL);
389 prevtime = t.tv_sec * 1000 + t.tv_usec / 1000;
390 }
391
392 for(;;) {
393 struct pollfd pfd;
394 int rv;
395 threadEntry_t self;
396
397 /*
398 * Poll the fd. If interrupted by our wakeup signal
399 * errno will be set to EBADF.
400 */
401 pfd.fd = s;
402 pfd.events = POLLIN | POLLERR;
403
404 startOp(fdEntry, &self);
405 rv = poll(&pfd, 1, timeout);
406 endOp(fdEntry, &self);
407
408 /*
409 * If interrupted then adjust timeout. If timeout
410 * has expired return 0 (indicating timeout expired).
411 */
412 if (rv < 0 && errno == EINTR) {
413 if (timeout > 0) {
414 gettimeofday(&t, NULL);
415 newtime = t.tv_sec * 1000 + t.tv_usec / 1000;
416 timeout -= newtime - prevtime;
417 if (timeout <= 0) {
418 return 0;
419 }
420 prevtime = newtime;
421 }
422 } else {
423 return rv;
424 }
425
426 }
427 }