diff options
| author | Sander Temme <sctemme@apache.org> | 2007-11-18 16:41:03 +0100 |
|---|---|---|
| committer | Sander Temme <sctemme@apache.org> | 2007-11-18 16:41:03 +0100 |
| commit | df96b77cf2c5b0a70aeb6b24ea0dff6faec35efc (patch) | |
| tree | 72eea2e4e354262b483aa5da62eb73e3c55c45b2 /modules/examples/mod_example_ipc.c | |
| parent | Update transformations (diff) | |
| download | apache2-df96b77cf2c5b0a70aeb6b24ea0dff6faec35efc.tar.xz apache2-df96b77cf2c5b0a70aeb6b24ea0dff6faec35efc.zip | |
* Move the Example modules to the newly created examples subdirectory
* Hopefully correctly fudge the NWGNU make files
* Add mod_example_ipc (without NWGNU stuff or dsp)
git-svn-id: https://svn.apache.org/repos/asf/httpd/httpd/trunk@596093 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'modules/examples/mod_example_ipc.c')
| -rw-r--r-- | modules/examples/mod_example_ipc.c | 385 |
1 files changed, 385 insertions, 0 deletions
diff --git a/modules/examples/mod_example_ipc.c b/modules/examples/mod_example_ipc.c new file mode 100644 index 0000000000..7340cb7b0f --- /dev/null +++ b/modules/examples/mod_example_ipc.c @@ -0,0 +1,385 @@ +/* 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. + */ + +#include "apr.h" +#include "apr_strings.h" + +#include "httpd.h" +#include "http_config.h" +#include "http_log.h" +#include "http_protocol.h" +#include "ap_config.h" + +#if !defined(OS2) && !defined(WIN32) && !defined(BEOS) && !defined(NETWARE) +#include "unixd.h" +#define MOD_EXIPC_SET_MUTEX_PERMS /* XXX Apache should define something */ +#endif + +#if APR_HAVE_SYS_TYPES_H +#include <sys/types.h> +#endif +#if APR_HAVE_UNISTD_H +#include <unistd.h> +#endif + +#define HTML_HEADER "<html>\n<head>\n<title>Mod_example_IPC Status Page " \ + "</title>\n</head>\n<body>\n<h1>Mod_example_IPC Status</h1>\n" +#define HTML_FOOTER "</body>\n</html>\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 */ +char *mutexfilename; /* Lock file name, used on some systems */ + +/* Data structure for shared memory block */ +typedef struct 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, so we'll set up the shared + * memory segment and mutex here. + */ + +static int exipc_post_config(apr_pool_t *pconf, apr_pool_t *plog, + apr_pool_t *ptemp, server_rec *s) +{ + void *data; /* These two help ensure that we only init once. */ + const char *userdata_key; + apr_status_t rs; + exipc_data *base; + const char *tempdir; + + + /* + * The following checks if this routine has been called before. + * This is necessary because 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. + * + * The key needs to be unique for the entire web server, so put + * the module name in it. + */ + userdata_key = "example_ipc_init_module"; + apr_pool_userdata_get(&data, userdata_key, s->process->pool); + if (!data) { + /* + * If no data was found for our key, this must be the first + * time the module is initialized. Put some data under that + * key and return. + */ + apr_pool_userdata_set((const void *) 1, userdata_key, + apr_pool_cleanup_null, s->process->pool); + return OK; + } /* Kilroy was here */ + + /* + * Both the shared memory and mutex 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, + "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, + (long int)getpid()); + + /* Now create that segment */ + rs = apr_shm_create(&exipc_shm, sizeof(exipc_data), + (const char *) shmfilename, pconf); + if (APR_SUCCESS != rs) { + ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, + "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; + + /* Create global mutex */ + + /* + * Create another unique filename to lock upon. Note that + * depending on OS and locking mechanism of choice, the file + * may or may not be actually created. + */ + mutexfilename = apr_psprintf(pconf, "%s/httpd_mutex.%ld", tempdir, + (long int) getpid()); + + rs = apr_global_mutex_create(&exipc_mutex, (const char *) mutexfilename, + APR_LOCK_DEFAULT, pconf); + if (APR_SUCCESS != rs) { + ap_log_error(APLOG_MARK, APLOG_ERR, rs, s, + "Failed to create mutex on file %s", + mutexfilename); + return HTTP_INTERNAL_SERVER_ERROR; + } + + /* + * After the mutex is created, its permissions need to be adjusted + * on unix platforms so that the child processe can acquire + * it. This call takes care of that. The preprocessor define was + * set up early in this source file since Apache doesn't provide + * it. + */ +#ifdef MOD_EXIPC_SET_MUTEX_PERMS + rs = unixd_set_global_mutex_perms(exipc_mutex); + if (APR_SUCCESS != rs) { + ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s, + "Parent could not set permissions on Example IPC " + "mutex: check User and Group directives"); + return HTTP_INTERNAL_SERVER_ERROR; + } +#endif /* MOD_EXIPC_SET_MUTEX_PERMS */ + + /* + * 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. + */ + +static void exipc_child_init(apr_pool_t *p, server_rec *s) +{ + apr_status_t rs; + + /* + * Re-open the mutex for the child. Note we're reusing + * the mutex pointer global here. + */ + rs = apr_global_mutex_child_init(&exipc_mutex, + (const char *) mutexfilename, + p); + if (APR_SUCCESS != rs) { + ap_log_error(APLOG_MARK, APLOG_CRIT, rs, s, + "Failed to reopen mutex on file %s", + shmfilename); + /* 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 */ +static int 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); + } else if (APR_SUCCESS == rs) { + gotlock = 1; + break; /* Get out of the loop */ + } else if (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, + "Child %ld failed to acquire lock", + (long int)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, + "Child %ld failed to try and acquire lock", + (long int)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_NOERRNO | APLOG_NOTICE, + 0, r->server, "Child %ld camping out on mutex for %d " + "microseconds", + (long int) 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, "<p>Lock acquired after %ld microseoncds.</p>\n", + (long int) timecamped); + ap_rputs("<table border=\"1\">\n", r); + ap_rprintf(r, "<tr><td>Child pid:</td><td>%d</td></tr>\n", + (int) getpid()); + ap_rprintf(r, "<tr><td>Counter:</td><td>%u</td></tr>\n", + (unsigned int)base->counter); + ap_rputs("</table>\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, "<p>Child %d failed to acquire lock " + "after camping out for %d microseconds.</p>\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? + */ + + return OK; +} + +static void exipc_register_hooks(apr_pool_t *p) +{ + ap_hook_post_config(exipc_post_config, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_child_init(exipc_child_init, NULL, NULL, APR_HOOK_MIDDLE); + ap_hook_handler(exipc_handler, NULL, NULL, APR_HOOK_MIDDLE); +} + +/* Dispatch list for API hooks */ +module AP_MODULE_DECLARE_DATA example_ipc_module = { + STANDARD20_MODULE_STUFF, + NULL, /* create per-dir config structures */ + NULL, /* merge per-dir config structures */ + NULL, /* create per-server config structures */ + NULL, /* merge per-server config structures */ + NULL, /* table of config file commands */ + exipc_register_hooks /* register hooks */ +}; + |