Kernel/linux
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2025-01-09 14:50:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

RDMA: Split the alloc_hw_stats() ops to port and device variants

Browse Source 
This is being used to implement both the port and device global stats,
which is causing some confusion in the drivers. For instance EFA and i40iw
both seem to be misusing the device stats.

Split it into two ops so drivers that don't support one or the other can
leave the op NULL'd, making the calling code a little simpler to
understand.

Link: https://lore.kernel.org/r/1955c154197b2a159adc2dc97266ddc74afe420c.1623427137.git.leonro@nvidia.com
Tested-by: Gal Pressman <galpress@amazon.com>
Signed-off-by: Leon Romanovsky <leonro@nvidia.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
This commit is contained in:
Jason Gunthorpe 2021-06-11 19:00:20 +03:00
parent 570d2b99d0
commit 4b5f4d3fb4
19 changed files with 142 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/infiniband/core/counters.c
View File

@ -605,10 +605,10 @@ void rdma_counter_init(struct ib_device *dev)
port_counter->mode.mode = RDMA_COUNTER_MODE_NONE; port_counter->mode.mode = RDMA_COUNTER_MODE_NONE;
mutex_init(&port_counter->lock); mutex_init(&port_counter->lock);
if (!dev->ops.alloc_hw_stats) if (!dev->ops.alloc_hw_port_stats)
continue; continue;
port_counter->hstats = dev->ops.alloc_hw_stats(dev, port); port_counter->hstats = dev->ops.alloc_hw_port_stats(dev, port);
if (!port_counter->hstats) if (!port_counter->hstats)
goto fail; goto fail;
} }

3
drivers/infiniband/core/device.c
View File

@ -2595,7 +2595,8 @@ void ib_set_device_ops(struct ib_device *dev, const struct ib_device_ops *ops)
SET_DEVICE_OP(dev_ops, add_gid); SET_DEVICE_OP(dev_ops, add_gid);
SET_DEVICE_OP(dev_ops, advise_mr); SET_DEVICE_OP(dev_ops, advise_mr);
SET_DEVICE_OP(dev_ops, alloc_dm); SET_DEVICE_OP(dev_ops, alloc_dm);
SET_DEVICE_OP(dev_ops, alloc_hw_stats); SET_DEVICE_OP(dev_ops, alloc_hw_device_stats);
SET_DEVICE_OP(dev_ops, alloc_hw_port_stats);
SET_DEVICE_OP(dev_ops, alloc_mr); SET_DEVICE_OP(dev_ops, alloc_mr);
SET_DEVICE_OP(dev_ops, alloc_mr_integrity); SET_DEVICE_OP(dev_ops, alloc_mr_integrity);
SET_DEVICE_OP(dev_ops, alloc_mw); SET_DEVICE_OP(dev_ops, alloc_mw);

2
drivers/infiniband/core/nldev.c
View File

@ -2060,7 +2060,7 @@ static int stat_get_doit_default_counter(struct sk_buff *skb,
if (!device) if (!device)
return -EINVAL; return -EINVAL;
if (!device->ops.alloc_hw_stats || !device->ops.get_hw_stats) { if (!device->ops.alloc_hw_port_stats || !device->ops.get_hw_stats) {
ret = -EINVAL; ret = -EINVAL;
goto err; goto err;
} }

10
drivers/infiniband/core/sysfs.c
View File

@ -981,8 +981,10 @@ static void setup_hw_stats(struct ib_device *device, struct ib_port *port,
struct rdma_hw_stats *stats; struct rdma_hw_stats *stats;
int i, ret; int i, ret;
stats = device->ops.alloc_hw_stats(device, port_num); if (port_num)
stats = device->ops.alloc_hw_port_stats(device, port_num);
else
stats = device->ops.alloc_hw_device_stats(device);
if (!stats) if (!stats)
return; return;
@ -1165,7 +1167,7 @@ static int add_port(struct ib_core_device *coredev, int port_num)
* port, so holder should be device. Therefore skip per port conunter * port, so holder should be device. Therefore skip per port conunter
* initialization. * initialization.
*/ */
if (device->ops.alloc_hw_stats && port_num && is_full_dev) if (device->ops.alloc_hw_port_stats && port_num && is_full_dev)
setup_hw_stats(device, p, port_num); setup_hw_stats(device, p, port_num);
list_add_tail(&p->kobj.entry, &coredev->port_list); list_add_tail(&p->kobj.entry, &coredev->port_list);
@ -1409,7 +1411,7 @@ int ib_device_register_sysfs(struct ib_device *device)
if (ret) if (ret)
return ret; return ret;
if (device->ops.alloc_hw_stats) if (device->ops.alloc_hw_device_stats)
setup_hw_stats(device, NULL, 0); setup_hw_stats(device, NULL, 0);
return 0; return 0;

7
drivers/infiniband/hw/bnxt_re/hw_counters.c
View File

@ -234,13 +234,10 @@ int bnxt_re_ib_get_hw_stats(struct ib_device *ibdev,
return ARRAY_SIZE(bnxt_re_stat_name); return ARRAY_SIZE(bnxt_re_stat_name);
} }
struct rdma_hw_stats *bnxt_re_ib_alloc_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *bnxt_re_ib_alloc_hw_port_stats(struct ib_device *ibdev,
u32 port_num) u32 port_num)
{ {
BUILD_BUG_ON(ARRAY_SIZE(bnxt_re_stat_name) != BNXT_RE_NUM_COUNTERS); BUILD_BUG_ON(ARRAY_SIZE(bnxt_re_stat_name) != BNXT_RE_NUM_COUNTERS);
/* We support only per port stats */
if (!port_num)
return NULL;
return rdma_alloc_hw_stats_struct(bnxt_re_stat_name, return rdma_alloc_hw_stats_struct(bnxt_re_stat_name,
ARRAY_SIZE(bnxt_re_stat_name), ARRAY_SIZE(bnxt_re_stat_name),

4
drivers/infiniband/hw/bnxt_re/hw_counters.h
View File

@ -96,8 +96,8 @@ enum bnxt_re_hw_stats {
BNXT_RE_NUM_COUNTERS BNXT_RE_NUM_COUNTERS
}; };
struct rdma_hw_stats *bnxt_re_ib_alloc_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *bnxt_re_ib_alloc_hw_port_stats(struct ib_device *ibdev,
u32 port_num); u32 port_num);
int bnxt_re_ib_get_hw_stats(struct ib_device *ibdev, int bnxt_re_ib_get_hw_stats(struct ib_device *ibdev,
struct rdma_hw_stats *stats, struct rdma_hw_stats *stats,
u32 port, int index); u32 port, int index);

2
drivers/infiniband/hw/bnxt_re/main.c
View File

@ -665,7 +665,7 @@ static const struct ib_device_ops bnxt_re_dev_ops = {
.uverbs_abi_ver = BNXT_RE_ABI_VERSION, .uverbs_abi_ver = BNXT_RE_ABI_VERSION,
.add_gid = bnxt_re_add_gid, .add_gid = bnxt_re_add_gid,
.alloc_hw_stats = bnxt_re_ib_alloc_hw_stats, .alloc_hw_port_stats = bnxt_re_ib_alloc_hw_port_stats,
.alloc_mr = bnxt_re_alloc_mr, .alloc_mr = bnxt_re_alloc_mr,
.alloc_pd = bnxt_re_alloc_pd, .alloc_pd = bnxt_re_alloc_pd,
.alloc_ucontext = bnxt_re_alloc_ucontext, .alloc_ucontext = bnxt_re_alloc_ucontext,

9
drivers/infiniband/hw/cxgb4/provider.c
View File

@ -377,14 +377,11 @@ static const char * const names[] = {
[IP6OUTRSTS] = "ip6OutRsts" [IP6OUTRSTS] = "ip6OutRsts"
}; };
static struct rdma_hw_stats *c4iw_alloc_stats(struct ib_device *ibdev, static struct rdma_hw_stats *c4iw_alloc_device_stats(struct ib_device *ibdev)
u32 port_num)
{ {
BUILD_BUG_ON(ARRAY_SIZE(names) != NR_COUNTERS); BUILD_BUG_ON(ARRAY_SIZE(names) != NR_COUNTERS);
if (port_num != 0) /* FIXME: these look like port stats */
return NULL;
return rdma_alloc_hw_stats_struct(names, NR_COUNTERS, return rdma_alloc_hw_stats_struct(names, NR_COUNTERS,
RDMA_HW_STATS_DEFAULT_LIFESPAN); RDMA_HW_STATS_DEFAULT_LIFESPAN);
} }
@ -455,7 +452,7 @@ static const struct ib_device_ops c4iw_dev_ops = {
.driver_id = RDMA_DRIVER_CXGB4, .driver_id = RDMA_DRIVER_CXGB4,
.uverbs_abi_ver = C4IW_UVERBS_ABI_VERSION, .uverbs_abi_ver = C4IW_UVERBS_ABI_VERSION,
.alloc_hw_stats = c4iw_alloc_stats, .alloc_hw_device_stats = c4iw_alloc_device_stats,
.alloc_mr = c4iw_alloc_mr, .alloc_mr = c4iw_alloc_mr,
.alloc_pd = c4iw_allocate_pd, .alloc_pd = c4iw_allocate_pd,
.alloc_ucontext = c4iw_alloc_ucontext, .alloc_ucontext = c4iw_alloc_ucontext,

3
drivers/infiniband/hw/efa/efa.h
View File

@ -157,7 +157,8 @@ int efa_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *qp_attr,
int qp_attr_mask, struct ib_udata *udata); int qp_attr_mask, struct ib_udata *udata);
enum rdma_link_layer efa_port_link_layer(struct ib_device *ibdev, enum rdma_link_layer efa_port_link_layer(struct ib_device *ibdev,
u32 port_num); u32 port_num);
struct rdma_hw_stats *efa_alloc_hw_stats(struct ib_device *ibdev, u32 port_num); struct rdma_hw_stats *efa_alloc_hw_port_stats(struct ib_device *ibdev, u32 port_num);
struct rdma_hw_stats *efa_alloc_hw_device_stats(struct ib_device *ibdev);
int efa_get_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *stats, int efa_get_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *stats,
u32 port_num, int index); u32 port_num, int index);

3
drivers/infiniband/hw/efa/efa_main.c
View File

@ -242,7 +242,8 @@ static const struct ib_device_ops efa_dev_ops = {
.driver_id = RDMA_DRIVER_EFA, .driver_id = RDMA_DRIVER_EFA,
.uverbs_abi_ver = EFA_UVERBS_ABI_VERSION, .uverbs_abi_ver = EFA_UVERBS_ABI_VERSION,
.alloc_hw_stats = efa_alloc_hw_stats, .alloc_hw_port_stats = efa_alloc_hw_port_stats,
.alloc_hw_device_stats = efa_alloc_hw_device_stats,
.alloc_pd = efa_alloc_pd, .alloc_pd = efa_alloc_pd,
.alloc_ucontext = efa_alloc_ucontext, .alloc_ucontext = efa_alloc_ucontext,
.create_cq = efa_create_cq, .create_cq = efa_create_cq,

11
drivers/infiniband/hw/efa/efa_verbs.c
View File

@ -1904,13 +1904,22 @@ int efa_destroy_ah(struct ib_ah *ibah, u32 flags)
return 0; return 0;
} }
struct rdma_hw_stats *efa_alloc_hw_stats(struct ib_device *ibdev, u32 port_num) struct rdma_hw_stats *efa_alloc_hw_port_stats(struct ib_device *ibdev, u32 port_num)
{ {
return rdma_alloc_hw_stats_struct(efa_stats_names, return rdma_alloc_hw_stats_struct(efa_stats_names,
ARRAY_SIZE(efa_stats_names), ARRAY_SIZE(efa_stats_names),
RDMA_HW_STATS_DEFAULT_LIFESPAN); RDMA_HW_STATS_DEFAULT_LIFESPAN);
} }
struct rdma_hw_stats *efa_alloc_hw_device_stats(struct ib_device *ibdev)
{
/*
* It is probably a bug that efa reports its port stats as device
* stats
*/
return efa_alloc_hw_port_stats(ibdev, 0);
}
int efa_get_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *stats, int efa_get_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *stats,
u32 port_num, int index) u32 port_num, int index)
{ {

82
drivers/infiniband/hw/hfi1/verbs.c
View File

@ -1693,54 +1693,53 @@ static int init_cntr_names(const char *names_in,
return 0; return 0;
} }
static struct rdma_hw_stats *alloc_hw_stats(struct ib_device *ibdev, static int init_counters(struct ib_device *ibdev)
u32 port_num)
{ {
int i, err; struct hfi1_devdata *dd = dd_from_ibdev(ibdev);
int i, err = 0;
mutex_lock(&cntr_names_lock); mutex_lock(&cntr_names_lock);
if (!cntr_names_initialized) { if (cntr_names_initialized)
struct hfi1_devdata *dd = dd_from_ibdev(ibdev); goto out_unlock;
err = init_cntr_names(dd->cntrnames, err = init_cntr_names(dd->cntrnames, dd->cntrnameslen, num_driver_cntrs,
dd->cntrnameslen, &num_dev_cntrs, &dev_cntr_names);
num_driver_cntrs, if (err)
&num_dev_cntrs, goto out_unlock;
&dev_cntr_names);
if (err) {
mutex_unlock(&cntr_names_lock);
return NULL;
}
for (i = 0; i < num_driver_cntrs; i++) for (i = 0; i < num_driver_cntrs; i++)
dev_cntr_names[num_dev_cntrs + i] = dev_cntr_names[num_dev_cntrs + i] = driver_cntr_names[i];
driver_cntr_names[i];
err = init_cntr_names(dd->portcntrnames, err = init_cntr_names(dd->portcntrnames, dd->portcntrnameslen, 0,
dd->portcntrnameslen, &num_port_cntrs, &port_cntr_names);
0, if (err) {
&num_port_cntrs, kfree(dev_cntr_names);
&port_cntr_names); dev_cntr_names = NULL;
if (err) { goto out_unlock;
kfree(dev_cntr_names);
dev_cntr_names = NULL;
mutex_unlock(&cntr_names_lock);
return NULL;
}
cntr_names_initialized = 1;
} }
mutex_unlock(&cntr_names_lock); cntr_names_initialized = 1;
if (!port_num) out_unlock:
return rdma_alloc_hw_stats_struct( mutex_unlock(&cntr_names_lock);
dev_cntr_names, return err;
num_dev_cntrs + num_driver_cntrs, }
RDMA_HW_STATS_DEFAULT_LIFESPAN);
else static struct rdma_hw_stats *hfi1_alloc_hw_device_stats(struct ib_device *ibdev)
return rdma_alloc_hw_stats_struct( {
port_cntr_names, if (init_counters(ibdev))
num_port_cntrs, return NULL;
RDMA_HW_STATS_DEFAULT_LIFESPAN); return rdma_alloc_hw_stats_struct(dev_cntr_names,
num_dev_cntrs + num_driver_cntrs,
RDMA_HW_STATS_DEFAULT_LIFESPAN);
}
static struct rdma_hw_stats *hfi_alloc_hw_port_stats(struct ib_device *ibdev,
u32 port_num)
{
if (init_counters(ibdev))
return NULL;
return rdma_alloc_hw_stats_struct(port_cntr_names, num_port_cntrs,
RDMA_HW_STATS_DEFAULT_LIFESPAN);
} }
static u64 hfi1_sps_ints(void) static u64 hfi1_sps_ints(void)
@ -1787,7 +1786,8 @@ static const struct ib_device_ops hfi1_dev_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.driver_id = RDMA_DRIVER_HFI1, .driver_id = RDMA_DRIVER_HFI1,
.alloc_hw_stats = alloc_hw_stats, .alloc_hw_device_stats = hfi1_alloc_hw_device_stats,
.alloc_hw_port_stats = hfi_alloc_hw_port_stats,
.alloc_rdma_netdev = hfi1_vnic_alloc_rn, .alloc_rdma_netdev = hfi1_vnic_alloc_rn,
.get_dev_fw_str = hfi1_get_dev_fw_str, .get_dev_fw_str = hfi1_get_dev_fw_str,
.get_hw_stats = get_hw_stats, .get_hw_stats = get_hw_stats,

11
drivers/infiniband/hw/irdma/verbs.c
View File

@ -3727,20 +3727,17 @@ static void irdma_get_dev_fw_str(struct ib_device *dev, char *str)
} }
/** /**
* irdma_alloc_hw_stats - Allocate a hw stats structure * irdma_alloc_hw_port_stats - Allocate a hw stats structure
* @ibdev: device pointer from stack * @ibdev: device pointer from stack
* @port_num: port number * @port_num: port number
*/ */
static struct rdma_hw_stats *irdma_alloc_hw_stats(struct ib_device *ibdev, static struct rdma_hw_stats *irdma_alloc_hw_port_stats(struct ib_device *ibdev,
u32 port_num) u32 port_num)
{ {
int num_counters = IRDMA_HW_STAT_INDEX_MAX_32 + int num_counters = IRDMA_HW_STAT_INDEX_MAX_32 +
IRDMA_HW_STAT_INDEX_MAX_64; IRDMA_HW_STAT_INDEX_MAX_64;
unsigned long lifespan = RDMA_HW_STATS_DEFAULT_LIFESPAN; unsigned long lifespan = RDMA_HW_STATS_DEFAULT_LIFESPAN;
if (!port_num)
return NULL;
BUILD_BUG_ON(ARRAY_SIZE(irdma_hw_stat_names) != BUILD_BUG_ON(ARRAY_SIZE(irdma_hw_stat_names) !=
(IRDMA_HW_STAT_INDEX_MAX_32 + IRDMA_HW_STAT_INDEX_MAX_64)); (IRDMA_HW_STAT_INDEX_MAX_32 + IRDMA_HW_STAT_INDEX_MAX_64));
@ -4354,7 +4351,7 @@ static const struct ib_device_ops irdma_dev_ops = {
.driver_id = RDMA_DRIVER_IRDMA, .driver_id = RDMA_DRIVER_IRDMA,
.uverbs_abi_ver = IRDMA_ABI_VER, .uverbs_abi_ver = IRDMA_ABI_VER,
.alloc_hw_stats = irdma_alloc_hw_stats, .alloc_hw_port_stats = irdma_alloc_hw_port_stats,
.alloc_mr = irdma_alloc_mr, .alloc_mr = irdma_alloc_mr,
.alloc_mw = irdma_alloc_mw, .alloc_mw = irdma_alloc_mw,
.alloc_pd = irdma_alloc_pd, .alloc_pd = irdma_alloc_pd,

25
drivers/infiniband/hw/mlx4/main.c
View File

@ -2105,17 +2105,29 @@ static const struct diag_counter diag_device_only[] = {
DIAG_COUNTER(rq_num_udsdprd, 0x118), DIAG_COUNTER(rq_num_udsdprd, 0x118),
}; };
static struct rdma_hw_stats *mlx4_ib_alloc_hw_stats(struct ib_device *ibdev, static struct rdma_hw_stats *
u32 port_num) mlx4_ib_alloc_hw_device_stats(struct ib_device *ibdev)
{ {
struct mlx4_ib_dev *dev = to_mdev(ibdev); struct mlx4_ib_dev *dev = to_mdev(ibdev);
struct mlx4_ib_diag_counters *diag = dev->diag_counters; struct mlx4_ib_diag_counters *diag = dev->diag_counters;
if (!diag[!!port_num].name) if (!diag[0].name)
return NULL; return NULL;
return rdma_alloc_hw_stats_struct(diag[!!port_num].name, return rdma_alloc_hw_stats_struct(diag[0].name, diag[0].num_counters,
diag[!!port_num].num_counters, RDMA_HW_STATS_DEFAULT_LIFESPAN);
}
static struct rdma_hw_stats *
mlx4_ib_alloc_hw_port_stats(struct ib_device *ibdev, u32 port_num)
{
struct mlx4_ib_dev *dev = to_mdev(ibdev);
struct mlx4_ib_diag_counters *diag = dev->diag_counters;
if (!diag[1].name)
return NULL;
return rdma_alloc_hw_stats_struct(diag[1].name, diag[1].num_counters,
RDMA_HW_STATS_DEFAULT_LIFESPAN); RDMA_HW_STATS_DEFAULT_LIFESPAN);
} }
@ -2206,7 +2218,8 @@ static void mlx4_ib_fill_diag_counters(struct mlx4_ib_dev *ibdev,
} }
static const struct ib_device_ops mlx4_ib_hw_stats_ops = { static const struct ib_device_ops mlx4_ib_hw_stats_ops = {
.alloc_hw_stats = mlx4_ib_alloc_hw_stats, .alloc_hw_device_stats = mlx4_ib_alloc_hw_device_stats,
.alloc_hw_port_stats = mlx4_ib_alloc_hw_port_stats,
.get_hw_stats = mlx4_ib_get_hw_stats, .get_hw_stats = mlx4_ib_get_hw_stats,
}; };

46
drivers/infiniband/hw/mlx5/counters.c
View File

@ -161,22 +161,29 @@ u16 mlx5_ib_get_counters_id(struct mlx5_ib_dev *dev, u32 port_num)
return cnts->set_id; return cnts->set_id;
} }
static struct rdma_hw_stats *mlx5_ib_alloc_hw_stats(struct ib_device *ibdev, static struct rdma_hw_stats *
u32 port_num) mlx5_ib_alloc_hw_device_stats(struct ib_device *ibdev)
{ {
struct mlx5_ib_dev *dev = to_mdev(ibdev); struct mlx5_ib_dev *dev = to_mdev(ibdev);
const struct mlx5_ib_counters *cnts; const struct mlx5_ib_counters *cnts = &dev->port[0].cnts;
bool is_switchdev = is_mdev_switchdev_mode(dev->mdev);
if ((is_switchdev && port_num) || (!is_switchdev && !port_num))
return NULL;
cnts = get_counters(dev, port_num - 1);
return rdma_alloc_hw_stats_struct(cnts->names, return rdma_alloc_hw_stats_struct(cnts->names,
cnts->num_q_counters + cnts->num_q_counters +
cnts->num_cong_counters + cnts->num_cong_counters +
cnts->num_ext_ppcnt_counters, cnts->num_ext_ppcnt_counters,
RDMA_HW_STATS_DEFAULT_LIFESPAN);
}
static struct rdma_hw_stats *
mlx5_ib_alloc_hw_port_stats(struct ib_device *ibdev, u32 port_num)
{
struct mlx5_ib_dev *dev = to_mdev(ibdev);
const struct mlx5_ib_counters *cnts = &dev->port[port_num - 1].cnts;
return rdma_alloc_hw_stats_struct(cnts->names,
cnts->num_q_counters +
cnts->num_cong_counters +
cnts->num_ext_ppcnt_counters,
RDMA_HW_STATS_DEFAULT_LIFESPAN); RDMA_HW_STATS_DEFAULT_LIFESPAN);
} }
@ -666,7 +673,17 @@ void mlx5_ib_counters_clear_description(struct ib_counters *counters)
} }
static const struct ib_device_ops hw_stats_ops = { static const struct ib_device_ops hw_stats_ops = {
.alloc_hw_stats = mlx5_ib_alloc_hw_stats, .alloc_hw_port_stats = mlx5_ib_alloc_hw_port_stats,
.get_hw_stats = mlx5_ib_get_hw_stats,
.counter_bind_qp = mlx5_ib_counter_bind_qp,
.counter_unbind_qp = mlx5_ib_counter_unbind_qp,
.counter_dealloc = mlx5_ib_counter_dealloc,
.counter_alloc_stats = mlx5_ib_counter_alloc_stats,
.counter_update_stats = mlx5_ib_counter_update_stats,
};
static const struct ib_device_ops hw_switchdev_stats_ops = {
.alloc_hw_device_stats = mlx5_ib_alloc_hw_device_stats,
.get_hw_stats = mlx5_ib_get_hw_stats, .get_hw_stats = mlx5_ib_get_hw_stats,
.counter_bind_qp = mlx5_ib_counter_bind_qp, .counter_bind_qp = mlx5_ib_counter_bind_qp,
.counter_unbind_qp = mlx5_ib_counter_unbind_qp, .counter_unbind_qp = mlx5_ib_counter_unbind_qp,
@ -690,7 +707,10 @@ int mlx5_ib_counters_init(struct mlx5_ib_dev *dev)
if (!MLX5_CAP_GEN(dev->mdev, max_qp_cnt)) if (!MLX5_CAP_GEN(dev->mdev, max_qp_cnt))
return 0; return 0;
ib_set_device_ops(&dev->ib_dev, &hw_stats_ops); if (is_mdev_switchdev_mode(dev->mdev))
ib_set_device_ops(&dev->ib_dev, &hw_switchdev_stats_ops);
else
ib_set_device_ops(&dev->ib_dev, &hw_stats_ops);
return mlx5_ib_alloc_counters(dev); return mlx5_ib_alloc_counters(dev);
} }

7
drivers/infiniband/sw/rxe/rxe_hw_counters.c
View File

@ -40,13 +40,10 @@ int rxe_ib_get_hw_stats(struct ib_device *ibdev,
return ARRAY_SIZE(rxe_counter_name); return ARRAY_SIZE(rxe_counter_name);
} }
struct rdma_hw_stats *rxe_ib_alloc_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *rxe_ib_alloc_hw_port_stats(struct ib_device *ibdev,
u32 port_num) u32 port_num)
{ {
BUILD_BUG_ON(ARRAY_SIZE(rxe_counter_name) != RXE_NUM_OF_COUNTERS); BUILD_BUG_ON(ARRAY_SIZE(rxe_counter_name) != RXE_NUM_OF_COUNTERS);
/* We support only per port stats */
if (!port_num)
return NULL;
return rdma_alloc_hw_stats_struct(rxe_counter_name, return rdma_alloc_hw_stats_struct(rxe_counter_name,
ARRAY_SIZE(rxe_counter_name), ARRAY_SIZE(rxe_counter_name),

4
drivers/infiniband/sw/rxe/rxe_hw_counters.h
View File

@ -29,8 +29,8 @@ enum rxe_counters {
RXE_NUM_OF_COUNTERS RXE_NUM_OF_COUNTERS
}; };
struct rdma_hw_stats *rxe_ib_alloc_hw_stats(struct ib_device *ibdev, struct rdma_hw_stats *rxe_ib_alloc_hw_port_stats(struct ib_device *ibdev,
u32 port_num); u32 port_num);
int rxe_ib_get_hw_stats(struct ib_device *ibdev, int rxe_ib_get_hw_stats(struct ib_device *ibdev,
struct rdma_hw_stats *stats, struct rdma_hw_stats *stats,
u32 port, int index); u32 port, int index);

2
drivers/infiniband/sw/rxe/rxe_verbs.c
View File

@ -1093,7 +1093,7 @@ static const struct ib_device_ops rxe_dev_ops = {
.driver_id = RDMA_DRIVER_RXE, .driver_id = RDMA_DRIVER_RXE,
.uverbs_abi_ver = RXE_UVERBS_ABI_VERSION, .uverbs_abi_ver = RXE_UVERBS_ABI_VERSION,
.alloc_hw_stats = rxe_ib_alloc_hw_stats, .alloc_hw_port_stats = rxe_ib_alloc_hw_port_stats,
.alloc_mr = rxe_alloc_mr, .alloc_mr = rxe_alloc_mr,
.alloc_mw = rxe_alloc_mw, .alloc_mw = rxe_alloc_mw,
.alloc_pd = rxe_alloc_pd, .alloc_pd = rxe_alloc_pd,

13
include/rdma/ib_verbs.h
View File

@ -2522,13 +2522,14 @@ struct ib_device_ops {
unsigned int *meta_sg_offset); unsigned int *meta_sg_offset);
/** /**
* alloc_hw_stats - Allocate a struct rdma_hw_stats and fill in the * alloc_hw_[device,port]_stats - Allocate a struct rdma_hw_stats and
* driver initialized data. The struct is kfree()'ed by the sysfs * fill in the driver initialized data. The struct is kfree()'ed by
* core when the device is removed. A lifespan of -1 in the return * the sysfs core when the device is removed. A lifespan of -1 in the
* struct tells the core to set a default lifespan. * return struct tells the core to set a default lifespan.
*/ */
struct rdma_hw_stats *(*alloc_hw_stats)(struct ib_device *device, struct rdma_hw_stats *(*alloc_hw_device_stats)(struct ib_device *device);
u32 port_num); struct rdma_hw_stats *(*alloc_hw_port_stats)(struct ib_device *device,
u32 port_num);
/** /**
* get_hw_stats - Fill in the counter value(s) in the stats struct. * get_hw_stats - Fill in the counter value(s) in the stats struct.
* @index - The index in the value array we wish to have updated, or * @index - The index in the value array we wish to have updated, or