[ceph.git] / ceph / src / spdk / ocf / src / concurrency / ocf_metadata_concurrency.h

/*
 * Copyright(c) 2019-2019 Intel Corporation
 * SPDX-License-Identifier: BSD-3-Clause-Clear
 */
#include "../ocf_cache_priv.h"

#ifndef __OCF_METADATA_CONCURRENCY_H__
#define __OCF_METADATA_CONCURRENCY_H__

#define OCF_METADATA_RD 0
#define OCF_METADATA_WR 1

int ocf_metadata_concurrency_init(struct ocf_metadata_lock *metadata_lock);

void ocf_metadata_concurrency_deinit(struct ocf_metadata_lock *metadata_lock);

int ocf_metadata_concurrency_attached_init(
		struct ocf_metadata_lock *metadata_lock, ocf_cache_t cache,
		uint32_t hash_table_entries, uint32_t colision_table_pages);

void ocf_metadata_concurrency_attached_deinit(
		struct ocf_metadata_lock *metadata_lock);

static inline void ocf_metadata_eviction_lock(
		struct ocf_metadata_lock *metadata_lock)
{
	env_spinlock_lock(&metadata_lock->eviction);
}

static inline void ocf_metadata_eviction_unlock(
		struct ocf_metadata_lock *metadata_lock)
{
	env_spinlock_unlock(&metadata_lock->eviction);
}

static inline void ocf_metadata_partition_lock(
		struct ocf_metadata_lock *metadata_lock,
		ocf_part_id_t part_id)
{
	env_spinlock_lock(&metadata_lock->partition[part_id]);
}

static inline void ocf_metadata_partition_unlock(
		struct ocf_metadata_lock *metadata_lock,
		ocf_part_id_t part_id)
{
	env_spinlock_unlock(&metadata_lock->partition[part_id]);
}

#define OCF_METADATA_EVICTION_LOCK() \
		ocf_metadata_eviction_lock(&cache->metadata.lock)

#define OCF_METADATA_EVICTION_UNLOCK() \
		ocf_metadata_eviction_unlock(&cache->metadata.lock)

void ocf_metadata_start_exclusive_access(
		struct ocf_metadata_lock *metadata_lock);

int ocf_metadata_try_start_exclusive_access(
		struct ocf_metadata_lock *metadata_lock);

void ocf_metadata_end_exclusive_access(
		struct ocf_metadata_lock *metadata_lock);

int ocf_metadata_try_start_shared_access(
		struct ocf_metadata_lock *metadata_lock);

void ocf_metadata_start_shared_access(
		struct ocf_metadata_lock *metadata_lock);

void ocf_metadata_end_shared_access(
		struct ocf_metadata_lock *metadata_lock);

static inline void ocf_metadata_status_bits_lock(
		struct ocf_metadata_lock *metadata_lock, int rw)
{
	if (rw == OCF_METADATA_WR)
		env_rwlock_write_lock(&metadata_lock->status);
	else if (rw == OCF_METADATA_RD)
		env_rwlock_read_lock(&metadata_lock->status);
	else
		ENV_BUG();
}

static inline void ocf_metadata_status_bits_unlock(
		struct ocf_metadata_lock *metadata_lock, int rw)
{
	if (rw == OCF_METADATA_WR)
		env_rwlock_write_unlock(&metadata_lock->status);
	else if (rw == OCF_METADATA_RD)
		env_rwlock_read_unlock(&metadata_lock->status);
	else
		ENV_BUG();
}

#define OCF_METADATA_BITS_LOCK_RD() \
		ocf_metadata_status_bits_lock(&cache->metadata.lock, \
				OCF_METADATA_RD)

#define OCF_METADATA_BITS_UNLOCK_RD() \
		ocf_metadata_status_bits_unlock(&cache->metadata.lock, \
				OCF_METADATA_RD)

#define OCF_METADATA_BITS_LOCK_WR() \
		ocf_metadata_status_bits_lock(&cache->metadata.lock, \
				OCF_METADATA_WR)

#define OCF_METADATA_BITS_UNLOCK_WR() \
		ocf_metadata_status_bits_unlock(&cache->metadata.lock, \
				OCF_METADATA_WR)

void ocf_metadata_hash_lock_rd(struct ocf_metadata_lock *metadata_lock,
		uint32_t core_id, uint64_t core_line);
void ocf_metadata_hash_unlock_rd(struct ocf_metadata_lock *metadata_lock,
		uint32_t core_id, uint64_t core_line);
void ocf_metadata_hash_lock_wr(struct ocf_metadata_lock *metadata_lock,
		uint32_t core_id, uint64_t core_line);
void ocf_metadata_hash_unlock_wr(struct ocf_metadata_lock *metadata_lock,
		uint32_t core_id, uint64_t core_line);

/* lock entire request in deadlock-free manner */
void ocf_req_hash_lock_rd(struct ocf_request *req);
void ocf_req_hash_unlock_rd(struct ocf_request *req);
void ocf_req_hash_lock_wr(struct ocf_request *req);
void ocf_req_hash_unlock_wr(struct ocf_request *req);
void ocf_req_hash_lock_upgrade(struct ocf_request *req);

/* collision table page lock interface */
void ocf_collision_start_shared_access(struct ocf_metadata_lock *metadata_lock,
		uint32_t page);
void ocf_collision_end_shared_access(struct ocf_metadata_lock *metadata_lock,
		uint32_t page);
void ocf_collision_start_exclusive_access(struct ocf_metadata_lock *metadata_lock,
		uint32_t page);
void ocf_collision_end_exclusive_access(struct ocf_metadata_lock *metadata_lock,
		uint32_t page);
#endif
Commit	Line	Data
f67539c2 TL	1	/*
	2	* Copyright(c) 2019-2019 Intel Corporation
	3	* SPDX-License-Identifier: BSD-3-Clause-Clear
	4	*/
	5	#include "../ocf_cache_priv.h"
	6
	7	#ifndef __OCF_METADATA_CONCURRENCY_H__
	8	#define __OCF_METADATA_CONCURRENCY_H__
	9
	10	#define OCF_METADATA_RD 0
	11	#define OCF_METADATA_WR 1
	12
	13	int ocf_metadata_concurrency_init(struct ocf_metadata_lock *metadata_lock);
	14
	15	void ocf_metadata_concurrency_deinit(struct ocf_metadata_lock *metadata_lock);
	16
	17	int ocf_metadata_concurrency_attached_init(
	18	struct ocf_metadata_lock *metadata_lock, ocf_cache_t cache,
	19	uint32_t hash_table_entries, uint32_t colision_table_pages);
	20
	21	void ocf_metadata_concurrency_attached_deinit(
	22	struct ocf_metadata_lock *metadata_lock);
	23
	24	static inline void ocf_metadata_eviction_lock(
	25	struct ocf_metadata_lock *metadata_lock)
	26	{
	27	env_spinlock_lock(&metadata_lock->eviction);
	28	}
	29
	30	static inline void ocf_metadata_eviction_unlock(
	31	struct ocf_metadata_lock *metadata_lock)
	32	{
	33	env_spinlock_unlock(&metadata_lock->eviction);
	34	}
	35
	36	static inline void ocf_metadata_partition_lock(
	37	struct ocf_metadata_lock *metadata_lock,
	38	ocf_part_id_t part_id)
	39	{
	40	env_spinlock_lock(&metadata_lock->partition[part_id]);
	41	}
	42
	43	static inline void ocf_metadata_partition_unlock(
	44	struct ocf_metadata_lock *metadata_lock,
	45	ocf_part_id_t part_id)
	46	{
	47	env_spinlock_unlock(&metadata_lock->partition[part_id]);
	48	}
	49
	50	#define OCF_METADATA_EVICTION_LOCK() \
	51	ocf_metadata_eviction_lock(&cache->metadata.lock)
	52
	53	#define OCF_METADATA_EVICTION_UNLOCK() \
	54	ocf_metadata_eviction_unlock(&cache->metadata.lock)
	55
	56	void ocf_metadata_start_exclusive_access(
	57	struct ocf_metadata_lock *metadata_lock);
	58
	59	int ocf_metadata_try_start_exclusive_access(
	60	struct ocf_metadata_lock *metadata_lock);
	61
	62	void ocf_metadata_end_exclusive_access(
	63	struct ocf_metadata_lock *metadata_lock);
	64
65	int ocf_metadata_try_start_shared_access(
66	struct ocf_metadata_lock *metadata_lock);
67
68	void ocf_metadata_start_shared_access(
69	struct ocf_metadata_lock *metadata_lock);
70
71	void ocf_metadata_end_shared_access(
72	struct ocf_metadata_lock *metadata_lock);
73
74	static inline void ocf_metadata_status_bits_lock(
75	struct ocf_metadata_lock *metadata_lock, int rw)
76	{
77	if (rw == OCF_METADATA_WR)
78	env_rwlock_write_lock(&metadata_lock->status);
79	else if (rw == OCF_METADATA_RD)
80	env_rwlock_read_lock(&metadata_lock->status);
81	else
82	ENV_BUG();
83	}
84
85	static inline void ocf_metadata_status_bits_unlock(
86	struct ocf_metadata_lock *metadata_lock, int rw)
87	{
88	if (rw == OCF_METADATA_WR)
89	env_rwlock_write_unlock(&metadata_lock->status);
90	else if (rw == OCF_METADATA_RD)
91	env_rwlock_read_unlock(&metadata_lock->status);
92	else
93	ENV_BUG();
94	}
95
96	#define OCF_METADATA_BITS_LOCK_RD() \
97	ocf_metadata_status_bits_lock(&cache->metadata.lock, \
98	OCF_METADATA_RD)
99
100	#define OCF_METADATA_BITS_UNLOCK_RD() \
101	ocf_metadata_status_bits_unlock(&cache->metadata.lock, \
102	OCF_METADATA_RD)
103
104	#define OCF_METADATA_BITS_LOCK_WR() \
105	ocf_metadata_status_bits_lock(&cache->metadata.lock, \
106	OCF_METADATA_WR)
107
108	#define OCF_METADATA_BITS_UNLOCK_WR() \
109	ocf_metadata_status_bits_unlock(&cache->metadata.lock, \
110	OCF_METADATA_WR)
111
112	void ocf_metadata_hash_lock_rd(struct ocf_metadata_lock *metadata_lock,
113	uint32_t core_id, uint64_t core_line);
114	void ocf_metadata_hash_unlock_rd(struct ocf_metadata_lock *metadata_lock,
115	uint32_t core_id, uint64_t core_line);
116	void ocf_metadata_hash_lock_wr(struct ocf_metadata_lock *metadata_lock,
117	uint32_t core_id, uint64_t core_line);
118	void ocf_metadata_hash_unlock_wr(struct ocf_metadata_lock *metadata_lock,
119	uint32_t core_id, uint64_t core_line);
120
121	/* lock entire request in deadlock-free manner */
122	void ocf_req_hash_lock_rd(struct ocf_request *req);
123	void ocf_req_hash_unlock_rd(struct ocf_request *req);
124	void ocf_req_hash_lock_wr(struct ocf_request *req);
125	void ocf_req_hash_unlock_wr(struct ocf_request *req);
126	void ocf_req_hash_lock_upgrade(struct ocf_request *req);
127
128	/* collision table page lock interface */
129	void ocf_collision_start_shared_access(struct ocf_metadata_lock *metadata_lock,
130	uint32_t page);
131	void ocf_collision_end_shared_access(struct ocf_metadata_lock *metadata_lock,
132	uint32_t page);
133	void ocf_collision_start_exclusive_access(struct ocf_metadata_lock *metadata_lock,
134	uint32_t page);
135	void ocf_collision_end_exclusive_access(struct ocf_metadata_lock *metadata_lock,
136	uint32_t page);
137	#endif