#include <netinet/in.h>
#include <stdbool.h>
#include <stdlib.h>
+#include "byte-order.h"
#include "classifier.h"
#include "coverage.h"
#include "discovery.h"
#include "unixctl.h"
#include "vconn.h"
#include "vlog.h"
-#include "xtoxll.h"
-VLOG_DEFINE_THIS_MODULE(ofproto)
+VLOG_DEFINE_THIS_MODULE(ofproto);
#include "sflow_api.h"
-enum {
- TABLEID_HASH = 0,
- TABLEID_CLASSIFIER = 1
-};
-
-
struct ofport {
struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */
struct netdev *netdev;
static void hton_ofp_phy_port(struct ofp_phy_port *);
static int xlate_actions(const union ofp_action *in, size_t n_in,
- const flow_t *flow, struct ofproto *ofproto,
+ const struct flow *, struct ofproto *,
const struct ofpbuf *packet,
struct odp_actions *out, tag_type *tags,
bool *may_set_up_flow, uint16_t *nf_output_iface);
struct rule {
struct cls_rule cr;
- uint64_t flow_cookie; /* Controller-issued identifier.
- (Kept in network-byte order.) */
+ ovs_be64 flow_cookie; /* Controller-issued identifier. */
uint16_t idle_timeout; /* In seconds from time of last use. */
uint16_t hard_timeout; /* In seconds from time of creation. */
bool send_flow_removed; /* Send a flow removed message? */
static struct rule *rule_create(struct ofproto *, struct rule *super,
const union ofp_action *, size_t n_actions,
uint16_t idle_timeout, uint16_t hard_timeout,
- uint64_t flow_cookie, bool send_flow_removed);
+ ovs_be64 flow_cookie, bool send_flow_removed);
static void rule_free(struct rule *);
static void rule_destroy(struct ofproto *, struct rule *);
static struct rule *rule_from_cls_rule(const struct cls_rule *);
struct rule *displaced_rule);
static void rule_uninstall(struct ofproto *, struct rule *);
static void rule_post_uninstall(struct ofproto *, struct rule *);
-static void send_flow_removed(struct ofproto *p, struct rule *rule,
- long long int now, uint8_t reason);
+static void send_flow_removed(struct ofproto *, struct rule *, uint8_t reason);
/* ofproto supports two kinds of OpenFlow connections:
*
struct list node; /* In struct ofproto's "all_conns" list. */
struct rconn *rconn; /* OpenFlow connection. */
enum ofconn_type type; /* Type. */
+ int flow_format; /* One of NXFF_*. */
/* OFPT_PACKET_IN related data. */
struct rconn_packet_counter *packet_in_counter; /* # queued on 'rconn'. */
static struct ofconn *ofconn_create(struct ofproto *, struct rconn *,
enum ofconn_type);
static void ofconn_destroy(struct ofconn *);
-static void ofconn_run(struct ofconn *, struct ofproto *);
+static void ofconn_run(struct ofconn *);
static void ofconn_wait(struct ofconn *);
static bool ofconn_receives_async_msgs(const struct ofconn *);
static char *ofconn_make_name(const struct ofproto *, const char *target);
bool need_revalidate;
long long int next_expiration;
struct tag_set revalidate_set;
- bool tun_id_from_cookie;
/* OpenFlow connections. */
struct hmap controllers; /* Controller "struct ofconn"s. */
static void handle_odp_msg(struct ofproto *, struct ofpbuf *);
-static void handle_openflow(struct ofconn *, struct ofproto *,
- struct ofpbuf *);
-
-static void refresh_port_groups(struct ofproto *);
+static void handle_openflow(struct ofconn *, struct ofpbuf *);
static struct ofport *get_port(const struct ofproto *, uint16_t odp_port);
static void update_port(struct ofproto *, const char *devname);
struct ofport *ofport;
os = ofproto->sflow = ofproto_sflow_create(ofproto->dpif);
- refresh_port_groups(ofproto);
HMAP_FOR_EACH (ofport, hmap_node, &ofproto->ports) {
ofproto_sflow_add_port(os, ofport->odp_port,
netdev_get_name(ofport->netdev));
}
LIST_FOR_EACH_SAFE (ofconn, next_ofconn, node, &p->all_conns) {
- ofconn_run(ofconn, p);
+ ofconn_run(ofconn);
}
/* Fail-open maintenance. Do this after processing the ofconns since
* to do because of the conflict. (The netdev would eventually get closed on
* the next trip through ofproto_run(), but this interface is more direct.)
*
- * The caller must be prepared for a callback to its port_changed_cb hook
- * function.
- *
* Returns 0 if successful, otherwise a positive errno. */
int
ofproto_port_del(struct ofproto *ofproto, uint16_t odp_port)
return error;
}
+/* Checks if 'ofproto' thinks 'odp_port' should be included in floods. Returns
+ * true if 'odp_port' exists and should be included, false otherwise. */
+bool
+ofproto_port_is_floodable(struct ofproto *ofproto, uint16_t odp_port)
+{
+ struct ofport *ofport = get_port(ofproto, odp_port);
+ return ofport && !(ofport->opp.config & OFPPC_NO_FLOOD);
+}
+
int
-ofproto_send_packet(struct ofproto *p, const flow_t *flow,
+ofproto_send_packet(struct ofproto *p, const struct flow *flow,
const union ofp_action *actions, size_t n_actions,
const struct ofpbuf *packet)
{
/* XXX Should we translate the dpif_execute() errno value into an OpenFlow
* error code? */
- dpif_execute(p->dpif, flow->in_port, odp_actions.actions,
- odp_actions.n_actions, packet);
+ dpif_execute(p->dpif, odp_actions.actions, odp_actions.n_actions, packet);
return 0;
}
void
-ofproto_add_flow(struct ofproto *p,
- const flow_t *flow, uint32_t wildcards, unsigned int priority,
+ofproto_add_flow(struct ofproto *p, const struct flow *flow,
+ uint32_t wildcards, unsigned int priority,
const union ofp_action *actions, size_t n_actions,
int idle_timeout)
{
}
void
-ofproto_delete_flow(struct ofproto *ofproto, const flow_t *flow,
+ofproto_delete_flow(struct ofproto *ofproto, const struct flow *flow,
uint32_t wildcards, unsigned int priority)
{
+ struct cls_rule target;
struct rule *rule;
+ cls_rule_from_flow(flow, wildcards, priority, &target);
rule = rule_from_cls_rule(classifier_find_rule_exactly(&ofproto->cls,
- flow, wildcards,
- priority));
+ &target));
if (rule) {
rule_remove(ofproto, rule);
}
size_t n_odp_ports;
size_t i;
+ COVERAGE_INC(ofproto_reinit_ports);
+
svec_init(&devnames);
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
svec_add (&devnames, (char *) ofport->opp.name);
svec_destroy(&devnames);
}
-static size_t
-refresh_port_group(struct ofproto *p, unsigned int group)
-{
- uint16_t *ports;
- size_t n_ports;
- struct ofport *port;
-
- assert(group == DP_GROUP_ALL || group == DP_GROUP_FLOOD);
-
- ports = xmalloc(hmap_count(&p->ports) * sizeof *ports);
- n_ports = 0;
- HMAP_FOR_EACH (port, hmap_node, &p->ports) {
- if (group == DP_GROUP_ALL || !(port->opp.config & OFPPC_NO_FLOOD)) {
- ports[n_ports++] = port->odp_port;
- }
- }
- dpif_port_group_set(p->dpif, group, ports, n_ports);
- free(ports);
-
- return n_ports;
-}
-
-static void
-refresh_port_groups(struct ofproto *p)
-{
- size_t n_flood = refresh_port_group(p, DP_GROUP_FLOOD);
- size_t n_all = refresh_port_group(p, DP_GROUP_ALL);
- if (p->sflow) {
- ofproto_sflow_set_group_sizes(p->sflow, n_flood, n_all);
- }
-}
-
static struct ofport *
make_ofport(const struct odp_port *odp_port)
{
enum netdev_flags flags;
struct ofport *ofport;
struct netdev *netdev;
- bool carrier;
int error;
memset(&netdev_options, 0, sizeof netdev_options);
netdev_get_flags(netdev, &flags);
ofport->opp.config = flags & NETDEV_UP ? 0 : OFPPC_PORT_DOWN;
- netdev_get_carrier(netdev, &carrier);
- ofport->opp.state = carrier ? 0 : OFPPS_LINK_DOWN;
+ ofport->opp.state = netdev_get_carrier(netdev) ? 0 : OFPPS_LINK_DOWN;
netdev_get_features(netdev,
&ofport->opp.curr, &ofport->opp.advertised,
hton_ofp_phy_port(&ops->desc);
queue_tx(b, ofconn, NULL);
}
- if (p->ofhooks->port_changed_cb) {
- p->ofhooks->port_changed_cb(reason, &ofport->opp, p->aux);
- }
}
static void
: !new_ofport ? OFPPR_DELETE
: OFPPR_MODIFY));
ofport_free(old_ofport);
-
- /* Update port groups. */
- refresh_port_groups(p);
}
static int
}
}
free(ports);
- refresh_port_groups(p);
return 0;
}
\f
list_push_back(&p->all_conns, &ofconn->node);
ofconn->rconn = rconn;
ofconn->type = type;
+ ofconn->flow_format = NXFF_OPENFLOW10;
ofconn->role = NX_ROLE_OTHER;
ofconn->packet_in_counter = rconn_packet_counter_create ();
ofconn->pktbuf = NULL;
}
static void
-ofconn_run(struct ofconn *ofconn, struct ofproto *p)
+ofconn_run(struct ofconn *ofconn)
{
+ struct ofproto *p = ofconn->ofproto;
int iteration;
size_t i;
if (p->fail_open) {
fail_open_maybe_recover(p->fail_open);
}
- handle_openflow(ofconn, p, of_msg);
+ handle_openflow(ofconn, of_msg);
ofpbuf_delete(of_msg);
}
}
rule_create(struct ofproto *ofproto, struct rule *super,
const union ofp_action *actions, size_t n_actions,
uint16_t idle_timeout, uint16_t hard_timeout,
- uint64_t flow_cookie, bool send_flow_removed)
+ ovs_be64 flow_cookie, bool send_flow_removed)
{
struct rule *rule = xzalloc(sizeof *rule);
rule->idle_timeout = idle_timeout;
}
static bool
-rule_has_out_port(const struct rule *rule, uint16_t out_port)
+rule_has_out_port(const struct rule *rule, ovs_be16 out_port)
{
const union ofp_action *oa;
struct actions_iterator i;
} else {
int error;
- error = dpif_execute(ofproto->dpif, in_port,
- actions, n_actions, packet);
+ error = dpif_execute(ofproto->dpif, actions, n_actions, packet);
ofpbuf_delete(packet);
return !error;
}
* Takes ownership of 'packet'. */
static void
rule_execute(struct ofproto *ofproto, struct rule *rule,
- struct ofpbuf *packet, const flow_t *flow)
+ struct ofpbuf *packet, const struct flow *flow)
{
const union odp_action *actions;
struct odp_flow_stats stats;
/* Send the packet and credit it to the rule. */
if (packet) {
- flow_t flow;
+ struct flow flow;
flow_extract(packet, 0, in_port, &flow);
rule_execute(p, rule, packet, &flow);
}
static struct rule *
rule_create_subrule(struct ofproto *ofproto, struct rule *rule,
- const flow_t *flow)
+ const struct flow *flow)
{
struct rule *subrule = rule_create(ofproto, rule, NULL, 0,
rule->idle_timeout, rule->hard_timeout,
COVERAGE_INC(ofproto_subrule_create);
cls_rule_from_flow(flow, 0, (rule->cr.priority <= UINT16_MAX ? UINT16_MAX
: rule->cr.priority), &subrule->cr);
- classifier_insert_exact(&ofproto->cls, &subrule->cr);
+
+ if (classifier_insert(&ofproto->cls, &subrule->cr)) {
+ /* Can't happen, */
+ NOT_REACHED();
+ }
return subrule;
}
struct odp_flow_put *put)
{
memset(&put->flow.stats, 0, sizeof put->flow.stats);
- put->flow.key = rule->cr.flow;
+ odp_flow_key_from_flow(&put->flow.key, &rule->cr.flow);
put->flow.actions = rule->odp_actions;
put->flow.n_actions = rule->n_odp_actions;
put->flow.flags = 0;
if (rule->installed) {
struct odp_flow odp_flow;
- odp_flow.key = rule->cr.flow;
+ odp_flow_key_from_flow(&odp_flow.key, &rule->cr.flow);
odp_flow.actions = NULL;
odp_flow.n_actions = 0;
odp_flow.flags = 0;
}
}
-static void
-send_error(const struct ofconn *ofconn, const struct ofp_header *oh,
- int error, const void *data, size_t len)
-{
- struct ofpbuf *buf;
- struct ofp_error_msg *oem;
-
- if (!(error >> 16)) {
- VLOG_WARN_RL(&rl, "not sending bad error code %d to controller",
- error);
- return;
- }
-
- COVERAGE_INC(ofproto_error);
- oem = make_openflow_xid(len + sizeof *oem, OFPT_ERROR,
- oh ? oh->xid : 0, &buf);
- oem->type = htons((unsigned int) error >> 16);
- oem->code = htons(error & 0xffff);
- memcpy(oem->data, data, len);
- queue_tx(buf, ofconn, ofconn->reply_counter);
-}
-
static void
send_error_oh(const struct ofconn *ofconn, const struct ofp_header *oh,
int error)
{
- size_t oh_length = ntohs(oh->length);
- send_error(ofconn, oh, error, oh, MIN(oh_length, 64));
+ struct ofpbuf *buf = make_ofp_error_msg(error, oh);
+ if (buf) {
+ COVERAGE_INC(ofproto_error);
+ queue_tx(buf, ofconn, ofconn->reply_counter);
+ }
}
static void
}
static int
-handle_features_request(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_header *oh)
+handle_features_request(struct ofconn *ofconn, struct ofp_header *oh)
{
struct ofp_switch_features *osf;
struct ofpbuf *buf;
struct ofport *port;
osf = make_openflow_xid(sizeof *osf, OFPT_FEATURES_REPLY, oh->xid, &buf);
- osf->datapath_id = htonll(p->datapath_id);
+ osf->datapath_id = htonll(ofconn->ofproto->datapath_id);
osf->n_buffers = htonl(pktbuf_capacity());
osf->n_tables = 2;
osf->capabilities = htonl(OFPC_FLOW_STATS | OFPC_TABLE_STATS |
(1u << OFPAT_SET_TP_DST) |
(1u << OFPAT_ENQUEUE));
- HMAP_FOR_EACH (port, hmap_node, &p->ports) {
+ HMAP_FOR_EACH (port, hmap_node, &ofconn->ofproto->ports) {
hton_ofp_phy_port(ofpbuf_put(buf, &port->opp, sizeof port->opp));
}
}
static int
-handle_get_config_request(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_header *oh)
+handle_get_config_request(struct ofconn *ofconn, struct ofp_header *oh)
{
struct ofpbuf *buf;
struct ofp_switch_config *osc;
bool drop_frags;
/* Figure out flags. */
- dpif_get_drop_frags(p->dpif, &drop_frags);
+ dpif_get_drop_frags(ofconn->ofproto->dpif, &drop_frags);
flags = drop_frags ? OFPC_FRAG_DROP : OFPC_FRAG_NORMAL;
/* Send reply. */
}
static int
-handle_set_config(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_switch_config *osc)
+handle_set_config(struct ofconn *ofconn, struct ofp_switch_config *osc)
{
uint16_t flags;
int error;
if (ofconn->type == OFCONN_PRIMARY && ofconn->role != NX_ROLE_SLAVE) {
switch (flags & OFPC_FRAG_MASK) {
case OFPC_FRAG_NORMAL:
- dpif_set_drop_frags(p->dpif, false);
+ dpif_set_drop_frags(ofconn->ofproto->dpif, false);
break;
case OFPC_FRAG_DROP:
- dpif_set_drop_frags(p->dpif, true);
+ dpif_set_drop_frags(ofconn->ofproto->dpif, true);
break;
default:
VLOG_WARN_RL(&rl, "requested bad fragment mode (flags=%"PRIx16")",
return 0;
}
-static void
-add_output_group_action(struct odp_actions *actions, uint16_t group,
- uint16_t *nf_output_iface)
-{
- odp_actions_add(actions, ODPAT_OUTPUT_GROUP)->output_group.group = group;
-
- if (group == DP_GROUP_ALL || group == DP_GROUP_FLOOD) {
- *nf_output_iface = NF_OUT_FLOOD;
- }
-}
-
static void
add_controller_action(struct odp_actions *actions, uint16_t max_len)
{
struct action_xlate_ctx {
/* Input. */
- flow_t flow; /* Flow to which these actions correspond. */
+ struct flow flow; /* Flow to which these actions correspond. */
int recurse; /* Recursion level, via xlate_table_action. */
struct ofproto *ofproto;
const struct ofpbuf *packet; /* The packet corresponding to 'flow', or a
}
static struct rule *
-lookup_valid_rule(struct ofproto *ofproto, const flow_t *flow)
+lookup_valid_rule(struct ofproto *ofproto, const struct flow *flow)
{
struct rule *rule;
- rule = rule_from_cls_rule(classifier_lookup(&ofproto->cls, flow));
+ rule = rule_from_cls_rule(classifier_lookup(&ofproto->cls, flow,
+ CLS_INC_ALL));
/* The rule we found might not be valid, since we could be in need of
* revalidation. If it is not valid, don't return it. */
}
}
+static void
+flood_packets(struct ofproto *ofproto, uint16_t odp_in_port, uint32_t mask,
+ uint16_t *nf_output_iface, struct odp_actions *actions)
+{
+ struct ofport *ofport;
+
+ HMAP_FOR_EACH (ofport, hmap_node, &ofproto->ports) {
+ uint16_t odp_port = ofport->odp_port;
+ if (odp_port != odp_in_port && !(ofport->opp.config & mask)) {
+ odp_actions_add(actions, ODPAT_OUTPUT)->output.port = odp_port;
+ }
+ }
+ *nf_output_iface = NF_OUT_FLOOD;
+}
+
static void
xlate_output_action__(struct action_xlate_ctx *ctx,
uint16_t port, uint16_t max_len)
}
break;
case OFPP_FLOOD:
- add_output_group_action(ctx->out, DP_GROUP_FLOOD,
- &ctx->nf_output_iface);
+ flood_packets(ctx->ofproto, ctx->flow.in_port, OFPPC_NO_FLOOD,
+ &ctx->nf_output_iface, ctx->out);
break;
case OFPP_ALL:
- add_output_group_action(ctx->out, DP_GROUP_ALL, &ctx->nf_output_iface);
+ flood_packets(ctx->ofproto, ctx->flow.in_port, 0,
+ &ctx->nf_output_iface, ctx->out);
break;
case OFPP_CONTROLLER:
add_controller_action(ctx->out, max_len);
break;
case OFPAT_SET_VLAN_VID:
- oa = odp_actions_add(ctx->out, ODPAT_SET_VLAN_VID);
- ctx->flow.dl_vlan = oa->vlan_vid.vlan_vid = ia->vlan_vid.vlan_vid;
+ oa = odp_actions_add(ctx->out, ODPAT_SET_DL_TCI);
+ oa->dl_tci.tci = ia->vlan_vid.vlan_vid;
+ oa->dl_tci.tci |= htons(ctx->flow.dl_vlan_pcp << VLAN_PCP_SHIFT);
+ ctx->flow.dl_vlan = ia->vlan_vid.vlan_vid;
break;
case OFPAT_SET_VLAN_PCP:
- oa = odp_actions_add(ctx->out, ODPAT_SET_VLAN_PCP);
- ctx->flow.dl_vlan_pcp = oa->vlan_pcp.vlan_pcp = ia->vlan_pcp.vlan_pcp;
+ oa = odp_actions_add(ctx->out, ODPAT_SET_DL_TCI);
+ oa->dl_tci.tci = htons(ia->vlan_pcp.vlan_pcp << VLAN_PCP_SHIFT);
+ oa->dl_tci.tci |= ctx->flow.dl_vlan;
+ ctx->flow.dl_vlan_pcp = ia->vlan_pcp.vlan_pcp;
break;
case OFPAT_STRIP_VLAN:
static int
xlate_actions(const union ofp_action *in, size_t n_in,
- const flow_t *flow, struct ofproto *ofproto,
+ const struct flow *flow, struct ofproto *ofproto,
const struct ofpbuf *packet,
struct odp_actions *out, tag_type *tags, bool *may_set_up_flow,
uint16_t *nf_output_iface)
* error message code (composed with ofp_mkerr()) for the caller to propagate
* upward. Otherwise, returns 0.
*
- * 'oh' is used to make log messages more informative. */
+ * The log message mentions 'msg_type'. */
static int
-reject_slave_controller(struct ofconn *ofconn, const struct ofp_header *oh)
+reject_slave_controller(struct ofconn *ofconn, const const char *msg_type)
{
if (ofconn->type == OFCONN_PRIMARY && ofconn->role == NX_ROLE_SLAVE) {
static struct vlog_rate_limit perm_rl = VLOG_RATE_LIMIT_INIT(1, 5);
- char *type_name;
-
- type_name = ofp_message_type_to_string(oh->type);
VLOG_WARN_RL(&perm_rl, "rejecting %s message from slave controller",
- type_name);
- free(type_name);
+ msg_type);
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
} else {
}
static int
-handle_packet_out(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_header *oh)
+handle_packet_out(struct ofconn *ofconn, struct ofp_header *oh)
{
+ struct ofproto *p = ofconn->ofproto;
struct ofp_packet_out *opo;
struct ofpbuf payload, *buffer;
struct odp_actions actions;
+ struct flow flow;
int n_actions;
uint16_t in_port;
- flow_t flow;
int error;
- error = reject_slave_controller(ofconn, oh);
+ error = reject_slave_controller(ofconn, "OFPT_PACKET_OUT");
if (error) {
return error;
}
flow_extract(&payload, 0, ofp_port_to_odp_port(ntohs(opo->in_port)), &flow);
error = xlate_actions((const union ofp_action *) opo->actions, n_actions,
&flow, p, &payload, &actions, NULL, NULL, NULL);
- if (error) {
- return error;
+ if (!error) {
+ dpif_execute(p->dpif, actions.actions, actions.n_actions, &payload);
}
-
- dpif_execute(p->dpif, flow.in_port, actions.actions, actions.n_actions,
- &payload);
ofpbuf_delete(buffer);
- return 0;
+ return error;
}
static void
netdev_turn_flags_on(port->netdev, NETDEV_UP, true);
}
}
-#define REVALIDATE_BITS (OFPPC_NO_RECV | OFPPC_NO_RECV_STP | OFPPC_NO_FWD)
+#define REVALIDATE_BITS (OFPPC_NO_RECV | OFPPC_NO_RECV_STP | \
+ OFPPC_NO_FWD | OFPPC_NO_FLOOD)
if (mask & REVALIDATE_BITS) {
COVERAGE_INC(ofproto_costly_flags);
port->opp.config ^= mask & REVALIDATE_BITS;
p->need_revalidate = true;
}
#undef REVALIDATE_BITS
- if (mask & OFPPC_NO_FLOOD) {
- port->opp.config ^= OFPPC_NO_FLOOD;
- refresh_port_groups(p);
- }
if (mask & OFPPC_NO_PACKET_IN) {
port->opp.config ^= OFPPC_NO_PACKET_IN;
}
}
static int
-handle_port_mod(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_header *oh)
+handle_port_mod(struct ofconn *ofconn, struct ofp_header *oh)
{
+ struct ofproto *p = ofconn->ofproto;
const struct ofp_port_mod *opm;
struct ofport *port;
int error;
- error = reject_slave_controller(ofconn, oh);
+ error = reject_slave_controller(ofconn, "OFPT_PORT_MOD");
if (error) {
return error;
}
}
static struct ofpbuf *
-make_stats_reply(uint32_t xid, uint16_t type, size_t body_len)
+make_stats_reply(ovs_be32 xid, ovs_be16 type, size_t body_len)
{
struct ofp_stats_reply *osr;
struct ofpbuf *msg;
}
static int
-handle_desc_stats_request(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_stats_request *request)
+handle_desc_stats_request(struct ofconn *ofconn,
+ struct ofp_stats_request *request)
{
+ struct ofproto *p = ofconn->ofproto;
struct ofp_desc_stats *ods;
struct ofpbuf *msg;
}
static int
-handle_table_stats_request(struct ofproto *p, struct ofconn *ofconn,
+handle_table_stats_request(struct ofconn *ofconn,
struct ofp_stats_request *request)
{
+ struct ofproto *p = ofconn->ofproto;
struct ofp_table_stats *ots;
struct ofpbuf *msg;
- struct odp_stats dpstats;
- int n_exact, n_subrules, n_wild;
struct rule *rule;
+ int n_rules;
msg = start_stats_reply(request, sizeof *ots * 2);
- /* Count rules of various kinds. */
- n_subrules = 0;
+ /* Count rules other than subrules. */
+ n_rules = classifier_count(&p->cls);
CLASSIFIER_FOR_EACH_EXACT_RULE (rule, cr, &p->cls) {
if (rule->super) {
- n_subrules++;
+ n_rules--;
}
}
- n_exact = classifier_count_exact(&p->cls) - n_subrules;
- n_wild = classifier_count(&p->cls) - classifier_count_exact(&p->cls);
-
- /* Hash table. */
- dpif_get_dp_stats(p->dpif, &dpstats);
- ots = append_stats_reply(sizeof *ots, ofconn, &msg);
- memset(ots, 0, sizeof *ots);
- ots->table_id = TABLEID_HASH;
- strcpy(ots->name, "hash");
- ots->wildcards = htonl(0);
- ots->max_entries = htonl(dpstats.max_capacity);
- ots->active_count = htonl(n_exact);
- ots->lookup_count = htonll(dpstats.n_frags + dpstats.n_hit +
- dpstats.n_missed);
- ots->matched_count = htonll(dpstats.n_hit); /* XXX */
/* Classifier table. */
ots = append_stats_reply(sizeof *ots, ofconn, &msg);
memset(ots, 0, sizeof *ots);
- ots->table_id = TABLEID_CLASSIFIER;
strcpy(ots->name, "classifier");
- ots->wildcards = p->tun_id_from_cookie ? htonl(OVSFW_ALL)
- : htonl(OFPFW_ALL);
- ots->max_entries = htonl(65536);
- ots->active_count = htonl(n_wild);
+ ots->wildcards = (ofconn->flow_format == NXFF_OPENFLOW10
+ ? htonl(OFPFW_ALL) : htonl(OVSFW_ALL));
+ ots->max_entries = htonl(1024 * 1024); /* An arbitrary big number. */
+ ots->active_count = htonl(n_rules);
ots->lookup_count = htonll(0); /* XXX */
ots->matched_count = htonll(0); /* XXX */
}
static int
-handle_port_stats_request(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_stats_request *osr,
+handle_port_stats_request(struct ofconn *ofconn, struct ofp_stats_request *osr,
size_t arg_size)
{
+ struct ofproto *p = ofconn->ofproto;
struct ofp_port_stats_request *psr;
struct ofp_port_stats *ops;
struct ofpbuf *msg;
}
struct flow_stats_cbdata {
- struct ofproto *ofproto;
struct ofconn *ofconn;
- uint16_t out_port;
+ ovs_be16 out_port;
struct ofpbuf *msg;
};
if (rule->cr.wc.wildcards) {
size_t i = 0;
LIST_FOR_EACH (subrule, list, &rule->list) {
- odp_flows[i++].key = subrule->cr.flow;
+ odp_flow_key_from_flow(&odp_flows[i++].key, &subrule->cr.flow);
packet_count += subrule->packet_count;
byte_count += subrule->byte_count;
}
} else {
- odp_flows[0].key = rule->cr.flow;
+ odp_flow_key_from_flow(&odp_flows[0].key, &rule->cr.flow);
}
/* Fetch up-to-date statistics from the datapath and add them in. */
*byte_countp = byte_count;
}
+static void
+calc_flow_duration(long long int start, ovs_be32 *sec, ovs_be32 *nsec)
+{
+ long long int msecs = time_msec() - start;
+ *sec = htonl(msecs / 1000);
+ *nsec = htonl((msecs % 1000) * (1000 * 1000));
+}
+
static void
flow_stats_cb(struct cls_rule *rule_, void *cbdata_)
{
struct ofp_flow_stats *ofs;
uint64_t packet_count, byte_count;
size_t act_len, len;
- long long int tdiff = time_msec() - rule->created;
- uint32_t sec = tdiff / 1000;
- uint32_t msec = tdiff - (sec * 1000);
if (rule_is_hidden(rule) || !rule_has_out_port(rule, cbdata->out_port)) {
return;
act_len = sizeof *rule->actions * rule->n_actions;
len = offsetof(struct ofp_flow_stats, actions) + act_len;
- query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
+ query_stats(cbdata->ofconn->ofproto, rule, &packet_count, &byte_count);
ofs = append_stats_reply(len, cbdata->ofconn, &cbdata->msg);
ofs->length = htons(len);
- ofs->table_id = rule->cr.wc.wildcards ? TABLEID_CLASSIFIER : TABLEID_HASH;
+ ofs->table_id = 0;
ofs->pad = 0;
flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards,
- cbdata->ofproto->tun_id_from_cookie, &ofs->match);
- ofs->duration_sec = htonl(sec);
- ofs->duration_nsec = htonl(msec * 1000000);
+ cbdata->ofconn->flow_format, &ofs->match);
+ calc_flow_duration(rule->created, &ofs->duration_sec, &ofs->duration_nsec);
ofs->cookie = rule->flow_cookie;
ofs->priority = htons(rule->cr.priority);
ofs->idle_timeout = htons(rule->idle_timeout);
static int
table_id_to_include(uint8_t table_id)
{
- return (table_id == TABLEID_HASH ? CLS_INC_EXACT
- : table_id == TABLEID_CLASSIFIER ? CLS_INC_WILD
- : table_id == 0xff ? CLS_INC_ALL
- : 0);
+ return table_id == 0 || table_id == 0xff ? CLS_INC_ALL : 0;
}
static int
-handle_flow_stats_request(struct ofproto *p, struct ofconn *ofconn,
- const struct ofp_stats_request *osr,
- size_t arg_size)
+handle_flow_stats_request(struct ofconn *ofconn,
+ const struct ofp_stats_request *osr, size_t arg_size)
{
struct ofp_flow_stats_request *fsr;
struct flow_stats_cbdata cbdata;
fsr = (struct ofp_flow_stats_request *) osr->body;
COVERAGE_INC(ofproto_flows_req);
- cbdata.ofproto = p;
cbdata.ofconn = ofconn;
cbdata.out_port = fsr->out_port;
cbdata.msg = start_stats_reply(osr, 1024);
- cls_rule_from_match(&fsr->match, 0, false, 0, &target);
- classifier_for_each_match(&p->cls, &target,
+ cls_rule_from_match(&fsr->match, 0, NXFF_OPENFLOW10, 0, &target);
+ classifier_for_each_match(&ofconn->ofproto->cls, &target,
table_id_to_include(fsr->table_id),
flow_stats_cb, &cbdata);
queue_tx(cbdata.msg, ofconn, ofconn->reply_counter);
query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards,
- cbdata->ofproto->tun_id_from_cookie, &match);
+ NXFF_OPENFLOW10, &match);
ds_put_format(results, "duration=%llds, ",
(time_msec() - rule->created) / 1000);
ofp_print_match(results, &match, true);
if (act_len > 0) {
ofp_print_actions(results, &rule->actions->header, act_len);
+ } else {
+ ds_put_cstr(results, "drop");
}
ds_put_cstr(results, "\n");
}
cbdata.ofproto = p;
cbdata.results = results;
- cls_rule_from_match(&match, 0, false, 0, &target);
+ cls_rule_from_match(&match, 0, NXFF_OPENFLOW10, 0, &target);
classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
flow_stats_ds_cb, &cbdata);
}
struct aggregate_stats_cbdata {
struct ofproto *ofproto;
- uint16_t out_port;
+ ovs_be16 out_port;
uint64_t packet_count;
uint64_t byte_count;
uint32_t n_flows;
cbdata->n_flows++;
}
+static void
+query_aggregate_stats(struct ofproto *ofproto, struct cls_rule *target,
+ uint16_t out_port, uint8_t table_id,
+ struct ofp_aggregate_stats_reply *oasr)
+{
+ struct aggregate_stats_cbdata cbdata;
+
+ COVERAGE_INC(ofproto_agg_request);
+ cbdata.ofproto = ofproto;
+ cbdata.out_port = out_port;
+ cbdata.packet_count = 0;
+ cbdata.byte_count = 0;
+ cbdata.n_flows = 0;
+ classifier_for_each_match(&ofproto->cls, target,
+ table_id_to_include(table_id),
+ aggregate_stats_cb, &cbdata);
+
+ oasr->flow_count = htonl(cbdata.n_flows);
+ oasr->packet_count = htonll(cbdata.packet_count);
+ oasr->byte_count = htonll(cbdata.byte_count);
+ memset(oasr->pad, 0, sizeof oasr->pad);
+}
+
static int
-handle_aggregate_stats_request(struct ofproto *p, struct ofconn *ofconn,
+handle_aggregate_stats_request(struct ofconn *ofconn,
const struct ofp_stats_request *osr,
size_t arg_size)
{
- struct ofp_aggregate_stats_request *asr;
+ struct ofp_aggregate_stats_request *request;
struct ofp_aggregate_stats_reply *reply;
- struct aggregate_stats_cbdata cbdata;
struct cls_rule target;
struct ofpbuf *msg;
- if (arg_size != sizeof *asr) {
+ if (arg_size != sizeof *request) {
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
}
- asr = (struct ofp_aggregate_stats_request *) osr->body;
+ request = (struct ofp_aggregate_stats_request *) osr->body;
- COVERAGE_INC(ofproto_agg_request);
- cbdata.ofproto = p;
- cbdata.out_port = asr->out_port;
- cbdata.packet_count = 0;
- cbdata.byte_count = 0;
- cbdata.n_flows = 0;
- cls_rule_from_match(&asr->match, 0, false, 0, &target);
- classifier_for_each_match(&p->cls, &target,
- table_id_to_include(asr->table_id),
- aggregate_stats_cb, &cbdata);
+ cls_rule_from_match(&request->match, 0, NXFF_OPENFLOW10, 0, &target);
msg = start_stats_reply(osr, sizeof *reply);
reply = append_stats_reply(sizeof *reply, ofconn, &msg);
- reply->flow_count = htonl(cbdata.n_flows);
- reply->packet_count = htonll(cbdata.packet_count);
- reply->byte_count = htonll(cbdata.byte_count);
+ query_aggregate_stats(ofconn->ofproto, &target, request->out_port,
+ request->table_id, reply);
queue_tx(msg, ofconn, ofconn->reply_counter);
return 0;
}
}
static int
-handle_queue_stats_request(struct ofproto *ofproto, struct ofconn *ofconn,
+handle_queue_stats_request(struct ofconn *ofconn,
const struct ofp_stats_request *osr,
size_t arg_size)
{
+ struct ofproto *ofproto = ofconn->ofproto;
struct ofp_queue_stats_request *qsr;
struct queue_stats_cbdata cbdata;
struct ofport *port;
}
static int
-handle_stats_request(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_header *oh)
+handle_stats_request(struct ofconn *ofconn, struct ofp_header *oh)
{
struct ofp_stats_request *osr;
size_t arg_size;
switch (ntohs(osr->type)) {
case OFPST_DESC:
- return handle_desc_stats_request(p, ofconn, osr);
+ return handle_desc_stats_request(ofconn, osr);
case OFPST_FLOW:
- return handle_flow_stats_request(p, ofconn, osr, arg_size);
+ return handle_flow_stats_request(ofconn, osr, arg_size);
case OFPST_AGGREGATE:
- return handle_aggregate_stats_request(p, ofconn, osr, arg_size);
+ return handle_aggregate_stats_request(ofconn, osr, arg_size);
case OFPST_TABLE:
- return handle_table_stats_request(p, ofconn, osr);
+ return handle_table_stats_request(ofconn, osr);
case OFPST_PORT:
- return handle_port_stats_request(p, ofconn, osr, arg_size);
+ return handle_port_stats_request(ofconn, osr, arg_size);
case OFPST_QUEUE:
- return handle_queue_stats_request(p, ofconn, osr, arg_size);
+ return handle_queue_stats_request(ofconn, osr, arg_size);
case OFPST_VENDOR:
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
* in which no matching flow already exists in the flow table.
*
* Adds the flow specified by 'ofm', which is followed by 'n_actions'
- * ofp_actions, to 'p''s flow table. Returns 0 on success or an OpenFlow error
- * code as encoded by ofp_mkerr() on failure.
+ * ofp_actions, to ofconn->ofproto's flow table. Returns 0 on success or an
+ * OpenFlow error code as encoded by ofp_mkerr() on failure.
*
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static int
-add_flow(struct ofproto *p, struct ofconn *ofconn,
- const struct ofp_flow_mod *ofm, size_t n_actions)
+add_flow(struct ofconn *ofconn, const struct ofp_flow_mod *ofm,
+ size_t n_actions)
{
+ struct ofproto *p = ofconn->ofproto;
struct ofpbuf *packet;
struct rule *rule;
uint16_t in_port;
int error;
if (ofm->flags & htons(OFPFF_CHECK_OVERLAP)) {
- flow_t flow;
- uint32_t wildcards;
+ struct cls_rule cr;
- flow_from_match(&ofm->match, p->tun_id_from_cookie, ofm->cookie,
- &flow, &wildcards);
- if (classifier_rule_overlaps(&p->cls, &flow, wildcards,
- ntohs(ofm->priority))) {
+ cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
+ ofconn->flow_format, ofm->cookie, &cr);
+ if (classifier_rule_overlaps(&p->cls, &cr)) {
return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP);
}
}
ntohs(ofm->hard_timeout), ofm->cookie,
ofm->flags & htons(OFPFF_SEND_FLOW_REM));
cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
- p->tun_id_from_cookie, ofm->cookie, &rule->cr);
+ ofconn->flow_format, ofm->cookie, &rule->cr);
error = 0;
if (ofm->buffer_id != htonl(UINT32_MAX)) {
}
static struct rule *
-find_flow_strict(struct ofproto *p, const struct ofp_flow_mod *ofm)
+find_flow_strict(struct ofconn *ofconn, const struct ofp_flow_mod *ofm)
{
- uint32_t wildcards;
- flow_t flow;
+ struct ofproto *p = ofconn->ofproto;
+ struct cls_rule target;
- flow_from_match(&ofm->match, p->tun_id_from_cookie, ofm->cookie,
- &flow, &wildcards);
- return rule_from_cls_rule(classifier_find_rule_exactly(
- &p->cls, &flow, wildcards,
- ntohs(ofm->priority)));
+ cls_rule_from_match(&ofm->match, ntohs(ofm->priority),
+ ofconn->flow_format, ofm->cookie, &target);
+ return rule_from_cls_rule(classifier_find_rule_exactly(&p->cls, &target));
}
static int
-send_buffered_packet(struct ofproto *ofproto, struct ofconn *ofconn,
+send_buffered_packet(struct ofconn *ofconn,
struct rule *rule, const struct ofp_flow_mod *ofm)
{
struct ofpbuf *packet;
uint16_t in_port;
- flow_t flow;
+ struct flow flow;
int error;
if (ofm->buffer_id == htonl(UINT32_MAX)) {
}
flow_extract(packet, 0, in_port, &flow);
- rule_execute(ofproto, rule, packet, &flow);
+ rule_execute(ofconn->ofproto, rule, packet, &flow);
return 0;
}
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static int
-modify_flows_loose(struct ofproto *p, struct ofconn *ofconn,
+modify_flows_loose(struct ofconn *ofconn,
const struct ofp_flow_mod *ofm, size_t n_actions)
{
struct modify_flows_cbdata cbdata;
struct cls_rule target;
- cbdata.ofproto = p;
+ cbdata.ofproto = ofconn->ofproto;
cbdata.ofm = ofm;
cbdata.n_actions = n_actions;
cbdata.match = NULL;
- cls_rule_from_match(&ofm->match, 0, p->tun_id_from_cookie, ofm->cookie,
- &target);
+ cls_rule_from_match(&ofm->match, 0, ofconn->flow_format,
+ ofm->cookie, &target);
- classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
+ classifier_for_each_match(&ofconn->ofproto->cls, &target, CLS_INC_ALL,
modify_flows_cb, &cbdata);
if (cbdata.match) {
/* This credits the packet to whichever flow happened to happened to
* match last. That's weird. Maybe we should do a lookup for the
* flow that actually matches the packet? Who knows. */
- send_buffered_packet(p, ofconn, cbdata.match, ofm);
+ send_buffered_packet(ofconn, cbdata.match, ofm);
return 0;
} else {
- return add_flow(p, ofconn, ofm, n_actions);
+ return add_flow(ofconn, ofm, n_actions);
}
}
* 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
* if any. */
static int
-modify_flow_strict(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_flow_mod *ofm, size_t n_actions)
+modify_flow_strict(struct ofconn *ofconn, struct ofp_flow_mod *ofm,
+ size_t n_actions)
{
- struct rule *rule = find_flow_strict(p, ofm);
+ struct rule *rule = find_flow_strict(ofconn, ofm);
if (rule && !rule_is_hidden(rule)) {
- modify_flow(p, ofm, n_actions, rule);
- return send_buffered_packet(p, ofconn, rule, ofm);
+ modify_flow(ofconn->ofproto, ofm, n_actions, rule);
+ return send_buffered_packet(ofconn, rule, ofm);
} else {
- return add_flow(p, ofconn, ofm, n_actions);
+ return add_flow(ofconn, ofm, n_actions);
}
}
struct delete_flows_cbdata {
struct ofproto *ofproto;
- uint16_t out_port;
+ ovs_be16 out_port;
};
static void delete_flows_cb(struct cls_rule *, void *cbdata_);
-static void delete_flow(struct ofproto *, struct rule *, uint16_t out_port);
+static void delete_flow(struct ofproto *, struct rule *, ovs_be16 out_port);
/* Implements OFPFC_DELETE. */
static void
-delete_flows_loose(struct ofproto *p, const struct ofp_flow_mod *ofm)
+delete_flows_loose(struct ofconn *ofconn, const struct ofp_flow_mod *ofm)
{
struct delete_flows_cbdata cbdata;
struct cls_rule target;
- cbdata.ofproto = p;
+ cbdata.ofproto = ofconn->ofproto;
cbdata.out_port = ofm->out_port;
- cls_rule_from_match(&ofm->match, 0, p->tun_id_from_cookie, ofm->cookie,
- &target);
+ cls_rule_from_match(&ofm->match, 0, ofconn->flow_format,
+ ofm->cookie, &target);
- classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
+ classifier_for_each_match(&ofconn->ofproto->cls, &target, CLS_INC_ALL,
delete_flows_cb, &cbdata);
}
/* Implements OFPFC_DELETE_STRICT. */
static void
-delete_flow_strict(struct ofproto *p, struct ofp_flow_mod *ofm)
+delete_flow_strict(struct ofconn *ofconn, struct ofp_flow_mod *ofm)
{
- struct rule *rule = find_flow_strict(p, ofm);
+ struct rule *rule = find_flow_strict(ofconn, ofm);
if (rule) {
- delete_flow(p, rule, ofm->out_port);
+ delete_flow(ofconn->ofproto, rule, ofm->out_port);
}
}
* 'out_port' is htons(OFPP_NONE) or if 'rule' actually outputs to the
* specified 'out_port'. */
static void
-delete_flow(struct ofproto *p, struct rule *rule, uint16_t out_port)
+delete_flow(struct ofproto *p, struct rule *rule, ovs_be16 out_port)
{
if (rule_is_hidden(rule)) {
return;
return;
}
- send_flow_removed(p, rule, time_msec(), OFPRR_DELETE);
+ send_flow_removed(p, rule, OFPRR_DELETE);
rule_remove(p, rule);
}
\f
static int
-handle_flow_mod(struct ofproto *p, struct ofconn *ofconn,
- struct ofp_flow_mod *ofm)
+handle_flow_mod(struct ofconn *ofconn, struct ofp_flow_mod *ofm)
{
struct ofp_match orig_match;
size_t n_actions;
int error;
- error = reject_slave_controller(ofconn, &ofm->header);
+ error = reject_slave_controller(ofconn, "OFPT_FLOW_MOD");
if (error) {
return error;
}
}
error = validate_actions((const union ofp_action *) ofm->actions,
- n_actions, p->max_ports);
+ n_actions, ofconn->ofproto->max_ports);
if (error) {
return error;
}
switch (ntohs(ofm->command)) {
case OFPFC_ADD:
- return add_flow(p, ofconn, ofm, n_actions);
+ return add_flow(ofconn, ofm, n_actions);
case OFPFC_MODIFY:
- return modify_flows_loose(p, ofconn, ofm, n_actions);
+ return modify_flows_loose(ofconn, ofm, n_actions);
case OFPFC_MODIFY_STRICT:
- return modify_flow_strict(p, ofconn, ofm, n_actions);
+ return modify_flow_strict(ofconn, ofm, n_actions);
case OFPFC_DELETE:
- delete_flows_loose(p, ofm);
+ delete_flows_loose(ofconn, ofm);
return 0;
case OFPFC_DELETE_STRICT:
- delete_flow_strict(p, ofm);
+ delete_flow_strict(ofconn, ofm);
return 0;
default:
}
static int
-handle_tun_id_from_cookie(struct ofproto *p, struct nxt_tun_id_cookie *msg)
+handle_tun_id_from_cookie(struct ofconn *ofconn, struct nxt_tun_id_cookie *msg)
{
int error;
return error;
}
- p->tun_id_from_cookie = !!msg->set;
+ ofconn->flow_format = msg->set ? NXFF_TUN_ID_FROM_COOKIE : NXFF_OPENFLOW10;
return 0;
}
static int
-handle_role_request(struct ofproto *ofproto,
- struct ofconn *ofconn, struct nicira_header *msg)
+handle_role_request(struct ofconn *ofconn, struct nicira_header *msg)
{
struct nx_role_request *nrr;
struct nx_role_request *reply;
if (role == NX_ROLE_MASTER) {
struct ofconn *other;
- HMAP_FOR_EACH (other, hmap_node, &ofproto->controllers) {
+ HMAP_FOR_EACH (other, hmap_node, &ofconn->ofproto->controllers) {
if (other->role == NX_ROLE_MASTER) {
other->role = NX_ROLE_SLAVE;
}
}
ofconn->role = role;
- reply = make_openflow_xid(sizeof *reply, OFPT_VENDOR, msg->header.xid,
- &buf);
- reply->nxh.vendor = htonl(NX_VENDOR_ID);
- reply->nxh.subtype = htonl(NXT_ROLE_REPLY);
+ reply = make_nxmsg_xid(sizeof *reply, NXT_ROLE_REPLY, msg->header.xid,
+ &buf);
reply->role = htonl(role);
queue_tx(buf, ofconn, ofconn->reply_counter);
}
static int
-handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg)
+handle_vendor(struct ofconn *ofconn, void *msg)
{
+ struct ofproto *p = ofconn->ofproto;
struct ofp_vendor_header *ovh = msg;
struct nicira_header *nh;
msg);
case NXT_TUN_ID_FROM_COOKIE:
- return handle_tun_id_from_cookie(p, msg);
+ return handle_tun_id_from_cookie(ofconn, msg);
case NXT_ROLE_REQUEST:
- return handle_role_request(p, ofconn, msg);
+ return handle_role_request(ofconn, msg);
}
return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE);
}
static void
-handle_openflow(struct ofconn *ofconn, struct ofproto *p,
- struct ofpbuf *ofp_msg)
+handle_openflow(struct ofconn *ofconn, struct ofpbuf *ofp_msg)
{
struct ofp_header *oh = ofp_msg->data;
int error;
break;
case OFPT_FEATURES_REQUEST:
- error = handle_features_request(p, ofconn, oh);
+ error = handle_features_request(ofconn, oh);
break;
case OFPT_GET_CONFIG_REQUEST:
- error = handle_get_config_request(p, ofconn, oh);
+ error = handle_get_config_request(ofconn, oh);
break;
case OFPT_SET_CONFIG:
- error = handle_set_config(p, ofconn, ofp_msg->data);
+ error = handle_set_config(ofconn, ofp_msg->data);
break;
case OFPT_PACKET_OUT:
- error = handle_packet_out(p, ofconn, ofp_msg->data);
+ error = handle_packet_out(ofconn, ofp_msg->data);
break;
case OFPT_PORT_MOD:
- error = handle_port_mod(p, ofconn, oh);
+ error = handle_port_mod(ofconn, oh);
break;
case OFPT_FLOW_MOD:
- error = handle_flow_mod(p, ofconn, ofp_msg->data);
+ error = handle_flow_mod(ofconn, ofp_msg->data);
break;
case OFPT_STATS_REQUEST:
- error = handle_stats_request(p, ofconn, oh);
+ error = handle_stats_request(ofconn, oh);
break;
case OFPT_VENDOR:
- error = handle_vendor(p, ofconn, ofp_msg->data);
+ error = handle_vendor(ofconn, ofp_msg->data);
break;
case OFPT_BARRIER_REQUEST:
struct odp_msg *msg = packet->data;
struct rule *rule;
struct ofpbuf payload;
- flow_t flow;
+ struct flow flow;
payload.data = msg + 1;
payload.size = msg->length - sizeof *msg;
memset(&action, 0, sizeof(action));
action.output.type = ODPAT_OUTPUT;
action.output.port = ODPP_LOCAL;
- dpif_execute(p->dpif, flow.in_port, &action, 1, &payload);
+ dpif_execute(p->dpif, &action, 1, &payload);
}
rule = lookup_valid_rule(p, &flow);
for (i = 0; i < n_flows; i++) {
struct odp_flow *f = &flows[i];
+ struct cls_rule target;
struct rule *rule;
+ struct flow flow;
- rule = rule_from_cls_rule(
- classifier_find_rule_exactly(&p->cls, &f->key, 0, UINT16_MAX));
+ odp_flow_key_to_flow(&f->key, &flow);
+ cls_rule_from_flow(&flow, 0, UINT16_MAX, &target);
+
+ rule = rule_from_cls_rule(classifier_find_rule_exactly(&p->cls,
+ &target));
if (rule && rule->installed) {
update_time(p, rule, &f->stats);
* ofproto_update_used() zeroed TCP flags. */
memset(&odp_flow, 0, sizeof odp_flow);
if (rule->installed) {
- odp_flow.key = rule->cr.flow;
+ odp_flow_key_from_flow(&odp_flow.key, &rule->cr.flow);
odp_flow.flags = ODPFF_ZERO_TCP_FLAGS;
dpif_flow_get(ofproto->dpif, &odp_flow);
/* Get rid of the rule. */
if (!rule_is_hidden(rule)) {
- send_flow_removed(cbdata->ofproto, rule, now,
+ send_flow_removed(cbdata->ofproto, rule,
(now >= hard_expire
? OFPRR_HARD_TIMEOUT : OFPRR_IDLE_TIMEOUT));
}
static bool
revalidate_rule(struct ofproto *p, struct rule *rule)
{
- const flow_t *flow = &rule->cr.flow;
+ const struct flow *flow = &rule->cr.flow;
COVERAGE_INC(ofproto_revalidate_rule);
if (rule->super) {
struct rule *super;
- super = rule_from_cls_rule(classifier_lookup_wild(&p->cls, flow));
+ super = rule_from_cls_rule(classifier_lookup(&p->cls, flow,
+ CLS_INC_WILD));
if (!super) {
rule_remove(p, rule);
return false;
}
static struct ofpbuf *
-compose_flow_removed(struct ofproto *p, const struct rule *rule,
- long long int now, uint8_t reason)
+compose_flow_removed(struct ofconn *ofconn, const struct rule *rule,
+ uint8_t reason)
{
struct ofp_flow_removed *ofr;
struct ofpbuf *buf;
- long long int tdiff = now - rule->created;
- uint32_t sec = tdiff / 1000;
- uint32_t msec = tdiff - (sec * 1000);
ofr = make_openflow(sizeof *ofr, OFPT_FLOW_REMOVED, &buf);
- flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, p->tun_id_from_cookie,
+ flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, ofconn->flow_format,
&ofr->match);
ofr->cookie = rule->flow_cookie;
ofr->priority = htons(rule->cr.priority);
ofr->reason = reason;
- ofr->duration_sec = htonl(sec);
- ofr->duration_nsec = htonl(msec * 1000000);
+ calc_flow_duration(rule->created, &ofr->duration_sec, &ofr->duration_nsec);
ofr->idle_timeout = htons(rule->idle_timeout);
ofr->packet_count = htonll(rule->packet_count);
ofr->byte_count = htonll(rule->byte_count);
}
static void
-send_flow_removed(struct ofproto *p, struct rule *rule,
- long long int now, uint8_t reason)
+send_flow_removed(struct ofproto *p, struct rule *rule, uint8_t reason)
{
struct ofconn *ofconn;
- struct ofconn *prev;
- struct ofpbuf *buf = NULL;
if (!rule->send_flow_removed) {
return;
}
- /* We limit the maximum number of queued flow expirations it by accounting
- * them under the counter for replies. That works because preventing
- * OpenFlow requests from being processed also prevents new flows from
- * being added (and expiring). (It also prevents processing OpenFlow
- * requests that would not add new flows, so it is imperfect.) */
-
- prev = NULL;
LIST_FOR_EACH (ofconn, node, &p->all_conns) {
- if (rconn_is_connected(ofconn->rconn)
- && ofconn_receives_async_msgs(ofconn)) {
- if (prev) {
- queue_tx(ofpbuf_clone(buf), prev, prev->reply_counter);
- } else {
- buf = compose_flow_removed(p, rule, now, reason);
- }
- prev = ofconn;
+ struct ofpbuf *msg;
+
+ if (!rconn_is_connected(ofconn->rconn)
+ || !ofconn_receives_async_msgs(ofconn)) {
+ continue;
}
- }
- if (prev) {
- queue_tx(buf, prev, prev->reply_counter);
+
+ msg = compose_flow_removed(ofconn, rule, reason);
+
+ /* Account flow expirations under ofconn->reply_counter, the counter
+ * for replies to OpenFlow requests. That works because preventing
+ * OpenFlow requests from being processed also prevents new flows from
+ * being added (and expiring). (It also prevents processing OpenFlow
+ * requests that would not add new flows, so it is imperfect.) */
+ queue_tx(msg, ofconn, ofconn->reply_counter);
}
}
}
\f
static bool
-default_normal_ofhook_cb(const flow_t *flow, const struct ofpbuf *packet,
+default_normal_ofhook_cb(const struct flow *flow, const struct ofpbuf *packet,
struct odp_actions *actions, tag_type *tags,
uint16_t *nf_output_iface, void *ofproto_)
{
out_port = mac_learning_lookup_tag(ofproto->ml, flow->dl_dst, 0, tags,
NULL);
if (out_port < 0) {
- add_output_group_action(actions, DP_GROUP_FLOOD, nf_output_iface);
+ flood_packets(ofproto, flow->in_port, OFPPC_NO_FLOOD,
+ nf_output_iface, actions);
} else if (out_port != flow->in_port) {
odp_actions_add(actions, ODPAT_OUTPUT)->output.port = out_port;
*nf_output_iface = out_port;
}
static const struct ofhooks default_ofhooks = {
- NULL,
default_normal_ofhook_cb,
NULL,
NULL
projects / openvswitch / blobdiff