2 * Copyright (c) 2005 Voltaire Inc. All rights reserved.
3 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
4 * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
5 * Copyright (c) 2005 Intel Corporation. All rights reserved.
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36 #include <linux/mutex.h>
37 #include <linux/inetdevice.h>
38 #include <linux/slab.h>
39 #include <linux/workqueue.h>
40 #include <linux/module.h>
42 #include <net/neighbour.h>
43 #include <net/route.h>
44 #include <net/netevent.h>
45 #include <net/addrconf.h>
46 #include <net/ip6_route.h>
47 #include <rdma/ib_addr.h>
49 #include <rdma/rdma_netlink.h>
50 #include <net/netlink.h>
52 #include "core_priv.h"
55 struct list_head list
;
56 struct sockaddr_storage src_addr
;
57 struct sockaddr_storage dst_addr
;
58 struct rdma_dev_addr
*addr
;
59 struct rdma_addr_client
*client
;
61 void (*callback
)(int status
, struct sockaddr
*src_addr
,
62 struct rdma_dev_addr
*addr
, void *context
);
63 unsigned long timeout
;
68 static atomic_t ib_nl_addr_request_seq
= ATOMIC_INIT(0);
70 static void process_req(struct work_struct
*work
);
72 static DEFINE_MUTEX(lock
);
73 static LIST_HEAD(req_list
);
74 static DECLARE_DELAYED_WORK(work
, process_req
);
75 static struct workqueue_struct
*addr_wq
;
77 static const struct nla_policy ib_nl_addr_policy
[LS_NLA_TYPE_MAX
] = {
78 [LS_NLA_TYPE_DGID
] = {.type
= NLA_BINARY
,
79 .len
= sizeof(struct rdma_nla_ls_gid
)},
82 static inline bool ib_nl_is_good_ip_resp(const struct nlmsghdr
*nlh
)
84 struct nlattr
*tb
[LS_NLA_TYPE_MAX
] = {};
87 if (nlh
->nlmsg_flags
& RDMA_NL_LS_F_ERR
)
90 ret
= nla_parse(tb
, LS_NLA_TYPE_MAX
- 1, nlmsg_data(nlh
),
91 nlmsg_len(nlh
), ib_nl_addr_policy
, NULL
);
98 static void ib_nl_process_good_ip_rsep(const struct nlmsghdr
*nlh
)
100 const struct nlattr
*head
, *curr
;
102 struct addr_req
*req
;
106 head
= (const struct nlattr
*)nlmsg_data(nlh
);
107 len
= nlmsg_len(nlh
);
109 nla_for_each_attr(curr
, head
, len
, rem
) {
110 if (curr
->nla_type
== LS_NLA_TYPE_DGID
)
111 memcpy(&gid
, nla_data(curr
), nla_len(curr
));
115 list_for_each_entry(req
, &req_list
, list
) {
116 if (nlh
->nlmsg_seq
!= req
->seq
)
118 /* We set the DGID part, the rest was set earlier */
119 rdma_addr_set_dgid(req
->addr
, &gid
);
127 pr_info("Couldn't find request waiting for DGID: %pI6\n",
131 int ib_nl_handle_ip_res_resp(struct sk_buff
*skb
,
132 struct netlink_callback
*cb
)
134 const struct nlmsghdr
*nlh
= (struct nlmsghdr
*)cb
->nlh
;
136 if ((nlh
->nlmsg_flags
& NLM_F_REQUEST
) ||
137 !(NETLINK_CB(skb
).sk
) ||
138 !netlink_capable(skb
, CAP_NET_ADMIN
))
141 if (ib_nl_is_good_ip_resp(nlh
))
142 ib_nl_process_good_ip_rsep(nlh
);
147 static int ib_nl_ip_send_msg(struct rdma_dev_addr
*dev_addr
,
151 struct sk_buff
*skb
= NULL
;
152 struct nlmsghdr
*nlh
;
153 struct rdma_ls_ip_resolve_header
*header
;
159 if (family
== AF_INET
) {
160 size
= sizeof(struct in_addr
);
161 attrtype
= RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_IPV4
;
163 size
= sizeof(struct in6_addr
);
164 attrtype
= RDMA_NLA_F_MANDATORY
| LS_NLA_TYPE_IPV6
;
167 len
= nla_total_size(sizeof(size
));
168 len
+= NLMSG_ALIGN(sizeof(*header
));
170 skb
= nlmsg_new(len
, GFP_KERNEL
);
174 data
= ibnl_put_msg(skb
, &nlh
, seq
, 0, RDMA_NL_LS
,
175 RDMA_NL_LS_OP_IP_RESOLVE
, NLM_F_REQUEST
);
181 /* Construct the family header first */
182 header
= (struct rdma_ls_ip_resolve_header
*)
183 skb_put(skb
, NLMSG_ALIGN(sizeof(*header
)));
184 header
->ifindex
= dev_addr
->bound_dev_if
;
185 nla_put(skb
, attrtype
, size
, daddr
);
187 /* Repair the nlmsg header length */
189 ibnl_multicast(skb
, nlh
, RDMA_NL_GROUP_LS
, GFP_KERNEL
);
191 /* Make the request retry, so when we get the response from userspace
192 * we will have something.
197 int rdma_addr_size(struct sockaddr
*addr
)
199 switch (addr
->sa_family
) {
201 return sizeof(struct sockaddr_in
);
203 return sizeof(struct sockaddr_in6
);
205 return sizeof(struct sockaddr_ib
);
210 EXPORT_SYMBOL(rdma_addr_size
);
212 static struct rdma_addr_client self
;
214 void rdma_addr_register_client(struct rdma_addr_client
*client
)
216 atomic_set(&client
->refcount
, 1);
217 init_completion(&client
->comp
);
219 EXPORT_SYMBOL(rdma_addr_register_client
);
221 static inline void put_client(struct rdma_addr_client
*client
)
223 if (atomic_dec_and_test(&client
->refcount
))
224 complete(&client
->comp
);
227 void rdma_addr_unregister_client(struct rdma_addr_client
*client
)
230 wait_for_completion(&client
->comp
);
232 EXPORT_SYMBOL(rdma_addr_unregister_client
);
234 int rdma_copy_addr(struct rdma_dev_addr
*dev_addr
, struct net_device
*dev
,
235 const unsigned char *dst_dev_addr
)
237 dev_addr
->dev_type
= dev
->type
;
238 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
239 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
241 memcpy(dev_addr
->dst_dev_addr
, dst_dev_addr
, MAX_ADDR_LEN
);
242 dev_addr
->bound_dev_if
= dev
->ifindex
;
245 EXPORT_SYMBOL(rdma_copy_addr
);
247 int rdma_translate_ip(const struct sockaddr
*addr
,
248 struct rdma_dev_addr
*dev_addr
,
251 struct net_device
*dev
;
252 int ret
= -EADDRNOTAVAIL
;
254 if (dev_addr
->bound_dev_if
) {
255 dev
= dev_get_by_index(dev_addr
->net
, dev_addr
->bound_dev_if
);
258 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
263 switch (addr
->sa_family
) {
265 dev
= ip_dev_find(dev_addr
->net
,
266 ((const struct sockaddr_in
*)addr
)->sin_addr
.s_addr
);
271 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
273 *vlan_id
= rdma_vlan_dev_vlan_id(dev
);
276 #if IS_ENABLED(CONFIG_IPV6)
279 for_each_netdev_rcu(dev_addr
->net
, dev
) {
280 if (ipv6_chk_addr(dev_addr
->net
,
281 &((const struct sockaddr_in6
*)addr
)->sin6_addr
,
283 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
285 *vlan_id
= rdma_vlan_dev_vlan_id(dev
);
295 EXPORT_SYMBOL(rdma_translate_ip
);
297 static void set_timeout(unsigned long time
)
301 delay
= time
- jiffies
;
305 mod_delayed_work(addr_wq
, &work
, delay
);
308 static void queue_req(struct addr_req
*req
)
310 struct addr_req
*temp_req
;
313 list_for_each_entry_reverse(temp_req
, &req_list
, list
) {
314 if (time_after_eq(req
->timeout
, temp_req
->timeout
))
318 list_add(&req
->list
, &temp_req
->list
);
320 if (req_list
.next
== &req
->list
)
321 set_timeout(req
->timeout
);
325 static int ib_nl_fetch_ha(struct dst_entry
*dst
, struct rdma_dev_addr
*dev_addr
,
326 const void *daddr
, u32 seq
, u16 family
)
328 if (ibnl_chk_listeners(RDMA_NL_GROUP_LS
))
329 return -EADDRNOTAVAIL
;
331 /* We fill in what we can, the response will fill the rest */
332 rdma_copy_addr(dev_addr
, dst
->dev
, NULL
);
333 return ib_nl_ip_send_msg(dev_addr
, daddr
, seq
, family
);
336 static int dst_fetch_ha(struct dst_entry
*dst
, struct rdma_dev_addr
*dev_addr
,
342 n
= dst_neigh_lookup(dst
, daddr
);
345 if (!n
|| !(n
->nud_state
& NUD_VALID
)) {
347 neigh_event_send(n
, NULL
);
350 ret
= rdma_copy_addr(dev_addr
, dst
->dev
, n
->ha
);
360 static bool has_gateway(struct dst_entry
*dst
, sa_family_t family
)
363 struct rt6_info
*rt6
;
365 if (family
== AF_INET
) {
366 rt
= container_of(dst
, struct rtable
, dst
);
367 return rt
->rt_uses_gateway
;
370 rt6
= container_of(dst
, struct rt6_info
, dst
);
371 return rt6
->rt6i_flags
& RTF_GATEWAY
;
374 static int fetch_ha(struct dst_entry
*dst
, struct rdma_dev_addr
*dev_addr
,
375 const struct sockaddr
*dst_in
, u32 seq
)
377 const struct sockaddr_in
*dst_in4
=
378 (const struct sockaddr_in
*)dst_in
;
379 const struct sockaddr_in6
*dst_in6
=
380 (const struct sockaddr_in6
*)dst_in
;
381 const void *daddr
= (dst_in
->sa_family
== AF_INET
) ?
382 (const void *)&dst_in4
->sin_addr
.s_addr
:
383 (const void *)&dst_in6
->sin6_addr
;
384 sa_family_t family
= dst_in
->sa_family
;
386 /* Gateway + ARPHRD_INFINIBAND -> IB router */
387 if (has_gateway(dst
, family
) && dst
->dev
->type
== ARPHRD_INFINIBAND
)
388 return ib_nl_fetch_ha(dst
, dev_addr
, daddr
, seq
, family
);
390 return dst_fetch_ha(dst
, dev_addr
, daddr
);
393 static int addr4_resolve(struct sockaddr_in
*src_in
,
394 const struct sockaddr_in
*dst_in
,
395 struct rdma_dev_addr
*addr
,
398 __be32 src_ip
= src_in
->sin_addr
.s_addr
;
399 __be32 dst_ip
= dst_in
->sin_addr
.s_addr
;
404 memset(&fl4
, 0, sizeof(fl4
));
407 fl4
.flowi4_oif
= addr
->bound_dev_if
;
408 rt
= ip_route_output_key(addr
->net
, &fl4
);
413 src_in
->sin_family
= AF_INET
;
414 src_in
->sin_addr
.s_addr
= fl4
.saddr
;
416 /* If there's a gateway and type of device not ARPHRD_INFINIBAND, we're
417 * definitely in RoCE v2 (as RoCE v1 isn't routable) set the network
420 if (rt
->rt_uses_gateway
&& rt
->dst
.dev
->type
!= ARPHRD_INFINIBAND
)
421 addr
->network
= RDMA_NETWORK_IPV4
;
423 addr
->hoplimit
= ip4_dst_hoplimit(&rt
->dst
);
431 #if IS_ENABLED(CONFIG_IPV6)
432 static int addr6_resolve(struct sockaddr_in6
*src_in
,
433 const struct sockaddr_in6
*dst_in
,
434 struct rdma_dev_addr
*addr
,
435 struct dst_entry
**pdst
)
438 struct dst_entry
*dst
;
442 memset(&fl6
, 0, sizeof fl6
);
443 fl6
.daddr
= dst_in
->sin6_addr
;
444 fl6
.saddr
= src_in
->sin6_addr
;
445 fl6
.flowi6_oif
= addr
->bound_dev_if
;
447 ret
= ipv6_stub
->ipv6_dst_lookup(addr
->net
, NULL
, &dst
, &fl6
);
451 rt
= (struct rt6_info
*)dst
;
452 if (ipv6_addr_any(&fl6
.saddr
)) {
453 ret
= ipv6_dev_get_saddr(addr
->net
, ip6_dst_idev(dst
)->dev
,
454 &fl6
.daddr
, 0, &fl6
.saddr
);
458 src_in
->sin6_family
= AF_INET6
;
459 src_in
->sin6_addr
= fl6
.saddr
;
462 /* If there's a gateway and type of device not ARPHRD_INFINIBAND, we're
463 * definitely in RoCE v2 (as RoCE v1 isn't routable) set the network
466 if (rt
->rt6i_flags
& RTF_GATEWAY
&&
467 ip6_dst_idev(dst
)->dev
->type
!= ARPHRD_INFINIBAND
)
468 addr
->network
= RDMA_NETWORK_IPV6
;
470 addr
->hoplimit
= ip6_dst_hoplimit(dst
);
479 static int addr6_resolve(struct sockaddr_in6
*src_in
,
480 const struct sockaddr_in6
*dst_in
,
481 struct rdma_dev_addr
*addr
,
482 struct dst_entry
**pdst
)
484 return -EADDRNOTAVAIL
;
488 static int addr_resolve_neigh(struct dst_entry
*dst
,
489 const struct sockaddr
*dst_in
,
490 struct rdma_dev_addr
*addr
,
493 if (dst
->dev
->flags
& IFF_LOOPBACK
) {
496 ret
= rdma_translate_ip(dst_in
, addr
, NULL
);
498 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
,
504 /* If the device doesn't do ARP internally */
505 if (!(dst
->dev
->flags
& IFF_NOARP
))
506 return fetch_ha(dst
, addr
, dst_in
, seq
);
508 return rdma_copy_addr(addr
, dst
->dev
, NULL
);
511 static int addr_resolve(struct sockaddr
*src_in
,
512 const struct sockaddr
*dst_in
,
513 struct rdma_dev_addr
*addr
,
517 struct net_device
*ndev
;
518 struct dst_entry
*dst
;
521 if (src_in
->sa_family
== AF_INET
) {
522 struct rtable
*rt
= NULL
;
523 const struct sockaddr_in
*dst_in4
=
524 (const struct sockaddr_in
*)dst_in
;
526 ret
= addr4_resolve((struct sockaddr_in
*)src_in
,
532 ret
= addr_resolve_neigh(&rt
->dst
, dst_in
, addr
, seq
);
539 const struct sockaddr_in6
*dst_in6
=
540 (const struct sockaddr_in6
*)dst_in
;
542 ret
= addr6_resolve((struct sockaddr_in6
*)src_in
,
549 ret
= addr_resolve_neigh(dst
, dst_in
, addr
, seq
);
557 addr
->bound_dev_if
= ndev
->ifindex
;
558 addr
->net
= dev_net(ndev
);
564 static void process_req(struct work_struct
*work
)
566 struct addr_req
*req
, *temp_req
;
567 struct sockaddr
*src_in
, *dst_in
;
568 struct list_head done_list
;
570 INIT_LIST_HEAD(&done_list
);
573 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
574 if (req
->status
== -ENODATA
) {
575 src_in
= (struct sockaddr
*) &req
->src_addr
;
576 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
577 req
->status
= addr_resolve(src_in
, dst_in
, req
->addr
,
579 if (req
->status
&& time_after_eq(jiffies
, req
->timeout
))
580 req
->status
= -ETIMEDOUT
;
581 else if (req
->status
== -ENODATA
)
584 list_move_tail(&req
->list
, &done_list
);
587 if (!list_empty(&req_list
)) {
588 req
= list_entry(req_list
.next
, struct addr_req
, list
);
589 set_timeout(req
->timeout
);
593 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
594 list_del(&req
->list
);
595 req
->callback(req
->status
, (struct sockaddr
*) &req
->src_addr
,
596 req
->addr
, req
->context
);
597 put_client(req
->client
);
602 int rdma_resolve_ip(struct rdma_addr_client
*client
,
603 struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
604 struct rdma_dev_addr
*addr
, int timeout_ms
,
605 void (*callback
)(int status
, struct sockaddr
*src_addr
,
606 struct rdma_dev_addr
*addr
, void *context
),
609 struct sockaddr
*src_in
, *dst_in
;
610 struct addr_req
*req
;
613 req
= kzalloc(sizeof *req
, GFP_KERNEL
);
617 src_in
= (struct sockaddr
*) &req
->src_addr
;
618 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
621 if (src_addr
->sa_family
!= dst_addr
->sa_family
) {
626 memcpy(src_in
, src_addr
, rdma_addr_size(src_addr
));
628 src_in
->sa_family
= dst_addr
->sa_family
;
631 memcpy(dst_in
, dst_addr
, rdma_addr_size(dst_addr
));
633 req
->callback
= callback
;
634 req
->context
= context
;
635 req
->client
= client
;
636 atomic_inc(&client
->refcount
);
637 req
->seq
= (u32
)atomic_inc_return(&ib_nl_addr_request_seq
);
639 req
->status
= addr_resolve(src_in
, dst_in
, addr
, true, req
->seq
);
640 switch (req
->status
) {
642 req
->timeout
= jiffies
;
646 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
651 atomic_dec(&client
->refcount
);
659 EXPORT_SYMBOL(rdma_resolve_ip
);
661 int rdma_resolve_ip_route(struct sockaddr
*src_addr
,
662 const struct sockaddr
*dst_addr
,
663 struct rdma_dev_addr
*addr
)
665 struct sockaddr_storage ssrc_addr
= {};
666 struct sockaddr
*src_in
= (struct sockaddr
*)&ssrc_addr
;
669 if (src_addr
->sa_family
!= dst_addr
->sa_family
)
672 memcpy(src_in
, src_addr
, rdma_addr_size(src_addr
));
674 src_in
->sa_family
= dst_addr
->sa_family
;
677 return addr_resolve(src_in
, dst_addr
, addr
, false, 0);
679 EXPORT_SYMBOL(rdma_resolve_ip_route
);
681 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
683 struct addr_req
*req
, *temp_req
;
686 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
687 if (req
->addr
== addr
) {
688 req
->status
= -ECANCELED
;
689 req
->timeout
= jiffies
;
690 list_move(&req
->list
, &req_list
);
691 set_timeout(req
->timeout
);
697 EXPORT_SYMBOL(rdma_addr_cancel
);
699 struct resolve_cb_context
{
700 struct rdma_dev_addr
*addr
;
701 struct completion comp
;
705 static void resolve_cb(int status
, struct sockaddr
*src_addr
,
706 struct rdma_dev_addr
*addr
, void *context
)
709 memcpy(((struct resolve_cb_context
*)context
)->addr
,
710 addr
, sizeof(struct rdma_dev_addr
));
711 ((struct resolve_cb_context
*)context
)->status
= status
;
712 complete(&((struct resolve_cb_context
*)context
)->comp
);
715 int rdma_addr_find_l2_eth_by_grh(const union ib_gid
*sgid
,
716 const union ib_gid
*dgid
,
717 u8
*dmac
, u16
*vlan_id
, int *if_index
,
721 struct rdma_dev_addr dev_addr
;
722 struct resolve_cb_context ctx
;
723 struct net_device
*dev
;
726 struct sockaddr _sockaddr
;
727 struct sockaddr_in _sockaddr_in
;
728 struct sockaddr_in6 _sockaddr_in6
;
729 } sgid_addr
, dgid_addr
;
732 rdma_gid2ip(&sgid_addr
._sockaddr
, sgid
);
733 rdma_gid2ip(&dgid_addr
._sockaddr
, dgid
);
735 memset(&dev_addr
, 0, sizeof(dev_addr
));
737 dev_addr
.bound_dev_if
= *if_index
;
738 dev_addr
.net
= &init_net
;
740 ctx
.addr
= &dev_addr
;
741 init_completion(&ctx
.comp
);
742 ret
= rdma_resolve_ip(&self
, &sgid_addr
._sockaddr
, &dgid_addr
._sockaddr
,
743 &dev_addr
, 1000, resolve_cb
, &ctx
);
747 wait_for_completion(&ctx
.comp
);
753 memcpy(dmac
, dev_addr
.dst_dev_addr
, ETH_ALEN
);
754 dev
= dev_get_by_index(&init_net
, dev_addr
.bound_dev_if
);
758 *if_index
= dev_addr
.bound_dev_if
;
760 *vlan_id
= rdma_vlan_dev_vlan_id(dev
);
762 *hoplimit
= dev_addr
.hoplimit
;
766 EXPORT_SYMBOL(rdma_addr_find_l2_eth_by_grh
);
768 int rdma_addr_find_smac_by_sgid(union ib_gid
*sgid
, u8
*smac
, u16
*vlan_id
)
771 struct rdma_dev_addr dev_addr
;
773 struct sockaddr _sockaddr
;
774 struct sockaddr_in _sockaddr_in
;
775 struct sockaddr_in6 _sockaddr_in6
;
778 rdma_gid2ip(&gid_addr
._sockaddr
, sgid
);
780 memset(&dev_addr
, 0, sizeof(dev_addr
));
781 dev_addr
.net
= &init_net
;
782 ret
= rdma_translate_ip(&gid_addr
._sockaddr
, &dev_addr
, vlan_id
);
786 memcpy(smac
, dev_addr
.src_dev_addr
, ETH_ALEN
);
789 EXPORT_SYMBOL(rdma_addr_find_smac_by_sgid
);
791 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
794 if (event
== NETEVENT_NEIGH_UPDATE
) {
795 struct neighbour
*neigh
= ctx
;
797 if (neigh
->nud_state
& NUD_VALID
) {
798 set_timeout(jiffies
);
804 static struct notifier_block nb
= {
805 .notifier_call
= netevent_callback
810 addr_wq
= alloc_workqueue("ib_addr", WQ_MEM_RECLAIM
, 0);
814 register_netevent_notifier(&nb
);
815 rdma_addr_register_client(&self
);
820 void addr_cleanup(void)
822 rdma_addr_unregister_client(&self
);
823 unregister_netevent_notifier(&nb
);
824 destroy_workqueue(addr_wq
);