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 #include <stdio.h>

    27 #include <stdlib.h>

    28 #include <signal.h>

    29 #include <pthread.h>

    30 #include <sys/types.h>

    31 #include <sys/socket.h>

    32 #include <sys/time.h>

    33 #include <sys/resource.h>

    34 #include <sys/uio.h>

    35 #include <unistd.h>

    36 #include <errno.h>

    37 #include <sys/poll.h>

    38 

    39 /*

    40  * Stack allocated by thread when doing blocking operation

    41  */

    42 typedef struct threadEntry {

    43     pthread_t thr;                      /* this thread */

    44     struct threadEntry *next;           /* next thread */

    45     int intr;                           /* interrupted */

    46 } threadEntry_t;

    47 

    48 /*

    49  * Heap allocated during initialized - one entry per fd

    50  */

    51 typedef struct {

    52     pthread_mutex_t lock;               /* fd lock */

    53     threadEntry_t *threads;             /* threads blocked on fd */

    54 } fdEntry_t;

    55 

    56 /*

    57  * Signal to unblock thread

    58  */

    59 static int sigWakeup = (__SIGRTMAX - 2);

    60 

    61 /*

    62  * The fd table and the number of file descriptors

    63  */

    64 static fdEntry_t *fdTable;

    65 static int fdCount;

    66 

    67 /*

    68  * Null signal handler

    69  */

    70 static void sig_wakeup(int sig) {

    71 }

    72 

    73 /*

    74  * Initialization routine (executed when library is loaded)

    75  * Allocate fd tables and sets up signal handler.

    76  */

    77 static void __attribute((constructor)) init() {

    78     struct rlimit nbr_files;

    79     sigset_t sigset;

    80     struct sigaction sa;

    81 

    82     /*

    83      * Allocate table based on the maximum number of

    84      * file descriptors.

    85      */

    86     getrlimit(RLIMIT_NOFILE, &nbr_files);

    87     fdCount = nbr_files.rlim_max;

    88     fdTable = (fdEntry_t *)calloc(fdCount, sizeof(fdEntry_t));

    89     if (fdTable == NULL) {

    90         fprintf(stderr, "library initialization failed - "

    91                 "unable to allocate file descriptor table - out of memory");

    92         abort();

    93     }

    94 

    95     /*

    96      * Setup the signal handler

    97      */

    98     sa.sa_handler = sig_wakeup;

    99     sa.sa_flags   = 0;

   100     sigemptyset(&sa.sa_mask);

   101     sigaction(sigWakeup, &sa, NULL);

   102 

   103     sigemptyset(&sigset);

   104     sigaddset(&sigset, sigWakeup);

   105     sigprocmask(SIG_UNBLOCK, &sigset, NULL);

   106 }

   107 

   108 /*

   109  * Return the fd table for this fd or NULL is fd out

   110  * of range.

   111  */

   112 static inline fdEntry_t *getFdEntry(int fd)

   113 {

   114     if (fd < 0 || fd >= fdCount) {

   115         return NULL;

   116     }

   117     return &fdTable[fd];

   118 }

   119 

   120 /*

   121  * Start a blocking operation :-

   122  *    Insert thread onto thread list for the fd.

   123  */

   124 static inline void startOp(fdEntry_t *fdEntry, threadEntry_t *self)

   125 {

   126     self->thr = pthread_self();

   127     self->intr = 0;

   128 

   129     pthread_mutex_lock(&(fdEntry->lock));

   130     {

   131         self->next = fdEntry->threads;

   132         fdEntry->threads = self;

   133     }

   134     pthread_mutex_unlock(&(fdEntry->lock));

   135 }

   136 

   137 /*

   138  * End a blocking operation :-

   139  *     Remove thread from thread list for the fd

   140  *     If fd has been interrupted then set errno to EBADF

   141  */

   142 static inline void endOp

   143     (fdEntry_t *fdEntry, threadEntry_t *self)

   144 {

   145     int orig_errno = errno;

   146     pthread_mutex_lock(&(fdEntry->lock));

   147     {

   148         threadEntry_t *curr, *prev=NULL;

   149         curr = fdEntry->threads;

   150         while (curr != NULL) {

   151             if (curr == self) {

   152                 if (curr->intr) {

   153                     orig_errno = EBADF;

   154                 }

   155                 if (prev == NULL) {

   156                     fdEntry->threads = curr->next;

   157                 } else {

   158                     prev->next = curr->next;

   159                 }

   160                 break;

   161             }

   162             prev = curr;

   163             curr = curr->next;

   164         }

   165     }

   166     pthread_mutex_unlock(&(fdEntry->lock));

   167     errno = orig_errno;

   168 }

   169 

   170 /*

   171  * Close or dup2 a file descriptor ensuring that all threads blocked on

   172  * the file descriptor are notified via a wakeup signal.

   173  *

   174  *      fd1 < 0    => close(fd2)

   175  *      fd1 >= 0   => dup2(fd1, fd2)

   176  *

   177  * Returns -1 with errno set if operation fails.

   178  */

   179 static int closefd(int fd1, int fd2) {

   180     int rv, orig_errno;

   181     fdEntry_t *fdEntry = getFdEntry(fd2);

   182     if (fdEntry == NULL) {

   183         errno = EBADF;

   184         return -1;

   185     }

   186 

   187     /*

   188      * Lock the fd to hold-off additional I/O on this fd.

   189      */

   190     pthread_mutex_lock(&(fdEntry->lock));

   191 

   192     {

   193         /*

   194          * And close/dup the file descriptor

   195          * (restart if interrupted by signal)

   196          */

   197         do {

   198             if (fd1 < 0) {

   199                 rv = close(fd2);

   200             } else {

   201                 rv = dup2(fd1, fd2);

   202             }

   203         } while (rv == -1 && errno == EINTR);

   204 

   205         /*

   206          * Send a wakeup signal to all threads blocked on this

   207          * file descriptor.

   208          */

   209         threadEntry_t *curr = fdEntry->threads;

   210         while (curr != NULL) {

   211             curr->intr = 1;

   212             pthread_kill( curr->thr, sigWakeup );

   213             curr = curr->next;

   214         }

   215     }

   216 

   217     /*

   218      * Unlock without destroying errno

   219      */

   220     orig_errno = errno;

   221     pthread_mutex_unlock(&(fdEntry->lock));

   222     errno = orig_errno;

   223 

   224     return rv;

   225 }

   226 

   227 /*

   228  * Wrapper for dup2 - same semantics as dup2 system call except

   229  * that any threads blocked in an I/O system call on fd2 will be

   230  * preempted and return -1/EBADF;

   231  */

   232 int NET_Dup2(int fd, int fd2) {

   233     if (fd < 0) {

   234         errno = EBADF;

   235         return -1;

   236     }

   237     return closefd(fd, fd2);

   238 }

   239 

   240 /*

   241  * Wrapper for close - same semantics as close system call

   242  * except that any threads blocked in an I/O on fd will be

   243  * preempted and the I/O system call will return -1/EBADF.

   244  */

   245 int NET_SocketClose(int fd) {

   246     return closefd(-1, fd);

   247 }

   248 

   249 /************** Basic I/O operations here ***************/

   250 

   251 /*

   252  * Macro to perform a blocking IO operation. Restarts

   253  * automatically if interrupted by signal (other than

   254  * our wakeup signal)

   255  */

   256 #define BLOCKING_IO_RETURN_INT(FD, FUNC) {      \

   257     int ret;                                    \

   258     threadEntry_t self;                         \

   259     fdEntry_t *fdEntry = getFdEntry(FD);        \

   260     if (fdEntry == NULL) {                      \

   261         errno = EBADF;                          \

   262         return -1;                              \

   263     }                                           \

   264     do {                                        \

   265         startOp(fdEntry, &self);                \

   266         ret = FUNC;                             \

   267         endOp(fdEntry, &self);                  \

   268     } while (ret == -1 && errno == EINTR);      \

   269     return ret;                                 \

   270 }

   271 

   272 int NET_Read(int s, void* buf, size_t len) {

   273     BLOCKING_IO_RETURN_INT( s, recv(s, buf, len, 0) );

   274 }

   275 

   276 int NET_ReadV(int s, const struct iovec * vector, int count) {

   277     BLOCKING_IO_RETURN_INT( s, readv(s, vector, count) );

   278 }

   279 

   280 int NET_RecvFrom(int s, void *buf, int len, unsigned int flags,

   281        struct sockaddr *from, socklen_t *fromlen) {

   282     BLOCKING_IO_RETURN_INT( s, recvfrom(s, buf, len, flags, from, fromlen) );

   283 }

   284 

   285 int NET_Send(int s, void *msg, int len, unsigned int flags) {

   286     BLOCKING_IO_RETURN_INT( s, send(s, msg, len, flags) );

   287 }

   288 

   289 int NET_WriteV(int s, const struct iovec * vector, int count) {

   290     BLOCKING_IO_RETURN_INT( s, writev(s, vector, count) );

   291 }

   292 

   293 int NET_SendTo(int s, const void *msg, int len,  unsigned  int

   294        flags, const struct sockaddr *to, int tolen) {

   295     BLOCKING_IO_RETURN_INT( s, sendto(s, msg, len, flags, to, tolen) );

   296 }

   297 

   298 int NET_Accept(int s, struct sockaddr *addr, socklen_t *addrlen) {

   299     BLOCKING_IO_RETURN_INT( s, accept(s, addr, addrlen) );

   300 }

   301 

   302 int NET_Connect(int s, struct sockaddr *addr, int addrlen) {

   303     BLOCKING_IO_RETURN_INT( s, connect(s, addr, addrlen) );

   304 }

   305 

   306 int NET_Poll(struct pollfd *ufds, unsigned int nfds, int timeout) {

   307     BLOCKING_IO_RETURN_INT( ufds[0].fd, poll(ufds, nfds, timeout) );

   308 }

   309 

   310 /*

   311  * Wrapper for poll(s, timeout).

   312  * Auto restarts with adjusted timeout if interrupted by

   313  * signal other than our wakeup signal.

   314  */

   315 int NET_Timeout(int s, long timeout) {

   316     long prevtime = 0, newtime;

   317     struct timeval t;

   318     fdEntry_t *fdEntry = getFdEntry(s);

   319 

   320     /*

   321      * Check that fd hasn't been closed.

   322      */

   323     if (fdEntry == NULL) {

   324         errno = EBADF;

   325         return -1;

   326     }

   327 

   328     /*

   329      * Pick up current time as may need to adjust timeout

   330      */

   331     if (timeout > 0) {

   332         gettimeofday(&t, NULL);

   333         prevtime = t.tv_sec * 1000  +  t.tv_usec / 1000;

   334     }

   335 

   336     for(;;) {

   337         struct pollfd pfd;

   338         int rv;

   339         threadEntry_t self;

   340 

   341         /*

   342          * Poll the fd. If interrupted by our wakeup signal

   343          * errno will be set to EBADF.

   344          */

   345         pfd.fd = s;

   346         pfd.events = POLLIN | POLLERR;

   347 

   348         startOp(fdEntry, &self);

   349         rv = poll(&pfd, 1, timeout);

   350         endOp(fdEntry, &self);

   351 

   352         /*

   353          * If interrupted then adjust timeout. If timeout

   354          * has expired return 0 (indicating timeout expired).

   355          */

   356         if (rv < 0 && errno == EINTR) {

   357             if (timeout > 0) {

   358                 gettimeofday(&t, NULL);

   359                 newtime = t.tv_sec * 1000  +  t.tv_usec / 1000;

   360                 timeout -= newtime - prevtime;

   361                 if (timeout <= 0) {

   362                     return 0;

   363                 }

   364                 prevtime = newtime;

   365             }

   366         } else {

   367             return rv;

   368         }

   369 

   370     }

   371 }