X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fnetdev.c;h=82a490419778edcd8601f60569d55f46a6d38059;hb=67a4917b07031b387beafaedce413b4207214059;hp=481671f798e1c9d3a518ebed0df4babc62e0f49f;hpb=e8b52a913a8fc3d2ef0dae82eda5905668ebfae1;p=openvswitch diff --git a/lib/netdev.c b/lib/netdev.c index 481671f7..82a49041 100644 --- a/lib/netdev.c +++ b/lib/netdev.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -31,6 +31,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" @@ -45,6 +46,9 @@ static const struct netdev_class *netdev_classes[] = { }; static int n_netdev_classes = ARRAY_SIZE(netdev_classes); +/* All created network devices. */ +static struct shash netdev_obj_shash = SHASH_INITIALIZER(&netdev_obj_shash); + /* All open network devices. */ static struct list netdev_list = LIST_INITIALIZER(&netdev_list); @@ -59,7 +63,8 @@ static int restore_flags(struct netdev *netdev); * 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 a network device. */ + * automatically be called upon the first attempt to open or create a + * network device. */ int netdev_initialize(void) { @@ -78,7 +83,7 @@ netdev_initialize(void) netdev_classes[j++] = class; } else { VLOG_ERR("failed to initialize %s network device " - "class: %s", class->name, strerror(retval)); + "class: %s", class->type, strerror(retval)); if (!status) { status = retval; } @@ -124,6 +129,92 @@ netdev_wait(void) } } +/* Attempts to create a network device object of 'type' with 'name'. 'type' + * corresponds to the 'type' field used in the netdev_class * structure. + * Arguments for creation are provided in 'args', which may be empty or NULL + * if none are needed. */ +int +netdev_create(const char *name, const char *type, const struct shash *args) +{ + struct shash empty_args = SHASH_INITIALIZER(&empty_args); + int i; + + netdev_initialize(); + + if (!args) { + args = &empty_args; + } + + if (shash_find(&netdev_obj_shash, name)) { + VLOG_WARN("attempted to create a netdev object with bound name: %s", + name); + return EEXIST; + } + + for (i = 0; i < n_netdev_classes; i++) { + const struct netdev_class *class = netdev_classes[i]; + if (!strcmp(type, class->type)) { + return class->create(name, type, args, true); + } + } + + VLOG_WARN("could not create netdev object of unknown type: %s", type); + + return EINVAL; +} + +/* Destroys netdev object 'name'. Netdev objects maintain a reference count + * which is incremented on netdev_open() and decremented on netdev_close(). + * If 'name' has a non-zero reference count, it will not destroy the object + * and return EBUSY. */ +int +netdev_destroy(const char *name) +{ + struct shash_node *node; + struct netdev_obj *netdev_obj; + + node = shash_find(&netdev_obj_shash, name); + if (!node) { + return ENODEV; + } + + netdev_obj = node->data; + if (netdev_obj->ref_cnt != 0) { + VLOG_WARN("attempt to destroy open netdev object (%d): %s", + netdev_obj->ref_cnt, name); + return EBUSY; + } + + shash_delete(&netdev_obj_shash, node); + netdev_obj->netdev_class->destroy(netdev_obj); + + return 0; +} + +/* Reconfigures the device object 'name' with 'args'. 'args' may be empty + * or NULL if none are needed. */ +int +netdev_reconfigure(const char *name, const struct shash *args) +{ + struct shash empty_args = SHASH_INITIALIZER(&empty_args); + struct netdev_obj *netdev_obj; + + if (!args) { + args = &empty_args; + } + + netdev_obj = shash_find_data(&netdev_obj_shash, name); + if (!netdev_obj) { + return ENODEV; + } + + if (netdev_obj->netdev_class->reconfigure) { + return netdev_obj->netdev_class->reconfigure(netdev_obj, args); + } + + return 0; +} + /* 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. @@ -133,37 +224,42 @@ netdev_wait(void) * the 'enum netdev_pseudo_ethertype' values to receive frames in one of those * categories. */ int -netdev_open(const char *name_, int ethertype, struct netdev **netdevp) +netdev_open(const char *name, int ethertype, struct netdev **netdevp) { - char *name = xstrdup(name_); - char *prefix, *suffix, *colon; + struct netdev_obj *netdev_obj; struct netdev *netdev = NULL; int error; int i; netdev_initialize(); - colon = strchr(name, ':'); - if (colon) { - *colon = '\0'; - prefix = name; - suffix = colon + 1; + + netdev_obj = shash_find_data(&netdev_obj_shash, name); + if (netdev_obj) { + netdev_obj->ref_cnt++; + error = netdev_obj->netdev_class->open(name, ethertype, &netdev); } else { - prefix = ""; - suffix = name; - } + /* Default to "system". */ + error = EAFNOSUPPORT; + for (i = 0; i < n_netdev_classes; i++) { + const struct netdev_class *class = netdev_classes[i]; + if (!strcmp(class->type, "system")) { + struct shash empty_args = SHASH_INITIALIZER(&empty_args); - for (i = 0; i < n_netdev_classes; i++) { - const struct netdev_class *class = netdev_classes[i]; - if (!strcmp(prefix, class->prefix)) { - error = class->open(name_, suffix, ethertype, &netdev); - goto exit; + /* Dynamically create the netdev object, but indicate + * that it should be destroyed when the the last user + * closes its handle. */ + error = class->create(name, "system", &empty_args, false); + if (!error) { + netdev_obj = shash_find_data(&netdev_obj_shash, name); + netdev_obj->ref_cnt++; + error = class->open(name, ethertype, &netdev); + } + break; + } } } - error = EAFNOSUPPORT; -exit: *netdevp = error ? NULL : netdev; - free(name); return error; } @@ -172,9 +268,24 @@ void netdev_close(struct netdev *netdev) { if (netdev) { - char *name; + struct netdev_obj *netdev_obj; + char *name = netdev->name; int error; + netdev_obj = shash_find_data(&netdev_obj_shash, name); + assert(netdev_obj); + if (netdev_obj->ref_cnt > 0) { + netdev_obj->ref_cnt--; + } else { + VLOG_WARN("netdev %s closed too many times", name); + } + + /* If the reference count for the netdev object is zero, and it + * was dynamically created by netdev_open(), destroy it. */ + if (!netdev_obj->ref_cnt && !netdev_obj->created) { + netdev_destroy(name); + } + /* Restore flags that we changed, if any. */ fatal_signal_block(); error = restore_flags(netdev); @@ -182,12 +293,11 @@ netdev_close(struct netdev *netdev) fatal_signal_unblock(); if (error) { VLOG_WARN("failed to restore network device flags on %s: %s", - netdev->name, strerror(error)); + name, strerror(error)); } /* Free. */ - name = netdev->name; - netdev->class->close(netdev); + netdev->netdev_class->close(netdev); free(name); } } @@ -231,7 +341,7 @@ netdev_enumerate(struct svec *svec) int retval = class->enumerate(svec); if (retval) { VLOG_WARN("failed to enumerate %s network devices: %s", - class->name, strerror(retval)); + class->type, strerror(retval)); if (!error) { error = retval; } @@ -261,8 +371,8 @@ netdev_recv(struct netdev *netdev, struct ofpbuf *buffer) assert(buffer->size == 0); assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN); - retval = netdev->class->recv(netdev, - buffer->data, ofpbuf_tailroom(buffer)); + retval = netdev->netdev_class->recv(netdev, + buffer->data, ofpbuf_tailroom(buffer)); if (retval >= 0) { COVERAGE_INC(netdev_received); buffer->size += retval; @@ -280,14 +390,14 @@ netdev_recv(struct netdev *netdev, struct ofpbuf *buffer) void netdev_recv_wait(struct netdev *netdev) { - netdev->class->recv_wait(netdev); + netdev->netdev_class->recv_wait(netdev); } /* Discards all packets waiting to be received from 'netdev'. */ int netdev_drain(struct netdev *netdev) { - return netdev->class->drain(netdev); + return netdev->netdev_class->drain(netdev); } /* Sends 'buffer' on 'netdev'. Returns 0 if successful, otherwise a positive @@ -302,7 +412,7 @@ netdev_drain(struct netdev *netdev) int netdev_send(struct netdev *netdev, const struct ofpbuf *buffer) { - int error = netdev->class->send(netdev, buffer->data, buffer->size); + int error = netdev->netdev_class->send(netdev, buffer->data, buffer->size); if (!error) { COVERAGE_INC(netdev_sent); } @@ -319,7 +429,7 @@ netdev_send(struct netdev *netdev, const struct ofpbuf *buffer) void netdev_send_wait(struct netdev *netdev) { - return netdev->class->send_wait(netdev); + return netdev->netdev_class->send_wait(netdev); } /* Attempts to set 'netdev''s MAC address to 'mac'. Returns 0 if successful, @@ -327,7 +437,7 @@ netdev_send_wait(struct netdev *netdev) int netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN]) { - return netdev->class->set_etheraddr(netdev, mac); + return netdev->netdev_class->set_etheraddr(netdev, mac); } /* Retrieves 'netdev''s MAC address. If successful, returns 0 and copies the @@ -336,7 +446,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->class->get_etheraddr(netdev, mac); + return netdev->netdev_class->get_etheraddr(netdev, mac); } /* Returns the name of the network device that 'netdev' represents, @@ -357,7 +467,7 @@ netdev_get_name(const struct netdev *netdev) int netdev_get_mtu(const struct netdev *netdev, int *mtup) { - int error = netdev->class->get_mtu(netdev, mtup); + int error = 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)); @@ -366,6 +476,21 @@ netdev_get_mtu(const struct netdev *netdev, int *mtup) return error; } +/* Returns the ifindex of 'netdev', if successful, as a positive number. On + * failure, returns a negative errno value. + * + * The desired semantics of the ifindex value are a combination of those + * specified by POSIX for if_nametoindex() and by SNMP for ifIndex. An ifindex + * 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. + */ +int +netdev_get_ifindex(const struct netdev *netdev) +{ + return netdev->netdev_class->get_ifindex(netdev); +} + /* 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 @@ -377,11 +502,56 @@ netdev_get_features(struct netdev *netdev, uint32_t *supported, uint32_t *peer) { uint32_t dummy[4]; - return netdev->class->get_features(netdev, - current ? current : &dummy[0], - advertised ? advertised : &dummy[1], - supported ? supported : &dummy[2], - peer ? peer : &dummy[3]); + int error; + + if (!current) { + current = &dummy[0]; + } + if (!advertised) { + advertised = &dummy[1]; + } + if (!supported) { + supported = &dummy[2]; + } + if (!peer) { + peer = &dummy[3]; + } + + error = netdev->netdev_class->get_features(netdev, current, advertised, + supported, peer); + 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 @@ -389,8 +559,8 @@ netdev_get_features(struct netdev *netdev, int netdev_set_advertisements(struct netdev *netdev, uint32_t advertise) { - return (netdev->class->set_advertisements - ? netdev->class->set_advertisements(netdev, advertise) + return (netdev->netdev_class->set_advertisements + ? netdev->netdev_class->set_advertisements(netdev, advertise) : EOPNOTSUPP); } @@ -414,8 +584,8 @@ netdev_get_in4(const struct netdev *netdev, struct in_addr netmask; int error; - error = (netdev->class->get_in4 - ? netdev->class->get_in4(netdev, &address, &netmask) + error = (netdev->netdev_class->get_in4 + ? netdev->netdev_class->get_in4(netdev, &address, &netmask) : EOPNOTSUPP); if (address_) { address_->s_addr = error ? 0 : address.s_addr; @@ -432,8 +602,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->class->set_in4 - ? netdev->class->set_in4(netdev, addr, mask) + return (netdev->netdev_class->set_in4 + ? netdev->netdev_class->set_in4(netdev, addr, mask) : EOPNOTSUPP); } @@ -443,8 +613,8 @@ int netdev_add_router(struct netdev *netdev, struct in_addr router) { COVERAGE_INC(netdev_add_router); - return (netdev->class->add_router - ? netdev->class->add_router(netdev, router) + return (netdev->netdev_class->add_router + ? netdev->netdev_class->add_router(netdev, router) : EOPNOTSUPP); } @@ -460,8 +630,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->class->get_next_hop - ? netdev->class->get_next_hop(host, next_hop, netdev_name) + int error = (netdev->netdev_class->get_next_hop + ? netdev->netdev_class->get_next_hop(host, next_hop, + netdev_name) : EOPNOTSUPP); if (error) { next_hop->s_addr = 0; @@ -487,8 +658,8 @@ netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6) struct in6_addr dummy; int error; - error = (netdev->class->get_in6 - ? netdev->class->get_in6(netdev, in6 ? in6 : &dummy) + error = (netdev->netdev_class->get_in6 + ? netdev->netdev_class->get_in6(netdev, in6 ? in6 : &dummy) : EOPNOTSUPP); if (error && in6) { memset(in6, 0, sizeof *in6); @@ -508,7 +679,8 @@ do_update_flags(struct netdev *netdev, enum netdev_flags off, enum netdev_flags old_flags; int error; - error = netdev->class->update_flags(netdev, off & ~on, on, &old_flags); + error = 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), @@ -581,8 +753,8 @@ int netdev_arp_lookup(const struct netdev *netdev, uint32_t ip, uint8_t mac[ETH_ADDR_LEN]) { - int error = (netdev->class->arp_lookup - ? netdev->class->arp_lookup(netdev, ip, mac) + int error = (netdev->netdev_class->arp_lookup + ? netdev->netdev_class->arp_lookup(netdev, ip, mac) : EOPNOTSUPP); if (error) { memset(mac, 0, ETH_ADDR_LEN); @@ -595,8 +767,8 @@ netdev_arp_lookup(const struct netdev *netdev, int netdev_get_carrier(const struct netdev *netdev, bool *carrier) { - int error = (netdev->class->get_carrier - ? netdev->class->get_carrier(netdev, carrier) + int error = (netdev->netdev_class->get_carrier + ? netdev->netdev_class->get_carrier(netdev, carrier) : EOPNOTSUPP); if (error) { *carrier = false; @@ -611,8 +783,8 @@ netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats) int error; COVERAGE_INC(netdev_get_stats); - error = (netdev->class->get_stats - ? netdev->class->get_stats(netdev, stats) + error = (netdev->netdev_class->get_stats + ? netdev->netdev_class->get_stats(netdev, stats) : EOPNOTSUPP); if (error) { memset(stats, 0xff, sizeof *stats); @@ -627,8 +799,9 @@ int netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate, uint32_t kbits_burst) { - return (netdev->class->set_policing - ? netdev->class->set_policing(netdev, kbits_rate, kbits_burst) + return (netdev->netdev_class->set_policing + ? netdev->netdev_class->set_policing(netdev, + kbits_rate, kbits_burst) : EOPNOTSUPP); } @@ -640,8 +813,8 @@ 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->class->get_vlan_vid - ? netdev->class->get_vlan_vid(netdev, vlan_vid) + int error = (netdev->netdev_class->get_vlan_vid + ? netdev->netdev_class->get_vlan_vid(netdev, vlan_vid) : ENOENT); if (error) { *vlan_vid = 0; @@ -677,21 +850,48 @@ exit: return netdev; } -/* Initializes 'netdev' as a netdev named 'name' of the specified 'class'. +/* Initializes 'netdev_obj' as a netdev object named 'name' of the + * specified 'netdev_class'. + * + * This function adds 'netdev_obj' to a netdev-owned shash, so it is + * very important that 'netdev_obj' only be freed after calling + * netdev_destroy(). */ +void +netdev_obj_init(struct netdev_obj *netdev_obj, const char *name, + const struct netdev_class *netdev_class, bool created) +{ + assert(!shash_find(&netdev_obj_shash, name)); + + netdev_obj->netdev_class = netdev_class; + netdev_obj->ref_cnt = 0; + netdev_obj->created = created; + shash_add(&netdev_obj_shash, name, netdev_obj); +} + +/* Initializes 'netdev' as a netdev named 'name' of the specified + * 'netdev_class'. * * This function adds 'netdev' to a netdev-owned linked list, so it is very * important that 'netdev' only be freed after calling netdev_close(). */ void netdev_init(struct netdev *netdev, const char *name, - const struct netdev_class *class) + const struct netdev_class *netdev_class) { - netdev->class = class; + netdev->netdev_class = netdev_class; netdev->name = xstrdup(name); netdev->save_flags = 0; netdev->changed_flags = 0; list_push_back(&netdev_list, &netdev->node); } +/* Returns the class type of 'netdev'. + * + * The caller must not free the returned value. */ +const char *netdev_get_type(const struct netdev *netdev) +{ + return netdev->netdev_class->type; +} + /* Initializes 'notifier' as a netdev notifier for 'netdev', for which * notification will consist of calling 'cb', with auxiliary data 'aux'. */ void @@ -729,7 +929,7 @@ netdev_monitor_destroy(struct netdev_monitor *monitor) SHASH_FOR_EACH (node, &monitor->polled_netdevs) { struct netdev_notifier *notifier = node->data; - notifier->netdev->class->poll_remove(notifier); + notifier->netdev->netdev_class->poll_remove(notifier); } shash_destroy(&monitor->polled_netdevs); @@ -759,11 +959,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->class->poll_add) + && netdev->netdev_class->poll_add) { struct netdev_notifier *notifier; - error = netdev->class->poll_add(netdev, netdev_monitor_cb, monitor, - ¬ifier); + error = 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); @@ -785,7 +985,7 @@ netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev) if (node) { /* Cancel future notifications. */ struct netdev_notifier *notifier = node->data; - netdev->class->poll_remove(notifier); + netdev->netdev_class->poll_remove(notifier); shash_delete(&monitor->polled_netdevs, node); /* Drop any pending notification. */ @@ -843,9 +1043,10 @@ 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->class->update_flags(netdev, - netdev->changed_flags & ~restore, - restore, &old_flags); + return netdev->netdev_class->update_flags(netdev, + netdev->changed_flags + & ~restore, + restore, &old_flags); } return 0; } @@ -853,7 +1054,7 @@ restore_flags(struct netdev *netdev) /* Retores all the flags on all network devices that we modified. Called from * a signal handler, so it does not attempt to report error conditions. */ static void -restore_all_flags(void *aux UNUSED) +restore_all_flags(void *aux OVS_UNUSED) { struct netdev *netdev; LIST_FOR_EACH (netdev, struct netdev, node, &netdev_list) {