X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnetdev.c;h=f5f92333d62863be7a1eaaef70610d14f23adaad;hb=db19b72b9f6d0d40b743214241d9666116e3b448;hp=d5a51fa0ea90b91b4524c47859cf8105776bac73;hpb=bd3ad2c3508aaf7283f3ee041ecd3e5108471b21;p=sliver-openvswitch.git

diff --git a/lib/netdev.c b/lib/netdev.c
index d5a51fa0e..f5f92333d 100644
--- a/lib/netdev.c
+++ b/lib/netdev.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,6 +24,7 @@
 #include <string.h>
 #include <unistd.h>
 
+#include "connectivity.h"
 #include "coverage.h"
 #include "dpif.h"
 #include "dynamic-string.h"
@@ -36,6 +37,7 @@
 #include "openflow/openflow.h"
 #include "packets.h"
 #include "poll-loop.h"
+#include "seq.h"
 #include "shash.h"
 #include "smap.h"
 #include "sset.h"
@@ -56,10 +58,30 @@ struct netdev_saved_flags {
     enum netdev_flags saved_values;
 };
 
-static struct shash netdev_classes = SHASH_INITIALIZER(&netdev_classes);
+/* Protects 'netdev_shash' and the mutable members of struct netdev. */
+static struct ovs_mutex netdev_mutex = OVS_MUTEX_INITIALIZER;
 
 /* All created network devices. */
-static struct shash netdev_shash = SHASH_INITIALIZER(&netdev_shash);
+static struct shash netdev_shash OVS_GUARDED_BY(netdev_mutex)
+    = SHASH_INITIALIZER(&netdev_shash);
+
+/* Protects 'netdev_classes' against insertions or deletions.
+ *
+ * This is a recursive mutex to allow recursive acquisition when calling into
+ * providers.  For example, netdev_run() calls into provider 'run' functions,
+ * which might reasonably want to call one of the netdev functions that takes
+ * netdev_class_mutex. */
+static struct ovs_mutex netdev_class_mutex OVS_ACQ_BEFORE(netdev_mutex);
+
+/* Contains 'struct netdev_registered_class'es. */
+static struct hmap netdev_classes OVS_GUARDED_BY(netdev_class_mutex)
+    = HMAP_INITIALIZER(&netdev_classes);
+
+struct netdev_registered_class {
+    struct hmap_node hmap_node; /* In 'netdev_classes', by class->type. */
+    const struct netdev_class *class;
+    atomic_int ref_cnt;         /* Number of 'struct netdev's of this class. */
+};
 
 /* This is set pretty low because we probably won't learn anything from the
  * additional log messages. */
@@ -70,11 +92,12 @@ void update_device_args(struct netdev *, const struct shash *args);
 
 static void
 netdev_initialize(void)
+    OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
 {
-    static bool inited;
+    static struct ovsthread_once once = OVSTHREAD_ONCE_INITIALIZER;
 
-    if (!inited) {
-        inited = true;
+    if (ovsthread_once_start(&once)) {
+        ovs_mutex_init_recursive(&netdev_class_mutex);
 
         fatal_signal_add_hook(restore_all_flags, NULL, NULL, true);
         netdev_vport_patch_register();
@@ -89,8 +112,10 @@ netdev_initialize(void)
         netdev_register_provider(&netdev_tap_class);
         netdev_register_provider(&netdev_bsd_class);
 #endif
-	netdev_register_provider(&netdev_tunnel_class);
-	netdev_register_provider(&netdev_pltap_class);
+        netdev_register_provider(&netdev_tunnel_class);
+        netdev_register_provider(&netdev_pltap_class);
+
+        ovsthread_once_done(&once);
     }
 }
 
@@ -100,14 +125,17 @@ netdev_initialize(void)
  * main poll loop. */
 void
 netdev_run(void)
+    OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
 {
-    struct shash_node *node;
-    SHASH_FOR_EACH(node, &netdev_classes) {
-        const struct netdev_class *netdev_class = node->data;
-        if (netdev_class->run) {
-            netdev_class->run();
+    struct netdev_registered_class *rc;
+
+    ovs_mutex_lock(&netdev_class_mutex);
+    HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
+        if (rc->class->run) {
+            rc->class->run();
         }
     }
+    ovs_mutex_unlock(&netdev_class_mutex);
 }
 
 /* Arranges for poll_block() to wake up when netdev_run() needs to be called.
@@ -116,39 +144,65 @@ netdev_run(void)
  * main poll loop. */
 void
 netdev_wait(void)
+    OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
 {
-    struct shash_node *node;
-    SHASH_FOR_EACH(node, &netdev_classes) {
-        const struct netdev_class *netdev_class = node->data;
-        if (netdev_class->wait) {
-            netdev_class->wait();
+    struct netdev_registered_class *rc;
+
+    ovs_mutex_lock(&netdev_class_mutex);
+    HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
+        if (rc->class->wait) {
+            rc->class->wait();
         }
     }
+    ovs_mutex_unlock(&netdev_class_mutex);
+}
+
+static struct netdev_registered_class *
+netdev_lookup_class(const char *type)
+    OVS_REQ_RDLOCK(netdev_class_mutex)
+{
+    struct netdev_registered_class *rc;
+
+    HMAP_FOR_EACH_WITH_HASH (rc, hmap_node, hash_string(type, 0),
+                             &netdev_classes) {
+        if (!strcmp(type, rc->class->type)) {
+            return rc;
+        }
+    }
+    return NULL;
 }
 
 /* Initializes and registers a new netdev provider.  After successful
  * registration, new netdevs of that type can be opened using netdev_open(). */
 int
 netdev_register_provider(const struct netdev_class *new_class)
+    OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
 {
-    if (shash_find(&netdev_classes, new_class->type)) {
+    int error;
+
+    ovs_mutex_lock(&netdev_class_mutex);
+    if (netdev_lookup_class(new_class->type)) {
         VLOG_WARN("attempted to register duplicate netdev provider: %s",
                    new_class->type);
-        return EEXIST;
-    }
-
-    if (new_class->init) {
-        int error = new_class->init();
-        if (error) {
+        error = EEXIST;
+    } else {
+        error = new_class->init ? new_class->init() : 0;
+        if (!error) {
+            struct netdev_registered_class *rc;
+
+            rc = xmalloc(sizeof *rc);
+            hmap_insert(&netdev_classes, &rc->hmap_node,
+                        hash_string(new_class->type, 0));
+            rc->class = new_class;
+            atomic_init(&rc->ref_cnt, 0);
+        } else {
             VLOG_ERR("failed to initialize %s network device class: %s",
                      new_class->type, ovs_strerror(error));
-            return error;
         }
     }
+    ovs_mutex_unlock(&netdev_class_mutex);
 
-    shash_add(&netdev_classes, new_class->type, new_class);
-
-    return 0;
+    return error;
 }
 
 /* Unregisters a netdev provider.  'type' must have been previously
@@ -156,51 +210,53 @@ netdev_register_provider(const struct netdev_class *new_class)
  * new netdevs of that type cannot be opened using netdev_open(). */
 int
 netdev_unregister_provider(const char *type)
+    OVS_EXCLUDED(netdev_class_mutex, netdev_mutex)
 {
-    struct shash_node *del_node, *netdev_node;
+    struct netdev_registered_class *rc;
+    int error;
 
-    del_node = shash_find(&netdev_classes, type);
-    if (!del_node) {
+    ovs_mutex_lock(&netdev_class_mutex);
+    rc = netdev_lookup_class(type);
+    if (!rc) {
         VLOG_WARN("attempted to unregister a netdev provider that is not "
                   "registered: %s", type);
-        return EAFNOSUPPORT;
-    }
-
-    SHASH_FOR_EACH (netdev_node, &netdev_shash) {
-        struct netdev *netdev = netdev_node->data;
-        if (!strcmp(netdev->netdev_class->type, type)) {
+        error = EAFNOSUPPORT;
+    } else {
+        int ref_cnt;
+
+        atomic_read(&rc->ref_cnt, &ref_cnt);
+        if (!ref_cnt) {
+            hmap_remove(&netdev_classes, &rc->hmap_node);
+            atomic_destroy(&rc->ref_cnt);
+            free(rc);
+            error = 0;
+        } else {
             VLOG_WARN("attempted to unregister in use netdev provider: %s",
                       type);
-            return EBUSY;
+            error = EBUSY;
         }
     }
+    ovs_mutex_unlock(&netdev_class_mutex);
 
-    shash_delete(&netdev_classes, del_node);
-
-    return 0;
-}
-
-const struct netdev_class *
-netdev_lookup_provider(const char *type)
-{
-    netdev_initialize();
-    return shash_find_data(&netdev_classes, type && type[0] ? type : "system");
+    return error;
 }
 
 /* Clears 'types' and enumerates the types of all currently registered netdev
  * providers into it.  The caller must first initialize the sset. */
 void
 netdev_enumerate_types(struct sset *types)
+    OVS_EXCLUDED(netdev_mutex)
 {
-    struct shash_node *node;
+    struct netdev_registered_class *rc;
 
     netdev_initialize();
     sset_clear(types);
 
-    SHASH_FOR_EACH(node, &netdev_classes) {
-        const struct netdev_class *netdev_class = node->data;
-        sset_add(types, netdev_class->type);
+    ovs_mutex_lock(&netdev_class_mutex);
+    HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
+        sset_add(types, rc->class->type);
     }
+    ovs_mutex_unlock(&netdev_class_mutex);
 }
 
 /* Check that the network device name is not the same as any of the registered
@@ -210,17 +266,21 @@ netdev_enumerate_types(struct sset *types)
  * Returns true if there is a name conflict, false otherwise. */
 bool
 netdev_is_reserved_name(const char *name)
+    OVS_EXCLUDED(netdev_mutex)
 {
-    struct shash_node *node;
+    struct netdev_registered_class *rc;
 
     netdev_initialize();
-    SHASH_FOR_EACH (node, &netdev_classes) {
-        const char *dpif_port;
-        dpif_port = netdev_vport_class_get_dpif_port(node->data);
+
+    ovs_mutex_lock(&netdev_class_mutex);
+    HMAP_FOR_EACH (rc, hmap_node, &netdev_classes) {
+        const char *dpif_port = netdev_vport_class_get_dpif_port(rc->class);
         if (dpif_port && !strcmp(dpif_port, name)) {
+            ovs_mutex_unlock(&netdev_class_mutex);
             return true;
         }
     }
+    ovs_mutex_unlock(&netdev_class_mutex);
 
     if (!strncmp(name, "ovs-", 4)) {
         struct sset types;
@@ -249,46 +309,78 @@ netdev_is_reserved_name(const char *name)
  * before they can be used. */
 int
 netdev_open(const char *name, const char *type, struct netdev **netdevp)
+    OVS_EXCLUDED(netdev_mutex)
 {
     struct netdev *netdev;
     int error;
 
-    *netdevp = NULL;
     netdev_initialize();
 
+    ovs_mutex_lock(&netdev_class_mutex);
+    ovs_mutex_lock(&netdev_mutex);
     netdev = shash_find_data(&netdev_shash, name);
     if (!netdev) {
-        const struct netdev_class *class;
-
-        class = netdev_lookup_provider(type);
-        if (!class) {
+        struct netdev_registered_class *rc;
+
+        rc = netdev_lookup_class(type && type[0] ? type : "system");
+        if (rc) {
+            netdev = rc->class->alloc();
+            if (netdev) {
+                memset(netdev, 0, sizeof *netdev);
+                netdev->netdev_class = rc->class;
+                netdev->name = xstrdup(name);
+                netdev->node = shash_add(&netdev_shash, name, netdev);
+                list_init(&netdev->saved_flags_list);
+
+                error = rc->class->construct(netdev);
+                if (!error) {
+                    int old_ref_cnt;
+
+                    atomic_add(&rc->ref_cnt, 1, &old_ref_cnt);
+                    seq_change(connectivity_seq_get());
+                } else {
+                    free(netdev->name);
+                    ovs_assert(list_is_empty(&netdev->saved_flags_list));
+                    shash_delete(&netdev_shash, netdev->node);
+                    rc->class->dealloc(netdev);
+                }
+            } else {
+                error = ENOMEM;
+            }
+        } else {
             VLOG_WARN("could not create netdev %s of unknown type %s",
                       name, type);
-            return EAFNOSUPPORT;
-        }
-        error = class->create(class, name, &netdev);
-        if (error) {
-            return error;
+            error = EAFNOSUPPORT;
         }
-        ovs_assert(netdev->netdev_class == class);
-
+    } else {
+        error = 0;
     }
-    netdev->ref_cnt++;
 
-    *netdevp = netdev;
-    return 0;
+    ovs_mutex_unlock(&netdev_mutex);
+    ovs_mutex_unlock(&netdev_class_mutex);
+
+    if (!error) {
+        netdev->ref_cnt++;
+        *netdevp = netdev;
+    } else {
+        *netdevp = NULL;
+    }
+    return error;
 }
 
 /* Returns a reference to 'netdev_' for the caller to own. Returns null if
  * 'netdev_' is null. */
 struct netdev *
 netdev_ref(const struct netdev *netdev_)
+    OVS_EXCLUDED(netdev_mutex)
 {
     struct netdev *netdev = CONST_CAST(struct netdev *, netdev_);
 
     if (netdev) {
+        ovs_mutex_lock(&netdev_mutex);
         ovs_assert(netdev->ref_cnt > 0);
         netdev->ref_cnt++;
+        ovs_mutex_unlock(&netdev_mutex);
     }
     return netdev;
 }
@@ -297,16 +389,23 @@ netdev_ref(const struct netdev *netdev_)
  * or NULL if none are needed. */
 int
 netdev_set_config(struct netdev *netdev, const struct smap *args)
+    OVS_EXCLUDED(netdev_mutex)
 {
     if (netdev->netdev_class->set_config) {
-        struct smap no_args = SMAP_INITIALIZER(&no_args);
-        return netdev->netdev_class->set_config(netdev,
-                                                args ? args : &no_args);
+        const struct smap no_args = SMAP_INITIALIZER(&no_args);
+        int error;
+
+        error = netdev->netdev_class->set_config(netdev,
+                                                 args ? args : &no_args);
+        if (error) {
+            VLOG_WARN("%s: could not set configuration (%s)",
+                      netdev_get_name(netdev), ovs_strerror(error));
+        }
+        return error;
     } else if (args && !smap_is_empty(args)) {
         VLOG_WARN("%s: arguments provided to device that is not configurable",
                   netdev_get_name(netdev));
     }
-
     return 0;
 }
 
@@ -319,6 +418,7 @@ netdev_set_config(struct netdev *netdev, const struct smap *args)
  * smap_destroy(). */
 int
 netdev_get_config(const struct netdev *netdev, struct smap *args)
+    OVS_EXCLUDED(netdev_mutex)
 {
     int error;
 
@@ -337,6 +437,7 @@ netdev_get_config(const struct netdev *netdev, struct smap *args)
 
 const struct netdev_tunnel_config *
 netdev_get_tunnel_config(const struct netdev *netdev)
+    OVS_EXCLUDED(netdev_mutex)
 {
     if (netdev->netdev_class->get_tunnel_config) {
         return netdev->netdev_class->get_tunnel_config(netdev);
@@ -347,18 +448,38 @@ netdev_get_tunnel_config(const struct netdev *netdev)
 
 static void
 netdev_unref(struct netdev *dev)
+    OVS_RELEASES(netdev_mutex)
 {
     ovs_assert(dev->ref_cnt);
     if (!--dev->ref_cnt) {
-        netdev_uninit(dev, true);
+        const struct netdev_class *class = dev->netdev_class;
+        struct netdev_registered_class *rc;
+        int old_ref_cnt;
+
+        dev->netdev_class->destruct(dev);
+
+        shash_delete(&netdev_shash, dev->node);
+        free(dev->name);
+        dev->netdev_class->dealloc(dev);
+        ovs_mutex_unlock(&netdev_mutex);
+
+        ovs_mutex_lock(&netdev_class_mutex);
+        rc = netdev_lookup_class(class->type);
+        atomic_sub(&rc->ref_cnt, 1, &old_ref_cnt);
+        ovs_assert(old_ref_cnt > 0);
+        ovs_mutex_unlock(&netdev_class_mutex);
+    } else {
+        ovs_mutex_unlock(&netdev_mutex);
     }
 }
 
 /* Closes and destroys 'netdev'. */
 void
 netdev_close(struct netdev *netdev)
+    OVS_EXCLUDED(netdev_mutex)
 {
     if (netdev) {
+        ovs_mutex_lock(&netdev_mutex);
         netdev_unref(netdev);
     }
 }
@@ -382,34 +503,80 @@ netdev_parse_name(const char *netdev_name_, char **name, char **type)
     }
 }
 
+/* Attempts to open a netdev_rx handle for obtaining packets received on
+ * 'netdev'.  On success, returns 0 and stores a nonnull 'netdev_rx *' into
+ * '*rxp'.  On failure, returns a positive errno value and stores NULL into
+ * '*rxp'.
+ *
+ * Some kinds of network devices might not support receiving packets.  This
+ * function returns EOPNOTSUPP in that case.*/
 int
 netdev_rx_open(struct netdev *netdev, struct netdev_rx **rxp)
+    OVS_EXCLUDED(netdev_mutex)
 {
     int error;
 
-    error = (netdev->netdev_class->rx_open
-             ? netdev->netdev_class->rx_open(netdev, rxp)
-             : EOPNOTSUPP);
-    if (!error) {
-        ovs_assert((*rxp)->netdev == netdev);
-        netdev->ref_cnt++;
+    if (netdev->netdev_class->rx_alloc) {
+        struct netdev_rx *rx = netdev->netdev_class->rx_alloc();
+        if (rx) {
+            rx->netdev = netdev;
+            error = netdev->netdev_class->rx_construct(rx);
+            if (!error) {
+                ovs_mutex_lock(&netdev_mutex);
+                netdev->ref_cnt++;
+                ovs_mutex_unlock(&netdev_mutex);
+
+                *rxp = rx;
+                return 0;
+            }
+            netdev->netdev_class->rx_dealloc(rx);
+        } else {
+            error = ENOMEM;
+        }
     } else {
-        *rxp = NULL;
+        error = EOPNOTSUPP;
     }
+
+    *rxp = NULL;
     return error;
 }
 
+/* Closes 'rx'. */
 void
 netdev_rx_close(struct netdev_rx *rx)
+    OVS_EXCLUDED(netdev_mutex)
 {
     if (rx) {
-        struct netdev *dev = rx->netdev;
-
-        rx->rx_class->destroy(rx);
-        netdev_unref(dev);
+        struct netdev *netdev = rx->netdev;
+        netdev->netdev_class->rx_destruct(rx);
+        netdev->netdev_class->rx_dealloc(rx);
+        netdev_close(netdev);
     }
 }
 
+/* Attempts to receive a packet from 'rx' into the tailroom of 'buffer', which
+ * must initially be empty.  If successful, returns 0 and increments
+ * 'buffer->size' by the number of bytes in the received packet, otherwise a
+ * positive errno value.
+ *
+ * Returns EAGAIN immediately if no packet is ready to be received.
+ *
+ * Returns EMSGSIZE, and discards the packet, if the received packet is longer
+ * than 'ofpbuf_tailroom(buffer)'.
+ *
+ * Implementations may make use of VLAN_HEADER_LEN bytes of tailroom to
+ * add a VLAN header which is obtained out-of-band to the packet. If
+ * this occurs then VLAN_HEADER_LEN bytes of tailroom will no longer be
+ * available for the packet, otherwise it may be used for the packet
+ * itself.
+ *
+ * It is advised that the tailroom of 'buffer' should be
+ * VLAN_HEADER_LEN bytes longer than the MTU to allow space for an
+ * out-of-band VLAN header to be added to the packet.  At the very least,
+ * 'buffer' must have at least ETH_TOTAL_MIN bytes of tailroom.
+ *
+ * This function may be set to null if it would always return EOPNOTSUPP
+ * anyhow. */
 int
 netdev_rx_recv(struct netdev_rx *rx, struct ofpbuf *buffer)
 {
@@ -418,29 +585,33 @@ netdev_rx_recv(struct netdev_rx *rx, struct ofpbuf *buffer)
     ovs_assert(buffer->size == 0);
     ovs_assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
 
-    retval = rx->rx_class->recv(rx, buffer->data, ofpbuf_tailroom(buffer));
-    if (retval >= 0) {
+    retval = rx->netdev->netdev_class->rx_recv(rx, buffer);
+    if (!retval) {
         COVERAGE_INC(netdev_received);
-        buffer->size += retval;
         if (buffer->size < ETH_TOTAL_MIN) {
             ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
         }
         return 0;
     } else {
-        return -retval;
+        return retval;
     }
 }
 
+/* Arranges for poll_block() to wake up when a packet is ready to be received
+ * on 'rx'. */
 void
 netdev_rx_wait(struct netdev_rx *rx)
 {
-    rx->rx_class->wait(rx);
+    rx->netdev->netdev_class->rx_wait(rx);
 }
 
+/* Discards any packets ready to be received on 'rx'. */
 int
 netdev_rx_drain(struct netdev_rx *rx)
 {
-    return rx->rx_class->drain ? rx->rx_class->drain(rx) : 0;
+    return (rx->netdev->netdev_class->rx_drain
+            ? rx->netdev->netdev_class->rx_drain(rx)
+            : 0);
 }
 
 /* Sends 'buffer' on 'netdev'.  Returns 0 if successful, otherwise a positive
@@ -817,6 +988,7 @@ static int
 do_update_flags(struct netdev *netdev, enum netdev_flags off,
                 enum netdev_flags on, enum netdev_flags *old_flagsp,
                 struct netdev_saved_flags **sfp)
+    OVS_EXCLUDED(netdev_mutex)
 {
     struct netdev_saved_flags *sf = NULL;
     enum netdev_flags old_flags;
@@ -833,6 +1005,7 @@ do_update_flags(struct netdev *netdev, enum netdev_flags off,
         enum netdev_flags new_flags = (old_flags & ~off) | on;
         enum netdev_flags changed_flags = old_flags ^ new_flags;
         if (changed_flags) {
+            ovs_mutex_lock(&netdev_mutex);
             *sfp = sf = xmalloc(sizeof *sf);
             sf->netdev = netdev;
             list_push_front(&netdev->saved_flags_list, &sf->node);
@@ -840,6 +1013,7 @@ do_update_flags(struct netdev *netdev, enum netdev_flags off,
             sf->saved_values = changed_flags & new_flags;
 
             netdev->ref_cnt++;
+            ovs_mutex_unlock(&netdev_mutex);
         }
     }
 
@@ -903,6 +1077,7 @@ netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
  * Does nothing if 'sf' is NULL. */
 void
 netdev_restore_flags(struct netdev_saved_flags *sf)
+    OVS_EXCLUDED(netdev_mutex)
 {
     if (sf) {
         struct netdev *netdev = sf->netdev;
@@ -912,9 +1087,10 @@ netdev_restore_flags(struct netdev_saved_flags *sf)
                                            sf->saved_flags & sf->saved_values,
                                            sf->saved_flags & ~sf->saved_values,
                                            &old_flags);
+
+        ovs_mutex_lock(&netdev_mutex);
         list_remove(&sf->node);
         free(sf);
-
         netdev_unref(netdev);
     }
 }
@@ -1267,30 +1443,78 @@ netdev_get_queue_stats(const struct netdev *netdev, unsigned int queue_id,
     return retval;
 }
 
-/* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's ID,
- * its configuration, and the 'aux' specified by the caller.  The order of
- * iteration is unspecified, but (when successful) each queue is visited
- * exactly once.
+/* Initializes 'dump' to begin dumping the queues in a netdev.
+ *
+ * This function provides no status indication.  An error status for the entire
+ * dump operation is provided when it is completed by calling
+ * netdev_queue_dump_done().
+ */
+void
+netdev_queue_dump_start(struct netdev_queue_dump *dump,
+                        const struct netdev *netdev)
+{
+    dump->netdev = netdev_ref(netdev);
+    if (netdev->netdev_class->queue_dump_start) {
+        dump->error = netdev->netdev_class->queue_dump_start(netdev,
+                                                             &dump->state);
+    } else {
+        dump->error = EOPNOTSUPP;
+    }
+}
+
+/* Attempts to retrieve another queue from 'dump', which must have been
+ * initialized with netdev_queue_dump_start().  On success, stores a new queue
+ * ID into '*queue_id', fills 'details' with configuration details for the
+ * queue, and returns true.  On failure, returns false.
  *
- * Calling this function may be more efficient than calling netdev_get_queue()
- * for every queue.
+ * Queues are not necessarily dumped in increasing order of queue ID (or any
+ * other predictable order).
  *
- * 'cb' must not modify or free the 'details' argument passed in.  It may
- * delete or modify the queue passed in as its 'queue_id' argument.  It may
- * modify but must not delete any other queue within 'netdev'.  'cb' should not
- * add new queues because this may cause some queues to be visited twice or not
- * at all.
+ * Failure might indicate an actual error or merely that the last queue has
+ * been dumped.  An error status for the entire dump operation is provided when
+ * it is completed by calling netdev_queue_dump_done().
  *
- * Returns 0 if successful, otherwise a positive errno value.  On error, some
- * configured queues may not have been included in the iteration. */
+ * The returned contents of 'details' should be documented as valid for the
+ * given 'type' in the "other_config" column in the "Queue" table in
+ * vswitchd/vswitch.xml (which is built as ovs-vswitchd.conf.db(8)).
+ *
+ * The caller must initialize 'details' (e.g. with smap_init()) before calling
+ * this function.  This function will clear and replace its contents.  The
+ * caller must free 'details' when it is no longer needed (e.g. with
+ * smap_destroy()). */
+bool
+netdev_queue_dump_next(struct netdev_queue_dump *dump,
+                       unsigned int *queue_id, struct smap *details)
+{
+    const struct netdev *netdev = dump->netdev;
+
+    if (dump->error) {
+        return false;
+    }
+
+    dump->error = netdev->netdev_class->queue_dump_next(netdev, dump->state,
+                                                        queue_id, details);
+
+    if (dump->error) {
+        netdev->netdev_class->queue_dump_done(netdev, dump->state);
+        return false;
+    }
+    return true;
+}
+
+/* Completes queue table dump operation 'dump', which must have been
+ * initialized with netdev_queue_dump_start().  Returns 0 if the dump operation
+ * was error-free, otherwise a positive errno value describing the problem. */
 int
-netdev_dump_queues(const struct netdev *netdev,
-                   netdev_dump_queues_cb *cb, void *aux)
+netdev_queue_dump_done(struct netdev_queue_dump *dump)
 {
-    const struct netdev_class *class = netdev->netdev_class;
-    return (class->dump_queues
-            ? class->dump_queues(netdev, cb, aux)
-            : EOPNOTSUPP);
+    const struct netdev *netdev = dump->netdev;
+    if (!dump->error && netdev->netdev_class->queue_dump_done) {
+        dump->error = netdev->netdev_class->queue_dump_done(netdev,
+                                                            dump->state);
+    }
+    netdev_close(dump->netdev);
+    return dump->error == EOF ? 0 : dump->error;
 }
 
 /* Iterates over all of 'netdev''s queues, calling 'cb' with the queue's ID,
@@ -1315,61 +1539,7 @@ netdev_dump_queue_stats(const struct netdev *netdev,
             : EOPNOTSUPP);
 }
 
-/* Returns a sequence number which indicates changes in one of 'netdev''s
- * properties.  The returned sequence will be nonzero so that callers have a
- * value which they may use as a reset when tracking 'netdev'.
- *
- * The returned sequence number will change whenever 'netdev''s flags,
- * features, ethernet address, or carrier changes.  It may change for other
- * reasons as well, or no reason at all. */
-unsigned int
-netdev_change_seq(const struct netdev *netdev)
-{
-    return netdev->netdev_class->change_seq(netdev);
-}
 
-/* Initializes 'netdev' as a netdev device named 'name' of the specified
- * 'netdev_class'.  This function is ordinarily called from a netdev provider's
- * 'create' function.
- *
- * This function adds 'netdev' to a netdev-owned shash, so it is very important
- * that 'netdev' only be freed after calling netdev_uninit().  */
-void
-netdev_init(struct netdev *netdev, const char *name,
-            const struct netdev_class *netdev_class)
-{
-    ovs_assert(!shash_find(&netdev_shash, name));
-
-    memset(netdev, 0, sizeof *netdev);
-    netdev->netdev_class = netdev_class;
-    netdev->name = xstrdup(name);
-    netdev->node = shash_add(&netdev_shash, name, netdev);
-    list_init(&netdev->saved_flags_list);
-}
-
-/* Undoes the results of initialization.
- *
- * Normally this function does not need to be called as netdev_close has
- * the same effect when the refcount drops to zero.
- * However, it may be called by providers due to an error on creation
- * that occurs after initialization.  It this case netdev_close() would
- * never be called. */
-void
-netdev_uninit(struct netdev *netdev, bool destroy)
-{
-    char *name = netdev->name;
-
-    ovs_assert(!netdev->ref_cnt);
-    ovs_assert(list_is_empty(&netdev->saved_flags_list));
-
-    shash_delete(&netdev_shash, netdev->node);
-
-    if (destroy) {
-        netdev->netdev_class->destroy(netdev);
-    }
-    free(name);
-}
-
 /* Returns the class type of 'netdev'.
  *
  * The caller must not free the returned value. */
@@ -1391,13 +1561,16 @@ netdev_get_class(const struct netdev *netdev)
  * The caller must free the returned netdev with netdev_close(). */
 struct netdev *
 netdev_from_name(const char *name)
+    OVS_EXCLUDED(netdev_mutex)
 {
     struct netdev *netdev;
 
+    ovs_mutex_lock(&netdev_mutex);
     netdev = shash_find_data(&netdev_shash, name);
     if (netdev) {
-        netdev_ref(netdev);
+        netdev->ref_cnt++;
     }
+    ovs_mutex_unlock(&netdev_mutex);
 
     return netdev;
 }
@@ -1409,8 +1582,11 @@ netdev_from_name(const char *name)
 void
 netdev_get_devices(const struct netdev_class *netdev_class,
                    struct shash *device_list)
+    OVS_EXCLUDED(netdev_mutex)
 {
     struct shash_node *node;
+
+    ovs_mutex_lock(&netdev_mutex);
     SHASH_FOR_EACH (node, &netdev_shash) {
         struct netdev *dev = node->data;
 
@@ -1419,6 +1595,7 @@ netdev_get_devices(const struct netdev_class *netdev_class,
             shash_add(device_list, node->name, node->data);
         }
     }
+    ovs_mutex_unlock(&netdev_mutex);
 }
 
 const char *
@@ -1430,21 +1607,6 @@ netdev_get_type_from_name(const char *name)
     return type;
 }
 
-void
-netdev_rx_init(struct netdev_rx *rx, struct netdev *netdev,
-               const struct netdev_rx_class *class)
-{
-    ovs_assert(netdev->ref_cnt > 0);
-    rx->rx_class = class;
-    rx->netdev = netdev;
-}
-
-void
-netdev_rx_uninit(struct netdev_rx *rx OVS_UNUSED)
-{
-    /* Nothing to do. */
-}
-
 struct netdev *
 netdev_rx_get_netdev(const struct netdev_rx *rx)
 {