/*
- * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
* Copyright (c) 2010 Jean Tourrilhes - HP-Labs.
*
* Licensed under the Apache License, Version 2.0 (the "License");
OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT);
ofproto->forward_bpdu = false;
ofproto->fallback_dpid = pick_fallback_dpid();
- ofproto->mfr_desc = xstrdup(DEFAULT_MFR_DESC);
- ofproto->hw_desc = xstrdup(DEFAULT_HW_DESC);
- ofproto->sw_desc = xstrdup(DEFAULT_SW_DESC);
- ofproto->serial_desc = xstrdup(DEFAULT_SERIAL_DESC);
- ofproto->dp_desc = xstrdup(DEFAULT_DP_DESC);
+ ofproto->mfr_desc = NULL;
+ ofproto->hw_desc = NULL;
+ ofproto->sw_desc = NULL;
+ ofproto->serial_desc = NULL;
+ ofproto->dp_desc = NULL;
ofproto->frag_handling = OFPC_FRAG_NORMAL;
hmap_init(&ofproto->ports);
shash_init(&ofproto->port_by_name);
ofproto->max_ports = OFPP_MAX;
ofproto->tables = NULL;
ofproto->n_tables = 0;
+ list_init(&ofproto->expirable);
ofproto->connmgr = connmgr_create(ofproto, datapath_name, datapath_name);
ofproto->state = S_OPENFLOW;
list_init(&ofproto->pending);
bitmap_set1(ofproto->ofp_port_ids, 0);
/* Check that hidden tables, if any, are at the end. */
- assert(ofproto->n_tables);
+ ovs_assert(ofproto->n_tables);
for (i = 0; i + 1 < ofproto->n_tables; i++) {
enum oftable_flags flags = ofproto->tables[i].flags;
enum oftable_flags next_flags = ofproto->tables[i + 1].flags;
- assert(!(flags & OFTABLE_HIDDEN) || next_flags & OFTABLE_HIDDEN);
+ ovs_assert(!(flags & OFTABLE_HIDDEN) || next_flags & OFTABLE_HIDDEN);
}
ofproto->datapath_id = pick_datapath_id(ofproto);
{
struct oftable *table;
- assert(!ofproto->n_tables);
- assert(n_tables >= 1 && n_tables <= 255);
+ ovs_assert(!ofproto->n_tables);
+ ovs_assert(n_tables >= 1 && n_tables <= 255);
ofproto->n_tables = n_tables;
ofproto->tables = xmalloc(n_tables * sizeof *ofproto->tables);
void
ofproto_init_max_ports(struct ofproto *ofproto, uint16_t max_ports)
{
- assert(max_ports <= OFPP_MAX);
+ ovs_assert(max_ports <= OFPP_MAX);
ofproto->max_ports = max_ports;
}
}
/* Sets the MAC aging timeout for the OFPP_NORMAL action on 'ofproto' to
- * 'idle_time', in seconds. */
+ * 'idle_time', in seconds, and the maximum number of MAC table entries to
+ * 'max_entries'. */
void
-ofproto_set_mac_idle_time(struct ofproto *ofproto, unsigned idle_time)
+ofproto_set_mac_table_config(struct ofproto *ofproto, unsigned idle_time,
+ size_t max_entries)
{
- if (ofproto->ofproto_class->set_mac_idle_time) {
- ofproto->ofproto_class->set_mac_idle_time(ofproto, idle_time);
+ if (ofproto->ofproto_class->set_mac_table_config) {
+ ofproto->ofproto_class->set_mac_table_config(ofproto, idle_time,
+ max_entries);
}
}
void
-ofproto_set_desc(struct ofproto *p,
- const char *mfr_desc, const char *hw_desc,
- const char *sw_desc, const char *serial_desc,
- const char *dp_desc)
+ofproto_set_dp_desc(struct ofproto *p, const char *dp_desc)
{
- struct ofp_desc_stats *ods;
-
- if (mfr_desc) {
- if (strlen(mfr_desc) >= sizeof ods->mfr_desc) {
- VLOG_WARN("%s: truncating mfr_desc, must be less than %zu bytes",
- p->name, sizeof ods->mfr_desc);
- }
- free(p->mfr_desc);
- p->mfr_desc = xstrdup(mfr_desc);
- }
- if (hw_desc) {
- if (strlen(hw_desc) >= sizeof ods->hw_desc) {
- VLOG_WARN("%s: truncating hw_desc, must be less than %zu bytes",
- p->name, sizeof ods->hw_desc);
- }
- free(p->hw_desc);
- p->hw_desc = xstrdup(hw_desc);
- }
- if (sw_desc) {
- if (strlen(sw_desc) >= sizeof ods->sw_desc) {
- VLOG_WARN("%s: truncating sw_desc, must be less than %zu bytes",
- p->name, sizeof ods->sw_desc);
- }
- free(p->sw_desc);
- p->sw_desc = xstrdup(sw_desc);
- }
- if (serial_desc) {
- if (strlen(serial_desc) >= sizeof ods->serial_num) {
- VLOG_WARN("%s: truncating serial_desc, must be less than %zu "
- "bytes", p->name, sizeof ods->serial_num);
- }
- free(p->serial_desc);
- p->serial_desc = xstrdup(serial_desc);
- }
- if (dp_desc) {
- if (strlen(dp_desc) >= sizeof ods->dp_desc) {
- VLOG_WARN("%s: truncating dp_desc, must be less than %zu bytes",
- p->name, sizeof ods->dp_desc);
- }
- free(p->dp_desc);
- p->dp_desc = xstrdup(dp_desc);
- }
+ free(p->dp_desc);
+ p->dp_desc = dp_desc ? xstrdup(dp_desc) : NULL;
}
int
{
struct oftable *table;
- assert(table_id >= 0 && table_id < ofproto->n_tables);
+ ovs_assert(table_id >= 0 && table_id < ofproto->n_tables);
table = &ofproto->tables[table_id];
oftable_set_name(table, s->name);
{
struct oftable *table;
- assert(list_is_empty(&ofproto->pending));
- assert(!ofproto->n_pending);
+ ovs_assert(list_is_empty(&ofproto->pending));
+ ovs_assert(!ofproto->n_pending);
connmgr_destroy(ofproto->connmgr);
alloc_ofp_port(struct ofproto *ofproto, const char *netdev_name)
{
uint16_t ofp_port;
+ uint16_t end_port_no = ofproto->alloc_port_no;
ofp_port = simap_get(&ofproto->ofp_requests, netdev_name);
ofp_port = ofp_port ? ofp_port : OFPP_NONE;
if (ofp_port >= ofproto->max_ports
|| bitmap_is_set(ofproto->ofp_port_ids, ofp_port)) {
- bool retry = ofproto->alloc_port_no ? true : false;
-
/* Search for a free OpenFlow port number. We try not to
* immediately reuse them to prevent problems due to old
* flows. */
- while (ofp_port >= ofproto->max_ports) {
- for (ofproto->alloc_port_no++;
- ofproto->alloc_port_no < ofproto->max_ports;
- ofproto->alloc_port_no++) {
- if (!bitmap_is_set(ofproto->ofp_port_ids,
- ofproto->alloc_port_no)) {
- ofp_port = ofproto->alloc_port_no;
- break;
- }
+ for (;;) {
+ if (++ofproto->alloc_port_no >= ofproto->max_ports) {
+ ofproto->alloc_port_no = 0;
}
- if (ofproto->alloc_port_no >= ofproto->max_ports) {
- if (retry) {
- ofproto->alloc_port_no = 0;
- retry = false;
- } else {
- return OFPP_NONE;
- }
+ if (!bitmap_is_set(ofproto->ofp_port_ids,
+ ofproto->alloc_port_no)) {
+ ofp_port = ofproto->alloc_port_no;
+ break;
+ }
+ if (ofproto->alloc_port_no == end_port_no) {
+ return OFPP_NONE;
}
}
}
-
bitmap_set1(ofproto->ofp_port_ids, ofp_port);
return ofp_port;
}
static void
dealloc_ofp_port(const struct ofproto *ofproto, uint16_t ofp_port)
{
- bitmap_set0(ofproto->ofp_port_ids, ofp_port);
+ if (ofp_port < ofproto->max_ports) {
+ bitmap_set0(ofproto->ofp_port_ids, ofp_port);
+ }
}
/* Opens and returns a netdev for 'ofproto_port' in 'ofproto', or a null
}
SHASH_FOR_EACH_SAFE(node, next, &init_ofp_ports) {
- const struct iface_hint *iface_hint = node->data;
+ struct iface_hint *iface_hint = node->data;
if (!strcmp(iface_hint->br_name, p->name)) {
free(iface_hint->br_name);
free(iface_hint->br_type);
+ free(iface_hint);
shash_delete(&init_ofp_ports, node);
}
}
void
ofproto_rule_destroy(struct rule *rule)
{
- assert(!rule->pending);
+ ovs_assert(!rule->pending);
oftable_remove_rule(rule);
ofproto_rule_destroy__(rule);
}
bool
ofproto_rule_has_out_port(const struct rule *rule, uint16_t port)
{
- return (port == OFPP_NONE
+ return (port == OFPP_ANY
|| ofpacts_output_to_port(rule->ofpacts, rule->ofpacts_len, port));
}
/* Executes the actions indicated by 'rule' on 'packet' and credits 'rule''s
* statistics appropriately. 'packet' must have at least sizeof(struct
- * ofp_packet_in) bytes of headroom.
+ * ofp10_packet_in) bytes of headroom.
*
* 'packet' doesn't necessarily have to match 'rule'. 'rule' will be credited
* with statistics for 'packet' either way.
{
struct flow flow;
- assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
+ ovs_assert(ofpbuf_headroom(packet) >= sizeof(struct ofp10_packet_in));
flow_extract(packet, 0, 0, NULL, in_port, &flow);
return rule->ofproto->ofproto_class->rule_execute(rule, &flow, packet);
ofproto->ofproto_class->get_features(ofproto, &arp_match_ip,
&features.actions);
- assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */
+ ovs_assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */
/* Count only non-hidden tables in the number of tables. (Hidden tables,
* if present, are always at the end.) */
if (arp_match_ip) {
features.capabilities |= OFPUTIL_C_ARP_MATCH_IP;
}
-
+ /* FIXME: Fill in proper features.auxiliary_id for auxiliary connections */
+ features.auxiliary_id = 0;
b = ofputil_encode_switch_features(&features, ofconn_get_protocol(ofconn),
oh->xid);
HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
buf = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY, oh, 0);
osc = ofpbuf_put_uninit(buf, sizeof *osc);
flags = ofproto->frag_handling;
- if (ofconn_get_invalid_ttl_to_controller(ofconn)) {
+ /* OFPC_INVALID_TTL_TO_CONTROLLER is deprecated in OF 1.3 */
+ if (oh->version < OFP13_VERSION
+ && ofconn_get_invalid_ttl_to_controller(ofconn)) {
flags |= OFPC_INVALID_TTL_TO_CONTROLLER;
}
osc->flags = htons(flags);
enum ofp_config_flags cur = ofproto->frag_handling;
enum ofp_config_flags next = flags & OFPC_FRAG_MASK;
- assert((cur & OFPC_FRAG_MASK) == cur);
+ ovs_assert((cur & OFPC_FRAG_MASK) == cur);
if (cur != next) {
if (ofproto->ofproto_class->set_frag_handling(ofproto, next)) {
ofproto->frag_handling = next;
}
}
}
+ /* OFPC_INVALID_TTL_TO_CONTROLLER is deprecated in OF 1.3 */
ofconn_set_invalid_ttl_to_controller(ofconn,
- (flags & OFPC_INVALID_TTL_TO_CONTROLLER));
+ (oh->version < OFP13_VERSION
+ && flags & OFPC_INVALID_TTL_TO_CONTROLLER));
ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len));
handle_desc_stats_request(struct ofconn *ofconn,
const struct ofp_header *request)
{
+ static const char *default_mfr_desc = "Nicira, Inc.";
+ static const char *default_hw_desc = "Open vSwitch";
+ static const char *default_sw_desc = VERSION;
+ static const char *default_serial_desc = "None";
+ static const char *default_dp_desc = "None";
+
struct ofproto *p = ofconn_get_ofproto(ofconn);
struct ofp_desc_stats *ods;
struct ofpbuf *msg;
msg = ofpraw_alloc_stats_reply(request, 0);
ods = ofpbuf_put_zeros(msg, 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);
- ovs_strlcpy(ods->sw_desc, p->sw_desc, sizeof ods->sw_desc);
- ovs_strlcpy(ods->serial_num, p->serial_desc, sizeof ods->serial_num);
- ovs_strlcpy(ods->dp_desc, p->dp_desc, sizeof ods->dp_desc);
+ ovs_strlcpy(ods->mfr_desc, p->mfr_desc ? p->mfr_desc : default_mfr_desc,
+ sizeof ods->mfr_desc);
+ ovs_strlcpy(ods->hw_desc, p->hw_desc ? p->hw_desc : default_hw_desc,
+ sizeof ods->hw_desc);
+ ovs_strlcpy(ods->sw_desc, p->sw_desc ? p->sw_desc : default_sw_desc,
+ sizeof ods->sw_desc);
+ ovs_strlcpy(ods->serial_num,
+ p->serial_desc ? p->serial_desc : default_serial_desc,
+ sizeof ods->serial_num);
+ ovs_strlcpy(ods->dp_desc, p->dp_desc ? p->dp_desc : default_dp_desc,
+ sizeof ods->dp_desc);
ofconn_send_reply(ofconn, msg);
return 0;
}
ofpmp_init(&replies, request);
- if (port_no != OFPP_NONE) {
+ if (port_no != OFPP_ANY) {
port = ofproto_get_port(p, port_no);
if (port) {
append_port_stat(port, &replies);
* OpenFlow OFPFC_MODIFY and OFPFC_DELETE requests and puts them on list
* 'rules'.
*
- * If 'out_port' is anything other than OFPP_NONE, then only rules that output
+ * If 'out_port' is anything other than OFPP_ANY, then only rules that output
* to 'out_port' are included.
*
* Hidden rules are always omitted.
* OpenFlow OFPFC_MODIFY_STRICT and OFPFC_DELETE_STRICT requests and puts them
* on list 'rules'.
*
- * If 'out_port' is anything other than OFPP_NONE, then only rules that output
+ * If 'out_port' is anything other than OFPP_ANY, then only rules that output
* to 'out_port' are included.
*
* Hidden rules are always omitted.
&fs.byte_count);
fs.ofpacts = rule->ofpacts;
fs.ofpacts_len = rule->ofpacts_len;
+ fs.flags = 0;
+ if (rule->send_flow_removed) {
+ fs.flags |= OFPFF_SEND_FLOW_REM;
+ /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS
+ and OFPFF13_NO_BYT_COUNTS */
+ }
ofputil_append_flow_stats_reply(&fs, &replies);
}
ofconn_send_replies(ofconn, &replies);
ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
cls_rule_format(&rule->cr, results);
ds_put_char(results, ',');
- if (rule->ofpacts_len > 0) {
- ofpacts_format(rule->ofpacts, rule->ofpacts_len, results);
- } else {
- ds_put_cstr(results, "drop");
- }
+ ofpacts_format(rule->ofpacts, rule->ofpacts_len, results);
ds_put_cstr(results, "\n");
}
return error;
}
- if (oqsr.port_no == OFPP_ALL) {
+ if (oqsr.port_no == OFPP_ANY) {
error = OFPERR_OFPQOFC_BAD_QUEUE;
HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
if (!handle_queue_stats_for_port(port, oqsr.queue_id, &cbdata)) {
if (error) {
return error;
}
- assert(table_id < ofproto->n_tables);
+ ovs_assert(table_id < ofproto->n_tables);
table = &ofproto->tables[table_id];
} else {
table = &ofproto->tables[0];
return OFPERR_OFPFMFC_OVERLAP;
}
+ /* FIXME: Implement OFPFF12_RESET_COUNTS */
+
rule->ofproto = ofproto;
rule->pending = NULL;
rule->flow_cookie = fm->new_cookie;
rule->hard_timeout = fm->hard_timeout;
rule->table_id = table - ofproto->tables;
rule->send_flow_removed = (fm->flags & OFPFF_SEND_FLOW_REM) != 0;
+ /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS
+ and OFPFF13_NO_BYT_COUNTS */
rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len);
rule->ofpacts_len = fm->ofpacts_len;
rule->evictable = true;
rule->eviction_group = NULL;
+ list_init(&rule->expirable);
rule->monitor_flags = 0;
rule->add_seqno = 0;
rule->modify_seqno = 0;
bool actions_changed;
ovs_be64 new_cookie;
+ /* FIXME: Implement OFPFF12_RESET_COUNTS */
+
if (rule_is_modifiable(rule)) {
/* At least one rule is modifiable, don't report EPERM error. */
error = 0;
error = collect_rules_loose(ofproto, fm->table_id, &fm->match,
fm->cookie, fm->cookie_mask,
- OFPP_NONE, &rules);
+ OFPP_ANY, &rules);
if (error) {
return error;
} else if (list_is_empty(&rules)) {
error = collect_rules_strict(ofproto, fm->table_id, &fm->match,
fm->priority, fm->cookie, fm->cookie_mask,
- OFPP_NONE, &rules);
+ OFPP_ANY, &rules);
if (error) {
return error;
struct ofproto *ofproto = rule->ofproto;
struct ofopgroup *group;
- assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT);
+ ovs_assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT);
ofproto_rule_send_removed(rule, reason);
ofpbuf_use_stub(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
error = ofputil_decode_flow_mod(&fm, oh, ofconn_get_protocol(ofconn),
&ofpacts);
- if (error) {
- goto exit_free_ofpacts;
- }
-
- if (fm.flags & OFPFF10_EMERG) {
- /* We do not support the OpenFlow 1.0 emergency flow cache, which
- * is not required in OpenFlow 1.0.1 and removed from OpenFlow 1.1.
- * There is no good error code, so just state that the flow table
- * is full. */
- error = OFPERR_OFPFMFC_TABLE_FULL;
- }
if (!error) {
error = ofpacts_check(fm.ofpacts, fm.ofpacts_len,
&fm.match.flow, ofproto->max_ports);
}
if (!error) {
- error = handle_flow_mod__(ofconn_get_ofproto(ofconn), ofconn, &fm, oh);
+ error = handle_flow_mod__(ofproto, ofconn, &fm, oh);
}
if (error) {
goto exit_free_ofpacts;
const struct ofp_header *oh)
{
if (ofproto->n_pending >= 50) {
- assert(!list_is_empty(&ofproto->pending));
+ ovs_assert(!list_is_empty(&ofproto->pending));
return OFPROTO_POSTPONE;
}
static enum ofperr
handle_role_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
- const struct nx_role_request *nrr = ofpmsg_body(oh);
- struct nx_role_request *reply;
+ struct ofputil_role_request rr;
struct ofpbuf *buf;
uint32_t role;
+ enum ofperr error;
- role = ntohl(nrr->role);
- if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER
- && role != NX_ROLE_SLAVE) {
- return OFPERR_OFPRRFC_BAD_ROLE;
+ error = ofputil_decode_role_message(oh, &rr);
+ if (error) {
+ return error;
+ }
+
+ if (rr.request_current_role_only) {
+ role = ofconn_get_role(ofconn); /* NX_ROLE_* */
+ goto reply;
}
+ role = rr.role;
+
if (ofconn_get_role(ofconn) != role
&& ofconn_has_pending_opgroups(ofconn)) {
return OFPROTO_POSTPONE;
}
+ if (rr.have_generation_id) {
+ if (!ofconn_set_master_election_id(ofconn, rr.generation_id)) {
+ return OFPERR_OFPRRFC_STALE;
+ }
+ }
+
ofconn_set_role(ofconn, role);
- buf = ofpraw_alloc_reply(OFPRAW_NXT_ROLE_REPLY, oh, 0);
- reply = ofpbuf_put_zeros(buf, sizeof *reply);
- reply->role = htonl(role);
+reply:
+ buf = ofputil_encode_role_reply(oh, role);
ofconn_send_reply(ofconn, buf);
return 0;
cls_cursor_init(&cursor, &table->cls, &target);
CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
- assert(!rule->pending); /* XXX */
+ ovs_assert(!rule->pending); /* XXX */
ofproto_collect_ofmonitor_refresh_rule(m, rule, seqno, rules);
}
}
case OFPTYPE_BARRIER_REQUEST:
return handle_barrier_request(ofconn, oh);
+ case OFPTYPE_ROLE_REQUEST:
+ return handle_role_request(ofconn, oh);
+
/* OpenFlow replies. */
case OFPTYPE_ECHO_REPLY:
return 0;
/* Nicira extension requests. */
- case OFPTYPE_ROLE_REQUEST:
- return handle_role_request(ofconn, oh);
-
case OFPTYPE_FLOW_MOD_TABLE_ID:
return handle_nxt_flow_mod_table_id(ofconn, oh);
case OFPTYPE_FLOW_MONITOR_STATS_REQUEST:
return handle_flow_monitor_request(ofconn, oh);
+ /* FIXME: Change the following once they are implemented: */
+ case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
+ case OFPTYPE_GET_ASYNC_REQUEST:
+ case OFPTYPE_METER_MOD:
+ case OFPTYPE_GROUP_REQUEST:
+ case OFPTYPE_GROUP_DESC_REQUEST:
+ case OFPTYPE_GROUP_FEATURES_REQUEST:
+ case OFPTYPE_METER_REQUEST:
+ case OFPTYPE_METER_CONFIG_REQUEST:
+ case OFPTYPE_METER_FEATURES_REQUEST:
+ case OFPTYPE_TABLE_FEATURES_REQUEST:
+ return OFPERR_OFPBRC_BAD_TYPE;
+
case OFPTYPE_HELLO:
case OFPTYPE_ERROR:
case OFPTYPE_FEATURES_REPLY:
case OFPTYPE_FLOW_REMOVED:
case OFPTYPE_PORT_STATUS:
case OFPTYPE_BARRIER_REPLY:
+ case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
case OFPTYPE_DESC_STATS_REPLY:
case OFPTYPE_FLOW_STATS_REPLY:
case OFPTYPE_QUEUE_STATS_REPLY:
case OFPTYPE_FLOW_MONITOR_PAUSED:
case OFPTYPE_FLOW_MONITOR_RESUMED:
case OFPTYPE_FLOW_MONITOR_STATS_REPLY:
+ case OFPTYPE_GET_ASYNC_REPLY:
+ case OFPTYPE_GROUP_REPLY:
+ case OFPTYPE_GROUP_DESC_REPLY:
+ case OFPTYPE_GROUP_FEATURES_REPLY:
+ case OFPTYPE_METER_REPLY:
+ case OFPTYPE_METER_CONFIG_REPLY:
+ case OFPTYPE_METER_FEATURES_REPLY:
+ case OFPTYPE_TABLE_FEATURES_REPLY:
default:
return OFPERR_OFPBRC_BAD_TYPE;
}
if (ofconn) {
size_t request_len = ntohs(request->length);
- assert(ofconn_get_ofproto(ofconn) == ofproto);
+ ovs_assert(ofconn_get_ofproto(ofconn) == ofproto);
ofconn_add_opgroup(ofconn, &group->ofconn_node);
group->ofconn = ofconn;
struct ofoperation *op, *next_op;
int error;
- assert(!group->n_running);
+ ovs_assert(!group->n_running);
error = 0;
LIST_FOR_EACH (op, group_node, &group->ops) {
error = ofconn_pktbuf_retrieve(group->ofconn, group->buffer_id,
&packet, &in_port);
if (packet) {
- assert(!error);
+ ovs_assert(!error);
error = rule_execute(op->rule, in_port, packet);
}
break;
break;
case OFOPERATION_DELETE:
- assert(!op->error);
+ ovs_assert(!op->error);
ofproto_rule_destroy__(rule);
op->rule = NULL;
break;
ofmonitor_flush(ofproto->connmgr);
if (!list_is_empty(&group->ofproto_node)) {
- assert(ofproto->n_pending > 0);
+ ovs_assert(ofproto->n_pending > 0);
ofproto->n_pending--;
list_remove(&group->ofproto_node);
}
struct ofproto *ofproto = group->ofproto;
struct ofoperation *op;
- assert(!rule->pending);
+ ovs_assert(!rule->pending);
op = rule->pending = xzalloc(sizeof *op);
op->group = group;
{
struct ofopgroup *group = op->group;
- assert(op->rule->pending == op);
- assert(group->n_running > 0);
- assert(!error || op->type != OFOPERATION_DELETE);
+ ovs_assert(op->rule->pending == op);
+ ovs_assert(group->n_running > 0);
+ ovs_assert(!error || op->type != OFOPERATION_DELETE);
op->error = error;
if (!--group->n_running && !list_is_empty(&group->ofproto_node)) {
struct rule *
ofoperation_get_victim(struct ofoperation *op)
{
- assert(op->type == OFOPERATION_ADD);
+ ovs_assert(op->type == OFOPERATION_ADD);
return op->victim;
}
\f
static void
oftable_destroy(struct oftable *table)
{
- assert(classifier_is_empty(&table->cls));
+ ovs_assert(classifier_is_empty(&table->cls));
oftable_disable_eviction(table);
classifier_destroy(&table->cls);
free(table->name);
classifier_remove(&table->cls, &rule->cr);
eviction_group_remove_rule(rule);
+ if (!list_is_empty(&rule->expirable)) {
+ list_remove(&rule->expirable);
+ }
}
/* Inserts 'rule' into its oftable. Removes any existing rule from 'rule''s
struct ofproto *ofproto = rule->ofproto;
struct oftable *table = &ofproto->tables[rule->table_id];
struct rule *victim;
+ bool may_expire = rule->hard_timeout || rule->idle_timeout;
+
+ if (may_expire) {
+ list_insert(&ofproto->expirable, &rule->expirable);
+ }
victim = rule_from_cls_rule(classifier_replace(&table->cls, &rule->cr));
if (victim) {
struct ofport *ofport;
int error;
- assert(vlandev_ofp_port != realdev_ofp_port);
+ ovs_assert(vlandev_ofp_port != realdev_ofp_port);
ofport = ofproto_get_port(ofproto, vlandev_ofp_port);
if (!ofport) {
git://git.onelab.eu / sliver-openvswitch.git / blobdiff