2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Voltaire, Inc. All rights reserved.
4 * Copyright (c) 2006 Intel Corporation. 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 <linux/module.h>
36 #include <linux/init.h>
37 #include <linux/err.h>
38 #include <linux/random.h>
39 #include <linux/spinlock.h>
40 #include <linux/slab.h>
41 #include <linux/dma-mapping.h>
42 #include <linux/kref.h>
43 #include <linux/idr.h>
44 #include <linux/workqueue.h>
45 #include <uapi/linux/if_ether.h>
46 #include <rdma/ib_pack.h>
47 #include <rdma/ib_cache.h>
48 #include <rdma/rdma_netlink.h>
49 #include <net/netlink.h>
50 #include <uapi/rdma/ib_user_sa.h>
51 #include <rdma/ib_marshall.h>
52 #include <rdma/ib_addr.h>
53 #include <rdma/opa_addr.h>
55 #include "core_priv.h"
57 #define IB_SA_LOCAL_SVC_TIMEOUT_MIN 100
58 #define IB_SA_LOCAL_SVC_TIMEOUT_DEFAULT 2000
59 #define IB_SA_LOCAL_SVC_TIMEOUT_MAX 200000
60 #define IB_SA_CPI_MAX_RETRY_CNT 3
61 #define IB_SA_CPI_RETRY_WAIT 1000 /*msecs */
62 static int sa_local_svc_timeout_ms
= IB_SA_LOCAL_SVC_TIMEOUT_DEFAULT
;
71 enum rdma_class_port_info_type
{
72 RDMA_CLASS_PORT_INFO_IB
,
73 RDMA_CLASS_PORT_INFO_OPA
76 struct rdma_class_port_info
{
77 enum rdma_class_port_info_type type
;
79 struct ib_class_port_info ib
;
80 struct opa_class_port_info opa
;
84 struct ib_sa_classport_cache
{
87 struct rdma_class_port_info data
;
91 struct ib_mad_agent
*agent
;
92 struct ib_sa_sm_ah
*sm_ah
;
93 struct work_struct update_task
;
94 struct ib_sa_classport_cache classport_info
;
95 struct delayed_work ib_cpi_work
;
96 spinlock_t classport_lock
; /* protects class port info set */
101 struct ib_sa_device
{
102 int start_port
, end_port
;
103 struct ib_event_handler event_handler
;
104 struct ib_sa_port port
[0];
108 void (*callback
)(struct ib_sa_query
*, int, struct ib_sa_mad
*);
109 void (*release
)(struct ib_sa_query
*);
110 struct ib_sa_client
*client
;
111 struct ib_sa_port
*port
;
112 struct ib_mad_send_buf
*mad_buf
;
113 struct ib_sa_sm_ah
*sm_ah
;
116 struct list_head list
; /* Local svc request list */
117 u32 seq
; /* Local svc request sequence number */
118 unsigned long timeout
; /* Local svc timeout */
119 u8 path_use
; /* How will the pathrecord be used */
122 #define IB_SA_ENABLE_LOCAL_SERVICE 0x00000001
123 #define IB_SA_CANCEL 0x00000002
124 #define IB_SA_QUERY_OPA 0x00000004
126 struct ib_sa_service_query
{
127 void (*callback
)(int, struct ib_sa_service_rec
*, void *);
129 struct ib_sa_query sa_query
;
132 struct ib_sa_path_query
{
133 void (*callback
)(int, struct sa_path_rec
*, void *);
135 struct ib_sa_query sa_query
;
136 struct sa_path_rec
*conv_pr
;
139 struct ib_sa_guidinfo_query
{
140 void (*callback
)(int, struct ib_sa_guidinfo_rec
*, void *);
142 struct ib_sa_query sa_query
;
145 struct ib_sa_classport_info_query
{
146 void (*callback
)(void *);
148 struct ib_sa_query sa_query
;
151 struct ib_sa_mcmember_query
{
152 void (*callback
)(int, struct ib_sa_mcmember_rec
*, void *);
154 struct ib_sa_query sa_query
;
157 static LIST_HEAD(ib_nl_request_list
);
158 static DEFINE_SPINLOCK(ib_nl_request_lock
);
159 static atomic_t ib_nl_sa_request_seq
;
160 static struct workqueue_struct
*ib_nl_wq
;
161 static struct delayed_work ib_nl_timed_work
;
162 static const struct nla_policy ib_nl_policy
[LS_NLA_TYPE_MAX
] = {
163 [LS_NLA_TYPE_PATH_RECORD
] = {.type
= NLA_BINARY
,
164 .len
= sizeof(struct ib_path_rec_data
)},
165 [LS_NLA_TYPE_TIMEOUT
] = {.type
= NLA_U32
},
166 [LS_NLA_TYPE_SERVICE_ID
] = {.type
= NLA_U64
},
167 [LS_NLA_TYPE_DGID
] = {.type
= NLA_BINARY
,
168 .len
= sizeof(struct rdma_nla_ls_gid
)},
169 [LS_NLA_TYPE_SGID
] = {.type
= NLA_BINARY
,
170 .len
= sizeof(struct rdma_nla_ls_gid
)},
171 [LS_NLA_TYPE_TCLASS
] = {.type
= NLA_U8
},
172 [LS_NLA_TYPE_PKEY
] = {.type
= NLA_U16
},
173 [LS_NLA_TYPE_QOS_CLASS
] = {.type
= NLA_U16
},
177 static void ib_sa_add_one(struct ib_device
*device
);
178 static void ib_sa_remove_one(struct ib_device
*device
, void *client_data
);
180 static struct ib_client sa_client
= {
182 .add
= ib_sa_add_one
,
183 .remove
= ib_sa_remove_one
186 static DEFINE_SPINLOCK(idr_lock
);
187 static DEFINE_IDR(query_idr
);
189 static DEFINE_SPINLOCK(tid_lock
);
192 #define PATH_REC_FIELD(field) \
193 .struct_offset_bytes = offsetof(struct sa_path_rec, field), \
194 .struct_size_bytes = sizeof((struct sa_path_rec *)0)->field, \
195 .field_name = "sa_path_rec:" #field
197 static const struct ib_field path_rec_table
[] = {
198 { PATH_REC_FIELD(service_id
),
202 { PATH_REC_FIELD(dgid
),
206 { PATH_REC_FIELD(sgid
),
210 { PATH_REC_FIELD(ib
.dlid
),
214 { PATH_REC_FIELD(ib
.slid
),
218 { PATH_REC_FIELD(ib
.raw_traffic
),
226 { PATH_REC_FIELD(flow_label
),
230 { PATH_REC_FIELD(hop_limit
),
234 { PATH_REC_FIELD(traffic_class
),
238 { PATH_REC_FIELD(reversible
),
242 { PATH_REC_FIELD(numb_path
),
246 { PATH_REC_FIELD(pkey
),
250 { PATH_REC_FIELD(qos_class
),
254 { PATH_REC_FIELD(sl
),
258 { PATH_REC_FIELD(mtu_selector
),
262 { PATH_REC_FIELD(mtu
),
266 { PATH_REC_FIELD(rate_selector
),
270 { PATH_REC_FIELD(rate
),
274 { PATH_REC_FIELD(packet_life_time_selector
),
278 { PATH_REC_FIELD(packet_life_time
),
282 { PATH_REC_FIELD(preference
),
292 #define OPA_PATH_REC_FIELD(field) \
293 .struct_offset_bytes = \
294 offsetof(struct sa_path_rec, field), \
295 .struct_size_bytes = \
296 sizeof((struct sa_path_rec *)0)->field, \
297 .field_name = "sa_path_rec:" #field
299 static const struct ib_field opa_path_rec_table
[] = {
300 { OPA_PATH_REC_FIELD(service_id
),
304 { OPA_PATH_REC_FIELD(dgid
),
308 { OPA_PATH_REC_FIELD(sgid
),
312 { OPA_PATH_REC_FIELD(opa
.dlid
),
316 { OPA_PATH_REC_FIELD(opa
.slid
),
320 { OPA_PATH_REC_FIELD(opa
.raw_traffic
),
328 { OPA_PATH_REC_FIELD(flow_label
),
332 { OPA_PATH_REC_FIELD(hop_limit
),
336 { OPA_PATH_REC_FIELD(traffic_class
),
340 { OPA_PATH_REC_FIELD(reversible
),
344 { OPA_PATH_REC_FIELD(numb_path
),
348 { OPA_PATH_REC_FIELD(pkey
),
352 { OPA_PATH_REC_FIELD(opa
.l2_8B
),
356 { OPA_PATH_REC_FIELD(opa
.l2_10B
),
360 { OPA_PATH_REC_FIELD(opa
.l2_9B
),
364 { OPA_PATH_REC_FIELD(opa
.l2_16B
),
372 { OPA_PATH_REC_FIELD(opa
.qos_type
),
376 { OPA_PATH_REC_FIELD(opa
.qos_priority
),
384 { OPA_PATH_REC_FIELD(sl
),
392 { OPA_PATH_REC_FIELD(mtu_selector
),
396 { OPA_PATH_REC_FIELD(mtu
),
400 { OPA_PATH_REC_FIELD(rate_selector
),
404 { OPA_PATH_REC_FIELD(rate
),
408 { OPA_PATH_REC_FIELD(packet_life_time_selector
),
412 { OPA_PATH_REC_FIELD(packet_life_time
),
416 { OPA_PATH_REC_FIELD(preference
),
422 #define MCMEMBER_REC_FIELD(field) \
423 .struct_offset_bytes = offsetof(struct ib_sa_mcmember_rec, field), \
424 .struct_size_bytes = sizeof ((struct ib_sa_mcmember_rec *) 0)->field, \
425 .field_name = "sa_mcmember_rec:" #field
427 static const struct ib_field mcmember_rec_table
[] = {
428 { MCMEMBER_REC_FIELD(mgid
),
432 { MCMEMBER_REC_FIELD(port_gid
),
436 { MCMEMBER_REC_FIELD(qkey
),
440 { MCMEMBER_REC_FIELD(mlid
),
444 { MCMEMBER_REC_FIELD(mtu_selector
),
448 { MCMEMBER_REC_FIELD(mtu
),
452 { MCMEMBER_REC_FIELD(traffic_class
),
456 { MCMEMBER_REC_FIELD(pkey
),
460 { MCMEMBER_REC_FIELD(rate_selector
),
464 { MCMEMBER_REC_FIELD(rate
),
468 { MCMEMBER_REC_FIELD(packet_life_time_selector
),
472 { MCMEMBER_REC_FIELD(packet_life_time
),
476 { MCMEMBER_REC_FIELD(sl
),
480 { MCMEMBER_REC_FIELD(flow_label
),
484 { MCMEMBER_REC_FIELD(hop_limit
),
488 { MCMEMBER_REC_FIELD(scope
),
492 { MCMEMBER_REC_FIELD(join_state
),
496 { MCMEMBER_REC_FIELD(proxy_join
),
506 #define SERVICE_REC_FIELD(field) \
507 .struct_offset_bytes = offsetof(struct ib_sa_service_rec, field), \
508 .struct_size_bytes = sizeof ((struct ib_sa_service_rec *) 0)->field, \
509 .field_name = "sa_service_rec:" #field
511 static const struct ib_field service_rec_table
[] = {
512 { SERVICE_REC_FIELD(id
),
516 { SERVICE_REC_FIELD(gid
),
520 { SERVICE_REC_FIELD(pkey
),
524 { SERVICE_REC_FIELD(lease
),
528 { SERVICE_REC_FIELD(key
),
532 { SERVICE_REC_FIELD(name
),
536 { SERVICE_REC_FIELD(data8
),
540 { SERVICE_REC_FIELD(data16
),
544 { SERVICE_REC_FIELD(data32
),
548 { SERVICE_REC_FIELD(data64
),
554 #define CLASSPORTINFO_REC_FIELD(field) \
555 .struct_offset_bytes = offsetof(struct ib_class_port_info, field), \
556 .struct_size_bytes = sizeof((struct ib_class_port_info *)0)->field, \
557 .field_name = "ib_class_port_info:" #field
559 static const struct ib_field ib_classport_info_rec_table
[] = {
560 { CLASSPORTINFO_REC_FIELD(base_version
),
564 { CLASSPORTINFO_REC_FIELD(class_version
),
568 { CLASSPORTINFO_REC_FIELD(capability_mask
),
572 { CLASSPORTINFO_REC_FIELD(cap_mask2_resp_time
),
576 { CLASSPORTINFO_REC_FIELD(redirect_gid
),
580 { CLASSPORTINFO_REC_FIELD(redirect_tcslfl
),
584 { CLASSPORTINFO_REC_FIELD(redirect_lid
),
588 { CLASSPORTINFO_REC_FIELD(redirect_pkey
),
593 { CLASSPORTINFO_REC_FIELD(redirect_qp
),
597 { CLASSPORTINFO_REC_FIELD(redirect_qkey
),
602 { CLASSPORTINFO_REC_FIELD(trap_gid
),
606 { CLASSPORTINFO_REC_FIELD(trap_tcslfl
),
611 { CLASSPORTINFO_REC_FIELD(trap_lid
),
615 { CLASSPORTINFO_REC_FIELD(trap_pkey
),
620 { CLASSPORTINFO_REC_FIELD(trap_hlqp
),
624 { CLASSPORTINFO_REC_FIELD(trap_qkey
),
630 #define OPA_CLASSPORTINFO_REC_FIELD(field) \
631 .struct_offset_bytes =\
632 offsetof(struct opa_class_port_info, field), \
633 .struct_size_bytes = \
634 sizeof((struct opa_class_port_info *)0)->field, \
635 .field_name = "opa_class_port_info:" #field
637 static const struct ib_field opa_classport_info_rec_table
[] = {
638 { OPA_CLASSPORTINFO_REC_FIELD(base_version
),
642 { OPA_CLASSPORTINFO_REC_FIELD(class_version
),
646 { OPA_CLASSPORTINFO_REC_FIELD(cap_mask
),
650 { OPA_CLASSPORTINFO_REC_FIELD(cap_mask2_resp_time
),
654 { OPA_CLASSPORTINFO_REC_FIELD(redirect_gid
),
658 { OPA_CLASSPORTINFO_REC_FIELD(redirect_tc_fl
),
662 { OPA_CLASSPORTINFO_REC_FIELD(redirect_lid
),
666 { OPA_CLASSPORTINFO_REC_FIELD(redirect_sl_qp
),
670 { OPA_CLASSPORTINFO_REC_FIELD(redirect_qkey
),
674 { OPA_CLASSPORTINFO_REC_FIELD(trap_gid
),
678 { OPA_CLASSPORTINFO_REC_FIELD(trap_tc_fl
),
682 { OPA_CLASSPORTINFO_REC_FIELD(trap_lid
),
686 { OPA_CLASSPORTINFO_REC_FIELD(trap_hl_qp
),
690 { OPA_CLASSPORTINFO_REC_FIELD(trap_qkey
),
694 { OPA_CLASSPORTINFO_REC_FIELD(trap_pkey
),
698 { OPA_CLASSPORTINFO_REC_FIELD(redirect_pkey
),
702 { OPA_CLASSPORTINFO_REC_FIELD(trap_sl_rsvd
),
712 #define GUIDINFO_REC_FIELD(field) \
713 .struct_offset_bytes = offsetof(struct ib_sa_guidinfo_rec, field), \
714 .struct_size_bytes = sizeof((struct ib_sa_guidinfo_rec *) 0)->field, \
715 .field_name = "sa_guidinfo_rec:" #field
717 static const struct ib_field guidinfo_rec_table
[] = {
718 { GUIDINFO_REC_FIELD(lid
),
722 { GUIDINFO_REC_FIELD(block_num
),
726 { GUIDINFO_REC_FIELD(res1
),
730 { GUIDINFO_REC_FIELD(res2
),
734 { GUIDINFO_REC_FIELD(guid_info_list
),
740 static inline void ib_sa_disable_local_svc(struct ib_sa_query
*query
)
742 query
->flags
&= ~IB_SA_ENABLE_LOCAL_SERVICE
;
745 static inline int ib_sa_query_cancelled(struct ib_sa_query
*query
)
747 return (query
->flags
& IB_SA_CANCEL
);
750 static void ib_nl_set_path_rec_attrs(struct sk_buff
*skb
,
751 struct ib_sa_query
*query
)
753 struct sa_path_rec
*sa_rec
= query
->mad_buf
->context
[1];
754 struct ib_sa_mad
*mad
= query
->mad_buf
->mad
;
755 ib_sa_comp_mask comp_mask
= mad
->sa_hdr
.comp_mask
;
758 struct rdma_ls_resolve_header
*header
;
760 query
->mad_buf
->context
[1] = NULL
;
762 /* Construct the family header first */
763 header
= skb_put(skb
, NLMSG_ALIGN(sizeof(*header
)));
764 memcpy(header
->device_name
, query
->port
->agent
->device
->name
,
766 header
->port_num
= query
->port
->port_num
;
768 if ((comp_mask
& IB_SA_PATH_REC_REVERSIBLE
) &&
769 sa_rec
->reversible
!= 0)
770 query
->path_use
= LS_RESOLVE_PATH_USE_GMP
;
772 query
->path_use
= LS_RESOLVE_PATH_USE_UNIDIRECTIONAL
;
773 header
->path_use
= query
->path_use
;
775 /* Now build the attributes */
776 if (comp_mask
& IB_SA_PATH_REC_SERVICE_ID
) {
777 val64
= be64_to_cpu(sa_rec
->service_id
);
778 nla_put(skb
, RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_SERVICE_ID
,
779 sizeof(val64
), &val64
);
781 if (comp_mask
& IB_SA_PATH_REC_DGID
)
782 nla_put(skb
, RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_DGID
,
783 sizeof(sa_rec
->dgid
), &sa_rec
->dgid
);
784 if (comp_mask
& IB_SA_PATH_REC_SGID
)
785 nla_put(skb
, RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_SGID
,
786 sizeof(sa_rec
->sgid
), &sa_rec
->sgid
);
787 if (comp_mask
& IB_SA_PATH_REC_TRAFFIC_CLASS
)
788 nla_put(skb
, RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_TCLASS
,
789 sizeof(sa_rec
->traffic_class
), &sa_rec
->traffic_class
);
791 if (comp_mask
& IB_SA_PATH_REC_PKEY
) {
792 val16
= be16_to_cpu(sa_rec
->pkey
);
793 nla_put(skb
, RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_PKEY
,
794 sizeof(val16
), &val16
);
796 if (comp_mask
& IB_SA_PATH_REC_QOS_CLASS
) {
797 val16
= be16_to_cpu(sa_rec
->qos_class
);
798 nla_put(skb
, RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_QOS_CLASS
,
799 sizeof(val16
), &val16
);
803 static int ib_nl_get_path_rec_attrs_len(ib_sa_comp_mask comp_mask
)
807 if (comp_mask
& IB_SA_PATH_REC_SERVICE_ID
)
808 len
+= nla_total_size(sizeof(u64
));
809 if (comp_mask
& IB_SA_PATH_REC_DGID
)
810 len
+= nla_total_size(sizeof(struct rdma_nla_ls_gid
));
811 if (comp_mask
& IB_SA_PATH_REC_SGID
)
812 len
+= nla_total_size(sizeof(struct rdma_nla_ls_gid
));
813 if (comp_mask
& IB_SA_PATH_REC_TRAFFIC_CLASS
)
814 len
+= nla_total_size(sizeof(u8
));
815 if (comp_mask
& IB_SA_PATH_REC_PKEY
)
816 len
+= nla_total_size(sizeof(u16
));
817 if (comp_mask
& IB_SA_PATH_REC_QOS_CLASS
)
818 len
+= nla_total_size(sizeof(u16
));
821 * Make sure that at least some of the required comp_mask bits are
824 if (WARN_ON(len
== 0))
827 /* Add the family header */
828 len
+= NLMSG_ALIGN(sizeof(struct rdma_ls_resolve_header
));
833 static int ib_nl_send_msg(struct ib_sa_query
*query
, gfp_t gfp_mask
)
835 struct sk_buff
*skb
= NULL
;
836 struct nlmsghdr
*nlh
;
839 struct ib_sa_mad
*mad
;
842 mad
= query
->mad_buf
->mad
;
843 len
= ib_nl_get_path_rec_attrs_len(mad
->sa_hdr
.comp_mask
);
847 skb
= nlmsg_new(len
, gfp_mask
);
851 /* Put nlmsg header only for now */
852 data
= ibnl_put_msg(skb
, &nlh
, query
->seq
, 0, RDMA_NL_LS
,
853 RDMA_NL_LS_OP_RESOLVE
, NLM_F_REQUEST
);
860 ib_nl_set_path_rec_attrs(skb
, query
);
862 /* Repair the nlmsg header length */
865 ret
= rdma_nl_multicast(skb
, RDMA_NL_GROUP_LS
, gfp_mask
);
874 static int ib_nl_make_request(struct ib_sa_query
*query
, gfp_t gfp_mask
)
880 INIT_LIST_HEAD(&query
->list
);
881 query
->seq
= (u32
)atomic_inc_return(&ib_nl_sa_request_seq
);
883 /* Put the request on the list first.*/
884 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
885 delay
= msecs_to_jiffies(sa_local_svc_timeout_ms
);
886 query
->timeout
= delay
+ jiffies
;
887 list_add_tail(&query
->list
, &ib_nl_request_list
);
888 /* Start the timeout if this is the only request */
889 if (ib_nl_request_list
.next
== &query
->list
)
890 queue_delayed_work(ib_nl_wq
, &ib_nl_timed_work
, delay
);
891 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
893 ret
= ib_nl_send_msg(query
, gfp_mask
);
896 /* Remove the request */
897 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
898 list_del(&query
->list
);
899 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
907 static int ib_nl_cancel_request(struct ib_sa_query
*query
)
910 struct ib_sa_query
*wait_query
;
913 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
914 list_for_each_entry(wait_query
, &ib_nl_request_list
, list
) {
915 /* Let the timeout to take care of the callback */
916 if (query
== wait_query
) {
917 query
->flags
|= IB_SA_CANCEL
;
918 query
->timeout
= jiffies
;
919 list_move(&query
->list
, &ib_nl_request_list
);
921 mod_delayed_work(ib_nl_wq
, &ib_nl_timed_work
, 1);
925 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
930 static void send_handler(struct ib_mad_agent
*agent
,
931 struct ib_mad_send_wc
*mad_send_wc
);
933 static void ib_nl_process_good_resolve_rsp(struct ib_sa_query
*query
,
934 const struct nlmsghdr
*nlh
)
936 struct ib_mad_send_wc mad_send_wc
;
937 struct ib_sa_mad
*mad
= NULL
;
938 const struct nlattr
*head
, *curr
;
939 struct ib_path_rec_data
*rec
;
944 if (query
->callback
) {
945 head
= (const struct nlattr
*) nlmsg_data(nlh
);
946 len
= nlmsg_len(nlh
);
947 switch (query
->path_use
) {
948 case LS_RESOLVE_PATH_USE_UNIDIRECTIONAL
:
949 mask
= IB_PATH_PRIMARY
| IB_PATH_OUTBOUND
;
952 case LS_RESOLVE_PATH_USE_ALL
:
953 case LS_RESOLVE_PATH_USE_GMP
:
955 mask
= IB_PATH_PRIMARY
| IB_PATH_GMP
|
956 IB_PATH_BIDIRECTIONAL
;
959 nla_for_each_attr(curr
, head
, len
, rem
) {
960 if (curr
->nla_type
== LS_NLA_TYPE_PATH_RECORD
) {
961 rec
= nla_data(curr
);
963 * Get the first one. In the future, we may
964 * need to get up to 6 pathrecords.
966 if ((rec
->flags
& mask
) == mask
) {
967 mad
= query
->mad_buf
->mad
;
968 mad
->mad_hdr
.method
|=
970 memcpy(mad
->data
, rec
->path_rec
,
971 sizeof(rec
->path_rec
));
977 query
->callback(query
, status
, mad
);
980 mad_send_wc
.send_buf
= query
->mad_buf
;
981 mad_send_wc
.status
= IB_WC_SUCCESS
;
982 send_handler(query
->mad_buf
->mad_agent
, &mad_send_wc
);
985 static void ib_nl_request_timeout(struct work_struct
*work
)
988 struct ib_sa_query
*query
;
990 struct ib_mad_send_wc mad_send_wc
;
993 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
994 while (!list_empty(&ib_nl_request_list
)) {
995 query
= list_entry(ib_nl_request_list
.next
,
996 struct ib_sa_query
, list
);
998 if (time_after(query
->timeout
, jiffies
)) {
999 delay
= query
->timeout
- jiffies
;
1000 if ((long)delay
<= 0)
1002 queue_delayed_work(ib_nl_wq
, &ib_nl_timed_work
, delay
);
1006 list_del(&query
->list
);
1007 ib_sa_disable_local_svc(query
);
1008 /* Hold the lock to protect against query cancellation */
1009 if (ib_sa_query_cancelled(query
))
1012 ret
= ib_post_send_mad(query
->mad_buf
, NULL
);
1014 mad_send_wc
.send_buf
= query
->mad_buf
;
1015 mad_send_wc
.status
= IB_WC_WR_FLUSH_ERR
;
1016 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
1017 send_handler(query
->port
->agent
, &mad_send_wc
);
1018 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
1021 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
1024 int ib_nl_handle_set_timeout(struct sk_buff
*skb
,
1025 struct nlmsghdr
*nlh
,
1026 struct netlink_ext_ack
*extack
)
1028 int timeout
, delta
, abs_delta
;
1029 const struct nlattr
*attr
;
1030 unsigned long flags
;
1031 struct ib_sa_query
*query
;
1033 struct nlattr
*tb
[LS_NLA_TYPE_MAX
];
1036 if (!(nlh
->nlmsg_flags
& NLM_F_REQUEST
) ||
1037 !(NETLINK_CB(skb
).sk
))
1040 ret
= nla_parse(tb
, LS_NLA_TYPE_MAX
- 1, nlmsg_data(nlh
),
1041 nlmsg_len(nlh
), ib_nl_policy
, NULL
);
1042 attr
= (const struct nlattr
*)tb
[LS_NLA_TYPE_TIMEOUT
];
1044 goto settimeout_out
;
1046 timeout
= *(int *) nla_data(attr
);
1047 if (timeout
< IB_SA_LOCAL_SVC_TIMEOUT_MIN
)
1048 timeout
= IB_SA_LOCAL_SVC_TIMEOUT_MIN
;
1049 if (timeout
> IB_SA_LOCAL_SVC_TIMEOUT_MAX
)
1050 timeout
= IB_SA_LOCAL_SVC_TIMEOUT_MAX
;
1052 delta
= timeout
- sa_local_svc_timeout_ms
;
1059 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
1060 sa_local_svc_timeout_ms
= timeout
;
1061 list_for_each_entry(query
, &ib_nl_request_list
, list
) {
1062 if (delta
< 0 && abs_delta
> query
->timeout
)
1065 query
->timeout
+= delta
;
1067 /* Get the new delay from the first entry */
1069 delay
= query
->timeout
- jiffies
;
1075 mod_delayed_work(ib_nl_wq
, &ib_nl_timed_work
,
1076 (unsigned long)delay
);
1077 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
1084 static inline int ib_nl_is_good_resolve_resp(const struct nlmsghdr
*nlh
)
1086 struct nlattr
*tb
[LS_NLA_TYPE_MAX
];
1089 if (nlh
->nlmsg_flags
& RDMA_NL_LS_F_ERR
)
1092 ret
= nla_parse(tb
, LS_NLA_TYPE_MAX
- 1, nlmsg_data(nlh
),
1093 nlmsg_len(nlh
), ib_nl_policy
, NULL
);
1100 int ib_nl_handle_resolve_resp(struct sk_buff
*skb
,
1101 struct nlmsghdr
*nlh
,
1102 struct netlink_ext_ack
*extack
)
1104 unsigned long flags
;
1105 struct ib_sa_query
*query
;
1106 struct ib_mad_send_buf
*send_buf
;
1107 struct ib_mad_send_wc mad_send_wc
;
1111 if ((nlh
->nlmsg_flags
& NLM_F_REQUEST
) ||
1112 !(NETLINK_CB(skb
).sk
))
1115 spin_lock_irqsave(&ib_nl_request_lock
, flags
);
1116 list_for_each_entry(query
, &ib_nl_request_list
, list
) {
1118 * If the query is cancelled, let the timeout routine
1121 if (nlh
->nlmsg_seq
== query
->seq
) {
1122 found
= !ib_sa_query_cancelled(query
);
1124 list_del(&query
->list
);
1130 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
1134 send_buf
= query
->mad_buf
;
1136 if (!ib_nl_is_good_resolve_resp(nlh
)) {
1137 /* if the result is a failure, send out the packet via IB */
1138 ib_sa_disable_local_svc(query
);
1139 ret
= ib_post_send_mad(query
->mad_buf
, NULL
);
1140 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
1142 mad_send_wc
.send_buf
= send_buf
;
1143 mad_send_wc
.status
= IB_WC_GENERAL_ERR
;
1144 send_handler(query
->port
->agent
, &mad_send_wc
);
1147 spin_unlock_irqrestore(&ib_nl_request_lock
, flags
);
1148 ib_nl_process_good_resolve_rsp(query
, nlh
);
1155 static void free_sm_ah(struct kref
*kref
)
1157 struct ib_sa_sm_ah
*sm_ah
= container_of(kref
, struct ib_sa_sm_ah
, ref
);
1159 rdma_destroy_ah(sm_ah
->ah
);
1163 void ib_sa_register_client(struct ib_sa_client
*client
)
1165 atomic_set(&client
->users
, 1);
1166 init_completion(&client
->comp
);
1168 EXPORT_SYMBOL(ib_sa_register_client
);
1170 void ib_sa_unregister_client(struct ib_sa_client
*client
)
1172 ib_sa_client_put(client
);
1173 wait_for_completion(&client
->comp
);
1175 EXPORT_SYMBOL(ib_sa_unregister_client
);
1178 * ib_sa_cancel_query - try to cancel an SA query
1179 * @id:ID of query to cancel
1180 * @query:query pointer to cancel
1182 * Try to cancel an SA query. If the id and query don't match up or
1183 * the query has already completed, nothing is done. Otherwise the
1184 * query is canceled and will complete with a status of -EINTR.
1186 void ib_sa_cancel_query(int id
, struct ib_sa_query
*query
)
1188 unsigned long flags
;
1189 struct ib_mad_agent
*agent
;
1190 struct ib_mad_send_buf
*mad_buf
;
1192 spin_lock_irqsave(&idr_lock
, flags
);
1193 if (idr_find(&query_idr
, id
) != query
) {
1194 spin_unlock_irqrestore(&idr_lock
, flags
);
1197 agent
= query
->port
->agent
;
1198 mad_buf
= query
->mad_buf
;
1199 spin_unlock_irqrestore(&idr_lock
, flags
);
1202 * If the query is still on the netlink request list, schedule
1203 * it to be cancelled by the timeout routine. Otherwise, it has been
1204 * sent to the MAD layer and has to be cancelled from there.
1206 if (!ib_nl_cancel_request(query
))
1207 ib_cancel_mad(agent
, mad_buf
);
1209 EXPORT_SYMBOL(ib_sa_cancel_query
);
1211 static u8
get_src_path_mask(struct ib_device
*device
, u8 port_num
)
1213 struct ib_sa_device
*sa_dev
;
1214 struct ib_sa_port
*port
;
1215 unsigned long flags
;
1218 sa_dev
= ib_get_client_data(device
, &sa_client
);
1222 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
1223 spin_lock_irqsave(&port
->ah_lock
, flags
);
1224 src_path_mask
= port
->sm_ah
? port
->sm_ah
->src_path_mask
: 0x7f;
1225 spin_unlock_irqrestore(&port
->ah_lock
, flags
);
1227 return src_path_mask
;
1230 int ib_init_ah_from_path(struct ib_device
*device
, u8 port_num
,
1231 struct sa_path_rec
*rec
,
1232 struct rdma_ah_attr
*ah_attr
)
1237 struct net_device
*ndev
= NULL
;
1239 memset(ah_attr
, 0, sizeof *ah_attr
);
1240 ah_attr
->type
= rdma_ah_find_type(device
, port_num
);
1242 rdma_ah_set_dlid(ah_attr
, be32_to_cpu(sa_path_get_dlid(rec
)));
1244 if ((ah_attr
->type
== RDMA_AH_ATTR_TYPE_OPA
) &&
1245 (rdma_ah_get_dlid(ah_attr
) == be16_to_cpu(IB_LID_PERMISSIVE
)))
1246 rdma_ah_set_make_grd(ah_attr
, true);
1248 rdma_ah_set_sl(ah_attr
, rec
->sl
);
1249 rdma_ah_set_path_bits(ah_attr
, be32_to_cpu(sa_path_get_slid(rec
)) &
1250 get_src_path_mask(device
, port_num
));
1251 rdma_ah_set_port_num(ah_attr
, port_num
);
1252 rdma_ah_set_static_rate(ah_attr
, rec
->rate
);
1253 use_roce
= rdma_cap_eth_ah(device
, port_num
);
1256 struct net_device
*idev
;
1257 struct net_device
*resolved_dev
;
1258 struct rdma_dev_addr dev_addr
= {
1259 .bound_dev_if
= ((sa_path_get_ifindex(rec
) >= 0) ?
1260 sa_path_get_ifindex(rec
) : 0),
1261 .net
= sa_path_get_ndev(rec
) ?
1262 sa_path_get_ndev(rec
) :
1266 struct sockaddr_in _sockaddr_in
;
1267 struct sockaddr_in6 _sockaddr_in6
;
1268 } sgid_addr
, dgid_addr
;
1270 if (!device
->get_netdev
)
1273 rdma_gid2ip((struct sockaddr
*)&sgid_addr
, &rec
->sgid
);
1274 rdma_gid2ip((struct sockaddr
*)&dgid_addr
, &rec
->dgid
);
1276 /* validate the route */
1277 ret
= rdma_resolve_ip_route((struct sockaddr
*)&sgid_addr
,
1278 (struct sockaddr
*)&dgid_addr
,
1283 if ((dev_addr
.network
== RDMA_NETWORK_IPV4
||
1284 dev_addr
.network
== RDMA_NETWORK_IPV6
) &&
1285 rec
->rec_type
!= SA_PATH_REC_TYPE_ROCE_V2
)
1288 idev
= device
->get_netdev(device
, port_num
);
1292 resolved_dev
= dev_get_by_index(dev_addr
.net
,
1293 dev_addr
.bound_dev_if
);
1294 if (!resolved_dev
) {
1298 ndev
= ib_get_ndev_from_path(rec
);
1300 if ((ndev
&& ndev
!= resolved_dev
) ||
1301 (resolved_dev
!= idev
&&
1302 !rdma_is_upper_dev_rcu(idev
, resolved_dev
)))
1303 ret
= -EHOSTUNREACH
;
1306 dev_put(resolved_dev
);
1314 if (rec
->hop_limit
> 0 || use_roce
) {
1315 enum ib_gid_type type
= sa_conv_pathrec_to_gid_type(rec
);
1317 ret
= ib_find_cached_gid_by_port(device
, &rec
->sgid
, type
,
1318 port_num
, ndev
, &gid_index
);
1325 rdma_ah_set_grh(ah_attr
, &rec
->dgid
,
1326 be32_to_cpu(rec
->flow_label
),
1327 gid_index
, rec
->hop_limit
,
1328 rec
->traffic_class
);
1334 u8
*dmac
= sa_path_get_dmac(rec
);
1338 memcpy(ah_attr
->roce
.dmac
, dmac
, ETH_ALEN
);
1343 EXPORT_SYMBOL(ib_init_ah_from_path
);
1345 static int alloc_mad(struct ib_sa_query
*query
, gfp_t gfp_mask
)
1347 unsigned long flags
;
1349 spin_lock_irqsave(&query
->port
->ah_lock
, flags
);
1350 if (!query
->port
->sm_ah
) {
1351 spin_unlock_irqrestore(&query
->port
->ah_lock
, flags
);
1354 kref_get(&query
->port
->sm_ah
->ref
);
1355 query
->sm_ah
= query
->port
->sm_ah
;
1356 spin_unlock_irqrestore(&query
->port
->ah_lock
, flags
);
1358 query
->mad_buf
= ib_create_send_mad(query
->port
->agent
, 1,
1359 query
->sm_ah
->pkey_index
,
1360 0, IB_MGMT_SA_HDR
, IB_MGMT_SA_DATA
,
1362 ((query
->flags
& IB_SA_QUERY_OPA
) ?
1363 OPA_MGMT_BASE_VERSION
:
1364 IB_MGMT_BASE_VERSION
));
1365 if (IS_ERR(query
->mad_buf
)) {
1366 kref_put(&query
->sm_ah
->ref
, free_sm_ah
);
1370 query
->mad_buf
->ah
= query
->sm_ah
->ah
;
1375 static void free_mad(struct ib_sa_query
*query
)
1377 ib_free_send_mad(query
->mad_buf
);
1378 kref_put(&query
->sm_ah
->ref
, free_sm_ah
);
1381 static void init_mad(struct ib_sa_query
*query
, struct ib_mad_agent
*agent
)
1383 struct ib_sa_mad
*mad
= query
->mad_buf
->mad
;
1384 unsigned long flags
;
1386 memset(mad
, 0, sizeof *mad
);
1388 if (query
->flags
& IB_SA_QUERY_OPA
) {
1389 mad
->mad_hdr
.base_version
= OPA_MGMT_BASE_VERSION
;
1390 mad
->mad_hdr
.class_version
= OPA_SA_CLASS_VERSION
;
1392 mad
->mad_hdr
.base_version
= IB_MGMT_BASE_VERSION
;
1393 mad
->mad_hdr
.class_version
= IB_SA_CLASS_VERSION
;
1395 mad
->mad_hdr
.mgmt_class
= IB_MGMT_CLASS_SUBN_ADM
;
1396 spin_lock_irqsave(&tid_lock
, flags
);
1398 cpu_to_be64(((u64
) agent
->hi_tid
) << 32 | tid
++);
1399 spin_unlock_irqrestore(&tid_lock
, flags
);
1402 static int send_mad(struct ib_sa_query
*query
, int timeout_ms
, gfp_t gfp_mask
)
1404 bool preload
= gfpflags_allow_blocking(gfp_mask
);
1405 unsigned long flags
;
1409 idr_preload(gfp_mask
);
1410 spin_lock_irqsave(&idr_lock
, flags
);
1412 id
= idr_alloc(&query_idr
, query
, 0, 0, GFP_NOWAIT
);
1414 spin_unlock_irqrestore(&idr_lock
, flags
);
1420 query
->mad_buf
->timeout_ms
= timeout_ms
;
1421 query
->mad_buf
->context
[0] = query
;
1424 if ((query
->flags
& IB_SA_ENABLE_LOCAL_SERVICE
) &&
1425 (!(query
->flags
& IB_SA_QUERY_OPA
))) {
1426 if (!rdma_nl_chk_listeners(RDMA_NL_GROUP_LS
)) {
1427 if (!ib_nl_make_request(query
, gfp_mask
))
1430 ib_sa_disable_local_svc(query
);
1433 ret
= ib_post_send_mad(query
->mad_buf
, NULL
);
1435 spin_lock_irqsave(&idr_lock
, flags
);
1436 idr_remove(&query_idr
, id
);
1437 spin_unlock_irqrestore(&idr_lock
, flags
);
1441 * It's not safe to dereference query any more, because the
1442 * send may already have completed and freed the query in
1445 return ret
? ret
: id
;
1448 void ib_sa_unpack_path(void *attribute
, struct sa_path_rec
*rec
)
1450 ib_unpack(path_rec_table
, ARRAY_SIZE(path_rec_table
), attribute
, rec
);
1452 EXPORT_SYMBOL(ib_sa_unpack_path
);
1454 void ib_sa_pack_path(struct sa_path_rec
*rec
, void *attribute
)
1456 ib_pack(path_rec_table
, ARRAY_SIZE(path_rec_table
), rec
, attribute
);
1458 EXPORT_SYMBOL(ib_sa_pack_path
);
1460 static bool ib_sa_opa_pathrecord_support(struct ib_sa_client
*client
,
1461 struct ib_device
*device
,
1464 struct ib_sa_device
*sa_dev
= ib_get_client_data(device
, &sa_client
);
1465 struct ib_sa_port
*port
;
1466 unsigned long flags
;
1472 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
1473 spin_lock_irqsave(&port
->classport_lock
, flags
);
1474 if (!port
->classport_info
.valid
)
1477 if (port
->classport_info
.data
.type
== RDMA_CLASS_PORT_INFO_OPA
)
1478 ret
= opa_get_cpi_capmask2(&port
->classport_info
.data
.opa
) &
1479 OPA_CLASS_PORT_INFO_PR_SUPPORT
;
1481 spin_unlock_irqrestore(&port
->classport_lock
, flags
);
1485 enum opa_pr_supported
{
1492 * Check if current PR query can be an OPA query.
1493 * Retuns PR_NOT_SUPPORTED if a path record query is not
1494 * possible, PR_OPA_SUPPORTED if an OPA path record query
1495 * is possible and PR_IB_SUPPORTED if an IB path record
1496 * query is possible.
1498 static int opa_pr_query_possible(struct ib_sa_client
*client
,
1499 struct ib_device
*device
,
1501 struct sa_path_rec
*rec
)
1503 struct ib_port_attr port_attr
;
1505 if (ib_query_port(device
, port_num
, &port_attr
))
1506 return PR_NOT_SUPPORTED
;
1508 if (ib_sa_opa_pathrecord_support(client
, device
, port_num
))
1509 return PR_OPA_SUPPORTED
;
1511 if (port_attr
.lid
>= be16_to_cpu(IB_MULTICAST_LID_BASE
))
1512 return PR_NOT_SUPPORTED
;
1514 return PR_IB_SUPPORTED
;
1517 static void ib_sa_path_rec_callback(struct ib_sa_query
*sa_query
,
1519 struct ib_sa_mad
*mad
)
1521 struct ib_sa_path_query
*query
=
1522 container_of(sa_query
, struct ib_sa_path_query
, sa_query
);
1525 struct sa_path_rec rec
;
1527 if (sa_query
->flags
& IB_SA_QUERY_OPA
) {
1528 ib_unpack(opa_path_rec_table
,
1529 ARRAY_SIZE(opa_path_rec_table
),
1531 rec
.rec_type
= SA_PATH_REC_TYPE_OPA
;
1532 query
->callback(status
, &rec
, query
->context
);
1534 ib_unpack(path_rec_table
,
1535 ARRAY_SIZE(path_rec_table
),
1537 rec
.rec_type
= SA_PATH_REC_TYPE_IB
;
1538 sa_path_set_ndev(&rec
, NULL
);
1539 sa_path_set_ifindex(&rec
, 0);
1540 sa_path_set_dmac_zero(&rec
);
1542 if (query
->conv_pr
) {
1543 struct sa_path_rec opa
;
1545 memset(&opa
, 0, sizeof(struct sa_path_rec
));
1546 sa_convert_path_ib_to_opa(&opa
, &rec
);
1547 query
->callback(status
, &opa
, query
->context
);
1549 query
->callback(status
, &rec
, query
->context
);
1553 query
->callback(status
, NULL
, query
->context
);
1556 static void ib_sa_path_rec_release(struct ib_sa_query
*sa_query
)
1558 struct ib_sa_path_query
*query
=
1559 container_of(sa_query
, struct ib_sa_path_query
, sa_query
);
1561 kfree(query
->conv_pr
);
1566 * ib_sa_path_rec_get - Start a Path get query
1568 * @device:device to send query on
1569 * @port_num: port number to send query on
1570 * @rec:Path Record to send in query
1571 * @comp_mask:component mask to send in query
1572 * @timeout_ms:time to wait for response
1573 * @gfp_mask:GFP mask to use for internal allocations
1574 * @callback:function called when query completes, times out or is
1576 * @context:opaque user context passed to callback
1577 * @sa_query:query context, used to cancel query
1579 * Send a Path Record Get query to the SA to look up a path. The
1580 * callback function will be called when the query completes (or
1581 * fails); status is 0 for a successful response, -EINTR if the query
1582 * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
1583 * occurred sending the query. The resp parameter of the callback is
1584 * only valid if status is 0.
1586 * If the return value of ib_sa_path_rec_get() is negative, it is an
1587 * error code. Otherwise it is a query ID that can be used to cancel
1590 int ib_sa_path_rec_get(struct ib_sa_client
*client
,
1591 struct ib_device
*device
, u8 port_num
,
1592 struct sa_path_rec
*rec
,
1593 ib_sa_comp_mask comp_mask
,
1594 int timeout_ms
, gfp_t gfp_mask
,
1595 void (*callback
)(int status
,
1596 struct sa_path_rec
*resp
,
1599 struct ib_sa_query
**sa_query
)
1601 struct ib_sa_path_query
*query
;
1602 struct ib_sa_device
*sa_dev
= ib_get_client_data(device
, &sa_client
);
1603 struct ib_sa_port
*port
;
1604 struct ib_mad_agent
*agent
;
1605 struct ib_sa_mad
*mad
;
1606 enum opa_pr_supported status
;
1612 if ((rec
->rec_type
!= SA_PATH_REC_TYPE_IB
) &&
1613 (rec
->rec_type
!= SA_PATH_REC_TYPE_OPA
))
1616 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
1617 agent
= port
->agent
;
1619 query
= kzalloc(sizeof(*query
), gfp_mask
);
1623 query
->sa_query
.port
= port
;
1624 if (rec
->rec_type
== SA_PATH_REC_TYPE_OPA
) {
1625 status
= opa_pr_query_possible(client
, device
, port_num
, rec
);
1626 if (status
== PR_NOT_SUPPORTED
) {
1629 } else if (status
== PR_OPA_SUPPORTED
) {
1630 query
->sa_query
.flags
|= IB_SA_QUERY_OPA
;
1633 kmalloc(sizeof(*query
->conv_pr
), gfp_mask
);
1634 if (!query
->conv_pr
) {
1641 ret
= alloc_mad(&query
->sa_query
, gfp_mask
);
1645 ib_sa_client_get(client
);
1646 query
->sa_query
.client
= client
;
1647 query
->callback
= callback
;
1648 query
->context
= context
;
1650 mad
= query
->sa_query
.mad_buf
->mad
;
1651 init_mad(&query
->sa_query
, agent
);
1653 query
->sa_query
.callback
= callback
? ib_sa_path_rec_callback
: NULL
;
1654 query
->sa_query
.release
= ib_sa_path_rec_release
;
1655 mad
->mad_hdr
.method
= IB_MGMT_METHOD_GET
;
1656 mad
->mad_hdr
.attr_id
= cpu_to_be16(IB_SA_ATTR_PATH_REC
);
1657 mad
->sa_hdr
.comp_mask
= comp_mask
;
1659 if (query
->sa_query
.flags
& IB_SA_QUERY_OPA
) {
1660 ib_pack(opa_path_rec_table
, ARRAY_SIZE(opa_path_rec_table
),
1662 } else if (query
->conv_pr
) {
1663 sa_convert_path_opa_to_ib(query
->conv_pr
, rec
);
1664 ib_pack(path_rec_table
, ARRAY_SIZE(path_rec_table
),
1665 query
->conv_pr
, mad
->data
);
1667 ib_pack(path_rec_table
, ARRAY_SIZE(path_rec_table
),
1671 *sa_query
= &query
->sa_query
;
1673 query
->sa_query
.flags
|= IB_SA_ENABLE_LOCAL_SERVICE
;
1674 query
->sa_query
.mad_buf
->context
[1] = (query
->conv_pr
) ?
1675 query
->conv_pr
: rec
;
1677 ret
= send_mad(&query
->sa_query
, timeout_ms
, gfp_mask
);
1685 ib_sa_client_put(query
->sa_query
.client
);
1686 free_mad(&query
->sa_query
);
1688 kfree(query
->conv_pr
);
1693 EXPORT_SYMBOL(ib_sa_path_rec_get
);
1695 static void ib_sa_service_rec_callback(struct ib_sa_query
*sa_query
,
1697 struct ib_sa_mad
*mad
)
1699 struct ib_sa_service_query
*query
=
1700 container_of(sa_query
, struct ib_sa_service_query
, sa_query
);
1703 struct ib_sa_service_rec rec
;
1705 ib_unpack(service_rec_table
, ARRAY_SIZE(service_rec_table
),
1707 query
->callback(status
, &rec
, query
->context
);
1709 query
->callback(status
, NULL
, query
->context
);
1712 static void ib_sa_service_rec_release(struct ib_sa_query
*sa_query
)
1714 kfree(container_of(sa_query
, struct ib_sa_service_query
, sa_query
));
1718 * ib_sa_service_rec_query - Start Service Record operation
1720 * @device:device to send request on
1721 * @port_num: port number to send request on
1722 * @method:SA method - should be get, set, or delete
1723 * @rec:Service Record to send in request
1724 * @comp_mask:component mask to send in request
1725 * @timeout_ms:time to wait for response
1726 * @gfp_mask:GFP mask to use for internal allocations
1727 * @callback:function called when request completes, times out or is
1729 * @context:opaque user context passed to callback
1730 * @sa_query:request context, used to cancel request
1732 * Send a Service Record set/get/delete to the SA to register,
1733 * unregister or query a service record.
1734 * The callback function will be called when the request completes (or
1735 * fails); status is 0 for a successful response, -EINTR if the query
1736 * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
1737 * occurred sending the query. The resp parameter of the callback is
1738 * only valid if status is 0.
1740 * If the return value of ib_sa_service_rec_query() is negative, it is an
1741 * error code. Otherwise it is a request ID that can be used to cancel
1744 int ib_sa_service_rec_query(struct ib_sa_client
*client
,
1745 struct ib_device
*device
, u8 port_num
, u8 method
,
1746 struct ib_sa_service_rec
*rec
,
1747 ib_sa_comp_mask comp_mask
,
1748 int timeout_ms
, gfp_t gfp_mask
,
1749 void (*callback
)(int status
,
1750 struct ib_sa_service_rec
*resp
,
1753 struct ib_sa_query
**sa_query
)
1755 struct ib_sa_service_query
*query
;
1756 struct ib_sa_device
*sa_dev
= ib_get_client_data(device
, &sa_client
);
1757 struct ib_sa_port
*port
;
1758 struct ib_mad_agent
*agent
;
1759 struct ib_sa_mad
*mad
;
1765 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
1766 agent
= port
->agent
;
1768 if (method
!= IB_MGMT_METHOD_GET
&&
1769 method
!= IB_MGMT_METHOD_SET
&&
1770 method
!= IB_SA_METHOD_DELETE
)
1773 query
= kzalloc(sizeof(*query
), gfp_mask
);
1777 query
->sa_query
.port
= port
;
1778 ret
= alloc_mad(&query
->sa_query
, gfp_mask
);
1782 ib_sa_client_get(client
);
1783 query
->sa_query
.client
= client
;
1784 query
->callback
= callback
;
1785 query
->context
= context
;
1787 mad
= query
->sa_query
.mad_buf
->mad
;
1788 init_mad(&query
->sa_query
, agent
);
1790 query
->sa_query
.callback
= callback
? ib_sa_service_rec_callback
: NULL
;
1791 query
->sa_query
.release
= ib_sa_service_rec_release
;
1792 mad
->mad_hdr
.method
= method
;
1793 mad
->mad_hdr
.attr_id
= cpu_to_be16(IB_SA_ATTR_SERVICE_REC
);
1794 mad
->sa_hdr
.comp_mask
= comp_mask
;
1796 ib_pack(service_rec_table
, ARRAY_SIZE(service_rec_table
),
1799 *sa_query
= &query
->sa_query
;
1801 ret
= send_mad(&query
->sa_query
, timeout_ms
, gfp_mask
);
1809 ib_sa_client_put(query
->sa_query
.client
);
1810 free_mad(&query
->sa_query
);
1816 EXPORT_SYMBOL(ib_sa_service_rec_query
);
1818 static void ib_sa_mcmember_rec_callback(struct ib_sa_query
*sa_query
,
1820 struct ib_sa_mad
*mad
)
1822 struct ib_sa_mcmember_query
*query
=
1823 container_of(sa_query
, struct ib_sa_mcmember_query
, sa_query
);
1826 struct ib_sa_mcmember_rec rec
;
1828 ib_unpack(mcmember_rec_table
, ARRAY_SIZE(mcmember_rec_table
),
1830 query
->callback(status
, &rec
, query
->context
);
1832 query
->callback(status
, NULL
, query
->context
);
1835 static void ib_sa_mcmember_rec_release(struct ib_sa_query
*sa_query
)
1837 kfree(container_of(sa_query
, struct ib_sa_mcmember_query
, sa_query
));
1840 int ib_sa_mcmember_rec_query(struct ib_sa_client
*client
,
1841 struct ib_device
*device
, u8 port_num
,
1843 struct ib_sa_mcmember_rec
*rec
,
1844 ib_sa_comp_mask comp_mask
,
1845 int timeout_ms
, gfp_t gfp_mask
,
1846 void (*callback
)(int status
,
1847 struct ib_sa_mcmember_rec
*resp
,
1850 struct ib_sa_query
**sa_query
)
1852 struct ib_sa_mcmember_query
*query
;
1853 struct ib_sa_device
*sa_dev
= ib_get_client_data(device
, &sa_client
);
1854 struct ib_sa_port
*port
;
1855 struct ib_mad_agent
*agent
;
1856 struct ib_sa_mad
*mad
;
1862 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
1863 agent
= port
->agent
;
1865 query
= kzalloc(sizeof(*query
), gfp_mask
);
1869 query
->sa_query
.port
= port
;
1870 ret
= alloc_mad(&query
->sa_query
, gfp_mask
);
1874 ib_sa_client_get(client
);
1875 query
->sa_query
.client
= client
;
1876 query
->callback
= callback
;
1877 query
->context
= context
;
1879 mad
= query
->sa_query
.mad_buf
->mad
;
1880 init_mad(&query
->sa_query
, agent
);
1882 query
->sa_query
.callback
= callback
? ib_sa_mcmember_rec_callback
: NULL
;
1883 query
->sa_query
.release
= ib_sa_mcmember_rec_release
;
1884 mad
->mad_hdr
.method
= method
;
1885 mad
->mad_hdr
.attr_id
= cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC
);
1886 mad
->sa_hdr
.comp_mask
= comp_mask
;
1888 ib_pack(mcmember_rec_table
, ARRAY_SIZE(mcmember_rec_table
),
1891 *sa_query
= &query
->sa_query
;
1893 ret
= send_mad(&query
->sa_query
, timeout_ms
, gfp_mask
);
1901 ib_sa_client_put(query
->sa_query
.client
);
1902 free_mad(&query
->sa_query
);
1909 /* Support GuidInfoRecord */
1910 static void ib_sa_guidinfo_rec_callback(struct ib_sa_query
*sa_query
,
1912 struct ib_sa_mad
*mad
)
1914 struct ib_sa_guidinfo_query
*query
=
1915 container_of(sa_query
, struct ib_sa_guidinfo_query
, sa_query
);
1918 struct ib_sa_guidinfo_rec rec
;
1920 ib_unpack(guidinfo_rec_table
, ARRAY_SIZE(guidinfo_rec_table
),
1922 query
->callback(status
, &rec
, query
->context
);
1924 query
->callback(status
, NULL
, query
->context
);
1927 static void ib_sa_guidinfo_rec_release(struct ib_sa_query
*sa_query
)
1929 kfree(container_of(sa_query
, struct ib_sa_guidinfo_query
, sa_query
));
1932 int ib_sa_guid_info_rec_query(struct ib_sa_client
*client
,
1933 struct ib_device
*device
, u8 port_num
,
1934 struct ib_sa_guidinfo_rec
*rec
,
1935 ib_sa_comp_mask comp_mask
, u8 method
,
1936 int timeout_ms
, gfp_t gfp_mask
,
1937 void (*callback
)(int status
,
1938 struct ib_sa_guidinfo_rec
*resp
,
1941 struct ib_sa_query
**sa_query
)
1943 struct ib_sa_guidinfo_query
*query
;
1944 struct ib_sa_device
*sa_dev
= ib_get_client_data(device
, &sa_client
);
1945 struct ib_sa_port
*port
;
1946 struct ib_mad_agent
*agent
;
1947 struct ib_sa_mad
*mad
;
1953 if (method
!= IB_MGMT_METHOD_GET
&&
1954 method
!= IB_MGMT_METHOD_SET
&&
1955 method
!= IB_SA_METHOD_DELETE
) {
1959 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
1960 agent
= port
->agent
;
1962 query
= kzalloc(sizeof(*query
), gfp_mask
);
1966 query
->sa_query
.port
= port
;
1967 ret
= alloc_mad(&query
->sa_query
, gfp_mask
);
1971 ib_sa_client_get(client
);
1972 query
->sa_query
.client
= client
;
1973 query
->callback
= callback
;
1974 query
->context
= context
;
1976 mad
= query
->sa_query
.mad_buf
->mad
;
1977 init_mad(&query
->sa_query
, agent
);
1979 query
->sa_query
.callback
= callback
? ib_sa_guidinfo_rec_callback
: NULL
;
1980 query
->sa_query
.release
= ib_sa_guidinfo_rec_release
;
1982 mad
->mad_hdr
.method
= method
;
1983 mad
->mad_hdr
.attr_id
= cpu_to_be16(IB_SA_ATTR_GUID_INFO_REC
);
1984 mad
->sa_hdr
.comp_mask
= comp_mask
;
1986 ib_pack(guidinfo_rec_table
, ARRAY_SIZE(guidinfo_rec_table
), rec
,
1989 *sa_query
= &query
->sa_query
;
1991 ret
= send_mad(&query
->sa_query
, timeout_ms
, gfp_mask
);
1999 ib_sa_client_put(query
->sa_query
.client
);
2000 free_mad(&query
->sa_query
);
2006 EXPORT_SYMBOL(ib_sa_guid_info_rec_query
);
2008 bool ib_sa_sendonly_fullmem_support(struct ib_sa_client
*client
,
2009 struct ib_device
*device
,
2012 struct ib_sa_device
*sa_dev
= ib_get_client_data(device
, &sa_client
);
2013 struct ib_sa_port
*port
;
2015 unsigned long flags
;
2020 port
= &sa_dev
->port
[port_num
- sa_dev
->start_port
];
2022 spin_lock_irqsave(&port
->classport_lock
, flags
);
2023 if ((port
->classport_info
.valid
) &&
2024 (port
->classport_info
.data
.type
== RDMA_CLASS_PORT_INFO_IB
))
2025 ret
= ib_get_cpi_capmask2(&port
->classport_info
.data
.ib
)
2026 & IB_SA_CAP_MASK2_SENDONLY_FULL_MEM_SUPPORT
;
2027 spin_unlock_irqrestore(&port
->classport_lock
, flags
);
2030 EXPORT_SYMBOL(ib_sa_sendonly_fullmem_support
);
2032 struct ib_classport_info_context
{
2033 struct completion done
;
2034 struct ib_sa_query
*sa_query
;
2037 static void ib_classportinfo_cb(void *context
)
2039 struct ib_classport_info_context
*cb_ctx
= context
;
2041 complete(&cb_ctx
->done
);
2044 static void ib_sa_classport_info_rec_callback(struct ib_sa_query
*sa_query
,
2046 struct ib_sa_mad
*mad
)
2048 unsigned long flags
;
2049 struct ib_sa_classport_info_query
*query
=
2050 container_of(sa_query
, struct ib_sa_classport_info_query
, sa_query
);
2051 struct ib_sa_classport_cache
*info
= &sa_query
->port
->classport_info
;
2054 if (sa_query
->flags
& IB_SA_QUERY_OPA
) {
2055 struct opa_class_port_info rec
;
2057 ib_unpack(opa_classport_info_rec_table
,
2058 ARRAY_SIZE(opa_classport_info_rec_table
),
2061 spin_lock_irqsave(&sa_query
->port
->classport_lock
,
2063 if (!status
&& !info
->valid
) {
2064 memcpy(&info
->data
.opa
, &rec
,
2065 sizeof(info
->data
.opa
));
2068 info
->data
.type
= RDMA_CLASS_PORT_INFO_OPA
;
2070 spin_unlock_irqrestore(&sa_query
->port
->classport_lock
,
2074 struct ib_class_port_info rec
;
2076 ib_unpack(ib_classport_info_rec_table
,
2077 ARRAY_SIZE(ib_classport_info_rec_table
),
2080 spin_lock_irqsave(&sa_query
->port
->classport_lock
,
2082 if (!status
&& !info
->valid
) {
2083 memcpy(&info
->data
.ib
, &rec
,
2084 sizeof(info
->data
.ib
));
2087 info
->data
.type
= RDMA_CLASS_PORT_INFO_IB
;
2089 spin_unlock_irqrestore(&sa_query
->port
->classport_lock
,
2093 query
->callback(query
->context
);
2096 static void ib_sa_classport_info_rec_release(struct ib_sa_query
*sa_query
)
2098 kfree(container_of(sa_query
, struct ib_sa_classport_info_query
,
2102 static int ib_sa_classport_info_rec_query(struct ib_sa_port
*port
,
2104 void (*callback
)(void *context
),
2106 struct ib_sa_query
**sa_query
)
2108 struct ib_mad_agent
*agent
;
2109 struct ib_sa_classport_info_query
*query
;
2110 struct ib_sa_mad
*mad
;
2111 gfp_t gfp_mask
= GFP_KERNEL
;
2114 agent
= port
->agent
;
2116 query
= kzalloc(sizeof(*query
), gfp_mask
);
2120 query
->sa_query
.port
= port
;
2121 query
->sa_query
.flags
|= rdma_cap_opa_ah(port
->agent
->device
,
2123 IB_SA_QUERY_OPA
: 0;
2124 ret
= alloc_mad(&query
->sa_query
, gfp_mask
);
2128 query
->callback
= callback
;
2129 query
->context
= context
;
2131 mad
= query
->sa_query
.mad_buf
->mad
;
2132 init_mad(&query
->sa_query
, agent
);
2134 query
->sa_query
.callback
= ib_sa_classport_info_rec_callback
;
2135 query
->sa_query
.release
= ib_sa_classport_info_rec_release
;
2136 mad
->mad_hdr
.method
= IB_MGMT_METHOD_GET
;
2137 mad
->mad_hdr
.attr_id
= cpu_to_be16(IB_SA_ATTR_CLASS_PORTINFO
);
2138 mad
->sa_hdr
.comp_mask
= 0;
2139 *sa_query
= &query
->sa_query
;
2141 ret
= send_mad(&query
->sa_query
, timeout_ms
, gfp_mask
);
2149 free_mad(&query
->sa_query
);
2156 static void update_ib_cpi(struct work_struct
*work
)
2158 struct ib_sa_port
*port
=
2159 container_of(work
, struct ib_sa_port
, ib_cpi_work
.work
);
2160 struct ib_classport_info_context
*cb_context
;
2161 unsigned long flags
;
2164 /* If the classport info is valid, nothing
2167 spin_lock_irqsave(&port
->classport_lock
, flags
);
2168 if (port
->classport_info
.valid
) {
2169 spin_unlock_irqrestore(&port
->classport_lock
, flags
);
2172 spin_unlock_irqrestore(&port
->classport_lock
, flags
);
2174 cb_context
= kmalloc(sizeof(*cb_context
), GFP_KERNEL
);
2178 init_completion(&cb_context
->done
);
2180 ret
= ib_sa_classport_info_rec_query(port
, 3000,
2181 ib_classportinfo_cb
, cb_context
,
2182 &cb_context
->sa_query
);
2185 wait_for_completion(&cb_context
->done
);
2188 spin_lock_irqsave(&port
->classport_lock
, flags
);
2190 /* If the classport info is still not valid, the query should have
2191 * failed for some reason. Retry issuing the query
2193 if (!port
->classport_info
.valid
) {
2194 port
->classport_info
.retry_cnt
++;
2195 if (port
->classport_info
.retry_cnt
<=
2196 IB_SA_CPI_MAX_RETRY_CNT
) {
2197 unsigned long delay
=
2198 msecs_to_jiffies(IB_SA_CPI_RETRY_WAIT
);
2200 queue_delayed_work(ib_wq
, &port
->ib_cpi_work
, delay
);
2203 spin_unlock_irqrestore(&port
->classport_lock
, flags
);
2209 static void send_handler(struct ib_mad_agent
*agent
,
2210 struct ib_mad_send_wc
*mad_send_wc
)
2212 struct ib_sa_query
*query
= mad_send_wc
->send_buf
->context
[0];
2213 unsigned long flags
;
2215 if (query
->callback
)
2216 switch (mad_send_wc
->status
) {
2218 /* No callback -- already got recv */
2220 case IB_WC_RESP_TIMEOUT_ERR
:
2221 query
->callback(query
, -ETIMEDOUT
, NULL
);
2223 case IB_WC_WR_FLUSH_ERR
:
2224 query
->callback(query
, -EINTR
, NULL
);
2227 query
->callback(query
, -EIO
, NULL
);
2231 spin_lock_irqsave(&idr_lock
, flags
);
2232 idr_remove(&query_idr
, query
->id
);
2233 spin_unlock_irqrestore(&idr_lock
, flags
);
2237 ib_sa_client_put(query
->client
);
2238 query
->release(query
);
2241 static void recv_handler(struct ib_mad_agent
*mad_agent
,
2242 struct ib_mad_send_buf
*send_buf
,
2243 struct ib_mad_recv_wc
*mad_recv_wc
)
2245 struct ib_sa_query
*query
;
2250 query
= send_buf
->context
[0];
2251 if (query
->callback
) {
2252 if (mad_recv_wc
->wc
->status
== IB_WC_SUCCESS
)
2253 query
->callback(query
,
2254 mad_recv_wc
->recv_buf
.mad
->mad_hdr
.status
?
2256 (struct ib_sa_mad
*) mad_recv_wc
->recv_buf
.mad
);
2258 query
->callback(query
, -EIO
, NULL
);
2261 ib_free_recv_mad(mad_recv_wc
);
2264 static void update_sm_ah(struct work_struct
*work
)
2266 struct ib_sa_port
*port
=
2267 container_of(work
, struct ib_sa_port
, update_task
);
2268 struct ib_sa_sm_ah
*new_ah
;
2269 struct ib_port_attr port_attr
;
2270 struct rdma_ah_attr ah_attr
;
2272 if (ib_query_port(port
->agent
->device
, port
->port_num
, &port_attr
)) {
2273 pr_warn("Couldn't query port\n");
2277 new_ah
= kmalloc(sizeof(*new_ah
), GFP_KERNEL
);
2281 kref_init(&new_ah
->ref
);
2282 new_ah
->src_path_mask
= (1 << port_attr
.lmc
) - 1;
2284 new_ah
->pkey_index
= 0;
2285 if (ib_find_pkey(port
->agent
->device
, port
->port_num
,
2286 IB_DEFAULT_PKEY_FULL
, &new_ah
->pkey_index
))
2287 pr_err("Couldn't find index for default PKey\n");
2289 memset(&ah_attr
, 0, sizeof(ah_attr
));
2290 ah_attr
.type
= rdma_ah_find_type(port
->agent
->device
,
2292 rdma_ah_set_dlid(&ah_attr
, port_attr
.sm_lid
);
2293 rdma_ah_set_sl(&ah_attr
, port_attr
.sm_sl
);
2294 rdma_ah_set_port_num(&ah_attr
, port
->port_num
);
2295 if (port_attr
.grh_required
) {
2296 if (ah_attr
.type
== RDMA_AH_ATTR_TYPE_OPA
) {
2297 rdma_ah_set_make_grd(&ah_attr
, true);
2299 rdma_ah_set_ah_flags(&ah_attr
, IB_AH_GRH
);
2300 rdma_ah_set_subnet_prefix(&ah_attr
,
2301 cpu_to_be64(port_attr
.subnet_prefix
));
2302 rdma_ah_set_interface_id(&ah_attr
,
2303 cpu_to_be64(IB_SA_WELL_KNOWN_GUID
));
2307 new_ah
->ah
= rdma_create_ah(port
->agent
->qp
->pd
, &ah_attr
);
2308 if (IS_ERR(new_ah
->ah
)) {
2309 pr_warn("Couldn't create new SM AH\n");
2314 spin_lock_irq(&port
->ah_lock
);
2316 kref_put(&port
->sm_ah
->ref
, free_sm_ah
);
2317 port
->sm_ah
= new_ah
;
2318 spin_unlock_irq(&port
->ah_lock
);
2321 static void ib_sa_event(struct ib_event_handler
*handler
,
2322 struct ib_event
*event
)
2324 if (event
->event
== IB_EVENT_PORT_ERR
||
2325 event
->event
== IB_EVENT_PORT_ACTIVE
||
2326 event
->event
== IB_EVENT_LID_CHANGE
||
2327 event
->event
== IB_EVENT_PKEY_CHANGE
||
2328 event
->event
== IB_EVENT_SM_CHANGE
||
2329 event
->event
== IB_EVENT_CLIENT_REREGISTER
) {
2330 unsigned long flags
;
2331 struct ib_sa_device
*sa_dev
=
2332 container_of(handler
, typeof(*sa_dev
), event_handler
);
2333 u8 port_num
= event
->element
.port_num
- sa_dev
->start_port
;
2334 struct ib_sa_port
*port
= &sa_dev
->port
[port_num
];
2336 if (!rdma_cap_ib_sa(handler
->device
, port
->port_num
))
2339 spin_lock_irqsave(&port
->ah_lock
, flags
);
2341 kref_put(&port
->sm_ah
->ref
, free_sm_ah
);
2343 spin_unlock_irqrestore(&port
->ah_lock
, flags
);
2345 if (event
->event
== IB_EVENT_SM_CHANGE
||
2346 event
->event
== IB_EVENT_CLIENT_REREGISTER
||
2347 event
->event
== IB_EVENT_LID_CHANGE
||
2348 event
->event
== IB_EVENT_PORT_ACTIVE
) {
2349 unsigned long delay
=
2350 msecs_to_jiffies(IB_SA_CPI_RETRY_WAIT
);
2352 spin_lock_irqsave(&port
->classport_lock
, flags
);
2353 port
->classport_info
.valid
= false;
2354 port
->classport_info
.retry_cnt
= 0;
2355 spin_unlock_irqrestore(&port
->classport_lock
, flags
);
2356 queue_delayed_work(ib_wq
,
2357 &port
->ib_cpi_work
, delay
);
2359 queue_work(ib_wq
, &sa_dev
->port
[port_num
].update_task
);
2363 static void ib_sa_add_one(struct ib_device
*device
)
2365 struct ib_sa_device
*sa_dev
;
2369 s
= rdma_start_port(device
);
2370 e
= rdma_end_port(device
);
2372 sa_dev
= kzalloc(sizeof *sa_dev
+
2373 (e
- s
+ 1) * sizeof (struct ib_sa_port
),
2378 sa_dev
->start_port
= s
;
2379 sa_dev
->end_port
= e
;
2381 for (i
= 0; i
<= e
- s
; ++i
) {
2382 spin_lock_init(&sa_dev
->port
[i
].ah_lock
);
2383 if (!rdma_cap_ib_sa(device
, i
+ 1))
2386 sa_dev
->port
[i
].sm_ah
= NULL
;
2387 sa_dev
->port
[i
].port_num
= i
+ s
;
2389 spin_lock_init(&sa_dev
->port
[i
].classport_lock
);
2390 sa_dev
->port
[i
].classport_info
.valid
= false;
2392 sa_dev
->port
[i
].agent
=
2393 ib_register_mad_agent(device
, i
+ s
, IB_QPT_GSI
,
2394 NULL
, 0, send_handler
,
2395 recv_handler
, sa_dev
, 0);
2396 if (IS_ERR(sa_dev
->port
[i
].agent
))
2399 INIT_WORK(&sa_dev
->port
[i
].update_task
, update_sm_ah
);
2400 INIT_DELAYED_WORK(&sa_dev
->port
[i
].ib_cpi_work
,
2409 ib_set_client_data(device
, &sa_client
, sa_dev
);
2412 * We register our event handler after everything is set up,
2413 * and then update our cached info after the event handler is
2414 * registered to avoid any problems if a port changes state
2415 * during our initialization.
2418 INIT_IB_EVENT_HANDLER(&sa_dev
->event_handler
, device
, ib_sa_event
);
2419 ib_register_event_handler(&sa_dev
->event_handler
);
2421 for (i
= 0; i
<= e
- s
; ++i
) {
2422 if (rdma_cap_ib_sa(device
, i
+ 1))
2423 update_sm_ah(&sa_dev
->port
[i
].update_task
);
2430 if (rdma_cap_ib_sa(device
, i
+ 1))
2431 ib_unregister_mad_agent(sa_dev
->port
[i
].agent
);
2438 static void ib_sa_remove_one(struct ib_device
*device
, void *client_data
)
2440 struct ib_sa_device
*sa_dev
= client_data
;
2446 ib_unregister_event_handler(&sa_dev
->event_handler
);
2447 flush_workqueue(ib_wq
);
2449 for (i
= 0; i
<= sa_dev
->end_port
- sa_dev
->start_port
; ++i
) {
2450 if (rdma_cap_ib_sa(device
, i
+ 1)) {
2451 cancel_delayed_work_sync(&sa_dev
->port
[i
].ib_cpi_work
);
2452 ib_unregister_mad_agent(sa_dev
->port
[i
].agent
);
2453 if (sa_dev
->port
[i
].sm_ah
)
2454 kref_put(&sa_dev
->port
[i
].sm_ah
->ref
, free_sm_ah
);
2462 int ib_sa_init(void)
2466 get_random_bytes(&tid
, sizeof tid
);
2468 atomic_set(&ib_nl_sa_request_seq
, 0);
2470 ret
= ib_register_client(&sa_client
);
2472 pr_err("Couldn't register ib_sa client\n");
2478 pr_err("Couldn't initialize multicast handling\n");
2482 ib_nl_wq
= alloc_ordered_workqueue("ib_nl_sa_wq", WQ_MEM_RECLAIM
);
2488 INIT_DELAYED_WORK(&ib_nl_timed_work
, ib_nl_request_timeout
);
2495 ib_unregister_client(&sa_client
);
2500 void ib_sa_cleanup(void)
2502 cancel_delayed_work(&ib_nl_timed_work
);
2503 flush_workqueue(ib_nl_wq
);
2504 destroy_workqueue(ib_nl_wq
);
2506 ib_unregister_client(&sa_client
);
2507 idr_destroy(&query_idr
);