mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-05-25 08:22:49 +00:00
a590a4b23d
git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@5224 d0543943-73ff-0310-b7d9-9358b9ac24b2
312 lines
11 KiB
C
312 lines
11 KiB
C
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is the Netscape Portable Runtime (NSPR).
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 1998-2000
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#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;
|
|
PRStack *stack;
|
|
PRFileDesc *head, *tail;
|
|
PRIntn limit_low, limit_high;
|
|
} _PR_Fd_Cache;
|
|
|
|
static _PR_Fd_Cache _pr_fd_cache;
|
|
static PRFileDesc **stack2fd = &(((PRFileDesc*)NULL)->higher);
|
|
|
|
|
|
/*
|
|
** 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)
|
|
{
|
|
PRStackElem *pop;
|
|
PR_ASSERT(NULL != _pr_fd_cache.stack);
|
|
pop = PR_StackPop(_pr_fd_cache.stack);
|
|
if (NULL == pop) goto allocate;
|
|
fd = (PRFileDesc*)((PRPtrdiff)pop - (PRPtrdiff)stack2fd);
|
|
}
|
|
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)
|
|
{
|
|
PR_StackPush(_pr_fd_cache.stack, (PRStackElem*)(&fd->higher));
|
|
}
|
|
else
|
|
{
|
|
if (_pr_fd_cache.count > _pr_fd_cache.limit_high)
|
|
{
|
|
PR_Free(fd->secret);
|
|
PR_Free(fd);
|
|
}
|
|
else
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
} /* _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);
|
|
if (0 == high) /* shutting down or staying down */
|
|
{
|
|
if (0 != _pr_fd_cache.limit_high) /* shutting down */
|
|
{
|
|
_pr_fd_cache.limit_high = 0; /* stop use */
|
|
/*
|
|
** Hold the lock throughout - nobody's going to want it
|
|
** other than another caller to this routine. Just don't
|
|
** let that happen.
|
|
**
|
|
** Put all the cached fds onto the new cache.
|
|
*/
|
|
while (NULL != _pr_fd_cache.head)
|
|
{
|
|
PRFileDesc *fd = _pr_fd_cache.head;
|
|
_pr_fd_cache.head = fd->higher;
|
|
PR_StackPush(_pr_fd_cache.stack, (PRStackElem*)(&fd->higher));
|
|
}
|
|
_pr_fd_cache.limit_low = 0;
|
|
_pr_fd_cache.tail = NULL;
|
|
_pr_fd_cache.count = 0;
|
|
}
|
|
}
|
|
else /* starting up or just adjusting parameters */
|
|
{
|
|
PRBool was_using_stack = (0 == _pr_fd_cache.limit_high);
|
|
_pr_fd_cache.limit_low = low;
|
|
_pr_fd_cache.limit_high = high;
|
|
if (was_using_stack) /* was using stack - feed into cache */
|
|
{
|
|
PRStackElem *pop;
|
|
while (NULL != (pop = PR_StackPop(_pr_fd_cache.stack)))
|
|
{
|
|
PRFileDesc *fd = (PRFileDesc*)
|
|
((PRPtrdiff)pop - (PRPtrdiff)stack2fd);
|
|
if (NULL == _pr_fd_cache.tail) _pr_fd_cache.tail = fd;
|
|
fd->higher = _pr_fd_cache.head;
|
|
_pr_fd_cache.head = fd;
|
|
_pr_fd_cache.count += 1;
|
|
}
|
|
}
|
|
}
|
|
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_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_fd_cache.stack = PR_CreateStack("FD");
|
|
PR_ASSERT(NULL != _pr_fd_cache.stack);
|
|
|
|
} /* _PR_InitFdCache */
|
|
|
|
void _PR_CleanupFdCache(void)
|
|
{
|
|
PRFileDesc *fd, *next;
|
|
PRStackElem *pop;
|
|
|
|
for (fd = _pr_fd_cache.head; fd != NULL; fd = next)
|
|
{
|
|
next = fd->higher;
|
|
PR_DELETE(fd->secret);
|
|
PR_DELETE(fd);
|
|
}
|
|
PR_DestroyLock(_pr_fd_cache.ml);
|
|
while ((pop = PR_StackPop(_pr_fd_cache.stack)) != NULL)
|
|
{
|
|
fd = (PRFileDesc*)((PRPtrdiff)pop - (PRPtrdiff)stack2fd);
|
|
PR_DELETE(fd->secret);
|
|
PR_DELETE(fd);
|
|
}
|
|
PR_DestroyStack(_pr_fd_cache.stack);
|
|
} /* _PR_CleanupFdCache */
|
|
|
|
/* prfdcach.c */
|