1// SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
2/*
3 * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
4 * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
5 */
6
7#include <linux/skbuff.h>
8#include <linux/if_arp.h>
9#include <linux/netdevice.h>
10#include <linux/if.h>
11#include <linux/if_vlan.h>
12#include <net/udp_tunnel.h>
13#include <net/sch_generic.h>
14#include <linux/netfilter.h>
15#include <rdma/ib_addr.h>
16
17#include "rxe.h"
18#include "rxe_net.h"
19#include "rxe_loc.h"
20
21static struct rxe_recv_sockets recv_sockets;
22
23int rxe_mcast_add(struct rxe_dev *rxe, union ib_gid *mgid)
24{
25	int err;
26	unsigned char ll_addr[ETH_ALEN];
27
28	ipv6_eth_mc_map((struct in6_addr *)mgid->raw, ll_addr);
29	err = dev_mc_add(rxe->ndev, ll_addr);
30
31	return err;
32}
33
34int rxe_mcast_delete(struct rxe_dev *rxe, union ib_gid *mgid)
35{
36	int err;
37	unsigned char ll_addr[ETH_ALEN];
38
39	ipv6_eth_mc_map((struct in6_addr *)mgid->raw, ll_addr);
40	err = dev_mc_del(rxe->ndev, ll_addr);
41
42	return err;
43}
44
45static struct dst_entry *rxe_find_route4(struct net_device *ndev,
46				  struct in_addr *saddr,
47				  struct in_addr *daddr)
48{
49	struct rtable *rt;
50	struct flowi4 fl = { { 0 } };
51
52	memset(&fl, 0, sizeof(fl));
53	fl.flowi4_oif = ndev->ifindex;
54	memcpy(&fl.saddr, saddr, sizeof(*saddr));
55	memcpy(&fl.daddr, daddr, sizeof(*daddr));
56	fl.flowi4_proto = IPPROTO_UDP;
57
58	rt = ip_route_output_key(&init_net, &fl);
59	if (IS_ERR(rt)) {
60		pr_err_ratelimited("no route to %pI4\n", &daddr->s_addr);
61		return NULL;
62	}
63
64	return &rt->dst;
65}
66
67#if IS_ENABLED(CONFIG_IPV6)
68static struct dst_entry *rxe_find_route6(struct net_device *ndev,
69					 struct in6_addr *saddr,
70					 struct in6_addr *daddr)
71{
72	struct dst_entry *ndst;
73	struct flowi6 fl6 = { { 0 } };
74
75	memset(&fl6, 0, sizeof(fl6));
76	fl6.flowi6_oif = ndev->ifindex;
77	memcpy(&fl6.saddr, saddr, sizeof(*saddr));
78	memcpy(&fl6.daddr, daddr, sizeof(*daddr));
79	fl6.flowi6_proto = IPPROTO_UDP;
80
81	ndst = ipv6_stub->ipv6_dst_lookup_flow(sock_net(recv_sockets.sk6->sk),
82					       recv_sockets.sk6->sk, &fl6,
83					       NULL);
84	if (IS_ERR(ndst)) {
85		pr_err_ratelimited("no route to %pI6\n", daddr);
86		return NULL;
87	}
88
89	if (unlikely(ndst->error)) {
90		pr_err("no route to %pI6\n", daddr);
91		goto put;
92	}
93
94	return ndst;
95put:
96	dst_release(ndst);
97	return NULL;
98}
99
100#else
101
102static struct dst_entry *rxe_find_route6(struct net_device *ndev,
103					 struct in6_addr *saddr,
104					 struct in6_addr *daddr)
105{
106	return NULL;
107}
108
109#endif
110
111static struct dst_entry *rxe_find_route(struct net_device *ndev,
112					struct rxe_qp *qp,
113					struct rxe_av *av)
114{
115	struct dst_entry *dst = NULL;
116
117	if (qp_type(qp) == IB_QPT_RC)
118		dst = sk_dst_get(qp->sk->sk);
119
120	if (!dst || !dst_check(dst, qp->dst_cookie)) {
121		if (dst)
122			dst_release(dst);
123
124		if (av->network_type == RXE_NETWORK_TYPE_IPV4) {
125			struct in_addr *saddr;
126			struct in_addr *daddr;
127
128			saddr = &av->sgid_addr._sockaddr_in.sin_addr;
129			daddr = &av->dgid_addr._sockaddr_in.sin_addr;
130			dst = rxe_find_route4(ndev, saddr, daddr);
131		} else if (av->network_type == RXE_NETWORK_TYPE_IPV6) {
132			struct in6_addr *saddr6;
133			struct in6_addr *daddr6;
134
135			saddr6 = &av->sgid_addr._sockaddr_in6.sin6_addr;
136			daddr6 = &av->dgid_addr._sockaddr_in6.sin6_addr;
137			dst = rxe_find_route6(ndev, saddr6, daddr6);
138#if IS_ENABLED(CONFIG_IPV6)
139			if (dst)
140				qp->dst_cookie =
141					rt6_get_cookie((struct rt6_info *)dst);
142#endif
143		}
144
145		if (dst && (qp_type(qp) == IB_QPT_RC)) {
146			dst_hold(dst);
147			sk_dst_set(qp->sk->sk, dst);
148		}
149	}
150	return dst;
151}
152
153static int rxe_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
154{
155	struct udphdr *udph;
156	struct net_device *ndev = skb->dev;
157	struct net_device *rdev = ndev;
158	struct rxe_dev *rxe = rxe_get_dev_from_net(ndev);
159	struct rxe_pkt_info *pkt = SKB_TO_PKT(skb);
160
161	if (!rxe && is_vlan_dev(rdev)) {
162		rdev = vlan_dev_real_dev(ndev);
163		rxe = rxe_get_dev_from_net(rdev);
164	}
165	if (!rxe)
166		goto drop;
167
168	if (skb_linearize(skb)) {
169		pr_err("skb_linearize failed\n");
170		ib_device_put(&rxe->ib_dev);
171		goto drop;
172	}
173
174	udph = udp_hdr(skb);
175	pkt->rxe = rxe;
176	pkt->port_num = 1;
177	pkt->hdr = (u8 *)(udph + 1);
178	pkt->mask = RXE_GRH_MASK;
179	pkt->paylen = be16_to_cpu(udph->len) - sizeof(*udph);
180
181	rxe_rcv(skb);
182
183	/*
184	 * FIXME: this is in the wrong place, it needs to be done when pkt is
185	 * destroyed
186	 */
187	ib_device_put(&rxe->ib_dev);
188
189	return 0;
190drop:
191	kfree_skb(skb);
192
193	return 0;
194}
195
196static struct socket *rxe_setup_udp_tunnel(struct net *net, __be16 port,
197					   bool ipv6)
198{
199	int err;
200	struct socket *sock;
201	struct udp_port_cfg udp_cfg = { };
202	struct udp_tunnel_sock_cfg tnl_cfg = { };
203
204	if (ipv6) {
205		udp_cfg.family = AF_INET6;
206		udp_cfg.ipv6_v6only = 1;
207	} else {
208		udp_cfg.family = AF_INET;
209	}
210
211	udp_cfg.local_udp_port = port;
212
213	/* Create UDP socket */
214	err = udp_sock_create(net, &udp_cfg, &sock);
215	if (err < 0)
216		return ERR_PTR(err);
217
218	tnl_cfg.encap_type = 1;
219	tnl_cfg.encap_rcv = rxe_udp_encap_recv;
220
221	/* Setup UDP tunnel */
222	setup_udp_tunnel_sock(net, sock, &tnl_cfg);
223
224	return sock;
225}
226
227static void rxe_release_udp_tunnel(struct socket *sk)
228{
229	if (sk)
230		udp_tunnel_sock_release(sk);
231}
232
233static void prepare_udp_hdr(struct sk_buff *skb, __be16 src_port,
234			    __be16 dst_port)
235{
236	struct udphdr *udph;
237
238	__skb_push(skb, sizeof(*udph));
239	skb_reset_transport_header(skb);
240	udph = udp_hdr(skb);
241
242	udph->dest = dst_port;
243	udph->source = src_port;
244	udph->len = htons(skb->len);
245	udph->check = 0;
246}
247
248static void prepare_ipv4_hdr(struct dst_entry *dst, struct sk_buff *skb,
249			     __be32 saddr, __be32 daddr, __u8 proto,
250			     __u8 tos, __u8 ttl, __be16 df, bool xnet)
251{
252	struct iphdr *iph;
253
254	skb_scrub_packet(skb, xnet);
255
256	skb_clear_hash(skb);
257	skb_dst_set(skb, dst_clone(dst));
258	memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
259
260	skb_push(skb, sizeof(struct iphdr));
261	skb_reset_network_header(skb);
262
263	iph = ip_hdr(skb);
264
265	iph->version	=	IPVERSION;
266	iph->ihl	=	sizeof(struct iphdr) >> 2;
267	iph->frag_off	=	df;
268	iph->protocol	=	proto;
269	iph->tos	=	tos;
270	iph->daddr	=	daddr;
271	iph->saddr	=	saddr;
272	iph->ttl	=	ttl;
273	__ip_select_ident(dev_net(dst->dev), iph,
274			  skb_shinfo(skb)->gso_segs ?: 1);
275	iph->tot_len = htons(skb->len);
276	ip_send_check(iph);
277}
278
279static void prepare_ipv6_hdr(struct dst_entry *dst, struct sk_buff *skb,
280			     struct in6_addr *saddr, struct in6_addr *daddr,
281			     __u8 proto, __u8 prio, __u8 ttl)
282{
283	struct ipv6hdr *ip6h;
284
285	memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
286	IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED
287			    | IPSKB_REROUTED);
288	skb_dst_set(skb, dst_clone(dst));
289
290	__skb_push(skb, sizeof(*ip6h));
291	skb_reset_network_header(skb);
292	ip6h		  = ipv6_hdr(skb);
293	ip6_flow_hdr(ip6h, prio, htonl(0));
294	ip6h->payload_len = htons(skb->len);
295	ip6h->nexthdr     = proto;
296	ip6h->hop_limit   = ttl;
297	ip6h->daddr	  = *daddr;
298	ip6h->saddr	  = *saddr;
299	ip6h->payload_len = htons(skb->len - sizeof(*ip6h));
300}
301
302static int prepare4(struct rxe_pkt_info *pkt, struct sk_buff *skb)
303{
304	struct rxe_qp *qp = pkt->qp;
305	struct dst_entry *dst;
306	bool xnet = false;
307	__be16 df = htons(IP_DF);
308	struct rxe_av *av = rxe_get_av(pkt);
309	struct in_addr *saddr = &av->sgid_addr._sockaddr_in.sin_addr;
310	struct in_addr *daddr = &av->dgid_addr._sockaddr_in.sin_addr;
311
312	dst = rxe_find_route(skb->dev, qp, av);
313	if (!dst) {
314		pr_err("Host not reachable\n");
315		return -EHOSTUNREACH;
316	}
317
318	prepare_udp_hdr(skb, cpu_to_be16(qp->src_port),
319			cpu_to_be16(ROCE_V2_UDP_DPORT));
320
321	prepare_ipv4_hdr(dst, skb, saddr->s_addr, daddr->s_addr, IPPROTO_UDP,
322			 av->grh.traffic_class, av->grh.hop_limit, df, xnet);
323
324	dst_release(dst);
325	return 0;
326}
327
328static int prepare6(struct rxe_pkt_info *pkt, struct sk_buff *skb)
329{
330	struct rxe_qp *qp = pkt->qp;
331	struct dst_entry *dst;
332	struct rxe_av *av = rxe_get_av(pkt);
333	struct in6_addr *saddr = &av->sgid_addr._sockaddr_in6.sin6_addr;
334	struct in6_addr *daddr = &av->dgid_addr._sockaddr_in6.sin6_addr;
335
336	dst = rxe_find_route(skb->dev, qp, av);
337	if (!dst) {
338		pr_err("Host not reachable\n");
339		return -EHOSTUNREACH;
340	}
341
342	prepare_udp_hdr(skb, cpu_to_be16(qp->src_port),
343			cpu_to_be16(ROCE_V2_UDP_DPORT));
344
345	prepare_ipv6_hdr(dst, skb, saddr, daddr, IPPROTO_UDP,
346			 av->grh.traffic_class,
347			 av->grh.hop_limit);
348
349	dst_release(dst);
350	return 0;
351}
352
353int rxe_prepare(struct rxe_pkt_info *pkt, struct sk_buff *skb, u32 *crc)
354{
355	int err = 0;
356
357	if (skb->protocol == htons(ETH_P_IP))
358		err = prepare4(pkt, skb);
359	else if (skb->protocol == htons(ETH_P_IPV6))
360		err = prepare6(pkt, skb);
361
362	*crc = rxe_icrc_hdr(pkt, skb);
363
364	if (ether_addr_equal(skb->dev->dev_addr, rxe_get_av(pkt)->dmac))
365		pkt->mask |= RXE_LOOPBACK_MASK;
366
367	return err;
368}
369
370static void rxe_skb_tx_dtor(struct sk_buff *skb)
371{
372	struct sock *sk = skb->sk;
373	struct rxe_qp *qp = sk->sk_user_data;
374	int skb_out = atomic_dec_return(&qp->skb_out);
375
376	if (unlikely(qp->need_req_skb &&
377		     skb_out < RXE_INFLIGHT_SKBS_PER_QP_LOW))
378		rxe_run_task(&qp->req.task, 1);
379
380	rxe_drop_ref(qp);
381}
382
383int rxe_send(struct rxe_pkt_info *pkt, struct sk_buff *skb)
384{
385	int err;
386
387	skb->destructor = rxe_skb_tx_dtor;
388	skb->sk = pkt->qp->sk->sk;
389
390	rxe_add_ref(pkt->qp);
391	atomic_inc(&pkt->qp->skb_out);
392
393	if (skb->protocol == htons(ETH_P_IP)) {
394		err = ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
395	} else if (skb->protocol == htons(ETH_P_IPV6)) {
396		err = ip6_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
397	} else {
398		pr_err("Unknown layer 3 protocol: %d\n", skb->protocol);
399		atomic_dec(&pkt->qp->skb_out);
400		rxe_drop_ref(pkt->qp);
401		kfree_skb(skb);
402		return -EINVAL;
403	}
404
405	if (unlikely(net_xmit_eval(err))) {
406		pr_debug("error sending packet: %d\n", err);
407		return -EAGAIN;
408	}
409
410	return 0;
411}
412
413void rxe_loopback(struct sk_buff *skb)
414{
415	if (skb->protocol == htons(ETH_P_IP))
416		skb_pull(skb, sizeof(struct iphdr));
417	else
418		skb_pull(skb, sizeof(struct ipv6hdr));
419
420	rxe_rcv(skb);
421}
422
423struct sk_buff *rxe_init_packet(struct rxe_dev *rxe, struct rxe_av *av,
424				int paylen, struct rxe_pkt_info *pkt)
425{
426	unsigned int hdr_len;
427	struct sk_buff *skb = NULL;
428	struct net_device *ndev;
429	const struct ib_gid_attr *attr;
430	const int port_num = 1;
431
432	attr = rdma_get_gid_attr(&rxe->ib_dev, port_num, av->grh.sgid_index);
433	if (IS_ERR(attr))
434		return NULL;
435
436	if (av->network_type == RXE_NETWORK_TYPE_IPV4)
437		hdr_len = ETH_HLEN + sizeof(struct udphdr) +
438			sizeof(struct iphdr);
439	else
440		hdr_len = ETH_HLEN + sizeof(struct udphdr) +
441			sizeof(struct ipv6hdr);
442
443	rcu_read_lock();
444	ndev = rdma_read_gid_attr_ndev_rcu(attr);
445	if (IS_ERR(ndev)) {
446		rcu_read_unlock();
447		goto out;
448	}
449	skb = alloc_skb(paylen + hdr_len + LL_RESERVED_SPACE(ndev),
450			GFP_ATOMIC);
451
452	if (unlikely(!skb)) {
453		rcu_read_unlock();
454		goto out;
455	}
456
457	skb_reserve(skb, hdr_len + LL_RESERVED_SPACE(ndev));
458
459	/* FIXME: hold reference to this netdev until life of this skb. */
460	skb->dev	= ndev;
461	rcu_read_unlock();
462
463	if (av->network_type == RXE_NETWORK_TYPE_IPV4)
464		skb->protocol = htons(ETH_P_IP);
465	else
466		skb->protocol = htons(ETH_P_IPV6);
467
468	pkt->rxe	= rxe;
469	pkt->port_num	= port_num;
470	pkt->hdr	= skb_put_zero(skb, paylen);
471	pkt->mask	|= RXE_GRH_MASK;
472
473out:
474	rdma_put_gid_attr(attr);
475	return skb;
476}
477
478/*
479 * this is required by rxe_cfg to match rxe devices in
480 * /sys/class/infiniband up with their underlying ethernet devices
481 */
482const char *rxe_parent_name(struct rxe_dev *rxe, unsigned int port_num)
483{
484	return rxe->ndev->name;
485}
486
487int rxe_net_add(const char *ibdev_name, struct net_device *ndev)
488{
489	int err;
490	struct rxe_dev *rxe = NULL;
491
492	rxe = ib_alloc_device(rxe_dev, ib_dev);
493	if (!rxe)
494		return -ENOMEM;
495
496	rxe->ndev = ndev;
497
498	err = rxe_add(rxe, ndev->mtu, ibdev_name);
499	if (err) {
500		ib_dealloc_device(&rxe->ib_dev);
501		return err;
502	}
503
504	return 0;
505}
506
507static void rxe_port_event(struct rxe_dev *rxe,
508			   enum ib_event_type event)
509{
510	struct ib_event ev;
511
512	ev.device = &rxe->ib_dev;
513	ev.element.port_num = 1;
514	ev.event = event;
515
516	ib_dispatch_event(&ev);
517}
518
519/* Caller must hold net_info_lock */
520void rxe_port_up(struct rxe_dev *rxe)
521{
522	struct rxe_port *port;
523
524	port = &rxe->port;
525	port->attr.state = IB_PORT_ACTIVE;
526
527	rxe_port_event(rxe, IB_EVENT_PORT_ACTIVE);
528	dev_info(&rxe->ib_dev.dev, "set active\n");
529}
530
531/* Caller must hold net_info_lock */
532void rxe_port_down(struct rxe_dev *rxe)
533{
534	struct rxe_port *port;
535
536	port = &rxe->port;
537	port->attr.state = IB_PORT_DOWN;
538
539	rxe_port_event(rxe, IB_EVENT_PORT_ERR);
540	rxe_counter_inc(rxe, RXE_CNT_LINK_DOWNED);
541	dev_info(&rxe->ib_dev.dev, "set down\n");
542}
543
544void rxe_set_port_state(struct rxe_dev *rxe)
545{
546	if (netif_running(rxe->ndev) && netif_carrier_ok(rxe->ndev))
547		rxe_port_up(rxe);
548	else
549		rxe_port_down(rxe);
550}
551
552static int rxe_notify(struct notifier_block *not_blk,
553		      unsigned long event,
554		      void *arg)
555{
556	struct net_device *ndev = netdev_notifier_info_to_dev(arg);
557	struct rxe_dev *rxe = rxe_get_dev_from_net(ndev);
558
559	if (!rxe)
560		return NOTIFY_OK;
561
562	switch (event) {
563	case NETDEV_UNREGISTER:
564		ib_unregister_device_queued(&rxe->ib_dev);
565		break;
566	case NETDEV_UP:
567		rxe_port_up(rxe);
568		break;
569	case NETDEV_DOWN:
570		rxe_port_down(rxe);
571		break;
572	case NETDEV_CHANGEMTU:
573		pr_info("%s changed mtu to %d\n", ndev->name, ndev->mtu);
574		rxe_set_mtu(rxe, ndev->mtu);
575		break;
576	case NETDEV_CHANGE:
577		rxe_set_port_state(rxe);
578		break;
579	case NETDEV_REBOOT:
580	case NETDEV_GOING_DOWN:
581	case NETDEV_CHANGEADDR:
582	case NETDEV_CHANGENAME:
583	case NETDEV_FEAT_CHANGE:
584	default:
585		pr_info("ignoring netdev event = %ld for %s\n",
586			event, ndev->name);
587		break;
588	}
589
590	ib_device_put(&rxe->ib_dev);
591	return NOTIFY_OK;
592}
593
594static struct notifier_block rxe_net_notifier = {
595	.notifier_call = rxe_notify,
596};
597
598static int rxe_net_ipv4_init(void)
599{
600	recv_sockets.sk4 = rxe_setup_udp_tunnel(&init_net,
601				htons(ROCE_V2_UDP_DPORT), false);
602	if (IS_ERR(recv_sockets.sk4)) {
603		recv_sockets.sk4 = NULL;
604		pr_err("Failed to create IPv4 UDP tunnel\n");
605		return -1;
606	}
607
608	return 0;
609}
610
611static int rxe_net_ipv6_init(void)
612{
613#if IS_ENABLED(CONFIG_IPV6)
614
615	recv_sockets.sk6 = rxe_setup_udp_tunnel(&init_net,
616						htons(ROCE_V2_UDP_DPORT), true);
617	if (PTR_ERR(recv_sockets.sk6) == -EAFNOSUPPORT) {
618		recv_sockets.sk6 = NULL;
619		pr_warn("IPv6 is not supported, can not create a UDPv6 socket\n");
620		return 0;
621	}
622
623	if (IS_ERR(recv_sockets.sk6)) {
624		recv_sockets.sk6 = NULL;
625		pr_err("Failed to create IPv6 UDP tunnel\n");
626		return -1;
627	}
628#endif
629	return 0;
630}
631
632void rxe_net_exit(void)
633{
634	rxe_release_udp_tunnel(recv_sockets.sk6);
635	rxe_release_udp_tunnel(recv_sockets.sk4);
636	unregister_netdevice_notifier(&rxe_net_notifier);
637}
638
639int rxe_net_init(void)
640{
641	int err;
642
643	recv_sockets.sk6 = NULL;
644
645	err = rxe_net_ipv4_init();
646	if (err)
647		return err;
648	err = rxe_net_ipv6_init();
649	if (err)
650		goto err_out;
651	err = register_netdevice_notifier(&rxe_net_notifier);
652	if (err) {
653		pr_err("Failed to register netdev notifier\n");
654		goto err_out;
655	}
656	return 0;
657err_out:
658	rxe_net_exit();
659	return err;
660}
661