X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnetdev.c;h=eff6e4cb7259372c63f528ced1c322d113723c09;hb=733adf2aaf614cf7735e1c6f8466900ea79a7f98;hp=bf7ff6aaf1a0d5d2c1b6f4c0998df271de7d4cf0;hpb=19993ef3caac9964c2bef6e31fc8699c4f4b53c8;p=sliver-openvswitch.git

diff --git a/lib/netdev.c b/lib/netdev.c
index bf7ff6aaf..eff6e4cb7 100644
--- a/lib/netdev.c
+++ b/lib/netdev.c
@@ -192,66 +192,42 @@ netdev_enumerate_types(struct sset *types)
     }
 }
 
-void
-update_device_args(struct netdev_dev *dev, const struct shash *args)
-{
-    smap_destroy(&dev->args);
-    smap_clone(&dev->args, args);
-}
-
-/* Opens the network device named 'name' (e.g. "eth0") and returns zero if
- * successful, otherwise a positive errno value.  On success, sets '*netdevp'
- * to the new network device, otherwise to null.
- *
- * If this is the first time the device has been opened, then create is called
- * before opening.  The device is created using the given type and arguments.
+/* Opens the network device named 'name' (e.g. "eth0") of the specified 'type'
+ * (e.g. "system") and returns zero if successful, otherwise a positive errno
+ * value.  On success, sets '*netdevp' to the new network device, otherwise to
+ * null.
  *
- * 'ethertype' may be a 16-bit Ethernet protocol value in host byte order to
- * capture frames of that type received on the device.  It may also be one of
- * the 'enum netdev_pseudo_ethertype' values to receive frames in one of those
- * categories. */
+ * Some network devices may need to be configured (with netdev_set_config())
+ * before they can be used. */
 int
-netdev_open(struct netdev_options *options, struct netdev **netdevp)
+netdev_open(const char *name, const char *type, struct netdev **netdevp)
 {
-    struct shash empty_args = SHASH_INITIALIZER(&empty_args);
     struct netdev_dev *netdev_dev;
     int error;
 
     *netdevp = NULL;
     netdev_initialize();
 
-    if (!options->args) {
-        options->args = &empty_args;
-    }
-
-    netdev_dev = shash_find_data(&netdev_dev_shash, options->name);
+    netdev_dev = shash_find_data(&netdev_dev_shash, name);
 
     if (!netdev_dev) {
         const struct netdev_class *class;
 
-        class = netdev_lookup_provider(options->type);
+        class = netdev_lookup_provider(type);
         if (!class) {
             VLOG_WARN("could not create netdev %s of unknown type %s",
-                      options->name, options->type);
+                      name, type);
             return EAFNOSUPPORT;
         }
-        error = class->create(class, options->name, options->args,
-                              &netdev_dev);
+        error = class->create(class, name, &netdev_dev);
         if (error) {
             return error;
         }
         assert(netdev_dev->netdev_class == class);
 
-    } else if (!shash_is_empty(options->args) &&
-               !smap_equal(&netdev_dev->args, options->args)) {
-
-        VLOG_WARN("%s: attempted to open already open netdev with "
-                  "different arguments", options->name);
-        return EINVAL;
     }
 
-    error = netdev_dev->netdev_class->open(netdev_dev, options->ethertype,
-                netdevp);
+    error = netdev_dev->netdev_class->open(netdev_dev, netdevp);
 
     if (!error) {
         netdev_dev->ref_cnt++;
@@ -264,53 +240,49 @@ netdev_open(struct netdev_options *options, struct netdev **netdevp)
     return error;
 }
 
-int
-netdev_open_default(const char *name, struct netdev **netdevp)
-{
-    struct netdev_options options;
-
-    memset(&options, 0, sizeof options);
-    options.name = name;
-    options.ethertype = NETDEV_ETH_TYPE_NONE;
-
-    return netdev_open(&options, netdevp);
-}
-
 /* Reconfigures the device 'netdev' with 'args'.  'args' may be empty
  * or NULL if none are needed. */
 int
 netdev_set_config(struct netdev *netdev, const struct shash *args)
 {
-    struct shash empty_args = SHASH_INITIALIZER(&empty_args);
     struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
 
-    if (!args) {
-        args = &empty_args;
-    }
-
     if (netdev_dev->netdev_class->set_config) {
-        if (!smap_equal(&netdev_dev->args, args)) {
-            update_device_args(netdev_dev, args);
-            return netdev_dev->netdev_class->set_config(netdev_dev, args);
-        }
-    } else if (!shash_is_empty(args)) {
-        VLOG_WARN("%s: arguments provided to device whose configuration "
-                  "cannot be changed", netdev_get_name(netdev));
+        struct shash no_args = SHASH_INITIALIZER(&no_args);
+        return netdev_dev->netdev_class->set_config(netdev_dev,
+                                                    args ? args : &no_args);
+    } else if (args && !shash_is_empty(args)) {
+        VLOG_WARN("%s: arguments provided to device that is not configurable",
+                  netdev_get_name(netdev));
     }
 
     return 0;
 }
 
-/* Returns the current configuration for 'netdev'.  This is either the
- * configuration passed to netdev_open() or netdev_set_config(), or it is a
- * configuration retrieved from the device itself if no configuration was
- * passed to those functions.
+/* Returns the current configuration for 'netdev' in 'args'.  The caller must
+ * have already initialized 'args' with shash_init().  Returns 0 on success, in
+ * which case 'args' will be filled with 'netdev''s configuration.  On failure
+ * returns a positive errno value, in which case 'args' will be empty.
  *
- * 'netdev' retains ownership of the returned configuration. */
-const struct shash *
-netdev_get_config(const struct netdev *netdev)
+ * The caller owns 'args' and its contents and must eventually free them with
+ * shash_destroy_free_data(). */
+int
+netdev_get_config(const struct netdev *netdev, struct shash *args)
 {
-    return &netdev_get_dev(netdev)->args;
+    struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
+    int error;
+
+    shash_clear_free_data(args);
+    if (netdev_dev->netdev_class->get_config) {
+        error = netdev_dev->netdev_class->get_config(netdev_dev, args);
+        if (error) {
+            shash_clear_free_data(args);
+        }
+    } else {
+        error = 0;
+    }
+
+    return error;
 }
 
 /* Closes and destroys 'netdev'. */
@@ -339,7 +311,7 @@ netdev_exists(const char *name)
     struct netdev *netdev;
     int error;
 
-    error = netdev_open_default(name, &netdev);
+    error = netdev_open(name, "system", &netdev);
     if (!error) {
         netdev_close(netdev);
         return true;
@@ -360,31 +332,36 @@ netdev_is_open(const char *name)
     return !!shash_find_data(&netdev_dev_shash, name);
 }
 
-/*  Clears 'sset' and enumerates the names of all known network devices. */
-int
-netdev_enumerate(struct sset *sset)
+/* Parses 'netdev_name_', which is of the form [type@]name into its component
+ * pieces.  'name' and 'type' must be freed by the caller. */
+void
+netdev_parse_name(const char *netdev_name_, char **name, char **type)
 {
-    struct shash_node *node;
-    int error = 0;
+    char *netdev_name = xstrdup(netdev_name_);
+    char *separator;
 
-    netdev_initialize();
-    sset_clear(sset);
-
-    SHASH_FOR_EACH(node, &netdev_classes) {
-        const struct netdev_class *netdev_class = node->data;
-        if (netdev_class->enumerate) {
-            int retval = netdev_class->enumerate(sset);
-            if (retval) {
-                VLOG_WARN("failed to enumerate %s network devices: %s",
-                          netdev_class->type, strerror(retval));
-                if (!error) {
-                    error = retval;
-                }
-            }
-        }
+    separator = strchr(netdev_name, '@');
+    if (separator) {
+        *separator = '\0';
+        *type = netdev_name;
+        *name = xstrdup(separator + 1);
+    } else {
+        *name = netdev_name;
+        *type = xstrdup("system");
     }
+}
 
-    return error;
+/* Attempts to set up 'netdev' for receiving packets with netdev_recv().
+ * Returns 0 if successful, otherwise a positive errno value.  EOPNOTSUPP
+ * indicates that the network device does not implement packet reception
+ * through this interface. */
+int
+netdev_listen(struct netdev *netdev)
+{
+    int (*listen)(struct netdev *);
+
+    listen = netdev_get_dev(netdev)->netdev_class->listen;
+    return listen ? (listen)(netdev) : EOPNOTSUPP;
 }
 
 /* Attempts to receive a packet from 'netdev' into 'buffer', which the caller
@@ -394,6 +371,9 @@ netdev_enumerate(struct sset *sset)
  * (Some devices do not allow for a VLAN header, in which case VLAN_HEADER_LEN
  * need not be included.)
  *
+ * This function can only be expected to return a packet if ->listen() has
+ * been called successfully.
+ *
  * If a packet is successfully retrieved, returns 0.  In this case 'buffer' is
  * guaranteed to contain at least ETH_TOTAL_MIN bytes.  Otherwise, returns a
  * positive errno value.  Returns EAGAIN immediately if no packet is ready to
@@ -522,19 +502,45 @@ netdev_get_name(const struct netdev *netdev)
  * (and received) packets, in bytes, not including the hardware header; thus,
  * this is typically 1500 bytes for Ethernet devices.
  *
- * If successful, returns 0 and stores the MTU size in '*mtup'.  Stores INT_MAX
- * in '*mtup' if 'netdev' does not have an MTU (as e.g. some tunnels do not).On
- * failure, returns a positive errno value and stores ETH_PAYLOAD_MAX (1500) in
- * '*mtup'. */
+ * If successful, returns 0 and stores the MTU size in '*mtup'.  Returns
+ * EOPNOTSUPP if 'netdev' does not have an MTU (as e.g. some tunnels do not).
+ * On other failure, returns a positive errno value.  On failure, sets '*mtup'
+ * to 0. */
 int
 netdev_get_mtu(const struct netdev *netdev, int *mtup)
 {
-    int error = netdev_get_dev(netdev)->netdev_class->get_mtu(netdev, mtup);
+    const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
+    int error;
+
+    error = class->get_mtu ? class->get_mtu(netdev, mtup) : EOPNOTSUPP;
     if (error) {
+        *mtup = 0;
+        if (error != EOPNOTSUPP) {
+            VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: "
+                         "%s", netdev_get_name(netdev), strerror(error));
+        }
+    }
+    return error;
+}
+
+/* Sets the MTU of 'netdev'.  The MTU is the maximum size of transmitted
+ * (and received) packets, in bytes.
+ *
+ * If successful, returns 0.  Returns EOPNOTSUPP if 'netdev' does not have an
+ * MTU (as e.g. some tunnels do not).  On other failure, returns a positive
+ * errno value. */
+int
+netdev_set_mtu(const struct netdev *netdev, int mtu)
+{
+    const struct netdev_class *class = netdev_get_dev(netdev)->netdev_class;
+    int error;
+
+    error = class->set_mtu ? class->set_mtu(netdev, mtu) : EOPNOTSUPP;
+    if (error && error != EOPNOTSUPP) {
         VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: %s",
                      netdev_get_name(netdev), strerror(error));
-        *mtup = ETH_PAYLOAD_MAX;
     }
+
     return error;
 }
 
@@ -652,7 +658,7 @@ netdev_set_advertisements(struct netdev *netdev, uint32_t advertise)
  *
  *   - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
  *
- * 'address' or 'netmask' or both may be null, in which case the address or 
+ * 'address' or 'netmask' or both may be null, in which case the address or
  * netmask is not reported. */
 int
 netdev_get_in4(const struct netdev *netdev,
@@ -686,6 +692,26 @@ netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask)
             : EOPNOTSUPP);
 }
 
+/* Obtains ad IPv4 address from device name and save the address in
+ * in4.  Returns 0 if successful, otherwise a positive errno value.
+ */
+int
+netdev_get_in4_by_name(const char *device_name, struct in_addr *in4)
+{
+    struct netdev *netdev;
+    int error;
+
+    error = netdev_open(device_name, "system", &netdev);
+    if (error) {
+        in4->s_addr = htonl(0);
+        return error;
+    }
+
+    error = netdev_get_in4(netdev, in4, NULL);
+    netdev_close(netdev);
+    return error;
+}
+
 /* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds
  * to 'netdev'. */
 int
@@ -846,7 +872,7 @@ netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
  * ENXIO indicates that there is no ARP table entry for 'ip' on 'netdev'. */
 int
 netdev_arp_lookup(const struct netdev *netdev,
-                  uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
+                  ovs_be32 ip, uint8_t mac[ETH_ADDR_LEN])
 {
     int error = (netdev_get_dev(netdev)->netdev_class->arp_lookup
                  ? netdev_get_dev(netdev)->netdev_class->arp_lookup(netdev,
@@ -886,32 +912,30 @@ netdev_get_carrier(const struct netdev *netdev)
     return carrier;
 }
 
-/* Returns true if 'netdev' is up according to its MII. */
-bool
-netdev_get_miimon(const struct netdev *netdev)
+/* Returns the number of times 'netdev''s carrier has changed. */
+long long int
+netdev_get_carrier_resets(const struct netdev *netdev)
 {
-    int error;
-    enum netdev_flags flags;
-    bool miimon;
-
-    netdev_get_flags(netdev, &flags);
-    if (!(flags & NETDEV_UP)) {
-        return false;
-    }
-
-    if (!netdev_get_dev(netdev)->netdev_class->get_miimon) {
-        return true;
-    }
-
-    error = netdev_get_dev(netdev)->netdev_class->get_miimon(netdev, &miimon);
-
-    if (error) {
-        VLOG_DBG("%s: failed to get network device MII status, assuming "
-                 "down: %s", netdev_get_name(netdev), strerror(error));
-        miimon = false;
-    }
+    return (netdev_get_dev(netdev)->netdev_class->get_carrier_resets
+            ? netdev_get_dev(netdev)->netdev_class->get_carrier_resets(netdev)
+            : 0);
+}
 
-    return miimon;
+/* Attempts to force netdev_get_carrier() to poll 'netdev''s MII registers for
+ * link status instead of checking 'netdev''s carrier.  'netdev''s MII
+ * registers will be polled once ever 'interval' milliseconds.  If 'netdev'
+ * does not support MII, another method may be used as a fallback.  If
+ * 'interval' is less than or equal to zero, reverts netdev_get_carrier() to
+ * its normal behavior.
+ *
+ * Returns 0 if successful, otherwise a positive errno value. */
+int
+netdev_set_miimon_interval(struct netdev *netdev, long long int interval)
+{
+    struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
+    return (netdev_dev->netdev_class->set_miimon_interval
+            ? netdev_dev->netdev_class->set_miimon_interval(netdev, interval)
+            : EOPNOTSUPP);
 }
 
 /* Retrieves current device stats for 'netdev'. */
@@ -1234,66 +1258,28 @@ netdev_dump_queue_stats(const struct netdev *netdev,
             : EOPNOTSUPP);
 }
 
-/* If 'netdev' is a VLAN network device (e.g. one created with vconfig(8)),
- * sets '*vlan_vid' to the VLAN VID associated with that device and returns 0.
- * Otherwise returns a errno value (specifically ENOENT if 'netdev_name' is the
- * name of a network device that is not a VLAN device) and sets '*vlan_vid' to
- * -1. */
-int
-netdev_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
-{
-    int error = (netdev_get_dev(netdev)->netdev_class->get_vlan_vid
-                 ? netdev_get_dev(netdev)->netdev_class->get_vlan_vid(netdev,
-                        vlan_vid)
-                 : ENOENT);
-    if (error) {
-        *vlan_vid = 0;
-    }
-    return error;
-}
-
-/* Returns a network device that has 'in4' as its IP address, if one exists,
- * otherwise a null pointer. */
-struct netdev *
-netdev_find_dev_by_in4(const struct in_addr *in4)
+/* 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)
 {
-    struct netdev *netdev;
-    struct sset dev_list = SSET_INITIALIZER(&dev_list);
-    const char *name;
-
-    netdev_enumerate(&dev_list);
-    SSET_FOR_EACH (name, &dev_list) {
-        struct in_addr dev_in4;
-
-        if (!netdev_open_default(name, &netdev)
-            && !netdev_get_in4(netdev, &dev_in4, NULL)
-            && dev_in4.s_addr == in4->s_addr) {
-            goto exit;
-        }
-        netdev_close(netdev);
-    }
-    netdev = NULL;
-
-exit:
-    sset_destroy(&dev_list);
-    return netdev;
+    return netdev_get_dev(netdev)->netdev_class->change_seq(netdev);
 }
 
 /* Initializes 'netdev_dev' as a netdev device named 'name' of the specified
  * 'netdev_class'.  This function is ordinarily called from a netdev provider's
  * 'create' function.
  *
- * 'args' should be the arguments that were passed to the netdev provider's
- * 'create'.  If an empty set of arguments was passed, and 'name' is the name
- * of a network device that existed before the 'create' call, then 'args' may
- * instead be the configuration for that existing device.
- *
  * This function adds 'netdev_dev' to a netdev-owned shash, so it is
  * very important that 'netdev_dev' only be freed after calling
  * the refcount drops to zero.  */
 void
 netdev_dev_init(struct netdev_dev *netdev_dev, const char *name,
-                const struct shash *args,
                 const struct netdev_class *netdev_class)
 {
     assert(!shash_find(&netdev_dev_shash, name));
@@ -1302,7 +1288,6 @@ netdev_dev_init(struct netdev_dev *netdev_dev, const char *name,
     netdev_dev->netdev_class = netdev_class;
     netdev_dev->name = xstrdup(name);
     netdev_dev->node = shash_add(&netdev_dev_shash, name, netdev_dev);
-    smap_clone(&netdev_dev->args, args);
 }
 
 /* Undoes the results of initialization.
@@ -1320,7 +1305,6 @@ netdev_dev_uninit(struct netdev_dev *netdev_dev, bool destroy)
     assert(!netdev_dev->ref_cnt);
 
     shash_delete(&netdev_dev_shash, netdev_dev->node);
-    smap_destroy(&netdev_dev->args);
 
     if (destroy) {
         netdev_dev->netdev_class->destroy(netdev_dev);
@@ -1429,139 +1413,6 @@ netdev_get_dev(const struct netdev *netdev)
 {
     return netdev->netdev_dev;
 }
-
-/* Initializes 'notifier' as a netdev notifier for 'netdev', for which
- * notification will consist of calling 'cb', with auxiliary data 'aux'. */
-void
-netdev_notifier_init(struct netdev_notifier *notifier, struct netdev *netdev,
-                     void (*cb)(struct netdev_notifier *), void *aux)
-{
-    notifier->netdev = netdev;
-    notifier->cb = cb;
-    notifier->aux = aux;
-}
-
-/* Tracks changes in the status of a set of network devices. */
-struct netdev_monitor {
-    struct shash polled_netdevs;
-    struct sset changed_netdevs;
-};
-
-/* Creates and returns a new structure for monitor changes in the status of
- * network devices. */
-struct netdev_monitor *
-netdev_monitor_create(void)
-{
-    struct netdev_monitor *monitor = xmalloc(sizeof *monitor);
-    shash_init(&monitor->polled_netdevs);
-    sset_init(&monitor->changed_netdevs);
-    return monitor;
-}
-
-/* Destroys 'monitor'. */
-void
-netdev_monitor_destroy(struct netdev_monitor *monitor)
-{
-    if (monitor) {
-        struct shash_node *node;
-
-        SHASH_FOR_EACH (node, &monitor->polled_netdevs) {
-            struct netdev_notifier *notifier = node->data;
-            netdev_get_dev(notifier->netdev)->netdev_class->poll_remove(
-                    notifier);
-        }
-
-        shash_destroy(&monitor->polled_netdevs);
-        sset_destroy(&monitor->changed_netdevs);
-        free(monitor);
-    }
-}
-
-static void
-netdev_monitor_cb(struct netdev_notifier *notifier)
-{
-    struct netdev_monitor *monitor = notifier->aux;
-    const char *name = netdev_get_name(notifier->netdev);
-    sset_add(&monitor->changed_netdevs, name);
-}
-
-/* Attempts to add 'netdev' as a netdev monitored by 'monitor'.  Returns 0 if
- * successful, otherwise a positive errno value.
- *
- * Adding a given 'netdev' to a monitor multiple times is equivalent to adding
- * it once. */
-int
-netdev_monitor_add(struct netdev_monitor *monitor, struct netdev *netdev)
-{
-    const char *netdev_name = netdev_get_name(netdev);
-    int error = 0;
-    if (!shash_find(&monitor->polled_netdevs, netdev_name)
-            && netdev_get_dev(netdev)->netdev_class->poll_add)
-    {
-        struct netdev_notifier *notifier;
-        error = netdev_get_dev(netdev)->netdev_class->poll_add(netdev,
-                    netdev_monitor_cb, monitor, &notifier);
-        if (!error) {
-            assert(notifier->netdev == netdev);
-            shash_add(&monitor->polled_netdevs, netdev_name, notifier);
-        }
-    }
-    return error;
-}
-
-/* Removes 'netdev' from the set of netdevs monitored by 'monitor'.  (This has
- * no effect if 'netdev' is not in the set of devices monitored by
- * 'monitor'.) */
-void
-netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev)
-{
-    const char *netdev_name = netdev_get_name(netdev);
-    struct shash_node *node;
-
-    node = shash_find(&monitor->polled_netdevs, netdev_name);
-    if (node) {
-        /* Cancel future notifications. */
-        struct netdev_notifier *notifier = node->data;
-        netdev_get_dev(netdev)->netdev_class->poll_remove(notifier);
-        shash_delete(&monitor->polled_netdevs, node);
-
-        /* Drop any pending notification. */
-        sset_find_and_delete(&monitor->changed_netdevs, netdev_name);
-    }
-}
-
-/* Checks for changes to netdevs in the set monitored by 'monitor'.  If any of
- * the attributes (Ethernet address, carrier status, speed or peer-advertised
- * speed, flags, etc.) of a network device monitored by 'monitor' has changed,
- * sets '*devnamep' to the name of a device that has changed and returns 0.
- * The caller is responsible for freeing '*devnamep' (with free()).
- *
- * If no devices have changed, sets '*devnamep' to NULL and returns EAGAIN. */
-int
-netdev_monitor_poll(struct netdev_monitor *monitor, char **devnamep)
-{
-    if (sset_is_empty(&monitor->changed_netdevs)) {
-        *devnamep = NULL;
-        return EAGAIN;
-    } else {
-        *devnamep = sset_pop(&monitor->changed_netdevs);
-        return 0;
-    }
-}
-
-/* Registers with the poll loop to wake up from the next call to poll_block()
- * when netdev_monitor_poll(monitor) would indicate that a device has
- * changed. */
-void
-netdev_monitor_poll_wait(const struct netdev_monitor *monitor)
-{
-    if (!sset_is_empty(&monitor->changed_netdevs)) {
-        poll_immediate_wake();
-    } else {
-        /* XXX Nothing needed here for netdev_linux, but maybe other netdev
-         * classes need help. */
-    }
-}
 
 /* Restore the network device flags on 'netdev' to those that were active
  * before we changed them.  Returns 0 if successful, otherwise a positive