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