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);
533 static PORT_PMA_ATTR(port_xmit_wait
, 0, 32, 320);
536 * Counters added by extended set
538 static PORT_PMA_ATTR_EXT(port_xmit_data
, 64, 64);
539 static PORT_PMA_ATTR_EXT(port_rcv_data
, 64, 128);
540 static PORT_PMA_ATTR_EXT(port_xmit_packets
, 64, 192);
541 static PORT_PMA_ATTR_EXT(port_rcv_packets
, 64, 256);
542 static PORT_PMA_ATTR_EXT(unicast_xmit_packets
, 64, 320);
543 static PORT_PMA_ATTR_EXT(unicast_rcv_packets
, 64, 384);
544 static PORT_PMA_ATTR_EXT(multicast_xmit_packets
, 64, 448);
545 static PORT_PMA_ATTR_EXT(multicast_rcv_packets
, 64, 512);
547 static struct attribute
*pma_attrs
[] = {
548 &port_pma_attr_symbol_error
.attr
.attr
,
549 &port_pma_attr_link_error_recovery
.attr
.attr
,
550 &port_pma_attr_link_downed
.attr
.attr
,
551 &port_pma_attr_port_rcv_errors
.attr
.attr
,
552 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
553 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
554 &port_pma_attr_port_xmit_discards
.attr
.attr
,
555 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
556 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
557 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
558 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
559 &port_pma_attr_VL15_dropped
.attr
.attr
,
560 &port_pma_attr_port_xmit_data
.attr
.attr
,
561 &port_pma_attr_port_rcv_data
.attr
.attr
,
562 &port_pma_attr_port_xmit_packets
.attr
.attr
,
563 &port_pma_attr_port_rcv_packets
.attr
.attr
,
564 &port_pma_attr_port_xmit_wait
.attr
.attr
,
568 static struct attribute
*pma_attrs_ext
[] = {
569 &port_pma_attr_symbol_error
.attr
.attr
,
570 &port_pma_attr_link_error_recovery
.attr
.attr
,
571 &port_pma_attr_link_downed
.attr
.attr
,
572 &port_pma_attr_port_rcv_errors
.attr
.attr
,
573 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
574 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
575 &port_pma_attr_port_xmit_discards
.attr
.attr
,
576 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
577 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
578 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
579 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
580 &port_pma_attr_VL15_dropped
.attr
.attr
,
581 &port_pma_attr_ext_port_xmit_data
.attr
.attr
,
582 &port_pma_attr_ext_port_rcv_data
.attr
.attr
,
583 &port_pma_attr_ext_port_xmit_packets
.attr
.attr
,
584 &port_pma_attr_port_xmit_wait
.attr
.attr
,
585 &port_pma_attr_ext_port_rcv_packets
.attr
.attr
,
586 &port_pma_attr_ext_unicast_rcv_packets
.attr
.attr
,
587 &port_pma_attr_ext_unicast_xmit_packets
.attr
.attr
,
588 &port_pma_attr_ext_multicast_rcv_packets
.attr
.attr
,
589 &port_pma_attr_ext_multicast_xmit_packets
.attr
.attr
,
593 static struct attribute
*pma_attrs_noietf
[] = {
594 &port_pma_attr_symbol_error
.attr
.attr
,
595 &port_pma_attr_link_error_recovery
.attr
.attr
,
596 &port_pma_attr_link_downed
.attr
.attr
,
597 &port_pma_attr_port_rcv_errors
.attr
.attr
,
598 &port_pma_attr_port_rcv_remote_physical_errors
.attr
.attr
,
599 &port_pma_attr_port_rcv_switch_relay_errors
.attr
.attr
,
600 &port_pma_attr_port_xmit_discards
.attr
.attr
,
601 &port_pma_attr_port_xmit_constraint_errors
.attr
.attr
,
602 &port_pma_attr_port_rcv_constraint_errors
.attr
.attr
,
603 &port_pma_attr_local_link_integrity_errors
.attr
.attr
,
604 &port_pma_attr_excessive_buffer_overrun_errors
.attr
.attr
,
605 &port_pma_attr_VL15_dropped
.attr
.attr
,
606 &port_pma_attr_ext_port_xmit_data
.attr
.attr
,
607 &port_pma_attr_ext_port_rcv_data
.attr
.attr
,
608 &port_pma_attr_ext_port_xmit_packets
.attr
.attr
,
609 &port_pma_attr_ext_port_rcv_packets
.attr
.attr
,
610 &port_pma_attr_port_xmit_wait
.attr
.attr
,
614 static struct attribute_group pma_group
= {
619 static struct attribute_group pma_group_ext
= {
621 .attrs
= pma_attrs_ext
624 static struct attribute_group pma_group_noietf
= {
626 .attrs
= pma_attrs_noietf
629 static void ib_port_release(struct kobject
*kobj
)
631 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
635 if (p
->gid_group
.attrs
) {
636 for (i
= 0; (a
= p
->gid_group
.attrs
[i
]); ++i
)
639 kfree(p
->gid_group
.attrs
);
642 if (p
->pkey_group
.attrs
) {
643 for (i
= 0; (a
= p
->pkey_group
.attrs
[i
]); ++i
)
646 kfree(p
->pkey_group
.attrs
);
652 static void ib_port_gid_attr_release(struct kobject
*kobj
)
654 struct gid_attr_group
*g
= container_of(kobj
, struct gid_attr_group
,
660 for (i
= 0; (a
= g
->ndev
.attrs
[i
]); ++i
)
663 kfree(g
->ndev
.attrs
);
667 for (i
= 0; (a
= g
->type
.attrs
[i
]); ++i
)
670 kfree(g
->type
.attrs
);
676 static struct kobj_type port_type
= {
677 .release
= ib_port_release
,
678 .sysfs_ops
= &port_sysfs_ops
,
679 .default_attrs
= port_default_attrs
682 static struct kobj_type gid_attr_type
= {
683 .sysfs_ops
= &gid_attr_sysfs_ops
,
684 .release
= ib_port_gid_attr_release
687 static struct attribute
**
688 alloc_group_attrs(ssize_t (*show
)(struct ib_port
*,
689 struct port_attribute
*, char *buf
),
692 struct attribute
**tab_attr
;
693 struct port_table_attribute
*element
;
696 tab_attr
= kcalloc(1 + len
, sizeof(struct attribute
*), GFP_KERNEL
);
700 for (i
= 0; i
< len
; i
++) {
701 element
= kzalloc(sizeof(struct port_table_attribute
),
706 if (snprintf(element
->name
, sizeof(element
->name
),
707 "%d", i
) >= sizeof(element
->name
)) {
712 element
->attr
.attr
.name
= element
->name
;
713 element
->attr
.attr
.mode
= S_IRUGO
;
714 element
->attr
.show
= show
;
716 sysfs_attr_init(&element
->attr
.attr
);
718 tab_attr
[i
] = &element
->attr
.attr
;
731 * Figure out which counter table to use depending on
732 * the device capabilities.
734 static struct attribute_group
*get_counter_table(struct ib_device
*dev
,
737 struct ib_class_port_info cpi
;
739 if (get_perf_mad(dev
, port_num
, IB_PMA_CLASS_PORT_INFO
,
740 &cpi
, 40, sizeof(cpi
)) >= 0) {
741 if (cpi
.capability_mask
& IB_PMA_CLASS_CAP_EXT_WIDTH
)
742 /* We have extended counters */
743 return &pma_group_ext
;
745 if (cpi
.capability_mask
& IB_PMA_CLASS_CAP_EXT_WIDTH_NOIETF
)
746 /* But not the IETF ones */
747 return &pma_group_noietf
;
750 /* Fall back to normal counters */
754 static int update_hw_stats(struct ib_device
*dev
, struct rdma_hw_stats
*stats
,
755 u8 port_num
, int index
)
759 if (time_is_after_eq_jiffies(stats
->timestamp
+ stats
->lifespan
))
761 ret
= dev
->get_hw_stats(dev
, stats
, port_num
, index
);
764 if (ret
== stats
->num_counters
)
765 stats
->timestamp
= jiffies
;
770 static ssize_t
print_hw_stat(struct rdma_hw_stats
*stats
, int index
, char *buf
)
772 return sprintf(buf
, "%llu\n", stats
->value
[index
]);
775 static ssize_t
show_hw_stats(struct kobject
*kobj
, struct attribute
*attr
,
778 struct ib_device
*dev
;
779 struct ib_port
*port
;
780 struct hw_stats_attribute
*hsa
;
781 struct rdma_hw_stats
*stats
;
784 hsa
= container_of(attr
, struct hw_stats_attribute
, attr
);
785 if (!hsa
->port_num
) {
786 dev
= container_of((struct device
*)kobj
,
787 struct ib_device
, dev
);
788 stats
= dev
->hw_stats
;
790 port
= container_of(kobj
, struct ib_port
, kobj
);
792 stats
= port
->hw_stats
;
794 ret
= update_hw_stats(dev
, stats
, hsa
->port_num
, hsa
->index
);
797 return print_hw_stat(stats
, hsa
->index
, buf
);
800 static ssize_t
show_stats_lifespan(struct kobject
*kobj
,
801 struct attribute
*attr
,
804 struct hw_stats_attribute
*hsa
;
807 hsa
= container_of(attr
, struct hw_stats_attribute
, attr
);
808 if (!hsa
->port_num
) {
809 struct ib_device
*dev
= container_of((struct device
*)kobj
,
810 struct ib_device
, dev
);
811 msecs
= jiffies_to_msecs(dev
->hw_stats
->lifespan
);
813 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
814 msecs
= jiffies_to_msecs(p
->hw_stats
->lifespan
);
816 return sprintf(buf
, "%d\n", msecs
);
819 static ssize_t
set_stats_lifespan(struct kobject
*kobj
,
820 struct attribute
*attr
,
821 const char *buf
, size_t count
)
823 struct hw_stats_attribute
*hsa
;
828 ret
= kstrtoint(buf
, 10, &msecs
);
831 if (msecs
< 0 || msecs
> 10000)
833 jiffies
= msecs_to_jiffies(msecs
);
834 hsa
= container_of(attr
, struct hw_stats_attribute
, attr
);
835 if (!hsa
->port_num
) {
836 struct ib_device
*dev
= container_of((struct device
*)kobj
,
837 struct ib_device
, dev
);
838 dev
->hw_stats
->lifespan
= jiffies
;
840 struct ib_port
*p
= container_of(kobj
, struct ib_port
, kobj
);
841 p
->hw_stats
->lifespan
= jiffies
;
846 static void free_hsag(struct kobject
*kobj
, struct attribute_group
*attr_group
)
848 struct attribute
**attr
;
850 sysfs_remove_group(kobj
, attr_group
);
852 for (attr
= attr_group
->attrs
; *attr
; attr
++)
857 static struct attribute
*alloc_hsa(int index
, u8 port_num
, const char *name
)
859 struct hw_stats_attribute
*hsa
;
861 hsa
= kmalloc(sizeof(*hsa
), GFP_KERNEL
);
865 hsa
->attr
.name
= (char *)name
;
866 hsa
->attr
.mode
= S_IRUGO
;
867 hsa
->show
= show_hw_stats
;
870 hsa
->port_num
= port_num
;
875 static struct attribute
*alloc_hsa_lifespan(char *name
, u8 port_num
)
877 struct hw_stats_attribute
*hsa
;
879 hsa
= kmalloc(sizeof(*hsa
), GFP_KERNEL
);
883 hsa
->attr
.name
= name
;
884 hsa
->attr
.mode
= S_IWUSR
| S_IRUGO
;
885 hsa
->show
= show_stats_lifespan
;
886 hsa
->store
= set_stats_lifespan
;
888 hsa
->port_num
= port_num
;
893 static void setup_hw_stats(struct ib_device
*device
, struct ib_port
*port
,
896 struct attribute_group
*hsag
;
897 struct rdma_hw_stats
*stats
;
900 stats
= device
->alloc_hw_stats(device
, port_num
);
905 if (!stats
->names
|| stats
->num_counters
<= 0)
909 * Two extra attribue elements here, one for the lifespan entry and
910 * one to NULL terminate the list for the sysfs core code
912 hsag
= kzalloc(sizeof(*hsag
) +
913 sizeof(void *) * (stats
->num_counters
+ 2),
918 ret
= device
->get_hw_stats(device
, stats
, port_num
,
919 stats
->num_counters
);
920 if (ret
!= stats
->num_counters
)
923 stats
->timestamp
= jiffies
;
925 hsag
->name
= "hw_counters";
926 hsag
->attrs
= (void *)hsag
+ sizeof(*hsag
);
928 for (i
= 0; i
< stats
->num_counters
; i
++) {
929 hsag
->attrs
[i
] = alloc_hsa(i
, port_num
, stats
->names
[i
]);
932 sysfs_attr_init(hsag
->attrs
[i
]);
935 /* treat an error here as non-fatal */
936 hsag
->attrs
[i
] = alloc_hsa_lifespan("lifespan", port_num
);
938 sysfs_attr_init(hsag
->attrs
[i
]);
941 struct kobject
*kobj
= &port
->kobj
;
942 ret
= sysfs_create_group(kobj
, hsag
);
945 port
->hw_stats_ag
= hsag
;
946 port
->hw_stats
= stats
;
948 struct kobject
*kobj
= &device
->dev
.kobj
;
949 ret
= sysfs_create_group(kobj
, hsag
);
952 device
->hw_stats_ag
= hsag
;
953 device
->hw_stats
= stats
;
960 kfree(hsag
->attrs
[i
]);
968 static int add_port(struct ib_device
*device
, int port_num
,
969 int (*port_callback
)(struct ib_device
*,
970 u8
, struct kobject
*))
973 struct ib_port_attr attr
;
977 ret
= ib_query_port(device
, port_num
, &attr
);
981 p
= kzalloc(sizeof *p
, GFP_KERNEL
);
986 p
->port_num
= port_num
;
988 ret
= kobject_init_and_add(&p
->kobj
, &port_type
,
989 device
->ports_parent
,
996 p
->gid_attr_group
= kzalloc(sizeof(*p
->gid_attr_group
), GFP_KERNEL
);
997 if (!p
->gid_attr_group
) {
1002 p
->gid_attr_group
->port
= p
;
1003 ret
= kobject_init_and_add(&p
->gid_attr_group
->kobj
, &gid_attr_type
,
1004 &p
->kobj
, "gid_attrs");
1006 kfree(p
->gid_attr_group
);
1010 p
->pma_table
= get_counter_table(device
, port_num
);
1011 ret
= sysfs_create_group(&p
->kobj
, p
->pma_table
);
1013 goto err_put_gid_attrs
;
1015 p
->gid_group
.name
= "gids";
1016 p
->gid_group
.attrs
= alloc_group_attrs(show_port_gid
, attr
.gid_tbl_len
);
1017 if (!p
->gid_group
.attrs
) {
1019 goto err_remove_pma
;
1022 ret
= sysfs_create_group(&p
->kobj
, &p
->gid_group
);
1026 p
->gid_attr_group
->ndev
.name
= "ndevs";
1027 p
->gid_attr_group
->ndev
.attrs
= alloc_group_attrs(show_port_gid_attr_ndev
,
1029 if (!p
->gid_attr_group
->ndev
.attrs
) {
1031 goto err_remove_gid
;
1034 ret
= sysfs_create_group(&p
->gid_attr_group
->kobj
,
1035 &p
->gid_attr_group
->ndev
);
1037 goto err_free_gid_ndev
;
1039 p
->gid_attr_group
->type
.name
= "types";
1040 p
->gid_attr_group
->type
.attrs
= alloc_group_attrs(show_port_gid_attr_gid_type
,
1042 if (!p
->gid_attr_group
->type
.attrs
) {
1044 goto err_remove_gid_ndev
;
1047 ret
= sysfs_create_group(&p
->gid_attr_group
->kobj
,
1048 &p
->gid_attr_group
->type
);
1050 goto err_free_gid_type
;
1052 p
->pkey_group
.name
= "pkeys";
1053 p
->pkey_group
.attrs
= alloc_group_attrs(show_port_pkey
,
1055 if (!p
->pkey_group
.attrs
) {
1057 goto err_remove_gid_type
;
1060 ret
= sysfs_create_group(&p
->kobj
, &p
->pkey_group
);
1064 if (port_callback
) {
1065 ret
= port_callback(device
, port_num
, &p
->kobj
);
1067 goto err_remove_pkey
;
1071 * If port == 0, it means we have only one port and the parent
1072 * device, not this port device, should be the holder of the
1075 if (device
->alloc_hw_stats
&& port_num
)
1076 setup_hw_stats(device
, p
, port_num
);
1078 list_add_tail(&p
->kobj
.entry
, &device
->port_list
);
1080 kobject_uevent(&p
->kobj
, KOBJ_ADD
);
1084 sysfs_remove_group(&p
->kobj
, &p
->pkey_group
);
1087 for (i
= 0; i
< attr
.pkey_tbl_len
; ++i
)
1088 kfree(p
->pkey_group
.attrs
[i
]);
1090 kfree(p
->pkey_group
.attrs
);
1091 p
->pkey_group
.attrs
= NULL
;
1093 err_remove_gid_type
:
1094 sysfs_remove_group(&p
->gid_attr_group
->kobj
,
1095 &p
->gid_attr_group
->type
);
1098 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
1099 kfree(p
->gid_attr_group
->type
.attrs
[i
]);
1101 kfree(p
->gid_attr_group
->type
.attrs
);
1102 p
->gid_attr_group
->type
.attrs
= NULL
;
1104 err_remove_gid_ndev
:
1105 sysfs_remove_group(&p
->gid_attr_group
->kobj
,
1106 &p
->gid_attr_group
->ndev
);
1109 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
1110 kfree(p
->gid_attr_group
->ndev
.attrs
[i
]);
1112 kfree(p
->gid_attr_group
->ndev
.attrs
);
1113 p
->gid_attr_group
->ndev
.attrs
= NULL
;
1116 sysfs_remove_group(&p
->kobj
, &p
->gid_group
);
1119 for (i
= 0; i
< attr
.gid_tbl_len
; ++i
)
1120 kfree(p
->gid_group
.attrs
[i
]);
1122 kfree(p
->gid_group
.attrs
);
1123 p
->gid_group
.attrs
= NULL
;
1126 sysfs_remove_group(&p
->kobj
, p
->pma_table
);
1129 kobject_put(&p
->gid_attr_group
->kobj
);
1132 kobject_put(&p
->kobj
);
1136 static ssize_t
show_node_type(struct device
*device
,
1137 struct device_attribute
*attr
, char *buf
)
1139 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1141 switch (dev
->node_type
) {
1142 case RDMA_NODE_IB_CA
: return sprintf(buf
, "%d: CA\n", dev
->node_type
);
1143 case RDMA_NODE_RNIC
: return sprintf(buf
, "%d: RNIC\n", dev
->node_type
);
1144 case RDMA_NODE_USNIC
: return sprintf(buf
, "%d: usNIC\n", dev
->node_type
);
1145 case RDMA_NODE_USNIC_UDP
: return sprintf(buf
, "%d: usNIC UDP\n", dev
->node_type
);
1146 case RDMA_NODE_IB_SWITCH
: return sprintf(buf
, "%d: switch\n", dev
->node_type
);
1147 case RDMA_NODE_IB_ROUTER
: return sprintf(buf
, "%d: router\n", dev
->node_type
);
1148 default: return sprintf(buf
, "%d: <unknown>\n", dev
->node_type
);
1152 static ssize_t
show_sys_image_guid(struct device
*device
,
1153 struct device_attribute
*dev_attr
, char *buf
)
1155 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1157 return sprintf(buf
, "%04x:%04x:%04x:%04x\n",
1158 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[0]),
1159 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[1]),
1160 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[2]),
1161 be16_to_cpu(((__be16
*) &dev
->attrs
.sys_image_guid
)[3]));
1164 static ssize_t
show_node_guid(struct device
*device
,
1165 struct device_attribute
*attr
, char *buf
)
1167 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1169 return sprintf(buf
, "%04x:%04x:%04x:%04x\n",
1170 be16_to_cpu(((__be16
*) &dev
->node_guid
)[0]),
1171 be16_to_cpu(((__be16
*) &dev
->node_guid
)[1]),
1172 be16_to_cpu(((__be16
*) &dev
->node_guid
)[2]),
1173 be16_to_cpu(((__be16
*) &dev
->node_guid
)[3]));
1176 static ssize_t
show_node_desc(struct device
*device
,
1177 struct device_attribute
*attr
, char *buf
)
1179 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1181 return sprintf(buf
, "%.64s\n", dev
->node_desc
);
1184 static ssize_t
set_node_desc(struct device
*device
,
1185 struct device_attribute
*attr
,
1186 const char *buf
, size_t count
)
1188 struct ib_device
*dev
= container_of(device
, struct ib_device
, dev
);
1189 struct ib_device_modify desc
= {};
1192 if (!dev
->modify_device
)
1195 memcpy(desc
.node_desc
, buf
, min_t(int, count
, 64));
1196 ret
= ib_modify_device(dev
, IB_DEVICE_MODIFY_NODE_DESC
, &desc
);
1203 static DEVICE_ATTR(node_type
, S_IRUGO
, show_node_type
, NULL
);
1204 static DEVICE_ATTR(sys_image_guid
, S_IRUGO
, show_sys_image_guid
, NULL
);
1205 static DEVICE_ATTR(node_guid
, S_IRUGO
, show_node_guid
, NULL
);
1206 static DEVICE_ATTR(node_desc
, S_IRUGO
| S_IWUSR
, show_node_desc
, set_node_desc
);
1208 static struct device_attribute
*ib_class_attributes
[] = {
1209 &dev_attr_node_type
,
1210 &dev_attr_sys_image_guid
,
1211 &dev_attr_node_guid
,
1215 static void free_port_list_attributes(struct ib_device
*device
)
1217 struct kobject
*p
, *t
;
1219 list_for_each_entry_safe(p
, t
, &device
->port_list
, entry
) {
1220 struct ib_port
*port
= container_of(p
, struct ib_port
, kobj
);
1221 list_del(&p
->entry
);
1222 if (port
->hw_stats
) {
1223 kfree(port
->hw_stats
);
1224 free_hsag(&port
->kobj
, port
->hw_stats_ag
);
1226 sysfs_remove_group(p
, port
->pma_table
);
1227 sysfs_remove_group(p
, &port
->pkey_group
);
1228 sysfs_remove_group(p
, &port
->gid_group
);
1229 sysfs_remove_group(&port
->gid_attr_group
->kobj
,
1230 &port
->gid_attr_group
->ndev
);
1231 sysfs_remove_group(&port
->gid_attr_group
->kobj
,
1232 &port
->gid_attr_group
->type
);
1233 kobject_put(&port
->gid_attr_group
->kobj
);
1237 kobject_put(device
->ports_parent
);
1240 int ib_device_register_sysfs(struct ib_device
*device
,
1241 int (*port_callback
)(struct ib_device
*,
1242 u8
, struct kobject
*))
1244 struct device
*class_dev
= &device
->dev
;
1248 device
->dev
.parent
= device
->dma_device
;
1249 ret
= dev_set_name(class_dev
, "%s", device
->name
);
1253 ret
= device_add(class_dev
);
1257 for (i
= 0; i
< ARRAY_SIZE(ib_class_attributes
); ++i
) {
1258 ret
= device_create_file(class_dev
, ib_class_attributes
[i
]);
1260 goto err_unregister
;
1263 device
->ports_parent
= kobject_create_and_add("ports",
1265 if (!device
->ports_parent
) {
1270 if (rdma_cap_ib_switch(device
)) {
1271 ret
= add_port(device
, 0, port_callback
);
1275 for (i
= 1; i
<= device
->phys_port_cnt
; ++i
) {
1276 ret
= add_port(device
, i
, port_callback
);
1282 if (device
->alloc_hw_stats
)
1283 setup_hw_stats(device
, NULL
, 0);
1288 free_port_list_attributes(device
);
1291 device_unregister(class_dev
);
1297 void ib_device_unregister_sysfs(struct ib_device
*device
)
1301 /* Hold kobject until ib_dealloc_device() */
1302 kobject_get(&device
->dev
.kobj
);
1304 free_port_list_attributes(device
);
1306 if (device
->hw_stats
) {
1307 kfree(device
->hw_stats
);
1308 free_hsag(&device
->dev
.kobj
, device
->hw_stats_ag
);
1311 for (i
= 0; i
< ARRAY_SIZE(ib_class_attributes
); ++i
)
1312 device_remove_file(&device
->dev
, ib_class_attributes
[i
]);
1314 device_unregister(&device
->dev
);