apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From b..@apache.org
Subject cvs commit: apr/locks/os2 proc_mutex.c
Date Mon, 11 Feb 2002 12:56:14 GMT
bjh         02/02/11 04:56:13

  Modified:    include/arch/os2 proc_mutex.h
               locks/os2 proc_mutex.c
  Log:
  OS/2: Implement apr_proc_mutex*()
  
  Revision  Changes    Path
  1.2       +3 -0      apr/include/arch/os2/proc_mutex.h
  
  Index: proc_mutex.h
  ===================================================================
  RCS file: /home/cvs/apr/include/arch/os2/proc_mutex.h,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- proc_mutex.h	19 Sep 2001 20:06:43 -0000	1.1
  +++ proc_mutex.h	11 Feb 2002 12:56:13 -0000	1.2
  @@ -60,6 +60,9 @@
   
   struct apr_proc_mutex_t {
       apr_pool_t *pool;
  +    HMTX hMutex;
  +    TID owner;
  +    int lock_count;
   };
   
   #endif  /* PROC_MUTEX_H */
  
  
  
  1.7       +152 -8    apr/locks/os2/proc_mutex.c
  
  Index: proc_mutex.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/os2/proc_mutex.c,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- proc_mutex.c	29 Dec 2001 23:14:21 -0000	1.6
  +++ proc_mutex.c	11 Feb 2002 12:56:13 -0000	1.7
  @@ -59,56 +59,200 @@
   #include "proc_mutex.h"
   #include "fileio.h"
   #include <string.h>
  +#include <stddef.h>
  +
  +#define CurrentTid (*_threadid)
  +
  +static char *fixed_name(const char *fname, apr_pool_t *pool)
  +{
  +    char *semname;
  +
  +    if (fname == NULL)
  +        semname = NULL;
  +    else {
  +        // Semaphores don't live in the file system, fix up the name
  +        while (*fname == '/' || *fname == '\\') {
  +            fname++;
  +        }
  +
  +        semname = apr_pstrcat(pool, "/SEM32/", fname, NULL);
  +
  +        if (semname[8] == ':') {
  +            semname[8] = '$';
  +        }
  +    }
  +
  +    return semname;
  +}
  +
  +
  +
  +static apr_status_t proc_mutex_cleanup(void *vmutex)
  +{
  +    apr_proc_mutex_t *mutex = vmutex;
  +    return apr_proc_mutex_destroy(mutex);
  +}
  +
  +
   
   APR_DECLARE(apr_status_t) apr_proc_mutex_create(apr_proc_mutex_t **mutex,
                                                   const char *fname,
                                                   apr_lockmech_e mech,
                                                   apr_pool_t *pool)
   {
  -    return APR_ENOTIMPL;
  +    apr_proc_mutex_t *new;
  +    ULONG rc;
  +    char *semname;
  +
  +    if (mech != APR_LOCK_DEFAULT) {
  +        return APR_ENOTIMPL;
  +    }
  +
  +    new = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
  +    new->pool       = pool;
  +    new->owner      = 0;
  +    new->lock_count = 0;
  +    *mutex = new;
  +
  +    semname = fixed_name(fname, pool);
  +    rc = DosCreateMutexSem(semname, &(new->hMutex), DC_SEM_SHARED, FALSE);
  +
  +    if (!rc) {
  +        apr_pool_cleanup_register(pool, new, proc_mutex_cleanup, apr_pool_cleanup_null);
  +    }
  +
  +    return APR_FROM_OS_ERROR(rc);
   }
   
  +
  +
   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_proc_mutex_t *new;
  +    ULONG rc;
  +    char *semname;
  +
  +    new = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
  +    new->pool       = pool;
  +    new->owner      = 0;
  +    new->lock_count = 0;
  +
  +    semname = fixed_name(fname, pool);
  +    rc = DosOpenMutexSem(semname, &(new->hMutex));
  +    *mutex = new;
  +
  +    if (!rc) {
  +        apr_pool_cleanup_register(pool, new, proc_mutex_cleanup, apr_pool_cleanup_null);
  +    }
  +
  +    return APR_FROM_OS_ERROR(rc);
   }
  -    
  +
  +
  +
   APR_DECLARE(apr_status_t) apr_proc_mutex_lock(apr_proc_mutex_t *mutex)
   {
  -    return APR_ENOTIMPL;
  +    ULONG rc = DosRequestMutexSem(mutex->hMutex, SEM_INDEFINITE_WAIT);
  +
  +    if (rc == 0) {
  +        mutex->owner = CurrentTid;
  +        mutex->lock_count++;
  +    }
  +
  +    return APR_FROM_OS_ERROR(rc);
   }
   
  +
  +
   APR_DECLARE(apr_status_t) apr_proc_mutex_trylock(apr_proc_mutex_t *mutex)
   {
  -    return APR_ENOTIMPL;
  +    ULONG rc = DosRequestMutexSem(mutex->hMutex, SEM_IMMEDIATE_RETURN);
  +
  +    if (rc == 0) {
  +        mutex->owner = CurrentTid;
  +        mutex->lock_count++;
  +    }
  +
  +    return APR_FROM_OS_ERROR(rc);
   }
   
  +
  +
   APR_DECLARE(apr_status_t) apr_proc_mutex_unlock(apr_proc_mutex_t *mutex)
   {
  -    return APR_ENOTIMPL;
  +    ULONG rc;
  +
  +    if (mutex->owner == CurrentTid && mutex->lock_count > 0) {
  +        mutex->lock_count--;
  +        rc = DosReleaseMutexSem(mutex->hMutex);
  +        return APR_FROM_OS_ERROR(rc);
  +    }
  +
  +    return APR_SUCCESS;
   }
   
  +
  +
   APR_DECLARE(apr_status_t) apr_proc_mutex_destroy(apr_proc_mutex_t *mutex)
   {
  -    return APR_ENOTIMPL;
  +    ULONG rc;
  +    apr_status_t status = APR_SUCCESS;
  +
  +    if (mutex->owner == CurrentTid) {
  +        while (mutex->lock_count > 0 && status == APR_SUCCESS) {
  +            status = apr_proc_mutex_unlock(mutex);
  +        }
  +    }
  +
  +    if (status != APR_SUCCESS) {
  +        return status;
  +    }
  +
  +    if (mutex->hMutex == 0) {
  +        return APR_SUCCESS;
  +    }
  +
  +    rc = DosCloseMutexSem(mutex->hMutex);
  +
  +    if (!rc) {
  +        mutex->hMutex = 0;
  +    }
  +
  +    return APR_FROM_OS_ERROR(rc);
   }
   
  +
  +
   APR_POOL_IMPLEMENT_ACCESSOR(proc_mutex)
   
  +
  +
   /* Implement OS-specific accessors defined in apr_portable.h */
   
   APR_DECLARE(apr_status_t) apr_os_proc_mutex_get(apr_os_proc_mutex_t *ospmutex,
                                                   apr_proc_mutex_t *pmutex)
   {
  +    *ospmutex = pmutex->hMutex;
       return APR_ENOTIMPL;
   }
   
  +
  +
   APR_DECLARE(apr_status_t) apr_os_proc_mutex_put(apr_proc_mutex_t **pmutex,
                                                   apr_os_proc_mutex_t *ospmutex,
                                                   apr_pool_t *pool)
   {
  -    return APR_ENOTIMPL;
  +    apr_proc_mutex_t *new;
  +
  +    new = (apr_proc_mutex_t *)apr_palloc(pool, sizeof(apr_proc_mutex_t));
  +    new->pool       = pool;
  +    new->owner      = 0;
  +    new->lock_count = 0;
  +    new->hMutex     = *ospmutex;
  +    *pmutex = new;
  +
  +    return APR_SUCCESS;
   }
   
  
  
  

Mime
View raw message