1 /* 2 * Copyright (c) 2004, 2005 Topspin Communications. All rights reserved. 3 * Copyright (c) 2005 Mellanox Technologies Ltd. All rights reserved. 4 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 */ 34 35 #include "core_priv.h" 36 37 #include <linux/slab.h> 38 #include <linux/stat.h> 39 #include <linux/string.h> 40 #include <linux/netdevice.h> 41 #include <linux/ethtool.h> 42 43 #include <rdma/ib_mad.h> 44 #include <rdma/ib_pma.h> 45 #include <rdma/ib_cache.h> 46 #include <rdma/rdma_counter.h> 47 48 struct ib_port; 49 50 struct port_attribute { 51 struct attribute attr; 52 ssize_t (*show)(struct ib_port *, struct port_attribute *, char *buf); 53 ssize_t (*store)(struct ib_port *, struct port_attribute *, 54 const char *buf, size_t count); 55 }; 56 57 #define PORT_ATTR(_name, _mode, _show, _store) \ 58 struct port_attribute port_attr_##_name = __ATTR(_name, _mode, _show, _store) 59 60 #define PORT_ATTR_RO(_name) \ 61 struct port_attribute port_attr_##_name = __ATTR_RO(_name) 62 63 struct port_table_attribute { 64 struct port_attribute attr; 65 char name[8]; 66 int index; 67 __be16 attr_id; 68 }; 69 70 struct gid_attr_group { 71 struct ib_port *port; 72 struct kobject kobj; 73 struct attribute_group groups[2]; 74 const struct attribute_group *groups_list[3]; 75 struct port_table_attribute attrs_list[]; 76 }; 77 78 struct ib_port { 79 struct kobject kobj; 80 struct ib_device *ibdev; 81 struct gid_attr_group *gid_attr_group; 82 struct attribute_group gid_group; 83 struct attribute_group *pkey_group; 84 const struct attribute_group *pma_table; 85 struct hw_stats_port_data *hw_stats_data; 86 u32 port_num; 87 }; 88 89 struct hw_stats_device_attribute { 90 struct device_attribute attr; 91 ssize_t (*show)(struct ib_device *ibdev, struct rdma_hw_stats *stats, 92 unsigned int index, unsigned int port_num, char *buf); 93 ssize_t (*store)(struct ib_device *ibdev, struct rdma_hw_stats *stats, 94 unsigned int index, unsigned int port_num, 95 const char *buf, size_t count); 96 }; 97 98 struct hw_stats_port_attribute { 99 struct port_attribute attr; 100 ssize_t (*show)(struct ib_device *ibdev, struct rdma_hw_stats *stats, 101 unsigned int index, unsigned int port_num, char *buf); 102 ssize_t (*store)(struct ib_device *ibdev, struct rdma_hw_stats *stats, 103 unsigned int index, unsigned int port_num, 104 const char *buf, size_t count); 105 }; 106 107 struct hw_stats_device_data { 108 struct attribute_group group; 109 const struct attribute_group *groups[2]; 110 struct rdma_hw_stats *stats; 111 struct hw_stats_device_attribute attrs[]; 112 }; 113 114 struct hw_stats_port_data { 115 struct attribute_group group; 116 struct rdma_hw_stats *stats; 117 struct hw_stats_port_attribute attrs[]; 118 }; 119 120 static ssize_t port_attr_show(struct kobject *kobj, 121 struct attribute *attr, char *buf) 122 { 123 struct port_attribute *port_attr = 124 container_of(attr, struct port_attribute, attr); 125 struct ib_port *p = container_of(kobj, struct ib_port, kobj); 126 127 if (!port_attr->show) 128 return -EIO; 129 130 return port_attr->show(p, port_attr, buf); 131 } 132 133 static ssize_t port_attr_store(struct kobject *kobj, 134 struct attribute *attr, 135 const char *buf, size_t count) 136 { 137 struct port_attribute *port_attr = 138 container_of(attr, struct port_attribute, attr); 139 struct ib_port *p = container_of(kobj, struct ib_port, kobj); 140 141 if (!port_attr->store) 142 return -EIO; 143 return port_attr->store(p, port_attr, buf, count); 144 } 145 146 static const struct sysfs_ops port_sysfs_ops = { 147 .show = port_attr_show, 148 .store = port_attr_store 149 }; 150 151 static ssize_t hw_stat_device_show(struct device *dev, 152 struct device_attribute *attr, char *buf) 153 { 154 struct hw_stats_device_attribute *stat_attr = 155 container_of(attr, struct hw_stats_device_attribute, attr); 156 struct ib_device *ibdev = container_of(dev, struct ib_device, dev); 157 158 return stat_attr->show(ibdev, ibdev->hw_stats_data->stats, 159 stat_attr - ibdev->hw_stats_data->attrs, 0, buf); 160 } 161 162 static ssize_t hw_stat_device_store(struct device *dev, 163 struct device_attribute *attr, 164 const char *buf, size_t count) 165 { 166 struct hw_stats_device_attribute *stat_attr = 167 container_of(attr, struct hw_stats_device_attribute, attr); 168 struct ib_device *ibdev = container_of(dev, struct ib_device, dev); 169 170 return stat_attr->store(ibdev, ibdev->hw_stats_data->stats, 171 stat_attr - ibdev->hw_stats_data->attrs, 0, buf, 172 count); 173 } 174 175 static ssize_t hw_stat_port_show(struct ib_port *port, 176 struct port_attribute *attr, char *buf) 177 { 178 struct hw_stats_port_attribute *stat_attr = 179 container_of(attr, struct hw_stats_port_attribute, attr); 180 181 return stat_attr->show(port->ibdev, port->hw_stats_data->stats, 182 stat_attr - port->hw_stats_data->attrs, 183 port->port_num, buf); 184 } 185 186 static ssize_t hw_stat_port_store(struct ib_port *port, 187 struct port_attribute *attr, const char *buf, 188 size_t count) 189 { 190 struct hw_stats_port_attribute *stat_attr = 191 container_of(attr, struct hw_stats_port_attribute, attr); 192 193 return stat_attr->store(port->ibdev, port->hw_stats_data->stats, 194 stat_attr - port->hw_stats_data->attrs, 195 port->port_num, buf, count); 196 } 197 198 static ssize_t gid_attr_show(struct kobject *kobj, 199 struct attribute *attr, char *buf) 200 { 201 struct port_attribute *port_attr = 202 container_of(attr, struct port_attribute, attr); 203 struct ib_port *p = container_of(kobj, struct gid_attr_group, 204 kobj)->port; 205 206 if (!port_attr->show) 207 return -EIO; 208 209 return port_attr->show(p, port_attr, buf); 210 } 211 212 static const struct sysfs_ops gid_attr_sysfs_ops = { 213 .show = gid_attr_show 214 }; 215 216 static ssize_t state_show(struct ib_port *p, struct port_attribute *unused, 217 char *buf) 218 { 219 struct ib_port_attr attr; 220 ssize_t ret; 221 222 static const char *state_name[] = { 223 [IB_PORT_NOP] = "NOP", 224 [IB_PORT_DOWN] = "DOWN", 225 [IB_PORT_INIT] = "INIT", 226 [IB_PORT_ARMED] = "ARMED", 227 [IB_PORT_ACTIVE] = "ACTIVE", 228 [IB_PORT_ACTIVE_DEFER] = "ACTIVE_DEFER" 229 }; 230 231 ret = ib_query_port(p->ibdev, p->port_num, &attr); 232 if (ret) 233 return ret; 234 235 return sysfs_emit(buf, "%d: %s\n", attr.state, 236 attr.state >= 0 && 237 attr.state < ARRAY_SIZE(state_name) ? 238 state_name[attr.state] : 239 "UNKNOWN"); 240 } 241 242 static ssize_t lid_show(struct ib_port *p, struct port_attribute *unused, 243 char *buf) 244 { 245 struct ib_port_attr attr; 246 ssize_t ret; 247 248 ret = ib_query_port(p->ibdev, p->port_num, &attr); 249 if (ret) 250 return ret; 251 252 return sysfs_emit(buf, "0x%x\n", attr.lid); 253 } 254 255 static ssize_t lid_mask_count_show(struct ib_port *p, 256 struct port_attribute *unused, 257 char *buf) 258 { 259 struct ib_port_attr attr; 260 ssize_t ret; 261 262 ret = ib_query_port(p->ibdev, p->port_num, &attr); 263 if (ret) 264 return ret; 265 266 return sysfs_emit(buf, "%d\n", attr.lmc); 267 } 268 269 static ssize_t sm_lid_show(struct ib_port *p, struct port_attribute *unused, 270 char *buf) 271 { 272 struct ib_port_attr attr; 273 ssize_t ret; 274 275 ret = ib_query_port(p->ibdev, p->port_num, &attr); 276 if (ret) 277 return ret; 278 279 return sysfs_emit(buf, "0x%x\n", attr.sm_lid); 280 } 281 282 static ssize_t sm_sl_show(struct ib_port *p, struct port_attribute *unused, 283 char *buf) 284 { 285 struct ib_port_attr attr; 286 ssize_t ret; 287 288 ret = ib_query_port(p->ibdev, p->port_num, &attr); 289 if (ret) 290 return ret; 291 292 return sysfs_emit(buf, "%d\n", attr.sm_sl); 293 } 294 295 static ssize_t cap_mask_show(struct ib_port *p, struct port_attribute *unused, 296 char *buf) 297 { 298 struct ib_port_attr attr; 299 ssize_t ret; 300 301 ret = ib_query_port(p->ibdev, p->port_num, &attr); 302 if (ret) 303 return ret; 304 305 return sysfs_emit(buf, "0x%08x\n", attr.port_cap_flags); 306 } 307 308 static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused, 309 char *buf) 310 { 311 struct ib_port_attr attr; 312 char *speed = ""; 313 int rate; /* in deci-Gb/sec */ 314 ssize_t ret; 315 316 ret = ib_query_port(p->ibdev, p->port_num, &attr); 317 if (ret) 318 return ret; 319 320 switch (attr.active_speed) { 321 case IB_SPEED_DDR: 322 speed = " DDR"; 323 rate = 50; 324 break; 325 case IB_SPEED_QDR: 326 speed = " QDR"; 327 rate = 100; 328 break; 329 case IB_SPEED_FDR10: 330 speed = " FDR10"; 331 rate = 100; 332 break; 333 case IB_SPEED_FDR: 334 speed = " FDR"; 335 rate = 140; 336 break; 337 case IB_SPEED_EDR: 338 speed = " EDR"; 339 rate = 250; 340 break; 341 case IB_SPEED_HDR: 342 speed = " HDR"; 343 rate = 500; 344 break; 345 case IB_SPEED_NDR: 346 speed = " NDR"; 347 rate = 1000; 348 break; 349 case IB_SPEED_SDR: 350 default: /* default to SDR for invalid rates */ 351 speed = " SDR"; 352 rate = 25; 353 break; 354 } 355 356 rate *= ib_width_enum_to_int(attr.active_width); 357 if (rate < 0) 358 return -EINVAL; 359 360 return sysfs_emit(buf, "%d%s Gb/sec (%dX%s)\n", rate / 10, 361 rate % 10 ? ".5" : "", 362 ib_width_enum_to_int(attr.active_width), speed); 363 } 364 365 static const char *phys_state_to_str(enum ib_port_phys_state phys_state) 366 { 367 static const char *phys_state_str[] = { 368 "<unknown>", 369 "Sleep", 370 "Polling", 371 "Disabled", 372 "PortConfigurationTraining", 373 "LinkUp", 374 "LinkErrorRecovery", 375 "Phy Test", 376 }; 377 378 if (phys_state < ARRAY_SIZE(phys_state_str)) 379 return phys_state_str[phys_state]; 380 return "<unknown>"; 381 } 382 383 static ssize_t phys_state_show(struct ib_port *p, struct port_attribute *unused, 384 char *buf) 385 { 386 struct ib_port_attr attr; 387 388 ssize_t ret; 389 390 ret = ib_query_port(p->ibdev, p->port_num, &attr); 391 if (ret) 392 return ret; 393 394 return sysfs_emit(buf, "%d: %s\n", attr.phys_state, 395 phys_state_to_str(attr.phys_state)); 396 } 397 398 static ssize_t link_layer_show(struct ib_port *p, struct port_attribute *unused, 399 char *buf) 400 { 401 const char *output; 402 403 switch (rdma_port_get_link_layer(p->ibdev, p->port_num)) { 404 case IB_LINK_LAYER_INFINIBAND: 405 output = "InfiniBand"; 406 break; 407 case IB_LINK_LAYER_ETHERNET: 408 output = "Ethernet"; 409 break; 410 default: 411 output = "Unknown"; 412 break; 413 } 414 415 return sysfs_emit(buf, "%s\n", output); 416 } 417 418 static PORT_ATTR_RO(state); 419 static PORT_ATTR_RO(lid); 420 static PORT_ATTR_RO(lid_mask_count); 421 static PORT_ATTR_RO(sm_lid); 422 static PORT_ATTR_RO(sm_sl); 423 static PORT_ATTR_RO(cap_mask); 424 static PORT_ATTR_RO(rate); 425 static PORT_ATTR_RO(phys_state); 426 static PORT_ATTR_RO(link_layer); 427 428 static struct attribute *port_default_attrs[] = { 429 &port_attr_state.attr, 430 &port_attr_lid.attr, 431 &port_attr_lid_mask_count.attr, 432 &port_attr_sm_lid.attr, 433 &port_attr_sm_sl.attr, 434 &port_attr_cap_mask.attr, 435 &port_attr_rate.attr, 436 &port_attr_phys_state.attr, 437 &port_attr_link_layer.attr, 438 NULL 439 }; 440 441 static ssize_t print_ndev(const struct ib_gid_attr *gid_attr, char *buf) 442 { 443 struct net_device *ndev; 444 int ret = -EINVAL; 445 446 rcu_read_lock(); 447 ndev = rcu_dereference(gid_attr->ndev); 448 if (ndev) 449 ret = sysfs_emit(buf, "%s\n", ndev->name); 450 rcu_read_unlock(); 451 return ret; 452 } 453 454 static ssize_t print_gid_type(const struct ib_gid_attr *gid_attr, char *buf) 455 { 456 return sysfs_emit(buf, "%s\n", 457 ib_cache_gid_type_str(gid_attr->gid_type)); 458 } 459 460 static ssize_t _show_port_gid_attr( 461 struct ib_port *p, struct port_attribute *attr, char *buf, 462 ssize_t (*print)(const struct ib_gid_attr *gid_attr, char *buf)) 463 { 464 struct port_table_attribute *tab_attr = 465 container_of(attr, struct port_table_attribute, attr); 466 const struct ib_gid_attr *gid_attr; 467 ssize_t ret; 468 469 gid_attr = rdma_get_gid_attr(p->ibdev, p->port_num, tab_attr->index); 470 if (IS_ERR(gid_attr)) 471 /* -EINVAL is returned for user space compatibility reasons. */ 472 return -EINVAL; 473 474 ret = print(gid_attr, buf); 475 rdma_put_gid_attr(gid_attr); 476 return ret; 477 } 478 479 static ssize_t show_port_gid(struct ib_port *p, struct port_attribute *attr, 480 char *buf) 481 { 482 struct port_table_attribute *tab_attr = 483 container_of(attr, struct port_table_attribute, attr); 484 const struct ib_gid_attr *gid_attr; 485 int len; 486 487 gid_attr = rdma_get_gid_attr(p->ibdev, p->port_num, tab_attr->index); 488 if (IS_ERR(gid_attr)) { 489 const union ib_gid zgid = {}; 490 491 /* If reading GID fails, it is likely due to GID entry being 492 * empty (invalid) or reserved GID in the table. User space 493 * expects to read GID table entries as long as it given index 494 * is within GID table size. Administrative/debugging tool 495 * fails to query rest of the GID entries if it hits error 496 * while querying a GID of the given index. To avoid user 497 * space throwing such error on fail to read gid, return zero 498 * GID as before. This maintains backward compatibility. 499 */ 500 return sysfs_emit(buf, "%pI6\n", zgid.raw); 501 } 502 503 len = sysfs_emit(buf, "%pI6\n", gid_attr->gid.raw); 504 rdma_put_gid_attr(gid_attr); 505 return len; 506 } 507 508 static ssize_t show_port_gid_attr_ndev(struct ib_port *p, 509 struct port_attribute *attr, char *buf) 510 { 511 return _show_port_gid_attr(p, attr, buf, print_ndev); 512 } 513 514 static ssize_t show_port_gid_attr_gid_type(struct ib_port *p, 515 struct port_attribute *attr, 516 char *buf) 517 { 518 return _show_port_gid_attr(p, attr, buf, print_gid_type); 519 } 520 521 static ssize_t show_port_pkey(struct ib_port *p, struct port_attribute *attr, 522 char *buf) 523 { 524 struct port_table_attribute *tab_attr = 525 container_of(attr, struct port_table_attribute, attr); 526 u16 pkey; 527 int ret; 528 529 ret = ib_query_pkey(p->ibdev, p->port_num, tab_attr->index, &pkey); 530 if (ret) 531 return ret; 532 533 return sysfs_emit(buf, "0x%04x\n", pkey); 534 } 535 536 #define PORT_PMA_ATTR(_name, _counter, _width, _offset) \ 537 struct port_table_attribute port_pma_attr_##_name = { \ 538 .attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \ 539 .index = (_offset) | ((_width) << 16) | ((_counter) << 24), \ 540 .attr_id = IB_PMA_PORT_COUNTERS, \ 541 } 542 543 #define PORT_PMA_ATTR_EXT(_name, _width, _offset) \ 544 struct port_table_attribute port_pma_attr_ext_##_name = { \ 545 .attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \ 546 .index = (_offset) | ((_width) << 16), \ 547 .attr_id = IB_PMA_PORT_COUNTERS_EXT, \ 548 } 549 550 /* 551 * Get a Perfmgmt MAD block of data. 552 * Returns error code or the number of bytes retrieved. 553 */ 554 static int get_perf_mad(struct ib_device *dev, int port_num, __be16 attr, 555 void *data, int offset, size_t size) 556 { 557 struct ib_mad *in_mad; 558 struct ib_mad *out_mad; 559 size_t mad_size = sizeof(*out_mad); 560 u16 out_mad_pkey_index = 0; 561 ssize_t ret; 562 563 if (!dev->ops.process_mad) 564 return -ENOSYS; 565 566 in_mad = kzalloc(sizeof(*in_mad), GFP_KERNEL); 567 out_mad = kzalloc(sizeof(*out_mad), GFP_KERNEL); 568 if (!in_mad || !out_mad) { 569 ret = -ENOMEM; 570 goto out; 571 } 572 573 in_mad->mad_hdr.base_version = 1; 574 in_mad->mad_hdr.mgmt_class = IB_MGMT_CLASS_PERF_MGMT; 575 in_mad->mad_hdr.class_version = 1; 576 in_mad->mad_hdr.method = IB_MGMT_METHOD_GET; 577 in_mad->mad_hdr.attr_id = attr; 578 579 if (attr != IB_PMA_CLASS_PORT_INFO) 580 in_mad->data[41] = port_num; /* PortSelect field */ 581 582 if ((dev->ops.process_mad(dev, IB_MAD_IGNORE_MKEY, port_num, NULL, NULL, 583 in_mad, out_mad, &mad_size, 584 &out_mad_pkey_index) & 585 (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) != 586 (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) { 587 ret = -EINVAL; 588 goto out; 589 } 590 memcpy(data, out_mad->data + offset, size); 591 ret = size; 592 out: 593 kfree(in_mad); 594 kfree(out_mad); 595 return ret; 596 } 597 598 static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr, 599 char *buf) 600 { 601 struct port_table_attribute *tab_attr = 602 container_of(attr, struct port_table_attribute, attr); 603 int offset = tab_attr->index & 0xffff; 604 int width = (tab_attr->index >> 16) & 0xff; 605 int ret; 606 u8 data[8]; 607 int len; 608 609 ret = get_perf_mad(p->ibdev, p->port_num, tab_attr->attr_id, &data, 610 40 + offset / 8, sizeof(data)); 611 if (ret < 0) 612 return ret; 613 614 switch (width) { 615 case 4: 616 len = sysfs_emit(buf, "%u\n", 617 (*data >> (4 - (offset % 8))) & 0xf); 618 break; 619 case 8: 620 len = sysfs_emit(buf, "%u\n", *data); 621 break; 622 case 16: 623 len = sysfs_emit(buf, "%u\n", be16_to_cpup((__be16 *)data)); 624 break; 625 case 32: 626 len = sysfs_emit(buf, "%u\n", be32_to_cpup((__be32 *)data)); 627 break; 628 case 64: 629 len = sysfs_emit(buf, "%llu\n", be64_to_cpup((__be64 *)data)); 630 break; 631 default: 632 len = 0; 633 break; 634 } 635 636 return len; 637 } 638 639 static PORT_PMA_ATTR(symbol_error , 0, 16, 32); 640 static PORT_PMA_ATTR(link_error_recovery , 1, 8, 48); 641 static PORT_PMA_ATTR(link_downed , 2, 8, 56); 642 static PORT_PMA_ATTR(port_rcv_errors , 3, 16, 64); 643 static PORT_PMA_ATTR(port_rcv_remote_physical_errors, 4, 16, 80); 644 static PORT_PMA_ATTR(port_rcv_switch_relay_errors , 5, 16, 96); 645 static PORT_PMA_ATTR(port_xmit_discards , 6, 16, 112); 646 static PORT_PMA_ATTR(port_xmit_constraint_errors , 7, 8, 128); 647 static PORT_PMA_ATTR(port_rcv_constraint_errors , 8, 8, 136); 648 static PORT_PMA_ATTR(local_link_integrity_errors , 9, 4, 152); 649 static PORT_PMA_ATTR(excessive_buffer_overrun_errors, 10, 4, 156); 650 static PORT_PMA_ATTR(VL15_dropped , 11, 16, 176); 651 static PORT_PMA_ATTR(port_xmit_data , 12, 32, 192); 652 static PORT_PMA_ATTR(port_rcv_data , 13, 32, 224); 653 static PORT_PMA_ATTR(port_xmit_packets , 14, 32, 256); 654 static PORT_PMA_ATTR(port_rcv_packets , 15, 32, 288); 655 static PORT_PMA_ATTR(port_xmit_wait , 0, 32, 320); 656 657 /* 658 * Counters added by extended set 659 */ 660 static PORT_PMA_ATTR_EXT(port_xmit_data , 64, 64); 661 static PORT_PMA_ATTR_EXT(port_rcv_data , 64, 128); 662 static PORT_PMA_ATTR_EXT(port_xmit_packets , 64, 192); 663 static PORT_PMA_ATTR_EXT(port_rcv_packets , 64, 256); 664 static PORT_PMA_ATTR_EXT(unicast_xmit_packets , 64, 320); 665 static PORT_PMA_ATTR_EXT(unicast_rcv_packets , 64, 384); 666 static PORT_PMA_ATTR_EXT(multicast_xmit_packets , 64, 448); 667 static PORT_PMA_ATTR_EXT(multicast_rcv_packets , 64, 512); 668 669 static struct attribute *pma_attrs[] = { 670 &port_pma_attr_symbol_error.attr.attr, 671 &port_pma_attr_link_error_recovery.attr.attr, 672 &port_pma_attr_link_downed.attr.attr, 673 &port_pma_attr_port_rcv_errors.attr.attr, 674 &port_pma_attr_port_rcv_remote_physical_errors.attr.attr, 675 &port_pma_attr_port_rcv_switch_relay_errors.attr.attr, 676 &port_pma_attr_port_xmit_discards.attr.attr, 677 &port_pma_attr_port_xmit_constraint_errors.attr.attr, 678 &port_pma_attr_port_rcv_constraint_errors.attr.attr, 679 &port_pma_attr_local_link_integrity_errors.attr.attr, 680 &port_pma_attr_excessive_buffer_overrun_errors.attr.attr, 681 &port_pma_attr_VL15_dropped.attr.attr, 682 &port_pma_attr_port_xmit_data.attr.attr, 683 &port_pma_attr_port_rcv_data.attr.attr, 684 &port_pma_attr_port_xmit_packets.attr.attr, 685 &port_pma_attr_port_rcv_packets.attr.attr, 686 &port_pma_attr_port_xmit_wait.attr.attr, 687 NULL 688 }; 689 690 static struct attribute *pma_attrs_ext[] = { 691 &port_pma_attr_symbol_error.attr.attr, 692 &port_pma_attr_link_error_recovery.attr.attr, 693 &port_pma_attr_link_downed.attr.attr, 694 &port_pma_attr_port_rcv_errors.attr.attr, 695 &port_pma_attr_port_rcv_remote_physical_errors.attr.attr, 696 &port_pma_attr_port_rcv_switch_relay_errors.attr.attr, 697 &port_pma_attr_port_xmit_discards.attr.attr, 698 &port_pma_attr_port_xmit_constraint_errors.attr.attr, 699 &port_pma_attr_port_rcv_constraint_errors.attr.attr, 700 &port_pma_attr_local_link_integrity_errors.attr.attr, 701 &port_pma_attr_excessive_buffer_overrun_errors.attr.attr, 702 &port_pma_attr_VL15_dropped.attr.attr, 703 &port_pma_attr_ext_port_xmit_data.attr.attr, 704 &port_pma_attr_ext_port_rcv_data.attr.attr, 705 &port_pma_attr_ext_port_xmit_packets.attr.attr, 706 &port_pma_attr_port_xmit_wait.attr.attr, 707 &port_pma_attr_ext_port_rcv_packets.attr.attr, 708 &port_pma_attr_ext_unicast_rcv_packets.attr.attr, 709 &port_pma_attr_ext_unicast_xmit_packets.attr.attr, 710 &port_pma_attr_ext_multicast_rcv_packets.attr.attr, 711 &port_pma_attr_ext_multicast_xmit_packets.attr.attr, 712 NULL 713 }; 714 715 static struct attribute *pma_attrs_noietf[] = { 716 &port_pma_attr_symbol_error.attr.attr, 717 &port_pma_attr_link_error_recovery.attr.attr, 718 &port_pma_attr_link_downed.attr.attr, 719 &port_pma_attr_port_rcv_errors.attr.attr, 720 &port_pma_attr_port_rcv_remote_physical_errors.attr.attr, 721 &port_pma_attr_port_rcv_switch_relay_errors.attr.attr, 722 &port_pma_attr_port_xmit_discards.attr.attr, 723 &port_pma_attr_port_xmit_constraint_errors.attr.attr, 724 &port_pma_attr_port_rcv_constraint_errors.attr.attr, 725 &port_pma_attr_local_link_integrity_errors.attr.attr, 726 &port_pma_attr_excessive_buffer_overrun_errors.attr.attr, 727 &port_pma_attr_VL15_dropped.attr.attr, 728 &port_pma_attr_ext_port_xmit_data.attr.attr, 729 &port_pma_attr_ext_port_rcv_data.attr.attr, 730 &port_pma_attr_ext_port_xmit_packets.attr.attr, 731 &port_pma_attr_ext_port_rcv_packets.attr.attr, 732 &port_pma_attr_port_xmit_wait.attr.attr, 733 NULL 734 }; 735 736 static const struct attribute_group pma_group = { 737 .name = "counters", 738 .attrs = pma_attrs 739 }; 740 741 static const struct attribute_group pma_group_ext = { 742 .name = "counters", 743 .attrs = pma_attrs_ext 744 }; 745 746 static const struct attribute_group pma_group_noietf = { 747 .name = "counters", 748 .attrs = pma_attrs_noietf 749 }; 750 751 static void ib_port_release(struct kobject *kobj) 752 { 753 struct ib_port *p = container_of(kobj, struct ib_port, kobj); 754 struct attribute *a; 755 int i; 756 757 if (p->gid_group.attrs) { 758 for (i = 0; (a = p->gid_group.attrs[i]); ++i) 759 kfree(a); 760 761 kfree(p->gid_group.attrs); 762 } 763 764 if (p->pkey_group) { 765 if (p->pkey_group->attrs) { 766 for (i = 0; (a = p->pkey_group->attrs[i]); ++i) 767 kfree(a); 768 769 kfree(p->pkey_group->attrs); 770 } 771 772 kfree(p->pkey_group); 773 p->pkey_group = NULL; 774 } 775 776 kfree(p); 777 } 778 779 static void ib_port_gid_attr_release(struct kobject *kobj) 780 { 781 struct gid_attr_group *gid_attr_group = 782 container_of(kobj, struct gid_attr_group, kobj); 783 int i; 784 785 for (i = 0; i != ARRAY_SIZE(gid_attr_group->groups); i++) 786 kfree(gid_attr_group->groups[i].attrs); 787 kfree(gid_attr_group); 788 } 789 790 static struct kobj_type port_type = { 791 .release = ib_port_release, 792 .sysfs_ops = &port_sysfs_ops, 793 .default_attrs = port_default_attrs 794 }; 795 796 static struct kobj_type gid_attr_type = { 797 .sysfs_ops = &gid_attr_sysfs_ops, 798 .release = ib_port_gid_attr_release 799 }; 800 801 static struct attribute ** 802 alloc_group_attrs(ssize_t (*show)(struct ib_port *, 803 struct port_attribute *, char *buf), 804 int len) 805 { 806 struct attribute **tab_attr; 807 struct port_table_attribute *element; 808 int i; 809 810 tab_attr = kcalloc(1 + len, sizeof(struct attribute *), GFP_KERNEL); 811 if (!tab_attr) 812 return NULL; 813 814 for (i = 0; i < len; i++) { 815 element = kzalloc(sizeof(struct port_table_attribute), 816 GFP_KERNEL); 817 if (!element) 818 goto err; 819 820 if (snprintf(element->name, sizeof(element->name), 821 "%d", i) >= sizeof(element->name)) { 822 kfree(element); 823 goto err; 824 } 825 826 element->attr.attr.name = element->name; 827 element->attr.attr.mode = S_IRUGO; 828 element->attr.show = show; 829 element->index = i; 830 sysfs_attr_init(&element->attr.attr); 831 832 tab_attr[i] = &element->attr.attr; 833 } 834 835 return tab_attr; 836 837 err: 838 while (--i >= 0) 839 kfree(tab_attr[i]); 840 kfree(tab_attr); 841 return NULL; 842 } 843 844 /* 845 * Figure out which counter table to use depending on 846 * the device capabilities. 847 */ 848 static const struct attribute_group *get_counter_table(struct ib_device *dev, 849 int port_num) 850 { 851 struct ib_class_port_info cpi; 852 853 if (get_perf_mad(dev, port_num, IB_PMA_CLASS_PORT_INFO, 854 &cpi, 40, sizeof(cpi)) >= 0) { 855 if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH) 856 /* We have extended counters */ 857 return &pma_group_ext; 858 859 if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH_NOIETF) 860 /* But not the IETF ones */ 861 return &pma_group_noietf; 862 } 863 864 /* Fall back to normal counters */ 865 return &pma_group; 866 } 867 868 static int update_hw_stats(struct ib_device *dev, struct rdma_hw_stats *stats, 869 u32 port_num, int index) 870 { 871 int ret; 872 873 if (time_is_after_eq_jiffies(stats->timestamp + stats->lifespan)) 874 return 0; 875 ret = dev->ops.get_hw_stats(dev, stats, port_num, index); 876 if (ret < 0) 877 return ret; 878 if (ret == stats->num_counters) 879 stats->timestamp = jiffies; 880 881 return 0; 882 } 883 884 static int print_hw_stat(struct ib_device *dev, int port_num, 885 struct rdma_hw_stats *stats, int index, char *buf) 886 { 887 u64 v = rdma_counter_get_hwstat_value(dev, port_num, index); 888 889 return sysfs_emit(buf, "%llu\n", stats->value[index] + v); 890 } 891 892 static ssize_t show_hw_stats(struct ib_device *ibdev, 893 struct rdma_hw_stats *stats, unsigned int index, 894 unsigned int port_num, char *buf) 895 { 896 int ret; 897 898 mutex_lock(&stats->lock); 899 ret = update_hw_stats(ibdev, stats, port_num, index); 900 if (ret) 901 goto unlock; 902 ret = print_hw_stat(ibdev, port_num, stats, index, buf); 903 unlock: 904 mutex_unlock(&stats->lock); 905 906 return ret; 907 } 908 909 static ssize_t show_stats_lifespan(struct ib_device *ibdev, 910 struct rdma_hw_stats *stats, 911 unsigned int index, unsigned int port_num, 912 char *buf) 913 { 914 int msecs; 915 916 mutex_lock(&stats->lock); 917 msecs = jiffies_to_msecs(stats->lifespan); 918 mutex_unlock(&stats->lock); 919 920 return sysfs_emit(buf, "%d\n", msecs); 921 } 922 923 static ssize_t set_stats_lifespan(struct ib_device *ibdev, 924 struct rdma_hw_stats *stats, 925 unsigned int index, unsigned int port_num, 926 const char *buf, size_t count) 927 { 928 int msecs; 929 int jiffies; 930 int ret; 931 932 ret = kstrtoint(buf, 10, &msecs); 933 if (ret) 934 return ret; 935 if (msecs < 0 || msecs > 10000) 936 return -EINVAL; 937 jiffies = msecs_to_jiffies(msecs); 938 939 mutex_lock(&stats->lock); 940 stats->lifespan = jiffies; 941 mutex_unlock(&stats->lock); 942 943 return count; 944 } 945 946 static struct hw_stats_device_data * 947 alloc_hw_stats_device(struct ib_device *ibdev) 948 { 949 struct hw_stats_device_data *data; 950 struct rdma_hw_stats *stats; 951 952 if (!ibdev->ops.alloc_hw_device_stats) 953 return ERR_PTR(-EOPNOTSUPP); 954 stats = ibdev->ops.alloc_hw_device_stats(ibdev); 955 if (!stats) 956 return ERR_PTR(-ENOMEM); 957 if (!stats->names || stats->num_counters <= 0) 958 goto err_free_stats; 959 960 /* 961 * Two extra attribue elements here, one for the lifespan entry and 962 * one to NULL terminate the list for the sysfs core code 963 */ 964 data = kzalloc(struct_size(data, attrs, stats->num_counters + 1), 965 GFP_KERNEL); 966 if (!data) 967 goto err_free_stats; 968 data->group.attrs = kcalloc(stats->num_counters + 2, 969 sizeof(*data->group.attrs), GFP_KERNEL); 970 if (!data->group.attrs) 971 goto err_free_data; 972 973 mutex_init(&stats->lock); 974 data->group.name = "hw_counters"; 975 data->stats = stats; 976 data->groups[0] = &data->group; 977 return data; 978 979 err_free_data: 980 kfree(data); 981 err_free_stats: 982 kfree(stats); 983 return ERR_PTR(-ENOMEM); 984 } 985 986 static void free_hw_stats_device(struct hw_stats_device_data *data) 987 { 988 kfree(data->group.attrs); 989 kfree(data->stats); 990 kfree(data); 991 } 992 993 static int setup_hw_device_stats(struct ib_device *ibdev) 994 { 995 struct hw_stats_device_attribute *attr; 996 struct hw_stats_device_data *data; 997 int i, ret; 998 999 data = alloc_hw_stats_device(ibdev); 1000 if (IS_ERR(data)) 1001 return PTR_ERR(data); 1002 1003 ret = ibdev->ops.get_hw_stats(ibdev, data->stats, 0, 1004 data->stats->num_counters); 1005 if (ret != data->stats->num_counters) { 1006 if (WARN_ON(ret >= 0)) 1007 ret = -EINVAL; 1008 goto err_free; 1009 } 1010 1011 data->stats->timestamp = jiffies; 1012 1013 for (i = 0; i < data->stats->num_counters; i++) { 1014 attr = &data->attrs[i]; 1015 sysfs_attr_init(&attr->attr.attr); 1016 attr->attr.attr.name = data->stats->names[i]; 1017 attr->attr.attr.mode = 0444; 1018 attr->attr.show = hw_stat_device_show; 1019 attr->show = show_hw_stats; 1020 data->group.attrs[i] = &attr->attr.attr; 1021 } 1022 1023 attr = &data->attrs[i]; 1024 sysfs_attr_init(&attr->attr.attr); 1025 attr->attr.attr.name = "lifespan"; 1026 attr->attr.attr.mode = 0644; 1027 attr->attr.show = hw_stat_device_show; 1028 attr->show = show_stats_lifespan; 1029 attr->attr.store = hw_stat_device_store; 1030 attr->store = set_stats_lifespan; 1031 data->group.attrs[i] = &attr->attr.attr; 1032 1033 ibdev->hw_stats_data = data; 1034 ret = device_add_groups(&ibdev->dev, data->groups); 1035 if (ret) 1036 goto err_free; 1037 return 0; 1038 1039 err_free: 1040 free_hw_stats_device(data); 1041 ibdev->hw_stats_data = NULL; 1042 return ret; 1043 } 1044 1045 static void destroy_hw_device_stats(struct ib_device *ibdev) 1046 { 1047 if (!ibdev->hw_stats_data) 1048 return; 1049 device_remove_groups(&ibdev->dev, ibdev->hw_stats_data->groups); 1050 free_hw_stats_device(ibdev->hw_stats_data); 1051 ibdev->hw_stats_data = NULL; 1052 } 1053 1054 static struct hw_stats_port_data *alloc_hw_stats_port(struct ib_port *port) 1055 { 1056 struct ib_device *ibdev = port->ibdev; 1057 struct hw_stats_port_data *data; 1058 struct rdma_hw_stats *stats; 1059 1060 if (!ibdev->ops.alloc_hw_port_stats) 1061 return ERR_PTR(-EOPNOTSUPP); 1062 stats = ibdev->ops.alloc_hw_port_stats(port->ibdev, port->port_num); 1063 if (!stats) 1064 return ERR_PTR(-ENOMEM); 1065 if (!stats->names || stats->num_counters <= 0) 1066 goto err_free_stats; 1067 1068 /* 1069 * Two extra attribue elements here, one for the lifespan entry and 1070 * one to NULL terminate the list for the sysfs core code 1071 */ 1072 data = kzalloc(struct_size(data, attrs, stats->num_counters + 1), 1073 GFP_KERNEL); 1074 if (!data) 1075 goto err_free_stats; 1076 data->group.attrs = kcalloc(stats->num_counters + 2, 1077 sizeof(*data->group.attrs), GFP_KERNEL); 1078 if (!data->group.attrs) 1079 goto err_free_data; 1080 1081 mutex_init(&stats->lock); 1082 data->group.name = "hw_counters"; 1083 data->stats = stats; 1084 return data; 1085 1086 err_free_data: 1087 kfree(data); 1088 err_free_stats: 1089 kfree(stats); 1090 return ERR_PTR(-ENOMEM); 1091 } 1092 1093 static void free_hw_stats_port(struct hw_stats_port_data *data) 1094 { 1095 kfree(data->group.attrs); 1096 kfree(data->stats); 1097 kfree(data); 1098 } 1099 1100 static int setup_hw_port_stats(struct ib_port *port) 1101 { 1102 struct hw_stats_port_attribute *attr; 1103 struct hw_stats_port_data *data; 1104 int i, ret; 1105 1106 data = alloc_hw_stats_port(port); 1107 if (IS_ERR(data)) 1108 return PTR_ERR(data); 1109 1110 ret = port->ibdev->ops.get_hw_stats(port->ibdev, data->stats, 1111 port->port_num, 1112 data->stats->num_counters); 1113 if (ret != data->stats->num_counters) { 1114 if (WARN_ON(ret >= 0)) 1115 ret = -EINVAL; 1116 goto err_free; 1117 } 1118 data->stats->timestamp = jiffies; 1119 1120 for (i = 0; i < data->stats->num_counters; i++) { 1121 attr = &data->attrs[i]; 1122 sysfs_attr_init(&attr->attr.attr); 1123 attr->attr.attr.name = data->stats->names[i]; 1124 attr->attr.attr.mode = 0444; 1125 attr->attr.show = hw_stat_port_show; 1126 attr->show = show_hw_stats; 1127 data->group.attrs[i] = &attr->attr.attr; 1128 } 1129 1130 attr = &data->attrs[i]; 1131 sysfs_attr_init(&attr->attr.attr); 1132 attr->attr.attr.name = "lifespan"; 1133 attr->attr.attr.mode = 0644; 1134 attr->attr.show = hw_stat_port_show; 1135 attr->show = show_stats_lifespan; 1136 attr->attr.store = hw_stat_port_store; 1137 attr->store = set_stats_lifespan; 1138 data->group.attrs[i] = &attr->attr.attr; 1139 1140 port->hw_stats_data = data; 1141 ret = sysfs_create_group(&port->kobj, &data->group); 1142 if (ret) 1143 goto err_free; 1144 return 0; 1145 1146 err_free: 1147 free_hw_stats_port(data); 1148 port->hw_stats_data = NULL; 1149 return ret; 1150 } 1151 1152 static void destroy_hw_port_stats(struct ib_port *port) 1153 { 1154 if (!port->hw_stats_data) 1155 return; 1156 sysfs_remove_group(&port->kobj, &port->hw_stats_data->group); 1157 free_hw_stats_port(port->hw_stats_data); 1158 port->hw_stats_data = NULL; 1159 } 1160 1161 struct rdma_hw_stats *ib_get_hw_stats_port(struct ib_device *ibdev, 1162 u32 port_num) 1163 { 1164 if (!ibdev->port_data || !rdma_is_port_valid(ibdev, port_num) || 1165 !ibdev->port_data[port_num].sysfs->hw_stats_data) 1166 return NULL; 1167 return ibdev->port_data[port_num].sysfs->hw_stats_data->stats; 1168 } 1169 1170 static int alloc_port_table_group( 1171 const char *name, struct attribute_group *group, 1172 struct port_table_attribute *attrs, size_t num, 1173 ssize_t (*show)(struct ib_port *, struct port_attribute *, char *buf)) 1174 { 1175 struct attribute **attr_list; 1176 int i; 1177 1178 attr_list = kcalloc(num + 1, sizeof(*attr_list), GFP_KERNEL); 1179 if (!attr_list) 1180 return -ENOMEM; 1181 1182 for (i = 0; i < num; i++) { 1183 struct port_table_attribute *element = &attrs[i]; 1184 1185 if (snprintf(element->name, sizeof(element->name), "%d", i) >= 1186 sizeof(element->name)) 1187 goto err; 1188 1189 sysfs_attr_init(&element->attr.attr); 1190 element->attr.attr.name = element->name; 1191 element->attr.attr.mode = 0444; 1192 element->attr.show = show; 1193 element->index = i; 1194 1195 attr_list[i] = &element->attr.attr; 1196 } 1197 group->name = name; 1198 group->attrs = attr_list; 1199 return 0; 1200 err: 1201 kfree(attr_list); 1202 return -EINVAL; 1203 } 1204 1205 /* 1206 * Create the sysfs: 1207 * ibp0s9/ports/XX/gid_attrs/{ndevs,types}/YYY 1208 * YYY is the gid table index in decimal 1209 */ 1210 static int setup_gid_attrs(struct ib_port *port, 1211 const struct ib_port_attr *attr) 1212 { 1213 struct gid_attr_group *gid_attr_group; 1214 int ret; 1215 1216 gid_attr_group = kzalloc(struct_size(gid_attr_group, attrs_list, 1217 attr->gid_tbl_len * 2), 1218 GFP_KERNEL); 1219 if (!gid_attr_group) 1220 return -ENOMEM; 1221 gid_attr_group->port = port; 1222 kobject_init(&gid_attr_group->kobj, &gid_attr_type); 1223 1224 ret = alloc_port_table_group("ndevs", &gid_attr_group->groups[0], 1225 gid_attr_group->attrs_list, 1226 attr->gid_tbl_len, 1227 show_port_gid_attr_ndev); 1228 if (ret) 1229 goto err_put; 1230 gid_attr_group->groups_list[0] = &gid_attr_group->groups[0]; 1231 1232 ret = alloc_port_table_group( 1233 "types", &gid_attr_group->groups[1], 1234 gid_attr_group->attrs_list + attr->gid_tbl_len, 1235 attr->gid_tbl_len, show_port_gid_attr_gid_type); 1236 if (ret) 1237 goto err_put; 1238 gid_attr_group->groups_list[1] = &gid_attr_group->groups[1]; 1239 1240 ret = kobject_add(&gid_attr_group->kobj, &port->kobj, "gid_attrs"); 1241 if (ret) 1242 goto err_put; 1243 ret = sysfs_create_groups(&gid_attr_group->kobj, 1244 gid_attr_group->groups_list); 1245 if (ret) 1246 goto err_del; 1247 port->gid_attr_group = gid_attr_group; 1248 return 0; 1249 1250 err_del: 1251 kobject_del(&gid_attr_group->kobj); 1252 err_put: 1253 kobject_put(&gid_attr_group->kobj); 1254 return ret; 1255 } 1256 1257 static void destroy_gid_attrs(struct ib_port *port) 1258 { 1259 struct gid_attr_group *gid_attr_group = port->gid_attr_group; 1260 1261 if (!gid_attr_group) 1262 return; 1263 sysfs_remove_groups(&gid_attr_group->kobj, gid_attr_group->groups_list); 1264 kobject_del(&gid_attr_group->kobj); 1265 kobject_put(&gid_attr_group->kobj); 1266 } 1267 1268 static int add_port(struct ib_core_device *coredev, int port_num) 1269 { 1270 struct ib_device *device = rdma_device_to_ibdev(&coredev->dev); 1271 bool is_full_dev = &device->coredev == coredev; 1272 struct ib_port *p; 1273 struct ib_port_attr attr; 1274 int i; 1275 int ret; 1276 1277 ret = ib_query_port(device, port_num, &attr); 1278 if (ret) 1279 return ret; 1280 1281 p = kzalloc(sizeof *p, GFP_KERNEL); 1282 if (!p) 1283 return -ENOMEM; 1284 1285 p->ibdev = device; 1286 p->port_num = port_num; 1287 1288 ret = kobject_init_and_add(&p->kobj, &port_type, 1289 coredev->ports_kobj, 1290 "%d", port_num); 1291 if (ret) 1292 goto err_put; 1293 1294 if (device->ops.process_mad && is_full_dev) { 1295 p->pma_table = get_counter_table(device, port_num); 1296 ret = sysfs_create_group(&p->kobj, p->pma_table); 1297 if (ret) 1298 goto err_put; 1299 } 1300 1301 p->gid_group.name = "gids"; 1302 p->gid_group.attrs = alloc_group_attrs(show_port_gid, attr.gid_tbl_len); 1303 if (!p->gid_group.attrs) { 1304 ret = -ENOMEM; 1305 goto err_remove_pma; 1306 } 1307 1308 ret = sysfs_create_group(&p->kobj, &p->gid_group); 1309 if (ret) 1310 goto err_free_gid; 1311 1312 if (attr.pkey_tbl_len) { 1313 p->pkey_group = kzalloc(sizeof(*p->pkey_group), GFP_KERNEL); 1314 if (!p->pkey_group) { 1315 ret = -ENOMEM; 1316 goto err_remove_gid; 1317 } 1318 1319 p->pkey_group->name = "pkeys"; 1320 p->pkey_group->attrs = alloc_group_attrs(show_port_pkey, 1321 attr.pkey_tbl_len); 1322 if (!p->pkey_group->attrs) { 1323 ret = -ENOMEM; 1324 goto err_free_pkey_group; 1325 } 1326 1327 ret = sysfs_create_group(&p->kobj, p->pkey_group); 1328 if (ret) 1329 goto err_free_pkey; 1330 } 1331 1332 /* 1333 * If port == 0, it means hw_counters are per device and not per 1334 * port, so holder should be device. Therefore skip per port 1335 * counter initialization. 1336 */ 1337 if (port_num && is_full_dev) { 1338 ret = setup_hw_port_stats(p); 1339 if (ret && ret != -EOPNOTSUPP) 1340 goto err_remove_pkey; 1341 } 1342 ret = setup_gid_attrs(p, &attr); 1343 if (ret) 1344 goto err_remove_stats; 1345 1346 if (device->ops.init_port && is_full_dev) { 1347 ret = device->ops.init_port(device, port_num, &p->kobj); 1348 if (ret) 1349 goto err_remove_gid_attrs; 1350 } 1351 1352 list_add_tail(&p->kobj.entry, &coredev->port_list); 1353 if (device->port_data && is_full_dev) 1354 device->port_data[port_num].sysfs = p; 1355 1356 kobject_uevent(&p->kobj, KOBJ_ADD); 1357 return 0; 1358 1359 err_remove_gid_attrs: 1360 destroy_gid_attrs(p); 1361 1362 err_remove_stats: 1363 destroy_hw_port_stats(p); 1364 1365 err_remove_pkey: 1366 if (p->pkey_group) 1367 sysfs_remove_group(&p->kobj, p->pkey_group); 1368 1369 err_free_pkey: 1370 if (p->pkey_group) { 1371 for (i = 0; i < attr.pkey_tbl_len; ++i) 1372 kfree(p->pkey_group->attrs[i]); 1373 1374 kfree(p->pkey_group->attrs); 1375 p->pkey_group->attrs = NULL; 1376 } 1377 1378 err_free_pkey_group: 1379 kfree(p->pkey_group); 1380 1381 err_remove_gid: 1382 sysfs_remove_group(&p->kobj, &p->gid_group); 1383 1384 err_free_gid: 1385 for (i = 0; i < attr.gid_tbl_len; ++i) 1386 kfree(p->gid_group.attrs[i]); 1387 1388 kfree(p->gid_group.attrs); 1389 p->gid_group.attrs = NULL; 1390 1391 err_remove_pma: 1392 if (p->pma_table) 1393 sysfs_remove_group(&p->kobj, p->pma_table); 1394 1395 err_put: 1396 kobject_put(&p->kobj); 1397 return ret; 1398 } 1399 1400 static const char *node_type_string(int node_type) 1401 { 1402 switch (node_type) { 1403 case RDMA_NODE_IB_CA: 1404 return "CA"; 1405 case RDMA_NODE_IB_SWITCH: 1406 return "switch"; 1407 case RDMA_NODE_IB_ROUTER: 1408 return "router"; 1409 case RDMA_NODE_RNIC: 1410 return "RNIC"; 1411 case RDMA_NODE_USNIC: 1412 return "usNIC"; 1413 case RDMA_NODE_USNIC_UDP: 1414 return "usNIC UDP"; 1415 case RDMA_NODE_UNSPECIFIED: 1416 return "unspecified"; 1417 } 1418 return "<unknown>"; 1419 } 1420 1421 static ssize_t node_type_show(struct device *device, 1422 struct device_attribute *attr, char *buf) 1423 { 1424 struct ib_device *dev = rdma_device_to_ibdev(device); 1425 1426 return sysfs_emit(buf, "%d: %s\n", dev->node_type, 1427 node_type_string(dev->node_type)); 1428 } 1429 static DEVICE_ATTR_RO(node_type); 1430 1431 static ssize_t sys_image_guid_show(struct device *device, 1432 struct device_attribute *dev_attr, char *buf) 1433 { 1434 struct ib_device *dev = rdma_device_to_ibdev(device); 1435 __be16 *guid = (__be16 *)&dev->attrs.sys_image_guid; 1436 1437 return sysfs_emit(buf, "%04x:%04x:%04x:%04x\n", 1438 be16_to_cpu(guid[0]), 1439 be16_to_cpu(guid[1]), 1440 be16_to_cpu(guid[2]), 1441 be16_to_cpu(guid[3])); 1442 } 1443 static DEVICE_ATTR_RO(sys_image_guid); 1444 1445 static ssize_t node_guid_show(struct device *device, 1446 struct device_attribute *attr, char *buf) 1447 { 1448 struct ib_device *dev = rdma_device_to_ibdev(device); 1449 __be16 *node_guid = (__be16 *)&dev->node_guid; 1450 1451 return sysfs_emit(buf, "%04x:%04x:%04x:%04x\n", 1452 be16_to_cpu(node_guid[0]), 1453 be16_to_cpu(node_guid[1]), 1454 be16_to_cpu(node_guid[2]), 1455 be16_to_cpu(node_guid[3])); 1456 } 1457 static DEVICE_ATTR_RO(node_guid); 1458 1459 static ssize_t node_desc_show(struct device *device, 1460 struct device_attribute *attr, char *buf) 1461 { 1462 struct ib_device *dev = rdma_device_to_ibdev(device); 1463 1464 return sysfs_emit(buf, "%.64s\n", dev->node_desc); 1465 } 1466 1467 static ssize_t node_desc_store(struct device *device, 1468 struct device_attribute *attr, 1469 const char *buf, size_t count) 1470 { 1471 struct ib_device *dev = rdma_device_to_ibdev(device); 1472 struct ib_device_modify desc = {}; 1473 int ret; 1474 1475 if (!dev->ops.modify_device) 1476 return -EOPNOTSUPP; 1477 1478 memcpy(desc.node_desc, buf, min_t(int, count, IB_DEVICE_NODE_DESC_MAX)); 1479 ret = ib_modify_device(dev, IB_DEVICE_MODIFY_NODE_DESC, &desc); 1480 if (ret) 1481 return ret; 1482 1483 return count; 1484 } 1485 static DEVICE_ATTR_RW(node_desc); 1486 1487 static ssize_t fw_ver_show(struct device *device, struct device_attribute *attr, 1488 char *buf) 1489 { 1490 struct ib_device *dev = rdma_device_to_ibdev(device); 1491 char version[IB_FW_VERSION_NAME_MAX] = {}; 1492 1493 ib_get_device_fw_str(dev, version); 1494 1495 return sysfs_emit(buf, "%s\n", version); 1496 } 1497 static DEVICE_ATTR_RO(fw_ver); 1498 1499 static struct attribute *ib_dev_attrs[] = { 1500 &dev_attr_node_type.attr, 1501 &dev_attr_node_guid.attr, 1502 &dev_attr_sys_image_guid.attr, 1503 &dev_attr_fw_ver.attr, 1504 &dev_attr_node_desc.attr, 1505 NULL, 1506 }; 1507 1508 const struct attribute_group ib_dev_attr_group = { 1509 .attrs = ib_dev_attrs, 1510 }; 1511 1512 void ib_free_port_attrs(struct ib_core_device *coredev) 1513 { 1514 struct ib_device *device = rdma_device_to_ibdev(&coredev->dev); 1515 bool is_full_dev = &device->coredev == coredev; 1516 struct kobject *p, *t; 1517 1518 list_for_each_entry_safe(p, t, &coredev->port_list, entry) { 1519 struct ib_port *port = container_of(p, struct ib_port, kobj); 1520 1521 list_del(&p->entry); 1522 destroy_hw_port_stats(port); 1523 if (device->port_data && is_full_dev) 1524 device->port_data[port->port_num].sysfs = NULL; 1525 1526 if (port->pma_table) 1527 sysfs_remove_group(p, port->pma_table); 1528 if (port->pkey_group) 1529 sysfs_remove_group(p, port->pkey_group); 1530 sysfs_remove_group(p, &port->gid_group); 1531 destroy_gid_attrs(port); 1532 kobject_put(p); 1533 } 1534 1535 kobject_put(coredev->ports_kobj); 1536 } 1537 1538 int ib_setup_port_attrs(struct ib_core_device *coredev) 1539 { 1540 struct ib_device *device = rdma_device_to_ibdev(&coredev->dev); 1541 u32 port; 1542 int ret; 1543 1544 coredev->ports_kobj = kobject_create_and_add("ports", 1545 &coredev->dev.kobj); 1546 if (!coredev->ports_kobj) 1547 return -ENOMEM; 1548 1549 rdma_for_each_port (device, port) { 1550 ret = add_port(coredev, port); 1551 if (ret) 1552 goto err_put; 1553 } 1554 1555 return 0; 1556 1557 err_put: 1558 ib_free_port_attrs(coredev); 1559 return ret; 1560 } 1561 1562 int ib_device_register_sysfs(struct ib_device *device) 1563 { 1564 int ret; 1565 1566 ret = ib_setup_port_attrs(&device->coredev); 1567 if (ret) 1568 return ret; 1569 1570 ret = setup_hw_device_stats(device); 1571 if (ret && ret != -EOPNOTSUPP) { 1572 ib_free_port_attrs(&device->coredev); 1573 return ret; 1574 } 1575 1576 return 0; 1577 } 1578 1579 void ib_device_unregister_sysfs(struct ib_device *device) 1580 { 1581 destroy_hw_device_stats(device); 1582 ib_free_port_attrs(&device->coredev); 1583 } 1584 1585 /** 1586 * ib_port_register_module_stat - add module counters under relevant port 1587 * of IB device. 1588 * 1589 * @device: IB device to add counters 1590 * @port_num: valid port number 1591 * @kobj: pointer to the kobject to initialize 1592 * @ktype: pointer to the ktype for this kobject. 1593 * @name: the name of the kobject 1594 */ 1595 int ib_port_register_module_stat(struct ib_device *device, u32 port_num, 1596 struct kobject *kobj, struct kobj_type *ktype, 1597 const char *name) 1598 { 1599 struct kobject *p, *t; 1600 int ret; 1601 1602 list_for_each_entry_safe(p, t, &device->coredev.port_list, entry) { 1603 struct ib_port *port = container_of(p, struct ib_port, kobj); 1604 1605 if (port->port_num != port_num) 1606 continue; 1607 1608 ret = kobject_init_and_add(kobj, ktype, &port->kobj, "%s", 1609 name); 1610 if (ret) { 1611 kobject_put(kobj); 1612 return ret; 1613 } 1614 } 1615 1616 return 0; 1617 } 1618 EXPORT_SYMBOL(ib_port_register_module_stat); 1619 1620 /** 1621 * ib_port_unregister_module_stat - release module counters 1622 * @kobj: pointer to the kobject to release 1623 */ 1624 void ib_port_unregister_module_stat(struct kobject *kobj) 1625 { 1626 kobject_put(kobj); 1627 } 1628 EXPORT_SYMBOL(ib_port_unregister_module_stat); 1629