#include "sflow_api.h"
-enum {
- TABLEID_HASH = 0,
- TABLEID_CLASSIFIER = 1
-};
-
-
struct ofport {
struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */
struct netdev *netdev;
bool need_revalidate;
long long int next_expiration;
struct tag_set revalidate_set;
- bool tun_id_from_cookie;
+ int flow_format; /* One of NXFF_*. */
/* OpenFlow connections. */
struct hmap controllers; /* Controller "struct ofconn"s. */
p->need_revalidate = false;
p->next_expiration = time_msec() + 1000;
tag_set_init(&p->revalidate_set);
+ p->flow_format = NXFF_OPENFLOW10;
/* Initialize OpenFlow connections. */
list_init(&p->all_conns);
ofproto_delete_flow(struct ofproto *ofproto, const struct flow *flow,
uint32_t wildcards, unsigned int priority)
{
+ struct cls_rule target;
struct rule *rule;
+ cls_rule_from_flow(flow, wildcards, priority, &target);
rule = rule_from_cls_rule(classifier_find_rule_exactly(&ofproto->cls,
- flow, wildcards,
- priority));
+ &target));
if (rule) {
rule_remove(ofproto, rule);
}
}
}
-static void
-send_error(const struct ofconn *ofconn, const struct ofp_header *oh,
- int error, const void *data, size_t len)
-{
- struct ofpbuf *buf;
- struct ofp_error_msg *oem;
-
- if (!(error >> 16)) {
- VLOG_WARN_RL(&rl, "not sending bad error code %d to controller",
- error);
- return;
- }
-
- COVERAGE_INC(ofproto_error);
- oem = make_openflow_xid(len + sizeof *oem, OFPT_ERROR,
- oh ? oh->xid : 0, &buf);
- oem->type = htons((unsigned int) error >> 16);
- oem->code = htons(error & 0xffff);
- memcpy(oem->data, data, len);
- queue_tx(buf, ofconn, ofconn->reply_counter);
-}
-
static void
send_error_oh(const struct ofconn *ofconn, const struct ofp_header *oh,
int error)
{
- size_t oh_length = ntohs(oh->length);
- send_error(ofconn, oh, error, oh, MIN(oh_length, 64));
+ struct ofpbuf *buf = make_ofp_error_msg(error, oh);
+ if (buf) {
+ COVERAGE_INC(ofproto_error);
+ queue_tx(buf, ofconn, ofconn->reply_counter);
+ }
}
static void
lookup_valid_rule(struct ofproto *ofproto, const struct flow *flow)
{
struct rule *rule;
- rule = rule_from_cls_rule(classifier_lookup(&ofproto->cls, flow));
+ rule = rule_from_cls_rule(classifier_lookup(&ofproto->cls, flow,
+ CLS_INC_ALL));
/* The rule we found might not be valid, since we could be in need of
* revalidation. If it is not valid, don't return it. */
{
struct ofp_table_stats *ots;
struct ofpbuf *msg;
- struct odp_stats dpstats;
- int n_exact, n_subrules, n_wild;
struct rule *rule;
+ int n_rules;
msg = start_stats_reply(request, sizeof *ots * 2);
- /* Count rules of various kinds. */
- n_subrules = 0;
+ /* Count rules other than subrules. */
+ n_rules = classifier_count(&p->cls);
CLASSIFIER_FOR_EACH_EXACT_RULE (rule, cr, &p->cls) {
if (rule->super) {
- n_subrules++;
+ n_rules--;
}
}
- n_exact = classifier_count_exact(&p->cls) - n_subrules;
- n_wild = classifier_count(&p->cls) - classifier_count_exact(&p->cls);
-
- /* Hash table. */
- dpif_get_dp_stats(p->dpif, &dpstats);
- ots = append_stats_reply(sizeof *ots, ofconn, &msg);
- memset(ots, 0, sizeof *ots);
- ots->table_id = TABLEID_HASH;
- strcpy(ots->name, "hash");
- ots->wildcards = htonl(0);
- ots->max_entries = htonl(dpstats.max_capacity);
- ots->active_count = htonl(n_exact);
- ots->lookup_count = htonll(dpstats.n_frags + dpstats.n_hit +
- dpstats.n_missed);
- ots->matched_count = htonll(dpstats.n_hit); /* XXX */
/* Classifier table. */
ots = append_stats_reply(sizeof *ots, ofconn, &msg);
memset(ots, 0, sizeof *ots);
- ots->table_id = TABLEID_CLASSIFIER;
strcpy(ots->name, "classifier");
- ots->wildcards = p->tun_id_from_cookie ? htonl(OVSFW_ALL)
- : htonl(OFPFW_ALL);
- ots->max_entries = htonl(65536);
- ots->active_count = htonl(n_wild);
+ ots->wildcards = (p->flow_format == NXFF_OPENFLOW10
+ ? htonl(OFPFW_ALL) : htonl(OVSFW_ALL));
+ ots->max_entries = htonl(1024 * 1024); /* An arbitrary big number. */
+ ots->active_count = htonl(n_rules);
ots->lookup_count = htonll(0); /* XXX */
ots->matched_count = htonll(0); /* XXX */
ofs = append_stats_reply(len, cbdata->ofconn, &cbdata->msg);
ofs->length = htons(len);
- ofs->table_id = rule->cr.wc.wildcards ? TABLEID_CLASSIFIER : TABLEID_HASH;
+ ofs->table_id = 0;
ofs->pad = 0;
flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards,
- cbdata->ofproto->tun_id_from_cookie, &ofs->match);
+ cbdata->ofproto->flow_format, &ofs->match);
ofs->duration_sec = htonl(sec);
ofs->duration_nsec = htonl(msec * 1000000);
ofs->cookie = rule->flow_cookie;
static int
table_id_to_include(uint8_t table_id)
{
- return (table_id == TABLEID_HASH ? CLS_INC_EXACT
- : table_id == TABLEID_CLASSIFIER ? CLS_INC_WILD
- : table_id == 0xff ? CLS_INC_ALL
- : 0);
+ return table_id == 0 || table_id == 0xff ? CLS_INC_ALL : 0;
}
static int
cbdata.ofconn = ofconn;
cbdata.out_port = fsr->out_port;
cbdata.msg = start_stats_reply(osr, 1024);
- cls_rule_from_match(&fsr->match, 0, false, 0, &target);
+ cls_rule_from_match(&fsr->match, 0, NXFF_OPENFLOW10, 0, &target);
classifier_for_each_match(&p->cls, &target,
table_id_to_include(fsr->table_id),
flow_stats_cb, &cbdata);
query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards,
- cbdata->ofproto->tun_id_from_cookie, &match);
+ cbdata->ofproto->flow_format, &match);
ds_put_format(results, "duration=%llds, ",
(time_msec() - rule->created) / 1000);
cbdata.ofproto = p;
cbdata.results = results;
- cls_rule_from_match(&match, 0, false, 0, &target);
+ cls_rule_from_match(&match, 0, NXFF_OPENFLOW10, 0, &target);
classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
flow_stats_ds_cb, &cbdata);
}
cbdata.packet_count = 0;
cbdata.byte_count = 0;
cbdata.n_flows = 0;
- cls_rule_from_match(&asr->match, 0, false, 0, &target);
+ cls_rule_from_match(&asr->match, 0, NXFF_OPENFLOW10, 0, &target);
classifier_for_each_match(&p->cls, &target,
table_id_to_include(asr->table_id),
aggregate_stats_cb, &cbdata);
int error;
if (ofm->flags & htons(OFPFF_CHECK_OVERLAP)) {
- struct flow flow;
- uint32_t wildcards;
+ struct cls_rule cr;
- flow_from_match(&ofm->match, p->tun_id_from_cookie, ofm->cookie,
- &flow, &wildcards);
- if (classifier_rule_overlaps(&p->cls, &flow, wildcards,
- ntohs(ofm->priority))) {
+ cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
+ p->flow_format, ofm->cookie, &cr);
+ if (classifier_rule_overlaps(&p->cls, &cr)) {
return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP);
}
}
ntohs(ofm->hard_timeout), ofm->cookie,
ofm->flags & htons(OFPFF_SEND_FLOW_REM));
cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
- p->tun_id_from_cookie, ofm->cookie, &rule->cr);
+ p->flow_format, ofm->cookie, &rule->cr);
error = 0;
if (ofm->buffer_id != htonl(UINT32_MAX)) {
static struct rule *
find_flow_strict(struct ofproto *p, const struct ofp_flow_mod *ofm)
{
- uint32_t wildcards;
- struct flow flow;
+ struct cls_rule target;
- flow_from_match(&ofm->match, p->tun_id_from_cookie, ofm->cookie,
- &flow, &wildcards);
- return rule_from_cls_rule(classifier_find_rule_exactly(
- &p->cls, &flow, wildcards,
- ntohs(ofm->priority)));
+ cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
+ p->flow_format, ofm->cookie, &target);
+ return rule_from_cls_rule(classifier_find_rule_exactly(&p->cls, &target));
}
static int
cbdata.n_actions = n_actions;
cbdata.match = NULL;
- cls_rule_from_match(&ofm->match, 0, p->tun_id_from_cookie, ofm->cookie,
- &target);
+ cls_rule_from_match(&ofm->match, 0, p->flow_format, ofm->cookie, &target);
classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
modify_flows_cb, &cbdata);
cbdata.ofproto = p;
cbdata.out_port = ofm->out_port;
- cls_rule_from_match(&ofm->match, 0, p->tun_id_from_cookie, ofm->cookie,
- &target);
+ cls_rule_from_match(&ofm->match, 0, p->flow_format, ofm->cookie, &target);
classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
delete_flows_cb, &cbdata);
return error;
}
- p->tun_id_from_cookie = !!msg->set;
+ p->flow_format = msg->set ? NXFF_TUN_ID_FROM_COOKIE : NXFF_OPENFLOW10;
return 0;
}
}
ofconn->role = role;
- reply = make_openflow_xid(sizeof *reply, OFPT_VENDOR, msg->header.xid,
- &buf);
- reply->nxh.vendor = htonl(NX_VENDOR_ID);
- reply->nxh.subtype = htonl(NXT_ROLE_REPLY);
+ reply = make_nxmsg_xid(sizeof *reply, NXT_ROLE_REPLY, msg->header.xid,
+ &buf);
reply->role = htonl(role);
queue_tx(buf, ofconn, ofconn->reply_counter);
for (i = 0; i < n_flows; i++) {
struct odp_flow *f = &flows[i];
+ struct cls_rule target;
struct rule *rule;
struct flow flow;
odp_flow_key_to_flow(&f->key, &flow);
+ cls_rule_from_flow(&flow, 0, UINT16_MAX, &target);
- rule = rule_from_cls_rule(
- classifier_find_rule_exactly(&p->cls, &flow, 0, UINT16_MAX));
+ rule = rule_from_cls_rule(classifier_find_rule_exactly(&p->cls,
+ &target));
if (rule && rule->installed) {
update_time(p, rule, &f->stats);
COVERAGE_INC(ofproto_revalidate_rule);
if (rule->super) {
struct rule *super;
- super = rule_from_cls_rule(classifier_lookup_wild(&p->cls, flow));
+ super = rule_from_cls_rule(classifier_lookup(&p->cls, flow,
+ CLS_INC_WILD));
if (!super) {
rule_remove(p, rule);
return false;
uint32_t msec = tdiff - (sec * 1000);
ofr = make_openflow(sizeof *ofr, OFPT_FLOW_REMOVED, &buf);
- flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, p->tun_id_from_cookie,
+ flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, p->flow_format,
&ofr->match);
ofr->cookie = rule->flow_cookie;
ofr->priority = htons(rule->cr.priority);
long long int now, uint8_t reason)
{
struct ofconn *ofconn;
- struct ofconn *prev;
- struct ofpbuf *buf = NULL;
if (!rule->send_flow_removed) {
return;
}
- /* We limit the maximum number of queued flow expirations it by accounting
- * them under the counter for replies. That works because preventing
- * OpenFlow requests from being processed also prevents new flows from
- * being added (and expiring). (It also prevents processing OpenFlow
- * requests that would not add new flows, so it is imperfect.) */
-
- prev = NULL;
LIST_FOR_EACH (ofconn, node, &p->all_conns) {
- if (rconn_is_connected(ofconn->rconn)
- && ofconn_receives_async_msgs(ofconn)) {
- if (prev) {
- queue_tx(ofpbuf_clone(buf), prev, prev->reply_counter);
- } else {
- buf = compose_flow_removed(p, rule, now, reason);
- }
- prev = ofconn;
+ struct ofpbuf *msg;
+
+ if (!rconn_is_connected(ofconn->rconn)
+ || !ofconn_receives_async_msgs(ofconn)) {
+ continue;
}
- }
- if (prev) {
- queue_tx(buf, prev, prev->reply_counter);
+
+ msg = compose_flow_removed(p, rule, now, reason);
+
+ /* Account flow expirations under ofconn->reply_counter, the counter
+ * for replies to OpenFlow requests. That works because preventing
+ * OpenFlow requests from being processed also prevents new flows from
+ * being added (and expiring). (It also prevents processing OpenFlow
+ * requests that would not add new flows, so it is imperfect.) */
+ queue_tx(msg, ofconn, ofconn->reply_counter);
}
}
projects / openvswitch / blobdiff