| /* |
| * svn_named_atomic.c: routines for machine-wide named atomics. |
| * |
| * ==================================================================== |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * ==================================================================== |
| */ |
| |
| #include "private/svn_named_atomic.h" |
| |
| #include <apr_global_mutex.h> |
| #include <apr_mmap.h> |
| |
| #include "svn_private_config.h" |
| #include "private/svn_atomic.h" |
| #include "private/svn_mutex.h" |
| #include "svn_pools.h" |
| #include "svn_dirent_uri.h" |
| #include "svn_io.h" |
| |
| /* Implementation aspects. |
| * |
| * We use a single shared memory block (memory mapped file) that will be |
| * created by the first user and merely mapped by all subsequent ones. |
| * The memory block contains an short header followed by a fixed-capacity |
| * array of named atomics. The number of entries currently in use is stored |
| * in the header part. |
| * |
| * Finding / creating the MMAP object as well as adding new array entries |
| * is being guarded by an APR global mutex. Since releasing the MMAP |
| * structure and closing the underlying does not affect other users of the |
| * same, cleanup will not be synchronized. |
| * |
| * The array is append-only. Once a process mapped the block into its |
| * address space, it may freely access any of the used entries. However, |
| * it must synchronize access to the volatile data within the entries. |
| * On Windows and where otherwise supported by GCC, lightweight "lock-free" |
| * synchronization will be used. Other targets serialize all access using |
| * a global mutex. |
| * |
| * Atomics will be identified by their name (a short string) and lookup |
| * takes linear time. But even that takes only about 10 microseconds for a |
| * full array scan -- which is in the same order of magnitude than e.g. a |
| * single global mutex lock / unlock pair. |
| */ |
| |
| /* Capacity of our shared memory object, i.e. max number of named atomics |
| * that may be created. Should have the form 2**N - 1. |
| */ |
| #define MAX_ATOMIC_COUNT 1023 |
| |
| /* We choose the size of a single named atomic object to fill a complete |
| * cache line (on most architectures). Thereby, we minimize the cache |
| * sync. overhead between different CPU cores. |
| */ |
| #define CACHE_LINE_LENGTH 64 |
| |
| /* We need 8 bytes for the actual value and the remainder is used to |
| * store the NUL-terminated name. |
| * |
| * Must not be smaller than SVN_NAMED_ATOMIC__MAX_NAME_LENGTH. |
| */ |
| #define MAX_NAME_LENGTH (CACHE_LINE_LENGTH - sizeof(apr_int64_t) - 1) |
| |
| /* Particle that will be appended to the namespace name to form the |
| * name of the mutex / lock file used for that namespace. |
| */ |
| #define MUTEX_NAME_SUFFIX ".mutex" |
| |
| /* Particle that will be appended to the namespace name to form the |
| * name of the shared memory file that backs that namespace. |
| */ |
| #define SHM_NAME_SUFFIX ".shm" |
| |
| /* Platform-dependent implementations of our basic atomic operations. |
| * NA_SYNCHRONIZE(op) will ensure that the OP gets executed atomically. |
| * This will be zero-overhead if OP itself is already atomic. |
| * |
| * (We don't call it SYNCHRONIZE because Windows has a preprocess macro by |
| * that name.) |
| * |
| * The default implementation will use the same mutex for initialization |
| * as well as any type of data access. This is quite expensive and we |
| * can do much better on most platforms. |
| */ |
| #if defined(WIN32) && ((_WIN32_WINNT >= 0x0502) || defined(InterlockedExchangeAdd64)) |
| |
| /* Interlocked API / intrinsics guarantee full data synchronization |
| */ |
| #define synched_read(mem) *mem |
| #define synched_write(mem, value) InterlockedExchange64(mem, value) |
| #define synched_add(mem, delta) InterlockedExchangeAdd64(mem, delta) |
| #define synched_cmpxchg(mem, value, comperand) \ |
| InterlockedCompareExchange64(mem, value, comperand) |
| |
| #define NA_SYNCHRONIZE(_atomic,op) op; |
| #define NA_SYNCHRONIZE_IS_FAST TRUE |
| |
| #elif SVN_HAS_ATOMIC_BUILTINS |
| |
| /* GCC provides atomic intrinsics for most common CPU types |
| */ |
| #define synched_read(mem) *mem |
| #define synched_write(mem, value) __sync_lock_test_and_set(mem, value) |
| #define synched_add(mem, delta) __sync_add_and_fetch(mem, delta) |
| #define synched_cmpxchg(mem, value, comperand) \ |
| __sync_val_compare_and_swap(mem, comperand, value) |
| |
| #define NA_SYNCHRONIZE(_atomic,op) op; |
| #define NA_SYNCHRONIZE_IS_FAST TRUE |
| |
| #else |
| |
| /* Default implementation |
| */ |
| static apr_int64_t |
| synched_read(volatile apr_int64_t *mem) |
| { |
| return *mem; |
| } |
| |
| static apr_int64_t |
| synched_write(volatile apr_int64_t *mem, apr_int64_t value) |
| { |
| apr_int64_t old_value = *mem; |
| *mem = value; |
| |
| return old_value; |
| } |
| |
| static apr_int64_t |
| synched_add(volatile apr_int64_t *mem, apr_int64_t delta) |
| { |
| return *mem += delta; |
| } |
| |
| static apr_int64_t |
| synched_cmpxchg(volatile apr_int64_t *mem, |
| apr_int64_t value, |
| apr_int64_t comperand) |
| { |
| apr_int64_t old_value = *mem; |
| if (old_value == comperand) |
| *mem = value; |
| |
| return old_value; |
| } |
| |
| #define NA_SYNCHRONIZE(_atomic,op)\ |
| do{\ |
| SVN_ERR(lock(_atomic->mutex));\ |
| op;\ |
| SVN_ERR(unlock(_atomic->mutex,SVN_NO_ERROR));\ |
| }while(0) |
| |
| #define NA_SYNCHRONIZE_IS_FAST FALSE |
| |
| #endif |
| |
| /* Structure describing a single atomic: its VALUE and NAME. |
| */ |
| struct named_atomic_data_t |
| { |
| volatile apr_int64_t value; |
| char name[MAX_NAME_LENGTH + 1]; |
| }; |
| |
| /* Content of our shared memory buffer. COUNT is the number |
| * of used entries in ATOMICS. Insertion is append-only. |
| * PADDING is used to align the header information with the |
| * atomics to create a favorable data alignment. |
| */ |
| struct shared_data_t |
| { |
| volatile apr_uint32_t count; |
| char padding [sizeof(struct named_atomic_data_t) - sizeof(apr_uint32_t)]; |
| |
| struct named_atomic_data_t atomics[MAX_ATOMIC_COUNT]; |
| }; |
| |
| /* Structure combining all objects that we need for access serialization. |
| */ |
| struct mutex_t |
| { |
| /* Inter-process sync. is handled by through lock file. */ |
| apr_file_t *lock_file; |
| |
| /* Pool to be used with lock / unlock functions */ |
| apr_pool_t *pool; |
| }; |
| |
| /* API structure combining the atomic data and the access mutex |
| */ |
| struct svn_named_atomic__t |
| { |
| /* pointer into the shared memory */ |
| struct named_atomic_data_t *data; |
| |
| /* sync. object; never NULL (even if unused) */ |
| struct mutex_t *mutex; |
| }; |
| |
| /* This is intended to be a singleton struct. It contains all |
| * information necessary to initialize and access the shared |
| * memory. |
| */ |
| struct svn_atomic_namespace__t |
| { |
| /* Pointer to the shared data mapped into our process */ |
| struct shared_data_t *data; |
| |
| /* Last time we checked, this was the number of used |
| * (i.e. fully initialized) items. I.e. we can read |
| * their names without further sync. */ |
| volatile svn_atomic_t min_used; |
| |
| /* for each atomic in the shared memory, we hand out |
| * at most one API-level object. */ |
| struct svn_named_atomic__t atomics[MAX_ATOMIC_COUNT]; |
| |
| /* Synchronization object for this namespace */ |
| struct mutex_t mutex; |
| }; |
| |
| /* On most operating systems APR implements file locks per process, not |
| * per file. I.e. the lock file will only sync. among processes but within |
| * a process, we must use a mutex to sync the threads. */ |
| /* Compare ../libsvn_fs_fs/fs.h:SVN_FS_FS__USE_LOCK_MUTEX */ |
| #if APR_HAS_THREADS && !defined(WIN32) |
| #define USE_THREAD_MUTEX 1 |
| #else |
| #define USE_THREAD_MUTEX 0 |
| #endif |
| |
| /* Used for process-local thread sync. |
| */ |
| static svn_mutex__t *thread_mutex = NULL; |
| |
| #if APR_HAS_MMAP |
| /* Initialization flag for the above used by svn_atomic__init_once. |
| */ |
| static volatile svn_atomic_t mutex_initialized = FALSE; |
| |
| /* Initialize the thread sync. structures. |
| * To be called by svn_atomic__init_once. |
| */ |
| static svn_error_t * |
| init_thread_mutex(void *baton, apr_pool_t *pool) |
| { |
| /* let the mutex live as long as the APR */ |
| apr_pool_t *global_pool = svn_pool_create(NULL); |
| |
| return svn_mutex__init(&thread_mutex, USE_THREAD_MUTEX, global_pool); |
| } |
| #endif /* APR_HAS_MMAP */ |
| |
| /* Utility that acquires our global mutex and converts error types. |
| */ |
| static svn_error_t * |
| lock(struct mutex_t *mutex) |
| { |
| svn_error_t *err; |
| |
| /* Get lock on the filehandle. */ |
| SVN_ERR(svn_mutex__lock(thread_mutex)); |
| err = svn_io_lock_open_file(mutex->lock_file, TRUE, FALSE, mutex->pool); |
| |
| return err |
| ? svn_mutex__unlock(thread_mutex, err) |
| : err; |
| } |
| |
| /* Utility that releases the lock previously acquired via lock(). If the |
| * unlock succeeds and OUTER_ERR is not NULL, OUTER_ERR will be returned. |
| * Otherwise, return the result of the unlock operation. |
| */ |
| static svn_error_t * |
| unlock(struct mutex_t *mutex, svn_error_t * outer_err) |
| { |
| svn_error_t *unlock_err |
| = svn_io_unlock_open_file(mutex->lock_file, mutex->pool); |
| return svn_mutex__unlock(thread_mutex, |
| svn_error_compose_create(outer_err, |
| unlock_err)); |
| } |
| |
| #if APR_HAS_MMAP |
| /* The last user to close a particular namespace should also remove the |
| * lock file. Failure to do so, however, does not affect further uses |
| * of the same namespace. |
| */ |
| static apr_status_t |
| delete_lock_file(void *arg) |
| { |
| struct mutex_t *mutex = arg; |
| const char *lock_name = NULL; |
| |
| /* locks have already been cleaned up. Simply close the file */ |
| apr_status_t status = apr_file_close(mutex->lock_file); |
| |
| /* Remove the file from disk. This will fail if there ares still other |
| * users of this lock file, i.e. namespace. */ |
| apr_file_name_get(&lock_name, mutex->lock_file); |
| if (lock_name) |
| apr_file_remove(lock_name, mutex->pool); |
| |
| return status; |
| } |
| #endif /* APR_HAS_MMAP */ |
| |
| /* Validate the ATOMIC parameter, i.e it's address. Correct code will |
| * never need this but if someone should accidentally to use a NULL or |
| * incomplete structure, let's catch that here instead of segfaulting. |
| */ |
| static svn_error_t * |
| validate(svn_named_atomic__t *atomic) |
| { |
| return atomic && atomic->data && atomic->mutex |
| ? SVN_NO_ERROR |
| : svn_error_create(SVN_ERR_BAD_ATOMIC, 0, _("Not a valid atomic")); |
| } |
| |
| /* Auto-initialize and return in *ATOMIC the API-level object for the |
| * atomic with index I within NS. */ |
| static void |
| return_atomic(svn_named_atomic__t **atomic, |
| svn_atomic_namespace__t *ns, |
| int i) |
| { |
| *atomic = &ns->atomics[i]; |
| if (ns->atomics[i].data == NULL) |
| { |
| (*atomic)->mutex = &ns->mutex; |
| (*atomic)->data = &ns->data->atomics[i]; |
| } |
| } |
| |
| /* Implement API */ |
| |
| svn_boolean_t |
| svn_named_atomic__is_supported(void) |
| { |
| #if !APR_HAS_MMAP |
| return FALSE; |
| #elif !defined(_WIN32) |
| return TRUE; |
| #else |
| static svn_tristate_t result = svn_tristate_unknown; |
| |
| if (result == svn_tristate_unknown) |
| { |
| /* APR SHM implementation requires the creation of global objects */ |
| HANDLE handle = CreateFileMappingA(INVALID_HANDLE_VALUE, |
| NULL, |
| PAGE_READONLY, |
| 0, |
| 1, |
| "Global\\__RandomXZY_svn"); |
| if (handle != NULL) |
| { |
| CloseHandle(handle); |
| result = svn_tristate_true; |
| } |
| else |
| result = svn_tristate_false; |
| } |
| |
| return result == svn_tristate_true; |
| #endif /* _WIN32 */ |
| } |
| |
| svn_boolean_t |
| svn_named_atomic__is_efficient(void) |
| { |
| return NA_SYNCHRONIZE_IS_FAST; |
| } |
| |
| svn_error_t * |
| svn_atomic_namespace__create(svn_atomic_namespace__t **ns, |
| const char *name, |
| apr_pool_t *result_pool) |
| { |
| #if !APR_HAS_MMAP |
| return svn_error_create(APR_ENOTIMPL, NULL, NULL); |
| #else |
| apr_status_t apr_err; |
| svn_error_t *err; |
| apr_file_t *file; |
| apr_mmap_t *mmap; |
| const char *shm_name, *lock_name; |
| apr_finfo_t finfo; |
| |
| apr_pool_t *subpool = svn_pool_create(result_pool); |
| |
| /* allocate the namespace data structure |
| */ |
| svn_atomic_namespace__t *new_ns = apr_pcalloc(result_pool, sizeof(**ns)); |
| |
| /* construct the names of the system objects that we need |
| */ |
| shm_name = apr_pstrcat(subpool, name, SHM_NAME_SUFFIX, NULL); |
| lock_name = apr_pstrcat(subpool, name, MUTEX_NAME_SUFFIX, NULL); |
| |
| /* initialize the lock objects |
| */ |
| SVN_ERR(svn_atomic__init_once(&mutex_initialized, init_thread_mutex, NULL, |
| result_pool)); |
| |
| new_ns->mutex.pool = result_pool; |
| SVN_ERR(svn_io_file_open(&new_ns->mutex.lock_file, lock_name, |
| APR_READ | APR_WRITE | APR_CREATE, |
| APR_OS_DEFAULT, |
| result_pool)); |
| |
| /* Make sure the last user of our lock file will actually remove it. |
| * Please note that only the last file handle begin closed will actually |
| * remove the underlying file (see docstring for apr_file_remove). |
| */ |
| apr_pool_cleanup_register(result_pool, &new_ns->mutex, |
| delete_lock_file, |
| apr_pool_cleanup_null); |
| |
| /* Prevent concurrent initialization. |
| */ |
| SVN_ERR(lock(&new_ns->mutex)); |
| |
| /* First, make sure that the underlying file exists. If it doesn't |
| * exist, create one and initialize its content. |
| */ |
| err = svn_io_file_open(&file, shm_name, |
| APR_READ | APR_WRITE | APR_CREATE, |
| APR_OS_DEFAULT, |
| result_pool); |
| if (!err) |
| { |
| err = svn_io_stat(&finfo, shm_name, APR_FINFO_SIZE, subpool); |
| if (!err && finfo.size < sizeof(struct shared_data_t)) |
| { |
| /* Zero all counters, values and names. |
| */ |
| struct shared_data_t initial_data; |
| memset(&initial_data, 0, sizeof(initial_data)); |
| err = svn_io_file_write_full(file, &initial_data, |
| sizeof(initial_data), NULL, |
| subpool); |
| } |
| } |
| |
| /* Now, map it into memory. |
| */ |
| if (!err) |
| { |
| apr_err = apr_mmap_create(&mmap, file, 0, sizeof(*new_ns->data), |
| APR_MMAP_READ | APR_MMAP_WRITE , result_pool); |
| if (!apr_err) |
| new_ns->data = mmap->mm; |
| else |
| err = svn_error_createf(apr_err, NULL, |
| _("MMAP failed for file '%s'"), shm_name); |
| } |
| |
| svn_pool_destroy(subpool); |
| |
| if (!err && new_ns->data) |
| { |
| /* Detect severe cases of corruption (i.e. when some outsider messed |
| * with our data file) |
| */ |
| if (new_ns->data->count > MAX_ATOMIC_COUNT) |
| return svn_error_create(SVN_ERR_CORRUPTED_ATOMIC_STORAGE, 0, |
| _("Number of atomics in namespace is too large.")); |
| |
| /* Cache the number of existing, complete entries. There can't be |
| * incomplete ones from other processes because we hold the mutex. |
| * Our process will also not access this information since we are |
| * either being called from within svn_atomic__init_once or by |
| * svn_atomic_namespace__create for a new object. |
| */ |
| new_ns->min_used = new_ns->data->count; |
| *ns = new_ns; |
| } |
| |
| /* Unlock to allow other processes may access the shared memory as well. |
| */ |
| return unlock(&new_ns->mutex, err); |
| #endif /* APR_HAS_MMAP */ |
| } |
| |
| svn_error_t * |
| svn_atomic_namespace__cleanup(const char *name, |
| apr_pool_t *pool) |
| { |
| const char *shm_name, *lock_name; |
| |
| /* file names used for the specified namespace */ |
| shm_name = apr_pstrcat(pool, name, SHM_NAME_SUFFIX, NULL); |
| lock_name = apr_pstrcat(pool, name, MUTEX_NAME_SUFFIX, NULL); |
| |
| /* remove these files if they exist */ |
| SVN_ERR(svn_io_remove_file2(shm_name, TRUE, pool)); |
| SVN_ERR(svn_io_remove_file2(lock_name, TRUE, pool)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_named_atomic__get(svn_named_atomic__t **atomic, |
| svn_atomic_namespace__t *ns, |
| const char *name, |
| svn_boolean_t auto_create) |
| { |
| apr_uint32_t i, count; |
| svn_error_t *error = SVN_NO_ERROR; |
| apr_size_t len = strlen(name); |
| |
| /* Check parameters and make sure we return a NULL atomic |
| * in case of failure. |
| */ |
| *atomic = NULL; |
| if (len > SVN_NAMED_ATOMIC__MAX_NAME_LENGTH) |
| return svn_error_create(SVN_ERR_BAD_ATOMIC, 0, |
| _("Atomic's name is too long.")); |
| |
| /* If no namespace has been provided, bail out. |
| */ |
| if (ns == NULL || ns->data == NULL) |
| return svn_error_create(SVN_ERR_BAD_ATOMIC, 0, |
| _("Namespace has not been initialized.")); |
| |
| /* Optimistic lookup. |
| * Because we never change the name of existing atomics and may only |
| * append new ones, we can safely compare the name of existing ones |
| * with the name that we are looking for. |
| */ |
| for (i = 0, count = svn_atomic_read(&ns->min_used); i < count; ++i) |
| if (strncmp(ns->data->atomics[i].name, name, len + 1) == 0) |
| { |
| return_atomic(atomic, ns, i); |
| return SVN_NO_ERROR; |
| } |
| |
| /* Try harder: |
| * Serialize all lookup and insert the item, if necessary and allowed. |
| */ |
| SVN_ERR(lock(&ns->mutex)); |
| |
| /* We only need to check for new entries. |
| */ |
| for (i = count; i < ns->data->count; ++i) |
| if (strncmp(ns->data->atomics[i].name, name, len + 1) == 0) |
| { |
| return_atomic(atomic, ns, i); |
| |
| /* Update our cached number of complete entries. */ |
| svn_atomic_set(&ns->min_used, ns->data->count); |
| |
| return unlock(&ns->mutex, error); |
| } |
| |
| /* Not found. Append a new entry, if allowed & possible. |
| */ |
| if (auto_create) |
| { |
| if (ns->data->count < MAX_ATOMIC_COUNT) |
| { |
| ns->data->atomics[ns->data->count].value = 0; |
| memcpy(ns->data->atomics[ns->data->count].name, |
| name, |
| len+1); |
| |
| return_atomic(atomic, ns, ns->data->count); |
| ++ns->data->count; |
| } |
| else |
| error = svn_error_create(SVN_ERR_BAD_ATOMIC, 0, |
| _("Out of slots for named atomic.")); |
| } |
| |
| /* We are mainly done here. Let others continue their work. |
| */ |
| SVN_ERR(unlock(&ns->mutex, error)); |
| |
| /* Only now can we be sure that a full memory barrier has been set |
| * and that the new entry has been written to memory in full. |
| */ |
| svn_atomic_set(&ns->min_used, ns->data->count); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_named_atomic__read(apr_int64_t *value, |
| svn_named_atomic__t *atomic) |
| { |
| SVN_ERR(validate(atomic)); |
| NA_SYNCHRONIZE(atomic, *value = synched_read(&atomic->data->value)); |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_named_atomic__write(apr_int64_t *old_value, |
| apr_int64_t new_value, |
| svn_named_atomic__t *atomic) |
| { |
| apr_int64_t temp; |
| |
| SVN_ERR(validate(atomic)); |
| NA_SYNCHRONIZE(atomic, temp = synched_write(&atomic->data->value, new_value)); |
| |
| if (old_value) |
| *old_value = temp; |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_named_atomic__add(apr_int64_t *new_value, |
| apr_int64_t delta, |
| svn_named_atomic__t *atomic) |
| { |
| apr_int64_t temp; |
| |
| SVN_ERR(validate(atomic)); |
| NA_SYNCHRONIZE(atomic, temp = synched_add(&atomic->data->value, delta)); |
| |
| if (new_value) |
| *new_value = temp; |
| |
| return SVN_NO_ERROR; |
| } |
| |
| svn_error_t * |
| svn_named_atomic__cmpxchg(apr_int64_t *old_value, |
| apr_int64_t new_value, |
| apr_int64_t comperand, |
| svn_named_atomic__t *atomic) |
| { |
| apr_int64_t temp; |
| |
| SVN_ERR(validate(atomic)); |
| NA_SYNCHRONIZE(atomic, temp = synched_cmpxchg(&atomic->data->value, |
| new_value, |
| comperand)); |
| |
| if (old_value) |
| *old_value = temp; |
| |
| return SVN_NO_ERROR; |
| } |