/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "primpl.h"

#include <string.h>

/*****************************************************************************/
/*****************************************************************************/
/************************** File descriptor caching **************************/
/*****************************************************************************/
/*****************************************************************************/

/*
** This code is built into debuggable versions of NSPR to assist in
** finding misused file descriptors. Since file descritors (PRFileDesc)
** are identified by a pointer to their structure, they can be the
** target of dangling references. Furthermore, NSPR caches and tries
** to aggressively reuse file descriptors, leading to more ambiguity.
** The following code will allow a debugging client to set environment
** variables and control the number of file descriptors that will be
** preserved before they are recycled. The environment variables are
** NSPR_FD_CACHE_SIZE_LOW and NSPR_FD_CACHE_SIZE_HIGH. The former sets
** the number of descriptors NSPR will allocate before beginning to
** recycle. The latter is the maximum number permitted in the cache
** (exclusive of those in use) at a time.
*/
typedef struct _PR_Fd_Cache {
  PRLock* ml;
  PRIntn count;
  PRFileDesc *head, *tail;
  PRIntn limit_low, limit_high;
} _PR_Fd_Cache;

static _PR_Fd_Cache _pr_fd_cache;

/*
** Get a FileDescriptor from the cache if one exists. If not allocate
** a new one from the heap.
*/
PRFileDesc* _PR_Getfd(void) {
  PRFileDesc* fd;
  /*
  ** $$$
  ** This may look a little wasteful. We'll see. Right now I want to
  ** be able to toggle between caching and not at runtime to measure
  ** the differences. If it isn't too annoying, I'll leave it in.
  ** $$$$
  **
  ** The test is against _pr_fd_cache.limit_high. If that's zero,
  ** we're not doing the extended cache but going for performance.
  */
  if (0 == _pr_fd_cache.limit_high) {
    goto allocate;
  } else {
    do {
      if (NULL == _pr_fd_cache.head) {
        goto allocate; /* nothing there */
      }
      if (_pr_fd_cache.count < _pr_fd_cache.limit_low) {
        goto allocate;
      }

      /* we "should" be able to extract an fd from the cache */
      PR_Lock(_pr_fd_cache.ml); /* need the lock to do this safely */
      fd = _pr_fd_cache.head;   /* protected extraction */
      if (NULL == fd)           /* unexpected, but not fatal */
      {
        PR_ASSERT(0 == _pr_fd_cache.count);
        PR_ASSERT(NULL == _pr_fd_cache.tail);
      } else {
        _pr_fd_cache.count -= 1;
        _pr_fd_cache.head = fd->higher;
        if (NULL == _pr_fd_cache.head) {
          PR_ASSERT(0 == _pr_fd_cache.count);
          _pr_fd_cache.tail = NULL;
        }
        PR_ASSERT(&_pr_faulty_methods == fd->methods);
        PR_ASSERT(PR_INVALID_IO_LAYER == fd->identity);
        PR_ASSERT(_PR_FILEDESC_FREED == fd->secret->state);
      }
      PR_Unlock(_pr_fd_cache.ml);

    } while (NULL == fd); /* then go around and allocate a new one */
  }

finished:
  fd->dtor = NULL;
  fd->lower = fd->higher = NULL;
  fd->identity = PR_NSPR_IO_LAYER;
  memset(fd->secret, 0, sizeof(PRFilePrivate));
  return fd;

allocate:
  fd = PR_NEW(PRFileDesc);
  if (NULL != fd) {
    fd->secret = PR_NEW(PRFilePrivate);
    if (NULL == fd->secret) {
      PR_DELETE(fd);
    }
  }
  if (NULL != fd) {
    goto finished;
  } else {
    return NULL;
  }

} /* _PR_Getfd */

/*
** Return a file descriptor to the cache unless there are too many in
** there already. If put in cache, clear the fields first.
*/
void _PR_Putfd(PRFileDesc* fd) {
  PR_ASSERT(PR_NSPR_IO_LAYER == fd->identity);
  fd->methods = &_pr_faulty_methods;
  fd->identity = PR_INVALID_IO_LAYER;
  fd->secret->state = _PR_FILEDESC_FREED;

  if (0 != _pr_fd_cache.limit_high) {
    if (_pr_fd_cache.count < _pr_fd_cache.limit_high) {
      PR_Lock(_pr_fd_cache.ml);
      if (NULL == _pr_fd_cache.tail) {
        PR_ASSERT(0 == _pr_fd_cache.count);
        PR_ASSERT(NULL == _pr_fd_cache.head);
        _pr_fd_cache.head = _pr_fd_cache.tail = fd;
      } else {
        PR_ASSERT(NULL == _pr_fd_cache.tail->higher);
        _pr_fd_cache.tail->higher = fd;
        _pr_fd_cache.tail = fd; /* new value */
      }
      fd->higher = NULL;       /* always so */
      _pr_fd_cache.count += 1; /* count the new entry */
      PR_Unlock(_pr_fd_cache.ml);
      return;
    }
  }

  PR_Free(fd->secret);
  PR_Free(fd);
} /* _PR_Putfd */

PR_IMPLEMENT(PRStatus) PR_SetFDCacheSize(PRIntn low, PRIntn high) {
  /*
  ** This can be called at any time, may adjust the cache sizes,
  ** turn the caches off, or turn them on. It is not dependent
  ** on the compilation setting of DEBUG.
  */
  if (!_pr_initialized) {
    _PR_ImplicitInitialization();
  }

  if (low > high) {
    low = high; /* sanity check the params */
  }

  PR_Lock(_pr_fd_cache.ml);
  _pr_fd_cache.limit_high = high;
  _pr_fd_cache.limit_low = low;
  PR_Unlock(_pr_fd_cache.ml);
  return PR_SUCCESS;
} /* PR_SetFDCacheSize */

void _PR_InitFdCache(void) {
  /*
  ** The fd caching is enabled by default for DEBUG builds,
  ** disabled by default for OPT builds. That default can
  ** be overridden at runtime using environment variables
  ** or a super-wiz-bang API.
  */
  const char* low = PR_GetEnv("NSPR_FD_CACHE_SIZE_LOW");
  const char* high = PR_GetEnv("NSPR_FD_CACHE_SIZE_HIGH");

  /*
  ** _low is allowed to be zero, _high is not.
  ** If _high is zero, we're not doing the caching.
  */

  _pr_fd_cache.limit_low = 0;
#if defined(DEBUG)
  _pr_fd_cache.limit_high = FD_SETSIZE;
#else
  _pr_fd_cache.limit_high = 0;
#endif /* defined(DEBUG) */

  if (NULL != low) {
    _pr_fd_cache.limit_low = atoi(low);
  }
  if (NULL != high) {
    _pr_fd_cache.limit_high = atoi(high);
  }

  if (_pr_fd_cache.limit_low < 0) {
    _pr_fd_cache.limit_low = 0;
  }
  if (_pr_fd_cache.limit_low > FD_SETSIZE) {
    _pr_fd_cache.limit_low = FD_SETSIZE;
  }

  if (_pr_fd_cache.limit_high > FD_SETSIZE) {
    _pr_fd_cache.limit_high = FD_SETSIZE;
  }

  if (_pr_fd_cache.limit_high < _pr_fd_cache.limit_low) {
    _pr_fd_cache.limit_high = _pr_fd_cache.limit_low;
  }

  _pr_fd_cache.ml = PR_NewLock();
  PR_ASSERT(NULL != _pr_fd_cache.ml);

} /* _PR_InitFdCache */

void _PR_CleanupFdCache(void) {
  PRFileDesc *fd, *next;

  for (fd = _pr_fd_cache.head; fd != NULL; fd = next) {
    next = fd->higher;
    PR_DELETE(fd->secret);
    PR_DELETE(fd);
  }
  _pr_fd_cache.head = NULL;
  _pr_fd_cache.tail = NULL;
  _pr_fd_cache.count = 0;
  PR_DestroyLock(_pr_fd_cache.ml);
  _pr_fd_cache.ml = NULL;
} /* _PR_CleanupFdCache */

/* prfdcach.c */