Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8ceb1357 authored by Jason Gunthorpe's avatar Jason Gunthorpe
Browse files

RDMA/device: Consolidate ib_device per_port data into one place 



There is no reason to have three allocations of per-port data. Combine
them together and make the lifetime for all the per-port data match the
struct ib_device.

Following patches will require more port-specific data, now there is a
good place to put it.

Signed-off-by: default avatarJason Gunthorpe <jgg@mellanox.com>
parent ea1075ed

drivers/infiniband/core/cache.c

+2 −2
Original line number Diff line number Diff line
@@ -882,7 +882,7 @@ static int _gid_table_setup_one(struct ib_device *ib_dev) 
		u8 rdma_port = port + rdma_start_port(ib_dev);



		table = alloc_gid_table(

				ib_dev->port_immutable[rdma_port].gid_tbl_len);

			ib_dev->port_data[rdma_port].immutable.gid_tbl_len);

		if (!table)

			goto rollback_table_setup;

drivers/infiniband/core/device.c

+22 −48
Original line number Diff line number Diff line
@@ -293,8 +293,7 @@ static void ib_device_release(struct device *device) 
	WARN_ON(refcount_read(&dev->refcount));

	ib_cache_release_one(dev);

	ib_security_release_port_pkey_list(dev);

	kfree(dev->port_pkey_list);

	kfree(dev->port_immutable);

	kfree(dev->port_data);

	xa_destroy(&dev->client_data);

	kfree(dev);

}
@@ -468,27 +467,31 @@ static int verify_immutable(const struct ib_device *dev, u8 port) 
			    rdma_max_mad_size(dev, port) != 0);

}



static int read_port_immutable(struct ib_device *device)

static int setup_port_data(struct ib_device *device)

{

	unsigned int port;

	int ret;



	/**

	 * device->port_immutable is indexed directly by the port number to make

	/*

	 * device->port_data is indexed directly by the port number to make

	 * access to this data as efficient as possible.

	 *

	 * Therefore port_immutable is declared as a 1 based array with

	 * potential empty slots at the beginning.

	 * Therefore port_data is declared as a 1 based array with potential

	 * empty slots at the beginning.

	 */

	device->port_immutable =

		kcalloc(rdma_end_port(device) + 1,

			sizeof(*device->port_immutable), GFP_KERNEL);

	if (!device->port_immutable)

	device->port_data = kcalloc(rdma_end_port(device) + 1,

				    sizeof(*device->port_data), GFP_KERNEL);

	if (!device->port_data)

		return -ENOMEM;



	rdma_for_each_port (device, port) {

		ret = device->ops.get_port_immutable(

			device, port, &device->port_immutable[port]);

		struct ib_port_data *pdata = &device->port_data[port];



		spin_lock_init(&pdata->pkey_list_lock);

		INIT_LIST_HEAD(&pdata->pkey_list);



		ret = device->ops.get_port_immutable(device, port,

						     &pdata->immutable);

		if (ret)

			return ret;
@@ -507,30 +510,6 @@ void ib_get_device_fw_str(struct ib_device *dev, char *str) 
}

EXPORT_SYMBOL(ib_get_device_fw_str);



static int setup_port_pkey_list(struct ib_device *device)

{

	int i;



	/**

	 * device->port_pkey_list is indexed directly by the port number,

	 * Therefore it is declared as a 1 based array with potential empty

	 * slots at the beginning.

	 */

	device->port_pkey_list = kcalloc(rdma_end_port(device) + 1,

					 sizeof(*device->port_pkey_list),

					 GFP_KERNEL);



	if (!device->port_pkey_list)

		return -ENOMEM;



	for (i = 0; i < (rdma_end_port(device) + 1); i++) {

		spin_lock_init(&device->port_pkey_list[i].list_lock);

		INIT_LIST_HEAD(&device->port_pkey_list[i].pkey_list);

	}



	return 0;

}



static void ib_policy_change_task(struct work_struct *work)

{

	struct ib_device *dev;
@@ -668,10 +647,9 @@ static int setup_device(struct ib_device *device) 
	if (ret)

		return ret;



	ret = read_port_immutable(device);

	ret = setup_port_data(device);

	if (ret) {

		dev_warn(&device->dev,

			 "Couldn't create per port immutable data\n");

		dev_warn(&device->dev, "Couldn't create per-port data\n");

		return ret;

	}
@@ -683,12 +661,6 @@ static int setup_device(struct ib_device *device) 
		return ret;

	}



	ret = setup_port_pkey_list(device);

	if (ret) {

		dev_warn(&device->dev, "Couldn't create per port_pkey_list\n");

		return ret;

	}



	return 0;

}
@@ -1221,7 +1193,8 @@ int ib_find_gid(struct ib_device *device, union ib_gid *gid, 
		if (!rdma_protocol_ib(device, port))

			continue;



		for (i = 0; i < device->port_immutable[port].gid_tbl_len; ++i) {

		for (i = 0; i < device->port_data[port].immutable.gid_tbl_len;

		     ++i) {

			ret = rdma_query_gid(device, port, i, &tmp_gid);

			if (ret)

				return ret;
@@ -1253,7 +1226,8 @@ int ib_find_pkey(struct ib_device *device, 
	u16 tmp_pkey;

	int partial_ix = -1;



	for (i = 0; i < device->port_immutable[port_num].pkey_tbl_len; ++i) {

	for (i = 0; i < device->port_data[port_num].immutable.pkey_tbl_len;

	     ++i) {

		ret = ib_query_pkey(device, port_num, i, &tmp_pkey);

		if (ret)

			return ret;

drivers/infiniband/core/security.c

+11 −13
Original line number Diff line number Diff line
@@ -49,16 +49,15 @@ static struct pkey_index_qp_list *get_pkey_idx_qp_list(struct ib_port_pkey *pp) 
	struct pkey_index_qp_list *tmp_pkey;

	struct ib_device *dev = pp->sec->dev;



	spin_lock(&dev->port_pkey_list[pp->port_num].list_lock);

	list_for_each_entry(tmp_pkey,

			    &dev->port_pkey_list[pp->port_num].pkey_list,

	spin_lock(&dev->port_data[pp->port_num].pkey_list_lock);

	list_for_each_entry (tmp_pkey, &dev->port_data[pp->port_num].pkey_list,

			     pkey_index_list) {

		if (tmp_pkey->pkey_index == pp->pkey_index) {

			pkey = tmp_pkey;

			break;

		}

	}

	spin_unlock(&dev->port_pkey_list[pp->port_num].list_lock);

	spin_unlock(&dev->port_data[pp->port_num].pkey_list_lock);

	return pkey;

}
@@ -263,12 +262,12 @@ static int port_pkey_list_insert(struct ib_port_pkey *pp) 
		if (!pkey)

			return -ENOMEM;



		spin_lock(&dev->port_pkey_list[port_num].list_lock);

		spin_lock(&dev->port_data[port_num].pkey_list_lock);

		/* Check for the PKey again.  A racing process may

		 * have created it.

		 */

		list_for_each_entry(tmp_pkey,

				    &dev->port_pkey_list[port_num].pkey_list,

				    &dev->port_data[port_num].pkey_list,

				    pkey_index_list) {

			if (tmp_pkey->pkey_index == pp->pkey_index) {

				kfree(pkey);
@@ -283,9 +282,9 @@ static int port_pkey_list_insert(struct ib_port_pkey *pp) 
			spin_lock_init(&pkey->qp_list_lock);

			INIT_LIST_HEAD(&pkey->qp_list);

			list_add(&pkey->pkey_index_list,

				 &dev->port_pkey_list[port_num].pkey_list);

				 &dev->port_data[port_num].pkey_list);

		}

		spin_unlock(&dev->port_pkey_list[port_num].list_lock);

		spin_unlock(&dev->port_data[port_num].pkey_list_lock);

	}



	spin_lock(&pkey->qp_list_lock);
@@ -551,8 +550,7 @@ void ib_security_cache_change(struct ib_device *device, 
{

	struct pkey_index_qp_list *pkey;



	list_for_each_entry(pkey,

			    &device->port_pkey_list[port_num].pkey_list,

	list_for_each_entry (pkey, &device->port_data[port_num].pkey_list,

			     pkey_index_list) {

		check_pkey_qps(pkey,

			       device,
@@ -569,7 +567,7 @@ void ib_security_release_port_pkey_list(struct ib_device *device) 
	rdma_for_each_port (device, i) {

		list_for_each_entry_safe(pkey,

					 tmp_pkey,

					 &device->port_pkey_list[i].pkey_list,

					 &device->port_data[i].pkey_list,

					 pkey_index_list) {

			list_del(&pkey->pkey_index_list);

			kfree(pkey);

include/rdma/ib_verbs.h

+43 −31
Original line number Diff line number Diff line
@@ -2198,6 +2198,13 @@ struct ib_port_immutable { 
	u32                           max_mad_size;

};



struct ib_port_data {

	struct ib_port_immutable immutable;



	spinlock_t pkey_list_lock;

	struct list_head pkey_list;

};



/* rdma netdev type - specifies protocol type */

enum rdma_netdev_t {

	RDMA_NETDEV_OPA_VNIC,
@@ -2243,12 +2250,6 @@ struct rdma_netdev_alloc_params { 
				      struct net_device *netdev, void *param);

};



struct ib_port_pkey_list {

	/* Lock to hold while modifying the list. */

	spinlock_t                    list_lock;

	struct list_head              pkey_list;

};



struct ib_counters {

	struct ib_device	*device;

	struct ib_uobject	*uobject;
@@ -2549,14 +2550,12 @@ struct ib_device { 


	struct ib_cache               cache;

	/**

	 * port_immutable is indexed by port number

	 * port_data is indexed by port number

	 */

	struct ib_port_immutable     *port_immutable;

	struct ib_port_data *port_data;



	int			      num_comp_vectors;



	struct ib_port_pkey_list     *port_pkey_list;



	struct iw_cm_verbs	     *iwcm;



	struct module               *owner;
@@ -2860,34 +2859,38 @@ static inline int rdma_is_port_valid(const struct ib_device *device, 
static inline bool rdma_is_grh_required(const struct ib_device *device,

					u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags &

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_PORT_IB_GRH_REQUIRED;

}



static inline bool rdma_protocol_ib(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IB;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_PROT_IB;

}



static inline bool rdma_protocol_roce(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags &

	return device->port_data[port_num].immutable.core_cap_flags &

	       (RDMA_CORE_CAP_PROT_ROCE | RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP);

}



static inline bool rdma_protocol_roce_udp_encap(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_PROT_ROCE_UDP_ENCAP;

}



static inline bool rdma_protocol_roce_eth_encap(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_ROCE;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_PROT_ROCE;

}



static inline bool rdma_protocol_iwarp(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_IWARP;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_PROT_IWARP;

}



static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num)
@@ -2898,12 +2901,14 @@ static inline bool rdma_ib_or_roce(const struct ib_device *device, u8 port_num) 


static inline bool rdma_protocol_raw_packet(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_RAW_PACKET;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_PROT_RAW_PACKET;

}



static inline bool rdma_protocol_usnic(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_PROT_USNIC;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_PROT_USNIC;

}



/**
@@ -2920,7 +2925,8 @@ static inline bool rdma_protocol_usnic(const struct ib_device *device, u8 port_n 
 */

static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_MAD;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_IB_MAD;

}



/**
@@ -2944,8 +2950,8 @@ static inline bool rdma_cap_ib_mad(const struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num)

{

	return (device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_OPA_MAD)

		== RDMA_CORE_CAP_OPA_MAD;

	return (device->port_data[port_num].immutable.core_cap_flags &

		RDMA_CORE_CAP_OPA_MAD) == RDMA_CORE_CAP_OPA_MAD;

}



/**
@@ -2970,7 +2976,8 @@ static inline bool rdma_cap_opa_mad(struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SMI;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_IB_SMI;

}



/**
@@ -2990,7 +2997,8 @@ static inline bool rdma_cap_ib_smi(const struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_CM;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_IB_CM;

}



/**
@@ -3007,7 +3015,8 @@ static inline bool rdma_cap_ib_cm(const struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IW_CM;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_IW_CM;

}



/**
@@ -3027,7 +3036,8 @@ static inline bool rdma_cap_iw_cm(const struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_ib_sa(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_IB_SA;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_IB_SA;

}



/**
@@ -3067,7 +3077,8 @@ static inline bool rdma_cap_ib_mcast(const struct ib_device *device, u8 port_num 
 */

static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_AF_IB;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_AF_IB;

}



/**
@@ -3088,7 +3099,8 @@ static inline bool rdma_cap_af_ib(const struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].core_cap_flags & RDMA_CORE_CAP_ETH_AH;

	return device->port_data[port_num].immutable.core_cap_flags &

	       RDMA_CORE_CAP_ETH_AH;

}



/**
@@ -3102,7 +3114,7 @@ static inline bool rdma_cap_eth_ah(const struct ib_device *device, u8 port_num) 
 */

static inline bool rdma_cap_opa_ah(struct ib_device *device, u8 port_num)

{

	return (device->port_immutable[port_num].core_cap_flags &

	return (device->port_data[port_num].immutable.core_cap_flags &

		RDMA_CORE_CAP_OPA_AH) == RDMA_CORE_CAP_OPA_AH;

}
@@ -3120,7 +3132,7 @@ static inline bool rdma_cap_opa_ah(struct ib_device *device, u8 port_num) 
 */

static inline size_t rdma_max_mad_size(const struct ib_device *device, u8 port_num)

{

	return device->port_immutable[port_num].max_mad_size;

	return device->port_data[port_num].immutable.max_mad_size;

}



/**