httpd-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@hyperreal.org
Subject cvs commit: apache-apr/pthreads/src/main http_main.c
Date Fri, 19 Feb 1999 20:35:43 GMT
rbb         99/02/19 12:35:42

  Modified:    pthreads/src/main http_main.c
  Log:
  Logic to serialize per socket, instead of one mutex for the whole server.
  Probably not optimal yet, but this will still improve our performance.
  
  Revision  Changes    Path
  1.50      +245 -178  apache-apr/pthreads/src/main/http_main.c
  
  Index: http_main.c
  ===================================================================
  RCS file: /home/cvs/apache-apr/pthreads/src/main/http_main.c,v
  retrieving revision 1.49
  retrieving revision 1.50
  diff -u -r1.49 -r1.50
  --- http_main.c	1999/02/19 20:33:23	1.49
  +++ http_main.c	1999/02/19 20:35:41	1.50
  @@ -253,7 +253,6 @@
   
   static server_rec *server_conf;
   static struct pollfd *listenfds;   /* ZZZZZ abstract fd_set */ 
  -static int num_listenfds;   /* ZZZZZ abstract num_listenfds */
   static pid_t pgrp;
   
   /* one_process --- debugging mode variable; can be set from the command line
  @@ -435,11 +434,13 @@
   /******  ZZZ this should probably be abstracted to it's own file.   ****/
   
   #if defined(USE_FCNTL_SERIALIZED_ACCEPT) || defined(USE_FLOCK_SERIALIZED_ACCEPT)
  -static void expand_lock_fname(pool *p)
  +char * expand_lock_fname(pool *p, int i)
   {
  +    char *fname; 
       /* XXXX possibly bogus cast */
  -    ap_lock_fname = ap_psprintf(p, "%s.%lu",
  -	ap_server_root_relative(p, ap_lock_fname), (unsigned long)getpid());
  +    fname = ap_psprintf(p, "%s.%d",
  +	ap_server_root_relative(p, ap_lock_fname), i, (unsigned long)getpid());
  +    return fname;
   }
   #endif
   
  @@ -447,7 +448,7 @@
   
   #include <ulocks.h>
   
  -static ulock_t uslock = NULL;
  +static ulock_t *uslock = NULL;
   
   #define accept_mutex_child_init(x)
   
  @@ -455,36 +456,40 @@
   {
       ptrdiff_t old;
       usptr_t *us;
  +    int i;
   
  +    uslock = (ulock_t *)ap_palloc(p, ap_acceptors_per_child * sizeof(ulock_t));
   
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
       /* default is 8, allocate enough for all the children plus the parent */
  -    if ((old = usconfig(CONF_INITUSERS, HARD_SERVER_LIMIT + 1)) == -1) {
  -	perror("usconfig(CONF_INITUSERS)");
  -	exit(-1);
  -    }
  -
  -    if ((old = usconfig(CONF_LOCKTYPE, US_NODEBUG)) == -1) {
  -	perror("usconfig(CONF_LOCKTYPE)");
  -	exit(-1);
  -    }
  -    if ((old = usconfig(CONF_ARENATYPE, US_SHAREDONLY)) == -1) {
  -	perror("usconfig(CONF_ARENATYPE)");
  -	exit(-1);
  -    }
  -    if ((us = usinit("/dev/zero")) == NULL) {
  -	perror("usinit");
  -	exit(-1);
  -    }
  -
  -    if ((uslock = usnewlock(us)) == NULL) {
  -	perror("usnewlock");
  -	exit(-1);
  +        if ((old = usconfig(CONF_INITUSERS, HARD_SERVER_LIMIT + 1)) == -1) {
  +	    perror("usconfig(CONF_INITUSERS)");
  +	    exit(-1);
  +	}
  +	
  +	if ((old = usconfig(CONF_LOCKTYPE, US_NODEBUG)) == -1) {
  +	    perror("usconfig(CONF_LOCKTYPE)");
  +	    exit(-1);
  +	}
  +	if ((old = usconfig(CONF_ARENATYPE, US_SHAREDONLY)) == -1) {
  +	    perror("usconfig(CONF_ARENATYPE)");
  +	    exit(-1);
  +	}
  +	if ((us = usinit("/dev/zero")) == NULL) {
  +	    perror("usinit");
  +	    exit(-1);
  +	}
  +	
  +	if ((uslock[i] = usnewlock(us)) == NULL) {
  +	    perror("usnewlock");
  +	    exit(-1);
  +	}
       }
   }
   
  -static void accept_mutex_on(void)
  +static void accept_mutex_on(int locknum)
   {
  -    switch (ussetlock(uslock)) {
  +    switch (ussetlock(uslock[locknum])) {
       case 1:
   	/* got lock */
   	break;
  @@ -497,9 +502,9 @@
       }
   }
   
  -static void accept_mutex_off(void)
  +static void accept_mutex_off(int locknum)
   {
  -    if (usunsetlock(uslock) == -1) {
  +    if (usunsetlock(uslock[locknum]) == -1) {
   	perror("usunsetlock");
   	clean_child_exit(APEXIT_CHILDFATAL);
       }
  @@ -515,19 +520,22 @@
   
   #include <pthread.h>
   
  -static pthread_mutex_t *accept_mutex = (void *)(caddr_t) -1;
  -static int have_accept_mutex;
  +static pthread_mutex_t **accept_mutex = (void *)(caddr_t) -1;
  +static int *have_accept_mutex;
   static sigset_t accept_block_mask;
   static sigset_t accept_previous_mask;
   
   static void accept_mutex_child_cleanup(void *foo)
   {
  -    if (accept_mutex != (void *)(caddr_t)-1
  -	&& have_accept_mutex) {
  -	pthread_mutex_unlock(accept_mutex);
  +    int i;
  +   
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        if (accept_mutex[i] != (void *)(caddr_t)-1
  +	      && have_accept_mutex[i]) {
  +  	    pthread_mutex_unlock(accept_mutex[i]);
  +	}
       }
   }
  -
   static void accept_mutex_child_init(pool *p)
   {
       ap_register_cleanup(p, NULL, accept_mutex_child_cleanup, ap_null_cleanup);
  @@ -535,51 +543,65 @@
   
   static void accept_mutex_cleanup(void *foo)
   {
  -    if (accept_mutex != (void *)(caddr_t)-1
  -	&& munmap((caddr_t) accept_mutex, sizeof(*accept_mutex))) {
  -	perror("munmap");
  +    int i;
  +   
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        if (accept_mutex[i] != (void *)(caddr_t)-1
  +	      && munmap((caddr_t) accept_mutex[i], sizeof(pthread_mutex_t))) {
  +	    perror("munmap");
  +	}
  +	accept_mutex[i] = (void *)(caddr_t)-1;
       }
  -    accept_mutex = (void *)(caddr_t)-1;
   }
   
   static void accept_mutex_init(pool *p)
   {
       pthread_mutexattr_t mattr;
       int fd;
  +    int i;
  +   
  +    accept_mutex = (pthread_mutex_t *)ap_palloc(p, 
  +		    ap_acceptors_per_child * sizeof(pthread_mutex_t *));
  +    have_accept_mutex = (int *)ap_palloc(p, 
  +		    ap_acceptors_per_child * sizeof(int));
  +
   
  -    fd = open("/dev/zero", O_RDWR);
  -    if (fd == -1) {
  -	perror("open(/dev/zero)");
  -	exit(APEXIT_INIT);
  -    }
  -    accept_mutex = (pthread_mutex_t *) mmap((caddr_t) 0, sizeof(*accept_mutex),
  -				 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  -    if (accept_mutex == (void *) (caddr_t) - 1) {
  -	perror("mmap");
  -	exit(APEXIT_INIT);
  -    }
  -    close(fd);
  -    if ((errno = pthread_mutexattr_init(&mattr))) {
  -	perror("pthread_mutexattr_init");
  -	exit(APEXIT_INIT);
  -    }
  -    if ((errno = pthread_mutexattr_setpshared(&mattr,
  -						PTHREAD_PROCESS_SHARED))) {
  -	perror("pthread_mutexattr_setpshared");
  -	exit(APEXIT_INIT);
  -    }
  -    if ((errno = pthread_mutex_init(accept_mutex, &mattr))) {
  -	perror("pthread_mutex_init");
  -	exit(APEXIT_INIT);
  -    }
  -    sigfillset(&accept_block_mask);
  -    sigdelset(&accept_block_mask, SIGHUP);
  -    sigdelset(&accept_block_mask, SIGTERM);
  -    sigdelset(&accept_block_mask, SIGWINCH);
  -    ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        fd = open("/dev/zero", O_RDWR);
  +	if (fd == -1) {
  +	    perror("open(/dev/zero)");
  +	    exit(APEXIT_INIT);
  +	}
  +	accept_mutex[i] = (pthread_mutex_t *) mmap((caddr_t) 0, 
  +						   sizeof(*accept_mutex),
  +						   PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  +	if (accept_mutex[i] == (void *) (caddr_t) - 1) {
  +	    perror("mmap");
  +	    exit(APEXIT_INIT);
  +	}
  +	close(fd);
  +	if ((errno = pthread_mutexattr_init(&mattr))) {
  +	    perror("pthread_mutexattr_init");
  +	    exit(APEXIT_INIT);
  +	}
  +	if ((errno = pthread_mutexattr_setpshared(&mattr,
  +						  PTHREAD_PROCESS_SHARED))) {
  +	    perror("pthread_mutexattr_setpshared");
  +	    exit(APEXIT_INIT);
  +	}
  +	if ((errno = pthread_mutex_init(accept_mutex, &mattr))) {
  +	    perror("pthread_mutex_init");
  +	    exit(APEXIT_INIT);
  +	}
  +	sigfillset(&accept_block_mask);
  +	sigdelset(&accept_block_mask, SIGHUP);
  +	sigdelset(&accept_block_mask, SIGTERM);
  +	sigdelset(&accept_block_mask, SIGWINCH);
  +	ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
  +    }
   }
   
  -static void accept_mutex_on(void)
  +static void accept_mutex_on(int locknum)
   {
       int err;
   
  @@ -587,19 +609,19 @@
   	perror("sigprocmask(SIG_BLOCK)");
   	clean_child_exit(APEXIT_CHILDFATAL);
       }
  -    if ((err = pthread_mutex_lock(accept_mutex))) {
  +    if ((err = pthread_mutex_lock(accept_mutex[locknum]))) {
   	errno = err;
   	perror("pthread_mutex_lock");
   	clean_child_exit(APEXIT_CHILDFATAL);
       }
  -    have_accept_mutex = 1;
  +    have_accept_mutex[locknum] = 1;
   }
   
  -static void accept_mutex_off(void)
  +static void accept_mutex_off(int locknum)
   {
       int err;
   
  -    if ((err = pthread_mutex_unlock(accept_mutex))) {
  +    if ((err = pthread_mutex_unlock(accept_mutex[locknum]))) {
   	errno = err;
   	perror("pthread_mutex_unlock");
   	clean_child_exit(APEXIT_CHILDFATAL);
  @@ -617,7 +639,7 @@
        * child might be in the critical section ... at least it's still serving
        * hits.
        */
  -    have_accept_mutex = 0;
  +    have_accept_mutex[locknum] = 0;
       if (sigprocmask(SIG_SETMASK, &accept_previous_mask, NULL)) {
   	perror("sigprocmask(SIG_SETMASK)");
   	clean_child_exit(1);
  @@ -640,7 +662,7 @@
   
   #endif
   
  -static int sem_id = -1;
  +static int *sem_id = NULL;
   static struct sembuf op_on;
   static struct sembuf op_off;
   
  @@ -651,12 +673,15 @@
   static void accept_mutex_cleanup(void *foo)
   {
       union semun ick;
  +    int i;
   
  -    if (sem_id < 0)
  -	return;
  -    /* this is ignored anyhow */
  -    ick.val = 0;
  -    semctl(sem_id, 0, IPC_RMID, ick);
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        if (sem_id[i] < 0)
  +	  return;
  +	/* this is ignored anyhow */
  +	ick.val = 0;
  +	semctl(sem_id[i], 0, IPC_RMID, ick);
  +    }
   }
   
   #define accept_mutex_child_init(x)
  @@ -665,53 +690,58 @@
   {
       union semun ick;
       struct semid_ds buf;
  +    int i;
  +   
  +    sem_id = (int *)ap_palloc(p, ap_acceptors_per_child * sizeof(int));
   
  -    /* acquire the semaphore */
  -    sem_id = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
  -    if (sem_id < 0) {
  -	perror("semget");
  -	exit(APEXIT_INIT);
  -    }
  -    ick.val = 1;
  -    if (semctl(sem_id, 0, SETVAL, ick) < 0) {
  -	perror("semctl(SETVAL)");
  -	exit(APEXIT_INIT);
  -    }
  -    if (!getuid()) {
  -	/* restrict it to use only by the appropriate user_id ... not that this
  -	 * stops CGIs from acquiring it and dinking around with it.
  -	 */
  -	buf.sem_perm.uid = ap_user_id;
  -	buf.sem_perm.gid = ap_group_id;
  -	buf.sem_perm.mode = 0600;
  -	ick.buf = &buf;
  -	if (semctl(sem_id, 0, IPC_SET, ick) < 0) {
  -	    perror("semctl(IPC_SET)");
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        /* acquire the semaphore */
  +        sem_id[i] = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
  +	if (sem_id[i] < 0) {
  +	    perror("semget");
   	    exit(APEXIT_INIT);
   	}
  -    }
  -    ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
  +	ick.val = 1;
  +	if (semctl(sem_id[i], 0, SETVAL, ick) < 0) {
  +	    perror("semctl(SETVAL)");
  +	    exit(APEXIT_INIT);
  +	}
  +	if (!getuid()) {
  +	  /* restrict it to use only by the appropriate user_id ... not that this
  +	   * stops CGIs from acquiring it and dinking around with it.
  +	   */
  +	    buf.sem_perm.uid = ap_user_id;
  +	    buf.sem_perm.gid = ap_group_id;
  +	    buf.sem_perm.mode = 0600;
  +	    ick.buf = &buf;
  +	    if (semctl(sem_id[i], 0, IPC_SET, ick) < 0) {
  +	      perror("semctl(IPC_SET)");
  +	      exit(APEXIT_INIT);
  +	    }
  +	}
  +	ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
   
  -    /* pre-initialize these */
  -    op_on.sem_num = 0;
  -    op_on.sem_op = -1;
  -    op_on.sem_flg = SEM_UNDO;
  -    op_off.sem_num = 0;
  -    op_off.sem_op = 1;
  -    op_off.sem_flg = SEM_UNDO;
  +	/* pre-initialize these */
  +	op_on.sem_num = 0;
  +	op_on.sem_op = -1;
  +	op_on.sem_flg = SEM_UNDO;
  +	op_off.sem_num = 0;
  +	op_off.sem_op = 1;
  +	op_off.sem_flg = SEM_UNDO;
  +    }
   }
   
  -static void accept_mutex_on(void)
  +static void accept_mutex_on(int locknum)
   {
  -    if (semop(sem_id, &op_on, 1) < 0) {
  +    if (semop(sem_id[locknum], &op_on, 1) < 0) {
   	perror("accept_mutex_on");
   	clean_child_exit(APEXIT_CHILDFATAL);
       }
   }
   
  -static void accept_mutex_off(void)
  +static void accept_mutex_off(int locknum)
   {
  -    if (semop(sem_id, &op_off, 1) < 0) {
  +    if (semop(sem_id[locknum], &op_off, 1) < 0) {
   	perror("accept_mutex_off");
   	clean_child_exit(APEXIT_CHILDFATAL);
       }
  @@ -721,7 +751,7 @@
   static struct flock lock_it;
   static struct flock unlock_it;
   
  -static int lock_fd = -1;
  +static int *lock_fd = NULL;
   
   #define accept_mutex_child_init(x)
   
  @@ -731,6 +761,9 @@
    */
   static void accept_mutex_init(pool *p)
   {
  +    int i;
  +    char * lock_fname;
  +    lock_fd = (int *)ap_palloc(p, ap_acceptors_per_child * sizeof(int *));
   
       lock_it.l_whence = SEEK_SET;	/* from current point */
       lock_it.l_start = 0;		/* -"- */
  @@ -743,21 +776,25 @@
       unlock_it.l_type = F_UNLCK;		/* set exclusive/write lock */
       unlock_it.l_pid = 0;		/* pid not actually interesting */
   
  -    expand_lock_fname(p);
  -    lock_fd = ap_popenf(p, ap_lock_fname, O_CREAT | O_WRONLY | O_EXCL, 0644);
  -    if (lock_fd == -1) {
  -	perror("open");
  -	fprintf(stderr, "Cannot open lock file: %s\n", ap_lock_fname);
  -	exit(APEXIT_INIT);
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        lock_fname = expand_lock_fname(p, i);
  +	lock_fd[i] = ap_popenf(p, lock_fname, 
  +			       O_CREAT | O_WRONLY | O_EXCL, 0644);
  +	if (lock_fd[i] == -1) {
  +	    perror("open");
  +	    fprintf(stderr, "Cannot open lock file: %s\n", lock_fname);
  +	    exit(APEXIT_INIT);
  +	}
  +	unlink(lock_fname);
       }
  -    unlink(ap_lock_fname);
   }
   
  -static void accept_mutex_on(void)
  +static void accept_mutex_on(int locknum)
   {
       int ret;
   
  -    while ((ret = fcntl(lock_fd, F_SETLKW, &lock_it)) < 0 && errno != EINTR)
{
  +    while ((ret = fcntl(lock_fd[locknum], F_SETLKW, &lock_it)) < 0 && 
  +	   errno != EINTR) {
   	/* nop */
       }
   
  @@ -770,11 +807,12 @@
       }
   }
   
  -static void accept_mutex_off(void)
  +static void accept_mutex_off(int locknum)
   {
       int ret;
   
  -    while ((ret = fcntl(lock_fd, F_SETLKW, &unlock_it)) < 0 && errno !=
EINTR) {
  +    while ((ret = fcntl(lock_fd[locknum], F_SETLKW, &unlock_it)) < 0 
  +	   && errno != EINTR) {
   	/* nop */
       }
       if (ret < 0 && errno != EINTR) {
  @@ -788,11 +826,17 @@
   
   #elif defined(USE_FLOCK_SERIALIZED_ACCEPT)
   
  -static int lock_fd = -1;
  +static int *lock_fd = NULL;
   
   static void accept_mutex_cleanup(void *foo)
   {
  -    unlink(ap_lock_fname);
  +    int i;
  +
  +    char * lock_fname;
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        lock_fname = expand_lock_fname(foo, i);
  +	unlink(lock_fname);
  +    }
   }
   
   /*
  @@ -801,12 +845,17 @@
    */
   static void accept_mutex_child_init(pool *p)
   {
  -
  -    lock_fd = ap_popenf(p, ap_lock_fname, O_WRONLY, 0600);
  -    if (lock_fd == -1) {
  -	ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
  -		    "Child cannot open lock file: %s", ap_lock_fname);
  -	clean_child_exit(APEXIT_CHILDINIT);
  +    int i;
  +    
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        char *lock_fname = expand_lock_fname(p, i);
  +      
  +	lock_fd[i] = ap_popenf(p, lock_fname, O_WRONLY, 0600);
  +	if (lock_fd[i] == -1) {
  +	  ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
  +		       "Child cannot open lock file: %s", lock_fname);
  +	  clean_child_exit(APEXIT_CHILDINIT);
  +	}
       }
   }
   
  @@ -816,22 +865,29 @@
    */
   static void accept_mutex_init(pool *p)
   {
  -    expand_lock_fname(p);
  -    unlink(ap_lock_fname);
  -    lock_fd = ap_popenf(p, ap_lock_fname, O_CREAT | O_WRONLY | O_EXCL, 0600);
  -    if (lock_fd == -1) {
  -	ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
  -		    "Parent cannot open lock file: %s", ap_lock_fname);
  -	exit(APEXIT_INIT);
  +    int i;
  +    char * lock_fname;
  +    lock_fd = (int *)ap_palloc(p, ap_acceptors_per_child * sizeof(int *));
  +
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        lock_fname = expand_lock_fname(p, i);
  +	unlink(lock_fname);
  +	lock_fd[i] = ap_popenf(p, lock_fname, 
  +			       O_CREAT | O_WRONLY | O_EXCL, 0600);
  +	if (lock_fd[i] == -1) {
  +	  ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
  +		       "Parent cannot open lock file: %s", lock_fname);
  +	  exit(APEXIT_INIT);
  +	}
  +	ap_register_cleanup(p, p, accept_mutex_cleanup, ap_null_cleanup);
       }
  -    ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
   }
   
  -static void accept_mutex_on(void)
  +static void accept_mutex_on(int locknum)
   {
       int ret;
   
  -    while ((ret = flock(lock_fd, LOCK_EX)) < 0 && errno != EINTR)
  +    while ((ret = flock(lock_fd[locknum], LOCK_EX)) < 0 && errno != EINTR)
   	continue;
   
       if (ret < 0 && errno != EINTR) {
  @@ -841,9 +897,9 @@
       }
   }
   
  -static void accept_mutex_off(void)
  +static void accept_mutex_off(int locknum)
   {
  -    if (flock(lock_fd, LOCK_UN) < 0 && errno != EINTR) {
  +    if (flock(lock_fd[locknum], LOCK_UN) < 0 && errno != EINTR) {
   	ap_log_error(APLOG_MARK, APLOG_EMERG, server_conf,
   		    "flock: LOCK_UN: Error freeing accept lock. Exiting!");
   	clean_child_exit(APEXIT_CHILDFATAL);
  @@ -852,12 +908,16 @@
   
   #elif defined(USE_OS2SEM_SERIALIZED_ACCEPT)
   
  -static HMTX lock_sem = -1;
  +static HMTX *lock_sem = NULL;
   
   static void accept_mutex_cleanup(void *foo)
  -{
  -    DosReleaseMutexSem(lock_sem);
  -    DosCloseMutexSem(lock_sem);
  +{ 
  +    int i;
  +  
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        DosReleaseMutexSem(lock_sem[i]);
  +	DosCloseMutexSem(lock_sem[i]);
  +    }
   }
   
   /*
  @@ -866,35 +926,45 @@
    */
   static void accept_mutex_child_init(pool *p)
   {
  -    int rc = DosOpenMutexSem(NULL, &lock_sem);
  +    int i;
  +    
  +    for(i = 0; i < ap_acceptors_per_child; i++) {
  +        int rc = DosOpenMutexSem(NULL, &lock_sem[locknum]);
   
  -    if (rc != 0) {
  -	ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, server_conf,
  -		    "Child cannot open lock semaphore, rc=%d", rc);
  -	clean_child_exit(APEXIT_CHILDINIT);
  +	if (rc != 0) {
  +	    ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, server_conf,
  +			 "Child cannot open lock semaphore, rc=%d", rc);
  +	    clean_child_exit(APEXIT_CHILDINIT);
  +	}
       }
   }
  -
   /*
    * Initialize mutex lock.
    * Must be safe to call this on a restart.
    */
   static void accept_mutex_init(pool *p)
   {
  -    int rc = DosCreateMutexSem(NULL, &lock_sem, DC_SEM_SHARED, FALSE);
  +    int rc;
  +    int i;
   
  -    if (rc != 0) {
  -	ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, server_conf,
  -		    "Parent cannot create lock semaphore, rc=%d", rc);
  -	exit(APEXIT_INIT);
  -    }
  +    lock_fd = (int *)ap_palloc(p, ap_acceptors_per_child * sizeof(int *));
  +
  +    for (i = 0; i < ap_acceptors_per_child; i++) {
  +        rc = DosCreateMutexSem(NULL, &lock_sem[i], DC_SEM_SHARED, FALSE);
   
  -    ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
  +	if (rc != 0) {
  +	  ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, server_conf,
  +		       "Parent cannot create lock semaphore, rc=%d", rc);
  +	  exit(APEXIT_INIT);
  +	}
  +	
  +	ap_register_cleanup(p, NULL, accept_mutex_cleanup, ap_null_cleanup);
  +    }
   }
   
  -static void accept_mutex_on(void)
  +static void accept_mutex_on(int locknum)
   {
  -    int rc = DosRequestMutexSem(lock_sem, SEM_INDEFINITE_WAIT);
  +    int rc = DosRequestMutexSem(lock_sem[locknum], SEM_INDEFINITE_WAIT);
   
       if (rc != 0) {
   	ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, server_conf,
  @@ -903,9 +973,9 @@
       }
   }
   
  -static void accept_mutex_off(void)
  +static void accept_mutex_off(int locknum)
   {
  -    int rc = DosReleaseMutexSem(lock_sem);
  +    int rc = DosReleaseMutexSem(lock_sem[locknum]);
       
       if (rc != 0) {
   	ap_log_error(APLOG_MARK, APLOG_NOERRNO|APLOG_EMERG, server_conf,
  @@ -924,8 +994,8 @@
   #define NO_SERIALIZED_ACCEPT
   #define accept_mutex_child_init(x)
   #define accept_mutex_init(x)
  -#define accept_mutex_on()
  -#define accept_mutex_off()
  +#define accept_mutex_on(x)
  +#define accept_mutex_off(x)
   #endif
   #endif
   
  @@ -1985,7 +2055,7 @@
       int i;
   
       lr = ap_listeners;
  -    num_listenfds = 0;
  +    ap_acceptors_per_child = 0;
       for (;;) {
   	fd = find_listener(lr);
   	if (fd < 0) {
  @@ -1995,7 +2065,7 @@
   	    ap_note_cleanups_for_socket(p, fd);
   	}
   	if (fd >= 0) {
  -            ++num_listenfds;
  +            ++ap_acceptors_per_child;
   	}
   	lr->fd = fd;
   	if (lr->next == NULL)
  @@ -2272,9 +2342,9 @@
           (void) ap_update_child_status(my_pid, my_tid, SERVER_ACCEPTING, 
   				    (request_rec *) NULL);
   	/* lock around the accept if necessary */
  -	SAFE_ACCEPT(accept_mutex_on());
  +	SAFE_ACCEPT(accept_mutex_on(my_tid - ap_threads_per_child));
           csd = accept(sd, &sa_client, &len);
  -	SAFE_ACCEPT(accept_mutex_off());
  +	SAFE_ACCEPT(accept_mutex_off(my_tid - ap_threads_per_child));
   	(void) ap_update_child_status(my_pid, my_tid, SERVER_QUEUEING, 
   				      (request_rec *) NULL);
   	if (csd >= 0) {
  @@ -2602,9 +2672,6 @@
       pthread_t tid;   /* ZZZZ */
       int pid;
       listen_rec *lr;
  -
  -    for (lr = ap_listeners, ap_acceptors_per_child = 0; lr; 
  -	 lr=lr->next, ap_acceptors_per_child++);
   
       if (ap_acceptors_per_child + ap_threads_per_child  > HARD_THREAD_LIMIT) {
           ap_log_error(APLOG_MARK, APLOG_ERR, s,
  
  
  

Mime
View raw message