#include "mac-learning.h"
#include "netdev.h"
#include "netflow.h"
+#include "nx-match.h"
#include "odp-util.h"
#include "ofp-print.h"
#include "ofp-util.h"
}
void
-ofproto_add_flow(struct ofproto *p, const struct flow *flow,
- uint32_t wildcards, unsigned int priority,
+ofproto_add_flow(struct ofproto *p, const struct cls_rule *cls_rule,
const union ofp_action *actions, size_t n_actions,
int idle_timeout)
{
rule = rule_create(p, NULL, actions, n_actions,
idle_timeout >= 0 ? idle_timeout : 5 /* XXX */,
0, 0, false);
- cls_rule_from_flow(flow, wildcards, priority, &rule->cr);
+ rule->cr = *cls_rule;
rule_insert(p, rule, NULL, 0);
}
void
-ofproto_delete_flow(struct ofproto *ofproto, const struct flow *flow,
- uint32_t wildcards, unsigned int priority)
+ofproto_delete_flow(struct ofproto *ofproto, const struct cls_rule *target)
{
- 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,
- &target));
+ target));
if (rule) {
rule_remove(ofproto, rule);
}
rule->idle_timeout, rule->hard_timeout,
0, false);
COVERAGE_INC(ofproto_subrule_create);
- cls_rule_from_flow(flow, 0, (rule->cr.priority <= UINT16_MAX ? UINT16_MAX
- : rule->cr.priority), &subrule->cr);
+ cls_rule_init_exact(flow, (rule->cr.priority <= UINT16_MAX ? UINT16_MAX
+ : rule->cr.priority),
+ &subrule->cr);
if (classifier_insert(&ofproto->cls, &subrule->cr)) {
/* Can't happen, */
struct ofproto *p = ofconn->ofproto;
struct ofp_packet_out *opo;
struct ofpbuf payload, *buffer;
- struct odp_actions actions;
+ union ofp_action *ofp_actions;
+ struct odp_actions odp_actions;
+ struct ofpbuf request;
struct flow flow;
- int n_actions;
+ size_t n_ofp_actions;
uint16_t in_port;
int error;
+ COVERAGE_INC(ofproto_packet_out);
+
error = reject_slave_controller(ofconn, "OFPT_PACKET_OUT");
if (error) {
return error;
}
- error = check_ofp_packet_out(oh, &payload, &n_actions, p->max_ports);
+ /* Get ofp_packet_out. */
+ request.data = oh;
+ request.size = ntohs(oh->length);
+ opo = ofpbuf_try_pull(&request, offsetof(struct ofp_packet_out, actions));
+ if (!opo) {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+
+ /* Get actions. */
+ error = ofputil_pull_actions(&request, ntohs(opo->actions_len),
+ &ofp_actions, &n_ofp_actions);
if (error) {
return error;
}
- opo = (struct ofp_packet_out *) oh;
- COVERAGE_INC(ofproto_packet_out);
+ /* Get payload. */
if (opo->buffer_id != htonl(UINT32_MAX)) {
error = pktbuf_retrieve(ofconn->pktbuf, ntohl(opo->buffer_id),
&buffer, &in_port);
}
payload = *buffer;
} else {
+ payload = request;
buffer = NULL;
}
- flow_extract(&payload, 0, ofp_port_to_odp_port(ntohs(opo->in_port)), &flow);
- error = xlate_actions((const union ofp_action *) opo->actions, n_actions,
- &flow, p, &payload, &actions, NULL, NULL, NULL);
+ /* Extract flow, check actions. */
+ flow_extract(&payload, 0, ofp_port_to_odp_port(ntohs(opo->in_port)),
+ &flow);
+ error = validate_actions(ofp_actions, n_ofp_actions, &flow, p->max_ports);
+ if (error) {
+ goto exit;
+ }
+
+ /* Send. */
+ error = xlate_actions(ofp_actions, n_ofp_actions, &flow, p, &payload,
+ &odp_actions, NULL, NULL, NULL);
if (!error) {
- dpif_execute(p->dpif, actions.actions, actions.n_actions, &payload);
+ dpif_execute(p->dpif, odp_actions.actions, odp_actions.n_actions,
+ &payload);
}
- ofpbuf_delete(buffer);
- return error;
+exit:
+ ofpbuf_delete(buffer);
+ return 0;
}
static void
}
static struct ofpbuf *
-make_stats_reply(ovs_be32 xid, ovs_be16 type, size_t body_len)
+make_ofp_stats_reply(ovs_be32 xid, ovs_be16 type, size_t body_len)
{
struct ofp_stats_reply *osr;
struct ofpbuf *msg;
}
static struct ofpbuf *
-start_stats_reply(const struct ofp_stats_request *request, size_t body_len)
+start_ofp_stats_reply(const struct ofp_stats_request *request, size_t body_len)
{
- return make_stats_reply(request->header.xid, request->type, body_len);
+ return make_ofp_stats_reply(request->header.xid, request->type, body_len);
}
static void *
-append_stats_reply(size_t nbytes, struct ofconn *ofconn, struct ofpbuf **msgp)
+append_ofp_stats_reply(size_t nbytes, struct ofconn *ofconn,
+ struct ofpbuf **msgp)
{
struct ofpbuf *msg = *msgp;
assert(nbytes <= UINT16_MAX - sizeof(struct ofp_stats_reply));
if (nbytes + msg->size > UINT16_MAX) {
struct ofp_stats_reply *reply = msg->data;
reply->flags = htons(OFPSF_REPLY_MORE);
- *msgp = make_stats_reply(reply->header.xid, reply->type, nbytes);
+ *msgp = make_ofp_stats_reply(reply->header.xid, reply->type, nbytes);
queue_tx(msg, ofconn, ofconn->reply_counter);
}
return ofpbuf_put_uninit(*msgp, nbytes);
}
+static struct ofpbuf *
+make_nxstats_reply(ovs_be32 xid, ovs_be32 subtype, size_t body_len)
+{
+ struct nicira_stats_msg *nsm;
+ struct ofpbuf *msg;
+
+ msg = ofpbuf_new(MIN(sizeof *nsm + body_len, UINT16_MAX));
+ nsm = put_openflow_xid(sizeof *nsm, OFPT_STATS_REPLY, xid, msg);
+ nsm->type = htons(OFPST_VENDOR);
+ nsm->flags = htons(0);
+ nsm->vendor = htonl(NX_VENDOR_ID);
+ nsm->subtype = htonl(subtype);
+ return msg;
+}
+
+static struct ofpbuf *
+start_nxstats_reply(const struct nicira_stats_msg *request, size_t body_len)
+{
+ return make_nxstats_reply(request->header.xid, request->subtype, body_len);
+}
+
+static void
+append_nxstats_reply(size_t nbytes, struct ofconn *ofconn,
+ struct ofpbuf **msgp)
+{
+ struct ofpbuf *msg = *msgp;
+ assert(nbytes <= UINT16_MAX - sizeof(struct nicira_stats_msg));
+ if (nbytes + msg->size > UINT16_MAX) {
+ struct nicira_stats_msg *reply = msg->data;
+ reply->flags = htons(OFPSF_REPLY_MORE);
+ *msgp = make_nxstats_reply(reply->header.xid, reply->subtype, nbytes);
+ queue_tx(msg, ofconn, ofconn->reply_counter);
+ }
+ ofpbuf_prealloc_tailroom(*msgp, nbytes);
+}
+
static int
handle_desc_stats_request(struct ofconn *ofconn,
struct ofp_stats_request *request)
struct ofp_desc_stats *ods;
struct ofpbuf *msg;
- msg = start_stats_reply(request, sizeof *ods);
- ods = append_stats_reply(sizeof *ods, ofconn, &msg);
+ msg = start_ofp_stats_reply(request, sizeof *ods);
+ ods = append_ofp_stats_reply(sizeof *ods, ofconn, &msg);
memset(ods, 0, sizeof *ods);
ovs_strlcpy(ods->mfr_desc, p->mfr_desc, sizeof ods->mfr_desc);
ovs_strlcpy(ods->hw_desc, p->hw_desc, sizeof ods->hw_desc);
struct rule *rule;
int n_rules;
- msg = start_stats_reply(request, sizeof *ots * 2);
+ msg = start_ofp_stats_reply(request, sizeof *ots * 2);
/* Count rules other than subrules. */
n_rules = classifier_count(&p->cls);
}
/* Classifier table. */
- ots = append_stats_reply(sizeof *ots, ofconn, &msg);
+ ots = append_ofp_stats_reply(sizeof *ots, ofconn, &msg);
memset(ots, 0, sizeof *ots);
strcpy(ots->name, "classifier");
ots->wildcards = (ofconn->flow_format == NXFF_OPENFLOW10
* netdev_get_stats() will log errors. */
netdev_get_stats(port->netdev, &stats);
- ops = append_stats_reply(sizeof *ops, ofconn, msgp);
+ ops = append_ofp_stats_reply(sizeof *ops, ofconn, msgp);
ops->port_no = htons(port->opp.port_no);
memset(ops->pad, 0, sizeof ops->pad);
ops->rx_packets = htonll(stats.rx_packets);
}
psr = (struct ofp_port_stats_request *) osr->body;
- msg = start_stats_reply(osr, sizeof *ops * 16);
+ msg = start_ofp_stats_reply(osr, sizeof *ops * 16);
if (psr->port_no != htons(OFPP_NONE)) {
port = get_port(p, ofp_port_to_odp_port(ntohs(psr->port_no)));
if (port) {
query_stats(cbdata->ofconn->ofproto, rule, &packet_count, &byte_count);
- ofs = append_stats_reply(len, cbdata->ofconn, &cbdata->msg);
+ ofs = append_ofp_stats_reply(len, cbdata->ofconn, &cbdata->msg);
ofs->length = htons(len);
ofs->table_id = 0;
ofs->pad = 0;
COVERAGE_INC(ofproto_flows_req);
cbdata.ofconn = ofconn;
cbdata.out_port = fsr->out_port;
- cbdata.msg = start_stats_reply(osr, 1024);
+ cbdata.msg = start_ofp_stats_reply(osr, 1024);
cls_rule_from_match(&fsr->match, 0, NXFF_OPENFLOW10, 0, &target);
classifier_for_each_match(&ofconn->ofproto->cls, &target,
table_id_to_include(fsr->table_id),
return 0;
}
+static void
+nx_flow_stats_cb(struct cls_rule *rule_, void *cbdata_)
+{
+ struct rule *rule = rule_from_cls_rule(rule_);
+ struct flow_stats_cbdata *cbdata = cbdata_;
+ struct nx_flow_stats *nfs;
+ uint64_t packet_count, byte_count;
+ size_t act_len, start_len;
+
+ if (rule_is_hidden(rule) || !rule_has_out_port(rule, cbdata->out_port)) {
+ return;
+ }
+
+ query_stats(cbdata->ofconn->ofproto, rule, &packet_count, &byte_count);
+
+ act_len = sizeof *rule->actions * rule->n_actions;
+
+ start_len = cbdata->msg->size;
+ append_nxstats_reply(sizeof *nfs + NXM_MAX_LEN + act_len,
+ cbdata->ofconn, &cbdata->msg);
+ nfs = ofpbuf_put_uninit(cbdata->msg, sizeof *nfs);
+ nfs->table_id = 0;
+ nfs->pad = 0;
+ calc_flow_duration(rule->created, &nfs->duration_sec, &nfs->duration_nsec);
+ nfs->cookie = rule->flow_cookie;
+ nfs->priority = htons(rule->cr.priority);
+ nfs->idle_timeout = htons(rule->idle_timeout);
+ nfs->hard_timeout = htons(rule->hard_timeout);
+ nfs->match_len = htons(nx_put_match(cbdata->msg, &rule->cr));
+ memset(nfs->pad2, 0, sizeof nfs->pad2);
+ nfs->packet_count = htonll(packet_count);
+ nfs->byte_count = htonll(byte_count);
+ if (rule->n_actions > 0) {
+ ofpbuf_put(cbdata->msg, rule->actions, act_len);
+ }
+ nfs->length = htons(cbdata->msg->size - start_len);
+}
+
+static int
+handle_nxst_flow(struct ofconn *ofconn, struct ofpbuf *b)
+{
+ struct nx_flow_stats_request *nfsr;
+ struct flow_stats_cbdata cbdata;
+ struct cls_rule target;
+ int error;
+
+ /* Dissect the message. */
+ nfsr = ofpbuf_try_pull(b, sizeof *nfsr);
+ if (!nfsr) {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+ error = nx_pull_match(b, ntohs(nfsr->match_len), 0, &target);
+ if (error) {
+ return error;
+ }
+
+ COVERAGE_INC(ofproto_flows_req);
+ cbdata.ofconn = ofconn;
+ cbdata.out_port = nfsr->out_port;
+ cbdata.msg = start_nxstats_reply(&nfsr->nsm, 1024);
+ classifier_for_each_match(&ofconn->ofproto->cls, &target,
+ table_id_to_include(nfsr->table_id),
+ nx_flow_stats_cb, &cbdata);
+ queue_tx(cbdata.msg, ofconn, ofconn->reply_counter);
+ return 0;
+}
+
struct flow_stats_ds_cbdata {
struct ofproto *ofproto;
struct ds *results;
static void
query_aggregate_stats(struct ofproto *ofproto, struct cls_rule *target,
- uint16_t out_port, uint8_t table_id,
+ ovs_be16 out_port, uint8_t table_id,
struct ofp_aggregate_stats_reply *oasr)
{
struct aggregate_stats_cbdata cbdata;
cls_rule_from_match(&request->match, 0, NXFF_OPENFLOW10, 0, &target);
- msg = start_stats_reply(osr, sizeof *reply);
- reply = append_stats_reply(sizeof *reply, ofconn, &msg);
+ msg = start_ofp_stats_reply(osr, sizeof *reply);
+ reply = append_ofp_stats_reply(sizeof *reply, ofconn, &msg);
query_aggregate_stats(ofconn->ofproto, &target, request->out_port,
request->table_id, reply);
queue_tx(msg, ofconn, ofconn->reply_counter);
return 0;
}
+static int
+handle_nxst_aggregate(struct ofconn *ofconn, struct ofpbuf *b)
+{
+ struct nx_aggregate_stats_request *request;
+ struct ofp_aggregate_stats_reply *reply;
+ struct cls_rule target;
+ struct ofpbuf *buf;
+ int error;
+
+ /* Dissect the message. */
+ request = ofpbuf_try_pull(b, sizeof *request);
+ if (!request) {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+ error = nx_pull_match(b, ntohs(request->match_len), 0, &target);
+ if (error) {
+ return error;
+ }
+
+ /* Reply. */
+ COVERAGE_INC(ofproto_flows_req);
+ buf = start_nxstats_reply(&request->nsm, sizeof *reply);
+ reply = ofpbuf_put_uninit(buf, sizeof *reply);
+ query_aggregate_stats(ofconn->ofproto, &target, request->out_port,
+ request->table_id, reply);
+ queue_tx(buf, ofconn, ofconn->reply_counter);
+
+ return 0;
+}
+
struct queue_stats_cbdata {
struct ofconn *ofconn;
struct ofport *ofport;
{
struct ofp_queue_stats *reply;
- reply = append_stats_reply(sizeof *reply, cbdata->ofconn, &cbdata->msg);
+ reply = append_ofp_stats_reply(sizeof *reply, cbdata->ofconn, &cbdata->msg);
reply->port_no = htons(cbdata->ofport->opp.port_no);
memset(reply->pad, 0, sizeof reply->pad);
reply->queue_id = htonl(queue_id);
COVERAGE_INC(ofproto_queue_req);
cbdata.ofconn = ofconn;
- cbdata.msg = start_stats_reply(osr, 128);
+ cbdata.msg = start_ofp_stats_reply(osr, 128);
port_no = ntohs(qsr->port_no);
queue_id = ntohl(qsr->queue_id);
return 0;
}
+static int
+handle_vendor_stats_request(struct ofconn *ofconn,
+ struct ofp_stats_request *osr, size_t arg_size)
+{
+ struct nicira_stats_msg *nsm;
+ struct ofpbuf b;
+ ovs_be32 vendor;
+
+ if (arg_size < 4) {
+ VLOG_WARN_RL(&rl, "truncated vendor stats request body");
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+
+ memcpy(&vendor, osr->body, sizeof vendor);
+ if (vendor != htonl(NX_VENDOR_ID)) {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
+ }
+
+ if (ntohs(nsm->header.length) < sizeof(struct nicira_stats_msg)) {
+ VLOG_WARN_RL(&rl, "truncated Nicira stats request");
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+
+ nsm = (struct nicira_stats_msg *) osr;
+ b.data = nsm;
+ b.size = ntohs(nsm->header.length);
+ switch (ntohl(nsm->subtype)) {
+ case NXST_FLOW:
+ return handle_nxst_flow(ofconn, &b);
+
+ case NXST_AGGREGATE:
+ return handle_nxst_aggregate(ofconn, &b);
+
+ default:
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE);
+ }
+}
+
static int
handle_stats_request(struct ofconn *ofconn, struct ofp_header *oh)
{
return handle_queue_stats_request(ofconn, osr, arg_size);
case OFPST_VENDOR:
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
+ return handle_vendor_stats_request(ofconn, osr, arg_size);
default:
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT);
}
}
+struct flow_mod {
+ struct cls_rule cr;
+ ovs_be64 cookie;
+ uint16_t command;
+ uint16_t idle_timeout;
+ uint16_t hard_timeout;
+ uint32_t buffer_id;
+ uint16_t out_port;
+ uint16_t flags;
+ union ofp_action *actions;
+ size_t n_actions;
+};
+
/* Implements OFPFC_ADD and the cases for OFPFC_MODIFY and OFPFC_MODIFY_STRICT
* in which no matching flow already exists in the flow table.
*
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static int
-add_flow(struct ofconn *ofconn, const struct ofp_flow_mod *ofm,
- size_t n_actions)
+add_flow(struct ofconn *ofconn, struct flow_mod *fm)
{
struct ofproto *p = ofconn->ofproto;
struct ofpbuf *packet;
uint16_t in_port;
int error;
- if (ofm->flags & htons(OFPFF_CHECK_OVERLAP)) {
- struct cls_rule cr;
-
- cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
- ofconn->flow_format, ofm->cookie, &cr);
- if (classifier_rule_overlaps(&p->cls, &cr)) {
- return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP);
- }
+ if (fm->flags & OFPFF_CHECK_OVERLAP
+ && classifier_rule_overlaps(&p->cls, &fm->cr)) {
+ return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP);
}
- rule = rule_create(p, NULL, (const union ofp_action *) ofm->actions,
- n_actions, ntohs(ofm->idle_timeout),
- ntohs(ofm->hard_timeout), ofm->cookie,
- ofm->flags & htons(OFPFF_SEND_FLOW_REM));
- cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
- ofconn->flow_format, ofm->cookie, &rule->cr);
+ rule = rule_create(p, NULL, fm->actions, fm->n_actions,
+ fm->idle_timeout, fm->hard_timeout, fm->cookie,
+ fm->flags & OFPFF_SEND_FLOW_REM);
+ rule->cr = fm->cr;
error = 0;
- if (ofm->buffer_id != htonl(UINT32_MAX)) {
- error = pktbuf_retrieve(ofconn->pktbuf, ntohl(ofm->buffer_id),
+ if (fm->buffer_id != UINT32_MAX) {
+ error = pktbuf_retrieve(ofconn->pktbuf, fm->buffer_id,
&packet, &in_port);
} else {
packet = NULL;
}
static struct rule *
-find_flow_strict(struct ofconn *ofconn, const struct ofp_flow_mod *ofm)
+find_flow_strict(struct ofproto *p, const struct flow_mod *fm)
{
- struct ofproto *p = ofconn->ofproto;
- struct cls_rule target;
-
- cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
- ofconn->flow_format, ofm->cookie, &target);
- return rule_from_cls_rule(classifier_find_rule_exactly(&p->cls, &target));
+ return rule_from_cls_rule(classifier_find_rule_exactly(&p->cls, &fm->cr));
}
static int
send_buffered_packet(struct ofconn *ofconn,
- struct rule *rule, const struct ofp_flow_mod *ofm)
+ struct rule *rule, uint32_t buffer_id)
{
struct ofpbuf *packet;
uint16_t in_port;
struct flow flow;
int error;
- if (ofm->buffer_id == htonl(UINT32_MAX)) {
+ if (buffer_id == UINT32_MAX) {
return 0;
}
- error = pktbuf_retrieve(ofconn->pktbuf, ntohl(ofm->buffer_id),
- &packet, &in_port);
+ error = pktbuf_retrieve(ofconn->pktbuf, buffer_id, &packet, &in_port);
if (error) {
return error;
}
struct modify_flows_cbdata {
struct ofproto *ofproto;
- const struct ofp_flow_mod *ofm;
- size_t n_actions;
+ const struct flow_mod *fm;
struct rule *match;
};
-static int modify_flow(struct ofproto *, const struct ofp_flow_mod *,
- size_t n_actions, struct rule *);
+static int modify_flow(struct ofproto *, const struct flow_mod *,
+ struct rule *);
static void modify_flows_cb(struct cls_rule *, void *cbdata_);
/* Implements OFPFC_MODIFY. Returns 0 on success or an OpenFlow error code as
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static int
-modify_flows_loose(struct ofconn *ofconn,
- const struct ofp_flow_mod *ofm, size_t n_actions)
+modify_flows_loose(struct ofconn *ofconn, struct flow_mod *fm)
{
struct modify_flows_cbdata cbdata;
- struct cls_rule target;
cbdata.ofproto = ofconn->ofproto;
- cbdata.ofm = ofm;
- cbdata.n_actions = n_actions;
+ cbdata.fm = fm;
cbdata.match = NULL;
- cls_rule_from_match(&ofm->match, 0, ofconn->flow_format,
- ofm->cookie, &target);
-
- classifier_for_each_match(&ofconn->ofproto->cls, &target, CLS_INC_ALL,
+ classifier_for_each_match(&ofconn->ofproto->cls, &fm->cr, CLS_INC_ALL,
modify_flows_cb, &cbdata);
if (cbdata.match) {
/* This credits the packet to whichever flow happened to happened to
* match last. That's weird. Maybe we should do a lookup for the
* flow that actually matches the packet? Who knows. */
- send_buffered_packet(ofconn, cbdata.match, ofm);
+ send_buffered_packet(ofconn, cbdata.match, fm->buffer_id);
return 0;
} else {
- return add_flow(ofconn, ofm, n_actions);
+ return add_flow(ofconn, fm);
}
}
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static int
-modify_flow_strict(struct ofconn *ofconn, struct ofp_flow_mod *ofm,
- size_t n_actions)
+modify_flow_strict(struct ofconn *ofconn, struct flow_mod *fm)
{
- struct rule *rule = find_flow_strict(ofconn, ofm);
+ struct ofproto *p = ofconn->ofproto;
+ struct rule *rule = find_flow_strict(p, fm);
if (rule && !rule_is_hidden(rule)) {
- modify_flow(ofconn->ofproto, ofm, n_actions, rule);
- return send_buffered_packet(ofconn, rule, ofm);
+ modify_flow(p, fm, rule);
+ return send_buffered_packet(ofconn, rule, fm->buffer_id);
} else {
- return add_flow(ofconn, ofm, n_actions);
+ return add_flow(ofconn, fm);
}
}
if (!rule_is_hidden(rule)) {
cbdata->match = rule;
- modify_flow(cbdata->ofproto, cbdata->ofm, cbdata->n_actions, rule);
+ modify_flow(cbdata->ofproto, cbdata->fm, rule);
}
}
* the rule's actions to match those in 'ofm' (which is followed by 'n_actions'
* ofp_action[] structures). */
static int
-modify_flow(struct ofproto *p, const struct ofp_flow_mod *ofm,
- size_t n_actions, struct rule *rule)
+modify_flow(struct ofproto *p, const struct flow_mod *fm, struct rule *rule)
{
- size_t actions_len = n_actions * sizeof *rule->actions;
+ size_t actions_len = fm->n_actions * sizeof *rule->actions;
- rule->flow_cookie = ofm->cookie;
+ rule->flow_cookie = fm->cookie;
/* If the actions are the same, do nothing. */
- if (n_actions == rule->n_actions
- && (!n_actions || !memcmp(ofm->actions, rule->actions, actions_len)))
- {
+ if (fm->n_actions == rule->n_actions
+ && (!fm->n_actions
+ || !memcmp(fm->actions, rule->actions, actions_len))) {
return 0;
}
/* Replace actions. */
free(rule->actions);
- rule->actions = n_actions ? xmemdup(ofm->actions, actions_len) : NULL;
- rule->n_actions = n_actions;
+ rule->actions = fm->n_actions ? xmemdup(fm->actions, actions_len) : NULL;
+ rule->n_actions = fm->n_actions;
/* Make sure that the datapath gets updated properly. */
if (rule->cr.wc.wildcards) {
/* Implements OFPFC_DELETE. */
static void
-delete_flows_loose(struct ofconn *ofconn, const struct ofp_flow_mod *ofm)
+delete_flows_loose(struct ofproto *p, const struct flow_mod *fm)
{
struct delete_flows_cbdata cbdata;
- struct cls_rule target;
-
- cbdata.ofproto = ofconn->ofproto;
- cbdata.out_port = ofm->out_port;
- cls_rule_from_match(&ofm->match, 0, ofconn->flow_format,
- ofm->cookie, &target);
+ cbdata.ofproto = p;
+ cbdata.out_port = htons(fm->out_port);
- classifier_for_each_match(&ofconn->ofproto->cls, &target, CLS_INC_ALL,
+ classifier_for_each_match(&p->cls, &fm->cr, CLS_INC_ALL,
delete_flows_cb, &cbdata);
}
/* Implements OFPFC_DELETE_STRICT. */
static void
-delete_flow_strict(struct ofconn *ofconn, struct ofp_flow_mod *ofm)
+delete_flow_strict(struct ofproto *p, struct flow_mod *fm)
{
- struct rule *rule = find_flow_strict(ofconn, ofm);
+ struct rule *rule = find_flow_strict(p, fm);
if (rule) {
- delete_flow(ofconn->ofproto, rule, ofm->out_port);
+ delete_flow(p, rule, htons(fm->out_port));
}
}
}
\f
static int
-handle_flow_mod(struct ofconn *ofconn, struct ofp_flow_mod *ofm)
+flow_mod_core(struct ofconn *ofconn, struct flow_mod *fm)
{
- struct ofp_match orig_match;
- size_t n_actions;
+ struct ofproto *p = ofconn->ofproto;
int error;
- error = reject_slave_controller(ofconn, "OFPT_FLOW_MOD");
+ error = reject_slave_controller(ofconn, "flow_mod");
if (error) {
return error;
}
- error = check_ofp_message_array(&ofm->header, OFPT_FLOW_MOD, sizeof *ofm,
- sizeof *ofm->actions, &n_actions);
+
+ error = validate_actions(fm->actions, fm->n_actions,
+ &fm->cr.flow, p->max_ports);
if (error) {
return error;
}
/* We do not support the emergency flow cache. It will hopefully
* get dropped from OpenFlow in the near future. */
- if (ofm->flags & htons(OFPFF_EMERG)) {
+ if (fm->flags & OFPFF_EMERG) {
/* There isn't a good fit for an error code, so just state that the
* flow table is full. */
return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_ALL_TABLES_FULL);
}
- /* Normalize ofp->match. If normalization actually changes anything, then
+ switch (fm->command) {
+ case OFPFC_ADD:
+ return add_flow(ofconn, fm);
+
+ case OFPFC_MODIFY:
+ return modify_flows_loose(ofconn, fm);
+
+ case OFPFC_MODIFY_STRICT:
+ return modify_flow_strict(ofconn, fm);
+
+ case OFPFC_DELETE:
+ delete_flows_loose(p, fm);
+ return 0;
+
+ case OFPFC_DELETE_STRICT:
+ delete_flow_strict(p, fm);
+ return 0;
+
+ default:
+ return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND);
+ }
+}
+
+static int
+handle_ofpt_flow_mod(struct ofconn *ofconn, struct ofp_header *oh)
+{
+ struct ofp_match orig_match;
+ struct ofp_flow_mod *ofm;
+ struct flow_mod fm;
+ struct ofpbuf b;
+ int error;
+
+ b.data = oh;
+ b.size = ntohs(oh->length);
+
+ /* Dissect the message. */
+ ofm = ofpbuf_try_pull(&b, sizeof *ofm);
+ if (!ofm) {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+ error = ofputil_pull_actions(&b, b.size, &fm.actions, &fm.n_actions);
+ if (error) {
+ return error;
+ }
+
+ /* Normalize ofm->match. If normalization actually changes anything, then
* log the differences. */
ofm->match.pad1[0] = ofm->match.pad2[0] = 0;
orig_match = ofm->match;
}
}
- if (!ofm->match.wildcards) {
- ofm->priority = htons(UINT16_MAX);
- }
+ /* Translate the message. */
+ cls_rule_from_match(&ofm->match, ntohs(ofm->priority), ofconn->flow_format,
+ ofm->cookie, &fm.cr);
+ fm.cookie = ofm->cookie;
+ fm.command = ntohs(ofm->command);
+ fm.idle_timeout = ntohs(ofm->idle_timeout);
+ fm.hard_timeout = ntohs(ofm->hard_timeout);
+ fm.buffer_id = ntohl(ofm->buffer_id);
+ fm.out_port = ntohs(ofm->out_port);
+ fm.flags = ntohs(ofm->flags);
- error = validate_actions((const union ofp_action *) ofm->actions,
- n_actions, ofconn->ofproto->max_ports);
- if (error) {
- return error;
- }
-
- switch (ntohs(ofm->command)) {
- case OFPFC_ADD:
- return add_flow(ofconn, ofm, n_actions);
+ /* Execute the command. */
+ return flow_mod_core(ofconn, &fm);
+}
- case OFPFC_MODIFY:
- return modify_flows_loose(ofconn, ofm, n_actions);
+static int
+handle_nxt_flow_mod(struct ofconn *ofconn, struct ofp_header *oh)
+{
+ struct nx_flow_mod *nfm;
+ struct flow_mod fm;
+ struct ofpbuf b;
+ int error;
- case OFPFC_MODIFY_STRICT:
- return modify_flow_strict(ofconn, ofm, n_actions);
+ b.data = oh;
+ b.size = ntohs(oh->length);
- case OFPFC_DELETE:
- delete_flows_loose(ofconn, ofm);
- return 0;
+ /* Dissect the message. */
+ nfm = ofpbuf_try_pull(&b, sizeof *nfm);
+ if (!nfm) {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
+ }
+ error = nx_pull_match(&b, ntohs(nfm->match_len), ntohs(nfm->priority),
+ &fm.cr);
+ if (error) {
+ return error;
+ }
+ error = ofputil_pull_actions(&b, b.size, &fm.actions, &fm.n_actions);
+ if (error) {
+ return error;
+ }
- case OFPFC_DELETE_STRICT:
- delete_flow_strict(ofconn, ofm);
- return 0;
+ /* Translate the message. */
+ fm.cookie = nfm->cookie;
+ fm.command = ntohs(nfm->command);
+ fm.idle_timeout = ntohs(nfm->idle_timeout);
+ fm.hard_timeout = ntohs(nfm->hard_timeout);
+ fm.buffer_id = ntohl(nfm->buffer_id);
+ fm.out_port = ntohs(nfm->out_port);
+ fm.flags = ntohs(nfm->flags);
- default:
- return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND);
- }
+ /* Execute the command. */
+ return flow_mod_core(ofconn, &fm);
}
static int
return 0;
}
+static int
+handle_nxt_set_flow_format(struct ofconn *ofconn,
+ struct nxt_set_flow_format *msg)
+{
+ uint32_t format;
+ int error;
+
+ error = check_ofp_message(&msg->header, OFPT_VENDOR, sizeof *msg);
+ if (error) {
+ return error;
+ }
+
+ format = ntohl(msg->format);
+ if (format == NXFF_OPENFLOW10
+ || format == NXFF_TUN_ID_FROM_COOKIE
+ || format == NXFF_NXM) {
+ ofconn->flow_format = format;
+ return 0;
+ } else {
+ return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
+ }
+}
+
static int
handle_vendor(struct ofconn *ofconn, void *msg)
{
case NXT_ROLE_REQUEST:
return handle_role_request(ofconn, msg);
+
+ case NXT_SET_FLOW_FORMAT:
+ return handle_nxt_set_flow_format(ofconn, msg);
+
+ case NXT_FLOW_MOD:
+ return handle_nxt_flow_mod(ofconn, &ovh->header);
}
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE);
break;
case OFPT_FLOW_MOD:
- error = handle_flow_mod(ofconn, ofp_msg->data);
+ error = handle_ofpt_flow_mod(ofconn, ofp_msg->data);
break;
case OFPT_STATS_REQUEST:
struct flow flow;
odp_flow_key_to_flow(&f->key, &flow);
- cls_rule_from_flow(&flow, 0, UINT16_MAX, &target);
+ cls_rule_init_exact(&flow, UINT16_MAX, &target);
rule = rule_from_cls_rule(classifier_find_rule_exactly(&p->cls,
&target));
}
static struct ofpbuf *
-compose_flow_removed(struct ofconn *ofconn, const struct rule *rule,
- uint8_t reason)
+compose_ofp_flow_removed(struct ofconn *ofconn, const struct rule *rule,
+ uint8_t reason)
{
struct ofp_flow_removed *ofr;
struct ofpbuf *buf;
return buf;
}
+static struct ofpbuf *
+compose_nx_flow_removed(const struct rule *rule, uint8_t reason)
+{
+ struct nx_flow_removed *nfr;
+ struct ofpbuf *buf;
+ int match_len;
+
+ nfr = make_nxmsg(sizeof *nfr, NXT_FLOW_REMOVED, &buf);
+
+ match_len = nx_put_match(buf, &rule->cr);
+
+ nfr->cookie = rule->flow_cookie;
+ nfr->priority = htons(rule->cr.priority);
+ nfr->reason = reason;
+ calc_flow_duration(rule->created, &nfr->duration_sec, &nfr->duration_nsec);
+ nfr->idle_timeout = htons(rule->idle_timeout);
+ nfr->match_len = htons(match_len);
+ nfr->packet_count = htonll(rule->packet_count);
+ nfr->byte_count = htonll(rule->byte_count);
+
+ return buf;
+}
+
static void
send_flow_removed(struct ofproto *p, struct rule *rule, uint8_t reason)
{
continue;
}
- msg = compose_flow_removed(ofconn, rule, reason);
+ msg = (ofconn->flow_format == NXFF_NXM
+ ? compose_nx_flow_removed(rule, reason)
+ : compose_ofp_flow_removed(ofconn, rule, reason));
/* Account flow expirations under ofconn->reply_counter, the counter
* for replies to OpenFlow requests. That works because preventing