X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnetdev.c;h=c21afef829ca22d1bca8e475813df654dc5f9955;hb=2158888d8d8f3b4c00dcf979390a19fa7fcf7942;hp=428ad9501809eec3ccc5d3b5ce0da17579d52916;hpb=0b0544d706d10516d3122fbcce8f1dc1dec6cb92;p=sliver-openvswitch.git diff --git a/lib/netdev.c b/lib/netdev.c index 428ad9501..c21afef82 100644 --- a/lib/netdev.c +++ b/lib/netdev.c @@ -32,6 +32,7 @@ #include "list.h" #include "netdev-provider.h" #include "ofpbuf.h" +#include "openflow/openflow.h" #include "packets.h" #include "poll-loop.h" #include "shash.h" @@ -40,12 +41,14 @@ #define THIS_MODULE VLM_netdev #include "vlog.h" -static const struct netdev_class *netdev_classes[] = { +static const struct netdev_class *base_netdev_classes[] = { &netdev_linux_class, &netdev_tap_class, + &netdev_patch_class, &netdev_gre_class, }; -static int n_netdev_classes = ARRAY_SIZE(netdev_classes); + +static struct shash netdev_classes = SHASH_INITIALIZER(&netdev_classes); /* All created network devices. */ static struct shash netdev_dev_shash = SHASH_INITIALIZER(&netdev_dev_shash); @@ -57,45 +60,25 @@ static struct list netdev_list = LIST_INITIALIZER(&netdev_list); * additional log messages. */ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20); -static void close_all_netdevs(void *aux UNUSED); +static void close_all_netdevs(void *aux OVS_UNUSED); static int restore_flags(struct netdev *netdev); +void update_device_args(struct netdev_dev *, const struct shash *args); -/* Attempts to initialize the netdev module. Returns 0 if successful, - * otherwise a positive errno value. - * - * Calling this function is optional. If not called explicitly, it will - * automatically be called upon the first attempt to open or create a - * network device. */ -int +static void netdev_initialize(void) { static int status = -1; + if (status < 0) { - int i, j; + int i; - fatal_signal_add_hook(close_all_netdevs, NULL, true); + fatal_signal_add_hook(close_all_netdevs, NULL, NULL, true); status = 0; - for (i = j = 0; i < n_netdev_classes; i++) { - const struct netdev_class *class = netdev_classes[i]; - if (class->init) { - int retval = class->init(); - if (!retval) { - netdev_classes[j++] = class; - } else { - VLOG_ERR("failed to initialize %s network device " - "class: %s", class->type, strerror(retval)); - if (!status) { - status = retval; - } - } - } else { - netdev_classes[j++] = class; - } + for (i = 0; i < ARRAY_SIZE(base_netdev_classes); i++) { + netdev_register_provider(base_netdev_classes[i]); } - n_netdev_classes = j; } - return status; } /* Performs periodic work needed by all the various kinds of netdevs. @@ -105,11 +88,11 @@ netdev_initialize(void) void netdev_run(void) { - int i; - for (i = 0; i < n_netdev_classes; i++) { - const struct netdev_class *class = netdev_classes[i]; - if (class->run) { - class->run(); + 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(); } } } @@ -121,59 +104,185 @@ netdev_run(void) void netdev_wait(void) { + 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(); + } + } +} + +/* 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) +{ + struct netdev_class *new_provider; + + if (shash_find(&netdev_classes, 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) { + VLOG_ERR("failed to initialize %s network device class: %s", + new_class->type, strerror(error)); + return error; + } + } + + new_provider = xmalloc(sizeof *new_provider); + memcpy(new_provider, new_class, sizeof *new_provider); + + shash_add(&netdev_classes, new_class->type, new_provider); + + return 0; +} + +/* Unregisters a netdev provider. 'type' must have been previously + * registered and not currently be in use by any netdevs. After unregistration + * new netdevs of that type cannot be opened using netdev_open(). */ +int +netdev_unregister_provider(const char *type) +{ + struct shash_node *del_node, *netdev_dev_node; + + del_node = shash_find(&netdev_classes, type); + if (!del_node) { + VLOG_WARN("attempted to unregister a netdev provider that is not " + "registered: %s", type); + return EAFNOSUPPORT; + } + + SHASH_FOR_EACH(netdev_dev_node, &netdev_dev_shash) { + struct netdev_dev *netdev_dev = netdev_dev_node->data; + if (!strcmp(netdev_dev->netdev_class->type, type)) { + VLOG_WARN("attempted to unregister in use netdev provider: %s", + type); + return EBUSY; + } + } + + shash_delete(&netdev_classes, del_node); + free(del_node->data); + + return 0; +} + +/* Clears 'types' and enumerates the types of all currently registered netdev + * providers into it. The caller must first initialize the svec. */ +void +netdev_enumerate_types(struct svec *types) +{ + struct shash_node *node; + + netdev_initialize(); + svec_clear(types); + + SHASH_FOR_EACH(node, &netdev_classes) { + const struct netdev_class *netdev_class = node->data; + svec_add(types, netdev_class->type); + } +} + +/* Compares 'args' to those used to those used by 'dev'. Returns true + * if the arguments are the same, false otherwise. Does not update the + * values stored in 'dev'. */ +static bool +compare_device_args(const struct netdev_dev *dev, const struct shash *args) +{ + const struct shash_node **new_args; + bool result = true; int i; - for (i = 0; i < n_netdev_classes; i++) { - const struct netdev_class *class = netdev_classes[i]; - if (class->wait) { - class->wait(); + + if (shash_count(args) != dev->n_args) { + return false; + } + + new_args = shash_sort(args); + for (i = 0; i < dev->n_args; i++) { + if (strcmp(dev->args[i].key, new_args[i]->name) || + strcmp(dev->args[i].value, new_args[i]->data)) { + result = false; + goto finish; } } + +finish: + free(new_args); + return result; } static int -create_device(struct netdev_options *options, struct netdev_dev **netdev_devp) +compare_args(const void *a_, const void *b_) { + const struct arg *a = a_; + const struct arg *b = b_; + return strcmp(a->key, b->key); +} + +void +update_device_args(struct netdev_dev *dev, const struct shash *args) +{ + struct shash_node *node; int i; - if (!options->may_create) { - VLOG_WARN("attempted to create a device that may not be created: %s", - options->name); - return ENODEV; + if (dev->n_args) { + for (i = 0; i < dev->n_args; i++) { + free(dev->args[i].key); + free(dev->args[i].value); + } + + free(dev->args); + dev->n_args = 0; } - if (!options->type || strlen(options->type) == 0) { - /* Default to system. */ - options->type = "system"; + if (!args || shash_is_empty(args)) { + return; } - for (i = 0; i < n_netdev_classes; i++) { - const struct netdev_class *class = netdev_classes[i]; + dev->n_args = shash_count(args); + dev->args = xmalloc(dev->n_args * sizeof *dev->args); - if (!strcmp(options->type, class->type)) { - return class->create(options->name, options->type, options->args, - netdev_devp); - } + i = 0; + SHASH_FOR_EACH(node, args) { + dev->args[i].key = xstrdup(node->name); + dev->args[i].value = xstrdup(node->data); + i++; } - VLOG_WARN("could not create netdev %s of unknown type %s", options->name, - options->type); - return EINVAL; + qsort(dev->args, dev->n_args, sizeof *dev->args, compare_args); } -static uint32_t -shash_hash(const struct shash *shash) +static int +create_device(struct netdev_options *options, struct netdev_dev **netdev_devp) { - int hash = 0; - struct shash_node *node; - uint32_t entry_hash; + struct netdev_class *netdev_class; - SHASH_FOR_EACH(node, shash) { - entry_hash = hash_string(node->name, 0); - entry_hash ^= hash_string(node->data, 10); - hash ^= hash_int(entry_hash, 0); + if (!options->may_create) { + VLOG_WARN("attempted to create a device that may not be created: %s", + options->name); + return ENODEV; } - return hash; + if (!options->type || strlen(options->type) == 0) { + /* Default to system. */ + options->type = "system"; + } + + netdev_class = shash_find_data(&netdev_classes, options->type); + if (!netdev_class) { + VLOG_WARN("could not create netdev %s of unknown type %s", + options->name, options->type); + return EAFNOSUPPORT; + } + + return netdev_class->create(options->name, options->type, options->args, + netdev_devp); } /* Opens the network device named 'name' (e.g. "eth0") and returns zero if @@ -217,26 +326,24 @@ netdev_open(struct netdev_options *options, struct netdev **netdevp) if (error) { return error; } - - netdev_dev->args_hash = shash_hash(options->args); + update_device_args(netdev_dev, options->args); } else if (options->may_open) { - if (!shash_is_empty(options->args)) { - uint32_t args_hash = shash_hash(options->args); + if (!shash_is_empty(options->args) && + !compare_device_args(netdev_dev, options->args)) { - if (args_hash != netdev_dev->args_hash) { - VLOG_WARN("attempted to open already created netdev with " - "different arguments: %s", options->name); - return EINVAL; - } + VLOG_WARN("%s: attempted to open already created netdev with " + "different arguments", options->name); + return EINVAL; } } else { - VLOG_WARN("attempted to create a netdev device with bound name: %s", + VLOG_WARN("%s: attempted to create a netdev device with bound name", options->name); return EEXIST; } - error = netdev_dev->class->open(netdev_dev, options->ethertype, netdevp); + error = netdev_dev->netdev_class->open(netdev_dev, options->ethertype, + netdevp); if (!error) { netdev_dev->ref_cnt++; @@ -276,13 +383,14 @@ netdev_reconfigure(struct netdev *netdev, const struct shash *args) args = &empty_args; } - if (netdev_dev->class->reconfigure) { - uint32_t args_hash = shash_hash(args); - - if (netdev_dev->args_hash != args_hash) { - netdev_dev->args_hash = args_hash; - return netdev_dev->class->reconfigure(netdev_dev, args); + if (netdev_dev->netdev_class->reconfigure) { + if (!compare_device_args(netdev_dev, args)) { + update_device_args(netdev_dev, args); + return netdev_dev->netdev_class->reconfigure(netdev_dev, args); } + } else if (!shash_is_empty(args)) { + VLOG_WARN("%s: arguments provided to device that does not have a " + "reconfigure function", netdev_get_name(netdev)); } return 0; @@ -327,31 +435,38 @@ netdev_exists(const char *name) } } -/* Initializes 'svec' with a list of the names of all known network devices. */ +/* Returns true if a network device named 'name' is currently opened, + * otherwise false. */ +bool +netdev_is_open(const char *name) +{ + return !!shash_find_data(&netdev_dev_shash, name); +} + +/* Clears 'svec' and enumerates the names of all known network devices. */ int netdev_enumerate(struct svec *svec) { - int error; - int i; - - svec_init(svec); + struct shash_node *node; + int error = 0; netdev_initialize(); + svec_clear(svec); - error = 0; - for (i = 0; i < n_netdev_classes; i++) { - const struct netdev_class *class = netdev_classes[i]; - if (class->enumerate) { - int retval = class->enumerate(svec); + SHASH_FOR_EACH(node, &netdev_classes) { + const struct netdev_class *netdev_class = node->data; + if (netdev_class->enumerate) { + int retval = netdev_class->enumerate(svec); if (retval) { VLOG_WARN("failed to enumerate %s network devices: %s", - class->type, strerror(retval)); + netdev_class->type, strerror(retval)); if (!error) { error = retval; } } } } + return error; } @@ -366,17 +481,23 @@ netdev_enumerate(struct svec *svec) * guaranteed to contain at least ETH_TOTAL_MIN bytes. Otherwise, returns a * positive errno value. Returns EAGAIN immediately if no packet is ready to * be returned. + * + * Some network devices may not implement support for this function. In such + * cases this function will always return EOPNOTSUPP. */ int netdev_recv(struct netdev *netdev, struct ofpbuf *buffer) { + int (*recv)(struct netdev *, void *, size_t); int retval; assert(buffer->size == 0); assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN); - retval = netdev_get_dev(netdev)->class->recv(netdev, buffer->data, - ofpbuf_tailroom(buffer)); + recv = netdev_get_dev(netdev)->netdev_class->recv; + retval = (recv + ? (recv)(netdev, buffer->data, ofpbuf_tailroom(buffer)) + : -EOPNOTSUPP); if (retval >= 0) { COVERAGE_INC(netdev_received); buffer->size += retval; @@ -394,14 +515,22 @@ netdev_recv(struct netdev *netdev, struct ofpbuf *buffer) void netdev_recv_wait(struct netdev *netdev) { - netdev_get_dev(netdev)->class->recv_wait(netdev); + void (*recv_wait)(struct netdev *); + + recv_wait = netdev_get_dev(netdev)->netdev_class->recv_wait; + if (recv_wait) { + recv_wait(netdev); + } } /* Discards all packets waiting to be received from 'netdev'. */ int netdev_drain(struct netdev *netdev) { - return netdev_get_dev(netdev)->class->drain(netdev); + int (*drain)(struct netdev *); + + drain = netdev_get_dev(netdev)->netdev_class->drain; + return drain ? drain(netdev) : 0; } /* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive @@ -412,12 +541,18 @@ netdev_drain(struct netdev *netdev) * The caller retains ownership of 'buffer' in all cases. * * The kernel maintains a packet transmission queue, so the caller is not - * expected to do additional queuing of packets. */ + * expected to do additional queuing of packets. + * + * Some network devices may not implement support for this function. In such + * cases this function will always return EOPNOTSUPP. */ int netdev_send(struct netdev *netdev, const struct ofpbuf *buffer) { - int error = netdev_get_dev(netdev)->class->send(netdev, buffer->data, - buffer->size); + int (*send)(struct netdev *, const void *, size_t); + int error; + + send = netdev_get_dev(netdev)->netdev_class->send; + error = send ? (send)(netdev, buffer->data, buffer->size) : EOPNOTSUPP; if (!error) { COVERAGE_INC(netdev_sent); } @@ -434,7 +569,12 @@ netdev_send(struct netdev *netdev, const struct ofpbuf *buffer) void netdev_send_wait(struct netdev *netdev) { - return netdev_get_dev(netdev)->class->send_wait(netdev); + void (*send_wait)(struct netdev *); + + send_wait = netdev_get_dev(netdev)->netdev_class->send_wait; + if (send_wait) { + send_wait(netdev); + } } /* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful, @@ -442,7 +582,7 @@ netdev_send_wait(struct netdev *netdev) int netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN]) { - return netdev_get_dev(netdev)->class->set_etheraddr(netdev, mac); + return netdev_get_dev(netdev)->netdev_class->set_etheraddr(netdev, mac); } /* Retrieves 'netdev''s MAC address. If successful, returns 0 and copies the @@ -451,7 +591,7 @@ netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN]) int netdev_get_etheraddr(const struct netdev *netdev, uint8_t mac[ETH_ADDR_LEN]) { - return netdev_get_dev(netdev)->class->get_etheraddr(netdev, mac); + return netdev_get_dev(netdev)->netdev_class->get_etheraddr(netdev, mac); } /* Returns the name of the network device that 'netdev' represents, @@ -472,7 +612,7 @@ netdev_get_name(const struct netdev *netdev) int netdev_get_mtu(const struct netdev *netdev, int *mtup) { - int error = netdev_get_dev(netdev)->class->get_mtu(netdev, mtup); + int error = netdev_get_dev(netdev)->netdev_class->get_mtu(netdev, mtup); if (error) { VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: %s", netdev_get_name(netdev), strerror(error)); @@ -489,23 +629,37 @@ netdev_get_mtu(const struct netdev *netdev, int *mtup) * value should be unique within a host and remain stable at least until * reboot. SNMP says an ifindex "ranges between 1 and the value of ifNumber" * but many systems do not follow this rule anyhow. + * + * Some network devices may not implement support for this function. In such + * cases this function will always return -EOPNOTSUPP. */ int netdev_get_ifindex(const struct netdev *netdev) { - return netdev_get_dev(netdev)->class->get_ifindex(netdev); + int (*get_ifindex)(const struct netdev *); + + get_ifindex = netdev_get_dev(netdev)->netdev_class->get_ifindex; + + return get_ifindex ? get_ifindex(netdev) : -EOPNOTSUPP; } /* Stores the features supported by 'netdev' into each of '*current', * '*advertised', '*supported', and '*peer' that are non-null. Each value is a * bitmap of "enum ofp_port_features" bits, in host byte order. Returns 0 if * successful, otherwise a positive errno value. On failure, all of the - * passed-in values are set to 0. */ + * passed-in values are set to 0. + * + * Some network devices may not implement support for this function. In such + * cases this function will always return EOPNOTSUPP. + */ int netdev_get_features(struct netdev *netdev, uint32_t *current, uint32_t *advertised, uint32_t *supported, uint32_t *peer) { + int (*get_features)(struct netdev *netdev, + uint32_t *current, uint32_t *advertised, + uint32_t *supported, uint32_t *peer); uint32_t dummy[4]; int error; @@ -522,23 +676,53 @@ netdev_get_features(struct netdev *netdev, peer = &dummy[3]; } - error = netdev_get_dev(netdev)->class->get_features(netdev, current, - advertised, supported, - peer); + get_features = netdev_get_dev(netdev)->netdev_class->get_features; + error = get_features + ? get_features(netdev, current, advertised, supported, peer) + : EOPNOTSUPP; if (error) { *current = *advertised = *supported = *peer = 0; } return error; } +/* Returns the maximum speed of a network connection that has the "enum + * ofp_port_features" bits in 'features', in bits per second. If no bits that + * indicate a speed are set in 'features', assumes 100Mbps. */ +uint64_t +netdev_features_to_bps(uint32_t features) +{ + enum { + F_10000MB = OFPPF_10GB_FD, + F_1000MB = OFPPF_1GB_HD | OFPPF_1GB_FD, + F_100MB = OFPPF_100MB_HD | OFPPF_100MB_FD, + F_10MB = OFPPF_10MB_HD | OFPPF_10MB_FD + }; + + return ( features & F_10000MB ? UINT64_C(10000000000) + : features & F_1000MB ? UINT64_C(1000000000) + : features & F_100MB ? UINT64_C(100000000) + : features & F_10MB ? UINT64_C(10000000) + : UINT64_C(100000000)); +} + +/* Returns true if any of the "enum ofp_port_features" bits that indicate a + * full-duplex link are set in 'features', otherwise false. */ +bool +netdev_features_is_full_duplex(uint32_t features) +{ + return (features & (OFPPF_10MB_FD | OFPPF_100MB_FD | OFPPF_1GB_FD + | OFPPF_10GB_FD)) != 0; +} + /* Set the features advertised by 'netdev' to 'advertise'. Returns 0 if * successful, otherwise a positive errno value. */ int netdev_set_advertisements(struct netdev *netdev, uint32_t advertise) { - return (netdev_get_dev(netdev)->class->set_advertisements - ? netdev_get_dev(netdev)->class->set_advertisements(netdev, - advertise) + return (netdev_get_dev(netdev)->netdev_class->set_advertisements + ? netdev_get_dev(netdev)->netdev_class->set_advertisements( + netdev, advertise) : EOPNOTSUPP); } @@ -562,9 +746,9 @@ netdev_get_in4(const struct netdev *netdev, struct in_addr netmask; int error; - error = (netdev_get_dev(netdev)->class->get_in4 - ? netdev_get_dev(netdev)->class->get_in4(netdev, &address, - &netmask) + error = (netdev_get_dev(netdev)->netdev_class->get_in4 + ? netdev_get_dev(netdev)->netdev_class->get_in4(netdev, + &address, &netmask) : EOPNOTSUPP); if (address_) { address_->s_addr = error ? 0 : address.s_addr; @@ -581,8 +765,8 @@ netdev_get_in4(const struct netdev *netdev, int netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask) { - return (netdev_get_dev(netdev)->class->set_in4 - ? netdev_get_dev(netdev)->class->set_in4(netdev, addr, mask) + return (netdev_get_dev(netdev)->netdev_class->set_in4 + ? netdev_get_dev(netdev)->netdev_class->set_in4(netdev, addr, mask) : EOPNOTSUPP); } @@ -592,8 +776,8 @@ int netdev_add_router(struct netdev *netdev, struct in_addr router) { COVERAGE_INC(netdev_add_router); - return (netdev_get_dev(netdev)->class->add_router - ? netdev_get_dev(netdev)->class->add_router(netdev, router) + return (netdev_get_dev(netdev)->netdev_class->add_router + ? netdev_get_dev(netdev)->netdev_class->add_router(netdev, router) : EOPNOTSUPP); } @@ -609,9 +793,9 @@ netdev_get_next_hop(const struct netdev *netdev, const struct in_addr *host, struct in_addr *next_hop, char **netdev_name) { - int error = (netdev_get_dev(netdev)->class->get_next_hop - ? netdev_get_dev(netdev)->class->get_next_hop(host, next_hop, - netdev_name) + int error = (netdev_get_dev(netdev)->netdev_class->get_next_hop + ? netdev_get_dev(netdev)->netdev_class->get_next_hop( + host, next_hop, netdev_name) : EOPNOTSUPP); if (error) { next_hop->s_addr = 0; @@ -637,9 +821,9 @@ netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6) struct in6_addr dummy; int error; - error = (netdev_get_dev(netdev)->class->get_in6 - ? netdev_get_dev(netdev)->class->get_in6(netdev, in6 ? in6 - : &dummy) + error = (netdev_get_dev(netdev)->netdev_class->get_in6 + ? netdev_get_dev(netdev)->netdev_class->get_in6(netdev, + in6 ? in6 : &dummy) : EOPNOTSUPP); if (error && in6) { memset(in6, 0, sizeof *in6); @@ -659,8 +843,8 @@ do_update_flags(struct netdev *netdev, enum netdev_flags off, enum netdev_flags old_flags; int error; - error = netdev_get_dev(netdev)->class->update_flags(netdev, off & ~on, on, - &old_flags); + error = netdev_get_dev(netdev)->netdev_class->update_flags(netdev, + off & ~on, on, &old_flags); if (error) { VLOG_WARN_RL(&rl, "failed to %s flags for network device %s: %s", off || on ? "set" : "get", netdev_get_name(netdev), @@ -733,8 +917,9 @@ int netdev_arp_lookup(const struct netdev *netdev, uint32_t ip, uint8_t mac[ETH_ADDR_LEN]) { - int error = (netdev_get_dev(netdev)->class->arp_lookup - ? netdev_get_dev(netdev)->class->arp_lookup(netdev, ip, mac) + int error = (netdev_get_dev(netdev)->netdev_class->arp_lookup + ? netdev_get_dev(netdev)->netdev_class->arp_lookup(netdev, + ip, mac) : EOPNOTSUPP); if (error) { memset(mac, 0, ETH_ADDR_LEN); @@ -747,8 +932,9 @@ netdev_arp_lookup(const struct netdev *netdev, int netdev_get_carrier(const struct netdev *netdev, bool *carrier) { - int error = (netdev_get_dev(netdev)->class->get_carrier - ? netdev_get_dev(netdev)->class->get_carrier(netdev, carrier) + int error = (netdev_get_dev(netdev)->netdev_class->get_carrier + ? netdev_get_dev(netdev)->netdev_class->get_carrier(netdev, + carrier) : EOPNOTSUPP); if (error) { *carrier = false; @@ -763,8 +949,8 @@ netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats) int error; COVERAGE_INC(netdev_get_stats); - error = (netdev_get_dev(netdev)->class->get_stats - ? netdev_get_dev(netdev)->class->get_stats(netdev, stats) + error = (netdev_get_dev(netdev)->netdev_class->get_stats + ? netdev_get_dev(netdev)->netdev_class->get_stats(netdev, stats) : EOPNOTSUPP); if (error) { memset(stats, 0xff, sizeof *stats); @@ -772,6 +958,19 @@ netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats) return error; } +/* Attempts to change the stats for 'netdev' to those provided in 'stats'. + * Returns 0 if successful, otherwise a positive errno value. + * + * This will probably fail for most network devices. Some devices might only + * allow setting their stats to 0. */ +int +netdev_set_stats(struct netdev *netdev, const struct netdev_stats *stats) +{ + return (netdev_get_dev(netdev)->netdev_class->set_stats + ? netdev_get_dev(netdev)->netdev_class->set_stats(netdev, stats) + : EOPNOTSUPP); +} + /* Attempts to set input rate limiting (policing) policy, such that up to * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative burst * size of 'kbits' kb. */ @@ -779,9 +978,9 @@ int netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate, uint32_t kbits_burst) { - return (netdev_get_dev(netdev)->class->set_policing - ? netdev_get_dev(netdev)->class->set_policing(netdev, kbits_rate, - kbits_burst) + return (netdev_get_dev(netdev)->netdev_class->set_policing + ? netdev_get_dev(netdev)->netdev_class->set_policing(netdev, + kbits_rate, kbits_burst) : EOPNOTSUPP); } @@ -793,8 +992,9 @@ netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate, int netdev_get_vlan_vid(const struct netdev *netdev, int *vlan_vid) { - int error = (netdev_get_dev(netdev)->class->get_vlan_vid - ? netdev_get_dev(netdev)->class->get_vlan_vid(netdev, 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; @@ -808,7 +1008,7 @@ struct netdev * netdev_find_dev_by_in4(const struct in_addr *in4) { struct netdev *netdev; - struct svec dev_list; + struct svec dev_list = SVEC_EMPTY_INITIALIZER; size_t i; netdev_enumerate(&dev_list); @@ -831,19 +1031,19 @@ exit: } /* Initializes 'netdev_dev' as a netdev device named 'name' of the - * specified 'class'. + * specified 'netdev_class'. * * 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 netdev_class *class) + const struct netdev_class *netdev_class) { assert(!shash_find(&netdev_dev_shash, name)); - netdev_dev->class = class; - netdev_dev->ref_cnt = 0; + memset(netdev_dev, 0, sizeof *netdev_dev); + netdev_dev->netdev_class = netdev_class; netdev_dev->name = xstrdup(name); netdev_dev->node = shash_add(&netdev_dev_shash, name, netdev_dev); } @@ -863,9 +1063,10 @@ netdev_dev_uninit(struct netdev_dev *netdev_dev, bool destroy) assert(!netdev_dev->ref_cnt); shash_delete(&netdev_dev_shash, netdev_dev->node); + update_device_args(netdev_dev, NULL); if (destroy) { - netdev_dev->class->destroy(netdev_dev); + netdev_dev->netdev_class->destroy(netdev_dev); } free(name); } @@ -876,7 +1077,14 @@ netdev_dev_uninit(struct netdev_dev *netdev_dev, bool destroy) const char * netdev_dev_get_type(const struct netdev_dev *netdev_dev) { - return netdev_dev->class->type; + return netdev_dev->netdev_class->type; +} + +/* Returns the class associated with 'netdev_dev'. */ +const struct netdev_class * +netdev_dev_get_class(const struct netdev_dev *netdev_dev) +{ + return netdev_dev->netdev_class; } /* Returns the name of 'netdev_dev'. @@ -888,6 +1096,33 @@ netdev_dev_get_name(const struct netdev_dev *netdev_dev) return netdev_dev->name; } +/* Returns the netdev_dev with 'name' or NULL if there is none. + * + * The caller must not free the returned value. */ +struct netdev_dev * +netdev_dev_from_name(const char *name) +{ + return shash_find_data(&netdev_dev_shash, name); +} + +/* Fills 'device_list' with devices that match 'netdev_class'. + * + * The caller is responsible for initializing and destroying 'device_list' + * but the contained netdev_devs must not be freed. */ +void +netdev_dev_get_devices(const struct netdev_class *netdev_class, + struct shash *device_list) +{ + struct shash_node *node; + SHASH_FOR_EACH (node, &netdev_dev_shash) { + struct netdev_dev *dev = node->data; + + if (dev->netdev_class == netdev_class) { + shash_add(device_list, node->name, node->data); + } + } +} + /* Initializes 'netdev' as a instance of the netdev_dev. * * This function adds 'netdev' to a netdev-owned linked list, so it is very @@ -895,9 +1130,8 @@ netdev_dev_get_name(const struct netdev_dev *netdev_dev) void netdev_init(struct netdev *netdev, struct netdev_dev *netdev_dev) { + memset(netdev, 0, sizeof *netdev); netdev->netdev_dev = netdev_dev; - netdev->save_flags = 0; - netdev->changed_flags = 0; list_push_back(&netdev_list, &netdev->node); } @@ -919,7 +1153,7 @@ netdev_uninit(struct netdev *netdev, bool close) } if (close) { - netdev_get_dev(netdev)->class->close(netdev); + netdev_get_dev(netdev)->netdev_class->close(netdev); } } @@ -930,7 +1164,7 @@ netdev_uninit(struct netdev *netdev, bool close) const char * netdev_get_type(const struct netdev *netdev) { - return netdev_get_dev(netdev)->class->type; + return netdev_get_dev(netdev)->netdev_class->type; } struct netdev_dev * @@ -976,7 +1210,8 @@ netdev_monitor_destroy(struct netdev_monitor *monitor) SHASH_FOR_EACH (node, &monitor->polled_netdevs) { struct netdev_notifier *notifier = node->data; - netdev_get_dev(notifier->netdev)->class->poll_remove(notifier); + netdev_get_dev(notifier->netdev)->netdev_class->poll_remove( + notifier); } shash_destroy(&monitor->polled_netdevs); @@ -1006,12 +1241,11 @@ 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)->class->poll_add) + && netdev_get_dev(netdev)->netdev_class->poll_add) { struct netdev_notifier *notifier; - error = netdev_get_dev(netdev)->class->poll_add(netdev, - netdev_monitor_cb, - monitor, ¬ifier); + error = netdev_get_dev(netdev)->netdev_class->poll_add(netdev, + netdev_monitor_cb, monitor, ¬ifier); if (!error) { assert(notifier->netdev == netdev); shash_add(&monitor->polled_netdevs, netdev_name, notifier); @@ -1033,7 +1267,7 @@ netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev) if (node) { /* Cancel future notifications. */ struct netdev_notifier *notifier = node->data; - netdev_get_dev(netdev)->class->poll_remove(notifier); + netdev_get_dev(netdev)->netdev_class->poll_remove(notifier); shash_delete(&monitor->polled_netdevs, node); /* Drop any pending notification. */ @@ -1091,7 +1325,7 @@ restore_flags(struct netdev *netdev) if (netdev->changed_flags) { enum netdev_flags restore = netdev->save_flags & netdev->changed_flags; enum netdev_flags old_flags; - return netdev_get_dev(netdev)->class->update_flags(netdev, + return netdev_get_dev(netdev)->netdev_class->update_flags(netdev, netdev->changed_flags & ~restore, restore, &old_flags); } @@ -1101,7 +1335,7 @@ restore_flags(struct netdev *netdev) /* Close all netdevs on shutdown so they can do any needed cleanup such as * destroying devices, restoring flags, etc. */ static void -close_all_netdevs(void *aux UNUSED) +close_all_netdevs(void *aux OVS_UNUSED) { struct netdev *netdev, *next; LIST_FOR_EACH_SAFE(netdev, next, struct netdev, node, &netdev_list) {