X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fdpif-netdev.c;h=7284e2f14bfcf94d39408a62660932e723a080a8;hb=c62b0064a0cdbd5f3ecfc2cda90999a9d7ec551d;hp=73ab1e5f3eac3cbf71661368175d1099ab2cf87f;hpb=856081f683d3e7d5b5fa07af4233d285eb205c47;p=openvswitch

diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c
index 73ab1e5f..7284e2f1 100644
--- a/lib/dpif-netdev.c
+++ b/lib/dpif-netdev.c
@@ -111,7 +111,7 @@ struct dp_netdev_flow {
     struct flow key;
 
     /* Statistics. */
-    struct timespec used;       /* Last used time. */
+    long long int used;         /* Last used time, in monotonic msecs. */
     long long int packet_count; /* Number of packets matched. */
     long long int byte_count;   /* Number of bytes matched. */
     uint16_t tcp_ctl;           /* Bitwise-OR of seen tcp_ctl values. */
@@ -246,27 +246,32 @@ dpif_netdev_open(const struct dpif_class *class, const char *name,
 }
 
 static void
-dp_netdev_free(struct dp_netdev *dp)
+dp_netdev_purge_queues(struct dp_netdev *dp)
 {
     int i;
 
-    dp_netdev_flow_flush(dp);
-    while (dp->n_ports > 0) {
-        struct dp_netdev_port *port = CONTAINER_OF(
-            dp->port_list.next, struct dp_netdev_port, node);
-        do_del_port(dp, port->port_no);
-    }
     for (i = 0; i < N_QUEUES; i++) {
         struct dp_netdev_queue *q = &dp->queues[i];
-        unsigned int j;
 
-        for (j = q->tail; j != q->head; j++) {
-            struct dpif_upcall *upcall = q->upcalls[j & QUEUE_MASK];
+        while (q->tail != q->head) {
+            struct dpif_upcall *upcall = q->upcalls[q->tail++ & QUEUE_MASK];
 
             ofpbuf_delete(upcall->packet);
             free(upcall);
         }
     }
+}
+
+static void
+dp_netdev_free(struct dp_netdev *dp)
+{
+    dp_netdev_flow_flush(dp);
+    while (dp->n_ports > 0) {
+        struct dp_netdev_port *port = CONTAINER_OF(
+            dp->port_list.next, struct dp_netdev_port, node);
+        do_del_port(dp, port->port_no);
+    }
+    dp_netdev_purge_queues(dp);
     hmap_destroy(&dp->flow_table);
     free(dp->name);
     free(dp);
@@ -297,17 +302,10 @@ dpif_netdev_get_stats(const struct dpif *dpif, struct odp_stats *stats)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
     memset(stats, 0, sizeof *stats);
-    stats->n_flows = hmap_count(&dp->flow_table);
-    stats->cur_capacity = hmap_capacity(&dp->flow_table);
-    stats->max_capacity = MAX_FLOWS;
-    stats->n_ports = dp->n_ports;
-    stats->max_ports = MAX_PORTS;
     stats->n_frags = dp->n_frags;
     stats->n_hit = dp->n_hit;
     stats->n_missed = dp->n_missed;
     stats->n_lost = dp->n_lost;
-    stats->max_miss_queue = MAX_QUEUE_LEN;
-    stats->max_action_queue = MAX_QUEUE_LEN;
     return 0;
 }
 
@@ -474,18 +472,17 @@ do_del_port(struct dp_netdev *dp, uint16_t port_no)
 }
 
 static void
-answer_port_query(const struct dp_netdev_port *port, struct odp_port *odp_port)
+answer_port_query(const struct dp_netdev_port *port,
+                  struct dpif_port *dpif_port)
 {
-    memset(odp_port, 0, sizeof *odp_port);
-    ovs_strlcpy(odp_port->devname, netdev_get_name(port->netdev),
-                sizeof odp_port->devname);
-    odp_port->port = port->port_no;
-    strcpy(odp_port->type, port->internal ? "internal" : "system");
+    dpif_port->name = xstrdup(netdev_get_name(port->netdev));
+    dpif_port->type = xstrdup(port->internal ? "internal" : "system");
+    dpif_port->port_no = port->port_no;
 }
 
 static int
 dpif_netdev_port_query_by_number(const struct dpif *dpif, uint16_t port_no,
-                                 struct odp_port *odp_port)
+                                 struct dpif_port *dpif_port)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
     struct dp_netdev_port *port;
@@ -493,14 +490,14 @@ dpif_netdev_port_query_by_number(const struct dpif *dpif, uint16_t port_no,
 
     error = get_port_by_number(dp, port_no, &port);
     if (!error) {
-        answer_port_query(port, odp_port);
+        answer_port_query(port, dpif_port);
     }
     return error;
 }
 
 static int
 dpif_netdev_port_query_by_name(const struct dpif *dpif, const char *devname,
-                               struct odp_port *odp_port)
+                               struct dpif_port *dpif_port)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
     struct dp_netdev_port *port;
@@ -508,11 +505,17 @@ dpif_netdev_port_query_by_name(const struct dpif *dpif, const char *devname,
 
     error = get_port_by_name(dp, devname, &port);
     if (!error) {
-        answer_port_query(port, odp_port);
+        answer_port_query(port, dpif_port);
     }
     return error;
 }
 
+static int
+dpif_netdev_get_max_ports(const struct dpif *dpif OVS_UNUSED)
+{
+    return MAX_PORTS;
+}
+
 static void
 dp_netdev_free_flow(struct dp_netdev *dp, struct dp_netdev_flow *flow)
 {
@@ -539,23 +542,48 @@ dpif_netdev_flow_flush(struct dpif *dpif)
     return 0;
 }
 
+struct dp_netdev_port_state {
+    uint32_t port_no;
+    char *name;
+};
+
 static int
-dpif_netdev_port_list(const struct dpif *dpif, struct odp_port *ports, int n)
+dpif_netdev_port_dump_start(const struct dpif *dpif OVS_UNUSED, void **statep)
 {
-    struct dp_netdev *dp = get_dp_netdev(dpif);
-    struct dp_netdev_port *port;
-    int i;
+    *statep = xzalloc(sizeof(struct dp_netdev_port_state));
+    return 0;
+}
 
-    i = 0;
-    LIST_FOR_EACH (port, node, &dp->port_list) {
-        struct odp_port *odp_port = &ports[i];
-        if (i >= n) {
-            break;
+static int
+dpif_netdev_port_dump_next(const struct dpif *dpif, void *state_,
+                           struct dpif_port *dpif_port)
+{
+    struct dp_netdev_port_state *state = state_;
+    struct dp_netdev *dp = get_dp_netdev(dpif);
+    uint32_t port_no;
+
+    for (port_no = state->port_no; port_no < MAX_PORTS; port_no++) {
+        struct dp_netdev_port *port = dp->ports[port_no];
+        if (port) {
+            free(state->name);
+            state->name = xstrdup(netdev_get_name(port->netdev));
+            dpif_port->name = state->name;
+            dpif_port->type = port->internal ? "internal" : "system";
+            dpif_port->port_no = port->port_no;
+            state->port_no = port_no + 1;
+            return 0;
         }
-        answer_port_query(port, odp_port);
-        i++;
     }
-    return dp->n_ports;
+    return EOF;
+}
+
+static int
+dpif_netdev_port_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
+{
+    struct dp_netdev_port_state *state = state_;
+    free(state->name);
+    free(state);
+    return 0;
 }
 
 static int
@@ -592,32 +620,13 @@ dp_netdev_lookup_flow(const struct dp_netdev *dp, const struct flow *key)
     return NULL;
 }
 
-/* The caller must fill in odp_flow->key itself. */
 static void
-answer_flow_query(struct dp_netdev_flow *flow, uint32_t query_flags,
-                  struct odp_flow *odp_flow)
+get_dpif_flow_stats(struct dp_netdev_flow *flow, struct dpif_flow_stats *stats)
 {
-    if (flow) {
-        odp_flow->stats.n_packets = flow->packet_count;
-        odp_flow->stats.n_bytes = flow->byte_count;
-        odp_flow->stats.used_sec = flow->used.tv_sec;
-        odp_flow->stats.used_nsec = flow->used.tv_nsec;
-        odp_flow->stats.tcp_flags = TCP_FLAGS(flow->tcp_ctl);
-        odp_flow->stats.reserved = 0;
-        odp_flow->stats.error = 0;
-        if (odp_flow->actions_len > 0) {
-            memcpy(odp_flow->actions, flow->actions,
-                   MIN(odp_flow->actions_len, flow->actions_len));
-            odp_flow->actions_len = flow->actions_len;
-        }
-
-        if (query_flags & ODPFF_ZERO_TCP_FLAGS) {
-            flow->tcp_ctl = 0;
-        }
-
-    } else {
-        odp_flow->stats.error = ENOENT;
-    }
+    stats->n_packets = flow->packet_count;
+    stats->n_bytes = flow->byte_count;
+    stats->used = flow->used;
+    stats->tcp_flags = TCP_FLAGS(flow->tcp_ctl);
 }
 
 static int
@@ -647,24 +656,33 @@ dpif_netdev_flow_from_nlattrs(const struct nlattr *key, uint32_t key_len,
 }
 
 static int
-dpif_netdev_flow_get(const struct dpif *dpif, struct odp_flow flows[], int n)
+dpif_netdev_flow_get(const struct dpif *dpif, int flags,
+                     const struct nlattr *nl_key, size_t nl_key_len,
+                     struct ofpbuf **actionsp, struct dpif_flow_stats *stats)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
-    int i;
+    struct dp_netdev_flow *flow;
+    struct flow key;
+    int error;
 
-    for (i = 0; i < n; i++) {
-        struct odp_flow *odp_flow = &flows[i];
-        struct flow key;
-        int error;
+    error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
+    if (error) {
+        return error;
+    }
 
-        error = dpif_netdev_flow_from_nlattrs(odp_flow->key, odp_flow->key_len,
-                                              &key);
-        if (error) {
-            return error;
-        }
+    flow = dp_netdev_lookup_flow(dp, &key);
+    if (!flow) {
+        return ENOENT;
+    }
 
-        answer_flow_query(dp_netdev_lookup_flow(dp, &key),
-                          odp_flow->flags, odp_flow);
+    if (stats) {
+        get_dpif_flow_stats(flow, stats);
+    }
+    if (actionsp) {
+        *actionsp = ofpbuf_clone_data(flow->actions, flow->actions_len);
+    }
+    if (flags & ODPFF_ZERO_TCP_FLAGS) {
+        flow->tcp_ctl = 0;
     }
     return 0;
 }
@@ -731,25 +749,26 @@ dpif_netdev_validate_actions(const struct nlattr *actions,
 }
 
 static int
-set_flow_actions(struct dp_netdev_flow *flow, struct odp_flow *odp_flow)
+set_flow_actions(struct dp_netdev_flow *flow,
+                 const struct nlattr *actions, size_t actions_len)
 {
     bool mutates;
     int error;
 
-    error = dpif_netdev_validate_actions(odp_flow->actions,
-                                         odp_flow->actions_len, &mutates);
+    error = dpif_netdev_validate_actions(actions, actions_len, &mutates);
     if (error) {
         return error;
     }
 
-    flow->actions = xrealloc(flow->actions, odp_flow->actions_len);
-    flow->actions_len = odp_flow->actions_len;
-    memcpy(flow->actions, odp_flow->actions, odp_flow->actions_len);
+    flow->actions = xrealloc(flow->actions, actions_len);
+    flow->actions_len = actions_len;
+    memcpy(flow->actions, actions, actions_len);
     return 0;
 }
 
 static int
-add_flow(struct dpif *dpif, const struct flow *key, struct odp_flow *odp_flow)
+add_flow(struct dpif *dpif, const struct flow *key,
+         const struct nlattr *actions, size_t actions_len)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
     struct dp_netdev_flow *flow;
@@ -758,7 +777,7 @@ add_flow(struct dpif *dpif, const struct flow *key, struct odp_flow *odp_flow)
     flow = xzalloc(sizeof *flow);
     flow->key = *key;
 
-    error = set_flow_actions(flow, odp_flow);
+    error = set_flow_actions(flow, actions, actions_len);
     if (error) {
         free(flow);
         return error;
@@ -771,32 +790,36 @@ add_flow(struct dpif *dpif, const struct flow *key, struct odp_flow *odp_flow)
 static void
 clear_stats(struct dp_netdev_flow *flow)
 {
-    flow->used.tv_sec = 0;
-    flow->used.tv_nsec = 0;
+    flow->used = 0;
     flow->packet_count = 0;
     flow->byte_count = 0;
     flow->tcp_ctl = 0;
 }
 
 static int
-dpif_netdev_flow_put(struct dpif *dpif, struct odp_flow_put *put)
+dpif_netdev_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags,
+                    const struct nlattr *nl_key, size_t nl_key_len,
+                    const struct nlattr *actions, size_t actions_len,
+                    struct dpif_flow_stats *stats)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
     struct dp_netdev_flow *flow;
     struct flow key;
     int error;
 
-    error = dpif_netdev_flow_from_nlattrs(put->flow.key, put->flow.key_len,
-                                          &key);
+    error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
     if (error) {
         return error;
     }
 
     flow = dp_netdev_lookup_flow(dp, &key);
     if (!flow) {
-        if (put->flags & ODPPF_CREATE) {
+        if (flags & DPIF_FP_CREATE) {
             if (hmap_count(&dp->flow_table) < MAX_FLOWS) {
-                return add_flow(dpif, &key, &put->flow);
+                if (stats) {
+                    memset(stats, 0, sizeof *stats);
+                }
+                return add_flow(dpif, &key, actions, actions_len);
             } else {
                 return EFBIG;
             }
@@ -804,10 +827,15 @@ dpif_netdev_flow_put(struct dpif *dpif, struct odp_flow_put *put)
             return ENOENT;
         }
     } else {
-        if (put->flags & ODPPF_MODIFY) {
-            int error = set_flow_actions(flow, &put->flow);
-            if (!error && put->flags & ODPPF_ZERO_STATS) {
-                clear_stats(flow);
+        if (flags & DPIF_FP_MODIFY) {
+            int error = set_flow_actions(flow, actions, actions_len);
+            if (!error) {
+                if (stats) {
+                    get_dpif_flow_stats(flow, stats);
+                }
+                if (flags & DPIF_FP_ZERO_STATS) {
+                    clear_stats(flow);
+                }
             }
             return error;
         } else {
@@ -816,24 +844,26 @@ dpif_netdev_flow_put(struct dpif *dpif, struct odp_flow_put *put)
     }
 }
 
-
 static int
-dpif_netdev_flow_del(struct dpif *dpif, struct odp_flow *odp_flow)
+dpif_netdev_flow_del(struct dpif *dpif,
+                     const struct nlattr *nl_key, size_t nl_key_len,
+                     struct dpif_flow_stats *stats)
 {
     struct dp_netdev *dp = get_dp_netdev(dpif);
     struct dp_netdev_flow *flow;
     struct flow key;
     int error;
 
-    error = dpif_netdev_flow_from_nlattrs(odp_flow->key, odp_flow->key_len,
-                                          &key);
+    error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
     if (error) {
         return error;
     }
 
     flow = dp_netdev_lookup_flow(dp, &key);
     if (flow) {
-        answer_flow_query(flow, 0, odp_flow);
+        if (stats) {
+            get_dpif_flow_stats(flow, stats);
+        }
         dp_netdev_free_flow(dp, flow);
         return 0;
     } else {
@@ -844,24 +874,33 @@ dpif_netdev_flow_del(struct dpif *dpif, struct odp_flow *odp_flow)
 struct dp_netdev_flow_state {
     uint32_t bucket;
     uint32_t offset;
+    struct nlattr *actions;
+    uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
+    struct dpif_flow_stats stats;
 };
 
 static int
 dpif_netdev_flow_dump_start(const struct dpif *dpif OVS_UNUSED, void **statep)
 {
-    *statep = xzalloc(sizeof(struct dp_netdev_flow_state));
+    struct dp_netdev_flow_state *state;
+
+    *statep = state = xmalloc(sizeof *state);
+    state->bucket = 0;
+    state->offset = 0;
+    state->actions = NULL;
     return 0;
 }
 
 static int
 dpif_netdev_flow_dump_next(const struct dpif *dpif, void *state_,
-                           struct odp_flow *odp_flow)
+                           const struct nlattr **key, size_t *key_len,
+                           const struct nlattr **actions, size_t *actions_len,
+                           const struct dpif_flow_stats **stats)
 {
     struct dp_netdev_flow_state *state = state_;
     struct dp_netdev *dp = get_dp_netdev(dpif);
     struct dp_netdev_flow *flow;
     struct hmap_node *node;
-    struct ofpbuf key;
 
     node = hmap_at_position(&dp->flow_table, &state->bucket, &state->offset);
     if (!node) {
@@ -870,19 +909,39 @@ dpif_netdev_flow_dump_next(const struct dpif *dpif, void *state_,
 
     flow = CONTAINER_OF(node, struct dp_netdev_flow, node);
 
-    ofpbuf_use_stack(&key, odp_flow->key, odp_flow->key_len);
-    odp_flow_key_from_flow(&key, &flow->key);
-    odp_flow->key_len = key.size;
-    ofpbuf_uninit(&key);
+    if (key) {
+        struct ofpbuf buf;
+
+        ofpbuf_use_stack(&buf, state->keybuf, sizeof state->keybuf);
+        odp_flow_key_from_flow(&buf, &flow->key);
+        assert(buf.base == state->keybuf);
+
+        *key = buf.data;
+        *key_len = buf.size;
+    }
+
+    if (actions) {
+        free(state->actions);
+        state->actions = xmemdup(flow->actions, flow->actions_len);
+
+        *actions = state->actions;
+        *actions_len = flow->actions_len;
+    }
 
-    answer_flow_query(flow, 0, odp_flow);
+    if (stats) {
+        get_dpif_flow_stats(flow, &state->stats);
+        *stats = &state->stats;
+    }
 
     return 0;
 }
 
 static int
-dpif_netdev_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state)
+dpif_netdev_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
 {
+    struct dp_netdev_flow_state *state = state_;
+
+    free(state->actions);
     free(state);
     return 0;
 }
@@ -990,12 +1049,19 @@ dpif_netdev_recv_wait(struct dpif *dpif)
          * wake up to queue new messages, so there is nothing to do. */
     }
 }
+
+static void
+dpif_netdev_recv_purge(struct dpif *dpif)
+{
+    struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif);
+    dp_netdev_purge_queues(dpif_netdev->dp);
+}
 
 static void
 dp_netdev_flow_used(struct dp_netdev_flow *flow, struct flow *key,
                     const struct ofpbuf *packet)
 {
-    time_timespec(&flow->used);
+    flow->used = time_msec();
     flow->packet_count++;
     flow->byte_count += packet->size;
     if (key->dl_type == htons(ETH_TYPE_IP) && key->nw_proto == IPPROTO_TCP) {
@@ -1362,7 +1428,10 @@ const struct dpif_class dpif_netdev_class = {
     dpif_netdev_port_del,
     dpif_netdev_port_query_by_number,
     dpif_netdev_port_query_by_name,
-    dpif_netdev_port_list,
+    dpif_netdev_get_max_ports,
+    dpif_netdev_port_dump_start,
+    dpif_netdev_port_dump_next,
+    dpif_netdev_port_dump_done,
     dpif_netdev_port_poll,
     dpif_netdev_port_poll_wait,
     dpif_netdev_flow_get,
@@ -1380,6 +1449,7 @@ const struct dpif_class dpif_netdev_class = {
     NULL,                       /* queue_to_priority */
     dpif_netdev_recv,
     dpif_netdev_recv_wait,
+    dpif_netdev_recv_purge,
 };
 
 void