Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved. |
| 3 | * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved. |
| 4 | * |
| 5 | * This software is available to you under a choice of one of two |
| 6 | * licenses. You may choose to be licensed under the terms of the GNU |
| 7 | * General Public License (GPL) Version 2, available from the file |
| 8 | * COPYING in the main directory of this source tree, or the |
| 9 | * OpenIB.org BSD license below: |
| 10 | * |
| 11 | * Redistribution and use in source and binary forms, with or |
| 12 | * without modification, are permitted provided that the following |
| 13 | * conditions are met: |
| 14 | * |
| 15 | * - Redistributions of source code must retain the above |
| 16 | * copyright notice, this list of conditions and the following |
| 17 | * disclaimer. |
| 18 | * |
| 19 | * - Redistributions in binary form must reproduce the above |
| 20 | * copyright notice, this list of conditions and the following |
| 21 | * disclaimer in the documentation and/or other materials |
| 22 | * provided with the distribution. |
| 23 | * |
| 24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
| 25 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 26 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
| 27 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
| 28 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| 29 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| 30 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| 31 | * SOFTWARE. |
| 32 | */ |
| 33 | |
| 34 | #include <linux/skbuff.h> |
| 35 | #include <linux/if_arp.h> |
| 36 | #include <linux/netdevice.h> |
| 37 | #include <linux/if.h> |
| 38 | #include <linux/if_vlan.h> |
| 39 | #include <net/udp_tunnel.h> |
| 40 | #include <net/sch_generic.h> |
| 41 | #include <linux/netfilter.h> |
| 42 | #include <rdma/ib_addr.h> |
| 43 | |
| 44 | #include "rxe.h" |
| 45 | #include "rxe_net.h" |
| 46 | #include "rxe_loc.h" |
| 47 | |
| 48 | static LIST_HEAD(rxe_dev_list); |
Wei Yongjun | 4ac4707 | 2016-10-29 16:19:33 +0000 | [diff] [blame] | 49 | static DEFINE_SPINLOCK(dev_list_lock); /* spinlock for device list */ |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 50 | |
| 51 | struct rxe_dev *net_to_rxe(struct net_device *ndev) |
| 52 | { |
| 53 | struct rxe_dev *rxe; |
| 54 | struct rxe_dev *found = NULL; |
| 55 | |
| 56 | spin_lock_bh(&dev_list_lock); |
| 57 | list_for_each_entry(rxe, &rxe_dev_list, list) { |
| 58 | if (rxe->ndev == ndev) { |
| 59 | found = rxe; |
| 60 | break; |
| 61 | } |
| 62 | } |
| 63 | spin_unlock_bh(&dev_list_lock); |
| 64 | |
| 65 | return found; |
| 66 | } |
| 67 | |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 68 | struct rxe_dev *get_rxe_by_name(const char *name) |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 69 | { |
| 70 | struct rxe_dev *rxe; |
| 71 | struct rxe_dev *found = NULL; |
| 72 | |
| 73 | spin_lock_bh(&dev_list_lock); |
| 74 | list_for_each_entry(rxe, &rxe_dev_list, list) { |
| 75 | if (!strcmp(name, rxe->ib_dev.name)) { |
| 76 | found = rxe; |
| 77 | break; |
| 78 | } |
| 79 | } |
| 80 | spin_unlock_bh(&dev_list_lock); |
| 81 | return found; |
| 82 | } |
| 83 | |
| 84 | |
| 85 | struct rxe_recv_sockets recv_sockets; |
| 86 | |
| 87 | static __be64 rxe_mac_to_eui64(struct net_device *ndev) |
| 88 | { |
| 89 | unsigned char *mac_addr = ndev->dev_addr; |
| 90 | __be64 eui64; |
| 91 | unsigned char *dst = (unsigned char *)&eui64; |
| 92 | |
| 93 | dst[0] = mac_addr[0] ^ 2; |
| 94 | dst[1] = mac_addr[1]; |
| 95 | dst[2] = mac_addr[2]; |
| 96 | dst[3] = 0xff; |
| 97 | dst[4] = 0xfe; |
| 98 | dst[5] = mac_addr[3]; |
| 99 | dst[6] = mac_addr[4]; |
| 100 | dst[7] = mac_addr[5]; |
| 101 | |
| 102 | return eui64; |
| 103 | } |
| 104 | |
| 105 | static __be64 node_guid(struct rxe_dev *rxe) |
| 106 | { |
| 107 | return rxe_mac_to_eui64(rxe->ndev); |
| 108 | } |
| 109 | |
| 110 | static __be64 port_guid(struct rxe_dev *rxe) |
| 111 | { |
| 112 | return rxe_mac_to_eui64(rxe->ndev); |
| 113 | } |
| 114 | |
| 115 | static struct device *dma_device(struct rxe_dev *rxe) |
| 116 | { |
| 117 | struct net_device *ndev; |
| 118 | |
| 119 | ndev = rxe->ndev; |
| 120 | |
| 121 | if (ndev->priv_flags & IFF_802_1Q_VLAN) |
| 122 | ndev = vlan_dev_real_dev(ndev); |
| 123 | |
| 124 | return ndev->dev.parent; |
| 125 | } |
| 126 | |
| 127 | static int mcast_add(struct rxe_dev *rxe, union ib_gid *mgid) |
| 128 | { |
| 129 | int err; |
| 130 | unsigned char ll_addr[ETH_ALEN]; |
| 131 | |
| 132 | ipv6_eth_mc_map((struct in6_addr *)mgid->raw, ll_addr); |
| 133 | err = dev_mc_add(rxe->ndev, ll_addr); |
| 134 | |
| 135 | return err; |
| 136 | } |
| 137 | |
| 138 | static int mcast_delete(struct rxe_dev *rxe, union ib_gid *mgid) |
| 139 | { |
| 140 | int err; |
| 141 | unsigned char ll_addr[ETH_ALEN]; |
| 142 | |
| 143 | ipv6_eth_mc_map((struct in6_addr *)mgid->raw, ll_addr); |
| 144 | err = dev_mc_del(rxe->ndev, ll_addr); |
| 145 | |
| 146 | return err; |
| 147 | } |
| 148 | |
| 149 | static struct dst_entry *rxe_find_route4(struct net_device *ndev, |
| 150 | struct in_addr *saddr, |
| 151 | struct in_addr *daddr) |
| 152 | { |
| 153 | struct rtable *rt; |
| 154 | struct flowi4 fl = { { 0 } }; |
| 155 | |
| 156 | memset(&fl, 0, sizeof(fl)); |
| 157 | fl.flowi4_oif = ndev->ifindex; |
| 158 | memcpy(&fl.saddr, saddr, sizeof(*saddr)); |
| 159 | memcpy(&fl.daddr, daddr, sizeof(*daddr)); |
| 160 | fl.flowi4_proto = IPPROTO_UDP; |
| 161 | |
| 162 | rt = ip_route_output_key(&init_net, &fl); |
| 163 | if (IS_ERR(rt)) { |
| 164 | pr_err_ratelimited("no route to %pI4\n", &daddr->s_addr); |
| 165 | return NULL; |
| 166 | } |
| 167 | |
| 168 | return &rt->dst; |
| 169 | } |
| 170 | |
| 171 | #if IS_ENABLED(CONFIG_IPV6) |
| 172 | static struct dst_entry *rxe_find_route6(struct net_device *ndev, |
| 173 | struct in6_addr *saddr, |
| 174 | struct in6_addr *daddr) |
| 175 | { |
| 176 | struct dst_entry *ndst; |
| 177 | struct flowi6 fl6 = { { 0 } }; |
| 178 | |
| 179 | memset(&fl6, 0, sizeof(fl6)); |
| 180 | fl6.flowi6_oif = ndev->ifindex; |
| 181 | memcpy(&fl6.saddr, saddr, sizeof(*saddr)); |
| 182 | memcpy(&fl6.daddr, daddr, sizeof(*daddr)); |
| 183 | fl6.flowi6_proto = IPPROTO_UDP; |
| 184 | |
| 185 | if (unlikely(ipv6_stub->ipv6_dst_lookup(sock_net(recv_sockets.sk6->sk), |
| 186 | recv_sockets.sk6->sk, &ndst, &fl6))) { |
| 187 | pr_err_ratelimited("no route to %pI6\n", daddr); |
| 188 | goto put; |
| 189 | } |
| 190 | |
| 191 | if (unlikely(ndst->error)) { |
| 192 | pr_err("no route to %pI6\n", daddr); |
| 193 | goto put; |
| 194 | } |
| 195 | |
| 196 | return ndst; |
| 197 | put: |
| 198 | dst_release(ndst); |
| 199 | return NULL; |
| 200 | } |
| 201 | |
| 202 | #else |
| 203 | |
| 204 | static struct dst_entry *rxe_find_route6(struct net_device *ndev, |
| 205 | struct in6_addr *saddr, |
| 206 | struct in6_addr *daddr) |
| 207 | { |
| 208 | return NULL; |
| 209 | } |
| 210 | |
| 211 | #endif |
| 212 | |
| 213 | static int rxe_udp_encap_recv(struct sock *sk, struct sk_buff *skb) |
| 214 | { |
| 215 | struct udphdr *udph; |
| 216 | struct net_device *ndev = skb->dev; |
| 217 | struct rxe_dev *rxe = net_to_rxe(ndev); |
| 218 | struct rxe_pkt_info *pkt = SKB_TO_PKT(skb); |
| 219 | |
| 220 | if (!rxe) |
| 221 | goto drop; |
| 222 | |
| 223 | if (skb_linearize(skb)) { |
| 224 | pr_err("skb_linearize failed\n"); |
| 225 | goto drop; |
| 226 | } |
| 227 | |
| 228 | udph = udp_hdr(skb); |
| 229 | pkt->rxe = rxe; |
| 230 | pkt->port_num = 1; |
| 231 | pkt->hdr = (u8 *)(udph + 1); |
| 232 | pkt->mask = RXE_GRH_MASK; |
| 233 | pkt->paylen = be16_to_cpu(udph->len) - sizeof(*udph); |
| 234 | |
| 235 | return rxe_rcv(skb); |
| 236 | drop: |
| 237 | kfree_skb(skb); |
| 238 | return 0; |
| 239 | } |
| 240 | |
| 241 | static struct socket *rxe_setup_udp_tunnel(struct net *net, __be16 port, |
| 242 | bool ipv6) |
| 243 | { |
| 244 | int err; |
| 245 | struct socket *sock; |
Yonatan Cohen | 1454ca3 | 2016-11-16 10:39:14 +0200 | [diff] [blame] | 246 | struct udp_port_cfg udp_cfg = {0}; |
| 247 | struct udp_tunnel_sock_cfg tnl_cfg = {0}; |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 248 | |
| 249 | if (ipv6) { |
| 250 | udp_cfg.family = AF_INET6; |
| 251 | udp_cfg.ipv6_v6only = 1; |
| 252 | } else { |
| 253 | udp_cfg.family = AF_INET; |
| 254 | } |
| 255 | |
| 256 | udp_cfg.local_udp_port = port; |
| 257 | |
| 258 | /* Create UDP socket */ |
| 259 | err = udp_sock_create(net, &udp_cfg, &sock); |
| 260 | if (err < 0) { |
| 261 | pr_err("failed to create udp socket. err = %d\n", err); |
| 262 | return ERR_PTR(err); |
| 263 | } |
| 264 | |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 265 | tnl_cfg.encap_type = 1; |
| 266 | tnl_cfg.encap_rcv = rxe_udp_encap_recv; |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 267 | |
| 268 | /* Setup UDP tunnel */ |
| 269 | setup_udp_tunnel_sock(net, sock, &tnl_cfg); |
| 270 | |
| 271 | return sock; |
| 272 | } |
| 273 | |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 274 | void rxe_release_udp_tunnel(struct socket *sk) |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 275 | { |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 276 | if (sk) |
| 277 | udp_tunnel_sock_release(sk); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | static void prepare_udp_hdr(struct sk_buff *skb, __be16 src_port, |
| 281 | __be16 dst_port) |
| 282 | { |
| 283 | struct udphdr *udph; |
| 284 | |
| 285 | __skb_push(skb, sizeof(*udph)); |
| 286 | skb_reset_transport_header(skb); |
| 287 | udph = udp_hdr(skb); |
| 288 | |
| 289 | udph->dest = dst_port; |
| 290 | udph->source = src_port; |
| 291 | udph->len = htons(skb->len); |
| 292 | udph->check = 0; |
| 293 | } |
| 294 | |
| 295 | static void prepare_ipv4_hdr(struct dst_entry *dst, struct sk_buff *skb, |
| 296 | __be32 saddr, __be32 daddr, __u8 proto, |
| 297 | __u8 tos, __u8 ttl, __be16 df, bool xnet) |
| 298 | { |
| 299 | struct iphdr *iph; |
| 300 | |
| 301 | skb_scrub_packet(skb, xnet); |
| 302 | |
| 303 | skb_clear_hash(skb); |
| 304 | skb_dst_set(skb, dst); |
| 305 | memset(IPCB(skb), 0, sizeof(*IPCB(skb))); |
| 306 | |
| 307 | skb_push(skb, sizeof(struct iphdr)); |
| 308 | skb_reset_network_header(skb); |
| 309 | |
| 310 | iph = ip_hdr(skb); |
| 311 | |
| 312 | iph->version = IPVERSION; |
| 313 | iph->ihl = sizeof(struct iphdr) >> 2; |
| 314 | iph->frag_off = df; |
| 315 | iph->protocol = proto; |
| 316 | iph->tos = tos; |
| 317 | iph->daddr = daddr; |
| 318 | iph->saddr = saddr; |
| 319 | iph->ttl = ttl; |
| 320 | __ip_select_ident(dev_net(dst->dev), iph, |
| 321 | skb_shinfo(skb)->gso_segs ?: 1); |
| 322 | iph->tot_len = htons(skb->len); |
| 323 | ip_send_check(iph); |
| 324 | } |
| 325 | |
| 326 | static void prepare_ipv6_hdr(struct dst_entry *dst, struct sk_buff *skb, |
| 327 | struct in6_addr *saddr, struct in6_addr *daddr, |
| 328 | __u8 proto, __u8 prio, __u8 ttl) |
| 329 | { |
| 330 | struct ipv6hdr *ip6h; |
| 331 | |
| 332 | memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); |
| 333 | IPCB(skb)->flags &= ~(IPSKB_XFRM_TUNNEL_SIZE | IPSKB_XFRM_TRANSFORMED |
| 334 | | IPSKB_REROUTED); |
| 335 | skb_dst_set(skb, dst); |
| 336 | |
| 337 | __skb_push(skb, sizeof(*ip6h)); |
| 338 | skb_reset_network_header(skb); |
| 339 | ip6h = ipv6_hdr(skb); |
| 340 | ip6_flow_hdr(ip6h, prio, htonl(0)); |
| 341 | ip6h->payload_len = htons(skb->len); |
| 342 | ip6h->nexthdr = proto; |
| 343 | ip6h->hop_limit = ttl; |
| 344 | ip6h->daddr = *daddr; |
| 345 | ip6h->saddr = *saddr; |
| 346 | ip6h->payload_len = htons(skb->len - sizeof(*ip6h)); |
| 347 | } |
| 348 | |
Parav Pandit | ffae955 | 2016-09-28 20:24:42 +0000 | [diff] [blame] | 349 | static int prepare4(struct rxe_dev *rxe, struct rxe_pkt_info *pkt, |
| 350 | struct sk_buff *skb, struct rxe_av *av) |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 351 | { |
| 352 | struct dst_entry *dst; |
| 353 | bool xnet = false; |
| 354 | __be16 df = htons(IP_DF); |
| 355 | struct in_addr *saddr = &av->sgid_addr._sockaddr_in.sin_addr; |
| 356 | struct in_addr *daddr = &av->dgid_addr._sockaddr_in.sin_addr; |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 357 | |
| 358 | dst = rxe_find_route4(rxe->ndev, saddr, daddr); |
| 359 | if (!dst) { |
| 360 | pr_err("Host not reachable\n"); |
| 361 | return -EHOSTUNREACH; |
| 362 | } |
| 363 | |
| 364 | if (!memcmp(saddr, daddr, sizeof(*daddr))) |
| 365 | pkt->mask |= RXE_LOOPBACK_MASK; |
| 366 | |
| 367 | prepare_udp_hdr(skb, htons(RXE_ROCE_V2_SPORT), |
| 368 | htons(ROCE_V2_UDP_DPORT)); |
| 369 | |
| 370 | prepare_ipv4_hdr(dst, skb, saddr->s_addr, daddr->s_addr, IPPROTO_UDP, |
| 371 | av->grh.traffic_class, av->grh.hop_limit, df, xnet); |
| 372 | return 0; |
| 373 | } |
| 374 | |
Parav Pandit | ffae955 | 2016-09-28 20:24:42 +0000 | [diff] [blame] | 375 | static int prepare6(struct rxe_dev *rxe, struct rxe_pkt_info *pkt, |
| 376 | struct sk_buff *skb, struct rxe_av *av) |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 377 | { |
| 378 | struct dst_entry *dst; |
| 379 | struct in6_addr *saddr = &av->sgid_addr._sockaddr_in6.sin6_addr; |
| 380 | struct in6_addr *daddr = &av->dgid_addr._sockaddr_in6.sin6_addr; |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 381 | |
| 382 | dst = rxe_find_route6(rxe->ndev, saddr, daddr); |
| 383 | if (!dst) { |
| 384 | pr_err("Host not reachable\n"); |
| 385 | return -EHOSTUNREACH; |
| 386 | } |
| 387 | |
| 388 | if (!memcmp(saddr, daddr, sizeof(*daddr))) |
| 389 | pkt->mask |= RXE_LOOPBACK_MASK; |
| 390 | |
| 391 | prepare_udp_hdr(skb, htons(RXE_ROCE_V2_SPORT), |
| 392 | htons(ROCE_V2_UDP_DPORT)); |
| 393 | |
| 394 | prepare_ipv6_hdr(dst, skb, saddr, daddr, IPPROTO_UDP, |
| 395 | av->grh.traffic_class, |
| 396 | av->grh.hop_limit); |
| 397 | return 0; |
| 398 | } |
| 399 | |
| 400 | static int prepare(struct rxe_dev *rxe, struct rxe_pkt_info *pkt, |
| 401 | struct sk_buff *skb, u32 *crc) |
| 402 | { |
| 403 | int err = 0; |
| 404 | struct rxe_av *av = rxe_get_av(pkt); |
| 405 | |
| 406 | if (av->network_type == RDMA_NETWORK_IPV4) |
Parav Pandit | ffae955 | 2016-09-28 20:24:42 +0000 | [diff] [blame] | 407 | err = prepare4(rxe, pkt, skb, av); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 408 | else if (av->network_type == RDMA_NETWORK_IPV6) |
Parav Pandit | ffae955 | 2016-09-28 20:24:42 +0000 | [diff] [blame] | 409 | err = prepare6(rxe, pkt, skb, av); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 410 | |
| 411 | *crc = rxe_icrc_hdr(pkt, skb); |
| 412 | |
| 413 | return err; |
| 414 | } |
| 415 | |
| 416 | static void rxe_skb_tx_dtor(struct sk_buff *skb) |
| 417 | { |
| 418 | struct sock *sk = skb->sk; |
| 419 | struct rxe_qp *qp = sk->sk_user_data; |
| 420 | int skb_out = atomic_dec_return(&qp->skb_out); |
| 421 | |
| 422 | if (unlikely(qp->need_req_skb && |
| 423 | skb_out < RXE_INFLIGHT_SKBS_PER_QP_LOW)) |
| 424 | rxe_run_task(&qp->req.task, 1); |
| 425 | } |
| 426 | |
| 427 | static int send(struct rxe_dev *rxe, struct rxe_pkt_info *pkt, |
| 428 | struct sk_buff *skb) |
| 429 | { |
| 430 | struct sk_buff *nskb; |
| 431 | struct rxe_av *av; |
| 432 | int err; |
| 433 | |
| 434 | av = rxe_get_av(pkt); |
| 435 | |
| 436 | nskb = skb_clone(skb, GFP_ATOMIC); |
| 437 | if (!nskb) |
| 438 | return -ENOMEM; |
| 439 | |
| 440 | nskb->destructor = rxe_skb_tx_dtor; |
| 441 | nskb->sk = pkt->qp->sk->sk; |
| 442 | |
| 443 | if (av->network_type == RDMA_NETWORK_IPV4) { |
| 444 | err = ip_local_out(dev_net(skb_dst(skb)->dev), nskb->sk, nskb); |
| 445 | } else if (av->network_type == RDMA_NETWORK_IPV6) { |
| 446 | err = ip6_local_out(dev_net(skb_dst(skb)->dev), nskb->sk, nskb); |
| 447 | } else { |
| 448 | pr_err("Unknown layer 3 protocol: %d\n", av->network_type); |
| 449 | kfree_skb(nskb); |
| 450 | return -EINVAL; |
| 451 | } |
| 452 | |
| 453 | if (unlikely(net_xmit_eval(err))) { |
| 454 | pr_debug("error sending packet: %d\n", err); |
| 455 | return -EAGAIN; |
| 456 | } |
| 457 | |
Andrew Boyer | 5cc8fab | 2016-12-22 08:54:38 -0500 | [diff] [blame] | 458 | atomic_inc(&pkt->qp->skb_out); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 459 | kfree_skb(skb); |
| 460 | |
| 461 | return 0; |
| 462 | } |
| 463 | |
| 464 | static int loopback(struct sk_buff *skb) |
| 465 | { |
| 466 | return rxe_rcv(skb); |
| 467 | } |
| 468 | |
| 469 | static inline int addr_same(struct rxe_dev *rxe, struct rxe_av *av) |
| 470 | { |
| 471 | return rxe->port.port_guid == av->grh.dgid.global.interface_id; |
| 472 | } |
| 473 | |
| 474 | static struct sk_buff *init_packet(struct rxe_dev *rxe, struct rxe_av *av, |
| 475 | int paylen, struct rxe_pkt_info *pkt) |
| 476 | { |
| 477 | unsigned int hdr_len; |
| 478 | struct sk_buff *skb; |
| 479 | |
| 480 | if (av->network_type == RDMA_NETWORK_IPV4) |
| 481 | hdr_len = ETH_HLEN + sizeof(struct udphdr) + |
| 482 | sizeof(struct iphdr); |
| 483 | else |
| 484 | hdr_len = ETH_HLEN + sizeof(struct udphdr) + |
| 485 | sizeof(struct ipv6hdr); |
| 486 | |
| 487 | skb = alloc_skb(paylen + hdr_len + LL_RESERVED_SPACE(rxe->ndev), |
| 488 | GFP_ATOMIC); |
| 489 | if (unlikely(!skb)) |
| 490 | return NULL; |
| 491 | |
| 492 | skb_reserve(skb, hdr_len + LL_RESERVED_SPACE(rxe->ndev)); |
| 493 | |
| 494 | skb->dev = rxe->ndev; |
| 495 | if (av->network_type == RDMA_NETWORK_IPV4) |
| 496 | skb->protocol = htons(ETH_P_IP); |
| 497 | else |
| 498 | skb->protocol = htons(ETH_P_IPV6); |
| 499 | |
| 500 | pkt->rxe = rxe; |
| 501 | pkt->port_num = 1; |
| 502 | pkt->hdr = skb_put(skb, paylen); |
| 503 | pkt->mask |= RXE_GRH_MASK; |
| 504 | |
| 505 | memset(pkt->hdr, 0, paylen); |
| 506 | |
| 507 | return skb; |
| 508 | } |
| 509 | |
| 510 | /* |
| 511 | * this is required by rxe_cfg to match rxe devices in |
| 512 | * /sys/class/infiniband up with their underlying ethernet devices |
| 513 | */ |
| 514 | static char *parent_name(struct rxe_dev *rxe, unsigned int port_num) |
| 515 | { |
| 516 | return rxe->ndev->name; |
| 517 | } |
| 518 | |
| 519 | static enum rdma_link_layer link_layer(struct rxe_dev *rxe, |
| 520 | unsigned int port_num) |
| 521 | { |
| 522 | return IB_LINK_LAYER_ETHERNET; |
| 523 | } |
| 524 | |
| 525 | static struct rxe_ifc_ops ifc_ops = { |
| 526 | .node_guid = node_guid, |
| 527 | .port_guid = port_guid, |
| 528 | .dma_device = dma_device, |
| 529 | .mcast_add = mcast_add, |
| 530 | .mcast_delete = mcast_delete, |
| 531 | .prepare = prepare, |
| 532 | .send = send, |
| 533 | .loopback = loopback, |
| 534 | .init_packet = init_packet, |
| 535 | .parent_name = parent_name, |
| 536 | .link_layer = link_layer, |
| 537 | }; |
| 538 | |
| 539 | struct rxe_dev *rxe_net_add(struct net_device *ndev) |
| 540 | { |
| 541 | int err; |
| 542 | struct rxe_dev *rxe = NULL; |
| 543 | |
| 544 | rxe = (struct rxe_dev *)ib_alloc_device(sizeof(*rxe)); |
| 545 | if (!rxe) |
| 546 | return NULL; |
| 547 | |
| 548 | rxe->ifc_ops = &ifc_ops; |
| 549 | rxe->ndev = ndev; |
| 550 | |
| 551 | err = rxe_add(rxe, ndev->mtu); |
| 552 | if (err) { |
| 553 | ib_dealloc_device(&rxe->ib_dev); |
| 554 | return NULL; |
| 555 | } |
| 556 | |
| 557 | spin_lock_bh(&dev_list_lock); |
Maor Gottlieb | f39f775 | 2017-01-19 15:25:58 +0200 | [diff] [blame^] | 558 | list_add_tail(&rxe->list, &rxe_dev_list); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 559 | spin_unlock_bh(&dev_list_lock); |
| 560 | return rxe; |
| 561 | } |
| 562 | |
| 563 | void rxe_remove_all(void) |
| 564 | { |
| 565 | spin_lock_bh(&dev_list_lock); |
| 566 | while (!list_empty(&rxe_dev_list)) { |
| 567 | struct rxe_dev *rxe = |
| 568 | list_first_entry(&rxe_dev_list, struct rxe_dev, list); |
| 569 | |
| 570 | list_del(&rxe->list); |
| 571 | spin_unlock_bh(&dev_list_lock); |
| 572 | rxe_remove(rxe); |
| 573 | spin_lock_bh(&dev_list_lock); |
| 574 | } |
| 575 | spin_unlock_bh(&dev_list_lock); |
| 576 | } |
| 577 | EXPORT_SYMBOL(rxe_remove_all); |
| 578 | |
| 579 | static void rxe_port_event(struct rxe_dev *rxe, |
| 580 | enum ib_event_type event) |
| 581 | { |
| 582 | struct ib_event ev; |
| 583 | |
| 584 | ev.device = &rxe->ib_dev; |
| 585 | ev.element.port_num = 1; |
| 586 | ev.event = event; |
| 587 | |
| 588 | ib_dispatch_event(&ev); |
| 589 | } |
| 590 | |
| 591 | /* Caller must hold net_info_lock */ |
| 592 | void rxe_port_up(struct rxe_dev *rxe) |
| 593 | { |
| 594 | struct rxe_port *port; |
| 595 | |
| 596 | port = &rxe->port; |
| 597 | port->attr.state = IB_PORT_ACTIVE; |
| 598 | port->attr.phys_state = IB_PHYS_STATE_LINK_UP; |
| 599 | |
| 600 | rxe_port_event(rxe, IB_EVENT_PORT_ACTIVE); |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 601 | pr_info("set %s active\n", rxe->ib_dev.name); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 602 | } |
| 603 | |
| 604 | /* Caller must hold net_info_lock */ |
| 605 | void rxe_port_down(struct rxe_dev *rxe) |
| 606 | { |
| 607 | struct rxe_port *port; |
| 608 | |
| 609 | port = &rxe->port; |
| 610 | port->attr.state = IB_PORT_DOWN; |
| 611 | port->attr.phys_state = IB_PHYS_STATE_LINK_DOWN; |
| 612 | |
| 613 | rxe_port_event(rxe, IB_EVENT_PORT_ERR); |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 614 | pr_info("set %s down\n", rxe->ib_dev.name); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 615 | } |
| 616 | |
| 617 | static int rxe_notify(struct notifier_block *not_blk, |
| 618 | unsigned long event, |
| 619 | void *arg) |
| 620 | { |
| 621 | struct net_device *ndev = netdev_notifier_info_to_dev(arg); |
| 622 | struct rxe_dev *rxe = net_to_rxe(ndev); |
| 623 | |
| 624 | if (!rxe) |
| 625 | goto out; |
| 626 | |
| 627 | switch (event) { |
| 628 | case NETDEV_UNREGISTER: |
| 629 | list_del(&rxe->list); |
| 630 | rxe_remove(rxe); |
| 631 | break; |
| 632 | case NETDEV_UP: |
| 633 | rxe_port_up(rxe); |
| 634 | break; |
| 635 | case NETDEV_DOWN: |
| 636 | rxe_port_down(rxe); |
| 637 | break; |
| 638 | case NETDEV_CHANGEMTU: |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 639 | pr_info("%s changed mtu to %d\n", ndev->name, ndev->mtu); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 640 | rxe_set_mtu(rxe, ndev->mtu); |
| 641 | break; |
| 642 | case NETDEV_REBOOT: |
| 643 | case NETDEV_CHANGE: |
| 644 | case NETDEV_GOING_DOWN: |
| 645 | case NETDEV_CHANGEADDR: |
| 646 | case NETDEV_CHANGENAME: |
| 647 | case NETDEV_FEAT_CHANGE: |
| 648 | default: |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 649 | pr_info("ignoring netdev event = %ld for %s\n", |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 650 | event, ndev->name); |
| 651 | break; |
| 652 | } |
| 653 | out: |
| 654 | return NOTIFY_OK; |
| 655 | } |
| 656 | |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 657 | struct notifier_block rxe_net_notifier = { |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 658 | .notifier_call = rxe_notify, |
| 659 | }; |
| 660 | |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 661 | int rxe_net_ipv4_init(void) |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 662 | { |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 663 | recv_sockets.sk4 = rxe_setup_udp_tunnel(&init_net, |
| 664 | htons(ROCE_V2_UDP_DPORT), false); |
| 665 | if (IS_ERR(recv_sockets.sk4)) { |
| 666 | recv_sockets.sk4 = NULL; |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 667 | pr_err("Failed to create IPv4 UDP tunnel\n"); |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 668 | return -1; |
| 669 | } |
| 670 | |
| 671 | return 0; |
| 672 | } |
| 673 | |
| 674 | int rxe_net_ipv6_init(void) |
| 675 | { |
| 676 | #if IS_ENABLED(CONFIG_IPV6) |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 677 | |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 678 | recv_sockets.sk6 = rxe_setup_udp_tunnel(&init_net, |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 679 | htons(ROCE_V2_UDP_DPORT), true); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 680 | if (IS_ERR(recv_sockets.sk6)) { |
| 681 | recv_sockets.sk6 = NULL; |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 682 | pr_err("Failed to create IPv6 UDP tunnel\n"); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 683 | return -1; |
| 684 | } |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 685 | #endif |
| 686 | return 0; |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 687 | } |
| 688 | |
| 689 | void rxe_net_exit(void) |
| 690 | { |
Yonatan Cohen | dfdd615 | 2016-09-07 14:04:04 +0300 | [diff] [blame] | 691 | rxe_release_udp_tunnel(recv_sockets.sk6); |
| 692 | rxe_release_udp_tunnel(recv_sockets.sk4); |
Moni Shoua | 8700e3e | 2016-06-16 16:45:23 +0300 | [diff] [blame] | 693 | unregister_netdevice_notifier(&rxe_net_notifier); |
| 694 | } |
Parav Pandit | e404f94 | 2016-09-28 20:26:26 +0000 | [diff] [blame] | 695 | |
| 696 | int rxe_net_init(void) |
| 697 | { |
| 698 | int err; |
| 699 | |
| 700 | recv_sockets.sk6 = NULL; |
| 701 | |
| 702 | err = rxe_net_ipv4_init(); |
| 703 | if (err) |
| 704 | return err; |
| 705 | err = rxe_net_ipv6_init(); |
| 706 | if (err) |
| 707 | goto err_out; |
| 708 | err = register_netdevice_notifier(&rxe_net_notifier); |
| 709 | if (err) { |
| 710 | pr_err("Failed to register netdev notifier\n"); |
| 711 | goto err_out; |
| 712 | } |
| 713 | return 0; |
| 714 | err_out: |
| 715 | rxe_net_exit(); |
| 716 | return err; |
| 717 | } |