static void queue_tx(struct ofpbuf *msg, const struct ofconn *ofconn,
struct rconn_packet_counter *counter);
-static void send_packet_in(struct ofproto *, struct ofpbuf *odp_msg);
-static void do_send_packet_in(struct ofpbuf *odp_msg, void *ofconn);
+static void send_packet_in(struct ofproto *, struct dpif_upcall *,
+ const struct flow *, bool clone);
+static void do_send_packet_in(struct ofpbuf *ofp_packet_in, void *ofconn);
struct ofproto {
/* Settings. */
static int ofproto_expire(struct ofproto *);
-static void handle_odp_msg(struct ofproto *, struct ofpbuf *);
+static void handle_upcall(struct ofproto *, struct dpif_upcall *);
static void handle_openflow(struct ofconn *, struct ofpbuf *);
}
for (i = 0; i < 50; i++) {
- struct ofpbuf *buf;
+ struct dpif_upcall packet;
- error = dpif_recv(p->dpif, &buf);
+ error = dpif_recv(p->dpif, &packet);
if (error) {
if (error == ENODEV) {
/* Someone destroyed the datapath behind our back. The caller
break;
}
- handle_odp_msg(p, buf);
+ handle_upcall(p, &packet);
}
while ((error = dpif_port_poll(p->dpif, &devname)) != EAGAIN) {
return !hmap_is_empty(&p->controllers);
}
+void
+ofproto_get_ofproto_controller_info(const struct ofproto * ofproto,
+ struct shash *info)
+{
+ const struct ofconn *ofconn;
+
+ shash_init(info);
+
+ HMAP_FOR_EACH (ofconn, hmap_node, &ofproto->controllers) {
+ const struct rconn *rconn = ofconn->rconn;
+ const int last_error = rconn_get_last_error(rconn);
+ struct ofproto_controller_info *cinfo = xmalloc(sizeof *cinfo);
+
+ shash_add(info, rconn_get_target(rconn), cinfo);
+
+ cinfo->is_connected = rconn_is_connected(rconn);
+ cinfo->role = ofconn->role;
+
+ cinfo->pairs.n = 0;
+
+ if (last_error == EOF) {
+ cinfo->pairs.keys[cinfo->pairs.n] = "last_error";
+ cinfo->pairs.values[cinfo->pairs.n++] = xstrdup("End of file");
+ } else if (last_error > 0) {
+ cinfo->pairs.keys[cinfo->pairs.n] = "last_error";
+ cinfo->pairs.values[cinfo->pairs.n++] =
+ xstrdup(strerror(last_error));
+ }
+
+ cinfo->pairs.keys[cinfo->pairs.n] = "state";
+ cinfo->pairs.values[cinfo->pairs.n++] =
+ xstrdup(rconn_get_state(rconn));
+
+ cinfo->pairs.keys[cinfo->pairs.n] = "time_in_state";
+ cinfo->pairs.values[cinfo->pairs.n++] =
+ xasprintf("%u", rconn_get_state_elapsed(rconn));
+ }
+}
+
+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);
+}
+
/* Deletes port number 'odp_port' from the datapath for 'ofproto'.
*
* This is almost the same as calling dpif_port_del() directly on the
*
* Takes ownership of 'packet'. */
static bool
-execute_odp_actions(struct ofproto *ofproto, uint16_t in_port,
+execute_odp_actions(struct ofproto *ofproto, const struct flow *flow,
const struct nlattr *odp_actions, size_t actions_len,
struct ofpbuf *packet)
{
/* As an optimization, avoid a round-trip from userspace to kernel to
* userspace. This also avoids possibly filling up kernel packet
* buffers along the way. */
- struct odp_msg *msg;
+ struct dpif_upcall upcall;
- msg = ofpbuf_push_uninit(packet, sizeof *msg);
- msg->type = _ODPL_ACTION_NR;
- msg->length = sizeof(struct odp_msg) + packet->size;
- msg->port = in_port;
- msg->arg = nl_attr_get_u64(odp_actions);
+ upcall.type = _ODPL_ACTION_NR;
+ upcall.packet = packet;
+ upcall.key = NULL;
+ upcall.key_len = 0;
+ upcall.userdata = nl_attr_get_u64(odp_actions);
+ upcall.sample_pool = 0;
+ upcall.actions = NULL;
+ upcall.actions_len = 0;
- send_packet_in(ofproto, packet);
+ send_packet_in(ofproto, &upcall, flow, false);
return true;
} else {
assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
flow_extract_stats(&facet->flow, packet, &stats);
- if (execute_odp_actions(ofproto, facet->flow.in_port,
+ if (execute_odp_actions(ofproto, &facet->flow,
facet->actions, facet->actions_len, packet)) {
facet_update_stats(ofproto, facet, &stats);
facet->used = time_msec();
action_xlate_ctx_init(&ctx, ofproto, &flow, packet);
odp_actions = xlate_actions(&ctx, rule->actions, rule->n_actions);
size = packet->size;
- if (execute_odp_actions(ofproto, in_port, odp_actions->data,
+ if (execute_odp_actions(ofproto, &flow, odp_actions->data,
odp_actions->size, packet)) {
rule->used = time_msec();
rule->packet_count++;
facet_put__(struct ofproto *ofproto, struct facet *facet, int flags,
struct odp_flow_put *put)
{
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
+ struct ofpbuf key;
+
+ ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
+ odp_flow_key_from_flow(&key, &facet->flow);
+ assert(key.base == keybuf);
+
memset(&put->flow.stats, 0, sizeof put->flow.stats);
- odp_flow_key_from_flow(&put->flow.key, &facet->flow);
+ put->flow.key = key.data;
+ put->flow.key_len = key.size;
put->flow.actions = facet->actions;
put->flow.actions_len = facet->actions_len;
put->flow.flags = 0;
facet_uninstall(struct ofproto *p, struct facet *facet)
{
if (facet->installed) {
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
struct odp_flow odp_flow;
+ struct ofpbuf key;
+
+ ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
+ odp_flow_key_from_flow(&key, &facet->flow);
+ assert(key.base == keybuf);
- odp_flow_key_from_flow(&odp_flow.key, &facet->flow);
+ odp_flow.key = key.data;
+ odp_flow.key_len = key.size;
odp_flow.actions = NULL;
odp_flow.actions_len = 0;
odp_flow.flags = 0;
* to talk to the datapath. */
if (actions_changed || facet->may_install != facet->installed) {
if (facet->may_install) {
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
struct odp_flow_put put;
+ struct ofpbuf key;
+
+ ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
+ odp_flow_key_from_flow(&key, &facet->flow);
memset(&put.flow.stats, 0, sizeof put.flow.stats);
- odp_flow_key_from_flow(&put.flow.key, &facet->flow);
+ put.flow.key = key.data;
+ put.flow.key_len = key.size;
put.flow.actions = odp_actions->data;
put.flow.actions_len = odp_actions->size;
put.flow.flags = 0;
}
}
+struct xlate_reg_state {
+ ovs_be16 vlan_tci;
+ ovs_be64 tun_id;
+};
+
static void
-xlate_reg_move_action(struct action_xlate_ctx *ctx,
- const struct nx_action_reg_move *narm)
+save_reg_state(const struct action_xlate_ctx *ctx,
+ struct xlate_reg_state *state)
{
- ovs_be16 old_tci = ctx->flow.vlan_tci;
-
- nxm_execute_reg_move(narm, &ctx->flow);
+ state->vlan_tci = ctx->flow.vlan_tci;
+ state->tun_id = ctx->flow.tun_id;
+}
- if (ctx->flow.vlan_tci != old_tci) {
+static void
+update_reg_state(struct action_xlate_ctx *ctx,
+ const struct xlate_reg_state *state)
+{
+ if (ctx->flow.vlan_tci != state->vlan_tci) {
xlate_set_dl_tci(ctx);
}
+ if (ctx->flow.tun_id != state->tun_id) {
+ nl_msg_put_be64(ctx->odp_actions, ODPAT_SET_TUNNEL, ctx->flow.tun_id);
+ }
}
static void
const struct nx_action_set_queue *nasq;
const struct nx_action_multipath *nam;
enum nx_action_subtype subtype = ntohs(nah->subtype);
+ struct xlate_reg_state state;
ovs_be64 tun_id;
assert(nah->vendor == htonl(NX_VENDOR_ID));
break;
case NXAST_REG_MOVE:
- xlate_reg_move_action(ctx, (const struct nx_action_reg_move *) nah);
+ save_reg_state(ctx, &state);
+ nxm_execute_reg_move((const struct nx_action_reg_move *) nah,
+ &ctx->flow);
+ update_reg_state(ctx, &state);
break;
case NXAST_REG_LOAD:
+ save_reg_state(ctx, &state);
nxm_execute_reg_load((const struct nx_action_reg_load *) nah,
&ctx->flow);
+ update_reg_state(ctx, &state);
+ break;
case NXAST_NOTE:
/* Nothing to do. */
query_stats(struct ofproto *p, struct rule *rule,
uint64_t *packet_countp, uint64_t *byte_countp)
{
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
uint64_t packet_count, byte_count;
struct facet *facet;
- struct odp_flow *odp_flows;
- size_t n_odp_flows;
+ struct ofpbuf key;
/* Start from historical data for 'rule' itself that are no longer tracked
* by the datapath. This counts, for example, facets that have expired. */
packet_count = rule->packet_count;
byte_count = rule->byte_count;
- /* Prepare to ask the datapath for statistics on all of the rule's facets.
+ /* Ask the datapath for statistics on all of the rule's facets. (We could
+ * batch up statistics requests using dpif_flow_get_multiple(), but that is
+ * not yet implemented.)
*
* Also, add any statistics that are not tracked by the datapath for each
* facet. This includes, for example, statistics for packets that were
* executed "by hand" by ofproto via dpif_execute() but must be accounted
* to a rule. */
- odp_flows = xzalloc(list_size(&rule->facets) * sizeof *odp_flows);
- n_odp_flows = 0;
+ ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
LIST_FOR_EACH (facet, list_node, &rule->facets) {
- struct odp_flow *odp_flow = &odp_flows[n_odp_flows++];
- odp_flow_key_from_flow(&odp_flow->key, &facet->flow);
- packet_count += facet->packet_count;
- byte_count += facet->byte_count;
- }
+ struct odp_flow odp_flow;
- /* Fetch up-to-date statistics from the datapath and add them in. */
- if (!dpif_flow_get_multiple(p->dpif, odp_flows, n_odp_flows)) {
- size_t i;
+ ofpbuf_clear(&key);
+ odp_flow_key_from_flow(&key, &facet->flow);
- for (i = 0; i < n_odp_flows; i++) {
- struct odp_flow *odp_flow = &odp_flows[i];
- packet_count += odp_flow->stats.n_packets;
- byte_count += odp_flow->stats.n_bytes;
+ odp_flow.key = key.data;
+ odp_flow.key_len = key.size;
+ odp_flow.actions = NULL;
+ odp_flow.actions_len = 0;
+ odp_flow.flags = 0;
+ if (!dpif_flow_get(p->dpif, &odp_flow)) {
+ packet_count += odp_flow.stats.n_packets;
+ byte_count += odp_flow.stats.n_bytes;
}
+
+ packet_count += facet->packet_count;
+ byte_count += facet->byte_count;
}
- free(odp_flows);
/* Return the stats to the caller. */
*packet_countp = packet_count;
act_len = sizeof *rule->actions * rule->n_actions;
- start_len = (*replyp)->size;
append_nxstats_reply(sizeof *nfs + NXM_MAX_LEN + act_len, ofconn, replyp);
+ start_len = (*replyp)->size;
reply = *replyp;
nfs = ofpbuf_put_uninit(reply, sizeof *nfs);
}
\f
static void
-handle_odp_miss_msg(struct ofproto *p, struct ofpbuf *packet)
+handle_miss_upcall(struct ofproto *p, struct dpif_upcall *upcall)
{
- struct odp_msg *msg = packet->data;
- struct ofpbuf payload;
struct facet *facet;
struct flow flow;
- ofpbuf_use_const(&payload, msg + 1, msg->length - sizeof *msg);
- flow_extract(&payload, msg->arg, msg->port, &flow);
+ /* Obtain in_port and tun_id, at least. */
+ odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
- packet->l2 = payload.l2;
- packet->l3 = payload.l3;
- packet->l4 = payload.l4;
- packet->l7 = payload.l7;
+ /* Set header pointers in 'flow'. */
+ flow_extract(upcall->packet, flow.tun_id, flow.in_port, &flow);
/* Check with in-band control to see if this packet should be sent
* to the local port regardless of the flow table. */
- if (in_band_msg_in_hook(p->in_band, &flow, &payload)) {
+ if (in_band_msg_in_hook(p->in_band, &flow, upcall->packet)) {
struct ofpbuf odp_actions;
ofpbuf_init(&odp_actions, 32);
nl_msg_put_u32(&odp_actions, ODPAT_OUTPUT, ODPP_LOCAL);
- dpif_execute(p->dpif, odp_actions.data, odp_actions.size, &payload);
+ dpif_execute(p->dpif, odp_actions.data, odp_actions.size,
+ upcall->packet);
ofpbuf_uninit(&odp_actions);
}
struct rule *rule = rule_lookup(p, &flow);
if (!rule) {
/* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
- struct ofport *port = get_port(p, msg->port);
+ struct ofport *port = get_port(p, flow.in_port);
if (port) {
if (port->opp.config & OFPPC_NO_PACKET_IN) {
COVERAGE_INC(ofproto_no_packet_in);
/* XXX install 'drop' flow entry */
- ofpbuf_delete(packet);
+ ofpbuf_delete(upcall->packet);
return;
}
} else {
VLOG_WARN_RL(&rl, "packet-in on unknown port %"PRIu16,
- msg->port);
+ flow.in_port);
}
COVERAGE_INC(ofproto_packet_in);
- send_packet_in(p, packet);
+ send_packet_in(p, upcall, &flow, false);
return;
}
- facet = facet_create(p, rule, &flow, packet);
+ facet = facet_create(p, rule, &flow, upcall->packet);
} else if (!facet->may_install) {
/* The facet is not installable, that is, we need to process every
* packet, so process the current packet's actions into 'facet'. */
- facet_make_actions(p, facet, packet);
+ facet_make_actions(p, facet, upcall->packet);
}
if (facet->rule->cr.priority == FAIL_OPEN_PRIORITY) {
*
* See the top-level comment in fail-open.c for more information.
*/
- send_packet_in(p, ofpbuf_clone_with_headroom(packet,
- DPIF_RECV_MSG_PADDING));
+ send_packet_in(p, upcall, &flow, true);
}
- ofpbuf_pull(packet, sizeof *msg);
- facet_execute(p, facet, packet);
+ facet_execute(p, facet, upcall->packet);
facet_install(p, facet, false);
}
static void
-handle_odp_msg(struct ofproto *p, struct ofpbuf *packet)
+handle_upcall(struct ofproto *p, struct dpif_upcall *upcall)
{
- struct odp_msg *msg = packet->data;
+ struct flow flow;
- switch (msg->type) {
+ switch (upcall->type) {
case _ODPL_ACTION_NR:
COVERAGE_INC(ofproto_ctlr_action);
- send_packet_in(p, packet);
+ odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
+ send_packet_in(p, upcall, &flow, false);
break;
case _ODPL_SFLOW_NR:
if (p->sflow) {
- ofproto_sflow_received(p->sflow, msg);
+ odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
+ ofproto_sflow_received(p->sflow, upcall, &flow);
}
- ofpbuf_delete(packet);
+ ofpbuf_delete(upcall->packet);
break;
case _ODPL_MISS_NR:
- handle_odp_miss_msg(p, packet);
+ handle_miss_upcall(p, upcall);
break;
default:
- VLOG_WARN_RL(&rl, "received ODP message of unexpected type %"PRIu32,
- msg->type);
+ VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32, upcall->type);
break;
}
}
static void
ofproto_update_used(struct ofproto *p)
{
- struct odp_flow *flows;
- size_t n_flows;
- size_t i;
- int error;
+ struct dpif_flow_dump dump;
- error = dpif_flow_list_all(p->dpif, &flows, &n_flows);
- if (error) {
- return;
- }
-
- for (i = 0; i < n_flows; i++) {
- struct odp_flow *f = &flows[i];
+ dpif_flow_dump_start(&dump, p->dpif);
+ for (;;) {
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
struct facet *facet;
+ struct odp_flow f;
struct flow flow;
- odp_flow_key_to_flow(&f->key, &flow);
+ memset(&f, 0, sizeof f);
+ f.key = (struct nlattr *) keybuf;
+ f.key_len = sizeof keybuf;
+ if (!dpif_flow_dump_next(&dump, &f)) {
+ break;
+ }
+
+ if (f.key_len > sizeof keybuf) {
+ VLOG_WARN_RL(&rl, "ODP flow key overflowed buffer");
+ continue;
+ }
+ if (odp_flow_key_to_flow(f.key, f.key_len, &flow)) {
+ struct ds s;
+
+ ds_init(&s);
+ odp_flow_key_format(f.key, f.key_len, &s);
+ VLOG_WARN_RL(&rl, "failed to convert ODP flow key to flow: %s",
+ ds_cstr(&s));
+ ds_destroy(&s);
+
+ continue;
+ }
facet = facet_find(p, &flow);
if (facet && facet->installed) {
- facet_update_time(p, facet, &f->stats);
- facet_account(p, facet, f->stats.n_bytes);
+ facet_update_time(p, facet, &f.stats);
+ facet_account(p, facet, f.stats.n_bytes);
} else {
/* There's a flow in the datapath that we know nothing about.
* Delete it. */
COVERAGE_INC(ofproto_unexpected_rule);
- dpif_flow_del(p->dpif, f);
+ dpif_flow_del(p->dpif, &f);
}
-
}
- free(flows);
+ dpif_flow_dump_done(&dump);
}
/* Calculates and returns the number of milliseconds of idle time after which
* ofproto_update_used() zeroed TCP flags. */
memset(&odp_flow, 0, sizeof odp_flow);
if (facet->installed) {
- odp_flow_key_from_flow(&odp_flow.key, &facet->flow);
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
+ struct ofpbuf key;
+
+ ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
+ odp_flow_key_from_flow(&key, &facet->flow);
+
+ odp_flow.key = key.data;
+ odp_flow.key_len = key.size;
odp_flow.flags = ODPFF_ZERO_TCP_FLAGS;
dpif_flow_get(ofproto->dpif, &odp_flow);
}
}
-/* pinsched callback for sending 'packet' on 'ofconn'. */
+/* pinsched callback for sending 'ofp_packet_in' on 'ofconn'. */
static void
-do_send_packet_in(struct ofpbuf *packet, void *ofconn_)
+do_send_packet_in(struct ofpbuf *ofp_packet_in, void *ofconn_)
{
struct ofconn *ofconn = ofconn_;
- rconn_send_with_limit(ofconn->rconn, packet,
+ rconn_send_with_limit(ofconn->rconn, ofp_packet_in,
ofconn->packet_in_counter, 100);
}
-/* Takes 'packet', which has been converted with do_convert_to_packet_in(), and
- * finalizes its content for sending on 'ofconn', and passes it to 'ofconn''s
- * packet scheduler for sending.
- *
- * 'max_len' specifies the maximum number of bytes of the packet to send on
- * 'ofconn' (INT_MAX specifies no limit).
+/* Takes 'upcall', whose packet has the flow specified by 'flow', composes an
+ * OpenFlow packet-in message from it, and passes it to 'ofconn''s packet
+ * scheduler for sending.
*
- * If 'clone' is true, the caller retains ownership of 'packet'. Otherwise,
- * ownership is transferred to this function. */
+ * If 'clone' is true, the caller retains ownership of 'upcall->packet'.
+ * Otherwise, ownership is transferred to this function. */
static void
-schedule_packet_in(struct ofconn *ofconn, struct ofpbuf *packet, int max_len,
- bool clone)
+schedule_packet_in(struct ofconn *ofconn, struct dpif_upcall *upcall,
+ const struct flow *flow, bool clone)
{
+ enum { OPI_SIZE = offsetof(struct ofp_packet_in, data) };
struct ofproto *ofproto = ofconn->ofproto;
- struct ofp_packet_in *opi = packet->data;
- uint16_t in_port = ofp_port_to_odp_port(ntohs(opi->in_port));
- int send_len, trim_size;
+ struct ofp_packet_in *opi;
+ int total_len, send_len;
+ struct ofpbuf *packet;
uint32_t buffer_id;
- /* Get buffer. */
- if (opi->reason == OFPR_ACTION) {
+ /* Get OpenFlow buffer_id. */
+ if (upcall->type == _ODPL_ACTION_NR) {
buffer_id = UINT32_MAX;
} else if (ofproto->fail_open && fail_open_is_active(ofproto->fail_open)) {
buffer_id = pktbuf_get_null();
} else if (!ofconn->pktbuf) {
buffer_id = UINT32_MAX;
} else {
- struct ofpbuf payload;
-
- ofpbuf_use_const(&payload, opi->data,
- packet->size - offsetof(struct ofp_packet_in, data));
- buffer_id = pktbuf_save(ofconn->pktbuf, &payload, in_port);
+ buffer_id = pktbuf_save(ofconn->pktbuf, upcall->packet, flow->in_port);
}
/* Figure out how much of the packet to send. */
- send_len = ntohs(opi->total_len);
+ total_len = send_len = upcall->packet->size;
if (buffer_id != UINT32_MAX) {
send_len = MIN(send_len, ofconn->miss_send_len);
}
- send_len = MIN(send_len, max_len);
+ if (upcall->type == _ODPL_ACTION_NR) {
+ send_len = MIN(send_len, upcall->userdata);
+ }
- /* Adjust packet length and clone if necessary. */
- trim_size = offsetof(struct ofp_packet_in, data) + send_len;
+ /* Copy or steal buffer for OFPT_PACKET_IN. */
if (clone) {
- packet = ofpbuf_clone_data(packet->data, trim_size);
- opi = packet->data;
+ packet = ofpbuf_clone_data_with_headroom(upcall->packet->data,
+ send_len, OPI_SIZE);
} else {
- packet->size = trim_size;
+ packet = upcall->packet;
+ packet->size = send_len;
}
- /* Update packet headers. */
+ /* Add OFPT_PACKET_IN. */
+ opi = ofpbuf_push_zeros(packet, OPI_SIZE);
+ opi->header.version = OFP_VERSION;
+ opi->header.type = OFPT_PACKET_IN;
+ opi->total_len = htons(total_len);
+ opi->in_port = htons(odp_port_to_ofp_port(flow->in_port));
+ opi->reason = upcall->type == _ODPL_MISS_NR ? OFPR_NO_MATCH : OFPR_ACTION;
opi->buffer_id = htonl(buffer_id);
update_openflow_length(packet);
/* Hand over to packet scheduler. It might immediately call into
* do_send_packet_in() or it might buffer it for a while (until a later
* call to pinsched_run()). */
- pinsched_send(ofconn->schedulers[opi->reason], in_port,
+ pinsched_send(ofconn->schedulers[opi->reason], flow->in_port,
packet, do_send_packet_in, ofconn);
}
-/* Replace struct odp_msg header in 'packet' by equivalent struct
- * ofp_packet_in. The odp_msg must have sufficient headroom to do so (e.g. as
- * returned by dpif_recv()).
- *
- * The conversion is not complete: the caller still needs to trim any unneeded
- * payload off the end of the buffer, set the length in the OpenFlow header,
- * and set buffer_id. Those require us to know the controller settings and so
- * must be done on a per-controller basis.
- *
- * Returns the maximum number of bytes of the packet that should be sent to
- * the controller (INT_MAX if no limit). */
-static int
-do_convert_to_packet_in(struct ofpbuf *packet)
-{
- struct odp_msg *msg = packet->data;
- struct ofp_packet_in *opi;
- uint8_t reason;
- uint16_t total_len;
- uint16_t in_port;
- int max_len;
-
- /* Extract relevant header fields */
- if (msg->type == _ODPL_ACTION_NR) {
- reason = OFPR_ACTION;
- max_len = msg->arg;
- } else {
- reason = OFPR_NO_MATCH;
- max_len = INT_MAX;
- }
- total_len = msg->length - sizeof *msg;
- in_port = odp_port_to_ofp_port(msg->port);
-
- /* Repurpose packet buffer by overwriting header. */
- ofpbuf_pull(packet, sizeof(struct odp_msg));
- opi = ofpbuf_push_zeros(packet, offsetof(struct ofp_packet_in, data));
- opi->header.version = OFP_VERSION;
- opi->header.type = OFPT_PACKET_IN;
- opi->total_len = htons(total_len);
- opi->in_port = htons(in_port);
- opi->reason = reason;
-
- return max_len;
-}
-
-/* Given 'packet' containing an odp_msg of type _ODPL_ACTION_NR or
- * _ODPL_MISS_NR, sends an OFPT_PACKET_IN message to each OpenFlow controller
- * as necessary according to their individual configurations.
- *
- * 'packet' must have sufficient headroom to convert it into a struct
- * ofp_packet_in (e.g. as returned by dpif_recv()).
+/* Given 'upcall', of type _ODPL_ACTION_NR or _ODPL_MISS_NR, sends an
+ * OFPT_PACKET_IN message to each OpenFlow controller as necessary according to
+ * their individual configurations.
*
* Takes ownership of 'packet'. */
static void
-send_packet_in(struct ofproto *ofproto, struct ofpbuf *packet)
+send_packet_in(struct ofproto *ofproto, struct dpif_upcall *upcall,
+ const struct flow *flow, bool clone)
{
struct ofconn *ofconn, *prev;
- int max_len;
-
- max_len = do_convert_to_packet_in(packet);
prev = NULL;
LIST_FOR_EACH (ofconn, node, &ofproto->all_conns) {
if (ofconn_receives_async_msgs(ofconn)) {
if (prev) {
- schedule_packet_in(prev, packet, max_len, true);
+ schedule_packet_in(prev, upcall, flow, true);
}
prev = ofconn;
}
}
if (prev) {
- schedule_packet_in(prev, packet, max_len, false);
- } else {
- ofpbuf_delete(packet);
+ schedule_packet_in(prev, upcall, flow, clone);
+ } else if (!clone) {
+ ofpbuf_delete(upcall->packet);
}
}
struct ds result;
struct flow flow;
uint16_t in_port;
- ovs_be32 tun_id;
+ ovs_be64 tun_id;
char *s;
ofpbuf_init(&packet, strlen(args) / 2);
goto exit;
}
- tun_id = ntohl(strtoul(tun_id_s, NULL, 10));
+ tun_id = htonll(strtoull(tun_id_s, NULL, 10));
in_port = ofp_port_to_odp_port(atoi(in_port_s));
packet_s = ofpbuf_put_hex(&packet, packet_s, NULL);
git://git.onelab.eu / sliver-openvswitch.git / blobdiff