static const struct netdev_class *netdev_classes[] = {
&netdev_linux_class,
&netdev_tap_class,
+ &netdev_gre_class,
};
-enum { N_NETDEV_CLASSES = ARRAY_SIZE(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);
* 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)
{
static int status = -1;
if (status < 0) {
- int i;
+ int i, j;
fatal_signal_add_hook(restore_all_flags, NULL, true);
status = 0;
- for (i = 0; i < N_NETDEV_CLASSES; i++) {
+ 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) {
+ if (!retval) {
+ 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;
}
return status;
}
netdev_run(void)
{
int i;
- for (i = 0; i < N_NETDEV_CLASSES; i++) {
+ for (i = 0; i < n_netdev_classes; i++) {
const struct netdev_class *class = netdev_classes[i];
if (class->run) {
class->run();
netdev_wait(void)
{
int i;
- for (i = 0; i < N_NETDEV_CLASSES; i++) {
+ for (i = 0; i < n_netdev_classes; i++) {
const struct netdev_class *class = netdev_classes[i];
if (class->wait) {
class->wait();
}
}
+/* 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.
* 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;
- error = netdev_initialize();
- if (error) {
- return error;
- }
+ 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;
}
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);
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);
}
svec_init(svec);
- error = netdev_initialize();
- if (error) {
- return error;
- }
+ netdev_initialize();
error = 0;
- for (i = 0; i < N_NETDEV_CLASSES; i++) {
+ for (i = 0; i < n_netdev_classes; i++) {
const struct netdev_class *class = netdev_classes[i];
if (class->enumerate) {
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;
}
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
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
: 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:
*
*
* - 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;
}
: 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).
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;
}
return netdev;
}
\f
+/* 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
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
git://git.onelab.eu / sliver-openvswitch.git / blobdiff