#include "ofp-print.h"
#include "ofp-util.h"
#include "ofpbuf.h"
+#include "ofproto-provider.h"
#include "openflow/nicira-ext.h"
#include "openflow/openflow.h"
#include "packets.h"
#include "pinsched.h"
#include "pktbuf.h"
#include "poll-loop.h"
-#include "private.h"
#include "shash.h"
#include "sset.h"
#include "timeval.h"
{
const struct ofproto_class *class;
struct ofproto *ofproto;
+ int n_tables;
int error;
+ int i;
*ofprotop = NULL;
hmap_insert(&all_ofprotos, &ofproto->hmap_node,
hash_string(ofproto->name, 0));
ofproto->datapath_id = 0;
+ ofproto_set_flow_eviction_threshold(ofproto,
+ OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT);
ofproto->fallback_dpid = pick_fallback_dpid();
ofproto->mfr_desc = xstrdup(DEFAULT_MFR_DESC);
ofproto->hw_desc = xstrdup(DEFAULT_HW_DESC);
list_init(&ofproto->pending);
hmap_init(&ofproto->deletions);
- error = ofproto->ofproto_class->construct(ofproto);
+ error = ofproto->ofproto_class->construct(ofproto, &n_tables);
if (error) {
VLOG_ERR("failed to open datapath %s: %s",
datapath_name, strerror(error));
ofproto_destroy__(ofproto);
return error;
}
- assert(ofproto->n_tables > 0);
+
+ assert(n_tables >= 1 && n_tables <= 255);
+ ofproto->n_tables = n_tables;
+ ofproto->tables = xmalloc(n_tables * sizeof *ofproto->tables);
+ for (i = 0; i < n_tables; i++) {
+ classifier_init(&ofproto->tables[i]);
+ }
ofproto->datapath_id = pick_datapath_id(ofproto);
VLOG_INFO("using datapath ID %016"PRIx64, ofproto->datapath_id);
connmgr_set_in_band_queue(ofproto->connmgr, queue_id);
}
+/* Sets the number of flows at which eviction from the kernel flow table
+ * will occur. */
+void
+ofproto_set_flow_eviction_threshold(struct ofproto *ofproto, unsigned threshold)
+{
+ if (threshold < OFPROTO_FLOW_EVICTION_THRESHOLD_MIN) {
+ ofproto->flow_eviction_threshold = OFPROTO_FLOW_EVICTION_THRESHOLD_MIN;
+ } else {
+ ofproto->flow_eviction_threshold = threshold;
+ }
+}
+
void
ofproto_set_desc(struct ofproto *p,
const char *mfr_desc, const char *hw_desc,
void
ofproto_free_ofproto_controller_info(struct shash *info)
{
- struct shash_node *node;
-
- SHASH_FOR_EACH (node, info) {
- struct ofproto_controller_info *cinfo = node->data;
- while (cinfo->pairs.n) {
- free((char *) cinfo->pairs.values[--cinfo->pairs.n]);
- }
- free(cinfo);
- }
- shash_destroy(info);
+ connmgr_free_controller_info(info);
}
/* Makes a deep copy of 'old' into 'port'. */
ofport_open(const struct ofproto_port *ofproto_port, struct ofp_phy_port *opp)
{
uint32_t curr, advertised, supported, peer;
- struct netdev_options netdev_options;
enum netdev_flags flags;
struct netdev *netdev;
int error;
- memset(&netdev_options, 0, sizeof netdev_options);
- netdev_options.name = ofproto_port->name;
- netdev_options.type = ofproto_port->type;
- netdev_options.ethertype = NETDEV_ETH_TYPE_NONE;
-
- error = netdev_open(&netdev_options, &netdev);
+ error = netdev_open(ofproto_port->name, ofproto_port->type, &netdev);
if (error) {
VLOG_WARN_RL(&rl, "ignoring port %s (%"PRIu16") because netdev %s "
"cannot be opened (%s)",
/* This function allows an ofproto implementation to destroy any rules that
* remain when its ->destruct() function is called. The caller must have
* already uninitialized any derived members of 'rule' (step 5 described in the
- * large comment in ofproto/private.h titled "Life Cycle"). This function
- * implements steps 6 and 7.
+ * large comment in ofproto/ofproto-provider.h titled "Life Cycle").
+ * This function implements steps 6 and 7.
*
* This function should only be called from an ofproto implementation's
* ->destruct() function. It is not suitable elsewhere. */
rule_has_out_port(const struct rule *rule, uint16_t out_port)
{
const union ofp_action *oa;
- struct actions_iterator i;
+ size_t left;
if (out_port == OFPP_NONE) {
return true;
}
- for (oa = actions_first(&i, rule->actions, rule->n_actions); oa;
- oa = actions_next(&i)) {
+ OFPUTIL_ACTION_FOR_EACH_UNSAFE (oa, left, rule->actions, rule->n_actions) {
if (action_outputs_to_port(oa, htons(out_port))) {
return true;
}
flow_stats_ds(struct rule *rule, struct ds *results)
{
uint64_t packet_count, byte_count;
- size_t act_len = sizeof *rule->actions * rule->n_actions;
rule->ofproto->ofproto_class->rule_get_stats(rule,
&packet_count, &byte_count);
ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
cls_rule_format(&rule->cr, results);
ds_put_char(results, ',');
- if (act_len > 0) {
- ofp_print_actions(results, &rule->actions->header, act_len);
+ if (rule->n_actions > 0) {
+ ofp_print_actions(results, rule->actions, rule->n_actions);
} else {
ds_put_cstr(results, "drop");
}
struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
struct flow_stats_request request;
struct ofputil_aggregate_stats stats;
+ bool unknown_packets, unknown_bytes;
struct ofpbuf *reply;
struct list rules;
struct rule *rule;
}
memset(&stats, 0, sizeof stats);
+ unknown_packets = unknown_bytes = false;
LIST_FOR_EACH (rule, ofproto_node, &rules) {
uint64_t packet_count;
uint64_t byte_count;
ofproto->ofproto_class->rule_get_stats(rule, &packet_count,
&byte_count);
- stats.packet_count += packet_count;
- stats.byte_count += byte_count;
+ if (packet_count == UINT64_MAX) {
+ unknown_packets = true;
+ } else {
+ stats.packet_count += packet_count;
+ }
+
+ if (byte_count == UINT64_MAX) {
+ unknown_bytes = true;
+ } else {
+ stats.byte_count += byte_count;
+ }
+
stats.flow_count++;
}
+ if (unknown_packets) {
+ stats.packet_count = UINT64_MAX;
+ }
+ if (unknown_bytes) {
+ stats.byte_count = UINT64_MAX;
+ }
reply = ofputil_encode_aggregate_stats_reply(&stats, osm);
ofconn_send_reply(ofconn, reply);
/* Pick table. */
if (fm->table_id == 0xff) {
uint8_t table_id;
- if (ofproto->n_tables > 1) {
+ if (ofproto->ofproto_class->rule_choose_table) {
error = ofproto->ofproto_class->rule_choose_table(ofproto, &fm->cr,
&table_id);
if (error) {
case OFPUTIL_OFPST_QUEUE_REQUEST:
return handle_queue_stats_request(ofconn, msg->data);
- case OFPUTIL_INVALID:
+ case OFPUTIL_MSG_INVALID:
case OFPUTIL_OFPT_HELLO:
case OFPUTIL_OFPT_ERROR:
case OFPUTIL_OFPT_FEATURES_REPLY:
* If 'op' is a "delete flow" operation, 'error' must be 0. That is, flow
* deletions are not allowed to fail.
*
- * Please see the large comment in ofproto/private.h titled "Asynchronous
- * Operation Support" for more information. */
+ * 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)
{
git://git.onelab.eu / sliver-openvswitch.git / blobdiff