lib/netdev.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include "netdev.h"
  19
  20 #include <errno.h>
  21 #include <inttypes.h>
  22 #include <netinet/in.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <unistd.h>
  26
  27 #include "coverage.h"
  28 #include "dpif.h"
  29 #include "dynamic-string.h"
  30 #include "fatal-signal.h"
  31 #include "hash.h"
  32 #include "list.h"
  33 #include "netdev-provider.h"
  34 #include "netdev-vport.h"
  35 #include "ofpbuf.h"
  36 #include "openflow/openflow.h"
  37 #include "packets.h"
  38 #include "poll-loop.h"
  39 #include "shash.h"
  40 #include "smap.h"
  41 #include "sset.h"
  42 #include "svec.h"
  43 #include "vlog.h"
  44
  45 VLOG_DEFINE_THIS_MODULE(netdev);
  46
  47 COVERAGE_DEFINE(netdev_received);
  48 COVERAGE_DEFINE(netdev_sent);
  49 COVERAGE_DEFINE(netdev_add_router);
  50 COVERAGE_DEFINE(netdev_get_stats);
  51
  52 struct netdev_saved_flags {
  53     struct netdev *netdev;
  54     struct list node;           /* In struct netdev's saved_flags_list. */
  55     enum netdev_flags saved_flags;
  56     enum netdev_flags saved_values;
  57 };
  58
  59 /* Protects 'netdev_shash' and the mutable members of struct netdev. */
  60 static struct ovs_mutex netdev_mutex = OVS_MUTEX_INITIALIZER;
  61
  62 /* All created network devices. */
  63 static struct shash netdev_shash OVS_GUARDED_BY(netdev_mutex)
  64     = SHASH_INITIALIZER(&netdev_shash);
  65
  66 /* Protects 'netdev_classes' against insertions or deletions.
  67  *
  68  * This is not an rwlock for performance reasons but to allow recursive
  69  * acquisition when calling into providers.  For example, netdev_run() calls
  70  * into provider 'run' functions, which might reasonably want to call one of
  71  * the netdev functions that takes netdev_class_rwlock read-only. */
  72 static struct ovs_rwlock netdev_class_rwlock OVS_ACQ_BEFORE(netdev_mutex)
  73     = OVS_RWLOCK_INITIALIZER;
  74
  75 /* Contains 'struct netdev_registered_class'es. */
  76 static struct hmap netdev_classes OVS_GUARDED_BY(netdev_class_rwlock)
  77     = HMAP_INITIALIZER(&netdev_classes);
  78
  79 struct netdev_registered_class {
  80     struct hmap_node hmap_node; /* In 'netdev_classes', by class->type. */
  81     const struct netdev_class *class;
  82     atomic_int ref_cnt;         /* Number of 'struct netdev's of this class. */
  83 };
  84
  85 /* This is set pretty low because we probably won't learn anything from the
  86  * additional log messages. */
  87 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
  88
  89 static void restore_all_flags(void *aux OVS_UNUSED);
  90 void update_device_args(struct netdev *, const struct shash *args);
  91
  92 static void
  93 netdev_initialize(void)
  94     OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
  95 {
  96     static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
  97
  98     if (ovsthread_once_start(&once)) {
  99         fatal_signal_add_hook(restore_all_flags, NULL, NULL, true);
 100         netdev_vport_patch_register();
 101
 102 #ifdef LINUX_DATAPATH
 103         netdev_register_provider(&netdev_linux_class);
 104         netdev_register_provider(&netdev_internal_class);
 105         netdev_register_provider(&netdev_tap_class);
 106         netdev_vport_tunnel_register();
 107 #endif
 108 #if defined(__FreeBSD__) || defined(__NetBSD__)
 109         netdev_register_provider(&netdev_tap_class);
 110         netdev_register_provider(&netdev_bsd_class);
 111 #endif
 112         netdev_register_provider(&netdev_tunnel_class);
 113         netdev_register_provider(&netdev_pltap_class);
 114
 115         ovsthread_once_done(&once);
 116     }
 117 }
 118
 119 /* Performs periodic work needed by all the various kinds of netdevs.
 120  *
 121  * If your program opens any netdevs, it must call this function within its
 122  * main poll loop. */
 123 void
 124 netdev_run(void)
 125     OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
 126 {
 127     struct netdev_registered_class *rc;
 128
 129     ovs_rwlock_rdlock(&netdev_class_rwlock);
 130     HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
 131         if (rc->class->run) {
 132             rc->class->run();
 133         }
 134     }
 135     ovs_rwlock_unlock(&netdev_class_rwlock);
 136 }
 137
 138 /* Arranges for poll_block() to wake up when netdev_run() needs to be called.
 139  *
 140  * If your program opens any netdevs, it must call this function within its
 141  * main poll loop. */
 142 void
 143 netdev_wait(void)
 144     OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
 145 {
 146     struct netdev_registered_class *rc;
 147
 148     ovs_rwlock_rdlock(&netdev_class_rwlock);
 149     HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
 150         if (rc->class->wait) {
 151             rc->class->wait();
 152         }
 153     }
 154     ovs_rwlock_unlock(&netdev_class_rwlock);
 155 }
 156
 157 static struct netdev_registered_class *
 158 netdev_lookup_class(const char *type)
 159     OVS_REQ_RDLOCK(netdev_class_rwlock)
 160 {
 161     struct netdev_registered_class *rc;
 162
 163     HMAP_FOR_EACH_WITH_HASH (rc, hmap_node, hash_string(type, 0),
 164                              &netdev_classes) {
 165         if (!strcmp(type, rc->class->type)) {
 166             return rc;
 167         }
 168     }
 169     return NULL;
 170 }
 171
 172 /* Initializes and registers a new netdev provider.  After successful
 173  * registration, new netdevs of that type can be opened using netdev_open(). */
 174 int
 175 netdev_register_provider(const struct netdev_class *new_class)
 176     OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
 177 {
 178     int error;
 179
 180     ovs_rwlock_wrlock(&netdev_class_rwlock);
 181     if (netdev_lookup_class(new_class->type)) {
 182         VLOG_WARN("attempted to register duplicate netdev provider: %s",
 183                    new_class->type);
 184         error = EEXIST;
 185     } else {
 186         error = new_class->init ? new_class->init() : 0;
 187         if (!error) {
 188             struct netdev_registered_class *rc;
 189
 190             rc = xmalloc(sizeof *rc);
 191             hmap_insert(&netdev_classes, &rc->hmap_node,
 192                         hash_string(new_class->type, 0));
 193             rc->class = new_class;
 194             atomic_init(&rc->ref_cnt, 0);
 195         } else {
 196             VLOG_ERR("failed to initialize %s network device class: %s",
 197                      new_class->type, ovs_strerror(error));
 198         }
 199     }
 200     ovs_rwlock_unlock(&netdev_class_rwlock);
 201
 202     return error;
 203 }
 204
 205 /* Unregisters a netdev provider.  'type' must have been previously
 206  * registered and not currently be in use by any netdevs.  After unregistration
 207  * new netdevs of that type cannot be opened using netdev_open(). */
 208 int
 209 netdev_unregister_provider(const char *type)
 210     OVS_EXCLUDED(netdev_class_rwlock, netdev_mutex)
 211 {
 212     struct netdev_registered_class *rc;
 213     int error;
 214
 215     ovs_rwlock_wrlock(&netdev_class_rwlock);
 216     rc = netdev_lookup_class(type);
 217     if (!rc) {
 218         VLOG_WARN("attempted to unregister a netdev provider that is not "
 219                   "registered: %s", type);
 220         error = EAFNOSUPPORT;
 221     } else {
 222         int ref_cnt;
 223
 224         atomic_read(&rc->ref_cnt, &ref_cnt);
 225         if (!ref_cnt) {
 226             hmap_remove(&netdev_classes, &rc->hmap_node);
 227             free(rc);
 228             error = 0;
 229         } else {
 230             VLOG_WARN("attempted to unregister in use netdev provider: %s",
 231                       type);
 232             error = EBUSY;
 233         }
 234     }
 235     ovs_rwlock_unlock(&netdev_class_rwlock);
 236
 237     return error;
 238 }
 239
 240 /* Clears 'types' and enumerates the types of all currently registered netdev
 241  * providers into it.  The caller must first initialize the sset. */
 242 void
 243 netdev_enumerate_types(struct sset *types)
 244     OVS_EXCLUDED(netdev_mutex)
 245 {
 246     struct netdev_registered_class *rc;
 247
 248     netdev_initialize();
 249     sset_clear(types);
 250
 251     ovs_rwlock_rdlock(&netdev_class_rwlock);
 252     HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
 253         sset_add(types, rc->class->type);
 254     }
 255     ovs_rwlock_unlock(&netdev_class_rwlock);
 256 }
 257
 258 /* Check that the network device name is not the same as any of the registered
 259  * vport providers' dpif_port name (dpif_port is NULL if the vport provider
 260  * does not define it) or the datapath internal port name (e.g. ovs-system).
 261  *
 262  * Returns true if there is a name conflict, false otherwise. */
 263 bool
 264 netdev_is_reserved_name(const char *name)
 265     OVS_EXCLUDED(netdev_mutex)
 266 {
 267     struct netdev_registered_class *rc;
 268
 269     netdev_initialize();
 270
 271     ovs_rwlock_rdlock(&netdev_class_rwlock);
 272     HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
 273         const char *dpif_port = netdev_vport_class_get_dpif_port(rc->class);
 274         if (dpif_port && !strcmp(dpif_port, name)) {
 275             ovs_rwlock_unlock(&netdev_class_rwlock);
 276             return true;
 277         }
 278     }
 279     ovs_rwlock_unlock(&netdev_class_rwlock);
 280
 281     if (!strncmp(name, "ovs-", 4)) {
 282         struct sset types;
 283         const char *type;
 284
 285         sset_init(&types);
 286         dp_enumerate_types(&types);
 287         SSET_FOR_EACH (type, &types) {
 288             if (!strcmp(name+4, type)) {
 289                 sset_destroy(&types);
 290                 return true;
 291             }
 292         }
 293         sset_destroy(&types);
 294     }
 295
 296     return false;
 297 }
 298
 299 /* Opens the network device named 'name' (e.g. "eth0") of the specified 'type'
 300  * (e.g. "system") and returns zero if successful, otherwise a positive errno
 301  * value.  On success, sets '*netdevp' to the new network device, otherwise to
 302  * null.
 303  *
 304  * Some network devices may need to be configured (with netdev_set_config())
 305  * before they can be used. */
 306 int
 307 netdev_open(const char *name, const char *type, struct netdev **netdevp)
 308     OVS_EXCLUDED(netdev_mutex)
 309 {
 310     struct netdev *netdev;
 311     int error;
 312
 313     netdev_initialize();
 314
 315     ovs_rwlock_rdlock(&netdev_class_rwlock);
 316     ovs_mutex_lock(&netdev_mutex);
 317     netdev = shash_find_data(&netdev_shash, name);
 318     if (!netdev) {
 319         struct netdev_registered_class *rc;
 320
 321         rc = netdev_lookup_class(type && type[0] ? type : "system");
 322         if (rc) {
 323             netdev = rc->class->alloc();
 324             if (netdev) {
 325                 memset(netdev, 0, sizeof *netdev);
 326                 netdev->netdev_class = rc->class;
 327                 netdev->name = xstrdup(name);
 328                 netdev->node = shash_add(&netdev_shash, name, netdev);
 329                 list_init(&netdev->saved_flags_list);
 330
 331                 error = rc->class->construct(netdev);
 332                 if (!error) {
 333                     int old_ref_cnt;
 334
 335                     atomic_add(&rc->ref_cnt, 1, &old_ref_cnt);
 336                 } else {
 337                     free(netdev->name);
 338                     ovs_assert(list_is_empty(&netdev->saved_flags_list));
 339                     shash_delete(&netdev_shash, netdev->node);
 340                     rc->class->dealloc(netdev);
 341                 }
 342             } else {
 343                 error = ENOMEM;
 344             }
 345         } else {
 346             VLOG_WARN("could not create netdev %s of unknown type %s",
 347                       name, type);
 348             error = EAFNOSUPPORT;
 349         }
 350     } else {
 351         error = 0;
 352     }
 353
 354     ovs_mutex_unlock(&netdev_mutex);
 355     ovs_rwlock_unlock(&netdev_class_rwlock);
 356
 357     if (!error) {
 358         netdev->ref_cnt++;
 359         *netdevp = netdev;
 360     } else {
 361         *netdevp = NULL;
 362     }
 363     return error;
 364 }
 365
 366 /* Returns a reference to 'netdev_' for the caller to own. Returns null if
 367  * 'netdev_' is null. */
 368 struct netdev *
 369 netdev_ref(const struct netdev *netdev_)
 370     OVS_EXCLUDED(netdev_mutex)
 371 {
 372     struct netdev *netdev = CONST_CAST(struct netdev *, netdev_);
 373
 374     if (netdev) {
 375         ovs_mutex_lock(&netdev_mutex);
 376         ovs_assert(netdev->ref_cnt > 0);
 377         netdev->ref_cnt++;
 378         ovs_mutex_unlock(&netdev_mutex);
 379     }
 380     return netdev;
 381 }
 382
 383 /* Reconfigures the device 'netdev' with 'args'.  'args' may be empty
 384  * or NULL if none are needed. */
 385 int
 386 netdev_set_config(struct netdev *netdev, const struct smap *args)
 387     OVS_EXCLUDED(netdev_mutex)
 388 {
 389     if (netdev->netdev_class->set_config) {
 390         const struct smap no_args = SMAP_INITIALIZER(&no_args);
 391         return netdev->netdev_class->set_config(netdev,
 392                                                 args ? args : &no_args);
 393     } else if (args && !smap_is_empty(args)) {
 394         VLOG_WARN("%s: arguments provided to device that is not configurable",
 395                   netdev_get_name(netdev));
 396     }
 397
 398     return 0;
 399 }
 400
 401 /* Returns the current configuration for 'netdev' in 'args'.  The caller must
 402  * have already initialized 'args' with smap_init().  Returns 0 on success, in
 403  * which case 'args' will be filled with 'netdev''s configuration.  On failure
 404  * returns a positive errno value, in which case 'args' will be empty.
 405  *
 406  * The caller owns 'args' and its contents and must eventually free them with
 407  * smap_destroy(). */
 408 int
 409 netdev_get_config(const struct netdev *netdev, struct smap *args)
 410     OVS_EXCLUDED(netdev_mutex)
 411 {
 412     int error;
 413
 414     smap_clear(args);
 415     if (netdev->netdev_class->get_config) {
 416         error = netdev->netdev_class->get_config(netdev, args);
 417         if (error) {
 418             smap_clear(args);
 419         }
 420     } else {
 421         error = 0;
 422     }
 423
 424     return error;
 425 }
 426
 427 const struct netdev_tunnel_config *
 428 netdev_get_tunnel_config(const struct netdev *netdev)
 429     OVS_EXCLUDED(netdev_mutex)
 430 {
 431     if (netdev->netdev_class->get_tunnel_config) {
 432         return netdev->netdev_class->get_tunnel_config(netdev);
 433     } else {
 434         return NULL;
 435     }
 436 }
 437
 438 static void
 439 netdev_unref(struct netdev *dev)
 440     OVS_RELEASES(netdev_mutex)
 441 {
 442     ovs_assert(dev->ref_cnt);
 443     if (!--dev->ref_cnt) {
 444         const struct netdev_class *class = dev->netdev_class;
 445         struct netdev_registered_class *rc;
 446         int old_ref_cnt;
 447
 448         dev->netdev_class->destruct(dev);
 449
 450         shash_delete(&netdev_shash, dev->node);
 451         free(dev->name);
 452         dev->netdev_class->dealloc(dev);
 453         ovs_mutex_unlock(&netdev_mutex);
 454
 455         ovs_rwlock_rdlock(&netdev_class_rwlock);
 456         rc = netdev_lookup_class(class->type);
 457         atomic_sub(&rc->ref_cnt, 1, &old_ref_cnt);
 458         ovs_assert(old_ref_cnt > 0);
 459         ovs_rwlock_unlock(&netdev_class_rwlock);
 460     } else {
 461         ovs_mutex_unlock(&netdev_mutex);
 462     }
 463 }
 464
 465 /* Closes and destroys 'netdev'. */
 466 void
 467 netdev_close(struct netdev *netdev)
 468     OVS_EXCLUDED(netdev_mutex)
 469 {
 470     if (netdev) {
 471         ovs_mutex_lock(&netdev_mutex);
 472         netdev_unref(netdev);
 473     }
 474 }
 475
 476 /* Parses 'netdev_name_', which is of the form [type@]name into its component
 477  * pieces.  'name' and 'type' must be freed by the caller. */
 478 void
 479 netdev_parse_name(const char *netdev_name_, char **name, char **type)
 480 {
 481     char *netdev_name = xstrdup(netdev_name_);
 482     char *separator;
 483
 484     separator = strchr(netdev_name, '@');
 485     if (separator) {
 486         *separator = '\0';
 487         *type = netdev_name;
 488         *name = xstrdup(separator + 1);
 489     } else {
 490         *name = netdev_name;
 491         *type = xstrdup("system");
 492     }
 493 }
 494
 495 int
 496 netdev_rx_open(struct netdev *netdev, struct netdev_rx **rxp)
 497     OVS_EXCLUDED(netdev_mutex)
 498 {
 499     int error;
 500
 501     if (netdev->netdev_class->rx_alloc) {
 502         struct netdev_rx *rx = netdev->netdev_class->rx_alloc();
 503         if (rx) {
 504             rx->netdev = netdev;
 505             error = netdev->netdev_class->rx_construct(rx);
 506             if (!error) {
 507                 ovs_mutex_lock(&netdev_mutex);
 508                 netdev->ref_cnt++;
 509                 ovs_mutex_unlock(&netdev_mutex);
 510
 511                 *rxp = rx;
 512                 return 0;
 513             }
 514             netdev->netdev_class->rx_dealloc(rx);
 515         } else {
 516             error = ENOMEM;
 517         }
 518     } else {
 519         error = EOPNOTSUPP;
 520     }
 521
 522     *rxp = NULL;
 523     return error;
 524 }
 525
 526 void
 527 netdev_rx_close(struct netdev_rx *rx)
 528     OVS_EXCLUDED(netdev_mutex)
 529 {
 530     if (rx) {
 531         struct netdev *netdev = rx->netdev;
 532         netdev->netdev_class->rx_destruct(rx);
 533         netdev->netdev_class->rx_dealloc(rx);
 534         netdev_close(netdev);
 535     }
 536 }
 537
 538 int
 539 netdev_rx_recv(struct netdev_rx *rx, struct ofpbuf *buffer)
 540 {
 541     int retval;
 542
 543     ovs_assert(buffer->size == 0);
 544     ovs_assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
 545
 546     retval = rx->netdev->netdev_class->rx_recv(rx, buffer->data,
 547                                                ofpbuf_tailroom(buffer));
 548     if (retval >= 0) {
 549         COVERAGE_INC(netdev_received);
 550         buffer->size += retval;
 551         if (buffer->size < ETH_TOTAL_MIN) {
 552             ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
 553         }
 554         return 0;
 555     } else {
 556         return -retval;
 557     }
 558 }
 559
 560 void
 561 netdev_rx_wait(struct netdev_rx *rx)
 562 {
 563     rx->netdev->netdev_class->rx_wait(rx);
 564 }
 565
 566 int
 567 netdev_rx_drain(struct netdev_rx *rx)
 568 {
 569     return (rx->netdev->netdev_class->rx_drain
 570             ? rx->netdev->netdev_class->rx_drain(rx)
 571             : 0);
 572 }
 573
 574 /* Sends 'buffer' on 'netdev'.  Returns 0 if successful, otherwise a positive
 575  * errno value.  Returns EAGAIN without blocking if the packet cannot be queued
 576  * immediately.  Returns EMSGSIZE if a partial packet was transmitted or if
 577  * the packet is too big or too small to transmit on the device.
 578  *
 579  * The caller retains ownership of 'buffer' in all cases.
 580  *
 581  * The kernel maintains a packet transmission queue, so the caller is not
 582  * expected to do additional queuing of packets.
 583  *
 584  * Some network devices may not implement support for this function.  In such
 585  * cases this function will always return EOPNOTSUPP. */
 586 int
 587 netdev_send(struct netdev *netdev, const struct ofpbuf *buffer)
 588 {
 589     int error;
 590
 591     error = (netdev->netdev_class->send
 592              ? netdev->netdev_class->send(netdev, buffer->data, buffer->size)
 593              : EOPNOTSUPP);
 594     if (!error) {
 595         COVERAGE_INC(netdev_sent);
 596     }
 597     return error;
 598 }
 599
 600 /* Registers with the poll loop to wake up from the next call to poll_block()
 601  * when the packet transmission queue has sufficient room to transmit a packet
 602  * with netdev_send().
 603  *
 604  * The kernel maintains a packet transmission queue, so the client is not
 605  * expected to do additional queuing of packets.  Thus, this function is
 606  * unlikely to ever be used.  It is included for completeness. */
 607 void
 608 netdev_send_wait(struct netdev *netdev)
 609 {
 610     if (netdev->netdev_class->send_wait) {
 611         netdev->netdev_class->send_wait(netdev);
 612     }
 613 }
 614
 615 /* Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
 616  * otherwise a positive errno value. */
 617 int
 618 netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN])
 619 {
 620     return netdev->netdev_class->set_etheraddr(netdev, mac);
 621 }
 622
 623 /* Retrieves 'netdev''s MAC address.  If successful, returns 0 and copies the
 624  * the MAC address into 'mac'.  On failure, returns a positive errno value and
 625  * clears 'mac' to all-zeros. */
 626 int
 627 netdev_get_etheraddr(const struct netdev *netdev, uint8_t mac[ETH_ADDR_LEN])
 628 {
 629     return netdev->netdev_class->get_etheraddr(netdev, mac);
 630 }
 631
 632 /* Returns the name of the network device that 'netdev' represents,
 633  * e.g. "eth0".  The caller must not modify or free the returned string. */
 634 const char *
 635 netdev_get_name(const struct netdev *netdev)
 636 {
 637     return netdev->name;
 638 }
 639
 640 /* Retrieves the MTU of 'netdev'.  The MTU is the maximum size of transmitted
 641  * (and received) packets, in bytes, not including the hardware header; thus,
 642  * this is typically 1500 bytes for Ethernet devices.
 643  *
 644  * If successful, returns 0 and stores the MTU size in '*mtup'.  Returns
 645  * EOPNOTSUPP if 'netdev' does not have an MTU (as e.g. some tunnels do not).
 646  * On other failure, returns a positive errno value.  On failure, sets '*mtup'
 647  * to 0. */
 648 int
 649 netdev_get_mtu(const struct netdev *netdev, int *mtup)
 650 {
 651     const struct netdev_class *class = netdev->netdev_class;
 652     int error;
 653
 654     error = class->get_mtu ? class->get_mtu(netdev, mtup) : EOPNOTSUPP;
 655     if (error) {
 656         *mtup = 0;
 657         if (error != EOPNOTSUPP) {
 658             VLOG_DBG_RL(&rl, "failed to retrieve MTU for network device %s: "
 659                          "%s", netdev_get_name(netdev), ovs_strerror(error));
 660         }
 661     }
 662     return error;
 663 }
 664
 665 /* Sets the MTU of 'netdev'.  The MTU is the maximum size of transmitted
 666  * (and received) packets, in bytes.
 667  *
 668  * If successful, returns 0.  Returns EOPNOTSUPP if 'netdev' does not have an
 669  * MTU (as e.g. some tunnels do not).  On other failure, returns a positive
 670  * errno value. */
 671 int
 672 netdev_set_mtu(const struct netdev *netdev, int mtu)
 673 {
 674     const struct netdev_class *class = netdev->netdev_class;
 675     int error;
 676
 677     error = class->set_mtu ? class->set_mtu(netdev, mtu) : EOPNOTSUPP;
 678     if (error && error != EOPNOTSUPP) {
 679         VLOG_DBG_RL(&rl, "failed to set MTU for network device %s: %s",
 680                      netdev_get_name(netdev), ovs_strerror(error));
 681     }
 682
 683     return error;
 684 }
 685
 686 /* Returns the ifindex of 'netdev', if successful, as a positive number.  On
 687  * failure, returns a negative errno value.
 688  *
 689  * The desired semantics of the ifindex value are a combination of those
 690  * specified by POSIX for if_nametoindex() and by SNMP for ifIndex.  An ifindex
 691  * value should be unique within a host and remain stable at least until
 692  * reboot.  SNMP says an ifindex "ranges between 1 and the value of ifNumber"
 693  * but many systems do not follow this rule anyhow.
 694  *
 695  * Some network devices may not implement support for this function.  In such
 696  * cases this function will always return -EOPNOTSUPP.
 697  */
 698 int
 699 netdev_get_ifindex(const struct netdev *netdev)
 700 {
 701     int (*get_ifindex)(const struct netdev *);
 702
 703     get_ifindex = netdev->netdev_class->get_ifindex;
 704
 705     return get_ifindex ? get_ifindex(netdev) : -EOPNOTSUPP;
 706 }
 707
 708 /* Stores the features supported by 'netdev' into each of '*current',
 709  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
 710  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
 711  * successful, otherwise a positive errno value.  On failure, all of the
 712  * passed-in values are set to 0.
 713  *
 714  * Some network devices may not implement support for this function.  In such
 715  * cases this function will always return EOPNOTSUPP. */
 716 int
 717 netdev_get_features(const struct netdev *netdev,
 718                     enum netdev_features *current,
 719                     enum netdev_features *advertised,
 720                     enum netdev_features *supported,
 721                     enum netdev_features *peer)
 722 {
 723     int (*get_features)(const struct netdev *netdev,
 724                         enum netdev_features *current,
 725                         enum netdev_features *advertised,
 726                         enum netdev_features *supported,
 727                         enum netdev_features *peer);
 728     enum netdev_features dummy[4];
 729     int error;
 730
 731     if (!current) {
 732         current = &dummy[0];
 733     }
 734     if (!advertised) {
 735         advertised = &dummy[1];
 736     }
 737     if (!supported) {
 738         supported = &dummy[2];
 739     }
 740     if (!peer) {
 741         peer = &dummy[3];
 742     }
 743
 744     get_features = netdev->netdev_class->get_features;
 745     error = get_features
 746                     ? get_features(netdev, current, advertised, supported,
 747                                    peer)
 748                     : EOPNOTSUPP;
 749     if (error) {
 750         *current = *advertised = *supported = *peer = 0;
 751     }
 752     return error;
 753 }
 754
 755 /* Returns the maximum speed of a network connection that has the NETDEV_F_*
 756  * bits in 'features', in bits per second.  If no bits that indicate a speed
 757  * are set in 'features', returns 'default_bps'. */
 758 uint64_t
 759 netdev_features_to_bps(enum netdev_features features,
 760                        uint64_t default_bps)
 761 {
 762     enum {
 763         F_1000000MB = NETDEV_F_1TB_FD,
 764         F_100000MB = NETDEV_F_100GB_FD,
 765         F_40000MB = NETDEV_F_40GB_FD,
 766         F_10000MB = NETDEV_F_10GB_FD,
 767         F_1000MB = NETDEV_F_1GB_HD | NETDEV_F_1GB_FD,
 768         F_100MB = NETDEV_F_100MB_HD | NETDEV_F_100MB_FD,
 769         F_10MB = NETDEV_F_10MB_HD | NETDEV_F_10MB_FD
 770     };
 771
 772     return (  features & F_1000000MB ? UINT64_C(1000000000000)
 773             : features & F_100000MB  ? UINT64_C(100000000000)
 774             : features & F_40000MB   ? UINT64_C(40000000000)
 775             : features & F_10000MB   ? UINT64_C(10000000000)
 776             : features & F_1000MB    ? UINT64_C(1000000000)
 777             : features & F_100MB     ? UINT64_C(100000000)
 778             : features & F_10MB      ? UINT64_C(10000000)
 779                                      : default_bps);
 780 }
 781
 782 /* Returns true if any of the NETDEV_F_* bits that indicate a full-duplex link
 783  * are set in 'features', otherwise false. */
 784 bool
 785 netdev_features_is_full_duplex(enum netdev_features features)
 786 {
 787     return (features & (NETDEV_F_10MB_FD | NETDEV_F_100MB_FD | NETDEV_F_1GB_FD
 788                         | NETDEV_F_10GB_FD | NETDEV_F_40GB_FD
 789                         | NETDEV_F_100GB_FD | NETDEV_F_1TB_FD)) != 0;
 790 }
 791
 792 /* Set the features advertised by 'netdev' to 'advertise'.  Returns 0 if
 793  * successful, otherwise a positive errno value. */
 794 int
 795 netdev_set_advertisements(struct netdev *netdev,
 796                           enum netdev_features advertise)
 797 {
 798     return (netdev->netdev_class->set_advertisements
 799             ? netdev->netdev_class->set_advertisements(
 800                     netdev, advertise)
 801             : EOPNOTSUPP);
 802 }
 803
 804 /* If 'netdev' has an assigned IPv4 address, sets '*address' to that address
 805  * and '*netmask' to its netmask and returns 0.  Otherwise, returns a positive
 806  * errno value and sets '*address' to 0 (INADDR_ANY).
 807  *
 808  * The following error values have well-defined meanings:
 809  *
 810  *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address.
 811  *
 812  *   - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
 813  *
 814  * 'address' or 'netmask' or both may be null, in which case the address or
 815  * netmask is not reported. */
 816 int
 817 netdev_get_in4(const struct netdev *netdev,
 818                struct in_addr *address_, struct in_addr *netmask_)
 819 {
 820     struct in_addr address;
 821     struct in_addr netmask;
 822     int error;
 823
 824     error = (netdev->netdev_class->get_in4
 825              ? netdev->netdev_class->get_in4(netdev,
 826                     &address, &netmask)
 827              : EOPNOTSUPP);
 828     if (address_) {
 829         address_->s_addr = error ? 0 : address.s_addr;
 830     }
 831     if (netmask_) {
 832         netmask_->s_addr = error ? 0 : netmask.s_addr;
 833     }
 834     return error;
 835 }
 836
 837 /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
 838  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
 839  * positive errno value. */
 840 int
 841 netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask)
 842 {
 843     return (netdev->netdev_class->set_in4
 844             ? netdev->netdev_class->set_in4(netdev, addr, mask)
 845             : EOPNOTSUPP);
 846 }
 847
 848 /* Obtains ad IPv4 address from device name and save the address in
 849  * in4.  Returns 0 if successful, otherwise a positive errno value.
 850  */
 851 int
 852 netdev_get_in4_by_name(const char *device_name, struct in_addr *in4)
 853 {
 854     struct netdev *netdev;
 855     int error;
 856
 857     error = netdev_open(device_name, "system", &netdev);
 858     if (error) {
 859         in4->s_addr = htonl(0);
 860         return error;
 861     }
 862
 863     error = netdev_get_in4(netdev, in4, NULL);
 864     netdev_close(netdev);
 865     return error;
 866 }
 867
 868 /* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds
 869  * to 'netdev'. */
 870 int
 871 netdev_add_router(struct netdev *netdev, struct in_addr router)
 872 {
 873     COVERAGE_INC(netdev_add_router);
 874     return (netdev->netdev_class->add_router
 875             ? netdev->netdev_class->add_router(netdev, router)
 876             : EOPNOTSUPP);
 877 }
 878
 879 /* Looks up the next hop for 'host' for the TCP/IP stack that corresponds to
 880  * 'netdev'.  If a route cannot not be determined, sets '*next_hop' to 0,
 881  * '*netdev_name' to null, and returns a positive errno value.  Otherwise, if a
 882  * next hop is found, stores the next hop gateway's address (0 if 'host' is on
 883  * a directly connected network) in '*next_hop' and a copy of the name of the
 884  * device to reach 'host' in '*netdev_name', and returns 0.  The caller is
 885  * responsible for freeing '*netdev_name' (by calling free()). */
 886 int
 887 netdev_get_next_hop(const struct netdev *netdev,
 888                     const struct in_addr *host, struct in_addr *next_hop,
 889                     char **netdev_name)
 890 {
 891     int error = (netdev->netdev_class->get_next_hop
 892                  ? netdev->netdev_class->get_next_hop(
 893                         host, next_hop, netdev_name)
 894                  : EOPNOTSUPP);
 895     if (error) {
 896         next_hop->s_addr = 0;
 897         *netdev_name = NULL;
 898     }
 899     return error;
 900 }
 901
 902 /* Populates 'smap' with status information.
 903  *
 904  * Populates 'smap' with 'netdev' specific status information.  This
 905  * information may be used to populate the status column of the Interface table
 906  * as defined in ovs-vswitchd.conf.db(5). */
 907 int
 908 netdev_get_status(const struct netdev *netdev, struct smap *smap)
 909 {
 910     return (netdev->netdev_class->get_status
 911             ? netdev->netdev_class->get_status(netdev, smap)
 912             : EOPNOTSUPP);
 913 }
 914
 915 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address and
 916  * returns 0.  Otherwise, returns a positive errno value and sets '*in6' to
 917  * all-zero-bits (in6addr_any).
 918  *
 919  * The following error values have well-defined meanings:
 920  *
 921  *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address.
 922  *
 923  *   - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'.
 924  *
 925  * 'in6' may be null, in which case the address itself is not reported. */
 926 int
 927 netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6)
 928 {
 929     struct in6_addr dummy;
 930     int error;
 931
 932     error = (netdev->netdev_class->get_in6
 933              ? netdev->netdev_class->get_in6(netdev,
 934                     in6 ? in6 : &dummy)
 935              : EOPNOTSUPP);
 936     if (error && in6) {
 937         memset(in6, 0, sizeof *in6);
 938     }
 939     return error;
 940 }
 941
 942 /* On 'netdev', turns off the flags in 'off' and then turns on the flags in
 943  * 'on'.  Returns 0 if successful, otherwise a positive errno value. */
 944 static int
 945 do_update_flags(struct netdev *netdev, enum netdev_flags off,
 946                 enum netdev_flags on, enum netdev_flags *old_flagsp,
 947                 struct netdev_saved_flags **sfp)
 948     OVS_EXCLUDED(netdev_mutex)
 949 {
 950     struct netdev_saved_flags *sf = NULL;
 951     enum netdev_flags old_flags;
 952     int error;
 953
 954     error = netdev->netdev_class->update_flags(netdev, off & ~on, on,
 955                                                &old_flags);
 956     if (error) {
 957         VLOG_WARN_RL(&rl, "failed to %s flags for network device %s: %s",
 958                      off || on ? "set" : "get", netdev_get_name(netdev),
 959                      ovs_strerror(error));
 960         old_flags = 0;
 961     } else if ((off || on) && sfp) {
 962         enum netdev_flags new_flags = (old_flags & ~off) | on;
 963         enum netdev_flags changed_flags = old_flags ^ new_flags;
 964         if (changed_flags) {
 965             ovs_mutex_lock(&netdev_mutex);
 966             *sfp = sf = xmalloc(sizeof *sf);
 967             sf->netdev = netdev;
 968             list_push_front(&netdev->saved_flags_list, &sf->node);
 969             sf->saved_flags = changed_flags;
 970             sf->saved_values = changed_flags & new_flags;
 971
 972             netdev->ref_cnt++;
 973             ovs_mutex_unlock(&netdev_mutex);
 974         }
 975     }
 976
 977     if (old_flagsp) {
 978         *old_flagsp = old_flags;
 979     }
 980     if (sfp) {
 981         *sfp = sf;
 982     }
 983
 984     return error;
 985 }
 986
 987 /* Obtains the current flags for 'netdev' and stores them into '*flagsp'.
 988  * Returns 0 if successful, otherwise a positive errno value.  On failure,
 989  * stores 0 into '*flagsp'. */
 990 int
 991 netdev_get_flags(const struct netdev *netdev_, enum netdev_flags *flagsp)
 992 {
 993     struct netdev *netdev = CONST_CAST(struct netdev *, netdev_);
 994     return do_update_flags(netdev, 0, 0, flagsp, NULL);
 995 }
 996
 997 /* Sets the flags for 'netdev' to 'flags'.
 998  * Returns 0 if successful, otherwise a positive errno value. */
 999 int
1000 netdev_set_flags(struct netdev *netdev, enum netdev_flags flags,
1001                  struct netdev_saved_flags **sfp)
1002 {
1003     return do_update_flags(netdev, -1, flags, NULL, sfp);
1004 }
1005
1006 /* Turns on the specified 'flags' on 'netdev':
1007  *
1008  *    - On success, returns 0.  If 'sfp' is nonnull, sets '*sfp' to a newly
1009  *      allocated 'struct netdev_saved_flags *' that may be passed to
1010  *      netdev_restore_flags() to restore the original values of 'flags' on
1011  *      'netdev' (this will happen automatically at program termination if
1012  *      netdev_restore_flags() is never called) , or to NULL if no flags were
1013  *      actually changed.
1014  *
1015  *    - On failure, returns a positive errno value.  If 'sfp' is nonnull, sets
1016  *      '*sfp' to NULL. */
1017 int
1018 netdev_turn_flags_on(struct netdev *netdev, enum netdev_flags flags,
1019                      struct netdev_saved_flags **sfp)
1020 {
1021     return do_update_flags(netdev, 0, flags, NULL, sfp);
1022 }
1023
1024 /* Turns off the specified 'flags' on 'netdev'.  See netdev_turn_flags_on() for
1025  * details of the interface. */
1026 int
1027 netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
1028                       struct netdev_saved_flags **sfp)
1029 {
1030     return do_update_flags(netdev, flags, 0, NULL, sfp);
1031 }
1032
1033 /* Restores the flags that were saved in 'sf', and destroys 'sf'.
1034  * Does nothing if 'sf' is NULL. */
1035 void
1036 netdev_restore_flags(struct netdev_saved_flags *sf)
1037     OVS_EXCLUDED(netdev_mutex)
1038 {
1039     if (sf) {
1040         struct netdev *netdev = sf->netdev;
1041         enum netdev_flags old_flags;
1042
1043         netdev->netdev_class->update_flags(netdev,
1044                                            sf->saved_flags & sf->saved_values,
1045                                            sf->saved_flags & ~sf->saved_values,
1046                                            &old_flags);
1047
1048         ovs_mutex_lock(&netdev_mutex);
1049         list_remove(&sf->node);
1050         free(sf);
1051         netdev_unref(netdev);
1052     }
1053 }
1054
1055 /* Looks up the ARP table entry for 'ip' on 'netdev'.  If one exists and can be
1056  * successfully retrieved, it stores the corresponding MAC address in 'mac' and
1057  * returns 0.  Otherwise, it returns a positive errno value; in particular,
1058  * ENXIO indicates that there is no ARP table entry for 'ip' on 'netdev'. */
1059 int
1060 netdev_arp_lookup(const struct netdev *netdev,
1061                   ovs_be32 ip, uint8_t mac[ETH_ADDR_LEN])
1062 {
1063     int error = (netdev->netdev_class->arp_lookup
1064                  ? netdev->netdev_class->arp_lookup(netdev, ip, mac)
1065                  : EOPNOTSUPP);
1066     if (error) {
1067         memset(mac, 0, ETH_ADDR_LEN);
1068     }
1069     return error;
1070 }
1071
1072 /* Returns true if carrier is active (link light is on) on 'netdev'. */
1073 bool
1074 netdev_get_carrier(const struct netdev *netdev)
1075 {
1076     int error;
1077     enum netdev_flags flags;
1078     bool carrier;
1079
1080     netdev_get_flags(netdev, &flags);
1081     if (!(flags & NETDEV_UP)) {
1082         return false;
1083     }
1084
1085     if (!netdev->netdev_class->get_carrier) {
1086         return true;
1087     }
1088
1089     error = netdev->netdev_class->get_carrier(netdev, &carrier);
1090     if (error) {
1091         VLOG_DBG("%s: failed to get network device carrier status, assuming "
1092                  "down: %s", netdev_get_name(netdev), ovs_strerror(error));
1093         carrier = false;
1094     }
1095
1096     return carrier;
1097 }
1098
1099 /* Returns the number of times 'netdev''s carrier has changed. */
1100 long long int
1101 netdev_get_carrier_resets(const struct netdev *netdev)
1102 {
1103     return (netdev->netdev_class->get_carrier_resets
1104             ? netdev->netdev_class->get_carrier_resets(netdev)
1105             : 0);
1106 }
1107
1108 /* Attempts to force netdev_get_carrier() to poll 'netdev''s MII registers for
1109  * link status instead of checking 'netdev''s carrier.  'netdev''s MII
1110  * registers will be polled once ever 'interval' milliseconds.  If 'netdev'
1111  * does not support MII, another method may be used as a fallback.  If
1112  * 'interval' is less than or equal to zero, reverts netdev_get_carrier() to
1113  * its normal behavior.
1114  *
1115  * Returns 0 if successful, otherwise a positive errno value. */
1116 int
1117 netdev_set_miimon_interval(struct netdev *netdev, long long int interval)
1118 {
1119     return (netdev->netdev_class->set_miimon_interval
1120             ? netdev->netdev_class->set_miimon_interval(netdev, interval)
1121             : EOPNOTSUPP);
1122 }
1123
1124 /* Retrieves current device stats for 'netdev'. */
1125 int
1126 netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
1127 {
1128     int error;
1129
1130     COVERAGE_INC(netdev_get_stats);
1131     error = (netdev->netdev_class->get_stats
1132              ? netdev->netdev_class->get_stats(netdev, stats)
1133              : EOPNOTSUPP);
1134     if (error) {
1135         memset(stats, 0xff, sizeof *stats);
1136     }
1137     return error;
1138 }
1139
1140 /* Attempts to change the stats for 'netdev' to those provided in 'stats'.
1141  * Returns 0 if successful, otherwise a positive errno value.
1142  *
1143  * This will probably fail for most network devices.  Some devices might only
1144  * allow setting their stats to 0. */
1145 int
1146 netdev_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
1147 {
1148     return (netdev->netdev_class->set_stats
1149              ? netdev->netdev_class->set_stats(netdev, stats)
1150              : EOPNOTSUPP);
1151 }
1152
1153 /* Attempts to set input rate limiting (policing) policy, such that up to
1154  * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative burst
1155  * size of 'kbits' kb. */
1156 int
1157 netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate,
1158                     uint32_t kbits_burst)
1159 {
1160     return (netdev->netdev_class->set_policing
1161             ? netdev->netdev_class->set_policing(netdev,
1162                     kbits_rate, kbits_burst)
1163             : EOPNOTSUPP);
1164 }
1165
1166 /* Adds to 'types' all of the forms of QoS supported by 'netdev', or leaves it
1167  * empty if 'netdev' does not support QoS.  Any names added to 'types' should
1168  * be documented as valid for the "type" column in the "QoS" table in
1169  * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
1170  *
1171  * Every network device supports disabling QoS with a type of "", but this type
1172  * will not be added to 'types'.
1173  *
1174  * The caller must initialize 'types' (e.g. with sset_init()) before calling
1175  * this function.  The caller is responsible for destroying 'types' (e.g. with
1176  * sset_destroy()) when it is no longer needed.
1177  *
1178  * Returns 0 if successful, otherwise a positive errno value. */
1179 int
1180 netdev_get_qos_types(const struct netdev *netdev, struct sset *types)
1181 {
1182     const struct netdev_class *class = netdev->netdev_class;
1183     return (class->get_qos_types
1184             ? class->get_qos_types(netdev, types)
1185             : 0);
1186 }
1187
1188 /* Queries 'netdev' for its capabilities regarding the specified 'type' of QoS,
1189  * which should be "" or one of the types returned by netdev_get_qos_types()
1190  * for 'netdev'.  Returns 0 if successful, otherwise a positive errno value.
1191  * On success, initializes 'caps' with the QoS capabilities; on failure, clears
1192  * 'caps' to all zeros. */
1193 int
1194 netdev_get_qos_capabilities(const struct netdev *netdev, const char *type,
1195                             struct netdev_qos_capabilities *caps)
1196 {
1197     const struct netdev_class *class = netdev->netdev_class;
1198
1199     if (*type) {
1200         int retval = (class->get_qos_capabilities
1201                       ? class->get_qos_capabilities(netdev, type, caps)
1202                       : EOPNOTSUPP);
1203         if (retval) {
1204             memset(caps, 0, sizeof *caps);
1205         }
1206         return retval;
1207     } else {
1208         /* Every netdev supports turning off QoS. */
1209         memset(caps, 0, sizeof *caps);
1210         return 0;
1211     }
1212 }
1213
1214 /* Obtains the number of queues supported by 'netdev' for the specified 'type'
1215  * of QoS.  Returns 0 if successful, otherwise a positive errno value.  Stores
1216  * the number of queues (zero on failure) in '*n_queuesp'.
1217  *
1218  * This is just a simple wrapper around netdev_get_qos_capabilities(). */
1219 int
1220 netdev_get_n_queues(const struct netdev *netdev,
1221                     const char *type, unsigned int *n_queuesp)
1222 {
1223     struct netdev_qos_capabilities caps;
1224     int retval;
1225
1226     retval = netdev_get_qos_capabilities(netdev, type, &caps);
1227     *n_queuesp = caps.n_queues;
1228     return retval;
1229 }
1230
1231 /* Queries 'netdev' about its currently configured form of QoS.  If successful,
1232  * stores the name of the current form of QoS into '*typep', stores any details
1233  * of configuration as string key-value pairs in 'details', and returns 0.  On
1234  * failure, sets '*typep' to NULL and returns a positive errno value.
1235  *
1236  * A '*typep' of "" indicates that QoS is currently disabled on 'netdev'.
1237  *
1238  * The caller must initialize 'details' as an empty smap (e.g. with
1239  * smap_init()) before calling this function.  The caller must free 'details'
1240  * when it is no longer needed (e.g. with smap_destroy()).
1241  *
1242  * The caller must not modify or free '*typep'.
1243  *
1244  * '*typep' will be one of the types returned by netdev_get_qos_types() for
1245  * 'netdev'.  The contents of 'details' should be documented as valid for
1246  * '*typep' in the "other_config" column in the "QoS" table in
1247  * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)). */
1248 int
1249 netdev_get_qos(const struct netdev *netdev,
1250                const char **typep, struct smap *details)
1251 {
1252     const struct netdev_class *class = netdev->netdev_class;
1253     int retval;
1254
1255     if (class->get_qos) {
1256         retval = class->get_qos(netdev, typep, details);
1257         if (retval) {
1258             *typep = NULL;
1259             smap_clear(details);
1260         }
1261         return retval;
1262     } else {
1263         /* 'netdev' doesn't support QoS, so report that QoS is disabled. */
1264         *typep = "";
1265         return 0;
1266     }
1267 }
1268
1269 /* Attempts to reconfigure QoS on 'netdev', changing the form of QoS to 'type'
1270  * with details of configuration from 'details'.  Returns 0 if successful,
1271  * otherwise a positive errno value.  On error, the previous QoS configuration
1272  * is retained.
1273  *
1274  * When this function changes the type of QoS (not just 'details'), this also
1275  * resets all queue configuration for 'netdev' to their defaults (which depend
1276  * on the specific type of QoS).  Otherwise, the queue configuration for
1277  * 'netdev' is unchanged.
1278  *
1279  * 'type' should be "" (to disable QoS) or one of the types returned by
1280  * netdev_get_qos_types() for 'netdev'.  The contents of 'details' should be
1281  * documented as valid for the given 'type' in the "other_config" column in the
1282  * "QoS" table in vswitchd/vswitch.xml (which is built as
1283  * ovs-vswitchd.conf.db(8)).
1284  *
1285  * NULL may be specified for 'details' if there are no configuration
1286  * details. */
1287 int
1288 netdev_set_qos(struct netdev *netdev,
1289                const char *type, const struct smap *details)
1290 {
1291     const struct netdev_class *class = netdev->netdev_class;
1292
1293     if (!type) {
1294         type = "";
1295     }
1296
1297     if (class->set_qos) {
1298         if (!details) {
1299             static const struct smap empty = SMAP_INITIALIZER(&empty);
1300             details = &empty;
1301         }
1302         return class->set_qos(netdev, type, details);
1303     } else {
1304         return *type ? EOPNOTSUPP : 0;
1305     }
1306 }
1307
1308 /* Queries 'netdev' for information about the queue numbered 'queue_id'.  If
1309  * successful, adds that information as string key-value pairs to 'details'.
1310  * Returns 0 if successful, otherwise a positive errno value.
1311  *
1312  * 'queue_id' must be less than the number of queues supported by 'netdev' for
1313  * the current form of QoS (e.g. as returned by netdev_get_n_queues(netdev)).
1314  *
1315  * The returned contents of 'details' should be documented as valid for the
1316  * given 'type' in the "other_config" column in the "Queue" table in
1317  * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
1318  *
1319  * The caller must initialize 'details' (e.g. with smap_init()) before calling
1320  * this function.  The caller must free 'details' when it is no longer needed
1321  * (e.g. with smap_destroy()). */
1322 int
1323 netdev_get_queue(const struct netdev *netdev,
1324                  unsigned int queue_id, struct smap *details)
1325 {
1326     const struct netdev_class *class = netdev->netdev_class;
1327     int retval;
1328
1329     retval = (class->get_queue
1330               ? class->get_queue(netdev, queue_id, details)
1331               : EOPNOTSUPP);
1332     if (retval) {
1333         smap_clear(details);
1334     }
1335     return retval;
1336 }
1337
1338 /* Configures the queue numbered 'queue_id' on 'netdev' with the key-value
1339  * string pairs in 'details'.  The contents of 'details' should be documented
1340  * as valid for the given 'type' in the "other_config" column in the "Queue"
1341  * table in vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
1342  * Returns 0 if successful, otherwise a positive errno value.  On failure, the
1343  * given queue's configuration should be unmodified.
1344  *
1345  * 'queue_id' must be less than the number of queues supported by 'netdev' for
1346  * the current form of QoS (e.g. as returned by netdev_get_n_queues(netdev)).
1347  *
1348  * This function does not modify 'details', and the caller retains ownership of
1349  * it. */
1350 int
1351 netdev_set_queue(struct netdev *netdev,
1352                  unsigned int queue_id, const struct smap *details)
1353 {
1354     const struct netdev_class *class = netdev->netdev_class;
1355     return (class->set_queue
1356             ? class->set_queue(netdev, queue_id, details)
1357             : EOPNOTSUPP);
1358 }
1359
1360 /* Attempts to delete the queue numbered 'queue_id' from 'netdev'.  Some kinds
1361  * of QoS may have a fixed set of queues, in which case attempts to delete them
1362  * will fail with EOPNOTSUPP.
1363  *
1364  * Returns 0 if successful, otherwise a positive errno value.  On failure, the
1365  * given queue will be unmodified.
1366  *
1367  * 'queue_id' must be less than the number of queues supported by 'netdev' for
1368  * the current form of QoS (e.g. as returned by
1369  * netdev_get_n_queues(netdev)). */
1370 int
1371 netdev_delete_queue(struct netdev *netdev, unsigned int queue_id)
1372 {
1373     const struct netdev_class *class = netdev->netdev_class;
1374     return (class->delete_queue
1375             ? class->delete_queue(netdev, queue_id)
1376             : EOPNOTSUPP);
1377 }
1378
1379 /* Obtains statistics about 'queue_id' on 'netdev'.  On success, returns 0 and
1380  * fills 'stats' with the queue's statistics; individual members of 'stats' may
1381  * be set to all-1-bits if the statistic is unavailable.  On failure, returns a
1382  * positive errno value and fills 'stats' with values indicating unsupported
1383  * statistics. */
1384 int
1385 netdev_get_queue_stats(const struct netdev *netdev, unsigned int queue_id,
1386                        struct netdev_queue_stats *stats)
1387 {
1388     const struct netdev_class *class = netdev->netdev_class;
1389     int retval;
1390
1391     retval = (class->get_queue_stats
1392               ? class->get_queue_stats(netdev, queue_id, stats)
1393               : EOPNOTSUPP);
1394     if (retval) {
1395         stats->tx_bytes = UINT64_MAX;
1396         stats->tx_packets = UINT64_MAX;
1397         stats->tx_errors = UINT64_MAX;
1398         stats->created = LLONG_MIN;
1399     }
1400     return retval;
1401 }
1402
1403 /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's ID,
1404  * its configuration, and the 'aux' specified by the caller.  The order of
1405  * iteration is unspecified, but (when successful) each queue is visited
1406  * exactly once.
1407  *
1408  * Calling this function may be more efficient than calling netdev_get_queue()
1409  * for every queue.
1410  *
1411  * 'cb' must not modify or free the 'details' argument passed in.  It may
1412  * delete or modify the queue passed in as its 'queue_id' argument.  It may
1413  * modify but must not delete any other queue within 'netdev'.  'cb' should not
1414  * add new queues because this may cause some queues to be visited twice or not
1415  * at all.
1416  *
1417  * Returns 0 if successful, otherwise a positive errno value.  On error, some
1418  * configured queues may not have been included in the iteration. */
1419 int
1420 netdev_dump_queues(const struct netdev *netdev,
1421                    netdev_dump_queues_cb *cb, void *aux)
1422 {
1423     const struct netdev_class *class = netdev->netdev_class;
1424     return (class->dump_queues
1425             ? class->dump_queues(netdev, cb, aux)
1426             : EOPNOTSUPP);
1427 }
1428
1429 /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's ID,
1430  * its statistics, and the 'aux' specified by the caller.  The order of
1431  * iteration is unspecified, but (when successful) each queue is visited
1432  * exactly once.
1433  *
1434  * Calling this function may be more efficient than calling
1435  * netdev_get_queue_stats() for every queue.
1436  *
1437  * 'cb' must not modify or free the statistics passed in.
1438  *
1439  * Returns 0 if successful, otherwise a positive errno value.  On error, some
1440  * configured queues may not have been included in the iteration. */
1441 int
1442 netdev_dump_queue_stats(const struct netdev *netdev,
1443                         netdev_dump_queue_stats_cb *cb, void *aux)
1444 {
1445     const struct netdev_class *class = netdev->netdev_class;
1446     return (class->dump_queue_stats
1447             ? class->dump_queue_stats(netdev, cb, aux)
1448             : EOPNOTSUPP);
1449 }
1450
1451 /* Returns a sequence number which indicates changes in one of 'netdev''s
1452  * properties.  The returned sequence will be nonzero so that callers have a
1453  * value which they may use as a reset when tracking 'netdev'.
1454  *
1455  * The returned sequence number will change whenever 'netdev''s flags,
1456  * features, ethernet address, or carrier changes.  It may change for other
1457  * reasons as well, or no reason at all. */
1458 unsigned int
1459 netdev_change_seq(const struct netdev *netdev)
1460 {
1461     return netdev->netdev_class->change_seq(netdev);
1462 }
1463 \f
1464 /* Returns the class type of 'netdev'.
1465  *
1466  * The caller must not free the returned value. */
1467 const char *
1468 netdev_get_type(const struct netdev *netdev)
1469 {
1470     return netdev->netdev_class->type;
1471 }
1472
1473 /* Returns the class associated with 'netdev'. */
1474 const struct netdev_class *
1475 netdev_get_class(const struct netdev *netdev)
1476 {
1477     return netdev->netdev_class;
1478 }
1479
1480 /* Returns the netdev with 'name' or NULL if there is none.
1481  *
1482  * The caller must free the returned netdev with netdev_close(). */
1483 struct netdev *
1484 netdev_from_name(const char *name)
1485     OVS_EXCLUDED(netdev_mutex)
1486 {
1487     struct netdev *netdev;
1488
1489     ovs_mutex_lock(&netdev_mutex);
1490     netdev = shash_find_data(&netdev_shash, name);
1491     if (netdev) {
1492         netdev->ref_cnt++;
1493     }
1494     ovs_mutex_unlock(&netdev_mutex);
1495
1496     return netdev;
1497 }
1498
1499 /* Fills 'device_list' with devices that match 'netdev_class'.
1500  *
1501  * The caller is responsible for initializing and destroying 'device_list' and
1502  * must close each device on the list. */
1503 void
1504 netdev_get_devices(const struct netdev_class *netdev_class,
1505                    struct shash *device_list)
1506     OVS_EXCLUDED(netdev_mutex)
1507 {
1508     struct shash_node *node;
1509
1510     ovs_mutex_lock(&netdev_mutex);
1511     SHASH_FOR_EACH (node, &netdev_shash) {
1512         struct netdev *dev = node->data;
1513
1514         if (dev->netdev_class == netdev_class) {
1515             dev->ref_cnt++;
1516             shash_add(device_list, node->name, node->data);
1517         }
1518     }
1519     ovs_mutex_unlock(&netdev_mutex);
1520 }
1521
1522 const char *
1523 netdev_get_type_from_name(const char *name)
1524 {
1525     struct netdev *dev = netdev_from_name(name);
1526     const char *type = dev ? netdev_get_type(dev) : NULL;
1527     netdev_close(dev);
1528     return type;
1529 }
1530 \f
1531 struct netdev *
1532 netdev_rx_get_netdev(const struct netdev_rx *rx)
1533 {
1534     ovs_assert(rx->netdev->ref_cnt > 0);
1535     return rx->netdev;
1536 }
1537
1538 const char *
1539 netdev_rx_get_name(const struct netdev_rx *rx)
1540 {
1541     return netdev_get_name(netdev_rx_get_netdev(rx));
1542 }
1543
1544 static void
1545 restore_all_flags(void *aux OVS_UNUSED)
1546 {
1547     struct shash_node *node;
1548
1549     SHASH_FOR_EACH (node, &netdev_shash) {
1550         struct netdev *netdev = node->data;
1551         const struct netdev_saved_flags *sf;
1552         enum netdev_flags saved_values;
1553         enum netdev_flags saved_flags;
1554
1555         saved_values = saved_flags = 0;
1556         LIST_FOR_EACH (sf, node, &netdev->saved_flags_list) {
1557             saved_flags |= sf->saved_flags;
1558             saved_values &= ~sf->saved_flags;
1559             saved_values |= sf->saved_flags & sf->saved_values;
1560         }
1561         if (saved_flags) {
1562             enum netdev_flags old_flags;
1563
1564             netdev->netdev_class->update_flags(netdev,
1565                                                saved_flags & saved_values,
1566                                                saved_flags & ~saved_values,
1567                                                &old_flags);
1568         }
1569     }
1570 }