Statistics counter support
Subsystems (5)
v4 cover Statistics counter support
From: Leon Romanovsky <[email protected]>
Changelog:
v3 -> v4:
* Add counter_dealloc() callback function
* Moved to kref implementation
* Fixed lock during spinlock
v2 -> v3:
* We didn't change use of atomics over kref for management of unbind counter from QP. The reason to it that bind and unbind are non-symmetric in regards of put and get, so we need to count differently memory release flows of HW objects (restrack) and SW bind operations.
* Everything else was addressed.
v1 -> v2:
* Rebased to latest rdma-next
v0 -> v1:
* Changed wording of counter comment
* Removed unneeded assignments
* Added extra patch to present global counters
----------------------------------------------------
Hi,
This series from Mark provides dynamic statistics infrastructure. He uses netlink interface to configure and retrieve those counters.
This infrastructure allows to users monitor various objects by binding to them counters. As the beginning, we used QP object as target for those counters, but future patches will include ODP MR information too.
Two binding modes are supported:
- Auto: This allows a user to build automatic set of objects to a counter according to common criteria. For example in a per-type scheme, where in one process all QPs with same QP type are bound automatically to a single counter.
- Manual: This allows a user to manually bind objects on a counter.
Those two modes are mutual-exclusive with separation between processes, objects created by different processes cannot be bound to a same counter.
For objects which don't support counter binding, we will return pre-allocated counters.
$ rdma statistic qp set link mlx5_2/1 auto type on $ rdma statistic qp set link mlx5_2/1 auto off $ rdma statistic qp bind link mlx5_2/1 lqpn 178 $ rdma statistic qp unbind link mlx5_2/1 cntn 4 lqpn 178 $ rdma statistic show $ rdma statistic qp mode
Thanks
Mark Zhang (17):
net/mlx5: Add rts2rts_qp_counters_set_id field in hca cap RDMA/restrack: Introduce statistic counter RDMA/restrack: Add an API to attach a task to a resource RDMA/restrack: Make is_visible_in_pid_ns() as an API RDMA/counter: Add set/clear per-port auto mode support RDMA/counter: Add "auto" configuration mode support IB/mlx5: Support set qp counter
IB/mlx5: Add counter set id as a parameter for
mlx5_ib_query_q_counters()
IB/mlx5: Support statistic q counter configuration RDMA/nldev: Allow counter auto mode configration through RDMA netlink RDMA/netlink: Implement counter dumpit calback
IB/mlx5: Add counter_alloc_stats() and counter_update_stats() support RDMA/core: Get sum value of all counters when perform a sysfs stat
read
RDMA/counter: Allow manual mode configuration support RDMA/nldev: Allow counter manual mode configration through RDMA
netlink
RDMA/nldev: Allow get counter mode through RDMA netlink RDMA/nldev: Allow get default counter statistics through RDMA netlink
drivers/infiniband/core/Makefile | 2 +- drivers/infiniband/core/counters.c | 663 +++++++++++++++++++++++++++ drivers/infiniband/core/device.c | 12 +- drivers/infiniband/core/nldev.c | 551 +++++++++++++++++++++- drivers/infiniband/core/restrack.c | 49 +- drivers/infiniband/core/restrack.h | 3 + drivers/infiniband/core/sysfs.c | 16 +- drivers/infiniband/core/verbs.c | 9 + drivers/infiniband/hw/mlx5/main.c | 77 +++- drivers/infiniband/hw/mlx5/mlx5_ib.h | 6 + drivers/infiniband/hw/mlx5/qp.c | 76 ++- include/linux/mlx5/mlx5_ifc.h | 4 +- include/linux/mlx5/qp.h | 1 + include/rdma/ib_verbs.h | 31 ++ include/rdma/rdma_counter.h | 65 +++ include/rdma/restrack.h | 4 + include/uapi/rdma/rdma_netlink.h | 52 ++- 17 files changed, 1589 insertions(+), 32 deletions(-) create mode 100644 drivers/infiniband/core/counters.c create mode 100644 include/rdma/rdma_counter.h
PATCH v4 1/17 net/mlx5: Add rts2rts_qp_counters_set_id field in hca cap
From: Mark Zhang <[email protected]>
Add rts2rts_qp_counters_set_id field in hca cap so that RTS2RTS qp modification can be used to change the counter of a QP.
--- include/linux/mlx5/mlx5_ifc.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
include/linux/mlx5/mlx5_ifc.h +3 -1
@@ -1028,7 +1028,9 @@ struct mlx5_ifc_cmd_hca_cap_bits {u8 cc_modify_allowed[0x1 ];u8 start_pad[0x1 ];u8 cache_line_128byte[0x1 ]; -u8 reserved_at_165[0xa ]; +u8 reserved_at_165[0x4 ]; +u8 rts2rts_qp_counters_set_id[0x1 ]; +u8 reserved_at_16a[0x5 ];u8 qcam_reg[0x1 ];u8 gid_table_size[0x10 ];
Re: [PATCH mlx5-next v4 01/17] net/mlx5: Add rts2rts_qp_counters_set_id field in hca cap
Quoted 29 lines · Leon Romanovsky
From: Mark Zhang <[email protected]>
Add
rts2rts_qp_counters_set_idfield in hca cap so that RTS2RTS qp modification can be used to change the counter of a QP.Signed-off-by Mark Zhang <[email protected]>Reviewed-by Majd Dibbiny <[email protected]>Signed-off-by Leon Romanovsky <[email protected]>--- include/linux/mlx5/mlx5_ifc.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)include/linux/mlx5/mlx5_ifc.h +3
-2@@ -1028,7 +1028,9 @@ struct mlx5_ifc_cmd_hca_cap_bits {u8 cc_modify_allowed[0x1 ];u8 start_pad[0x1 ];u8 cache_line_128byte[0x1 ]; -u8 reserved_at_165[0xa ]; +u8 reserved_at_165[0x4 ]; +u8 rts2rts_qp_counters_set_id[0x1 ]; +u8 reserved_at_16a[0x5 ];u8 qcam_reg[0x1 ];u8 gid_table_size[0x10 ]; --
Quoted 2 lines
2.20.1
PATCH v4 2/17 RDMA/restrack: Introduce statistic counter
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Introduce statistic counter as a new resource. It allows a user to monitor specific objects (e.g., QPs) by binding to a counter.
In some cases a user counter resource is created with task other then "current", because its creation is done as part of rdmatool call.
--- drivers/infiniband/core/restrack.c | 22 +++++++++++++++++----- include/rdma/rdma_counter.h | 18 ++++++++++++++++++ include/rdma/restrack.h | 4 ++++ 3 files changed, 39 insertions(+), 5 deletions(-) create mode 100644 include/rdma/rdma_counter.h
drivers/infiniband/core/restrack.c +17 -5
@@ -6,6 +6,7 @@#include <rdma/rdma_cm.h> #include <rdma/ib_verbs.h> #include <rdma/restrack.h> +#include <rdma/rdma_counter.h> #include <linux/mutex.h> #include <linux/sched/task.h> #include <linux/pid_namespace.h>
@@ -45,6 +46,7 @@ static const char *type2str(enum rdma_restrack_type type) [RDMA_RESTRACK_CM_ID] = "CM_ID", [RDMA_RESTRACK_MR] = "MR", [RDMA_RESTRACK_CTX] = "CTX", + [RDMA_RESTRACK_COUNTER] = "COUNTER", };return names[type];
@@ -169,6 +171,8 @@ static struct ib_device *res_to_dev(struct rdma_restrack_entry *res) return container_of(res, struct ib_mr, res)->device;case RDMA_RESTRACK_CTX : return container_of(res, struct ib_ucontext, res)->device; +case RDMA_RESTRACK_COUNTER : + return container_of(res, struct rdma_counter, res)->device;default :WARN_ONCE (true,"Wrong resource tracking type %u\n" , res->type);return NULL ;
@@ -203,15 +207,22 @@ static void rdma_restrack_add(struct rdma_restrack_entry *res)kref_init (&res->kref);init_completion (&res->comp); -if (res->type !=RDMA_RESTRACK_QP ) - ret =xa_alloc_cyclic (&rt->xa, &res->id, res, xa_limit_32b, - &rt->next_id,GFP_KERNEL ); -else { +if (res->type ==RDMA_RESTRACK_QP ) {/* Special case to ensure that LQPN points to right QP */ struct ib_qp *qp = container_of(res, struct ib_qp, res); ret =xa_insert (&rt->xa, qp->qp_num, res,GFP_KERNEL ); res->id = ret ?0 : qp->qp_num; + }else if (res->type ==RDMA_RESTRACK_COUNTER ) { +/* Special case to ensure that cntn points to right counter */ +struct rdma_counter *counter; + + counter = container_of(res, struct rdma_counter, res); + ret =xa_insert (&rt->xa, counter->id, res,GFP_KERNEL ); + res->id = ret ?0 : counter->id; + }else { + ret =xa_alloc_cyclic (&rt->xa, &res->id, res, xa_limit_32b, + &rt->next_id,GFP_KERNEL ); }if (!ret)
@@ -237,7 +248,8 @@ EXPORT_SYMBOL(rdma_restrack_kadd);*/ void rdma_restrack_uadd (struct rdma_restrack_entry *res) { -if (res->type !=RDMA_RESTRACK_CM_ID ) +if ((res->type !=RDMA_RESTRACK_CM_ID ) && + (res->type !=RDMA_RESTRACK_COUNTER )) res->task =NULL ;if (!res->task)
include/rdma/rdma_counter.h new file +18 -0
@@ -0,0 +1,18 @@ +/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */ +/* +* Copyright (c) 2019 Mellanox Technologies. All rights reserved. +*/ + +#ifndef _RDMA_COUNTER_H_ +#define _RDMA_COUNTER_H_ + +#include <rdma/ib_verbs.h> +#include <rdma/restrack.h> + +struct rdma_counter { +struct rdma_restrack_entry res; +struct ib_device *device; +uint32_t id; +u8 port; +}; +#endif /* _RDMA_COUNTER_H_ */
include/rdma/restrack.h +4 -0
@@ -42,6 +42,10 @@ enum rdma_restrack_type {* @RDMA_RESTRACK_CTX: Verbs contexts (CTX) */ RDMA_RESTRACK_CTX , +/** +* @RDMA_RESTRACK_COUNTER: Statistic Counter +*/ + RDMA_RESTRACK_COUNTER,/** * @RDMA_RESTRACK_MAX: Last entry, used for array dclarations */
PATCH v4 3/17 RDMA/restrack: Add an API to attach a task to a resource
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Add rdma_restrack_attach_task() which is able to attach a task other then "current" to a resource.
--- drivers/infiniband/core/restrack.c | 14 ++++++++++++++ drivers/infiniband/core/restrack.h | 2 ++ 2 files changed, 16 insertions(+)
drivers/infiniband/core/restrack.c +14 -0
@@ -194,6 +194,20 @@ void rdma_restrack_set_task(struct rdma_restrack_entry *res, }EXPORT_SYMBOL (rdma_restrack_set_task); +/** +* rdma_restrack_attach_task() - attach the task onto this resource +* @res: resource entry +* @task: the task to attach, the current task will be used if it is NULL. +*/ +void rdma_restrack_attach_task (struct rdma_restrack_entry *res, +struct task_struct *task) +{ +if (res->task) +put_task_struct (res->task); +get_task_struct (task); + res->task = task; +} +static void rdma_restrack_add (struct rdma_restrack_entry *res) {struct ib_device *dev =res_to_dev (res);
drivers/infiniband/core/restrack.h +2 -0
@@ -25,4 +25,6 @@ struct rdma_restrack_root {int rdma_restrack_init (struct ib_device *dev);void rdma_restrack_clean (struct ib_device *dev); +void rdma_restrack_attach_task (struct rdma_restrack_entry *res, +struct task_struct *task);#endif /* _RDMA_CORE_RESTRACK_H_ */
PATCH v4 4/17 RDMA/restrack: Make is_visible_in_pid_ns() as an API
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Remove is_visible_in_pid_ns() from nldev.c and make it as a restrack API, so that it can be taken advantage by other parts like counter.
--- drivers/infiniband/core/nldev.c | 15 ++------------- drivers/infiniband/core/restrack.c | 13 +++++++++++++ drivers/infiniband/core/restrack.h | 1 + 3 files changed, 16 insertions(+), 13 deletions(-)
drivers/infiniband/core/nldev.c +2 -13
@@ -992,17 +992,6 @@ static const struct nldev_fill_res_entry fill_entries[RDMA_RESTRACK_MAX] = { }, }; -static bool is_visible_in_pid_ns (struct rdma_restrack_entry *res) -{ -/* -* 1. Kern resources should be visible in init name space only -* 2. Present only resources visible in the current namespace -*/ -if (rdma_is_kernel_res (res)) -return task_active_pid_ns (current) == &init_pid_ns; -return task_active_pid_ns (current) ==task_active_pid_ns (res->task); -} -static int res_get_common_doit (struct sk_buff *skb,struct nlmsghdr *nlh,struct netlink_ext_ack *extack,enum rdma_restrack_type res_type)
@@ -1047,7 +1036,7 @@ static int res_get_common_doit(struct sk_buff *skb, struct nlmsghdr *nlh, goto err; } -if (!is_visible_in_pid_ns (res)) { +if (!rdma_is_visible_in_pid_ns (res)) { ret = -ENOENT ; goto err_get; }
@@ -1159,7 +1148,7 @@ static int res_get_common_dumpit(struct sk_buff *skb,* objects. */ xa_for_each (&rt->xa, id, res) { -if (!is_visible_in_pid_ns (res)) +if (!rdma_is_visible_in_pid_ns (res))continue ;if (idx < start || !rdma_restrack_get (res))
drivers/infiniband/core/restrack.c +13 -0
@@ -349,3 +349,16 @@ void rdma_restrack_del(struct rdma_restrack_entry *res) } }EXPORT_SYMBOL (rdma_restrack_del); + +bool rdma_is_visible_in_pid_ns (struct rdma_restrack_entry *res) +{ +/* +* 1. Kern resources should be visible in init +* namespace only +* 2. Present only resources visible in the current +* namespace +*/ +if (rdma_is_kernel_res (res)) +return task_active_pid_ns (current) == &init_pid_ns; +return task_active_pid_ns (current) ==task_active_pid_ns (res->task); +}
drivers/infiniband/core/restrack.h +1 -0
@@ -27,4 +27,5 @@ int rdma_restrack_init(struct ib_device *dev);void rdma_restrack_clean (struct ib_device *dev);void rdma_restrack_attach_task (struct rdma_restrack_entry *res,struct task_struct *task); +bool rdma_is_visible_in_pid_ns (struct rdma_restrack_entry *res);#endif /* _RDMA_CORE_RESTRACK_H_ */
PATCH v4 5/17 RDMA/counter: Add set/clear per-port auto mode support
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Add an API to support set/clear per-port auto mode.
--- drivers/infiniband/core/Makefile | 2 +- drivers/infiniband/core/counters.c | 74 ++++++++++++++++++++++++++++++ drivers/infiniband/core/device.c | 7 ++- include/rdma/ib_verbs.h | 2 + include/rdma/rdma_counter.h | 24 ++++++++++ include/uapi/rdma/rdma_netlink.h | 26 +++++++++++ 6 files changed, 133 insertions(+), 2 deletions(-) create mode 100644 drivers/infiniband/core/counters.c
drivers/infiniband/core/Makefile +1 -1
@@ -11,7 +11,7 @@ ib_core-y := packer.o ud_header.o verbs.o cq.o rw.o sysfs.o \ device.o fmr_pool.o cache.o netlink.o \ roce_gid_mgmt.o mr_pool.o addr.o sa_query.o \ multicast.o mad.o smi.o agent.o mad_rmpp.o \ - nldev.o restrack.o + nldev.o restrack.o counters.o ib_core-$(CONFIG_SECURITY_INFINIBAND) += security.o ib_core-$(CONFIG_CGROUP_RDMA) += cgroup.o
drivers/infiniband/core/counters.c new file +74 -0
74 lines not on this page · raw message
drivers/infiniband/core/device.c +6 -1
@@ -46,6 +46,7 @@#include <rdma/rdma_netlink.h> #include <rdma/ib_addr.h> #include <rdma/ib_cache.h> +#include <rdma/rdma_counter.h> #include "core_priv.h" #include "restrack.h"
@@ -493,10 +494,12 @@ static void ib_device_release(struct device *device)ib_security_release_port_pkey_list (dev);xa_destroy (&dev->compat_devs);xa_destroy (&dev->client_data); -if (dev->port_data) +if (dev->port_data) { +rdma_counter_release (dev); kfree_rcu(container_of(dev->port_data, struct ib_port_data_rcu, pdata[0 ]), rcu_head); + }kfree_rcu (dev, rcu_head); }
@@ -1315,6 +1318,8 @@ int ib_register_device(struct ib_device *device, const char *name)ib_device_register_rdmacg (device); +rdma_counter_init (device); +/* * Ensure that ADD uevent is not fired because it * is too early amd device is not initialized yet.
include/rdma/ib_verbs.h +2 -0
@@ -62,6 +62,7 @@#include <linux/irqflags.h> #include <linux/preempt.h> #include <uapi/rdma/ib_user_verbs.h> +#include <rdma/rdma_counter.h> #include <rdma/restrack.h> #include <uapi/rdma/rdma_user_ioctl.h> #include <uapi/rdma/ib_user_ioctl_verbs.h>
@@ -2232,6 +2233,7 @@ struct ib_port_data {spinlock_t netdev_lock;struct net_device __rcu *netdev;struct hlist_node ndev_hash_link; +struct rdma_port_counter port_counter; };/* rdma netdev type - specifies protocol type */
include/rdma/rdma_counter.h +24 -0
@@ -6,8 +6,26 @@ #ifndef _RDMA_COUNTER_H_ #define _RDMA_COUNTER_H_ +#include <linux/mutex.h> + #include <rdma/ib_verbs.h> #include <rdma/restrack.h> +#include <rdma/rdma_netlink.h> + +struct auto_mode_param { + int qp_type; +}; + +struct rdma_counter_mode { + enum rdma_nl_counter_mode mode; + enum rdma_nl_counter_mask mask; + struct auto_mode_param param; +}; + +struct rdma_port_counter { + struct rdma_counter_mode mode; + struct mutex lock; +}; struct rdma_counter { struct rdma_restrack_entry res;
@@ -15,4 +33,10 @@ struct rdma_counter {uint32_t id; u8 port; }; + +void rdma_counter_init (struct ib_device *dev); +void rdma_counter_release (struct ib_device *dev); +int rdma_counter_set_auto_mode (struct ib_device *dev,u8 port, +bool on,enum rdma_nl_counter_mask mask); +#endif /* _RDMA_COUNTER_H_ */
include/uapi/rdma/rdma_netlink.h +26 -0
@@ -496,4 +496,30 @@ enum rdma_nldev_attr {*/ RDMA_NLDEV_ATTR_MAX }; + +/* +* Supported counter bind modes. All modes are mutual-exclusive. +*/ +enum rdma_nl_counter_mode { +RDMA_COUNTER_MODE_NONE , + +/* +* A qp is bound with a counter automatically during initialization +* based on the auto mode (e.g., qp type, ...) +*/ +RDMA_COUNTER_MODE_AUTO , + +/* +* Always the end +*/ +RDMA_COUNTER_MODE_MAX , +}; + +/* +* Supported criteria in counter auto mode. +* Currently only "qp type" is supported +*/ +enum rdma_nl_counter_mask { +RDMA_COUNTER_MASK_QP_TYPE =1 , +};#endif /* _UAPI_RDMA_NETLINK_H */
PATCH v4 6/17 RDMA/counter: Add "auto" configuration mode support
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
In auto mode all QPs belong to one category are bind automatically to a single counter set. Currently only "qp type" is supported.
In this mode the qp counter is set in RST2INIT modification, and when a qp is destroyed the counter is unbound.
--- drivers/infiniband/core/counters.c | 248 +++++++++++++++++++++++++++++ drivers/infiniband/core/device.c | 3 + drivers/infiniband/core/verbs.c | 9 ++ include/rdma/ib_verbs.h | 18 +++ include/rdma/rdma_counter.h | 8 + 5 files changed, 286 insertions(+)
drivers/infiniband/core/counters.c +248 -0
@@ -54,6 +54,254 @@ int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port,return ret; } +static struct rdma_counter *rdma_counter_alloc (struct ib_device *dev,u8 port, +enum rdma_nl_counter_mode mode) +{ +struct rdma_counter *counter; + +if (!dev->ops.counter_dealloc) +return NULL ; + + counter =kzalloc (sizeof (*counter),GFP_KERNEL ); +if (!counter) +return NULL ; + + counter->device = dev; + counter->port = port; + counter->res.type =RDMA_RESTRACK_COUNTER ; + counter->mode.mode = mode; +kref_init (&counter->kref); +mutex_init (&counter->lock); + +return counter; +} + +static void rdma_counter_free (struct rdma_counter *counter) +{ +rdma_restrack_del (&counter->res); +kfree (counter); +} + +static void __rdma_counter_dealloc (struct rdma_counter *counter) +{ +mutex_lock (&counter->lock); + counter->device->ops.counter_dealloc (counter); +mutex_unlock (&counter->lock); +} + +static void rdma_counter_dealloc (struct rdma_counter *counter) +{ +if (!counter) +return ; + +__rdma_counter_dealloc (counter); +rdma_counter_free (counter); +} + +static void auto_mode_init_counter (struct rdma_counter *counter, +const struct ib_qp *qp, +enum rdma_nl_counter_mask new_mask) +{ +struct auto_mode_param *param = &counter->mode.param; + + counter->mode.mode =RDMA_COUNTER_MODE_AUTO ; + counter->mode.mask = new_mask; + +if (new_mask &RDMA_COUNTER_MASK_QP_TYPE ) + param->qp_type = qp->qp_type; +} + +static bool auto_mode_match (struct ib_qp *qp,struct rdma_counter *counter, +enum rdma_nl_counter_mask auto_mask) +{ +struct auto_mode_param *param = &counter->mode.param; +bool match = true; + +if (rdma_is_kernel_res (&counter->res) !=rdma_is_kernel_res (&qp->res)) +return false; + +/* Ensure that counter belong to right PID */ +if (!rdma_is_kernel_res (&counter->res) && + !rdma_is_kernel_res (&qp->res) && + (task_pid_vnr (counter->res.task) != current->pid)) +return false; + +if (auto_mask &RDMA_COUNTER_MASK_QP_TYPE ) + match &= (param->qp_type == qp->qp_type); + +return match; +} + +static int __rdma_counter_bind_qp (struct rdma_counter *counter, +struct ib_qp *qp) +{ +int ret; + +if (qp->counter) +return -EINVAL ; + +if (!qp->device->ops.counter_bind_qp) +return -EOPNOTSUPP ; + +mutex_lock (&counter->lock); + ret = qp->device->ops.counter_bind_qp (counter, qp); +mutex_unlock (&counter->lock); + +return ret; +} + +static int __rdma_counter_unbind_qp (struct ib_qp *qp) +{ +struct rdma_counter *counter = qp->counter; +int ret; + +if (!qp->device->ops.counter_unbind_qp) +return -EOPNOTSUPP ; + +mutex_lock (&counter->lock); + ret = qp->device->ops.counter_unbind_qp (qp); +mutex_unlock (&counter->lock); + +return ret; +} + +/** +* rdma_get_counter_auto_mode - Find the counter that @qp should be bound +* with in auto mode +* +* Return: The counter (with ref-count increased) if found +*/ +static struct rdma_counter *rdma_get_counter_auto_mode (struct ib_qp *qp, +u8 port) +{ +struct rdma_port_counter *port_counter; +struct rdma_counter *counter =NULL ; +struct ib_device *dev = qp->device; +struct rdma_restrack_entry *res; +struct rdma_restrack_root *rt; +unsigned long id =0 ; + + port_counter = &dev->port_data[port].port_counter; + rt = &dev->res[RDMA_RESTRACK_COUNTER ]; +xa_lock (&rt->xa); +xa_for_each (&rt->xa, id, res) { +if (!rdma_is_visible_in_pid_ns (res)) +continue ; + + counter = container_of(res, struct rdma_counter, res); +if ((counter->device != qp->device) || (counter->port != port)) + goto next; + +if (auto_mode_match (qp, counter, port_counter->mode.mask)) +break ; +next: + counter =NULL ; + } + +if (counter && !rdma_restrack_get (&counter->res)) + counter =NULL ; + +xa_unlock (&rt->xa); +return counter; +} + +static void rdma_counter_res_add (struct rdma_counter *counter, +struct ib_qp *qp) +{ +if (rdma_is_kernel_res (&qp->res)) { +rdma_restrack_set_task (&counter->res, qp->res.kern_name); +rdma_restrack_kadd (&counter->res); + }else { +rdma_restrack_attach_task (&counter->res, qp->res.task); +rdma_restrack_uadd (&counter->res); + } +} + +/** +* rdma_counter_bind_qp_auto - Check and bind the QP to a counter base on +* the auto-mode rule +*/ +int rdma_counter_bind_qp_auto (struct ib_qp *qp,u8 port) +{ +struct rdma_port_counter *port_counter; +struct ib_device *dev = qp->device; +struct rdma_counter *counter; +int ret; + +if (!rdma_is_port_valid (dev, port)) +return -EINVAL ; + + port_counter = &dev->port_data[port].port_counter; +if (port_counter->mode.mode !=RDMA_COUNTER_MODE_AUTO ) +return 0 ; + + counter =rdma_get_counter_auto_mode (qp, port); +if (counter) { + ret =__rdma_counter_bind_qp (counter, qp); +if (ret) { +rdma_restrack_put (&counter->res); +return ret; + } +kref_get (&counter->kref); + }else { + counter =rdma_counter_alloc (dev, port,RDMA_COUNTER_MODE_AUTO ); +if (!counter) +return -ENOMEM ; + +auto_mode_init_counter (counter, qp, port_counter->mode.mask); + + ret =__rdma_counter_bind_qp (counter, qp); +if (ret) + goto err_bind; + +rdma_counter_res_add (counter, qp); +if (!rdma_restrack_get (&counter->res)) { + ret = -EINVAL ; + goto err_get; + } + } + +return 0 ; + +err_get: +__rdma_counter_unbind_qp (qp); +__rdma_counter_dealloc (counter); +err_bind: +rdma_counter_free (counter); +return ret; +} + +static void counter_release (struct kref *kref) +{ +struct rdma_counter *counter; + + counter = container_of(kref, struct rdma_counter, kref); +rdma_counter_dealloc (counter); +} + +/** +* rdma_counter_unbind_qp - Unbind a qp from a counter +* @force: +* true - Decrease the counter ref-count anyway (e.g., qp destroy) +*/ +int rdma_counter_unbind_qp (struct ib_qp *qp,bool force) +{ +struct rdma_counter *counter = qp->counter; +int ret; + +if (!counter) +return -EINVAL ; + + ret =__rdma_counter_unbind_qp (qp); +if (ret && !force) +return ret; + +rdma_restrack_put (&counter->res); +kref_put (&counter->kref, counter_release); + +return 0 ; +} +void rdma_counter_init (struct ib_device *dev) {struct rdma_port_counter *port_counter;
drivers/infiniband/core/device.c +3 -0
@@ -2365,6 +2365,9 @@ void ib_set_device_ops(struct ib_device *dev, const struct ib_device_ops *ops)SET_DEVICE_OP (dev_ops, alloc_xrcd);SET_DEVICE_OP (dev_ops, attach_mcast);SET_DEVICE_OP (dev_ops, check_mr_status); +SET_DEVICE_OP (dev_ops, counter_bind_qp); +SET_DEVICE_OP (dev_ops, counter_dealloc); +SET_DEVICE_OP (dev_ops, counter_unbind_qp);SET_DEVICE_OP (dev_ops, create_ah);SET_DEVICE_OP (dev_ops, create_counters);SET_DEVICE_OP (dev_ops, create_cq);
drivers/infiniband/core/verbs.c +9 -0
@@ -1683,6 +1683,14 @@ static int _ib_modify_qp(struct ib_qp *qp, struct ib_qp_attr *attr, } } +/* +* Bind this qp to a counter automatically based on the rdma counter +* rules. This only set in RST2INIT with port specified +*/ +if (!qp->counter && (attr_mask &IB_QP_PORT ) && + ((attr_mask &IB_QP_STATE ) && attr->qp_state ==IB_QPS_INIT )) +rdma_counter_bind_qp_auto (qp, attr->port_num); + ret =ib_security_modify_qp (qp, attr, attr_mask, udata);if (ret) goto out;
@@ -1878,6 +1886,7 @@ int ib_destroy_qp_user(struct ib_qp *qp, struct ib_udata *udata)if (!qp->uobject)rdma_rw_cleanup_mrs (qp); +rdma_counter_unbind_qp (qp, true);rdma_restrack_del (&qp->res); ret = qp->device->ops.destroy_qp (qp, udata);if (!ret) {
include/rdma/ib_verbs.h +18 -0
@@ -1812,6 +1812,9 @@ struct ib_qp {* Implementation details of the RDMA core, don't use in drivers: */ struct rdma_restrack_entry res; + +/* The counter the qp is bind to */ +struct rdma_counter *counter; };struct ib_dm {
@@ -2589,6 +2592,21 @@ struct ib_device_ops { u8 pdata_len);int (*iw_create_listen)(struct iw_cm_id *cm_id,int backlog);int (*iw_destroy_listen)(struct iw_cm_id *cm_id); +/** +* counter_bind_qp - Bind a QP to a counter. +* @counter - The counter to be bound. If counter->id is zero then +* the driver needs to allocate a new counter and set counter->id +*/ +int (*counter_bind_qp)(struct rdma_counter *counter,struct ib_qp *qp); +/** +* counter_unbind_qp - Unbind the qp from the dynamically-allocated +* counter and bind it onto the default one +*/ +int (*counter_unbind_qp)(struct ib_qp *qp); +/** +* counter_dealloc -De-allocate the hw counter +*/ +int (*counter_dealloc)(struct rdma_counter *counter);DECLARE_RDMA_OBJ_SIZE (ib_ah);DECLARE_RDMA_OBJ_SIZE (ib_cq);
include/rdma/rdma_counter.h +8 -0
@@ -7,11 +7,14 @@#define _RDMA_COUNTER_H_#include <linux/mutex.h> +#include <linux/pid_namespace.h> #include <rdma/ib_verbs.h> #include <rdma/restrack.h> #include <rdma/rdma_netlink.h> +struct ib_qp ; +struct auto_mode_param {int qp_type; };
@@ -31,6 +34,9 @@ struct rdma_counter {struct rdma_restrack_entry res;struct ib_device *device;uint32_t id; +struct kref kref; +struct rdma_counter_mode mode; +struct mutex lock;u8 port; };
@@ -38,5 +44,7 @@ void rdma_counter_init(struct ib_device *dev);void rdma_counter_release (struct ib_device *dev);int rdma_counter_set_auto_mode (struct ib_device *dev,u8 port,bool on,enum rdma_nl_counter_mask mask); +int rdma_counter_bind_qp_auto (struct ib_qp *qp,u8 port); +int rdma_counter_unbind_qp (struct ib_qp *qp,bool force);#endif /* _RDMA_COUNTER_H_ */
Re: [PATCH rdma-next v4 06/17] RDMA/counter: Add "auto" configuration mode support
Quoted 16 lines · Leon Romanovsky
drivers/infiniband/core/counters.c +16
-0+/** +* rdma_counter_bind_qp_auto - Check and bind the QP to a counter base on +* the auto-mode rule +*/ +int rdma_counter_bind_qp_auto (struct ib_qp *qp,u8 port) +{ +struct rdma_port_counter *port_counter; +struct ib_device *dev = qp->device; +struct rdma_counter *counter; +int ret; + +if (!rdma_is_port_valid (dev, port)) +return -EINVAL ; + + port_counter = &dev->port_data[port].port_counter; +if (port_counter->mode.mode !=RDMA_COUNTER_MODE_AUTO )
drivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 245
Quoted 10 lines
drivers/infiniband/core/counters.c +10
-0+return 0 ; + + counter =rdma_get_counter_auto_mode (qp, port); +if (counter) { + ret =__rdma_counter_bind_qp (counter, qp); +if (ret) { +rdma_restrack_put (&counter->res); +return ret; + } +kref_get (&counter->kref);
The counter is left in the xarray while the kref is zero, this kref_get is wrong..
Using two kref like things at the same time is a bad idea, the 'rdma_get_counter_auto_mode' should return the kref held, not the restrack get. The restrack_del doesn't happen as long as the kref is positive, so we don't need the retrack thing here..
Quoted 6 lines
drivers/infiniband/core/counters.c +6
-0+ }else { + counter =rdma_counter_alloc (dev, port,RDMA_COUNTER_MODE_AUTO ); +if (!counter) +return -ENOMEM ; + +auto_mode_init_counter (counter, qp, port_counter->mode.mask);
drivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 261
Quoted 10 lines
drivers/infiniband/core/counters.c +10
-0+ + ret =__rdma_counter_bind_qp (counter, qp); +if (ret) + goto err_bind; + +rdma_counter_res_add (counter, qp); +if (!rdma_restrack_get (&counter->res)) { + ret = -EINVAL ; + goto err_get; + }
and this shouldn't be needed as the kref is inited to 1 by the rdma_counter_alloc..
drivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 272
Quoted 11 lines
drivers/infiniband/core/counters.c +11
-0+ } + +return 0 ; + +err_get: +__rdma_counter_unbind_qp (qp); +__rdma_counter_dealloc (counter); +err_bind: +rdma_counter_free (counter); +return ret; +}
And then all this error unwind and all the twisty __ functions should just be a single kref_put and the release should handle everything.
Jason
Re: [PATCH rdma-next v4 06/17] RDMA/counter: Add "auto" configuration mode support
In reply to Leon Romanovskydrivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 90
Quoted 6 lines · Leon Romanovsky
drivers/infiniband/core/counters.c +6
-0+static void __rdma_counter_dealloc (struct rdma_counter *counter) +{ +mutex_lock (&counter->lock); + counter->device->ops.counter_dealloc (counter); +mutex_unlock (&counter->lock); +}
Does this lock do anything? The kref is 0 at this point, so no other thread can have a pointer to this lock.
drivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 95
Quoted 5 lines
drivers/infiniband/core/counters.c +5
-0+ +static void rdma_counter_dealloc (struct rdma_counter *counter) +{ +if (!counter) +return ;
Counter is never NULL.
Jason
Re: [PATCH rdma-next v4 06/17] RDMA/counter: Add "auto" configuration mode support
Quoted 11 lines · Jason Gunthorpe
drivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 90
Quoted 6 lines · Leon Romanovsky
drivers/infiniband/core/counters.c +6
-0+static void __rdma_counter_dealloc (struct rdma_counter *counter) +{ +mutex_lock (&counter->lock); + counter->device->ops.counter_dealloc (counter); +mutex_unlock (&counter->lock); +}Does this lock do anything? The kref is 0 at this point, so no other thread can have a pointer to this lock.
Yes, it is leftover from atomic_read implementation.
Quoted 8 lines
drivers/infiniband/core/counters.c int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, · line 95
Quoted 6 lines
drivers/infiniband/core/counters.c +5
-0+ +static void rdma_counter_dealloc (struct rdma_counter *counter) +{ +if (!counter) +return ;Counter is never NULL.
Ohh, right, I'll clean some code near rdma_counter_dealloc/__rdma_counter_dealloc.
Thanks
Quoted 2 lines
Jason
PATCH v4 7/17 IB/mlx5: Support set qp counter
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Support bind a qp with counter. If counter is null then bind the qp to the default counter. Different QP state has different operation:
- RESET: Set the counter field so that it will take effective during RST2INIT change;
- RTS: Issue an RTS2RTS change to update the QP counter;
- Other: Set the counter field and mark the counter_pending flag, when QP is moved to RTS state and this flag is set, then issue an RTS2RTS modification to update the counter.
--- drivers/infiniband/hw/mlx5/mlx5_ib.h | 6 +++ drivers/infiniband/hw/mlx5/qp.c | 76 +++++++++++++++++++++++++++- include/linux/mlx5/qp.h | 1 + 3 files changed, 81 insertions(+), 2 deletions(-)
drivers/infiniband/hw/mlx5/mlx5_ib.h +6 -0
@@ -442,6 +442,10 @@ struct mlx5_ib_qp {u32 flags_en;/* storage for qp sub type when core qp type is IB_QPT_DRIVER */ enum ib_qp_type qp_sub_type; +/* A flag to indicate if there's a new counter is configured +* but not take effective +*/ +u32 counter_pending; };struct mlx5_ib_cq_buf {
@@ -1442,4 +1446,6 @@ void mlx5_ib_put_xlt_emergency_page(void);int bfregn_to_uar_index (struct mlx5_ib_dev *dev,struct mlx5_bfreg_info *bfregi,u32 bfregn,bool dyn_bfreg); + +int mlx5_ib_qp_set_counter (struct ib_qp *qp,struct rdma_counter *counter);#endif /* MLX5_IB_H */
drivers/infiniband/hw/mlx5/qp.c +74 -2
116 lines not on this page · raw message
include/linux/mlx5/qp.h +1 -0
@@ -70,6 +70,7 @@ enum mlx5_qp_optpar {MLX5_QP_OPTPAR_CQN_RCV =1 <<19 ,MLX5_QP_OPTPAR_DC_HS =1 <<20 ,MLX5_QP_OPTPAR_DC_KEY =1 <<21 , + MLX5_QP_OPTPAR_COUNTER_SET_ID = 1 << 25, }; enum mlx5_qp_state {
Re: [PATCH mlx5-next v4 07/17] IB/mlx5: Support set qp counter
Quoted 191 lines · Leon Romanovsky
From: Mark Zhang <[email protected]>
Support bind a qp with counter. If counter is null then bind the qp to
the default counter. Different QP state has different operation:
- RESET: Set the counter field so that it will take effective during RST2INIT change;
- RTS: Issue an RTS2RTS change to update the QP counter;
- Other: Set the counter field and mark thecounter_pendingflag, when QP is moved to RTS state and this flag is set, then issue an RTS2RTS modification to update the counter.Signed-off-by Mark Zhang <[email protected]>Reviewed-by Majd Dibbiny <[email protected]>Signed-off-by Leon Romanovsky <[email protected]>--- drivers/infiniband/hw/mlx5/mlx5_ib.h | 6 +++ drivers/infiniband/hw/mlx5/qp.c | 76 +++++++++++++++++++++++++++- include/linux/mlx5/qp.h | 1 + 3 files changed, 81 insertions(+), 2 deletions(-)drivers/infiniband/hw/mlx5/mlx5_ib.h +4
-0@@ -442,6 +442,10 @@ struct mlx5_ib_qp {u32 flags_en;/* storage for qp sub type when core qp type is IB_QPT_DRIVER */ enum ib_qp_type qp_sub_type; +/* A flag to indicate if there's a new counter is configured +* but not take effective +*/ +u32 counter_pending; };struct
mlx5_ib_cq_buf{drivers/infiniband/hw/mlx5/mlx5_ib.h +2
-0@@ -1442,4 +1446,6 @@ void mlx5_ib_put_xlt_emergency_page(void);int bfregn_to_uar_index (struct mlx5_ib_dev *dev,struct mlx5_bfreg_info *bfregi,u32 bfregn,bool dyn_bfreg); + +int mlx5_ib_qp_set_counter (struct ib_qp *qp,struct rdma_counter *counter);#endif /*
MLX5_IB_H*/drivers/infiniband/hw/mlx5/qp.c +30
-0@@ -34,6 +34,7 @@#include <rdma/ib_umem.h> #include <rdma/ib_cache.h> #include <rdma/ib_user_verbs.h> +#include <rdma/rdma_counter.h> #include <linux/mlx5/fs.h> #include "mlx5_ib.h" #include "ib_rep.h" @@ -3386,6 +3387,35 @@ static unsigned int get_tx_affinity(structmlx5_ib_dev *dev, return tx_port_affinity; } +static int __mlx5_ib_qp_set_counter (struct ib_qp *qp, +struct rdma_counter *counter) +{ +struct mlx5_ib_dev *dev =to_mdev (qp->device); +struct mlx5_ib_qp *mqp =to_mqp (qp); +struct mlx5_qp_context context = {}; +struct mlx5_ib_port *mibport =NULL ; +struct mlx5_ib_qp_base *base; +u32 set_id; + +if (!MLX5_CAP_GEN (dev->mdev, rts2rts_qp_counters_set_id)) +return 0 ; + +if (counter) { + set_id = counter->id; + }else { + mibport = &dev->port[mqp->port -1 ]; + set_id = mibport->cnts.set_id; + } + + base = &mqp->trans_qp.base; + context.qp_counter_set_usr_page &=cpu_to_be32 (0xffffff ); + context.qp_counter_set_usr_page |=cpu_to_be32 (set_id <<24 ); +return mlx5_core_qp_modify (dev->mdev, +MLX5_CMD_OP_RTS2RTS_QP , +MLX5_QP_OPTPAR_COUNTER_SET_ID , + &context, &base->mqp); +} +static int __mlx5_ib_modify_qp (struct ib_qp *ibqp, const struct ib_qp_attr *attr, int
attr_mask,drivers/infiniband/hw/mlx5/qp.c +1
-0enum ib_qp_state cur_state,@@ -3439,6 +3469,7 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp, struct mlx5_ib_port *mibport = NULL;enum mlx5_qp_state mlx5_cur, mlx5_new;enum mlx5_qp_optpar optpar; +u32 set_id =0 ;int mlx5_st;int err;drivers/infiniband/hw/mlx5/qp.c +5
-1u16 op;@@ -3601,8 +3632,12 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp, port_num =0 ; mibport = &dev->port[port_num]; +if (ibqp->counter) + set_id = ibqp->counter->id; +else + set_id = mibport->cnts.set_id; context->qp_counter_set_usr_page |= -cpu_to_be32 ((u32)(mibport->cnts.set_id) <<24 ); +cpu_to_be32 (set_id <<24 ); }if (!ibqp->uobject &&
cur_state==IB_QPS_RESET&&new_state==IB_QPS_INIT)drivers/infiniband/hw/mlx5/qp.c +1
-1@@ -3630,7 +3665,7 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp, raw_qp_param.operation = op;if (cur_state ==IB_QPS_RESET && new_state ==IB_QPS_INIT ) { - raw_qp_param.rq_q_ctr_id = mibport- >cnts.set_id; + raw_qp_param.rq_q_ctr_id = set_id;raw_qp_param.set_mask |=
MLX5_RAW_QP_MOD_SET_RQ_Q_CTR_ID;drivers/infiniband/hw/mlx5/qp.c +6
-0}@@ -3707,6 +3742,12 @@ static int __mlx5_ib_modify_qp(struct ib_qp *ibqp, qp->db.db[MLX5_SND_DBR ] =0 ; } +if ((new_state ==IB_QPS_RTS ) && qp->counter_pending) { + err =__mlx5_ib_qp_set_counter (ibqp, ibqp->counter); +if (!err) + qp->counter_pending =0 ; + } + out:kfree (context);drivers/infiniband/hw/mlx5/qp.c +6
-0return err;@@ -6367,3 +6408,34 @@ void mlx5_ib_drain_rq(struct ib_qp *qp)handle_drain_completion (cq, &rdrain, dev); } + +/** +* Bind a qp to a counter. If @counter is NULL then bind the qp to +* the default counter +*/ +int mlx5_ib_qp_set_counter(struct ib_qp *qp, struct rdma_counter*counter)
drivers/infiniband/hw/mlx5/qp.c +25
-0+{ +struct mlx5_ib_qp *mqp =to_mqp (qp); +int err =0 ; + +mutex_lock (&mqp->mutex); +if (mqp->state ==IB_QPS_RESET ) { + qp->counter = counter; + goto out; + } + +if (mqp->state ==IB_QPS_RTS ) { + err =__mlx5_ib_qp_set_counter (qp, counter); +if (!err) + qp->counter = counter; + + goto out; + } + + mqp->counter_pending =1 ; + qp->counter = counter; + +out: +mutex_unlock (&mqp->mutex); +return err; +}include/linux/mlx5/qp.h +0
-0
include/linux/mlx5/qp.h enum mlx5_qp_optpar { · line 75
Quoted 6 lines
include/linux/mlx5/qp.h +1
-0@@ -70,6 +70,7 @@ enum mlx5_qp_optpar {MLX5_QP_OPTPAR_CQN_RCV =1 <<19 ,MLX5_QP_OPTPAR_DC_HS =1 <<20 ,MLX5_QP_OPTPAR_DC_KEY =1 <<21 , + MLX5_QP_OPTPAR_COUNTER_SET_ID = 1 << 25, };
Quoted 4 lines
include/linux/mlx5/qp.h +0
-1enum mlx5_qp_state { --2.20.1
PATCH v4 8/17 IB/mlx5: Add counter set id as a parameter for mlx5_ib_query_q_counters()
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Add counter set id as a parameter so that this API can be used for querying any q counter.
--- drivers/infiniband/hw/mlx5/main.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)
drivers/infiniband/hw/mlx5/main.c +5 -5
@@ -5441,7 +5441,8 @@ static struct rdma_hw_stats *mlx5_ib_alloc_hw_stats(struct ib_device *ibdev,static int mlx5_ib_query_q_counters (struct mlx5_core_dev *mdev,struct mlx5_ib_port *port, -struct rdma_hw_stats *stats) +struct rdma_hw_stats *stats, +u16 set_id) {int outlen =MLX5_ST_SZ_BYTES (query_q_counter_out);void *out;
@@ -5452,9 +5453,7 @@ static int mlx5_ib_query_q_counters(struct mlx5_core_dev *mdev,if (!out)return -ENOMEM ; - ret =mlx5_core_query_q_counter (mdev, - port->cnts.set_id,0 , - out, outlen); + ret =mlx5_core_query_q_counter (mdev, set_id,0 , out, outlen);if (ret) goto free;
@@ -5514,7 +5513,8 @@ static int mlx5_ib_get_hw_stats(struct ib_device *ibdev, port->cnts.num_ext_ppcnt_counters;/* q_counters are per IB device, query the master mdev */ - ret =mlx5_ib_query_q_counters (dev->mdev, port, stats); + ret =mlx5_ib_query_q_counters (dev->mdev, port, stats, + port->cnts.set_id);if (ret)return ret;
PATCH v4 9/17 IB/mlx5: Support statistic q counter configuration
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Add support for ib callbacks counter_bind_qp(), counter_unbind_qp() and counter_dealloc().
--- drivers/infiniband/hw/mlx5/main.c | 44 +++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+)
drivers/infiniband/hw/mlx5/main.c +44 -0
@@ -5550,6 +5550,47 @@ static int mlx5_ib_get_hw_stats(struct ib_device *ibdev,return num_counters; } +static int mlx5_ib_counter_bind_qp (struct rdma_counter *counter, +struct ib_qp *qp) +{ +struct mlx5_ib_dev *dev =to_mdev (qp->device); +u16 cnt_set_id =0 ; +int err; + +if (!counter->id) { + err =mlx5_cmd_alloc_q_counter (dev->mdev, + &cnt_set_id, +MLX5_SHARED_RESOURCE_UID ); +if (err) +return err; + counter->id = cnt_set_id; + } + + err =mlx5_ib_qp_set_counter (qp, counter); +if (err) + goto fail_set_counter; + +return 0 ; + +fail_set_counter: +mlx5_core_dealloc_q_counter (dev->mdev, cnt_set_id); + counter->id =0 ; + +return err; +} + +static int mlx5_ib_counter_unbind_qp (struct ib_qp *qp) +{ +return mlx5_ib_qp_set_counter (qp,NULL ); +} + +static int mlx5_ib_counter_dealloc (struct rdma_counter *counter) +{ +struct mlx5_ib_dev *dev =to_mdev (counter->device); + +return mlx5_core_dealloc_q_counter (dev->mdev, counter->id); +} +static int mlx5_ib_rn_get_params (struct ib_device *device,u8 port_num,enum rdma_netdev_t type,struct rdma_netdev_alloc_params *params)
@@ -6471,6 +6512,9 @@ static void mlx5_ib_stage_odp_cleanup(struct mlx5_ib_dev *dev)static const struct ib_device_ops mlx5_ib_dev_hw_stats_ops = { .alloc_hw_stats = mlx5_ib_alloc_hw_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, };static int mlx5_ib_stage_counters_init (struct mlx5_ib_dev *dev)
PATCH v4 10/17 RDMA/nldev: Allow counter auto mode configration through RDMA netlink
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Provide an option to enable/disable per-port counter auto mode through RDMA netlink. Limit it to users with ADMIN capability only.
--- drivers/infiniband/core/nldev.c | 78 ++++++++++++++++++++++++++++++++ include/uapi/rdma/rdma_netlink.h | 8 ++++ 2 files changed, 86 insertions(+)
drivers/infiniband/core/nldev.c +78 -0
@@ -120,6 +120,9 @@ static const struct nla_policy nldev_policy[RDMA_NLDEV_ATTR_MAX] = { [RDMA_NLDEV_ATTR_DEV_PROTOCOL ] = { .type =NLA_NUL_STRING , .len = RDMA_NLDEV_ATTR_ENTRY_STRLEN }, [RDMA_NLDEV_NET_NS_FD] = { .type = NLA_U32 }, + [RDMA_NLDEV_ATTR_STAT_MODE] = { .type = NLA_U32 }, + [RDMA_NLDEV_ATTR_STAT_RES] = { .type = NLA_U32 }, + [RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK] = { .type = NLA_U32 }, }; static int put_driver_name_print_type(struct sk_buff *msg, const char *name,
@@ -1388,6 +1391,78 @@ static int nldev_set_sys_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh,return err; } +static int nldev_stat_set_doit (struct sk_buff *skb,struct nlmsghdr *nlh, +struct netlink_ext_ack *extack) +{ +struct nlattr *tb[RDMA_NLDEV_ATTR_MAX ]; +u32 index, port, mode, mask =0 ; +struct ib_device *device; +struct sk_buff *msg; +int ret; + + ret =nlmsg_parse (nlh,0 , tb,RDMA_NLDEV_ATTR_MAX -1 , + nldev_policy, extack); +/* Currently only counter for QP is supported */ +if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES ] || + !tb[RDMA_NLDEV_ATTR_DEV_INDEX ] || + !tb[RDMA_NLDEV_ATTR_PORT_INDEX ] || !tb[RDMA_NLDEV_ATTR_STAT_MODE ]) +return -EINVAL ; + +if (nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_RES ]) !=RDMA_NLDEV_ATTR_RES_QP ) +return -EINVAL ; + + index =nla_get_u32 (tb[RDMA_NLDEV_ATTR_DEV_INDEX ]); + device =ib_device_get_by_index (sock_net (skb->sk), index); +if (!device) +return -EINVAL ; + + port =nla_get_u32 (tb[RDMA_NLDEV_ATTR_PORT_INDEX ]); +if (!rdma_is_port_valid (device, port)) { + ret = -EINVAL ; + goto err; + } + + msg =nlmsg_new (NLMSG_DEFAULT_SIZE ,GFP_KERNEL ); +if (!msg) { + ret = -ENOMEM ; + goto err; + } + nlh =nlmsg_put (msg,NETLINK_CB (skb).portid, nlh->nlmsg_seq, +RDMA_NL_GET_TYPE (RDMA_NL_NLDEV , +RDMA_NLDEV_CMD_STAT_SET ), +0 ,0 ); + + mode =nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_MODE ]); +if (mode !=RDMA_COUNTER_MODE_AUTO ) { + ret = -EMSGSIZE ; + goto err_msg; + } + +if (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ]) + mask =nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ]); + + ret =rdma_counter_set_auto_mode (device, port, + mask ? true : false, mask); +if (ret) + goto err_msg; + +if (nla_put_u32 (msg,RDMA_NLDEV_ATTR_STAT_MODE , mode) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK , mask)) { + ret = -EMSGSIZE ; + goto err_msg; + } + +nlmsg_end (msg, nlh); +ib_device_put (device); +return rdma_nl_unicast (msg,NETLINK_CB (skb).portid); + +err_msg: +nlmsg_free (msg); +err: +ib_device_put (device); +return ret; +} +static const struct rdma_nl_cbs nldev_cb_table[RDMA_NLDEV_NUM_OPS ] = { [RDMA_NLDEV_CMD_GET ] = { .doit = nldev_get_doit,
@@ -1438,6 +1513,9 @@ static const struct rdma_nl_cbs nldev_cb_table[RDMA_NLDEV_NUM_OPS] = { }, [RDMA_NLDEV_CMD_SYS_SET ] = { .doit = nldev_set_sys_set_doit, + }, + [RDMA_NLDEV_CMD_STAT_SET ] = { + .doit = nldev_stat_set_doit, .flags =RDMA_NL_ADMIN_PERM , }, };
include/uapi/rdma/rdma_netlink.h +8 -0
@@ -279,6 +279,8 @@ enum rdma_nldev_command {RDMA_NLDEV_CMD_RES_PD_GET ,/* can dump */ +RDMA_NLDEV_CMD_STAT_SET , + RDMA_NLDEV_NUM_OPS };
@@ -490,6 +492,12 @@ enum rdma_nldev_attr {* File descriptor handle of the net namespace object */ RDMA_NLDEV_NET_NS_FD ,/* u32 */ +/* +* Counter-specific attributes. +*/ +RDMA_NLDEV_ATTR_STAT_MODE ,/* u32 */ +RDMA_NLDEV_ATTR_STAT_RES ,/* u32 */ + RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK, /* u32 *//* * Always the end
PATCH v4 11/17 RDMA/netlink: Implement counter dumpit calback
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
This patch adds the ability to return all available counters together with their properties and hwstats.
--- drivers/infiniband/core/counters.c | 26 +++- drivers/infiniband/core/device.c | 2 + drivers/infiniband/core/nldev.c | 213 +++++++++++++++++++++++++++++ include/rdma/ib_verbs.h | 10 ++ include/rdma/rdma_counter.h | 3 + include/uapi/rdma/rdma_netlink.h | 10 +- 6 files changed, 262 insertions(+), 2 deletions(-)
drivers/infiniband/core/counters.c +25 -1
@@ -59,7 +59,7 @@ static struct rdma_counter *rdma_counter_alloc(struct ib_device *dev, u8 port, {struct rdma_counter *counter; -if (!dev->ops.counter_dealloc) +if (!dev->ops.counter_dealloc || !dev->ops.counter_alloc_stats)return NULL ; counter =kzalloc (sizeof (*counter),GFP_KERNEL );
@@ -69,16 +69,25 @@ static struct rdma_counter *rdma_counter_alloc(struct ib_device *dev, u8 port, counter->device = dev; counter->port = port; counter->res.type =RDMA_RESTRACK_COUNTER ; + counter->stats = dev->ops.counter_alloc_stats (counter); +if (!counter->stats) + goto err_stats; + counter->mode.mode = mode;kref_init (&counter->kref);mutex_init (&counter->lock);return counter; + +err_stats: +kfree (counter); +return NULL ; }static void rdma_counter_free (struct rdma_counter *counter) {rdma_restrack_del (&counter->res); +kfree (counter->stats);kfree (counter); }
@@ -302,6 +311,21 @@ int rdma_counter_unbind_qp(struct ib_qp *qp, bool force)return 0 ; } +int rdma_counter_query_stats (struct rdma_counter *counter) +{ +struct ib_device *dev = counter->device; +int ret; + +if (!dev->ops.counter_update_stats) +return -EINVAL ; + +mutex_lock (&counter->lock); + ret = dev->ops.counter_update_stats (counter); +mutex_unlock (&counter->lock); + +return ret; +} +void rdma_counter_init (struct ib_device *dev) {struct rdma_port_counter *port_counter;
drivers/infiniband/core/device.c +2 -0
@@ -2365,9 +2365,11 @@ void ib_set_device_ops(struct ib_device *dev, const struct ib_device_ops *ops)SET_DEVICE_OP (dev_ops, alloc_xrcd);SET_DEVICE_OP (dev_ops, attach_mcast);SET_DEVICE_OP (dev_ops, check_mr_status); +SET_DEVICE_OP (dev_ops, counter_alloc_stats);SET_DEVICE_OP (dev_ops, counter_bind_qp);SET_DEVICE_OP (dev_ops, counter_dealloc);SET_DEVICE_OP (dev_ops, counter_unbind_qp); +SET_DEVICE_OP (dev_ops, counter_update_stats);SET_DEVICE_OP (dev_ops, create_ah);SET_DEVICE_OP (dev_ops, create_counters);SET_DEVICE_OP (dev_ops, create_cq);
drivers/infiniband/core/nldev.c +213 -0
249 lines not on this page · raw message
include/rdma/ib_verbs.h +10 -0
@@ -2607,6 +2607,16 @@ struct ib_device_ops {* counter_dealloc -De-allocate the hw counter */ int (*counter_dealloc)(struct rdma_counter *counter); +/** +* counter_alloc_stats - Allocate a struct rdma_hw_stats and fill in +* the driver initialized data. +*/ +struct rdma_hw_stats *(*counter_alloc_stats)( +struct rdma_counter *counter); +/** +* counter_update_stats - Query the stats value of this counter +*/ +int (*counter_update_stats)(struct rdma_counter *counter);DECLARE_RDMA_OBJ_SIZE (ib_ah);DECLARE_RDMA_OBJ_SIZE (ib_cq);
include/rdma/rdma_counter.h +3 -0
@@ -37,6 +37,7 @@ struct rdma_counter {struct kref kref;struct rdma_counter_mode mode;struct mutex lock; +struct rdma_hw_stats *stats;u8 port; };
@@ -47,4 +48,6 @@ int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port,int rdma_counter_bind_qp_auto (struct ib_qp *qp,u8 port);int rdma_counter_unbind_qp (struct ib_qp *qp,bool force); +int rdma_counter_query_stats (struct rdma_counter *counter); +#endif /* _RDMA_COUNTER_H_ */
include/uapi/rdma/rdma_netlink.h +9 -1
@@ -281,6 +281,8 @@ enum rdma_nldev_command {RDMA_NLDEV_CMD_STAT_SET , +RDMA_NLDEV_CMD_STAT_GET ,/* can dump */ + RDMA_NLDEV_NUM_OPS };
@@ -498,7 +500,13 @@ enum rdma_nldev_attr {RDMA_NLDEV_ATTR_STAT_MODE ,/* u32 */ RDMA_NLDEV_ATTR_STAT_RES ,/* u32 */ RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ,/* u32 */ - +RDMA_NLDEV_ATTR_STAT_COUNTER ,/* nested table */ +RDMA_NLDEV_ATTR_STAT_COUNTER_ENTRY ,/* nested table */ +RDMA_NLDEV_ATTR_STAT_COUNTER_ID ,/* u32 */ +RDMA_NLDEV_ATTR_STAT_HWCOUNTERS ,/* nested table */ +RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY ,/* nested table */ +RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_NAME ,/* string */ +RDMA_NLDEV_ATTR_STAT_HWCOUNTER_ENTRY_VALUE ,/* u64 */ /* * Always the end */
PATCH v4 12/17 IB/mlx5: Add counter_alloc_stats() and counter_update_stats() support
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Add support for ib callback counter_alloc_stats() and counter_update_stats().
--- drivers/infiniband/hw/mlx5/main.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+)
drivers/infiniband/hw/mlx5/main.c +23 -0
@@ -5550,6 +5550,27 @@ static int mlx5_ib_get_hw_stats(struct ib_device *ibdev,return num_counters; } +static struct rdma_hw_stats * +mlx5_ib_counter_alloc_stats (struct rdma_counter *counter) +{ +struct mlx5_ib_dev *dev =to_mdev (counter->device); +struct mlx5_ib_port *port = &dev->port[counter->port -1 ]; + +/* Q counters are in the beginning of all counters */ +return rdma_alloc_hw_stats_struct (port->cnts.names, + port->cnts.num_q_counters, +RDMA_HW_STATS_DEFAULT_LIFESPAN ); +} + +static int mlx5_ib_counter_update_stats (struct rdma_counter *counter) +{ +struct mlx5_ib_dev *dev =to_mdev (counter->device); +struct mlx5_ib_port *port = &dev->port[counter->port -1 ]; + +return mlx5_ib_query_q_counters (dev->mdev, port, + counter->stats, counter->id); +} +static int mlx5_ib_counter_bind_qp (struct rdma_counter *counter,struct ib_qp *qp) {
@@ -6515,6 +6536,8 @@ static const struct ib_device_ops mlx5_ib_dev_hw_stats_ops = { .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 int mlx5_ib_stage_counters_init (struct mlx5_ib_dev *dev)
PATCH v4 13/17 RDMA/core: Get sum value of all counters when perform a sysfs stat read
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Since a QP can only be bound to one counter, then if it is bound to a separate counter, for backward compatibility purpose, the statistic value must be:
* stat of default counter
+ stat of all running allocated counters
+ stat of all deallocated counters (history stats)
--- drivers/infiniband/core/counters.c | 89 ++++++++++++++++++++++++++++++ drivers/infiniband/core/sysfs.c | 10 +++- include/rdma/rdma_counter.h | 2 + 3 files changed, 98 insertions(+), 3 deletions(-)
drivers/infiniband/core/counters.c +89 -0
@@ -174,6 +174,20 @@ static int __rdma_counter_unbind_qp(struct ib_qp *qp)return ret; } +static void counter_history_stat_update (const struct rdma_counter *counter) +{ +struct ib_device *dev = counter->device; +struct rdma_port_counter *port_counter; +int i; + + port_counter = &dev->port_data[counter->port].port_counter; +if (!port_counter->hstats) +return ; + +for (i =0 ; i < counter->stats->num_counters; i++) + port_counter->hstats->value[i] += counter->stats->value[i]; +} +/** * rdma_get_counter_auto_mode - Find the counter that @qp should be bound * with in auto mode
@@ -285,6 +299,7 @@ static void counter_release(struct kref *kref)struct rdma_counter *counter; counter = container_of(kref, struct rdma_counter, kref); +counter_history_stat_update (counter);rdma_counter_dealloc (counter); }
@@ -326,6 +341,55 @@ int rdma_counter_query_stats(struct rdma_counter *counter)return ret; } +static u64 get_running_counters_hwstat_sum (struct ib_device *dev, +u8 port,u32 index) +{ +struct rdma_restrack_entry *res; +struct rdma_restrack_root *rt; +struct rdma_counter *counter; +unsigned long id =0 ; +u64 sum =0 ; + + rt = &dev->res[RDMA_RESTRACK_COUNTER ]; +xa_lock (&rt->xa); +xa_for_each (&rt->xa, id, res) { +if (!rdma_restrack_get (res)) +continue ; + +xa_unlock (&rt->xa); + + counter = container_of(res, struct rdma_counter, res); +if ((counter->device != dev) || (counter->port != port) || +rdma_counter_query_stats (counter)) + goto next; + + sum += counter->stats->value[index]; + +next: +xa_lock (&rt->xa); +rdma_restrack_put (res); + } + +xa_unlock (&rt->xa); +return sum; +} + +/** +* rdma_counter_get_hwstat_value() - Get the sum value of all counters on a +* specific port, including the running ones and history data +*/ +u64 rdma_counter_get_hwstat_value (struct ib_device *dev,u8 port,u32 index) +{ +struct rdma_port_counter *port_counter; +u64 sum; + + port_counter = &dev->port_data[port].port_counter; + sum =get_running_counters_hwstat_sum (dev, port, index); + sum += port_counter->hstats->value[index]; + +return sum; +} +void rdma_counter_init (struct ib_device *dev) {struct rdma_port_counter *port_counter;
@@ -338,9 +402,34 @@ void rdma_counter_init(struct ib_device *dev) port_counter = &dev->port_data[port].port_counter; port_counter->mode.mode =RDMA_COUNTER_MODE_NONE ;mutex_init (&port_counter->lock); + + port_counter->hstats = dev->ops.alloc_hw_stats (dev, port); +if (!port_counter->hstats) + goto fail; } + +return ; + +fail: +rdma_for_each_port (dev, port) { + port_counter = &dev->port_data[port].port_counter; +kfree (port_counter->hstats); + port_counter->hstats =NULL ; + } + +return ; }void rdma_counter_release (struct ib_device *dev) { +struct rdma_port_counter *port_counter; +u32 port; + +if (!dev->ops.alloc_hw_stats) +return ; + +rdma_for_each_port (dev, port) { + port_counter = &dev->port_data[port].port_counter; +kfree (port_counter->hstats); + } }
drivers/infiniband/core/sysfs.c +7 -3
@@ -43,6 +43,7 @@#include <rdma/ib_mad.h> #include <rdma/ib_pma.h> #include <rdma/ib_cache.h> +#include <rdma/rdma_counter.h> struct ib_port ;
@@ -800,9 +801,12 @@ static int update_hw_stats(struct ib_device *dev, struct rdma_hw_stats *stats,return 0 ; } -static ssize_t print_hw_stat (struct rdma_hw_stats *stats,int index,char *buf) +static ssize_t print_hw_stat (struct ib_device *dev,int port_num, +struct rdma_hw_stats *stats,int index,char *buf) { -return sprintf (buf,"%llu\n" , stats->value[index]); +u64 v =rdma_counter_get_hwstat_value (dev, port_num, index); + +return sprintf (buf,"%llu\n" , stats->value[index] + v); } static ssize_t show_hw_stats(struct kobject *kobj, struct attribute *attr,
@@ -828,7 +832,7 @@ static ssize_t show_hw_stats(struct kobject *kobj, struct attribute *attr, ret =update_hw_stats (dev, stats, hsa->port_num, hsa->index);if (ret) goto unlock; - ret =print_hw_stat (stats, hsa->index, buf); + ret =print_hw_stat (dev, hsa->port_num, stats, hsa->index, buf); unlock:mutex_unlock (&stats->lock);
include/rdma/rdma_counter.h +2 -0
@@ -27,6 +27,7 @@ struct rdma_counter_mode {struct rdma_port_counter {struct rdma_counter_mode mode; +struct rdma_hw_stats *hstats;struct mutex lock; };
@@ -49,5 +50,6 @@ int rdma_counter_bind_qp_auto(struct ib_qp *qp, u8 port);int rdma_counter_unbind_qp (struct ib_qp *qp,bool force);int rdma_counter_query_stats (struct rdma_counter *counter); +u64 rdma_counter_get_hwstat_value (struct ib_device *dev,u8 port,u32 index);#endif /* _RDMA_COUNTER_H_ */
PATCH v4 14/17 RDMA/counter: Allow manual mode configuration support
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
In manual mode a QP is bound to a counter manually. If counter is not specified then a new one will be allocated.
Manually mode is enabled when user binds a QP, and disabled when the last manually bound QP is unbound.
When auto-mode is turned off and there are counters left, manual mode is enabled so that the user is able to access these counters.
--- drivers/infiniband/core/counters.c | 221 ++++++++++++++++++++++++++++- include/rdma/rdma_counter.h | 7 + include/uapi/rdma/rdma_netlink.h | 6 + 3 files changed, 231 insertions(+), 3 deletions(-)
drivers/infiniband/core/counters.c +218 -3
@@ -27,7 +27,9 @@ static int __counter_set_mode(struct rdma_counter_mode *curr,/** * rdma_counter_set_auto_mode() - Turn on/off per-port auto mode * -* When @on is true, the @mask must be set +* When @on is true, the @mask must be set; When @on is false, it goes +* into manual mode if there's any counter, so that the user is able to +* manually access them. */ int rdma_counter_set_auto_mode (struct ib_device *dev,u8 port,bool on,enum rdma_nl_counter_mask mask)
@@ -45,8 +47,13 @@ int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port, ret = -EINVAL ; goto out; } - ret =__counter_set_mode (&port_counter->mode, -RDMA_COUNTER_MODE_NONE ,0 ); + +if (port_counter->num_counters) + ret =__counter_set_mode (&port_counter->mode, +RDMA_COUNTER_MODE_MANUAL ,0 ); +else + ret =__counter_set_mode (&port_counter->mode, +RDMA_COUNTER_MODE_NONE ,0 ); } out:
@@ -57,7 +64,9 @@ int rdma_counter_set_auto_mode(struct ib_device *dev, u8 port,static struct rdma_counter *rdma_counter_alloc (struct ib_device *dev,u8 port,enum rdma_nl_counter_mode mode) { +struct rdma_port_counter *port_counter;struct rdma_counter *counter; +int ret;if (!dev->ops.counter_dealloc || !dev->ops.counter_alloc_stats)return NULL ;
@@ -73,12 +82,27 @@ static struct rdma_counter *rdma_counter_alloc(struct ib_device *dev, u8 port,if (!counter->stats) goto err_stats; + port_counter = &dev->port_data[port].port_counter; +mutex_lock (&port_counter->lock); +if (mode ==RDMA_COUNTER_MODE_MANUAL ) { + ret =__counter_set_mode (&port_counter->mode, +RDMA_COUNTER_MODE_MANUAL ,0 ); +if (ret) + goto err_mode; + } + + port_counter->num_counters++; +mutex_unlock (&port_counter->lock); + counter->mode.mode = mode;kref_init (&counter->kref);mutex_init (&counter->lock);return counter; +err_mode: +mutex_unlock (&port_counter->lock); +kfree (counter->stats); err_stats:kfree (counter);return NULL ;
@@ -86,6 +110,18 @@ static struct rdma_counter *rdma_counter_alloc(struct ib_device *dev, u8 port,static void rdma_counter_free (struct rdma_counter *counter) { +struct rdma_port_counter *port_counter; + + port_counter = &counter->device->port_data[counter->port].port_counter; +mutex_lock (&port_counter->lock); + port_counter->num_counters--; +if (!port_counter->num_counters && + (port_counter->mode.mode ==RDMA_COUNTER_MODE_MANUAL )) +__counter_set_mode (&port_counter->mode,RDMA_COUNTER_MODE_NONE , +0 ); + +mutex_unlock (&port_counter->lock); +rdma_restrack_del (&counter->res);kfree (counter->stats);kfree (counter);
@@ -390,6 +426,185 @@ u64 rdma_counter_get_hwstat_value(struct ib_device *dev, u8 port, u32 index)return sum; } +static struct ib_qp *rdma_counter_get_qp (struct ib_device *dev,u32 qp_num) +{ +struct rdma_restrack_entry *res =NULL ; +struct ib_qp *qp =NULL ; + + res =rdma_restrack_get_byid (dev,RDMA_RESTRACK_QP , qp_num); +if (IS_ERR (res)) +return NULL ; + +if (!rdma_is_visible_in_pid_ns (res)) + goto err; + + qp = container_of(res, struct ib_qp, res); +if (qp->qp_type ==IB_QPT_RAW_PACKET && !capable (CAP_NET_RAW )) + goto err; + +return qp; + +err: +rdma_restrack_put (&qp->res); +return NULL ; +} + +static int rdma_counter_bind_qp_manual (struct rdma_counter *counter, +struct ib_qp *qp) +{ +if ((counter->device != qp->device) || (counter->port != qp->port)) +return -EINVAL ; + +return __rdma_counter_bind_qp (counter, qp); +} + +static struct rdma_counter *rdma_get_counter_by_id (struct ib_device *dev, +u32 counter_id) +{ +struct rdma_restrack_entry *res; + + res =rdma_restrack_get_byid (dev,RDMA_RESTRACK_COUNTER , counter_id); +if (IS_ERR (res)) +return NULL ; + +if (!rdma_is_visible_in_pid_ns (res)) { +rdma_restrack_put (res); +return NULL ; + } + + return container_of(res, struct rdma_counter, res); +} + +/** +* rdma_counter_bind_qpn() - Bind QP @qp_num to counter @counter_id +*/ +int rdma_counter_bind_qpn (struct ib_device *dev,u8 port, +u32 qp_num,u32 counter_id) +{ +struct rdma_counter *counter; +struct ib_qp *qp; +int ret; + + qp =rdma_counter_get_qp (dev, qp_num); +if (!qp) +return -ENOENT ; + + counter =rdma_get_counter_by_id (dev, counter_id); +if (!counter) { + ret = -ENOENT ; + goto err; + } + +if (counter->res.task != qp->res.task) { + ret = -EINVAL ; + goto err_task; + } + + ret =rdma_counter_bind_qp_manual (counter, qp); +if (ret) + goto err_task; + +kref_get (&counter->kref); + +rdma_restrack_put (&qp->res); +return 0 ; + +err_task: +rdma_restrack_put (&counter->res); +err: +rdma_restrack_put (&qp->res); +return ret; +} + +/** +* rdma_counter_bind_qpn_alloc() - Alloc a counter and bind QP @qp_num to it +* The id of new counter is returned in @counter_id +*/ +int rdma_counter_bind_qpn_alloc (struct ib_device *dev,u8 port, +u32 qp_num,u32 *counter_id) +{ +struct rdma_counter *counter; +struct ib_qp *qp; +int ret; + +if (!rdma_is_port_valid (dev, port)) +return -EINVAL ; + + qp =rdma_counter_get_qp (dev, qp_num); +if (!qp) +return -ENOENT ; + +if (rdma_is_port_valid (dev, qp->port) && (qp->port != port)) { + ret = -EINVAL ; + goto err; + } + + counter =rdma_counter_alloc (dev, port,RDMA_COUNTER_MODE_MANUAL ); +if (!counter) { + ret = -ENOMEM ; + goto err; + } + + ret =rdma_counter_bind_qp_manual (counter, qp); +if (ret) + goto err_bind; + +if (counter_id) + *counter_id = counter->id; + +rdma_counter_res_add (counter, qp); + +if (!rdma_restrack_get (&counter->res)) { +rdma_counter_unbind_qp (qp, false); + ret = -EINVAL ; + } + +rdma_restrack_put (&qp->res); +return ret; + +err_bind: +rdma_counter_free (counter); +err: +rdma_restrack_put (&qp->res); +return ret; +} + +/** +* rdma_counter_unbind_qpn() - Unbind QP @qp_num from a counter +*/ +int rdma_counter_unbind_qpn (struct ib_device *dev,u8 port, +u32 qp_num,u32 counter_id) +{ +struct rdma_port_counter *port_counter; +struct ib_qp *qp; +int ret; + +if (!rdma_is_port_valid (dev, port)) +return -EINVAL ; + + qp =rdma_counter_get_qp (dev, qp_num); +if (!qp) +return -ENOENT ; + +if (rdma_is_port_valid (dev, qp->port) && (qp->port != port)) { + ret = -EINVAL ; + goto out; + } + + port_counter = &dev->port_data[port].port_counter; +if (!qp->counter || qp->counter->id != counter_id || + port_counter->mode.mode !=RDMA_COUNTER_MODE_MANUAL ) { + ret = -EINVAL ; + goto out; + } + + ret =rdma_counter_unbind_qp (qp, false); + +out: +rdma_restrack_put (&qp->res); +return ret; +} +void rdma_counter_init (struct ib_device *dev) {struct rdma_port_counter *port_counter;
include/rdma/rdma_counter.h +7 -0
@@ -28,6 +28,7 @@ struct rdma_counter_mode {struct rdma_port_counter {struct rdma_counter_mode mode;struct rdma_hw_stats *hstats; +unsigned int num_counters;struct mutex lock; };
@@ -51,5 +52,11 @@ int rdma_counter_unbind_qp(struct ib_qp *qp, bool force);int rdma_counter_query_stats (struct rdma_counter *counter);u64 rdma_counter_get_hwstat_value (struct ib_device *dev,u8 port,u32 index); +int rdma_counter_bind_qpn (struct ib_device *dev,u8 port, +u32 qp_num,u32 counter_id); +int rdma_counter_bind_qpn_alloc (struct ib_device *dev,u8 port, +u32 qp_num,u32 *counter_id); +int rdma_counter_unbind_qpn (struct ib_device *dev,u8 port, +u32 qp_num,u32 counter_id);#endif /* _RDMA_COUNTER_H_ */
include/uapi/rdma/rdma_netlink.h +6 -0
@@ -525,6 +525,12 @@ enum rdma_nl_counter_mode {*/ RDMA_COUNTER_MODE_AUTO , +/* +* Which qp are bound with which counter is explicitly specified +* by the user +*/ + RDMA_COUNTER_MODE_MANUAL, +/* * Always the end */
PATCH v4 15/17 RDMA/nldev: Allow counter manual mode configration through RDMA netlink
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Provide an option to allow users to manually bind a qp with a counter through RDMA netlink. Limit it to users with ADMIN capability only.
--- drivers/infiniband/core/nldev.c | 111 +++++++++++++++++++++++++++---- include/rdma/rdma_counter.h | 3 + include/uapi/rdma/rdma_netlink.h | 2 + 3 files changed, 103 insertions(+), 13 deletions(-)
drivers/infiniband/core/nldev.c +98 -13
@@ -1555,8 +1555,8 @@ static int nldev_set_sys_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh,static int nldev_stat_set_doit (struct sk_buff *skb,struct nlmsghdr *nlh,struct netlink_ext_ack *extack) { +u32 index, port, mode, mask =0 , qpn, cntn =0 ;struct nlattr *tb[RDMA_NLDEV_ATTR_MAX ]; -u32 index, port, mode, mask =0 ;struct ib_device *device;struct sk_buff *msg;int ret;
@@ -1594,30 +1594,111 @@ static int nldev_stat_set_doit(struct sk_buff *skb, struct nlmsghdr *nlh, 0, 0); mode =nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_MODE ]); -if (mode !=RDMA_COUNTER_MODE_AUTO ) { - ret = -EMSGSIZE ; - goto err_msg; +if (mode ==RDMA_COUNTER_MODE_AUTO ) { +if (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ]) + mask =nla_get_u32 ( + tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ]); + + ret =rdma_counter_set_auto_mode (device, port, + mask ? true : false, mask); +if (ret) + goto err_msg; + }else { + qpn =nla_get_u32 (tb[RDMA_NLDEV_ATTR_RES_LQPN ]); +if (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID ]) { + cntn =nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID ]); + ret =rdma_counter_bind_qpn (device, port, qpn, cntn); + }else { + ret =rdma_counter_bind_qpn_alloc (device, port, + qpn, &cntn); + } +if (ret) + goto err_msg; + +if (fill_nldev_handle (msg, device) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_PORT_INDEX , port) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_STAT_COUNTER_ID , cntn) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_RES_LQPN , qpn)) { + ret = -EMSGSIZE ; + goto err_fill; + } + } + +nlmsg_end (msg, nlh); +ib_device_put (device); +return rdma_nl_unicast (msg,NETLINK_CB (skb).portid); + +err_fill: +rdma_counter_unbind_qpn (device, port, qpn, cntn); +err_msg: +nlmsg_free (msg); +err: +ib_device_put (device); +return ret; +} + +static int nldev_stat_del_doit (struct sk_buff *skb,struct nlmsghdr *nlh, +struct netlink_ext_ack *extack) +{ +struct nlattr *tb[RDMA_NLDEV_ATTR_MAX ]; +struct ib_device *device; +struct sk_buff *msg; +u32 index, port, qpn, cntn; +int ret; + + ret =nlmsg_parse (nlh,0 , tb,RDMA_NLDEV_ATTR_MAX -1 , + nldev_policy, extack); +if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES ] || + !tb[RDMA_NLDEV_ATTR_DEV_INDEX ] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX ] || + !tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID ] || + !tb[RDMA_NLDEV_ATTR_RES_LQPN ]) +return -EINVAL ; + +if (nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_RES ]) !=RDMA_NLDEV_ATTR_RES_QP ) +return -EINVAL ; + + index =nla_get_u32 (tb[RDMA_NLDEV_ATTR_DEV_INDEX ]); + device =ib_device_get_by_index (sock_net (skb->sk), index); +if (!device) +return -EINVAL ; + + port =nla_get_u32 (tb[RDMA_NLDEV_ATTR_PORT_INDEX ]); +if (!rdma_is_port_valid (device, port)) { + ret = -EINVAL ; + goto err; } -if (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ]) - mask =nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK ]); + msg =nlmsg_new (NLMSG_DEFAULT_SIZE ,GFP_KERNEL ); +if (!msg) { + ret = -ENOMEM ; + goto err; + } + nlh =nlmsg_put (msg,NETLINK_CB (skb).portid, nlh->nlmsg_seq, +RDMA_NL_GET_TYPE (RDMA_NL_NLDEV , +RDMA_NLDEV_CMD_STAT_SET ), +0 ,0 ); - ret =rdma_counter_set_auto_mode (device, port, - mask ? true : false, mask); + cntn =nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_COUNTER_ID ]); + qpn =nla_get_u32 (tb[RDMA_NLDEV_ATTR_RES_LQPN ]); + ret =rdma_counter_unbind_qpn (device, port, qpn, cntn);if (ret) - goto err_msg; + goto err_unbind; -if (nla_put_u32 (msg,RDMA_NLDEV_ATTR_STAT_MODE , mode) || -nla_put_u32 (msg,RDMA_NLDEV_ATTR_STAT_AUTO_MODE_MASK , mask)) { +if (fill_nldev_handle (msg, device) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_PORT_INDEX , port) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_STAT_COUNTER_ID , cntn) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_RES_LQPN , qpn)) { ret = -EMSGSIZE ; - goto err_msg; + goto err_fill; }nlmsg_end (msg, nlh);ib_device_put (device);return rdma_nl_unicast (msg,NETLINK_CB (skb).portid); -err_msg: +err_fill: +rdma_counter_bind_qpn (device, port, qpn, cntn); +err_unbind:nlmsg_free (msg); err:ib_device_put (device);
@@ -1731,6 +1812,10 @@ static const struct rdma_nl_cbs nldev_cb_table[RDMA_NLDEV_NUM_OPS] = { .doit = nldev_stat_get_doit, .dump = nldev_stat_get_dumpit, }, + [RDMA_NLDEV_CMD_STAT_DEL] = { + .doit = nldev_stat_del_doit, + .flags = RDMA_NL_ADMIN_PERM, + }, };void __init nldev_init (void )
include/rdma/rdma_counter.h +3 -0
@@ -58,5 +58,8 @@ int rdma_counter_bind_qpn_alloc(struct ib_device *dev, u8 port, u32 qp_num, u32 *counter_id);int rdma_counter_unbind_qpn (struct ib_device *dev,u8 port,u32 qp_num,u32 counter_id); +int rdma_counter_get_mode (struct ib_device *dev,u8 port, +enum rdma_nl_counter_mode *mode, +enum rdma_nl_counter_mask *mask);#endif /* _RDMA_COUNTER_H_ */
include/uapi/rdma/rdma_netlink.h +2 -0
@@ -283,6 +283,8 @@ enum rdma_nldev_command {RDMA_NLDEV_CMD_STAT_GET ,/* can dump */ +RDMA_NLDEV_CMD_STAT_DEL , + RDMA_NLDEV_NUM_OPS };
PATCH v4 16/17 RDMA/nldev: Allow get counter mode through RDMA netlink
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
Provide an option to get current counter mode through RDMA netlink.
--- drivers/infiniband/core/counters.c | 13 ++++++ drivers/infiniband/core/nldev.c | 66 +++++++++++++++++++++++++++++- 2 files changed, 78 insertions(+), 1 deletion(-)
drivers/infiniband/core/counters.c +13 -0
@@ -605,6 +605,19 @@ int rdma_counter_unbind_qpn(struct ib_device *dev, u8 port,return ret; } +int rdma_counter_get_mode (struct ib_device *dev,u8 port, +enum rdma_nl_counter_mode *mode, +enum rdma_nl_counter_mask *mask) +{ +struct rdma_port_counter *port_counter; + + port_counter = &dev->port_data[port].port_counter; + *mode = port_counter->mode.mode; + *mask = port_counter->mode.mask; + +return 0 ; +} +void rdma_counter_init (struct ib_device *dev) {struct rdma_port_counter *port_counter;
drivers/infiniband/core/nldev.c +65 -1
78 lines not on this page · raw message
PATCH v4 17/17 RDMA/nldev: Allow get default counter statistics through RDMA netlink
In reply to Leon RomanovskyFrom: Mark Zhang <[email protected]>
This patch adds the ability to return the hwstats of per-port default counters (which can also be queried through sysfs nodes).
--- drivers/infiniband/core/nldev.c | 98 ++++++++++++++++++++++++++++++++- drivers/infiniband/core/sysfs.c | 6 ++ include/rdma/ib_verbs.h | 1 + 3 files changed, 104 insertions(+), 1 deletion(-)
drivers/infiniband/core/nldev.c +97 -1
@@ -1705,6 +1705,99 @@ static int nldev_stat_del_doit(struct sk_buff *skb, struct nlmsghdr *nlh,return ret; } +static int stat_get_doit_default_counter (struct sk_buff *skb, +struct nlmsghdr *nlh, +struct netlink_ext_ack *extack, +struct nlattr *tb[]) +{ +struct rdma_hw_stats *stats; +struct nlattr *table_attr; +struct ib_device *device; +int ret, num_cnts, i; +struct sk_buff *msg; +u32 index, port; +u64 v; + +if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX ] || !tb[RDMA_NLDEV_ATTR_PORT_INDEX ]) +return -EINVAL ; + + index =nla_get_u32 (tb[RDMA_NLDEV_ATTR_DEV_INDEX ]); + device =ib_device_get_by_index (sock_net (skb->sk), index); +if (!device) +return -EINVAL ; + +if (!device->ops.alloc_hw_stats || !device->ops.get_hw_stats) { + ret = -EINVAL ; + goto err; + } + + port =nla_get_u32 (tb[RDMA_NLDEV_ATTR_PORT_INDEX ]); +if (!rdma_is_port_valid (device, port)) { + ret = -EINVAL ; + goto err; + } + + msg =nlmsg_new (NLMSG_DEFAULT_SIZE ,GFP_KERNEL ); +if (!msg) { + ret = -ENOMEM ; + goto err; + } + + nlh =nlmsg_put (msg,NETLINK_CB (skb).portid, nlh->nlmsg_seq, +RDMA_NL_GET_TYPE (RDMA_NL_NLDEV , +RDMA_NLDEV_CMD_STAT_GET ), +0 ,0 ); + +if (fill_nldev_handle (msg, device) || +nla_put_u32 (msg,RDMA_NLDEV_ATTR_PORT_INDEX , port)) { + ret = -EMSGSIZE ; + goto err_msg; + } + + stats = device->port_data ? device->port_data[port].hw_stats :NULL ; +if (stats ==NULL ) { + ret = -EINVAL ; + goto err_msg; + } +mutex_lock (&stats->lock); + + num_cnts = device->ops.get_hw_stats (device, stats, port,0 ); +if (num_cnts <0 ) { + ret = -EINVAL ; + goto err_stats; + } + + table_attr =nla_nest_start (msg,RDMA_NLDEV_ATTR_STAT_HWCOUNTERS ); +if (!table_attr) { + ret = -EMSGSIZE ; + goto err_stats; + } +for (i =0 ; i < num_cnts; i++) { + v = stats->value[i] + +rdma_counter_get_hwstat_value (device, port, i); +if (fill_stat_hwcounter_entry (msg, stats->names[i], v)) { + ret = -EMSGSIZE ; + goto err_table; + } + } +nla_nest_end (msg, table_attr); + +mutex_unlock (&stats->lock); +nlmsg_end (msg, nlh); +ib_device_put (device); +return rdma_nl_unicast (msg,NETLINK_CB (skb).portid); + +err_table: +nla_nest_cancel (msg, table_attr); +err_stats: +mutex_unlock (&stats->lock); +err_msg: +nlmsg_free (msg); +err: +ib_device_put (device); +return ret; +} +static int stat_get_doit_qp (struct sk_buff *skb,struct nlmsghdr *nlh,struct netlink_ext_ack *extack,struct nlattr *tb[])
@@ -1777,9 +1870,12 @@ static int nldev_stat_get_doit(struct sk_buff *skb, struct nlmsghdr *nlh, ret =nlmsg_parse (nlh,0 , tb,RDMA_NLDEV_ATTR_MAX -1 , nldev_policy, extack); -if (ret || !tb[RDMA_NLDEV_ATTR_STAT_RES ]) +if (ret)return -EINVAL ; +if (!tb[RDMA_NLDEV_ATTR_STAT_RES ]) +return stat_get_doit_default_counter (skb, nlh, extack, tb); +switch (nla_get_u32 (tb[RDMA_NLDEV_ATTR_STAT_RES ])) {case RDMA_NLDEV_ATTR_RES_QP : ret =stat_get_doit_qp (skb, nlh, extack, tb);
drivers/infiniband/core/sysfs.c +6 -0
@@ -1003,6 +1003,8 @@ static void setup_hw_stats(struct ib_device *device, struct ib_port *port, goto err; port->hw_stats_ag = hsag; port->hw_stats = stats; +if (device->port_data) + device->port_data[port_num].hw_stats = stats; }else {struct kobject *kobj = &device->dev.kobj; ret =sysfs_create_group (kobj, hsag);
@@ -1293,6 +1295,8 @@ const struct attribute_group ib_dev_attr_group = {void ib_free_port_attrs (struct ib_core_device *coredev) { +struct ib_device *device =rdma_device_to_ibdev (&coredev->dev); +bool is_full_dev = &device->coredev == coredev;struct kobject *p, *t;list_for_each_entry_safe (p, t, &coredev->port_list, entry) {
@@ -1302,6 +1306,8 @@ void ib_free_port_attrs(struct ib_core_device *coredev)if (port->hw_stats_ag)free_hsag (&port->kobj, port->hw_stats_ag);kfree (port->hw_stats); +if (device->port_data && is_full_dev) + device->port_data[port->port_num].hw_stats =NULL ;if (port->pma_table)sysfs_remove_group (p, port->pma_table);
include/rdma/ib_verbs.h +1 -0
@@ -2237,6 +2237,7 @@ struct ib_port_data {struct net_device __rcu *netdev;struct hlist_node ndev_hash_link;struct rdma_port_counter port_counter; +struct rdma_hw_stats *hw_stats; };/* rdma netdev type - specifies protocol type */