/*
- * Copyright (c) 2009, 2010 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011 Nicira Networks.
* Copyright (c) 2010 Jean Tourrilhes - HP-Labs.
*
* Licensed under the Apache License, Version 2.0 (the "License");
#include "hmap.h"
#include "in-band.h"
#include "mac-learning.h"
+#include "multipath.h"
#include "netdev.h"
#include "netflow.h"
#include "netlink.h"
bool installed; /* Installed in datapath? */
bool may_install; /* True ordinarily; false if actions must
* be reassessed for every packet. */
- unsigned int actions_len; /* Number of bytes in actions[]. */
+ size_t actions_len; /* Number of bytes in actions[]. */
struct nlattr *actions; /* Datapath actions. */
tag_type tags; /* Tags (set only by hooks). */
struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
static void
reinit_ports(struct ofproto *p)
{
- struct svec devnames;
+ struct shash_node *node;
+ struct shash devnames;
struct ofport *ofport;
struct odp_port *odp_ports;
size_t n_odp_ports;
COVERAGE_INC(ofproto_reinit_ports);
- svec_init(&devnames);
+ shash_init(&devnames);
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
- svec_add (&devnames, ofport->opp.name);
+ shash_add_once (&devnames, ofport->opp.name, NULL);
}
dpif_port_list(p->dpif, &odp_ports, &n_odp_ports);
for (i = 0; i < n_odp_ports; i++) {
- svec_add (&devnames, odp_ports[i].devname);
+ shash_add_once (&devnames, odp_ports[i].devname, NULL);
}
free(odp_ports);
- svec_sort_unique(&devnames);
- for (i = 0; i < devnames.n; i++) {
- update_port(p, devnames.names[i]);
+ SHASH_FOR_EACH (node, &devnames) {
+ update_port(p, node->name);
}
- svec_destroy(&devnames);
+ shash_destroy(&devnames);
}
static struct ofport *
* Takes ownership of 'packet'. */
static bool
execute_odp_actions(struct ofproto *ofproto, uint16_t in_port,
- const struct nlattr *odp_actions, unsigned int actions_len,
+ const struct nlattr *odp_actions, size_t actions_len,
struct ofpbuf *packet)
{
- if (actions_len == NLA_ALIGN(NLA_HDRLEN + sizeof(uint32_t))
+ if (actions_len == NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t))
&& odp_actions->nla_type == ODPAT_CONTROLLER) {
/* As an optimization, avoid a round-trip from userspace to kernel to
* userspace. This also avoids possibly filling up kernel packet
msg->type = _ODPL_ACTION_NR;
msg->length = sizeof(struct odp_msg) + packet->size;
msg->port = in_port;
- msg->reserved = 0;
- msg->arg = nl_attr_get_u32(odp_actions);
+ msg->arg = nl_attr_get_u64(odp_actions);
send_packet_in(ofproto, packet);
action_xlate_ctx_init(&ctx, p, &facet->flow, packet);
odp_actions = xlate_actions(&ctx, rule->actions, rule->n_actions);
+ facet->tags = ctx.tags;
+ facet->may_install = ctx.may_set_up_flow;
+ facet->nf_flow.output_iface = ctx.nf_output_iface;
if (facet->actions_len != odp_actions->size
|| memcmp(facet->actions, odp_actions->data, odp_actions->size)) {
facet_flush_stats(ofproto, facet);
}
- ofpbuf_delete(odp_actions);
-
/* Update 'facet' now that we've taken care of all the old state. */
facet->tags = ctx.tags;
facet->nf_flow.output_iface = ctx.nf_output_iface;
facet->used = new_rule->created;
}
+ ofpbuf_delete(odp_actions);
+
return true;
}
\f
/* Maximum depth of flow table recursion (due to NXAST_RESUBMIT actions) in a
* flow translation. */
-#define MAX_RESUBMIT_RECURSION 8
+#define MAX_RESUBMIT_RECURSION 16
static void do_xlate_actions(const union ofp_action *in, size_t n_in,
struct action_xlate_ctx *ctx);
ctx->recurse--;
}
} else {
- struct vlog_rate_limit recurse_rl = VLOG_RATE_LIMIT_INIT(1, 1);
+ static struct vlog_rate_limit recurse_rl = VLOG_RATE_LIMIT_INIT(1, 1);
VLOG_ERR_RL(&recurse_rl, "NXAST_RESUBMIT recursed over %d times",
MAX_RESUBMIT_RECURSION);
&ctx->nf_output_iface, ctx->odp_actions);
break;
case OFPP_CONTROLLER:
- nl_msg_put_u32(ctx->odp_actions, ODPAT_CONTROLLER, max_len);
+ nl_msg_put_u64(ctx->odp_actions, ODPAT_CONTROLLER, max_len);
break;
case OFPP_LOCAL:
add_output_action(ctx, ODPP_LOCAL);
const struct nx_action_resubmit *nar;
const struct nx_action_set_tunnel *nast;
const struct nx_action_set_queue *nasq;
+ const struct nx_action_multipath *nam;
enum nx_action_subtype subtype = ntohs(nah->subtype);
+ ovs_be64 tun_id;
assert(nah->vendor == htonl(NX_VENDOR_ID));
switch (subtype) {
case NXAST_SET_TUNNEL:
nast = (const struct nx_action_set_tunnel *) nah;
- nl_msg_put_be32(ctx->odp_actions, ODPAT_SET_TUNNEL, nast->tun_id);
- ctx->flow.tun_id = nast->tun_id;
+ tun_id = htonll(ntohl(nast->tun_id));
+ nl_msg_put_be64(ctx->odp_actions, ODPAT_SET_TUNNEL, tun_id);
+ ctx->flow.tun_id = tun_id;
break;
case NXAST_DROP_SPOOFED_ARP:
/* Nothing to do. */
break;
+ case NXAST_SET_TUNNEL64:
+ tun_id = ((const struct nx_action_set_tunnel64 *) nah)->tun_id;
+ nl_msg_put_be64(ctx->odp_actions, ODPAT_SET_TUNNEL, tun_id);
+ ctx->flow.tun_id = tun_id;
+ break;
+
+ case NXAST_MULTIPATH:
+ nam = (const struct nx_action_multipath *) nah;
+ multipath_execute(nam, &ctx->flow);
+ break;
+
/* If you add a new action here that modifies flow data, don't forget to
* update the flow key in ctx->flow at the same time. */
nsm->type = htons(OFPST_VENDOR);
nsm->flags = htons(0);
nsm->vendor = htonl(NX_VENDOR_ID);
- nsm->subtype = htonl(subtype);
+ nsm->subtype = subtype;
return msg;
}
ofs->length = htons(len);
ofs->table_id = 0;
ofs->pad = 0;
- ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofs->match);
+ ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofs->match,
+ rule->flow_cookie, &ofs->cookie);
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);
ofs->hard_timeout = htons(rule->hard_timeout);
static void
flow_stats_ds(struct ofproto *ofproto, struct rule *rule, struct ds *results)
{
- struct ofp_match match;
uint64_t packet_count, byte_count;
size_t act_len = sizeof *rule->actions * rule->n_actions;
query_stats(ofproto, rule, &packet_count, &byte_count);
- ofputil_cls_rule_to_match(&rule->cr, NXFF_OPENFLOW10, &match);
ds_put_format(results, "duration=%llds, ",
(time_msec() - rule->created) / 1000);
ds_put_format(results, "priority=%u, ", rule->cr.priority);
ds_put_format(results, "n_packets=%"PRIu64", ", packet_count);
ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
- ofp_print_match(results, &match, true);
+ cls_rule_format(&rule->cr, results);
if (act_len > 0) {
ofp_print_actions(results, &rule->actions->header, act_len);
} else {
struct ofp_flow_removed *ofr;
struct ofpbuf *buf;
- ofr = make_openflow(sizeof *ofr, OFPT_FLOW_REMOVED, &buf);
- ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofr->match);
- ofr->cookie = rule->flow_cookie;
+ ofr = make_openflow_xid(sizeof *ofr, OFPT_FLOW_REMOVED, htonl(0), &buf);
+ ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofr->match,
+ rule->flow_cookie, &ofr->cookie);
ofr->priority = htons(rule->cr.priority);
ofr->reason = reason;
calc_flow_duration(rule->created, &ofr->duration_sec, &ofr->duration_nsec);
struct ofpbuf *buf;
int match_len;
- nfr = make_nxmsg(sizeof *nfr, NXT_FLOW_REMOVED, &buf);
-
+ make_nxmsg_xid(sizeof *nfr, NXT_FLOW_REMOVED, htonl(0), &buf);
match_len = nx_put_match(buf, &rule->cr);
+ nfr = buf->data;
nfr->cookie = rule->flow_cookie;
nfr->priority = htons(rule->cr.priority);
nfr->reason = reason;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff