summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
037821c)
This allows other libraries to use util.h that has already
defined NOT_REACHED.
Signed-off-by: Harold Lim <haroldl@vmware.com>
Signed-off-by: Ben Pfaff <blp@nicira.com>
55 files changed:
}
"switch" statements with very short, uniform cases may use an
}
"switch" statements with very short, uniform cases may use an
async_append_write(struct async_append *ap OVS_UNUSED,
const void *data OVS_UNUSED, size_t size OVS_UNUSED)
{
async_append_write(struct async_append *ap OVS_UNUSED,
const void *data OVS_UNUSED, size_t size OVS_UNUSED)
{
}
void
async_append_flush(struct async_append *ap OVS_UNUSED)
{
}
void
async_append_flush(struct async_append *ap OVS_UNUSED)
{
break;
case STATE_ADMIN_DOWN:
default:
break;
case STATE_ADMIN_DOWN:
default:
}
}
/* XXX: RFC 5880 Section 6.8.6 Demand mode related calculations here. */
}
}
/* XXX: RFC 5880 Section 6.8.6 Demand mode related calculations here. */
return execute_ab(bundle, slave_enabled, aux);
default:
return execute_ab(bundle, slave_enabled, aux);
default:
ccm_interval_to_ms(uint8_t interval)
{
switch (interval) {
ccm_interval_to_ms(uint8_t interval)
{
switch (interval) {
- case 0: NOT_REACHED(); /* Explicitly not supported by 802.1ag. */
+ case 0: OVS_NOT_REACHED(); /* Explicitly not supported by 802.1ag. */
case 1: return 3; /* Not recommended due to timer resolution. */
case 2: return 10; /* Not recommended due to timer resolution. */
case 3: return 100;
case 1: return 3; /* Not recommended due to timer resolution. */
case 2: return 10; /* Not recommended due to timer resolution. */
case 3: return 100;
case 5: return 10000;
case 6: return 60000;
case 7: return 600000;
case 5: return 10000;
case 6: return 60000;
case 7: return 600000;
- default: NOT_REACHED(); /* Explicitly not supported by 802.1ag. */
+ default: OVS_NOT_REACHED(); /* Explicitly not supported by 802.1ag. */
} else if (retval < 0) {
VLOG_FATAL("waitpid failed (%s)", ovs_strerror(errno));
} else {
} else if (retval < 0) {
VLOG_FATAL("waitpid failed (%s)", ovs_strerror(errno));
} else {
}
ofpbuf_uninit(&aux->request);
}
ofpbuf_uninit(&aux->request);
raise(sig_nr);
ovs_mutex_unlock(&mutex);
raise(sig_nr);
ovs_mutex_unlock(&mutex);
return flow_hash_symmetric_l4(flow, basis);
}
return flow_hash_symmetric_l4(flow, basis);
}
}
/* Returns a string representation of 'fields'. */
}
/* Returns a string representation of 'fields'. */
break;
case JSON_N_TYPES:
break;
case JSON_N_TYPES:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
} else if (node->json->type == JSON_ARRAY) {
json_array_add(node->json, value);
} else {
} else if (node->json->type == JSON_ARRAY) {
json_array_add(node->json, value);
} else {
} else if (node->json->type == JSON_OBJECT) {
p->parse_state = JSON_PARSE_OBJECT_NEXT;
} else {
} else if (node->json->type == JSON_OBJECT) {
p->parse_state = JSON_PARSE_OBJECT_NEXT;
} else {
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
case JSON_N_TYPES:
default:
status = "defaulted";
break;
default:
status = "defaulted";
break;
default:
}
ds_put_format(ds, "\nslave: %s: %s %s\n", slave->name, status,
}
ds_put_format(ds, "\nslave: %s: %s %s\n", slave->name, status,
&& (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
}
&& (flow->tp_src == htons(ND_NEIGHBOR_ADVERT)));
}
}
/* Set field and it's prerequisities in the mask.
}
/* Set field and it's prerequisities in the mask.
}
return mf->usable_protocols_bitwise;
}
return mf->usable_protocols_bitwise;
}
if (!error && !mf_is_mask_valid(mf, mask)) {
}
if (!error && !mf_is_mask_valid(mf, mask)) {
return algorithm_iter_hash(hash, n_links, arg);
}
return algorithm_iter_hash(hash, n_links, arg);
}
}
\f
/* Parses 's_' as a set of arguments to the "multipath" action and initializes
}
\f
/* Parses 's_' as a set of arguments to the "multipath" action and initializes
case NL_A_STRING: return 1;
case NL_A_FLAG: return 0;
case NL_A_NESTED: return 0;
case NL_A_STRING: return 1;
case NL_A_FLAG: return 0;
case NL_A_NESTED: return 0;
- case N_NL_ATTR_TYPES: default: NOT_REACHED();
+ case N_NL_ATTR_TYPES: default: OVS_NOT_REACHED();
case NL_A_STRING: return SIZE_MAX;
case NL_A_FLAG: return SIZE_MAX;
case NL_A_NESTED: return SIZE_MAX;
case NL_A_STRING: return SIZE_MAX;
case NL_A_FLAG: return SIZE_MAX;
case NL_A_NESTED: return SIZE_MAX;
- case N_NL_ATTR_TYPES: default: NOT_REACHED();
+ case N_NL_ATTR_TYPES: default: OVS_NOT_REACHED();
case OVS_KEY_ATTR_TCP_FLAGS:
case __OVS_KEY_ATTR_MAX:
default:
case OVS_KEY_ATTR_TCP_FLAGS:
case __OVS_KEY_ATTR_MAX:
default:
case OVS_SAMPLE_ATTR_UNSPEC:
case __OVS_SAMPLE_ATTR_MAX:
default:
case OVS_SAMPLE_ATTR_UNSPEC:
case __OVS_SAMPLE_ATTR_MAX:
default:
case OVS_ACTION_ATTR_UNSPEC:
case __OVS_ACTION_ATTR_MAX:
case OVS_ACTION_ATTR_UNSPEC:
case __OVS_ACTION_ATTR_MAX:
}
base->dl_type = flow->dl_type;
}
base->dl_type = flow->dl_type;
} else { \
return OFPERR_OFPBAC_BAD_LEN; \
} \
} else { \
return OFPERR_OFPBAC_BAD_LEN; \
} \
#include "ofp-util.def"
case CONSTANT_HTONS(NXAST_SNAT__OBSOLETE):
#include "ofp-util.def"
case CONSTANT_HTONS(NXAST_SNAT__OBSOLETE):
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
case OFPUTIL_NXAST_RESUBMIT:
resubmit_from_openflow(&a->resubmit, out);
case OFPUTIL_NXAST_RESUBMIT:
resubmit_from_openflow(&a->resubmit, out);
case OFPUTIL_ACTION_INVALID:
#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
case OFPUTIL_ACTION_INVALID:
#define OFPAT11_ACTION(ENUM, STRUCT, EXTENSIBLE, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
case OFPUTIL_OFPAT10_OUTPUT:
return output_from_openflow10(&a->output10, out);
case OFPUTIL_OFPAT10_OUTPUT:
return output_from_openflow10(&a->output10, out);
} else { \
return OFPERR_OFPBAC_BAD_LEN; \
} \
} else { \
return OFPERR_OFPBAC_BAD_LEN; \
} \
#include "ofp-util.def"
default:
#include "ofp-util.def"
default:
} else if (oh->version == OFP10_VERSION) {
set_field_to_openflow10(sf, openflow);
} else {
} else if (oh->version == OFP10_VERSION) {
set_field_to_openflow10(sf, openflow);
} else {
case OFPUTIL_ACTION_INVALID:
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
case OFPUTIL_ACTION_INVALID:
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) case OFPUTIL_##ENUM:
#include "ofp-util.def"
case OFPUTIL_OFPAT11_OUTPUT:
return output_from_openflow11(&a->ofp11_output, out);
case OFPUTIL_OFPAT11_OUTPUT:
return output_from_openflow11(&a->ofp11_output, out);
case OFPACT_WRITE_METADATA:
return false;
default:
case OFPACT_WRITE_METADATA:
return false;
default:
case OFPACT_WRITE_METADATA:
return false;
default:
case OFPACT_WRITE_METADATA:
return false;
default:
case OFPACT_GOTO_TABLE:
case OFPACT_METER:
case OFPACT_SET_FIELD:
case OFPACT_GOTO_TABLE:
case OFPACT_METER:
case OFPACT_SET_FIELD:
case OFPACT_WRITE_ACTIONS:
case OFPACT_GOTO_TABLE:
case OFPACT_METER:
case OFPACT_WRITE_ACTIONS:
case OFPACT_GOTO_TABLE:
case OFPACT_METER:
case OFPACT_GROUP:
ofputil_put_OFPAT11_GROUP(out)->group_id =
case OFPACT_GROUP:
ofputil_put_OFPAT11_GROUP(out)->group_id =
nsm->subtype = htonl(hdrs->subtype);
memset(nsm->pad, 0, sizeof nsm->pad);
} else {
nsm->subtype = htonl(hdrs->subtype);
memset(nsm->pad, 0, sizeof nsm->pad);
} else {
}
}
} else if (version != OFP10_VERSION
}
}
} else if (version != OFP10_VERSION
nsm->subtype = htonl(hdrs->subtype);
} else {
nsm->subtype = htonl(hdrs->subtype);
} else {
hdrs.type = OFPT11_STATS_REPLY;
break;
default:
hdrs.type = OFPT11_STATS_REPLY;
break;
default:
}
error = ofpraw_from_ofphdrs(&reply_raw, &hdrs);
}
error = ofpraw_from_ofphdrs(&reply_raw, &hdrs);
case OFP13_VERSION:
return &((struct ofp11_stats_msg *) oh)->flags;
default:
case OFP13_VERSION:
return &((struct ofp11_stats_msg *) oh)->flags;
default:
switch (code) {
case OFPUTIL_ACTION_INVALID:
switch (code) {
case OFPUTIL_ACTION_INVALID:
case OFPUTIL_OFPAT10_OUTPUT:
case OFPUTIL_OFPAT11_OUTPUT:
case OFPUTIL_OFPAT10_OUTPUT:
case OFPUTIL_OFPAT11_OUTPUT:
break;
case OFPUTIL_OFPAT11_DEC_NW_TTL:
break;
case OFPUTIL_OFPAT11_DEC_NW_TTL:
case OFPUTIL_OFPAT10_SET_TP_SRC:
case OFPUTIL_OFPAT11_SET_TP_SRC:
case OFPUTIL_OFPAT10_SET_TP_SRC:
case OFPUTIL_OFPAT11_SET_TP_SRC:
case OFPUTIL_NXAST_RESUBMIT_TABLE:
case OFPUTIL_NXAST_OUTPUT_REG:
case OFPUTIL_NXAST_DEC_TTL_CNT_IDS:
case OFPUTIL_NXAST_RESUBMIT_TABLE:
case OFPUTIL_NXAST_OUTPUT_REG:
case OFPUTIL_NXAST_DEC_TTL_CNT_IDS:
case OFPUTIL_NXAST_LEARN:
error = learn_parse(arg, ofpacts);
case OFPUTIL_NXAST_LEARN:
error = learn_parse(arg, ofpacts);
switch (type) {
case OVSINST_OFPIT11_APPLY_ACTIONS:
switch (type) {
case OVSINST_OFPIT11_APPLY_ACTIONS:
- NOT_REACHED(); /* This case is handled by str_to_inst_ofpacts() */
+ OVS_NOT_REACHED(); /* This case is handled by str_to_inst_ofpacts() */
break;
case OVSINST_OFPIT11_WRITE_ACTIONS: {
break;
case OVSINST_OFPIT11_WRITE_ACTIONS: {
}
match_init_catchall(&fm->match);
}
match_init_catchall(&fm->match);
}
memset(gm, 0, sizeof *gm);
}
memset(gm, 0, sizeof *gm);
case OFP13_VERSION:
return; /* no ports in ofp13_switch_features */
default:
case OFP13_VERSION:
return; /* no ports in ofp13_switch_features */
default:
}
ofp_print_phy_ports(string, oh->version, &b);
}
ofp_print_phy_ports(string, oh->version, &b);
ds_put_cstr(string, "slave");
break;
default:
ds_put_cstr(string, "slave");
break;
default:
}
if (generation_id != UINT64_MAX) {
}
if (generation_id != UINT64_MAX) {
ds_put_cstr(string, "experimenter_data_changed");
break;
default:
ds_put_cstr(string, "experimenter_data_changed");
break;
default:
return NXM_TYPICAL_LEN;
default:
return NXM_TYPICAL_LEN;
default:
case OFPUTIL_P_OF10_STD_TID:
case OFPUTIL_P_OF10_NXM:
case OFPUTIL_P_OF10_NXM_TID:
case OFPUTIL_P_OF10_STD_TID:
case OFPUTIL_P_OF10_NXM:
case OFPUTIL_P_OF10_NXM_TID:
case OFPUTIL_P_OF11_STD: {
struct ofp11_match *om;
case OFPUTIL_P_OF11_STD: {
struct ofp11_match *om;
return oxm_put_match(b, match);
}
return oxm_put_match(b, match);
}
}
/* Given a 'dl_type' value in the format used in struct flow, returns the
}
/* Given a 'dl_type' value in the format used in struct flow, returns the
}
/* Returns a bitmap of OpenFlow versions that are supported by at
}
/* Returns a bitmap of OpenFlow versions that are supported by at
return OFPUTIL_P_OF13_OXM;
default:
return OFPUTIL_P_OF13_OXM;
default:
return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
default:
return ofputil_protocol_set_tid(OFPUTIL_P_OF13_OXM, tid);
default:
case OFP13_VERSION:
return "OpenFlow13";
default:
case OFP13_VERSION:
return "OpenFlow13";
default:
case NXPIF_NXM:
return "nxm";
default:
case NXPIF_NXM:
return "nxm";
default:
case OFPUTIL_P_OF13_OXM:
/* There is only one variant of each OpenFlow 1.1+ protocol, and we
* verified above that we're not trying to change versions. */
case OFPUTIL_P_OF13_OXM:
/* There is only one variant of each OpenFlow 1.1+ protocol, and we
* verified above that we're not trying to change versions. */
case OFPUTIL_P_OF10_STD_TID:
case OFPUTIL_P_OF10_NXM_TID:
case OFPUTIL_P_OF10_STD_TID:
case OFPUTIL_P_OF10_NXM_TID:
case NXFF_NXM:
return "nxm";
default:
case NXFF_NXM:
return "nxm";
default:
fm->out_group = OFPG11_ANY;
raw_flags = nfm->flags;
} else {
fm->out_group = OFPG11_ANY;
raw_flags = nfm->flags;
} else {
}
fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
}
fm->modify_cookie = fm->new_cookie != OVS_BE64_MAX;
}
ofpmsg_update_length(msg);
}
ofpmsg_update_length(msg);
return ofputil_port_from_ofp11(qgcr11->port, port);
}
return ofputil_port_from_ofp11(qgcr11->port, port);
}
}
/* Constructs and returns the beginning of a reply to
}
/* Constructs and returns the beginning of a reply to
return ofputil_port_from_ofp11(qgcr11->port, port);
}
return ofputil_port_from_ofp11(qgcr11->port, port);
}
default:
/* Hey, the caller lied. */
default:
/* Hey, the caller lied. */
fs->byte_count = ntohll(nfs->byte_count);
fs->flags = 0;
} else {
fs->byte_count = ntohll(nfs->byte_count);
fs->flags = 0;
} else {
}
fs->ofpacts = ofpacts->data;
}
fs->ofpacts = ofpacts->data;
nfs->packet_count = htonll(fs->packet_count);
nfs->byte_count = htonll(fs->byte_count);
} else {
nfs->packet_count = htonll(fs->packet_count);
nfs->byte_count = htonll(fs->byte_count);
} else {
}
ofpmp_postappend(replies, start_ofs);
}
ofpmp_postappend(replies, start_ofs);
fr->packet_count = ntohll(nfr->packet_count);
fr->byte_count = ntohll(nfr->byte_count);
} else {
fr->packet_count = ntohll(nfr->packet_count);
fr->byte_count = ntohll(nfr->byte_count);
} else {
ofputil_decode_packet_in_finish(pin, &match, &b);
} else {
ofputil_decode_packet_in_finish(pin, &match, &b);
} else {
}
ofpmsg_update_length(packet);
}
ofpmsg_update_length(packet);
}
if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX)
}
if (ofp_to_u16(po->in_port) >= ofp_to_u16(OFPP_MAX)
case OFP13_VERSION:
return sizeof(struct ofp11_port);
default:
case OFP13_VERSION:
return sizeof(struct ofp11_port);
default:
raw = OFPRAW_OFPT13_FEATURES_REPLY;
break;
default:
raw = OFPRAW_OFPT13_FEATURES_REPLY;
break;
default:
}
b = ofpraw_alloc_xid(raw, version, xid, 0);
osf = ofpbuf_put_zeros(b, sizeof *osf);
}
b = ofpraw_alloc_xid(raw, version, xid, 0);
osf = ofpbuf_put_zeros(b, sizeof *osf);
}
b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
}
b = ofpraw_alloc_xid(raw, version, htonl(0), 0);
rr->have_generation_id = false;
rr->generation_id = 0;
} else {
rr->have_generation_id = false;
rr->generation_id = 0;
} else {
nrr = ofpbuf_put_zeros(buf, sizeof *nrr);
nrr->role = htonl(rr->role - 1);
} else {
nrr = ofpbuf_put_zeros(buf, sizeof *nrr);
nrr->role = htonl(rr->role - 1);
} else {
}
if (po->buffer_id == UINT32_MAX) {
}
if (po->buffer_id == UINT32_MAX) {
}
return ofpraw_alloc(type, ofp_version, 0);
}
return ofpraw_alloc(type, ofp_version, 0);
case OFPC_FRAG_NX_MATCH: return "nx-match";
}
case OFPC_FRAG_NX_MATCH: return "nx-match";
}
return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
}
default:
return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
}
default:
{
switch (code) {
case OFPUTIL_ACTION_INVALID:
{
switch (code) {
case OFPUTIL_ACTION_INVALID:
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
#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"
}
case OFPUTIL_##ENUM: return ofputil_put_##ENUM(buf);
#include "ofp-util.def"
}
}
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
}
#define OFPAT10_ACTION(ENUM, STRUCT, NAME) \
case OFP13_VERSION:
return sizeof(struct ofp13_port_stats);
default:
case OFP13_VERSION:
return sizeof(struct ofp13_port_stats);
default:
}
return ofputil_port_stats_from_ofp10(ps, ps10);
} else {
}
return ofputil_port_stats_from_ofp10(ps, ps10);
} else {
case OFP10_VERSION:
default:
case OFP10_VERSION:
default:
case OFP13_VERSION:
return sizeof(struct ofp13_queue_stats);
default:
case OFP13_VERSION:
return sizeof(struct ofp13_queue_stats);
default:
}
return ofputil_queue_stats_from_ofp10(qs, qs10);
} else {
}
return ofputil_queue_stats_from_ofp10(qs, qs10);
} else {
break;
case OFPBUF_STACK:
break;
case OFPBUF_STACK:
case OFPBUF_STUB:
b->source = OFPBUF_MALLOC;
case OFPBUF_STUB:
b->source = OFPBUF_MALLOC;
}
b->allocated = new_allocated;
}
b->allocated = new_allocated;
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
atom->integer = 0;
case OVSDB_TYPE_INTEGER:
atom->integer = 0;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
return atom->integer == 0;
case OVSDB_TYPE_INTEGER:
return atom->integer == 0;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
new->integer = old->integer;
case OVSDB_TYPE_INTEGER:
new->integer = old->integer;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
return hash_int(atom->integer, basis);
case OVSDB_TYPE_INTEGER:
return hash_int(atom->integer, basis);
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
return a->integer < b->integer ? -1 : a->integer > b->integer;
case OVSDB_TYPE_INTEGER:
return a->integer < b->integer ? -1 : a->integer > b->integer;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
switch (type) {
case OVSDB_TYPE_VOID:
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
if (json->type == JSON_INTEGER) {
case OVSDB_TYPE_INTEGER:
if (json->type == JSON_INTEGER) {
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
}
return ovsdb_syntax_error(json, NULL, "expected %s",
}
return ovsdb_syntax_error(json, NULL, "expected %s",
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
return json_integer_create(atom->integer);
case OVSDB_TYPE_INTEGER:
return json_integer_create(atom->integer);
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
switch (type) {
case OVSDB_TYPE_VOID:
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
json.type = JSON_INTEGER;
case OVSDB_TYPE_INTEGER:
json.type = JSON_INTEGER;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
}
return json_serialized_length(&json);
}
return json_serialized_length(&json);
switch (type) {
case OVSDB_TYPE_VOID:
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER: {
long long int integer;
case OVSDB_TYPE_INTEGER: {
long long int integer;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
{
switch (type) {
case OVSDB_TYPE_VOID:
{
switch (type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
ds_put_format(out, "%"PRId64, atom->integer);
case OVSDB_TYPE_INTEGER:
ds_put_format(out, "%"PRId64, atom->integer);
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
switch (base->type) {
case OVSDB_TYPE_VOID:
switch (base->type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
if (atom->integer >= base->u.integer.min
case OVSDB_TYPE_INTEGER:
if (atom->integer >= base->u.integer.min
"value %"PRId64,
atom->integer, base->u.integer.max);
}
"value %"PRId64,
atom->integer, base->u.integer.max);
}
case OVSDB_TYPE_REAL:
if (atom->real >= base->u.real.min && atom->real <= base->u.real.max) {
case OVSDB_TYPE_REAL:
if (atom->real >= base->u.real.min && atom->real <= base->u.real.max) {
DBL_DIG, atom->real,
DBL_DIG, base->u.real.max);
}
DBL_DIG, atom->real,
DBL_DIG, base->u.real.max);
}
case OVSDB_TYPE_BOOLEAN:
return NULL;
case OVSDB_TYPE_BOOLEAN:
return NULL;
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
{
struct ovsdb_error *error = ovsdb_datum_sort(datum, key_type);
if (error) {
{
struct ovsdb_error *error = ovsdb_datum_sort(datum, key_type);
if (error) {
}
/* Turns off OVSDB_IDL_ALERT for 'column' in 'idl'.
}
/* Turns off OVSDB_IDL_ALERT for 'column' in 'idl'.
break;
case OVSDB_N_TYPES:
break;
case OVSDB_N_TYPES:
case OVSDB_N_TYPES:
default:
case OVSDB_N_TYPES:
default:
break;
case OVSDB_N_TYPES:
break;
case OVSDB_N_TYPES:
switch (base->type) {
case OVSDB_TYPE_VOID:
switch (base->type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
return (base->u.integer.min != INT64_MIN
case OVSDB_TYPE_INTEGER:
return (base->u.integer.min != INT64_MIN
return base->u.uuid.refTableName != NULL;
case OVSDB_N_TYPES:
return base->u.uuid.refTableName != NULL;
case OVSDB_N_TYPES:
switch (base->type) {
case OVSDB_TYPE_VOID:
switch (base->type) {
case OVSDB_TYPE_VOID:
case OVSDB_TYPE_INTEGER:
if (base->u.integer.min != INT64_MIN) {
case OVSDB_TYPE_INTEGER:
if (base->u.integer.min != INT64_MIN) {
break;
case OVSDB_N_TYPES:
break;
case OVSDB_N_TYPES:
STATES
#undef STATE
default:
STATES
#undef STATE
default:
}
} while (rc->state != old_state);
ovs_mutex_unlock(&rc->mutex);
}
} while (rc->state != old_state);
ovs_mutex_unlock(&rc->mutex);
STATES
#undef STATE
default:
STATES
#undef STATE
default:
return fsm->state_entered;
}
return fsm->state_entered;
}
}
/* Assesses whether any action should be taken on 'fsm'. The return value is
}
/* Assesses whether any action should be taken on 'fsm'. The return value is
case STP_BLOCKING:
return "blocking";
default:
case STP_BLOCKING:
return "blocking";
default:
case STP_ROLE_DISABLED:
return "disabled";
default:
case STP_ROLE_DISABLED:
return "disabled";
default:
{
switch (want) {
case SSL_NOTHING:
{
switch (want) {
case SSL_NOTHING:
case SSL_READING:
return POLLIN;
case SSL_READING:
return POLLIN;
return stream->error;
default:
return stream->error;
default:
}
} while (stream->state != last_state);
}
} while (stream->state != last_state);
case 0:
VLOG_ABORT("%s: assertion %s failed in %s()",
where, condition, function);
case 0:
VLOG_ABORT("%s: assertion %s failed in %s()",
where, condition, function);
case 1:
fprintf(stderr, "%s: assertion %s failed in %s()",
case 1:
fprintf(stderr, "%s: assertion %s failed in %s()",
case SCAN_INTMAX_T:
case SCAN_PTRDIFF_T:
case SCAN_SIZE_T:
case SCAN_INTMAX_T:
case SCAN_PTRDIFF_T:
case SCAN_SIZE_T:
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
#endif
#define MAX(X, Y) ((X) > (Y) ? (X) : (Y))
#endif
-#define NOT_REACHED() abort()
+#define OVS_NOT_REACHED() abort()
/* Expands to a string that looks like "<file>:<line>", e.g. "tmp.c:10".
*
/* Expands to a string that looks like "<file>:<line>", e.g. "tmp.c:10".
*
return vconn->error;
default:
return vconn->error;
default:
}
} while (vconn->state != last_state);
}
} while (vconn->state != last_state);
case BM_AB:
return "active-backup";
}
case BM_AB:
return "active-backup";
}
out:
ovs_rwlock_unlock(&rwlock);
return verdict;
out:
ovs_rwlock_unlock(&rwlock);
return verdict;
return e->slave;
default:
return e->slave;
default:
default:
case NXFME_ABBREV:
default:
case NXFME_ABBREV:
}
LIST_FOR_EACH (ofconn, node, &mgr->all_conns) {
}
LIST_FOR_EACH (ofconn, node, &mgr->all_conns) {
case BAD_UPCALL:
break;
case MISS_UPCALL:
case BAD_UPCALL:
break;
case MISS_UPCALL:
}
dpif_ipfix_unref(ipfix);
}
dpif_ipfix_unref(ipfix);
return vid ? vid : in_xbundle->vlan;
default:
return vid ? vid : in_xbundle->vlan;
default:
return vlan == out_xbundle->vlan ? 0 : vlan;
default:
return vlan == out_xbundle->vlan ? 0 : vlan;
default:
xlate_ff_group(ctx, group);
break;
default:
xlate_ff_group(ctx, group);
break;
default:
}
group_dpif_release(group);
}
}
group_dpif_release(group);
}
ofpacts = actions->ofpacts;
ofpacts_len = actions->ofpacts_len;
} else {
ofpacts = actions->ofpacts;
ofpacts_len = actions->ofpacts_len;
} else {
}
ofpbuf_use_stub(&ctx.stack, ctx.init_stack, sizeof ctx.init_stack);
}
ofpbuf_use_stub(&ctx.stack, ctx.init_stack, sizeof ctx.init_stack);
goto out;
case OFPC_FRAG_REASM:
goto out;
case OFPC_FRAG_REASM:
case OFPC_FRAG_NX_MATCH:
/* Nothing to do. */
break;
case OFPC_INVALID_TTL_TO_CONTROLLER:
case OFPC_FRAG_NX_MATCH:
/* Nothing to do. */
break;
case OFPC_INVALID_TTL_TO_CONTROLLER:
rulep)) {
rule_dpif_unref(*rulep);
} else {
rulep)) {
rule_dpif_unref(*rulep);
} else {
}
if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
free(bundle->trunks);
}
if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
free(bundle->trunks);
}
if (time_msec() >= p->next_op_report) {
}
if (time_msec() >= p->next_op_report) {
op->actions->ofpacts_len, out_port);
}
op->actions->ofpacts_len, out_port);
}
* actions, so that when the operation commits we report the change. */
switch (op->type) {
case OFOPERATION_ADD:
* actions, so that when the operation commits we report the change. */
switch (op->type) {
case OFOPERATION_ADD:
case OFOPERATION_MODIFY:
case OFOPERATION_REPLACE:
case OFOPERATION_MODIFY:
case OFOPERATION_REPLACE:
}
}
fu.ofpacts = actions ? actions->ofpacts : NULL;
}
}
fu.ofpacts = actions ? actions->ofpacts : NULL;
}
ofmonitor_report(ofproto->connmgr, rule, event_type,
}
ofmonitor_report(ofproto->connmgr, rule, event_type,
}
ofoperation_destroy(op);
}
ofoperation_destroy(op);
case OVSDB_F_LE:
case OVSDB_F_GE:
case OVSDB_F_GT:
case OVSDB_F_LE:
case OVSDB_F_GE:
case OVSDB_F_GT:
flags = O_RDWR | O_CREAT | O_EXCL;
}
} else {
flags = O_RDWR | O_CREAT | O_EXCL;
}
} else {
}
fd = open(name, flags, 0666);
if (fd < 0) {
}
fd = open(name, flags, 0666);
if (fd < 0) {
}
for (i = 0; i < dst->n; i++) {
}
for (i = 0; i < dst->n; i++) {
}
if (error) {
return error;
}
if (error) {
return error;
^ wild.flow.in_port.ofp_port)
& wild.wc.masks.in_port.ofp_port);
} else {
^ wild.flow.in_port.ofp_port)
& wild.wc.masks.in_port.ofp_port);
} else {
} else if (f_idx == CLS_F_IDX_IN_PORT) {
match.wc.masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX);
} else {
} else if (f_idx == CLS_F_IDX_IN_PORT) {
match.wc.masks.in_port.ofp_port = u16_to_ofp(UINT16_MAX);
} else {
}
/* 16 randomly chosen flows with N >= 3 nonzero values. */
}
/* 16 randomly chosen flows with N >= 3 nonzero values. */
found:
heap_remove(&heap, &element->heap_node);
found:
heap_remove(&heap, &element->heap_node);
found:
heap_raw_remove(&heap, &element->heap_node);
found:
heap_raw_remove(&heap, &element->heap_node);
switch (action) {
default:
if (action != 0) {
switch (action) {
default:
if (action != 0) {
} else if (cmd_result) {
fputs(cmd_result, stdout);
} else {
} else if (cmd_result) {
fputs(cmd_result, stdout);
} else {
exit(EXIT_FAILURE);
default:
exit(EXIT_FAILURE);
default:
case OFP13_VERSION:
break;
default:
case OFP13_VERSION:
break;
default:
exit(EXIT_FAILURE);
default:
exit(EXIT_FAILURE);
default:
struct uuid dummy;
if (!uuid_from_string(&dummy, ds_cstr(&ctx->output))) {
struct uuid dummy;
if (!uuid_from_string(&dummy, ds_cstr(&ctx->output))) {
}
real = ovsdb_idl_txn_get_insert_uuid(ctx->txn, &dummy);
if (real) {
}
real = ovsdb_idl_txn_get_insert_uuid(ctx->txn, &dummy);
if (real) {
return ovsdb_datum_includes_all(b, a, type);
default:
return ovsdb_datum_includes_all(b, a, type);
default:
switch (status) {
case TXN_UNCOMMITTED:
case TXN_INCOMPLETE:
switch (status) {
case TXN_UNCOMMITTED:
case TXN_INCOMPLETE:
case TXN_ABORTED:
/* Should not happen--we never call ovsdb_idl_txn_abort(). */
case TXN_ABORTED:
/* Should not happen--we never call ovsdb_idl_txn_abort(). */
vsctl_fatal("database not locked");
default:
vsctl_fatal("database not locked");
default:
struct uuid dummy;
if (!uuid_from_string(&dummy, ds_cstr(&ctx->output))) {
struct uuid dummy;
if (!uuid_from_string(&dummy, ds_cstr(&ctx->output))) {
}
real = ovsdb_idl_txn_get_insert_uuid(ctx->txn, &dummy);
if (real) {
}
real = ovsdb_idl_txn_get_insert_uuid(ctx->txn, &dummy);
if (real) {
return ovsdb_datum_includes_all(b, a, type);
default:
return ovsdb_datum_includes_all(b, a, type);
default:
switch (status) {
case TXN_UNCOMMITTED:
case TXN_INCOMPLETE:
switch (status) {
case TXN_UNCOMMITTED:
case TXN_INCOMPLETE:
case TXN_ABORTED:
/* Should not happen--we never call ovsdb_idl_txn_abort(). */
case TXN_ABORTED:
/* Should not happen--we never call ovsdb_idl_txn_abort(). */
vtep_ctl_fatal("database not locked");
default:
vtep_ctl_fatal("database not locked");
default: