diff options
Diffstat (limited to 'src/spdk/lib/env_ocf')
| -rw-r--r-- | src/spdk/lib/env_ocf/.gitignore | 2 | ||||
| -rw-r--r-- | src/spdk/lib/env_ocf/Makefile | 108 | ||||
| -rw-r--r-- | src/spdk/lib/env_ocf/ocf_env.c | 176 | ||||
| -rw-r--r-- | src/spdk/lib/env_ocf/ocf_env.h | 834 | ||||
| -rw-r--r-- | src/spdk/lib/env_ocf/ocf_env_headers.h | 43 | ||||
| -rw-r--r-- | src/spdk/lib/env_ocf/ocf_env_list.h | 185 |
6 files changed, 1348 insertions, 0 deletions
diff --git a/src/spdk/lib/env_ocf/.gitignore b/src/spdk/lib/env_ocf/.gitignore new file mode 100644 index 000000000..f5452c248 --- /dev/null +++ b/src/spdk/lib/env_ocf/.gitignore @@ -0,0 +1,2 @@ +src/ +include/ diff --git a/src/spdk/lib/env_ocf/Makefile b/src/spdk/lib/env_ocf/Makefile new file mode 100644 index 000000000..0ac51eecd --- /dev/null +++ b/src/spdk/lib/env_ocf/Makefile @@ -0,0 +1,108 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * 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. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS 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 COPYRIGHT +# OWNER OR 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. +# + +# OCF requires users to build with their sources +# If SPDK is configured with OCF source directory, +# we export its files and then compile SPDK LIB with them +# Else if SPDK is configured with OCF precompiled library +# we just use it as SPDK lib by copying it to /build/lib/ + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../..) +OCFDIR=$(CONFIG_OCF_DIR) + +include $(SPDK_ROOT_DIR)/mk/spdk.common.mk + +LIBNAME := ocfenv + +CFLAGS += $(ENV_CFLAGS) -I$(CURDIR) -I$(CURDIR)/include -w +C_SRCS = $(shell find -name \*.c) + +LIB = $(call spdk_lib_list_to_static_libs,$(LIBNAME)) + + +ifeq ($(CONFIG_CUSTOMOCF),y) + +.PHONY: all clean install + +all: + $(Q)$(MAKE) $(LIB) + +clean: + $(Q)rm -f $(LIB) + +$(LIB): + cp $(CONFIG_OCF_PATH) $(LIB) + +install: + +uninstall: + $(UNINSTALL_LIB) + +else + +.PHONY: all clean install ocf_inc ocf_src ocf_distclean all exportlib + +all: ocf_inc ocf_src + $(Q)$(MAKE) $(LIB) + +ocf_inc: + $(Q)$(MAKE) -C "$(CONFIG_OCF_PATH)" inc O="$(SPDK_ROOT_DIR)/lib/env_ocf/" ENV= --quiet + +ocf_src: ocf_inc + $(Q)$(MAKE) -C "$(CONFIG_OCF_PATH)" src O="$(SPDK_ROOT_DIR)/lib/env_ocf/" CMD=cp ENV= --quiet + +ocf_distclean: + $(Q)$(MAKE) -C "$(CONFIG_OCF_PATH)" distclean O="$(SPDK_ROOT_DIR)/lib/env_ocf/" ENV= --quiet + +clean: ocf_distclean + $(Q)rm -rf "$(SPDK_ROOT_DIR)/lib/env_ocf/include" \ + "$(SPDK_ROOT_DIR)/lib/env_ocf/src" \ + $(LIB) $(OBJS); + +$(LIB): $(OBJS) + $(LIB_C) + +install: + +uninstall: + $(UNINSTALL_LIB) + +endif + +exportlib: all + @ if [ -z $(O) ]; then echo "No output specified"; exit 1; fi + cp $(LIB) $(O) + +help: + @ echo "all Default" + @ echo "exportlib O=<outpath> Default build to specified outpath" diff --git a/src/spdk/lib/env_ocf/ocf_env.c b/src/spdk/lib/env_ocf/ocf_env.c new file mode 100644 index 000000000..ab5445203 --- /dev/null +++ b/src/spdk/lib/env_ocf/ocf_env.c @@ -0,0 +1,176 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS 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 COPYRIGHT + * OWNER OR 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. + */ +#include "ocf/ocf_def.h" +#include "ocf_env.h" + +#include "spdk/crc32.h" +#include "spdk/env.h" +#include "spdk_internal/log.h" + +/* Number of buffers for mempool + * Need to be power of two - 1 for better memory utilization + * It depends on memory usage of OCF which + * in itself depends on the workload + * It is a big number because OCF uses allocators + * for every request it sends and recieves + */ +#define ENV_ALLOCATOR_NBUFS 32767 + +/* Use unique index for env allocators */ +static env_atomic g_env_allocator_index = 0; + +void * +env_allocator_new(env_allocator *allocator) +{ + void *mem = spdk_mempool_get(allocator->mempool); + + if (spdk_likely(mem)) { + memset(mem, 0, allocator->element_size); + } + + return mem; +} + +env_allocator * +env_allocator_create(uint32_t size, const char *name) +{ + env_allocator *allocator; + char qualified_name[128] = {0}; + + snprintf(qualified_name, 128, "ocf_env_%d", env_atomic_inc_return(&g_env_allocator_index)); + + allocator = calloc(1, sizeof(*allocator)); + if (!allocator) { + return NULL; + } + + allocator->mempool = spdk_mempool_create(qualified_name, + ENV_ALLOCATOR_NBUFS, size, + SPDK_MEMPOOL_DEFAULT_CACHE_SIZE, + SPDK_ENV_SOCKET_ID_ANY); + + if (!allocator->mempool) { + free(allocator); + return NULL; + } + + allocator->element_size = size; + + return allocator; +} + +void +env_allocator_del(env_allocator *allocator, void *item) +{ + spdk_mempool_put(allocator->mempool, item); +} + +void +env_allocator_destroy(env_allocator *allocator) +{ + if (allocator) { + if (ENV_ALLOCATOR_NBUFS - spdk_mempool_count(allocator->mempool)) { + SPDK_ERRLOG("Not all objects deallocated\n"); + assert(false); + } + + spdk_mempool_free(allocator->mempool); + free(allocator); + } +} +/* *** CRC *** */ + +uint32_t +env_crc32(uint32_t crc, uint8_t const *message, size_t len) +{ + return spdk_crc32_ieee_update(message, len, crc); +} + +/* EXECUTION CONTEXTS */ +pthread_mutex_t *exec_context_mutex; + +static void __attribute__((constructor)) init_execution_context(void) +{ + unsigned count = env_get_execution_context_count(); + unsigned i; + + ENV_BUG_ON(count == 0); + exec_context_mutex = malloc(count * sizeof(exec_context_mutex[0])); + ENV_BUG_ON(exec_context_mutex == NULL); + for (i = 0; i < count; i++) { + ENV_BUG_ON(pthread_mutex_init(&exec_context_mutex[i], NULL)); + } +} + +static void __attribute__((destructor)) deinit_execution_context(void) +{ + unsigned count = env_get_execution_context_count(); + unsigned i; + + ENV_BUG_ON(count == 0); + ENV_BUG_ON(exec_context_mutex == NULL); + + for (i = 0; i < count; i++) { + ENV_BUG_ON(pthread_mutex_destroy(&exec_context_mutex[i])); + } + free(exec_context_mutex); +} + +/* get_execuction_context must assure that after the call finishes, the caller + * will not get preempted from current execution context. For userspace env + * we simulate this behavior by acquiring per execution context mutex. As a + * result the caller might actually get preempted, but no other thread will + * execute in this context by the time the caller puts current execution ctx. */ +unsigned env_get_execution_context(void) +{ + unsigned cpu; + + cpu = sched_getcpu(); + cpu = (cpu == -1) ? 0 : cpu; + + ENV_BUG_ON(pthread_mutex_lock(&exec_context_mutex[cpu])); + + return cpu; +} + +void env_put_execution_context(unsigned ctx) +{ + pthread_mutex_unlock(&exec_context_mutex[ctx]); +} + +unsigned env_get_execution_context_count(void) +{ + int num = sysconf(_SC_NPROCESSORS_ONLN); + + return (num == -1) ? 0 : num; +} diff --git a/src/spdk/lib/env_ocf/ocf_env.h b/src/spdk/lib/env_ocf/ocf_env.h new file mode 100644 index 000000000..81d2e814b --- /dev/null +++ b/src/spdk/lib/env_ocf/ocf_env.h @@ -0,0 +1,834 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS 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 COPYRIGHT + * OWNER OR 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. + */ + + +#ifndef __LIBOCF_ENV_H__ +#define __LIBOCF_ENV_H__ + +#ifndef _GNU_SOURCE +#define _GNU_SOURCE +#endif +#ifndef __USE_GNU +#define __USE_GNU +#endif + +#include <linux/limits.h> +#include <linux/stddef.h> + +#include "spdk/stdinc.h" +#include "spdk/likely.h" +#include "spdk/env.h" +#include "spdk/util.h" +#include "spdk_internal/log.h" + +#include "ocf_env_list.h" +#include "ocf/ocf_err.h" + +typedef uint8_t u8; +typedef uint16_t u16; +typedef uint32_t u32; +typedef uint64_t u64; + +typedef uint64_t sector_t; + +#define __packed __attribute__((packed)) +#define __aligned(x) __attribute__((aligned(x))) + +/* linux sector 512-bytes */ +#define ENV_SECTOR_SHIFT 9 +#define ENV_SECTOR_SIZE (1<<ENV_SECTOR_SHIFT) +#define BYTES_TO_SECTOR(x) ((x) >> ENV_SECTOR_SHIFT) + +/* *** MEMORY MANAGEMENT *** */ + +#define ENV_MEM_NORMAL 0 +#define ENV_MEM_NOIO 0 +#define ENV_MEM_ATOMIC 0 + +#define likely spdk_likely +#define unlikely spdk_unlikely + +#define min(x, y) MIN(x, y) +#ifndef MIN +#define MIN(x, y) spdk_min(x, y) +#endif + +#define ARRAY_SIZE(x) SPDK_COUNTOF(x) + +/* LOGGING */ +#define ENV_PRIu64 PRIu64 + +#define ENV_WARN(cond, fmt, args...) ({ \ + if (spdk_unlikely((uintptr_t)(cond))) \ + SPDK_NOTICELOG("WARNING" fmt, ##args); \ + }) + +#define ENV_WARN_ON(cond) ({ \ + if (spdk_unlikely((uintptr_t)(cond))) \ + SPDK_NOTICELOG("WARNING\n"); \ + }) + +#define ENV_BUG() ({ \ + SPDK_ERRLOG("BUG\n"); \ + assert(0); \ + abort(); \ + }) + +#define ENV_BUG_ON(cond) ({ \ + if (spdk_unlikely((uintptr_t)(cond))) { \ + SPDK_ERRLOG("BUG\n"); \ + assert(0); \ + abort(); \ + } \ + }) + +#define ENV_BUILD_BUG_ON(cond) _Static_assert(!(cond), "static "\ + "assertion failure") + +#define container_of(ptr, type, member) SPDK_CONTAINEROF(ptr, type, member) + +static inline void *env_malloc(size_t size, int flags) +{ + return spdk_malloc(size, 0, NULL, SPDK_ENV_LCORE_ID_ANY, + SPDK_MALLOC_DMA); +} + +static inline void *env_zalloc(size_t size, int flags) +{ + return spdk_zmalloc(size, 0, NULL, SPDK_ENV_LCORE_ID_ANY, + SPDK_MALLOC_DMA); +} + +static inline void env_free(const void *ptr) +{ + return spdk_free((void *)ptr); +} + +static inline void *env_vmalloc(size_t size) +{ + return spdk_malloc(size, 0, NULL, SPDK_ENV_LCORE_ID_ANY, + SPDK_MALLOC_DMA); +} + +static inline void *env_vzalloc(size_t size) +{ + /* TODO: raw_ram init can request huge amount of memory to store + * hashtable in it. need to ensure that allocation succedds */ + return spdk_zmalloc(size, 0, NULL, SPDK_ENV_LCORE_ID_ANY, + SPDK_MALLOC_DMA); +} + +static inline void *env_vzalloc_flags(size_t size, int flags) +{ + return env_vzalloc(size); +} + +static inline void *env_secure_alloc(size_t size) +{ + return spdk_zmalloc(size, 0, NULL, SPDK_ENV_LCORE_ID_ANY, + SPDK_MALLOC_DMA); +} + +static inline void env_secure_free(const void *ptr, size_t size) +{ + return spdk_free((void *)ptr); +} + +static inline void env_vfree(const void *ptr) +{ + return spdk_free((void *)ptr); +} + +static inline uint64_t env_get_free_memory(void) +{ + return -1; +} + +/* *** ALLOCATOR *** */ + +#define OCF_ALLOCATOR_NAME_MAX 128 + +typedef struct { + struct spdk_mempool *mempool; + size_t element_size; +} env_allocator; + +env_allocator *env_allocator_create(uint32_t size, const char *name); + +void env_allocator_destroy(env_allocator *allocator); + +void *env_allocator_new(env_allocator *allocator); + +void env_allocator_del(env_allocator *allocator, void *item); + +uint32_t env_allocator_item_count(env_allocator *allocator); + +/* *** MUTEX *** */ + +typedef struct { + pthread_mutex_t m; +} env_mutex; + +static inline int env_mutex_init(env_mutex *mutex) +{ + return !!pthread_mutex_init(&mutex->m, NULL); +} + +static inline void env_mutex_lock(env_mutex *mutex) +{ + ENV_BUG_ON(pthread_mutex_lock(&mutex->m)); +} + +static inline int env_mutex_lock_interruptible(env_mutex *mutex) +{ + env_mutex_lock(mutex); + return 0; +} + +static inline int env_mutex_trylock(env_mutex *mutex) +{ + return pthread_mutex_trylock(&mutex->m) ? -OCF_ERR_NO_LOCK : 0; +} + +static inline void env_mutex_unlock(env_mutex *mutex) +{ + ENV_BUG_ON(pthread_mutex_unlock(&mutex->m)); +} + +static inline int env_mutex_is_locked(env_mutex *mutex) +{ + if (env_mutex_trylock(mutex) == 0) { + env_mutex_unlock(mutex); + return 0; + } + + return 1; +} + +static inline int env_mutex_destroy(env_mutex *mutex) +{ + if (pthread_mutex_destroy(&mutex->m)) { + return 1; + } + + return 0; +} + +/* *** RECURSIVE MUTEX *** */ + +typedef env_mutex env_rmutex; + +static inline int env_rmutex_init(env_rmutex *rmutex) +{ + pthread_mutexattr_t attr; + + pthread_mutexattr_init(&attr); + pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); + pthread_mutex_init(&rmutex->m, &attr); + + return 0; +} + +static inline void env_rmutex_lock(env_rmutex *rmutex) +{ + env_mutex_lock(rmutex); +} + +static inline int env_rmutex_lock_interruptible(env_rmutex *rmutex) +{ + return env_mutex_lock_interruptible(rmutex); +} + +static inline int env_rmutex_trylock(env_rmutex *rmutex) +{ + return env_mutex_trylock(rmutex); +} + +static inline void env_rmutex_unlock(env_rmutex *rmutex) +{ + env_mutex_unlock(rmutex); +} + +static inline int env_rmutex_is_locked(env_rmutex *rmutex) +{ + return env_mutex_is_locked(rmutex); +} + +static inline int env_rmutex_destroy(env_rmutex *rmutex) +{ + return env_mutex_destroy(rmutex); +} + +/* *** RW SEMAPHORE *** */ +typedef struct { + pthread_rwlock_t lock; +} env_rwsem; + +static inline int env_rwsem_init(env_rwsem *s) +{ + return !!pthread_rwlock_init(&s->lock, NULL); +} + +static inline void env_rwsem_up_read(env_rwsem *s) +{ + ENV_BUG_ON(pthread_rwlock_unlock(&s->lock)); +} + +static inline void env_rwsem_down_read(env_rwsem *s) +{ + ENV_BUG_ON(pthread_rwlock_rdlock(&s->lock)); +} + +static inline int env_rwsem_down_read_trylock(env_rwsem *s) +{ + return pthread_rwlock_tryrdlock(&s->lock) ? -OCF_ERR_NO_LOCK : 0; +} + +static inline void env_rwsem_up_write(env_rwsem *s) +{ + ENV_BUG_ON(pthread_rwlock_unlock(&s->lock)); +} + +static inline void env_rwsem_down_write(env_rwsem *s) +{ + ENV_BUG_ON(pthread_rwlock_wrlock(&s->lock)); +} + +static inline int env_rwsem_down_write_trylock(env_rwsem *s) +{ + return pthread_rwlock_trywrlock(&s->lock) ? -OCF_ERR_NO_LOCK : 0; +} + +static inline int env_rwsem_is_locked(env_rwsem *s) +{ + if (env_rwsem_down_read_trylock(s) == 0) { + env_rwsem_up_read(s); + return 0; + } + + return 1; +} + +static inline int env_rwsem_down_read_interruptible(env_rwsem *s) +{ + return pthread_rwlock_rdlock(&s->lock); +} +static inline int env_rwsem_down_write_interruptible(env_rwsem *s) +{ + return pthread_rwlock_wrlock(&s->lock); +} + +static inline int env_rwsem_destroy(env_rwsem *s) +{ + return pthread_rwlock_destroy(&s->lock); +} + +/* *** ATOMIC VARIABLES *** */ + +typedef int env_atomic; + +typedef long env_atomic64; + +#ifndef atomic_read +#define atomic_read(ptr) (*(__typeof__(*ptr) *volatile) (ptr)) +#endif + +#ifndef atomic_set +#define atomic_set(ptr, i) ((*(__typeof__(*ptr) *volatile) (ptr)) = (i)) +#endif + +#define atomic_inc(ptr) ((void) __sync_fetch_and_add(ptr, 1)) +#define atomic_dec(ptr) ((void) __sync_fetch_and_add(ptr, -1)) +#define atomic_add(ptr, n) ((void) __sync_fetch_and_add(ptr, n)) +#define atomic_sub(ptr, n) ((void) __sync_fetch_and_sub(ptr, n)) + +#define atomic_cmpxchg __sync_val_compare_and_swap + +static inline int env_atomic_read(const env_atomic *a) +{ + return atomic_read(a); +} + +static inline void env_atomic_set(env_atomic *a, int i) +{ + atomic_set(a, i); +} + +static inline void env_atomic_add(int i, env_atomic *a) +{ + atomic_add(a, i); +} + +static inline void env_atomic_sub(int i, env_atomic *a) +{ + atomic_sub(a, i); +} + +static inline bool env_atomic_sub_and_test(int i, env_atomic *a) +{ + return __sync_sub_and_fetch(a, i) == 0; +} + +static inline void env_atomic_inc(env_atomic *a) +{ + atomic_inc(a); +} + +static inline void env_atomic_dec(env_atomic *a) +{ + atomic_dec(a); +} + +static inline bool env_atomic_dec_and_test(env_atomic *a) +{ + return __sync_sub_and_fetch(a, 1) == 0; +} + +static inline bool env_atomic_inc_and_test(env_atomic *a) +{ + return __sync_add_and_fetch(a, 1) == 0; +} + +static inline int env_atomic_add_return(int i, env_atomic *a) +{ + return __sync_add_and_fetch(a, i); +} + +static inline int env_atomic_sub_return(int i, env_atomic *a) +{ + return __sync_sub_and_fetch(a, i); +} + +static inline int env_atomic_inc_return(env_atomic *a) +{ + return env_atomic_add_return(1, a); +} + +static inline int env_atomic_dec_return(env_atomic *a) +{ + return env_atomic_sub_return(1, a); +} + +static inline int env_atomic_cmpxchg(env_atomic *a, int old, int new_value) +{ + return atomic_cmpxchg(a, old, new_value); +} + +static inline int env_atomic_add_unless(env_atomic *a, int i, int u) +{ + int c, old; + c = env_atomic_read(a); + for (;;) { + if (spdk_unlikely(c == (u))) { + break; + } + old = env_atomic_cmpxchg((a), c, c + (i)); + if (spdk_likely(old == c)) { + break; + } + c = old; + } + return c != (u); +} + +static inline long env_atomic64_read(const env_atomic64 *a) +{ + return atomic_read(a); +} + +static inline void env_atomic64_set(env_atomic64 *a, long i) +{ + atomic_set(a, i); +} + +static inline void env_atomic64_add(long i, env_atomic64 *a) +{ + atomic_add(a, i); +} + +static inline void env_atomic64_sub(long i, env_atomic64 *a) +{ + atomic_sub(a, i); +} + +static inline void env_atomic64_inc(env_atomic64 *a) +{ + atomic_inc(a); +} + +static inline void env_atomic64_dec(env_atomic64 *a) +{ + atomic_dec(a); +} + +static inline int env_atomic64_add_return(int i, env_atomic *a) +{ + return __sync_add_and_fetch(a, i); +} + +static inline int env_atomic64_sub_return(int i, env_atomic *a) +{ + return __sync_sub_and_fetch(a, i); +} + +static inline int env_atomic64_inc_return(env_atomic *a) +{ + return env_atomic64_add_return(1, a); +} + +static inline int env_atomic64_dec_return(env_atomic *a) +{ + return env_atomic_sub_return(1, a); +} + +static inline long env_atomic64_cmpxchg(env_atomic64 *a, long old, long new) +{ + return atomic_cmpxchg(a, old, new); +} + +/* *** COMPLETION *** */ +typedef struct completion { + sem_t sem; +} env_completion; + +static inline void env_completion_init(env_completion *completion) +{ + sem_init(&completion->sem, 0, 0); +} + +static inline void env_completion_wait(env_completion *completion) +{ + sem_wait(&completion->sem); +} + +static inline void env_completion_complete(env_completion *completion) +{ + sem_post(&completion->sem); +} + +static inline void env_completion_destroy(env_completion *completion) +{ + sem_destroy(&completion->sem); +} + +/* *** SPIN LOCKS *** */ + +typedef struct { + pthread_spinlock_t lock; +} env_spinlock; + +static inline int env_spinlock_init(env_spinlock *l) +{ + return pthread_spin_init(&l->lock, 0); +} + +static inline int env_spinlock_trylock(env_spinlock *l) +{ + return pthread_spin_trylock(&l->lock) ? -OCF_ERR_NO_LOCK : 0; +} + +static inline void env_spinlock_lock(env_spinlock *l) +{ + ENV_BUG_ON(pthread_spin_lock(&l->lock)); +} + +static inline void env_spinlock_unlock(env_spinlock *l) +{ + ENV_BUG_ON(pthread_spin_unlock(&l->lock)); +} + +#define env_spinlock_lock_irqsave(l, flags) \ + (void)flags; \ + env_spinlock_lock(l) + +#define env_spinlock_unlock_irqrestore(l, flags) \ + (void)flags; \ + env_spinlock_unlock(l) + +static inline void env_spinlock_destroy(env_spinlock *l) +{ + ENV_BUG_ON(pthread_spin_destroy(&l->lock)); +} + +/* *** RW LOCKS *** */ + +typedef struct { + pthread_rwlock_t lock; +} env_rwlock; + +static inline void env_rwlock_init(env_rwlock *l) +{ + ENV_BUG_ON(pthread_rwlock_init(&l->lock, NULL)); +} + +static inline void env_rwlock_read_lock(env_rwlock *l) +{ + ENV_BUG_ON(pthread_rwlock_rdlock(&l->lock)); +} + +static inline void env_rwlock_read_unlock(env_rwlock *l) +{ + ENV_BUG_ON(pthread_rwlock_unlock(&l->lock)); +} + +static inline void env_rwlock_write_lock(env_rwlock *l) +{ + ENV_BUG_ON(pthread_rwlock_wrlock(&l->lock)); +} + +static inline void env_rwlock_write_unlock(env_rwlock *l) +{ + ENV_BUG_ON(pthread_rwlock_unlock(&l->lock)); +} + +static inline void env_rwlock_destroy(env_rwlock *l) +{ + ENV_BUG_ON(pthread_rwlock_destroy(&l->lock)); +} + +static inline void env_bit_set(int nr, volatile void *addr) +{ + char *byte = (char *)addr + (nr >> 3); + char mask = 1 << (nr & 7); + + __sync_or_and_fetch(byte, mask); +} + +static inline void env_bit_clear(int nr, volatile void *addr) +{ + char *byte = (char *)addr + (nr >> 3); + char mask = 1 << (nr & 7); + + mask = ~mask; + __sync_and_and_fetch(byte, mask); +} + +static inline bool env_bit_test(int nr, const volatile unsigned long *addr) +{ + const char *byte = (char *)addr + (nr >> 3); + char mask = 1 << (nr & 7); + + return !!(*byte & mask); +} + +/* *** WAITQUEUE *** */ + +typedef struct { + sem_t sem; +} env_waitqueue; + +static inline void env_waitqueue_init(env_waitqueue *w) +{ + sem_init(&w->sem, 0, 0); +} + +static inline void env_waitqueue_wake_up(env_waitqueue *w) +{ + sem_post(&w->sem); +} + +#define env_waitqueue_wait(w, condition) \ +({ \ + int __ret = 0; \ + if (!(condition)) \ + sem_wait(&w.sem); \ + __ret = __ret; \ +}) + +/* *** SCHEDULING *** */ + +/* CAS does not need this while in user-space */ +static inline void env_schedule(void) +{ +} + +#define env_cond_resched env_schedule + +static inline int env_in_interrupt(void) +{ + return 0; +} + +static inline uint64_t env_get_tick_count(void) +{ + return spdk_get_ticks(); +} + +static inline uint64_t env_ticks_to_secs(uint64_t j) +{ + return j / spdk_get_ticks_hz(); +} + +static inline uint64_t env_ticks_to_msecs(uint64_t j) +{ + return env_ticks_to_secs(j) * 1000; +} + +static inline uint64_t env_ticks_to_nsecs(uint64_t j) +{ + return env_ticks_to_secs(j) * 1000 * 1000; +} + +static inline uint64_t env_ticks_to_usecs(uint64_t j) +{ + return env_ticks_to_secs(j) * 1000 * 1000 * 1000; +} + +static inline uint64_t env_secs_to_ticks(uint64_t j) +{ + return j * spdk_get_ticks_hz(); +} + +/* *** STRING OPERATIONS *** */ + +/* 512 KB is sufficient amount of memory for OCF operations */ +#define ENV_MAX_MEM (512 * 1024) + +static inline int env_memset(void *dest, size_t len, uint8_t value) +{ + if (dest == NULL || len == 0) { + return 1; + } + + memset(dest, value, len); + return 0; +} + +static inline int env_memcpy(void *dest, size_t dmax, const void *src, size_t len) +{ + if (dest == NULL || src == NULL) { + return 1; + } + if (dmax == 0 || dmax > ENV_MAX_MEM) { + return 1; + } + if (len == 0 || len > dmax) { + return 1; + } + + memcpy(dest, src, len); + return 0; +} + +static inline int env_memcmp(const void *aptr, size_t dmax, const void *bptr, size_t len, + int *diff) +{ + if (diff == NULL || aptr == NULL || bptr == NULL) { + return 1; + } + if (dmax == 0 || dmax > ENV_MAX_MEM) { + return 1; + } + if (len == 0 || len > dmax) { + return 1; + } + + *diff = memcmp(aptr, bptr, len); + return 0; +} + +/* 4096 is sufficient max length for any OCF operation on string */ +#define ENV_MAX_STR (4 * 1024) + +static inline size_t env_strnlen(const char *src, size_t dmax) +{ + return strnlen(src, dmax); +} + +static inline int env_strncpy(char *dest, size_t dmax, const char *src, size_t len) +{ + if (dest == NULL || src == NULL) { + return 1; + } + if (dmax == 0 || dmax > ENV_MAX_STR) { + return 1; + } + if (len == 0) { + return 1; + } + /* Just copy as many characters as we can instead of return failure */ + len = min(len, dmax); + + strncpy(dest, src, len); + return 0; +} + +#define env_strncmp(s1, slen1, s2, slen2) strncmp(s1, s2, min(slen1, slen2)) + +static inline char *env_strdup(const char *src, int flags) +{ + int len; + char *ret; + + if (src == NULL) { + return NULL; + } + + len = env_strnlen(src, ENV_MAX_STR) + 1; + ret = env_malloc(len, flags); + + if (env_strncpy(ret, ENV_MAX_STR, src, len)) { + return NULL; + } else { + return ret; + } +} + +/* *** SORTING *** */ + +static inline void env_sort(void *base, size_t num, size_t size, + int (*cmp_fn)(const void *, const void *), + void (*swap_fn)(void *, void *, int size)) +{ + qsort(base, num, size, cmp_fn); +} + +static inline void env_msleep(uint64_t n) +{ + usleep(n * 1000); +} + +static inline void env_touch_softlockup_wd(void) +{ +} + +/* *** CRC *** */ + +uint32_t env_crc32(uint32_t crc, uint8_t const *data, size_t len); + +/* EXECUTION CONTEXTS */ +unsigned env_get_execution_context(void); +void env_put_execution_context(unsigned ctx); +unsigned env_get_execution_context_count(void); + +#endif /* __OCF_ENV_H__ */ diff --git a/src/spdk/lib/env_ocf/ocf_env_headers.h b/src/spdk/lib/env_ocf/ocf_env_headers.h new file mode 100644 index 000000000..742479374 --- /dev/null +++ b/src/spdk/lib/env_ocf/ocf_env_headers.h @@ -0,0 +1,43 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS 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 COPYRIGHT + * OWNER OR 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. + */ + +#ifndef __OCF_ENV_HEADERS_H__ +#define __OCF_ENV_HEADERS_H__ + +#include "spdk/stdinc.h" + +#define OCF_VERSION_MAIN 20 +#define OCF_VERSION_MAJOR 3 +#define OCF_VERSION_MINOR 0 + +#endif /* __OCF_ENV_HEADERS_H__ */ diff --git a/src/spdk/lib/env_ocf/ocf_env_list.h b/src/spdk/lib/env_ocf/ocf_env_list.h new file mode 100644 index 000000000..e5f60d6c3 --- /dev/null +++ b/src/spdk/lib/env_ocf/ocf_env_list.h @@ -0,0 +1,185 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS 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 COPYRIGHT + * OWNER OR 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. + */ + +#ifndef __OCF_LIST_H__ +#define __OCF_LIST_H__ + +#define LIST_POISON1 ((void *) 0x00100100) +#define LIST_POISON2 ((void *) 0x00200200) + +/** + * List entry structure mimicking linux kernel based one. + */ +struct list_head { + struct list_head *next; + struct list_head *prev; +}; + +/** + * start an empty list + */ +#define INIT_LIST_HEAD(l) { (l)->prev = l; (l)->next = l; } + +/** + * Add item to list head. + * @param it list entry to be added + * @param l1 list main node (head) + */ +static inline void list_add(struct list_head *it, struct list_head *l1) +{ + it->prev = l1; + it->next = l1->next; + + l1->next->prev = it; + l1->next = it; +} + +/** + * Add item it to tail. + * @param it list entry to be added + * @param l1 list main node (head) + */ +static inline void list_add_tail(struct list_head *it, struct list_head *l1) +{ + it->prev = l1->prev; + it->next = l1; + + l1->prev->next = it; + l1->prev = it; +} + +/** + * check if a list is empty (return true) + */ +static inline int list_empty(struct list_head *it) +{ + return it->next == it; +} + +/** + * delete an entry from a list + */ +static inline void list_del(struct list_head *it) +{ + it->next->prev = it->prev; + it->prev->next = it->next; +} + +static inline void list_move_tail(struct list_head *list, + struct list_head *head) +{ + list_del(list); + list_add_tail(list, head); +} + +static inline void list_move(struct list_head *list, + struct list_head *head) +{ + list_del(list); + list_add(list, head); +} + +/** + * Extract an entry. + * @param list_head_i list head item, from which entry is extracted + * @param item_type type (struct) of list entry + * @param field_name name of list_head field within item_type + */ +#define list_entry(list_head_i, item_type, field_name) \ + (item_type *)(((void*)(list_head_i)) - offsetof(item_type, field_name)) + +#define list_first_entry(list_head_i, item_type, field_name) \ + list_entry((list_head_i)->next, item_type, field_name) + +/** + * @param iterator uninitialized list_head pointer, to be used as iterator + * @param plist list head (main node) + */ +#define list_for_each(iterator, plist) \ + for (iterator = (plist)->next; \ + (iterator)->next != (plist)->next; \ + iterator = (iterator)->next) + +/** + * Safe version of list_for_each which works even if entries are deleted during + * loop. + * @param iterator uninitialized list_head pointer, to be used as iterator + * @param q another uninitialized list_head, used as helper + * @param plist list head (main node) + */ +/* + * Algorithm handles situation, where q is deleted. + * consider in example 3 element list with header h: + * + * h -> 1 -> 2 -> 3 -> + *1. i q + * + *2. i q + * + *3. q i + */ +#define list_for_each_safe(iterator, q, plist) \ + for (iterator = (q = (plist)->next->next)->prev; \ + (q) != (plist)->next; \ + iterator = (q = (q)->next)->prev) + +#define _list_entry_helper(item, head, field_name) list_entry(head, typeof(*item), field_name) + +/** + * Iterate over list entries. + * @param list pointer to list item (iterator) + * @param plist pointer to list_head item + * @param field_name name of list_head field in list entry + */ +#define list_for_each_entry(item, plist, field_name) \ + for (item = _list_entry_helper(item, (plist)->next, field_name); \ + _list_entry_helper(item, (item)->field_name.next, field_name) !=\ + _list_entry_helper(item, (plist)->next, field_name); \ + item = _list_entry_helper(item, (item)->field_name.next, field_name)) + +/** + * Safe version of list_for_each_entry which works even if entries are deleted + * during loop. + * @param list pointer to list item (iterator) + * @param q another pointer to list item, used as helper + * @param plist pointer to list_head item + * @param field_name name of list_head field in list entry + */ +#define list_for_each_entry_safe(item, q, plist, field_name) \ + for (item = _list_entry_helper(item, (plist)->next, field_name), \ + q = _list_entry_helper(item, (item)->field_name.next, field_name); \ + _list_entry_helper(item, (item)->field_name.next, field_name) != \ + _list_entry_helper(item, (plist)->next, field_name); \ + item = q, q = _list_entry_helper(q, (q)->field_name.next, field_name)) + +#endif |