mirrors/linux-stable
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2024-09-07 03:18:31 +00:00
Code Issues Releases Wiki Activity

RDMA/core: Simplify how the port sysfs is created

Browse source 
Use the same technique as gid_attrs now uses to manage the port
sysfs. Bundle everything into three allocations and use a single
sysfs_create_groups() to build everything in one shot.

All the memory is always freed in the kobj release function, removing most
of the error unwinding.

The gid_attr technique and the hw_counters are very similar, merge the two
together and combine the sysfs_create_group() call for hw_counters with
the single sysfs group setup.

Link: https://lore.kernel.org/r/b688f3340694c59f7b44b1bde40e25559ef43cf3.1623427137.git.leonro@nvidia.com
Signed-off-by: Leon Romanovsky <leonro@nvidia.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
This commit is contained in:
Jason Gunthorpe 2021-06-11 19:00:25 +03:00
parent a4676388e2
commit 2ca1cca435
1 changed files with 103 additions and 219 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

314
drivers/infiniband/core/sysfs.c
View file

@ -79,11 +79,12 @@ struct ib_port {
struct kobject kobj; struct kobject kobj;
struct ib_device *ibdev; struct ib_device *ibdev;
struct gid_attr_group *gid_attr_group; struct gid_attr_group *gid_attr_group;
struct attribute_group gid_group;
struct attribute_group *pkey_group;
const struct attribute_group *pma_table;
struct hw_stats_port_data *hw_stats_data; struct hw_stats_port_data *hw_stats_data;
struct attribute_group groups[3];
const struct attribute_group *groups_list[5];
u32 port_num; u32 port_num;
struct port_table_attribute attrs_list[];
}; };
struct hw_stats_device_attribute { struct hw_stats_device_attribute {
@ -112,7 +113,6 @@ struct hw_stats_device_data {
}; };
struct hw_stats_port_data { struct hw_stats_port_data {
struct attribute_group group;
struct rdma_hw_stats *stats; struct rdma_hw_stats *stats;
struct hw_stats_port_attribute attrs[]; struct hw_stats_port_attribute attrs[];
}; };
@ -750,30 +750,15 @@ static const struct attribute_group pma_group_noietf = {
static void ib_port_release(struct kobject *kobj) static void ib_port_release(struct kobject *kobj)
{ {
struct ib_port *p = container_of(kobj, struct ib_port, kobj); struct ib_port *port = container_of(kobj, struct ib_port, kobj);
struct attribute *a;
int i; int i;
if (p->gid_group.attrs) { for (i = 0; i != ARRAY_SIZE(port->groups); i++)
for (i = 0; (a = p->gid_group.attrs[i]); ++i) kfree(port->groups[i].attrs);
kfree(a); if (port->hw_stats_data)
kfree(port->hw_stats_data->stats);
kfree(p->gid_group.attrs); kfree(port->hw_stats_data);
} kfree(port);
if (p->pkey_group) {
if (p->pkey_group->attrs) {
for (i = 0; (a = p->pkey_group->attrs[i]); ++i)
kfree(a);
kfree(p->pkey_group->attrs);
}
kfree(p->pkey_group);
p->pkey_group = NULL;
}
kfree(p);
} }
static void ib_port_gid_attr_release(struct kobject *kobj) static void ib_port_gid_attr_release(struct kobject *kobj)
@ -798,49 +783,6 @@ static struct kobj_type gid_attr_type = {
.release = ib_port_gid_attr_release .release = ib_port_gid_attr_release
}; };
static struct attribute **
alloc_group_attrs(ssize_t (*show)(struct ib_port *,
struct port_attribute *, char *buf),
int len)
{
struct attribute **tab_attr;
struct port_table_attribute *element;
int i;
tab_attr = kcalloc(1 + len, sizeof(struct attribute *), GFP_KERNEL);
if (!tab_attr)
return NULL;
for (i = 0; i < len; i++) {
element = kzalloc(sizeof(struct port_table_attribute),
GFP_KERNEL);
if (!element)
goto err;
if (snprintf(element->name, sizeof(element->name),
"%d", i) >= sizeof(element->name)) {
kfree(element);
goto err;
}
element->attr.attr.name = element->name;
element->attr.attr.mode = S_IRUGO;
element->attr.show = show;
element->index = i;
sysfs_attr_init(&element->attr.attr);
tab_attr[i] = &element->attr.attr;
}
return tab_attr;
err:
while (--i >= 0)
kfree(tab_attr[i]);
kfree(tab_attr);
return NULL;
}
/* /*
* Figure out which counter table to use depending on * Figure out which counter table to use depending on
* the device capabilities. * the device capabilities.
@ -1051,7 +993,8 @@ static void destroy_hw_device_stats(struct ib_device *ibdev)
ibdev->hw_stats_data = NULL; ibdev->hw_stats_data = NULL;
} }
static struct hw_stats_port_data *alloc_hw_stats_port(struct ib_port *port) static struct hw_stats_port_data *
alloc_hw_stats_port(struct ib_port *port, struct attribute_group *group)
{ {
struct ib_device *ibdev = port->ibdev; struct ib_device *ibdev = port->ibdev;
struct hw_stats_port_data *data; struct hw_stats_port_data *data;
@ -1073,13 +1016,13 @@ static struct hw_stats_port_data *alloc_hw_stats_port(struct ib_port *port)
GFP_KERNEL); GFP_KERNEL);
if (!data) if (!data)
goto err_free_stats; goto err_free_stats;
data->group.attrs = kcalloc(stats->num_counters + 2, group->attrs = kcalloc(stats->num_counters + 2,
sizeof(*data->group.attrs), GFP_KERNEL); sizeof(*group->attrs), GFP_KERNEL);
if (!data->group.attrs) if (!group->attrs)
goto err_free_data; goto err_free_data;
mutex_init(&stats->lock); mutex_init(&stats->lock);
data->group.name = "hw_counters"; group->name = "hw_counters";
data->stats = stats; data->stats = stats;
return data; return data;
@ -1090,20 +1033,14 @@ static struct hw_stats_port_data *alloc_hw_stats_port(struct ib_port *port)
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
static void free_hw_stats_port(struct hw_stats_port_data *data) static int setup_hw_port_stats(struct ib_port *port,
{ struct attribute_group *group)
kfree(data->group.attrs);
kfree(data->stats);
kfree(data);
}
static int setup_hw_port_stats(struct ib_port *port)
{ {
struct hw_stats_port_attribute *attr; struct hw_stats_port_attribute *attr;
struct hw_stats_port_data *data; struct hw_stats_port_data *data;
int i, ret; int i, ret;
data = alloc_hw_stats_port(port); data = alloc_hw_stats_port(port, group);
if (IS_ERR(data)) if (IS_ERR(data))
return PTR_ERR(data); return PTR_ERR(data);
@ -1112,9 +1049,10 @@ static int setup_hw_port_stats(struct ib_port *port)
data->stats->num_counters); data->stats->num_counters);
if (ret != data->stats->num_counters) { if (ret != data->stats->num_counters) {
if (WARN_ON(ret >= 0)) if (WARN_ON(ret >= 0))
ret = -EINVAL; return -EINVAL;
goto err_free; return ret;
} }
data->stats->timestamp = jiffies; data->stats->timestamp = jiffies;
for (i = 0; i < data->stats->num_counters; i++) { for (i = 0; i < data->stats->num_counters; i++) {
@ -1124,7 +1062,7 @@ static int setup_hw_port_stats(struct ib_port *port)
attr->attr.attr.mode = 0444; attr->attr.attr.mode = 0444;
attr->attr.show = hw_stat_port_show; attr->attr.show = hw_stat_port_show;
attr->show = show_hw_stats; attr->show = show_hw_stats;
data->group.attrs[i] = &attr->attr.attr; group->attrs[i] = &attr->attr.attr;
} }
attr = &data->attrs[i]; attr = &data->attrs[i];
@ -1135,27 +1073,10 @@ static int setup_hw_port_stats(struct ib_port *port)
attr->show = show_stats_lifespan; attr->show = show_stats_lifespan;
attr->attr.store = hw_stat_port_store; attr->attr.store = hw_stat_port_store;
attr->store = set_stats_lifespan; attr->store = set_stats_lifespan;
data->group.attrs[i] = &attr->attr.attr; group->attrs[i] = &attr->attr.attr;
port->hw_stats_data = data; port->hw_stats_data = data;
ret = sysfs_create_group(&port->kobj, &data->group);
if (ret)
goto err_free;
return 0; return 0;
err_free:
free_hw_stats_port(data);
port->hw_stats_data = NULL;
return ret;
}
static void destroy_hw_port_stats(struct ib_port *port)
{
if (!port->hw_stats_data)
return;
sysfs_remove_group(&port->kobj, &port->hw_stats_data->group);
free_hw_stats_port(port->hw_stats_data);
port->hw_stats_data = NULL;
} }
struct rdma_hw_stats *ib_get_hw_stats_port(struct ib_device *ibdev, struct rdma_hw_stats *ib_get_hw_stats_port(struct ib_device *ibdev,
@ -1265,68 +1186,42 @@ static void destroy_gid_attrs(struct ib_port *port)
kobject_put(&gid_attr_group->kobj); kobject_put(&gid_attr_group->kobj);
} }
static int add_port(struct ib_core_device *coredev, int port_num) /*
* Create the sysfs:
* ibp0s9/ports/XX/{gids,pkeys,counters}/YYY
*/
static struct ib_port *setup_port(struct ib_core_device *coredev, int port_num,
const struct ib_port_attr *attr)
{ {
struct ib_device *device = rdma_device_to_ibdev(&coredev->dev); struct ib_device *device = rdma_device_to_ibdev(&coredev->dev);
bool is_full_dev = &device->coredev == coredev; bool is_full_dev = &device->coredev == coredev;
const struct attribute_group **cur_group;
struct ib_port *p; struct ib_port *p;
struct ib_port_attr attr;
int i;
int ret; int ret;
ret = ib_query_port(device, port_num, &attr); p = kzalloc(struct_size(p, attrs_list,
if (ret) attr->gid_tbl_len + attr->pkey_tbl_len),
return ret; GFP_KERNEL);
p = kzalloc(sizeof *p, GFP_KERNEL);
if (!p) if (!p)
return -ENOMEM; return ERR_PTR(-ENOMEM);
p->ibdev = device; p->ibdev = device;
p->port_num = port_num; p->port_num = port_num;
kobject_init(&p->kobj, &port_type);
ret = kobject_init_and_add(&p->kobj, &port_type, cur_group = p->groups_list;
coredev->ports_kobj, ret = alloc_port_table_group("gids", &p->groups[0], p->attrs_list,
"%d", port_num); attr->gid_tbl_len, show_port_gid);
if (ret) if (ret)
goto err_put; goto err_put;
*cur_group++ = &p->groups[0];
if (device->ops.process_mad && is_full_dev) { if (attr->pkey_tbl_len) {
p->pma_table = get_counter_table(device, port_num); ret = alloc_port_table_group("pkeys", &p->groups[1],
ret = sysfs_create_group(&p->kobj, p->pma_table); p->attrs_list + attr->gid_tbl_len,
attr->pkey_tbl_len, show_port_pkey);
if (ret) if (ret)
goto err_put; goto err_put;
} *cur_group++ = &p->groups[1];
p->gid_group.name = "gids";
p->gid_group.attrs = alloc_group_attrs(show_port_gid, attr.gid_tbl_len);
if (!p->gid_group.attrs) {
ret = -ENOMEM;
goto err_remove_pma;
}
ret = sysfs_create_group(&p->kobj, &p->gid_group);
if (ret)
goto err_free_gid;
if (attr.pkey_tbl_len) {
p->pkey_group = kzalloc(sizeof(*p->pkey_group), GFP_KERNEL);
if (!p->pkey_group) {
ret = -ENOMEM;
goto err_remove_gid;
}
p->pkey_group->name = "pkeys";
p->pkey_group->attrs = alloc_group_attrs(show_port_pkey,
attr.pkey_tbl_len);
if (!p->pkey_group->attrs) {
ret = -ENOMEM;
goto err_free_pkey_group;
}
ret = sysfs_create_group(&p->kobj, p->pkey_group);
if (ret)
goto err_free_pkey;
} }
/* /*
@ -1335,66 +1230,45 @@ static int add_port(struct ib_core_device *coredev, int port_num)
* counter initialization. * counter initialization.
*/ */
if (port_num && is_full_dev) { if (port_num && is_full_dev) {
ret = setup_hw_port_stats(p); ret = setup_hw_port_stats(p, &p->groups[2]);
if (ret && ret != -EOPNOTSUPP) if (ret && ret != -EOPNOTSUPP)
goto err_remove_pkey; goto err_put;
if (!ret)
*cur_group++ = &p->groups[2];
} }
ret = setup_gid_attrs(p, &attr);
if (ret)
goto err_remove_stats;
if (device->ops.init_port && is_full_dev) { if (device->ops.process_mad && is_full_dev)
ret = device->ops.init_port(device, port_num, &p->kobj); *cur_group++ = get_counter_table(device, port_num);
ret = kobject_add(&p->kobj, coredev->ports_kobj, "%d", port_num);
if (ret) if (ret)
goto err_remove_gid_attrs; goto err_put;
} ret = sysfs_create_groups(&p->kobj, p->groups_list);
if (ret)
goto err_del;
list_add_tail(&p->kobj.entry, &coredev->port_list); list_add_tail(&p->kobj.entry, &coredev->port_list);
if (device->port_data && is_full_dev) if (device->port_data && is_full_dev)
device->port_data[port_num].sysfs = p; device->port_data[port_num].sysfs = p;
kobject_uevent(&p->kobj, KOBJ_ADD); return p;
return 0;
err_remove_gid_attrs:
destroy_gid_attrs(p);
err_remove_stats:
destroy_hw_port_stats(p);
err_remove_pkey:
if (p->pkey_group)
sysfs_remove_group(&p->kobj, p->pkey_group);
err_free_pkey:
if (p->pkey_group) {
for (i = 0; i < attr.pkey_tbl_len; ++i)
kfree(p->pkey_group->attrs[i]);
kfree(p->pkey_group->attrs);
p->pkey_group->attrs = NULL;
}
err_free_pkey_group:
kfree(p->pkey_group);
err_remove_gid:
sysfs_remove_group(&p->kobj, &p->gid_group);
err_free_gid:
for (i = 0; i < attr.gid_tbl_len; ++i)
kfree(p->gid_group.attrs[i]);
kfree(p->gid_group.attrs);
p->gid_group.attrs = NULL;
err_remove_pma:
if (p->pma_table)
sysfs_remove_group(&p->kobj, p->pma_table);
err_del:
kobject_del(&p->kobj);
err_put: err_put:
kobject_put(&p->kobj); kobject_put(&p->kobj);
return ret; return ERR_PTR(ret);
}
static void destroy_port(struct ib_port *port)
{
if (port->ibdev->port_data &&
port->ibdev->port_data[port->port_num].sysfs == port)
port->ibdev->port_data[port->port_num].sysfs = NULL;
list_del(&port->kobj.entry);
sysfs_remove_groups(&port->kobj, port->groups_list);
kobject_del(&port->kobj);
kobject_put(&port->kobj);
} }
static const char *node_type_string(int node_type) static const char *node_type_string(int node_type)
@ -1511,25 +1385,13 @@ const struct attribute_group ib_dev_attr_group = {
void ib_free_port_attrs(struct ib_core_device *coredev) 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; struct kobject *p, *t;
list_for_each_entry_safe(p, t, &coredev->port_list, entry) { list_for_each_entry_safe(p, t, &coredev->port_list, entry) {
struct ib_port *port = container_of(p, struct ib_port, kobj); struct ib_port *port = container_of(p, struct ib_port, kobj);
list_del(&p->entry);
destroy_hw_port_stats(port);
if (device->port_data && is_full_dev)
device->port_data[port->port_num].sysfs = NULL;
if (port->pma_table)
sysfs_remove_group(p, port->pma_table);
if (port->pkey_group)
sysfs_remove_group(p, port->pkey_group);
sysfs_remove_group(p, &port->gid_group);
destroy_gid_attrs(port); destroy_gid_attrs(port);
kobject_put(p); destroy_port(port);
} }
kobject_put(coredev->ports_kobj); kobject_put(coredev->ports_kobj);
@ -1538,7 +1400,8 @@ void ib_free_port_attrs(struct ib_core_device *coredev)
int ib_setup_port_attrs(struct ib_core_device *coredev) int ib_setup_port_attrs(struct ib_core_device *coredev)
{ {
struct ib_device *device = rdma_device_to_ibdev(&coredev->dev); struct ib_device *device = rdma_device_to_ibdev(&coredev->dev);
u32 port; bool is_full_dev = &device->coredev == coredev;
u32 port_num;
int ret; int ret;
coredev->ports_kobj = kobject_create_and_add("ports", coredev->ports_kobj = kobject_create_and_add("ports",
@ -1546,12 +1409,33 @@ int ib_setup_port_attrs(struct ib_core_device *coredev)
if (!coredev->ports_kobj) if (!coredev->ports_kobj)
return -ENOMEM; return -ENOMEM;
rdma_for_each_port (device, port) { rdma_for_each_port (device, port_num) {
ret = add_port(coredev, port); struct ib_port_attr attr;
struct ib_port *port;
ret = ib_query_port(device, port_num, &attr);
if (ret)
goto err_put;
port = setup_port(coredev, port_num, &attr);
if (IS_ERR(port)) {
ret = PTR_ERR(port);
goto err_put;
}
ret = setup_gid_attrs(port, &attr);
if (ret)
goto err_put;
if (device->ops.init_port && is_full_dev) {
ret = device->ops.init_port(device, port_num,
&port->kobj);
if (ret) if (ret)
goto err_put; goto err_put;
} }
kobject_uevent(&port->kobj, KOBJ_ADD);
}
return 0; return 0;
err_put: err_put: