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