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