2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
|
2005-08-11 14:03:10 +08:00
|
|
|
* Copyright (c) 2005 Mellanox Technologies Ltd. All rights reserved.
|
|
|
|
* Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* 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 "core_priv.h"
|
|
|
|
|
2005-11-07 16:59:43 +08:00
|
|
|
#include <linux/slab.h>
|
2011-05-28 01:27:45 +08:00
|
|
|
#include <linux/stat.h>
|
2005-11-07 16:59:43 +08:00
|
|
|
#include <linux/string.h>
|
2015-12-23 20:56:49 +08:00
|
|
|
#include <linux/netdevice.h>
|
2005-11-07 16:59:43 +08:00
|
|
|
|
2005-08-26 04:40:04 +08:00
|
|
|
#include <rdma/ib_mad.h>
|
2015-12-21 22:20:28 +08:00
|
|
|
#include <rdma/ib_pma.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
struct ib_port;
|
|
|
|
|
|
|
|
struct gid_attr_group {
|
|
|
|
struct ib_port *port;
|
|
|
|
struct kobject kobj;
|
|
|
|
struct attribute_group ndev;
|
|
|
|
struct attribute_group type;
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
struct ib_port {
|
|
|
|
struct kobject kobj;
|
|
|
|
struct ib_device *ibdev;
|
2015-12-23 20:56:49 +08:00
|
|
|
struct gid_attr_group *gid_attr_group;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct attribute_group gid_group;
|
|
|
|
struct attribute_group pkey_group;
|
2015-12-21 22:20:29 +08:00
|
|
|
struct attribute_group *pma_table;
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
struct attribute_group *hw_stats_ag;
|
|
|
|
struct rdma_hw_stats *hw_stats;
|
|
|
|
u8 port_num;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct port_attribute {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(struct ib_port *, struct port_attribute *, char *buf);
|
|
|
|
ssize_t (*store)(struct ib_port *, struct port_attribute *,
|
|
|
|
const char *buf, size_t count);
|
|
|
|
};
|
|
|
|
|
|
|
|
#define PORT_ATTR(_name, _mode, _show, _store) \
|
|
|
|
struct port_attribute port_attr_##_name = __ATTR(_name, _mode, _show, _store)
|
|
|
|
|
|
|
|
#define PORT_ATTR_RO(_name) \
|
|
|
|
struct port_attribute port_attr_##_name = __ATTR_RO(_name)
|
|
|
|
|
|
|
|
struct port_table_attribute {
|
2005-04-29 13:58:46 +08:00
|
|
|
struct port_attribute attr;
|
|
|
|
char name[8];
|
|
|
|
int index;
|
2016-01-04 11:44:25 +08:00
|
|
|
__be16 attr_id;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
struct hw_stats_attribute {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(struct kobject *kobj,
|
|
|
|
struct attribute *attr, char *buf);
|
|
|
|
ssize_t (*store)(struct kobject *kobj,
|
|
|
|
struct attribute *attr,
|
|
|
|
const char *buf,
|
|
|
|
size_t count);
|
|
|
|
int index;
|
|
|
|
u8 port_num;
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static ssize_t port_attr_show(struct kobject *kobj,
|
|
|
|
struct attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct port_attribute *port_attr =
|
|
|
|
container_of(attr, struct port_attribute, attr);
|
|
|
|
struct ib_port *p = container_of(kobj, struct ib_port, kobj);
|
|
|
|
|
|
|
|
if (!port_attr->show)
|
2005-04-29 14:27:34 +08:00
|
|
|
return -EIO;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return port_attr->show(p, port_attr, buf);
|
|
|
|
}
|
|
|
|
|
2010-01-19 09:58:23 +08:00
|
|
|
static const struct sysfs_ops port_sysfs_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.show = port_attr_show
|
|
|
|
};
|
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
static ssize_t gid_attr_show(struct kobject *kobj,
|
|
|
|
struct attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct port_attribute *port_attr =
|
|
|
|
container_of(attr, struct port_attribute, attr);
|
|
|
|
struct ib_port *p = container_of(kobj, struct gid_attr_group,
|
|
|
|
kobj)->port;
|
|
|
|
|
|
|
|
if (!port_attr->show)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return port_attr->show(p, port_attr, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct sysfs_ops gid_attr_sysfs_ops = {
|
|
|
|
.show = gid_attr_show
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static ssize_t state_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
static const char *state_name[] = {
|
|
|
|
[IB_PORT_NOP] = "NOP",
|
|
|
|
[IB_PORT_DOWN] = "DOWN",
|
|
|
|
[IB_PORT_INIT] = "INIT",
|
|
|
|
[IB_PORT_ARMED] = "ARMED",
|
|
|
|
[IB_PORT_ACTIVE] = "ACTIVE",
|
|
|
|
[IB_PORT_ACTIVE_DEFER] = "ACTIVE_DEFER"
|
|
|
|
};
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d: %s\n", attr.state,
|
2006-03-21 02:08:25 +08:00
|
|
|
attr.state >= 0 && attr.state < ARRAY_SIZE(state_name) ?
|
2005-04-17 06:20:36 +08:00
|
|
|
state_name[attr.state] : "UNKNOWN");
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t lid_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "0x%x\n", attr.lid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t lid_mask_count_show(struct ib_port *p,
|
|
|
|
struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", attr.lmc);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t sm_lid_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "0x%x\n", attr.sm_lid);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t sm_sl_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", attr.sm_sl);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t cap_mask_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "0x%08x\n", attr.port_cap_flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
char *speed = "";
|
2012-04-03 01:57:31 +08:00
|
|
|
int rate; /* in deci-Gb/sec */
|
2005-04-17 06:20:36 +08:00
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
switch (attr.active_speed) {
|
2012-02-29 00:49:50 +08:00
|
|
|
case IB_SPEED_DDR:
|
2011-10-05 19:21:47 +08:00
|
|
|
speed = " DDR";
|
2012-02-28 01:15:08 +08:00
|
|
|
rate = 50;
|
2011-10-05 19:21:47 +08:00
|
|
|
break;
|
2012-02-29 00:49:50 +08:00
|
|
|
case IB_SPEED_QDR:
|
2011-10-05 19:21:47 +08:00
|
|
|
speed = " QDR";
|
2012-02-28 01:15:08 +08:00
|
|
|
rate = 100;
|
2011-10-05 19:21:47 +08:00
|
|
|
break;
|
2012-02-29 00:49:50 +08:00
|
|
|
case IB_SPEED_FDR10:
|
2011-10-05 19:21:47 +08:00
|
|
|
speed = " FDR10";
|
2012-02-28 01:15:08 +08:00
|
|
|
rate = 100;
|
2011-10-05 19:21:47 +08:00
|
|
|
break;
|
2012-02-29 00:49:50 +08:00
|
|
|
case IB_SPEED_FDR:
|
2011-10-05 19:21:47 +08:00
|
|
|
speed = " FDR";
|
2012-02-28 01:15:08 +08:00
|
|
|
rate = 140;
|
2011-10-05 19:21:47 +08:00
|
|
|
break;
|
2012-02-29 00:49:50 +08:00
|
|
|
case IB_SPEED_EDR:
|
2011-10-05 19:21:47 +08:00
|
|
|
speed = " EDR";
|
2012-02-28 01:15:08 +08:00
|
|
|
rate = 250;
|
2011-10-05 19:21:47 +08:00
|
|
|
break;
|
2012-04-03 01:57:31 +08:00
|
|
|
case IB_SPEED_SDR:
|
|
|
|
default: /* default to SDR for invalid rates */
|
|
|
|
rate = 25;
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-10-05 19:21:47 +08:00
|
|
|
rate *= ib_width_enum_to_int(attr.active_width);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (rate < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d%s Gb/sec (%dX%s)\n",
|
2012-02-28 01:15:08 +08:00
|
|
|
rate / 10, rate % 10 ? ".5" : "",
|
2005-04-17 06:20:36 +08:00
|
|
|
ib_width_enum_to_int(attr.active_width), speed);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t phys_state_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(p->ibdev, p->port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
switch (attr.phys_state) {
|
|
|
|
case 1: return sprintf(buf, "1: Sleep\n");
|
|
|
|
case 2: return sprintf(buf, "2: Polling\n");
|
|
|
|
case 3: return sprintf(buf, "3: Disabled\n");
|
|
|
|
case 4: return sprintf(buf, "4: PortConfigurationTraining\n");
|
|
|
|
case 5: return sprintf(buf, "5: LinkUp\n");
|
|
|
|
case 6: return sprintf(buf, "6: LinkErrorRecovery\n");
|
|
|
|
case 7: return sprintf(buf, "7: Phy Test\n");
|
|
|
|
default: return sprintf(buf, "%d: <unknown>\n", attr.phys_state);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-22 20:32:05 +08:00
|
|
|
static ssize_t link_layer_show(struct ib_port *p, struct port_attribute *unused,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
switch (rdma_port_get_link_layer(p->ibdev, p->port_num)) {
|
|
|
|
case IB_LINK_LAYER_INFINIBAND:
|
|
|
|
return sprintf(buf, "%s\n", "InfiniBand");
|
|
|
|
case IB_LINK_LAYER_ETHERNET:
|
|
|
|
return sprintf(buf, "%s\n", "Ethernet");
|
|
|
|
default:
|
|
|
|
return sprintf(buf, "%s\n", "Unknown");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static PORT_ATTR_RO(state);
|
|
|
|
static PORT_ATTR_RO(lid);
|
|
|
|
static PORT_ATTR_RO(lid_mask_count);
|
|
|
|
static PORT_ATTR_RO(sm_lid);
|
|
|
|
static PORT_ATTR_RO(sm_sl);
|
|
|
|
static PORT_ATTR_RO(cap_mask);
|
|
|
|
static PORT_ATTR_RO(rate);
|
|
|
|
static PORT_ATTR_RO(phys_state);
|
2010-10-22 20:32:05 +08:00
|
|
|
static PORT_ATTR_RO(link_layer);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static struct attribute *port_default_attrs[] = {
|
|
|
|
&port_attr_state.attr,
|
|
|
|
&port_attr_lid.attr,
|
|
|
|
&port_attr_lid_mask_count.attr,
|
|
|
|
&port_attr_sm_lid.attr,
|
|
|
|
&port_attr_sm_sl.attr,
|
|
|
|
&port_attr_cap_mask.attr,
|
|
|
|
&port_attr_rate.attr,
|
|
|
|
&port_attr_phys_state.attr,
|
2010-10-22 20:32:05 +08:00
|
|
|
&port_attr_link_layer.attr,
|
2005-04-17 06:20:36 +08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
static size_t print_ndev(struct ib_gid_attr *gid_attr, char *buf)
|
|
|
|
{
|
|
|
|
if (!gid_attr->ndev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", gid_attr->ndev->name);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t print_gid_type(struct ib_gid_attr *gid_attr, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%s\n", ib_cache_gid_type_str(gid_attr->gid_type));
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t _show_port_gid_attr(struct ib_port *p,
|
|
|
|
struct port_attribute *attr,
|
|
|
|
char *buf,
|
|
|
|
size_t (*print)(struct ib_gid_attr *gid_attr,
|
|
|
|
char *buf))
|
|
|
|
{
|
|
|
|
struct port_table_attribute *tab_attr =
|
|
|
|
container_of(attr, struct port_table_attribute, attr);
|
|
|
|
union ib_gid gid;
|
|
|
|
struct ib_gid_attr gid_attr = {};
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid,
|
|
|
|
&gid_attr);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
ret = print(&gid_attr, buf);
|
|
|
|
|
|
|
|
err:
|
|
|
|
if (gid_attr.ndev)
|
|
|
|
dev_put(gid_attr.ndev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static ssize_t show_port_gid(struct ib_port *p, struct port_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct port_table_attribute *tab_attr =
|
|
|
|
container_of(attr, struct port_table_attribute, attr);
|
|
|
|
union ib_gid gid;
|
|
|
|
ssize_t ret;
|
|
|
|
|
2015-10-15 23:38:45 +08:00
|
|
|
ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2008-10-30 03:52:50 +08:00
|
|
|
return sprintf(buf, "%pI6\n", gid.raw);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
static ssize_t show_port_gid_attr_ndev(struct ib_port *p,
|
|
|
|
struct port_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
return _show_port_gid_attr(p, attr, buf, print_ndev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t show_port_gid_attr_gid_type(struct ib_port *p,
|
|
|
|
struct port_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
return _show_port_gid_attr(p, attr, buf, print_gid_type);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static ssize_t show_port_pkey(struct ib_port *p, struct port_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct port_table_attribute *tab_attr =
|
|
|
|
container_of(attr, struct port_table_attribute, attr);
|
|
|
|
u16 pkey;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
ret = ib_query_pkey(p->ibdev, p->port_num, tab_attr->index, &pkey);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return sprintf(buf, "0x%04x\n", pkey);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define PORT_PMA_ATTR(_name, _counter, _width, _offset) \
|
|
|
|
struct port_table_attribute port_pma_attr_##_name = { \
|
|
|
|
.attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \
|
2015-12-21 22:20:28 +08:00
|
|
|
.index = (_offset) | ((_width) << 16) | ((_counter) << 24), \
|
|
|
|
.attr_id = IB_PMA_PORT_COUNTERS , \
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-12-21 22:20:29 +08:00
|
|
|
#define PORT_PMA_ATTR_EXT(_name, _width, _offset) \
|
|
|
|
struct port_table_attribute port_pma_attr_ext_##_name = { \
|
|
|
|
.attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \
|
|
|
|
.index = (_offset) | ((_width) << 16), \
|
|
|
|
.attr_id = IB_PMA_PORT_COUNTERS_EXT , \
|
|
|
|
}
|
|
|
|
|
2015-12-21 22:20:27 +08:00
|
|
|
/*
|
|
|
|
* Get a Perfmgmt MAD block of data.
|
|
|
|
* Returns error code or the number of bytes retrieved.
|
|
|
|
*/
|
2016-01-04 11:44:25 +08:00
|
|
|
static int get_perf_mad(struct ib_device *dev, int port_num, __be16 attr,
|
2015-12-21 22:20:27 +08:00
|
|
|
void *data, int offset, size_t size)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2015-12-21 22:20:27 +08:00
|
|
|
struct ib_mad *in_mad;
|
|
|
|
struct ib_mad *out_mad;
|
2015-06-07 02:38:31 +08:00
|
|
|
size_t mad_size = sizeof(*out_mad);
|
|
|
|
u16 out_mad_pkey_index = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
ssize_t ret;
|
|
|
|
|
2015-12-21 22:20:27 +08:00
|
|
|
if (!dev->process_mad)
|
|
|
|
return -ENOSYS;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-11-02 23:23:14 +08:00
|
|
|
in_mad = kzalloc(sizeof *in_mad, GFP_KERNEL);
|
2007-07-10 21:55:57 +08:00
|
|
|
out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!in_mad || !out_mad) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
in_mad->mad_hdr.base_version = 1;
|
|
|
|
in_mad->mad_hdr.mgmt_class = IB_MGMT_CLASS_PERF_MGMT;
|
|
|
|
in_mad->mad_hdr.class_version = 1;
|
|
|
|
in_mad->mad_hdr.method = IB_MGMT_METHOD_GET;
|
2015-12-21 22:20:27 +08:00
|
|
|
in_mad->mad_hdr.attr_id = attr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-12-29 18:43:43 +08:00
|
|
|
if (attr != IB_PMA_CLASS_PORT_INFO)
|
|
|
|
in_mad->data[41] = port_num; /* PortSelect field */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-12-21 22:20:27 +08:00
|
|
|
if ((dev->process_mad(dev, IB_MAD_IGNORE_MKEY,
|
|
|
|
port_num, NULL, NULL,
|
2015-06-07 02:38:31 +08:00
|
|
|
(const struct ib_mad_hdr *)in_mad, mad_size,
|
|
|
|
(struct ib_mad_hdr *)out_mad, &mad_size,
|
|
|
|
&out_mad_pkey_index) &
|
2005-04-17 06:20:36 +08:00
|
|
|
(IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) !=
|
|
|
|
(IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2015-12-21 22:20:27 +08:00
|
|
|
memcpy(data, out_mad->data + offset, size);
|
|
|
|
ret = size;
|
|
|
|
out:
|
|
|
|
kfree(in_mad);
|
|
|
|
kfree(out_mad);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct port_table_attribute *tab_attr =
|
|
|
|
container_of(attr, struct port_table_attribute, attr);
|
|
|
|
int offset = tab_attr->index & 0xffff;
|
|
|
|
int width = (tab_attr->index >> 16) & 0xff;
|
|
|
|
ssize_t ret;
|
|
|
|
u8 data[8];
|
|
|
|
|
2015-12-21 22:20:28 +08:00
|
|
|
ret = get_perf_mad(p->ibdev, p->port_num, tab_attr->attr_id, &data,
|
2015-12-21 22:20:27 +08:00
|
|
|
40 + offset / 8, sizeof(data));
|
|
|
|
if (ret < 0)
|
|
|
|
return sprintf(buf, "N/A (no PMA)\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
switch (width) {
|
|
|
|
case 4:
|
2015-12-21 22:20:27 +08:00
|
|
|
ret = sprintf(buf, "%u\n", (*data >>
|
2006-05-10 01:50:28 +08:00
|
|
|
(4 - (offset % 8))) & 0xf);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case 8:
|
2015-12-21 22:20:27 +08:00
|
|
|
ret = sprintf(buf, "%u\n", *data);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case 16:
|
|
|
|
ret = sprintf(buf, "%u\n",
|
2015-12-21 22:20:27 +08:00
|
|
|
be16_to_cpup((__be16 *)data));
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case 32:
|
|
|
|
ret = sprintf(buf, "%u\n",
|
2015-12-21 22:20:27 +08:00
|
|
|
be32_to_cpup((__be32 *)data));
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2015-12-21 22:20:29 +08:00
|
|
|
case 64:
|
|
|
|
ret = sprintf(buf, "%llu\n",
|
|
|
|
be64_to_cpup((__be64 *)data));
|
|
|
|
break;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
default:
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static PORT_PMA_ATTR(symbol_error , 0, 16, 32);
|
|
|
|
static PORT_PMA_ATTR(link_error_recovery , 1, 8, 48);
|
|
|
|
static PORT_PMA_ATTR(link_downed , 2, 8, 56);
|
|
|
|
static PORT_PMA_ATTR(port_rcv_errors , 3, 16, 64);
|
|
|
|
static PORT_PMA_ATTR(port_rcv_remote_physical_errors, 4, 16, 80);
|
|
|
|
static PORT_PMA_ATTR(port_rcv_switch_relay_errors , 5, 16, 96);
|
|
|
|
static PORT_PMA_ATTR(port_xmit_discards , 6, 16, 112);
|
|
|
|
static PORT_PMA_ATTR(port_xmit_constraint_errors , 7, 8, 128);
|
|
|
|
static PORT_PMA_ATTR(port_rcv_constraint_errors , 8, 8, 136);
|
|
|
|
static PORT_PMA_ATTR(local_link_integrity_errors , 9, 4, 152);
|
|
|
|
static PORT_PMA_ATTR(excessive_buffer_overrun_errors, 10, 4, 156);
|
|
|
|
static PORT_PMA_ATTR(VL15_dropped , 11, 16, 176);
|
|
|
|
static PORT_PMA_ATTR(port_xmit_data , 12, 32, 192);
|
|
|
|
static PORT_PMA_ATTR(port_rcv_data , 13, 32, 224);
|
|
|
|
static PORT_PMA_ATTR(port_xmit_packets , 14, 32, 256);
|
|
|
|
static PORT_PMA_ATTR(port_rcv_packets , 15, 32, 288);
|
|
|
|
|
2015-12-21 22:20:29 +08:00
|
|
|
/*
|
|
|
|
* Counters added by extended set
|
|
|
|
*/
|
|
|
|
static PORT_PMA_ATTR_EXT(port_xmit_data , 64, 64);
|
|
|
|
static PORT_PMA_ATTR_EXT(port_rcv_data , 64, 128);
|
|
|
|
static PORT_PMA_ATTR_EXT(port_xmit_packets , 64, 192);
|
|
|
|
static PORT_PMA_ATTR_EXT(port_rcv_packets , 64, 256);
|
|
|
|
static PORT_PMA_ATTR_EXT(unicast_xmit_packets , 64, 320);
|
|
|
|
static PORT_PMA_ATTR_EXT(unicast_rcv_packets , 64, 384);
|
|
|
|
static PORT_PMA_ATTR_EXT(multicast_xmit_packets , 64, 448);
|
|
|
|
static PORT_PMA_ATTR_EXT(multicast_rcv_packets , 64, 512);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static struct attribute *pma_attrs[] = {
|
|
|
|
&port_pma_attr_symbol_error.attr.attr,
|
|
|
|
&port_pma_attr_link_error_recovery.attr.attr,
|
|
|
|
&port_pma_attr_link_downed.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_discards.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_constraint_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_constraint_errors.attr.attr,
|
|
|
|
&port_pma_attr_local_link_integrity_errors.attr.attr,
|
|
|
|
&port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
|
|
|
|
&port_pma_attr_VL15_dropped.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_data.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_data.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_packets.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_packets.attr.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2015-12-21 22:20:29 +08:00
|
|
|
static struct attribute *pma_attrs_ext[] = {
|
|
|
|
&port_pma_attr_symbol_error.attr.attr,
|
|
|
|
&port_pma_attr_link_error_recovery.attr.attr,
|
|
|
|
&port_pma_attr_link_downed.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_discards.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_constraint_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_constraint_errors.attr.attr,
|
|
|
|
&port_pma_attr_local_link_integrity_errors.attr.attr,
|
|
|
|
&port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
|
|
|
|
&port_pma_attr_VL15_dropped.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_xmit_data.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_rcv_data.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_xmit_packets.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_rcv_packets.attr.attr,
|
|
|
|
&port_pma_attr_ext_unicast_rcv_packets.attr.attr,
|
|
|
|
&port_pma_attr_ext_unicast_xmit_packets.attr.attr,
|
|
|
|
&port_pma_attr_ext_multicast_rcv_packets.attr.attr,
|
|
|
|
&port_pma_attr_ext_multicast_xmit_packets.attr.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute *pma_attrs_noietf[] = {
|
|
|
|
&port_pma_attr_symbol_error.attr.attr,
|
|
|
|
&port_pma_attr_link_error_recovery.attr.attr,
|
|
|
|
&port_pma_attr_link_downed.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_discards.attr.attr,
|
|
|
|
&port_pma_attr_port_xmit_constraint_errors.attr.attr,
|
|
|
|
&port_pma_attr_port_rcv_constraint_errors.attr.attr,
|
|
|
|
&port_pma_attr_local_link_integrity_errors.attr.attr,
|
|
|
|
&port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
|
|
|
|
&port_pma_attr_VL15_dropped.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_xmit_data.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_rcv_data.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_xmit_packets.attr.attr,
|
|
|
|
&port_pma_attr_ext_port_rcv_packets.attr.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static struct attribute_group pma_group = {
|
|
|
|
.name = "counters",
|
|
|
|
.attrs = pma_attrs
|
|
|
|
};
|
|
|
|
|
2015-12-21 22:20:29 +08:00
|
|
|
static struct attribute_group pma_group_ext = {
|
|
|
|
.name = "counters",
|
|
|
|
.attrs = pma_attrs_ext
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group pma_group_noietf = {
|
|
|
|
.name = "counters",
|
|
|
|
.attrs = pma_attrs_noietf
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static void ib_port_release(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
struct ib_port *p = container_of(kobj, struct ib_port, kobj);
|
|
|
|
struct attribute *a;
|
|
|
|
int i;
|
|
|
|
|
2014-05-18 16:12:25 +08:00
|
|
|
if (p->gid_group.attrs) {
|
|
|
|
for (i = 0; (a = p->gid_group.attrs[i]); ++i)
|
|
|
|
kfree(a);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-05-18 16:12:25 +08:00
|
|
|
kfree(p->gid_group.attrs);
|
|
|
|
}
|
2005-04-29 13:58:46 +08:00
|
|
|
|
2014-05-18 16:12:25 +08:00
|
|
|
if (p->pkey_group.attrs) {
|
|
|
|
for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
|
|
|
|
kfree(a);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-05-18 16:12:25 +08:00
|
|
|
kfree(p->pkey_group.attrs);
|
|
|
|
}
|
2005-04-29 13:58:46 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree(p);
|
|
|
|
}
|
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
static void ib_port_gid_attr_release(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
struct gid_attr_group *g = container_of(kobj, struct gid_attr_group,
|
|
|
|
kobj);
|
|
|
|
struct attribute *a;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (g->ndev.attrs) {
|
|
|
|
for (i = 0; (a = g->ndev.attrs[i]); ++i)
|
|
|
|
kfree(a);
|
|
|
|
|
|
|
|
kfree(g->ndev.attrs);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (g->type.attrs) {
|
|
|
|
for (i = 0; (a = g->type.attrs[i]); ++i)
|
|
|
|
kfree(a);
|
|
|
|
|
|
|
|
kfree(g->type.attrs);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(g);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static struct kobj_type port_type = {
|
|
|
|
.release = ib_port_release,
|
|
|
|
.sysfs_ops = &port_sysfs_ops,
|
|
|
|
.default_attrs = port_default_attrs
|
|
|
|
};
|
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
static struct kobj_type gid_attr_type = {
|
|
|
|
.sysfs_ops = &gid_attr_sysfs_ops,
|
|
|
|
.release = ib_port_gid_attr_release
|
|
|
|
};
|
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
static struct attribute **
|
|
|
|
alloc_group_attrs(ssize_t (*show)(struct ib_port *,
|
|
|
|
struct port_attribute *, char *buf),
|
|
|
|
int len)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-04-29 13:58:46 +08:00
|
|
|
struct attribute **tab_attr;
|
|
|
|
struct port_table_attribute *element;
|
2005-04-17 06:20:36 +08:00
|
|
|
int i;
|
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
tab_attr = kcalloc(1 + len, sizeof(struct attribute *), GFP_KERNEL);
|
|
|
|
if (!tab_attr)
|
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
for (i = 0; i < len; i++) {
|
2005-09-07 06:18:35 +08:00
|
|
|
element = kzalloc(sizeof(struct port_table_attribute),
|
2005-04-29 13:58:46 +08:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!element)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto err;
|
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
if (snprintf(element->name, sizeof(element->name),
|
2006-03-21 02:08:25 +08:00
|
|
|
"%d", i) >= sizeof(element->name)) {
|
|
|
|
kfree(element);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto err;
|
2006-03-21 02:08:25 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
element->attr.attr.name = element->name;
|
|
|
|
element->attr.attr.mode = S_IRUGO;
|
|
|
|
element->attr.show = show;
|
|
|
|
element->index = i;
|
2010-03-16 05:01:25 +08:00
|
|
|
sysfs_attr_init(&element->attr.attr);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
tab_attr[i] = &element->attr.attr;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
return tab_attr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
err:
|
|
|
|
while (--i >= 0)
|
|
|
|
kfree(tab_attr[i]);
|
|
|
|
kfree(tab_attr);
|
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-12-21 22:20:29 +08:00
|
|
|
/*
|
|
|
|
* Figure out which counter table to use depending on
|
|
|
|
* the device capabilities.
|
|
|
|
*/
|
2015-12-29 18:43:43 +08:00
|
|
|
static struct attribute_group *get_counter_table(struct ib_device *dev,
|
|
|
|
int port_num)
|
2015-12-21 22:20:29 +08:00
|
|
|
{
|
|
|
|
struct ib_class_port_info cpi;
|
|
|
|
|
2015-12-29 18:43:43 +08:00
|
|
|
if (get_perf_mad(dev, port_num, IB_PMA_CLASS_PORT_INFO,
|
2015-12-21 22:20:29 +08:00
|
|
|
&cpi, 40, sizeof(cpi)) >= 0) {
|
2016-02-11 16:24:42 +08:00
|
|
|
if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH)
|
2015-12-21 22:20:29 +08:00
|
|
|
/* We have extended counters */
|
|
|
|
return &pma_group_ext;
|
|
|
|
|
2016-02-11 16:24:42 +08:00
|
|
|
if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH_NOIETF)
|
2015-12-21 22:20:29 +08:00
|
|
|
/* But not the IETF ones */
|
|
|
|
return &pma_group_noietf;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fall back to normal counters */
|
|
|
|
return &pma_group;
|
|
|
|
}
|
|
|
|
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
static int update_hw_stats(struct ib_device *dev, struct rdma_hw_stats *stats,
|
|
|
|
u8 port_num, int index)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (time_is_after_eq_jiffies(stats->timestamp + stats->lifespan))
|
|
|
|
return 0;
|
|
|
|
ret = dev->get_hw_stats(dev, stats, port_num, index);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (ret == stats->num_counters)
|
|
|
|
stats->timestamp = jiffies;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t print_hw_stat(struct rdma_hw_stats *stats, int index, char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%llu\n", stats->value[index]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t show_hw_stats(struct kobject *kobj, struct attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct ib_device *dev;
|
|
|
|
struct ib_port *port;
|
|
|
|
struct hw_stats_attribute *hsa;
|
|
|
|
struct rdma_hw_stats *stats;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
hsa = container_of(attr, struct hw_stats_attribute, attr);
|
|
|
|
if (!hsa->port_num) {
|
|
|
|
dev = container_of((struct device *)kobj,
|
|
|
|
struct ib_device, dev);
|
|
|
|
stats = dev->hw_stats;
|
|
|
|
} else {
|
|
|
|
port = container_of(kobj, struct ib_port, kobj);
|
|
|
|
dev = port->ibdev;
|
|
|
|
stats = port->hw_stats;
|
|
|
|
}
|
|
|
|
ret = update_hw_stats(dev, stats, hsa->port_num, hsa->index);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
return print_hw_stat(stats, hsa->index, buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t show_stats_lifespan(struct kobject *kobj,
|
|
|
|
struct attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct hw_stats_attribute *hsa;
|
|
|
|
int msecs;
|
|
|
|
|
|
|
|
hsa = container_of(attr, struct hw_stats_attribute, attr);
|
|
|
|
if (!hsa->port_num) {
|
|
|
|
struct ib_device *dev = container_of((struct device *)kobj,
|
|
|
|
struct ib_device, dev);
|
|
|
|
msecs = jiffies_to_msecs(dev->hw_stats->lifespan);
|
|
|
|
} else {
|
|
|
|
struct ib_port *p = container_of(kobj, struct ib_port, kobj);
|
|
|
|
msecs = jiffies_to_msecs(p->hw_stats->lifespan);
|
|
|
|
}
|
|
|
|
return sprintf(buf, "%d\n", msecs);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t set_stats_lifespan(struct kobject *kobj,
|
|
|
|
struct attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct hw_stats_attribute *hsa;
|
|
|
|
int msecs;
|
|
|
|
int jiffies;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = kstrtoint(buf, 10, &msecs);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
if (msecs < 0 || msecs > 10000)
|
|
|
|
return -EINVAL;
|
|
|
|
jiffies = msecs_to_jiffies(msecs);
|
|
|
|
hsa = container_of(attr, struct hw_stats_attribute, attr);
|
|
|
|
if (!hsa->port_num) {
|
|
|
|
struct ib_device *dev = container_of((struct device *)kobj,
|
|
|
|
struct ib_device, dev);
|
|
|
|
dev->hw_stats->lifespan = jiffies;
|
|
|
|
} else {
|
|
|
|
struct ib_port *p = container_of(kobj, struct ib_port, kobj);
|
|
|
|
p->hw_stats->lifespan = jiffies;
|
|
|
|
}
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void free_hsag(struct kobject *kobj, struct attribute_group *attr_group)
|
|
|
|
{
|
|
|
|
struct attribute **attr;
|
|
|
|
|
|
|
|
sysfs_remove_group(kobj, attr_group);
|
|
|
|
|
|
|
|
for (attr = attr_group->attrs; *attr; attr++)
|
|
|
|
kfree(*attr);
|
|
|
|
kfree(attr_group);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct attribute *alloc_hsa(int index, u8 port_num, const char *name)
|
|
|
|
{
|
|
|
|
struct hw_stats_attribute *hsa;
|
|
|
|
|
|
|
|
hsa = kmalloc(sizeof(*hsa), GFP_KERNEL);
|
|
|
|
if (!hsa)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
hsa->attr.name = (char *)name;
|
|
|
|
hsa->attr.mode = S_IRUGO;
|
|
|
|
hsa->show = show_hw_stats;
|
|
|
|
hsa->store = NULL;
|
|
|
|
hsa->index = index;
|
|
|
|
hsa->port_num = port_num;
|
|
|
|
|
|
|
|
return &hsa->attr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct attribute *alloc_hsa_lifespan(char *name, u8 port_num)
|
|
|
|
{
|
|
|
|
struct hw_stats_attribute *hsa;
|
|
|
|
|
|
|
|
hsa = kmalloc(sizeof(*hsa), GFP_KERNEL);
|
|
|
|
if (!hsa)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
hsa->attr.name = name;
|
|
|
|
hsa->attr.mode = S_IWUSR | S_IRUGO;
|
|
|
|
hsa->show = show_stats_lifespan;
|
|
|
|
hsa->store = set_stats_lifespan;
|
|
|
|
hsa->index = 0;
|
|
|
|
hsa->port_num = port_num;
|
|
|
|
|
|
|
|
return &hsa->attr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void setup_hw_stats(struct ib_device *device, struct ib_port *port,
|
|
|
|
u8 port_num)
|
|
|
|
{
|
2016-06-07 19:43:46 +08:00
|
|
|
struct attribute_group *hsag;
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
struct rdma_hw_stats *stats;
|
2016-06-07 19:43:46 +08:00
|
|
|
int i, ret;
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
|
|
|
|
stats = device->alloc_hw_stats(device, port_num);
|
|
|
|
|
|
|
|
if (!stats)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!stats->names || stats->num_counters <= 0)
|
2016-06-02 02:06:36 +08:00
|
|
|
goto err_free_stats;
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
|
2016-06-07 07:52:55 +08:00
|
|
|
/*
|
|
|
|
* Two extra attribue elements here, one for the lifespan entry and
|
|
|
|
* one to NULL terminate the list for the sysfs core code
|
|
|
|
*/
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
hsag = kzalloc(sizeof(*hsag) +
|
2016-06-07 07:52:55 +08:00
|
|
|
sizeof(void *) * (stats->num_counters + 2),
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hsag)
|
2016-06-02 02:06:36 +08:00
|
|
|
goto err_free_stats;
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
|
|
|
|
ret = device->get_hw_stats(device, stats, port_num,
|
|
|
|
stats->num_counters);
|
|
|
|
if (ret != stats->num_counters)
|
2016-06-07 19:43:46 +08:00
|
|
|
goto err_free_hsag;
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
|
|
|
|
stats->timestamp = jiffies;
|
|
|
|
|
|
|
|
hsag->name = "hw_counters";
|
|
|
|
hsag->attrs = (void *)hsag + sizeof(*hsag);
|
|
|
|
|
|
|
|
for (i = 0; i < stats->num_counters; i++) {
|
|
|
|
hsag->attrs[i] = alloc_hsa(i, port_num, stats->names[i]);
|
|
|
|
if (!hsag->attrs[i])
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* treat an error here as non-fatal */
|
|
|
|
hsag->attrs[i] = alloc_hsa_lifespan("lifespan", port_num);
|
|
|
|
|
|
|
|
if (port) {
|
|
|
|
struct kobject *kobj = &port->kobj;
|
|
|
|
ret = sysfs_create_group(kobj, hsag);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
port->hw_stats_ag = hsag;
|
|
|
|
port->hw_stats = stats;
|
|
|
|
} else {
|
|
|
|
struct kobject *kobj = &device->dev.kobj;
|
|
|
|
ret = sysfs_create_group(kobj, hsag);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
device->hw_stats_ag = hsag;
|
|
|
|
device->hw_stats = stats;
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (; i >= 0; i--)
|
|
|
|
kfree(hsag->attrs[i]);
|
2016-06-07 19:43:46 +08:00
|
|
|
err_free_hsag:
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
kfree(hsag);
|
2016-06-02 02:06:36 +08:00
|
|
|
err_free_stats:
|
|
|
|
kfree(stats);
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-05-07 08:03:25 +08:00
|
|
|
static int add_port(struct ib_device *device, int port_num,
|
|
|
|
int (*port_callback)(struct ib_device *,
|
|
|
|
u8, struct kobject *))
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct ib_port *p;
|
|
|
|
struct ib_port_attr attr;
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = ib_query_port(device, port_num, &attr);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2005-11-02 23:23:14 +08:00
|
|
|
p = kzalloc(sizeof *p, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!p)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
p->ibdev = device;
|
|
|
|
p->port_num = port_num;
|
|
|
|
|
2007-12-18 03:54:39 +08:00
|
|
|
ret = kobject_init_and_add(&p->kobj, &port_type,
|
2014-05-18 16:12:24 +08:00
|
|
|
device->ports_parent,
|
2007-12-18 03:54:39 +08:00
|
|
|
"%d", port_num);
|
2014-05-18 16:12:25 +08:00
|
|
|
if (ret) {
|
|
|
|
kfree(p);
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
p->gid_attr_group = kzalloc(sizeof(*p->gid_attr_group), GFP_KERNEL);
|
|
|
|
if (!p->gid_attr_group) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_put;
|
|
|
|
}
|
|
|
|
|
|
|
|
p->gid_attr_group->port = p;
|
|
|
|
ret = kobject_init_and_add(&p->gid_attr_group->kobj, &gid_attr_type,
|
|
|
|
&p->kobj, "gid_attrs");
|
|
|
|
if (ret) {
|
|
|
|
kfree(p->gid_attr_group);
|
|
|
|
goto err_put;
|
|
|
|
}
|
|
|
|
|
2015-12-29 18:43:43 +08:00
|
|
|
p->pma_table = get_counter_table(device, port_num);
|
2015-12-21 22:20:29 +08:00
|
|
|
ret = sysfs_create_group(&p->kobj, p->pma_table);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
2015-12-23 20:56:49 +08:00
|
|
|
goto err_put_gid_attrs;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
p->gid_group.name = "gids";
|
2005-04-29 13:58:46 +08:00
|
|
|
p->gid_group.attrs = alloc_group_attrs(show_port_gid, attr.gid_tbl_len);
|
2013-06-21 11:24:27 +08:00
|
|
|
if (!p->gid_group.attrs) {
|
|
|
|
ret = -ENOMEM;
|
2005-04-29 13:58:46 +08:00
|
|
|
goto err_remove_pma;
|
2013-06-21 11:24:27 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret = sysfs_create_group(&p->kobj, &p->gid_group);
|
|
|
|
if (ret)
|
|
|
|
goto err_free_gid;
|
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
p->gid_attr_group->ndev.name = "ndevs";
|
|
|
|
p->gid_attr_group->ndev.attrs = alloc_group_attrs(show_port_gid_attr_ndev,
|
|
|
|
attr.gid_tbl_len);
|
|
|
|
if (!p->gid_attr_group->ndev.attrs) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_remove_gid;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = sysfs_create_group(&p->gid_attr_group->kobj,
|
|
|
|
&p->gid_attr_group->ndev);
|
|
|
|
if (ret)
|
|
|
|
goto err_free_gid_ndev;
|
|
|
|
|
|
|
|
p->gid_attr_group->type.name = "types";
|
|
|
|
p->gid_attr_group->type.attrs = alloc_group_attrs(show_port_gid_attr_gid_type,
|
|
|
|
attr.gid_tbl_len);
|
|
|
|
if (!p->gid_attr_group->type.attrs) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_remove_gid_ndev;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = sysfs_create_group(&p->gid_attr_group->kobj,
|
|
|
|
&p->gid_attr_group->type);
|
|
|
|
if (ret)
|
|
|
|
goto err_free_gid_type;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
p->pkey_group.name = "pkeys";
|
2005-04-29 13:58:46 +08:00
|
|
|
p->pkey_group.attrs = alloc_group_attrs(show_port_pkey,
|
|
|
|
attr.pkey_tbl_len);
|
2013-06-21 11:24:27 +08:00
|
|
|
if (!p->pkey_group.attrs) {
|
|
|
|
ret = -ENOMEM;
|
2015-12-23 20:56:49 +08:00
|
|
|
goto err_remove_gid_type;
|
2013-06-21 11:24:27 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
ret = sysfs_create_group(&p->kobj, &p->pkey_group);
|
|
|
|
if (ret)
|
|
|
|
goto err_free_pkey;
|
|
|
|
|
2010-05-07 08:03:25 +08:00
|
|
|
if (port_callback) {
|
|
|
|
ret = port_callback(device, port_num, &p->kobj);
|
|
|
|
if (ret)
|
|
|
|
goto err_remove_pkey;
|
|
|
|
}
|
|
|
|
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
/*
|
|
|
|
* If port == 0, it means we have only one port and the parent
|
|
|
|
* device, not this port device, should be the holder of the
|
|
|
|
* hw_counters
|
|
|
|
*/
|
|
|
|
if (device->alloc_hw_stats && port_num)
|
|
|
|
setup_hw_stats(device, p, port_num);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
list_add_tail(&p->kobj.entry, &device->port_list);
|
|
|
|
|
2007-12-18 03:54:39 +08:00
|
|
|
kobject_uevent(&p->kobj, KOBJ_ADD);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
2010-05-07 08:03:25 +08:00
|
|
|
err_remove_pkey:
|
|
|
|
sysfs_remove_group(&p->kobj, &p->pkey_group);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
err_free_pkey:
|
2005-04-29 13:58:46 +08:00
|
|
|
for (i = 0; i < attr.pkey_tbl_len; ++i)
|
|
|
|
kfree(p->pkey_group.attrs[i]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
kfree(p->pkey_group.attrs);
|
2014-05-18 16:12:25 +08:00
|
|
|
p->pkey_group.attrs = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
err_remove_gid_type:
|
|
|
|
sysfs_remove_group(&p->gid_attr_group->kobj,
|
|
|
|
&p->gid_attr_group->type);
|
|
|
|
|
|
|
|
err_free_gid_type:
|
|
|
|
for (i = 0; i < attr.gid_tbl_len; ++i)
|
|
|
|
kfree(p->gid_attr_group->type.attrs[i]);
|
|
|
|
|
|
|
|
kfree(p->gid_attr_group->type.attrs);
|
|
|
|
p->gid_attr_group->type.attrs = NULL;
|
|
|
|
|
|
|
|
err_remove_gid_ndev:
|
|
|
|
sysfs_remove_group(&p->gid_attr_group->kobj,
|
|
|
|
&p->gid_attr_group->ndev);
|
|
|
|
|
|
|
|
err_free_gid_ndev:
|
|
|
|
for (i = 0; i < attr.gid_tbl_len; ++i)
|
|
|
|
kfree(p->gid_attr_group->ndev.attrs[i]);
|
|
|
|
|
|
|
|
kfree(p->gid_attr_group->ndev.attrs);
|
|
|
|
p->gid_attr_group->ndev.attrs = NULL;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
err_remove_gid:
|
|
|
|
sysfs_remove_group(&p->kobj, &p->gid_group);
|
|
|
|
|
|
|
|
err_free_gid:
|
2005-04-29 13:58:46 +08:00
|
|
|
for (i = 0; i < attr.gid_tbl_len; ++i)
|
|
|
|
kfree(p->gid_group.attrs[i]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-29 13:58:46 +08:00
|
|
|
kfree(p->gid_group.attrs);
|
2014-05-18 16:12:25 +08:00
|
|
|
p->gid_group.attrs = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
err_remove_pma:
|
2015-12-21 22:20:29 +08:00
|
|
|
sysfs_remove_group(&p->kobj, p->pma_table);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-12-23 20:56:49 +08:00
|
|
|
err_put_gid_attrs:
|
|
|
|
kobject_put(&p->gid_attr_group->kobj);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
err_put:
|
2014-05-18 16:12:25 +08:00
|
|
|
kobject_put(&p->kobj);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static ssize_t show_node_type(struct device *device,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
switch (dev->node_type) {
|
2006-08-04 05:02:42 +08:00
|
|
|
case RDMA_NODE_IB_CA: return sprintf(buf, "%d: CA\n", dev->node_type);
|
|
|
|
case RDMA_NODE_RNIC: return sprintf(buf, "%d: RNIC\n", dev->node_type);
|
2013-09-10 11:36:59 +08:00
|
|
|
case RDMA_NODE_USNIC: return sprintf(buf, "%d: usNIC\n", dev->node_type);
|
2014-01-16 09:02:36 +08:00
|
|
|
case RDMA_NODE_USNIC_UDP: return sprintf(buf, "%d: usNIC UDP\n", dev->node_type);
|
2006-08-04 05:02:42 +08:00
|
|
|
case RDMA_NODE_IB_SWITCH: return sprintf(buf, "%d: switch\n", dev->node_type);
|
|
|
|
case RDMA_NODE_IB_ROUTER: return sprintf(buf, "%d: router\n", dev->node_type);
|
|
|
|
default: return sprintf(buf, "%d: <unknown>\n", dev->node_type);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static ssize_t show_sys_image_guid(struct device *device,
|
|
|
|
struct device_attribute *dev_attr, char *buf)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return sprintf(buf, "%04x:%04x:%04x:%04x\n",
|
2015-12-18 16:59:45 +08:00
|
|
|
be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[0]),
|
|
|
|
be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[1]),
|
|
|
|
be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[2]),
|
|
|
|
be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[3]));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static ssize_t show_node_guid(struct device *device,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return sprintf(buf, "%04x:%04x:%04x:%04x\n",
|
2006-01-10 23:39:34 +08:00
|
|
|
be16_to_cpu(((__be16 *) &dev->node_guid)[0]),
|
|
|
|
be16_to_cpu(((__be16 *) &dev->node_guid)[1]),
|
|
|
|
be16_to_cpu(((__be16 *) &dev->node_guid)[2]),
|
|
|
|
be16_to_cpu(((__be16 *) &dev->node_guid)[3]));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static ssize_t show_node_desc(struct device *device,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2006-02-03 01:47:14 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
2006-02-03 01:47:14 +08:00
|
|
|
|
|
|
|
return sprintf(buf, "%.64s\n", dev->node_desc);
|
|
|
|
}
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static ssize_t set_node_desc(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2006-02-03 01:47:14 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct ib_device *dev = container_of(device, struct ib_device, dev);
|
2006-02-03 01:47:14 +08:00
|
|
|
struct ib_device_modify desc = {};
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!dev->modify_device)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
memcpy(desc.node_desc, buf, min_t(int, count, 64));
|
|
|
|
ret = ib_modify_device(dev, IB_DEVICE_MODIFY_NODE_DESC, &desc);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);
|
|
|
|
static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);
|
|
|
|
static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);
|
|
|
|
static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc);
|
|
|
|
|
|
|
|
static struct device_attribute *ib_class_attributes[] = {
|
|
|
|
&dev_attr_node_type,
|
|
|
|
&dev_attr_sys_image_guid,
|
|
|
|
&dev_attr_node_guid,
|
|
|
|
&dev_attr_node_desc
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2014-05-18 16:12:26 +08:00
|
|
|
static void free_port_list_attributes(struct ib_device *device)
|
|
|
|
{
|
|
|
|
struct kobject *p, *t;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(p, t, &device->port_list, entry) {
|
|
|
|
struct ib_port *port = container_of(p, struct ib_port, kobj);
|
|
|
|
list_del(&p->entry);
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
if (port->hw_stats) {
|
|
|
|
kfree(port->hw_stats);
|
|
|
|
free_hsag(&port->kobj, port->hw_stats_ag);
|
|
|
|
}
|
2015-12-21 22:20:29 +08:00
|
|
|
sysfs_remove_group(p, port->pma_table);
|
2014-05-18 16:12:26 +08:00
|
|
|
sysfs_remove_group(p, &port->pkey_group);
|
|
|
|
sysfs_remove_group(p, &port->gid_group);
|
2015-12-23 20:56:49 +08:00
|
|
|
sysfs_remove_group(&port->gid_attr_group->kobj,
|
|
|
|
&port->gid_attr_group->ndev);
|
|
|
|
sysfs_remove_group(&port->gid_attr_group->kobj,
|
|
|
|
&port->gid_attr_group->type);
|
|
|
|
kobject_put(&port->gid_attr_group->kobj);
|
2014-05-18 16:12:26 +08:00
|
|
|
kobject_put(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
kobject_put(device->ports_parent);
|
|
|
|
}
|
|
|
|
|
2010-05-07 08:03:25 +08:00
|
|
|
int ib_device_register_sysfs(struct ib_device *device,
|
|
|
|
int (*port_callback)(struct ib_device *,
|
|
|
|
u8, struct kobject *))
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-22 07:13:36 +08:00
|
|
|
struct device *class_dev = &device->dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
int ret;
|
|
|
|
int i;
|
|
|
|
|
2015-08-05 05:23:34 +08:00
|
|
|
device->dev.parent = device->dma_device;
|
|
|
|
ret = dev_set_name(class_dev, "%s", device->name);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-08-05 05:23:34 +08:00
|
|
|
ret = device_add(class_dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) {
|
2008-02-22 07:13:36 +08:00
|
|
|
ret = device_create_file(class_dev, ib_class_attributes[i]);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
|
|
|
goto err_unregister;
|
|
|
|
}
|
|
|
|
|
2007-12-18 03:54:39 +08:00
|
|
|
device->ports_parent = kobject_create_and_add("ports",
|
2014-05-18 16:12:24 +08:00
|
|
|
&class_dev->kobj);
|
2008-02-15 10:24:49 +08:00
|
|
|
if (!device->ports_parent) {
|
|
|
|
ret = -ENOMEM;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto err_put;
|
2008-02-15 10:24:49 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-06-29 21:57:00 +08:00
|
|
|
if (rdma_cap_ib_switch(device)) {
|
2010-05-07 08:03:25 +08:00
|
|
|
ret = add_port(device, 0, port_callback);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
|
|
|
goto err_put;
|
|
|
|
} else {
|
|
|
|
for (i = 1; i <= device->phys_port_cnt; ++i) {
|
2010-05-07 08:03:25 +08:00
|
|
|
ret = add_port(device, i, port_callback);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ret)
|
|
|
|
goto err_put;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
if (device->alloc_hw_stats)
|
|
|
|
setup_hw_stats(device, NULL, 0);
|
2008-07-15 14:48:48 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_put:
|
2014-05-18 16:12:26 +08:00
|
|
|
free_port_list_attributes(device);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
err_unregister:
|
2008-02-22 07:13:36 +08:00
|
|
|
device_unregister(class_dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
err:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ib_device_unregister_sysfs(struct ib_device *device)
|
|
|
|
{
|
2014-05-18 16:12:26 +08:00
|
|
|
int i;
|
2009-02-26 05:27:46 +08:00
|
|
|
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
/* Hold kobject until ib_dealloc_device() */
|
|
|
|
kobject_get(&device->dev.kobj);
|
2014-05-18 16:12:26 +08:00
|
|
|
|
|
|
|
free_port_list_attributes(device);
|
|
|
|
|
IB/core: Make device counter infrastructure dynamic
In practice, each RDMA device has a unique set of counters that the
hardware implements. Having a central set of counters that they must
all adhere to is limiting and causes many useful counters to not be
available.
Therefore we create a dynamic counter registration infrastructure.
The driver must implement a stats structure allocation routine, in
which the driver must place the directory name it wants, a list of
names for all of the counters, an array of u64 counters themselves,
plus a few generic configuration options.
We then implement a core routine to create a sysfs file for each
of the named stats elements, and a core routine to retrieve the
stats when any of the sysfs attribute files are read.
To avoid excessive beating on the stats generation routine in the
drivers, the core code also caches the stats for a short period of
time so that someone attempting to read all of the stats in a
given device's directory will not result in a stats generation
call per file read.
Future work will attempt to standardize just the shared stats
elements, and possibly add a method to get the stats via netlink
in addition to sysfs.
Signed-off-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Mark Bloch <markb@mellanox.com>
Reviewed-by: Steve Wise <swise@opengridcomputing.com>
Signed-off-by: Doug Ledford <dledford@redhat.com>
[ Add caching, make structure names more informative, add i40iw support,
other significant rewrites from the original patch ]
2016-05-17 01:49:33 +08:00
|
|
|
if (device->hw_stats) {
|
|
|
|
kfree(device->hw_stats);
|
|
|
|
free_hsag(&device->dev.kobj, device->hw_stats_ag);
|
|
|
|
}
|
|
|
|
|
2014-05-18 16:12:26 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i)
|
|
|
|
device_remove_file(&device->dev, ib_class_attributes[i]);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-02-22 07:13:36 +08:00
|
|
|
device_unregister(&device->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|