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

Commit 0f45e69d authored by Jason Gunthorpe's avatar Jason Gunthorpe
Browse files

Merge tag 'verbs_flow_counters' of... 

Merge tag 'verbs_flow_counters' of git://git.kernel.org/pub/scm/linux/kernel/git/leon/linux-rdma.git into for-next

Pull verbs counters series from Leon Romanovsky:

====================
Verbs flow counters support

This series comes to allow user space applications to monitor real time
traffic activity and events of the verbs objects it manages, e.g.: ibv_qp,
ibv_wq, ibv_flow.

The API enables generic counters creation and define mapping to
association with a verbs object, the current mlx5 driver is using this API
for flow counters.

With this API, an application can monitor the entire life cycle of object
activity, defined here as a static counters attachment.  This API also
allows dynamic counters monitoring of measurement points for a partial
period in the verbs object life cycle.

In addition it presents the implementation of the generic counters
interface.

This will be achieved by extending flow creation by adding a new flow
count specification type which allows the user to associate a previously
created flow counters using the generic verbs counters interface to the
created flow, once associated the user could read statistics by using the
read function of the generic counters interface.

The API includes:
1. create and destroyed API of a new counters objects
2. read the counters values from HW

Note:
Attaching API to allow application to define the measurement points per
objects is a user space only API and this data is passed to kernel when
the counted object (e.g. flow) is created with the counters object.
===================

* tag 'verbs_flow_counters':
  IB/mlx5: Add counters read support
  IB/mlx5: Add flow counters read support
  IB/mlx5: Add flow counters binding support
  IB/mlx5: Add counters create and destroy support
  IB/uverbs: Add support for flow counters
  IB/core: Add support for flow counters
  IB/core: Support passing uhw for create_flow
  IB/uverbs: Add read counters support
  IB/core: Introduce counters read verb
  IB/uverbs: Add create/destroy counters support
  IB/core: Introduce counters object and its create/destroy
  IB/uverbs: Add an ib_uobject getter to ioctl() infrastructure
  net/mlx5: Export flow counter related API
  net/mlx5: Use flow counter pointer as input to the query function
parents 27d036e3 1a1e03dc

drivers/infiniband/core/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -37,4 +37,4 @@ ib_uverbs-y := uverbs_main.o uverbs_cmd.o uverbs_marshall.o \ 
				rdma_core.o uverbs_std_types.o uverbs_ioctl.o \

				uverbs_ioctl_merge.o uverbs_std_types_cq.o \

				uverbs_std_types_flow_action.o uverbs_std_types_dm.o \

				uverbs_std_types_mr.o
 
				uverbs_std_types_mr.o uverbs_std_types_counters.o

drivers/infiniband/core/uverbs.h

+2 −0
Original line number Diff line number Diff line
@@ -263,6 +263,7 @@ struct ib_uverbs_flow_spec { 
		struct ib_uverbs_flow_spec_action_tag	flow_tag;

		struct ib_uverbs_flow_spec_action_drop	drop;

		struct ib_uverbs_flow_spec_action_handle action;

		struct ib_uverbs_flow_spec_action_count flow_count;

	};

};
@@ -287,6 +288,7 @@ extern const struct uverbs_object_def UVERBS_OBJECT(UVERBS_OBJECT_RWQ_IND_TBL); 
extern const struct uverbs_object_def UVERBS_OBJECT(UVERBS_OBJECT_XRCD);

extern const struct uverbs_object_def UVERBS_OBJECT(UVERBS_OBJECT_FLOW_ACTION);

extern const struct uverbs_object_def UVERBS_OBJECT(UVERBS_OBJECT_DM);

extern const struct uverbs_object_def UVERBS_OBJECT(UVERBS_OBJECT_COUNTERS);



#define IB_UVERBS_DECLARE_CMD(name)					\

	ssize_t ib_uverbs_##name(struct ib_uverbs_file *file,		\

drivers/infiniband/core/uverbs_cmd.c

+76 −12
Original line number Diff line number Diff line
@@ -2748,43 +2748,82 @@ ssize_t ib_uverbs_detach_mcast(struct ib_uverbs_file *file, 
struct ib_uflow_resources {

	size_t			max;

	size_t			num;

	struct ib_flow_action	*collection[0];

	size_t			collection_num;

	size_t			counters_num;

	struct ib_counters	**counters;

	struct ib_flow_action	**collection;

};



static struct ib_uflow_resources *flow_resources_alloc(size_t num_specs)

{

	struct ib_uflow_resources *resources;



	resources =

		kmalloc(sizeof(*resources) +

			num_specs * sizeof(*resources->collection), GFP_KERNEL);

	resources = kzalloc(sizeof(*resources), GFP_KERNEL);



	if (!resources)

		return NULL;

		goto err_res;



	resources->counters =

		kcalloc(num_specs, sizeof(*resources->counters), GFP_KERNEL);



	if (!resources->counters)

		goto err_cnt;



	resources->collection =

		kcalloc(num_specs, sizeof(*resources->collection), GFP_KERNEL);



	if (!resources->collection)

		goto err_collection;



	resources->num = 0;

	resources->max = num_specs;



	return resources;



err_collection:

	kfree(resources->counters);

err_cnt:

	kfree(resources);

err_res:

	return NULL;

}



void ib_uverbs_flow_resources_free(struct ib_uflow_resources *uflow_res)

{

	unsigned int i;



	for (i = 0; i < uflow_res->num; i++)

	for (i = 0; i < uflow_res->collection_num; i++)

		atomic_dec(&uflow_res->collection[i]->usecnt);



	for (i = 0; i < uflow_res->counters_num; i++)

		atomic_dec(&uflow_res->counters[i]->usecnt);



	kfree(uflow_res->collection);

	kfree(uflow_res->counters);

	kfree(uflow_res);

}



static void flow_resources_add(struct ib_uflow_resources *uflow_res,

			       struct ib_flow_action *action)

			       enum ib_flow_spec_type type,

			       void *ibobj)

{

	WARN_ON(uflow_res->num >= uflow_res->max);



	atomic_inc(&action->usecnt);

	uflow_res->collection[uflow_res->num++] = action;

	switch (type) {

	case IB_FLOW_SPEC_ACTION_HANDLE:

		atomic_inc(&((struct ib_flow_action *)ibobj)->usecnt);

		uflow_res->collection[uflow_res->collection_num++] =

			(struct ib_flow_action *)ibobj;

		break;

	case IB_FLOW_SPEC_ACTION_COUNT:

		atomic_inc(&((struct ib_counters *)ibobj)->usecnt);

		uflow_res->counters[uflow_res->counters_num++] =

			(struct ib_counters *)ibobj;

		break;

	default:

		WARN_ON(1);

	}



	uflow_res->num++;

}



static int kern_spec_to_ib_spec_action(struct ib_ucontext *ucontext,
@@ -2821,9 +2860,29 @@ static int kern_spec_to_ib_spec_action(struct ib_ucontext *ucontext, 
			return -EINVAL;

		ib_spec->action.size =

			sizeof(struct ib_flow_spec_action_handle);

		flow_resources_add(uflow_res, ib_spec->action.act);

		flow_resources_add(uflow_res,

				   IB_FLOW_SPEC_ACTION_HANDLE,

				   ib_spec->action.act);

		uobj_put_obj_read(ib_spec->action.act);

		break;

	case IB_FLOW_SPEC_ACTION_COUNT:

		if (kern_spec->flow_count.size !=

			sizeof(struct ib_uverbs_flow_spec_action_count))

			return -EINVAL;

		ib_spec->flow_count.counters =

			uobj_get_obj_read(counters,

					  UVERBS_OBJECT_COUNTERS,

					  kern_spec->flow_count.handle,

					  ucontext);

		if (!ib_spec->flow_count.counters)

			return -EINVAL;

		ib_spec->flow_count.size =

				sizeof(struct ib_flow_spec_action_count);

		flow_resources_add(uflow_res,

				   IB_FLOW_SPEC_ACTION_COUNT,

				   ib_spec->flow_count.counters);

		uobj_put_obj_read(ib_spec->flow_count.counters);

		break;

	default:

		return -EINVAL;

	}
@@ -3542,11 +3601,16 @@ int ib_uverbs_ex_create_flow(struct ib_uverbs_file *file, 
		err = -EINVAL;

		goto err_free;

	}

	flow_id = ib_create_flow(qp, flow_attr, IB_FLOW_DOMAIN_USER);



	flow_id = qp->device->create_flow(qp, flow_attr,

					  IB_FLOW_DOMAIN_USER, uhw);



	if (IS_ERR(flow_id)) {

		err = PTR_ERR(flow_id);

		goto err_free;

	}

	atomic_inc(&qp->usecnt);

	flow_id->qp = qp;

	flow_id->uobject = uobj;

	uobj->object = flow_id;

	uflow = container_of(uobj, typeof(*uflow), uobject);

drivers/infiniband/core/uverbs_std_types.c

+2 −1
Original line number Diff line number Diff line
@@ -302,7 +302,8 @@ static DECLARE_UVERBS_OBJECT_TREE(uverbs_default_objects, 
				  &UVERBS_OBJECT(UVERBS_OBJECT_RWQ_IND_TBL),

				  &UVERBS_OBJECT(UVERBS_OBJECT_XRCD),

				  &UVERBS_OBJECT(UVERBS_OBJECT_FLOW_ACTION),

				  &UVERBS_OBJECT(UVERBS_OBJECT_DM));

				  &UVERBS_OBJECT(UVERBS_OBJECT_DM),

				  &UVERBS_OBJECT(UVERBS_OBJECT_COUNTERS));



const struct uverbs_object_tree_def *uverbs_default_get_objects(void)

{

drivers/infiniband/core/uverbs_std_types_counters.c

0 → 100644
+157 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB

/*

 * Copyright (c) 2018, Mellanox Technologies inc.  All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */



#include "uverbs.h"

#include <rdma/uverbs_std_types.h>



static int uverbs_free_counters(struct ib_uobject *uobject,

				enum rdma_remove_reason why)

{

	struct ib_counters *counters = uobject->object;



	if (why == RDMA_REMOVE_DESTROY &&

	    atomic_read(&counters->usecnt))

		return -EBUSY;



	return counters->device->destroy_counters(counters);

}



static int UVERBS_HANDLER(UVERBS_METHOD_COUNTERS_CREATE)(struct ib_device *ib_dev,

							 struct ib_uverbs_file *file,

							 struct uverbs_attr_bundle *attrs)

{

	struct ib_counters *counters;

	struct ib_uobject *uobj;

	int ret;



	/*

	 * This check should be removed once the infrastructure

	 * have the ability to remove methods from parse tree once

	 * such condition is met.

	 */

	if (!ib_dev->create_counters)

		return -EOPNOTSUPP;



	uobj = uverbs_attr_get_uobject(attrs, UVERBS_ATTR_CREATE_COUNTERS_HANDLE);

	counters = ib_dev->create_counters(ib_dev, attrs);

	if (IS_ERR(counters)) {

		ret = PTR_ERR(counters);

		goto err_create_counters;

	}



	counters->device = ib_dev;

	counters->uobject = uobj;

	uobj->object = counters;

	atomic_set(&counters->usecnt, 0);



	return 0;



err_create_counters:

	return ret;

}



static int UVERBS_HANDLER(UVERBS_METHOD_COUNTERS_READ)(struct ib_device *ib_dev,

						       struct ib_uverbs_file *file,

						       struct uverbs_attr_bundle *attrs)

{

	struct ib_counters_read_attr read_attr = {};

	const struct uverbs_attr *uattr;

	struct ib_counters *counters =

		uverbs_attr_get_obj(attrs, UVERBS_ATTR_READ_COUNTERS_HANDLE);

	int ret;



	if (!ib_dev->read_counters)

		return -EOPNOTSUPP;



	if (!atomic_read(&counters->usecnt))

		return -EINVAL;



	ret = uverbs_copy_from(&read_attr.flags, attrs,

			       UVERBS_ATTR_READ_COUNTERS_FLAGS);

	if (ret)

		return ret;



	uattr = uverbs_attr_get(attrs, UVERBS_ATTR_READ_COUNTERS_BUFF);

	read_attr.ncounters = uattr->ptr_attr.len / sizeof(u64);

	read_attr.counters_buff = kcalloc(read_attr.ncounters,

					  sizeof(u64), GFP_KERNEL);

	if (!read_attr.counters_buff)

		return -ENOMEM;



	ret = ib_dev->read_counters(counters,

				    &read_attr,

				    attrs);

	if (ret)

		goto err_read;



	ret = uverbs_copy_to(attrs, UVERBS_ATTR_READ_COUNTERS_BUFF,

			     read_attr.counters_buff,

			     read_attr.ncounters * sizeof(u64));



err_read:

	kfree(read_attr.counters_buff);

	return ret;

}



static DECLARE_UVERBS_NAMED_METHOD(UVERBS_METHOD_COUNTERS_CREATE,

	&UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_COUNTERS_HANDLE,

			 UVERBS_OBJECT_COUNTERS,

			 UVERBS_ACCESS_NEW,

			 UA_FLAGS(UVERBS_ATTR_SPEC_F_MANDATORY)));



static DECLARE_UVERBS_NAMED_METHOD_WITH_HANDLER(UVERBS_METHOD_COUNTERS_DESTROY,

	uverbs_destroy_def_handler,

	&UVERBS_ATTR_IDR(UVERBS_ATTR_DESTROY_COUNTERS_HANDLE,

			 UVERBS_OBJECT_COUNTERS,

			 UVERBS_ACCESS_DESTROY,

			 UA_FLAGS(UVERBS_ATTR_SPEC_F_MANDATORY)));



#define MAX_COUNTERS_BUFF_SIZE USHRT_MAX

static DECLARE_UVERBS_NAMED_METHOD(UVERBS_METHOD_COUNTERS_READ,

	&UVERBS_ATTR_IDR(UVERBS_ATTR_READ_COUNTERS_HANDLE,

			 UVERBS_OBJECT_COUNTERS,

			 UVERBS_ACCESS_READ,

			 UA_FLAGS(UVERBS_ATTR_SPEC_F_MANDATORY)),

	&UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_READ_COUNTERS_BUFF,

			     UVERBS_ATTR_SIZE(0, MAX_COUNTERS_BUFF_SIZE),

			     UA_FLAGS(UVERBS_ATTR_SPEC_F_MANDATORY)),

	&UVERBS_ATTR_PTR_IN(UVERBS_ATTR_READ_COUNTERS_FLAGS,

			    UVERBS_ATTR_TYPE(__u32),

			    UA_FLAGS(UVERBS_ATTR_SPEC_F_MANDATORY)));



DECLARE_UVERBS_NAMED_OBJECT(UVERBS_OBJECT_COUNTERS,

			    &UVERBS_TYPE_ALLOC_IDR(0, uverbs_free_counters),

			    &UVERBS_METHOD(UVERBS_METHOD_COUNTERS_CREATE),

			    &UVERBS_METHOD(UVERBS_METHOD_COUNTERS_DESTROY),

			    &UVERBS_METHOD(UVERBS_METHOD_COUNTERS_READ));