datapath/vport.c

   1 /*
   2  * Copyright (c) 2010 Nicira Networks.
   3  * Distributed under the terms of the GNU GPL version 2.
   4  *
   5  * Significant portions of this file may be copied from parts of the Linux
   6  * kernel, by Linus Torvalds and others.
   7  */
   8
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/dcache.h>
  12 #include <linux/etherdevice.h>
  13 #include <linux/if.h>
  14 #include <linux/if_vlan.h>
  15 #include <linux/kernel.h>
  16 #include <linux/list.h>
  17 #include <linux/mutex.h>
  18 #include <linux/percpu.h>
  19 #include <linux/rtnetlink.h>
  20 #include <linux/compat.h>
  21 #include <linux/version.h>
  22
  23 #include "vport.h"
  24 #include "vport-internal_dev.h"
  25
  26 /* List of statically compiled vport implementations.  Don't forget to also
  27  * add yours to the list at the bottom of vport.h. */
  28 static const struct vport_ops *base_vport_ops_list[] = {
  29         &netdev_vport_ops,
  30         &internal_vport_ops,
  31         &patch_vport_ops,
  32         &gre_vport_ops,
  33 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
  34         &capwap_vport_ops,
  35 #endif
  36 };
  37
  38 static const struct vport_ops **vport_ops_list;
  39 static int n_vport_types;
  40
  41 static struct hlist_head *dev_table;
  42 #define VPORT_HASH_BUCKETS 1024
  43
  44 /* Both RTNL lock and vport_mutex need to be held when updating dev_table.
  45  *
  46  * If you use vport_locate and then perform some operations, you need to hold
  47  * one of these locks if you don't want the vport to be deleted out from under
  48  * you.
  49  *
  50  * If you get a reference to a vport through a dp_port, it is protected
  51  * by RCU and you need to hold rcu_read_lock instead when reading.
  52  *
  53  * If multiple locks are taken, the hierarchy is:
  54  * 1. RTNL
  55  * 2. DP
  56  * 3. vport
  57  */
  58 static DEFINE_MUTEX(vport_mutex);
  59
  60 /**
  61  *      vport_lock - acquire vport lock
  62  *
  63  * Acquire global vport lock.  See above comment about locking requirements
  64  * and specific function definitions.  May sleep.
  65  */
  66 void vport_lock(void)
  67 {
  68         mutex_lock(&vport_mutex);
  69 }
  70
  71 /**
  72  *      vport_unlock - release vport lock
  73  *
  74  * Release lock acquired with vport_lock.
  75  */
  76 void vport_unlock(void)
  77 {
  78         mutex_unlock(&vport_mutex);
  79 }
  80
  81 #define ASSERT_VPORT()                                          \
  82 do {                                                            \
  83         if (unlikely(!mutex_is_locked(&vport_mutex))) {         \
  84                 pr_err("vport lock not held at %s (%d)\n",      \
  85                        __FILE__, __LINE__);                     \
  86                 dump_stack();                                   \
  87         }                                                       \
  88 } while (0)
  89
  90 /**
  91  *      vport_init - initialize vport subsystem
  92  *
  93  * Called at module load time to initialize the vport subsystem and any
  94  * compiled in vport types.
  95  */
  96 int vport_init(void)
  97 {
  98         int err;
  99         int i;
 100
 101         dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
 102                             GFP_KERNEL);
 103         if (!dev_table) {
 104                 err = -ENOMEM;
 105                 goto error;
 106         }
 107
 108         vport_ops_list = kmalloc(ARRAY_SIZE(base_vport_ops_list) *
 109                                  sizeof(struct vport_ops *), GFP_KERNEL);
 110         if (!vport_ops_list) {
 111                 err = -ENOMEM;
 112                 goto error_dev_table;
 113         }
 114
 115         for (i = 0; i < ARRAY_SIZE(base_vport_ops_list); i++) {
 116                 const struct vport_ops *new_ops = base_vport_ops_list[i];
 117
 118                 if (new_ops->init)
 119                         err = new_ops->init();
 120                 else
 121                         err = 0;
 122
 123                 if (!err)
 124                         vport_ops_list[n_vport_types++] = new_ops;
 125                 else if (new_ops->flags & VPORT_F_REQUIRED) {
 126                         vport_exit();
 127                         goto error;
 128                 }
 129         }
 130
 131         return 0;
 132
 133 error_dev_table:
 134         kfree(dev_table);
 135 error:
 136         return err;
 137 }
 138
 139 static void vport_del_all(void)
 140 {
 141         int i;
 142
 143         rtnl_lock();
 144         vport_lock();
 145
 146         for (i = 0; i < VPORT_HASH_BUCKETS; i++) {
 147                 struct hlist_head *bucket = &dev_table[i];
 148                 struct vport *vport;
 149                 struct hlist_node *node, *next;
 150
 151                 hlist_for_each_entry_safe(vport, node, next, bucket, hash_node)
 152                         vport_del(vport);
 153         }
 154
 155         vport_unlock();
 156         rtnl_unlock();
 157 }
 158
 159 /**
 160  *      vport_exit - shutdown vport subsystem
 161  *
 162  * Called at module exit time to shutdown the vport subsystem and any
 163  * initialized vport types.
 164  */
 165 void vport_exit(void)
 166 {
 167         int i;
 168
 169         vport_del_all();
 170
 171         for (i = 0; i < n_vport_types; i++) {
 172                 if (vport_ops_list[i]->exit)
 173                         vport_ops_list[i]->exit();
 174         }
 175
 176         kfree(vport_ops_list);
 177         kfree(dev_table);
 178 }
 179
 180 /**
 181  *      vport_user_mod - modify existing vport device (for userspace callers)
 182  *
 183  * @uport: New configuration for vport
 184  *
 185  * Modifies an existing device with the specified configuration (which is
 186  * dependent on device type).  This function is for userspace callers and
 187  * assumes no locks are held.
 188  */
 189 int vport_user_mod(const struct odp_port __user *uport)
 190 {
 191         struct odp_port port;
 192         struct vport *vport;
 193         int err;
 194
 195         if (copy_from_user(&port, uport, sizeof(port)))
 196                 return -EFAULT;
 197
 198         port.devname[IFNAMSIZ - 1] = '\0';
 199
 200         rtnl_lock();
 201
 202         vport = vport_locate(port.devname);
 203         if (!vport) {
 204                 err = -ENODEV;
 205                 goto out;
 206         }
 207
 208         vport_lock();
 209         err = vport_mod(vport, &port);
 210         vport_unlock();
 211
 212 out:
 213         rtnl_unlock();
 214         return err;
 215 }
 216
 217 /**
 218  *      vport_user_stats_get - retrieve device stats (for userspace callers)
 219  *
 220  * @ustats_req: Stats request parameters.
 221  *
 222  * Retrieves transmit, receive, and error stats for the given device.  This
 223  * function is for userspace callers and assumes no locks are held.
 224  */
 225 int vport_user_stats_get(struct odp_vport_stats_req __user *ustats_req)
 226 {
 227         struct odp_vport_stats_req stats_req;
 228         struct vport *vport;
 229         int err;
 230
 231         if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
 232                 return -EFAULT;
 233
 234         stats_req.devname[IFNAMSIZ - 1] = '\0';
 235
 236         vport_lock();
 237
 238         vport = vport_locate(stats_req.devname);
 239         if (!vport) {
 240                 err = -ENODEV;
 241                 goto out;
 242         }
 243
 244         err = vport_get_stats(vport, &stats_req.stats);
 245
 246 out:
 247         vport_unlock();
 248
 249         if (!err)
 250                 if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
 251                         err = -EFAULT;
 252
 253         return err;
 254 }
 255
 256 /**
 257  *      vport_user_stats_set - sets offset device stats (for userspace callers)
 258  *
 259  * @ustats_req: Stats set parameters.
 260  *
 261  * Provides a set of transmit, receive, and error stats to be added as an
 262  * offset to the collect data when stats are retreived.  Some devices may not
 263  * support setting the stats, in which case the result will always be
 264  * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
 265  * are held.
 266  */
 267 int vport_user_stats_set(struct odp_vport_stats_req __user *ustats_req)
 268 {
 269         struct odp_vport_stats_req stats_req;
 270         struct vport *vport;
 271         int err;
 272
 273         if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
 274                 return -EFAULT;
 275
 276         stats_req.devname[IFNAMSIZ - 1] = '\0';
 277
 278         rtnl_lock();
 279         vport_lock();
 280
 281         vport = vport_locate(stats_req.devname);
 282         if (!vport) {
 283                 err = -ENODEV;
 284                 goto out;
 285         }
 286
 287         err = vport_set_stats(vport, &stats_req.stats);
 288
 289 out:
 290         vport_unlock();
 291         rtnl_unlock();
 292         return err;
 293 }
 294
 295
 296 /**
 297  *      vport_user_ether_get - retrieve device Ethernet address (for userspace callers)
 298  *
 299  * @uvport_ether: Ethernet address request parameters.
 300  *
 301  * Retrieves the Ethernet address of the given device.  This function is for
 302  * userspace callers and assumes no locks are held.
 303  */
 304 int vport_user_ether_get(struct odp_vport_ether __user *uvport_ether)
 305 {
 306         struct odp_vport_ether vport_ether;
 307         struct vport *vport;
 308         int err = 0;
 309
 310         if (copy_from_user(&vport_ether, uvport_ether, sizeof(struct odp_vport_ether)))
 311                 return -EFAULT;
 312
 313         vport_ether.devname[IFNAMSIZ - 1] = '\0';
 314
 315         vport_lock();
 316
 317         vport = vport_locate(vport_ether.devname);
 318         if (!vport) {
 319                 err = -ENODEV;
 320                 goto out;
 321         }
 322
 323         rcu_read_lock();
 324         memcpy(vport_ether.ether_addr, vport_get_addr(vport), ETH_ALEN);
 325         rcu_read_unlock();
 326
 327 out:
 328         vport_unlock();
 329
 330         if (!err)
 331                 if (copy_to_user(uvport_ether, &vport_ether, sizeof(struct odp_vport_ether)))
 332                         err = -EFAULT;
 333
 334         return err;
 335 }
 336
 337 /**
 338  *      vport_user_ether_set - set device Ethernet address (for userspace callers)
 339  *
 340  * @uvport_ether: Ethernet address request parameters.
 341  *
 342  * Sets the Ethernet address of the given device.  Some devices may not support
 343  * setting the Ethernet address, in which case the result will always be
 344  * -EOPNOTSUPP.  This function is for userspace callers and assumes no locks
 345  * are held.
 346  */
 347 int vport_user_ether_set(struct odp_vport_ether __user *uvport_ether)
 348 {
 349         struct odp_vport_ether vport_ether;
 350         struct vport *vport;
 351         int err;
 352
 353         if (copy_from_user(&vport_ether, uvport_ether, sizeof(struct odp_vport_ether)))
 354                 return -EFAULT;
 355
 356         vport_ether.devname[IFNAMSIZ - 1] = '\0';
 357
 358         rtnl_lock();
 359         vport_lock();
 360
 361         vport = vport_locate(vport_ether.devname);
 362         if (!vport) {
 363                 err = -ENODEV;
 364                 goto out;
 365         }
 366
 367         err = vport_set_addr(vport, vport_ether.ether_addr);
 368
 369 out:
 370         vport_unlock();
 371         rtnl_unlock();
 372         return err;
 373 }
 374
 375 /**
 376  *      vport_user_mtu_get - retrieve device MTU (for userspace callers)
 377  *
 378  * @uvport_mtu: MTU request parameters.
 379  *
 380  * Retrieves the MTU of the given device.  This function is for userspace
 381  * callers and assumes no locks are held.
 382  */
 383 int vport_user_mtu_get(struct odp_vport_mtu __user *uvport_mtu)
 384 {
 385         struct odp_vport_mtu vport_mtu;
 386         struct vport *vport;
 387         int err = 0;
 388
 389         if (copy_from_user(&vport_mtu, uvport_mtu, sizeof(struct odp_vport_mtu)))
 390                 return -EFAULT;
 391
 392         vport_mtu.devname[IFNAMSIZ - 1] = '\0';
 393
 394         vport_lock();
 395
 396         vport = vport_locate(vport_mtu.devname);
 397         if (!vport) {
 398                 err = -ENODEV;
 399                 goto out;
 400         }
 401
 402         vport_mtu.mtu = vport_get_mtu(vport);
 403
 404 out:
 405         vport_unlock();
 406
 407         if (!err)
 408                 if (copy_to_user(uvport_mtu, &vport_mtu, sizeof(struct odp_vport_mtu)))
 409                         err = -EFAULT;
 410
 411         return err;
 412 }
 413
 414 /**
 415  *      vport_user_mtu_set - set device MTU (for userspace callers)
 416  *
 417  * @uvport_mtu: MTU request parameters.
 418  *
 419  * Sets the MTU of the given device.  Some devices may not support setting the
 420  * MTU, in which case the result will always be -EOPNOTSUPP.  This function is
 421  * for userspace callers and assumes no locks are held.
 422  */
 423 int vport_user_mtu_set(struct odp_vport_mtu __user *uvport_mtu)
 424 {
 425         struct odp_vport_mtu vport_mtu;
 426         struct vport *vport;
 427         int err;
 428
 429         if (copy_from_user(&vport_mtu, uvport_mtu, sizeof(struct odp_vport_mtu)))
 430                 return -EFAULT;
 431
 432         vport_mtu.devname[IFNAMSIZ - 1] = '\0';
 433
 434         rtnl_lock();
 435         vport_lock();
 436
 437         vport = vport_locate(vport_mtu.devname);
 438         if (!vport) {
 439                 err = -ENODEV;
 440                 goto out;
 441         }
 442
 443         err = vport_set_mtu(vport, vport_mtu.mtu);
 444
 445 out:
 446         vport_unlock();
 447         rtnl_unlock();
 448         return err;
 449 }
 450
 451 static struct hlist_head *hash_bucket(const char *name)
 452 {
 453         unsigned int hash = full_name_hash(name, strlen(name));
 454         return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
 455 }
 456
 457 /**
 458  *      vport_locate - find a port that has already been created
 459  *
 460  * @name: name of port to find
 461  *
 462  * Either RTNL or vport lock must be acquired before calling this function
 463  * and held while using the found port.  See the locking comments at the
 464  * top of the file.
 465  */
 466 struct vport *vport_locate(const char *name)
 467 {
 468         struct hlist_head *bucket = hash_bucket(name);
 469         struct vport *vport;
 470         struct hlist_node *node;
 471
 472         if (unlikely(!mutex_is_locked(&vport_mutex) && !rtnl_is_locked())) {
 473                 pr_err("neither RTNL nor vport lock held in vport_locate\n");
 474                 dump_stack();
 475         }
 476
 477         rcu_read_lock();
 478
 479         hlist_for_each_entry(vport, node, bucket, hash_node)
 480                 if (!strcmp(name, vport_get_name(vport)))
 481                         goto out;
 482
 483         vport = NULL;
 484
 485 out:
 486         rcu_read_unlock();
 487         return vport;
 488 }
 489
 490 static void register_vport(struct vport *vport)
 491 {
 492         hlist_add_head(&vport->hash_node, hash_bucket(vport_get_name(vport)));
 493 }
 494
 495 static void unregister_vport(struct vport *vport)
 496 {
 497         hlist_del(&vport->hash_node);
 498 }
 499
 500 /**
 501  *      vport_alloc - allocate and initialize new vport
 502  *
 503  * @priv_size: Size of private data area to allocate.
 504  * @ops: vport device ops
 505  *
 506  * Allocate and initialize a new vport defined by @ops.  The vport will contain
 507  * a private data area of size @priv_size that can be accessed using
 508  * vport_priv().  vports that are no longer needed should be released with
 509  * vport_free().
 510  */
 511 struct vport *vport_alloc(int priv_size, const struct vport_ops *ops)
 512 {
 513         struct vport *vport;
 514         size_t alloc_size;
 515
 516         alloc_size = sizeof(struct vport);
 517         if (priv_size) {
 518                 alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
 519                 alloc_size += priv_size;
 520         }
 521
 522         vport = kzalloc(alloc_size, GFP_KERNEL);
 523         if (!vport)
 524                 return ERR_PTR(-ENOMEM);
 525
 526         vport->ops = ops;
 527
 528         if (vport->ops->flags & VPORT_F_GEN_STATS) {
 529                 vport->percpu_stats = alloc_percpu(struct vport_percpu_stats);
 530                 if (!vport->percpu_stats)
 531                         return ERR_PTR(-ENOMEM);
 532
 533                 spin_lock_init(&vport->stats_lock);
 534         }
 535
 536         return vport;
 537 }
 538
 539 /**
 540  *      vport_free - uninitialize and free vport
 541  *
 542  * @vport: vport to free
 543  *
 544  * Frees a vport allocated with vport_alloc() when it is no longer needed.
 545  */
 546 void vport_free(struct vport *vport)
 547 {
 548         if (vport->ops->flags & VPORT_F_GEN_STATS)
 549                 free_percpu(vport->percpu_stats);
 550
 551         kfree(vport);
 552 }
 553
 554 /**
 555  *      vport_add - add vport device (for kernel callers)
 556  *
 557  * @parms: Information about new vport.
 558  *
 559  * Creates a new vport with the specified configuration (which is dependent
 560  * on device type).  Both RTNL and vport locks must be held.
 561  */
 562 struct vport *vport_add(const struct vport_parms *parms)
 563 {
 564         struct vport *vport;
 565         int err = 0;
 566         int i;
 567
 568         ASSERT_RTNL();
 569         ASSERT_VPORT();
 570
 571         for (i = 0; i < n_vport_types; i++) {
 572                 if (!strcmp(vport_ops_list[i]->type, parms->type)) {
 573                         vport = vport_ops_list[i]->create(parms);
 574                         if (IS_ERR(vport)) {
 575                                 err = PTR_ERR(vport);
 576                                 goto out;
 577                         }
 578
 579                         register_vport(vport);
 580                         return vport;
 581                 }
 582         }
 583
 584         err = -EAFNOSUPPORT;
 585
 586 out:
 587         return ERR_PTR(err);
 588 }
 589
 590 /**
 591  *      vport_mod - modify existing vport device (for kernel callers)
 592  *
 593  * @vport: vport to modify.
 594  * @port: New configuration.
 595  *
 596  * Modifies an existing device with the specified configuration (which is
 597  * dependent on device type).  Both RTNL and vport locks must be held.
 598  */
 599 int vport_mod(struct vport *vport, struct odp_port *port)
 600 {
 601         ASSERT_RTNL();
 602         ASSERT_VPORT();
 603
 604         if (vport->ops->modify)
 605                 return vport->ops->modify(vport, port);
 606         else
 607                 return -EOPNOTSUPP;
 608 }
 609
 610 /**
 611  *      vport_del - delete existing vport device (for kernel callers)
 612  *
 613  * @vport: vport to delete.
 614  *
 615  * Deletes the specified device.  The device must not be currently attached to
 616  * a datapath.  It is possible to fail for reasons such as lack of memory.
 617  * Both RTNL and vport locks must be held.
 618  */
 619 int vport_del(struct vport *vport)
 620 {
 621         ASSERT_RTNL();
 622         ASSERT_VPORT();
 623         BUG_ON(vport_get_dp_port(vport));
 624
 625         unregister_vport(vport);
 626
 627         return vport->ops->destroy(vport);
 628 }
 629
 630 /**
 631  *      vport_attach - attach a vport to a datapath
 632  *
 633  * @vport: vport to attach.
 634  * @dp_port: Datapath port to attach the vport to.
 635  *
 636  * Attaches a vport to a specific datapath so that packets may be exchanged.
 637  * Both ports must be currently unattached.  @dp_port must be successfully
 638  * attached to a vport before it is connected to a datapath and must not be
 639  * modified while connected.  RTNL lock and the appropriate DP mutex must be held.
 640  */
 641 int vport_attach(struct vport *vport, struct dp_port *dp_port)
 642 {
 643         ASSERT_RTNL();
 644
 645         if (vport_get_dp_port(vport))
 646                 return -EBUSY;
 647
 648         if (vport->ops->attach) {
 649                 int err;
 650
 651                 err = vport->ops->attach(vport);
 652                 if (err)
 653                         return err;
 654         }
 655
 656         rcu_assign_pointer(vport->dp_port, dp_port);
 657
 658         return 0;
 659 }
 660
 661 /**
 662  *      vport_detach - detach a vport from a datapath
 663  *
 664  * @vport: vport to detach.
 665  *
 666  * Detaches a vport from a datapath.  May fail for a variety of reasons,
 667  * including lack of memory.  RTNL lock and the appropriate DP mutex must be held.
 668  */
 669 int vport_detach(struct vport *vport)
 670 {
 671         struct dp_port *dp_port;
 672
 673         ASSERT_RTNL();
 674
 675         dp_port = vport_get_dp_port(vport);
 676         if (!dp_port)
 677                 return -EINVAL;
 678
 679         rcu_assign_pointer(vport->dp_port, NULL);
 680
 681         if (vport->ops->detach)
 682                 return vport->ops->detach(vport);
 683         else
 684                 return 0;
 685 }
 686
 687 /**
 688  *      vport_set_mtu - set device MTU (for kernel callers)
 689  *
 690  * @vport: vport on which to set MTU.
 691  * @mtu: New MTU.
 692  *
 693  * Sets the MTU of the given device.  Some devices may not support setting the
 694  * MTU, in which case the result will always be -EOPNOTSUPP.  RTNL lock must
 695  * be held.
 696  */
 697 int vport_set_mtu(struct vport *vport, int mtu)
 698 {
 699         ASSERT_RTNL();
 700
 701         if (mtu < 68)
 702                 return -EINVAL;
 703
 704         if (vport->ops->set_mtu) {
 705                 int ret;
 706
 707                 ret = vport->ops->set_mtu(vport, mtu);
 708
 709                 if (!ret && !is_internal_vport(vport)) {
 710                         struct dp_port *dp_port = vport_get_dp_port(vport);
 711
 712                         if (dp_port)
 713                                 set_internal_devs_mtu(dp_port->dp);
 714                 }
 715
 716                 return ret;
 717         } else
 718                 return -EOPNOTSUPP;
 719 }
 720
 721 /**
 722  *      vport_set_addr - set device Ethernet address (for kernel callers)
 723  *
 724  * @vport: vport on which to set Ethernet address.
 725  * @addr: New address.
 726  *
 727  * Sets the Ethernet address of the given device.  Some devices may not support
 728  * setting the Ethernet address, in which case the result will always be
 729  * -EOPNOTSUPP.  RTNL lock must be held.
 730  */
 731 int vport_set_addr(struct vport *vport, const unsigned char *addr)
 732 {
 733         ASSERT_RTNL();
 734
 735         if (!is_valid_ether_addr(addr))
 736                 return -EADDRNOTAVAIL;
 737
 738         if (vport->ops->set_addr)
 739                 return vport->ops->set_addr(vport, addr);
 740         else
 741                 return -EOPNOTSUPP;
 742 }
 743
 744 /**
 745  *      vport_set_stats - sets offset device stats (for kernel callers)
 746  *
 747  * @vport: vport on which to set stats
 748  * @stats: stats to set
 749  *
 750  * Provides a set of transmit, receive, and error stats to be added as an
 751  * offset to the collect data when stats are retreived.  Some devices may not
 752  * support setting the stats, in which case the result will always be
 753  * -EOPNOTSUPP.  RTNL lock must be held.
 754  */
 755 int vport_set_stats(struct vport *vport, struct rtnl_link_stats64 *stats)
 756 {
 757         ASSERT_RTNL();
 758
 759         if (vport->ops->flags & VPORT_F_GEN_STATS) {
 760                 spin_lock_bh(&vport->stats_lock);
 761                 vport->offset_stats = *stats;
 762                 spin_unlock_bh(&vport->stats_lock);
 763
 764                 return 0;
 765         } else if (vport->ops->set_stats)
 766                 return vport->ops->set_stats(vport, stats);
 767         else
 768                 return -EOPNOTSUPP;
 769 }
 770
 771 /**
 772  *      vport_get_name - retrieve device name
 773  *
 774  * @vport: vport from which to retrieve the name.
 775  *
 776  * Retrieves the name of the given device.  Either RTNL lock or rcu_read_lock
 777  * must be held for the entire duration that the name is in use.
 778  */
 779 const char *vport_get_name(const struct vport *vport)
 780 {
 781         return vport->ops->get_name(vport);
 782 }
 783
 784 /**
 785  *      vport_get_type - retrieve device type
 786  *
 787  * @vport: vport from which to retrieve the type.
 788  *
 789  * Retrieves the type of the given device.  Either RTNL lock or rcu_read_lock
 790  * must be held for the entire duration that the type is in use.
 791  */
 792 const char *vport_get_type(const struct vport *vport)
 793 {
 794         return vport->ops->type;
 795 }
 796
 797 /**
 798  *      vport_get_addr - retrieve device Ethernet address (for kernel callers)
 799  *
 800  * @vport: vport from which to retrieve the Ethernet address.
 801  *
 802  * Retrieves the Ethernet address of the given device.  Either RTNL lock or
 803  * rcu_read_lock must be held for the entire duration that the Ethernet address
 804  * is in use.
 805  */
 806 const unsigned char *vport_get_addr(const struct vport *vport)
 807 {
 808         return vport->ops->get_addr(vport);
 809 }
 810
 811 /**
 812  *      vport_get_dp_port - retrieve attached datapath port
 813  *
 814  * @vport: vport from which to retrieve the datapath port.
 815  *
 816  * Retrieves the attached datapath port or null if not attached.  Either RTNL
 817  * lock or rcu_read_lock must be held for the entire duration that the datapath
 818  * port is being accessed.
 819  */
 820 struct dp_port *vport_get_dp_port(const struct vport *vport)
 821 {
 822         return rcu_dereference(vport->dp_port);
 823 }
 824
 825 /**
 826  *      vport_get_kobj - retrieve associated kobj
 827  *
 828  * @vport: vport from which to retrieve the associated kobj
 829  *
 830  * Retrieves the associated kobj or null if no kobj.  The returned kobj is
 831  * valid for as long as the vport exists.
 832  */
 833 struct kobject *vport_get_kobj(const struct vport *vport)
 834 {
 835         if (vport->ops->get_kobj)
 836                 return vport->ops->get_kobj(vport);
 837         else
 838                 return NULL;
 839 }
 840
 841 /**
 842  *      vport_get_stats - retrieve device stats (for kernel callers)
 843  *
 844  * @vport: vport from which to retrieve the stats
 845  * @stats: location to store stats
 846  *
 847  * Retrieves transmit, receive, and error stats for the given device.
 848  */
 849 int vport_get_stats(struct vport *vport, struct rtnl_link_stats64 *stats)
 850 {
 851         struct rtnl_link_stats64 dev_stats;
 852         struct rtnl_link_stats64 *dev_statsp = NULL;
 853         int err;
 854
 855         if (vport->ops->get_stats) {
 856                 if (vport->ops->flags & VPORT_F_GEN_STATS)
 857                         dev_statsp = &dev_stats;
 858                 else
 859                         dev_statsp = stats;
 860
 861                 rcu_read_lock();
 862                 err = vport->ops->get_stats(vport, dev_statsp);
 863                 rcu_read_unlock();
 864
 865                 if (err)
 866                         goto out;
 867         }
 868
 869         if (vport->ops->flags & VPORT_F_GEN_STATS) {
 870                 int i;
 871
 872                 /* We potentially have 3 sources of stats that need to be
 873                  * combined: those we have collected (split into err_stats and
 874                  * percpu_stats), offset_stats from set_stats(), and device
 875                  * error stats from get_stats() (for errors that happen
 876                  * downstream and therefore aren't reported through our
 877                  * vport_record_error() function). */
 878
 879                 spin_lock_bh(&vport->stats_lock);
 880
 881                 *stats = vport->offset_stats;
 882
 883                 stats->rx_errors        += vport->err_stats.rx_errors;
 884                 stats->tx_errors        += vport->err_stats.tx_errors;
 885                 stats->tx_dropped       += vport->err_stats.tx_dropped;
 886                 stats->rx_dropped       += vport->err_stats.rx_dropped;
 887
 888                 spin_unlock_bh(&vport->stats_lock);
 889
 890                 if (dev_statsp) {
 891                         stats->rx_packets          += dev_statsp->rx_packets;
 892                         stats->tx_packets          += dev_statsp->tx_packets;
 893                         stats->rx_bytes            += dev_statsp->rx_bytes;
 894                         stats->tx_bytes            += dev_statsp->tx_bytes;
 895                         stats->rx_errors           += dev_statsp->rx_errors;
 896                         stats->tx_errors           += dev_statsp->tx_errors;
 897                         stats->rx_dropped          += dev_statsp->rx_dropped;
 898                         stats->tx_dropped          += dev_statsp->tx_dropped;
 899                         stats->multicast           += dev_statsp->multicast;
 900                         stats->collisions          += dev_statsp->collisions;
 901                         stats->rx_length_errors    += dev_statsp->rx_length_errors;
 902                         stats->rx_over_errors      += dev_statsp->rx_over_errors;
 903                         stats->rx_crc_errors       += dev_statsp->rx_crc_errors;
 904                         stats->rx_frame_errors     += dev_statsp->rx_frame_errors;
 905                         stats->rx_fifo_errors      += dev_statsp->rx_fifo_errors;
 906                         stats->rx_missed_errors    += dev_statsp->rx_missed_errors;
 907                         stats->tx_aborted_errors   += dev_statsp->tx_aborted_errors;
 908                         stats->tx_carrier_errors   += dev_statsp->tx_carrier_errors;
 909                         stats->tx_fifo_errors      += dev_statsp->tx_fifo_errors;
 910                         stats->tx_heartbeat_errors += dev_statsp->tx_heartbeat_errors;
 911                         stats->tx_window_errors    += dev_statsp->tx_window_errors;
 912                         stats->rx_compressed       += dev_statsp->rx_compressed;
 913                         stats->tx_compressed       += dev_statsp->tx_compressed;
 914                 }
 915
 916                 for_each_possible_cpu(i) {
 917                         const struct vport_percpu_stats *percpu_stats;
 918                         struct vport_percpu_stats local_stats;
 919                         unsigned seqcount;
 920
 921                         percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
 922
 923                         do {
 924                                 seqcount = read_seqcount_begin(&percpu_stats->seqlock);
 925                                 local_stats = *percpu_stats;
 926                         } while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
 927
 928                         stats->rx_bytes         += local_stats.rx_bytes;
 929                         stats->rx_packets       += local_stats.rx_packets;
 930                         stats->tx_bytes         += local_stats.tx_bytes;
 931                         stats->tx_packets       += local_stats.tx_packets;
 932                 }
 933
 934                 err = 0;
 935         } else
 936                 err = -EOPNOTSUPP;
 937
 938 out:
 939         return err;
 940 }
 941
 942 /**
 943  *      vport_get_flags - retrieve device flags
 944  *
 945  * @vport: vport from which to retrieve the flags
 946  *
 947  * Retrieves the flags of the given device.  Either RTNL lock or rcu_read_lock
 948  * must be held.
 949  */
 950 unsigned vport_get_flags(const struct vport *vport)
 951 {
 952         return vport->ops->get_dev_flags(vport);
 953 }
 954
 955 /**
 956  *      vport_get_flags - check whether device is running
 957  *
 958  * @vport: vport on which to check status.
 959  *
 960  * Checks whether the given device is running.  Either RTNL lock or
 961  * rcu_read_lock must be held.
 962  */
 963 int vport_is_running(const struct vport *vport)
 964 {
 965         return vport->ops->is_running(vport);
 966 }
 967
 968 /**
 969  *      vport_get_flags - retrieve device operating state
 970  *
 971  * @vport: vport from which to check status
 972  *
 973  * Retrieves the RFC2863 operstate of the given device.  Either RTNL lock or
 974  * rcu_read_lock must be held.
 975  */
 976 unsigned char vport_get_operstate(const struct vport *vport)
 977 {
 978         return vport->ops->get_operstate(vport);
 979 }
 980
 981 /**
 982  *      vport_get_ifindex - retrieve device system interface index
 983  *
 984  * @vport: vport from which to retrieve index
 985  *
 986  * Retrieves the system interface index of the given device.  Not all devices
 987  * will have system indexes, in which case the index of the datapath local
 988  * port is returned.  Returns a negative index on error.  Either RTNL lock or
 989  * rcu_read_lock must be held.
 990  */
 991 int vport_get_ifindex(const struct vport *vport)
 992 {
 993         const struct dp_port *dp_port;
 994
 995         if (vport->ops->get_ifindex)
 996                 return vport->ops->get_ifindex(vport);
 997
 998         /* If we don't actually have an ifindex, use the local port's.
 999          * Userspace doesn't check it anyways. */
1000         dp_port = vport_get_dp_port(vport);
1001         if (!dp_port)
1002                 return -EAGAIN;
1003
1004         return vport_get_ifindex(dp_port->dp->ports[ODPP_LOCAL]->vport);
1005 }
1006
1007 /**
1008  *      vport_get_iflink - retrieve device system link index
1009  *
1010  * @vport: vport from which to retrieve index
1011  *
1012  * Retrieves the system link index of the given device.  The link is the index
1013  * of the interface on which the packet will actually be sent.  In most cases
1014  * this is the same as the ifindex but may be different for tunnel devices.
1015  * Returns a negative index on error.  Either RTNL lock or rcu_read_lock must
1016  * be held.
1017  */
1018 int vport_get_iflink(const struct vport *vport)
1019 {
1020         if (vport->ops->get_iflink)
1021                 return vport->ops->get_iflink(vport);
1022
1023         /* If we don't have an iflink, use the ifindex.  In most cases they
1024          * are the same. */
1025         return vport_get_ifindex(vport);
1026 }
1027
1028 /**
1029  *      vport_get_mtu - retrieve device MTU (for kernel callers)
1030  *
1031  * @vport: vport from which to retrieve MTU
1032  *
1033  * Retrieves the MTU of the given device.  Either RTNL lock or rcu_read_lock
1034  * must be held.
1035  */
1036 int vport_get_mtu(const struct vport *vport)
1037 {
1038         return vport->ops->get_mtu(vport);
1039 }
1040
1041 /**
1042  *      vport_receive - pass up received packet to the datapath for processing
1043  *
1044  * @vport: vport that received the packet
1045  * @skb: skb that was received
1046  *
1047  * Must be called with rcu_read_lock.  The packet cannot be shared and
1048  * skb->data should point to the Ethernet header.  The caller must have already
1049  * called compute_ip_summed() to initialize the checksumming fields.
1050  */
1051 void vport_receive(struct vport *vport, struct sk_buff *skb)
1052 {
1053         struct dp_port *dp_port = vport_get_dp_port(vport);
1054
1055         if (!dp_port) {
1056                 vport_record_error(vport, VPORT_E_RX_DROPPED);
1057                 kfree_skb(skb);
1058
1059                 return;
1060         }
1061
1062         if (vport->ops->flags & VPORT_F_GEN_STATS) {
1063                 struct vport_percpu_stats *stats;
1064
1065                 local_bh_disable();
1066                 stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
1067
1068                 write_seqcount_begin(&stats->seqlock);
1069                 stats->rx_packets++;
1070                 stats->rx_bytes += skb->len;
1071                 write_seqcount_end(&stats->seqlock);
1072
1073                 local_bh_enable();
1074         }
1075
1076         if (!(vport->ops->flags & VPORT_F_FLOW))
1077                 OVS_CB(skb)->flow = NULL;
1078
1079         if (!(vport->ops->flags & VPORT_F_TUN_ID))
1080                 OVS_CB(skb)->tun_id = 0;
1081
1082         dp_process_received_packet(dp_port, skb);
1083 }
1084
1085 static inline unsigned packet_length(const struct sk_buff *skb)
1086 {
1087         unsigned length = skb->len - ETH_HLEN;
1088
1089         if (skb->protocol == htons(ETH_P_8021Q))
1090                 length -= VLAN_HLEN;
1091
1092         return length;
1093 }
1094
1095 /**
1096  *      vport_send - send a packet on a device
1097  *
1098  * @vport: vport on which to send the packet
1099  * @skb: skb to send
1100  *
1101  * Sends the given packet and returns the length of data sent.  Either RTNL
1102  * lock or rcu_read_lock must be held.
1103  */
1104 int vport_send(struct vport *vport, struct sk_buff *skb)
1105 {
1106         int mtu;
1107         int sent;
1108
1109         mtu = vport_get_mtu(vport);
1110         if (unlikely(packet_length(skb) > mtu && !skb_is_gso(skb))) {
1111                 if (net_ratelimit())
1112                         pr_warn("%s: dropped over-mtu packet: %d > %d\n",
1113                                 dp_name(vport_get_dp_port(vport)->dp),
1114                                 packet_length(skb), mtu);
1115                 goto error;
1116         }
1117
1118         sent = vport->ops->send(vport, skb);
1119
1120         if (vport->ops->flags & VPORT_F_GEN_STATS && sent > 0) {
1121                 struct vport_percpu_stats *stats;
1122
1123                 local_bh_disable();
1124                 stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
1125
1126                 write_seqcount_begin(&stats->seqlock);
1127                 stats->tx_packets++;
1128                 stats->tx_bytes += sent;
1129                 write_seqcount_end(&stats->seqlock);
1130
1131                 local_bh_enable();
1132         }
1133
1134         return sent;
1135
1136 error:
1137         kfree_skb(skb);
1138         vport_record_error(vport, VPORT_E_TX_DROPPED);
1139         return 0;
1140 }
1141
1142 /**
1143  *      vport_record_error - indicate device error to generic stats layer
1144  *
1145  * @vport: vport that encountered the error
1146  * @err_type: one of enum vport_err_type types to indicate the error type
1147  *
1148  * If using the vport generic stats layer indicate that an error of the given
1149  * type has occured.
1150  */
1151 void vport_record_error(struct vport *vport, enum vport_err_type err_type)
1152 {
1153         if (vport->ops->flags & VPORT_F_GEN_STATS) {
1154
1155                 spin_lock_bh(&vport->stats_lock);
1156
1157                 switch (err_type) {
1158                 case VPORT_E_RX_DROPPED:
1159                         vport->err_stats.rx_dropped++;
1160                         break;
1161
1162                 case VPORT_E_RX_ERROR:
1163                         vport->err_stats.rx_errors++;
1164                         break;
1165
1166                 case VPORT_E_TX_DROPPED:
1167                         vport->err_stats.tx_dropped++;
1168                         break;
1169
1170                 case VPORT_E_TX_ERROR:
1171                         vport->err_stats.tx_errors++;
1172                         break;
1173                 };
1174
1175                 spin_unlock_bh(&vport->stats_lock);
1176         }
1177 }