/* 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.
*/
/* * mod_example_ipc -- Apache sample module * * This module illustrates the use in an Apache 2.x module of the Interprocess * Communications routines that come with APR. It is example code, and not meant * to be used in a production server. * * To play with this sample module first compile it into a DSO file and install * it into Apache's modules directory by running: * * $ /path/to/apache2/bin/apxs -c -i mod_example_ipc.c * * Then activate it in Apache's httpd.conf file for instance for the URL * /example_ipc in as follows: * * # httpd.conf * LoadModule example_ipc_module modules/mod_example_ipc.so * <Location /example_ipc> * SetHandler example_ipc * </Location> * * Then restart Apache via * * $ /path/to/apache2/bin/apachectl restart * * The module allocates a counter in shared memory, which is incremented by the * request handler under a mutex. After installation, activate the handler by * hitting the URL configured above with ab at various concurrency levels to see * how mutex contention affects server performance.
*/
#define HTML_HEADER "\n\nMod_example_IPC Status Page "</span> \<br>
<span style='color:blue'>"\n\n\n
Mod_example_IPC Status
\n" #define HTML_FOOTER "\n\n"
/* Number of microseconds to camp out on the mutex */ #define CAMPOUT 10 /* Maximum number of times we camp out before giving up */ #define MAXCAMP 10 /* Number of microseconds the handler sits on the lock once acquired. */ #define SLEEPYTIME 1000
apr_shm_t *exipc_shm; /* Pointer to shared memory block */ char *shmfilename; /* Shared memory file name, used on some systems */
apr_global_mutex_t *exipc_mutex; /* Lock around shared memory segment access */ staticconstchar *exipc_mutex_type = "example-ipc-shm";
/* Data structure for shared memory block */ typedefstruct exipc_data {
apr_uint64_t counter; /* More fields if necessary */
} exipc_data;
/* * Clean up the shared memory block. This function is registered as * cleanup function for the configuration pool, which gets called * on restarts. It assures that the new children will not talk to a stale * shared memory segment.
*/ static apr_status_t shm_cleanup_wrapper(void *unused)
{ if (exipc_shm) return apr_shm_destroy(exipc_shm); return OK;
}
/* * This routine is called in the parent; we must register our * mutex type before the config is processed so that users can * adjust the mutex settings using the Mutex directive.
*/
/* * Do nothing if we are not creating the final configuration. * The parent process gets initialized a couple of times as the * server starts up, and we don't want to create any more mutexes * and shared memory segments than we're actually going to use.
*/ if (ap_state_query(AP_SQ_MAIN_STATE) == AP_SQ_MS_CREATE_PRE_CONFIG) return OK;
/* * The shared memory allocation routines take a file name. * Depending on system-specific implementation of these * routines, that file may or may not actually be created. We'd * like to store those files in the operating system's designated * temporary directory, which APR can point us to.
*/
rs = apr_temp_dir_get(&tempdir, pconf); if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, APLOGNO(02992) "Failed to find temporary directory"); return HTTP_INTERNAL_SERVER_ERROR;
}
/* Create the shared memory segment */
/* * Create a unique filename using our pid. This information is * stashed in the global variable so the children inherit it.
*/
shmfilename = apr_psprintf(pconf, "%s/httpd_shm.%ld", tempdir,
(longint)getpid());
/* Now create that segment */
rs = apr_shm_create(&exipc_shm, sizeof(exipc_data),
(constchar *) shmfilename, pconf); if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, APLOGNO(02993) "Failed to create shared memory segment on file %s",
shmfilename); return HTTP_INTERNAL_SERVER_ERROR;
}
/* Created it, now let's zero it out */
base = (exipc_data *)apr_shm_baseaddr_get(exipc_shm);
base->counter = 0;
/* * Destroy the shm segment when the configuration pool gets destroyed. This * happens on server restarts. The parent will then (above) allocate a new * shm segment that the new children will bind to.
*/
apr_pool_cleanup_register(pconf, NULL, shm_cleanup_wrapper,
apr_pool_cleanup_null); return OK;
}
/* * This routine gets called when a child inits. We use it to attach * to the shared memory segment, and reinitialize the mutex.
*/
/* * Re-open the mutex for the child. Note we're reusing * the mutex pointer global here.
*/
rs = apr_global_mutex_child_init(&exipc_mutex,
apr_global_mutex_lockfile(exipc_mutex),
p); if (APR_SUCCESS != rs) {
ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s, APLOGNO(02994) "Failed to reopen mutex %s in child",
exipc_mutex_type); /* There's really nothing else we can do here, since This * routine doesn't return a status. If this ever goes wrong, * it will turn Apache into a fork bomb. Let's hope it never * will.
*/ exit(1); /* Ugly, but what else? */
}
}
/* The sample content handler */ staticint exipc_handler(request_rec *r)
{ int gotlock = 0; int camped;
apr_time_t startcamp;
apr_int64_t timecamped;
apr_status_t rs;
exipc_data *base;
if (strcmp(r->handler, "example_ipc")) { return DECLINED;
}
/* * The main function of the handler, aside from sending the * status page to the client, is to increment the counter in * the shared memory segment. This action needs to be mutexed * out using the global mutex.
*/
/* * First, acquire the lock. This code is a lot more involved than * it usually needs to be, because the process based trylock * routine is not implemented on unix platforms. I left it in to * show how it would work if trylock worked, and for situations * and platforms where trylock works.
*/ for (camped = 0, timecamped = 0; camped < MAXCAMP; camped++) {
rs = apr_global_mutex_trylock(exipc_mutex); if (APR_STATUS_IS_EBUSY(rs)) {
apr_sleep(CAMPOUT);
} elseif (APR_SUCCESS == rs) {
gotlock = 1; break; /* Get out of the loop */
} elseif (APR_STATUS_IS_ENOTIMPL(rs)) { /* If it's not implemented, just hang in the mutex. */
startcamp = apr_time_now();
rs = apr_global_mutex_lock(exipc_mutex);
timecamped = (apr_int64_t) (apr_time_now() - startcamp); if (APR_SUCCESS == rs) {
gotlock = 1; break; /* Out of the loop */
} else { /* Some error, log and bail */
ap_log_error(APLOG_MARK, APLOG_ERR, rs, r->server, APLOGNO(02995) "Child %ld failed to acquire lock",
(longint)getpid()); break; /* Out of the loop without having the lock */
}
} else { /* Some other error, log and bail */
ap_log_error(APLOG_MARK, APLOG_ERR, rs, r->server, APLOGNO(02996) "Child %ld failed to try and acquire lock",
(longint)getpid()); break; /* Out of the loop without having the lock */
}
/* * The only way to get to this point is if the trylock worked * and returned BUSY. So, bump the time and try again
*/
timecamped += CAMPOUT;
ap_log_error(APLOG_MARK, APLOG_NOTICE, 0, r->server, APLOGNO(03187) "Child %ld camping out on mutex for %" APR_INT64_T_FMT " microseconds",
(longint) getpid(), timecamped);
} /* Lock acquisition loop */
/* Sleep for a millisecond to make it a little harder for * httpd children to acquire the lock.
*/
apr_sleep(SLEEPYTIME);
r->content_type = "text/html";
if (!r->header_only) {
ap_rputs(HTML_HEADER, r); if (gotlock) { /* Increment the counter */
base = (exipc_data *)apr_shm_baseaddr_get(exipc_shm);
base->counter++; /* Send a page with our pid and the new value of the counter. */
ap_rprintf(r, "
Lock acquired after %ld microseoncds.
\n",
(longint) timecamped);
ap_rputs("
1\">\n", r);
ap_rprintf(r, "
Child pid:
%d
\n",
(int) getpid());
ap_rprintf(r, "
Counter:
%u
\n",
(unsignedint)base->counter);
ap_rputs("
\n", r);
} else { /* * Send a page saying that we couldn't get the lock. Don't say * what the counter is, because without the lock the value could * race.
*/
ap_rprintf(r, "
Child %d failed to acquire lock "
"after camping out for %d microseconds.\n",
(int) getpid(), (int) timecamped);
}
ap_rputs(HTML_FOOTER, r);
} /* r->header_only */
/* Release the lock */ if (gotlock)
rs = apr_global_mutex_unlock(exipc_mutex); /* Swallowing the result because what are we going to do with it at * this stage?
*/
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
