httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dr...@hyperreal.org
Subject cvs commit: apache-2.0/src/modules/mpm/mpmt_beos Makefile.libdir Makefile.tmpl acceptlock.c acceptlock.h mpm_default.h mpmt_beos.c mpmt_beos.h mutex.c mutex.h poll.c poll.h scoreboard.c scoreboard.h
Date Fri, 08 Oct 1999 19:02:55 GMT
dreid       99/10/08 12:02:51

  Added:       src/modules/mpm/mpmt_beos Makefile.libdir Makefile.tmpl
                        acceptlock.c acceptlock.h mpm_default.h mpmt_beos.c
                        mpmt_beos.h mutex.c mutex.h poll.c poll.h
                        scoreboard.c scoreboard.h
  Log:
  Well here is the first attempt at an mpm for BeOS.  It's based
  on the mpmt_pthread module but is totally threaded as that what
  BeOS needs.  There's a lot that can be improved but now that it's
  committed others can start looking and helping.
  
  Revision  Changes    Path
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/Makefile.libdir
  
  Index: Makefile.libdir
  ===================================================================
  This is a place-holder which indicates to Configure that it shouldn't
  provide the default targets when building the Makefile in this directory.
  Instead it'll just prepend all the important variable definitions, and
  copy the Makefile.tmpl onto the end.
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/Makefile.tmpl
  
  Index: Makefile.tmpl
  ===================================================================
  
  LIB=libmpmt_beos.$(LIBEXT)
  
  OBJS=\
       mpmt_beos.o acceptlock.o scoreboard.o mutex.o poll.o
  OBJS_PIC=\
       mpmt_beos.lo acceptlock.lo scoreboard.lo mutex.lo poll.lo
  
  all: lib
  
  lib: $(LIB)
  
  libmpmt_beos.a: $(OBJS)
  	rm -f $@
  	ar cr $@ $(OBJS)
  	$(RANLIB) $@
  
  libmpmt_beos.so: $(OBJS_PIC)
  	rm -f $@
  	$(LD_SHLIB) $(LDFLAGS_SHLIB) -o $@ $(OBJS_PIC) $(LIBS_SHLIB)
  
  libmpmt_beos.dll: $(OBJS_PIC) mpmt_beos.def
  	$(LD_SHLIB) $(LDFLAGS_SHLIB) -o $* $(OBJS_PIC) $(LIBS_SHLIB)
  	emxbind -b -q -s -h0 -dmpmt_beos.def $* && \
  	rm $*
  
  .SUFFIXES: .o .lo .dll
  
  .c.o:
  	$(CC) -c $(INCLUDES) $(CFLAGS) $<
  
  .c.lo:
  	$(CC) -c $(INCLUDES) $(CFLAGS) $(CFLAGS_SHLIB) $< && mv $*.o $*.lo
  
  clean:
  	rm -f $(OBJS) $(OBJS_PIC) $(LIB)
  
  distclean: clean
  	-rm -f Makefile
  
  # We really don't expect end users to use this rule.  It works only with
  # gcc, and rebuilds Makefile.tmpl.  You have to re-run Configure after
  # using it.
  depend:
  	cp Makefile.tmpl Makefile.tmpl.bak \
  	    && sed -ne '1,/^# DO NOT REMOVE/p' Makefile.tmpl > Makefile.new \
  	    && gcc -MM $(INCLUDES) $(CFLAGS) *.c >> Makefile.new \
  	    && sed -e '1,$$s: $(INCDIR)/: $$(INCDIR)/:g' \
  	           -e '1,$$s: $(OSDIR)/: $$(OSDIR)/:g' Makefile.new \
  		> Makefile.tmpl \
  	    && rm Makefile.new
  
  #Dependencies
  
  $(OBJS) $(OBJS_PIC): Makefile
  
  # DO NOT REMOVE
  acceptlock.o: acceptlock.c mutex.h $(INCDIR)/httpd.h \
   $(INCDIR)/ap_config.h $(INCDIR)/ap_mmn.h \
   $(INCDIR)/ap_config_auto.h $(OSDIR)/os.h \
   $(INCDIR)/ap_ctype.h $(INCDIR)/hsregex.h \
   ../../../lib/apr/include/apr_general.h \
   ../../../lib/apr/include/apr_config.h \
   ../../../lib/apr/include/apr_errno.h \
   ../../../lib/apr/include/apr_lib.h \
   ../../../lib/apr/include/apr_file_io.h $(INCDIR)/buff.h \
   $(INCDIR)/ap_iol.h $(INCDIR)/ap.h \
   $(INCDIR)/apr.h $(INCDIR)/util_uri.h acceptlock.h \
   $(INCDIR)/ap_mpm.h mpmt_beos.h
  mpmt_beos.o: mpmt_beos.c ../../../lib/apr/include/apr_portable.h \
   ../../../lib/apr/include/apr_general.h \
   ../../../lib/apr/include/apr_config.h \
   ../../../lib/apr/include/apr_errno.h \
   ../../../lib/apr/include/apr_thread_proc.h \
   ../../../lib/apr/include/apr_file_io.h \
   ../../../lib/apr/include/apr_win.h \
   ../../../lib/apr/include/apr_network_io.h \
   ../../../lib/apr/include/apr_lock.h \
   ../../../lib/apr/include/apr_time.h $(INCDIR)/httpd.h \
   $(INCDIR)/ap_config.h $(INCDIR)/ap_mmn.h \
   $(INCDIR)/ap_config_auto.h $(OSDIR)/os.h \
   $(INCDIR)/ap_ctype.h $(INCDIR)/hsregex.h \
   ../../../lib/apr/include/apr_lib.h $(INCDIR)/buff.h \
   $(INCDIR)/ap_iol.h $(INCDIR)/ap.h \
   $(INCDIR)/apr.h $(INCDIR)/util_uri.h \
   $(INCDIR)/http_main.h $(INCDIR)/http_log.h \
   $(INCDIR)/http_config.h $(INCDIR)/ap_hooks.h \
   $(INCDIR)/http_core.h $(INCDIR)/http_connection.h \
   $(INCDIR)/ap_mpm.h $(OSDIR)/beosd.h \
   $(OSDIR)/iol_socket.h $(INCDIR)/ap_listen.h \
   scoreboard.h mpm_default.h acceptlock.h mutex.h poll.h
  mutex.o: mutex.c mutex.h
  poll.o: poll.c poll.h
  scoreboard.o: scoreboard.c $(INCDIR)/httpd.h \
   $(INCDIR)/ap_config.h $(INCDIR)/ap_mmn.h \
   $(INCDIR)/ap_config_auto.h $(OSDIR)/os.h \
   $(INCDIR)/ap_ctype.h $(INCDIR)/hsregex.h \
   ../../../lib/apr/include/apr_general.h \
   ../../../lib/apr/include/apr_config.h \
   ../../../lib/apr/include/apr_errno.h \
   ../../../lib/apr/include/apr_lib.h \
   ../../../lib/apr/include/apr_file_io.h $(INCDIR)/buff.h \
   $(INCDIR)/ap_iol.h $(INCDIR)/ap.h \
   $(INCDIR)/apr.h $(INCDIR)/util_uri.h \
   $(INCDIR)/http_log.h $(INCDIR)/http_main.h \
   $(INCDIR)/http_core.h $(INCDIR)/http_config.h \
   $(INCDIR)/ap_hooks.h $(OSDIR)/beosd.h \
   $(INCDIR)/http_conf_globals.h mpmt_beos.h scoreboard.h \
   mpm_default.h
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/acceptlock.c
  
  Index: acceptlock.c
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without 
   * modification, are permitted provided that the following conditions 
   * are met: 
   * 
   * 1. Redistributions of source code must retain the above copyright 
   *    notice, this list of conditions and the following disclaimer.  
   * 
   * 2. Redistributions in binary form must reproduce the above copyright 
   *    notice, this list of conditions and the following disclaimer in 
   *    the documentation and/or other materials provided with the 
   *    distribution. 
   * 
   * 3. All advertising materials mentioning features or use of this 
   *    software must display the following acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * 4. The names "Apache Server" and "Apache Group" must not be used to 
   *    endorse or promote products derived from this software without 
   *    prior written permission. For written permission, please contact 
   *    apache@apache.org. 
   * 
   * 5. Products derived from this software may not be called "Apache" 
   *    nor may "Apache" appear in their names without prior written 
   *    permission of the Apache Group. 
   * 
   * 6. Redistributions of any form whatsoever must retain the following 
   *    acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY 
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR 
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
   * OF THE POSSIBILITY OF SUCH DAMAGE. 
   * ==================================================================== 
   * 
   * This software consists of voluntary contributions made by many 
   * individuals on behalf of the Apache Group and was originally based 
   * on public domain software written at the National Center for 
   * Supercomputing Applications, University of Illinois, Urbana-Champaign. 
   * For more information on the Apache Group and the Apache HTTP server 
   * project, please see <http://www.apache.org/>. 
   * 
   */ 
  
  #include <stdio.h> 
  #include <kernel/OS.h>
  #include <math.h>
  
  #include "mutex.h"
  #include "httpd.h" 
  #include "acceptlock.h"
  #include "ap_mpm.h"
  #include "mpmt_beos.h"
  
  /* Number of cross-process locks we're managing */
  static int lock_count;
  static be_mutex_t *accept_mutexes = NULL;
  static int *have_accept_mutex;
  area_id	mutex_area;
  void * area_ptr;
  
  char *accept_mutex; /* pointer to area */
  /* Number of intra-process locks we're managing */
  static int intra_lock_count;
  
  /* Intraprocess locking used by other serialization techniques */
  static be_mutex_t *intra_mutex = NULL;
  
  static ap_status_t intra_mutex_cleanup(void *foo)
  {
      int i;
  
      for (i = 0; i < intra_lock_count; i++) {
          (void) be_mutex_destroy(&intra_mutex[i]);
      }
      return APR_SUCCESS;
  }
  
  void intra_mutex_init(ap_context_t *p, int number_of_locks)
  {
      int i;
      intra_lock_count = number_of_locks;
      intra_mutex = (be_mutex_t *)ap_palloc(p, intra_lock_count * sizeof(be_mutex_t));
      for (i = 0; i < intra_lock_count; i++) {       
          if (be_mutex_init(&intra_mutex[i], NULL) == -1) {
              perror("intra_mutex_init");
  	        clean_child_exit(APEXIT_CHILDFATAL);
          }
      }
      ap_register_cleanup(p, NULL, intra_mutex_cleanup, ap_null_cleanup);
  }
  
  void intra_mutex_on(int locknum)
  {
      be_mutex_lock(&intra_mutex[locknum]);
  }
  
  void intra_mutex_off(int locknum)
  {
      be_mutex_unlock(&intra_mutex[locknum]);
  }
  
  
  ap_status_t accept_mutex_child_cleanup(void *foo)
  {
      int i;
  
      if (accept_mutex != NULL) {
          for (i = 0; i < lock_count; i++) {
  	    	if (have_accept_mutex[i])
    	        	be_mutex_unlock(&accept_mutexes[i]);
  		}
      }
      return APR_SUCCESS;
  }
  
  void accept_mutex_child_init(ap_context_t *p)
  {
      ap_register_cleanup(p, NULL, accept_mutex_child_cleanup, ap_null_cleanup);
  }
  
  ap_status_t accept_mutex_cleanup(void *foo)
  { 
  	delete_area(mutex_area);
      accept_mutex = NULL;
      return APR_SUCCESS;
  }
  
  void accept_mutex_init(ap_context_t *p, int number_of_locks)
  {
      int i;
      float size = number_of_locks * sizeof(be_mutex_t);
      
      size_t	nPages = ceil(size / B_PAGE_SIZE);
      if (nPages == 0) nPages = 1;
      area_ptr = NULL;
      mutex_area = create_area("httpd_accept_mutex", &area_ptr, B_ANY_ADDRESS,
  	B_PAGE_SIZE * nPages, B_FULL_LOCK, B_READ_AREA|B_WRITE_AREA);
  	   
      lock_count = number_of_locks;
      have_accept_mutex = (int *)ap_palloc(p, lock_count * sizeof(int));
  
      if (area_ptr == NULL) {
          perror("create_area");
          exit(APEXIT_INIT);
      }
      accept_mutexes = (be_mutex_t *)area_ptr;
      for (i = 0; i < lock_count; i++) {
  		if ((errno = be_mutex_init(&accept_mutexes[i], NULL))) {
  		    perror("be_mutex_init");
  	    	exit(APEXIT_INIT);
  		}
      }
      ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
  }
  
  void accept_mutex_on(int locknum)
  {
      int err;
      if ((err = be_mutex_lock(&accept_mutexes[locknum]))) {
  	    errno = err;
  	    perror("be_mutex_lock");
  	    clean_child_exit(APEXIT_CHILDFATAL);
      }
      have_accept_mutex[locknum] = 1;
  }
  
  void accept_mutex_off(int locknum)
  {
      int err;
      if ((err = be_mutex_unlock(&accept_mutexes[locknum]))) {
  	    errno = err;
  	    perror("be_mutex_lock");
  	    clean_child_exit(APEXIT_CHILDFATAL);
      }
      have_accept_mutex[locknum] = 0;
  }
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/acceptlock.h
  
  Index: acceptlock.h
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without 
   * modification, are permitted provided that the following conditions 
   * are met: 
   * 
   * 1. Redistributions of source code must retain the above copyright 
   *    notice, this list of conditions and the following disclaimer.  
   * 
   * 2. Redistributions in binary form must reproduce the above copyright 
   *    notice, this list of conditions and the following disclaimer in 
   *    the documentation and/or other materials provided with the 
   *    distribution. 
   * 
   * 3. All advertising materials mentioning features or use of this 
   *    software must display the following acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * 4. The names "Apache Server" and "Apache Group" must not be used to 
   *    endorse or promote products derived from this software without 
   *    prior written permission. For written permission, please contact 
   *    apache@apache.org. 
   * 
   * 5. Products derived from this software may not be called "Apache" 
   *    nor may "Apache" appear in their names without prior written 
   *    permission of the Apache Group. 
   * 
   * 6. Redistributions of any form whatsoever must retain the following 
   *    acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY 
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR 
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
   * OF THE POSSIBILITY OF SUCH DAMAGE. 
   * ==================================================================== 
   * 
   * This software consists of voluntary contributions made by many 
   * individuals on behalf of the Apache Group and was originally based 
   * on public domain software written at the National Center for 
   * Supercomputing Applications, University of Illinois, Urbana-Champaign. 
   * For more information on the Apache Group and the Apache HTTP server 
   * project, please see <http://www.apache.org/>. 
   * 
   */ 
  
  #ifndef APACHE_ACCEPT_LOCK_H
  #define APACHE_ACCEPT_LOCK_H
  
  #ifdef __cplusplus
  extern "C" {
  #endif
    
  /* Prototypes for the intraprocess accept mutex functions */
  void intra_mutex_init(ap_context_t *, int);
  void intra_mutex_on(int);
  void intra_mutex_off(int);
  
  ap_status_t accept_mutex_child_cleanup(void *);
  void accept_mutex_child_init(ap_context_t *);
  ap_status_t accept_mutex_cleanup(void *);
  void accept_mutex_init(ap_context_t *, int);
  void accept_mutex_on(int);
  void accept_mutex_off(int);
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif /* APACHE_ACCEPT_LOCK_H */
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/mpm_default.h
  
  Index: mpm_default.h
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without 
   * modification, are permitted provided that the following conditions 
   * are met: 
   * 
   * 1. Redistributions of source code must retain the above copyright 
   *    notice, this list of conditions and the following disclaimer.  
   * 
   * 2. Redistributions in binary form must reproduce the above copyright 
   *    notice, this list of conditions and the following disclaimer in 
   *    the documentation and/or other materials provided with the 
   *    distribution. 
   * 
   * 3. All advertising materials mentioning features or use of this 
   *    software must display the following acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * 4. The names "Apache Server" and "Apache Group" must not be used to 
   *    endorse or promote products derived from this software without 
   *    prior written permission. For written permission, please contact 
   *    apache@apache.org. 
   * 
   * 5. Products derived from this software may not be called "Apache" 
   *    nor may "Apache" appear in their names without prior written 
   *    permission of the Apache Group. 
   * 
   * 6. Redistributions of any form whatsoever must retain the following 
   *    acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY 
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR 
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
   * OF THE POSSIBILITY OF SUCH DAMAGE. 
   * ==================================================================== 
   * 
   * This software consists of voluntary contributions made by many 
   * individuals on behalf of the Apache Group and was originally based 
   * on public domain software written at the National Center for 
   * Supercomputing Applications, University of Illinois, Urbana-Champaign. 
   * For more information on the Apache Group and the Apache HTTP server 
   * project, please see <http://www.apache.org/>. 
   * 
   */ 
  
  #ifndef APACHE_MPM_DEFAULT_H
  #define APACHE_MPM_DEFAULT_H
  
  /* Number of servers to spawn off by default --- also, if fewer than
   * this free when the caretaker checks, it will spawn more.
   */
  #ifndef DEFAULT_START_DAEMON
  #define DEFAULT_START_DAEMON 5
  #endif
  
  /* Maximum number of *free* server processes --- more than this, and
   * they will die off.
   */
  
  #ifndef DEFAULT_MAX_FREE_DAEMON
  #define DEFAULT_MAX_FREE_DAEMON 10
  #endif
  
  /* Minimum --- fewer than this, and more will be created */
  
  #ifndef DEFAULT_MIN_FREE_DAEMON
  #define DEFAULT_MIN_FREE_DAEMON 5
  #endif
  
  /* Limit on the total --- clients will be locked out if more servers than
   * this are needed.  It is intended solely to keep the server from crashing
   * when things get out of hand.
   *
   * We keep a hard maximum number of servers, for two reasons --- first off,
   * in case something goes seriously wrong, we want to stop the fork bomb
   * short of actually crashing the machine we're running on by filling some
   * kernel table.  Secondly, it keeps the size of the scoreboard file small
   * enough that we can read the whole thing without worrying too much about
   * the overhead.
   */
  #ifdef NO_THREADS
  #define HARD_SERVER_LIMIT 256
  #endif
  #ifndef HARD_SERVER_LIMIT
  #define HARD_SERVER_LIMIT 8 
  #endif
  
  /* Limit on the threads per process.  Clients will be locked out if more than
   * this  * HARD_SERVER_LIMIT are needed.
   *
   * We keep this for one reason it keeps the size of the scoreboard file small
   * enough that we can read the whole thing without worrying too much about
   * the overhead.
   */
  #ifdef NO_THREADS
  #define HARD_THREAD_LIMIT 1
  #endif
  #ifndef HARD_THREAD_LIMIT
  #define HARD_THREAD_LIMIT 64 
  #endif
  
  #ifdef NO_THREADS
  #define DEFAULT_THREADS_PER_CHILD 1
  #endif
  #ifndef DEFAULT_THREADS_PER_CHILD
  #define DEFAULT_THREADS_PER_CHILD 10
  #endif
  
  #endif /* AP_MPM_DEFAULT_H */
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/mpmt_beos.c
  
  Index: mpmt_beos.c
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without 
   * modification, are permitted provided that the following conditions 
   * are met: 
   * 
   * 1. Redistributions of source code must retain the above copyright 
   *    notice, this list of conditions and the following disclaimer.  
   * 
   * 2. Redistributions in binary form must reproduce the above copyright 
   *    notice, this list of conditions and the following disclaimer in 
   *    the documentation and/or other materials provided with the 
   *    distribution. 
   * 
   * 3. All advertising materials mentioning features or use of this 
   *    software must display the following acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * 4. The names "Apache Server" and "Apache Group" must not be used to 
   *    endorse or promote products derived from this software without 
   *    prior written permission. For written permission, please contact 
   *    apache@apache.org. 
   * 
   * 5. Products derived from this software may not be called "Apache" 
   *    nor may "Apache" appear in their names without prior written 
   *    permission of the Apache Group. 
   * 
   * 6. Redistributions of any form whatsoever must retain the following 
   *    acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY 
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR 
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
   * OF THE POSSIBILITY OF SUCH DAMAGE. 
   * ==================================================================== 
   * 
   * This software consists of voluntary contributions made by many 
   * individuals on behalf of the Apache Group and was originally based 
   * on public domain software written at the National Center for 
   * Supercomputing Applications, University of Illinois, Urbana-Champaign. 
   * For more information on the Apache Group and the Apache HTTP server 
   * project, please see <http://www.apache.org/>. 
   * 
   */ 
  
  /* This module is effectivly mpmt_pthread much modified to
   * allow it work on BeOS.  It's stable and works OK.
   */
   
  #define CORE_PRIVATE 
   
  #include "apr_portable.h"
  #include "httpd.h" 
  #include "http_main.h" 
  #include "http_log.h" 
  #include "http_config.h"	/* for read_config */ 
  #include "http_core.h"		/* for get_remote_host */ 
  #include "http_connection.h"
  #include "ap_mpm.h"
  #include "beosd.h"
  #include "iol_socket.h"
  #include "ap_listen.h"
  #include "scoreboard.h" 
  #include "acceptlock.h"
  #include "mutex.h"
  #include "poll.h"
  
  /*
   * Actual definitions of config globals
   */
  
  int ap_threads_per_child=0;         /* Worker threads per child */
  int ap_max_requests_per_child=0;
  static char *ap_pid_fname=NULL;
  static char *ap_scoreboard_fname=NULL;
  static int ap_daemons_to_start=0;
  static int min_spare_threads=0;
  static int max_spare_threads=0;
  static int ap_daemons_limit=0;
  static time_t ap_restart_time=0;
  API_VAR_EXPORT int ap_extended_status = 0;
  static int workers_may_exit = 0;
  static int requests_this_child;
  static int num_listenfds = 0;
  static struct pollfd *listenfds;
  
  /* The structure used to pass unique initialization info to each thread */
  typedef struct {
      int pid;
      thread_id tid;
      int sd;
      ap_context_t *tpool; /* "pthread" would be confusing */
  } proc_info;
  
  #if 0
  #define SAFE_ACCEPT(stmt) do {if (ap_listeners->next != NULL) {stmt;}} while (0)
  #else
  #define SAFE_ACCEPT(stmt) do {stmt;} while (0)
  #endif
  
  /*
   * The max child slot ever assigned, preserved across restarts.  Necessary
   * to deal with MaxClients changes across SIGWINCH restarts.  We use this
   * value to optimize routines that have to scan the entire scoreboard.
   */
  static int max_daemons_limit = -1;
  static char ap_coredump_dir[MAX_STRING_LEN];
  port_id port_of_death;
  
  /* *Non*-shared http_main globals... */
  
  static server_rec *server_conf;
  
  /* one_process --- debugging mode variable; can be set from the command line
   * with the -X flag.  If set, this gets you the child_main loop running
   * in the process which originally started up (no detach, no make_child),
   * which is a pretty nice debugging environment.  (You'll get a SIGHUP
   * early in standalone_main; just continue through.  This is the server
   * trying to kill off any child processes which it might have lying
   * around --- Apache doesn't keep track of their pids, it just sends
   * SIGHUP to the process group, ignoring it in the root process.
   * Continue through and you'll be fine.).
   */
  
  static int one_process = 0;
  
  #ifdef DEBUG_SIGSTOP
  int raise_sigstop_flags;
  #endif
  
  #ifdef HAS_OTHER_CHILD
  /* used to maintain list of children which aren't part of the scoreboard */
  typedef struct other_child_rec other_child_rec;
  struct other_child_rec {
      other_child_rec *next;
      int pid;
      void (*maintenance) (int, void *, ap_wait_t);
      void *data;
      int write_fd;
  };
  static other_child_rec *other_children;
  #endif
  
  static ap_context_t *pconf;		/* Pool for config stuff */
  static ap_context_t *pchild;		/* Pool for httpd child stuff */
  
  static int my_pid; /* Linux getpid() doesn't work except in main thread. Use
                        this instead */
  /* Keep track of the number of worker threads currently active */
  static int worker_thread_count;
  static be_mutex_t worker_thread_count_mutex;
  
  /* Global, alas, so http_core can talk to us */
  enum server_token_type ap_server_tokens = SrvTk_FULL;
  
  API_EXPORT(const server_rec *) ap_get_server_conf(void)
  {
      return (server_conf);
  }
  
  API_EXPORT(int) ap_get_max_daemons(void)
  {
      return max_daemons_limit;
  }
  
  /* a clean exit from a child with proper cleanup 
     static void clean_child_exit(int code) __attribute__ ((noreturn)); */
  void clean_child_exit(int code)
  {
      if (pchild) {
  	ap_destroy_pool(pchild);
      }
      exit(code);
  }
  
  /*****************************************************************
   * dealing with other children
   */
  
  #ifdef HAS_OTHER_CHILD
  API_EXPORT(void) ap_register_other_child(int pid,
  		       void (*maintenance) (int reason, void *, ap_wait_t status),
  			  void *data, int write_fd)
  {
      other_child_rec *ocr;
  
      ocr = ap_palloc(pconf, sizeof(*ocr));
      ocr->pid = pid;
      ocr->maintenance = maintenance;
      ocr->data = data;
      ocr->write_fd = write_fd;
      ocr->next = other_children;
      other_children = ocr;
  }
  
  /* note that since this can be called by a maintenance function while we're
   * scanning the other_children list, all scanners should protect themself
   * by loading ocr->next before calling any maintenance function.
   */
  API_EXPORT(void) ap_unregister_other_child(void *data)
  {
      other_child_rec **pocr, *nocr;
  
      for (pocr = &other_children; *pocr; pocr = &(*pocr)->next) {
  	if ((*pocr)->data == data) {
  	    nocr = (*pocr)->next;
  	    (*(*pocr)->maintenance) (OC_REASON_UNREGISTER, (*pocr)->data, -1);
  	    *pocr = nocr;
  	    /* XXX: um, well we've just wasted some space in pconf ? */
  	    return;
  	}
      }
  }
  
  /* test to ensure that the write_fds are all still writable, otherwise
   * invoke the maintenance functions as appropriate */
  static void probe_writable_fds(void)
  {
      return;
  #if 0
      fd_set writable_fds;
      int fd_max;
      other_child_rec *ocr, *nocr;
      struct timeval tv;
      int rc;
  
      if (other_children == NULL)
  	return;
  
      fd_max = 0;
      FD_ZERO(&writable_fds);
      do {
  	for (ocr = other_children; ocr; ocr = ocr->next) {
  	    if (ocr->write_fd == -1)
  		continue;
  	    FD_SET(ocr->write_fd, &writable_fds);
  	    if (ocr->write_fd > fd_max) {
  		fd_max = ocr->write_fd;
  	    }
  	}
  	if (fd_max == 0)
  	    return;
  
  	tv.tv_sec = 0;
  	tv.tv_usec = 0;
  	rc = ap_select(fd_max + 1, NULL, &writable_fds, NULL, &tv);
      } while (rc == -1 && errno == EINTR);
  
      if (rc == -1) {
  	/* XXX: uhh this could be really bad, we could have a bad file
  	 * descriptor due to a bug in one of the maintenance routines */
  	ap_log_unixerr("probe_writable_fds", "select",
  		    "could not probe writable fds", server_conf);
  	return;
      }
      if (rc == 0)
  	return;
  
      for (ocr = other_children; ocr; ocr = nocr) {
  	nocr = ocr->next;
  	if (ocr->write_fd == -1)
  	    continue;
  	if (FD_ISSET(ocr->write_fd, &writable_fds))
  	    continue;
  	(*ocr->maintenance) (OC_REASON_UNWRITABLE, ocr->data, -1);
      }
  #endif
  }
  
  /* possibly reap an other_child, return 0 if yes, -1 if not */
  static int reap_other_child(int pid, ap_wait_t status)
  {
      other_child_rec *ocr, *nocr;
  
      for (ocr = other_children; ocr; ocr = nocr) {
  	nocr = ocr->next;
  	if (ocr->pid != pid)
  	    continue;
  	ocr->pid = -1;
  	(*ocr->maintenance) (OC_REASON_DEATH, ocr->data, status);
  	return 0;
      }
      return -1;
  }
  #endif
  
  static void reclaim_child_processes(int terminate)
  {
      int i, status;
      long int waittime = 1024 * 16;	/* in usecs */
      struct timeval tv;
      int waitret, tries;
      int not_dead_yet;
  #ifdef HAS_OTHER_CHILD
      other_child_rec *ocr, *nocr;
  #endif
  
      ap_sync_scoreboard_image();
  
      for (tries = terminate ? 4 : 1; tries <= 9; ++tries) {
  	/* don't want to hold up progress any more than 
  	 * necessary, but we need to allow children a few moments to exit.
  	 * Set delay with an exponential backoff.
  	 */
  	tv.tv_sec = waittime / 1000000;
  	tv.tv_usec = waittime % 1000000;
  	waittime = waittime * 4;
  	ap_select(0, NULL, NULL, NULL, &tv);
  
  	/* now see who is done */
  	not_dead_yet = 0;
  	for (i = 0; i < max_daemons_limit; ++i) {
  	    int pid = ap_scoreboard_image->parent[i].pid;
  
  	    if (pid == my_pid || pid == 0)
  		continue;
  
  	    waitret = waitpid(pid, &status, WNOHANG);
  	    if (waitret == pid || waitret == -1) {
  		ap_scoreboard_image->parent[i].pid = 0;
  		continue;
  	    }
  	    ++not_dead_yet;
  	    switch (tries) {
  	    case 1:     /*  16ms */
  	    case 2:     /*  82ms */
  		break;
  	    case 3:     /* 344ms */
  	    case 4:     /*  16ms */
  	    case 5:     /*  82ms */
  	    case 6:     /* 344ms */
  	    case 7:     /* 1.4sec */
  		/* ok, now it's being annoying */
  		ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING,
  			    server_conf,
  		   "child process %d still did not exit, sending a SIGTERM",
  			    pid);
  		kill(pid, SIGTERM);
  		break;
  	    case 8:     /*  6 sec */
  		/* die child scum */
  		ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, server_conf,
  		   "child process %d still did not exit, sending a SIGKILL",
  			    pid);
  		kill(pid, SIGKILL);
  		break;
  	    case 9:     /* 14 sec */
  		/* gave it our best shot, but alas...  If this really 
  		 * is a child we are trying to kill and it really hasn't
  		 * exited, we will likely fail to bind to the port
  		 * after the restart.
  		 */
  		ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, server_conf,
  			    "could not make child process %d exit, "
  			    "attempting to continue anyway", pid);
  		break;
  	    }
  	}
  #ifdef HAS_OTHER_CHILD
  	for (ocr = other_children; ocr; ocr = nocr) {
  	    nocr = ocr->next;
  	    if (ocr->pid == -1)
  		continue;
  
  	    waitret = waitpid(ocr->pid, &status, WNOHANG);
  	    if (waitret == ocr->pid) {
  		ocr->pid = -1;
  		(*ocr->maintenance) (OC_REASON_DEATH, ocr->data, status);
  	    }
  	    else if (waitret == 0) {
  		(*ocr->maintenance) (OC_REASON_RESTART, ocr->data, -1);
  		++not_dead_yet;
  	    }
  	    else if (waitret == -1) {
  		/* uh what the heck? they didn't call unregister? */
  		ocr->pid = -1;
  		(*ocr->maintenance) (OC_REASON_LOST, ocr->data, -1);
  	    }
  	}
  #endif
  	if (!not_dead_yet) {
  	    /* nothing left to wait for */
  	    break;
  	}
      }
  }
  
  /* Finally, this routine is used by the caretaker process to wait for
   * a while...
   */
  
  /* number of calls to wait_or_timeout between writable probes */
  #ifndef INTERVAL_OF_WRITABLE_PROBES
  #define INTERVAL_OF_WRITABLE_PROBES 10
  #endif
  static int wait_or_timeout_counter;
  
  static int wait_or_timeout(ap_wait_t *status)
  {
      struct timeval tv;
      int ret;
  
      ++wait_or_timeout_counter;
      if (wait_or_timeout_counter == INTERVAL_OF_WRITABLE_PROBES) {
  	wait_or_timeout_counter = 0;
  #ifdef HAS_OTHER_CHILD
  	probe_writable_fds();
  #endif
      }
      ret = waitpid(-1, status, WNOHANG);
      if (ret == -1 && errno == EINTR) {
  	return -1;
      }
      if (ret > 0) {
  	return ret;
      }
      tv.tv_sec = SCOREBOARD_MAINTENANCE_INTERVAL / 1000000;
      tv.tv_usec = SCOREBOARD_MAINTENANCE_INTERVAL % 1000000;
      ap_select(0, NULL, NULL, NULL, &tv);
      return -1;
  }
  
  /* handle all varieties of core dumping signals */
  static void sig_coredump(int sig)
  {
      chdir(ap_coredump_dir);
      signal(sig, SIG_DFL);
      kill(my_pid, sig);
      /* At this point we've got sig blocked, because we're still inside
       * the signal handler.  When we leave the signal handler it will
       * be unblocked, and we'll take the signal... and coredump or whatever
       * is appropriate for this particular Unix.  In addition the parent
       * will see the real signal we received -- whereas if we called
       * abort() here, the parent would only see SIGABRT.
       */
  }
  
  static void just_die(int sig)
  {
      clean_child_exit(0);
  }
  
  /*****************************************************************
   * Connection structures and accounting...
   */
  
  /* volatile just in case */
  static int volatile shutdown_pending;
  static int volatile restart_pending;
  static int volatile is_graceful;
  ap_generation_t volatile ap_my_generation;
  
  /*
   * ap_start_shutdown() and ap_start_restart(), below, are a first stab at
   * functions to initiate shutdown or restart without relying on signals. 
   * Previously this was initiated in sig_term() and restart() signal handlers, 
   * but we want to be able to start a shutdown/restart from other sources --
   * e.g. on Win32, from the service manager. Now the service manager can
   * call ap_start_shutdown() or ap_start_restart() as appropiate.  Note that
   * these functions can also be called by the child processes, since global
   * variables are no longer used to pass on the required action to the parent.
   *
   * These should only be called from the parent process itself, since the
   * parent process will use the shutdown_pending and restart_pending variables
   * to determine whether to shutdown or restart. The child process should
   * call signal_parent() directly to tell the parent to die -- this will
   * cause neither of those variable to be set, which the parent will
   * assume means something serious is wrong (which it will be, for the
   * child to force an exit) and so do an exit anyway.
   */
  
  void ap_start_shutdown(void)
  {
      if (shutdown_pending == 1) {
  	/* Um, is this _probably_ not an error, if the user has
  	 * tried to do a shutdown twice quickly, so we won't
  	 * worry about reporting it.
  	 */
  	return;
      }
      shutdown_pending = 1;
  }
  
  /* do a graceful restart if graceful == 1 */
  void ap_start_restart(int graceful)
  {
  
      if (restart_pending == 1) {
  	/* Probably not an error - don't bother reporting it */
  	return;
      }
      restart_pending = 1;
      is_graceful = graceful;
  }
  
  static void sig_term(int sig)
  {
      ap_start_shutdown();
  }
  
  static void restart(int sig)
  {
      ap_start_restart(sig == SIGWINCH);
  }
  
  static void set_signals(void)
  {
      struct sigaction sa;
  
      sigemptyset(&sa.sa_mask);
      sa.sa_flags = 0;
  
      if (!one_process) {
  	sa.sa_handler = sig_coredump;
  
  	if (sigaction(SIGSEGV, &sa, NULL) < 0)
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGSEGV)");
  	if (sigaction(SIGBUS, &sa, NULL) < 0)
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGBUS)");
  	if (sigaction(SIGABRT, &sa, NULL) < 0)
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGABRT)");
  	if (sigaction(SIGILL, &sa, NULL) < 0)
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGILL)");
  	sa.sa_flags = 0;
      }
      sa.sa_handler = sig_term;
      if (sigaction(SIGTERM, &sa, NULL) < 0)
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGTERM)");
      if (sigaction(SIGINT, &sa, NULL) < 0)
          ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGINT)");
      
      sa.sa_handler = SIG_IGN;
      if (sigaction(SIGPIPE, &sa, NULL) < 0)
      	ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGPIPE)");
  
      /* we want to ignore HUPs and WINCH while we're busy processing one */
      sigaddset(&sa.sa_mask, SIGHUP);
      sigaddset(&sa.sa_mask, SIGWINCH);
      sa.sa_handler = restart;
      if (sigaction(SIGHUP, &sa, NULL) < 0)
      	ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGHUP)");
      if (sigaction(SIGWINCH, &sa, NULL) < 0)
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "sigaction(SIGWINCH)");
  }
  
  static void process_child_status(int pid, ap_wait_t status)
  {
      /* Child died... if it died due to a fatal error,
  	* we should simply bail out.
  	*/
      if ((WIFEXITED(status)) &&
  	WEXITSTATUS(status) == APEXIT_CHILDFATAL) {
  	ap_log_error(APLOG_MARK, APLOG_ALERT|APLOG_NOERRNO, server_conf,
  			"Child %d returned a Fatal error... \n"
  			"Apache is exiting!",
  			pid);
  	exit(APEXIT_CHILDFATAL);
      }
      if (WIFSIGNALED(status)) {
  	switch (WTERMSIG(status)) {
  	case SIGTERM:
  	case SIGHUP:
  	case SIGUSR1:
  	case SIGKILL:
  	    break;
  	default:
  #ifdef SYS_SIGLIST
  #ifdef WCOREDUMP
  	    if (WCOREDUMP(status)) {
  		ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE,
  			     server_conf,
  			     "child pid %d exit signal %s (%d), "
  			     "possible coredump in %s",
  			     pid, (WTERMSIG(status) >= NumSIG) ? "" : 
  			     SYS_SIGLIST[WTERMSIG(status)], WTERMSIG(status),
  			     ap_coredump_dir);
  	    }
  	    else {
  #endif
  		ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE,
  			     server_conf,
  			     "child pid %d exit signal %s (%d)", pid,
  			     SYS_SIGLIST[WTERMSIG(status)], WTERMSIG(status));
  #ifdef WCOREDUMP
  	    }
  #endif
  #else
  	    ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE,
  			 server_conf,
  			 "child pid %d exit signal %d",
  			 pid, WTERMSIG(status));
  #endif
  	}
      }
  }
  
  static int setup_listeners(ap_context_t *pconf, server_rec *s)
  {
      ap_listen_rec *lr;
      int num_listeners = 0;
      if (ap_listen_open(pconf, s->port)) {
         return 0;
      }
      for (lr = ap_listeners; lr; lr = lr->next) {
          num_listeners++;
      }
      return num_listeners;
  }
  
  /*****************************************************************
   * Here follows a long bunch of generic server bookkeeping stuff...
   */
  
  #define sock_disable_nagle(s)	/* NOOP */
  
  int ap_graceful_stop_signalled(void)
  {
      /* XXX - Does this really work? - Manoj */
      return is_graceful;
  }
  
  /*****************************************************************
   * Child process main loop.
   */
  
  static void process_socket(ap_context_t *p, struct sockaddr *sa_client, int csd, int my_child_num, int my_thread_num)
  {
      struct sockaddr sa_server; /* ZZZZ */
      int len = sizeof(struct sockaddr);
      BUFF *conn_io;
      conn_rec *current_conn;
      ap_iol *iol;
      long conn_id = my_child_num * HARD_THREAD_LIMIT + my_thread_num;
  
      if (getsockname(csd, &sa_server, &len) < 0) { 
  	ap_log_error(APLOG_MARK, APLOG_ERR, server_conf, "getsockname");
  	closesocket(csd);
  	return;
      }
  
      sock_disable_nagle(csd);
  
      iol = beos_attach_socket(csd);
      if (iol == NULL) {
          if (errno == EBADF) {
              ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, NULL,
                  "filedescriptor (%u) larger than FD_SETSIZE (%u) "
                  "found, you probably need to rebuild Apache with a "
                  "larger FD_SETSIZE", csd, FD_SETSIZE);
          }
          else {
              ap_log_error(APLOG_MARK, APLOG_WARNING, NULL,
                  "error attaching to socket");
          }
          closesocket(csd);
  	return;
      }
  
      (void) ap_update_child_status(my_child_num, my_thread_num,  
  				  SERVER_BUSY_READ, (request_rec *) NULL);
      conn_io = ap_bcreate(p, B_RDWR);
      ap_bpush_iol(conn_io, iol);
  
      current_conn = ap_new_connection(p, server_conf, conn_io,
                                    (const struct sockaddr_in *) sa_client, 
                                    (const struct sockaddr_in *) &sa_server,
                                    conn_id);
  
      ap_process_connection(current_conn);
  }
  
  static int32 worker_thread(void * dummy)
  {
      proc_info * ti = dummy;
      int process_slot = ti->pid;
      int thread_slot = ti->tid;
      ap_context_t *tpool = ti->tpool;
      struct sockaddr sa_client;
      ap_socket_t *csd = NULL;
      ap_context_t *ptrans;		/* Pool for per-transaction stuff */
      ap_socket_t *sd = NULL;
      int srv;
      int curr_pollfd, last_pollfd = 0;
      int thesock;
      sigset_t sig_mask;
      
      free(ti);
  
      /* block the signals for this thread */
      sigfillset(&sig_mask);
      sigprocmask(SIG_BLOCK, &sig_mask, NULL);
  
      ap_create_context(&ptrans, tpool);
  
      be_mutex_lock(&worker_thread_count_mutex);
      worker_thread_count++;
      be_mutex_unlock(&worker_thread_count_mutex);
  
      /* TODO: Switch to a system where threads reuse the results from earlier
         poll calls - manoj */
      while (!workers_may_exit) {
          workers_may_exit |= (ap_max_requests_per_child != 0) && (requests_this_child <= 0);
          if (workers_may_exit) break;
  
          (void) ap_update_child_status(process_slot, thread_slot, SERVER_READY, 
                                        (request_rec *) NULL);
          SAFE_ACCEPT(intra_mutex_on(0));
          if (workers_may_exit) {
              SAFE_ACCEPT(intra_mutex_off(0));
              break;
          }
          SAFE_ACCEPT(accept_mutex_on(0));
          while (!workers_may_exit) {
              srv = poll(listenfds, num_listenfds + 1, -1);
              if (srv < 0) {
                  if (errno == EINTR) {
                      continue;
                  }
  
                  /* poll() will only return errors in catastrophic
                   * circumstances. Let's try exiting gracefully, for now. */
                  ap_log_error(APLOG_MARK, APLOG_ERR, (const server_rec *)
                               ap_get_server_conf(), "poll: (listen)");
                  workers_may_exit = 1;
              }
  
              if (workers_may_exit) break;
  
              if (num_listenfds == 1) {
                  sd = ap_listeners->sd;
                  goto got_fd;
              }
              else {
                  /* find a listener */
                  curr_pollfd = last_pollfd;
                  do {
                      curr_pollfd++;
                      if (curr_pollfd > num_listenfds) {
                          curr_pollfd = 1;
                      }
                      /* XXX: Should we check for POLLERR? */
                      if (listenfds[curr_pollfd].revents & POLLIN) {
                          last_pollfd = curr_pollfd;
                          ap_put_os_sock(&sd, &listenfds[curr_pollfd].fd, tpool); 
                          goto got_fd;
                      }
                  } while (curr_pollfd != last_pollfd);
              }
          }
      got_fd:
          if (!workers_may_exit) {
              ap_accept(&csd, sd);
              SAFE_ACCEPT(accept_mutex_off(0));
              SAFE_ACCEPT(intra_mutex_off(0));
          }
          else {
              SAFE_ACCEPT(accept_mutex_off(0));
              SAFE_ACCEPT(intra_mutex_off(0));
              break;
          }
          ap_get_os_sock(csd, &thesock);
          process_socket(ptrans, &sa_client, thesock, process_slot, thread_slot);
          ap_clear_pool(ptrans);
          requests_this_child--;
      }
  
      ap_destroy_pool(tpool);
      ap_update_child_status(process_slot, thread_slot, SERVER_DEAD,
          (request_rec *) NULL);
      be_mutex_lock(&worker_thread_count_mutex);
      worker_thread_count--;
      if (worker_thread_count == 0) {
          /* All the threads have exited, now finish the shutdown process
           * by signalling the sigwait thread */
          kill(my_pid, SIGTERM);
      }
      be_mutex_unlock(&worker_thread_count_mutex);
  
      return (0);
  }
  
  
  static int32 child_main(void * data)
  {
      int child_num_arg = (int) data;
      sigset_t sig_mask;
      thread_id thread;
      int i;
      int my_child_num = child_num_arg;
      proc_info *my_info = NULL;
      ap_listen_rec *lr;
      struct sigaction sa;
      int32 msg;
      char buf;
      
      my_pid = getpid();
      ap_create_context(&pchild, pconf);
  
      /*stuff to do before we switch id's, so we have permissions.*/
      reopen_scoreboard(pchild);
  
      SAFE_ACCEPT(intra_mutex_init(pchild, 1));
      SAFE_ACCEPT(accept_mutex_child_init(pchild));
  
      if (beosd_setup_child()) {
  	clean_child_exit(APEXIT_CHILDFATAL);
      }
  
      ap_child_init_hook(pchild, server_conf);
  
      /*done with init critical section */
  
      /* All threads should mask signals out, accoring to sigwait(2) man page */
      sigfillset(&sig_mask);
      sigprocmask(SIG_BLOCK, &sig_mask, NULL);
      
      requests_this_child = ap_max_requests_per_child;
      
      /* Set up the pollfd array */
      listenfds = ap_palloc(pchild, sizeof(struct pollfd) * (num_listenfds));
      for (lr = ap_listeners, i = 0; i < num_listenfds; lr = lr->next, ++i) {
          ap_get_os_sock(lr->sd, &listenfds[i].fd);
          listenfds[i].events = POLLIN; /* should we add POLLPRI ?*/
          listenfds[i].revents = 0;
      }
  
      /* Setup worker threads */
  
      worker_thread_count = 0;
      be_mutex_init(&worker_thread_count_mutex, NULL);
  
      for (i=0; i < ap_threads_per_child; i++) {
  
  	my_info = (proc_info *)malloc(sizeof(proc_info));
          if (my_info == NULL) {
              ap_log_error(APLOG_MARK, APLOG_ALERT, server_conf,
  		         "malloc: out of memory");
              clean_child_exit(APEXIT_CHILDFATAL);
          }
  	my_info->pid = my_child_num;
          my_info->tid = i;
  	my_info->sd = 0;
  	ap_create_context(&my_info->tpool, pchild);
  	
  	/* We are creating threads right now */
  	(void) ap_update_child_status(my_child_num, i, SERVER_STARTING, 
  				      (request_rec *) NULL);
  
  	if ((thread = spawn_thread(worker_thread, "httpd_worker_thread",
  	      B_NORMAL_PRIORITY, my_info)) < B_NO_ERROR) {
  	    ap_log_error(APLOG_MARK, APLOG_ALERT, server_conf,
  			 "spawn_thread: unable to create worker thread");
              /* In case system resources are maxxed out, we don't want
                 Apache running away with the CPU trying to fork over and
                 over and over again if we exit. */
          sleep(10);
  	    clean_child_exit(APEXIT_CHILDFATAL);
  	}
  	resume_thread(thread);
  
  	/* We let each thread update it's own scoreboard entry.  This is done
  	 * because it let's us deal with tid better.
  	 */
      }
  
      sigemptyset(&sa.sa_mask);
      sa.sa_flags = 0;
      sa.sa_handler = just_die;
      sigaction(SIGTERM, &sa, NULL);
      sigaction(SIGINT, &sa, NULL);
      /* this blocks until it gets a message... */
      read_port(port_of_death, &msg, &buf, 1);
  
      return (0);
  }
  
  static int make_child(server_rec *s, int slot, time_t now) /* ZZZ */
  {
      thread_id tid;
      
      if (slot + 1 > max_daemons_limit) {
  	max_daemons_limit = slot + 1;
      }
  
      if (one_process) {
      	set_signals();
          ap_scoreboard_image->parent[slot].pid = getpid();
  	    //child_main(slot);
      }
  
      tid = spawn_thread(child_main, "httpd_child", B_NORMAL_PRIORITY,
          (void*)slot);
      if (tid < B_NO_ERROR) {
          ap_log_error(APLOG_MARK, APLOG_ERR, s, "spawn_thread: Unable to fork new process");
  	/* In case system resources are maxxed out, we don't want
  	   Apache running away with the CPU trying to fork over and
  	   over and over again. */
      	sleep(10);
  
      	return -1;
      }
      resume_thread(tid);
      
  /*    if (!pid) {
          RAISE_SIGSTOP(MAKE_CHILD);
          signal(SIGTERM, just_die);
          child_main(slot);
      	return 0;
      }*/
      /* else */
      ap_scoreboard_image->parent[slot].pid = tid;
      return 0;
  }
  
  /* start up a bunch of children */
  static void startup_children(int number_to_start)
  {
      int i;
  
      for (i = 0; number_to_start && i < ap_daemons_limit; ++i) {
  	if (ap_scoreboard_image->parent[i].pid != 0) {
  	    continue;
  	}
  	if (make_child(server_conf, i, 0) < 0) {
  	    break;
  	}
  	--number_to_start;
      }
  }
  
  
  /*
   * idle_spawn_rate is the number of children that will be spawned on the
   * next maintenance cycle if there aren't enough idle servers.  It is
   * doubled up to MAX_SPAWN_RATE, and reset only when a cycle goes by
   * without the need to spawn.
   */
  static int idle_spawn_rate = 1;
  #ifndef MAX_SPAWN_RATE
  #define MAX_SPAWN_RATE	(32)
  #endif
  static int hold_off_on_exponential_spawning;
  
  static void perform_idle_server_maintenance(void)
  {
      int i, j;
      int idle_thread_count;
      thread_score *ss;
      time_t now = 0;
      int free_length;
      int free_slots[MAX_SPAWN_RATE];
      int last_non_dead;
      int total_non_dead;
  
      /* initialize the free_list */
      free_length = 0;
  
      idle_thread_count = 0;
      last_non_dead = -1;
      total_non_dead = 0;
  
      ap_check_signals();
  
      ap_sync_scoreboard_image();
      for (i = 0; i < ap_daemons_limit; ++i) {
  	/* Initialization to satisfy the compiler. It doesn't know
  	 * that ap_threads_per_child is always > 0 */
  	int status = SERVER_DEAD;
  	int any_dying_threads = 0;
  	int all_dead_threads = 1;
  	int idle_thread_addition = 0;
  
  	if (i >= max_daemons_limit && free_length == idle_spawn_rate)
  	    break;
  	for (j = 0; j < ap_threads_per_child; j++) {
              ss = &ap_scoreboard_image->servers[i][j];
  	    status = ss->status;
  
  	    any_dying_threads = any_dying_threads || (status == SERVER_DEAD)
                                      || (status == SERVER_GRACEFUL);
  	    all_dead_threads = all_dead_threads && (status == SERVER_DEAD);
  
  	    /* We consider a starting server as idle because we started it
  	     * at least a cycle ago, and if it still hasn't finished starting
  	     * then we're just going to swamp things worse by forking more.
  	     * So we hopefully won't need to fork more if we count it.
  	     * This depends on the ordering of SERVER_READY and SERVER_STARTING.
  	     */
  	    if (status <= SERVER_READY) {
  	        ++idle_thread_addition;
  	    }
  	}
  	if (all_dead_threads && free_length < idle_spawn_rate) {
  	    free_slots[free_length] = i;
  	    ++free_length;
  	}
  	if (!all_dead_threads) {
              last_non_dead = i;
  	}
          if (!any_dying_threads) {
              ++total_non_dead;
  	    idle_thread_count += idle_thread_addition;
          }
      }
      max_daemons_limit = last_non_dead + 1;
  
      if (idle_thread_count > max_spare_threads) {
          /* Kill off one child */
          char char_of_death = '!';
          if (write_port(port_of_death, 99, &char_of_death, 1) != B_OK) {
              ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "write pipe_of_death");
          }
          idle_spawn_rate = 1;
      }
      else if (idle_thread_count < min_spare_threads) {
          /* terminate the free list */
          if (free_length == 0) {
  	    /* only report this condition once */
  	    static int reported = 0;
  	    
  	    if (!reported) {
  	        ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ERR, server_conf,
  			     "server reached MaxClients setting, consider"
  			     " raising the MaxClients setting");
  		reported = 1;
  	    }
  	    idle_spawn_rate = 1;
  	}
  	else {
  	    /* ZZZZ */
  	    
  	    if (idle_spawn_rate >= 8) {
  	        ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, server_conf,
  			     "server seems busy, (you may need "
  			     "to increase StartServers, ThreadsPerChild "
                               "or Min/MaxSparetThreads), "
  			     "spawning %d children, there are around %d idle "
                               "threads, and %d total children", idle_spawn_rate,
  			     idle_thread_count, total_non_dead);
  	    }
  	    for (i = 0; i < free_length; ++i) {
  	        make_child(server_conf, free_slots[i], now);
  	    }
  	    /* the next time around we want to spawn twice as many if this
  	     * wasn't good enough, but not if we've just done a graceful
  	     */
  	    if (hold_off_on_exponential_spawning) {
  	        --hold_off_on_exponential_spawning;
  	    }
  	    else if (idle_spawn_rate < MAX_SPAWN_RATE) {
  	        idle_spawn_rate *= 2;
  	    }
  	}
      }
      else {
        idle_spawn_rate = 1;
      }
  }
  
  static void server_main_loop(int remaining_children_to_start)
  {
      int child_slot;
      ap_wait_t status;
      int pid;
      int i;
  
      while (!restart_pending && !shutdown_pending) {
          pid = wait_or_timeout(&status);
          
          if (pid >= 0) {
              process_child_status(pid, status);
              /* non-fatal death... note that it's gone in the scoreboard. */
              child_slot = find_child_by_pid(pid);
              if (child_slot >= 0) {
                  for (i = 0; i < ap_threads_per_child; i++)
                      ap_update_child_status(child_slot, i, SERVER_DEAD, (request_rec *) NULL);
                  
  		if (remaining_children_to_start
  		    && child_slot < ap_daemons_limit) {
  		    /* we're still doing a 1-for-1 replacement of dead
                       * children with new children
                       */
                      /* ZZZ abstract out for AP funcs. */
  		    make_child(server_conf, child_slot, time(NULL));
  		    --remaining_children_to_start;
  		}
  #ifdef HAS_OTHER_CHILD
  	    }
  	    else if (reap_other_child(pid, status) == 0) {
  		/* handled */
  #endif
  	    }
  	    else if (is_graceful) {
  		/* Great, we've probably just lost a slot in the
  		    * scoreboard.  Somehow we don't know about this
  		    * child.
  		    */
  		ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_WARNING, server_conf,
  			    "long lost child came home! (pid %d)", pid);
  	    }
  	    /* Don't perform idle maintenance when a child dies,
               * only do it when there's a timeout.  Remember only a
               * finite number of children can die, and it's pretty
               * pathological for a lot to die suddenly.
               */
  	    continue;
  	}
  	else if (remaining_children_to_start) {
  	    /* we hit a 1 second timeout in which none of the previous
  	     * generation of children needed to be reaped... so assume
  	     * they're all done, and pick up the slack if any is left.
  	     */
  	    startup_children(remaining_children_to_start);
  	    remaining_children_to_start = 0;
  	    /* In any event we really shouldn't do the code below because
  	     * few of the servers we just started are in the IDLE state
  	     * yet, so we'd mistakenly create an extra server.
  	     */
  	    continue;
  	}
  
  	perform_idle_server_maintenance();
      }
  }
  
  int ap_mpm_run(ap_context_t *_pconf, ap_context_t *plog, server_rec *s)
  {
      int remaining_children_to_start;
  
      pconf = _pconf;
      server_conf = s;
      port_of_death = create_port(1, "httpd_port_of_death");
  
      if ((num_listenfds = setup_listeners(pconf, server_conf)) < 1) {
          /* XXX: hey, what's the right way for the mpm to indicate a fatal error? */
          ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_ALERT, s,
              "no listening sockets available, shutting down");
          return 1;
      }
      ap_log_pid(pconf, ap_pid_fname);
      SAFE_ACCEPT(accept_mutex_init(pconf, 1));
      if (!is_graceful) {
  	reinit_scoreboard(pconf);
      }
  
      set_signals();
      /* Don't thrash... */
      if (max_spare_threads < min_spare_threads + ap_threads_per_child)
  	max_spare_threads = min_spare_threads + ap_threads_per_child;
  
      /* If we're doing a graceful_restart then we're going to see a lot
       * of children exiting immediately when we get into the main loop
       * below (because we just sent them SIGWINCH).  This happens pretty
       * rapidly... and for each one that exits we'll start a new one until
       * we reach at least daemons_min_free.  But we may be permitted to
       * start more than that, so we'll just keep track of how many we're
       * supposed to start up without the 1 second penalty between each fork.
       */
      remaining_children_to_start = ap_daemons_to_start;
      if (remaining_children_to_start > ap_daemons_limit) {
  	remaining_children_to_start = ap_daemons_limit;
      }
      if (!is_graceful) {
  	startup_children(remaining_children_to_start);
  	remaining_children_to_start = 0;
      }
      else {
  	/* give the system some time to recover before kicking into
  	    * exponential mode */
  	hold_off_on_exponential_spawning = 10;
      }
  
      ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, server_conf,
  		"%s configured -- resuming normal operations",
  		ap_get_server_version());
      ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO, server_conf,
  		"Server built: %s", ap_get_server_built());
      restart_pending = shutdown_pending = 0;
  
      server_main_loop(remaining_children_to_start);
  
      if (shutdown_pending) {
          /* Time to gracefully shut down:
           * Kill child processes, tell them to call child_exit, etc...
           */
          if (ap_killpg(getpgrp(), SIGTERM) < 0) {
              ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "killpg SIGTERM");
          }
          reclaim_child_processes(1);		/* Start with SIGTERM */
      
          /* cleanup pid file on normal shutdown */
          {
              const char *pidfile = NULL;
              pidfile = ap_server_root_relative (pconf, ap_pid_fname);
              if ( pidfile != NULL && unlink(pidfile) == 0)
                  ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_INFO,
              		 server_conf,
              		 "removed PID file %s (pid=%ld)",
              		 pidfile, (long)getpid());
          }
      
          ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, server_conf,
              "caught SIGTERM, shutting down");
      
  	return 1;
      }
  
      /* we've been told to restart */
      signal(SIGHUP, SIG_IGN);
  
      if (one_process) {
  	/* not worth thinking about */
  	return 1;
      }
  
      /* advance to the next generation */
      /* XXX: we really need to make sure this new generation number isn't in
       * use by any of the children.
       */
      ++ap_my_generation;
      ap_scoreboard_image->global.running_generation = ap_my_generation;
      update_scoreboard_global();
  
      if (is_graceful) {
  	int i, j;
          char char_of_death = '!';
  
  	ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, server_conf,
  		    "SIGWINCH received.  Doing graceful restart");
  
  	/* give the children the signal to die */
          for (i = 0; i < ap_daemons_limit;) {
              if (write_port(port_of_death, 99, &char_of_death, 1) != B_OK) {
                  if (errno == EINTR) continue;
                  ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "write pipe_of_death");
              }
              i++;
          }
  
  	/* This is mostly for debugging... so that we know what is still
           * gracefully dealing with existing request.
           */
  	
  	for (i = 0; i < ap_daemons_limit; ++i) {
    	    for (j = 0; j < ap_threads_per_child; j++) { 
  	        if (ap_scoreboard_image->servers[i][j].status != SERVER_DEAD) {
  		    ap_scoreboard_image->servers[i][j].status = SERVER_GRACEFUL;
  		}
  	    } 
  	}
      }
      else {
        /* Kill 'em all.  Since the child acts the same on the parents SIGTERM 
         * and a SIGHUP, we may as well use the same signal, because some user
         * pthreads are stealing signals from us left and right.
         */
  	if (ap_killpg(getpgrp(), SIGTERM) < 0) {
  	    ap_log_error(APLOG_MARK, APLOG_WARNING, server_conf, "killpg SIGTERM");
  	}
          reclaim_child_processes(1);		/* Start with SIGTERM */
  	ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_NOTICE, server_conf,
  		    "SIGHUP received.  Attempting to restart");
      }
      if (!is_graceful) {
          ap_restart_time = time(NULL); /* ZZZZZ */
      }
      delete_port(port_of_death);
      return 0;
  }
  
  static void mpmt_beos_pre_config(ap_context_t *pconf, ap_context_t *plog, ap_context_t *ptemp)
  {
      static int restart_num = 0;
  
      one_process = !!getenv("ONE_PROCESS");
  
      /* sigh, want this only the second time around */
      if (restart_num++ == 1) {
  	is_graceful = 0;
  
  	if (!one_process) {
  	    beosd_detach();
  	}
  
  	my_pid = getpid();
      }
  
      beosd_pre_config();
      ap_listen_pre_config();
      ap_daemons_to_start = DEFAULT_START_DAEMON;
      min_spare_threads = DEFAULT_MIN_FREE_DAEMON * DEFAULT_THREADS_PER_CHILD;
      max_spare_threads = DEFAULT_MAX_FREE_DAEMON * DEFAULT_THREADS_PER_CHILD;
      ap_daemons_limit = HARD_SERVER_LIMIT;
      ap_threads_per_child = DEFAULT_THREADS_PER_CHILD;
      ap_pid_fname = DEFAULT_PIDLOG;
      ap_scoreboard_fname = DEFAULT_SCOREBOARD;
      ap_max_requests_per_child = DEFAULT_MAX_REQUESTS_PER_CHILD;
      ap_extended_status = 0;
  
      ap_cpystrn(ap_coredump_dir, ap_server_root, sizeof(ap_coredump_dir));
  }
  
  static void mpmt_beos_hooks(void)
  {
      ap_hook_pre_config(mpmt_beos_pre_config,NULL,NULL,HOOK_MIDDLE);
      INIT_SIGLIST()
      one_process = 0;
  }
  
  
  static const char *set_pidfile(cmd_parms *cmd, void *dummy, char *arg) 
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      if (cmd->server->is_virtual) {
  	return "PidFile directive not allowed in <VirtualHost>";
      }
      ap_pid_fname = arg;
      return NULL;
  }
  
  static const char *set_scoreboard(cmd_parms *cmd, void *dummy, char *arg) 
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      ap_scoreboard_fname = arg;
      return NULL;
  }
  
  static const char *set_daemons_to_start(cmd_parms *cmd, void *dummy, char *arg) 
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      ap_daemons_to_start = atoi(arg);
      return NULL;
  }
  
  static const char *set_min_spare_threads(cmd_parms *cmd, void *dummy, char *arg)
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      min_spare_threads = atoi(arg);
      if (min_spare_threads <= 0) {
         fprintf(stderr, "WARNING: detected MinSpareThreads set to non-positive.\n");
         fprintf(stderr, "Resetting to 1 to avoid almost certain Apache failure.\n");
         fprintf(stderr, "Please read the documentation.\n");
         min_spare_threads = 1;
      }
         
      return NULL;
  }
  
  static const char *set_max_spare_threads(cmd_parms *cmd, void *dummy, char *arg)
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      max_spare_threads = atoi(arg);
      return NULL;
  }
  
  static const char *set_server_limit (cmd_parms *cmd, void *dummy, char *arg) 
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      ap_daemons_limit = atoi(arg);
      if (ap_daemons_limit > HARD_SERVER_LIMIT) {
         fprintf(stderr, "WARNING: MaxClients of %d exceeds compile time limit "
             "of %d servers,\n", ap_daemons_limit, HARD_SERVER_LIMIT);
         fprintf(stderr, " lowering MaxClients to %d.  To increase, please "
             "see the\n", HARD_SERVER_LIMIT);
         fprintf(stderr, " HARD_SERVER_LIMIT define in src/include/httpd.h.\n");
         ap_daemons_limit = HARD_SERVER_LIMIT;
      } 
      else if (ap_daemons_limit < 1) {
  	fprintf(stderr, "WARNING: Require MaxClients > 0, setting to 1\n");
  	ap_daemons_limit = 1;
      }
      return NULL;
  }
  
  static const char *set_threads_per_child (cmd_parms *cmd, void *dummy, char *arg) 
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      ap_threads_per_child = atoi(arg);
      if (ap_threads_per_child > HARD_THREAD_LIMIT) {
          fprintf(stderr, "WARNING: ThreadsPerChild of %d exceeds compile time"
                  "limit of %d threads,\n", ap_threads_per_child,
                  HARD_THREAD_LIMIT);
          fprintf(stderr, " lowering ThreadsPerChild to %d. To increase, please"
                  "see the\n", HARD_THREAD_LIMIT);
          fprintf(stderr, " HARD_THREAD_LIMIT define in src/include/httpd.h.\n");
      }
      else if (ap_threads_per_child < 1) {
  	fprintf(stderr, "WARNING: Require ThreadsPerChild > 0, setting to 1\n");
  	ap_threads_per_child = 1;
      }
      return NULL;
  }
  
  static const char *set_max_requests(cmd_parms *cmd, void *dummy, char *arg) 
  {
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      ap_max_requests_per_child = atoi(arg);
  
      return NULL;
  }
  
  static const char *set_coredumpdir (cmd_parms *cmd, void *dummy, char *arg) 
  {
      struct stat finfo;
      const char *fname;
      const char *err = ap_check_cmd_context(cmd, GLOBAL_ONLY);
      if (err != NULL) {
          return err;
      }
  
      fname = ap_server_root_relative(cmd->pool, arg);
      /* ZZZ change this to the AP func FileInfo*/
      if ((stat(fname, &finfo) == -1) || !S_ISDIR(finfo.st_mode)) {
  	return ap_pstrcat(cmd->pool, "CoreDumpDirectory ", fname, 
  			  " does not exist or is not a directory", NULL);
      }
      ap_cpystrn(ap_coredump_dir, fname, sizeof(ap_coredump_dir));
      return NULL;
  }
  
  struct ap_thread_mutex {
      be_mutex_t mutex;
  };
  
  API_EXPORT(ap_thread_mutex *) ap_thread_mutex_new(void)
  {
      ap_thread_mutex *mtx;
  
      mtx = malloc(sizeof(ap_thread_mutex));
      be_mutex_init(&(mtx->mutex), NULL);
      return mtx;
  }
  
  API_EXPORT(void) ap_thread_mutex_lock(ap_thread_mutex *mtx)
  {
      /* Ignoring error conditions here. :( */
      be_mutex_lock(&(mtx->mutex));
  }
  
  API_EXPORT(void) ap_thread_mutex_unlock(ap_thread_mutex *mtx)
  {
      /* Here too. */
      be_mutex_unlock(&(mtx->mutex));
  }
  
  API_EXPORT(void) ap_thread_mutex_destroy(ap_thread_mutex *mtx)
  {
      /* Here too. */
      be_mutex_destroy(&(mtx->mutex));
      free(mtx);
  }
  
  
  static const command_rec mpmt_beos_cmds[] = {
  UNIX_DAEMON_COMMANDS
  LISTEN_COMMANDS
  { "PidFile", set_pidfile, NULL, RSRC_CONF, TAKE1,
      "A file for logging the server process ID"},
  { "ScoreBoardFile", set_scoreboard, NULL, RSRC_CONF, TAKE1,
      "A file for Apache to maintain runtime process management information"},
  { "StartServers", set_daemons_to_start, NULL, RSRC_CONF, TAKE1,
    "Number of child processes launched at server startup" },
  { "MinSpareThreads", set_min_spare_threads, NULL, RSRC_CONF, TAKE1,
    "Minimum number of idle children, to handle request spikes" },
  { "MaxSpareThreads", set_max_spare_threads, NULL, RSRC_CONF, TAKE1,
    "Maximum number of idle children" },
  { "MaxClients", set_server_limit, NULL, RSRC_CONF, TAKE1,
    "Maximum number of children alive at the same time" },
  { "ThreadsPerChild", set_threads_per_child, NULL, RSRC_CONF, TAKE1,
    "Number of threads each child creates" },
  { "MaxRequestsPerChild", set_max_requests, NULL, RSRC_CONF, TAKE1,
    "Maximum number of requests a particular child serves before dying." },
  { "CoreDumpDirectory", set_coredumpdir, NULL, RSRC_CONF, TAKE1,
    "The location of the directory Apache changes to before dumping core" },
  { NULL }
  };
  
  module MODULE_VAR_EXPORT mpm_mpmt_beos_module = {
      STANDARD20_MODULE_STUFF,
      NULL,			/* create per-directory config structure */
      NULL,			/* merge per-directory config structures */
      NULL,			/* create per-server config structure */
      NULL,			/* merge per-server config structures */
      mpmt_beos_cmds,		/* command ap_table_t */
      NULL,			/* handlers */
      mpmt_beos_hooks		/* register_hooks */
  };
  
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/mpmt_beos.h
  
  Index: mpmt_beos.h
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   * 
   * Redistribution and use in source and binary forms, with or without 
   * modification, are permitted provided that the following conditions 
   * are met: 
   * 
   * 1. Redistributions of source code must retain the above copyright 
   *    notice, this list of conditions and the following disclaimer.  
   * 
   * 2. Redistributions in binary form must reproduce the above copyright 
   *    notice, this list of conditions and the following disclaimer in 
   *    the documentation and/or other materials provided with the 
   *    distribution. 
   * 
   * 3. All advertising materials mentioning features or use of this 
   *    software must display the following acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * 4. The names "Apache Server" and "Apache Group" must not be used to 
   *    endorse or promote products derived from this software without 
   *    prior written permission. For written permission, please contact 
   *    apache@apache.org. 
   * 
   * 5. Products derived from this software may not be called "Apache" 
   *    nor may "Apache" appear in their names without prior written 
   *    permission of the Apache Group. 
   * 
   * 6. Redistributions of any form whatsoever must retain the following 
   *    acknowledgment: 
   *    "This product includes software developed by the Apache Group 
   *    for use in the Apache HTTP server project (http://www.apache.org/)." 
   * 
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY 
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR 
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
   * OF THE POSSIBILITY OF SUCH DAMAGE. 
   * ==================================================================== 
   * 
   * This software consists of voluntary contributions made by many 
   * individuals on behalf of the Apache Group and was originally based 
   * on public domain software written at the National Center for 
   * Supercomputing Applications, University of Illinois, Urbana-Champaign. 
   * For more information on the Apache Group and the Apache HTTP server 
   * project, please see <http://www.apache.org/>. 
   * 
   */ 
  
  #ifndef APACHE_MPM_MPMT_PTHREAD_H
  #define APACHE_MPM_MPMT_PTHREAD_H
  
  extern int ap_threads_per_child;
  extern int ap_max_requests_per_child;
  extern int ap_pipe_of_death[2];
  extern void clean_child_exit(int);
  extern int ap_extended_status;
  extern void clean_child_exit(int);
  
  #endif /* APACHE_MPM_MPMT_PTHREAD_H */
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/mutex.c
  
  Index: mutex.c
  ===================================================================
  /* This mutex implementation courtesy of Christopher Tate (ctate@be.com) */
  
  // BeOS mutex implementation
  
  #include "mutex.h"
  #include <kernel/OS.h>
  #include <stdio.h>
  
  // mutex operations
  static void lazy_init_mutex(be_mutex_t* mutex)
  {
  	int32 v = atomic_or(&mutex->init, 1);
  	if (2000 == v)			// we're the first, so do the init
  	{
  		be_mutex_init(mutex, NULL);
  	}
  	else							// we're not the first, so wait until the init is finished
  	{
  		while (mutex->init != 9999) snooze(10000);
  	}
  }
  
  status_t be_mutex_init(be_mutex_t* mutex, be_mutexattr_t* attr)
  {
  	if (!mutex) return B_BAD_VALUE;
  	if (mutex->init == 9999) return EALREADY;
  
  	mutex->lock = create_sem(1, "BeMutex");
  	mutex->owner = -1;
  	mutex->init = 9999;
  	return B_OK;
  }
  
  status_t be_mutex_destroy(be_mutex_t* mutex)
  {
  	if (!mutex) return B_BAD_VALUE;
  	if (mutex->init != 9999) return B_NO_INIT;
  	delete_sem(mutex->lock);
  	return B_OK;
  }
  
  status_t be_mutex_lock(be_mutex_t* mutex)
  {
  	status_t err;
  
  	if (!mutex) return B_BAD_VALUE;
  	if (mutex->init < 2000) return B_NO_INIT;
  	lazy_init_mutex(mutex);
  
  	err = acquire_sem(mutex->lock);
  	if (!err) mutex->owner = find_thread(NULL);
  	return err;
  }
  
  status_t be_mutex_unlock(be_mutex_t* mutex)
  {
  	if (!mutex) return B_BAD_VALUE;
  	if (mutex->init < 2000) return B_NO_INIT;
  	lazy_init_mutex(mutex);
  
  	if (mutex->owner != find_thread(NULL)) return ENOLCK;
  	mutex->owner = -1;
  	release_sem(mutex->lock);
  	return B_OK;
  }
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/mutex.h
  
  Index: mutex.h
  ===================================================================
  // BeOS mutex
  
  #ifndef _be_condvar_h
  #define _be_condvar_h 1
  
  #include <kernel/OS.h>
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  typedef struct be_mutex_t
  {
  	int32			init;
  	sem_id			lock;
  	thread_id		owner;
  } be_mutex_t;
  
  #define	BE_MUTEX_INITIALIZER { 2000, -1, -1 }
  
  // attributes are currently unused
  typedef int32 be_mutexattr_t;
  
  // mutex operations
  status_t be_mutex_init(be_mutex_t* mutex, be_mutexattr_t* attr);
  status_t be_mutex_destroy(be_mutex_t* mutex);
  status_t be_mutex_lock(be_mutex_t* mutex);
  status_t be_mutex_unlock(be_mutex_t* mutex);
  
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/poll.c
  
  Index: poll.c
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1999 Ralf S. Engelschall. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer. 
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY RALF S. ENGELSCHALL ``AS IS'' AND ANY
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL RALF S. ENGELSCHALL OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   * ====================================================================
   */
  
  #include <string.h>
  #include <sys/types.h>
  #include <sys/stat.h>
  #include <sys/socket.h>
  #include <sys/time.h>
  #include <time.h>
  #include <errno.h>
  #include <unistd.h>
  
  #include "poll.h"
  
  /* 
   * Emulate SysV poll(2) with BSD select(2)
   * Written in June 1999 by Ralf S. Engelschall <rse@engelschall.com>
   */
  
  int poll(struct pollfd *pfd, unsigned int nfd, int timeout)
  {
      fd_set rfds, wfds, efds;
      struct timeval tv, *ptv;
      int maxfd, rc, i, ok;
      char data[64];
  
      /* poll(2) semantics */
      if (pfd == NULL) {
          errno = EFAULT;
          return -1;
      }
  
      /* convert timeout number into a timeval structure */
      ptv = &tv;
      if (timeout == 0) {
          /* return immediately */
          ptv->tv_sec  = 0;
          ptv->tv_usec = 0;
      }
      else if (timeout == INFTIM) {
          /* wait forever */
          ptv = NULL;
      }
      else {
          /* return after timeout */
          ptv->tv_sec  = timeout / 1000;
          ptv->tv_usec = (timeout % 1000) * 1000;
      }
  
      /* clean illegal fd set and (re)enter the repeat loop */
  
      /* create fd sets and determine max fd */
      maxfd = 0;
      FD_ZERO(&rfds);
      FD_ZERO(&wfds);
      FD_ZERO(&efds);
      for(i = 0; i < nfd; i++) {
          if (pfd[i].fd < 0) {
              continue;
          }
          if (pfd[i].events & POLLIN)
              FD_SET(pfd[i].fd, &rfds);
          if (pfd[i].events & POLLOUT)
              FD_SET(pfd[i].fd, &wfds);
          if (pfd[i].events & POLLPRI)
              FD_SET(pfd[i].fd, &efds);
          if (pfd[i].fd >= maxfd && (pfd[i].events & (POLLIN|POLLOUT|POLLPRI)))
              maxfd = pfd[i].fd;
      }
  
      /* examine fd sets */
      rc = select(maxfd+1, &rfds, &wfds, &efds, ptv);
  
      /* establish results */
      if (rc > 0) {
          rc = 0;
          for (i = 0; i < nfd; i++) {
              ok = 0;
              pfd[i].revents = 0;
              if (pfd[i].fd < 0) {
                  /* support for POLLNVAL */
                  pfd[i].revents |= POLLNVAL;
                  continue;
              }
              if (FD_ISSET(pfd[i].fd, &rfds)) {
                  pfd[i].revents |= POLLIN;
                  ok++;
                  /* support for POLLHUP */
                  if (recv(pfd[i].fd, data, 0, 0) == -1) {
                      if (   errno == ESHUTDOWN    || errno == ECONNRESET
                          || errno == ECONNABORTED || errno == ENETRESET) {
                          pfd[i].revents &= ~(POLLIN);
                          pfd[i].revents |= POLLHUP;
                          ok--;
                      }
                  }
              }
              if (FD_ISSET(pfd[i].fd, &wfds)) {
                  pfd[i].revents |= POLLOUT;
                  ok++;
              }
              if (FD_ISSET(pfd[i].fd, &efds)) {
                  pfd[i].revents |= POLLPRI;
                  ok++;
              }
              if (ok)
                  rc++;
          }
      }
      return rc;
  }
  
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/poll.h
  
  Index: poll.h
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1999 Ralf S. Engelschall. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer. 
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * THIS SOFTWARE IS PROVIDED BY RALF S. ENGELSCHALL ``AS IS'' AND ANY
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL RALF S. ENGELSCHALL OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   * ====================================================================
   */
  
  #ifndef _POLL_H_
  #define _POLL_H_
  
  #define LIBPOLL_VERSION 19990812
  
  #ifndef POLLIN
  #define POLLIN      0x0001      /* any readable data available */
  #endif
  #ifndef POLLPRI
  #define POLLPRI     0x0002      /* OOB/Urgent readable data */
  #endif
  #ifndef POLLOUT
  #define POLLOUT     0x0004      /* file descriptor is writeable */
  #endif
  
  #ifndef POLLERR
  #define POLLERR     0x0008      /* some poll error occurred */
  #endif
  #ifndef POLLHUP
  #define POLLHUP     0x0010      /* file descriptor was "hung up" */
  #endif
  #ifndef POLLNVAL
  #define POLLNVAL    0x0020      /* requested events "invalid" */
  #endif
  
  #ifndef POLLRDNORM
  #define POLLRDNORM  POLLIN
  #endif
  #ifndef POLLRDBAND
  #define POLLRDBAND  POLLIN
  #endif
  #ifndef POLLWRNORM
  #define POLLWRNORM  POLLOUT
  #endif
  #ifndef POLLWRBAND
  #define POLLWRBAND  POLLOUT
  #endif
  
  #ifndef INFTIM
  #define INFTIM      (-1)
  #endif
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  struct pollfd {
      int fd;                     /* which file descriptor to poll */
      short events;               /* events we are interested in */
      short revents;              /* events found on return */
  };
  
  int poll(struct pollfd *, unsigned int, int);
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif /* _POLL_H_ */
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/scoreboard.c
  
  Index: scoreboard.c
  ===================================================================
  #include "httpd.h"
  #include "http_log.h"
  #include "http_main.h"
  #include "http_core.h"
  #include "http_config.h"
  #include "beosd.h"
  #include "http_conf_globals.h"
  #include "mpmt_beos.h"
  #include "scoreboard.h"
  
  scoreboard *ap_scoreboard_image = NULL;
  //static char *ap_server_argv0=NULL;
  extern ap_context_t * pconf;
  
  /*****************************************************************
   *
   * Dealing with the scoreboard... a lot of these variables are global
   * only to avoid getting clobbered by the longjmp() that happens when
   * a hard timeout expires...
   *
   * We begin with routines which deal with the file itself... 
   */
  
  void reinit_scoreboard(ap_context_t *p)
  {
      ap_assert(!ap_scoreboard_image);
      ap_scoreboard_image = (scoreboard *) malloc(SCOREBOARD_SIZE);
      if (ap_scoreboard_image == NULL) {
          fprintf(stderr, "Ouch! Out of memory reiniting scoreboard!\n");
      }
      memset(ap_scoreboard_image, 0, SCOREBOARD_SIZE);
  }
  
  void cleanup_scoreboard(void)
  {
      ap_assert(ap_scoreboard_image);
      free(ap_scoreboard_image);
      ap_scoreboard_image = NULL;
  }
  
  API_EXPORT(void) reopen_scoreboard(ap_context_t *p)
  {
  }
  
  API_EXPORT(void) ap_sync_scoreboard_image(void)
  {
  }
  
  API_EXPORT(int) ap_exists_scoreboard_image(void)
  {
      return (ap_scoreboard_image ? 1 : 0);
  }
  
  static ap_inline void put_scoreboard_info(int child_num, int thread_num, 
  				       thread_score *new_score_rec)
  {
      /* XXX - needs to be fixed to account for threads */
  }
  
  void update_scoreboard_global(void)
  {
  }
  
  void increment_counts(int child_num, int thread_num, request_rec *r)
  {
      long int bs = 0;
      thread_score *ss;
  
      ss = &ap_scoreboard_image->servers[child_num][thread_num];
  
      if (r->sent_bodyct)
  	ap_bgetopt(r->connection->client, BO_BYTECT, &bs);
  
  #ifndef NO_TIMES
      times(&ss->times);
  #endif
      ss->access_count++;
      ss->my_access_count++;
      ss->conn_count++;
      ss->bytes_served += (unsigned long) bs;
      ss->my_bytes_served += (unsigned long) bs;
      ss->conn_bytes += (unsigned long) bs;
  
      put_scoreboard_info(child_num, thread_num, ss);
  
  }
  
  API_EXPORT(int) find_child_by_pid(int pid)
  {
      int i;
      int max_daemons_limit = ap_get_max_daemons();
  
      for (i = 0; i < max_daemons_limit; ++i)
  	if (ap_scoreboard_image->parent[i].pid == pid)
  	    return i;
  
      return -1;
  }
  
  int ap_update_child_status(int child_num, int thread_num, int status, request_rec *r)
  {
      int old_status;
      thread_score *ss;
      parent_score *ps;
  
      if (child_num < 0)
  	return -1;
  
      ss = &ap_scoreboard_image->servers[child_num][thread_num];
      old_status = ss->status;
      ss->status = status;
  
      ps = &ap_scoreboard_image->parent[child_num];
      
      if ((status == SERVER_READY  || status == SERVER_ACCEPTING)
  	&& old_status == SERVER_STARTING) {
          ss->tid = find_thread(NULL);
  	ps->worker_threads = ap_threads_per_child;
      }
  
      if (ap_extended_status) {
  	if (status == SERVER_READY || status == SERVER_DEAD) {
  	    /*
  	     * Reset individual counters
  	     */
  	    if (status == SERVER_DEAD) {
  		ss->my_access_count = 0L;
  		ss->my_bytes_served = 0L;
  	    }
  	    ss->conn_count = (unsigned short) 0;
  	    ss->conn_bytes = (unsigned long) 0;
  	}
  	if (r) {
  	    conn_rec *c = r->connection;
  	    ap_cpystrn(ss->client, ap_get_remote_host(c, r->per_dir_config,
  				  REMOTE_NOLOOKUP), sizeof(ss->client));
  	    if (r->the_request == NULL) {
  		    ap_cpystrn(ss->request, "NULL", sizeof(ss->request));
  	    } else if (r->parsed_uri.password == NULL) {
  		    ap_cpystrn(ss->request, r->the_request, sizeof(ss->request));
  	    } else {
  		/* Don't reveal the password in the server-status view */
  		    ap_cpystrn(ss->request, ap_pstrcat(r->pool, r->method, " ",
  					       ap_unparse_uri_components(r->pool, &r->parsed_uri, UNP_OMITPASSWORD),
  					       r->assbackwards ? NULL : " ", r->protocol, NULL),
  				       sizeof(ss->request));
  	    }
  	    ss->vhostrec =  r->server;
  	}
      }
      
      put_scoreboard_info(child_num, thread_num, ss);
      return old_status;
  }
  
  void ap_time_process_request(int child_num, int thread_num, int status)
  {
      thread_score *ss;
  
      if (child_num < 0)
  	return;
  
      ss = &ap_scoreboard_image->servers[child_num][thread_num];
  
      if (status == START_PREQUEST) {
        /*ss->start_time = GetCurrentTime(); ZZZ return time in uS since the 
  	epoch. Some platforms do not support gettimeofday. Create a routine 
  	to get the current time is some useful units. */
          if (gettimeofday(&ss->start_time, (struct timezone *) 0) < 0) {
              ss->start_time.tv_sec = ss->start_time.tv_usec = 0L;
          }
      }
      else if (status == STOP_PREQUEST) {
        /*ss->stop_time = GetCurrentTime(); 
  	ZZZ return time in uS since the epoch */
          
          if (gettimeofday(&ss->stop_time, (struct timezone *) 0) < 0) {
              ss->start_time.tv_sec = ss->start_time.tv_usec = 0L;
          }
      }
      put_scoreboard_info(child_num, thread_num, ss);
  }
  
  
  
  1.1                  apache-2.0/src/modules/mpm/mpmt_beos/scoreboard.h
  
  Index: scoreboard.h
  ===================================================================
  /* ====================================================================
   * Copyright (c) 1995-1999 The Apache Group.  All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer. 
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. All advertising materials mentioning features or use of this
   *    software must display the following acknowledgment:
   *    "This product includes software developed by the Apache Group
   *    for use in the Apache HTTP server project (http://www.apache.org/)."
   *
   * 4. The names "Apache Server" and "Apache Group" must not be used to
   *    endorse or promote products derived from this software without
   *    prior written permission. For written permission, please contact
   *    apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache"
   *    nor may "Apache" appear in their names without prior written
   *    permission of the Apache Group.
   *
   * 6. Redistributions of any form whatsoever must retain the following
   *    acknowledgment:
   *    "This product includes software developed by the Apache Group
   *    for use in the Apache HTTP server project (http://www.apache.org/)."
   *
   * THIS SOFTWARE IS PROVIDED BY THE APACHE GROUP ``AS IS'' AND ANY
   * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE APACHE GROUP OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Group and was originally based
   * on public domain software written at the National Center for
   * Supercomputing Applications, University of Illinois, Urbana-Champaign.
   * For more information on the Apache Group and the Apache HTTP server
   * project, please see <http://www.apache.org/>.
   *
   */
  
  #ifndef APACHE_SCOREBOARD_H
  #define APACHE_SCOREBOARD_H
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  #ifndef WIN32
  #ifdef TPF
  #include <time.h>
  #else
  #include <sys/times.h>
  #endif /* TPF */
  #endif
  
  #include "mpm_default.h"	/* For HARD_.*_LIMIT */
  
  /* Scoreboard info on a process is, for now, kept very brief --- 
   * just status value and pid (the latter so that the caretaker process
   * can properly update the scoreboard when a process dies).  We may want
   * to eventually add a separate set of long_score structures which would
   * give, for each process, the number of requests serviced, and info on
   * the current, or most recent, request.
   *
   * Status values:
   */
  
  #define SERVER_DEAD 0
  #define SERVER_STARTING 1	/* Server Starting up */
  #define SERVER_READY 2		/* Waiting for connection (or accept() lock) */
  #define SERVER_BUSY_READ 3	/* Reading a client request */
  #define SERVER_BUSY_WRITE 4	/* Processing a client request */
  #define SERVER_BUSY_KEEPALIVE 5	/* Waiting for more requests via keepalive */
  #define SERVER_BUSY_LOG 6	/* Logging the request */
  #define SERVER_BUSY_DNS 7	/* Looking up a hostname */
  #define SERVER_GRACEFUL 8	/* server is gracefully finishing request */
  #define SERVER_ACCEPTING 9	/* thread is accepting connections */
  #define SERVER_QUEUEING	10      /* thread is putting connection on the queue */
  #define SERVER_NUM_STATUS 11	/* number of status settings */
  
  /* A "virtual time" is simply a counter that indicates that a child is
   * making progress.  The parent checks up on each child, and when they have
   * made progress it resets the last_rtime element.  But when the child hasn't
   * made progress in a time that's roughly timeout_len seconds long, it is
   * sent a SIGALRM.
   *
   * vtime is an optimization that is used only when the scoreboard is in
   * shared memory (it's not easy/feasible to do it in a scoreboard file).
   * The essential observation is that timeouts rarely occur, the vast majority
   * of hits finish before any timeout happens.  So it really sucks to have to
   * ask the operating system to set up and destroy alarms many times during
   * a request.
   */
  typedef unsigned vtime_t;
  
  /* Type used for generation indicies.  Startup and every restart cause a
   * new generation of children to be spawned.  Children within the same
   * generation share the same configuration information -- pointers to stuff
   * created at config time in the parent are valid across children.  For
   * example, the vhostrec pointer in the scoreboard below is valid in all
   * children of the same generation.
   *
   * The safe way to access the vhost pointer is like this:
   *
   * short_score *ss = pointer to whichver slot is interesting;
   * parent_score *ps = pointer to whichver slot is interesting;
   * server_rec *vh = ss->vhostrec;
   *
   * if (ps->generation != ap_my_generation) {
   *     vh = NULL;
   * }
   *
   * then if vh is not NULL it's valid in this child.
   *
   * This avoids various race conditions around restarts.
   */
  typedef int ap_generation_t;
  
  /* stuff which is thread specific */
  typedef struct {
  #ifdef OPTIMIZE_TIMEOUTS
      vtime_t cur_vtime;		/* the child's current vtime */
      unsigned short timeout_len;	/* length of the timeout */
  #endif
      thread_id tid;
      unsigned char status;
      unsigned long access_count;
      unsigned long bytes_served;
      unsigned long my_access_count;
      unsigned long my_bytes_served;
      unsigned long conn_bytes;
      unsigned short conn_count;
  #if defined(NO_GETTIMEOFDAY)
      clock_t start_time;
      clock_t stop_time;
  #else
      struct timeval start_time;
      struct timeval stop_time;
  #endif
  #ifndef NO_TIMES
      struct tms times;
  #endif
  #ifndef OPTIMIZE_TIMEOUTS
      time_t last_used;
  #endif
      char client[32];		/* Keep 'em small... */
      char request[64];		/* We just want an idea... */
      server_rec *vhostrec;	/* What virtual host is being accessed? */
                                  /* SEE ABOVE FOR SAFE USAGE! */
  } thread_score;
  
  typedef struct {
      ap_generation_t running_generation;	/* the generation of children which
                                           * should still be serving requests. */
  } global_score;
  
  /* stuff which the parent generally writes and the children rarely read */
  typedef struct {
      pid_t pid;
      ap_generation_t generation;	/* generation of this child */
      int worker_threads;
  #ifdef OPTIMIZE_TIMEOUTS
      time_t last_rtime;		/* time(0) of the last change */
      vtime_t last_vtime;		/* the last vtime the parent has seen */
  #endif
  } parent_score;
  
  typedef struct {
      thread_score servers[HARD_SERVER_LIMIT][HARD_THREAD_LIMIT];
      parent_score parent[HARD_SERVER_LIMIT];
      global_score global;
  } scoreboard;
  
  #define SCOREBOARD_SIZE		sizeof(scoreboard)
  #ifdef TPF
  #define SCOREBOARD_NAME		"SCOREBRD"
  #define SCOREBOARD_FRAMES		SCOREBOARD_SIZE/4095 + 1
  #endif
  
  API_EXPORT(int) ap_exists_scoreboard_image(void);
  void reinit_scoareboard(ap_context_t *p);
  void cleanup_scoreboard(void);
  API_EXPORT(void) ap_sync_scoreboard_image(void);
  
  #if defined(USE_OS2_SCOREBOARD)
  caddr_t create_shared_heap(const char *name, size_t size);
  caddr_t get_shared_heap(const char *Name);
  #elif defined(USE_POSIX_SCOREBOARD)
  static void cleanup_shared_mem(void *d);
  #else
  void reinit_scoreboard(ap_context_t *p);
  #endif
  
  API_EXPORT(void) reopen_scoreboard(ap_context_t *p);
  
  ap_inline void ap_sync_scoreboard_image(void);
  void increment_counts(int child_num, int thread_num, request_rec *r);
  void update_scoreboard_global(void);
  API_EXPORT(int) find_child_by_pid(int pid);
  int ap_update_child_status(int child_num, int thread_num, int status, request_rec *r);
  void ap_time_process_request(int child_num, int thread_num, int status);
  
  
  
  API_VAR_EXPORT extern scoreboard *ap_scoreboard_image;
  
  API_VAR_EXPORT extern ap_generation_t volatile ap_my_generation;
  
  /* for time_process_request() in http_main.c */
  #define START_PREQUEST 1
  #define STOP_PREQUEST  2
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif	/* !APACHE_SCOREBOARD_H */
  
  
  

Mime
View raw message