Commit d2ccf041 authored by Bob Pearson's avatar Bob Pearson Committed by Jason Gunthorpe
Browse files

RDMA/rxe: Remove key'ed object support 

Now that rxe_mcast.c has it's own red-black tree support there is no
longer any requirement for key'ed objects in rxe pools. This patch removes
the key APIs and related code.

Link: https://lore.kernel.org/r/20220208211644.123457-7-rpearsonhpe@gmail.com


Signed-off-by: default avatarBob Pearson <rpearsonhpe@gmail.com>
Signed-off-by: default avatarJason Gunthorpe <jgg@nvidia.com>
parent 8a0a5fe0

drivers/infiniband/sw/rxe/rxe_pool.c

+0 −126
Original line number Diff line number Diff line
@@ -16,8 +16,6 @@ static const struct rxe_type_info { 
	enum rxe_pool_flags flags;

	u32 min_index;

	u32 max_index;

	size_t key_offset;

	size_t key_size;

} rxe_type_info[RXE_NUM_TYPES] = {

	[RXE_TYPE_UC] = {

		.name		= "rxe-uc",
@@ -147,12 +145,6 @@ int rxe_pool_init( 
			goto out;

	}



	if (pool->flags & RXE_POOL_KEY) {

		pool->key.tree = RB_ROOT;

		pool->key.key_offset = info->key_offset;

		pool->key.key_size = info->key_size;

	}



out:

	return err;

}
@@ -209,79 +201,6 @@ static int rxe_insert_index(struct rxe_pool *pool, struct rxe_pool_elem *new) 
	return 0;

}



static int rxe_insert_key(struct rxe_pool *pool, struct rxe_pool_elem *new)

{

	struct rb_node **link = &pool->key.tree.rb_node;

	struct rb_node *parent = NULL;

	struct rxe_pool_elem *elem;

	int cmp;



	while (*link) {

		parent = *link;

		elem = rb_entry(parent, struct rxe_pool_elem, key_node);



		cmp = memcmp((u8 *)elem + pool->key.key_offset,

			     (u8 *)new + pool->key.key_offset,

			     pool->key.key_size);



		if (cmp == 0) {

			pr_warn("key already exists!\n");

			return -EINVAL;

		}



		if (cmp > 0)

			link = &(*link)->rb_left;

		else

			link = &(*link)->rb_right;

	}



	rb_link_node(&new->key_node, parent, link);

	rb_insert_color(&new->key_node, &pool->key.tree);



	return 0;

}



int __rxe_add_key_locked(struct rxe_pool_elem *elem, void *key)

{

	struct rxe_pool *pool = elem->pool;

	int err;



	memcpy((u8 *)elem + pool->key.key_offset, key, pool->key.key_size);

	err = rxe_insert_key(pool, elem);



	return err;

}



int __rxe_add_key(struct rxe_pool_elem *elem, void *key)

{

	struct rxe_pool *pool = elem->pool;

	unsigned long flags;

	int err;



	write_lock_irqsave(&pool->pool_lock, flags);

	err = __rxe_add_key_locked(elem, key);

	write_unlock_irqrestore(&pool->pool_lock, flags);



	return err;

}



void __rxe_drop_key_locked(struct rxe_pool_elem *elem)

{

	struct rxe_pool *pool = elem->pool;



	rb_erase(&elem->key_node, &pool->key.tree);

}



void __rxe_drop_key(struct rxe_pool_elem *elem)

{

	struct rxe_pool *pool = elem->pool;

	unsigned long flags;



	write_lock_irqsave(&pool->pool_lock, flags);

	__rxe_drop_key_locked(elem);

	write_unlock_irqrestore(&pool->pool_lock, flags);

}



int __rxe_add_index_locked(struct rxe_pool_elem *elem)

{

	struct rxe_pool *pool = elem->pool;
@@ -448,48 +367,3 @@ void *rxe_pool_get_index(struct rxe_pool *pool, u32 index) 


	return obj;

}
 


void *rxe_pool_get_key_locked(struct rxe_pool *pool, void *key)

{

	struct rb_node *node;

	struct rxe_pool_elem *elem;

	void *obj;

	int cmp;



	node = pool->key.tree.rb_node;



	while (node) {

		elem = rb_entry(node, struct rxe_pool_elem, key_node);



		cmp = memcmp((u8 *)elem + pool->key.key_offset,

			     key, pool->key.key_size);



		if (cmp > 0)

			node = node->rb_left;

		else if (cmp < 0)

			node = node->rb_right;

		else

			break;

	}



	if (node) {

		kref_get(&elem->ref_cnt);

		obj = elem->obj;

	} else {

		obj = NULL;

	}



	return obj;

}



void *rxe_pool_get_key(struct rxe_pool *pool, void *key)

{

	unsigned long flags;

	void *obj;



	read_lock_irqsave(&pool->pool_lock, flags);

	obj = rxe_pool_get_key_locked(pool, key);

	read_unlock_irqrestore(&pool->pool_lock, flags);



	return obj;

}

drivers/infiniband/sw/rxe/rxe_pool.h

+0 −38
Original line number Diff line number Diff line
@@ -9,7 +9,6 @@ 


enum rxe_pool_flags {

	RXE_POOL_INDEX		= BIT(1),

	RXE_POOL_KEY		= BIT(2),

	RXE_POOL_NO_ALLOC	= BIT(4),

};
@@ -32,9 +31,6 @@ struct rxe_pool_elem { 
	struct kref		ref_cnt;

	struct list_head	list;



	/* only used if keyed */

	struct rb_node		key_node;



	/* only used if indexed */

	struct rb_node		index_node;

	u32			index;
@@ -61,13 +57,6 @@ struct rxe_pool { 
		u32			max_index;

		u32			min_index;

	} index;



	/* only used if keyed */

	struct {

		struct rb_root		tree;

		size_t			key_offset;

		size_t			key_size;

	} key;

};



/* initialize a pool of objects with given limit on
@@ -112,26 +101,6 @@ void __rxe_drop_index(struct rxe_pool_elem *elem); 


#define rxe_drop_index(obj) __rxe_drop_index(&(obj)->elem)



/* assign a key to a keyed object and insert object into

 * pool's rb tree holding and not holding pool_lock

 */

int __rxe_add_key_locked(struct rxe_pool_elem *elem, void *key);



#define rxe_add_key_locked(obj, key) __rxe_add_key_locked(&(obj)->elem, key)



int __rxe_add_key(struct rxe_pool_elem *elem, void *key);



#define rxe_add_key(obj, key) __rxe_add_key(&(obj)->elem, key)



/* remove elem from rb tree holding and not holding the pool_lock */

void __rxe_drop_key_locked(struct rxe_pool_elem *elem);



#define rxe_drop_key_locked(obj) __rxe_drop_key_locked(&(obj)->elem)



void __rxe_drop_key(struct rxe_pool_elem *elem);



#define rxe_drop_key(obj) __rxe_drop_key(&(obj)->elem)



/* lookup an indexed object from index holding and not holding the pool_lock.

 * takes a reference on object

 */
@@ -139,13 +108,6 @@ void *rxe_pool_get_index_locked(struct rxe_pool *pool, u32 index); 


void *rxe_pool_get_index(struct rxe_pool *pool, u32 index);



/* lookup keyed object from key holding and not holding the pool_lock.

 * takes a reference on the objecti

 */

void *rxe_pool_get_key_locked(struct rxe_pool *pool, void *key);



void *rxe_pool_get_key(struct rxe_pool *pool, void *key);



/* cleanup an object when all references are dropped */

void rxe_elem_release(struct kref *kref);