/*
- * 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.
int retval;
sprintf(devname, "dp%d", i);
- retval = dpif_open(devname, &dpif);
+ retval = dpif_open(devname, "system", &dpif);
if (!retval) {
svec_add(all_dps, devname);
- dpif_close(dpif);
+ dpif_uninit(dpif, true);
} else if (retval != ENODEV && !error) {
error = retval;
}
}
static int
-dpif_linux_open(const char *name UNUSED, char *suffix, bool create,
+dpif_linux_open(const char *name, const char *type OVS_UNUSED, bool create,
struct dpif **dpifp)
{
int minor;
&& isdigit((unsigned char)name[2]) ? atoi(name + 2) : -1;
if (create) {
if (minor >= 0) {
- return create_minor(suffix, minor, dpifp);
+ return create_minor(name, minor, dpifp);
} else {
/* Scan for unused minor number. */
for (minor = 0; minor < ODP_MAX; minor++) {
- int error = create_minor(suffix, minor, dpifp);
+ int error = create_minor(name, minor, dpifp);
if (error != EBUSY) {
return error;
}
int error;
if (minor < 0) {
- error = lookup_minor(suffix, &minor);
+ error = lookup_minor(name, &minor);
if (error) {
return error;
}
VLOG_WARN("%s: probe returned unexpected error: %s",
dpif_name(*dpifp), strerror(error));
}
- dpif_close(*dpifp);
+ dpif_uninit(*dpifp, true);
return error;
}
}
static int
-dpif_linux_delete(struct dpif *dpif_)
+dpif_linux_destroy(struct dpif *dpif_)
{
return do_ioctl(dpif_, ODP_DP_DESTROY, NULL);
}
static int
dpif_linux_get_stats(const struct dpif *dpif_, struct odp_stats *stats)
{
+ memset(stats, 0, sizeof *stats);
return do_ioctl(dpif_, ODP_DP_STATS, stats);
}
return do_ioctl(dpif_, ODP_SET_LISTEN_MASK, &listen_mask);
}
+static int
+dpif_linux_get_sflow_probability(const struct dpif *dpif_,
+ uint32_t *probability)
+{
+ return do_ioctl(dpif_, ODP_GET_SFLOW_PROBABILITY, probability);
+}
+
+static int
+dpif_linux_set_sflow_probability(struct dpif *dpif_, uint32_t probability)
+{
+ return do_ioctl(dpif_, ODP_SET_SFLOW_PROBABILITY, &probability);
+}
+
static int
dpif_linux_recv(struct dpif *dpif_, struct ofpbuf **bufp)
{
}
const struct dpif_class dpif_linux_class = {
- "", /* This is the default class. */
- "linux",
+ "system",
NULL,
NULL,
dpif_linux_enumerate,
dpif_linux_open,
dpif_linux_close,
dpif_linux_get_all_names,
- dpif_linux_delete,
+ dpif_linux_destroy,
dpif_linux_get_stats,
dpif_linux_get_drop_frags,
dpif_linux_set_drop_frags,
dpif_linux_execute,
dpif_linux_recv_get_mask,
dpif_linux_recv_set_mask,
+ dpif_linux_get_sflow_probability,
+ dpif_linux_set_sflow_probability,
dpif_linux_recv,
dpif_linux_recv_wait,
};
struct stat s;
char fn[128];
+ *fnp = NULL;
+
major = get_openvswitch_major();
if (major < 0) {
return -major;
}
dev = makedev(major, minor);
- *fnp = NULL;
sprintf(fn, "%s/dp%d", dirname, minor);
if (!stat(fn, &s)) {
if (!S_ISCHR(s.st_mode)) {
}
}
+ fclose(file);
+
VLOG_ERR("%s: %s major not found (is the module loaded?)", fn, target);
return -ENODEV;
}
finish_open(struct dpif *dpif_, const char *local_ifname)
{
struct dpif_linux *dpif = dpif_linux_cast(dpif_);
- dpif->local_ifname = strdup(local_ifname);
+ dpif->local_ifname = xstrdup(local_ifname);
dpif->local_ifindex = if_nametoindex(local_ifname);
if (!dpif->local_ifindex) {
int error = errno;
- dpif_close(dpif_);
+ dpif_uninit(dpif_, true);
VLOG_WARN("could not get ifindex of %s device: %s",
local_ifname, strerror(errno));
return error;
if (!error) {
error = finish_open(*dpifp, name);
} else {
- dpif_close(*dpifp);
+ dpif_uninit(*dpifp, true);
}
}
return error;