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