apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject cvs commit: apr/locks/win32 proc_mutex.c
Date Wed, 19 Sep 2001 20:06:44 GMT
rbb         01/09/19 13:06:44

  Modified:    include/arch/unix locks.h
               locks/beos Makefile.in
               locks/os2 Makefile.in
               locks/unix Makefile.in
  Added:       include  apr_proc_mutex.h
               include/arch/beos proc_mutex.h
               include/arch/netware proc_mutex.h
               include/arch/os2 proc_mutex.h
               include/arch/unix proc_mutex.h
               include/arch/win32 proc_mutex.h
               locks/beos proc_mutex.c
               locks/netware proc_mutex.c
               locks/os2 proc_mutex.c
               locks/unix proc_mutex.c
               locks/win32 proc_mutex.c
  Log:
  New process locking API for APR.
  
  Submitted by:	Aaron Bannert <aaron@clove.org>
  
  Revision  Changes    Path
  1.1                  apr/include/apr_proc_mutex.h
  
  Index: apr_proc_mutex.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #ifndef APR_PROC_MUTEX_H
  #define APR_PROC_MUTEX_H
  
  #include "apr.h"
  #include "apr_lock.h"    /* only for apr_lockmech_e_np */
  #include "apr_pools.h"
  #include "apr_errno.h"
  
  #ifdef __cplusplus
  extern "C" {
  #endif /* __cplusplus */
  
  /**
   * @file apr_proc_mutex.h
   * @brief APR Process Locking Routines
   */
  
  /**
   * @defgroup APR_ProcMutex Process Locking Routines
   * @ingroup APR
   * @{
   */
  
  typedef struct apr_proc_mutex_t apr_proc_mutex_t;
  
  /*   Function definitions */
  
  /**
   * Create and initialize a mutex that can be used to synchronize processes.
   * @param mutex the memory address where the newly created mutex will be
   *        stored.
   * @param fname A file name to use if the lock mechanism requires one.  This
   *        argument should always be provided.  The lock code itself will
   *        determine if it should be used.
   * @param pool the pool from which to allocate the mutex.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                  const char *fname,
                                                  apr_pool_t *pool);
  
  /**
   * non-portable interface to apr_proc_mutex_create()
   *
   * Create and initialize a mutex that can be used to synchronize processes.
   * @param mutex the memory address where the newly created mutex will be
   *        stored.
   * @param fname A file name to use if the lock mechanism requires one.  This
   *        argument should always be provided.  The lock code itself will
   *        determine if it should be used.
   * @param mech The mechanism to use for the interprocess lock, if any; one of
   * <PRE>
   *            APR_LOCK_FCNTL
   *            APR_LOCK_FLOCK
   *            APR_LOCK_SYSVSEM
   *            APR_LOCK_PROC_PTHREAD
   *            APR_LOCK_DEFAULT     pick the default mechanism for the platform
   * </PRE>
   * @param pool the pool from which to allocate the mutex.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_create_np(apr_proc_mutex_t **mutex,
                                                     const char *fname,
                                                     apr_lockmech_e_np mech,
                                                     apr_pool_t *pool);
  /**
   * Re-open a mutex in a child process.
   * @param mutex The newly re-opened mutex structure.
   * @param fname A file name to use if the mutex mechanism requires one.  This
   *              argument should always be provided.  The mutex code itself will
   *              determine if it should be used.  This filename should be the 
   *              same one that was passed to apr_proc_mutex_create().
   * @param pool The pool to operate on.
   * @remark This function must be called to maintain portability, even
   *         if the underlying lock mechanism does not require it.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
                                                      const char *fname,
                                                      apr_pool_t *pool);
  
  /**
   * Acquire the lock for the given mutex. If the mutex is already locked,
   * the current thread will be put to sleep until the lock becomes available.
   * @param mutex the mutex on which to acquire the lock.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex);
  
  /**
   * Attempt to acquire the lock for the given mutex. If the mutex has already
   * been acquired, the call returns immediately with APR_EBUSY. Note: it
   * is important that the APR_STATUS_IS_EBUSY(s) macro be used to determine
   * if the return value was APR_EBUSY, for portability reasons.
   * @param mutex the mutex on which to attempt the lock acquiring.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex);
  
  /**
   * Release the lock for the given mutex.
   * @param mutex the mutex from which to release the lock.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex);
  
  /**
   * Destroy the mutex and free the memory associated with the lock.
   * @param mutex the mutex to destroy.
   */
  APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex);
  
  #ifdef __cplusplus
  }
  #endif
  
  #endif  /* ! APR_PROC_MUTEX_H */
  
  
  
  1.1                  apr/include/arch/beos/proc_mutex.h
  
  Index: proc_mutex.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #ifndef PROC_MUTEX_H
  #define PROC_MUTEX_H
  
  #include <kernel/OS.h>
  #include "apr_pools.h"
  #include "apr_proc_mutex.h"
  #include "apr_file_io.h"
  #include "apr_general.h"
  #include "apr_lib.h"
  #include "apr_portable.h"
  
  struct apr_proc_mutex_t {
      apr_pool_t *pool;
  };
  
  #endif  /* PROC_MUTEX_H */
  
  
  
  
  1.1                  apr/include/arch/netware/proc_mutex.h
  
  Index: proc_mutex.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #ifndef PROC_MUTEX_H
  #define PROC_MUTEX_H
  
  #include "apr_proc_mutex.h"
  #include <nks/synch.h>
  
  struct apr_proc_mutex_t {
      apr_pool_t *pool;
  };
  
  #endif  /* PROC_MUTEX_H */
  
  
  
  
  1.1                  apr/include/arch/os2/proc_mutex.h
  
  Index: proc_mutex.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #ifndef PROC_MUTEX_H
  #define PROC_MUTEX_H
  
  #include "apr_proc_mutex.h"
  #include "apr_file_io.h"
  
  struct apr_proc_mutex_t {
      apr_pool_t *pool;
  };
  
  #endif  /* PROC_MUTEX_H */
  
  
  
  
  1.38      +1 -9      apr/include/arch/unix/locks.h
  
  Index: locks.h
  ===================================================================
  RCS file: /home/cvs/apr/include/arch/unix/locks.h,v
  retrieving revision 1.37
  retrieving revision 1.38
  diff -u -r1.37 -r1.38
  --- locks.h	2001/08/11 07:32:54	1.37
  +++ locks.h	2001/09/19 20:06:43	1.38
  @@ -62,6 +62,7 @@
   #include "apr_lock.h"
   #include "apr_sms.h"
   #include "apr_portable.h"
  +#include "proc_mutex.h"
   
   /* System headers required by Locks library */
   #if APR_HAVE_SYS_TYPES_H
  @@ -127,15 +128,6 @@
   #endif
   #if APR_HAS_RWLOCK_SERIALIZE
   extern const apr_unix_lock_methods_t apr_unix_rwlock_methods;
  -#endif
  -
  -#if !APR_HAVE_UNION_SEMUN && defined(APR_HAS_SYSVSEM_SERIALIZE)
  -/* it makes no sense, but this isn't defined on solaris */
  -union semun {
  -    long val;
  -    struct semid_ds *buf;
  -    ushort *array;
  -};
   #endif
   
   struct apr_lock_t {
  
  
  
  1.1                  apr/include/arch/unix/proc_mutex.h
  
  Index: proc_mutex.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #ifndef PROC_MUTEX_H
  #define PROC_MUTEX_H
  
  #include "apr.h"
  #include "apr_private.h"
  #include "apr_general.h"
  #include "apr_lib.h"
  #include "apr_proc_mutex.h"
  #include "apr_pools.h"
  #include "apr_portable.h"
  
  /* System headers required by Locks library */
  #if APR_HAVE_SYS_TYPES_H
  #include <sys/types.h>
  #endif
  #if APR_HAVE_STDIO_H
  #include <stdio.h>
  #endif
  #if APR_HAVE_FCNTL_H
  #include <fcntl.h>
  #endif
  
  #ifdef HAVE_SYS_SEM_H
  #include <sys/sem.h>
  #endif
  #ifdef HAVE_SYS_FILE_H
  #include <sys/file.h>
  #endif
  #if APR_HAVE_STDLIB_H
  #include <stdlib.h>
  #endif
  #if APR_HAVE_UNISTD_H
  #include <unistd.h>
  #endif
  #if APR_HAVE_STRING_H
  #include <string.h>
  #endif
  #ifdef HAVE_SYS_MMAN_H
  #include <sys/mman.h>
  #endif
  #if APR_HAVE_PTHREAD_H
  #include <pthread.h>
  #endif
  /* End System Headers */
  
  struct apr_proc_mutex_unix_lock_methods_t {
      unsigned int flags;
      apr_status_t (*create)(apr_proc_mutex_t *, const char *);
      apr_status_t (*acquire)(apr_proc_mutex_t *);
      apr_status_t (*tryacquire)(apr_proc_mutex_t *);
      apr_status_t (*release)(apr_proc_mutex_t *);
      apr_status_t (*destroy)(apr_proc_mutex_t *);
      apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *);
  };
  typedef struct apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_lock_methods_t;
  
  /* bit values for flags field in apr_unix_lock_methods_t */
  #define APR_PROCESS_LOCK_MECH_IS_GLOBAL          1
  
  #if APR_HAS_SYSVSEM_SERIALIZE
  extern const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_sysv_methods;
  #endif
  #if APR_HAS_FCNTL_SERIALIZE
  extern const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_fcntl_methods;
  #endif
  #if APR_HAS_FLOCK_SERIALIZE
  extern const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_flock_methods;
  #endif
  #if APR_HAS_PROC_PTHREAD_SERIALIZE
  extern const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_proc_pthread_methods;
  #endif
  #if APR_HAS_RWLOCK_SERIALIZE
  extern const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_rwlock_methods;
  #endif
  
  
  #if !APR_HAVE_UNION_SEMUN && defined(APR_HAS_SYSVSEM_SERIALIZE)
  /* it makes no sense, but this isn't defined on solaris */
  union semun {
      long val;
      struct semid_ds *buf;
      ushort *array;
  };
  #endif
  
  struct apr_proc_mutex_t {
      apr_pool_t *pool;
      const apr_proc_mutex_unix_lock_methods_t *meth;
      const apr_proc_mutex_unix_lock_methods_t *inter_meth;
      apr_lockscope_e scope;
      int curr_locked;
      char *fname;
  #if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE
      int interproc;
  #endif
  #if APR_HAS_PROC_PTHREAD_SERIALIZE
      pthread_mutex_t *pthread_interproc;
  #endif
  #if APR_HAS_THREADS
      /* APR doesn't have threads, no sense in having a thread lock mechanism.
       */
  
      apr_os_thread_t owner;
      int owner_ref;
  #endif
  };
  
  void apr_proc_mutex_unix_setup_lock(void);
  
  #endif  /* PROC_MUTEX_H */
  
  
  
  
  1.1                  apr/include/arch/win32/proc_mutex.h
  
  Index: proc_mutex.h
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #ifndef PROC_MUTEX_H
  #define PROC_MUTEX_H
  
  #include "apr_proc_mutex.h"
  
  struct apr_proc_mutex_t {
      apr_pool_t *pool;
  };
  
  #endif  /* PROC_MUTEX_H */
  
  
  
  
  1.16      +2 -1      apr/locks/beos/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr/locks/beos/Makefile.in,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- Makefile.in	2001/09/13 01:04:23	1.15
  +++ Makefile.in	2001/09/19 20:06:43	1.16
  @@ -2,7 +2,8 @@
   TARGETS = locks.lo \
   	thread_mutex.lo \
   	thread_rwlock.lo \
  -	thread_cond.lo
  +	thread_cond.lo \
  +	proc_mutex.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.1                  apr/locks/beos/proc_mutex.c
  
  Index: proc_mutex.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  /*Read/Write locking implementation based on the MultiLock code from
   * Stephen Beaulieu <hippo@be.com>
   */
   
  #include "beos/proc_mutex.h"
  #include "apr_strings.h"
  #include "apr_portable.h"
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                  const char *fname,
                                                  apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create_np(apr_proc_mutex_t **mutex,
                                                     const char *fname,
                                                     apr_lockmech_e_np mech,
                                                     apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }       
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
                                                      const char *fname,
                                                      apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
      
  APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  
  
  
  1.1                  apr/locks/netware/proc_mutex.c
  
  Index: proc_mutex.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #include "apr.h"
  #include "apr_private.h"
  #include "apr_general.h"
  #include "apr_strings.h"
  #include "proc_mutex.h"
  #include "apr_portable.h"
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                  const char *fname,
                                                  apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create_np(apr_proc_mutex_t **mutex,
                                                     const char *fname,
                                                     apr_lockmech_e_np mech,
                                                     apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }       
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
                                                      const char *fname,
                                                      apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
      
  APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  
  
  
  1.16      +2 -1      apr/locks/os2/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr/locks/os2/Makefile.in,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- Makefile.in	2001/09/13 01:04:23	1.15
  +++ Makefile.in	2001/09/19 20:06:44	1.16
  @@ -2,7 +2,8 @@
   TARGETS = locks.lo \
   	thread_mutex.lo \
   	thread_rwlock.lo \
  -	thread_cond.lo
  +	thread_cond.lo \
  +    proc_mutex.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.1                  apr/locks/os2/proc_mutex.c
  
  Index: proc_mutex.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #include "apr_general.h"
  #include "apr_lib.h"
  #include "apr_strings.h"
  #include "apr_portable.h"
  #include "proc_mutex.h"
  #include "fileio.h"
  #include <string.h>
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                  const char *fname,
                                                  apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create_np(apr_proc_mutex_t **mutex,
                                                     const char *fname,
                                                     apr_lockmech_e_np mech,
                                                     apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }       
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
                                                      const char *fname,
                                                      apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
      
  APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  
  
  
  1.22      +2 -1      apr/locks/unix/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr/locks/unix/Makefile.in,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- Makefile.in	2001/09/13 01:04:23	1.21
  +++ Makefile.in	2001/09/19 20:06:44	1.22
  @@ -5,7 +5,8 @@
   	intraproc.lo \
   	thread_mutex.lo \
   	thread_rwlock.lo \
  -	thread_cond.lo
  +	thread_cond.lo \
  +	proc_mutex.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.1                  apr/locks/unix/proc_mutex.c
  
  Index: proc_mutex.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #include "apr.h"
  #include "apr_strings.h"
  #include "proc_mutex.h"
  #include "fileio.h" /* for apr_mkstemp() */
  
  #if APR_HAS_SYSVSEM_SERIALIZE
  
  static struct sembuf proc_mutex_op_on;
  static struct sembuf proc_mutex_op_off;
  
  static void proc_mutex_sysv_setup(void)
  {
      proc_mutex_op_on.sem_num = 0;
      proc_mutex_op_on.sem_op = -1;
      proc_mutex_op_on.sem_flg = SEM_UNDO;
      proc_mutex_op_off.sem_num = 0;
      proc_mutex_op_off.sem_op = 1;
      proc_mutex_op_off.sem_flg = SEM_UNDO;
  }
  
  static apr_status_t proc_mutex_sysv_cleanup(void *mutex_)
  {
      apr_proc_mutex_t *mutex=mutex_;
      union semun ick;
      
      if (mutex->interproc != -1) {
          ick.val = 0;
          semctl(mutex->interproc, 0, IPC_RMID, ick);
      }
      return APR_SUCCESS;
  }    
  
  static apr_status_t proc_mutex_sysv_create(apr_proc_mutex_t *new_mutex,
                                             const char *fname)
  {
      union semun ick;
      apr_status_t stat;
      
      new_mutex->interproc = semget(IPC_PRIVATE, 1, IPC_CREAT | 0600);
  
      if (new_mutex->interproc < 0) {
          stat = errno;
          proc_mutex_sysv_cleanup(new_mutex);
          return stat;
      }
      ick.val = 1;
      if (semctl(new_mutex->interproc, 0, SETVAL, ick) < 0) {
          stat = errno;
          proc_mutex_sysv_cleanup(new_mutex);
          return stat;
      }
      new_mutex->curr_locked = 0;
      apr_pool_cleanup_register(new_mutex->pool,
                                (void *)new_mutex, proc_mutex_sysv_cleanup, 
                                apr_pool_cleanup_null);
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_sysv_acquire(apr_proc_mutex_t *mutex)
  {
      int rc;
  
      do {
          rc = semop(mutex->interproc, &proc_mutex_op_on, 1);
      } while (rc < 0 && errno == EINTR);
      if (rc < 0) {
          return errno;
      }
      mutex->curr_locked = 1;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_sysv_release(apr_proc_mutex_t *mutex)
  {
      int rc;
  
      do {
          rc = semop(mutex->interproc, &proc_mutex_op_off, 1);
      } while (rc < 0 && errno == EINTR);
      if (rc < 0) {
          return errno;
      }
      mutex->curr_locked = 0;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_sysv_destroy(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
  
      if ((stat = proc_mutex_sysv_cleanup(mutex)) == APR_SUCCESS) {
          apr_pool_cleanup_kill(mutex->pool, mutex, proc_mutex_sysv_cleanup);
          return APR_SUCCESS;
      }
      return stat;
  }
  
  static apr_status_t proc_mutex_sysv_child_init(apr_proc_mutex_t **mutex, apr_pool_t *cont, const char *fname)
  {
      return APR_SUCCESS;
  }
  
  const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_sysv_methods =
  {
  #if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS
      APR_PROCESS_LOCK_MECH_IS_GLOBAL,
  #else
      0,
  #endif
      proc_mutex_sysv_create,
      proc_mutex_sysv_acquire,
      NULL, /* no tryacquire */
      proc_mutex_sysv_release,
      proc_mutex_sysv_destroy,
      proc_mutex_sysv_child_init
  };
  
  #endif /* SysV sem implementation */
  
  #if APR_HAS_PROC_PTHREAD_SERIALIZE
  
  static void proc_mutex_proc_pthread_setup(void)
  {
  }
  
  static apr_status_t proc_mutex_proc_pthread_cleanup(void *mutex_)
  {
      apr_proc_mutex_t *mutex=mutex_;
      apr_status_t stat;
  
      if (mutex->curr_locked == 1) {
          if ((stat = pthread_mutex_unlock(mutex->pthread_interproc))) {
  #ifdef PTHREAD_SETS_ERRNO
              stat = errno;
  #endif
              return stat;
          } 
          if (munmap((caddr_t)mutex->pthread_interproc, sizeof(pthread_mutex_t))){
              return errno;
          }
      }
      return APR_SUCCESS;
  }    
  
  static apr_status_t proc_mutex_proc_pthread_create(apr_proc_mutex_t *new_mutex,
                                                     const char *fname)
  {
      apr_status_t stat;
      int fd;
      pthread_mutexattr_t mattr;
  
      fd = open("/dev/zero", O_RDWR);
      if (fd < 0) {
          return errno;
      }
  
      new_mutex->pthread_interproc = (pthread_mutex_t *)mmap(
                                         (caddr_t) 0, 
                                         sizeof(pthread_mutex_t), 
                                         PROT_READ | PROT_WRITE, MAP_SHARED,
                                         fd, 0); 
      if (new_mutex->pthread_interproc == (pthread_mutex_t *) (caddr_t) -1) {
          return errno;
      }
      close(fd);
      if ((stat = pthread_mutexattr_init(&mattr))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          proc_pthread_cleanup(new_mutex);
          return stat;
      }
      if ((stat = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          proc_pthread_cleanup(new_mutex);
          return stat;
      }
  
  #ifdef HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP
      if ((stat = pthread_mutexattr_setrobust_np(&mattr, 
                                                 PTHREAD_MUTEX_ROBUST_NP))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          proc_pthread_cleanup(new_mutex);
          return stat;
      }
      if ((stat = pthread_mutexattr_setprotocol(&mattr, PTHREAD_PRIO_INHERIT))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          proc_pthread_cleanup(new_mutex);
          return stat;
      }
  #endif
  
      if ((stat = pthread_mutex_init(new_mutex->pthread_interproc, &mattr))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          proc_pthread_cleanup(new_mutex);
          return stat;
      }
  
      if ((stat = pthread_mutexattr_destroy(&mattr))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          proc_pthread_cleanup(new_mutex);
          return stat;
      }
  
      new_mutex->curr_locked = 0;
      apr_pool_cleanup_register(new_mutex->pool,
                                (void *)new_mutex,
                                proc_mutex_proc_pthread_cleanup, 
                                apr_pool_cleanup_null);
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_proc_pthread_acquire(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
  
      if ((stat = pthread_mutex_lock(mutex->pthread_interproc))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
  #ifdef HAVE_PTHREAD_MUTEXATTR_SETROBUST_NP
          /* Okay, our owner died.  Let's try to make it consistent again. */
          if (stat == EOWNERDEAD) {
              pthread_mutex_consistent_np(mutex->pthread_interproc);
          }
          else
              return stat;
  #else
          return stat;
  #endif
      }
      mutex->curr_locked = 1;
      return APR_SUCCESS;
  }
  
  /* TODO: Add proc_mutex_proc_pthread_tryacquire(apr_proc_mutex_t *mutex) */
  
  static apr_status_t proc_mutex_proc_pthread_release(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
  
      if ((stat = pthread_mutex_unlock(mutex->pthread_interproc))) {
  #ifdef PTHREAD_SETS_ERRNO
          stat = errno;
  #endif
          return stat;
      }
      mutex->curr_locked = 0;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_proc_pthread_destroy(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
      if ((stat = proc_mutex_proc_pthread_cleanup(mutex)) == APR_SUCCESS) {
          apr_pool_cleanup_kill(mutex->pool,
                                mutex,
                                proc_mutex_proc_pthread_cleanup);
          return APR_SUCCESS;
      }
      return stat;
  }
  
  static apr_status_t proc_mutex_proc_pthread_child_init(apr_proc_mutex_t **mutex,
                                              apr_pool_t *cont, 
                                              const char *fname)
  {
      return APR_SUCCESS;
  }
  
  const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_proc_pthread_methods =
  {
      APR_PROCESS_LOCK_MECH_IS_GLOBAL,
      proc_mutex_proc_pthread_create,
      proc_mutex_proc_pthread_acquire,
      NULL, /* no tryacquire */
      proc_mutex_proc_pthread_release,
      proc_mutex_proc_pthread_destroy,
      proc_mutex_proc_pthread_child_init
  };
  
  #endif
  
  #if APR_HAS_FCNTL_SERIALIZE
  
  static struct flock proc_mutex_lock_it;
  static struct flock proc_mutex_unlock_it;
  
  static apr_status_t proc_mutex_fcntl_release(apr_proc_mutex_t *);
  
  static void proc_mutex_fcntl_setup(void)
  {
      proc_mutex_lock_it.l_whence = SEEK_SET;   /* from current point */
      proc_mutex_lock_it.l_start = 0;           /* -"- */
      proc_mutex_lock_it.l_len = 0;             /* until end of file */
      proc_mutex_lock_it.l_type = F_WRLCK;      /* set exclusive/write lock */
      proc_mutex_lock_it.l_pid = 0;             /* pid not actually interesting */
      proc_mutex_unlock_it.l_whence = SEEK_SET; /* from current point */
      proc_mutex_unlock_it.l_start = 0;         /* -"- */
      proc_mutex_unlock_it.l_len = 0;           /* until end of file */
      proc_mutex_unlock_it.l_type = F_UNLCK;    /* set exclusive/write lock */
      proc_mutex_unlock_it.l_pid = 0;           /* pid not actually interesting */
  }
  
  static apr_status_t proc_mutex_fcntl_cleanup(void *mutex_)
  {
      apr_status_t status;
      apr_proc_mutex_t *mutex=mutex_;
  
      if (mutex->curr_locked == 1) {
          status = proc_mutex_fcntl_release(mutex);
          if (status != APR_SUCCESS)
              return status;
      }
      close(mutex->interproc);
      
      return APR_SUCCESS;
  }    
  
  static apr_status_t proc_mutex_fcntl_create(apr_proc_mutex_t *new_mutex,
                                              const char *fname)
  {
      if (fname) {
          new_mutex->fname = apr_pstrdup(new_mutex->pool, fname);
          new_mutex->interproc = open(new_mutex->fname,
                                      O_CREAT | O_WRONLY | O_EXCL, 0644);
      }
      else {
          new_mutex->fname = apr_pstrdup(new_mutex->pool, "/tmp/aprXXXXXX");
          new_mutex->interproc = apr_mkstemp(new_mutex->fname);
      }
  
      if (new_mutex->interproc < 0) {
          proc_mutex_fcntl_cleanup(new_mutex);
          return errno;
      }
  
      new_mutex->curr_locked = 0;
      unlink(new_mutex->fname);
      apr_pool_cleanup_register(new_mutex->pool,
                                (void*)new_mutex,
                                proc_mutex_fcntl_cleanup, 
                                apr_pool_cleanup_null);
      return APR_SUCCESS; 
  }
  
  static apr_status_t proc_mutex_fcntl_acquire(apr_proc_mutex_t *mutex)
  {
      int rc;
  
      do {
          rc = fcntl(mutex->interproc, F_SETLKW, &proc_mutex_lock_it);
      } while (rc < 0 && errno == EINTR);
      if (rc < 0) {
          return errno;
      }
      mutex->curr_locked=1;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_fcntl_release(apr_proc_mutex_t *mutex)
  {
      int rc;
  
      do {
          rc = fcntl(mutex->interproc, F_SETLKW, &proc_mutex_unlock_it);
      } while (rc < 0 && errno == EINTR);
      if (rc < 0) {
          return errno;
      }
      mutex->curr_locked=0;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_fcntl_destroy(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
      if ((stat = proc_mutex_fcntl_cleanup(mutex)) == APR_SUCCESS) {
          apr_pool_cleanup_kill(mutex->pool, mutex, proc_mutex_fcntl_cleanup);
          return APR_SUCCESS;
      }
      return stat;
  }
  
  static apr_status_t proc_mutex_fcntl_child_init(apr_proc_mutex_t **mutex,
                                                  apr_pool_t *pool, 
                                                  const char *fname)
  {
      return APR_SUCCESS;
  }
  
  const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_fcntl_methods =
  {
  #if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS
      APR_PROCESS_LOCK_MECH_IS_GLOBAL,
  #else
      0,
  #endif
      proc_mutex_fcntl_create,
      proc_mutex_fcntl_acquire,
      NULL, /* no tryacquire */
      proc_mutex_fcntl_release,
      proc_mutex_fcntl_destroy,
      proc_mutex_fcntl_child_init
  };
  
  #endif /* fcntl implementation */
  
  #if APR_HAS_FLOCK_SERIALIZE
  
  static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *);
  
  static void proc_mutex_flock_setup(void)
  {
  }
  
  static apr_status_t proc_mutex_flock_cleanup(void *mutex_)
  {
      apr_status_t status;
      apr_proc_mutex_t *mutex=mutex_;
  
      if (mutex->curr_locked == 1) {
          status = proc_mutex_flock_release(mutex);
          if (status != APR_SUCCESS)
              return status;
      }
      close(mutex->interproc);
      unlink(mutex->fname);
      return APR_SUCCESS;
  }    
  
  static apr_status_t proc_mutex_flock_create(apr_proc_mutex_t *new_mutex,
                                              const char *fname)
  {
      if (fname) {
          new_mutex->fname = apr_pstrdup(new_mutex->pool, fname);
          new_mutex->interproc = open(new_mutex->fname,
                                      O_CREAT | O_WRONLY | O_EXCL, 0600);
      }
      else {
          new_mutex->fname = apr_pstrdup(new_mutex->pool, "/tmp/aprXXXXXX");
          new_mutex->interproc = apr_mkstemp(new_mutex->fname);
      }
  
      if (new_mutex->interproc < 0) {
          proc_mutex_flock_cleanup(new_mutex);
          return errno;
      }
      new_mutex->curr_locked = 0;
      apr_pool_cleanup_register(new_mutex->pool, (void *)new_mutex,
                                proc_mutex_flock_cleanup,
                                apr_pool_cleanup_null);
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_flock_acquire(apr_proc_mutex_t *mutex)
  {
      int rc;
  
      do {
          rc = flock(mutex->interproc, LOCK_EX);
      } while (rc < 0 && errno == EINTR);
      if (rc < 0) {
          return errno;
      }
      mutex->curr_locked = 1;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_flock_release(apr_proc_mutex_t *mutex)
  {
      int rc;
  
      do {
          rc = flock(mutex->interproc, LOCK_UN);
      } while (rc < 0 && errno == EINTR);
      if (rc < 0) {
          return errno;
      }
      mutex->curr_locked = 0;
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_flock_destroy(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
      if ((stat = proc_mutex_flock_cleanup(mutex)) == APR_SUCCESS) {
          apr_pool_cleanup_kill(mutex->pool, mutex, proc_mutex_flock_cleanup);
          return APR_SUCCESS;
      }
      return stat;
  }
  
  static apr_status_t proc_mutex_flock_child_init(apr_proc_mutex_t **mutex,
                                                  apr_pool_t *pool, 
                                                  const char *fname)
  {
      apr_proc_mutex_t *new_mutex;
  
      new_mutex = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
  
      memcpy(new_mutex, *mutex, sizeof *new_mutex);
      new_mutex->pool = pool;
      new_mutex->fname = apr_pstrdup(pool, fname);
      new_mutex->interproc = open(new_mutex->fname, O_WRONLY, 0600);
      if (new_mutex->interproc == -1) {
          proc_mutex_flock_destroy(new_mutex);
          return errno;
      }
      *mutex = new_mutex;
      return APR_SUCCESS;
  }
  
  const apr_proc_mutex_unix_lock_methods_t apr_proc_mutex_unix_flock_methods =
  {
  #if APR_PROCESS_LOCK_IS_GLOBAL || !APR_HAS_THREADS
      APR_PROCESS_LOCK_MECH_IS_GLOBAL,
  #else
      0,
  #endif
      proc_mutex_flock_create,
      proc_mutex_flock_acquire,
      NULL, /* no tryacquire */
      proc_mutex_flock_release,
      proc_mutex_flock_destroy,
      proc_mutex_flock_child_init
  };
  
  #endif /* flock implementation */
  
  void apr_proc_mutex_unix_setup_lock(void)
  {
  #if APR_HAS_SYSVSEM_SERIALIZE
      proc_mutex_sysv_setup();
  #endif
  #if APR_HAS_PROC_PTHREAD_SERIALIZE
      proc_mutex_proc_pthread_setup();
  #endif
  #if APR_HAS_FCNTL_SERIALIZE
      proc_mutex_fcntl_setup();
  #endif
  #if APR_HAS_FLOCK_SERIALIZE
      proc_mutex_flock_setup();
  #endif
  }
  
  
  
  
  
  
  
  
  
  static apr_status_t proc_mutex_choose_method(apr_proc_mutex_t *new_mutex, apr_lockmech_e_np mech)
  {
      switch (mech) {
      case APR_LOCK_FCNTL:
  #if APR_HAS_FCNTL_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_fcntl_methods;
  #else
          return APR_ENOTIMPL;
  #endif
          break;
      case APR_LOCK_FLOCK:
  #if APR_HAS_FLOCK_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_flock_methods;
  #else
          return APR_ENOTIMPL;
  #endif
          break;
      case APR_LOCK_SYSVSEM:
  #if APR_HAS_SYSVSEM_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_sysv_methods;
  #else
          return APR_ENOTIMPL;
  #endif
          break;
      case APR_LOCK_PROC_PTHREAD:
  #if APR_HAS_PROC_PTHREAD_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_proc_pthread_methods;
  #else
          return APR_ENOTIMPL;
  #endif
          break;
      case APR_LOCK_DEFAULT:
  #if APR_USE_FLOCK_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_flock_methods;
  #elif APR_USE_SYSVSEM_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_sysv_methods;
  #elif APR_USE_FCNTL_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_fcntl_methods;
  #elif APR_USE_PROC_PTHREAD_SERIALIZE
          new_mutex->inter_meth = &apr_proc_mutex_unix_proc_pthread_methods;
  #else
          return APR_ENOTIMPL;
  #endif
          break;
      default:
          return APR_ENOTIMPL;
      }
      return APR_SUCCESS;
  }
  
  static apr_status_t proc_mutex_create(apr_proc_mutex_t *new_mutex, apr_lockmech_e_np mech, const char *fname)
  {
      apr_status_t stat;
  
      if (new_mutex->scope != APR_INTRAPROCESS) {
          if ((stat = proc_mutex_choose_method(new_mutex, mech)) != APR_SUCCESS) {
              return stat;
          }
      }
  
      new_mutex->meth = new_mutex->inter_meth;
  
      if ((stat = new_mutex->meth->create(new_mutex, fname)) != APR_SUCCESS) {
          return stat;
      }
  
      return APR_SUCCESS;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                  const char *fname,
                                                  apr_pool_t *pool)
  {
      return apr_proc_mutex_create_np(mutex, fname, APR_LOCK_DEFAULT, pool);
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create_np(apr_proc_mutex_t **mutex,
                                                     const char *fname,
                                                     apr_lockmech_e_np mech,
                                                     apr_pool_t *pool)
  {
      apr_proc_mutex_t *new_mutex;
      apr_status_t stat;
  
      new_mutex = (apr_proc_mutex_t *)apr_pcalloc(pool,
                                                  sizeof(apr_proc_mutex_t));
  
      new_mutex->pool  = pool;
  #if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE
      new_mutex->interproc = -1;
  #endif
  
      if ((stat = proc_mutex_create(new_mutex, mech, fname)) != APR_SUCCESS)
          return stat;
  
      *mutex = new_mutex;
      return APR_SUCCESS;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
                                                      const char *fname,
                                                      apr_pool_t *pool)
  {
      return (*mutex)->meth->child_init(mutex, pool, fname);
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
  
  #if APR_HAS_THREADS
      if (apr_os_thread_equal(mutex->owner, apr_os_thread_current())) {
          mutex->owner_ref++;
          return APR_SUCCESS;
      }
  #endif
  
      if ((stat = mutex->meth->acquire(mutex)) != APR_SUCCESS) {
          return stat;
      }
  
  #if APR_HAS_THREADS
      mutex->owner = apr_os_thread_current();
      mutex->owner_ref = 1;
  #endif
  
      return APR_SUCCESS;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
  
  #if APR_HAS_THREADS
      if (apr_os_thread_equal(mutex->owner, apr_os_thread_current())) {
          mutex->owner_ref++;
          return APR_SUCCESS;
      }
  #endif
  
      if ((stat = mutex->meth->tryacquire(mutex)) != APR_SUCCESS) {
          return stat;
      }
  
  #if APR_HAS_THREADS
      mutex->owner = apr_os_thread_current();
      mutex->owner_ref = 1;
  #endif
  
      return APR_SUCCESS;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
  {
      apr_status_t stat;
  
  #if APR_HAS_THREADS
      if (apr_os_thread_equal(mutex->owner, apr_os_thread_current())) {
          mutex->owner_ref--;
          if (mutex->owner_ref > 0)
              return APR_SUCCESS;
      }
  #endif
  
      if ((stat = mutex->meth->release(mutex)) != APR_SUCCESS) {
          return stat;
      }
  
  #if APR_HAS_THREADS
      memset(&mutex->owner, 0, sizeof mutex->owner);
      mutex->owner_ref = 0;
  #endif
      
      return APR_SUCCESS;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
  {
      return mutex->meth->destroy(mutex);
  }
  
  
  
  
  1.1                  apr/locks/win32/proc_mutex.c
  
  Index: proc_mutex.c
  ===================================================================
  /* ====================================================================
   * The Apache Software License, Version 1.1
   *
   * Copyright (c) 2000-2001 The Apache Software Foundation.  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. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Apache" and "Apache Software Foundation" 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 name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``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 SOFTWARE FOUNDATION 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 Software Foundation.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  
  #include "apr.h"
  #include "apr_private.h"
  #include "apr_general.h"
  #include "apr_strings.h"
  #include "win32/proc_mutex.h"
  #include "apr_portable.h"
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                  const char *fname,
                                                  apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_create_np(apr_proc_mutex_t **mutex,
                                                     const char *fname,
                                                     apr_lockmech_e_np mech,
                                                     apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
                                                      const char *fname,
                                                      apr_pool_t *pool)
  {
      return APR_ENOTIMPL;
  }
      
  APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
  {
      return APR_ENOTIMPL;
  }
  
  
  
  

Mime
View raw message