/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
void
ofputil_wildcard_from_ofpfw10(uint32_t ofpfw, struct flow_wildcards *wc)
{
- BUILD_ASSERT_DECL(FLOW_WC_SEQ == 23);
+ BUILD_ASSERT_DECL(FLOW_WC_SEQ == 24);
/* Initialize most of wc. */
flow_wildcards_init_catchall(wc);
match->wc.masks.vlan_tci = htons(0xffff);
} else {
ovs_be16 vid, pcp, tci;
+ uint16_t hpcp;
vid = ofmatch->dl_vlan & htons(VLAN_VID_MASK);
- pcp = htons((ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK);
+ hpcp = (ofmatch->dl_vlan_pcp << VLAN_PCP_SHIFT) & VLAN_PCP_MASK;
+ pcp = htons(hpcp);
tci = vid | pcp | htons(VLAN_CFI);
match->flow.vlan_tci = tci & match->wc.masks.vlan_tci;
}
if (eth_type_mpls(match->flow.dl_type)) {
if (!(wc & OFPFW11_MPLS_LABEL)) {
- match_set_mpls_label(match, ofmatch->mpls_label);
+ match_set_mpls_label(match, 0, ofmatch->mpls_label);
}
if (!(wc & OFPFW11_MPLS_TC)) {
- match_set_mpls_tc(match, ofmatch->mpls_tc);
+ match_set_mpls_tc(match, 0, ofmatch->mpls_tc);
}
}
ofmatch->tp_dst = match->flow.tp_dst;
}
- if (!(match->wc.masks.mpls_lse & htonl(MPLS_LABEL_MASK))) {
+ if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK))) {
wc |= OFPFW11_MPLS_LABEL;
} else {
- ofmatch->mpls_label = htonl(mpls_lse_to_label(match->flow.mpls_lse));
+ ofmatch->mpls_label = htonl(mpls_lse_to_label(
+ match->flow.mpls_lse[0]));
}
- if (!(match->wc.masks.mpls_lse & htonl(MPLS_TC_MASK))) {
+ if (!(match->wc.masks.mpls_lse[0] & htonl(MPLS_TC_MASK))) {
wc |= OFPFW11_MPLS_TC;
} else {
- ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse);
+ ofmatch->mpls_tc = mpls_lse_to_tc(match->flow.mpls_lse[0]);
}
ofmatch->metadata = match->flow.metadata;
case OFPUTIL_P_OF12_OXM:
case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM:
return NXM_TYPICAL_LEN;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case OFPUTIL_P_OF10_STD_TID:
case OFPUTIL_P_OF10_NXM:
case OFPUTIL_P_OF10_NXM_TID:
- NOT_REACHED();
+ OVS_NOT_REACHED();
case OFPUTIL_P_OF11_STD: {
struct ofp11_match *om;
case OFPUTIL_P_OF12_OXM:
case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM:
return oxm_put_match(b, match);
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
/* Given a 'dl_type' value in the format used in struct flow, returns the
#define N_PROTO_ABBREVS ARRAY_SIZE(proto_abbrevs)
enum ofputil_protocol ofputil_flow_dump_protocols[] = {
+ OFPUTIL_P_OF14_OXM,
OFPUTIL_P_OF13_OXM,
OFPUTIL_P_OF12_OXM,
OFPUTIL_P_OF11_STD,
return OFPUTIL_P_OF12_OXM;
case OFP13_VERSION:
return OFPUTIL_P_OF13_OXM;
+ case OFP14_VERSION:
+ return OFPUTIL_P_OF14_OXM;
default:
return 0;
}
return OFP12_VERSION;
case OFPUTIL_P_OF13_OXM:
return OFP13_VERSION;
+ case OFPUTIL_P_OF14_OXM:
+ return OFP14_VERSION;
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
/* Returns a bitmap of OpenFlow versions that are supported by at
case OFPUTIL_P_OF13_OXM:
return OFPUTIL_P_OF13_OXM;
+ case OFPUTIL_P_OF14_OXM:
+ return OFPUTIL_P_OF14_OXM;
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case OFPUTIL_P_OF13_OXM:
return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
+ case OFPUTIL_P_OF14_OXM:
+ return ofputil_protocol_set_tid(OFPUTIL_P_OF14_OXM, tid);
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case OFPUTIL_P_OF13_OXM:
return "OXM-OpenFlow13";
+
+ case OFPUTIL_P_OF14_OXM:
+ return "OXM-OpenFlow14";
}
/* Check abbreviations. */
goto match;
}
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
match: ;
}
if (!strcasecmp(s, "OpenFlow13")) {
return OFP13_VERSION;
}
+ if (!strcasecmp(s, "OpenFlow14")) {
+ return OFP14_VERSION;
+ }
return 0;
}
return "OpenFlow12";
case OFP13_VERSION:
return "OpenFlow13";
+ case OFP14_VERSION:
+ return "OpenFlow14";
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case NXPIF_NXM:
return "nxm";
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case OFPUTIL_P_OF11_STD:
case OFPUTIL_P_OF12_OXM:
case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM:
/* There is only one variant of each OpenFlow 1.1+ protocol, and we
* verified above that we're not trying to change versions. */
- NOT_REACHED();
+ OVS_NOT_REACHED();
case OFPUTIL_P_OF10_STD_TID:
case OFPUTIL_P_OF10_NXM_TID:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case NXFF_NXM:
return "nxm";
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
if (error) {
return error;
}
- fm->out_group = ntohl(ofm->out_group);
- if ((ofm->command == OFPFC_DELETE
- || ofm->command == OFPFC_DELETE_STRICT)
- && ofm->out_group != htonl(OFPG_ANY)) {
- return OFPERR_OFPFMFC_UNKNOWN;
- }
+ fm->out_group = (ofm->command == OFPFC_DELETE ||
+ ofm->command == OFPFC_DELETE_STRICT
+ ? ntohl(ofm->out_group)
+ : OFPG11_ANY);
raw_flags = ofm->flags;
} else {
uint16_t command;
fm->out_group = OFPG11_ANY;
raw_flags = nfm->flags;
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
switch (protocol) {
case OFPUTIL_P_OF11_STD:
case OFPUTIL_P_OF12_OXM:
- case OFPUTIL_P_OF13_OXM: {
+ case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM: {
struct ofp11_flow_mod *ofm;
int tailroom;
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
ofpmsg_update_length(msg);
return ofputil_port_from_ofp11(qgcr11->port, port);
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
/* Constructs and returns the beginning of a reply to
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return reply;
return ofputil_port_from_ofp11(qgcr11->port, port);
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
static enum ofperr
default:
/* Hey, the caller lied. */
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
switch (protocol) {
case OFPUTIL_P_OF11_STD:
case OFPUTIL_P_OF12_OXM:
- case OFPUTIL_P_OF13_OXM: {
+ case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM: {
struct ofp11_flow_stats_request *ofsr;
raw = (fsr->aggregate
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return msg;
fs->byte_count = ntohll(nfs->byte_count);
fs->flags = 0;
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
fs->ofpacts = ofpacts->data;
nfs->packet_count = htonll(fs->packet_count);
nfs->byte_count = htonll(fs->byte_count);
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
ofpmp_postappend(replies, start_ofs);
fr->packet_count = ntohll(nfr->packet_count);
fr->byte_count = ntohll(nfr->byte_count);
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return 0;
switch (protocol) {
case OFPUTIL_P_OF11_STD:
case OFPUTIL_P_OF12_OXM:
- case OFPUTIL_P_OF13_OXM: {
+ case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM: {
struct ofp12_flow_removed *ofr;
msg = ofpraw_alloc_xid(OFPRAW_OFPT11_FLOW_REMOVED,
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return msg;
ofputil_decode_packet_in_finish(pin, &match, &b);
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return 0;
case OFPUTIL_P_OF12_OXM:
case OFPUTIL_P_OF13_OXM:
+ case OFPUTIL_P_OF14_OXM:
packet = ofputil_encode_ofp12_packet_in(pin, protocol);
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
ofpmsg_update_length(packet);
return error;
}
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX)
ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN);
pp->config = ntohl(op->config) & OFPPC11_ALL;
- pp->state = ntohl(op->state) & OFPPC11_ALL;
+ pp->state = ntohl(op->state) & OFPPS11_ALL;
pp->curr = netdev_port_features_from_ofp11(op->curr);
pp->advertised = netdev_port_features_from_ofp11(op->advertised);
case OFP11_VERSION:
case OFP12_VERSION:
case OFP13_VERSION:
+ case OFP14_VERSION:
return sizeof(struct ofp11_port);
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
break;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
break;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
\f
case OFP12_VERSION:
case OFP13_VERSION:
return OFPC_COMMON | OFPC12_PORT_BLOCKED;
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
default:
/* Caller needs to check osf->header.version itself */
return 0;
raw = OFPRAW_OFPT11_FEATURES_REPLY;
break;
case OFP13_VERSION:
+ case OFP14_VERSION:
raw = OFPRAW_OFPT13_FEATURES_REPLY;
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
b = ofpraw_alloc_xid(raw, version, xid, 0);
osf = ofpbuf_put_zeros(b, sizeof *osf);
osf->actions = encode_action_bits(features->actions, of10_action_bits);
break;
case OFP13_VERSION:
+ case OFP14_VERSION:
osf->auxiliary_id = features->auxiliary_id;
/* fall through */
case OFP11_VERSION:
}
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return b;
case OFP11_VERSION:
case OFP12_VERSION:
case OFP13_VERSION:
+ case OFP14_VERSION:
raw = OFPRAW_OFPT11_PORT_STATUS;
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
break;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return b;
otm->config = htonl(pm->config);
break;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return b;
rr->have_generation_id = false;
rr->generation_id = 0;
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return 0;
nrr = ofpbuf_put_zeros(buf, sizeof *nrr);
nrr->role = htonl(rr->role - 1);
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return buf;
break;
case OFP13_VERSION:
+ case OFP14_VERSION:
ofputil_put_ofp13_table_stats(&stats[i], reply);
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
case OFP11_VERSION:
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION:{
struct ofp11_packet_out *opo;
size_t len;
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
if (po->buffer_id == UINT32_MAX) {
enum ofpraw type;
switch (ofp_version) {
+ case OFP14_VERSION:
case OFP13_VERSION:
case OFP12_VERSION:
case OFP11_VERSION:
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return ofpraw_alloc(type, ofp_version, 0);
case OFPC_FRAG_NX_MATCH: return "nx-match";
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
bool
const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op);
return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
{
switch (code) {
case OFPUTIL_ACTION_INVALID:
- NOT_REACHED();
+ OVS_NOT_REACHED();
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
#include "ofp-util.def"
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
wc.masks.nd_target = in6addr_any;
}
if (!(may_match & MAY_MPLS)) {
- wc.masks.mpls_lse = htonl(0);
+ memset(wc.masks.mpls_lse, 0, sizeof wc.masks.mpls_lse);
}
/* Log any changes. */
}
case OFP11_VERSION:
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION:{
struct ofp11_port_stats_request *req;
request = ofpraw_alloc(OFPRAW_OFPST11_PORT_REQUEST, ofp_version, 0);
req = ofpbuf_put_zeros(request, sizeof *req);
break;
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return request;
break;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
return sizeof(struct ofp11_port_stats);
case OFP13_VERSION:
return sizeof(struct ofp13_port_stats);
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ return 0;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
}
return ofputil_port_stats_from_ofp10(ps, ps10);
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
bad_len:
return 0;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
"(\'-O OpenFlow11\')");
case OFP11_VERSION:
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION: {
struct ofp11_group_stats_request *req;
request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_REQUEST, ofp_version, 0);
req = ofpbuf_put_zeros(request, sizeof *req);
break;
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return request;
"(\'-O OpenFlow11\')");
case OFP11_VERSION:
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION:
request = ofpraw_alloc(OFPRAW_OFPST11_GROUP_DESC_REQUEST, ofp_version, 0);
break;
- }
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return request;
ofputil_append_of13_group_stats(ogs, replies);
break;
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
case OFP10_VERSION:
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
ovs_fatal(0, "dump-group-features needs OpenFlow 1.2 or later "
"(\'-O OpenFlow12\')");
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION:
request = ofpraw_alloc(OFPRAW_OFPST12_GROUP_FEATURES_REQUEST,
- ofp_version, 0);
+ ofp_version, 0);
break;
- }
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return request;
ogs11 = NULL;
}
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
if (!ogs11) {
case OFP11_VERSION:
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION:
b = ofpraw_alloc(OFPRAW_OFPT11_GROUP_MOD, ofp_version, 0);
start_ogm = b->size;
ofpbuf_put_zeros(b, sizeof *ogm);
ogm->group_id = htonl(gm->group_id);
break;
- }
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return b;
}
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
struct ofputil_queue_stats_request *oqsr)
{
switch ((enum ofp_version)request->version) {
+ case OFP14_VERSION:
case OFP13_VERSION:
case OFP12_VERSION:
case OFP11_VERSION: {
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
switch (ofp_version) {
case OFP11_VERSION:
case OFP12_VERSION:
- case OFP13_VERSION: {
+ case OFP13_VERSION:
+ case OFP14_VERSION: {
struct ofp11_queue_stats_request *req;
request = ofpraw_alloc(OFPRAW_OFPST11_QUEUE_REQUEST, ofp_version, 0);
req = ofpbuf_put_zeros(request, sizeof *req);
break;
}
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
return request;
return sizeof(struct ofp11_queue_stats);
case OFP13_VERSION:
return sizeof(struct ofp13_queue_stats);
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ return 0;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
}
return ofputil_queue_stats_from_ofp10(qs, qs10);
} else {
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
bad_len:
break;
}
+ case OFP14_VERSION:
+ OVS_NOT_REACHED();
+ break;
+
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff