Below is the patch to implement AcceptMutex and SingleListen as
runtime parameters. There is still a little lint to work through, but
this is the implementation (eg: it would be nice to print/log the
settings).
Comments are welcome... I'd like to commit the patch this week. At
that point, we port to 2.0, which already has a lot of the
work done (just need to do the default stuff and handle SingleListen)
Cheers!
Index: src/include/ap_config.h
===================================================================
RCS file: /home/cvs/apache-1.3/src/include/ap_config.h,v
retrieving revision 1.309
diff -u -r1.309 ap_config.h
--- src/include/ap_config.h 2001/06/22 12:43:53 1.309
+++ src/include/ap_config.h 2001/08/20 18:19:42
@@ -179,10 +179,10 @@
#define NO_KILLPG
#undef NO_SETSID
#define bzero(a,b) memset(a,0,b)
-#if !defined(USE_SYSVSEM_SERIALIZED_ACCEPT) && \
- !defined(USE_PTHREAD_SERIALIZED_ACCEPT)
+#define USE_SYSVSEM_SERIALIZED_ACCEPT
+#define USE_PTHREAD_SERIALIZED_ACCEPT
#define USE_FCNTL_SERIALIZED_ACCEPT
-#endif
+#define DEFAULT_SERIALIZED_ACCEPT_METHOD fcntl
#define NEED_UNION_SEMUN
#define HAVE_MMAP 1
#define USE_MMAP_SCOREBOARD
@@ -433,6 +433,9 @@
#define JMP_BUF jmp_buf
#define USE_LONGJMP
#define USE_FLOCK_SERIALIZED_ACCEPT
+#define USE_FCNTL_SERIALIZED_ACCEPT
+#define USE_NONE_SERIALIZED_ACCEPT
+#define DEFAULT_SERIALIZED_ACCEPT_METHOD flock
#define SINGLE_LISTEN_UNSERIALIZED_ACCEPT
#elif defined(LINUX)
Index: src/include/http_main.h
===================================================================
RCS file: /home/cvs/apache-1.3/src/include/http_main.h,v
retrieving revision 1.36
diff -u -r1.36 http_main.h
--- src/include/http_main.h 2001/01/15 17:04:34 1.36
+++ src/include/http_main.h 2001/08/20 18:19:42
@@ -130,6 +130,11 @@
void setup_signal_names(char *prefix);
+/* functions for determination and setting of accept() mutexing */
+char *default_mutex_method(void);
+char *init_mutex_method(char *t);
+char *init_single_listen(int flag);
+
#ifndef NO_OTHER_CHILD
/*
* register an other_child -- a child which the main loop keeps track of
Index: src/main/http_core.c
===================================================================
RCS file: /home/cvs/apache-1.3/src/main/http_core.c,v
retrieving revision 1.296
diff -u -r1.296 http_core.c
--- src/main/http_core.c 2001/07/13 07:32:44 1.296
+++ src/main/http_core.c 2001/08/20 18:19:51
@@ -1135,6 +1135,14 @@
}
return NULL;
}
+static const char *set_accept_mutex(cmd_parms *cmd, void *dummy, char *arg)
+{
+ return init_mutex_method(arg);
+}
+static const char *set_single_listen(cmd_parms *cmd, void *dummy, int flag)
+{
+ return init_single_listen(flag ? 1 : 0);
+}
static const char *set_document_root(cmd_parms *cmd, void *dummy, char *arg)
{
@@ -3215,6 +3223,37 @@
(void*)XtOffsetOf(core_dir_config, limit_req_body),
OR_ALL, TAKE1,
"Limit (in bytes) on maximum size of request message body" },
+{ "AcceptMutex", set_accept_mutex, NULL, RSRC_CONF, TAKE1,
+ "Serialized Accept Mutex; the methods "
+#ifdef USE_FCNTL_SERIALIZED_ACCEPT
+ "'fcntl' "
+#endif
+#ifdef USE_FLOCK_SERIALIZED_ACCEPT
+ "'flock' "
+#endif
+#ifdef USE_USLOCK_SERIALIZED_ACCEPT
+ "'uslock "
+#endif
+#ifdef USE_SYSVSEM_SERIALIZED_ACCEPT
+ "'sysvsem' "
+#endif
+#ifdef USE_PTHREAD_SERIALIZED_ACCEPT
+ "'pthread' "
+#endif
+#ifdef USE_OS2SEM_SERIALIZED_ACCEPT
+ "'os2sem' "
+#endif
+#ifdef USE_TPF_CORE_SERIALIZED_ACCEPT
+ "'tpfcore' "
+#endif
+#ifdef USE_NONE_SERIALIZED_ACCEPT
+ "'none' "
+#endif
+ "are compiled in"
+},
+{ "SingleListen",set_single_listen,NULL,RSRC_CONF,FLAG,
+ "On - to serialize accept and Off to unserialize accept"
+},
/* EBCDIC Conversion directives: */
#ifdef CHARSET_EBCDIC
Index: src/main/http_main.c
===================================================================
RCS file: /home/cvs/apache-1.3/src/main/http_main.c,v
retrieving revision 1.546
diff -u -r1.546 http_main.c
--- src/main/http_main.c 2001/08/10 01:14:29 1.546
+++ src/main/http_main.c 2001/08/20 18:20:05
@@ -258,6 +258,17 @@
time_t ap_restart_time=0;
API_VAR_EXPORT int ap_suexec_enabled = 0;
int ap_listenbacklog=0;
+/* On some architectures it's safe to do unserialized accept()s in the single
+ * Listen case. But it's never safe to do it in the case where there's
+ * multiple Listen statements. Define SINGLE_LISTEN_UNSERIALIZED_ACCEPT
+ * when it's safe in the single Listen case.
+ */
+#ifdef SINGLE_LISTEN_UNSERIALIZED_ACCEPT
+int ap_single_listen = 1;
+#else
+int ap_single_listen = 0;
+#endif
+
#ifdef SO_ACCEPTFILTER
int ap_acceptfilter =
#ifdef AP_ACCEPTFILTER_OFF
@@ -513,14 +524,12 @@
#endif
#if defined (USE_USLOCK_SERIALIZED_ACCEPT)
-
#include <ulocks.h>
-
static ulock_t uslock = NULL;
-#define accept_mutex_child_init(x)
+#define accept_mutex_child_init_uslock(x)
-static void accept_mutex_init(pool *p)
+static void accept_mutex_init_uslock(pool *p)
{
ptrdiff_t old;
usptr_t *us;
@@ -551,7 +560,7 @@
}
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_uslock(void)
{
switch (ussetlock(uslock)) {
case 1:
@@ -566,15 +575,16 @@
}
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_uslock(void)
{
if (usunsetlock(uslock) == -1) {
perror("usunsetlock");
clean_child_exit(APEXIT_CHILDFATAL);
}
}
+#endif
-#elif defined (USE_PTHREAD_SERIALIZED_ACCEPT)
+#if defined (USE_PTHREAD_SERIALIZED_ACCEPT)
/* This code probably only works on Solaris ... but it works really fast
* on Solaris. Note that pthread mutexes are *NOT* released when a task
@@ -589,7 +599,7 @@
static sigset_t accept_block_mask;
static sigset_t accept_previous_mask;
-static void accept_mutex_child_cleanup(void *foo)
+static void accept_mutex_child_cleanup_pthread(void *foo)
{
if (accept_mutex != (void *)(caddr_t)-1
&& have_accept_mutex) {
@@ -597,12 +607,12 @@
}
}
-static void accept_mutex_child_init(pool *p)
+static void accept_mutex_child_init_pthread(pool *p)
{
- ap_register_cleanup(p, NULL, accept_mutex_child_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_child_cleanup_pthread, ap_null_cleanup);
}
-static void accept_mutex_cleanup(void *foo)
+static void accept_mutex_cleanup_pthread(void *foo)
{
if (accept_mutex != (void *)(caddr_t)-1
&& munmap((caddr_t) accept_mutex, sizeof(*accept_mutex))) {
@@ -611,7 +621,7 @@
accept_mutex = (void *)(caddr_t)-1;
}
-static void accept_mutex_init(pool *p)
+static void accept_mutex_init_pthread(pool *p)
{
pthread_mutexattr_t mattr;
int fd;
@@ -645,10 +655,10 @@
sigdelset(&accept_block_mask, SIGHUP);
sigdelset(&accept_block_mask, SIGTERM);
sigdelset(&accept_block_mask, SIGUSR1);
- ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_cleanup_pthread, ap_null_cleanup);
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_pthread(void)
{
int err;
@@ -670,7 +680,7 @@
ap_unblock_alarms();
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_pthread(void)
{
int err;
@@ -691,8 +701,9 @@
clean_child_exit(1);
}
}
+#endif
-#elif defined (USE_SYSVSEM_SERIALIZED_ACCEPT)
+#if defined (USE_SYSVSEM_SERIALIZED_ACCEPT)
#include <sys/types.h>
#include <sys/ipc.h>
@@ -716,7 +727,7 @@
* means we have to be sure to clean this up or else we'll leak
* semaphores.
*/
-static void accept_mutex_cleanup(void *foo)
+static void accept_mutex_cleanup_sysvsem(void *foo)
{
union semun ick;
@@ -727,9 +738,9 @@
semctl(sem_id, 0, IPC_RMID, ick);
}
-#define accept_mutex_child_init(x)
+#define accept_mutex_child_init_sysvsem(x)
-static void accept_mutex_init(pool *p)
+static void accept_mutex_init_sysvsem(pool *p)
{
union semun ick;
struct semid_ds buf;
@@ -758,7 +769,7 @@
exit(APEXIT_INIT);
}
}
- ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_cleanup_sysvsem, ap_null_cleanup);
/* pre-initialize these */
op_on.sem_num = 0;
@@ -769,7 +780,7 @@
op_off.sem_flg = SEM_UNDO;
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_sysvsem(void)
{
while (semop(sem_id, &op_on, 1) < 0) {
if (errno != EINTR) {
@@ -779,7 +790,7 @@
}
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_sysvsem(void)
{
while (semop(sem_id, &op_off, 1) < 0) {
if (errno != EINTR) {
@@ -788,20 +799,21 @@
}
}
}
+#endif
-#elif defined(USE_FCNTL_SERIALIZED_ACCEPT)
+#if defined(USE_FCNTL_SERIALIZED_ACCEPT)
static struct flock lock_it;
static struct flock unlock_it;
static int lock_fd = -1;
-#define accept_mutex_child_init(x)
+#define accept_mutex_child_init_fcntl(x)
/*
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(pool *p)
+static void accept_mutex_init_fcntl(pool *p)
{
lock_it.l_whence = SEEK_SET; /* from current point */
@@ -825,7 +837,7 @@
unlink(ap_lock_fname);
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_fcntl(void)
{
int ret;
@@ -842,7 +854,7 @@
}
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_fcntl(void)
{
int ret;
@@ -857,12 +869,13 @@
clean_child_exit(APEXIT_CHILDFATAL);
}
}
+#endif
-#elif defined(USE_FLOCK_SERIALIZED_ACCEPT)
+#if defined(USE_FLOCK_SERIALIZED_ACCEPT)
-static int lock_fd = -1;
+static int flock_fd = -1;
-static void accept_mutex_cleanup(void *foo)
+static void accept_mutex_cleanup_flock(void *foo)
{
unlink(ap_lock_fname);
}
@@ -871,11 +884,11 @@
* Initialize mutex lock.
* Done by each child at it's birth
*/
-static void accept_mutex_child_init(pool *p)
+static void accept_mutex_child_init_flock(pool *p)
{
- lock_fd = ap_popenf(p, ap_lock_fname, O_WRONLY, 0600);
- if (lock_fd == -1) {
+ flock_fd = ap_popenf(p, ap_lock_fname, O_WRONLY, 0600);
+ if (flock_fd == -1) {
ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
"Child cannot open lock file: %s", ap_lock_fname);
clean_child_exit(APEXIT_CHILDINIT);
@@ -886,24 +899,24 @@
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(pool *p)
+static void accept_mutex_init_flock(pool *p)
{
expand_lock_fname(p);
unlink(ap_lock_fname);
- lock_fd = ap_popenf(p, ap_lock_fname, O_CREAT | O_WRONLY | O_EXCL, 0600);
- if (lock_fd == -1) {
+ flock_fd = ap_popenf(p, ap_lock_fname, O_CREAT | O_WRONLY | O_EXCL, 0600);
+ if (flock_fd == -1) {
ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
"Parent cannot open lock file: %s", ap_lock_fname);
exit(APEXIT_INIT);
}
- ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_cleanup_flock, ap_null_cleanup);
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_flock(void)
{
int ret;
- while ((ret = flock(lock_fd, LOCK_EX)) < 0 && errno == EINTR)
+ while ((ret = flock(flock_fd, LOCK_EX)) < 0 && errno == EINTR)
continue;
if (ret < 0) {
@@ -913,20 +926,21 @@
}
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_flock(void)
{
- if (flock(lock_fd, LOCK_UN) < 0) {
+ if (flock(flock_fd, LOCK_UN) < 0) {
ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
"flock: LOCK_UN: Error freeing accept lock. Exiting!");
clean_child_exit(APEXIT_CHILDFATAL);
}
}
+#endif
-#elif defined(USE_OS2SEM_SERIALIZED_ACCEPT)
+#if defined(USE_OS2SEM_SERIALIZED_ACCEPT)
static HMTX lock_sem = -1;
-static void accept_mutex_cleanup(void *foo)
+static void accept_mutex_cleanup_os2sem(void *foo)
{
DosReleaseMutexSem(lock_sem);
DosCloseMutexSem(lock_sem);
@@ -936,7 +950,7 @@
* Initialize mutex lock.
* Done by each child at it's birth
*/
-static void accept_mutex_child_init(pool *p)
+static void accept_mutex_child_init_os2sem(pool *p)
{
int rc = DosOpenMutexSem(NULL, &lock_sem);
@@ -945,7 +959,7 @@
"Child cannot open lock semaphore, rc=%d", rc);
clean_child_exit(APEXIT_CHILDINIT);
} else {
- ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_cleanup_os2sem, ap_null_cleanup);
}
}
@@ -953,7 +967,7 @@
* Initialize mutex lock.
* Must be safe to call this on a restart.
*/
-static void accept_mutex_init(pool *p)
+static void accept_mutex_init_os2sem(pool *p)
{
int rc = DosCreateMutexSem(NULL, &lock_sem, DC_SEM_SHARED, FALSE);
@@ -963,10 +977,10 @@
exit(APEXIT_INIT);
}
- ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_cleanup_os2sem, ap_null_cleanup);
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_os2sem(void)
{
int rc = DosRequestMutexSem(lock_sem, SEM_INDEFINITE_WAIT);
@@ -977,7 +991,7 @@
}
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_os2sem(void)
{
int rc = DosReleaseMutexSem(lock_sem);
@@ -987,65 +1001,204 @@
clean_child_exit(APEXIT_CHILDFATAL);
}
}
+#endif
-#elif defined(USE_TPF_CORE_SERIALIZED_ACCEPT)
+#if defined(USE_TPF_CORE_SERIALIZED_ACCEPT)
static int tpf_core_held;
-static void accept_mutex_cleanup(void *foo)
+static void accept_mutex_cleanup_tpfcore(void *foo)
{
if(tpf_core_held)
coruc(RESOURCE_KEY);
}
-#define accept_mutex_init(x)
+#define accept_mutex_init_tpfcore(x)
-static void accept_mutex_child_init(pool *p)
+static void accept_mutex_child_init_tpfcore(pool *p)
{
- ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
+ ap_register_cleanup(p, NULL, accept_mutex_cleanup_tpfcore, ap_null_cleanup);
tpf_core_held = 0;
}
-static void accept_mutex_on(void)
+static void accept_mutex_on_tpfcore(void)
{
corhc(RESOURCE_KEY);
tpf_core_held = 1;
ap_check_signals();
}
-static void accept_mutex_off(void)
+static void accept_mutex_off_tpfcore(void)
{
coruc(RESOURCE_KEY);
tpf_core_held = 0;
ap_check_signals();
}
+#endif
-#else
-/* Default --- no serialization. Other methods *could* go here,
- * as #elifs...
- */
#if !defined(MULTITHREAD)
/* Multithreaded systems don't complete between processes for
* the sockets. */
#define NO_SERIALIZED_ACCEPT
-#define accept_mutex_child_init(x)
-#define accept_mutex_init(x)
-#define accept_mutex_on()
-#define accept_mutex_off()
+#define USE_NONE_CORE_SERIALIZED_ACCEPT
+/* The below are actually not-needed, but are here for completeness.
+ * We take care of this in USE_NONE_CORE_SERIALIZED_ACCEPT */
+#define accept_mutex_child_init_none(x)
+#define accept_mutex_init_none(x)
+#define accept_mutex_on_none()
+#define accept_mutex_off_none()
+#endif
+
+void (*accept_mutex_child_init_fptr)(pool *);
+void (*accept_mutex_init_fptr)(pool *);
+void (*accept_mutex_off_fptr)(void);
+void (*accept_mutex_on_fptr)(void);
+
+#define AP_FPTR1(x,y) { if (x) ((* x)(y)); }
+#define AP_FPTR0(x) { if (x) ((* x)()); }
+
+#define accept_mutex_child_init(x) AP_FPTR1(accept_mutex_child_init_fptr,x)
+#define accept_mutex_init(x) AP_FPTR1(accept_mutex_init_fptr,x)
+#define accept_mutex_off() AP_FPTR0(accept_mutex_off_fptr)
+#define accept_mutex_on() AP_FPTR0(accept_mutex_on_fptr)
+
+char *default_mutex_method(void)
+{
+ char *t;
+#if defined DEFAULT_SERIALIZED_ACCEPT_METHOD
+ t = "DEFAULT_SERIALIZED_ACCEPT_METHOD";
+#else
+ t = "default";
#endif
+#if defined USE_USLOCK_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"uslock")))) {
+ return "uslock";
+ } else
+#endif
+#if defined USE_PTHREAD_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"pthread")))) {
+ return "pthread";
+ } else
+#endif
+#if defined USE_SYSVSEM_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"sysvsem")))) {
+ return "sysvmem";
+ } else
+#endif
+#if defined USE_FCNTL_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"fcntl")))) {
+ return "fcntl";
+ } else
+#endif
+#if defined USE_FLOCK_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"flock")))) {
+ return "flock";
+ } else
+#endif
+#if defined USE_OS2SEM_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"os2sem")))) {
+ return "os2sem";
+ } else
+#endif
+#if defined USE_TPF_CORE_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"tpfcore")))) {
+ return "tpfcore";
+ } else
+#endif
+#if defined USE_NONE_CORE_SERIALIZED_ACCEPT
+ if ((!(strcasecmp(t,"default"))) || (!(strcasecmp(t,"none")))) {
+ return "none";
+ } else
#endif
+ return "Request serialized accept method not available";
+
+ return NULL;
+}
-/* On some architectures it's safe to do unserialized accept()s in the single
- * Listen case. But it's never safe to do it in the case where there's
- * multiple Listen statements. Define SINGLE_LISTEN_UNSERIALIZED_ACCEPT
- * when it's safe in the single Listen case.
- */
+char *init_mutex_method(char *t)
+{
+#if defined USE_USLOCK_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"uslock"))) {
+ accept_mutex_child_init_fptr = NULL;
+ accept_mutex_init_fptr = &accept_mutex_init_uslock;
+ accept_mutex_off_fptr = &accept_mutex_off_uslock;
+ accept_mutex_on_fptr = &accept_mutex_on_uslock;
+ } else
+#endif
+#if defined USE_PTHREAD_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"pthread"))) {
+ accept_mutex_child_init_fptr = &accept_mutex_child_init_pthread;
+ accept_mutex_init_fptr = &accept_mutex_init_pthread;
+ accept_mutex_off_fptr = &accept_mutex_off_pthread;
+ accept_mutex_on_fptr = &accept_mutex_on_pthread;
+ } else
+#endif
+#if defined USE_SYSVSEM_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"sysvsem"))) {
+ accept_mutex_child_init_fptr = NULL;
+ accept_mutex_init_fptr = &accept_mutex_init_sysvsem;
+ accept_mutex_off_fptr = &accept_mutex_off_sysvsem;
+ accept_mutex_on_fptr = &accept_mutex_on_sysvsem;
+ } else
+#endif
+#if defined USE_FCNTL_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"fcntl"))) {
+ accept_mutex_child_init_fptr = NULL;
+ accept_mutex_init_fptr = &accept_mutex_init_fcntl;
+ accept_mutex_off_fptr = &accept_mutex_off_fcntl;
+ accept_mutex_on_fptr = &accept_mutex_on_fcntl;
+ } else
+#endif
+#if defined USE_FLOCK_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"flock"))) {
+ accept_mutex_child_init_fptr = &accept_mutex_child_init_flock;
+ accept_mutex_init_fptr = &accept_mutex_init_flock;
+ accept_mutex_off_fptr = &accept_mutex_off_flock;
+ accept_mutex_on_fptr = &accept_mutex_on_flock;
+ } else
+#endif
+#if defined USE_OS2SEM_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"os2sem"))) {
+ accept_mutex_child_init_fptr = &accept_mutex_child_init_os2sem;
+ accept_mutex_init_fptr = &accept_mutex_init_os2sem;
+ accept_mutex_off_fptr = &accept_mutex_off_os2sem;
+ accept_mutex_on_fptr = &accept_mutex_on_os2sem;
+ } else
+#endif
+#if defined USE_TPF_CORE_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"tpfcore"))) {
+ accept_mutex_child_init_fptr = &accept_mutex_child_init_tpfcore;
+ accept_mutex_init_fptr = NULLL;
+ accept_mutex_off_fptr = &accept_mutex_off_tpfcore;
+ accept_mutex_on_fptr = &accept_mutex_on_tpfcore;
+ } else
+#endif
+#if defined USE_NONE_CORE_SERIALIZED_ACCEPT
+ if (!(strcasecmp(t,"none"))) {
+ accept_mutex_child_init_fptr = NULL;
+ accept_mutex_init_fptr = NULL;
+ accept_mutex_off_fptr = NULL;
+ accept_mutex_on_fptr = NULL;
+ } else
+#endif
+ return "Request serialized accept method not available";
+
+ return NULL;
+}
+
+char * init_single_listen( int flag )
+{
+ ap_single_listen = flag;
#ifdef SINGLE_LISTEN_UNSERIALIZED_ACCEPT
-#define SAFE_ACCEPT(stmt) do {if(ap_listeners->next != ap_listeners) {stmt;}} while(0)
+ return NULL;
#else
-#define SAFE_ACCEPT(stmt) do {stmt;} while(0)
+ return "Single Unserialized listen not compiled in - use with caution";
#endif
+}
+#define SAFE_ACCEPT(stmt) \
+ do {if(ap_listeners->next != ap_listeners || !ap_single_listen) {stmt;}}
+while(0);
+
static void usage(char *bin)
{
char pad[MAX_STRING_LEN];
@@ -3728,6 +3881,15 @@
#ifdef USE_PTHREAD_SERIALIZED_ACCEPT
printf(" -D USE_PTHREAD_SERIALIZED_ACCEPT\n");
#endif
+#ifdef USE_OS2SEM_SERIALIZED_ACCEPT
+ printf(" -D USE_OS2SEM_SERIALIZED_ACCEPT\n");
+#endif
+#ifdef USE_TPF_CORE_SERIALIZED_ACCEPT
+ printf(" -D USE_TPF_CORE_SERIALIZED_ACCEPT\n");
+#endif
+#ifdef USE_NONE_SERIALIZED_ACCEPT
+ printf(" -D USE_NONE_SERIALIZED_ACCEPT\n");
+#endif
#ifdef SINGLE_LISTEN_UNSERIALIZED_ACCEPT
printf(" -D SINGLE_LISTEN_UNSERIALIZED_ACCEPT\n");
#endif
@@ -3884,7 +4046,7 @@
/* needs to be done before we switch UIDs so we have permissions */
reopen_scoreboard(pchild);
- SAFE_ACCEPT(accept_mutex_child_init(pchild));
+ SAFE_ACCEPT((accept_mutex_child_init(pchild)));
set_group_privs();
#ifdef MPE
@@ -3982,7 +4144,7 @@
*/
/* Lock around "accept", if necessary */
- SAFE_ACCEPT(accept_mutex_on());
+ SAFE_ACCEPT((accept_mutex_on()));
for (;;) {
if (ap_listeners->next != ap_listeners) {
@@ -4687,6 +4849,9 @@
#endif
ap_clear_pool(pconf);
ptrans = ap_make_sub_pool(pconf);
+
+ init_single_listen(ap_single_listen);
+ init_mutex_method(default_mutex_method());
server_conf = ap_read_config(pconf, ptrans, ap_server_confname);
setup_listeners(pconf);
--
===========================================================================
Jim Jagielski [|] [EMAIL PROTECTED] [|] http://www.jaguNET.com/
"A society that will trade a little liberty for a little order
will lose both and deserve neither"
