APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
{
if (list->pool) {
apr_pool_cleanup_kill(list->pool, list, alloc_cleanup);
}
apr_allocator_free(list->allocator, list->blocks);
#if APR_POOL_DEBUG
if (list->pool && list->allocator != apr_pool_allocator_get(list->pool)) {
apr_allocator_destroy(list->allocator);
}
#endif
}
static apr_status_t alloc_cleanup(void *data)
{
apr_bucket_alloc_t *list = data;
apr_allocator_free(list->allocator, list->blocks);
#if APR_POOL_DEBUG
if (list->pool && list->allocator != apr_pool_allocator_get(list->pool)) {
apr_allocator_destroy(list->allocator);
}
#endif
return APR_SUCCESS;
}
static void worker_main(void *vpArg)
{
long conn_id;
conn_rec *current_conn;
apr_pool_t *pconn;
apr_allocator_t *allocator;
apr_bucket_alloc_t *bucket_alloc;
worker_args_t *worker_args;
HQUEUE workq;
PID owner;
int rc;
REQUESTDATA rd;
ULONG len;
BYTE priority;
int thread_slot = (int)vpArg;
EXCEPTIONREGISTRATIONRECORD reg_rec = { NULL, thread_exception_handler };
ap_sb_handle_t *sbh;
/* Trap exceptions in this thread so we don't take down the whole process */
DosSetExceptionHandler( ®_rec );
rc = DosOpenQueue(&owner, &workq,
apr_psprintf(pchild, "/queues/httpd/work.%d", getpid()));
if (rc) {
ap_log_error(APLOG_MARK, APLOG_ERR, APR_FROM_OS_ERROR(rc), ap_server_conf,
"unable to open work queue, exiting");
ap_scoreboard_image->servers[child_slot][thread_slot].tid = 0;
}
conn_id = ID_FROM_CHILD_THREAD(child_slot, thread_slot);
ap_update_child_status_from_indexes(child_slot, thread_slot, SERVER_READY,
NULL);
apr_allocator_create(&allocator);
apr_allocator_max_free_set(allocator, ap_max_mem_free);
bucket_alloc = apr_bucket_alloc_create_ex(allocator);
while (rc = DosReadQueue(workq, &rd, &len, (PPVOID)&worker_args, 0, DCWW_WAIT, &priority, NULLHANDLE),
rc == 0 && rd.ulData != WORKTYPE_EXIT) {
pconn = worker_args->pconn;
ap_create_sb_handle(&sbh, pconn, child_slot, thread_slot);
current_conn = ap_run_create_connection(pconn, ap_server_conf,
worker_args->conn_sd, conn_id,
sbh, bucket_alloc);
if (current_conn) {
ap_process_connection(current_conn, worker_args->conn_sd);
ap_lingering_close(current_conn);
}
apr_pool_destroy(pconn);
ap_update_child_status_from_indexes(child_slot, thread_slot,
SERVER_READY, NULL);
}
ap_update_child_status_from_indexes(child_slot, thread_slot, SERVER_DEAD,
NULL);
apr_bucket_alloc_destroy(bucket_alloc);
apr_allocator_destroy(allocator);
}
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;
}
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);
}
}
