Return-Path: Delivered-To: apmail-new-httpd-archive@apache.org Received: (qmail 71975 invoked by uid 500); 20 Aug 2001 18:36:27 -0000 Mailing-List: contact new-httpd-help@apache.org; run by ezmlm Precedence: bulk Reply-To: new-httpd@apache.org list-help: list-unsubscribe: list-post: Delivered-To: mailing list new-httpd@apache.org Received: (qmail 71964 invoked from network); 20 Aug 2001 18:36:26 -0000 Mime-Version: 1.0 X-Sender: jimpop@devsys.jagunet.com Message-Id: Date: Mon, 20 Aug 2001 14:36:25 -0400 To: new-httpd@apache.org From: Jim Jagielski Subject: [PATCH] AcceptMutex and SingleListen runtime Content-Type: text/plain; charset="us-ascii" X-Spam-Rating: h31.sny.collab.net 1.6.2 0/1000/N Status: O X-Status: X-Keywords: X-UID: 882 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 - 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 #include @@ -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 [|] jim@jaguNET.com [|] http://www.jaguNET.com/ "A society that will trade a little liberty for a little order will lose both and deserve neither"