X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=39d345736375efa04bf1a28a484507668ba0c79c;hb=ee9b9e716a18cc0b0e8861958c3a3eb110f89b93;hp=c980f693124213dd12ae7f1cf16e4ecdbfa4d6e5;hpb=c18ea70d06e980dc768166881c5aeac0b3491561;p=openvswitch

diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c
index c980f693..39d34573 100644
--- a/ofproto/ofproto.c
+++ b/ofproto/ofproto.c
@@ -59,6 +59,7 @@
 #include "svec.h"
 #include "tag.h"
 #include "timeval.h"
+#include "unaligned.h"
 #include "unixctl.h"
 #include "vconn.h"
 #include "vlog.h"
@@ -124,6 +125,11 @@ struct action_xlate_ctx {
      * calling action_xlate_ctx_init(). */
     void (*resubmit_hook)(struct action_xlate_ctx *, const struct rule *);
 
+    /* If true, the speciality of 'flow' should be checked before executing
+     * its actions.  If special_cb returns false on 'flow' rendered
+     * uninstallable and no actions will be executed. */
+    bool check_special;
+
 /* xlate_actions() initializes and uses these members.  The client might want
  * to look at them after it returns. */
 
@@ -1445,6 +1451,8 @@ ofproto_send_packet(struct ofproto *p, const struct flow *flow,
     struct ofpbuf *odp_actions;
 
     action_xlate_ctx_init(&ctx, p, flow, packet);
+    /* Always xlate packets originated in this function. */
+    ctx.check_special = false;
     odp_actions = xlate_actions(&ctx, actions, n_actions);
 
     /* XXX Should we translate the dpif_execute() errno value into an OpenFlow
@@ -1566,7 +1574,7 @@ make_ofport(const struct dpif_port *dpif_port)
         return NULL;
     }
 
-    ofport = xmalloc(sizeof *ofport);
+    ofport = xzalloc(sizeof *ofport);
     ofport->netdev = netdev;
     ofport->odp_port = dpif_port->port_no;
     ofport->opp.port_no = odp_port_to_ofp_port(dpif_port->port_no);
@@ -3109,6 +3117,7 @@ action_xlate_ctx_init(struct action_xlate_ctx *ctx,
     ctx->flow = *flow;
     ctx->packet = packet;
     ctx->resubmit_hook = NULL;
+    ctx->check_special = true;
 }
 
 static struct ofpbuf *
@@ -3123,7 +3132,16 @@ xlate_actions(struct action_xlate_ctx *ctx,
     ctx->nf_output_iface = NF_OUT_DROP;
     ctx->recurse = 0;
     ctx->last_pop_priority = -1;
-    do_xlate_actions(in, n_in, ctx);
+
+    if (!ctx->check_special
+        || (ctx->ofproto->ofhooks->special_cb
+            && ctx->ofproto->ofhooks->special_cb(&ctx->flow, ctx->packet,
+                                                 ctx->ofproto->aux))) {
+        do_xlate_actions(in, n_in, ctx);
+    } else {
+        ctx->may_set_up_flow = false;
+    }
+
     remove_pop_action(ctx);
 
     /* Check with in-band control to see if we're allowed to set up this
@@ -3383,8 +3401,8 @@ handle_table_stats_request(struct ofconn *ofconn,
                       ? htonl(OFPFW_ALL) : htonl(OVSFW_ALL));
     ots->max_entries = htonl(1024 * 1024); /* An arbitrary big number. */
     ots->active_count = htonl(classifier_count(&p->cls));
-    ots->lookup_count = htonll(0);              /* XXX */
-    ots->matched_count = htonll(0);             /* XXX */
+    put_32aligned_be64(&ots->lookup_count, htonll(0));  /* XXX */
+    put_32aligned_be64(&ots->matched_count, htonll(0)); /* XXX */
 
     queue_tx(msg, ofconn, ofconn->reply_counter);
     return 0;
@@ -3405,18 +3423,18 @@ append_port_stat(struct ofport *port, struct ofconn *ofconn,
     ops = append_ofp_stats_reply(sizeof *ops, ofconn, msgp);
     ops->port_no = htons(port->opp.port_no);
     memset(ops->pad, 0, sizeof ops->pad);
-    ops->rx_packets = htonll(stats.rx_packets);
-    ops->tx_packets = htonll(stats.tx_packets);
-    ops->rx_bytes = htonll(stats.rx_bytes);
-    ops->tx_bytes = htonll(stats.tx_bytes);
-    ops->rx_dropped = htonll(stats.rx_dropped);
-    ops->tx_dropped = htonll(stats.tx_dropped);
-    ops->rx_errors = htonll(stats.rx_errors);
-    ops->tx_errors = htonll(stats.tx_errors);
-    ops->rx_frame_err = htonll(stats.rx_frame_errors);
-    ops->rx_over_err = htonll(stats.rx_over_errors);
-    ops->rx_crc_err = htonll(stats.rx_crc_errors);
-    ops->collisions = htonll(stats.collisions);
+    put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets));
+    put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets));
+    put_32aligned_be64(&ops->rx_bytes, htonll(stats.rx_bytes));
+    put_32aligned_be64(&ops->tx_bytes, htonll(stats.tx_bytes));
+    put_32aligned_be64(&ops->rx_dropped, htonll(stats.rx_dropped));
+    put_32aligned_be64(&ops->tx_dropped, htonll(stats.tx_dropped));
+    put_32aligned_be64(&ops->rx_errors, htonll(stats.rx_errors));
+    put_32aligned_be64(&ops->tx_errors, htonll(stats.tx_errors));
+    put_32aligned_be64(&ops->rx_frame_err, htonll(stats.rx_frame_errors));
+    put_32aligned_be64(&ops->rx_over_err, htonll(stats.rx_over_errors));
+    put_32aligned_be64(&ops->rx_crc_err, htonll(stats.rx_crc_errors));
+    put_32aligned_be64(&ops->collisions, htonll(stats.collisions));
 }
 
 static int
@@ -3498,6 +3516,7 @@ put_ofp_flow_stats(struct ofconn *ofconn, struct rule *rule,
 {
     struct ofp_flow_stats *ofs;
     uint64_t packet_count, byte_count;
+    ovs_be64 cookie;
     size_t act_len, len;
 
     if (rule_is_hidden(rule) || !rule_has_out_port(rule, out_port)) {
@@ -3514,14 +3533,15 @@ put_ofp_flow_stats(struct ofconn *ofconn, struct rule *rule,
     ofs->table_id = 0;
     ofs->pad = 0;
     ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofs->match,
-                              rule->flow_cookie, &ofs->cookie);
+                              rule->flow_cookie, &cookie);
+    put_32aligned_be64(&ofs->cookie, cookie);
     calc_flow_duration(rule->created, &ofs->duration_sec, &ofs->duration_nsec);
     ofs->priority = htons(rule->cr.priority);
     ofs->idle_timeout = htons(rule->idle_timeout);
     ofs->hard_timeout = htons(rule->hard_timeout);
     memset(ofs->pad2, 0, sizeof ofs->pad2);
-    ofs->packet_count = htonll(packet_count);
-    ofs->byte_count = htonll(byte_count);
+    put_32aligned_be64(&ofs->packet_count, htonll(packet_count));
+    put_32aligned_be64(&ofs->byte_count, htonll(byte_count));
     if (rule->n_actions > 0) {
         memcpy(ofs->actions, rule->actions, act_len);
     }
@@ -3701,8 +3721,8 @@ query_aggregate_stats(struct ofproto *ofproto, struct cls_rule *target,
     }
 
     oasr->flow_count = htonl(n_flows);
-    oasr->packet_count = htonll(total_packets);
-    oasr->byte_count = htonll(total_bytes);
+    put_32aligned_be64(&oasr->packet_count, htonll(total_packets));
+    put_32aligned_be64(&oasr->byte_count, htonll(total_bytes));
     memset(oasr->pad, 0, sizeof oasr->pad);
 }
 
@@ -3775,9 +3795,9 @@ put_queue_stats(struct queue_stats_cbdata *cbdata, uint32_t queue_id,
     reply->port_no = htons(cbdata->ofport->opp.port_no);
     memset(reply->pad, 0, sizeof reply->pad);
     reply->queue_id = htonl(queue_id);
-    reply->tx_bytes = htonll(stats->tx_bytes);
-    reply->tx_packets = htonll(stats->tx_packets);
-    reply->tx_errors = htonll(stats->tx_errors);
+    put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes));
+    put_32aligned_be64(&reply->tx_packets, htonll(stats->tx_packets));
+    put_32aligned_be64(&reply->tx_errors, htonll(stats->tx_errors));
 }
 
 static void
@@ -4367,6 +4387,12 @@ handle_miss_upcall(struct ofproto *p, struct dpif_upcall *upcall)
     /* Set header pointers in 'flow'. */
     flow_extract(upcall->packet, flow.tun_id, flow.in_port, &flow);
 
+    if (p->ofhooks->special_cb
+        && !p->ofhooks->special_cb(&flow, upcall->packet, p->aux)) {
+        ofpbuf_delete(upcall->packet);
+        return;
+    }
+
     /* 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, upcall->packet)) {
@@ -5123,5 +5149,6 @@ default_normal_ofhook_cb(const struct flow *flow, const struct ofpbuf *packet,
 static const struct ofhooks default_ofhooks = {
     default_normal_ofhook_cb,
     NULL,
+    NULL,
     NULL
 };