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