Merge pull request #296 from micrakow/sec_rev_fixes

Env fixes & more

env/posix/ocf_env.h

@@ -450,9 +450,9 @@ typedef struct {
 	pthread_spinlock_t lock;
 } env_spinlock;
 
-static inline void env_spinlock_init(env_spinlock *l)
+static inline int env_spinlock_init(env_spinlock *l)
 {
-	ENV_BUG_ON(pthread_spin_init(&l->lock, 0));
+	return pthread_spin_init(&l->lock, 0);
 }
 
 static inline int env_spinlock_trylock(env_spinlock *l)

src/cleaning/acp.c

@@ -302,11 +302,16 @@ int cleaning_policy_acp_initialize(struct ocf_cache *cache,
 		ocf_cache_log(cache, log_err, "acp context allocation error\n");
 		return -OCF_ERR_NO_MEM;
 	}
+
+	err = env_rwsem_init(&acp->chunks_lock);
+	if (err) {
+		env_vfree(acp);
+		return err;
+	}
+
 	cache->cleaner.cleaning_policy_context = acp;
 	acp->cache = cache;
 
-	env_rwsem_init(&acp->chunks_lock);
-
 	for (i = 0; i < ACP_MAX_BUCKETS; i++) {
 		INIT_LIST_HEAD(&acp->bucket_info[i].chunk_list);
 		acp->bucket_info[i].threshold =

src/cleaning/alru.c

@@ -467,6 +467,7 @@ int cleaning_policy_alru_initialize(ocf_cache_t cache, int init_metadata)
 	struct ocf_user_part *part;
 	ocf_part_id_t part_id;
 	struct alru_context *alru;
+	int error = 0;
 	unsigned i;
 
 	alru = env_vzalloc(sizeof(*alru));
@@ -475,8 +476,19 @@ int cleaning_policy_alru_initialize(ocf_cache_t cache, int init_metadata)
 		return -OCF_ERR_NO_MEM;
 	}
 
-	for (i = 0; i < OCF_IO_CLASS_MAX; i++)
-		env_spinlock_init(&alru->list_lock[i]);
+	for (i = 0; i < OCF_IO_CLASS_MAX; i++) {
+		error = env_spinlock_init(&alru->list_lock[i]);
+		if (error)
+			break;
+	}
+
+	if (error) {
+		while (i--)
+			env_spinlock_destroy(&alru->list_lock[i]);
+		env_vfree(alru);
+		return error;
+	}
+
 
 	cache->cleaner.cleaning_policy_context = alru;
 

src/concurrency/ocf_cache_line_concurrency.c

@@ -110,13 +110,17 @@ int ocf_cache_line_concurrency_init(struct ocf_cache *cache)
 	/* Init concurrency control table */
 	for (i = 0; i < _WAITERS_LIST_ENTRIES; i++) {
 		INIT_LIST_HEAD(&c->waiters_lsts[i].head);
-		env_spinlock_init(&c->waiters_lsts[i].lock);
+		error = env_spinlock_init(&c->waiters_lsts[i].lock);
+		if (error)
+			goto spinlock_err;
 	}
 
 	return 0;
 
+spinlock_err:
+	while (i--)
+		env_spinlock_destroy(&c->waiters_lsts[i].lock);
 ocf_cache_line_concurrency_init:
-
 	ocf_cache_log(cache, log_err, "Cannot initialize cache concurrency, "
 			"ERROR %d", error);
 

src/concurrency/ocf_metadata_concurrency.c

@@ -6,17 +6,35 @@
 #include "ocf_metadata_concurrency.h"
 #include "../metadata/metadata_misc.h"
 
-void ocf_metadata_concurrency_init(struct ocf_metadata_lock *metadata_lock)
+int ocf_metadata_concurrency_init(struct ocf_metadata_lock *metadata_lock)
 {
+	int err = 0;
 	unsigned i;
 
-	env_spinlock_init(&metadata_lock->eviction);
+	err = env_spinlock_init(&metadata_lock->eviction);
+	if (err)
+		return err;
+
 	env_rwlock_init(&metadata_lock->status);
-	env_rwsem_init(&metadata_lock->global);
+	err = env_rwsem_init(&metadata_lock->global);
+	if (err)
+		goto rwsem_err;
 
 	for (i = 0; i < OCF_IO_CLASS_MAX; i++) {
-		env_spinlock_init(&metadata_lock->partition[i]);
+		err = env_spinlock_init(&metadata_lock->partition[i]);
+		if (err)
+			goto spinlocks_err;
 	}
+
+	return err;
+
+spinlocks_err:
+	while (i--)
+		env_spinlock_destroy(&metadata_lock->partition[i]);
+rwsem_err:
+	env_rwlock_destroy(&metadata_lock->status);
+	env_spinlock_destroy(&metadata_lock->eviction);
+	return err;
 }
 
 void ocf_metadata_concurrency_deinit(struct ocf_metadata_lock *metadata_lock)

src/concurrency/ocf_metadata_concurrency.h

@@ -10,7 +10,7 @@
 #define OCF_METADATA_RD 0
 #define OCF_METADATA_WR 1
 
-void ocf_metadata_concurrency_init(struct ocf_metadata_lock *metadata_lock);
+int ocf_metadata_concurrency_init(struct ocf_metadata_lock *metadata_lock);
 
 void ocf_metadata_concurrency_deinit(struct ocf_metadata_lock *metadata_lock);
 

src/engine/engine_discard.c

@@ -77,7 +77,7 @@ static int _ocf_discard_core(struct ocf_request *req)
 	ocf_io_set_cmpl(io, req, NULL, _ocf_discard_core_complete);
 	err = ocf_io_set_data(io, req->data, 0);
 	if (err) {
-		_ocf_discard_complete_req(req, err);
+		_ocf_discard_core_complete(io, err);
 		return err;
 	}
 

src/metadata/metadata.c

@@ -39,7 +39,14 @@ int ocf_metadata_init(struct ocf_cache *cache,
 		return ret;
 	}
 
-	ocf_metadata_concurrency_init(&cache->metadata.lock);
+	ret = ocf_metadata_concurrency_init(&cache->metadata.lock);
+	if (ret) {
+		if (cache->metadata.iface.deinit)
+			cache->metadata.iface.deinit(cache);
+
+		ocf_metadata_io_deinit(cache);
+		return ret;
+	}
 
 	return 0;
 }

src/metadata/metadata_superblock.h

@@ -6,7 +6,6 @@
 #ifndef __METADATA_SUPERBLOCK_H__
 #define __METADATA_SUPERBLOCK_H__
 
-#include <ocf/ocf_def.h>
 #include <ocf/ocf_def.h>
 
 #define CACHE_MAGIC_NUMBER	0x187E1CA6

src/mngt/ocf_mngt_cache.c

@@ -568,10 +568,7 @@ static int _ocf_mngt_init_new_cache(struct ocf_cache_mngt_init_params *params)
 		goto lock_err;
 	}
 
-	if (!ocf_refcnt_inc(&cache->refcnt.cache)){
-		result = -OCF_ERR_START_CACHE_FAIL;
-		goto flush_mutex_err;
-	}
+	ENV_BUG_ON(!ocf_refcnt_inc(&cache->refcnt.cache));
 
 	/* start with freezed metadata ref counter to indicate detached device*/
 	ocf_refcnt_freeze(&cache->refcnt.metadata);
@@ -586,8 +583,6 @@ static int _ocf_mngt_init_new_cache(struct ocf_cache_mngt_init_params *params)
 
 	return 0;
 
-flush_mutex_err:
-	env_mutex_destroy(&cache->flush_mutex);
 lock_err:
 	ocf_mngt_cache_lock_deinit(cache);
 alloc_err:

src/ocf_freelist.c

@@ -385,21 +385,28 @@ ocf_freelist_t ocf_freelist_init(struct ocf_cache *cache)
 	freelist->lock = env_vzalloc(sizeof(freelist->lock[0]) * num);
 	freelist->part = env_vzalloc(sizeof(freelist->part[0]) * num);
 
-	if (!freelist->lock || !freelist->part) {
-		env_vfree(freelist->lock);
-		env_vfree(freelist->part);
-		env_vfree(freelist);
-		return NULL;
-	}
+	if (!freelist->lock || !freelist->part)
+		goto free_allocs;
 
 	for (i = 0; i < num; i++) {
-		env_spinlock_init(&freelist->lock[i]);
+		if (env_spinlock_init(&freelist->lock[i]))
+			goto spinlock_err;
+
 		freelist->part[i].head = line_entries;
 		freelist->part[i].tail = line_entries;
 		env_atomic64_set(&freelist->part[i].curr_size, 0);
 	}
 
 	return freelist;
+
+spinlock_err:
+	while (i--)
+		env_spinlock_destroy(&freelist->lock[i]);
+free_allocs:
+	env_vfree(freelist->lock);
+	env_vfree(freelist->part);
+	env_vfree(freelist);
+	return NULL;
 }
 
 void ocf_freelist_deinit(ocf_freelist_t freelist)

src/ocf_queue.c

@@ -32,7 +32,13 @@ int ocf_queue_create(ocf_cache_t cache, ocf_queue_t *queue,
 	}
 
 	env_atomic_set(&tmp_queue->io_no, 0);
-	env_spinlock_init(&tmp_queue->io_list_lock);
+	result = env_spinlock_init(&tmp_queue->io_list_lock);
+	if (result) {
+		ocf_mngt_cache_put(cache);
+		free(tmp_queue);
+		return result;
+	}
+
 	INIT_LIST_HEAD(&tmp_queue->io_list);
 	env_atomic_set(&tmp_queue->ref_count, 1);
 	tmp_queue->cache = cache;

src/ocf_stats_builder.c

@@ -266,6 +266,9 @@ int ocf_stats_collect_part_core(ocf_core_t core, ocf_part_id_t part_id,
 
 	OCF_CHECK_NULL(core);
 
+	if (part_id > OCF_IO_CLASS_ID_MAX)
+		return -OCF_ERR_INVAL;
+
 	cache = ocf_core_get_cache(core);
 
 	_ocf_stats_zero(usage);
@@ -291,6 +294,9 @@ int ocf_stats_collect_part_cache(ocf_cache_t cache, ocf_part_id_t part_id,
 
 	OCF_CHECK_NULL(cache);
 
+	if (part_id > OCF_IO_CLASS_ID_MAX)
+		return -OCF_ERR_INVAL;
+
 	_ocf_stats_zero(usage);
 	_ocf_stats_zero(req);
 	_ocf_stats_zero(blocks);

src/promotion/nhit/nhit_hash.c

@@ -146,7 +146,6 @@ ocf_error_t nhit_hash_init(uint64_t hash_size, nhit_hash_t *ctx)
 	for (i_locks = 0; i_locks < new_ctx->hash_entries; i_locks++) {
 		if (env_rwsem_init(&new_ctx->hash_locks[i_locks])) {
 			result = -OCF_ERR_UNKNOWN;
-			i_locks--;
 			goto dealloc_locks;
 		}
 	}
@@ -163,14 +162,17 @@ ocf_error_t nhit_hash_init(uint64_t hash_size, nhit_hash_t *ctx)
 		env_atomic_set(&new_ctx->ring_buffer[i].counter, 0);
 	}
 
-	env_spinlock_init(&new_ctx->rb_pointer_lock);
+	result = env_spinlock_init(&new_ctx->rb_pointer_lock);
+	if (result)
+		goto dealloc_locks;
+
 	new_ctx->rb_pointer = 0;
 
 	*ctx = new_ctx;
 	return 0;
 
 dealloc_locks:
-	for (; i_locks >= 0; i_locks--)
+	while (i_locks--)
 		ENV_BUG_ON(env_rwsem_destroy(&new_ctx->hash_locks[i_locks]));
 	env_vfree(new_ctx->hash_locks);
 dealloc_hash:

src/utils/utils_async_lock.c

@@ -47,7 +47,12 @@ void _ocf_async_lock_run_waiters(struct ocf_async_lock *lock,
 
 int ocf_async_lock_init(struct ocf_async_lock *lock, uint32_t waiter_priv_size)
 {
-	env_spinlock_init(&lock->waiters_lock);
+	int err = 0;
+
+	err = env_spinlock_init(&lock->waiters_lock);
+	if (err)
+		return err;
+
 	INIT_LIST_HEAD(&lock->waiters);
 	lock->rd = 0;
 	lock->wr = 0;