6de4bfc15898df291053de2b285d7a4f1c2b1c7b
[openvswitch] / lib / dpif-netdev.c
1 /*
2  * Copyright (c) 2009, 2010, 2011 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "dpif.h"
19
20 #include <assert.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <fcntl.h>
24 #include <inttypes.h>
25 #include <netinet/in.h>
26 #include <sys/socket.h>
27 #include <net/if.h>
28 #include <stdint.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/ioctl.h>
32 #include <sys/stat.h>
33 #include <unistd.h>
34
35 #include "csum.h"
36 #include "dpif.h"
37 #include "dpif-provider.h"
38 #include "dummy.h"
39 #include "dynamic-string.h"
40 #include "flow.h"
41 #include "hmap.h"
42 #include "list.h"
43 #include "netdev.h"
44 #include "netlink.h"
45 #include "odp-util.h"
46 #include "ofp-print.h"
47 #include "ofpbuf.h"
48 #include "packets.h"
49 #include "poll-loop.h"
50 #include "random.h"
51 #include "shash.h"
52 #include "timeval.h"
53 #include "util.h"
54 #include "vlog.h"
55
56 VLOG_DEFINE_THIS_MODULE(dpif_netdev);
57
58 /* Configuration parameters. */
59 enum { MAX_PORTS = 256 };       /* Maximum number of ports. */
60 enum { MAX_FLOWS = 65536 };     /* Maximum number of flows in flow table. */
61
62 /* Enough headroom to add a vlan tag, plus an extra 2 bytes to allow IP
63  * headers to be aligned on a 4-byte boundary.  */
64 enum { DP_NETDEV_HEADROOM = 2 + VLAN_HEADER_LEN };
65
66 /* Queues. */
67 enum { N_QUEUES = 2 };          /* Number of queues for dpif_recv(). */
68 enum { MAX_QUEUE_LEN = 128 };   /* Maximum number of packets per queue. */
69 enum { QUEUE_MASK = MAX_QUEUE_LEN - 1 };
70 BUILD_ASSERT_DECL(IS_POW2(MAX_QUEUE_LEN));
71
72 struct dp_netdev_queue {
73     struct dpif_upcall *upcalls[MAX_QUEUE_LEN];
74     unsigned int head, tail;
75 };
76
77 /* Datapath based on the network device interface from netdev.h. */
78 struct dp_netdev {
79     const struct dpif_class *class;
80     char *name;
81     int open_cnt;
82     bool destroyed;
83
84     struct dp_netdev_queue queues[N_QUEUES];
85     struct hmap flow_table;     /* Flow table. */
86
87     /* Statistics. */
88     long long int n_hit;        /* Number of flow table matches. */
89     long long int n_missed;     /* Number of flow table misses. */
90     long long int n_lost;       /* Number of misses not passed to client. */
91
92     /* Ports. */
93     struct dp_netdev_port *ports[MAX_PORTS];
94     struct list port_list;
95     unsigned int serial;
96 };
97
98 /* A port in a netdev-based datapath. */
99 struct dp_netdev_port {
100     int port_no;                /* Index into dp_netdev's 'ports'. */
101     struct list node;           /* Element in dp_netdev's 'port_list'. */
102     struct netdev *netdev;
103     bool internal;              /* Internal port? */
104 };
105
106 /* A flow in dp_netdev's 'flow_table'. */
107 struct dp_netdev_flow {
108     struct hmap_node node;      /* Element in dp_netdev's 'flow_table'. */
109     struct flow key;
110
111     /* Statistics. */
112     long long int used;         /* Last used time, in monotonic msecs. */
113     long long int packet_count; /* Number of packets matched. */
114     long long int byte_count;   /* Number of bytes matched. */
115     ovs_be16 tcp_ctl;           /* Bitwise-OR of seen tcp_ctl values. */
116
117     /* Actions. */
118     struct nlattr *actions;
119     size_t actions_len;
120 };
121
122 /* Interface to netdev-based datapath. */
123 struct dpif_netdev {
124     struct dpif dpif;
125     struct dp_netdev *dp;
126     int listen_mask;
127     unsigned int dp_serial;
128 };
129
130 /* All netdev-based datapaths. */
131 static struct shash dp_netdevs = SHASH_INITIALIZER(&dp_netdevs);
132
133 /* Maximum port MTU seen so far. */
134 static int max_mtu = ETH_PAYLOAD_MAX;
135
136 static int get_port_by_number(struct dp_netdev *, uint16_t port_no,
137                               struct dp_netdev_port **portp);
138 static int get_port_by_name(struct dp_netdev *, const char *devname,
139                             struct dp_netdev_port **portp);
140 static void dp_netdev_free(struct dp_netdev *);
141 static void dp_netdev_flow_flush(struct dp_netdev *);
142 static int do_add_port(struct dp_netdev *, const char *devname,
143                        const char *type, uint16_t port_no);
144 static int do_del_port(struct dp_netdev *, uint16_t port_no);
145 static int dpif_netdev_open(const struct dpif_class *, const char *name,
146                             bool create, struct dpif **);
147 static int dp_netdev_output_userspace(struct dp_netdev *, const struct ofpbuf *,
148                                     int queue_no, const struct flow *,
149                                     uint64_t arg);
150 static void dp_netdev_execute_actions(struct dp_netdev *,
151                                       struct ofpbuf *, struct flow *,
152                                       const struct nlattr *actions,
153                                       size_t actions_len);
154
155 static struct dpif_class dpif_dummy_class;
156
157 static struct dpif_netdev *
158 dpif_netdev_cast(const struct dpif *dpif)
159 {
160     assert(dpif->dpif_class->open == dpif_netdev_open);
161     return CONTAINER_OF(dpif, struct dpif_netdev, dpif);
162 }
163
164 static struct dp_netdev *
165 get_dp_netdev(const struct dpif *dpif)
166 {
167     return dpif_netdev_cast(dpif)->dp;
168 }
169
170 static struct dpif *
171 create_dpif_netdev(struct dp_netdev *dp)
172 {
173     uint16_t netflow_id = hash_string(dp->name, 0);
174     struct dpif_netdev *dpif;
175
176     dp->open_cnt++;
177
178     dpif = xmalloc(sizeof *dpif);
179     dpif_init(&dpif->dpif, dp->class, dp->name, netflow_id >> 8, netflow_id);
180     dpif->dp = dp;
181     dpif->listen_mask = 0;
182     dpif->dp_serial = dp->serial;
183
184     return &dpif->dpif;
185 }
186
187 static int
188 create_dp_netdev(const char *name, const struct dpif_class *class,
189                  struct dp_netdev **dpp)
190 {
191     struct dp_netdev *dp;
192     int error;
193     int i;
194
195     dp = xzalloc(sizeof *dp);
196     dp->class = class;
197     dp->name = xstrdup(name);
198     dp->open_cnt = 0;
199     for (i = 0; i < N_QUEUES; i++) {
200         dp->queues[i].head = dp->queues[i].tail = 0;
201     }
202     hmap_init(&dp->flow_table);
203     list_init(&dp->port_list);
204     error = do_add_port(dp, name, "internal", OVSP_LOCAL);
205     if (error) {
206         dp_netdev_free(dp);
207         return error;
208     }
209
210     shash_add(&dp_netdevs, name, dp);
211
212     *dpp = dp;
213     return 0;
214 }
215
216 static int
217 dpif_netdev_open(const struct dpif_class *class, const char *name,
218                  bool create, struct dpif **dpifp)
219 {
220     struct dp_netdev *dp;
221
222     dp = shash_find_data(&dp_netdevs, name);
223     if (!dp) {
224         if (!create) {
225             return ENODEV;
226         } else {
227             int error = create_dp_netdev(name, class, &dp);
228             if (error) {
229                 return error;
230             }
231             assert(dp != NULL);
232         }
233     } else {
234         if (dp->class != class) {
235             return EINVAL;
236         } else if (create) {
237             return EEXIST;
238         }
239     }
240
241     *dpifp = create_dpif_netdev(dp);
242     return 0;
243 }
244
245 static void
246 dp_netdev_purge_queues(struct dp_netdev *dp)
247 {
248     int i;
249
250     for (i = 0; i < N_QUEUES; i++) {
251         struct dp_netdev_queue *q = &dp->queues[i];
252
253         while (q->tail != q->head) {
254             struct dpif_upcall *upcall = q->upcalls[q->tail++ & QUEUE_MASK];
255
256             ofpbuf_delete(upcall->packet);
257             free(upcall);
258         }
259     }
260 }
261
262 static void
263 dp_netdev_free(struct dp_netdev *dp)
264 {
265     struct dp_netdev_port *port, *next;
266
267     dp_netdev_flow_flush(dp);
268     LIST_FOR_EACH_SAFE (port, next, node, &dp->port_list) {
269         do_del_port(dp, port->port_no);
270     }
271     dp_netdev_purge_queues(dp);
272     hmap_destroy(&dp->flow_table);
273     free(dp->name);
274     free(dp);
275 }
276
277 static void
278 dpif_netdev_close(struct dpif *dpif)
279 {
280     struct dp_netdev *dp = get_dp_netdev(dpif);
281     assert(dp->open_cnt > 0);
282     if (--dp->open_cnt == 0 && dp->destroyed) {
283         shash_find_and_delete(&dp_netdevs, dp->name);
284         dp_netdev_free(dp);
285     }
286     free(dpif);
287 }
288
289 static int
290 dpif_netdev_destroy(struct dpif *dpif)
291 {
292     struct dp_netdev *dp = get_dp_netdev(dpif);
293     dp->destroyed = true;
294     return 0;
295 }
296
297 static int
298 dpif_netdev_get_stats(const struct dpif *dpif, struct dpif_dp_stats *stats)
299 {
300     struct dp_netdev *dp = get_dp_netdev(dpif);
301     stats->n_flows = hmap_count(&dp->flow_table);
302     stats->n_hit = dp->n_hit;
303     stats->n_missed = dp->n_missed;
304     stats->n_lost = dp->n_lost;
305     return 0;
306 }
307
308 static int
309 do_add_port(struct dp_netdev *dp, const char *devname, const char *type,
310             uint16_t port_no)
311 {
312     struct dp_netdev_port *port;
313     struct netdev *netdev;
314     bool internal;
315     int mtu;
316     int error;
317
318     /* XXX reject devices already in some dp_netdev. */
319     if (type[0] == '\0' || !strcmp(type, "system") || !strcmp(type, "dummy")) {
320         internal = false;
321     } else if (!strcmp(type, "internal")) {
322         internal = true;
323     } else {
324         VLOG_WARN("%s: unsupported port type %s", devname, type);
325         return EINVAL;
326     }
327
328     /* Open and validate network device. */
329     if (dp->class == &dpif_dummy_class) {
330         type = "dummy";
331     } else if (internal) {
332         type = "tap";
333     }
334
335     error = netdev_open(devname, type, &netdev);
336     if (error) {
337         return error;
338     }
339     /* XXX reject loopback devices */
340     /* XXX reject non-Ethernet devices */
341
342     error = netdev_listen(netdev);
343     if (error) {
344         VLOG_ERR("%s: cannot receive packets on this network device (%s)",
345                  devname, strerror(errno));
346         netdev_close(netdev);
347         return error;
348     }
349
350     error = netdev_turn_flags_on(netdev, NETDEV_PROMISC, false);
351     if (error) {
352         netdev_close(netdev);
353         return error;
354     }
355
356     port = xmalloc(sizeof *port);
357     port->port_no = port_no;
358     port->netdev = netdev;
359     port->internal = internal;
360
361     error = netdev_get_mtu(netdev, &mtu);
362     if (!error) {
363         max_mtu = mtu;
364     }
365
366     list_push_back(&dp->port_list, &port->node);
367     dp->ports[port_no] = port;
368     dp->serial++;
369
370     return 0;
371 }
372
373 static int
374 dpif_netdev_port_add(struct dpif *dpif, struct netdev *netdev,
375                      uint16_t *port_nop)
376 {
377     struct dp_netdev *dp = get_dp_netdev(dpif);
378     int port_no;
379
380     for (port_no = 0; port_no < MAX_PORTS; port_no++) {
381         if (!dp->ports[port_no]) {
382             *port_nop = port_no;
383             return do_add_port(dp, netdev_get_name(netdev),
384                                netdev_get_type(netdev), port_no);
385         }
386     }
387     return EFBIG;
388 }
389
390 static int
391 dpif_netdev_port_del(struct dpif *dpif, uint16_t port_no)
392 {
393     struct dp_netdev *dp = get_dp_netdev(dpif);
394     return port_no == OVSP_LOCAL ? EINVAL : do_del_port(dp, port_no);
395 }
396
397 static bool
398 is_valid_port_number(uint16_t port_no)
399 {
400     return port_no < MAX_PORTS;
401 }
402
403 static int
404 get_port_by_number(struct dp_netdev *dp,
405                    uint16_t port_no, struct dp_netdev_port **portp)
406 {
407     if (!is_valid_port_number(port_no)) {
408         *portp = NULL;
409         return EINVAL;
410     } else {
411         *portp = dp->ports[port_no];
412         return *portp ? 0 : ENOENT;
413     }
414 }
415
416 static int
417 get_port_by_name(struct dp_netdev *dp,
418                  const char *devname, struct dp_netdev_port **portp)
419 {
420     struct dp_netdev_port *port;
421
422     LIST_FOR_EACH (port, node, &dp->port_list) {
423         if (!strcmp(netdev_get_name(port->netdev), devname)) {
424             *portp = port;
425             return 0;
426         }
427     }
428     return ENOENT;
429 }
430
431 static int
432 do_del_port(struct dp_netdev *dp, uint16_t port_no)
433 {
434     struct dp_netdev_port *port;
435     char *name;
436     int error;
437
438     error = get_port_by_number(dp, port_no, &port);
439     if (error) {
440         return error;
441     }
442
443     list_remove(&port->node);
444     dp->ports[port->port_no] = NULL;
445     dp->serial++;
446
447     name = xstrdup(netdev_get_name(port->netdev));
448     netdev_close(port->netdev);
449
450     free(name);
451     free(port);
452
453     return 0;
454 }
455
456 static void
457 answer_port_query(const struct dp_netdev_port *port,
458                   struct dpif_port *dpif_port)
459 {
460     dpif_port->name = xstrdup(netdev_get_name(port->netdev));
461     dpif_port->type = xstrdup(port->internal ? "internal" : "system");
462     dpif_port->port_no = port->port_no;
463 }
464
465 static int
466 dpif_netdev_port_query_by_number(const struct dpif *dpif, uint16_t port_no,
467                                  struct dpif_port *dpif_port)
468 {
469     struct dp_netdev *dp = get_dp_netdev(dpif);
470     struct dp_netdev_port *port;
471     int error;
472
473     error = get_port_by_number(dp, port_no, &port);
474     if (!error) {
475         answer_port_query(port, dpif_port);
476     }
477     return error;
478 }
479
480 static int
481 dpif_netdev_port_query_by_name(const struct dpif *dpif, const char *devname,
482                                struct dpif_port *dpif_port)
483 {
484     struct dp_netdev *dp = get_dp_netdev(dpif);
485     struct dp_netdev_port *port;
486     int error;
487
488     error = get_port_by_name(dp, devname, &port);
489     if (!error) {
490         answer_port_query(port, dpif_port);
491     }
492     return error;
493 }
494
495 static int
496 dpif_netdev_get_max_ports(const struct dpif *dpif OVS_UNUSED)
497 {
498     return MAX_PORTS;
499 }
500
501 static void
502 dp_netdev_free_flow(struct dp_netdev *dp, struct dp_netdev_flow *flow)
503 {
504     hmap_remove(&dp->flow_table, &flow->node);
505     free(flow->actions);
506     free(flow);
507 }
508
509 static void
510 dp_netdev_flow_flush(struct dp_netdev *dp)
511 {
512     struct dp_netdev_flow *flow, *next;
513
514     HMAP_FOR_EACH_SAFE (flow, next, node, &dp->flow_table) {
515         dp_netdev_free_flow(dp, flow);
516     }
517 }
518
519 static int
520 dpif_netdev_flow_flush(struct dpif *dpif)
521 {
522     struct dp_netdev *dp = get_dp_netdev(dpif);
523     dp_netdev_flow_flush(dp);
524     return 0;
525 }
526
527 struct dp_netdev_port_state {
528     uint32_t port_no;
529     char *name;
530 };
531
532 static int
533 dpif_netdev_port_dump_start(const struct dpif *dpif OVS_UNUSED, void **statep)
534 {
535     *statep = xzalloc(sizeof(struct dp_netdev_port_state));
536     return 0;
537 }
538
539 static int
540 dpif_netdev_port_dump_next(const struct dpif *dpif, void *state_,
541                            struct dpif_port *dpif_port)
542 {
543     struct dp_netdev_port_state *state = state_;
544     struct dp_netdev *dp = get_dp_netdev(dpif);
545     uint32_t port_no;
546
547     for (port_no = state->port_no; port_no < MAX_PORTS; port_no++) {
548         struct dp_netdev_port *port = dp->ports[port_no];
549         if (port) {
550             free(state->name);
551             state->name = xstrdup(netdev_get_name(port->netdev));
552             dpif_port->name = state->name;
553             dpif_port->type = port->internal ? "internal" : "system";
554             dpif_port->port_no = port->port_no;
555             state->port_no = port_no + 1;
556             return 0;
557         }
558     }
559     return EOF;
560 }
561
562 static int
563 dpif_netdev_port_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
564 {
565     struct dp_netdev_port_state *state = state_;
566     free(state->name);
567     free(state);
568     return 0;
569 }
570
571 static int
572 dpif_netdev_port_poll(const struct dpif *dpif_, char **devnamep OVS_UNUSED)
573 {
574     struct dpif_netdev *dpif = dpif_netdev_cast(dpif_);
575     if (dpif->dp_serial != dpif->dp->serial) {
576         dpif->dp_serial = dpif->dp->serial;
577         return ENOBUFS;
578     } else {
579         return EAGAIN;
580     }
581 }
582
583 static void
584 dpif_netdev_port_poll_wait(const struct dpif *dpif_)
585 {
586     struct dpif_netdev *dpif = dpif_netdev_cast(dpif_);
587     if (dpif->dp_serial != dpif->dp->serial) {
588         poll_immediate_wake();
589     }
590 }
591
592 static struct dp_netdev_flow *
593 dp_netdev_lookup_flow(const struct dp_netdev *dp, const struct flow *key)
594 {
595     struct dp_netdev_flow *flow;
596
597     HMAP_FOR_EACH_WITH_HASH (flow, node, flow_hash(key, 0), &dp->flow_table) {
598         if (flow_equal(&flow->key, key)) {
599             return flow;
600         }
601     }
602     return NULL;
603 }
604
605 static void
606 get_dpif_flow_stats(struct dp_netdev_flow *flow, struct dpif_flow_stats *stats)
607 {
608     stats->n_packets = flow->packet_count;
609     stats->n_bytes = flow->byte_count;
610     stats->used = flow->used;
611     stats->tcp_flags = TCP_FLAGS(flow->tcp_ctl);
612 }
613
614 static int
615 dpif_netdev_flow_from_nlattrs(const struct nlattr *key, uint32_t key_len,
616                               struct flow *flow)
617 {
618     if (odp_flow_key_to_flow(key, key_len, flow)) {
619         /* This should not happen: it indicates that odp_flow_key_from_flow()
620          * and odp_flow_key_to_flow() disagree on the acceptable form of a
621          * flow.  Log the problem as an error, with enough details to enable
622          * debugging. */
623         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
624
625         if (!VLOG_DROP_ERR(&rl)) {
626             struct ds s;
627
628             ds_init(&s);
629             odp_flow_key_format(key, key_len, &s);
630             VLOG_ERR("internal error parsing flow key %s", ds_cstr(&s));
631             ds_destroy(&s);
632         }
633
634         return EINVAL;
635     }
636
637     if (flow->in_port < OFPP_MAX
638         ? flow->in_port >= MAX_PORTS
639         : flow->in_port != OFPP_LOCAL && flow->in_port != OFPP_NONE) {
640         return EINVAL;
641     }
642
643     return 0;
644 }
645
646 static int
647 dpif_netdev_flow_get(const struct dpif *dpif,
648                      const struct nlattr *nl_key, size_t nl_key_len,
649                      struct ofpbuf **actionsp, struct dpif_flow_stats *stats)
650 {
651     struct dp_netdev *dp = get_dp_netdev(dpif);
652     struct dp_netdev_flow *flow;
653     struct flow key;
654     int error;
655
656     error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
657     if (error) {
658         return error;
659     }
660
661     flow = dp_netdev_lookup_flow(dp, &key);
662     if (!flow) {
663         return ENOENT;
664     }
665
666     if (stats) {
667         get_dpif_flow_stats(flow, stats);
668     }
669     if (actionsp) {
670         *actionsp = ofpbuf_clone_data(flow->actions, flow->actions_len);
671     }
672     return 0;
673 }
674
675 static int
676 set_flow_actions(struct dp_netdev_flow *flow,
677                  const struct nlattr *actions, size_t actions_len)
678 {
679     flow->actions = xrealloc(flow->actions, actions_len);
680     flow->actions_len = actions_len;
681     memcpy(flow->actions, actions, actions_len);
682     return 0;
683 }
684
685 static int
686 add_flow(struct dpif *dpif, const struct flow *key,
687          const struct nlattr *actions, size_t actions_len)
688 {
689     struct dp_netdev *dp = get_dp_netdev(dpif);
690     struct dp_netdev_flow *flow;
691     int error;
692
693     flow = xzalloc(sizeof *flow);
694     flow->key = *key;
695
696     error = set_flow_actions(flow, actions, actions_len);
697     if (error) {
698         free(flow);
699         return error;
700     }
701
702     hmap_insert(&dp->flow_table, &flow->node, flow_hash(&flow->key, 0));
703     return 0;
704 }
705
706 static void
707 clear_stats(struct dp_netdev_flow *flow)
708 {
709     flow->used = 0;
710     flow->packet_count = 0;
711     flow->byte_count = 0;
712     flow->tcp_ctl = 0;
713 }
714
715 static int
716 dpif_netdev_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags,
717                     const struct nlattr *nl_key, size_t nl_key_len,
718                     const struct nlattr *actions, size_t actions_len,
719                     struct dpif_flow_stats *stats)
720 {
721     struct dp_netdev *dp = get_dp_netdev(dpif);
722     struct dp_netdev_flow *flow;
723     struct flow key;
724     int error;
725
726     error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
727     if (error) {
728         return error;
729     }
730
731     flow = dp_netdev_lookup_flow(dp, &key);
732     if (!flow) {
733         if (flags & DPIF_FP_CREATE) {
734             if (hmap_count(&dp->flow_table) < MAX_FLOWS) {
735                 if (stats) {
736                     memset(stats, 0, sizeof *stats);
737                 }
738                 return add_flow(dpif, &key, actions, actions_len);
739             } else {
740                 return EFBIG;
741             }
742         } else {
743             return ENOENT;
744         }
745     } else {
746         if (flags & DPIF_FP_MODIFY) {
747             int error = set_flow_actions(flow, actions, actions_len);
748             if (!error) {
749                 if (stats) {
750                     get_dpif_flow_stats(flow, stats);
751                 }
752                 if (flags & DPIF_FP_ZERO_STATS) {
753                     clear_stats(flow);
754                 }
755             }
756             return error;
757         } else {
758             return EEXIST;
759         }
760     }
761 }
762
763 static int
764 dpif_netdev_flow_del(struct dpif *dpif,
765                      const struct nlattr *nl_key, size_t nl_key_len,
766                      struct dpif_flow_stats *stats)
767 {
768     struct dp_netdev *dp = get_dp_netdev(dpif);
769     struct dp_netdev_flow *flow;
770     struct flow key;
771     int error;
772
773     error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
774     if (error) {
775         return error;
776     }
777
778     flow = dp_netdev_lookup_flow(dp, &key);
779     if (flow) {
780         if (stats) {
781             get_dpif_flow_stats(flow, stats);
782         }
783         dp_netdev_free_flow(dp, flow);
784         return 0;
785     } else {
786         return ENOENT;
787     }
788 }
789
790 struct dp_netdev_flow_state {
791     uint32_t bucket;
792     uint32_t offset;
793     struct nlattr *actions;
794     struct odputil_keybuf keybuf;
795     struct dpif_flow_stats stats;
796 };
797
798 static int
799 dpif_netdev_flow_dump_start(const struct dpif *dpif OVS_UNUSED, void **statep)
800 {
801     struct dp_netdev_flow_state *state;
802
803     *statep = state = xmalloc(sizeof *state);
804     state->bucket = 0;
805     state->offset = 0;
806     state->actions = NULL;
807     return 0;
808 }
809
810 static int
811 dpif_netdev_flow_dump_next(const struct dpif *dpif, void *state_,
812                            const struct nlattr **key, size_t *key_len,
813                            const struct nlattr **actions, size_t *actions_len,
814                            const struct dpif_flow_stats **stats)
815 {
816     struct dp_netdev_flow_state *state = state_;
817     struct dp_netdev *dp = get_dp_netdev(dpif);
818     struct dp_netdev_flow *flow;
819     struct hmap_node *node;
820
821     node = hmap_at_position(&dp->flow_table, &state->bucket, &state->offset);
822     if (!node) {
823         return EOF;
824     }
825
826     flow = CONTAINER_OF(node, struct dp_netdev_flow, node);
827
828     if (key) {
829         struct ofpbuf buf;
830
831         ofpbuf_use_stack(&buf, &state->keybuf, sizeof state->keybuf);
832         odp_flow_key_from_flow(&buf, &flow->key);
833
834         *key = buf.data;
835         *key_len = buf.size;
836     }
837
838     if (actions) {
839         free(state->actions);
840         state->actions = xmemdup(flow->actions, flow->actions_len);
841
842         *actions = state->actions;
843         *actions_len = flow->actions_len;
844     }
845
846     if (stats) {
847         get_dpif_flow_stats(flow, &state->stats);
848         *stats = &state->stats;
849     }
850
851     return 0;
852 }
853
854 static int
855 dpif_netdev_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
856 {
857     struct dp_netdev_flow_state *state = state_;
858
859     free(state->actions);
860     free(state);
861     return 0;
862 }
863
864 static int
865 dpif_netdev_execute(struct dpif *dpif,
866                     const struct nlattr *key_attrs, size_t key_len,
867                     const struct nlattr *actions, size_t actions_len,
868                     const struct ofpbuf *packet)
869 {
870     struct dp_netdev *dp = get_dp_netdev(dpif);
871     struct ofpbuf copy;
872     struct flow key;
873     int error;
874
875     if (packet->size < ETH_HEADER_LEN || packet->size > UINT16_MAX) {
876         return EINVAL;
877     }
878
879     /* Make a deep copy of 'packet', because we might modify its data. */
880     ofpbuf_init(&copy, DP_NETDEV_HEADROOM + packet->size);
881     ofpbuf_reserve(&copy, DP_NETDEV_HEADROOM);
882     ofpbuf_put(&copy, packet->data, packet->size);
883
884     flow_extract(&copy, 0, 0, -1, &key);
885     error = dpif_netdev_flow_from_nlattrs(key_attrs, key_len, &key);
886     if (!error) {
887         dp_netdev_execute_actions(dp, &copy, &key,
888                                   actions, actions_len);
889     }
890
891     ofpbuf_uninit(&copy);
892     return error;
893 }
894
895 static int
896 dpif_netdev_recv_get_mask(const struct dpif *dpif, int *listen_mask)
897 {
898     struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif);
899     *listen_mask = dpif_netdev->listen_mask;
900     return 0;
901 }
902
903 static int
904 dpif_netdev_recv_set_mask(struct dpif *dpif, int listen_mask)
905 {
906     struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif);
907     dpif_netdev->listen_mask = listen_mask;
908     return 0;
909 }
910
911 static int
912 dpif_netdev_queue_to_priority(const struct dpif *dpif OVS_UNUSED,
913                               uint32_t queue_id, uint32_t *priority)
914 {
915     *priority = queue_id;
916     return 0;
917 }
918
919 static struct dp_netdev_queue *
920 find_nonempty_queue(struct dpif *dpif)
921 {
922     struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif);
923     struct dp_netdev *dp = get_dp_netdev(dpif);
924     int mask = dpif_netdev->listen_mask;
925     int i;
926
927     for (i = 0; i < N_QUEUES; i++) {
928         struct dp_netdev_queue *q = &dp->queues[i];
929         if (q->head != q->tail && mask & (1u << i)) {
930             return q;
931         }
932     }
933     return NULL;
934 }
935
936 static int
937 dpif_netdev_recv(struct dpif *dpif, struct dpif_upcall *upcall)
938 {
939     struct dp_netdev_queue *q = find_nonempty_queue(dpif);
940     if (q) {
941         struct dpif_upcall *u = q->upcalls[q->tail++ & QUEUE_MASK];
942         *upcall = *u;
943         free(u);
944
945         return 0;
946     } else {
947         return EAGAIN;
948     }
949 }
950
951 static void
952 dpif_netdev_recv_wait(struct dpif *dpif)
953 {
954     if (find_nonempty_queue(dpif)) {
955         poll_immediate_wake();
956     } else {
957         /* No messages ready to be received, and dp_wait() will ensure that we
958          * wake up to queue new messages, so there is nothing to do. */
959     }
960 }
961
962 static void
963 dpif_netdev_recv_purge(struct dpif *dpif)
964 {
965     struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif);
966     dp_netdev_purge_queues(dpif_netdev->dp);
967 }
968 \f
969 static void
970 dp_netdev_flow_used(struct dp_netdev_flow *flow, struct flow *key,
971                     const struct ofpbuf *packet)
972 {
973     flow->used = time_msec();
974     flow->packet_count++;
975     flow->byte_count += packet->size;
976     if (key->dl_type == htons(ETH_TYPE_IP) && key->nw_proto == IPPROTO_TCP) {
977         struct tcp_header *th = packet->l4;
978         flow->tcp_ctl |= th->tcp_ctl;
979     }
980 }
981
982 static void
983 dp_netdev_port_input(struct dp_netdev *dp, struct dp_netdev_port *port,
984                      struct ofpbuf *packet)
985 {
986     struct dp_netdev_flow *flow;
987     struct flow key;
988
989     if (packet->size < ETH_HEADER_LEN) {
990         return;
991     }
992     flow_extract(packet, 0, 0, port->port_no, &key);
993     flow = dp_netdev_lookup_flow(dp, &key);
994     if (flow) {
995         dp_netdev_flow_used(flow, &key, packet);
996         dp_netdev_execute_actions(dp, packet, &key,
997                                   flow->actions, flow->actions_len);
998         dp->n_hit++;
999     } else {
1000         dp->n_missed++;
1001         dp_netdev_output_userspace(dp, packet, DPIF_UC_MISS, &key, 0);
1002     }
1003 }
1004
1005 static void
1006 dpif_netdev_run(struct dpif *dpif)
1007 {
1008     struct dp_netdev *dp = get_dp_netdev(dpif);
1009     struct dp_netdev_port *port;
1010     struct ofpbuf packet;
1011
1012     ofpbuf_init(&packet, DP_NETDEV_HEADROOM + VLAN_ETH_HEADER_LEN + max_mtu);
1013
1014     LIST_FOR_EACH (port, node, &dp->port_list) {
1015         int error;
1016
1017         /* Reset packet contents. */
1018         ofpbuf_clear(&packet);
1019         ofpbuf_reserve(&packet, DP_NETDEV_HEADROOM);
1020
1021         error = netdev_recv(port->netdev, &packet);
1022         if (!error) {
1023             dp_netdev_port_input(dp, port, &packet);
1024         } else if (error != EAGAIN && error != EOPNOTSUPP) {
1025             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1026             VLOG_ERR_RL(&rl, "error receiving data from %s: %s",
1027                         netdev_get_name(port->netdev), strerror(error));
1028         }
1029     }
1030     ofpbuf_uninit(&packet);
1031 }
1032
1033 static void
1034 dpif_netdev_wait(struct dpif *dpif)
1035 {
1036     struct dp_netdev *dp = get_dp_netdev(dpif);
1037     struct dp_netdev_port *port;
1038
1039     LIST_FOR_EACH (port, node, &dp->port_list) {
1040         netdev_recv_wait(port->netdev);
1041     }
1042 }
1043
1044 static void
1045 dp_netdev_pop_vlan(struct ofpbuf *packet)
1046 {
1047     struct vlan_eth_header *veh = packet->l2;
1048     if (packet->size >= sizeof *veh
1049         && veh->veth_type == htons(ETH_TYPE_VLAN)) {
1050         struct eth_header tmp;
1051
1052         memcpy(tmp.eth_dst, veh->veth_dst, ETH_ADDR_LEN);
1053         memcpy(tmp.eth_src, veh->veth_src, ETH_ADDR_LEN);
1054         tmp.eth_type = veh->veth_next_type;
1055
1056         ofpbuf_pull(packet, VLAN_HEADER_LEN);
1057         packet->l2 = (char*)packet->l2 + VLAN_HEADER_LEN;
1058         memcpy(packet->data, &tmp, sizeof tmp);
1059     }
1060 }
1061
1062 static void
1063 dp_netdev_set_dl(struct ofpbuf *packet, const struct ovs_key_ethernet *eth_key)
1064 {
1065     struct eth_header *eh = packet->l2;
1066
1067     memcpy(eh->eth_src, eth_key->eth_src, sizeof eh->eth_src);
1068     memcpy(eh->eth_dst, eth_key->eth_dst, sizeof eh->eth_dst);
1069 }
1070
1071 static void
1072 dp_netdev_set_ip_addr(struct ofpbuf *packet, ovs_be32 *addr, ovs_be32 new_addr)
1073 {
1074     struct ip_header *nh = packet->l3;
1075
1076     if (nh->ip_proto == IPPROTO_TCP && packet->l7) {
1077         struct tcp_header *th = packet->l4;
1078         th->tcp_csum = recalc_csum32(th->tcp_csum, *addr, new_addr);
1079     } else if (nh->ip_proto == IPPROTO_UDP && packet->l7) {
1080         struct udp_header *uh = packet->l4;
1081         if (uh->udp_csum) {
1082             uh->udp_csum = recalc_csum32(uh->udp_csum, *addr, new_addr);
1083             if (!uh->udp_csum) {
1084                 uh->udp_csum = htons(0xffff);
1085             }
1086         }
1087     }
1088     nh->ip_csum = recalc_csum32(nh->ip_csum, *addr, new_addr);
1089     *addr = new_addr;
1090 }
1091
1092 static void
1093 dp_netdev_set_ip_tos(struct ip_header *nh, uint8_t new_tos)
1094 {
1095     uint8_t *field = &nh->ip_tos;
1096
1097     nh->ip_csum = recalc_csum16(nh->ip_csum, htons((uint16_t)*field),
1098                                     htons((uint16_t) new_tos));
1099     *field = new_tos;
1100 }
1101
1102 static void
1103 dp_netdev_set_ip_ttl(struct ip_header *nh, uint8_t new_ttl)
1104 {
1105     uint8_t *field = &nh->ip_ttl;
1106
1107     nh->ip_csum = recalc_csum16(nh->ip_csum, htons(*field << 8),
1108                                     htons(new_ttl << 8));
1109     *field = new_ttl;
1110 }
1111
1112 static void
1113 dp_netdev_set_ipv4(struct ofpbuf *packet, const struct ovs_key_ipv4 *ipv4_key)
1114 {
1115     struct ip_header *nh = packet->l3;
1116
1117     if (nh->ip_src != ipv4_key->ipv4_src) {
1118         dp_netdev_set_ip_addr(packet, &nh->ip_src, ipv4_key->ipv4_src);
1119     }
1120     if (nh->ip_dst != ipv4_key->ipv4_dst) {
1121         dp_netdev_set_ip_addr(packet, &nh->ip_dst, ipv4_key->ipv4_dst);
1122     }
1123     if (nh->ip_tos != ipv4_key->ipv4_tos) {
1124         dp_netdev_set_ip_tos(nh, ipv4_key->ipv4_tos);
1125     }
1126     if (nh->ip_ttl != ipv4_key->ipv4_ttl) {
1127         dp_netdev_set_ip_ttl(nh, ipv4_key->ipv4_ttl);
1128     }
1129 }
1130
1131 static void
1132 dp_netdev_set_port(ovs_be16 *port, ovs_be16 new_port, ovs_be16 *csum)
1133 {
1134     *csum = recalc_csum16(*csum, *port, new_port);
1135     *port = new_port;
1136 }
1137
1138 static void
1139 dp_netdev_set_tcp_port(struct ofpbuf *packet, const struct ovs_key_tcp *tcp_key)
1140 {
1141     struct tcp_header *th = packet->l4;
1142
1143     if (th->tcp_src != tcp_key->tcp_src) {
1144         dp_netdev_set_port(&th->tcp_src, tcp_key->tcp_src, &th->tcp_csum);
1145     }
1146     if (th->tcp_dst != tcp_key->tcp_dst) {
1147         dp_netdev_set_port(&th->tcp_dst, tcp_key->tcp_dst, &th->tcp_csum);
1148     }
1149 }
1150
1151 static void
1152 dp_netdev_set_udp_port(struct ofpbuf *packet, const struct ovs_key_udp *udp_key)
1153 {
1154     struct udp_header *uh = packet->l4;
1155
1156     if (uh->udp_src != udp_key->udp_src) {
1157         dp_netdev_set_port(&uh->udp_src, udp_key->udp_src, &uh->udp_csum);
1158     }
1159     if (uh->udp_dst != udp_key->udp_dst) {
1160         dp_netdev_set_port(&uh->udp_dst, udp_key->udp_dst, &uh->udp_csum);
1161     }
1162 }
1163
1164 static void
1165 dp_netdev_output_port(struct dp_netdev *dp, struct ofpbuf *packet,
1166                       uint16_t out_port)
1167 {
1168     struct dp_netdev_port *p = dp->ports[out_port];
1169     if (p) {
1170         netdev_send(p->netdev, packet);
1171     }
1172 }
1173
1174 static int
1175 dp_netdev_output_userspace(struct dp_netdev *dp, const struct ofpbuf *packet,
1176                          int queue_no, const struct flow *flow, uint64_t arg)
1177 {
1178     struct dp_netdev_queue *q = &dp->queues[queue_no];
1179     struct dpif_upcall *upcall;
1180     struct ofpbuf *buf;
1181     size_t key_len;
1182
1183     if (q->head - q->tail >= MAX_QUEUE_LEN) {
1184         dp->n_lost++;
1185         return ENOBUFS;
1186     }
1187
1188     buf = ofpbuf_new(ODPUTIL_FLOW_KEY_BYTES + 2 + packet->size);
1189     odp_flow_key_from_flow(buf, flow);
1190     key_len = buf->size;
1191     ofpbuf_pull(buf, key_len);
1192     ofpbuf_reserve(buf, 2);
1193     ofpbuf_put(buf, packet->data, packet->size);
1194
1195     upcall = xzalloc(sizeof *upcall);
1196     upcall->type = queue_no;
1197     upcall->packet = buf;
1198     upcall->key = buf->base;
1199     upcall->key_len = key_len;
1200     upcall->userdata = arg;
1201
1202     q->upcalls[q->head++ & QUEUE_MASK] = upcall;
1203
1204     return 0;
1205 }
1206
1207 static void
1208 dp_netdev_sample(struct dp_netdev *dp,
1209                  struct ofpbuf *packet, struct flow *key,
1210                  const struct nlattr *action)
1211 {
1212     const struct nlattr *subactions = NULL;
1213     const struct nlattr *a;
1214     size_t left;
1215
1216     NL_NESTED_FOR_EACH_UNSAFE (a, left, action) {
1217         int type = nl_attr_type(a);
1218
1219         switch ((enum ovs_sample_attr) type) {
1220         case OVS_SAMPLE_ATTR_PROBABILITY:
1221             if (random_uint32() >= nl_attr_get_u32(a)) {
1222                 return;
1223             }
1224             break;
1225
1226         case OVS_SAMPLE_ATTR_ACTIONS:
1227             subactions = a;
1228             break;
1229
1230         case OVS_SAMPLE_ATTR_UNSPEC:
1231         case __OVS_SAMPLE_ATTR_MAX:
1232         default:
1233             NOT_REACHED();
1234         }
1235     }
1236
1237     dp_netdev_execute_actions(dp, packet, key, nl_attr_get(subactions),
1238                               nl_attr_get_size(subactions));
1239 }
1240
1241 static void
1242 dp_netdev_action_userspace(struct dp_netdev *dp,
1243                           struct ofpbuf *packet, struct flow *key,
1244                           const struct nlattr *a)
1245 {
1246     const struct nlattr *userdata_attr;
1247     uint64_t userdata;
1248
1249     userdata_attr = nl_attr_find_nested(a, OVS_USERSPACE_ATTR_USERDATA);
1250     userdata = userdata_attr ? nl_attr_get_u64(userdata_attr) : 0;
1251     dp_netdev_output_userspace(dp, packet, DPIF_UC_ACTION, key, userdata);
1252 }
1253
1254 static void
1255 execute_set_action(struct ofpbuf *packet, const struct nlattr *a)
1256 {
1257     enum ovs_key_attr type = nl_attr_type(a);
1258     switch (type) {
1259     case OVS_KEY_ATTR_TUN_ID:
1260     case OVS_KEY_ATTR_PRIORITY:
1261         /* not implemented */
1262         break;
1263
1264     case OVS_KEY_ATTR_ETHERNET:
1265         dp_netdev_set_dl(packet,
1266                    nl_attr_get_unspec(a, sizeof(struct ovs_key_ethernet)));
1267         break;
1268
1269     case OVS_KEY_ATTR_IPV4:
1270         dp_netdev_set_ipv4(packet,
1271                    nl_attr_get_unspec(a, sizeof(struct ovs_key_ipv4)));
1272         break;
1273
1274     case OVS_KEY_ATTR_TCP:
1275         dp_netdev_set_tcp_port(packet,
1276                    nl_attr_get_unspec(a, sizeof(struct ovs_key_tcp)));
1277         break;
1278
1279      case OVS_KEY_ATTR_UDP:
1280         dp_netdev_set_udp_port(packet,
1281                    nl_attr_get_unspec(a, sizeof(struct ovs_key_udp)));
1282         break;
1283
1284      case OVS_KEY_ATTR_UNSPEC:
1285      case OVS_KEY_ATTR_ENCAP:
1286      case OVS_KEY_ATTR_ETHERTYPE:
1287      case OVS_KEY_ATTR_IPV6:
1288      case OVS_KEY_ATTR_IN_PORT:
1289      case OVS_KEY_ATTR_VLAN:
1290      case OVS_KEY_ATTR_ICMP:
1291      case OVS_KEY_ATTR_ICMPV6:
1292      case OVS_KEY_ATTR_ARP:
1293      case OVS_KEY_ATTR_ND:
1294      case __OVS_KEY_ATTR_MAX:
1295      default:
1296         NOT_REACHED();
1297     }
1298 }
1299
1300 static void
1301 dp_netdev_execute_actions(struct dp_netdev *dp,
1302                           struct ofpbuf *packet, struct flow *key,
1303                           const struct nlattr *actions,
1304                           size_t actions_len)
1305 {
1306     const struct nlattr *a;
1307     unsigned int left;
1308
1309     NL_ATTR_FOR_EACH_UNSAFE (a, left, actions, actions_len) {
1310         const struct ovs_action_push_vlan *vlan;
1311         int type = nl_attr_type(a);
1312
1313         switch ((enum ovs_action_attr) type) {
1314         case OVS_ACTION_ATTR_OUTPUT:
1315             dp_netdev_output_port(dp, packet, nl_attr_get_u32(a));
1316             break;
1317
1318         case OVS_ACTION_ATTR_USERSPACE:
1319             dp_netdev_action_userspace(dp, packet, key, a);
1320             break;
1321
1322         case OVS_ACTION_ATTR_PUSH_VLAN:
1323             vlan = nl_attr_get(a);
1324             eth_push_vlan(packet, vlan->vlan_tci & ~htons(VLAN_CFI));
1325             break;
1326
1327         case OVS_ACTION_ATTR_POP_VLAN:
1328             dp_netdev_pop_vlan(packet);
1329             break;
1330
1331         case OVS_ACTION_ATTR_SET:
1332             execute_set_action(packet, nl_attr_get(a));
1333             break;
1334
1335         case OVS_ACTION_ATTR_SAMPLE:
1336             dp_netdev_sample(dp, packet, key, a);
1337             break;
1338
1339         case OVS_ACTION_ATTR_UNSPEC:
1340         case __OVS_ACTION_ATTR_MAX:
1341             NOT_REACHED();
1342         }
1343     }
1344 }
1345
1346 const struct dpif_class dpif_netdev_class = {
1347     "netdev",
1348     NULL,                       /* enumerate */
1349     dpif_netdev_open,
1350     dpif_netdev_close,
1351     dpif_netdev_destroy,
1352     dpif_netdev_run,
1353     dpif_netdev_wait,
1354     dpif_netdev_get_stats,
1355     dpif_netdev_port_add,
1356     dpif_netdev_port_del,
1357     dpif_netdev_port_query_by_number,
1358     dpif_netdev_port_query_by_name,
1359     dpif_netdev_get_max_ports,
1360     NULL,                       /* port_get_pid */
1361     dpif_netdev_port_dump_start,
1362     dpif_netdev_port_dump_next,
1363     dpif_netdev_port_dump_done,
1364     dpif_netdev_port_poll,
1365     dpif_netdev_port_poll_wait,
1366     dpif_netdev_flow_get,
1367     dpif_netdev_flow_put,
1368     dpif_netdev_flow_del,
1369     dpif_netdev_flow_flush,
1370     dpif_netdev_flow_dump_start,
1371     dpif_netdev_flow_dump_next,
1372     dpif_netdev_flow_dump_done,
1373     dpif_netdev_execute,
1374     NULL,                       /* operate */
1375     dpif_netdev_recv_get_mask,
1376     dpif_netdev_recv_set_mask,
1377     dpif_netdev_queue_to_priority,
1378     dpif_netdev_recv,
1379     dpif_netdev_recv_wait,
1380     dpif_netdev_recv_purge,
1381 };
1382
1383 void
1384 dpif_dummy_register(void)
1385 {
1386     if (!dpif_dummy_class.type) {
1387         dpif_dummy_class = dpif_netdev_class;
1388         dpif_dummy_class.type = "dummy";
1389         dp_register_provider(&dpif_dummy_class);
1390     }
1391 }