/* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (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.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <assert.h> #include "apu.h" #include "apr_reslist.h" #include "apr_errno.h" #include "apr_strings.h" #include "apr_thread_mutex.h" #include "apr_thread_cond.h" #include "apr_ring.h" #if APR_HAS_THREADS /** * A single resource element. */ struct apr_res_t { apr_time_t freed; void *opaque; APR_RING_ENTRY(apr_res_t) link; }; typedef struct apr_res_t apr_res_t; /** * A ring of resources representing the list of available resources. */ APR_RING_HEAD(apr_resring_t, apr_res_t); typedef struct apr_resring_t apr_resring_t; struct apr_reslist_t { apr_pool_t *pool; /* the pool used in constructor and destructor calls */ int ntotal; /* total number of resources managed by this list */ int nidle; /* number of available resources */ int min; /* desired minimum number of available resources */ int smax; /* soft maximum on the total number of resources */ int hmax; /* hard maximum on the total number of resources */ apr_interval_time_t ttl; /* TTL when we have too many resources */ apr_interval_time_t timeout; /* Timeout for waiting on resource */ apr_reslist_constructor constructor; apr_reslist_destructor destructor; void *params; /* opaque data passed to constructor and destructor calls */ apr_resring_t avail_list; apr_resring_t free_list; apr_thread_mutex_t *listlock; apr_thread_cond_t *avail; }; /** * Grab a resource from the front of the resource list. * Assumes: that the reslist is locked. */ static apr_res_t *pop_resource(apr_reslist_t *reslist) { apr_res_t *res; res = APR_RING_FIRST(&reslist->avail_list); APR_RING_REMOVE(res, link); reslist->nidle--; return res; } /** * Add a resource to the beginning of the list, set the time at which * it was added to the list. * Assumes: that the reslist is locked. */ static void push_resource(apr_reslist_t *reslist, apr_res_t *resource) { APR_RING_INSERT_HEAD(&reslist->avail_list, resource, apr_res_t, link); resource->freed = apr_time_now(); reslist->nidle++; } /** * Get an resource container from the free list or create a new one. */ static apr_res_t *get_container(apr_reslist_t *reslist) { apr_res_t *res; if (!APR_RING_EMPTY(&reslist->free_list, apr_res_t, link)) { res = APR_RING_FIRST(&reslist->free_list); APR_RING_REMOVE(res, link); } else res = apr_pcalloc(reslist->pool, sizeof(*res)); return res; } /** * Free up a resource container by placing it on the free list. */ static void free_container(apr_reslist_t *reslist, apr_res_t *container) { APR_RING_INSERT_TAIL(&reslist->free_list, container, apr_res_t, link); } /** * Create a new resource and return it. * Assumes: that the reslist is locked. */ static apr_status_t create_resource(apr_reslist_t *reslist, apr_res_t **ret_res) { apr_status_t rv; apr_res_t *res; res = get_container(reslist); rv = reslist->constructor(&res->opaque, reslist->params, reslist->pool); *ret_res = res; return rv; } /** * Destroy a single idle resource. * Assumes: that the reslist is locked. */ static apr_status_t destroy_resource(apr_reslist_t *reslist, apr_res_t *res) { return reslist->destructor(res->opaque, reslist->params, reslist->pool); } static apr_status_t reslist_cleanup(void *data_) { apr_status_t rv = APR_SUCCESS; apr_reslist_t *rl = data_; apr_res_t *res; apr_thread_mutex_lock(rl->listlock); while (rl->nidle > 0) { apr_status_t rv1; res = pop_resource(rl); rl->ntotal--; rv1 = destroy_resource(rl, res); if (rv1 != APR_SUCCESS) { rv = rv1; /* loses info in the unlikely event of * multiple *different* failures */ } free_container(rl, res); } assert(rl->nidle == 0); assert(rl->ntotal == 0); apr_thread_mutex_unlock(rl->listlock); apr_thread_mutex_destroy(rl->listlock); apr_thread_cond_destroy(rl->avail); return rv; } /** * Perform routine maintenance on the resource list. This call * may instantiate new resources or expire old resources. */ static apr_status_t reslist_maint(apr_reslist_t *reslist) { apr_time_t now; apr_status_t rv; apr_res_t *res; int created_one = 0; apr_thread_mutex_lock(reslist->listlock); /* Check if we need to create more resources, and if we are allowed to. */ while (reslist->nidle < reslist->min && reslist->ntotal < reslist->hmax) { /* Create the resource */ rv = create_resource(reslist, &res); if (rv != APR_SUCCESS) { free_container(reslist, res); apr_thread_mutex_unlock(reslist->listlock); return rv; } /* Add it to the list */ push_resource(reslist, res); /* Update our counters */ reslist->ntotal++; /* If someone is waiting on that guy, wake them up. */ rv = apr_thread_cond_signal(reslist->avail); if (rv != APR_SUCCESS) { apr_thread_mutex_unlock(reslist->listlock); return rv; } created_one++; } /* We don't need to see if we're over the max if we were under it before */ if (created_one) { apr_thread_mutex_unlock(reslist->listlock); return APR_SUCCESS; } /* Check if we need to expire old resources */ now = apr_time_now(); while (reslist->nidle > reslist->smax && reslist->nidle > 0) { /* Peak at the last resource in the list */ res = APR_RING_LAST(&reslist->avail_list); /* See if the oldest entry should be expired */ if (now - res->freed < reslist->ttl) { /* If this entry is too young, none of the others * will be ready to be expired either, so we are done. */ break; } APR_RING_REMOVE(res, link); reslist->nidle--; reslist->ntotal--; rv = destroy_resource(reslist, res); free_container(reslist, res); if (rv != APR_SUCCESS) { apr_thread_mutex_unlock(reslist->listlock); return rv; } } apr_thread_mutex_unlock(reslist->listlock); return APR_SUCCESS; } APU_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist, int min, int smax, int hmax, apr_interval_time_t ttl, apr_reslist_constructor con, apr_reslist_destructor de, void *params, apr_pool_t *pool) { apr_status_t rv; apr_reslist_t *rl; /* Do some sanity checks so we don't thrash around in the * maintenance routine later. */ if (min < 0 || min > smax || min > hmax || smax > hmax || hmax == 0 || ttl < 0) { return APR_EINVAL; } rl = apr_pcalloc(pool, sizeof(*rl)); rl->pool = pool; rl->min = min; rl->smax = smax; rl->hmax = hmax; rl->ttl = ttl; rl->constructor = con; rl->destructor = de; rl->params = params; APR_RING_INIT(&rl->avail_list, apr_res_t, link); APR_RING_INIT(&rl->free_list, apr_res_t, link); rv = apr_thread_mutex_create(&rl->listlock, APR_THREAD_MUTEX_DEFAULT, pool); if (rv != APR_SUCCESS) { return rv; } rv = apr_thread_cond_create(&rl->avail, pool); if (rv != APR_SUCCESS) { return rv; } rv = reslist_maint(rl); if (rv != APR_SUCCESS) { /* Destroy what we've created so far. */ reslist_cleanup(rl); return rv; } apr_pool_cleanup_register(rl->pool, rl, reslist_cleanup, apr_pool_cleanup_null); *reslist = rl; return APR_SUCCESS; } APU_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist) { return apr_pool_cleanup_run(reslist->pool, reslist, reslist_cleanup); } APU_DECLARE(apr_status_t) apr_reslist_acquire(apr_reslist_t *reslist, void **resource) { apr_status_t rv; apr_res_t *res; apr_time_t now; apr_thread_mutex_lock(reslist->listlock); /* If there are idle resources on the available list, use * them right away. */ now = apr_time_now(); while (reslist->nidle > 0) { /* Pop off the first resource */ res = pop_resource(reslist); if (reslist->ttl && (now - res->freed >= reslist->ttl)) { /* this res is expired - kill it */ reslist->ntotal--; rv = destroy_resource(reslist, res); free_container(reslist, res); if (rv != APR_SUCCESS) { apr_thread_mutex_unlock(reslist->listlock); return rv; /* FIXME: this might cause unnecessary fails */ } continue; } *resource = res->opaque; free_container(reslist, res); apr_thread_mutex_unlock(reslist->listlock); return APR_SUCCESS; } /* If we've hit our max, block until we're allowed to create * a new one, or something becomes free. */ while (reslist->ntotal >= reslist->hmax && reslist->nidle <= 0) { if (reslist->timeout) { if ((rv = apr_thread_cond_timedwait(reslist->avail, reslist->listlock, reslist->timeout)) != APR_SUCCESS) { apr_thread_mutex_unlock(reslist->listlock); return rv; } } else { apr_thread_cond_wait(reslist->avail, reslist->listlock); } } /* If we popped out of the loop, first try to see if there * are new resources available for immediate use. */ if (reslist->nidle > 0) { res = pop_resource(reslist); *resource = res->opaque; free_container(reslist, res); apr_thread_mutex_unlock(reslist->listlock); return APR_SUCCESS; } /* Otherwise the reason we dropped out of the loop * was because there is a new slot available, so create * a resource to fill the slot and use it. */ else { rv = create_resource(reslist, &res); if (rv == APR_SUCCESS) { reslist->ntotal++; *resource = res->opaque; } free_container(reslist, res); apr_thread_mutex_unlock(reslist->listlock); return rv; } } APU_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist, void *resource) { apr_res_t *res; apr_thread_mutex_lock(reslist->listlock); res = get_container(reslist); res->opaque = resource; push_resource(reslist, res); apr_thread_cond_signal(reslist->avail); apr_thread_mutex_unlock(reslist->listlock); return reslist_maint(reslist); } APU_DECLARE(void) apr_reslist_timeout_set(apr_reslist_t *reslist, apr_interval_time_t timeout) { reslist->timeout = timeout; } APU_DECLARE(apr_uint32_t) apr_reslist_acquired_count(apr_reslist_t *reslist) { apr_uint32_t count; apr_thread_mutex_lock(reslist->listlock); count = reslist->ntotal - reslist->nidle; apr_thread_mutex_unlock(reslist->listlock); return count; } APU_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist, void *resource) { apr_status_t ret; apr_thread_mutex_lock(reslist->listlock); ret = reslist->destructor(resource, reslist->params, reslist->pool); reslist->ntotal--; apr_thread_cond_signal(reslist->avail); apr_thread_mutex_unlock(reslist->listlock); return ret; } #endif /* APR_HAS_THREADS */
.htaccess Tutorial
Find information you are looking for on the AskApache Home Page.