summaryrefslogtreecommitdiffstats
path: root/modules/examples/mod_example_ipc.c
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 06:33:50 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 06:33:50 +0000
commitfe39ffb8b90ae4e002ed73fe98617cd590abb467 (patch)
treeb80e5956907d8aeaaffe4e4f0c068c0e6157ce8b /modules/examples/mod_example_ipc.c
parentInitial commit. (diff)
downloadapache2-fe39ffb8b90ae4e002ed73fe98617cd590abb467.tar.xz
apache2-fe39ffb8b90ae4e002ed73fe98617cd590abb467.zip
Adding upstream version 2.4.56.upstream/2.4.56
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'modules/examples/mod_example_ipc.c')
-rw-r--r--modules/examples/mod_example_ipc.c356
1 files changed, 356 insertions, 0 deletions
diff --git a/modules/examples/mod_example_ipc.c b/modules/examples/mod_example_ipc.c
new file mode 100644
index 0000000..6f48a84
--- /dev/null
+++ b/modules/examples/mod_example_ipc.c
@@ -0,0 +1,356 @@
+/* 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_core.h"
+#include "http_log.h"
+#include "http_protocol.h"
+#include "util_mutex.h"
+#include "ap_config.h"
+
+#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 */
+static const char *exipc_mutex_type = "example-ipc-shm";
+
+/* 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; we must register our
+ * mutex type before the config is processed so that users can
+ * adjust the mutex settings using the Mutex directive.
+ */
+
+static int exipc_pre_config(apr_pool_t *pconf, apr_pool_t *plog,
+ apr_pool_t *ptemp)
+{
+ ap_mutex_register(pconf, exipc_mutex_type, NULL, APR_LOCK_DEFAULT, 0);
+ 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)
+{
+ apr_status_t rs;
+ exipc_data *base;
+ const char *tempdir;
+
+
+ /*
+ * 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,
+ (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, 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;
+
+ /* Create global mutex */
+
+ rs = ap_global_mutex_create(&exipc_mutex, NULL, exipc_mutex_type, NULL,
+ s, pconf, 0);
+ if (APR_SUCCESS != rs) {
+ return HTTP_INTERNAL_SERVER_ERROR;
+ }
+
+ /*
+ * 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,
+ 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 */
+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, APLOGNO(02995)
+ "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, APLOGNO(02996)
+ "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_NOTICE, 0, r->server, APLOGNO(03187)
+ "Child %ld camping out on mutex for %" APR_INT64_T_FMT
+ " 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_pre_config(exipc_pre_config, NULL, NULL, APR_HOOK_MIDDLE);
+ 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 */
+AP_DECLARE_MODULE(example_ipc) = {
+ 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 */
+};
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-18 12:39:17 +0000