datapath/vport.c

   1 /*
   2  * Copyright (c) 2007-2012 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/kconfig.h>
  24 #include <linux/kernel.h>
  25 #include <linux/list.h>
  26 #include <linux/mutex.h>
  27 #include <linux/percpu.h>
  28 #include <linux/rcupdate.h>
  29 #include <linux/rtnetlink.h>
  30 #include <linux/compat.h>
  31 #include <linux/version.h>
  32 #include <net/net_namespace.h>
  33
  34 #include "datapath.h"
  35 #include "gso.h"
  36 #include "vport.h"
  37 #include "vport-internal_dev.h"
  38
  39 static void ovs_vport_record_error(struct vport *,
  40                                    enum vport_err_type err_type);
  41
  42 /* List of statically compiled vport implementations.  Don't forget to also
  43  * add yours to the list at the bottom of vport.h.
  44  */
  45 static const struct vport_ops *vport_ops_list[] = {
  46         &ovs_netdev_vport_ops,
  47         &ovs_internal_vport_ops,
  48         &ovs_geneve_vport_ops,
  49 #if IS_ENABLED(CONFIG_NET_IPGRE_DEMUX)
  50         &ovs_gre_vport_ops,
  51         &ovs_gre64_vport_ops,
  52 #endif
  53         &ovs_vxlan_vport_ops,
  54         &ovs_lisp_vport_ops,
  55 };
  56
  57 /* Protected by RCU read lock for reading, ovs_mutex for writing. */
  58 static struct hlist_head *dev_table;
  59 #define VPORT_HASH_BUCKETS 1024
  60
  61 /**
  62  *      ovs_vport_init - initialize vport subsystem
  63  *
  64  * Called at module load time to initialize the vport subsystem.
  65  */
  66 int ovs_vport_init(void)
  67 {
  68         dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
  69                             GFP_KERNEL);
  70         if (!dev_table)
  71                 return -ENOMEM;
  72
  73         return 0;
  74 }
  75
  76 /**
  77  *      ovs_vport_exit - shutdown vport subsystem
  78  *
  79  * Called at module exit time to shutdown the vport subsystem.
  80  */
  81 void ovs_vport_exit(void)
  82 {
  83         kfree(dev_table);
  84 }
  85
  86 static struct hlist_head *hash_bucket(const struct net *net, const char *name)
  87 {
  88         unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
  89         return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
  90 }
  91
  92 /**
  93  *      ovs_vport_locate - find a port that has already been created
  94  *
  95  * @name: name of port to find
  96  *
  97  * Must be called with ovs or RCU read lock.
  98  */
  99 struct vport *ovs_vport_locate(const struct net *net, const char *name)
 100 {
 101         struct hlist_head *bucket = hash_bucket(net, name);
 102         struct vport *vport;
 103
 104         hlist_for_each_entry_rcu(vport, bucket, hash_node)
 105                 if (!strcmp(name, vport->ops->get_name(vport)) &&
 106                     net_eq(ovs_dp_get_net(vport->dp), net))
 107                         return vport;
 108
 109         return NULL;
 110 }
 111
 112 /**
 113  *      ovs_vport_alloc - allocate and initialize new vport
 114  *
 115  * @priv_size: Size of private data area to allocate.
 116  * @ops: vport device ops
 117  *
 118  * Allocate and initialize a new vport defined by @ops.  The vport will contain
 119  * a private data area of size @priv_size that can be accessed using
 120  * vport_priv().  vports that are no longer needed should be released with
 121  * ovs_vport_free().
 122  */
 123 struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
 124                               const struct vport_parms *parms)
 125 {
 126         struct vport *vport;
 127         size_t alloc_size;
 128
 129         alloc_size = sizeof(struct vport);
 130         if (priv_size) {
 131                 alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
 132                 alloc_size += priv_size;
 133         }
 134
 135         vport = kzalloc(alloc_size, GFP_KERNEL);
 136         if (!vport)
 137                 return ERR_PTR(-ENOMEM);
 138
 139         vport->dp = parms->dp;
 140         vport->port_no = parms->port_no;
 141         vport->ops = ops;
 142         INIT_HLIST_NODE(&vport->dp_hash_node);
 143
 144         if (ovs_vport_set_upcall_portids(vport, parms->upcall_portids)) {
 145                 kfree(vport);
 146                 return ERR_PTR(-EINVAL);
 147         }
 148
 149         vport->percpu_stats = netdev_alloc_pcpu_stats(struct pcpu_sw_netstats);
 150         if (!vport->percpu_stats) {
 151                 kfree(vport);
 152                 return ERR_PTR(-ENOMEM);
 153         }
 154
 155         return vport;
 156 }
 157
 158 /**
 159  *      ovs_vport_free - uninitialize and free vport
 160  *
 161  * @vport: vport to free
 162  *
 163  * Frees a vport allocated with ovs_vport_alloc() when it is no longer needed.
 164  *
 165  * The caller must ensure that an RCU grace period has passed since the last
 166  * time @vport was in a datapath.
 167  */
 168 void ovs_vport_free(struct vport *vport)
 169 {
 170         kfree(rcu_dereference_raw(vport->upcall_portids));
 171         free_percpu(vport->percpu_stats);
 172         kfree(vport);
 173 }
 174
 175 /**
 176  *      ovs_vport_add - add vport device (for kernel callers)
 177  *
 178  * @parms: Information about new vport.
 179  *
 180  * Creates a new vport with the specified configuration (which is dependent on
 181  * device type).  ovs_mutex must be held.
 182  */
 183 struct vport *ovs_vport_add(const struct vport_parms *parms)
 184 {
 185         struct vport *vport;
 186         int err = 0;
 187         int i;
 188
 189         for (i = 0; i < ARRAY_SIZE(vport_ops_list); i++) {
 190                 if (vport_ops_list[i]->type == parms->type) {
 191                         struct hlist_head *bucket;
 192
 193                         vport = vport_ops_list[i]->create(parms);
 194                         if (IS_ERR(vport)) {
 195                                 err = PTR_ERR(vport);
 196                                 goto out;
 197                         }
 198
 199                         bucket = hash_bucket(ovs_dp_get_net(vport->dp),
 200                                              vport->ops->get_name(vport));
 201                         hlist_add_head_rcu(&vport->hash_node, bucket);
 202                         return vport;
 203                 }
 204         }
 205
 206         err = -EAFNOSUPPORT;
 207
 208 out:
 209         return ERR_PTR(err);
 210 }
 211
 212 /**
 213  *      ovs_vport_set_options - modify existing vport device (for kernel callers)
 214  *
 215  * @vport: vport to modify.
 216  * @options: New configuration.
 217  *
 218  * Modifies an existing device with the specified configuration (which is
 219  * dependent on device type).  ovs_mutex must be held.
 220  */
 221 int ovs_vport_set_options(struct vport *vport, struct nlattr *options)
 222 {
 223         if (!vport->ops->set_options)
 224                 return -EOPNOTSUPP;
 225         return vport->ops->set_options(vport, options);
 226 }
 227
 228 /**
 229  *      ovs_vport_del - delete existing vport device
 230  *
 231  * @vport: vport to delete.
 232  *
 233  * Detaches @vport from its datapath and destroys it.  It is possible to fail
 234  * for reasons such as lack of memory.  ovs_mutex must be held.
 235  */
 236 void ovs_vport_del(struct vport *vport)
 237 {
 238         ASSERT_OVSL();
 239
 240         hlist_del_rcu(&vport->hash_node);
 241         vport->ops->destroy(vport);
 242 }
 243
 244 /**
 245  *      ovs_vport_get_stats - retrieve device stats
 246  *
 247  * @vport: vport from which to retrieve the stats
 248  * @stats: location to store stats
 249  *
 250  * Retrieves transmit, receive, and error stats for the given device.
 251  *
 252  * Must be called with ovs_mutex or rcu_read_lock.
 253  */
 254 void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats)
 255 {
 256         int i;
 257
 258         /* We potentially have two surces of stats that need to be
 259          * combined: those we have collected (split into err_stats and
 260          * percpu_stats), and device error stats from netdev->get_stats()
 261          * (for errors that happen downstream and therefore aren't
 262          * reported through our vport_record_error() function).
 263          * Stats from first source are reported by ovs over
 264          * OVS_VPORT_ATTR_STATS.
 265          * netdev-stats can be directly read over netlink-ioctl.
 266          */
 267
 268         stats->rx_errors  = atomic_long_read(&vport->err_stats.rx_errors);
 269         stats->tx_errors  = atomic_long_read(&vport->err_stats.tx_errors);
 270         stats->tx_dropped = atomic_long_read(&vport->err_stats.tx_dropped);
 271         stats->rx_dropped = atomic_long_read(&vport->err_stats.rx_dropped);
 272
 273         stats->rx_bytes         = 0;
 274         stats->rx_packets       = 0;
 275         stats->tx_bytes         = 0;
 276         stats->tx_packets       = 0;
 277
 278         for_each_possible_cpu(i) {
 279                 const struct pcpu_sw_netstats *percpu_stats;
 280                 struct pcpu_sw_netstats local_stats;
 281                 unsigned int start;
 282
 283                 percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
 284
 285                 do {
 286                         start = u64_stats_fetch_begin_irq(&percpu_stats->syncp);
 287                         local_stats = *percpu_stats;
 288                 } while (u64_stats_fetch_retry_irq(&percpu_stats->syncp, start));
 289
 290                 stats->rx_bytes         += local_stats.rx_bytes;
 291                 stats->rx_packets       += local_stats.rx_packets;
 292                 stats->tx_bytes         += local_stats.tx_bytes;
 293                 stats->tx_packets       += local_stats.tx_packets;
 294         }
 295 }
 296
 297 /**
 298  *      ovs_vport_get_options - retrieve device options
 299  *
 300  * @vport: vport from which to retrieve the options.
 301  * @skb: sk_buff where options should be appended.
 302  *
 303  * Retrieves the configuration of the given device, appending an
 304  * %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested
 305  * vport-specific attributes to @skb.
 306  *
 307  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another
 308  * negative error code if a real error occurred.  If an error occurs, @skb is
 309  * left unmodified.
 310  *
 311  * Must be called with ovs_mutex or rcu_read_lock.
 312  */
 313 int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb)
 314 {
 315         struct nlattr *nla;
 316         int err;
 317
 318         if (!vport->ops->get_options)
 319                 return 0;
 320
 321         nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS);
 322         if (!nla)
 323                 return -EMSGSIZE;
 324
 325         err = vport->ops->get_options(vport, skb);
 326         if (err) {
 327                 nla_nest_cancel(skb, nla);
 328                 return err;
 329         }
 330
 331         nla_nest_end(skb, nla);
 332         return 0;
 333 }
 334
 335 static void vport_portids_destroy_rcu_cb(struct rcu_head *rcu)
 336 {
 337         struct vport_portids *ids = container_of(rcu, struct vport_portids,
 338                                                  rcu);
 339
 340         kfree(ids);
 341 }
 342
 343 /**
 344  *      ovs_vport_set_upcall_portids - set upcall portids of @vport.
 345  *
 346  * @vport: vport to modify.
 347  * @ids: new configuration, an array of port ids.
 348  *
 349  * Sets the vport's upcall_portids to @ids.
 350  *
 351  * Returns 0 if successful, -EINVAL if @ids is zero length or cannot be parsed
 352  * as an array of U32.
 353  *
 354  * Must be called with ovs_mutex.
 355  */
 356 int ovs_vport_set_upcall_portids(struct vport *vport, const struct nlattr *ids)
 357 {
 358         struct vport_portids *old, *vport_portids;
 359
 360         if (!nla_len(ids) || nla_len(ids) % sizeof(u32))
 361                 return -EINVAL;
 362
 363         old = ovsl_dereference(vport->upcall_portids);
 364
 365         vport_portids = kmalloc(sizeof *vport_portids + nla_len(ids),
 366                                 GFP_KERNEL);
 367         if (!vport_portids)
 368                 return -ENOMEM;
 369
 370         vport_portids->n_ids = nla_len(ids) / sizeof(u32);
 371         vport_portids->rn_ids = reciprocal_value(vport_portids->n_ids);
 372         nla_memcpy(vport_portids->ids, ids, nla_len(ids));
 373
 374         rcu_assign_pointer(vport->upcall_portids, vport_portids);
 375
 376         if (old)
 377                 call_rcu(&old->rcu, vport_portids_destroy_rcu_cb);
 378
 379         return 0;
 380 }
 381
 382 /**
 383  *      ovs_vport_get_upcall_portids - get the upcall_portids of @vport.
 384  *
 385  * @vport: vport from which to retrieve the portids.
 386  * @skb: sk_buff where portids should be appended.
 387  *
 388  * Retrieves the configuration of the given vport, appending the
 389  * %OVS_VPORT_ATTR_UPCALL_PID attribute which is the array of upcall
 390  * portids to @skb.
 391  *
 392  * Returns 0 if successful, -EMSGSIZE if @skb has insufficient room.
 393  * If an error occurs, @skb is left unmodified.  Must be called with
 394  * ovs_mutex or rcu_read_lock.
 395  */
 396 int ovs_vport_get_upcall_portids(const struct vport *vport,
 397                                  struct sk_buff *skb)
 398 {
 399         struct vport_portids *ids;
 400
 401         ids = rcu_dereference_ovsl(vport->upcall_portids);
 402
 403         if (vport->dp->user_features & OVS_DP_F_VPORT_PIDS)
 404                 return nla_put(skb, OVS_VPORT_ATTR_UPCALL_PID,
 405                                ids->n_ids * sizeof(u32), (void *) ids->ids);
 406         else
 407                 return nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, ids->ids[0]);
 408 }
 409
 410 /**
 411  *      ovs_vport_find_upcall_portid - find the upcall portid to send upcall.
 412  *
 413  * @vport: vport from which the missed packet is received.
 414  * @skb: skb that the missed packet was received.
 415  *
 416  * Uses the skb_get_hash() to select the upcall portid to send the
 417  * upcall.
 418  *
 419  * Returns the portid of the target socket.  Must be called with rcu_read_lock.
 420  */
 421 u32 ovs_vport_find_upcall_portid(const struct vport *vport, struct sk_buff *skb)
 422 {
 423         struct vport_portids *ids;
 424         u32 hash;
 425
 426         ids = rcu_dereference(vport->upcall_portids);
 427
 428         if (ids->n_ids == 1 && ids->ids[0] == 0)
 429                 return 0;
 430
 431         hash = skb_get_hash(skb);
 432         return ids->ids[hash - ids->n_ids * reciprocal_divide(hash, ids->rn_ids)];
 433 }
 434
 435 /**
 436  *      ovs_vport_receive - pass up received packet to the datapath for processing
 437  *
 438  * @vport: vport that received the packet
 439  * @skb: skb that was received
 440  * @tun_info: tunnel (if any) that carried packet
 441  *
 442  * Must be called with rcu_read_lock.  The packet cannot be shared and
 443  * skb->data should point to the Ethernet header.  The caller must have already
 444  * called compute_ip_summed() to initialize the checksumming fields.
 445  */
 446 void ovs_vport_receive(struct vport *vport, struct sk_buff *skb,
 447                        const struct ovs_tunnel_info *tun_info)
 448 {
 449         struct pcpu_sw_netstats *stats;
 450         struct sw_flow_key key;
 451         int error;
 452
 453         stats = this_cpu_ptr(vport->percpu_stats);
 454         u64_stats_update_begin(&stats->syncp);
 455         stats->rx_packets++;
 456         stats->rx_bytes += skb->len;
 457         u64_stats_update_end(&stats->syncp);
 458
 459         ovs_skb_init_inner_protocol(skb);
 460         OVS_CB(skb)->input_vport = vport;
 461         OVS_CB(skb)->egress_tun_info = NULL;
 462         error = ovs_flow_key_extract(tun_info, skb, &key);
 463         if (unlikely(error)) {
 464                 kfree_skb(skb);
 465                 return;
 466         }
 467
 468         ovs_dp_process_packet(skb, &key);
 469 }
 470
 471 /**
 472  *      ovs_vport_send - send a packet on a device
 473  *
 474  * @vport: vport on which to send the packet
 475  * @skb: skb to send
 476  *
 477  * Sends the given packet and returns the length of data sent.  Either ovs
 478  * lock or rcu_read_lock must be held.
 479  */
 480 int ovs_vport_send(struct vport *vport, struct sk_buff *skb)
 481 {
 482         int sent = vport->ops->send(vport, skb);
 483
 484         if (likely(sent > 0)) {
 485                 struct pcpu_sw_netstats *stats;
 486
 487                 stats = this_cpu_ptr(vport->percpu_stats);
 488
 489                 u64_stats_update_begin(&stats->syncp);
 490                 stats->tx_packets++;
 491                 stats->tx_bytes += sent;
 492                 u64_stats_update_end(&stats->syncp);
 493         } else if (sent < 0) {
 494                 ovs_vport_record_error(vport, VPORT_E_TX_ERROR);
 495                 kfree_skb(skb);
 496         } else
 497                 ovs_vport_record_error(vport, VPORT_E_TX_DROPPED);
 498
 499         return sent;
 500 }
 501
 502 /**
 503  *      ovs_vport_record_error - indicate device error to generic stats layer
 504  *
 505  * @vport: vport that encountered the error
 506  * @err_type: one of enum vport_err_type types to indicate the error type
 507  *
 508  * If using the vport generic stats layer indicate that an error of the given
 509  * type has occurred.
 510  */
 511 static void ovs_vport_record_error(struct vport *vport,
 512                                    enum vport_err_type err_type)
 513 {
 514         switch (err_type) {
 515         case VPORT_E_RX_DROPPED:
 516                 atomic_long_inc(&vport->err_stats.rx_dropped);
 517                 break;
 518
 519         case VPORT_E_RX_ERROR:
 520                 atomic_long_inc(&vport->err_stats.rx_errors);
 521                 break;
 522
 523         case VPORT_E_TX_DROPPED:
 524                 atomic_long_inc(&vport->err_stats.tx_dropped);
 525                 break;
 526
 527         case VPORT_E_TX_ERROR:
 528                 atomic_long_inc(&vport->err_stats.tx_errors);
 529                 break;
 530         }
 531 }
 532
 533 static void free_vport_rcu(struct rcu_head *rcu)
 534 {
 535         struct vport *vport = container_of(rcu, struct vport, rcu);
 536
 537         ovs_vport_free(vport);
 538 }
 539
 540 void ovs_vport_deferred_free(struct vport *vport)
 541 {
 542         if (!vport)
 543                 return;
 544
 545         call_rcu(&vport->rcu, free_vport_rcu);
 546 }
 547
 548 int ovs_tunnel_get_egress_info(struct ovs_tunnel_info *egress_tun_info,
 549                                struct net *net,
 550                                const struct ovs_tunnel_info *tun_info,
 551                                u8 ipproto,
 552                                u32 skb_mark,
 553                                __be16 tp_src,
 554                                __be16 tp_dst)
 555 {
 556         const struct ovs_key_ipv4_tunnel *tun_key;
 557         struct rtable *rt;
 558         __be32 saddr;
 559
 560         if (unlikely(!tun_info))
 561                 return -EINVAL;
 562
 563         tun_key = &tun_info->tunnel;
 564         saddr = tun_key->ipv4_src;
 565         /* Route lookup to get srouce IP address: saddr.
 566          * The process may need to be changed if the corresponding process
 567          * in vports ops changed.
 568          */
 569         rt = find_route(net,
 570                         &saddr,
 571                         tun_key->ipv4_dst,
 572                         ipproto,
 573                         tun_key->ipv4_tos,
 574                         skb_mark);
 575         if (IS_ERR(rt))
 576                 return PTR_ERR(rt);
 577
 578         ip_rt_put(rt);
 579
 580         /* Generate egress_tun_info based on tun_info,
 581          * saddr, tp_src and tp_dst
 582          */
 583         __ovs_flow_tun_info_init(egress_tun_info,
 584                                  saddr, tun_key->ipv4_dst,
 585                                  tun_key->ipv4_tos,
 586                                  tun_key->ipv4_ttl,
 587                                  tp_src, tp_dst,
 588                                  tun_key->tun_id,
 589                                  tun_key->tun_flags,
 590                                  tun_info->options,
 591                                  tun_info->options_len);
 592
 593         return 0;
 594 }
 595
 596 int ovs_vport_get_egress_tun_info(struct vport *vport, struct sk_buff *skb,
 597                                   struct ovs_tunnel_info *info)
 598 {
 599         /* get_egress_tun_info() is only implemented on tunnel ports. */
 600         if (unlikely(!vport->ops->get_egress_tun_info))
 601                 return -EINVAL;
 602
 603         return vport->ops->get_egress_tun_info(vport, skb, info);
 604 }