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(&src_in
->sin6_addr
)) {
453 src_in
->sin6_family
= AF_INET6
;
454 src_in
->sin6_addr
= fl6
.saddr
;
457 /* If there's a gateway and type of device not ARPHRD_INFINIBAND, we're
458 * definitely in RoCE v2 (as RoCE v1 isn't routable) set the network
461 if (rt
->rt6i_flags
& RTF_GATEWAY
&&
462 ip6_dst_idev(dst
)->dev
->type
!= ARPHRD_INFINIBAND
)
463 addr
->network
= RDMA_NETWORK_IPV6
;
465 addr
->hoplimit
= ip6_dst_hoplimit(dst
);
471 static int addr6_resolve(struct sockaddr_in6
*src_in
,
472 const struct sockaddr_in6
*dst_in
,
473 struct rdma_dev_addr
*addr
,
474 struct dst_entry
**pdst
)
476 return -EADDRNOTAVAIL
;
480 static int addr_resolve_neigh(struct dst_entry
*dst
,
481 const struct sockaddr
*dst_in
,
482 struct rdma_dev_addr
*addr
,
485 if (dst
->dev
->flags
& IFF_LOOPBACK
) {
488 ret
= rdma_translate_ip(dst_in
, addr
, NULL
);
490 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
,
496 /* If the device doesn't do ARP internally */
497 if (!(dst
->dev
->flags
& IFF_NOARP
))
498 return fetch_ha(dst
, addr
, dst_in
, seq
);
500 return rdma_copy_addr(addr
, dst
->dev
, NULL
);
503 static int addr_resolve(struct sockaddr
*src_in
,
504 const struct sockaddr
*dst_in
,
505 struct rdma_dev_addr
*addr
,
509 struct net_device
*ndev
;
510 struct dst_entry
*dst
;
513 if (src_in
->sa_family
== AF_INET
) {
514 struct rtable
*rt
= NULL
;
515 const struct sockaddr_in
*dst_in4
=
516 (const struct sockaddr_in
*)dst_in
;
518 ret
= addr4_resolve((struct sockaddr_in
*)src_in
,
524 ret
= addr_resolve_neigh(&rt
->dst
, dst_in
, addr
, seq
);
531 const struct sockaddr_in6
*dst_in6
=
532 (const struct sockaddr_in6
*)dst_in
;
534 ret
= addr6_resolve((struct sockaddr_in6
*)src_in
,
541 ret
= addr_resolve_neigh(dst
, dst_in
, addr
, seq
);
549 addr
->bound_dev_if
= ndev
->ifindex
;
550 addr
->net
= dev_net(ndev
);
556 static void process_req(struct work_struct
*work
)
558 struct addr_req
*req
, *temp_req
;
559 struct sockaddr
*src_in
, *dst_in
;
560 struct list_head done_list
;
562 INIT_LIST_HEAD(&done_list
);
565 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
566 if (req
->status
== -ENODATA
) {
567 src_in
= (struct sockaddr
*) &req
->src_addr
;
568 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
569 req
->status
= addr_resolve(src_in
, dst_in
, req
->addr
,
571 if (req
->status
&& time_after_eq(jiffies
, req
->timeout
))
572 req
->status
= -ETIMEDOUT
;
573 else if (req
->status
== -ENODATA
)
576 list_move_tail(&req
->list
, &done_list
);
579 if (!list_empty(&req_list
)) {
580 req
= list_entry(req_list
.next
, struct addr_req
, list
);
581 set_timeout(req
->timeout
);
585 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
586 list_del(&req
->list
);
587 req
->callback(req
->status
, (struct sockaddr
*) &req
->src_addr
,
588 req
->addr
, req
->context
);
589 put_client(req
->client
);
594 int rdma_resolve_ip(struct rdma_addr_client
*client
,
595 struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
596 struct rdma_dev_addr
*addr
, int timeout_ms
,
597 void (*callback
)(int status
, struct sockaddr
*src_addr
,
598 struct rdma_dev_addr
*addr
, void *context
),
601 struct sockaddr
*src_in
, *dst_in
;
602 struct addr_req
*req
;
605 req
= kzalloc(sizeof *req
, GFP_KERNEL
);
609 src_in
= (struct sockaddr
*) &req
->src_addr
;
610 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
613 if (src_addr
->sa_family
!= dst_addr
->sa_family
) {
618 memcpy(src_in
, src_addr
, rdma_addr_size(src_addr
));
620 src_in
->sa_family
= dst_addr
->sa_family
;
623 memcpy(dst_in
, dst_addr
, rdma_addr_size(dst_addr
));
625 req
->callback
= callback
;
626 req
->context
= context
;
627 req
->client
= client
;
628 atomic_inc(&client
->refcount
);
629 req
->seq
= (u32
)atomic_inc_return(&ib_nl_addr_request_seq
);
631 req
->status
= addr_resolve(src_in
, dst_in
, addr
, true, req
->seq
);
632 switch (req
->status
) {
634 req
->timeout
= jiffies
;
638 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
643 atomic_dec(&client
->refcount
);
651 EXPORT_SYMBOL(rdma_resolve_ip
);
653 int rdma_resolve_ip_route(struct sockaddr
*src_addr
,
654 const struct sockaddr
*dst_addr
,
655 struct rdma_dev_addr
*addr
)
657 struct sockaddr_storage ssrc_addr
= {};
658 struct sockaddr
*src_in
= (struct sockaddr
*)&ssrc_addr
;
661 if (src_addr
->sa_family
!= dst_addr
->sa_family
)
664 memcpy(src_in
, src_addr
, rdma_addr_size(src_addr
));
666 src_in
->sa_family
= dst_addr
->sa_family
;
669 return addr_resolve(src_in
, dst_addr
, addr
, false, 0);
671 EXPORT_SYMBOL(rdma_resolve_ip_route
);
673 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
675 struct addr_req
*req
, *temp_req
;
678 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
679 if (req
->addr
== addr
) {
680 req
->status
= -ECANCELED
;
681 req
->timeout
= jiffies
;
682 list_move(&req
->list
, &req_list
);
683 set_timeout(req
->timeout
);
689 EXPORT_SYMBOL(rdma_addr_cancel
);
691 struct resolve_cb_context
{
692 struct rdma_dev_addr
*addr
;
693 struct completion comp
;
697 static void resolve_cb(int status
, struct sockaddr
*src_addr
,
698 struct rdma_dev_addr
*addr
, void *context
)
701 memcpy(((struct resolve_cb_context
*)context
)->addr
,
702 addr
, sizeof(struct rdma_dev_addr
));
703 ((struct resolve_cb_context
*)context
)->status
= status
;
704 complete(&((struct resolve_cb_context
*)context
)->comp
);
707 int rdma_addr_find_l2_eth_by_grh(const union ib_gid
*sgid
,
708 const union ib_gid
*dgid
,
709 u8
*dmac
, u16
*vlan_id
, int *if_index
,
713 struct rdma_dev_addr dev_addr
;
714 struct resolve_cb_context ctx
;
715 struct net_device
*dev
;
718 struct sockaddr _sockaddr
;
719 struct sockaddr_in _sockaddr_in
;
720 struct sockaddr_in6 _sockaddr_in6
;
721 } sgid_addr
, dgid_addr
;
724 rdma_gid2ip(&sgid_addr
._sockaddr
, sgid
);
725 rdma_gid2ip(&dgid_addr
._sockaddr
, dgid
);
727 memset(&dev_addr
, 0, sizeof(dev_addr
));
729 dev_addr
.bound_dev_if
= *if_index
;
730 dev_addr
.net
= &init_net
;
732 ctx
.addr
= &dev_addr
;
733 init_completion(&ctx
.comp
);
734 ret
= rdma_resolve_ip(&self
, &sgid_addr
._sockaddr
, &dgid_addr
._sockaddr
,
735 &dev_addr
, 1000, resolve_cb
, &ctx
);
739 wait_for_completion(&ctx
.comp
);
745 memcpy(dmac
, dev_addr
.dst_dev_addr
, ETH_ALEN
);
746 dev
= dev_get_by_index(&init_net
, dev_addr
.bound_dev_if
);
750 *if_index
= dev_addr
.bound_dev_if
;
752 *vlan_id
= rdma_vlan_dev_vlan_id(dev
);
754 *hoplimit
= dev_addr
.hoplimit
;
758 EXPORT_SYMBOL(rdma_addr_find_l2_eth_by_grh
);
760 int rdma_addr_find_smac_by_sgid(union ib_gid
*sgid
, u8
*smac
, u16
*vlan_id
)
763 struct rdma_dev_addr dev_addr
;
765 struct sockaddr _sockaddr
;
766 struct sockaddr_in _sockaddr_in
;
767 struct sockaddr_in6 _sockaddr_in6
;
770 rdma_gid2ip(&gid_addr
._sockaddr
, sgid
);
772 memset(&dev_addr
, 0, sizeof(dev_addr
));
773 dev_addr
.net
= &init_net
;
774 ret
= rdma_translate_ip(&gid_addr
._sockaddr
, &dev_addr
, vlan_id
);
778 memcpy(smac
, dev_addr
.src_dev_addr
, ETH_ALEN
);
781 EXPORT_SYMBOL(rdma_addr_find_smac_by_sgid
);
783 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
786 if (event
== NETEVENT_NEIGH_UPDATE
) {
787 struct neighbour
*neigh
= ctx
;
789 if (neigh
->nud_state
& NUD_VALID
) {
790 set_timeout(jiffies
);
796 static struct notifier_block nb
= {
797 .notifier_call
= netevent_callback
802 addr_wq
= alloc_workqueue("ib_addr", WQ_MEM_RECLAIM
, 0);
806 register_netevent_notifier(&nb
);
807 rdma_addr_register_client(&self
);
812 void addr_cleanup(void)
814 rdma_addr_unregister_client(&self
);
815 unregister_netevent_notifier(&nb
);
816 destroy_workqueue(addr_wq
);