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 licensed under one of the following licenses:
9 * 1) under the terms of the "Common Public License 1.0" a copy of which is
10 * available from the Open Source Initiative, see
11 * http://www.opensource.org/licenses/cpl.php.
13 * 2) under the terms of the "The BSD License" a copy of which is
14 * available from the Open Source Initiative, see
15 * http://www.opensource.org/licenses/bsd-license.php.
17 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
18 * copy of which is available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
21 * Licensee has the right to choose one of the above licenses.
23 * Redistributions of source code must retain the above copyright
24 * notice and one of the license notices.
26 * Redistributions in binary form must reproduce both the above copyright
27 * notice, one of the license notices in the documentation
28 * and/or other materials provided with the distribution.
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
35 #include <sys/param.h>
36 #include <sys/condvar.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/socket.h>
40 #include <sys/module.h>
43 #include <sys/condvar.h>
44 #include <sys/mutex.h>
45 #include <sys/rwlock.h>
46 #include <sys/queue.h>
47 #include <sys/taskqueue.h>
50 #include <net/if_dl.h>
51 #include <net/if_var.h>
52 #include <net/if_arp.h>
53 #include <net/route.h>
55 #include <net80211/ieee80211_freebsd.h>
57 #include <netinet/in.h>
58 #include <netinet/if_ether.h>
60 #include <contrib/rdma/ib_addr.h>
63 TAILQ_ENTRY(addr_req) entry;
64 struct sockaddr src_addr;
65 struct sockaddr dst_addr;
66 struct rdma_dev_addr *addr;
67 struct rdma_addr_client *client;
69 void (*callback)(int status, struct sockaddr *src_addr,
70 struct rdma_dev_addr *addr, void *context);
71 unsigned long timeout;
75 static void process_req(void *ctx, int pending);
77 static struct mtx lock;
79 static TAILQ_HEAD(addr_req_list, addr_req) req_list;
80 static struct task addr_task;
81 static struct taskqueue *addr_taskq;
82 static struct callout addr_ch;
83 static eventhandler_tag route_event_tag;
85 static void addr_timeout(void *arg)
87 taskqueue_enqueue(addr_taskq, &addr_task);
90 void rdma_addr_register_client(struct rdma_addr_client *client)
92 mtx_init(&client->lock, "rdma_addr client lock", NULL, MTX_DUPOK|MTX_DEF);
93 cv_init(&client->comp, "rdma_addr cv");
97 static inline void put_client(struct rdma_addr_client *client)
99 mtx_lock(&client->lock);
100 if (--client->refcount == 0) {
101 cv_broadcast(&client->comp);
103 mtx_unlock(&client->lock);
106 void rdma_addr_unregister_client(struct rdma_addr_client *client)
109 mtx_lock(&client->lock);
110 if (client->refcount) {
111 cv_wait(&client->comp, &client->lock);
113 mtx_unlock(&client->lock);
116 int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct ifnet *dev,
117 const unsigned char *dst_dev_addr)
119 dev_addr->dev_type = RDMA_NODE_RNIC;
120 memcpy(dev_addr->src_dev_addr, IF_LLADDR(dev), MAX_ADDR_LEN);
121 memcpy(dev_addr->broadcast, dev->if_broadcastaddr, MAX_ADDR_LEN);
123 memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
127 int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
130 struct sockaddr_in *sin = (struct sockaddr_in *)addr;
131 uint16_t port = sin->sin_port;
134 ifa = ifa_ifwithaddr(addr);
135 sin->sin_port = port;
137 return (EADDRNOTAVAIL);
138 return rdma_copy_addr(dev_addr, ifa->ifa_ifp, NULL);
141 static void queue_req(struct addr_req *req)
143 struct addr_req *tmp_req = NULL;
146 TAILQ_FOREACH_REVERSE(tmp_req, &req_list, addr_req_list, entry)
147 if (time_after_eq(req->timeout, tmp_req->timeout))
151 TAILQ_INSERT_AFTER(&req_list, tmp_req, req, entry);
153 TAILQ_INSERT_TAIL(&req_list, req, entry);
155 if (TAILQ_FIRST(&req_list) == req)
156 callout_reset(&addr_ch, req->timeout - ticks, addr_timeout, NULL);
161 static void addr_send_arp(struct sockaddr_in *dst_in)
163 struct route iproute;
164 struct sockaddr_in *dst = (struct sockaddr_in *)&iproute.ro_dst;
165 char dmac[ETHER_ADDR_LEN];
167 bzero(&iproute, sizeof iproute);
171 if (iproute.ro_rt == NULL);
174 arpresolve(iproute.ro_rt->rt_ifp, iproute.ro_rt, NULL,
175 rt_key(iproute.ro_rt), dmac);
177 RTFREE(iproute.ro_rt);
181 static int addr_resolve_remote(struct sockaddr_in *src_in,
182 struct sockaddr_in *dst_in,
183 struct rdma_dev_addr *addr)
186 struct route iproute;
187 struct sockaddr_in *dst = (struct sockaddr_in *)&iproute.ro_dst;
188 char dmac[ETHER_ADDR_LEN];
190 bzero(&iproute, sizeof iproute);
194 if (iproute.ro_rt == NULL) {
199 /* If the device does ARP internally, return 'done' */
200 if (iproute.ro_rt->rt_ifp->if_flags & IFF_NOARP) {
201 rdma_copy_addr(addr, iproute.ro_rt->rt_ifp, NULL);
204 ret = arpresolve(iproute.ro_rt->rt_ifp, iproute.ro_rt, NULL,
205 rt_key(iproute.ro_rt), dmac);
210 if (!src_in->sin_addr.s_addr) {
211 src_in->sin_len = sizeof *src_in;
212 src_in->sin_family = dst_in->sin_family;
213 src_in->sin_addr.s_addr = ((struct sockaddr_in *)iproute.ro_rt->rt_ifa->ifa_addr)->sin_addr.s_addr;
216 ret = rdma_copy_addr(addr, iproute.ro_rt->rt_ifp, dmac);
218 RTFREE(iproute.ro_rt);
223 static void process_req(void *ctx, int pending)
225 struct addr_req *req, *tmp_req;
226 struct sockaddr_in *src_in, *dst_in;
227 TAILQ_HEAD(, addr_req) done_list;
229 TAILQ_INIT(&done_list);
232 TAILQ_FOREACH_SAFE(req, &req_list, entry, tmp_req) {
233 if (req->status == EWOULDBLOCK) {
234 src_in = (struct sockaddr_in *) &req->src_addr;
235 dst_in = (struct sockaddr_in *) &req->dst_addr;
236 req->status = addr_resolve_remote(src_in, dst_in,
238 if (req->status && time_after_eq(ticks, req->timeout))
239 req->status = ETIMEDOUT;
240 else if (req->status == EWOULDBLOCK)
243 TAILQ_REMOVE(&req_list, req, entry);
244 TAILQ_INSERT_TAIL(&done_list, req, entry);
247 if (!TAILQ_EMPTY(&req_list)) {
248 req = TAILQ_FIRST(&req_list);
249 callout_reset(&addr_ch, req->timeout - ticks, addr_timeout,
254 TAILQ_FOREACH_SAFE(req, &done_list, entry, tmp_req) {
255 TAILQ_REMOVE(&done_list, req, entry);
256 req->callback(req->status, &req->src_addr, req->addr,
258 put_client(req->client);
263 int rdma_resolve_ip(struct rdma_addr_client *client,
264 struct sockaddr *src_addr, struct sockaddr *dst_addr,
265 struct rdma_dev_addr *addr, int timeout_ms,
266 void (*callback)(int status, struct sockaddr *src_addr,
267 struct rdma_dev_addr *addr, void *context),
270 struct sockaddr_in *src_in, *dst_in;
271 struct addr_req *req;
274 req = malloc(sizeof *req, M_DEVBUF, M_NOWAIT);
277 memset(req, 0, sizeof *req);
280 memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
281 memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
283 req->callback = callback;
284 req->context = context;
285 req->client = client;
286 mtx_lock(&client->lock);
288 mtx_unlock(&client->lock);
290 src_in = (struct sockaddr_in *) &req->src_addr;
291 dst_in = (struct sockaddr_in *) &req->dst_addr;
293 req->status = addr_resolve_remote(src_in, dst_in, addr);
295 switch (req->status) {
297 req->timeout = ticks;
301 req->timeout = msecs_to_ticks(timeout_ms) + ticks;
304 addr_send_arp(dst_in);
309 mtx_lock(&client->lock);
311 mtx_unlock(&client->lock);
318 void rdma_addr_cancel(struct rdma_dev_addr *addr)
320 struct addr_req *req, *tmp_req;
323 TAILQ_FOREACH_SAFE(req, &req_list, entry, tmp_req) {
324 if (req->addr == addr) {
325 req->status = ECANCELED;
326 req->timeout = ticks;
327 TAILQ_REMOVE(&req_list, req, entry);
328 TAILQ_INSERT_HEAD(&req_list, req, entry);
329 callout_reset(&addr_ch, req->timeout - ticks, addr_timeout, NULL);
337 route_event_arp_update(void *unused, struct rtentry *rt0, uint8_t *enaddr,
340 callout_stop(&addr_ch);
341 taskqueue_enqueue(addr_taskq, &addr_task);
344 static int addr_init(void)
346 TAILQ_INIT(&req_list);
347 mtx_init(&lock, "rdma_addr req_list lock", NULL, MTX_DEF);
349 addr_taskq = taskqueue_create("rdma_addr_taskq", M_NOWAIT,
350 taskqueue_thread_enqueue, &addr_taskq);
351 if (addr_taskq == NULL) {
352 printf("failed to allocate rdma_addr taskqueue\n");
355 taskqueue_start_threads(&addr_taskq, 1, PI_NET, "rdma_addr taskq");
356 TASK_INIT(&addr_task, 0, process_req, NULL);
358 callout_init(&addr_ch, TRUE);
360 route_event_tag = EVENTHANDLER_REGISTER(route_arp_update_event,
361 route_event_arp_update, NULL, EVENTHANDLER_PRI_ANY);
366 static void addr_cleanup(void)
368 EVENTHANDLER_DEREGISTER(route_event_arp_update, route_event_tag);
369 callout_stop(&addr_ch);
370 taskqueue_drain(addr_taskq, &addr_task);
371 taskqueue_free(addr_taskq);
375 addr_load(module_t mod, int cmd, void *arg)
381 printf("Loading rdma_addr.\n");
388 printf("Unloading rdma_addr.\n");
401 static moduledata_t mod_data = {
407 MODULE_VERSION(rdma_addr, 1);
408 DECLARE_MODULE(rdma_addr, mod_data, SI_SUB_EXEC, SI_ORDER_ANY);