X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fnetdev.c;h=6c87bd4b346a11a621c3ebab4cfac4cffbdccc63;hb=2d2d6d4a71776813f8d2fd1af1051f22b836befc;hp=dcb63fa02046e7477192323a985e1b7b355552db;hpb=8fef8c7121222233075a03d57db7e0b48d5f6be5;p=openvswitch diff --git a/lib/netdev.c b/lib/netdev.c index dcb63fa0..6c87bd4b 100644 --- a/lib/netdev.c +++ b/lib/netdev.c @@ -42,9 +42,13 @@ static const struct netdev_class *netdev_classes[] = { &netdev_linux_class, &netdev_tap_class, + &netdev_gre_class, }; 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,11 +83,13 @@ 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; } } + } else { + netdev_classes[j++] = class; } } n_netdev_classes = j; @@ -122,6 +129,94 @@ 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 netdev object with %d open handles: %s", + netdev_obj->ref_cnt, name); +#if 0 /* Temp hack */ + return EBUSY; +#endif + } + + shash_delete(&netdev_obj_shash, node); + netdev_obj->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->class->reconfigure) { + return netdev_obj->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. @@ -131,35 +226,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) { + error = netdev_obj->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) { + error = class->open(name, ethertype, &netdev); + netdev_obj = shash_find_data(&netdev_obj_shash, name); + } + break; + } } } - error = EAFNOSUPPORT; + if (!error) { + netdev_obj->ref_cnt++; + } -exit: *netdevp = error ? NULL : netdev; return error; } @@ -169,9 +271,31 @@ 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); +#if 0 + assert(netdev_obj); +#else + if (netdev_obj) { +#endif + 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); + } +#if 1 + } +#endif + /* Restore flags that we changed, if any. */ fatal_signal_block(); error = restore_flags(netdev); @@ -179,11 +303,10 @@ 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); free(name); } @@ -228,7 +351,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; } @@ -363,6 +486,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->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 @@ -374,11 +512,27 @@ 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->class->get_features(netdev, current, advertised, supported, + peer); + if (error) { + *current = *advertised = *supported = *peer = 0; + } + return error; } /* Set the features advertised by 'netdev' to 'advertise'. Returns 0 if @@ -391,9 +545,9 @@ netdev_set_advertisements(struct netdev *netdev, uint32_t advertise) : EOPNOTSUPP); } -/* If 'netdev' has an assigned IPv4 address, sets '*in4' to that address and - * returns 0. Otherwise, returns a positive errno value and sets '*in4' to 0 - * (INADDR_ANY). +/* If 'netdev' has an assigned IPv4 address, sets '*address' to that address + * and '*netmask' to its netmask and returns 0. Otherwise, returns a positive + * errno value and sets '*address' to 0 (INADDR_ANY). * * The following error values have well-defined meanings: * @@ -401,18 +555,24 @@ netdev_set_advertisements(struct netdev *netdev, uint32_t advertise) * * - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'. * - * 'in4' may be null, in which case the address itself is not reported. */ + * '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, struct in_addr *in4) +netdev_get_in4(const struct netdev *netdev, + struct in_addr *address_, struct in_addr *netmask_) { - struct in_addr dummy; + struct in_addr address; + struct in_addr netmask; int error; error = (netdev->class->get_in4 - ? netdev->class->get_in4(netdev, in4 ? in4 : &dummy) + ? netdev->class->get_in4(netdev, &address, &netmask) : EOPNOTSUPP); - if (error && in4) { - in4->s_addr = 0; + if (address_) { + address_->s_addr = error ? 0 : address.s_addr; + } + if (netmask_) { + netmask_->s_addr = error ? 0 : netmask.s_addr; } return error; } @@ -439,6 +599,28 @@ netdev_add_router(struct netdev *netdev, struct in_addr router) : EOPNOTSUPP); } +/* Looks up the next hop for 'host' for the TCP/IP stack that corresponds to + * 'netdev'. If a route cannot not be determined, sets '*next_hop' to 0, + * '*netdev_name' to null, and returns a positive errno value. Otherwise, if a + * next hop is found, stores the next hop gateway's address (0 if 'host' is on + * a directly connected network) in '*next_hop' and a copy of the name of the + * device to reach 'host' in '*netdev_name', and returns 0. The caller is + * responsible for freeing '*netdev_name' (by calling free()). */ +int +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) + : EOPNOTSUPP); + if (error) { + next_hop->s_addr = 0; + *netdev_name = NULL; + } + return error; +} + /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address and * returns 0. Otherwise, returns a positive errno value and sets '*in6' to * all-zero-bits (in6addr_any). @@ -633,7 +815,7 @@ netdev_find_dev_by_in4(const struct in_addr *in4) struct in_addr dev_in4; if (!netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev) - && !netdev_get_in4(netdev, &dev_in4) + && !netdev_get_in4(netdev, &dev_in4, NULL) && dev_in4.s_addr == in4->s_addr) { goto exit; } @@ -646,6 +828,41 @@ exit: return netdev; } +/* Initializes 'netdev_obj' as a netdev object named 'name' of the + * specified '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 *class, bool created) +{ + assert(!shash_find(&netdev_obj_shash, name)); + + netdev_obj->class = class; + netdev_obj->ref_cnt = 0; + netdev_obj->created = created; + netdev_obj->name = xstrdup(name); + shash_add(&netdev_obj_shash, name, netdev_obj); +} + +/* Returns the class type of 'netdev_obj'. + * + * The caller must not free the returned value. */ +const char *netdev_obj_get_type(const struct netdev_obj *netdev_obj) +{ + return netdev_obj->class->type; +} + +/* Returns the name of 'netdev_obj'. + * + * The caller must not free the returned value. */ +const char *netdev_obj_get_name(const struct netdev_obj *netdev_obj) +{ + return netdev_obj->name; +} + /* Initializes 'netdev' as a netdev named 'name' of the specified 'class'. * * This function adds 'netdev' to a netdev-owned linked list, so it is very @@ -661,6 +878,14 @@ netdev_init(struct netdev *netdev, const char *name, 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->class->type; +} + /* Initializes 'notifier' as a netdev notifier for 'netdev', for which * notification will consist of calling 'cb', with auxiliary data 'aux'. */ void