drivers/infiniband/core/sysfs.c

   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
  46 struct ib_port;
  47
  48 struct gid_attr_group {
  49         struct ib_port          *port;
  50         struct kobject          kobj;
  51         struct attribute_group  ndev;
  52         struct attribute_group  type;
  53 };
  54 struct ib_port {
  55         struct kobject         kobj;
  56         struct ib_device      *ibdev;
  57         struct gid_attr_group *gid_attr_group;
  58         struct attribute_group gid_group;
  59         struct attribute_group pkey_group;
  60         struct attribute_group *pma_table;
  61         struct attribute_group *hw_stats_ag;
  62         struct rdma_hw_stats   *hw_stats;
  63         u8                     port_num;
  64 };
  65
  66 struct port_attribute {
  67         struct attribute attr;
  68         ssize_t (*show)(struct ib_port *, struct port_attribute *, char *buf);
  69         ssize_t (*store)(struct ib_port *, struct port_attribute *,
  70                          const char *buf, size_t count);
  71 };
  72
  73 #define PORT_ATTR(_name, _mode, _show, _store) \
  74 struct port_attribute port_attr_##_name = __ATTR(_name, _mode, _show, _store)
  75
  76 #define PORT_ATTR_RO(_name) \
  77 struct port_attribute port_attr_##_name = __ATTR_RO(_name)
  78
  79 struct port_table_attribute {
  80         struct port_attribute   attr;
  81         char                    name[8];
  82         int                     index;
  83         __be16                  attr_id;
  84 };
  85
  86 struct hw_stats_attribute {
  87         struct attribute        attr;
  88         ssize_t                 (*show)(struct kobject *kobj,
  89                                         struct attribute *attr, char *buf);
  90         ssize_t                 (*store)(struct kobject *kobj,
  91                                          struct attribute *attr,
  92                                          const char *buf,
  93                                          size_t count);
  94         int                     index;
  95         u8                      port_num;
  96 };
  97
  98 static ssize_t port_attr_show(struct kobject *kobj,
  99                               struct attribute *attr, char *buf)
 100 {
 101         struct port_attribute *port_attr =
 102                 container_of(attr, struct port_attribute, attr);
 103         struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 104
 105         if (!port_attr->show)
 106                 return -EIO;
 107
 108         return port_attr->show(p, port_attr, buf);
 109 }
 110
 111 static const struct sysfs_ops port_sysfs_ops = {
 112         .show = port_attr_show
 113 };
 114
 115 static ssize_t gid_attr_show(struct kobject *kobj,
 116                              struct attribute *attr, char *buf)
 117 {
 118         struct port_attribute *port_attr =
 119                 container_of(attr, struct port_attribute, attr);
 120         struct ib_port *p = container_of(kobj, struct gid_attr_group,
 121                                          kobj)->port;
 122
 123         if (!port_attr->show)
 124                 return -EIO;
 125
 126         return port_attr->show(p, port_attr, buf);
 127 }
 128
 129 static const struct sysfs_ops gid_attr_sysfs_ops = {
 130         .show = gid_attr_show
 131 };
 132
 133 static ssize_t state_show(struct ib_port *p, struct port_attribute *unused,
 134                           char *buf)
 135 {
 136         struct ib_port_attr attr;
 137         ssize_t ret;
 138
 139         static const char *state_name[] = {
 140                 [IB_PORT_NOP]           = "NOP",
 141                 [IB_PORT_DOWN]          = "DOWN",
 142                 [IB_PORT_INIT]          = "INIT",
 143                 [IB_PORT_ARMED]         = "ARMED",
 144                 [IB_PORT_ACTIVE]        = "ACTIVE",
 145                 [IB_PORT_ACTIVE_DEFER]  = "ACTIVE_DEFER"
 146         };
 147
 148         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 149         if (ret)
 150                 return ret;
 151
 152         return sprintf(buf, "%d: %s\n", attr.state,
 153                        attr.state >= 0 && attr.state < ARRAY_SIZE(state_name) ?
 154                        state_name[attr.state] : "UNKNOWN");
 155 }
 156
 157 static ssize_t lid_show(struct ib_port *p, struct port_attribute *unused,
 158                         char *buf)
 159 {
 160         struct ib_port_attr attr;
 161         ssize_t ret;
 162
 163         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 164         if (ret)
 165                 return ret;
 166
 167         return sprintf(buf, "0x%x\n", attr.lid);
 168 }
 169
 170 static ssize_t lid_mask_count_show(struct ib_port *p,
 171                                    struct port_attribute *unused,
 172                                    char *buf)
 173 {
 174         struct ib_port_attr attr;
 175         ssize_t ret;
 176
 177         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 178         if (ret)
 179                 return ret;
 180
 181         return sprintf(buf, "%d\n", attr.lmc);
 182 }
 183
 184 static ssize_t sm_lid_show(struct ib_port *p, struct port_attribute *unused,
 185                            char *buf)
 186 {
 187         struct ib_port_attr attr;
 188         ssize_t ret;
 189
 190         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 191         if (ret)
 192                 return ret;
 193
 194         return sprintf(buf, "0x%x\n", attr.sm_lid);
 195 }
 196
 197 static ssize_t sm_sl_show(struct ib_port *p, struct port_attribute *unused,
 198                           char *buf)
 199 {
 200         struct ib_port_attr attr;
 201         ssize_t ret;
 202
 203         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 204         if (ret)
 205                 return ret;
 206
 207         return sprintf(buf, "%d\n", attr.sm_sl);
 208 }
 209
 210 static ssize_t cap_mask_show(struct ib_port *p, struct port_attribute *unused,
 211                              char *buf)
 212 {
 213         struct ib_port_attr attr;
 214         ssize_t ret;
 215
 216         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 217         if (ret)
 218                 return ret;
 219
 220         return sprintf(buf, "0x%08x\n", attr.port_cap_flags);
 221 }
 222
 223 static ssize_t rate_show(struct ib_port *p, struct port_attribute *unused,
 224                          char *buf)
 225 {
 226         struct ib_port_attr attr;
 227         char *speed = "";
 228         int rate;               /* in deci-Gb/sec */
 229         ssize_t ret;
 230
 231         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 232         if (ret)
 233                 return ret;
 234
 235         switch (attr.active_speed) {
 236         case IB_SPEED_DDR:
 237                 speed = " DDR";
 238                 rate = 50;
 239                 break;
 240         case IB_SPEED_QDR:
 241                 speed = " QDR";
 242                 rate = 100;
 243                 break;
 244         case IB_SPEED_FDR10:
 245                 speed = " FDR10";
 246                 rate = 100;
 247                 break;
 248         case IB_SPEED_FDR:
 249                 speed = " FDR";
 250                 rate = 140;
 251                 break;
 252         case IB_SPEED_EDR:
 253                 speed = " EDR";
 254                 rate = 250;
 255                 break;
 256         case IB_SPEED_SDR:
 257         default:                /* default to SDR for invalid rates */
 258                 rate = 25;
 259                 break;
 260         }
 261
 262         rate *= ib_width_enum_to_int(attr.active_width);
 263         if (rate < 0)
 264                 return -EINVAL;
 265
 266         return sprintf(buf, "%d%s Gb/sec (%dX%s)\n",
 267                        rate / 10, rate % 10 ? ".5" : "",
 268                        ib_width_enum_to_int(attr.active_width), speed);
 269 }
 270
 271 static ssize_t phys_state_show(struct ib_port *p, struct port_attribute *unused,
 272                                char *buf)
 273 {
 274         struct ib_port_attr attr;
 275
 276         ssize_t ret;
 277
 278         ret = ib_query_port(p->ibdev, p->port_num, &attr);
 279         if (ret)
 280                 return ret;
 281
 282         switch (attr.phys_state) {
 283         case 1:  return sprintf(buf, "1: Sleep\n");
 284         case 2:  return sprintf(buf, "2: Polling\n");
 285         case 3:  return sprintf(buf, "3: Disabled\n");
 286         case 4:  return sprintf(buf, "4: PortConfigurationTraining\n");
 287         case 5:  return sprintf(buf, "5: LinkUp\n");
 288         case 6:  return sprintf(buf, "6: LinkErrorRecovery\n");
 289         case 7:  return sprintf(buf, "7: Phy Test\n");
 290         default: return sprintf(buf, "%d: <unknown>\n", attr.phys_state);
 291         }
 292 }
 293
 294 static ssize_t link_layer_show(struct ib_port *p, struct port_attribute *unused,
 295                                char *buf)
 296 {
 297         switch (rdma_port_get_link_layer(p->ibdev, p->port_num)) {
 298         case IB_LINK_LAYER_INFINIBAND:
 299                 return sprintf(buf, "%s\n", "InfiniBand");
 300         case IB_LINK_LAYER_ETHERNET:
 301                 return sprintf(buf, "%s\n", "Ethernet");
 302         default:
 303                 return sprintf(buf, "%s\n", "Unknown");
 304         }
 305 }
 306
 307 static PORT_ATTR_RO(state);
 308 static PORT_ATTR_RO(lid);
 309 static PORT_ATTR_RO(lid_mask_count);
 310 static PORT_ATTR_RO(sm_lid);
 311 static PORT_ATTR_RO(sm_sl);
 312 static PORT_ATTR_RO(cap_mask);
 313 static PORT_ATTR_RO(rate);
 314 static PORT_ATTR_RO(phys_state);
 315 static PORT_ATTR_RO(link_layer);
 316
 317 static struct attribute *port_default_attrs[] = {
 318         &port_attr_state.attr,
 319         &port_attr_lid.attr,
 320         &port_attr_lid_mask_count.attr,
 321         &port_attr_sm_lid.attr,
 322         &port_attr_sm_sl.attr,
 323         &port_attr_cap_mask.attr,
 324         &port_attr_rate.attr,
 325         &port_attr_phys_state.attr,
 326         &port_attr_link_layer.attr,
 327         NULL
 328 };
 329
 330 static size_t print_ndev(struct ib_gid_attr *gid_attr, char *buf)
 331 {
 332         if (!gid_attr->ndev)
 333                 return -EINVAL;
 334
 335         return sprintf(buf, "%s\n", gid_attr->ndev->name);
 336 }
 337
 338 static size_t print_gid_type(struct ib_gid_attr *gid_attr, char *buf)
 339 {
 340         return sprintf(buf, "%s\n", ib_cache_gid_type_str(gid_attr->gid_type));
 341 }
 342
 343 static ssize_t _show_port_gid_attr(struct ib_port *p,
 344                                    struct port_attribute *attr,
 345                                    char *buf,
 346                                    size_t (*print)(struct ib_gid_attr *gid_attr,
 347                                                    char *buf))
 348 {
 349         struct port_table_attribute *tab_attr =
 350                 container_of(attr, struct port_table_attribute, attr);
 351         union ib_gid gid;
 352         struct ib_gid_attr gid_attr = {};
 353         ssize_t ret;
 354
 355         ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid,
 356                            &gid_attr);
 357         if (ret)
 358                 goto err;
 359
 360         ret = print(&gid_attr, buf);
 361
 362 err:
 363         if (gid_attr.ndev)
 364                 dev_put(gid_attr.ndev);
 365         return ret;
 366 }
 367
 368 static ssize_t show_port_gid(struct ib_port *p, struct port_attribute *attr,
 369                              char *buf)
 370 {
 371         struct port_table_attribute *tab_attr =
 372                 container_of(attr, struct port_table_attribute, attr);
 373         union ib_gid gid;
 374         ssize_t ret;
 375
 376         ret = ib_query_gid(p->ibdev, p->port_num, tab_attr->index, &gid, NULL);
 377         if (ret)
 378                 return ret;
 379
 380         return sprintf(buf, "%pI6\n", gid.raw);
 381 }
 382
 383 static ssize_t show_port_gid_attr_ndev(struct ib_port *p,
 384                                        struct port_attribute *attr, char *buf)
 385 {
 386         return _show_port_gid_attr(p, attr, buf, print_ndev);
 387 }
 388
 389 static ssize_t show_port_gid_attr_gid_type(struct ib_port *p,
 390                                            struct port_attribute *attr,
 391                                            char *buf)
 392 {
 393         return _show_port_gid_attr(p, attr, buf, print_gid_type);
 394 }
 395
 396 static ssize_t show_port_pkey(struct ib_port *p, struct port_attribute *attr,
 397                               char *buf)
 398 {
 399         struct port_table_attribute *tab_attr =
 400                 container_of(attr, struct port_table_attribute, attr);
 401         u16 pkey;
 402         ssize_t ret;
 403
 404         ret = ib_query_pkey(p->ibdev, p->port_num, tab_attr->index, &pkey);
 405         if (ret)
 406                 return ret;
 407
 408         return sprintf(buf, "0x%04x\n", pkey);
 409 }
 410
 411 #define PORT_PMA_ATTR(_name, _counter, _width, _offset)                 \
 412 struct port_table_attribute port_pma_attr_##_name = {                   \
 413         .attr  = __ATTR(_name, S_IRUGO, show_pma_counter, NULL),        \
 414         .index = (_offset) | ((_width) << 16) | ((_counter) << 24),     \
 415         .attr_id = IB_PMA_PORT_COUNTERS ,                               \
 416 }
 417
 418 #define PORT_PMA_ATTR_EXT(_name, _width, _offset)                       \
 419 struct port_table_attribute port_pma_attr_ext_##_name = {               \
 420         .attr  = __ATTR(_name, S_IRUGO, show_pma_counter, NULL),        \
 421         .index = (_offset) | ((_width) << 16),                          \
 422         .attr_id = IB_PMA_PORT_COUNTERS_EXT ,                           \
 423 }
 424
 425 /*
 426  * Get a Perfmgmt MAD block of data.
 427  * Returns error code or the number of bytes retrieved.
 428  */
 429 static int get_perf_mad(struct ib_device *dev, int port_num, __be16 attr,
 430                 void *data, int offset, size_t size)
 431 {
 432         struct ib_mad *in_mad;
 433         struct ib_mad *out_mad;
 434         size_t mad_size = sizeof(*out_mad);
 435         u16 out_mad_pkey_index = 0;
 436         ssize_t ret;
 437
 438         if (!dev->process_mad)
 439                 return -ENOSYS;
 440
 441         in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
 442         out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
 443         if (!in_mad || !out_mad) {
 444                 ret = -ENOMEM;
 445                 goto out;
 446         }
 447
 448         in_mad->mad_hdr.base_version  = 1;
 449         in_mad->mad_hdr.mgmt_class    = IB_MGMT_CLASS_PERF_MGMT;
 450         in_mad->mad_hdr.class_version = 1;
 451         in_mad->mad_hdr.method        = IB_MGMT_METHOD_GET;
 452         in_mad->mad_hdr.attr_id       = attr;
 453
 454         if (attr != IB_PMA_CLASS_PORT_INFO)
 455                 in_mad->data[41] = port_num;    /* PortSelect field */
 456
 457         if ((dev->process_mad(dev, IB_MAD_IGNORE_MKEY,
 458                  port_num, NULL, NULL,
 459                  (const struct ib_mad_hdr *)in_mad, mad_size,
 460                  (struct ib_mad_hdr *)out_mad, &mad_size,
 461                  &out_mad_pkey_index) &
 462              (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) !=
 463             (IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY)) {
 464                 ret = -EINVAL;
 465                 goto out;
 466         }
 467         memcpy(data, out_mad->data + offset, size);
 468         ret = size;
 469 out:
 470         kfree(in_mad);
 471         kfree(out_mad);
 472         return ret;
 473 }
 474
 475 static ssize_t show_pma_counter(struct ib_port *p, struct port_attribute *attr,
 476                                 char *buf)
 477 {
 478         struct port_table_attribute *tab_attr =
 479                 container_of(attr, struct port_table_attribute, attr);
 480         int offset = tab_attr->index & 0xffff;
 481         int width  = (tab_attr->index >> 16) & 0xff;
 482         ssize_t ret;
 483         u8 data[8];
 484
 485         ret = get_perf_mad(p->ibdev, p->port_num, tab_attr->attr_id, &data,
 486                         40 + offset / 8, sizeof(data));
 487         if (ret < 0)
 488                 return sprintf(buf, "N/A (no PMA)\n");
 489
 490         switch (width) {
 491         case 4:
 492                 ret = sprintf(buf, "%u\n", (*data >>
 493                                             (4 - (offset % 8))) & 0xf);
 494                 break;
 495         case 8:
 496                 ret = sprintf(buf, "%u\n", *data);
 497                 break;
 498         case 16:
 499                 ret = sprintf(buf, "%u\n",
 500                               be16_to_cpup((__be16 *)data));
 501                 break;
 502         case 32:
 503                 ret = sprintf(buf, "%u\n",
 504                               be32_to_cpup((__be32 *)data));
 505                 break;
 506         case 64:
 507                 ret = sprintf(buf, "%llu\n",
 508                                 be64_to_cpup((__be64 *)data));
 509                 break;
 510
 511         default:
 512                 ret = 0;
 513         }
 514
 515         return ret;
 516 }
 517
 518 static PORT_PMA_ATTR(symbol_error                   ,  0, 16,  32);
 519 static PORT_PMA_ATTR(link_error_recovery            ,  1,  8,  48);
 520 static PORT_PMA_ATTR(link_downed                    ,  2,  8,  56);
 521 static PORT_PMA_ATTR(port_rcv_errors                ,  3, 16,  64);
 522 static PORT_PMA_ATTR(port_rcv_remote_physical_errors,  4, 16,  80);
 523 static PORT_PMA_ATTR(port_rcv_switch_relay_errors   ,  5, 16,  96);
 524 static PORT_PMA_ATTR(port_xmit_discards             ,  6, 16, 112);
 525 static PORT_PMA_ATTR(port_xmit_constraint_errors    ,  7,  8, 128);
 526 static PORT_PMA_ATTR(port_rcv_constraint_errors     ,  8,  8, 136);
 527 static PORT_PMA_ATTR(local_link_integrity_errors    ,  9,  4, 152);
 528 static PORT_PMA_ATTR(excessive_buffer_overrun_errors, 10,  4, 156);
 529 static PORT_PMA_ATTR(VL15_dropped                   , 11, 16, 176);
 530 static PORT_PMA_ATTR(port_xmit_data                 , 12, 32, 192);
 531 static PORT_PMA_ATTR(port_rcv_data                  , 13, 32, 224);
 532 static PORT_PMA_ATTR(port_xmit_packets              , 14, 32, 256);
 533 static PORT_PMA_ATTR(port_rcv_packets               , 15, 32, 288);
 534 static PORT_PMA_ATTR(port_xmit_wait                 ,  0, 32, 320);
 535
 536 /*
 537  * Counters added by extended set
 538  */
 539 static PORT_PMA_ATTR_EXT(port_xmit_data             , 64,  64);
 540 static PORT_PMA_ATTR_EXT(port_rcv_data              , 64, 128);
 541 static PORT_PMA_ATTR_EXT(port_xmit_packets          , 64, 192);
 542 static PORT_PMA_ATTR_EXT(port_rcv_packets           , 64, 256);
 543 static PORT_PMA_ATTR_EXT(unicast_xmit_packets       , 64, 320);
 544 static PORT_PMA_ATTR_EXT(unicast_rcv_packets        , 64, 384);
 545 static PORT_PMA_ATTR_EXT(multicast_xmit_packets     , 64, 448);
 546 static PORT_PMA_ATTR_EXT(multicast_rcv_packets      , 64, 512);
 547
 548 static struct attribute *pma_attrs[] = {
 549         &port_pma_attr_symbol_error.attr.attr,
 550         &port_pma_attr_link_error_recovery.attr.attr,
 551         &port_pma_attr_link_downed.attr.attr,
 552         &port_pma_attr_port_rcv_errors.attr.attr,
 553         &port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
 554         &port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
 555         &port_pma_attr_port_xmit_discards.attr.attr,
 556         &port_pma_attr_port_xmit_constraint_errors.attr.attr,
 557         &port_pma_attr_port_rcv_constraint_errors.attr.attr,
 558         &port_pma_attr_local_link_integrity_errors.attr.attr,
 559         &port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
 560         &port_pma_attr_VL15_dropped.attr.attr,
 561         &port_pma_attr_port_xmit_data.attr.attr,
 562         &port_pma_attr_port_rcv_data.attr.attr,
 563         &port_pma_attr_port_xmit_packets.attr.attr,
 564         &port_pma_attr_port_rcv_packets.attr.attr,
 565         &port_pma_attr_port_xmit_wait.attr.attr,
 566         NULL
 567 };
 568
 569 static struct attribute *pma_attrs_ext[] = {
 570         &port_pma_attr_symbol_error.attr.attr,
 571         &port_pma_attr_link_error_recovery.attr.attr,
 572         &port_pma_attr_link_downed.attr.attr,
 573         &port_pma_attr_port_rcv_errors.attr.attr,
 574         &port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
 575         &port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
 576         &port_pma_attr_port_xmit_discards.attr.attr,
 577         &port_pma_attr_port_xmit_constraint_errors.attr.attr,
 578         &port_pma_attr_port_rcv_constraint_errors.attr.attr,
 579         &port_pma_attr_local_link_integrity_errors.attr.attr,
 580         &port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
 581         &port_pma_attr_VL15_dropped.attr.attr,
 582         &port_pma_attr_ext_port_xmit_data.attr.attr,
 583         &port_pma_attr_ext_port_rcv_data.attr.attr,
 584         &port_pma_attr_ext_port_xmit_packets.attr.attr,
 585         &port_pma_attr_port_xmit_wait.attr.attr,
 586         &port_pma_attr_ext_port_rcv_packets.attr.attr,
 587         &port_pma_attr_ext_unicast_rcv_packets.attr.attr,
 588         &port_pma_attr_ext_unicast_xmit_packets.attr.attr,
 589         &port_pma_attr_ext_multicast_rcv_packets.attr.attr,
 590         &port_pma_attr_ext_multicast_xmit_packets.attr.attr,
 591         NULL
 592 };
 593
 594 static struct attribute *pma_attrs_noietf[] = {
 595         &port_pma_attr_symbol_error.attr.attr,
 596         &port_pma_attr_link_error_recovery.attr.attr,
 597         &port_pma_attr_link_downed.attr.attr,
 598         &port_pma_attr_port_rcv_errors.attr.attr,
 599         &port_pma_attr_port_rcv_remote_physical_errors.attr.attr,
 600         &port_pma_attr_port_rcv_switch_relay_errors.attr.attr,
 601         &port_pma_attr_port_xmit_discards.attr.attr,
 602         &port_pma_attr_port_xmit_constraint_errors.attr.attr,
 603         &port_pma_attr_port_rcv_constraint_errors.attr.attr,
 604         &port_pma_attr_local_link_integrity_errors.attr.attr,
 605         &port_pma_attr_excessive_buffer_overrun_errors.attr.attr,
 606         &port_pma_attr_VL15_dropped.attr.attr,
 607         &port_pma_attr_ext_port_xmit_data.attr.attr,
 608         &port_pma_attr_ext_port_rcv_data.attr.attr,
 609         &port_pma_attr_ext_port_xmit_packets.attr.attr,
 610         &port_pma_attr_ext_port_rcv_packets.attr.attr,
 611         &port_pma_attr_port_xmit_wait.attr.attr,
 612         NULL
 613 };
 614
 615 static struct attribute_group pma_group = {
 616         .name  = "counters",
 617         .attrs  = pma_attrs
 618 };
 619
 620 static struct attribute_group pma_group_ext = {
 621         .name  = "counters",
 622         .attrs  = pma_attrs_ext
 623 };
 624
 625 static struct attribute_group pma_group_noietf = {
 626         .name  = "counters",
 627         .attrs  = pma_attrs_noietf
 628 };
 629
 630 static void ib_port_release(struct kobject *kobj)
 631 {
 632         struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 633         struct attribute *a;
 634         int i;
 635
 636         if (p->gid_group.attrs) {
 637                 for (i = 0; (a = p->gid_group.attrs[i]); ++i)
 638                         kfree(a);
 639
 640                 kfree(p->gid_group.attrs);
 641         }
 642
 643         if (p->pkey_group.attrs) {
 644                 for (i = 0; (a = p->pkey_group.attrs[i]); ++i)
 645                         kfree(a);
 646
 647                 kfree(p->pkey_group.attrs);
 648         }
 649
 650         kfree(p);
 651 }
 652
 653 static void ib_port_gid_attr_release(struct kobject *kobj)
 654 {
 655         struct gid_attr_group *g = container_of(kobj, struct gid_attr_group,
 656                                                 kobj);
 657         struct attribute *a;
 658         int i;
 659
 660         if (g->ndev.attrs) {
 661                 for (i = 0; (a = g->ndev.attrs[i]); ++i)
 662                         kfree(a);
 663
 664                 kfree(g->ndev.attrs);
 665         }
 666
 667         if (g->type.attrs) {
 668                 for (i = 0; (a = g->type.attrs[i]); ++i)
 669                         kfree(a);
 670
 671                 kfree(g->type.attrs);
 672         }
 673
 674         kfree(g);
 675 }
 676
 677 static struct kobj_type port_type = {
 678         .release       = ib_port_release,
 679         .sysfs_ops     = &port_sysfs_ops,
 680         .default_attrs = port_default_attrs
 681 };
 682
 683 static struct kobj_type gid_attr_type = {
 684         .sysfs_ops      = &gid_attr_sysfs_ops,
 685         .release        = ib_port_gid_attr_release
 686 };
 687
 688 static struct attribute **
 689 alloc_group_attrs(ssize_t (*show)(struct ib_port *,
 690                                   struct port_attribute *, char *buf),
 691                   int len)
 692 {
 693         struct attribute **tab_attr;
 694         struct port_table_attribute *element;
 695         int i;
 696
 697         tab_attr = kcalloc(1 + len, sizeof(struct attribute *), GFP_KERNEL);
 698         if (!tab_attr)
 699                 return NULL;
 700
 701         for (i = 0; i < len; i++) {
 702                 element = kzalloc(sizeof(struct port_table_attribute),
 703                                   GFP_KERNEL);
 704                 if (!element)
 705                         goto err;
 706
 707                 if (snprintf(element->name, sizeof(element->name),
 708                              "%d", i) >= sizeof(element->name)) {
 709                         kfree(element);
 710                         goto err;
 711                 }
 712
 713                 element->attr.attr.name  = element->name;
 714                 element->attr.attr.mode  = S_IRUGO;
 715                 element->attr.show       = show;
 716                 element->index           = i;
 717                 sysfs_attr_init(&element->attr.attr);
 718
 719                 tab_attr[i] = &element->attr.attr;
 720         }
 721
 722         return tab_attr;
 723
 724 err:
 725         while (--i >= 0)
 726                 kfree(tab_attr[i]);
 727         kfree(tab_attr);
 728         return NULL;
 729 }
 730
 731 /*
 732  * Figure out which counter table to use depending on
 733  * the device capabilities.
 734  */
 735 static struct attribute_group *get_counter_table(struct ib_device *dev,
 736                                                  int port_num)
 737 {
 738         struct ib_class_port_info cpi;
 739
 740         if (get_perf_mad(dev, port_num, IB_PMA_CLASS_PORT_INFO,
 741                                 &cpi, 40, sizeof(cpi)) >= 0) {
 742                 if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH)
 743                         /* We have extended counters */
 744                         return &pma_group_ext;
 745
 746                 if (cpi.capability_mask & IB_PMA_CLASS_CAP_EXT_WIDTH_NOIETF)
 747                         /* But not the IETF ones */
 748                         return &pma_group_noietf;
 749         }
 750
 751         /* Fall back to normal counters */
 752         return &pma_group;
 753 }
 754
 755 static int update_hw_stats(struct ib_device *dev, struct rdma_hw_stats *stats,
 756                            u8 port_num, int index)
 757 {
 758         int ret;
 759
 760         if (time_is_after_eq_jiffies(stats->timestamp + stats->lifespan))
 761                 return 0;
 762         ret = dev->get_hw_stats(dev, stats, port_num, index);
 763         if (ret < 0)
 764                 return ret;
 765         if (ret == stats->num_counters)
 766                 stats->timestamp = jiffies;
 767
 768         return 0;
 769 }
 770
 771 static ssize_t print_hw_stat(struct rdma_hw_stats *stats, int index, char *buf)
 772 {
 773         return sprintf(buf, "%llu\n", stats->value[index]);
 774 }
 775
 776 static ssize_t show_hw_stats(struct kobject *kobj, struct attribute *attr,
 777                              char *buf)
 778 {
 779         struct ib_device *dev;
 780         struct ib_port *port;
 781         struct hw_stats_attribute *hsa;
 782         struct rdma_hw_stats *stats;
 783         int ret;
 784
 785         hsa = container_of(attr, struct hw_stats_attribute, attr);
 786         if (!hsa->port_num) {
 787                 dev = container_of((struct device *)kobj,
 788                                    struct ib_device, dev);
 789                 stats = dev->hw_stats;
 790         } else {
 791                 port = container_of(kobj, struct ib_port, kobj);
 792                 dev = port->ibdev;
 793                 stats = port->hw_stats;
 794         }
 795         ret = update_hw_stats(dev, stats, hsa->port_num, hsa->index);
 796         if (ret)
 797                 return ret;
 798         return print_hw_stat(stats, hsa->index, buf);
 799 }
 800
 801 static ssize_t show_stats_lifespan(struct kobject *kobj,
 802                                    struct attribute *attr,
 803                                    char *buf)
 804 {
 805         struct hw_stats_attribute *hsa;
 806         int msecs;
 807
 808         hsa = container_of(attr, struct hw_stats_attribute, attr);
 809         if (!hsa->port_num) {
 810                 struct ib_device *dev = container_of((struct device *)kobj,
 811                                                      struct ib_device, dev);
 812                 msecs = jiffies_to_msecs(dev->hw_stats->lifespan);
 813         } else {
 814                 struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 815                 msecs = jiffies_to_msecs(p->hw_stats->lifespan);
 816         }
 817         return sprintf(buf, "%d\n", msecs);
 818 }
 819
 820 static ssize_t set_stats_lifespan(struct kobject *kobj,
 821                                   struct attribute *attr,
 822                                   const char *buf, size_t count)
 823 {
 824         struct hw_stats_attribute *hsa;
 825         int msecs;
 826         int jiffies;
 827         int ret;
 828
 829         ret = kstrtoint(buf, 10, &msecs);
 830         if (ret)
 831                 return ret;
 832         if (msecs < 0 || msecs > 10000)
 833                 return -EINVAL;
 834         jiffies = msecs_to_jiffies(msecs);
 835         hsa = container_of(attr, struct hw_stats_attribute, attr);
 836         if (!hsa->port_num) {
 837                 struct ib_device *dev = container_of((struct device *)kobj,
 838                                                      struct ib_device, dev);
 839                 dev->hw_stats->lifespan = jiffies;
 840         } else {
 841                 struct ib_port *p = container_of(kobj, struct ib_port, kobj);
 842                 p->hw_stats->lifespan = jiffies;
 843         }
 844         return count;
 845 }
 846
 847 static void free_hsag(struct kobject *kobj, struct attribute_group *attr_group)
 848 {
 849         struct attribute **attr;
 850
 851         sysfs_remove_group(kobj, attr_group);
 852
 853         for (attr = attr_group->attrs; *attr; attr++)
 854                 kfree(*attr);
 855         kfree(attr_group);
 856 }
 857
 858 static struct attribute *alloc_hsa(int index, u8 port_num, const char *name)
 859 {
 860         struct hw_stats_attribute *hsa;
 861
 862         hsa = kmalloc(sizeof(*hsa), GFP_KERNEL);
 863         if (!hsa)
 864                 return NULL;
 865
 866         hsa->attr.name = (char *)name;
 867         hsa->attr.mode = S_IRUGO;
 868         hsa->show = show_hw_stats;
 869         hsa->store = NULL;
 870         hsa->index = index;
 871         hsa->port_num = port_num;
 872
 873         return &hsa->attr;
 874 }
 875
 876 static struct attribute *alloc_hsa_lifespan(char *name, u8 port_num)
 877 {
 878         struct hw_stats_attribute *hsa;
 879
 880         hsa = kmalloc(sizeof(*hsa), GFP_KERNEL);
 881         if (!hsa)
 882                 return NULL;
 883
 884         hsa->attr.name = name;
 885         hsa->attr.mode = S_IWUSR | S_IRUGO;
 886         hsa->show = show_stats_lifespan;
 887         hsa->store = set_stats_lifespan;
 888         hsa->index = 0;
 889         hsa->port_num = port_num;
 890
 891         return &hsa->attr;
 892 }
 893
 894 static void setup_hw_stats(struct ib_device *device, struct ib_port *port,
 895                            u8 port_num)
 896 {
 897         struct attribute_group *hsag;
 898         struct rdma_hw_stats *stats;
 899         int i, ret;
 900
 901         stats = device->alloc_hw_stats(device, port_num);
 902
 903         if (!stats)
 904                 return;
 905
 906         if (!stats->names || stats->num_counters <= 0)
 907                 goto err_free_stats;
 908
 909         /*
 910          * Two extra attribue elements here, one for the lifespan entry and
 911          * one to NULL terminate the list for the sysfs core code
 912          */
 913         hsag = kzalloc(sizeof(*hsag) +
 914                        sizeof(void *) * (stats->num_counters + 2),
 915                        GFP_KERNEL);
 916         if (!hsag)
 917                 goto err_free_stats;
 918
 919         ret = device->get_hw_stats(device, stats, port_num,
 920                                    stats->num_counters);
 921         if (ret != stats->num_counters)
 922                 goto err_free_hsag;
 923
 924         stats->timestamp = jiffies;
 925
 926         hsag->name = "hw_counters";
 927         hsag->attrs = (void *)hsag + sizeof(*hsag);
 928
 929         for (i = 0; i < stats->num_counters; i++) {
 930                 hsag->attrs[i] = alloc_hsa(i, port_num, stats->names[i]);
 931                 if (!hsag->attrs[i])
 932                         goto err;
 933                 sysfs_attr_init(hsag->attrs[i]);
 934         }
 935
 936         /* treat an error here as non-fatal */
 937         hsag->attrs[i] = alloc_hsa_lifespan("lifespan", port_num);
 938         if (hsag->attrs[i])
 939                 sysfs_attr_init(hsag->attrs[i]);
 940
 941         if (port) {
 942                 struct kobject *kobj = &port->kobj;
 943                 ret = sysfs_create_group(kobj, hsag);
 944                 if (ret)
 945                         goto err;
 946                 port->hw_stats_ag = hsag;
 947                 port->hw_stats = stats;
 948         } else {
 949                 struct kobject *kobj = &device->dev.kobj;
 950                 ret = sysfs_create_group(kobj, hsag);
 951                 if (ret)
 952                         goto err;
 953                 device->hw_stats_ag = hsag;
 954                 device->hw_stats = stats;
 955         }
 956
 957         return;
 958
 959 err:
 960         for (; i >= 0; i--)
 961                 kfree(hsag->attrs[i]);
 962 err_free_hsag:
 963         kfree(hsag);
 964 err_free_stats:
 965         kfree(stats);
 966         return;
 967 }
 968
 969 static int add_port(struct ib_device *device, int port_num,
 970                     int (*port_callback)(struct ib_device *,
 971                                          u8, struct kobject *))
 972 {
 973         struct ib_port *p;
 974         struct ib_port_attr attr;
 975         int i;
 976         int ret;
 977
 978         ret = ib_query_port(device, port_num, &attr);
 979         if (ret)
 980                 return ret;
 981
 982         p = kzalloc(sizeof *p, GFP_KERNEL);
 983         if (!p)
 984                 return -ENOMEM;
 985
 986         p->ibdev      = device;
 987         p->port_num   = port_num;
 988
 989         ret = kobject_init_and_add(&p->kobj, &port_type,
 990                                    device->ports_parent,
 991                                    "%d", port_num);
 992         if (ret) {
 993                 kfree(p);
 994                 return ret;
 995         }
 996
 997         p->gid_attr_group = kzalloc(sizeof(*p->gid_attr_group), GFP_KERNEL);
 998         if (!p->gid_attr_group) {
 999                 ret = -ENOMEM;
1000                 goto err_put;
1001         }
1002
1003         p->gid_attr_group->port = p;
1004         ret = kobject_init_and_add(&p->gid_attr_group->kobj, &gid_attr_type,
1005                                    &p->kobj, "gid_attrs");
1006         if (ret) {
1007                 kfree(p->gid_attr_group);
1008                 goto err_put;
1009         }
1010
1011         p->pma_table = get_counter_table(device, port_num);
1012         ret = sysfs_create_group(&p->kobj, p->pma_table);
1013         if (ret)
1014                 goto err_put_gid_attrs;
1015
1016         p->gid_group.name  = "gids";
1017         p->gid_group.attrs = alloc_group_attrs(show_port_gid, attr.gid_tbl_len);
1018         if (!p->gid_group.attrs) {
1019                 ret = -ENOMEM;
1020                 goto err_remove_pma;
1021         }
1022
1023         ret = sysfs_create_group(&p->kobj, &p->gid_group);
1024         if (ret)
1025                 goto err_free_gid;
1026
1027         p->gid_attr_group->ndev.name = "ndevs";
1028         p->gid_attr_group->ndev.attrs = alloc_group_attrs(show_port_gid_attr_ndev,
1029                                                           attr.gid_tbl_len);
1030         if (!p->gid_attr_group->ndev.attrs) {
1031                 ret = -ENOMEM;
1032                 goto err_remove_gid;
1033         }
1034
1035         ret = sysfs_create_group(&p->gid_attr_group->kobj,
1036                                  &p->gid_attr_group->ndev);
1037         if (ret)
1038                 goto err_free_gid_ndev;
1039
1040         p->gid_attr_group->type.name = "types";
1041         p->gid_attr_group->type.attrs = alloc_group_attrs(show_port_gid_attr_gid_type,
1042                                                           attr.gid_tbl_len);
1043         if (!p->gid_attr_group->type.attrs) {
1044                 ret = -ENOMEM;
1045                 goto err_remove_gid_ndev;
1046         }
1047
1048         ret = sysfs_create_group(&p->gid_attr_group->kobj,
1049                                  &p->gid_attr_group->type);
1050         if (ret)
1051                 goto err_free_gid_type;
1052
1053         p->pkey_group.name  = "pkeys";
1054         p->pkey_group.attrs = alloc_group_attrs(show_port_pkey,
1055                                                 attr.pkey_tbl_len);
1056         if (!p->pkey_group.attrs) {
1057                 ret = -ENOMEM;
1058                 goto err_remove_gid_type;
1059         }
1060
1061         ret = sysfs_create_group(&p->kobj, &p->pkey_group);
1062         if (ret)
1063                 goto err_free_pkey;
1064
1065         if (port_callback) {
1066                 ret = port_callback(device, port_num, &p->kobj);
1067                 if (ret)
1068                         goto err_remove_pkey;
1069         }
1070
1071         /*
1072          * If port == 0, it means we have only one port and the parent
1073          * device, not this port device, should be the holder of the
1074          * hw_counters
1075          */
1076         if (device->alloc_hw_stats && port_num)
1077                 setup_hw_stats(device, p, port_num);
1078
1079         list_add_tail(&p->kobj.entry, &device->port_list);
1080
1081         kobject_uevent(&p->kobj, KOBJ_ADD);
1082         return 0;
1083
1084 err_remove_pkey:
1085         sysfs_remove_group(&p->kobj, &p->pkey_group);
1086
1087 err_free_pkey:
1088         for (i = 0; i < attr.pkey_tbl_len; ++i)
1089                 kfree(p->pkey_group.attrs[i]);
1090
1091         kfree(p->pkey_group.attrs);
1092         p->pkey_group.attrs = NULL;
1093
1094 err_remove_gid_type:
1095         sysfs_remove_group(&p->gid_attr_group->kobj,
1096                            &p->gid_attr_group->type);
1097
1098 err_free_gid_type:
1099         for (i = 0; i < attr.gid_tbl_len; ++i)
1100                 kfree(p->gid_attr_group->type.attrs[i]);
1101
1102         kfree(p->gid_attr_group->type.attrs);
1103         p->gid_attr_group->type.attrs = NULL;
1104
1105 err_remove_gid_ndev:
1106         sysfs_remove_group(&p->gid_attr_group->kobj,
1107                            &p->gid_attr_group->ndev);
1108
1109 err_free_gid_ndev:
1110         for (i = 0; i < attr.gid_tbl_len; ++i)
1111                 kfree(p->gid_attr_group->ndev.attrs[i]);
1112
1113         kfree(p->gid_attr_group->ndev.attrs);
1114         p->gid_attr_group->ndev.attrs = NULL;
1115
1116 err_remove_gid:
1117         sysfs_remove_group(&p->kobj, &p->gid_group);
1118
1119 err_free_gid:
1120         for (i = 0; i < attr.gid_tbl_len; ++i)
1121                 kfree(p->gid_group.attrs[i]);
1122
1123         kfree(p->gid_group.attrs);
1124         p->gid_group.attrs = NULL;
1125
1126 err_remove_pma:
1127         sysfs_remove_group(&p->kobj, p->pma_table);
1128
1129 err_put_gid_attrs:
1130         kobject_put(&p->gid_attr_group->kobj);
1131
1132 err_put:
1133         kobject_put(&p->kobj);
1134         return ret;
1135 }
1136
1137 static ssize_t show_node_type(struct device *device,
1138                               struct device_attribute *attr, char *buf)
1139 {
1140         struct ib_device *dev = container_of(device, struct ib_device, dev);
1141
1142         switch (dev->node_type) {
1143         case RDMA_NODE_IB_CA:     return sprintf(buf, "%d: CA\n", dev->node_type);
1144         case RDMA_NODE_RNIC:      return sprintf(buf, "%d: RNIC\n", dev->node_type);
1145         case RDMA_NODE_USNIC:     return sprintf(buf, "%d: usNIC\n", dev->node_type);
1146         case RDMA_NODE_USNIC_UDP: return sprintf(buf, "%d: usNIC UDP\n", dev->node_type);
1147         case RDMA_NODE_IB_SWITCH: return sprintf(buf, "%d: switch\n", dev->node_type);
1148         case RDMA_NODE_IB_ROUTER: return sprintf(buf, "%d: router\n", dev->node_type);
1149         default:                  return sprintf(buf, "%d: <unknown>\n", dev->node_type);
1150         }
1151 }
1152
1153 static ssize_t show_sys_image_guid(struct device *device,
1154                                    struct device_attribute *dev_attr, char *buf)
1155 {
1156         struct ib_device *dev = container_of(device, struct ib_device, dev);
1157
1158         return sprintf(buf, "%04x:%04x:%04x:%04x\n",
1159                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[0]),
1160                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[1]),
1161                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[2]),
1162                        be16_to_cpu(((__be16 *) &dev->attrs.sys_image_guid)[3]));
1163 }
1164
1165 static ssize_t show_node_guid(struct device *device,
1166                               struct device_attribute *attr, char *buf)
1167 {
1168         struct ib_device *dev = container_of(device, struct ib_device, dev);
1169
1170         return sprintf(buf, "%04x:%04x:%04x:%04x\n",
1171                        be16_to_cpu(((__be16 *) &dev->node_guid)[0]),
1172                        be16_to_cpu(((__be16 *) &dev->node_guid)[1]),
1173                        be16_to_cpu(((__be16 *) &dev->node_guid)[2]),
1174                        be16_to_cpu(((__be16 *) &dev->node_guid)[3]));
1175 }
1176
1177 static ssize_t show_node_desc(struct device *device,
1178                               struct device_attribute *attr, char *buf)
1179 {
1180         struct ib_device *dev = container_of(device, struct ib_device, dev);
1181
1182         return sprintf(buf, "%.64s\n", dev->node_desc);
1183 }
1184
1185 static ssize_t set_node_desc(struct device *device,
1186                              struct device_attribute *attr,
1187                              const char *buf, size_t count)
1188 {
1189         struct ib_device *dev = container_of(device, struct ib_device, dev);
1190         struct ib_device_modify desc = {};
1191         int ret;
1192
1193         if (!dev->modify_device)
1194                 return -EIO;
1195
1196         memcpy(desc.node_desc, buf, min_t(int, count, 64));
1197         ret = ib_modify_device(dev, IB_DEVICE_MODIFY_NODE_DESC, &desc);
1198         if (ret)
1199                 return ret;
1200
1201         return count;
1202 }
1203
1204 static ssize_t show_fw_ver(struct device *device, struct device_attribute *attr,
1205                            char *buf)
1206 {
1207         struct ib_device *dev = container_of(device, struct ib_device, dev);
1208
1209         ib_get_device_fw_str(dev, buf, PAGE_SIZE);
1210         strlcat(buf, "\n", PAGE_SIZE);
1211         return strlen(buf);
1212 }
1213
1214 static DEVICE_ATTR(node_type, S_IRUGO, show_node_type, NULL);
1215 static DEVICE_ATTR(sys_image_guid, S_IRUGO, show_sys_image_guid, NULL);
1216 static DEVICE_ATTR(node_guid, S_IRUGO, show_node_guid, NULL);
1217 static DEVICE_ATTR(node_desc, S_IRUGO | S_IWUSR, show_node_desc, set_node_desc);
1218 static DEVICE_ATTR(fw_ver, S_IRUGO, show_fw_ver, NULL);
1219
1220 static struct device_attribute *ib_class_attributes[] = {
1221         &dev_attr_node_type,
1222         &dev_attr_sys_image_guid,
1223         &dev_attr_node_guid,
1224         &dev_attr_node_desc,
1225         &dev_attr_fw_ver,
1226 };
1227
1228 static void free_port_list_attributes(struct ib_device *device)
1229 {
1230         struct kobject *p, *t;
1231
1232         list_for_each_entry_safe(p, t, &device->port_list, entry) {
1233                 struct ib_port *port = container_of(p, struct ib_port, kobj);
1234                 list_del(&p->entry);
1235                 if (port->hw_stats) {
1236                         kfree(port->hw_stats);
1237                         free_hsag(&port->kobj, port->hw_stats_ag);
1238                 }
1239                 sysfs_remove_group(p, port->pma_table);
1240                 sysfs_remove_group(p, &port->pkey_group);
1241                 sysfs_remove_group(p, &port->gid_group);
1242                 sysfs_remove_group(&port->gid_attr_group->kobj,
1243                                    &port->gid_attr_group->ndev);
1244                 sysfs_remove_group(&port->gid_attr_group->kobj,
1245                                    &port->gid_attr_group->type);
1246                 kobject_put(&port->gid_attr_group->kobj);
1247                 kobject_put(p);
1248         }
1249
1250         kobject_put(device->ports_parent);
1251 }
1252
1253 int ib_device_register_sysfs(struct ib_device *device,
1254                              int (*port_callback)(struct ib_device *,
1255                                                   u8, struct kobject *))
1256 {
1257         struct device *class_dev = &device->dev;
1258         int ret;
1259         int i;
1260
1261         device->dev.parent = device->dma_device;
1262         ret = dev_set_name(class_dev, "%s", device->name);
1263         if (ret)
1264                 return ret;
1265
1266         ret = device_add(class_dev);
1267         if (ret)
1268                 goto err;
1269
1270         for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i) {
1271                 ret = device_create_file(class_dev, ib_class_attributes[i]);
1272                 if (ret)
1273                         goto err_unregister;
1274         }
1275
1276         device->ports_parent = kobject_create_and_add("ports",
1277                                                       &class_dev->kobj);
1278         if (!device->ports_parent) {
1279                 ret = -ENOMEM;
1280                 goto err_put;
1281         }
1282
1283         if (rdma_cap_ib_switch(device)) {
1284                 ret = add_port(device, 0, port_callback);
1285                 if (ret)
1286                         goto err_put;
1287         } else {
1288                 for (i = 1; i <= device->phys_port_cnt; ++i) {
1289                         ret = add_port(device, i, port_callback);
1290                         if (ret)
1291                                 goto err_put;
1292                 }
1293         }
1294
1295         if (device->alloc_hw_stats)
1296                 setup_hw_stats(device, NULL, 0);
1297
1298         return 0;
1299
1300 err_put:
1301         free_port_list_attributes(device);
1302
1303 err_unregister:
1304         device_unregister(class_dev);
1305
1306 err:
1307         return ret;
1308 }
1309
1310 void ib_device_unregister_sysfs(struct ib_device *device)
1311 {
1312         int i;
1313
1314         /* Hold kobject until ib_dealloc_device() */
1315         kobject_get(&device->dev.kobj);
1316
1317         free_port_list_attributes(device);
1318
1319         if (device->hw_stats) {
1320                 kfree(device->hw_stats);
1321                 free_hsag(&device->dev.kobj, device->hw_stats_ag);
1322         }
1323
1324         for (i = 0; i < ARRAY_SIZE(ib_class_attributes); ++i)
1325                 device_remove_file(&device->dev, ib_class_attributes[i]);
1326
1327         device_unregister(&device->dev);
1328 }