datapath/vport.c

   1 /*
   2  * Copyright (c) 2007-2015 Nicira, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of version 2 of the GNU General Public
   6  * License as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  16  * 02110-1301, USA
  17  */
  18
  19 #include <linux/etherdevice.h>
  20 #include <linux/if.h>
  21 #include <linux/if_vlan.h>
  22 #include <linux/jhash.h>
  23 #include <linux/kernel.h>
  24 #include <linux/list.h>
  25 #include <linux/mutex.h>
  26 #include <linux/percpu.h>
  27 #include <linux/rcupdate.h>
  28 #include <linux/rtnetlink.h>
  29 #include <linux/compat.h>
  30 #include <linux/module.h>
  31 #include <linux/if_link.h>
  32 #include <net/net_namespace.h>
  33 #include <net/lisp.h>
  34 #include <net/gre.h>
  35 #include <net/geneve.h>
  36 #include <net/stt.h>
  37 #include <net/vxlan.h>
  38
  39 #include "datapath.h"
  40 #include "gso.h"
  41 #include "vport.h"
  42 #include "vport-internal_dev.h"
  43
  44 static LIST_HEAD(vport_ops_list);
  45 static bool compat_gre_loaded = false;
  46 static bool compat_ip6_tunnel_loaded = false;
  47
  48 /* Protected by RCU read lock for reading, ovs_mutex for writing. */
  49 static struct hlist_head *dev_table;
  50 #define VPORT_HASH_BUCKETS 1024
  51
  52 /**
  53  *      ovs_vport_init - initialize vport subsystem
  54  *
  55  * Called at module load time to initialize the vport subsystem.
  56  */
  57 int ovs_vport_init(void)
  58 {
  59         int err;
  60
  61         dev_table = kcalloc(VPORT_HASH_BUCKETS, sizeof(struct hlist_head),
  62                             GFP_KERNEL);
  63         if (!dev_table)
  64                 return -ENOMEM;
  65
  66         err = lisp_init_module();
  67         if (err)
  68                 goto err_lisp;
  69         err = gre_init();
  70         if (err && err != -EEXIST) {
  71                 goto err_gre;
  72         } else {
  73                 if (err == -EEXIST) {
  74                         pr_warn("Cannot take GRE protocol rx entry"\
  75                                 "- The GRE/ERSPAN rx feature not supported\n");
  76                         /* continue GRE tx */
  77                 }
  78
  79                 err = ipgre_init();
  80                 if (err && err != -EEXIST)
  81                         goto err_ipgre;
  82                 compat_gre_loaded = true;
  83         }
  84         err = ip6gre_init();
  85         if (err && err != -EEXIST) {
  86                 goto err_ip6gre;
  87         } else {
  88                 if (err == -EEXIST) {
  89                         pr_warn("IPv6 GRE/ERSPAN Rx mode is not supported\n");
  90                         goto skip_ip6_tunnel_init;
  91                 }
  92         }
  93
  94         err = ip6_tunnel_init();
  95         if (err)
  96                 goto err_ip6_tunnel;
  97         else
  98                 compat_ip6_tunnel_loaded = true;
  99
 100 skip_ip6_tunnel_init:
 101         err = geneve_init_module();
 102         if (err)
 103                 goto err_geneve;
 104         err = vxlan_init_module();
 105         if (err)
 106                 goto err_vxlan;
 107         err = ovs_stt_init_module();
 108         if (err)
 109                 goto err_stt;
 110
 111         return 0;
 112         ovs_stt_cleanup_module();
 113 err_stt:
 114         vxlan_cleanup_module();
 115 err_vxlan:
 116         geneve_cleanup_module();
 117 err_geneve:
 118         ip6_tunnel_cleanup();
 119 err_ip6_tunnel:
 120         ip6gre_fini();
 121 err_ip6gre:
 122         ipgre_fini();
 123 err_ipgre:
 124         gre_exit();
 125 err_gre:
 126         lisp_cleanup_module();
 127 err_lisp:
 128         kfree(dev_table);
 129         return err;
 130 }
 131
 132 /**
 133  *      ovs_vport_exit - shutdown vport subsystem
 134  *
 135  * Called at module exit time to shutdown the vport subsystem.
 136  */
 137 void ovs_vport_exit(void)
 138 {
 139         if (compat_gre_loaded) {
 140                 gre_exit();
 141                 ipgre_fini();
 142         }
 143         ovs_stt_cleanup_module();
 144         vxlan_cleanup_module();
 145         geneve_cleanup_module();
 146         if (compat_ip6_tunnel_loaded)
 147                 ip6_tunnel_cleanup();
 148         ip6gre_fini();
 149         lisp_cleanup_module();
 150         kfree(dev_table);
 151 }
 152
 153 static struct hlist_head *hash_bucket(const struct net *net, const char *name)
 154 {
 155         unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
 156         return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
 157 }
 158
 159 int __ovs_vport_ops_register(struct vport_ops *ops)
 160 {
 161         int err = -EEXIST;
 162         struct vport_ops *o;
 163
 164         ovs_lock();
 165         list_for_each_entry(o, &vport_ops_list, list)
 166                 if (ops->type == o->type)
 167                         goto errout;
 168
 169         list_add_tail(&ops->list, &vport_ops_list);
 170         err = 0;
 171 errout:
 172         ovs_unlock();
 173         return err;
 174 }
 175 EXPORT_SYMBOL_GPL(__ovs_vport_ops_register);
 176
 177 void ovs_vport_ops_unregister(struct vport_ops *ops)
 178 {
 179         ovs_lock();
 180         list_del(&ops->list);
 181         ovs_unlock();
 182 }
 183 EXPORT_SYMBOL_GPL(ovs_vport_ops_unregister);
 184
 185 /**
 186  *      ovs_vport_locate - find a port that has already been created
 187  *
 188  * @name: name of port to find
 189  *
 190  * Must be called with ovs or RCU read lock.
 191  */
 192 struct vport *ovs_vport_locate(const struct net *net, const char *name)
 193 {
 194         struct hlist_head *bucket = hash_bucket(net, name);
 195         struct vport *vport;
 196
 197         hlist_for_each_entry_rcu(vport, bucket, hash_node)
 198                 if (!strcmp(name, ovs_vport_name(vport)) &&
 199                     net_eq(ovs_dp_get_net(vport->dp), net))
 200                         return vport;
 201
 202         return NULL;
 203 }
 204
 205 /**
 206  *      ovs_vport_alloc - allocate and initialize new vport
 207  *
 208  * @priv_size: Size of private data area to allocate.
 209  * @ops: vport device ops
 210  *
 211  * Allocate and initialize a new vport defined by @ops.  The vport will contain
 212  * a private data area of size @priv_size that can be accessed using
 213  * vport_priv().  vports that are no longer needed should be released with
 214  * vport_free().
 215  */
 216 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
 217                           const struct vport_parms *parms)
 218 {
 219         struct vport *vport;
 220         size_t alloc_size;
 221
 222         alloc_size = sizeof(struct vport);
 223         if (priv_size) {
 224                 alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
 225                 alloc_size += priv_size;
 226         }
 227
 228         vport = kzalloc(alloc_size, GFP_KERNEL);
 229         if (!vport)
 230                 return ERR_PTR(-ENOMEM);
 231
 232         vport->dp = parms->dp;
 233         vport->port_no = parms->port_no;
 234         vport->ops = ops;
 235         INIT_HLIST_NODE(&vport->dp_hash_node);
 236
 237         if (ovs_vport_set_upcall_portids(vport, parms->upcall_portids)) {
 238                 kfree(vport);
 239                 return ERR_PTR(-EINVAL);
 240         }
 241
 242         return vport;
 243 }
 244 EXPORT_SYMBOL_GPL(ovs_vport_alloc);
 245
 246 /**
 247  *      ovs_vport_free - uninitialize and free vport
 248  *
 249  * @vport: vport to free
 250  *
 251  * Frees a vport allocated with vport_alloc() when it is no longer needed.
 252  *
 253  * The caller must ensure that an RCU grace period has passed since the last
 254  * time @vport was in a datapath.
 255  */
 256 void ovs_vport_free(struct vport *vport)
 257 {
 258         /* vport is freed from RCU callback or error path, Therefore
 259          * it is safe to use raw dereference.
 260          */
 261         kfree(rcu_dereference_raw(vport->upcall_portids));
 262         kfree(vport);
 263 }
 264 EXPORT_SYMBOL_GPL(ovs_vport_free);
 265
 266 static struct vport_ops *ovs_vport_lookup(const struct vport_parms *parms)
 267 {
 268         struct vport_ops *ops;
 269
 270         list_for_each_entry(ops, &vport_ops_list, list)
 271                 if (ops->type == parms->type)
 272                         return ops;
 273
 274         return NULL;
 275 }
 276
 277 /**
 278  *      ovs_vport_add - add vport device (for kernel callers)
 279  *
 280  * @parms: Information about new vport.
 281  *
 282  * Creates a new vport with the specified configuration (which is dependent on
 283  * device type).  ovs_mutex must be held.
 284  */
 285 struct vport *ovs_vport_add(const struct vport_parms *parms)
 286 {
 287         struct vport_ops *ops;
 288         struct vport *vport;
 289
 290         ops = ovs_vport_lookup(parms);
 291         if (ops) {
 292                 struct hlist_head *bucket;
 293
 294                 if (!try_module_get(ops->owner))
 295                         return ERR_PTR(-EAFNOSUPPORT);
 296
 297                 vport = ops->create(parms);
 298                 if (IS_ERR(vport)) {
 299                         module_put(ops->owner);
 300                         return vport;
 301                 }
 302
 303                 bucket = hash_bucket(ovs_dp_get_net(vport->dp),
 304                                      ovs_vport_name(vport));
 305                 hlist_add_head_rcu(&vport->hash_node, bucket);
 306                 return vport;
 307         }
 308
 309         if (parms->type == OVS_VPORT_TYPE_GRE && !compat_gre_loaded) {
 310                 pr_warn("GRE protocol already loaded!\n");
 311                 return ERR_PTR(-EAFNOSUPPORT);
 312         }
 313         /* Unlock to attempt module load and return -EAGAIN if load
 314          * was successful as we need to restart the port addition
 315          * workflow.
 316          */
 317         ovs_unlock();
 318         request_module("vport-type-%d", parms->type);
 319         ovs_lock();
 320
 321         if (!ovs_vport_lookup(parms))
 322                 return ERR_PTR(-EAFNOSUPPORT);
 323         else
 324                 return ERR_PTR(-EAGAIN);
 325 }
 326
 327 /**
 328  *      ovs_vport_set_options - modify existing vport device (for kernel callers)
 329  *
 330  * @vport: vport to modify.
 331  * @options: New configuration.
 332  *
 333  * Modifies an existing device with the specified configuration (which is
 334  * dependent on device type).  ovs_mutex must be held.
 335  */
 336 int ovs_vport_set_options(struct vport *vport, struct nlattr *options)
 337 {
 338         if (!vport->ops->set_options)
 339                 return -EOPNOTSUPP;
 340         return vport->ops->set_options(vport, options);
 341 }
 342
 343 /**
 344  *      ovs_vport_del - delete existing vport device
 345  *
 346  * @vport: vport to delete.
 347  *
 348  * Detaches @vport from its datapath and destroys it.  ovs_mutex must be
 349  * held.
 350  */
 351 void ovs_vport_del(struct vport *vport)
 352 {
 353         ASSERT_OVSL();
 354
 355         hlist_del_rcu(&vport->hash_node);
 356         module_put(vport->ops->owner);
 357         vport->ops->destroy(vport);
 358 }
 359
 360 /**
 361  *      ovs_vport_get_stats - retrieve device stats
 362  *
 363  * @vport: vport from which to retrieve the stats
 364  * @stats: location to store stats
 365  *
 366  * Retrieves transmit, receive, and error stats for the given device.
 367  *
 368  * Must be called with ovs_mutex or rcu_read_lock.
 369  */
 370 void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats)
 371 {
 372         const struct rtnl_link_stats64 *dev_stats;
 373         struct rtnl_link_stats64 temp;
 374
 375         dev_stats = dev_get_stats(vport->dev, &temp);
 376         stats->rx_errors  = dev_stats->rx_errors;
 377         stats->tx_errors  = dev_stats->tx_errors;
 378         stats->tx_dropped = dev_stats->tx_dropped;
 379         stats->rx_dropped = dev_stats->rx_dropped;
 380
 381         stats->rx_bytes   = dev_stats->rx_bytes;
 382         stats->rx_packets = dev_stats->rx_packets;
 383         stats->tx_bytes   = dev_stats->tx_bytes;
 384         stats->tx_packets = dev_stats->tx_packets;
 385 }
 386
 387 /**
 388  *      ovs_vport_get_options - retrieve device options
 389  *
 390  * @vport: vport from which to retrieve the options.
 391  * @skb: sk_buff where options should be appended.
 392  *
 393  * Retrieves the configuration of the given device, appending an
 394  * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested
 395  * vport-specific attributes to @skb.
 396  *
 397  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another
 398  * negative error code if a real error occurred.  If an error occurs, @skb is
 399  * left unmodified.
 400  *
 401  * Must be called with ovs_mutex or rcu_read_lock.
 402  */
 403 int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb)
 404 {
 405         struct nlattr *nla;
 406         int err;
 407
 408         if (!vport->ops->get_options)
 409                 return 0;
 410
 411         nla = nla_nest_start_noflag(skb, OVS_VPORT_ATTR_OPTIONS);
 412         if (!nla)
 413                 return -EMSGSIZE;
 414
 415         err = vport->ops->get_options(vport, skb);
 416         if (err) {
 417                 nla_nest_cancel(skb, nla);
 418                 return err;
 419         }
 420
 421         nla_nest_end(skb, nla);
 422         return 0;
 423 }
 424
 425 /**
 426  *      ovs_vport_set_upcall_portids - set upcall portids of @vport.
 427  *
 428  * @vport: vport to modify.
 429  * @ids: new configuration, an array of port ids.
 430  *
 431  * Sets the vport's upcall_portids to @ids.
 432  *
 433  * Returns 0 if successful, -EINVAL if @ids is zero length or cannot be parsed
 434  * as an array of U32.
 435  *
 436  * Must be called with ovs_mutex.
 437  */
 438 int ovs_vport_set_upcall_portids(struct vport *vport, const struct nlattr *ids)
 439 {
 440         struct vport_portids *old, *vport_portids;
 441
 442         if (!nla_len(ids) || nla_len(ids) % sizeof(u32))
 443                 return -EINVAL;
 444
 445         old = ovsl_dereference(vport->upcall_portids);
 446
 447         vport_portids = kmalloc(sizeof(*vport_portids) + nla_len(ids),
 448                                 GFP_KERNEL);
 449         if (!vport_portids)
 450                 return -ENOMEM;
 451
 452         vport_portids->n_ids = nla_len(ids) / sizeof(u32);
 453         vport_portids->rn_ids = reciprocal_value(vport_portids->n_ids);
 454         nla_memcpy(vport_portids->ids, ids, nla_len(ids));
 455
 456         rcu_assign_pointer(vport->upcall_portids, vport_portids);
 457
 458         if (old)
 459                 kfree_rcu(old, rcu);
 460         return 0;
 461 }
 462
 463 /**
 464  *      ovs_vport_get_upcall_portids - get the upcall_portids of @vport.
 465  *
 466  * @vport: vport from which to retrieve the portids.
 467  * @skb: sk_buff where portids should be appended.
 468  *
 469  * Retrieves the configuration of the given vport, appending the
 470  * %OVS_VPORT_ATTR_UPCALL_PID attribute which is the array of upcall
 471  * portids to @skb.
 472  *
 473  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room.
 474  * If an error occurs, @skb is left unmodified.  Must be called with
 475  * ovs_mutex or rcu_read_lock.
 476  */
 477 int ovs_vport_get_upcall_portids(const struct vport *vport,
 478                                  struct sk_buff *skb)
 479 {
 480         struct vport_portids *ids;
 481
 482         ids = rcu_dereference_ovsl(vport->upcall_portids);
 483
 484         if (vport->dp->user_features & OVS_DP_F_VPORT_PIDS)
 485                 return nla_put(skb, OVS_VPORT_ATTR_UPCALL_PID,
 486                                ids->n_ids * sizeof(u32), (void *)ids->ids);
 487         else
 488                 return nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, ids->ids[0]);
 489 }
 490
 491 /**
 492  *      ovs_vport_find_upcall_portid - find the upcall portid to send upcall.
 493  *
 494  * @vport: vport from which the missed packet is received.
 495  * @skb: skb that the missed packet was received.
 496  *
 497  * Uses the skb_get_hash() to select the upcall portid to send the
 498  * upcall.
 499  *
 500  * Returns the portid of the target socket.  Must be called with rcu_read_lock.
 501  */
 502 u32 ovs_vport_find_upcall_portid(const struct vport *vport, struct sk_buff *skb)
 503 {
 504         struct vport_portids *ids;
 505         u32 ids_index;
 506         u32 hash;
 507
 508         ids = rcu_dereference(vport->upcall_portids);
 509
 510         if (ids->n_ids == 1 && ids->ids[0] == 0)
 511                 return 0;
 512
 513         hash = skb_get_hash(skb);
 514         ids_index = hash - ids->n_ids * reciprocal_divide(hash, ids->rn_ids);
 515         return ids->ids[ids_index];
 516 }
 517
 518 /**
 519  *      ovs_vport_receive - pass up received packet to the datapath for processing
 520  *
 521  * @vport: vport that received the packet
 522  * @skb: skb that was received
 523  * @tun_key: tunnel (if any) that carried packet
 524  *
 525  * Must be called with rcu_read_lock.  The packet cannot be shared and
 526  * skb->data should point to the Ethernet header.
 527  */
 528 int ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
 529                       const struct ip_tunnel_info *tun_info)
 530 {
 531         struct sw_flow_key key;
 532         int error;
 533
 534         OVS_CB(skb)->input_vport = vport;
 535         OVS_CB(skb)->mru = 0;
 536         OVS_CB(skb)->cutlen = 0;
 537         if (unlikely(dev_net(skb->dev) != ovs_dp_get_net(vport->dp))) {
 538                 u32 mark;
 539
 540                 mark = skb->mark;
 541                 skb_scrub_packet(skb, true);
 542                 skb->mark = mark;
 543                 tun_info = NULL;
 544         }
 545
 546         ovs_skb_init_inner_protocol(skb);
 547         skb_clear_ovs_gso_cb(skb);
 548         /* Extract flow from 'skb' into 'key'. */
 549         error = ovs_flow_key_extract(tun_info, skb, &key);
 550         if (unlikely(error)) {
 551                 kfree_skb(skb);
 552                 return error;
 553         }
 554         ovs_dp_process_packet(skb, &key);
 555         return 0;
 556 }
 557
 558 static int packet_length(const struct sk_buff *skb,
 559                          struct net_device *dev)
 560 {
 561         int length = skb->len - dev->hard_header_len;
 562
 563         if (!skb_vlan_tag_present(skb) &&
 564             eth_type_vlan(skb->protocol))
 565                 length -= VLAN_HLEN;
 566
 567         /* Don't subtract for multiple VLAN tags. Most (all?) drivers allow
 568          * (ETH_LEN + VLAN_HLEN) in addition to the mtu value, but almost none
 569          * account for 802.1ad. e.g. is_skb_forwardable().
 570          */
 571
 572         return length > 0 ? length: 0;
 573 }
 574
 575 void ovs_vport_send(struct vport *vport, struct sk_buff *skb, u8 mac_proto)
 576 {
 577         int mtu = vport->dev->mtu;
 578
 579         switch (vport->dev->type) {
 580         case ARPHRD_NONE:
 581                 if (mac_proto == MAC_PROTO_ETHERNET) {
 582                         skb_reset_network_header(skb);
 583                         skb_reset_mac_len(skb);
 584                         skb->protocol = htons(ETH_P_TEB);
 585                 } else if (mac_proto != MAC_PROTO_NONE) {
 586                         WARN_ON_ONCE(1);
 587                         goto drop;
 588                 }
 589                 break;
 590         case ARPHRD_ETHER:
 591                 if (mac_proto != MAC_PROTO_ETHERNET)
 592                         goto drop;
 593                 break;
 594         default:
 595                 goto drop;
 596         }
 597
 598         if (unlikely(packet_length(skb, vport->dev) > mtu &&
 599                      !skb_is_gso(skb))) {
 600                 net_warn_ratelimited("%s: dropped over-mtu packet: %d > %d\n",
 601                                      vport->dev->name,
 602                                      packet_length(skb, vport->dev), mtu);
 603                 vport->dev->stats.tx_errors++;
 604                 goto drop;
 605         }
 606
 607         skb->dev = vport->dev;
 608         vport->ops->send(skb);
 609         return;
 610
 611 drop:
 612         kfree_skb(skb);
 613 }