#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"
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 *);
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 struct flow *flow,
const union ofp_action *actions, size_t n_actions,
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);
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,
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;
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;
}
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. */
case OFPP_FLOOD:
flood_packets(ctx->ofproto, ctx->flow.in_port, OFPPC_NO_FLOOD,
&ctx->nf_output_iface, ctx->out);
+ break;
case OFPP_ALL:
flood_packets(ctx->ofproto, ctx->flow.in_port, 0,
&ctx->nf_output_iface, ctx->out);
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:
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, actions.actions, actions.n_actions, &payload);
ofpbuf_delete(buffer);
- return 0;
+ return error;
}
static void
}
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;
struct flow_stats_cbdata {
struct ofproto *ofproto;
struct ofconn *ofconn;
- uint16_t out_port;
+ ovs_be16 out_port;
struct ofpbuf *msg;
};
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");
}
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;
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
* '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;
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;
projects / openvswitch / blobdiff