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/ipv6_stubs.h>
46 #include <net/ip6_route.h>
47 #include <rdma/ib_addr.h>
48 #include <rdma/ib_cache.h>
49 #include <rdma/ib_sa.h>
51 #include <rdma/rdma_netlink.h>
52 #include <net/netlink.h>
54 #include "core_priv.h"
57 struct list_head list
;
58 struct sockaddr_storage src_addr
;
59 struct sockaddr_storage dst_addr
;
60 struct rdma_dev_addr
*addr
;
62 void (*callback
)(int status
, struct sockaddr
*src_addr
,
63 struct rdma_dev_addr
*addr
, void *context
);
64 unsigned long timeout
;
65 struct delayed_work work
;
66 bool resolve_by_gid_attr
; /* Consider gid attr in resolve phase */
71 static atomic_t ib_nl_addr_request_seq
= ATOMIC_INIT(0);
73 static DEFINE_SPINLOCK(lock
);
74 static LIST_HEAD(req_list
);
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
),
80 .validation_type
= NLA_VALIDATE_MIN
,
81 .min
= sizeof(struct rdma_nla_ls_gid
)},
84 static inline bool ib_nl_is_good_ip_resp(const struct nlmsghdr
*nlh
)
86 struct nlattr
*tb
[LS_NLA_TYPE_MAX
] = {};
89 if (nlh
->nlmsg_flags
& RDMA_NL_LS_F_ERR
)
92 ret
= nla_parse_deprecated(tb
, LS_NLA_TYPE_MAX
- 1, nlmsg_data(nlh
),
93 nlmsg_len(nlh
), ib_nl_addr_policy
, NULL
);
100 static void ib_nl_process_good_ip_rsep(const struct nlmsghdr
*nlh
)
102 const struct nlattr
*head
, *curr
;
104 struct addr_req
*req
;
108 head
= (const struct nlattr
*)nlmsg_data(nlh
);
109 len
= nlmsg_len(nlh
);
111 nla_for_each_attr(curr
, head
, len
, rem
) {
112 if (curr
->nla_type
== LS_NLA_TYPE_DGID
)
113 memcpy(&gid
, nla_data(curr
), nla_len(curr
));
117 list_for_each_entry(req
, &req_list
, list
) {
118 if (nlh
->nlmsg_seq
!= req
->seq
)
120 /* We set the DGID part, the rest was set earlier */
121 rdma_addr_set_dgid(req
->addr
, &gid
);
126 spin_unlock_bh(&lock
);
129 pr_info("Couldn't find request waiting for DGID: %pI6\n",
133 int ib_nl_handle_ip_res_resp(struct sk_buff
*skb
,
134 struct nlmsghdr
*nlh
,
135 struct netlink_ext_ack
*extack
)
137 if ((nlh
->nlmsg_flags
& NLM_F_REQUEST
) ||
138 !(NETLINK_CB(skb
).sk
))
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
= skb_put(skb
, NLMSG_ALIGN(sizeof(*header
)));
183 header
->ifindex
= dev_addr
->bound_dev_if
;
184 nla_put(skb
, attrtype
, size
, daddr
);
186 /* Repair the nlmsg header length */
188 rdma_nl_multicast(&init_net
, skb
, RDMA_NL_GROUP_LS
, GFP_KERNEL
);
190 /* Make the request retry, so when we get the response from userspace
191 * we will have something.
196 int rdma_addr_size(const struct sockaddr
*addr
)
198 switch (addr
->sa_family
) {
200 return sizeof(struct sockaddr_in
);
202 return sizeof(struct sockaddr_in6
);
204 return sizeof(struct sockaddr_ib
);
209 EXPORT_SYMBOL(rdma_addr_size
);
211 int rdma_addr_size_in6(struct sockaddr_in6
*addr
)
213 int ret
= rdma_addr_size((struct sockaddr
*) addr
);
215 return ret
<= sizeof(*addr
) ? ret
: 0;
217 EXPORT_SYMBOL(rdma_addr_size_in6
);
219 int rdma_addr_size_kss(struct __kernel_sockaddr_storage
*addr
)
221 int ret
= rdma_addr_size((struct sockaddr
*) addr
);
223 return ret
<= sizeof(*addr
) ? ret
: 0;
225 EXPORT_SYMBOL(rdma_addr_size_kss
);
228 * rdma_copy_src_l2_addr - Copy netdevice source addresses
229 * @dev_addr: Destination address pointer where to copy the addresses
230 * @dev: Netdevice whose source addresses to copy
232 * rdma_copy_src_l2_addr() copies source addresses from the specified netdevice.
233 * This includes unicast address, broadcast address, device type and
236 void rdma_copy_src_l2_addr(struct rdma_dev_addr
*dev_addr
,
237 const struct net_device
*dev
)
239 dev_addr
->dev_type
= dev
->type
;
240 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
241 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
242 dev_addr
->bound_dev_if
= dev
->ifindex
;
244 EXPORT_SYMBOL(rdma_copy_src_l2_addr
);
246 static struct net_device
*
247 rdma_find_ndev_for_src_ip_rcu(struct net
*net
, const struct sockaddr
*src_in
)
249 struct net_device
*dev
= NULL
;
250 int ret
= -EADDRNOTAVAIL
;
252 switch (src_in
->sa_family
) {
254 dev
= __ip_dev_find(net
,
255 ((const struct sockaddr_in
*)src_in
)->sin_addr
.s_addr
,
260 #if IS_ENABLED(CONFIG_IPV6)
262 for_each_netdev_rcu(net
, dev
) {
263 if (ipv6_chk_addr(net
,
264 &((const struct sockaddr_in6
*)src_in
)->sin6_addr
,
273 return ret
? ERR_PTR(ret
) : dev
;
276 int rdma_translate_ip(const struct sockaddr
*addr
,
277 struct rdma_dev_addr
*dev_addr
)
279 struct net_device
*dev
;
281 if (dev_addr
->bound_dev_if
) {
282 dev
= dev_get_by_index(dev_addr
->net
, dev_addr
->bound_dev_if
);
285 rdma_copy_src_l2_addr(dev_addr
, dev
);
291 dev
= rdma_find_ndev_for_src_ip_rcu(dev_addr
->net
, addr
);
293 rdma_copy_src_l2_addr(dev_addr
, dev
);
295 return PTR_ERR_OR_ZERO(dev
);
297 EXPORT_SYMBOL(rdma_translate_ip
);
299 static void set_timeout(struct addr_req
*req
, unsigned long time
)
303 delay
= time
- jiffies
;
307 mod_delayed_work(addr_wq
, &req
->work
, delay
);
310 static void queue_req(struct addr_req
*req
)
313 list_add_tail(&req
->list
, &req_list
);
314 set_timeout(req
, req
->timeout
);
315 spin_unlock_bh(&lock
);
318 static int ib_nl_fetch_ha(struct rdma_dev_addr
*dev_addr
,
319 const void *daddr
, u32 seq
, u16 family
)
321 if (!rdma_nl_chk_listeners(RDMA_NL_GROUP_LS
))
322 return -EADDRNOTAVAIL
;
324 return ib_nl_ip_send_msg(dev_addr
, daddr
, seq
, family
);
327 static int dst_fetch_ha(const struct dst_entry
*dst
,
328 struct rdma_dev_addr
*dev_addr
,
334 n
= dst_neigh_lookup(dst
, daddr
);
338 if (!(n
->nud_state
& NUD_VALID
)) {
339 neigh_event_send(n
, NULL
);
342 neigh_ha_snapshot(dev_addr
->dst_dev_addr
, n
, dst
->dev
);
350 static bool has_gateway(const struct dst_entry
*dst
, sa_family_t family
)
353 struct rt6_info
*rt6
;
355 if (family
== AF_INET
) {
356 rt
= container_of(dst
, struct rtable
, dst
);
357 return rt
->rt_uses_gateway
;
360 rt6
= container_of(dst
, struct rt6_info
, dst
);
361 return rt6
->rt6i_flags
& RTF_GATEWAY
;
364 static int fetch_ha(const struct dst_entry
*dst
, struct rdma_dev_addr
*dev_addr
,
365 const struct sockaddr
*dst_in
, u32 seq
)
367 const struct sockaddr_in
*dst_in4
=
368 (const struct sockaddr_in
*)dst_in
;
369 const struct sockaddr_in6
*dst_in6
=
370 (const struct sockaddr_in6
*)dst_in
;
371 const void *daddr
= (dst_in
->sa_family
== AF_INET
) ?
372 (const void *)&dst_in4
->sin_addr
.s_addr
:
373 (const void *)&dst_in6
->sin6_addr
;
374 sa_family_t family
= dst_in
->sa_family
;
378 /* If we have a gateway in IB mode then it must be an IB network */
379 if (has_gateway(dst
, family
) && dev_addr
->network
== RDMA_NETWORK_IB
)
380 return ib_nl_fetch_ha(dev_addr
, daddr
, seq
, family
);
382 return dst_fetch_ha(dst
, dev_addr
, daddr
);
385 static int addr4_resolve(struct sockaddr
*src_sock
,
386 const struct sockaddr
*dst_sock
,
387 struct rdma_dev_addr
*addr
,
390 struct sockaddr_in
*src_in
= (struct sockaddr_in
*)src_sock
;
391 const struct sockaddr_in
*dst_in
=
392 (const struct sockaddr_in
*)dst_sock
;
394 __be32 src_ip
= src_in
->sin_addr
.s_addr
;
395 __be32 dst_ip
= dst_in
->sin_addr
.s_addr
;
400 memset(&fl4
, 0, sizeof(fl4
));
403 fl4
.flowi4_oif
= addr
->bound_dev_if
;
404 rt
= ip_route_output_key(addr
->net
, &fl4
);
405 ret
= PTR_ERR_OR_ZERO(rt
);
409 src_in
->sin_addr
.s_addr
= fl4
.saddr
;
411 addr
->hoplimit
= ip4_dst_hoplimit(&rt
->dst
);
417 #if IS_ENABLED(CONFIG_IPV6)
418 static int addr6_resolve(struct sockaddr
*src_sock
,
419 const struct sockaddr
*dst_sock
,
420 struct rdma_dev_addr
*addr
,
421 struct dst_entry
**pdst
)
423 struct sockaddr_in6
*src_in
= (struct sockaddr_in6
*)src_sock
;
424 const struct sockaddr_in6
*dst_in
=
425 (const struct sockaddr_in6
*)dst_sock
;
427 struct dst_entry
*dst
;
429 memset(&fl6
, 0, sizeof fl6
);
430 fl6
.daddr
= dst_in
->sin6_addr
;
431 fl6
.saddr
= src_in
->sin6_addr
;
432 fl6
.flowi6_oif
= addr
->bound_dev_if
;
434 dst
= ipv6_stub
->ipv6_dst_lookup_flow(addr
->net
, NULL
, &fl6
, NULL
);
438 if (ipv6_addr_any(&src_in
->sin6_addr
))
439 src_in
->sin6_addr
= fl6
.saddr
;
441 addr
->hoplimit
= ip6_dst_hoplimit(dst
);
447 static int addr6_resolve(struct sockaddr
*src_sock
,
448 const struct sockaddr
*dst_sock
,
449 struct rdma_dev_addr
*addr
,
450 struct dst_entry
**pdst
)
452 return -EADDRNOTAVAIL
;
456 static int addr_resolve_neigh(const struct dst_entry
*dst
,
457 const struct sockaddr
*dst_in
,
458 struct rdma_dev_addr
*addr
,
459 unsigned int ndev_flags
,
464 if (ndev_flags
& IFF_LOOPBACK
) {
465 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
, MAX_ADDR_LEN
);
467 if (!(ndev_flags
& IFF_NOARP
)) {
468 /* If the device doesn't do ARP internally */
469 ret
= fetch_ha(dst
, addr
, dst_in
, seq
);
475 static int copy_src_l2_addr(struct rdma_dev_addr
*dev_addr
,
476 const struct sockaddr
*dst_in
,
477 const struct dst_entry
*dst
,
478 const struct net_device
*ndev
)
482 if (dst
->dev
->flags
& IFF_LOOPBACK
)
483 ret
= rdma_translate_ip(dst_in
, dev_addr
);
485 rdma_copy_src_l2_addr(dev_addr
, dst
->dev
);
488 * If there's a gateway and type of device not ARPHRD_INFINIBAND,
489 * we're definitely in RoCE v2 (as RoCE v1 isn't routable) set the
490 * network type accordingly.
492 if (has_gateway(dst
, dst_in
->sa_family
) &&
493 ndev
->type
!= ARPHRD_INFINIBAND
)
494 dev_addr
->network
= dst_in
->sa_family
== AF_INET
?
498 dev_addr
->network
= RDMA_NETWORK_IB
;
503 static int rdma_set_src_addr_rcu(struct rdma_dev_addr
*dev_addr
,
504 unsigned int *ndev_flags
,
505 const struct sockaddr
*dst_in
,
506 const struct dst_entry
*dst
)
508 struct net_device
*ndev
= READ_ONCE(dst
->dev
);
510 *ndev_flags
= ndev
->flags
;
511 /* A physical device must be the RDMA device to use */
512 if (ndev
->flags
& IFF_LOOPBACK
) {
514 * RDMA (IB/RoCE, iWarp) doesn't run on lo interface or
515 * loopback IP address. So if route is resolved to loopback
516 * interface, translate that to a real ndev based on non
517 * loopback IP address.
519 ndev
= rdma_find_ndev_for_src_ip_rcu(dev_net(ndev
), dst_in
);
524 return copy_src_l2_addr(dev_addr
, dst_in
, dst
, ndev
);
527 static int set_addr_netns_by_gid_rcu(struct rdma_dev_addr
*addr
)
529 struct net_device
*ndev
;
531 ndev
= rdma_read_gid_attr_ndev_rcu(addr
->sgid_attr
);
533 return PTR_ERR(ndev
);
536 * Since we are holding the rcu, reading net and ifindex
537 * are safe without any additional reference; because
538 * change_net_namespace() in net/core/dev.c does rcu sync
539 * after it changes the state to IFF_DOWN and before
540 * updating netdev fields {net, ifindex}.
542 addr
->net
= dev_net(ndev
);
543 addr
->bound_dev_if
= ndev
->ifindex
;
547 static void rdma_addr_set_net_defaults(struct rdma_dev_addr
*addr
)
549 addr
->net
= &init_net
;
550 addr
->bound_dev_if
= 0;
553 static int addr_resolve(struct sockaddr
*src_in
,
554 const struct sockaddr
*dst_in
,
555 struct rdma_dev_addr
*addr
,
557 bool resolve_by_gid_attr
,
560 struct dst_entry
*dst
= NULL
;
561 unsigned int ndev_flags
= 0;
562 struct rtable
*rt
= NULL
;
566 pr_warn_ratelimited("%s: missing namespace\n", __func__
);
571 if (resolve_by_gid_attr
) {
572 if (!addr
->sgid_attr
) {
574 pr_warn_ratelimited("%s: missing gid_attr\n", __func__
);
578 * If the request is for a specific gid attribute of the
579 * rdma_dev_addr, derive net from the netdevice of the
582 ret
= set_addr_netns_by_gid_rcu(addr
);
588 if (src_in
->sa_family
== AF_INET
) {
589 ret
= addr4_resolve(src_in
, dst_in
, addr
, &rt
);
592 ret
= addr6_resolve(src_in
, dst_in
, addr
, &dst
);
598 ret
= rdma_set_src_addr_rcu(addr
, &ndev_flags
, dst_in
, dst
);
602 * Resolve neighbor destination address if requested and
603 * only if src addr translation didn't fail.
605 if (!ret
&& resolve_neigh
)
606 ret
= addr_resolve_neigh(dst
, dst_in
, addr
, ndev_flags
, seq
);
608 if (src_in
->sa_family
== AF_INET
)
614 * Clear the addr net to go back to its original state, only if it was
615 * derived from GID attribute in this context.
617 if (resolve_by_gid_attr
)
618 rdma_addr_set_net_defaults(addr
);
622 static void process_one_req(struct work_struct
*_work
)
624 struct addr_req
*req
;
625 struct sockaddr
*src_in
, *dst_in
;
627 req
= container_of(_work
, struct addr_req
, work
.work
);
629 if (req
->status
== -ENODATA
) {
630 src_in
= (struct sockaddr
*)&req
->src_addr
;
631 dst_in
= (struct sockaddr
*)&req
->dst_addr
;
632 req
->status
= addr_resolve(src_in
, dst_in
, req
->addr
,
633 true, req
->resolve_by_gid_attr
,
635 if (req
->status
&& time_after_eq(jiffies
, req
->timeout
)) {
636 req
->status
= -ETIMEDOUT
;
637 } else if (req
->status
== -ENODATA
) {
638 /* requeue the work for retrying again */
640 if (!list_empty(&req
->list
))
641 set_timeout(req
, req
->timeout
);
642 spin_unlock_bh(&lock
);
647 req
->callback(req
->status
, (struct sockaddr
*)&req
->src_addr
,
648 req
->addr
, req
->context
);
649 req
->callback
= NULL
;
653 * Although the work will normally have been canceled by the workqueue,
654 * it can still be requeued as long as it is on the req_list.
656 cancel_delayed_work(&req
->work
);
657 if (!list_empty(&req
->list
)) {
658 list_del_init(&req
->list
);
661 spin_unlock_bh(&lock
);
664 int rdma_resolve_ip(struct sockaddr
*src_addr
, const struct sockaddr
*dst_addr
,
665 struct rdma_dev_addr
*addr
, unsigned long timeout_ms
,
666 void (*callback
)(int status
, struct sockaddr
*src_addr
,
667 struct rdma_dev_addr
*addr
, void *context
),
668 bool resolve_by_gid_attr
, void *context
)
670 struct sockaddr
*src_in
, *dst_in
;
671 struct addr_req
*req
;
674 req
= kzalloc(sizeof *req
, GFP_KERNEL
);
678 src_in
= (struct sockaddr
*) &req
->src_addr
;
679 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
682 if (src_addr
->sa_family
!= dst_addr
->sa_family
) {
687 memcpy(src_in
, src_addr
, rdma_addr_size(src_addr
));
689 src_in
->sa_family
= dst_addr
->sa_family
;
692 memcpy(dst_in
, dst_addr
, rdma_addr_size(dst_addr
));
694 req
->callback
= callback
;
695 req
->context
= context
;
696 req
->resolve_by_gid_attr
= resolve_by_gid_attr
;
697 INIT_DELAYED_WORK(&req
->work
, process_one_req
);
698 req
->seq
= (u32
)atomic_inc_return(&ib_nl_addr_request_seq
);
700 req
->status
= addr_resolve(src_in
, dst_in
, addr
, true,
701 req
->resolve_by_gid_attr
, req
->seq
);
702 switch (req
->status
) {
704 req
->timeout
= jiffies
;
708 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
720 EXPORT_SYMBOL(rdma_resolve_ip
);
722 int roce_resolve_route_from_path(struct sa_path_rec
*rec
,
723 const struct ib_gid_attr
*attr
)
726 struct sockaddr _sockaddr
;
727 struct sockaddr_in _sockaddr_in
;
728 struct sockaddr_in6 _sockaddr_in6
;
730 struct rdma_dev_addr dev_addr
= {};
735 if (rec
->roce
.route_resolved
)
738 rdma_gid2ip((struct sockaddr
*)&sgid
, &rec
->sgid
);
739 rdma_gid2ip((struct sockaddr
*)&dgid
, &rec
->dgid
);
741 if (sgid
._sockaddr
.sa_family
!= dgid
._sockaddr
.sa_family
)
744 if (!attr
|| !attr
->ndev
)
747 dev_addr
.net
= &init_net
;
748 dev_addr
.sgid_attr
= attr
;
750 ret
= addr_resolve((struct sockaddr
*)&sgid
, (struct sockaddr
*)&dgid
,
751 &dev_addr
, false, true, 0);
755 if ((dev_addr
.network
== RDMA_NETWORK_IPV4
||
756 dev_addr
.network
== RDMA_NETWORK_IPV6
) &&
757 rec
->rec_type
!= SA_PATH_REC_TYPE_ROCE_V2
)
760 rec
->roce
.route_resolved
= true;
765 * rdma_addr_cancel - Cancel resolve ip request
766 * @addr: Pointer to address structure given previously
767 * during rdma_resolve_ip().
768 * rdma_addr_cancel() is synchronous function which cancels any pending
769 * request if there is any.
771 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
773 struct addr_req
*req
, *temp_req
;
774 struct addr_req
*found
= NULL
;
777 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
778 if (req
->addr
== addr
) {
780 * Removing from the list means we take ownership of
783 list_del_init(&req
->list
);
788 spin_unlock_bh(&lock
);
794 * sync canceling the work after removing it from the req_list
795 * guarentees no work is running and none will be started.
797 cancel_delayed_work_sync(&found
->work
);
800 EXPORT_SYMBOL(rdma_addr_cancel
);
802 struct resolve_cb_context
{
803 struct completion comp
;
807 static void resolve_cb(int status
, struct sockaddr
*src_addr
,
808 struct rdma_dev_addr
*addr
, void *context
)
810 ((struct resolve_cb_context
*)context
)->status
= status
;
811 complete(&((struct resolve_cb_context
*)context
)->comp
);
814 int rdma_addr_find_l2_eth_by_grh(const union ib_gid
*sgid
,
815 const union ib_gid
*dgid
,
816 u8
*dmac
, const struct ib_gid_attr
*sgid_attr
,
819 struct rdma_dev_addr dev_addr
;
820 struct resolve_cb_context ctx
;
822 struct sockaddr_in _sockaddr_in
;
823 struct sockaddr_in6 _sockaddr_in6
;
824 } sgid_addr
, dgid_addr
;
827 rdma_gid2ip((struct sockaddr
*)&sgid_addr
, sgid
);
828 rdma_gid2ip((struct sockaddr
*)&dgid_addr
, dgid
);
830 memset(&dev_addr
, 0, sizeof(dev_addr
));
831 dev_addr
.net
= &init_net
;
832 dev_addr
.sgid_attr
= sgid_attr
;
834 init_completion(&ctx
.comp
);
835 ret
= rdma_resolve_ip((struct sockaddr
*)&sgid_addr
,
836 (struct sockaddr
*)&dgid_addr
, &dev_addr
, 1000,
837 resolve_cb
, true, &ctx
);
841 wait_for_completion(&ctx
.comp
);
847 memcpy(dmac
, dev_addr
.dst_dev_addr
, ETH_ALEN
);
848 *hoplimit
= dev_addr
.hoplimit
;
852 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
855 struct addr_req
*req
;
857 if (event
== NETEVENT_NEIGH_UPDATE
) {
858 struct neighbour
*neigh
= ctx
;
860 if (neigh
->nud_state
& NUD_VALID
) {
862 list_for_each_entry(req
, &req_list
, list
)
863 set_timeout(req
, jiffies
);
864 spin_unlock_bh(&lock
);
870 static struct notifier_block nb
= {
871 .notifier_call
= netevent_callback
876 addr_wq
= alloc_ordered_workqueue("ib_addr", 0);
880 register_netevent_notifier(&nb
);
885 void addr_cleanup(void)
887 unregister_netevent_notifier(&nb
);
888 destroy_workqueue(addr_wq
);
889 WARN_ON(!list_empty(&req_list
));