#include "bitmap.h"
#include "byte-order.h"
#include "classifier.h"
+#include "connectivity.h"
#include "connmgr.h"
#include "coverage.h"
#include "dynamic-string.h"
#include "pktbuf.h"
#include "poll-loop.h"
#include "random.h"
+#include "seq.h"
#include "shash.h"
#include "simap.h"
#include "smap.h"
{
size_t i;
+ sset_clear(types);
for (i = 0; i < n_ofproto_classes; i++) {
ofproto_classes[i]->enumerate_types(types);
}
ovs_rwlock_init(&ofproto->groups_rwlock);
hmap_init(&ofproto->groups);
ovs_mutex_unlock(&ofproto_mutex);
+ ofproto->ogf.capabilities = OFPGFC_CHAINING | OFPGFC_SELECT_LIVENESS |
+ OFPGFC_SELECT_WEIGHT;
+ ofproto->ogf.max_groups[OFPGT11_ALL] = OFPG_MAX;
+ ofproto->ogf.max_groups[OFPGT11_SELECT] = OFPG_MAX;
+ ofproto->ogf.max_groups[OFPGT11_INDIRECT] = OFPG_MAX;
+ ofproto->ogf.max_groups[OFPGT11_FF] = OFPG_MAX;
+ ofproto->ogf.actions[0] =
+ (1 << OFPAT11_OUTPUT) |
+ (1 << OFPAT11_COPY_TTL_OUT) |
+ (1 << OFPAT11_COPY_TTL_IN) |
+ (1 << OFPAT11_SET_MPLS_TTL) |
+ (1 << OFPAT11_DEC_MPLS_TTL) |
+ (1 << OFPAT11_PUSH_VLAN) |
+ (1 << OFPAT11_POP_VLAN) |
+ (1 << OFPAT11_PUSH_MPLS) |
+ (1 << OFPAT11_POP_MPLS) |
+ (1 << OFPAT11_SET_QUEUE) |
+ (1 << OFPAT11_GROUP) |
+ (1 << OFPAT11_SET_NW_TTL) |
+ (1 << OFPAT11_DEC_NW_TTL) |
+ (1 << OFPAT12_SET_FIELD);
+/* not supported:
+ * (1 << OFPAT13_PUSH_PBB) |
+ * (1 << OFPAT13_POP_PBB) */
error = ofproto->ofproto_class->construct(ofproto);
if (error) {
if (limit) {
n_handler_threads = limit;
} else {
- int n_proc = sysconf(_SC_NPROCESSORS_ONLN);
+ int n_proc = count_cpu_cores();
n_handler_threads = n_proc > 2 ? n_proc - 2 : 1;
}
}
? ofproto->ofproto_class->get_stp_port_status(ofport, s)
: EOPNOTSUPP);
}
+
+/* Retrieves STP port statistics of 'ofp_port' on 'ofproto' and stores it in
+ * 's'. If the 'enabled' member in 's' is false, then the other members
+ * are not meaningful.
+ *
+ * Returns 0 if successful, otherwise a positive errno value.*/
+int
+ofproto_port_get_stp_stats(struct ofproto *ofproto, ofp_port_t ofp_port,
+ struct ofproto_port_stp_stats *s)
+{
+ struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
+ if (!ofport) {
+ VLOG_WARN_RL(&rl, "%s: cannot get STP stats on nonexistent "
+ "port %"PRIu16, ofproto->name, ofp_port);
+ return ENODEV;
+ }
+
+ return (ofproto->ofproto_class->get_stp_port_stats
+ ? ofproto->ofproto_class->get_stp_port_stats(ofport, s)
+ : EOPNOTSUPP);
+}
\f
/* Queue DSCP configuration. */
}
table->max_flows = s->max_flows;
- ovs_rwlock_rdlock(&table->cls.rwlock);
+ ovs_rwlock_wrlock(&table->cls.rwlock);
if (classifier_count(&table->cls) > table->max_flows
&& table->eviction_fields) {
/* 'table' contains more flows than allowed. We might not be able to
break;
}
}
+
+ classifier_set_prefix_fields(&table->cls,
+ s->prefix_fields, s->n_prefix_fields);
+
ovs_rwlock_unlock(&table->cls.rwlock);
}
\f
int
ofproto_run(struct ofproto *p)
{
- struct sset changed_netdevs;
- const char *changed_netdev;
- struct ofport *ofport;
int error;
+ uint64_t new_seq;
error = p->ofproto_class->run(p);
if (error && error != EAGAIN) {
}
}
- /* Update OpenFlow port status for any port whose netdev has changed.
- *
- * Refreshing a given 'ofport' can cause an arbitrary ofport to be
- * destroyed, so it's not safe to update ports directly from the
- * HMAP_FOR_EACH loop, or even to use HMAP_FOR_EACH_SAFE. Instead, we
- * need this two-phase approach. */
- sset_init(&changed_netdevs);
- HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
- unsigned int change_seq = netdev_change_seq(ofport->netdev);
- if (ofport->change_seq != change_seq) {
- ofport->change_seq = change_seq;
- sset_add(&changed_netdevs, netdev_get_name(ofport->netdev));
+ new_seq = seq_read(connectivity_seq_get());
+ if (new_seq != p->change_seq) {
+ struct sset devnames;
+ const char *devname;
+ struct ofport *ofport;
+
+ /* Update OpenFlow port status for any port whose netdev has changed.
+ *
+ * Refreshing a given 'ofport' can cause an arbitrary ofport to be
+ * destroyed, so it's not safe to update ports directly from the
+ * HMAP_FOR_EACH loop, or even to use HMAP_FOR_EACH_SAFE. Instead, we
+ * need this two-phase approach. */
+ sset_init(&devnames);
+ HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
+ sset_add(&devnames, netdev_get_name(ofport->netdev));
}
+ SSET_FOR_EACH (devname, &devnames) {
+ update_port(p, devname);
+ }
+ sset_destroy(&devnames);
+
+ p->change_seq = new_seq;
}
- SSET_FOR_EACH (changed_netdev, &changed_netdevs) {
- update_port(p, changed_netdev);
- }
- sset_destroy(&changed_netdevs);
switch (p->state) {
case S_OPENFLOW:
void
ofproto_wait(struct ofproto *p)
{
- struct ofport *ofport;
-
p->ofproto_class->wait(p);
if (p->ofproto_class->port_poll_wait) {
p->ofproto_class->port_poll_wait(p);
}
-
- HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
- if (ofport->change_seq != netdev_change_seq(ofport->netdev)) {
- poll_immediate_wake();
- }
- }
+ seq_wait(connectivity_seq_get(), p->change_seq);
switch (p->state) {
case S_OPENFLOW:
update_port(ofproto, netdev_name);
}
if (ofp_portp) {
- 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);
+ *ofp_portp = OFPP_NONE;
+ if (!error) {
+ struct ofproto_port ofproto_port;
+
+ error = ofproto_port_query_by_name(ofproto,
+ netdev_get_name(netdev),
+ &ofproto_port);
+ if (!error) {
+ *ofp_portp = ofproto_port.ofp_port;
+ ofproto_port_destroy(&ofproto_port);
+ }
+ }
}
return error;
}
/* Search for a free OpenFlow port number. We try not to
* immediately reuse them to prevent problems due to old
- * flows. */
+ * flows.
+ *
+ * We limit the automatically assigned port numbers to the lower half
+ * of the port range, to reserve the upper half for assignment by
+ * controllers. */
for (;;) {
- if (++ofproto->alloc_port_no >= ofproto->max_ports) {
+ if (++ofproto->alloc_port_no >= MIN(ofproto->max_ports, 32768)) {
ofproto->alloc_port_no = 1;
}
last_used_at = ofport_get_usage(ofproto,
}
ofport->ofproto = p;
ofport->netdev = netdev;
- ofport->change_seq = netdev_change_seq(netdev);
ofport->pp = *pp;
ofport->ofp_port = pp->port_no;
ofport->created = time_msec();
* Don't close the old netdev yet in case port_modified has to
* remove a retained reference to it.*/
port->netdev = netdev;
- port->change_seq = netdev_change_seq(netdev);
if (port->ofproto->ofproto_class->port_modified) {
port->ofproto->ofproto_class->port_modified(port);
goto exit_free_ofpacts;
}
-
/* Get payload. */
if (po.buffer_id != UINT32_MAX) {
error = ofconn_pktbuf_retrieve(ofconn, po.buffer_id, &payload, NULL);
ots = xcalloc(p->n_tables, sizeof *ots);
for (i = 0; i < p->n_tables; i++) {
ots[i].table_id = i;
- sprintf(ots[i].name, "table%zu", i);
+ sprintf(ots[i].name, "table%"PRIuSIZE, i);
ots[i].match = htonll(OFPXMT13_MASK);
ots[i].wildcards = htonll(OFPXMT13_MASK);
ots[i].write_actions = htonl(OFPAT11_OUTPUT);
oftable_init(struct oftable *table)
{
memset(table, 0, sizeof *table);
- classifier_init(&table->cls);
+ classifier_init(&table->cls, flow_segment_u32s);
table->max_flows = UINT_MAX;
}