/* Map from datapath name to struct ofproto, for use by unixctl commands. */
static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos);
+/* Initial mappings of port to OpenFlow number mappings. */
+static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports);
+
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
/* Must be called to initialize the ofproto library.
void
ofproto_init(const struct shash *iface_hints)
{
+ struct shash_node *node;
size_t i;
ofproto_class_register(&ofproto_dpif_class);
+ /* Make a local copy, since we don't own 'iface_hints' elements. */
+ SHASH_FOR_EACH(node, iface_hints) {
+ const struct iface_hint *orig_hint = node->data;
+ struct iface_hint *new_hint = xmalloc(sizeof *new_hint);
+ const char *br_type = ofproto_normalize_type(orig_hint->br_type);
+
+ new_hint->br_name = xstrdup(orig_hint->br_name);
+ new_hint->br_type = xstrdup(br_type);
+ new_hint->ofp_port = orig_hint->ofp_port;
+
+ shash_add(&init_ofp_ports, node->name, new_hint);
+ }
+
for (i = 0; i < n_ofproto_classes; i++) {
- ofproto_classes[i]->init(iface_hints);
+ ofproto_classes[i]->init(&init_ofp_ports);
}
}
const struct ofproto_class *class;
struct ofproto *ofproto;
int error;
+ int i;
*ofprotop = NULL;
ofproto->frag_handling = OFPC_FRAG_NORMAL;
hmap_init(&ofproto->ports);
shash_init(&ofproto->port_by_name);
+ simap_init(&ofproto->ofp_requests);
ofproto->max_ports = OFPP_MAX;
ofproto->tables = NULL;
ofproto->n_tables = 0;
return error;
}
+ /* The "max_ports" member should have been set by ->construct(ofproto).
+ * Port 0 is not a valid OpenFlow port, so mark that as unavailable. */
+ ofproto->ofp_port_ids = bitmap_allocate(ofproto->max_ports);
+ bitmap_set1(ofproto->ofp_port_ids, 0);
+
+ /* Check that hidden tables, if any, are at the end. */
assert(ofproto->n_tables);
+ for (i = 0; i + 1 < ofproto->n_tables; i++) {
+ enum oftable_flags flags = ofproto->tables[i].flags;
+ enum oftable_flags next_flags = ofproto->tables[i + 1].flags;
+
+ assert(!(flags & OFTABLE_HIDDEN) || next_flags & OFTABLE_HIDDEN);
+ }
ofproto->datapath_id = pick_datapath_id(ofproto);
init_ports(ofproto);
void
ofproto_set_controllers(struct ofproto *p,
const struct ofproto_controller *controllers,
- size_t n_controllers)
+ size_t n_controllers, uint32_t allowed_versions)
{
- connmgr_set_controllers(p->connmgr, controllers, n_controllers);
+ connmgr_set_controllers(p->connmgr, controllers, n_controllers,
+ allowed_versions);
}
void
free(ofproto->dp_desc);
hmap_destroy(&ofproto->ports);
shash_destroy(&ofproto->port_by_name);
+ bitmap_free(ofproto->ofp_port_ids);
+ simap_destroy(&ofproto->ofp_requests);
OFPROTO_FOR_EACH_TABLE (table, ofproto) {
oftable_destroy(table);
}
}
+int
+ofproto_type_run(const char *datapath_type)
+{
+ const struct ofproto_class *class;
+ int error;
+
+ datapath_type = ofproto_normalize_type(datapath_type);
+ class = ofproto_class_find__(datapath_type);
+
+ error = class->type_run ? class->type_run(datapath_type) : 0;
+ if (error && error != EAGAIN) {
+ VLOG_ERR_RL(&rl, "%s: type_run failed (%s)",
+ datapath_type, strerror(error));
+ }
+ return error;
+}
+
+int
+ofproto_type_run_fast(const char *datapath_type)
+{
+ const struct ofproto_class *class;
+ int error;
+
+ datapath_type = ofproto_normalize_type(datapath_type);
+ class = ofproto_class_find__(datapath_type);
+
+ error = class->type_run_fast ? class->type_run_fast(datapath_type) : 0;
+ if (error && error != EAGAIN) {
+ VLOG_ERR_RL(&rl, "%s: type_run_fast failed (%s)",
+ datapath_type, strerror(error));
+ }
+ return error;
+}
+
+void
+ofproto_type_wait(const char *datapath_type)
+{
+ const struct ofproto_class *class;
+
+ datapath_type = ofproto_normalize_type(datapath_type);
+ class = ofproto_class_find__(datapath_type);
+
+ if (class->type_wait) {
+ class->type_wait(datapath_type);
+ }
+}
+
int
ofproto_run(struct ofproto *p)
{
return dump->error == EOF ? 0 : dump->error;
}
+/* Returns the type to pass to netdev_open() when a datapath of type
+ * 'datapath_type' has a port of type 'port_type', for a few special
+ * cases when a netdev type differs from a port type. For example, when
+ * using the userspace datapath, a port of type "internal" needs to be
+ * opened as "tap".
+ *
+ * Returns either 'type' itself or a string literal, which must not be
+ * freed. */
+const char *
+ofproto_port_open_type(const char *datapath_type, const char *port_type)
+{
+ const struct ofproto_class *class;
+
+ datapath_type = ofproto_normalize_type(datapath_type);
+ class = ofproto_class_find__(datapath_type);
+ if (!class) {
+ return port_type;
+ }
+
+ return (class->port_open_type
+ ? class->port_open_type(datapath_type, port_type)
+ : port_type);
+}
+
/* Attempts to add 'netdev' as a port on 'ofproto'. If 'ofp_portp' is
* non-null and '*ofp_portp' is not OFPP_NONE, attempts to use that as
* the port's OpenFlow port number.
uint16_t ofp_port = ofp_portp ? *ofp_portp : OFPP_NONE;
int error;
- error = ofproto->ofproto_class->port_add(ofproto, netdev, &ofp_port);
+ error = ofproto->ofproto_class->port_add(ofproto, netdev);
if (!error) {
- update_port(ofproto, netdev_get_name(netdev));
+ const char *netdev_name = netdev_get_name(netdev);
+
+ simap_put(&ofproto->ofp_requests, netdev_name, ofp_port);
+ update_port(ofproto, netdev_name);
}
if (ofp_portp) {
- *ofp_portp = error ? OFPP_NONE : ofp_port;
+ struct ofproto_port ofproto_port;
+
+ ofproto_port_query_by_name(ofproto, netdev_get_name(netdev),
+ &ofproto_port);
+ *ofp_portp = error ? OFPP_NONE : ofproto_port.ofp_port;
+ ofproto_port_destroy(&ofproto_port);
}
return error;
}
{
struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
const char *name = ofport ? netdev_get_name(ofport->netdev) : "<unknown>";
+ struct simap_node *ofp_request_node;
int error;
+ ofp_request_node = simap_find(&ofproto->ofp_requests, name);
+ if (ofp_request_node) {
+ simap_delete(&ofproto->ofp_requests, ofp_request_node);
+ }
+
error = ofproto->ofproto_class->port_del(ofproto, ofp_port);
if (!error && ofport) {
/* 'name' is the netdev's name and update_port() is going to close the
sset_destroy(&devnames);
}
+static uint16_t
+alloc_ofp_port(struct ofproto *ofproto, const char *netdev_name)
+{
+ uint16_t ofp_port;
+
+ ofp_port = simap_get(&ofproto->ofp_requests, netdev_name);
+ ofp_port = ofp_port ? ofp_port : OFPP_NONE;
+
+ if (ofp_port >= ofproto->max_ports
+ || bitmap_is_set(ofproto->ofp_port_ids, ofp_port)) {
+ bool retry = ofproto->alloc_port_no ? true : false;
+
+ /* Search for a free OpenFlow port number. We try not to
+ * immediately reuse them to prevent problems due to old
+ * flows. */
+ while (ofp_port >= ofproto->max_ports) {
+ for (ofproto->alloc_port_no++;
+ ofproto->alloc_port_no < ofproto->max_ports; ) {
+ if (!bitmap_is_set(ofproto->ofp_port_ids,
+ ofproto->alloc_port_no)) {
+ ofp_port = ofproto->alloc_port_no;
+ break;
+ }
+ }
+ if (ofproto->alloc_port_no >= ofproto->max_ports) {
+ if (retry) {
+ ofproto->alloc_port_no = 0;
+ retry = false;
+ } else {
+ return OFPP_NONE;
+ }
+ }
+ }
+ }
+
+ bitmap_set1(ofproto->ofp_port_ids, ofp_port);
+ return ofp_port;
+}
+
+static void
+dealloc_ofp_port(const struct ofproto *ofproto, uint16_t ofp_port)
+{
+ bitmap_set0(ofproto->ofp_port_ids, ofp_port);
+}
+
/* Opens and returns a netdev for 'ofproto_port' in 'ofproto', or a null
* pointer if the netdev cannot be opened. On success, also fills in
* 'opp'. */
static struct netdev *
-ofport_open(const struct ofproto *ofproto,
- const struct ofproto_port *ofproto_port,
+ofport_open(struct ofproto *ofproto,
+ struct ofproto_port *ofproto_port,
struct ofputil_phy_port *pp)
{
enum netdev_flags flags;
return NULL;
}
+ if (ofproto_port->ofp_port == OFPP_NONE) {
+ if (!strcmp(ofproto->name, ofproto_port->name)) {
+ ofproto_port->ofp_port = OFPP_LOCAL;
+ } else {
+ ofproto_port->ofp_port = alloc_ofp_port(ofproto,
+ ofproto_port->name);
+ }
+ }
pp->port_no = ofproto_port->ofp_port;
netdev_get_etheraddr(netdev, pp->hw_addr);
ovs_strlcpy(pp->name, ofproto_port->name, sizeof pp->name);
pp->state = netdev_get_carrier(netdev) ? 0 : OFPUTIL_PS_LINK_DOWN;
netdev_get_features(netdev, &pp->curr, &pp->advertised,
&pp->supported, &pp->peer);
- pp->curr_speed = netdev_features_to_bps(pp->curr);
- pp->max_speed = netdev_features_to_bps(pp->supported);
+ pp->curr_speed = netdev_features_to_bps(pp->curr, 0);
+ pp->max_speed = netdev_features_to_bps(pp->supported, 0);
return netdev;
}
ofport_destroy(struct ofport *port)
{
if (port) {
+ dealloc_ofp_port(port->ofproto, port->ofp_port);
port->ofproto->ofproto_class->port_destruct(port);
ofport_destroy__(port);
}
{
struct ofproto_port_dump dump;
struct ofproto_port ofproto_port;
+ struct shash_node *node, *next;
OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, p) {
- uint16_t ofp_port = ofproto_port.ofp_port;
- if (ofproto_get_port(p, ofp_port)) {
- VLOG_WARN_RL(&rl, "%s: ignoring duplicate port %"PRIu16" "
- "in datapath", p->name, ofp_port);
- } else if (shash_find(&p->port_by_name, ofproto_port.name)) {
+ const char *name = ofproto_port.name;
+
+ if (shash_find(&p->port_by_name, name)) {
VLOG_WARN_RL(&rl, "%s: ignoring duplicate device %s in datapath",
- p->name, ofproto_port.name);
+ p->name, name);
} else {
struct ofputil_phy_port pp;
struct netdev *netdev;
+ /* Check if an OpenFlow port number had been requested. */
+ node = shash_find(&init_ofp_ports, name);
+ if (node) {
+ const struct iface_hint *iface_hint = node->data;
+ simap_put(&p->ofp_requests, name, iface_hint->ofp_port);
+ }
+
netdev = ofport_open(p, &ofproto_port, &pp);
if (netdev) {
ofport_install(p, netdev, &pp);
}
}
+ SHASH_FOR_EACH_SAFE(node, next, &init_ofp_ports) {
+ const struct iface_hint *iface_hint = node->data;
+
+ if (!strcmp(iface_hint->br_name, p->name)) {
+ free(iface_hint->br_name);
+ free(iface_hint->br_type);
+ shash_delete(&init_ofp_ports, node);
+ }
+ }
+
return 0;
}
struct ofport *port;
bool arp_match_ip;
struct ofpbuf *b;
+ int n_tables;
+ int i;
ofproto->ofproto_class->get_features(ofproto, &arp_match_ip,
&features.actions);
assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */
+ /* Count only non-hidden tables in the number of tables. (Hidden tables,
+ * if present, are always at the end.) */
+ n_tables = ofproto->n_tables;
+ for (i = 0; i < ofproto->n_tables; i++) {
+ if (ofproto->tables[i].flags & OFTABLE_HIDDEN) {
+ n_tables = i;
+ break;
+ }
+ }
+
features.datapath_id = ofproto->datapath_id;
features.n_buffers = pktbuf_capacity();
- features.n_tables = ofproto->n_tables;
+ features.n_tables = n_tables;
features.capabilities = (OFPUTIL_C_FLOW_STATS | OFPUTIL_C_TABLE_STATS |
OFPUTIL_C_PORT_STATS | OFPUTIL_C_QUEUE_STATS);
if (arp_match_ip) {
struct ofproto *p = ofconn_get_ofproto(ofconn);
struct ofp12_table_stats *ots;
struct ofpbuf *msg;
+ int n_tables;
size_t i;
/* Set up default values.
p->ofproto_class->get_tables(p, ots);
+ /* Post-process the tables, dropping hidden tables. */
+ n_tables = p->n_tables;
for (i = 0; i < p->n_tables; i++) {
const struct oftable *table = &p->tables[i];
+ if (table->flags & OFTABLE_HIDDEN) {
+ n_tables = i;
+ break;
+ }
+
if (table->name) {
ovs_strzcpy(ots[i].name, table->name, sizeof ots[i].name);
}
}
}
- msg = ofputil_encode_table_stats_reply(ots, p->n_tables, request);
+ msg = ofputil_encode_table_stats_reply(ots, n_tables, request);
ofconn_send_reply(ofconn, msg);
free(ots);
projects / openvswitch / blobdiff