drivers/net/geneve.c

   1 /*
   2  * GENEVE: Generic Network Virtualization Encapsulation
   3  *
   4  * Copyright (c) 2015 Red Hat, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/netdevice.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/hash.h>
  18 #include <net/rtnetlink.h>
  19 #include <net/geneve.h>
  20
  21 #define GENEVE_NETDEV_VER       "0.6"
  22
  23 #define GENEVE_UDP_PORT         6081
  24
  25 #define GENEVE_N_VID            (1u << 24)
  26 #define GENEVE_VID_MASK         (GENEVE_N_VID - 1)
  27
  28 #define VNI_HASH_BITS           10
  29 #define VNI_HASH_SIZE           (1<<VNI_HASH_BITS)
  30
  31 static bool log_ecn_error = true;
  32 module_param(log_ecn_error, bool, 0644);
  33 MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
  34
  35 /* per-network namespace private data for this module */
  36 struct geneve_net {
  37         struct list_head  geneve_list;
  38         struct hlist_head vni_list[VNI_HASH_SIZE];
  39 };
  40
  41 /* Pseudo network device */
  42 struct geneve_dev {
  43         struct hlist_node  hlist;       /* vni hash table */
  44         struct net         *net;        /* netns for packet i/o */
  45         struct net_device  *dev;        /* netdev for geneve tunnel */
  46         struct geneve_sock *sock;       /* socket used for geneve tunnel */
  47         u8                 vni[3];      /* virtual network ID for tunnel */
  48         u8                 ttl;         /* TTL override */
  49         u8                 tos;         /* TOS override */
  50         struct sockaddr_in remote;      /* IPv4 address for link partner */
  51         struct list_head   next;        /* geneve's per namespace list */
  52         __be16             dst_port;
  53 };
  54
  55 static int geneve_net_id;
  56
  57 static inline __u32 geneve_net_vni_hash(u8 vni[3])
  58 {
  59         __u32 vnid;
  60
  61         vnid = (vni[0] << 16) | (vni[1] << 8) | vni[2];
  62         return hash_32(vnid, VNI_HASH_BITS);
  63 }
  64
  65 /* geneve receive/decap routine */
  66 static void geneve_rx(struct geneve_sock *gs, struct sk_buff *skb)
  67 {
  68         struct inet_sock *sk = inet_sk(gs->sock->sk);
  69         struct genevehdr *gnvh = geneve_hdr(skb);
  70         struct geneve_dev *dummy, *geneve = NULL;
  71         struct geneve_net *gn;
  72         struct iphdr *iph = NULL;
  73         struct pcpu_sw_netstats *stats;
  74         struct hlist_head *vni_list_head;
  75         int err = 0;
  76         __u32 hash;
  77
  78         iph = ip_hdr(skb); /* Still outer IP header... */
  79
  80         gn = gs->rcv_data;
  81
  82         /* Find the device for this VNI */
  83         hash = geneve_net_vni_hash(gnvh->vni);
  84         vni_list_head = &gn->vni_list[hash];
  85         hlist_for_each_entry_rcu(dummy, vni_list_head, hlist) {
  86                 if (!memcmp(gnvh->vni, dummy->vni, sizeof(dummy->vni)) &&
  87                     iph->saddr == dummy->remote.sin_addr.s_addr &&
  88                     sk->inet_sport == dummy->dst_port) {
  89                         geneve = dummy;
  90                         break;
  91                 }
  92         }
  93         if (!geneve)
  94                 goto drop;
  95
  96         /* Drop packets w/ critical options,
  97          * since we don't support any...
  98          */
  99         if (gnvh->critical)
 100                 goto drop;
 101
 102         skb_reset_mac_header(skb);
 103         skb_scrub_packet(skb, !net_eq(geneve->net, dev_net(geneve->dev)));
 104         skb->protocol = eth_type_trans(skb, geneve->dev);
 105         skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN);
 106
 107         /* Ignore packet loops (and multicast echo) */
 108         if (ether_addr_equal(eth_hdr(skb)->h_source, geneve->dev->dev_addr))
 109                 goto drop;
 110
 111         skb_reset_network_header(skb);
 112
 113         iph = ip_hdr(skb); /* Now inner IP header... */
 114         err = IP_ECN_decapsulate(iph, skb);
 115
 116         if (unlikely(err)) {
 117                 if (log_ecn_error)
 118                         net_info_ratelimited("non-ECT from %pI4 with TOS=%#x\n",
 119                                              &iph->saddr, iph->tos);
 120                 if (err > 1) {
 121                         ++geneve->dev->stats.rx_frame_errors;
 122                         ++geneve->dev->stats.rx_errors;
 123                         goto drop;
 124                 }
 125         }
 126
 127         stats = this_cpu_ptr(geneve->dev->tstats);
 128         u64_stats_update_begin(&stats->syncp);
 129         stats->rx_packets++;
 130         stats->rx_bytes += skb->len;
 131         u64_stats_update_end(&stats->syncp);
 132
 133         netif_rx(skb);
 134
 135         return;
 136 drop:
 137         /* Consume bad packet */
 138         kfree_skb(skb);
 139 }
 140
 141 /* Setup stats when device is created */
 142 static int geneve_init(struct net_device *dev)
 143 {
 144         dev->tstats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
 145         if (!dev->tstats)
 146                 return -ENOMEM;
 147
 148         return 0;
 149 }
 150
 151 static void geneve_uninit(struct net_device *dev)
 152 {
 153         free_percpu(dev->tstats);
 154 }
 155
 156 static int geneve_open(struct net_device *dev)
 157 {
 158         struct geneve_dev *geneve = netdev_priv(dev);
 159         struct net *net = geneve->net;
 160         struct geneve_net *gn = net_generic(geneve->net, geneve_net_id);
 161         struct geneve_sock *gs;
 162
 163         gs = geneve_sock_add(net, geneve->dst_port, geneve_rx, gn,
 164                              false, false);
 165         if (IS_ERR(gs))
 166                 return PTR_ERR(gs);
 167
 168         geneve->sock = gs;
 169
 170         return 0;
 171 }
 172
 173 static int geneve_stop(struct net_device *dev)
 174 {
 175         struct geneve_dev *geneve = netdev_priv(dev);
 176         struct geneve_sock *gs = geneve->sock;
 177
 178         geneve_sock_release(gs);
 179
 180         return 0;
 181 }
 182
 183 static netdev_tx_t geneve_xmit(struct sk_buff *skb, struct net_device *dev)
 184 {
 185         struct geneve_dev *geneve = netdev_priv(dev);
 186         struct geneve_sock *gs = geneve->sock;
 187         struct rtable *rt = NULL;
 188         const struct iphdr *iip; /* interior IP header */
 189         struct flowi4 fl4;
 190         int err;
 191         __be16 sport;
 192         __u8 tos, ttl;
 193
 194         iip = ip_hdr(skb);
 195
 196         skb_reset_mac_header(skb);
 197
 198         /* TODO: port min/max limits should be configurable */
 199         sport = udp_flow_src_port(dev_net(dev), skb, 0, 0, true);
 200
 201         tos = geneve->tos;
 202         if (tos == 1)
 203                 tos = ip_tunnel_get_dsfield(iip, skb);
 204
 205         memset(&fl4, 0, sizeof(fl4));
 206         fl4.flowi4_tos = RT_TOS(tos);
 207         fl4.daddr = geneve->remote.sin_addr.s_addr;
 208         fl4.flowi4_mark = skb->mark;
 209         fl4.flowi4_proto = IPPROTO_UDP;
 210
 211         rt = ip_route_output_key(geneve->net, &fl4);
 212         if (IS_ERR(rt)) {
 213                 netdev_dbg(dev, "no route to %pI4\n", &fl4.daddr);
 214                 dev->stats.tx_carrier_errors++;
 215                 goto tx_error;
 216         }
 217         if (rt->dst.dev == dev) { /* is this necessary? */
 218                 netdev_dbg(dev, "circular route to %pI4\n", &fl4.daddr);
 219                 dev->stats.collisions++;
 220                 goto rt_tx_error;
 221         }
 222
 223         tos = ip_tunnel_ecn_encap(tos, iip, skb);
 224
 225         ttl = geneve->ttl;
 226         if (!ttl && IN_MULTICAST(ntohl(fl4.daddr)))
 227                 ttl = 1;
 228
 229         ttl = ttl ? : ip4_dst_hoplimit(&rt->dst);
 230
 231         /* no need to handle local destination and encap bypass...yet... */
 232
 233         err = geneve_xmit_skb(gs, rt, skb, fl4.saddr, fl4.daddr,
 234                               tos, ttl, 0, sport, geneve->dst_port, 0,
 235                               geneve->vni, 0, NULL, false,
 236                               !net_eq(geneve->net, dev_net(geneve->dev)));
 237         if (err < 0)
 238                 ip_rt_put(rt);
 239
 240         iptunnel_xmit_stats(err, &dev->stats, dev->tstats);
 241
 242         return NETDEV_TX_OK;
 243
 244 rt_tx_error:
 245         ip_rt_put(rt);
 246 tx_error:
 247         dev->stats.tx_errors++;
 248         dev_kfree_skb(skb);
 249         return NETDEV_TX_OK;
 250 }
 251
 252 static const struct net_device_ops geneve_netdev_ops = {
 253         .ndo_init               = geneve_init,
 254         .ndo_uninit             = geneve_uninit,
 255         .ndo_open               = geneve_open,
 256         .ndo_stop               = geneve_stop,
 257         .ndo_start_xmit         = geneve_xmit,
 258         .ndo_get_stats64        = ip_tunnel_get_stats64,
 259         .ndo_change_mtu         = eth_change_mtu,
 260         .ndo_validate_addr      = eth_validate_addr,
 261         .ndo_set_mac_address    = eth_mac_addr,
 262 };
 263
 264 static void geneve_get_drvinfo(struct net_device *dev,
 265                                struct ethtool_drvinfo *drvinfo)
 266 {
 267         strlcpy(drvinfo->version, GENEVE_NETDEV_VER, sizeof(drvinfo->version));
 268         strlcpy(drvinfo->driver, "geneve", sizeof(drvinfo->driver));
 269 }
 270
 271 static const struct ethtool_ops geneve_ethtool_ops = {
 272         .get_drvinfo    = geneve_get_drvinfo,
 273         .get_link       = ethtool_op_get_link,
 274 };
 275
 276 /* Info for udev, that this is a virtual tunnel endpoint */
 277 static struct device_type geneve_type = {
 278         .name = "geneve",
 279 };
 280
 281 /* Initialize the device structure. */
 282 static void geneve_setup(struct net_device *dev)
 283 {
 284         ether_setup(dev);
 285
 286         dev->netdev_ops = &geneve_netdev_ops;
 287         dev->ethtool_ops = &geneve_ethtool_ops;
 288         dev->destructor = free_netdev;
 289
 290         SET_NETDEV_DEVTYPE(dev, &geneve_type);
 291
 292         dev->features    |= NETIF_F_LLTX;
 293         dev->features    |= NETIF_F_SG | NETIF_F_HW_CSUM;
 294         dev->features    |= NETIF_F_RXCSUM;
 295         dev->features    |= NETIF_F_GSO_SOFTWARE;
 296
 297         dev->vlan_features = dev->features;
 298         dev->features    |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
 299
 300         dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_RXCSUM;
 301         dev->hw_features |= NETIF_F_GSO_SOFTWARE;
 302         dev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_STAG_TX;
 303
 304         netif_keep_dst(dev);
 305         dev->priv_flags |= IFF_LIVE_ADDR_CHANGE | IFF_NO_QUEUE;
 306         eth_hw_addr_random(dev);
 307 }
 308
 309 static const struct nla_policy geneve_policy[IFLA_GENEVE_MAX + 1] = {
 310         [IFLA_GENEVE_ID]                = { .type = NLA_U32 },
 311         [IFLA_GENEVE_REMOTE]            = { .len = FIELD_SIZEOF(struct iphdr, daddr) },
 312         [IFLA_GENEVE_TTL]               = { .type = NLA_U8 },
 313         [IFLA_GENEVE_TOS]               = { .type = NLA_U8 },
 314         [IFLA_GENEVE_PORT]              = { .type = NLA_U16 },
 315 };
 316
 317 static int geneve_validate(struct nlattr *tb[], struct nlattr *data[])
 318 {
 319         if (tb[IFLA_ADDRESS]) {
 320                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 321                         return -EINVAL;
 322
 323                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 324                         return -EADDRNOTAVAIL;
 325         }
 326
 327         if (!data)
 328                 return -EINVAL;
 329
 330         if (data[IFLA_GENEVE_ID]) {
 331                 __u32 vni =  nla_get_u32(data[IFLA_GENEVE_ID]);
 332
 333                 if (vni >= GENEVE_VID_MASK)
 334                         return -ERANGE;
 335         }
 336
 337         return 0;
 338 }
 339
 340 static int geneve_newlink(struct net *net, struct net_device *dev,
 341                          struct nlattr *tb[], struct nlattr *data[])
 342 {
 343         struct geneve_net *gn = net_generic(net, geneve_net_id);
 344         struct geneve_dev *dummy, *geneve = netdev_priv(dev);
 345         struct hlist_head *vni_list_head;
 346         struct sockaddr_in remote;      /* IPv4 address for link partner */
 347         __u32 vni, hash;
 348         __be16 dst_port;
 349         int err;
 350
 351         if (!data[IFLA_GENEVE_ID] || !data[IFLA_GENEVE_REMOTE])
 352                 return -EINVAL;
 353
 354         geneve->net = net;
 355         geneve->dev = dev;
 356
 357         vni = nla_get_u32(data[IFLA_GENEVE_ID]);
 358         geneve->vni[0] = (vni & 0x00ff0000) >> 16;
 359         geneve->vni[1] = (vni & 0x0000ff00) >> 8;
 360         geneve->vni[2] =  vni & 0x000000ff;
 361
 362         geneve->remote.sin_addr.s_addr =
 363                 nla_get_in_addr(data[IFLA_GENEVE_REMOTE]);
 364         if (IN_MULTICAST(ntohl(geneve->remote.sin_addr.s_addr)))
 365                 return -EINVAL;
 366
 367         if (data[IFLA_GENEVE_PORT])
 368                 dst_port = htons(nla_get_u16(data[IFLA_GENEVE_PORT]));
 369         else
 370                 dst_port = htons(GENEVE_UDP_PORT);
 371
 372         remote = geneve->remote;
 373         hash = geneve_net_vni_hash(geneve->vni);
 374         vni_list_head = &gn->vni_list[hash];
 375         hlist_for_each_entry_rcu(dummy, vni_list_head, hlist) {
 376                 if (!memcmp(geneve->vni, dummy->vni, sizeof(dummy->vni)) &&
 377                     !memcmp(&remote, &dummy->remote, sizeof(dummy->remote)) &&
 378                     dst_port == dummy->dst_port) {
 379                         return -EBUSY;
 380                 }
 381         }
 382
 383         err = register_netdevice(dev);
 384         if (err)
 385                 return err;
 386
 387         if (data[IFLA_GENEVE_TTL])
 388                 geneve->ttl = nla_get_u8(data[IFLA_GENEVE_TTL]);
 389
 390         if (data[IFLA_GENEVE_TOS])
 391                 geneve->tos = nla_get_u8(data[IFLA_GENEVE_TOS]);
 392
 393         geneve->dst_port = dst_port;
 394         list_add(&geneve->next, &gn->geneve_list);
 395
 396         hlist_add_head_rcu(&geneve->hlist, &gn->vni_list[hash]);
 397
 398         return 0;
 399 }
 400
 401 static void geneve_dellink(struct net_device *dev, struct list_head *head)
 402 {
 403         struct geneve_dev *geneve = netdev_priv(dev);
 404
 405         if (!hlist_unhashed(&geneve->hlist))
 406                 hlist_del_rcu(&geneve->hlist);
 407
 408         list_del(&geneve->next);
 409         unregister_netdevice_queue(dev, head);
 410 }
 411
 412 static size_t geneve_get_size(const struct net_device *dev)
 413 {
 414         return nla_total_size(sizeof(__u32)) +  /* IFLA_GENEVE_ID */
 415                 nla_total_size(sizeof(struct in_addr)) + /* IFLA_GENEVE_REMOTE */
 416                 nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_TTL */
 417                 nla_total_size(sizeof(__u8)) +  /* IFLA_GENEVE_TOS */
 418                 nla_total_size(sizeof(__u16)) +  /* IFLA_GENEVE_PORT */
 419                 0;
 420 }
 421
 422 static int geneve_fill_info(struct sk_buff *skb, const struct net_device *dev)
 423 {
 424         struct geneve_dev *geneve = netdev_priv(dev);
 425         __u32 vni;
 426
 427         vni = (geneve->vni[0] << 16) | (geneve->vni[1] << 8) | geneve->vni[2];
 428         if (nla_put_u32(skb, IFLA_GENEVE_ID, vni))
 429                 goto nla_put_failure;
 430
 431         if (nla_put_in_addr(skb, IFLA_GENEVE_REMOTE,
 432                             geneve->remote.sin_addr.s_addr))
 433                 goto nla_put_failure;
 434
 435         if (nla_put_u8(skb, IFLA_GENEVE_TTL, geneve->ttl) ||
 436             nla_put_u8(skb, IFLA_GENEVE_TOS, geneve->tos))
 437                 goto nla_put_failure;
 438
 439         if (nla_put_u16(skb, IFLA_GENEVE_PORT, ntohs(geneve->dst_port)))
 440                 goto nla_put_failure;
 441
 442         return 0;
 443
 444 nla_put_failure:
 445         return -EMSGSIZE;
 446 }
 447
 448 static struct rtnl_link_ops geneve_link_ops __read_mostly = {
 449         .kind           = "geneve",
 450         .maxtype        = IFLA_GENEVE_MAX,
 451         .policy         = geneve_policy,
 452         .priv_size      = sizeof(struct geneve_dev),
 453         .setup          = geneve_setup,
 454         .validate       = geneve_validate,
 455         .newlink        = geneve_newlink,
 456         .dellink        = geneve_dellink,
 457         .get_size       = geneve_get_size,
 458         .fill_info      = geneve_fill_info,
 459 };
 460
 461 static __net_init int geneve_init_net(struct net *net)
 462 {
 463         struct geneve_net *gn = net_generic(net, geneve_net_id);
 464         unsigned int h;
 465
 466         INIT_LIST_HEAD(&gn->geneve_list);
 467
 468         for (h = 0; h < VNI_HASH_SIZE; ++h)
 469                 INIT_HLIST_HEAD(&gn->vni_list[h]);
 470
 471         return 0;
 472 }
 473
 474 static void __net_exit geneve_exit_net(struct net *net)
 475 {
 476         struct geneve_net *gn = net_generic(net, geneve_net_id);
 477         struct geneve_dev *geneve, *next;
 478         struct net_device *dev, *aux;
 479         LIST_HEAD(list);
 480
 481         rtnl_lock();
 482
 483         /* gather any geneve devices that were moved into this ns */
 484         for_each_netdev_safe(net, dev, aux)
 485                 if (dev->rtnl_link_ops == &geneve_link_ops)
 486                         unregister_netdevice_queue(dev, &list);
 487
 488         /* now gather any other geneve devices that were created in this ns */
 489         list_for_each_entry_safe(geneve, next, &gn->geneve_list, next) {
 490                 /* If geneve->dev is in the same netns, it was already added
 491                  * to the list by the previous loop.
 492                  */
 493                 if (!net_eq(dev_net(geneve->dev), net))
 494                         unregister_netdevice_queue(geneve->dev, &list);
 495         }
 496
 497         /* unregister the devices gathered above */
 498         unregister_netdevice_many(&list);
 499         rtnl_unlock();
 500 }
 501
 502 static struct pernet_operations geneve_net_ops = {
 503         .init = geneve_init_net,
 504         .exit = geneve_exit_net,
 505         .id   = &geneve_net_id,
 506         .size = sizeof(struct geneve_net),
 507 };
 508
 509 static int __init geneve_init_module(void)
 510 {
 511         int rc;
 512
 513         rc = register_pernet_subsys(&geneve_net_ops);
 514         if (rc)
 515                 goto out1;
 516
 517         rc = rtnl_link_register(&geneve_link_ops);
 518         if (rc)
 519                 goto out2;
 520
 521         return 0;
 522 out2:
 523         unregister_pernet_subsys(&geneve_net_ops);
 524 out1:
 525         return rc;
 526 }
 527 late_initcall(geneve_init_module);
 528
 529 static void __exit geneve_cleanup_module(void)
 530 {
 531         rtnl_link_unregister(&geneve_link_ops);
 532         unregister_pernet_subsys(&geneve_net_ops);
 533 }
 534 module_exit(geneve_cleanup_module);
 535
 536 MODULE_LICENSE("GPL");
 537 MODULE_VERSION(GENEVE_NETDEV_VER);
 538 MODULE_AUTHOR("John W. Linville <linville@tuxdriver.com>");
 539 MODULE_DESCRIPTION("Interface driver for GENEVE encapsulated traffic");
 540 MODULE_ALIAS_RTNL_LINK("geneve");