/*

 * Copyright (c) 1999, 2000, Oracle and/or its affiliates. All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 *   - Redistributions of source code must retain the above copyright

 *     notice, this list of conditions and the following disclaimer.

 *

 *   - Redistributions in binary form must reproduce the above copyright

 *     notice, this list of conditions and the following disclaimer in the

 *     documentation and/or other materials provided with the distribution.

 *

 *   - Neither the name of Oracle nor the names of its

 *     contributors may be used to endorse or promote products derived

 *     from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS

 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,

 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/*

 **********************************************************************

 * Poller.c :

 * JNI code for use with Poller.java, principally to take advantage

 * of poll() or /dev/poll multiplexing.

 *

 * One will need Solaris 8 or Solaris 7 with adequate patches to take

 * advantage of the /dev/poll performance enhancements, though any

 * version of Solaris 7 will automatically use the kernel poll()

 * caching.  And poll() will function in 2.5.1 and 2.6 as well, but

 * will not perform well for large numbers of file descriptors.

 *

 * Several assumptions have been made to simplify this code :

 *  1> At most MAX_HANDLES (32) separate pollable entities are currently

 *     supported.

 *  2> Global synchronization from Java is assumed for all init, create

 *     and destroy routines.  Per Object (handle passed in) synchronization

 *     is required for all AddFd, RemoveFd, IsMember, and Wait routines.

 *  3> It is currently up to the user to handle waking up an

 *     existing nativeWait() call to do an addfd or removefd on

 *     that set...could implement that here with an extra pipe, or

 *     with a pair of loopback sockets in Poller.java or user code.

 *     In most cases interruption is not necessary for deletions,

 *     so long as deletions are queued up outside the Poller class

 *     and then executed the next time waitMultiple() returns.

 *  4> /dev/poll performance could be slightly improved by coalescing

 *     adds/removes so that a write() is only done before the ioctl

 *     (DP_POLL), but this complicates exception handling and sees

 *     only modest performance gains so wasn't done.

 *  5> /dev/poll does not report errors on attempts to remove non-

 *     extant fds, but a future bug fix to the /dev/poll device driver

 *     should solve this problem.

 *  6> Could add simpler code for pre-Solaris 7 releases which will

 *     perform slightly better on those OSs.  But again there

 *     are only modest gains to be had from these new code paths,

 *     so they've been ommitted here.

 *

 * Compile "cc -G -o <dest_dir>/libpoller.so -I ${JAVA_HOME}/include " \

 * -I ${JAVA_HOME}/include/solaris Poller.c" and place the <dest_dir>

 * in your LD_LIBRARY_PATH

 *

 **********************************************************************

 */

#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include <poll.h>

#include <malloc.h>

#include <fcntl.h>

/*

 * Remove "_NOT"s to turn on features

 * Append "_NOT" to turn off features.

 * Use of /dev/poll requires both the include file and kernel driver.

 */

#define DEBUG_NOT

#define DEVPOLL_NOT

#ifdef DEVPOLL

#include <sys/devpoll.h>

#endif

#include "Poller.h"

#define MAX_HANDLES 32

#ifdef DEBUG

#define DBGMSG(x) printf x

#define ASSERT(x) {if (!(x)) \

                   printf("assertion(%s) failed at line : %d\n",#x,__LINE__);}

#define CHECK_HANDLE(x) check_handle(x)

#else

#define DBGMSG(x)

#define ASSERT(x)

#define CHECK_HANDLE(x)

#endif

/*

 * Globals ...protect all with a global synchronization object.

 */

static int Current_handle = 0;

static int Use_devpoll = 0;

static int Max_index = 0;

/*

 * Per Poller object data.

 * Must be synchronized on a per Poller object basis.

 */

typedef struct ioevent {

  int inuse;

  int devpollfd;

  int last_index;

  int total_free;

  int left_events;

  int max_index;

  pollfd_t *pfd;

} ioevent_t;

static ioevent_t IOE_handles[MAX_HANDLES];

/*

 * Exceptions to be thrown.

 * Note : assuming all illegal argument and NULL pointer checks

 *        have already been done by the Java calling methods.

 */

static jint throwOutOfMemoryError(JNIEnv *env, const char * cause)

{

  (*env)->ThrowNew(env, (*env)->FindClass(env,"java/lang/OutOfMemoryError"),

                   cause);

  return -1;

}

static jint throwInterruptedIOException(JNIEnv *env, const char * cause)

{

  (*env)->ThrowNew(env,

                   (*env)->FindClass(env,"java/io/InterruptedIOException"),

                   cause);

  return -1;

}

static jint throwIllegalStateException(JNIEnv *env, const char * cause)

{

  (*env)->ThrowNew(env,

                   (*env)->FindClass(env,"java/lang/IllegalStateException"),

                   cause);

  return -1;

}

#define INTERRUPT_EXCEPTION(str) throwInterruptedIOException(env, \

jint addfd(JNIEnv *, ioevent_t *, jint, jshort);

jint removefd(JNIEnv *, ioevent_t *, jint);

/*

 * Class Poller

 * Method: nativeInit

 * Signature: ()I

 *

 * Only to be called once, right after this library is loaded,

 * so no need to deal with reentrancy here.

 * Could do as a pragma ini, but that isn't as portable.

 */

JNIEXPORT jint JNICALL Java_Poller_nativeInit(JNIEnv *env, jclass cls)

{

  int testdevpollfd;

  int i;

#ifdef DEVPOLL

  /*

   * See if we can use this much faster method

   * Note : must have fix for BUGID # 4223353 or OS can crash!

   */

  testdevpollfd = open("/dev/poll",O_RDWR);

  if (testdevpollfd >= 0) {

    /*

     * If Solaris 7, we need a patch

     * Until we know what string to search for, we'll play it

     * safe and disable this for Solaris 7.

     */

    if (!strcmp(name.release,"5.7"))

      {

        Use_devpoll = 0;

      }

    else

      {

        Use_devpoll = 1;

      }

  }

  DBGMSG(("Use_devpoll=%d\n" ,Use_devpoll));

  close(testdevpollfd);

#endif

  /*

   * For now, we optimize for Solaris 7 if /dev/poll isn't

   * available, as it is only a small % hit for Solaris < 7.

   * if ( (Use_devpoll == 0) && !strcmp(name.release,"5.6") )

   *      Use_sol7opt = 0;

   */

  Current_handle = 0;

  for (i = 0; i < MAX_HANDLES; i++) {

    IOE_handles[i].devpollfd = -1;

    IOE_handles[i].pfd = NULL;

  }

  /*

   * this tells me the max number of open filedescriptors

   */

  Max_index = sysconf(_SC_OPEN_MAX);

  if (Max_index < 0) {

    Max_index = 1024;

  }

  DBGMSG(("got sysconf(_SC_OPEN_MAX)=%d file desc\n",Max_index));

  return 0;

}

JNIEXPORT jint JNICALL Java_Poller_getNumCPUs(JNIEnv *env, jclass cls)

{

  return sysconf(_SC_NPROCESSORS_ONLN);

}

/*

 * Class:     Poller

 * Method:    nativeCreatePoller

 * Signature: (I)I

 * Note : in the case where /dev/poll doesn't exist,

 *        using more than one poll array could hurt

 *        Solaris 7 performance due to kernel caching.

 */

JNIEXPORT jint JNICALL Java_Poller_nativeCreatePoller

  (JNIEnv *env, jobject obj, jint maximum_fds)

{

  int handle, retval, i;

  ioevent_t *ioeh;

  if (maximum_fds == -1) {

    maximum_fds = Max_index;

  }

  handle = Current_handle;

  if (Current_handle >= MAX_HANDLES) {

    for (i = 0; i < MAX_HANDLES; i++) {

      if (IOE_handles[i].inuse == 0) {

        handle = i;

        break;

      }

    }

    if (handle >= MAX_HANDLES) {

      return MEMORY_EXCEPTION("CreatePoller - MAX_HANDLES exceeded");

    }

  } else {

    Current_handle++;

  }

  ioeh = &IOE_handles[handle];

  ioeh->inuse      = 1;

  ioeh->last_index = 0;

  ioeh->total_free = 0;

  ioeh->left_events = 0;

  ioeh->max_index = maximum_fds;

  retval = handle;

  if (Use_devpoll) {

    ioeh->devpollfd = open("/dev/poll",O_RDWR);

    DBGMSG(("Opened /dev/poll, set devpollfd = %d\n",ioeh->devpollfd));

    if (ioeh->devpollfd < 0) {

      Current_handle--;

      return MEMORY_EXCEPTION("CreatePoller - can\'t open /dev/poll");

    }

  }

  ioeh->pfd = malloc(maximum_fds * sizeof(pollfd_t));

  if (ioeh->pfd == NULL) {

    Current_handle--;

    return MEMORY_EXCEPTION("CreatePoller - malloc failure");

  }

  return retval;

}

/*

 * Class:     Poller

 * Method:    nativeDestroyPoller

 * Signature: (I)V

 */

JNIEXPORT void JNICALL Java_Poller_nativeDestroyPoller

  (JNIEnv *env, jobject obj, jint handle)

{

  ioevent_t *ioeh;

  if (handle < 0 || handle > MAX_HANDLES)

    {

      STATE_EXCEPTION("DestroyPoller - handle out of range");

      return;

    }

  ioeh = &IOE_handles[handle];

  ioeh->inuse = 0;

  if (Use_devpoll) {

    close(ioeh->devpollfd);

  }

  free(ioeh->pfd);

}

#ifdef DEBUG

static void check_handle(ioevent_t *ioeh)

{

  int i,used,unused;

  used=unused=0;

  for (i = 0; i < ioeh->last_index; i++)

    {

      if (ioeh->pfd[i].fd == -1)

        unused++;

      else

        used++;

    }

  if (unused != ioeh->total_free)

    printf("WARNING : found %d free, claimed %d.  Used : %d\n",

           unused, ioeh->total_free, used);

}

#endif

/*

 * Class:     Poller

 * Method:    nativeAddFd

 * Signature: (IIS)I

 *

 * Currently doesn't check to make sure we aren't adding

 * an fd already added (no problem for /dev/poll...just

 * an array waster for poll()).

 */

JNIEXPORT jint JNICALL Java_Poller_nativeAddFd

  (JNIEnv *env, jobject obj, jint handle, jint fd, jshort events)

{

  int retval;

  ioevent_t *ioeh;

  if (handle < 0 || handle > MAX_HANDLES)

    return STATE_EXCEPTION("AddFd - handle out of range");

  ioeh = &IOE_handles[handle];

  CHECK_HANDLE(ioeh);

  #ifdef DEVPOLL

  if (Use_devpoll)

    {

      int i;

      pollfd_t pollelt;

      /*

       * use /dev/poll

       */

      pollelt.fd = fd;

      pollelt.events = events;

      if ((i = write(ioeh->devpollfd, &pollelt, sizeof(pollfd_t))) !=

          sizeof(pollfd_t)) {

        DBGMSG(("write to devpollfd=%d showed %d bytes out of %d\n",

                ioeh->devpollfd,i,sizeof(pollfd_t)));

        return STATE_EXCEPTION("AddFd - /dev/poll add failure");

      }

    else

      {

        retval = fd;

      }

    }

  else

  #endif

    { /* no /dev/poll available */

      retval = addfd(env, ioeh, fd, events);

    }

  return retval;

}

/*

 * Addfd to pollfd array...optimized for Solaris 7

 */

jint addfd(JNIEnv *env, ioevent_t *ioeh, jint fd, jshort events)

{

  int idx;

  if (ioeh->total_free)

    {

      /*

       * Traversing from end because that's where we pad.

       */

      ioeh->total_free--;

      for (idx = ioeh->last_index - 1; idx >= 0; idx--) {

        if (ioeh->pfd[idx].fd == -1)

          break;

      }

    }

  else if (ioeh->last_index >= ioeh->max_index)

    {

      return MEMORY_EXCEPTION("AddFd - too many fds");

    }

  else

    {

      int i;

      int new_total;

      /*

       * For Solaris 7, want to add some growth space

       * and fill extras with fd=-1.  This allows for

       * kernel poll() implementation to perform optimally.

       */

      new_total = ioeh->last_index;

      new_total += (new_total/10) + 1; /* bump size by 10% */

      if (new_total > ioeh->max_index)

        new_total = ioeh->max_index;

      for (i = ioeh->last_index; i <= new_total; i++)

        {

          ioeh->pfd[i].fd = -1;

        }

      idx = ioeh->last_index;

      ioeh->total_free = new_total - ioeh->last_index - 1;

      DBGMSG(("Just grew from %d to %d in size\n",

              ioeh->last_index, new_total));

      ioeh->last_index = new_total;

    }

  ASSERT((idx >= 0) && (idx <= ioeh->max_index));

  ASSERT(ioeh->pfd[idx].fd == -1);

  ioeh->pfd[idx].fd = fd;

  ioeh->pfd[idx].events = events;

  ioeh->pfd[idx].revents = 0;

  CHECK_HANDLE(ioeh);

  return fd;

}

/*

 * Class:     Poller

 * Method:    nativeRemoveFd

 * Signature: (II)I

 */

JNIEXPORT jint JNICALL Java_Poller_nativeRemoveFd

  (JNIEnv *env, jobject obj, jint handle, jint fd)

{

  ioevent_t *ioeh;

  if (handle < 0 || handle > MAX_HANDLES)

    return STATE_EXCEPTION("RemoveFd - handle out of range");

  ioeh = &IOE_handles[handle];

  #ifdef DEVPOLL

  if (Use_devpoll)

    {

      /*

       * use /dev/poll - currently no need for locking here.

       */

      pollfd_t pollelt;

      pollelt.fd = fd;

      pollelt.events = POLLREMOVE;

      if (write(ioeh->devpollfd, &pollelt,

                sizeof(pollfd_t) ) != sizeof(pollfd_t))

        {

          return STATE_EXCEPTION("RemoveFd - /dev/poll failure");

        }

    }

  else

  #endif DEVPOLL

    {

      return removefd(env, ioeh,fd);

    }

}

/*

 * remove from pollfd array...optimize for Solaris 7

 */

jint removefd(JNIEnv *env, ioevent_t *ioeh, jint fd)

{

  int i;

  int found = 0;

    { /* !Use_devpoll */

      for (i = 0; i < ioeh->last_index; i++)

        {

          if (ioeh->pfd[i].fd == fd)

            {

              ioeh->pfd[i].fd = -1;

              found = 1;

              break;

            }

        }

      if (!found)

        {

          return STATE_EXCEPTION("RemoveFd - no such fd");

        }

      ioeh->left_events = 0; /* Have to go back to the kernel */

      ioeh->total_free++;

      /*

       * Shrinking pool if > 33% empty. Just don't do this often!

       */

      if ( (ioeh->last_index > 100) &&

           (ioeh->total_free > (ioeh->last_index / 3)) )

        {

          int j;

          /*

           * we'll just bite the bullet here, since we're > 33% empty.

           * walk through and eliminate -1 fd values, shrink total

           * size to still have ~ 10 fd==-1 values at end.

           * Start at end (since we pad here) and, when we find fd != -1,

           * swap with an earlier fd == -1 until we have all -1 values

           * at the end.

           */