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.
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:
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
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.
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
35 #include "core_priv.h"
37 #include <linux/slab.h>
38 #include <linux/stat.h>
39 #include <linux/string.h>
40 #include <linux/netdevice.h>
42 #include <rdma/ib_mad.h>
43 #include <rdma/ib_pma.h>
47 struct gid_attr_group
{
50 struct attribute_group ndev
;
51 struct attribute_group type
;
55 struct ib_device
*ibdev
;
56 struct gid_attr_group
*gid_attr_group
;
57 struct attribute_group gid_group
;
58 struct attribute_group pkey_group
;
59 struct attribute_group
*pma_table
;
60 struct attribute_group
*hw_stats_ag
;
61 struct rdma_hw_stats
*hw_stats
;
65 struct port_attribute
{
66 struct attribute attr
;
67 ssize_t (*show
)(struct ib_port
*, struct port_attribute
*, char *buf
);
68 ssize_t (*store
)(struct ib_port
*, struct port_attribute
*,
69 const char *buf
, size_t count
);
72 #define PORT_ATTR(_name, _mode, _show, _store) \
73 struct port_attribute port_attr_##_name = __ATTR(_name, _mode, _show, _store)
75 #define PORT_ATTR_RO(_name) \
76 struct port_attribute port_attr_##_name = __ATTR_RO(_name)
78 struct port_table_attribute
{
79 struct port_attribute attr
;
85 struct hw_stats_attribute
{
86 struct attribute attr
;
87 ssize_t (*show
)(struct kobject
*kobj
,
88 struct attribute
*attr
, char *buf
);
89 ssize_t (*store
)(struct kobject
*kobj
,
90 struct attribute
*attr
,
97 static ssize_t
port_attr_show(struct kobject
*kobj
,
98 struct attribute
*attr
, char *buf
)
100 struct port_attribute
*port_attr
=
101 container_of(attr
, struct port_attribute
, attr
);
102 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
104 if (!port_attr
->show
)
107 return port_attr
->show(p
, port_attr
, buf
);
110 static const struct sysfs_ops port_sysfs_ops
= {
111 .show
= port_attr_show
114 static ssize_t
gid_attr_show(struct kobject
*kobj
,
115 struct attribute
*attr
, char *buf
)
117 struct port_attribute
*port_attr
=
118 container_of(attr
, struct port_attribute
, attr
);
119 struct ib_port
*p
= container_of(kobj
, struct gid_attr_group
,
122 if (!port_attr
->show
)
125 return port_attr
->show(p
, port_attr
, buf
);
128 static const struct sysfs_ops gid_attr_sysfs_ops
= {
129 .show
= gid_attr_show
132 static ssize_t
state_show(struct ib_port
*p
, struct port_attribute
*unused
,
135 struct ib_port_attr attr
;
138 static const char *state_name
[] = {
139 [IB_PORT_NOP
] = "NOP",
140 [IB_PORT_DOWN
] = "DOWN",
141 [IB_PORT_INIT
] = "INIT",
142 [IB_PORT_ARMED
] = "ARMED",
143 [IB_PORT_ACTIVE
] = "ACTIVE",
144 [IB_PORT_ACTIVE_DEFER
] = "ACTIVE_DEFER"
147 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
151 return sprintf(buf
, "%d: %s\n", attr
.state
,
152 attr
.state
>= 0 && attr
.state
< ARRAY_SIZE(state_name
) ?
153 state_name
[attr
.state
] : "UNKNOWN");
156 static ssize_t
lid_show(struct ib_port
*p
, struct port_attribute
*unused
,
159 struct ib_port_attr attr
;
162 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
166 return sprintf(buf
, "0x%x\n", attr
.lid
);
169 static ssize_t
lid_mask_count_show(struct ib_port
*p
,
170 struct port_attribute
*unused
,
173 struct ib_port_attr attr
;
176 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
180 return sprintf(buf
, "%d\n", attr
.lmc
);
183 static ssize_t
sm_lid_show(struct ib_port
*p
, struct port_attribute
*unused
,
186 struct ib_port_attr attr
;
189 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
193 return sprintf(buf
, "0x%x\n", attr
.sm_lid
);
196 static ssize_t
sm_sl_show(struct ib_port
*p
, struct port_attribute
*unused
,
199 struct ib_port_attr attr
;
202 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
206 return sprintf(buf
, "%d\n", attr
.sm_sl
);
209 static ssize_t
cap_mask_show(struct ib_port
*p
, struct port_attribute
*unused
,
212 struct ib_port_attr attr
;
215 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
219 return sprintf(buf
, "0x%08x\n", attr
.port_cap_flags
);
222 static ssize_t
rate_show(struct ib_port
*p
, struct port_attribute
*unused
,
225 struct ib_port_attr attr
;
227 int rate
; /* in deci-Gb/sec */
230 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
234 switch (attr
.active_speed
) {
256 default: /* default to SDR for invalid rates */
261 rate
*= ib_width_enum_to_int(attr
.active_width
);
265 return sprintf(buf
, "%d%s Gb/sec (%dX%s)\n",
266 rate
/ 10, rate
% 10 ? ".5" : "",
267 ib_width_enum_to_int(attr
.active_width
), speed
);
270 static ssize_t
phys_state_show(struct ib_port
*p
, struct port_attribute
*unused
,
273 struct ib_port_attr attr
;
277 ret
= ib_query_port(p
->ibdev
, p
->port_num
, &attr
);
281 switch (attr
.phys_state
) {
282 case 1: return sprintf(buf
, "1: Sleep\n");
283 case 2: return sprintf(buf
, "2: Polling\n");
284 case 3: return sprintf(buf
, "3: Disabled\n");
285 case 4: return sprintf(buf
, "4: PortConfigurationTraining\n");
286 case 5: return sprintf(buf
, "5: LinkUp\n");
287 case 6: return sprintf(buf
, "6: LinkErrorRecovery\n");
288 case 7: return sprintf(buf
, "7: Phy Test\n");
289 default: return sprintf(buf
, "%d: <unknown>\n", attr
.phys_state
);
293 static ssize_t
link_layer_show(struct ib_port
*p
, struct port_attribute
*unused
,
296 switch (rdma_port_get_link_layer(p
->ibdev
, p
->port_num
)) {
297 case IB_LINK_LAYER_INFINIBAND
:
298 return sprintf(buf
, "%s\n", "InfiniBand");
299 case IB_LINK_LAYER_ETHERNET
:
300 return sprintf(buf
, "%s\n", "Ethernet");
302 return sprintf(buf
, "%s\n", "Unknown");
306 static PORT_ATTR_RO(state
);
307 static PORT_ATTR_RO(lid
);
308 static PORT_ATTR_RO(lid_mask_count
);
309 static PORT_ATTR_RO(sm_lid
);
310 static PORT_ATTR_RO(sm_sl
);
311 static PORT_ATTR_RO(cap_mask
);
312 static PORT_ATTR_RO(rate
);
313 static PORT_ATTR_RO(phys_state
);
314 static PORT_ATTR_RO(link_layer
);
316 static struct attribute
*port_default_attrs
[] = {
317 &port_attr_state
.attr
,
319 &port_attr_lid_mask_count
.attr
,
320 &port_attr_sm_lid
.attr
,
321 &port_attr_sm_sl
.attr
,
322 &port_attr_cap_mask
.attr
,
323 &port_attr_rate
.attr
,
324 &port_attr_phys_state
.attr
,
325 &port_attr_link_layer
.attr
,
329 static size_t print_ndev(struct ib_gid_attr
*gid_attr
, char *buf
)
334 return sprintf(buf
, "%s\n", gid_attr
->ndev
->name
);
337 static size_t print_gid_type(struct ib_gid_attr
*gid_attr
, char *buf
)
339 return sprintf(buf
, "%s\n", ib_cache_gid_type_str(gid_attr
->gid_type
));
342 static ssize_t
_show_port_gid_attr(struct ib_port
*p
,
343 struct port_attribute
*attr
,
345 size_t (*print
)(struct ib_gid_attr
*gid_attr
,
348 struct port_table_attribute
*tab_attr
=
349 container_of(attr
, struct port_table_attribute
, attr
);
351 struct ib_gid_attr gid_attr
= {};
354 ret
= ib_query_gid(p
->ibdev
, p
->port_num
, tab_attr
->index
, &gid
,
359 ret
= print(&gid_attr
, buf
);
363 dev_put(gid_attr
.ndev
);
367 static ssize_t
show_port_gid(struct ib_port
*p
, struct port_attribute
*attr
,
370 struct port_table_attribute
*tab_attr
=
371 container_of(attr
, struct port_table_attribute
, attr
);
375 ret
= ib_query_gid(p
->ibdev
, p
->port_num
, tab_attr
->index
, &gid
, NULL
);
379 return sprintf(buf
, "%pI6\n", gid
.raw
);
382 static ssize_t
show_port_gid_attr_ndev(struct ib_port
*p
,
383 struct port_attribute
*attr
, char *buf
)
385 return _show_port_gid_attr(p
, attr
, buf
, print_ndev
);
388 static ssize_t
show_port_gid_attr_gid_type(struct ib_port
*p
,
389 struct port_attribute
*attr
,
392 return _show_port_gid_attr(p
, attr
, buf
, print_gid_type
);
395 static ssize_t
show_port_pkey(struct ib_port
*p
, struct port_attribute
*attr
,
398 struct port_table_attribute
*tab_attr
=
399 container_of(attr
, struct port_table_attribute
, attr
);
403 ret
= ib_query_pkey(p
->ibdev
, p
->port_num
, tab_attr
->index
, &pkey
);
407 return sprintf(buf
, "0x%04x\n", pkey
);
410 #define PORT_PMA_ATTR(_name, _counter, _width, _offset) \
411 struct port_table_attribute port_pma_attr_##_name = { \
412 .attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \
413 .index = (_offset) | ((_width) << 16) | ((_counter) << 24), \
414 .attr_id = IB_PMA_PORT_COUNTERS , \
417 #define PORT_PMA_ATTR_EXT(_name, _width, _offset) \
418 struct port_table_attribute port_pma_attr_ext_##_name = { \
419 .attr = __ATTR(_name, S_IRUGO, show_pma_counter, NULL), \
420 .index = (_offset) | ((_width) << 16), \
421 .attr_id = IB_PMA_PORT_COUNTERS_EXT , \
425 * Get a Perfmgmt MAD block of data.
426 * Returns error code or the number of bytes retrieved.
428 static int get_perf_mad(struct ib_device
*dev
, int port_num
, __be16 attr
,
429 void *data
, int offset
, size_t size
)
431 struct ib_mad
*in_mad
;
432 struct ib_mad
*out_mad
;
433 size_t mad_size
= sizeof(*out_mad
);
434 u16 out_mad_pkey_index
= 0;
437 if (!dev
->process_mad
)
440 in_mad
= kzalloc(sizeof *in_mad
, GFP_KERNEL
);
441 out_mad
= kmalloc(sizeof *out_mad
, GFP_KERNEL
);
442 if (!in_mad
|| !out_mad
) {
447 in_mad
->mad_hdr
.base_version
= 1;
448 in_mad
->mad_hdr
.mgmt_class
= IB_MGMT_CLASS_PERF_MGMT
;
449 in_mad
->mad_hdr
.class_version
= 1;
450 in_mad
->mad_hdr
.method
= IB_MGMT_METHOD_GET
;
451 in_mad
->mad_hdr
.attr_id
= attr
;
453 if (attr
!= IB_PMA_CLASS_PORT_INFO
)
454 in_mad
->data
[41] = port_num
; /* PortSelect field */
456 if ((dev
->process_mad(dev
, IB_MAD_IGNORE_MKEY
,
457 port_num
, NULL
, NULL
,
458 (const struct ib_mad_hdr
*)in_mad
, mad_size
,
459 (struct ib_mad_hdr
*)out_mad
, &mad_size
,
460 &out_mad_pkey_index
) &
461 (IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_REPLY
)) !=
462 (IB_MAD_RESULT_SUCCESS
| IB_MAD_RESULT_REPLY
)) {
466 memcpy(data
, out_mad
->data
+ offset
, size
);
474 static ssize_t
show_pma_counter(struct ib_port
*p
, struct port_attribute
*attr
,
477 struct port_table_attribute
*tab_attr
=
478 container_of(attr
, struct port_table_attribute
, attr
);
479 int offset
= tab_attr
->index
& 0xffff;
480 int width
= (tab_attr
->index
>> 16) & 0xff;
484 ret
= get_perf_mad(p
->ibdev
, p
->port_num
, tab_attr
->attr_id
, &data
,
485 40 + offset
/ 8, sizeof(data
));
487 return sprintf(buf
, "N/A (no PMA)\n");
491 ret
= sprintf(buf
, "%u\n", (*data
>>
492 (4 - (offset
% 8))) & 0xf);
495 ret
= sprintf(buf
, "%u\n", *data
);
498 ret
= sprintf(buf
, "%u\n",
499 be16_to_cpup((__be16
*)data
));
502 ret
= sprintf(buf
, "%u\n",
503 be32_to_cpup((__be32
*)data
));
506 ret
= sprintf(buf
, "%llu\n",
507 be64_to_cpup((__be64
*)data
));
517 static PORT_PMA_ATTR(symbol_error
, 0, 16, 32);
518 static PORT_PMA_ATTR(link_error_recovery
, 1, 8, 48);
519 static PORT_PMA_ATTR(link_downed
, 2, 8, 56);
520 static PORT_PMA_ATTR(port_rcv_errors
, 3, 16, 64);
521 static PORT_PMA_ATTR(port_rcv_remote_physical_errors
, 4, 16, 80);
522 static PORT_PMA_ATTR(port_rcv_switch_relay_errors
, 5, 16, 96);
523 static PORT_PMA_ATTR(port_xmit_discards
, 6, 16, 112);
524 static PORT_PMA_ATTR(port_xmit_constraint_errors
, 7, 8, 128);
525 static PORT_PMA_ATTR(port_rcv_constraint_errors
, 8, 8, 136);
526 static PORT_PMA_ATTR(local_link_integrity_errors
, 9, 4, 152);
527 static PORT_PMA_ATTR(excessive_buffer_overrun_errors
, 10, 4, 156);
528 static PORT_PMA_ATTR(VL15_dropped
, 11, 16, 176);
529 static PORT_PMA_ATTR(port_xmit_data
, 12, 32, 192);
530 static PORT_PMA_ATTR(port_rcv_data
, 13, 32, 224);
531 static PORT_PMA_ATTR(port_xmit_packets
, 14, 32, 256);
532 static PORT_PMA_ATTR(port_rcv_packets
, 15, 32, 288);
535 * Counters added by extended set
537 static PORT_PMA_ATTR_EXT(port_xmit_data
, 64, 64);
538 static PORT_PMA_ATTR_EXT(port_rcv_data
, 64, 128);
539 static PORT_PMA_ATTR_EXT(port_xmit_packets
, 64, 192);
540 static PORT_PMA_ATTR_EXT(port_rcv_packets
, 64, 256);
541 static PORT_PMA_ATTR_EXT(unicast_xmit_packets
, 64, 320);
542 static PORT_PMA_ATTR_EXT(unicast_rcv_packets
, 64, 384);
543 static PORT_PMA_ATTR_EXT(multicast_xmit_packets
, 64, 448);
544 static PORT_PMA_ATTR_EXT(multicast_rcv_packets
, 64, 512);
546 static struct attribute
*pma_attrs
[] = {
547 &port_pma_attr_symbol_error
.attr
.attr
,
548 &port_pma_attr_link_error_recovery
.attr
.attr
,
549 &port_pma_attr_link_downed
.attr
.attr
,
550 &port_pma_attr_port_rcv_errors
.attr
.attr
,
551 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
552 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
553 &port_pma_attr_port_xmit_discards
.attr
.attr
,
554 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
555 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
556 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
557 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
558 &port_pma_attr_VL15_dropped
.attr
.attr
,
559 &port_pma_attr_port_xmit_data
.attr
.attr
,
560 &port_pma_attr_port_rcv_data
.attr
.attr
,
561 &port_pma_attr_port_xmit_packets
.attr
.attr
,
562 &port_pma_attr_port_rcv_packets
.attr
.attr
,
566 static struct attribute
*pma_attrs_ext
[] = {
567 &port_pma_attr_symbol_error
.attr
.attr
,
568 &port_pma_attr_link_error_recovery
.attr
.attr
,
569 &port_pma_attr_link_downed
.attr
.attr
,
570 &port_pma_attr_port_rcv_errors
.attr
.attr
,
571 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
572 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
573 &port_pma_attr_port_xmit_discards
.attr
.attr
,
574 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
575 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
576 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
577 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
578 &port_pma_attr_VL15_dropped
.attr
.attr
,
579 &port_pma_attr_ext_port_xmit_data
.attr
.attr
,
580 &port_pma_attr_ext_port_rcv_data
.attr
.attr
,
581 &port_pma_attr_ext_port_xmit_packets
.attr
.attr
,
582 &port_pma_attr_ext_port_rcv_packets
.attr
.attr
,
583 &port_pma_attr_ext_unicast_rcv_packets
.attr
.attr
,
584 &port_pma_attr_ext_unicast_xmit_packets
.attr
.attr
,
585 &port_pma_attr_ext_multicast_rcv_packets
.attr
.attr
,
586 &port_pma_attr_ext_multicast_xmit_packets
.attr
.attr
,
590 static struct attribute
*pma_attrs_noietf
[] = {
591 &port_pma_attr_symbol_error
.attr
.attr
,
592 &port_pma_attr_link_error_recovery
.attr
.attr
,
593 &port_pma_attr_link_downed
.attr
.attr
,
594 &port_pma_attr_port_rcv_errors
.attr
.attr
,
595 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
596 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
597 &port_pma_attr_port_xmit_discards
.attr
.attr
,
598 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
599 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
600 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
601 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
602 &port_pma_attr_VL15_dropped
.attr
.attr
,
603 &port_pma_attr_ext_port_xmit_data
.attr
.attr
,
604 &port_pma_attr_ext_port_rcv_data
.attr
.attr
,
605 &port_pma_attr_ext_port_xmit_packets
.attr
.attr
,
606 &port_pma_attr_ext_port_rcv_packets
.attr
.attr
,
610 static struct attribute_group pma_group
= {
615 static struct attribute_group pma_group_ext
= {
617 .attrs
= pma_attrs_ext
620 static struct attribute_group pma_group_noietf
= {
622 .attrs
= pma_attrs_noietf
625 static void ib_port_release(struct kobject
*kobj
)
627 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
631 if (p
->gid_group
.attrs
) {
632 for (i
= 0; (a
= p
->gid_group
.attrs
[i
]); ++i
)
635 kfree(p
->gid_group
.attrs
);
638 if (p
->pkey_group
.attrs
) {
639 for (i
= 0; (a
= p
->pkey_group
.attrs
[i
]); ++i
)
642 kfree(p
->pkey_group
.attrs
);
648 static void ib_port_gid_attr_release(struct kobject
*kobj
)
650 struct gid_attr_group
*g
= container_of(kobj
, struct gid_attr_group
,
656 for (i
= 0; (a
= g
->ndev
.attrs
[i
]); ++i
)
659 kfree(g
->ndev
.attrs
);
663 for (i
= 0; (a
= g
->type
.attrs
[i
]); ++i
)
666 kfree(g
->type
.attrs
);
672 static struct kobj_type port_type
= {
673 .release
= ib_port_release
,
674 .sysfs_ops
= &port_sysfs_ops
,
675 .default_attrs
= port_default_attrs
678 static struct kobj_type gid_attr_type
= {
679 .sysfs_ops
= &gid_attr_sysfs_ops
,
680 .release
= ib_port_gid_attr_release
683 static struct attribute
**
684 alloc_group_attrs(ssize_t (*show
)(struct ib_port
*,
685 struct port_attribute
*, char *buf
),
688 struct attribute
**tab_attr
;
689 struct port_table_attribute
*element
;
692 tab_attr
= kcalloc(1 + len
, sizeof(struct attribute
*), GFP_KERNEL
);
696 for (i
= 0; i
< len
; i
++) {
697 element
= kzalloc(sizeof(struct port_table_attribute
),
702 if (snprintf(element
->name
, sizeof(element
->name
),
703 "%d", i
) >= sizeof(element
->name
)) {
708 element
->attr
.attr
.name
= element
->name
;
709 element
->attr
.attr
.mode
= S_IRUGO
;
710 element
->attr
.show
= show
;
712 sysfs_attr_init(&element
->attr
.attr
);
714 tab_attr
[i
] = &element
->attr
.attr
;
727 * Figure out which counter table to use depending on
728 * the device capabilities.
730 static struct attribute_group
*get_counter_table(struct ib_device
*dev
,
733 struct ib_class_port_info cpi
;
735 if (get_perf_mad(dev
, port_num
, IB_PMA_CLASS_PORT_INFO
,
736 &cpi
, 40, sizeof(cpi
)) >= 0) {
737 if (cpi
.capability_mask
& IB_PMA_CLASS_CAP_EXT_WIDTH
)
738 /* We have extended counters */
739 return &pma_group_ext
;
741 if (cpi
.capability_mask
& IB_PMA_CLASS_CAP_EXT_WIDTH_NOIETF
)
742 /* But not the IETF ones */
743 return &pma_group_noietf
;
746 /* Fall back to normal counters */
750 static int update_hw_stats(struct ib_device
*dev
, struct rdma_hw_stats
*stats
,
751 u8 port_num
, int index
)
755 if (time_is_after_eq_jiffies(stats
->timestamp
+ stats
->lifespan
))
757 ret
= dev
->get_hw_stats(dev
, stats
, port_num
, index
);
760 if (ret
== stats
->num_counters
)
761 stats
->timestamp
= jiffies
;
766 static ssize_t
print_hw_stat(struct rdma_hw_stats
*stats
, int index
, char *buf
)
768 return sprintf(buf
, "%llu\n", stats
->value
[index
]);
771 static ssize_t
show_hw_stats(struct kobject
*kobj
, struct attribute
*attr
,
774 struct ib_device
*dev
;
775 struct ib_port
*port
;
776 struct hw_stats_attribute
*hsa
;
777 struct rdma_hw_stats
*stats
;
780 hsa
= container_of(attr
, struct hw_stats_attribute
, attr
);
781 if (!hsa
->port_num
) {
782 dev
= container_of((struct device
*)kobj
,
783 struct ib_device
, dev
);
784 stats
= dev
->hw_stats
;
786 port
= container_of(kobj
, struct ib_port
, kobj
);
788 stats
= port
->hw_stats
;
790 ret
= update_hw_stats(dev
, stats
, hsa
->port_num
, hsa
->index
);
793 return print_hw_stat(stats
, hsa
->index
, buf
);
796 static ssize_t
show_stats_lifespan(struct kobject
*kobj
,
797 struct attribute
*attr
,
800 struct hw_stats_attribute
*hsa
;
803 hsa
= container_of(attr
, struct hw_stats_attribute
, attr
);
804 if (!hsa
->port_num
) {
805 struct ib_device
*dev
= container_of((struct device
*)kobj
,
806 struct ib_device
, dev
);
807 msecs
= jiffies_to_msecs(dev
->hw_stats
->lifespan
);
809 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
810 msecs
= jiffies_to_msecs(p
->hw_stats
->lifespan
);
812 return sprintf(buf
, "%d\n", msecs
);
815 static ssize_t
set_stats_lifespan(struct kobject
*kobj
,
816 struct attribute
*attr
,
817 const char *buf
, size_t count
)
819 struct hw_stats_attribute
*hsa
;
824 ret
= kstrtoint(buf
, 10, &msecs
);
827 if (msecs
< 0 || msecs
> 10000)
829 jiffies
= msecs_to_jiffies(msecs
);
830 hsa
= container_of(attr
, struct hw_stats_attribute
, attr
);
831 if (!hsa
->port_num
) {
832 struct ib_device
*dev
= container_of((struct device
*)kobj
,
833 struct ib_device
, dev
);
834 dev
->hw_stats
->lifespan
= jiffies
;
836 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
837 p
->hw_stats
->lifespan
= jiffies
;
842 static void free_hsag(struct kobject
*kobj
, struct attribute_group
*attr_group
)
844 struct attribute
**attr
;
846 sysfs_remove_group(kobj
, attr_group
);
848 for (attr
= attr_group
->attrs
; *attr
; attr
++)
853 static struct attribute
*alloc_hsa(int index
, u8 port_num
, const char *name
)
855 struct hw_stats_attribute
*hsa
;
857 hsa
= kmalloc(sizeof(*hsa
), GFP_KERNEL
);
861 hsa
->attr
.name
= (char *)name
;
862 hsa
->attr
.mode
= S_IRUGO
;
863 hsa
->show
= show_hw_stats
;
866 hsa
->port_num
= port_num
;
871 static struct attribute
*alloc_hsa_lifespan(char *name
, u8 port_num
)
873 struct hw_stats_attribute
*hsa
;
875 hsa
= kmalloc(sizeof(*hsa
), GFP_KERNEL
);
879 hsa
->attr
.name
= name
;
880 hsa
->attr
.mode
= S_IWUSR
| S_IRUGO
;
881 hsa
->show
= show_stats_lifespan
;
882 hsa
->store
= set_stats_lifespan
;
884 hsa
->port_num
= port_num
;
889 static void setup_hw_stats(struct ib_device
*device
, struct ib_port
*port
,
892 struct attribute_group
*hsag
;
893 struct rdma_hw_stats
*stats
;
896 stats
= device
->alloc_hw_stats(device
, port_num
);
901 if (!stats
->names
|| stats
->num_counters
<= 0)
905 * Two extra attribue elements here, one for the lifespan entry and
906 * one to NULL terminate the list for the sysfs core code
908 hsag
= kzalloc(sizeof(*hsag
) +
909 sizeof(void *) * (stats
->num_counters
+ 2),
914 ret
= device
->get_hw_stats(device
, stats
, port_num
,
915 stats
->num_counters
);
916 if (ret
!= stats
->num_counters
)
919 stats
->timestamp
= jiffies
;
921 hsag
->name
= "hw_counters";
922 hsag
->attrs
= (void *)hsag
+ sizeof(*hsag
);
924 for (i
= 0; i
< stats
->num_counters
; i
++) {
925 hsag
->attrs
[i
] = alloc_hsa(i
, port_num
, stats
->names
[i
]);
928 sysfs_attr_init(hsag
->attrs
[i
]);
931 /* treat an error here as non-fatal */
932 hsag
->attrs
[i
] = alloc_hsa_lifespan("lifespan", port_num
);
934 sysfs_attr_init(hsag
->attrs
[i
]);
937 struct kobject
*kobj
= &port
->kobj
;
938 ret
= sysfs_create_group(kobj
, hsag
);
941 port
->hw_stats_ag
= hsag
;
942 port
->hw_stats
= stats
;
944 struct kobject
*kobj
= &device
->dev
.kobj
;
945 ret
= sysfs_create_group(kobj
, hsag
);
948 device
->hw_stats_ag
= hsag
;
949 device
->hw_stats
= stats
;
956 kfree(hsag
->attrs
[i
]);
964 static int add_port(struct ib_device
*device
, int port_num
,
965 int (*port_callback
)(struct ib_device
*,
966 u8
, struct kobject
*))
969 struct ib_port_attr attr
;
973 ret
= ib_query_port(device
, port_num
, &attr
);
977 p
= kzalloc(sizeof *p
, GFP_KERNEL
);
982 p
->port_num
= port_num
;
984 ret
= kobject_init_and_add(&p
->kobj
, &port_type
,
985 device
->ports_parent
,
992 p
->gid_attr_group
= kzalloc(sizeof(*p
->gid_attr_group
), GFP_KERNEL
);
993 if (!p
->gid_attr_group
) {
998 p
->gid_attr_group
->port
= p
;
999 ret
= kobject_init_and_add(&p
->gid_attr_group
->kobj
, &gid_attr_type
,
1000 &p
->kobj
, "gid_attrs");
1002 kfree(p
->gid_attr_group
);
1006 p
->pma_table
= get_counter_table(device
, port_num
);
1007 ret
= sysfs_create_group(&p
->kobj
, p
->pma_table
);
1009 goto err_put_gid_attrs
;
1011 p
->gid_group
.name
= "gids";
1012 p
->gid_group
.attrs
= alloc_group_attrs(show_port_gid
, attr
.gid_tbl_len
);
1013 if (!p
->gid_group
.attrs
) {
1015 goto err_remove_pma
;
1018 ret
= sysfs_create_group(&p
->kobj
, &p
->gid_group
);
1022 p
->gid_attr_group
->ndev
.name
= "ndevs";
1023 p
->gid_attr_group
->ndev
.attrs
= alloc_group_attrs(show_port_gid_attr_ndev
,
1025 if (!p
->gid_attr_group
->ndev
.attrs
) {
1027 goto err_remove_gid
;
1030 ret
= sysfs_create_group(&p
->gid_attr_group
->kobj
,
1031 &p
->gid_attr_group
->ndev
);
1033 goto err_free_gid_ndev
;
1035 p
->gid_attr_group
->type
.name
= "types";
1036 p
->gid_attr_group
->type
.attrs
= alloc_group_attrs(show_port_gid_attr_gid_type
,
1038 if (!p
->gid_attr_group
->type
.attrs
) {
1040 goto err_remove_gid_ndev
;
1043 ret
= sysfs_create_group(&p
->gid_attr_group
->kobj
,
1044 &p
->gid_attr_group
->type
);
1046 goto err_free_gid_type
;
1048 p
->pkey_group
.name
= "pkeys";
1049 p
->pkey_group
.attrs
= alloc_group_attrs(show_port_pkey
,
1051 if (!p
->pkey_group
.attrs
) {
1053 goto err_remove_gid_type
;
1056 ret
= sysfs_create_group(&p
->kobj
, &p
->pkey_group
);
1060 if (port_callback
) {
1061 ret
= port_callback(device
, port_num
, &p
->kobj
);
1063 goto err_remove_pkey
;
1067 * If port == 0, it means we have only one port and the parent
1068 * device, not this port device, should be the holder of the
1071 if (device
->alloc_hw_stats
&& port_num
)
1072 setup_hw_stats(device
, p
, port_num
);
1074 list_add_tail(&p
->kobj
.entry
, &device
->port_list
);
1076 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
1080 sysfs_remove_group(&p
->kobj
, &p
->pkey_group
);
1083 for (i
= 0; i
< attr
.pkey_tbl_len
; ++i
)
1084 kfree(p
->pkey_group
.attrs
[i
]);
1086 kfree(p
->pkey_group
.attrs
);
1087 p
->pkey_group
.attrs
= NULL
;
1089 err_remove_gid_type
:
1090 sysfs_remove_group(&p
->gid_attr_group
->kobj
,
1091 &p
->gid_attr_group
->type
);
1094 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
1095 kfree(p
->gid_attr_group
->type
.attrs
[i
]);
1097 kfree(p
->gid_attr_group
->type
.attrs
);
1098 p
->gid_attr_group
->type
.attrs
= NULL
;
1100 err_remove_gid_ndev
:
1101 sysfs_remove_group(&p
->gid_attr_group
->kobj
,
1102 &p
->gid_attr_group
->ndev
);
1105 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
1106 kfree(p
->gid_attr_group
->ndev
.attrs
[i
]);
1108 kfree(p
->gid_attr_group
->ndev
.attrs
);
1109 p
->gid_attr_group
->ndev
.attrs
= NULL
;
1112 sysfs_remove_group(&p
->kobj
, &p
->gid_group
);
1115 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
1116 kfree(p
->gid_group
.attrs
[i
]);
1118 kfree(p
->gid_group
.attrs
);
1119 p
->gid_group
.attrs
= NULL
;
1122 sysfs_remove_group(&p
->kobj
, p
->pma_table
);
1125 kobject_put(&p
->gid_attr_group
->kobj
);
1128 kobject_put(&p
->kobj
);
1132 static ssize_t
show_node_type(struct device
*device
,
1133 struct device_attribute
*attr
, char *buf
)
1135 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1137 switch (dev
->node_type
) {
1138 case RDMA_NODE_IB_CA
: return sprintf(buf
, "%d: CA\n", dev
->node_type
);
1139 case RDMA_NODE_RNIC
: return sprintf(buf
, "%d: RNIC\n", dev
->node_type
);
1140 case RDMA_NODE_USNIC
: return sprintf(buf
, "%d: usNIC\n", dev
->node_type
);
1141 case RDMA_NODE_USNIC_UDP
: return sprintf(buf
, "%d: usNIC UDP\n", dev
->node_type
);
1142 case RDMA_NODE_IB_SWITCH
: return sprintf(buf
, "%d: switch\n", dev
->node_type
);
1143 case RDMA_NODE_IB_ROUTER
: return sprintf(buf
, "%d: router\n", dev
->node_type
);
1144 default: return sprintf(buf
, "%d: <unknown>\n", dev
->node_type
);
1148 static ssize_t
show_sys_image_guid(struct device
*device
,
1149 struct device_attribute
*dev_attr
, char *buf
)
1151 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1153 return sprintf(buf
, "%04x:%04x:%04x:%04x\n",
1154 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[0]),
1155 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[1]),
1156 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[2]),
1157 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[3]));
1160 static ssize_t
show_node_guid(struct device
*device
,
1161 struct device_attribute
*attr
, char *buf
)
1163 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1165 return sprintf(buf
, "%04x:%04x:%04x:%04x\n",
1166 be16_to_cpu(((__be16
*) &dev
->node_guid
)[0]),
1167 be16_to_cpu(((__be16
*) &dev
->node_guid
)[1]),
1168 be16_to_cpu(((__be16
*) &dev
->node_guid
)[2]),
1169 be16_to_cpu(((__be16
*) &dev
->node_guid
)[3]));
1172 static ssize_t
show_node_desc(struct device
*device
,
1173 struct device_attribute
*attr
, char *buf
)
1175 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1177 return sprintf(buf
, "%.64s\n", dev
->node_desc
);
1180 static ssize_t
set_node_desc(struct device
*device
,
1181 struct device_attribute
*attr
,
1182 const char *buf
, size_t count
)
1184 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1185 struct ib_device_modify desc
= {};
1188 if (!dev
->modify_device
)
1191 memcpy(desc
.node_desc
, buf
, min_t(int, count
, 64));
1192 ret
= ib_modify_device(dev
, IB_DEVICE_MODIFY_NODE_DESC
, &desc
);
1199 static DEVICE_ATTR(node_type
, S_IRUGO
, show_node_type
, NULL
);
1200 static DEVICE_ATTR(sys_image_guid
, S_IRUGO
, show_sys_image_guid
, NULL
);
1201 static DEVICE_ATTR(node_guid
, S_IRUGO
, show_node_guid
, NULL
);
1202 static DEVICE_ATTR(node_desc
, S_IRUGO
| S_IWUSR
, show_node_desc
, set_node_desc
);
1204 static struct device_attribute
*ib_class_attributes
[] = {
1205 &dev_attr_node_type
,
1206 &dev_attr_sys_image_guid
,
1207 &dev_attr_node_guid
,
1211 static void free_port_list_attributes(struct ib_device
*device
)
1213 struct kobject
*p
, *t
;
1215 list_for_each_entry_safe(p
, t
, &device
->port_list
, entry
) {
1216 struct ib_port
*port
= container_of(p
, struct ib_port
, kobj
);
1217 list_del(&p
->entry
);
1218 if (port
->hw_stats
) {
1219 kfree(port
->hw_stats
);
1220 free_hsag(&port
->kobj
, port
->hw_stats_ag
);
1222 sysfs_remove_group(p
, port
->pma_table
);
1223 sysfs_remove_group(p
, &port
->pkey_group
);
1224 sysfs_remove_group(p
, &port
->gid_group
);
1225 sysfs_remove_group(&port
->gid_attr_group
->kobj
,
1226 &port
->gid_attr_group
->ndev
);
1227 sysfs_remove_group(&port
->gid_attr_group
->kobj
,
1228 &port
->gid_attr_group
->type
);
1229 kobject_put(&port
->gid_attr_group
->kobj
);
1233 kobject_put(device
->ports_parent
);
1236 int ib_device_register_sysfs(struct ib_device
*device
,
1237 int (*port_callback
)(struct ib_device
*,
1238 u8
, struct kobject
*))
1240 struct device
*class_dev
= &device
->dev
;
1244 device
->dev
.parent
= device
->dma_device
;
1245 ret
= dev_set_name(class_dev
, "%s", device
->name
);
1249 ret
= device_add(class_dev
);
1253 for (i
= 0; i
< ARRAY_SIZE(ib_class_attributes
); ++i
) {
1254 ret
= device_create_file(class_dev
, ib_class_attributes
[i
]);
1256 goto err_unregister
;
1259 device
->ports_parent
= kobject_create_and_add("ports",
1261 if (!device
->ports_parent
) {
1266 if (rdma_cap_ib_switch(device
)) {
1267 ret
= add_port(device
, 0, port_callback
);
1271 for (i
= 1; i
<= device
->phys_port_cnt
; ++i
) {
1272 ret
= add_port(device
, i
, port_callback
);
1278 if (device
->alloc_hw_stats
)
1279 setup_hw_stats(device
, NULL
, 0);
1284 free_port_list_attributes(device
);
1287 device_unregister(class_dev
);
1293 void ib_device_unregister_sysfs(struct ib_device
*device
)
1297 /* Hold kobject until ib_dealloc_device() */
1298 kobject_get(&device
->dev
.kobj
);
1300 free_port_list_attributes(device
);
1302 if (device
->hw_stats
) {
1303 kfree(device
->hw_stats
);
1304 free_hsag(&device
->dev
.kobj
, device
->hw_stats_ag
);
1307 for (i
= 0; i
< ARRAY_SIZE(ib_class_attributes
); ++i
)
1308 device_remove_file(&device
->dev
, ib_class_attributes
[i
]);
1310 device_unregister(&device
->dev
);