contrib/apr/atomic/unix/mutex64.c

   1 /* Licensed to the Apache Software Foundation (ASF) under one or more
   2  * contributor license agreements.  See the NOTICE file distributed with
   3  * this work for additional information regarding copyright ownership.
   4  * The ASF licenses this file to You under the Apache License, Version 2.0
   5  * (the "License"); you may not use this file except in compliance with
   6  * the License.  You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "apr_arch_atomic.h"
  18 #include "apr_thread_mutex.h"
  19
  20 #if defined(USE_ATOMICS_GENERIC) || defined (NEED_ATOMICS_GENERIC64)
  21
  22 #include <stdlib.h>
  23
  24 #if APR_HAS_THREADS
  25 #   define DECLARE_MUTEX_LOCKED(name, mem)  \
  26         apr_thread_mutex_t *name = mutex_hash(mem)
  27 #   define MUTEX_UNLOCK(name)                                   \
  28         do {                                                    \
  29             if (apr_thread_mutex_unlock(name) != APR_SUCCESS)   \
  30                 abort();                                        \
  31         } while (0)
  32 #else
  33 #   define DECLARE_MUTEX_LOCKED(name, mem)
  34 #   define MUTEX_UNLOCK(name)
  35 #   warning Be warned: using stubs for all atomic operations
  36 #endif
  37
  38 #if APR_HAS_THREADS
  39
  40 static apr_thread_mutex_t **hash_mutex;
  41
  42 #define NUM_ATOMIC_HASH 7
  43 /* shift by 2 to get rid of alignment issues */
  44 #define ATOMIC_HASH(x) (unsigned int)(((unsigned long)(x)>>2)%(unsigned int)NUM_ATOMIC_HASH)
  45
  46 static apr_status_t atomic_cleanup(void *data)
  47 {
  48     if (hash_mutex == data)
  49         hash_mutex = NULL;
  50
  51     return APR_SUCCESS;
  52 }
  53
  54 apr_status_t apr__atomic_generic64_init(apr_pool_t *p)
  55 {
  56     int i;
  57     apr_status_t rv;
  58
  59     if (hash_mutex != NULL)
  60         return APR_SUCCESS;
  61
  62     hash_mutex = apr_palloc(p, sizeof(apr_thread_mutex_t*) * NUM_ATOMIC_HASH);
  63     apr_pool_cleanup_register(p, hash_mutex, atomic_cleanup,
  64                               apr_pool_cleanup_null);
  65
  66     for (i = 0; i < NUM_ATOMIC_HASH; i++) {
  67         rv = apr_thread_mutex_create(&(hash_mutex[i]),
  68                                      APR_THREAD_MUTEX_DEFAULT, p);
  69         if (rv != APR_SUCCESS) {
  70            return rv;
  71         }
  72     }
  73
  74     return APR_SUCCESS;
  75 }
  76
  77 static APR_INLINE apr_thread_mutex_t *mutex_hash(volatile apr_uint64_t *mem)
  78 {
  79     apr_thread_mutex_t *mutex = hash_mutex[ATOMIC_HASH(mem)];
  80
  81     if (apr_thread_mutex_lock(mutex) != APR_SUCCESS) {
  82         abort();
  83     }
  84
  85     return mutex;
  86 }
  87
  88 #else
  89
  90 apr_status_t apr__atomic_generic64_init(apr_pool_t *p)
  91 {
  92     return APR_SUCCESS;
  93 }
  94
  95 #endif /* APR_HAS_THREADS */
  96
  97 APR_DECLARE(apr_uint64_t) apr_atomic_read64(volatile apr_uint64_t *mem)
  98 {
  99     return *mem;
 100 }
 101
 102 APR_DECLARE(void) apr_atomic_set64(volatile apr_uint64_t *mem, apr_uint64_t val)
 103 {
 104     DECLARE_MUTEX_LOCKED(mutex, mem);
 105
 106     *mem = val;
 107
 108     MUTEX_UNLOCK(mutex);
 109 }
 110
 111 APR_DECLARE(apr_uint64_t) apr_atomic_add64(volatile apr_uint64_t *mem, apr_uint64_t val)
 112 {
 113     apr_uint64_t old_value;
 114     DECLARE_MUTEX_LOCKED(mutex, mem);
 115
 116     old_value = *mem;
 117     *mem += val;
 118
 119     MUTEX_UNLOCK(mutex);
 120
 121     return old_value;
 122 }
 123
 124 APR_DECLARE(void) apr_atomic_sub64(volatile apr_uint64_t *mem, apr_uint64_t val)
 125 {
 126     DECLARE_MUTEX_LOCKED(mutex, mem);
 127     *mem -= val;
 128     MUTEX_UNLOCK(mutex);
 129 }
 130
 131 APR_DECLARE(apr_uint64_t) apr_atomic_inc64(volatile apr_uint64_t *mem)
 132 {
 133     return apr_atomic_add64(mem, 1);
 134 }
 135
 136 APR_DECLARE(int) apr_atomic_dec64(volatile apr_uint64_t *mem)
 137 {
 138     apr_uint64_t new;
 139     DECLARE_MUTEX_LOCKED(mutex, mem);
 140
 141     (*mem)--;
 142     new = *mem;
 143
 144     MUTEX_UNLOCK(mutex);
 145
 146     return new;
 147 }
 148
 149 APR_DECLARE(apr_uint64_t) apr_atomic_cas64(volatile apr_uint64_t *mem, apr_uint64_t with,
 150                               apr_uint64_t cmp)
 151 {
 152     apr_uint64_t prev;
 153     DECLARE_MUTEX_LOCKED(mutex, mem);
 154
 155     prev = *mem;
 156     if (prev == cmp) {
 157         *mem = with;
 158     }
 159
 160     MUTEX_UNLOCK(mutex);
 161
 162     return prev;
 163 }
 164
 165 APR_DECLARE(apr_uint64_t) apr_atomic_xchg64(volatile apr_uint64_t *mem, apr_uint64_t val)
 166 {
 167     apr_uint64_t prev;
 168     DECLARE_MUTEX_LOCKED(mutex, mem);
 169
 170     prev = *mem;
 171     *mem = val;
 172
 173     MUTEX_UNLOCK(mutex);
 174
 175     return prev;
 176 }
 177
 178 #endif /* USE_ATOMICS_GENERIC64 */