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