637 lines
27 KiB
Diff
637 lines
27 KiB
Diff
diff --git a/modules/proxy/mod_proxy.h b/modules/proxy/mod_proxy.h
|
|
index 57cc92f..fbbd508 100644
|
|
--- a/modules/proxy/mod_proxy.h
|
|
+++ b/modules/proxy/mod_proxy.h
|
|
@@ -288,12 +288,15 @@ typedef struct {
|
|
|
|
/* Connection pool */
|
|
struct proxy_conn_pool {
|
|
- apr_pool_t *pool; /* The pool used in constructor and destructor calls */
|
|
- apr_sockaddr_t *addr; /* Preparsed remote address info */
|
|
- apr_reslist_t *res; /* Connection resource list */
|
|
- proxy_conn_rec *conn; /* Single connection for prefork mpm */
|
|
+ apr_pool_t *pool; /* The pool used in constructor and destructor calls */
|
|
+ apr_sockaddr_t *addr; /* Preparsed remote address info */
|
|
+ apr_reslist_t *res; /* Connection resource list */
|
|
+ proxy_conn_rec *conn; /* Single connection for prefork mpm */
|
|
+ apr_pool_t *dns_pool; /* The pool used for worker scoped DNS resolutions */
|
|
};
|
|
|
|
+#define AP_VOLATILIZE_T(T, x) (*(T volatile *)&(x))
|
|
+
|
|
/* worker status bits */
|
|
/*
|
|
* NOTE: Keep up-to-date w/ proxy_wstat_tbl[]
|
|
@@ -475,7 +478,9 @@ struct proxy_worker {
|
|
proxy_conn_pool *cp; /* Connection pool to use */
|
|
proxy_worker_shared *s; /* Shared data */
|
|
proxy_balancer *balancer; /* which balancer am I in? */
|
|
+#if APR_HAS_THREADS
|
|
apr_thread_mutex_t *tmutex; /* Thread lock for updating address cache */
|
|
+#endif
|
|
void *context; /* general purpose storage */
|
|
ap_conf_vector_t *section_config; /* <Proxy>-section wherein defined */
|
|
};
|
|
@@ -534,7 +539,9 @@ struct proxy_balancer {
|
|
apr_time_t wupdated; /* timestamp of last change to workers list */
|
|
proxy_balancer_method *lbmethod;
|
|
apr_global_mutex_t *gmutex; /* global lock for updating list of workers */
|
|
+#if APR_HAS_THREADS
|
|
apr_thread_mutex_t *tmutex; /* Thread lock for updating shm */
|
|
+#endif
|
|
proxy_server_conf *sconf;
|
|
void *context; /* general purpose storage */
|
|
proxy_balancer_shared *s; /* Shared data */
|
|
diff --git a/modules/proxy/mod_proxy_balancer.c b/modules/proxy/mod_proxy_balancer.c
|
|
index c59f5e9..3a28038 100644
|
|
--- a/modules/proxy/mod_proxy_balancer.c
|
|
+++ b/modules/proxy/mod_proxy_balancer.c
|
|
@@ -346,23 +346,27 @@ static proxy_worker *find_best_worker(proxy_balancer *balancer,
|
|
proxy_worker *candidate = NULL;
|
|
apr_status_t rv;
|
|
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_LOCK(balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01163)
|
|
"%s: Lock failed for find_best_worker()",
|
|
balancer->s->name);
|
|
return NULL;
|
|
}
|
|
+#endif
|
|
|
|
candidate = (*balancer->lbmethod->finder)(balancer, r);
|
|
|
|
if (candidate)
|
|
candidate->s->elected++;
|
|
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_UNLOCK(balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01164)
|
|
"%s: Unlock failed for find_best_worker()",
|
|
balancer->s->name);
|
|
}
|
|
+#endif
|
|
|
|
if (candidate == NULL) {
|
|
/* All the workers are in error state or disabled.
|
|
@@ -492,11 +496,13 @@ static int proxy_balancer_pre_request(proxy_worker **worker,
|
|
/* Step 2: Lock the LoadBalancer
|
|
* XXX: perhaps we need the process lock here
|
|
*/
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_LOCK(*balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01166)
|
|
"%s: Lock failed for pre_request", (*balancer)->s->name);
|
|
return DECLINED;
|
|
}
|
|
+#endif
|
|
|
|
/* Step 3: force recovery */
|
|
force_recovery(*balancer, r->server);
|
|
@@ -557,20 +563,24 @@ static int proxy_balancer_pre_request(proxy_worker **worker,
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(01167)
|
|
"%s: All workers are in error state for route (%s)",
|
|
(*balancer)->s->name, route);
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_UNLOCK(*balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01168)
|
|
"%s: Unlock failed for pre_request",
|
|
(*balancer)->s->name);
|
|
}
|
|
+#endif
|
|
return HTTP_SERVICE_UNAVAILABLE;
|
|
}
|
|
}
|
|
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_UNLOCK(*balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01169)
|
|
"%s: Unlock failed for pre_request",
|
|
(*balancer)->s->name);
|
|
}
|
|
+#endif
|
|
if (!*worker) {
|
|
runtime = find_best_worker(*balancer, r);
|
|
if (!runtime) {
|
|
@@ -644,12 +654,14 @@ static int proxy_balancer_post_request(proxy_worker *worker,
|
|
|
|
apr_status_t rv;
|
|
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_LOCK(balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01173)
|
|
"%s: Lock failed for post_request",
|
|
balancer->s->name);
|
|
return HTTP_INTERNAL_SERVER_ERROR;
|
|
}
|
|
+#endif
|
|
|
|
if (!apr_is_empty_array(balancer->errstatuses)
|
|
&& !(worker->s->status & PROXY_WORKER_IGNORE_ERRORS)) {
|
|
@@ -681,11 +693,12 @@ static int proxy_balancer_post_request(proxy_worker *worker,
|
|
worker->s->error_time = apr_time_now();
|
|
|
|
}
|
|
-
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_UNLOCK(balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01175)
|
|
"%s: Unlock failed for post_request", balancer->s->name);
|
|
}
|
|
+#endif
|
|
ap_log_rerror(APLOG_MARK, APLOG_DEBUG, 0, r, APLOGNO(01176)
|
|
"proxy_balancer_post_request for (%s)", balancer->s->name);
|
|
|
|
@@ -945,7 +958,6 @@ static int balancer_post_config(apr_pool_t *pconf, apr_pool_t *plog,
|
|
PROXY_STRNCPY(balancer->s->sname, sname); /* We know this will succeed */
|
|
|
|
balancer->max_workers = balancer->workers->nelts + balancer->growth;
|
|
-
|
|
/* Create global mutex */
|
|
rv = ap_global_mutex_create(&(balancer->gmutex), NULL, balancer_mutex_type,
|
|
balancer->s->sname, s, pconf, 0);
|
|
@@ -955,7 +967,6 @@ static int balancer_post_config(apr_pool_t *pconf, apr_pool_t *plog,
|
|
balancer->s->sname);
|
|
return HTTP_INTERNAL_SERVER_ERROR;
|
|
}
|
|
-
|
|
apr_pool_cleanup_register(pconf, (void *)s, lock_remove,
|
|
apr_pool_cleanup_null);
|
|
|
|
@@ -1135,17 +1146,21 @@ static int balancer_handler(request_rec *r)
|
|
|
|
balancer = (proxy_balancer *)conf->balancers->elts;
|
|
for (i = 0; i < conf->balancers->nelts; i++, balancer++) {
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_LOCK(balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01189)
|
|
"%s: Lock failed for balancer_handler",
|
|
balancer->s->name);
|
|
}
|
|
+#endif
|
|
ap_proxy_sync_balancer(balancer, r->server, conf);
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_THREAD_UNLOCK(balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01190)
|
|
"%s: Unlock failed for balancer_handler",
|
|
balancer->s->name);
|
|
}
|
|
+#endif
|
|
}
|
|
|
|
if (r->args && (r->method_number == M_GET)) {
|
|
@@ -1359,11 +1374,13 @@ static int balancer_handler(request_rec *r)
|
|
proxy_worker *nworker;
|
|
nworker = ap_proxy_get_worker(r->pool, bsel, conf, val);
|
|
if (!nworker && storage->num_free_slots(bsel->wslot)) {
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_GLOBAL_LOCK(bsel)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01194)
|
|
"%s: Lock failed for adding worker",
|
|
bsel->s->name);
|
|
}
|
|
+#endif
|
|
ret = ap_proxy_define_worker(conf->pool, &nworker, bsel, conf, val, 0);
|
|
if (!ret) {
|
|
unsigned int index;
|
|
@@ -1372,53 +1389,76 @@ static int balancer_handler(request_rec *r)
|
|
if ((rv = storage->grab(bsel->wslot, &index)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r, APLOGNO(01195)
|
|
"worker slotmem_grab failed");
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_GLOBAL_UNLOCK(bsel)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01196)
|
|
"%s: Unlock failed for adding worker",
|
|
bsel->s->name);
|
|
}
|
|
+#endif
|
|
return HTTP_BAD_REQUEST;
|
|
}
|
|
if ((rv = storage->dptr(bsel->wslot, index, (void *)&shm)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r, APLOGNO(01197)
|
|
"worker slotmem_dptr failed");
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_GLOBAL_UNLOCK(bsel)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01198)
|
|
"%s: Unlock failed for adding worker",
|
|
bsel->s->name);
|
|
}
|
|
+#endif
|
|
return HTTP_BAD_REQUEST;
|
|
}
|
|
if ((rv = ap_proxy_share_worker(nworker, shm, index)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r, APLOGNO(01199)
|
|
"Cannot share worker");
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_GLOBAL_UNLOCK(bsel)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01200)
|
|
"%s: Unlock failed for adding worker",
|
|
bsel->s->name);
|
|
}
|
|
+#endif
|
|
return HTTP_BAD_REQUEST;
|
|
}
|
|
if ((rv = ap_proxy_initialize_worker(nworker, r->server, conf->pool)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_EMERG, rv, r, APLOGNO(01201)
|
|
"Cannot init worker");
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_GLOBAL_UNLOCK(bsel)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01202)
|
|
"%s: Unlock failed for adding worker",
|
|
bsel->s->name);
|
|
}
|
|
+#endif
|
|
return HTTP_BAD_REQUEST;
|
|
}
|
|
/* sync all timestamps */
|
|
bsel->wupdated = bsel->s->wupdated = nworker->s->updated = apr_time_now();
|
|
/* by default, all new workers are disabled */
|
|
ap_proxy_set_wstatus(PROXY_WORKER_DISABLED_FLAG, 1, nworker);
|
|
+ } else {
|
|
+ ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(10163)
|
|
+ "%s: failed to add worker %s",
|
|
+ bsel->s->name, val);
|
|
+#if APR_HAS_THREADS
|
|
+ PROXY_GLOBAL_UNLOCK(bsel);
|
|
+#endif
|
|
+ return HTTP_BAD_REQUEST;
|
|
}
|
|
+#if APR_HAS_THREADS
|
|
if ((rv = PROXY_GLOBAL_UNLOCK(bsel)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, rv, r, APLOGNO(01203)
|
|
"%s: Unlock failed for adding worker",
|
|
bsel->s->name);
|
|
}
|
|
+#endif
|
|
+ } else {
|
|
+ ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, APLOGNO(10164)
|
|
+ "%s: failed to add worker %s",
|
|
+ bsel->s->name, val);
|
|
+ return HTTP_BAD_REQUEST;
|
|
}
|
|
|
|
}
|
|
diff --git a/modules/proxy/mod_proxy_ftp.c b/modules/proxy/mod_proxy_ftp.c
|
|
index 5d9175e..5c4d641 100644
|
|
--- a/modules/proxy/mod_proxy_ftp.c
|
|
+++ b/modules/proxy/mod_proxy_ftp.c
|
|
@@ -979,8 +979,10 @@ static int proxy_ftp_handler(request_rec *r, proxy_worker *worker,
|
|
apr_status_t rv;
|
|
conn_rec *origin, *data = NULL;
|
|
apr_status_t err = APR_SUCCESS;
|
|
+#if APR_HAS_THREADS
|
|
apr_status_t uerr = APR_SUCCESS;
|
|
- apr_bucket_brigade *bb = apr_brigade_create(p, c->bucket_alloc);
|
|
+#endif
|
|
+ apr_bucket_brigade *bb;
|
|
char *buf, *connectname;
|
|
apr_port_t connectport;
|
|
char *ftpmessage = NULL;
|
|
@@ -1120,13 +1122,15 @@ static int proxy_ftp_handler(request_rec *r, proxy_worker *worker,
|
|
|
|
if (worker->s->is_address_reusable) {
|
|
if (!worker->cp->addr) {
|
|
+#if APR_HAS_THREADS
|
|
if ((err = PROXY_THREAD_LOCK(worker->balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, err, r, APLOGNO(01037) "lock");
|
|
return HTTP_INTERNAL_SERVER_ERROR;
|
|
}
|
|
+#endif
|
|
}
|
|
- connect_addr = worker->cp->addr;
|
|
- address_pool = worker->cp->pool;
|
|
+ connect_addr = AP_VOLATILIZE_T(apr_sockaddr_t *, worker->cp->addr);
|
|
+ address_pool = worker->cp->dns_pool;
|
|
}
|
|
else
|
|
address_pool = r->pool;
|
|
@@ -1139,9 +1143,11 @@ static int proxy_ftp_handler(request_rec *r, proxy_worker *worker,
|
|
address_pool);
|
|
if (worker->s->is_address_reusable && !worker->cp->addr) {
|
|
worker->cp->addr = connect_addr;
|
|
+#if APR_HAS_THREADS
|
|
if ((uerr = PROXY_THREAD_UNLOCK(worker->balancer)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, uerr, r, APLOGNO(01038) "unlock");
|
|
}
|
|
+#endif
|
|
}
|
|
/*
|
|
* get all the possible IP addresses for the destname and loop through
|
|
@@ -1212,6 +1218,7 @@ static int proxy_ftp_handler(request_rec *r, proxy_worker *worker,
|
|
* correct directory...
|
|
*/
|
|
|
|
+ bb = apr_brigade_create(p, c->bucket_alloc);
|
|
|
|
/* possible results: */
|
|
/* 120 Service ready in nnn minutes. */
|
|
diff --git a/modules/proxy/proxy_util.c b/modules/proxy/proxy_util.c
|
|
index 2bfc8f0..7714b6c 100644
|
|
--- a/modules/proxy/proxy_util.c
|
|
+++ b/modules/proxy/proxy_util.c
|
|
@@ -1167,8 +1167,10 @@ PROXY_DECLARE(char *) ap_proxy_define_balancer(apr_pool_t *p,
|
|
lbmethod = ap_lookup_provider(PROXY_LBMETHOD, "byrequests", "0");
|
|
|
|
(*balancer)->workers = apr_array_make(p, 5, sizeof(proxy_worker *));
|
|
+#if APR_HAS_THREADS
|
|
(*balancer)->gmutex = NULL;
|
|
(*balancer)->tmutex = NULL;
|
|
+#endif
|
|
(*balancer)->lbmethod = lbmethod;
|
|
|
|
if (do_malloc)
|
|
@@ -1257,7 +1259,9 @@ PROXY_DECLARE(apr_status_t) ap_proxy_share_balancer(proxy_balancer *balancer,
|
|
|
|
PROXY_DECLARE(apr_status_t) ap_proxy_initialize_balancer(proxy_balancer *balancer, server_rec *s, apr_pool_t *p)
|
|
{
|
|
+#if APR_HAS_THREADS
|
|
apr_status_t rv = APR_SUCCESS;
|
|
+#endif
|
|
ap_slotmem_provider_t *storage = balancer->storage;
|
|
apr_size_t size;
|
|
unsigned int num;
|
|
@@ -1297,6 +1301,7 @@ PROXY_DECLARE(apr_status_t) ap_proxy_initialize_balancer(proxy_balancer *balance
|
|
if (balancer->lbmethod && balancer->lbmethod->reset)
|
|
balancer->lbmethod->reset(balancer, s);
|
|
|
|
+#if APR_HAS_THREADS
|
|
if (balancer->tmutex == NULL) {
|
|
rv = apr_thread_mutex_create(&(balancer->tmutex), APR_THREAD_MUTEX_DEFAULT, p);
|
|
if (rv != APR_SUCCESS) {
|
|
@@ -1305,6 +1310,7 @@ PROXY_DECLARE(apr_status_t) ap_proxy_initialize_balancer(proxy_balancer *balance
|
|
return rv;
|
|
}
|
|
}
|
|
+#endif
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
@@ -1446,16 +1452,14 @@ static void socket_cleanup(proxy_conn_rec *conn)
|
|
|
|
static apr_status_t conn_pool_cleanup(void *theworker)
|
|
{
|
|
- proxy_worker *worker = (proxy_worker *)theworker;
|
|
- if (worker->cp->res) {
|
|
- worker->cp->pool = NULL;
|
|
- }
|
|
+ ((proxy_worker *)theworker)->cp = NULL;
|
|
return APR_SUCCESS;
|
|
}
|
|
|
|
static void init_conn_pool(apr_pool_t *p, proxy_worker *worker)
|
|
{
|
|
apr_pool_t *pool;
|
|
+ apr_pool_t *dns_pool;
|
|
proxy_conn_pool *cp;
|
|
|
|
/*
|
|
@@ -1466,12 +1470,21 @@ static void init_conn_pool(apr_pool_t *p, proxy_worker *worker)
|
|
*/
|
|
apr_pool_create(&pool, p);
|
|
apr_pool_tag(pool, "proxy_worker_cp");
|
|
+ /*
|
|
+ * Create a subpool of the connection pool for worker
|
|
+ * scoped DNS resolutions. This is needed to avoid race
|
|
+ * conditions in using the connection pool by multiple
|
|
+ * threads during ramp up.
|
|
+ */
|
|
+ apr_pool_create(&dns_pool, pool);
|
|
+ apr_pool_tag(dns_pool, "proxy_worker_dns");
|
|
/*
|
|
* Alloc from the same pool as worker.
|
|
* proxy_conn_pool is permanently attached to the worker.
|
|
*/
|
|
cp = (proxy_conn_pool *)apr_pcalloc(p, sizeof(proxy_conn_pool));
|
|
cp->pool = pool;
|
|
+ cp->dns_pool = dns_pool;
|
|
worker->cp = cp;
|
|
}
|
|
|
|
@@ -1487,14 +1500,6 @@ static apr_status_t connection_cleanup(void *theconn)
|
|
proxy_conn_rec *conn = (proxy_conn_rec *)theconn;
|
|
proxy_worker *worker = conn->worker;
|
|
|
|
- /*
|
|
- * If the connection pool is NULL the worker
|
|
- * cleanup has been run. Just return.
|
|
- */
|
|
- if (!worker->cp->pool) {
|
|
- return APR_SUCCESS;
|
|
- }
|
|
-
|
|
if (conn->r) {
|
|
apr_pool_destroy(conn->r->pool);
|
|
conn->r = NULL;
|
|
@@ -1616,7 +1621,7 @@ static apr_status_t connection_destructor(void *resource, void *params,
|
|
proxy_worker *worker = params;
|
|
|
|
/* Destroy the pool only if not called from reslist_destroy */
|
|
- if (worker->cp->pool) {
|
|
+ if (worker->cp) {
|
|
proxy_conn_rec *conn = resource;
|
|
apr_pool_destroy(conn->pool);
|
|
}
|
|
@@ -1972,67 +1977,73 @@ PROXY_DECLARE(apr_status_t) ap_proxy_initialize_worker(proxy_worker *worker, ser
|
|
ap_proxy_worker_name(p, worker));
|
|
}
|
|
else {
|
|
- ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00927)
|
|
- "initializing worker %s local",
|
|
- ap_proxy_worker_name(p, worker));
|
|
apr_global_mutex_lock(proxy_mutex);
|
|
- /* Now init local worker data */
|
|
- if (worker->tmutex == NULL) {
|
|
- rv = apr_thread_mutex_create(&(worker->tmutex), APR_THREAD_MUTEX_DEFAULT, p);
|
|
- if (rv != APR_SUCCESS) {
|
|
- ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, APLOGNO(00928)
|
|
- "can not create worker thread mutex");
|
|
+ /* Check again after we got the lock if we are still uninitialized */
|
|
+ if (!(AP_VOLATILIZE_T(unsigned int, worker->local_status) & PROXY_WORKER_INITIALIZED)) {
|
|
+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00927)
|
|
+ "initializing worker %s local",
|
|
+ ap_proxy_worker_name(p, worker));
|
|
+ /* Now init local worker data */
|
|
+#if APR_HAS_THREADS
|
|
+ if (worker->tmutex == NULL) {
|
|
+ rv = apr_thread_mutex_create(&(worker->tmutex), APR_THREAD_MUTEX_DEFAULT, p);
|
|
+ if (rv != APR_SUCCESS) {
|
|
+ ap_log_error(APLOG_MARK, APLOG_ERR, rv, s, APLOGNO(00928)
|
|
+ "can not create worker thread mutex");
|
|
+ apr_global_mutex_unlock(proxy_mutex);
|
|
+ return rv;
|
|
+ }
|
|
+ }
|
|
+#endif
|
|
+ if (worker->cp == NULL)
|
|
+ init_conn_pool(p, worker);
|
|
+ if (worker->cp == NULL) {
|
|
+ ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, APLOGNO(00929)
|
|
+ "can not create connection pool");
|
|
apr_global_mutex_unlock(proxy_mutex);
|
|
- return rv;
|
|
+ return APR_EGENERAL;
|
|
}
|
|
- }
|
|
- if (worker->cp == NULL)
|
|
- init_conn_pool(p, worker);
|
|
- if (worker->cp == NULL) {
|
|
- ap_log_error(APLOG_MARK, APLOG_ERR, 0, s, APLOGNO(00929)
|
|
- "can not create connection pool");
|
|
- apr_global_mutex_unlock(proxy_mutex);
|
|
- return APR_EGENERAL;
|
|
- }
|
|
|
|
- if (worker->s->hmax) {
|
|
- rv = apr_reslist_create(&(worker->cp->res),
|
|
- worker->s->min, worker->s->smax,
|
|
- worker->s->hmax, worker->s->ttl,
|
|
- connection_constructor, connection_destructor,
|
|
- worker, worker->cp->pool);
|
|
+ if (worker->s->hmax) {
|
|
+ rv = apr_reslist_create(&(worker->cp->res),
|
|
+ worker->s->min, worker->s->smax,
|
|
+ worker->s->hmax, worker->s->ttl,
|
|
+ connection_constructor, connection_destructor,
|
|
+ worker, worker->cp->pool);
|
|
|
|
- apr_pool_cleanup_register(worker->cp->pool, (void *)worker,
|
|
- conn_pool_cleanup,
|
|
- apr_pool_cleanup_null);
|
|
+ apr_pool_pre_cleanup_register(worker->cp->pool, worker,
|
|
+ conn_pool_cleanup);
|
|
|
|
- ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00930)
|
|
- "initialized pool in child %" APR_PID_T_FMT " for (%s) min=%d max=%d smax=%d",
|
|
- getpid(), worker->s->hostname_ex, worker->s->min,
|
|
- worker->s->hmax, worker->s->smax);
|
|
+ ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00930)
|
|
+ "initialized pool in child %" APR_PID_T_FMT " for (%s) min=%d max=%d smax=%d",
|
|
+ getpid(), worker->s->hostname_ex, worker->s->min,
|
|
+ worker->s->hmax, worker->s->smax);
|
|
|
|
- /* Set the acquire timeout */
|
|
- if (rv == APR_SUCCESS && worker->s->acquire_set) {
|
|
- apr_reslist_timeout_set(worker->cp->res, worker->s->acquire);
|
|
- }
|
|
+ /* Set the acquire timeout */
|
|
+ if (rv == APR_SUCCESS && worker->s->acquire_set) {
|
|
+ apr_reslist_timeout_set(worker->cp->res, worker->s->acquire);
|
|
+ }
|
|
|
|
- }
|
|
- else {
|
|
- void *conn;
|
|
+ }
|
|
+ else {
|
|
+ void *conn;
|
|
|
|
- rv = connection_constructor(&conn, worker, worker->cp->pool);
|
|
- worker->cp->conn = conn;
|
|
+ rv = connection_constructor(&conn, worker, worker->cp->pool);
|
|
+ worker->cp->conn = conn;
|
|
|
|
- ap_log_error(APLOG_MARK, APLOG_DEBUG, 0, s, APLOGNO(00931)
|
|
- "initialized single connection worker in child %" APR_PID_T_FMT " for (%s)",
|
|
- getpid(), worker->s->hostname_ex);
|
|
+ ap_log_error(APLOG_MARK, APLOG_DEBUG, rv, s, APLOGNO(00931)
|
|
+ "initialized single connection worker in child %" APR_PID_T_FMT " for (%s)",
|
|
+ getpid(), worker->s->hostname_ex);
|
|
+ }
|
|
+ if (rv == APR_SUCCESS) {
|
|
+ worker->local_status |= (PROXY_WORKER_INITIALIZED);
|
|
+ }
|
|
}
|
|
apr_global_mutex_unlock(proxy_mutex);
|
|
|
|
}
|
|
if (rv == APR_SUCCESS) {
|
|
worker->s->status |= (PROXY_WORKER_INITIALIZED);
|
|
- worker->local_status |= (PROXY_WORKER_INITIALIZED);
|
|
}
|
|
return rv;
|
|
}
|
|
@@ -2292,13 +2303,13 @@ PROXY_DECLARE(int) ap_proxy_acquire_connection(const char *proxy_function,
|
|
else {
|
|
/* create the new connection if the previous was destroyed */
|
|
if (!worker->cp->conn) {
|
|
- connection_constructor((void **)conn, worker, worker->cp->pool);
|
|
+ rv = connection_constructor((void **)conn, worker, worker->cp->pool);
|
|
}
|
|
else {
|
|
*conn = worker->cp->conn;
|
|
worker->cp->conn = NULL;
|
|
+ rv = APR_SUCCESS;
|
|
}
|
|
- rv = APR_SUCCESS;
|
|
}
|
|
|
|
if (rv != APR_SUCCESS) {
|
|
@@ -2344,7 +2355,9 @@ ap_proxy_determine_connection(apr_pool_t *p, request_rec *r,
|
|
{
|
|
int server_port;
|
|
apr_status_t err = APR_SUCCESS;
|
|
+#if APR_HAS_THREADS
|
|
apr_status_t uerr = APR_SUCCESS;
|
|
+#endif
|
|
const char *uds_path;
|
|
|
|
/*
|
|
@@ -2481,25 +2494,39 @@ ap_proxy_determine_connection(apr_pool_t *p, request_rec *r,
|
|
* we can reuse the address.
|
|
*/
|
|
if (!worker->cp->addr) {
|
|
+#if APR_HAS_THREADS
|
|
if ((err = PROXY_THREAD_LOCK(worker)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, err, r, APLOGNO(00945) "lock");
|
|
return HTTP_INTERNAL_SERVER_ERROR;
|
|
}
|
|
+#endif
|
|
|
|
/*
|
|
- * Worker can have the single constant backend address.
|
|
- * The single DNS lookup is used once per worker.
|
|
- * If dynamic change is needed then set the addr to NULL
|
|
- * inside dynamic config to force the lookup.
|
|
+ * Recheck addr after we got the lock. This may have changed
|
|
+ * while waiting for the lock.
|
|
*/
|
|
- err = apr_sockaddr_info_get(&(worker->cp->addr),
|
|
- conn->hostname, APR_UNSPEC,
|
|
- conn->port, 0,
|
|
- worker->cp->pool);
|
|
+ if (!AP_VOLATILIZE_T(apr_sockaddr_t *, worker->cp->addr)) {
|
|
+
|
|
+ apr_sockaddr_t *addr;
|
|
+
|
|
+ /*
|
|
+ * Worker can have the single constant backend address.
|
|
+ * The single DNS lookup is used once per worker.
|
|
+ * If dynamic change is needed then set the addr to NULL
|
|
+ * inside dynamic config to force the lookup.
|
|
+ */
|
|
+ err = apr_sockaddr_info_get(&addr,
|
|
+ conn->hostname, APR_UNSPEC,
|
|
+ conn->port, 0,
|
|
+ worker->cp->dns_pool);
|
|
+ worker->cp->addr = addr;
|
|
+ }
|
|
conn->addr = worker->cp->addr;
|
|
+#if APR_HAS_THREADS
|
|
if ((uerr = PROXY_THREAD_UNLOCK(worker)) != APR_SUCCESS) {
|
|
ap_log_rerror(APLOG_MARK, APLOG_ERR, uerr, r, APLOGNO(00946) "unlock");
|
|
}
|
|
+#endif
|
|
}
|
|
else {
|
|
conn->addr = worker->cp->addr;
|
|
@@ -3422,7 +3449,9 @@ PROXY_DECLARE(apr_status_t) ap_proxy_sync_balancer(proxy_balancer *b, server_rec
|
|
(*runtime)->cp = NULL;
|
|
(*runtime)->balancer = b;
|
|
(*runtime)->s = shm;
|
|
+#if APR_HAS_THREADS
|
|
(*runtime)->tmutex = NULL;
|
|
+#endif
|
|
rv = ap_proxy_initialize_worker(*runtime, s, conf->pool);
|
|
if (rv != APR_SUCCESS) {
|
|
ap_log_error(APLOG_MARK, APLOG_EMERG, rv, s, APLOGNO(00966) "Cannot init worker");
|