/*
- * Copyright (c) 2009, 2010, 2011 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks.
* Copyright (c) 2010 Jean Tourrilhes - HP-Labs.
*
* Licensed under the Apache License, Version 2.0 (the "License");
#include "hmap.h"
#include "netdev.h"
#include "nx-match.h"
+#include "ofp-errors.h"
#include "ofp-print.h"
#include "ofp-util.h"
#include "ofpbuf.h"
static void ofopgroup_destroy(struct ofopgroup *);
-static int add_flow(struct ofproto *, struct ofconn *,
- const struct ofputil_flow_mod *,
- const struct ofp_header *);
+static enum ofperr add_flow(struct ofproto *, struct ofconn *,
+ const struct ofputil_flow_mod *,
+ const struct ofp_header *);
static bool handle_openflow(struct ofconn *, struct ofpbuf *);
-static int handle_flow_mod__(struct ofproto *, struct ofconn *,
- const struct ofputil_flow_mod *,
+static enum ofperr handle_flow_mod__(struct ofproto *, struct ofconn *,
+ const struct ofputil_flow_mod *,
const struct ofp_header *);
static void update_port(struct ofproto *, const char *devname);
}
/* Executes the flow modification specified in 'fm'. Returns 0 on success, an
- * OpenFlow error code as encoded by ofp_mkerr() on failure, or
- * OFPROTO_POSTPONE if the operation cannot be initiated now but may be retried
- * later.
+ * OFPERR_* OpenFlow error code on failure, or OFPROTO_POSTPONE if the
+ * operation cannot be initiated now but may be retried later.
*
* This is a helper function for in-band control and fail-open. */
int
return rule->cr.priority > UINT16_MAX;
}
\f
-static int
+static enum ofperr
handle_echo_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
ofconn_send_reply(ofconn, make_echo_reply(oh));
return 0;
}
-static int
+static enum ofperr
handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
return 0;
}
-static int
+static enum ofperr
handle_get_config_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
struct ofp_switch_config *osc;
+ enum ofp_config_flags flags;
struct ofpbuf *buf;
/* Send reply. */
osc = make_openflow_xid(sizeof *osc, OFPT_GET_CONFIG_REPLY, oh->xid, &buf);
- osc->flags = htons(ofproto->frag_handling);
+ flags = ofproto->frag_handling;
+ if (ofconn_get_invalid_ttl_to_controller(ofconn)) {
+ flags |= OFPC_INVALID_TTL_TO_CONTROLLER;
+ }
+ osc->flags = htons(flags);
osc->miss_send_len = htons(ofconn_get_miss_send_len(ofconn));
ofconn_send_reply(ofconn, buf);
return 0;
}
-static int
+static enum ofperr
handle_set_config(struct ofconn *ofconn, const struct ofp_switch_config *osc)
{
struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
}
}
}
+ ofconn_set_invalid_ttl_to_controller(ofconn,
+ (flags & OFPC_INVALID_TTL_TO_CONTROLLER));
ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len));
}
/* Checks whether 'ofconn' is a slave controller. If so, returns an OpenFlow
- * error message code (composed with ofp_mkerr()) for the caller to propagate
- * upward. Otherwise, returns 0. */
-static int
-reject_slave_controller(const struct ofconn *ofconn)
+ * error message code for the caller to propagate upward. Otherwise, returns
+ * 0.
+ *
+ * The log message mentions 'msg_type'. */
+static enum ofperr
+reject_slave_controller(struct ofconn *ofconn)
{
if (ofconn_get_type(ofconn) == OFCONN_PRIMARY
&& ofconn_get_role(ofconn) == NX_ROLE_SLAVE) {
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
+ return OFPERR_OFPBRC_EPERM;
} else {
return 0;
}
}
-static int
+static enum ofperr
handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofproto *p = ofconn_get_ofproto(ofconn);
struct ofpbuf request;
struct flow flow;
size_t n_ofp_actions;
+ enum ofperr error;
uint16_t in_port;
- int error;
COVERAGE_INC(ofproto_packet_out);
* above) are valid. */
in_port = ntohs(opo->in_port);
if (in_port >= OFPP_MAX && in_port != OFPP_LOCAL && in_port != OFPP_NONE) {
- return ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_IN_PORT);
+ return OFPERR_NXBRC_BAD_IN_PORT;
}
/* Send out packet. */
}
}
-static int
+static enum ofperr
handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofproto *p = ofconn_get_ofproto(ofconn);
port = ofproto_get_port(p, ntohs(opm->port_no));
if (!port) {
- return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_PORT);
+ return OFPERR_OFPPMFC_BAD_PORT;
} else if (memcmp(port->opp.hw_addr, opm->hw_addr, OFP_ETH_ALEN)) {
- return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR);
+ return OFPERR_OFPPMFC_BAD_HW_ADDR;
} else {
update_port_config(port, opm->config, opm->mask);
if (opm->advertise) {
return 0;
}
-static int
+static enum ofperr
handle_desc_stats_request(struct ofconn *ofconn,
const struct ofp_stats_msg *request)
{
return 0;
}
-static int
+static enum ofperr
handle_table_stats_request(struct ofconn *ofconn,
const struct ofp_stats_msg *request)
{
put_32aligned_be64(&ops->collisions, htonll(stats.collisions));
}
-static int
+static enum ofperr
handle_port_stats_request(struct ofconn *ofconn,
const struct ofp_port_stats_request *psr)
{
/* Checks whether 'table_id' is 0xff or a valid table ID in 'ofproto'. Returns
* 0 if 'table_id' is OK, otherwise an OpenFlow error code. */
-static int
+static enum ofperr
check_table_id(const struct ofproto *ofproto, uint8_t table_id)
{
return (table_id == 0xff || table_id < ofproto->n_tables
? 0
- : ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_TABLE_ID));
+ : OFPERR_NXBRC_BAD_TABLE_ID);
}
* Hidden rules are always omitted.
*
* Returns 0 on success, otherwise an OpenFlow error code. */
-static int
+static enum ofperr
collect_rules_loose(struct ofproto *ofproto, uint8_t table_id,
- const struct cls_rule *match, uint16_t out_port,
- struct list *rules)
+ const struct cls_rule *match,
+ ovs_be64 cookie, ovs_be64 cookie_mask,
+ uint16_t out_port, struct list *rules)
{
struct classifier *cls;
- int error;
+ enum ofperr error;
error = check_table_id(ofproto, table_id);
if (error) {
if (rule->pending) {
return OFPROTO_POSTPONE;
}
- if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)) {
+ if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)
+ && !((rule->flow_cookie ^ cookie) & cookie_mask)) {
list_push_back(rules, &rule->ofproto_node);
}
}
* Hidden rules are always omitted.
*
* Returns 0 on success, otherwise an OpenFlow error code. */
-static int
+static enum ofperr
collect_rules_strict(struct ofproto *ofproto, uint8_t table_id,
- const struct cls_rule *match, uint16_t out_port,
- struct list *rules)
+ const struct cls_rule *match,
+ ovs_be64 cookie, ovs_be64 cookie_mask,
+ uint16_t out_port, struct list *rules)
{
struct classifier *cls;
int error;
if (rule->pending) {
return OFPROTO_POSTPONE;
}
- if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)) {
+ if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)
+ && !((rule->flow_cookie ^ cookie) & cookie_mask)) {
list_push_back(rules, &rule->ofproto_node);
}
}
return 0;
}
-static int
+static enum ofperr
handle_flow_stats_request(struct ofconn *ofconn,
const struct ofp_stats_msg *osm)
{
struct list replies;
struct list rules;
struct rule *rule;
- int error;
+ enum ofperr error;
error = ofputil_decode_flow_stats_request(&fsr, &osm->header);
if (error) {
}
error = collect_rules_loose(ofproto, fsr.table_id, &fsr.match,
+ fsr.cookie, fsr.cookie_mask,
fsr.out_port, &rules);
if (error) {
return error;
: -1);
}
-static int
+static enum ofperr
handle_aggregate_stats_request(struct ofconn *ofconn,
const struct ofp_stats_msg *osm)
{
struct ofpbuf *reply;
struct list rules;
struct rule *rule;
- int error;
+ enum ofperr error;
error = ofputil_decode_flow_stats_request(&request, &osm->header);
if (error) {
}
error = collect_rules_loose(ofproto, request.table_id, &request.match,
+ request.cookie, request.cookie_mask,
request.out_port, &rules);
if (error) {
return error;
}
}
-static int
+static enum ofperr
handle_queue_stats_request(struct ofconn *ofconn,
const struct ofp_queue_stats_request *qsr)
{
}
} else {
ofpbuf_list_delete(&cbdata.replies);
- return ofp_mkerr(OFPET_QUEUE_OP_FAILED, OFPQOFC_BAD_PORT);
+ return OFPERR_OFPQOFC_BAD_PORT;
}
ofconn_send_replies(ofconn, &cbdata.replies);
*
* Adds the flow specified by 'ofm', which is followed by 'n_actions'
* ofp_actions, to the ofproto's flow table. Returns 0 on success, an OpenFlow
- * error code as encoded by ofp_mkerr() on failure, or OFPROTO_POSTPONE if the
- * operation cannot be initiated now but may be retried later.
+ * error code on failure, or OFPROTO_POSTPONE if the operation cannot be
+ * initiated now but may be retried later.
*
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
-static int
+static enum ofperr
add_flow(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm, const struct ofp_header *request)
{
} else if (fm->table_id < ofproto->n_tables) {
table = &ofproto->tables[fm->table_id];
} else {
- return ofp_mkerr_nicira(OFPET_FLOW_MOD_FAILED, NXFMFC_BAD_TABLE_ID);
+ return OFPERR_NXFMFC_BAD_TABLE_ID;
}
/* Check for overlap, if requested. */
if (fm->flags & OFPFF_CHECK_OVERLAP
&& classifier_rule_overlaps(table, &fm->cr)) {
- return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP);
+ return OFPERR_OFPFMFC_OVERLAP;
}
/* Serialize against pending deletion. */
* if any.
*
* Returns 0 on success, otherwise an OpenFlow error code. */
-static int
+static enum ofperr
modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm,
const struct ofp_header *request, struct list *rules)
return 0;
}
-/* Implements OFPFC_MODIFY. Returns 0 on success or an OpenFlow error code as
- * encoded by ofp_mkerr() on failure.
+/* Implements OFPFC_MODIFY. Returns 0 on success or an OpenFlow error code on
+ * failure.
*
* 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
* if any. */
-static int
+static enum ofperr
modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm,
const struct ofp_header *request)
struct list rules;
int error;
- error = collect_rules_loose(ofproto, fm->table_id, &fm->cr, OFPP_NONE,
- &rules);
+ error = collect_rules_loose(ofproto, fm->table_id, &fm->cr,
+ fm->cookie, fm->cookie_mask,
+ OFPP_NONE, &rules);
return (error ? error
: list_is_empty(&rules) ? add_flow(ofproto, ofconn, fm, request)
: modify_flows__(ofproto, ofconn, fm, request, &rules));
}
/* Implements OFPFC_MODIFY_STRICT. Returns 0 on success or an OpenFlow error
- * code as encoded by ofp_mkerr() on failure.
+ * code on failure.
*
* 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
* if any. */
-static int
+static enum ofperr
modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm,
const struct ofp_header *request)
struct list rules;
int error;
- error = collect_rules_strict(ofproto, fm->table_id, &fm->cr, OFPP_NONE,
- &rules);
+ error = collect_rules_strict(ofproto, fm->table_id, &fm->cr,
+ fm->cookie, fm->cookie_mask,
+ OFPP_NONE, &rules);
return (error ? error
: list_is_empty(&rules) ? add_flow(ofproto, ofconn, fm, request)
: list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn,
/* Deletes the rules listed in 'rules'.
*
* Returns 0 on success, otherwise an OpenFlow error code. */
-static int
+static enum ofperr
delete_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofp_header *request, struct list *rules)
{
}
/* Implements OFPFC_DELETE. */
-static int
+static enum ofperr
delete_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm,
const struct ofp_header *request)
{
struct list rules;
- int error;
+ enum ofperr error;
- error = collect_rules_loose(ofproto, fm->table_id, &fm->cr, fm->out_port,
- &rules);
+ error = collect_rules_loose(ofproto, fm->table_id, &fm->cr,
+ fm->cookie, fm->cookie_mask,
+ fm->out_port, &rules);
return (error ? error
: !list_is_empty(&rules) ? delete_flows__(ofproto, ofconn, request,
&rules)
}
/* Implements OFPFC_DELETE_STRICT. */
-static int
+static enum ofperr
delete_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm,
const struct ofp_header *request)
{
struct list rules;
- int error;
+ enum ofperr error;
- error = collect_rules_strict(ofproto, fm->table_id, &fm->cr, fm->out_port,
- &rules);
+ error = collect_rules_strict(ofproto, fm->table_id, &fm->cr,
+ fm->cookie, fm->cookie_mask,
+ fm->out_port, &rules);
return (error ? error
: list_is_singleton(&rules) ? delete_flows__(ofproto, ofconn,
request, &rules)
ofopgroup_submit(group);
}
\f
-static int
+static enum ofperr
handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofputil_flow_mod fm;
- int error;
+ enum ofperr error;
error = reject_slave_controller(ofconn);
if (error) {
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);
+ return OFPERR_OFPFMFC_ALL_TABLES_FULL;
}
return handle_flow_mod__(ofconn_get_ofproto(ofconn), ofconn, &fm, oh);
}
-static int
+static enum ofperr
handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn,
const struct ofputil_flow_mod *fm,
const struct ofp_header *oh)
VLOG_WARN_RL(&rl, "flow_mod has explicit table_id but "
"flow_mod_table_id extension is not enabled");
}
- return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND);
+ return OFPERR_OFPFMFC_BAD_COMMAND;
}
}
-static int
+static enum ofperr
handle_role_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct nx_role_request *nrr = (struct nx_role_request *) oh;
uint32_t role;
if (ofconn_get_type(ofconn) != OFCONN_PRIMARY) {
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
+ return OFPERR_OFPBRC_EPERM;
}
role = ntohl(nrr->role);
if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER
&& role != NX_ROLE_SLAVE) {
- return ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_ROLE);
+ return OFPERR_NXBRC_BAD_ROLE;
}
if (ofconn_get_role(ofconn) != role
return 0;
}
-static int
+static enum ofperr
handle_nxt_flow_mod_table_id(struct ofconn *ofconn,
const struct ofp_header *oh)
{
- const struct nxt_flow_mod_table_id *msg
- = (const struct nxt_flow_mod_table_id *) oh;
+ const struct nx_flow_mod_table_id *msg
+ = (const struct nx_flow_mod_table_id *) oh;
ofconn_set_flow_mod_table_id(ofconn, msg->set != 0);
return 0;
}
-static int
+static enum ofperr
handle_nxt_set_flow_format(struct ofconn *ofconn, const struct ofp_header *oh)
{
- const struct nxt_set_flow_format *msg
- = (const struct nxt_set_flow_format *) oh;
+ const struct nx_set_flow_format *msg
+ = (const struct nx_set_flow_format *) oh;
uint32_t format;
format = ntohl(msg->format);
if (format != NXFF_OPENFLOW10 && format != NXFF_NXM) {
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
+ return OFPERR_OFPBRC_EPERM;
}
if (format != ofconn_get_flow_format(ofconn)
return 0;
}
-static int
+static enum ofperr
+handle_nxt_set_packet_in_format(struct ofconn *ofconn,
+ const struct ofp_header *oh)
+{
+ const struct nx_set_packet_in_format *msg;
+ uint32_t format;
+
+ msg = (const struct nx_set_packet_in_format *) oh;
+ format = ntohl(msg->format);
+ if (format != NXFF_OPENFLOW10 && format != NXPIF_NXM) {
+ return OFPERR_OFPBRC_EPERM;
+ }
+
+ if (format != ofconn_get_packet_in_format(ofconn)
+ && ofconn_has_pending_opgroups(ofconn)) {
+ /* Avoid sending async message in surprsing packet in format. */
+ return OFPROTO_POSTPONE;
+ }
+
+ ofconn_set_packet_in_format(ofconn, format);
+ return 0;
+}
+
+static enum ofperr
handle_barrier_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofp_header *ob;
return 0;
}
-static int
+static enum ofperr
handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
{
const struct ofp_header *oh = msg->data;
const struct ofputil_msg_type *type;
- int error;
+ enum ofperr error;
error = ofputil_decode_msg_type(oh, &type);
if (error) {
case OFPUTIL_NXT_SET_FLOW_FORMAT:
return handle_nxt_set_flow_format(ofconn, oh);
+ case OFPUTIL_NXT_SET_PACKET_IN_FORMAT:
+ return handle_nxt_set_packet_in_format(ofconn, oh);
+
case OFPUTIL_NXT_FLOW_MOD:
return handle_flow_mod(ofconn, oh);
case OFPUTIL_OFPST_AGGREGATE_REPLY:
case OFPUTIL_NXT_ROLE_REPLY:
case OFPUTIL_NXT_FLOW_REMOVED:
+ case OFPUTIL_NXT_PACKET_IN:
case OFPUTIL_NXST_FLOW_REPLY:
case OFPUTIL_NXST_AGGREGATE_REPLY:
default:
if (oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY) {
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT);
+ return OFPERR_OFPBRC_BAD_STAT;
} else {
- return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
+ return OFPERR_OFPBRC_BAD_TYPE;
}
}
}
}
/* Indicates that 'op' completed with status 'error', which is either 0 to
- * indicate success or an OpenFlow error code (constructed with
- * e.g. ofp_mkerr()).
+ * indicate success or an OpenFlow error code on failure.
*
* If 'error' is 0, indicating success, the operation will be committed
* permanently to the flow table. There is one interesting subcase:
* Please see the large comment in ofproto/ofproto-provider.h titled
* "Asynchronous Operation Support" for more information. */
void
-ofoperation_complete(struct ofoperation *op, int error)
+ofoperation_complete(struct ofoperation *op, enum ofperr error)
{
struct ofopgroup *group = op->group;
struct rule *rule = op->rule;
assert(rule->pending == op);
assert(op->status < 0);
- assert(error >= 0);
if (!error
&& !group->error
if (op->victim) {
ofproto_rule_destroy__(op->victim);
}
- if (!(rule->cr.wc.vlan_tci_mask & htons(VLAN_VID_MASK))
- && ofproto->vlan_bitmap) {
- uint16_t vid = vlan_tci_to_vid(rule->cr.flow.vlan_tci);
-
- if (!bitmap_is_set(ofproto->vlan_bitmap, vid)) {
- bitmap_set1(ofproto->vlan_bitmap, vid);
+ if ((rule->cr.wc.vlan_tci_mask & htons(VLAN_VID_MASK))
+ == htons(VLAN_VID_MASK)) {
+ if (ofproto->vlan_bitmap) {
+ uint16_t vid = vlan_tci_to_vid(rule->cr.flow.vlan_tci);
+
+ if (!bitmap_is_set(ofproto->vlan_bitmap, vid)) {
+ bitmap_set1(ofproto->vlan_bitmap, vid);
+ ofproto->vlans_changed = true;
+ }
+ } else {
ofproto->vlans_changed = true;
}
}
const struct cls_table *table;
HMAP_FOR_EACH (table, hmap_node, &cls->tables) {
- if (!(table->wc.vlan_tci_mask & htons(VLAN_VID_MASK))) {
+ if ((table->wc.vlan_tci_mask & htons(VLAN_VID_MASK))
+ == htons(VLAN_VID_MASK)) {
const struct cls_rule *rule;
HMAP_FOR_EACH (rule, hmap_node, &table->rules) {
git://git.onelab.eu / sliver-openvswitch.git / blobdiff