1 /* 2 * Copyright (c) 2012 Mellanox Technologies. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 33 /*#include "core_priv.h"*/ 34 #include "mlx4_ib.h" 35 #include <linux/slab.h> 36 #include <linux/string.h> 37 #include <linux/stat.h> 38 39 #include <rdma/ib_mad.h> 40 /*show_admin_alias_guid returns the administratively assigned value of that GUID. 41 * Values returned in buf parameter string: 42 * 0 - requests opensm to assign a value. 43 * ffffffffffffffff - delete this entry. 44 * other - value assigned by administrator. 45 */ 46 static ssize_t show_admin_alias_guid(struct device *dev, 47 struct device_attribute *attr, char *buf) 48 { 49 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry = 50 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry); 51 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx; 52 struct mlx4_ib_dev *mdev = port->dev; 53 __be64 sysadmin_ag_val; 54 55 sysadmin_ag_val = mlx4_get_admin_guid(mdev->dev, 56 mlx4_ib_iov_dentry->entry_num, 57 port->num); 58 59 return sysfs_emit(buf, "%llx\n", be64_to_cpu(sysadmin_ag_val)); 60 } 61 62 /* store_admin_alias_guid stores the (new) administratively assigned value of that GUID. 63 * Values in buf parameter string: 64 * 0 - requests opensm to assign a value. 65 * 0xffffffffffffffff - delete this entry. 66 * other - guid value assigned by the administrator. 67 */ 68 static ssize_t store_admin_alias_guid(struct device *dev, 69 struct device_attribute *attr, 70 const char *buf, size_t count) 71 { 72 int record_num;/*0-15*/ 73 int guid_index_in_rec; /*0 - 7*/ 74 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry = 75 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry); 76 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx; 77 struct mlx4_ib_dev *mdev = port->dev; 78 u64 sysadmin_ag_val; 79 unsigned long flags; 80 81 record_num = mlx4_ib_iov_dentry->entry_num / 8; 82 guid_index_in_rec = mlx4_ib_iov_dentry->entry_num % 8; 83 if (0 == record_num && 0 == guid_index_in_rec) { 84 pr_err("GUID 0 block 0 is RO\n"); 85 return count; 86 } 87 spin_lock_irqsave(&mdev->sriov.alias_guid.ag_work_lock, flags); 88 sscanf(buf, "%llx", &sysadmin_ag_val); 89 *(__be64 *)&mdev->sriov.alias_guid.ports_guid[port->num - 1]. 90 all_rec_per_port[record_num]. 91 all_recs[GUID_REC_SIZE * guid_index_in_rec] = 92 cpu_to_be64(sysadmin_ag_val); 93 94 /* Change the state to be pending for update */ 95 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].status 96 = MLX4_GUID_INFO_STATUS_IDLE ; 97 mlx4_set_admin_guid(mdev->dev, cpu_to_be64(sysadmin_ag_val), 98 mlx4_ib_iov_dentry->entry_num, 99 port->num); 100 101 /* set the record index */ 102 mdev->sriov.alias_guid.ports_guid[port->num - 1].all_rec_per_port[record_num].guid_indexes 103 |= mlx4_ib_get_aguid_comp_mask_from_ix(guid_index_in_rec); 104 105 spin_unlock_irqrestore(&mdev->sriov.alias_guid.ag_work_lock, flags); 106 mlx4_ib_init_alias_guid_work(mdev, port->num - 1); 107 108 return count; 109 } 110 111 static ssize_t show_port_gid(struct device *dev, 112 struct device_attribute *attr, 113 char *buf) 114 { 115 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry = 116 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry); 117 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx; 118 struct mlx4_ib_dev *mdev = port->dev; 119 union ib_gid gid; 120 int ret; 121 __be16 *raw; 122 123 ret = __mlx4_ib_query_gid(&mdev->ib_dev, port->num, 124 mlx4_ib_iov_dentry->entry_num, &gid, 1); 125 if (ret) 126 return ret; 127 128 raw = (__be16 *)gid.raw; 129 return sysfs_emit(buf, "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x\n", 130 be16_to_cpu(raw[0]), 131 be16_to_cpu(raw[1]), 132 be16_to_cpu(raw[2]), 133 be16_to_cpu(raw[3]), 134 be16_to_cpu(raw[4]), 135 be16_to_cpu(raw[5]), 136 be16_to_cpu(raw[6]), 137 be16_to_cpu(raw[7])); 138 } 139 140 static ssize_t show_phys_port_pkey(struct device *dev, 141 struct device_attribute *attr, 142 char *buf) 143 { 144 struct mlx4_ib_iov_sysfs_attr *mlx4_ib_iov_dentry = 145 container_of(attr, struct mlx4_ib_iov_sysfs_attr, dentry); 146 struct mlx4_ib_iov_port *port = mlx4_ib_iov_dentry->ctx; 147 struct mlx4_ib_dev *mdev = port->dev; 148 u16 pkey; 149 ssize_t ret; 150 151 ret = __mlx4_ib_query_pkey(&mdev->ib_dev, port->num, 152 mlx4_ib_iov_dentry->entry_num, &pkey, 1); 153 if (ret) 154 return ret; 155 156 return sysfs_emit(buf, "0x%04x\n", pkey); 157 } 158 159 #define DENTRY_REMOVE(_dentry) \ 160 do { \ 161 sysfs_remove_file((_dentry)->kobj, &(_dentry)->dentry.attr); \ 162 } while (0); 163 164 static int create_sysfs_entry(void *_ctx, struct mlx4_ib_iov_sysfs_attr *_dentry, 165 char *_name, struct kobject *_kobj, 166 ssize_t (*show)(struct device *dev, 167 struct device_attribute *attr, 168 char *buf), 169 ssize_t (*store)(struct device *dev, 170 struct device_attribute *attr, 171 const char *buf, size_t count) 172 ) 173 { 174 int ret = 0; 175 struct mlx4_ib_iov_sysfs_attr *vdentry = _dentry; 176 177 vdentry->ctx = _ctx; 178 vdentry->dentry.show = show; 179 vdentry->dentry.store = store; 180 sysfs_attr_init(&vdentry->dentry.attr); 181 vdentry->dentry.attr.name = vdentry->name; 182 vdentry->dentry.attr.mode = 0; 183 vdentry->kobj = _kobj; 184 snprintf(vdentry->name, 15, "%s", _name); 185 186 if (vdentry->dentry.store) 187 vdentry->dentry.attr.mode |= S_IWUSR; 188 189 if (vdentry->dentry.show) 190 vdentry->dentry.attr.mode |= S_IRUGO; 191 192 ret = sysfs_create_file(vdentry->kobj, &vdentry->dentry.attr); 193 if (ret) { 194 pr_err("failed to create %s\n", vdentry->dentry.attr.name); 195 vdentry->ctx = NULL; 196 return ret; 197 } 198 199 return ret; 200 } 201 202 int add_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num, 203 struct attribute *attr) 204 { 205 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1]; 206 int ret; 207 208 ret = sysfs_create_file(port->mcgs_parent, attr); 209 if (ret) 210 pr_err("failed to create %s\n", attr->name); 211 212 return ret; 213 } 214 215 void del_sysfs_port_mcg_attr(struct mlx4_ib_dev *device, int port_num, 216 struct attribute *attr) 217 { 218 struct mlx4_ib_iov_port *port = &device->iov_ports[port_num - 1]; 219 220 sysfs_remove_file(port->mcgs_parent, attr); 221 } 222 223 static int add_port_entries(struct mlx4_ib_dev *device, int port_num) 224 { 225 int i; 226 char buff[11]; 227 struct mlx4_ib_iov_port *port = NULL; 228 int ret = 0 ; 229 struct ib_port_attr attr; 230 231 memset(&attr, 0, sizeof(attr)); 232 /* get the physical gid and pkey table sizes.*/ 233 ret = __mlx4_ib_query_port(&device->ib_dev, port_num, &attr, 1); 234 if (ret) 235 goto err; 236 237 port = &device->iov_ports[port_num - 1]; 238 port->dev = device; 239 port->num = port_num; 240 /* Directory structure: 241 * iov - 242 * port num - 243 * admin_guids 244 * gids (operational) 245 * mcg_table 246 */ 247 port->dentr_ar = kzalloc(sizeof (struct mlx4_ib_iov_sysfs_attr_ar), 248 GFP_KERNEL); 249 if (!port->dentr_ar) { 250 ret = -ENOMEM; 251 goto err; 252 } 253 sprintf(buff, "%d", port_num); 254 port->cur_port = kobject_create_and_add(buff, 255 kobject_get(device->ports_parent)); 256 if (!port->cur_port) { 257 ret = -ENOMEM; 258 goto kobj_create_err; 259 } 260 /* admin GUIDs */ 261 port->admin_alias_parent = kobject_create_and_add("admin_guids", 262 kobject_get(port->cur_port)); 263 if (!port->admin_alias_parent) { 264 ret = -ENOMEM; 265 goto err_admin_guids; 266 } 267 for (i = 0 ; i < attr.gid_tbl_len; i++) { 268 sprintf(buff, "%d", i); 269 port->dentr_ar->dentries[i].entry_num = i; 270 ret = create_sysfs_entry(port, &port->dentr_ar->dentries[i], 271 buff, port->admin_alias_parent, 272 show_admin_alias_guid, store_admin_alias_guid); 273 if (ret) 274 goto err_admin_alias_parent; 275 } 276 277 /* gids subdirectory (operational gids) */ 278 port->gids_parent = kobject_create_and_add("gids", 279 kobject_get(port->cur_port)); 280 if (!port->gids_parent) { 281 ret = -ENOMEM; 282 goto err_gids; 283 } 284 285 for (i = 0 ; i < attr.gid_tbl_len; i++) { 286 sprintf(buff, "%d", i); 287 port->dentr_ar->dentries[attr.gid_tbl_len + i].entry_num = i; 288 ret = create_sysfs_entry(port, 289 &port->dentr_ar->dentries[attr.gid_tbl_len + i], 290 buff, 291 port->gids_parent, show_port_gid, NULL); 292 if (ret) 293 goto err_gids_parent; 294 } 295 296 /* physical port pkey table */ 297 port->pkeys_parent = 298 kobject_create_and_add("pkeys", kobject_get(port->cur_port)); 299 if (!port->pkeys_parent) { 300 ret = -ENOMEM; 301 goto err_pkeys; 302 } 303 304 for (i = 0 ; i < attr.pkey_tbl_len; i++) { 305 sprintf(buff, "%d", i); 306 port->dentr_ar->dentries[2 * attr.gid_tbl_len + i].entry_num = i; 307 ret = create_sysfs_entry(port, 308 &port->dentr_ar->dentries[2 * attr.gid_tbl_len + i], 309 buff, port->pkeys_parent, 310 show_phys_port_pkey, NULL); 311 if (ret) 312 goto err_pkeys_parent; 313 } 314 315 /* MCGs table */ 316 port->mcgs_parent = 317 kobject_create_and_add("mcgs", kobject_get(port->cur_port)); 318 if (!port->mcgs_parent) { 319 ret = -ENOMEM; 320 goto err_mcgs; 321 } 322 return 0; 323 324 err_mcgs: 325 kobject_put(port->cur_port); 326 327 err_pkeys_parent: 328 kobject_put(port->pkeys_parent); 329 330 err_pkeys: 331 kobject_put(port->cur_port); 332 333 err_gids_parent: 334 kobject_put(port->gids_parent); 335 336 err_gids: 337 kobject_put(port->cur_port); 338 339 err_admin_alias_parent: 340 kobject_put(port->admin_alias_parent); 341 342 err_admin_guids: 343 kobject_put(port->cur_port); 344 kobject_put(port->cur_port); /* once more for create_and_add buff */ 345 346 kobj_create_err: 347 kobject_put(device->ports_parent); 348 kfree(port->dentr_ar); 349 350 err: 351 pr_err("add_port_entries FAILED: for port:%d, error: %d\n", 352 port_num, ret); 353 return ret; 354 } 355 356 static void get_name(struct mlx4_ib_dev *dev, char *name, int i, int max) 357 { 358 /* pci_name format is: bus:dev:func -> xxxx:yy:zz.n 359 * with no ARI only 3 last bits are used so when the fn is higher than 8 360 * need to add it to the dev num, so count in the last number will be 361 * modulo 8 */ 362 snprintf(name, max, "%.8s%.2d.%d", pci_name(dev->dev->persist->pdev), 363 i / 8, i % 8); 364 } 365 366 struct mlx4_port { 367 struct kobject kobj; 368 struct mlx4_ib_dev *dev; 369 struct attribute_group pkey_group; 370 struct attribute_group gid_group; 371 struct device_attribute enable_smi_admin; 372 struct device_attribute smi_enabled; 373 int slave; 374 u8 port_num; 375 }; 376 377 378 static void mlx4_port_release(struct kobject *kobj) 379 { 380 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj); 381 struct attribute *a; 382 int i; 383 384 for (i = 0; (a = p->pkey_group.attrs[i]); ++i) 385 kfree(a); 386 kfree(p->pkey_group.attrs); 387 for (i = 0; (a = p->gid_group.attrs[i]); ++i) 388 kfree(a); 389 kfree(p->gid_group.attrs); 390 kfree(p); 391 } 392 393 struct port_attribute { 394 struct attribute attr; 395 ssize_t (*show)(struct mlx4_port *, struct port_attribute *, char *buf); 396 ssize_t (*store)(struct mlx4_port *, struct port_attribute *, 397 const char *buf, size_t count); 398 }; 399 400 static ssize_t port_attr_show(struct kobject *kobj, 401 struct attribute *attr, char *buf) 402 { 403 struct port_attribute *port_attr = 404 container_of(attr, struct port_attribute, attr); 405 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj); 406 407 if (!port_attr->show) 408 return -EIO; 409 return port_attr->show(p, port_attr, buf); 410 } 411 412 static ssize_t port_attr_store(struct kobject *kobj, 413 struct attribute *attr, 414 const char *buf, size_t size) 415 { 416 struct port_attribute *port_attr = 417 container_of(attr, struct port_attribute, attr); 418 struct mlx4_port *p = container_of(kobj, struct mlx4_port, kobj); 419 420 if (!port_attr->store) 421 return -EIO; 422 return port_attr->store(p, port_attr, buf, size); 423 } 424 425 static const struct sysfs_ops port_sysfs_ops = { 426 .show = port_attr_show, 427 .store = port_attr_store, 428 }; 429 430 static struct kobj_type port_type = { 431 .release = mlx4_port_release, 432 .sysfs_ops = &port_sysfs_ops, 433 }; 434 435 struct port_table_attribute { 436 struct port_attribute attr; 437 char name[8]; 438 int index; 439 }; 440 441 static ssize_t show_port_pkey(struct mlx4_port *p, struct port_attribute *attr, 442 char *buf) 443 { 444 struct port_table_attribute *tab_attr = 445 container_of(attr, struct port_table_attribute, attr); 446 ssize_t ret = -ENODEV; 447 448 if (p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1][tab_attr->index] >= 449 (p->dev->dev->caps.pkey_table_len[p->port_num])) 450 ret = sprintf(buf, "none\n"); 451 else 452 ret = sprintf(buf, "%d\n", 453 p->dev->pkeys.virt2phys_pkey[p->slave] 454 [p->port_num - 1][tab_attr->index]); 455 return ret; 456 } 457 458 static ssize_t store_port_pkey(struct mlx4_port *p, struct port_attribute *attr, 459 const char *buf, size_t count) 460 { 461 struct port_table_attribute *tab_attr = 462 container_of(attr, struct port_table_attribute, attr); 463 int idx; 464 int err; 465 466 /* do not allow remapping Dom0 virtual pkey table */ 467 if (p->slave == mlx4_master_func_num(p->dev->dev)) 468 return -EINVAL; 469 470 if (!strncasecmp(buf, "no", 2)) 471 idx = p->dev->dev->phys_caps.pkey_phys_table_len[p->port_num] - 1; 472 else if (sscanf(buf, "%i", &idx) != 1 || 473 idx >= p->dev->dev->caps.pkey_table_len[p->port_num] || 474 idx < 0) 475 return -EINVAL; 476 477 p->dev->pkeys.virt2phys_pkey[p->slave][p->port_num - 1] 478 [tab_attr->index] = idx; 479 mlx4_sync_pkey_table(p->dev->dev, p->slave, p->port_num, 480 tab_attr->index, idx); 481 err = mlx4_gen_pkey_eqe(p->dev->dev, p->slave, p->port_num); 482 if (err) { 483 pr_err("mlx4_gen_pkey_eqe failed for slave %d," 484 " port %d, index %d\n", p->slave, p->port_num, idx); 485 return err; 486 } 487 return count; 488 } 489 490 static ssize_t show_port_gid_idx(struct mlx4_port *p, 491 struct port_attribute *attr, char *buf) 492 { 493 return sprintf(buf, "%d\n", p->slave); 494 } 495 496 static struct attribute ** 497 alloc_group_attrs(ssize_t (*show)(struct mlx4_port *, 498 struct port_attribute *, char *buf), 499 ssize_t (*store)(struct mlx4_port *, struct port_attribute *, 500 const char *buf, size_t count), 501 int len) 502 { 503 struct attribute **tab_attr; 504 struct port_table_attribute *element; 505 int i; 506 507 tab_attr = kcalloc(1 + len, sizeof (struct attribute *), GFP_KERNEL); 508 if (!tab_attr) 509 return NULL; 510 511 for (i = 0; i < len; i++) { 512 element = kzalloc(sizeof (struct port_table_attribute), 513 GFP_KERNEL); 514 if (!element) 515 goto err; 516 if (snprintf(element->name, sizeof (element->name), 517 "%d", i) >= sizeof (element->name)) { 518 kfree(element); 519 goto err; 520 } 521 sysfs_attr_init(&element->attr.attr); 522 element->attr.attr.name = element->name; 523 if (store) { 524 element->attr.attr.mode = S_IWUSR | S_IRUGO; 525 element->attr.store = store; 526 } else 527 element->attr.attr.mode = S_IRUGO; 528 529 element->attr.show = show; 530 element->index = i; 531 tab_attr[i] = &element->attr.attr; 532 } 533 return tab_attr; 534 535 err: 536 while (--i >= 0) 537 kfree(tab_attr[i]); 538 kfree(tab_attr); 539 return NULL; 540 } 541 542 static ssize_t sysfs_show_smi_enabled(struct device *dev, 543 struct device_attribute *attr, char *buf) 544 { 545 struct mlx4_port *p = 546 container_of(attr, struct mlx4_port, smi_enabled); 547 548 return sysfs_emit(buf, "%d\n", 549 !!mlx4_vf_smi_enabled(p->dev->dev, p->slave, 550 p->port_num)); 551 } 552 553 static ssize_t sysfs_show_enable_smi_admin(struct device *dev, 554 struct device_attribute *attr, 555 char *buf) 556 { 557 struct mlx4_port *p = 558 container_of(attr, struct mlx4_port, enable_smi_admin); 559 560 return sysfs_emit(buf, "%d\n", 561 !!mlx4_vf_get_enable_smi_admin(p->dev->dev, p->slave, 562 p->port_num)); 563 } 564 565 static ssize_t sysfs_store_enable_smi_admin(struct device *dev, 566 struct device_attribute *attr, 567 const char *buf, size_t count) 568 { 569 struct mlx4_port *p = 570 container_of(attr, struct mlx4_port, enable_smi_admin); 571 int enable; 572 573 if (sscanf(buf, "%i", &enable) != 1 || 574 enable < 0 || enable > 1) 575 return -EINVAL; 576 577 if (mlx4_vf_set_enable_smi_admin(p->dev->dev, p->slave, p->port_num, enable)) 578 return -EINVAL; 579 return count; 580 } 581 582 static int add_vf_smi_entries(struct mlx4_port *p) 583 { 584 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) == 585 IB_LINK_LAYER_ETHERNET; 586 int ret; 587 588 /* do not display entries if eth transport, or if master */ 589 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev)) 590 return 0; 591 592 sysfs_attr_init(&p->smi_enabled.attr); 593 p->smi_enabled.show = sysfs_show_smi_enabled; 594 p->smi_enabled.store = NULL; 595 p->smi_enabled.attr.name = "smi_enabled"; 596 p->smi_enabled.attr.mode = 0444; 597 ret = sysfs_create_file(&p->kobj, &p->smi_enabled.attr); 598 if (ret) { 599 pr_err("failed to create smi_enabled\n"); 600 return ret; 601 } 602 603 sysfs_attr_init(&p->enable_smi_admin.attr); 604 p->enable_smi_admin.show = sysfs_show_enable_smi_admin; 605 p->enable_smi_admin.store = sysfs_store_enable_smi_admin; 606 p->enable_smi_admin.attr.name = "enable_smi_admin"; 607 p->enable_smi_admin.attr.mode = 0644; 608 ret = sysfs_create_file(&p->kobj, &p->enable_smi_admin.attr); 609 if (ret) { 610 pr_err("failed to create enable_smi_admin\n"); 611 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr); 612 return ret; 613 } 614 return 0; 615 } 616 617 static void remove_vf_smi_entries(struct mlx4_port *p) 618 { 619 int is_eth = rdma_port_get_link_layer(&p->dev->ib_dev, p->port_num) == 620 IB_LINK_LAYER_ETHERNET; 621 622 if (is_eth || p->slave == mlx4_master_func_num(p->dev->dev)) 623 return; 624 625 sysfs_remove_file(&p->kobj, &p->smi_enabled.attr); 626 sysfs_remove_file(&p->kobj, &p->enable_smi_admin.attr); 627 } 628 629 static int add_port(struct mlx4_ib_dev *dev, int port_num, int slave) 630 { 631 struct mlx4_port *p; 632 int i; 633 int ret; 634 int is_eth = rdma_port_get_link_layer(&dev->ib_dev, port_num) == 635 IB_LINK_LAYER_ETHERNET; 636 637 p = kzalloc(sizeof *p, GFP_KERNEL); 638 if (!p) 639 return -ENOMEM; 640 641 p->dev = dev; 642 p->port_num = port_num; 643 p->slave = slave; 644 645 ret = kobject_init_and_add(&p->kobj, &port_type, 646 kobject_get(dev->dev_ports_parent[slave]), 647 "%d", port_num); 648 if (ret) 649 goto err_alloc; 650 651 p->pkey_group.name = "pkey_idx"; 652 p->pkey_group.attrs = 653 alloc_group_attrs(show_port_pkey, 654 is_eth ? NULL : store_port_pkey, 655 dev->dev->caps.pkey_table_len[port_num]); 656 if (!p->pkey_group.attrs) { 657 ret = -ENOMEM; 658 goto err_alloc; 659 } 660 661 ret = sysfs_create_group(&p->kobj, &p->pkey_group); 662 if (ret) 663 goto err_free_pkey; 664 665 p->gid_group.name = "gid_idx"; 666 p->gid_group.attrs = alloc_group_attrs(show_port_gid_idx, NULL, 1); 667 if (!p->gid_group.attrs) { 668 ret = -ENOMEM; 669 goto err_free_pkey; 670 } 671 672 ret = sysfs_create_group(&p->kobj, &p->gid_group); 673 if (ret) 674 goto err_free_gid; 675 676 ret = add_vf_smi_entries(p); 677 if (ret) 678 goto err_free_gid; 679 680 list_add_tail(&p->kobj.entry, &dev->pkeys.pkey_port_list[slave]); 681 return 0; 682 683 err_free_gid: 684 kfree(p->gid_group.attrs[0]); 685 kfree(p->gid_group.attrs); 686 687 err_free_pkey: 688 for (i = 0; i < dev->dev->caps.pkey_table_len[port_num]; ++i) 689 kfree(p->pkey_group.attrs[i]); 690 kfree(p->pkey_group.attrs); 691 692 err_alloc: 693 kobject_put(dev->dev_ports_parent[slave]); 694 kfree(p); 695 return ret; 696 } 697 698 static int register_one_pkey_tree(struct mlx4_ib_dev *dev, int slave) 699 { 700 char name[32]; 701 int err; 702 int port; 703 struct kobject *p, *t; 704 struct mlx4_port *mport; 705 struct mlx4_active_ports actv_ports; 706 707 get_name(dev, name, slave, sizeof name); 708 709 dev->pkeys.device_parent[slave] = 710 kobject_create_and_add(name, kobject_get(dev->iov_parent)); 711 712 if (!dev->pkeys.device_parent[slave]) { 713 err = -ENOMEM; 714 goto fail_dev; 715 } 716 717 INIT_LIST_HEAD(&dev->pkeys.pkey_port_list[slave]); 718 719 dev->dev_ports_parent[slave] = 720 kobject_create_and_add("ports", 721 kobject_get(dev->pkeys.device_parent[slave])); 722 723 if (!dev->dev_ports_parent[slave]) { 724 err = -ENOMEM; 725 goto err_ports; 726 } 727 728 actv_ports = mlx4_get_active_ports(dev->dev, slave); 729 730 for (port = 1; port <= dev->dev->caps.num_ports; ++port) { 731 if (!test_bit(port - 1, actv_ports.ports)) 732 continue; 733 err = add_port(dev, port, slave); 734 if (err) 735 goto err_add; 736 } 737 return 0; 738 739 err_add: 740 list_for_each_entry_safe(p, t, 741 &dev->pkeys.pkey_port_list[slave], 742 entry) { 743 list_del(&p->entry); 744 mport = container_of(p, struct mlx4_port, kobj); 745 sysfs_remove_group(p, &mport->pkey_group); 746 sysfs_remove_group(p, &mport->gid_group); 747 remove_vf_smi_entries(mport); 748 kobject_put(p); 749 } 750 kobject_put(dev->dev_ports_parent[slave]); 751 752 err_ports: 753 kobject_put(dev->pkeys.device_parent[slave]); 754 /* extra put for the device_parent create_and_add */ 755 kobject_put(dev->pkeys.device_parent[slave]); 756 757 fail_dev: 758 kobject_put(dev->iov_parent); 759 return err; 760 } 761 762 static int register_pkey_tree(struct mlx4_ib_dev *device) 763 { 764 int i; 765 766 if (!mlx4_is_master(device->dev)) 767 return 0; 768 769 for (i = 0; i <= device->dev->persist->num_vfs; ++i) 770 register_one_pkey_tree(device, i); 771 772 return 0; 773 } 774 775 static void unregister_pkey_tree(struct mlx4_ib_dev *device) 776 { 777 int slave; 778 struct kobject *p, *t; 779 struct mlx4_port *port; 780 781 if (!mlx4_is_master(device->dev)) 782 return; 783 784 for (slave = device->dev->persist->num_vfs; slave >= 0; --slave) { 785 list_for_each_entry_safe(p, t, 786 &device->pkeys.pkey_port_list[slave], 787 entry) { 788 list_del(&p->entry); 789 port = container_of(p, struct mlx4_port, kobj); 790 sysfs_remove_group(p, &port->pkey_group); 791 sysfs_remove_group(p, &port->gid_group); 792 remove_vf_smi_entries(port); 793 kobject_put(p); 794 kobject_put(device->dev_ports_parent[slave]); 795 } 796 kobject_put(device->dev_ports_parent[slave]); 797 kobject_put(device->pkeys.device_parent[slave]); 798 kobject_put(device->pkeys.device_parent[slave]); 799 kobject_put(device->iov_parent); 800 } 801 } 802 803 int mlx4_ib_device_register_sysfs(struct mlx4_ib_dev *dev) 804 { 805 int i; 806 int ret = 0; 807 808 if (!mlx4_is_master(dev->dev)) 809 return 0; 810 811 dev->iov_parent = kobject_create_and_add("iov", &dev->ib_dev.dev.kobj); 812 if (!dev->iov_parent) { 813 ret = -ENOMEM; 814 goto err; 815 } 816 dev->ports_parent = 817 kobject_create_and_add("ports", 818 kobject_get(dev->iov_parent)); 819 if (!dev->ports_parent) { 820 ret = -ENOMEM; 821 goto err_ports; 822 } 823 824 for (i = 1; i <= dev->ib_dev.phys_port_cnt; ++i) { 825 ret = add_port_entries(dev, i); 826 if (ret) 827 goto err_add_entries; 828 } 829 830 ret = register_pkey_tree(dev); 831 if (ret) 832 goto err_add_entries; 833 return 0; 834 835 err_add_entries: 836 kobject_put(dev->ports_parent); 837 838 err_ports: 839 kobject_put(dev->iov_parent); 840 err: 841 pr_err("mlx4_ib_device_register_sysfs error (%d)\n", ret); 842 return ret; 843 } 844 845 static void unregister_alias_guid_tree(struct mlx4_ib_dev *device) 846 { 847 struct mlx4_ib_iov_port *p; 848 int i; 849 850 if (!mlx4_is_master(device->dev)) 851 return; 852 853 for (i = 0; i < device->dev->caps.num_ports; i++) { 854 p = &device->iov_ports[i]; 855 kobject_put(p->admin_alias_parent); 856 kobject_put(p->gids_parent); 857 kobject_put(p->pkeys_parent); 858 kobject_put(p->mcgs_parent); 859 kobject_put(p->cur_port); 860 kobject_put(p->cur_port); 861 kobject_put(p->cur_port); 862 kobject_put(p->cur_port); 863 kobject_put(p->cur_port); 864 kobject_put(p->dev->ports_parent); 865 kfree(p->dentr_ar); 866 } 867 } 868 869 void mlx4_ib_device_unregister_sysfs(struct mlx4_ib_dev *device) 870 { 871 unregister_alias_guid_tree(device); 872 unregister_pkey_tree(device); 873 kobject_put(device->ports_parent); 874 kobject_put(device->iov_parent); 875 kobject_put(device->iov_parent); 876 } 877