APT_DECLARE(apr_pool_t*) apt_pool_create()
{
apr_pool_t *pool = NULL;
#ifdef OWN_ALLOCATOR_PER_POOL
apr_allocator_t *allocator = NULL;
apr_thread_mutex_t *mutex = NULL;
if(apr_allocator_create(&allocator) == APR_SUCCESS) {
if(apr_pool_create_ex(&pool,NULL,NULL,allocator) == APR_SUCCESS) {
apr_allocator_owner_set(allocator,pool);
apr_thread_mutex_create(&mutex,APR_THREAD_MUTEX_NESTED,pool);
apr_allocator_mutex_set(allocator,mutex);
apr_pool_mutex_set(pool,mutex);
}
}
#else
apr_pool_create(&pool,NULL);
#endif
return pool;
}
apr_pool_t *nx_pool_create_core()
{
apr_pool_t *pool;
apr_allocator_t *allocator;
apr_thread_mutex_t *mutex;
CHECKERR(apr_allocator_create(&allocator));
#ifdef HAVE_APR_POOL_CREATE_UNMANAGED_EX
// older apr does not have this
CHECKERR(apr_pool_create_unmanaged_ex(&pool, &abort_func, allocator));
#else
CHECKERR(apr_pool_create_ex(&pool, NULL, &abort_func, allocator));
#endif
allocator = apr_pool_allocator_get(pool);
apr_allocator_owner_set(allocator, pool);
ASSERT(allocator != NULL);
apr_allocator_max_free_set(allocator, NX_MAX_ALLOCATOR_SIZE);
CHECKERR(apr_thread_mutex_create(&mutex, APR_THREAD_MUTEX_UNNESTED, pool));
apr_allocator_mutex_set(allocator, mutex);
return ( pool );
}
switch_memory_pool_t *switch_core_memory_init(void)
{
#ifndef INSTANTLY_DESTROY_POOLS
switch_threadattr_t *thd_attr;
#endif
#ifdef PER_POOL_LOCK
apr_allocator_t *my_allocator = NULL;
apr_thread_mutex_t *my_mutex;
#endif
memset(&memory_manager, 0, sizeof(memory_manager));
#ifdef PER_POOL_LOCK
if ((apr_allocator_create(&my_allocator)) != APR_SUCCESS) {
abort();
}
if ((apr_pool_create_ex(&memory_manager.memory_pool, NULL, NULL, my_allocator)) != APR_SUCCESS) {
apr_allocator_destroy(my_allocator);
my_allocator = NULL;
abort();
}
if ((apr_thread_mutex_create(&my_mutex, APR_THREAD_MUTEX_NESTED, memory_manager.memory_pool)) != APR_SUCCESS) {
abort();
}
apr_allocator_mutex_set(my_allocator, my_mutex);
apr_pool_mutex_set(memory_manager.memory_pool, my_mutex);
apr_allocator_owner_set(my_allocator, memory_manager.memory_pool);
apr_pool_tag(memory_manager.memory_pool, "core_pool");
#else
apr_pool_create(&memory_manager.memory_pool, NULL);
switch_assert(memory_manager.memory_pool != NULL);
#endif
#ifdef USE_MEM_LOCK
switch_mutex_init(&memory_manager.mem_lock, SWITCH_MUTEX_NESTED, memory_manager.memory_pool);
#endif
#ifdef INSTANTLY_DESTROY_POOLS
{
void *foo;
foo = (void *) (intptr_t) pool_thread;
}
#else
switch_queue_create(&memory_manager.pool_queue, 50000, memory_manager.memory_pool);
switch_queue_create(&memory_manager.pool_recycle_queue, 50000, memory_manager.memory_pool);
switch_threadattr_create(&thd_attr, memory_manager.memory_pool);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
switch_thread_create(&pool_thread_p, thd_attr, pool_thread, NULL, memory_manager.memory_pool);
while (!memory_manager.pool_thread_running) {
switch_cond_next();
}
#endif
return memory_manager.memory_pool;
}
SWITCH_DECLARE(switch_status_t) switch_core_perform_new_memory_pool(switch_memory_pool_t **pool, const char *file, const char *func, int line)
{
char *tmp;
#ifdef INSTANTLY_DESTROY_POOLS
apr_pool_create(pool, NULL);
switch_assert(*pool != NULL);
#else
#ifdef PER_POOL_LOCK
apr_allocator_t *my_allocator = NULL;
apr_thread_mutex_t *my_mutex;
#else
void *pop = NULL;
#endif
#ifdef USE_MEM_LOCK
switch_mutex_lock(memory_manager.mem_lock);
#endif
switch_assert(pool != NULL);
#ifndef PER_POOL_LOCK
if (switch_queue_trypop(memory_manager.pool_recycle_queue, &pop) == SWITCH_STATUS_SUCCESS && pop) {
*pool = (switch_memory_pool_t *) pop;
} else {
#endif
#ifdef PER_POOL_LOCK
if ((apr_allocator_create(&my_allocator)) != APR_SUCCESS) {
abort();
}
if ((apr_pool_create_ex(pool, NULL, NULL, my_allocator)) != APR_SUCCESS) {
abort();
}
if ((apr_thread_mutex_create(&my_mutex, APR_THREAD_MUTEX_NESTED, *pool)) != APR_SUCCESS) {
abort();
}
apr_allocator_mutex_set(my_allocator, my_mutex);
apr_allocator_owner_set(my_allocator, *pool);
apr_pool_mutex_set(*pool, my_mutex);
#else
apr_pool_create(pool, NULL);
switch_assert(*pool != NULL);
}
#endif
#endif
tmp = switch_core_sprintf(*pool, "%s:%d", file, line);
apr_pool_tag(*pool, tmp);
#ifdef DEBUG_ALLOC2
switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_CONSOLE, "%p New Pool %s\n", (void *) *pool, apr_pool_tag(*pool, NULL));
#endif
#ifdef USE_MEM_LOCK
switch_mutex_unlock(memory_manager.mem_lock);
#endif
return SWITCH_STATUS_SUCCESS;
}
void h2_session_destroy(h2_session *session)
{
assert(session);
if (session->streams) {
if (h2_stream_set_size(session->streams)) {
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_session(%ld): destroy, %ld streams open",
session->id, h2_stream_set_size(session->streams));
/* destroy all sessions, join all existing tasks */
h2_stream_set_iter(session->streams, close_active_iter, session);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_session(%ld): destroy, %ld streams remain",
session->id, h2_stream_set_size(session->streams));
}
h2_stream_set_destroy(session->streams);
session->streams = NULL;
}
if (session->zombies) {
if (h2_stream_set_size(session->zombies)) {
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_session(%ld): destroy, %ld zombie streams",
session->id, h2_stream_set_size(session->zombies));
/* destroy all zombies, join all existing tasks */
h2_stream_set_iter(session->zombies, close_zombie_iter, session);
ap_log_cerror(APLOG_MARK, APLOG_DEBUG, 0, session->c,
"h2_session(%ld): destroy, %ld zombies remain",
session->id, h2_stream_set_size(session->zombies));
}
h2_stream_set_destroy(session->zombies);
session->zombies = NULL;
}
if (session->ngh2) {
nghttp2_session_del(session->ngh2);
session->ngh2 = NULL;
}
if (session->mplx) {
h2_mplx_destroy(session->mplx);
session->mplx = NULL;
}
h2_conn_io_destroy(&session->io);
if (session->iowait) {
apr_thread_cond_destroy(session->iowait);
session->iowait = NULL;
}
apr_allocator_t *allocator = session->allocator;
if (session->alock) {
if (allocator) {
apr_allocator_mutex_set(allocator, session->alock);
}
apr_thread_mutex_destroy(session->alock);
session->alock = NULL;
}
if (session->pool) {
apr_pool_destroy(session->pool);
}
if (allocator) {
apr_allocator_destroy(allocator);
}
}
static h2_session *h2_session_create_int(conn_rec *c,
request_rec *r,
h2_config *config)
{
nghttp2_session_callbacks *callbacks = NULL;
nghttp2_option *options = NULL;
apr_allocator_t *allocator = NULL;
apr_status_t status = apr_allocator_create(&allocator);
if (status != APR_SUCCESS) {
return NULL;
}
apr_pool_t *pool = NULL;
status = apr_pool_create_ex(&pool, c->pool, NULL, allocator);
if (status != APR_SUCCESS) {
return NULL;
}
h2_session *session = apr_pcalloc(pool, sizeof(h2_session));
if (session) {
session->id = c->id;
session->allocator = allocator;
session->pool = pool;
status = apr_thread_mutex_create(&session->alock,
APR_THREAD_MUTEX_DEFAULT,
session->pool);
if (status != APR_SUCCESS) {
return NULL;
}
apr_allocator_mutex_set(session->allocator, session->alock);
status = apr_thread_cond_create(&session->iowait, session->pool);
if (status != APR_SUCCESS) {
return NULL;
}
session->c = c;
session->r = r;
session->ngh2 = NULL;
session->streams = h2_stream_set_create(session->pool);
session->zombies = h2_stream_set_create(session->pool);
session->mplx = h2_mplx_create(c, session->pool);
h2_conn_io_init(&session->io, c, 0);
apr_status_t status = init_callbacks(c, &callbacks);
if (status != APR_SUCCESS) {
ap_log_cerror(APLOG_MARK, APLOG_ERR, status, c,
"nghttp2: error in init_callbacks");
h2_session_destroy(session);
return NULL;
}
int rv = nghttp2_option_new(&options);
if (rv != 0) {
ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, c,
"nghttp2_option_new: %s", nghttp2_strerror(rv));
h2_session_destroy(session);
return NULL;
}
/* Nowadays, we handle the preface ourselves. We had problems
* with nghttp2 internal state machine when traffic action occured
* before the preface was read.
*/
nghttp2_option_set_recv_client_preface(options, 1);
/* Set a value, to be observed before we receive any SETTINGS
* from the client. */
nghttp2_option_set_peer_max_concurrent_streams(options, 100);
/* We need to handle window updates ourself, otherwise we
* get flooded by nghttp2. */
nghttp2_option_set_no_auto_window_update(options, 1);
rv = nghttp2_session_server_new2(&session->ngh2, callbacks,
session, options);
nghttp2_session_callbacks_del(callbacks);
nghttp2_option_del(options);
if (rv != 0) {
ap_log_cerror(APLOG_MARK, APLOG_ERR, APR_EGENERAL, c,
"nghttp2_session_server_new: %s",
nghttp2_strerror(rv));
h2_session_destroy(session);
return NULL;
}
}
return session;
}
