X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fdpif-linux.c;h=c5628b7eb6d8abfd45a0412a44575f98a574be25;hb=d0c0b87f1ed1668499b8f4f770022ff3af225172;hp=43c2161464fbe7599dbae2550c592304c61197f1;hpb=09ded0ad489630236210a02f2d315816e558d701;p=openvswitch

diff --git a/lib/dpif-linux.c b/lib/dpif-linux.c
index 43c21614..c5628b7e 100644
--- a/lib/dpif-linux.c
+++ b/lib/dpif-linux.c
@@ -79,7 +79,6 @@ struct dpif_linux_dp {
     const char *name;                  /* OVS_DP_ATTR_NAME. */
     const uint32_t *upcall_pid;        /* OVS_DP_UPCALL_PID. */
     struct ovs_dp_stats stats;         /* OVS_DP_ATTR_STATS. */
-    enum ovs_datapath_frag ipv4_frags; /* OVS_DP_ATTR_IPV4_FRAGS. */
 };
 
 static void dpif_linux_dp_init(struct dpif_linux_dp *);
@@ -123,7 +122,7 @@ static int dpif_linux_flow_from_ofpbuf(struct dpif_linux_flow *,
                                        const struct ofpbuf *);
 static void dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow *,
                                       struct ofpbuf *);
-static int dpif_linux_flow_transact(const struct dpif_linux_flow *request,
+static int dpif_linux_flow_transact(struct dpif_linux_flow *request,
                                     struct dpif_linux_flow *reply,
                                     struct ofpbuf **bufp);
 static void dpif_linux_flow_get_stats(const struct dpif_linux_flow *,
@@ -347,7 +346,6 @@ dpif_linux_get_stats(const struct dpif *dpif_, struct dpif_dp_stats *stats)
 
     error = dpif_linux_dp_get(dpif_, &dp, &buf);
     if (!error) {
-        stats->n_frags  = dp.stats.n_frags;
         stats->n_hit    = dp.stats.n_hit;
         stats->n_missed = dp.stats.n_missed;
         stats->n_lost   = dp.stats.n_lost;
@@ -357,34 +355,6 @@ dpif_linux_get_stats(const struct dpif *dpif_, struct dpif_dp_stats *stats)
     return error;
 }
 
-static int
-dpif_linux_get_drop_frags(const struct dpif *dpif_, bool *drop_fragsp)
-{
-    struct dpif_linux_dp dp;
-    struct ofpbuf *buf;
-    int error;
-
-    error = dpif_linux_dp_get(dpif_, &dp, &buf);
-    if (!error) {
-        *drop_fragsp = dp.ipv4_frags == OVS_DP_FRAG_DROP;
-        ofpbuf_delete(buf);
-    }
-    return error;
-}
-
-static int
-dpif_linux_set_drop_frags(struct dpif *dpif_, bool drop_frags)
-{
-    struct dpif_linux *dpif = dpif_linux_cast(dpif_);
-    struct dpif_linux_dp dp;
-
-    dpif_linux_dp_init(&dp);
-    dp.cmd = OVS_DP_CMD_SET;
-    dp.dp_ifindex = dpif->dp_ifindex;
-    dp.ipv4_frags = drop_frags ? OVS_DP_FRAG_DROP : OVS_DP_FRAG_ZERO;
-    return dpif_linux_dp_transact(&dp, NULL, NULL);
-}
-
 static int
 dpif_linux_port_add(struct dpif *dpif_, struct netdev *netdev,
                     uint16_t *port_nop)
@@ -687,30 +657,43 @@ dpif_linux_flow_get(const struct dpif *dpif_,
     return error;
 }
 
+static void
+dpif_linux_init_flow_put(struct dpif *dpif_, enum dpif_flow_put_flags flags,
+                         const struct nlattr *key, size_t key_len,
+                         const struct nlattr *actions, size_t actions_len,
+                         struct dpif_linux_flow *request)
+{
+    static struct nlattr dummy_action;
+
+    struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+
+    dpif_linux_flow_init(request);
+    request->cmd = (flags & DPIF_FP_CREATE
+                    ? OVS_FLOW_CMD_NEW : OVS_FLOW_CMD_SET);
+    request->dp_ifindex = dpif->dp_ifindex;
+    request->key = key;
+    request->key_len = key_len;
+    /* Ensure that OVS_FLOW_ATTR_ACTIONS will always be included. */
+    request->actions = actions ? actions : &dummy_action;
+    request->actions_len = actions_len;
+    if (flags & DPIF_FP_ZERO_STATS) {
+        request->clear = true;
+    }
+    request->nlmsg_flags = flags & DPIF_FP_MODIFY ? 0 : NLM_F_CREATE;
+}
+
 static int
 dpif_linux_flow_put(struct dpif *dpif_, enum dpif_flow_put_flags flags,
                     const struct nlattr *key, size_t key_len,
                     const struct nlattr *actions, size_t actions_len,
                     struct dpif_flow_stats *stats)
 {
-    struct dpif_linux *dpif = dpif_linux_cast(dpif_);
     struct dpif_linux_flow request, reply;
-    struct nlattr dummy_action;
     struct ofpbuf *buf;
     int error;
 
-    dpif_linux_flow_init(&request);
-    request.cmd = flags & DPIF_FP_CREATE ? OVS_FLOW_CMD_NEW : OVS_FLOW_CMD_SET;
-    request.dp_ifindex = dpif->dp_ifindex;
-    request.key = key;
-    request.key_len = key_len;
-    /* Ensure that OVS_FLOW_ATTR_ACTIONS will always be included. */
-    request.actions = actions ? actions : &dummy_action;
-    request.actions_len = actions_len;
-    if (flags & DPIF_FP_ZERO_STATS) {
-        request.clear = true;
-    }
-    request.nlmsg_flags = flags & DPIF_FP_MODIFY ? 0 : NLM_F_CREATE;
+    dpif_linux_init_flow_put(dpif_, flags, key, key_len, actions, actions_len,
+                             &request);
     error = dpif_linux_flow_transact(&request,
                                      stats ? &reply : NULL,
                                      stats ? &buf : NULL);
@@ -837,19 +820,19 @@ dpif_linux_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
     return error;
 }
 
-static int
-dpif_linux_execute__(int dp_ifindex, const struct nlattr *key, size_t key_len,
-                     const struct nlattr *actions, size_t actions_len,
-                     const struct ofpbuf *packet)
+static struct ofpbuf *
+dpif_linux_encode_execute(int dp_ifindex,
+                          const struct nlattr *key, size_t key_len,
+                          const struct nlattr *actions, size_t actions_len,
+                          const struct ofpbuf *packet)
 {
     struct ovs_header *execute;
     struct ofpbuf *buf;
-    int error;
 
     buf = ofpbuf_new(128 + actions_len + packet->size);
 
     nl_msg_put_genlmsghdr(buf, 0, ovs_packet_family, NLM_F_REQUEST,
-                          OVS_PACKET_CMD_EXECUTE, 1);
+                          OVS_PACKET_CMD_EXECUTE, OVS_PACKET_VERSION);
 
     execute = ofpbuf_put_uninit(buf, sizeof *execute);
     execute->dp_ifindex = dp_ifindex;
@@ -858,8 +841,23 @@ dpif_linux_execute__(int dp_ifindex, const struct nlattr *key, size_t key_len,
     nl_msg_put_unspec(buf, OVS_PACKET_ATTR_KEY, key, key_len);
     nl_msg_put_unspec(buf, OVS_PACKET_ATTR_ACTIONS, actions, actions_len);
 
-    error = nl_sock_transact(genl_sock, buf, NULL);
-    ofpbuf_delete(buf);
+    return buf;
+}
+
+static int
+dpif_linux_execute__(int dp_ifindex, const struct nlattr *key, size_t key_len,
+                     const struct nlattr *actions, size_t actions_len,
+                     const struct ofpbuf *packet)
+{
+    struct ofpbuf *request;
+    int error;
+
+    request = dpif_linux_encode_execute(dp_ifindex,
+                                        key, key_len, actions, actions_len,
+                                        packet);
+    error = nl_sock_transact(genl_sock, request, NULL);
+    ofpbuf_delete(request);
+
     return error;
 }
 
@@ -875,6 +873,82 @@ dpif_linux_execute(struct dpif *dpif_,
                                 actions, actions_len, packet);
 }
 
+static void
+dpif_linux_operate(struct dpif *dpif_, union dpif_op **ops, size_t n_ops)
+{
+    struct dpif_linux *dpif = dpif_linux_cast(dpif_);
+    struct nl_transaction **txnsp;
+    struct nl_transaction *txns;
+    size_t i;
+
+    txns = xmalloc(n_ops * sizeof *txns);
+    for (i = 0; i < n_ops; i++) {
+        struct nl_transaction *txn = &txns[i];
+        union dpif_op *op = ops[i];
+
+        if (op->type == DPIF_OP_FLOW_PUT) {
+            struct dpif_flow_put *put = &op->flow_put;
+            struct dpif_linux_flow request;
+
+            dpif_linux_init_flow_put(dpif_, put->flags, put->key, put->key_len,
+                                     put->actions, put->actions_len,
+                                     &request);
+            if (put->stats) {
+                request.nlmsg_flags |= NLM_F_ECHO;
+            }
+            txn->request = ofpbuf_new(1024);
+            dpif_linux_flow_to_ofpbuf(&request, txn->request);
+        } else if (op->type == DPIF_OP_EXECUTE) {
+            struct dpif_execute *execute = &op->execute;
+
+            txn->request = dpif_linux_encode_execute(
+                dpif->dp_ifindex, execute->key, execute->key_len,
+                execute->actions, execute->actions_len, execute->packet);
+        } else {
+            NOT_REACHED();
+        }
+    }
+
+    txnsp = xmalloc(n_ops * sizeof *txnsp);
+    for (i = 0; i < n_ops; i++) {
+        txnsp[i] = &txns[i];
+    }
+
+    nl_sock_transact_multiple(genl_sock, txnsp, n_ops);
+
+    free(txnsp);
+
+    for (i = 0; i < n_ops; i++) {
+        struct nl_transaction *txn = &txns[i];
+        union dpif_op *op = ops[i];
+
+        if (op->type == DPIF_OP_FLOW_PUT) {
+            struct dpif_flow_put *put = &op->flow_put;
+            int error = txn->error;
+
+            if (!error && put->stats) {
+                struct dpif_linux_flow reply;
+
+                error = dpif_linux_flow_from_ofpbuf(&reply, txn->reply);
+                if (!error) {
+                    dpif_linux_flow_get_stats(&reply, put->stats);
+                }
+            }
+            put->error = error;
+        } else if (op->type == DPIF_OP_EXECUTE) {
+            struct dpif_execute *execute = &op->execute;
+
+            execute->error = txn->error;
+        } else {
+            NOT_REACHED();
+        }
+
+        ofpbuf_delete(txn->request);
+        ofpbuf_delete(txn->reply);
+    }
+    free(txns);
+}
+
 static int
 dpif_linux_recv_get_mask(const struct dpif *dpif_, int *listen_mask)
 {
@@ -1102,8 +1176,6 @@ const struct dpif_class dpif_linux_class = {
     dpif_linux_run,
     dpif_linux_wait,
     dpif_linux_get_stats,
-    dpif_linux_get_drop_frags,
-    dpif_linux_set_drop_frags,
     dpif_linux_port_add,
     dpif_linux_port_del,
     dpif_linux_port_query_by_number,
@@ -1123,6 +1195,7 @@ const struct dpif_class dpif_linux_class = {
     dpif_linux_flow_dump_next,
     dpif_linux_flow_dump_done,
     dpif_linux_execute,
+    dpif_linux_operate,
     dpif_linux_recv_get_mask,
     dpif_linux_recv_set_mask,
     dpif_linux_queue_to_priority,
@@ -1316,7 +1389,7 @@ dpif_linux_vport_to_ofpbuf(const struct dpif_linux_vport *vport,
     struct ovs_header *ovs_header;
 
     nl_msg_put_genlmsghdr(buf, 0, ovs_vport_family, NLM_F_REQUEST | NLM_F_ECHO,
-                          vport->cmd, 1);
+                          vport->cmd, OVS_VPORT_VERSION);
 
     ovs_header = ofpbuf_put_uninit(buf, sizeof *ovs_header);
     ovs_header->dp_ifindex = vport->dp_ifindex;
@@ -1435,7 +1508,6 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
                                 .min_len = sizeof(struct ovs_dp_stats),
                                 .max_len = sizeof(struct ovs_dp_stats),
                                 .optional = true },
-        [OVS_DP_ATTR_IPV4_FRAGS] = { .type = NL_A_U32, .optional = true },
     };
 
     struct nlattr *a[ARRAY_SIZE(ovs_datapath_policy)];
@@ -1466,9 +1538,6 @@ dpif_linux_dp_from_ofpbuf(struct dpif_linux_dp *dp, const struct ofpbuf *buf)
         memcpy(&dp->stats, nl_attr_get(a[OVS_DP_ATTR_STATS]),
                sizeof dp->stats);
     }
-    if (a[OVS_DP_ATTR_IPV4_FRAGS]) {
-        dp->ipv4_frags = nl_attr_get_u32(a[OVS_DP_ATTR_IPV4_FRAGS]);
-    }
 
     return 0;
 }
@@ -1480,7 +1549,8 @@ dpif_linux_dp_to_ofpbuf(const struct dpif_linux_dp *dp, struct ofpbuf *buf)
     struct ovs_header *ovs_header;
 
     nl_msg_put_genlmsghdr(buf, 0, ovs_datapath_family,
-                          NLM_F_REQUEST | NLM_F_ECHO, dp->cmd, 1);
+                          NLM_F_REQUEST | NLM_F_ECHO, dp->cmd,
+                          OVS_DATAPATH_VERSION);
 
     ovs_header = ofpbuf_put_uninit(buf, sizeof *ovs_header);
     ovs_header->dp_ifindex = dp->dp_ifindex;
@@ -1494,10 +1564,6 @@ dpif_linux_dp_to_ofpbuf(const struct dpif_linux_dp *dp, struct ofpbuf *buf)
     }
 
     /* Skip OVS_DP_ATTR_STATS since we never have a reason to serialize it. */
-
-    if (dp->ipv4_frags) {
-        nl_msg_put_u32(buf, OVS_DP_ATTR_IPV4_FRAGS, dp->ipv4_frags);
-    }
 }
 
 /* Clears 'dp' to "empty" values. */
@@ -1642,8 +1708,8 @@ dpif_linux_flow_to_ofpbuf(const struct dpif_linux_flow *flow,
     struct ovs_header *ovs_header;
 
     nl_msg_put_genlmsghdr(buf, 0, ovs_flow_family,
-                          NLM_F_REQUEST | NLM_F_ECHO | flow->nlmsg_flags,
-                          flow->cmd, 1);
+                          NLM_F_REQUEST | flow->nlmsg_flags,
+                          flow->cmd, OVS_FLOW_VERSION);
 
     ovs_header = ofpbuf_put_uninit(buf, sizeof *ovs_header);
     ovs_header->dp_ifindex = flow->dp_ifindex;
@@ -1681,7 +1747,7 @@ dpif_linux_flow_init(struct dpif_linux_flow *flow)
  * stored in '*reply' and '*bufp'.  The caller must free '*bufp' when the reply
  * is no longer needed ('reply' will contain pointers into '*bufp'). */
 static int
-dpif_linux_flow_transact(const struct dpif_linux_flow *request,
+dpif_linux_flow_transact(struct dpif_linux_flow *request,
                          struct dpif_linux_flow *reply, struct ofpbuf **bufp)
 {
     struct ofpbuf *request_buf;
@@ -1689,6 +1755,10 @@ dpif_linux_flow_transact(const struct dpif_linux_flow *request,
 
     assert((reply != NULL) == (bufp != NULL));
 
+    if (reply) {
+        request->nlmsg_flags |= NLM_F_ECHO;
+    }
+
     request_buf = ofpbuf_new(1024);
     dpif_linux_flow_to_ofpbuf(request, request_buf);
     error = nl_sock_transact(genl_sock, request_buf, bufp);
@@ -1721,4 +1791,3 @@ dpif_linux_flow_get_stats(const struct dpif_linux_flow *flow,
     stats->used = flow->used ? get_32aligned_u64(flow->used) : 0;
     stats->tcp_flags = flow->tcp_flags ? *flow->tcp_flags : 0;
 }
-