datapath: Move LRO check from transmit to receive.
[sliver-openvswitch.git] / lib / netdev-dummy.c
1 /*
2  * Copyright (c) 2010, 2011, 2012, 2013 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
19 #include "dummy.h"
20
21 #include <errno.h>
22
23 #include "flow.h"
24 #include "list.h"
25 #include "netdev-provider.h"
26 #include "odp-util.h"
27 #include "ofp-print.h"
28 #include "ofpbuf.h"
29 #include "packets.h"
30 #include "poll-loop.h"
31 #include "shash.h"
32 #include "sset.h"
33 #include "unixctl.h"
34 #include "vlog.h"
35
36 VLOG_DEFINE_THIS_MODULE(netdev_dummy);
37
38 struct netdev_dev_dummy {
39     struct netdev_dev netdev_dev;
40     uint8_t hwaddr[ETH_ADDR_LEN];
41     int mtu;
42     struct netdev_stats stats;
43     enum netdev_flags flags;
44     unsigned int change_seq;
45
46     struct list devs;           /* List of child "netdev_dummy"s. */
47 };
48
49 struct netdev_dummy {
50     struct netdev netdev;
51     struct list node;           /* In netdev_dev_dummy's "devs" list. */
52     struct list recv_queue;
53     bool listening;
54 };
55
56 static struct shash dummy_netdev_devs = SHASH_INITIALIZER(&dummy_netdev_devs);
57
58 static unixctl_cb_func netdev_dummy_set_admin_state;
59 static int netdev_dummy_create(const struct netdev_class *, const char *,
60                                struct netdev_dev **);
61 static void netdev_dev_dummy_poll_notify(struct netdev_dev_dummy *);
62 static int netdev_dev_dummy_update_flags(struct netdev_dev_dummy *,
63                                          enum netdev_flags off,
64                                          enum netdev_flags on,
65                                          enum netdev_flags *old_flagsp);
66
67 static bool
68 is_dummy_class(const struct netdev_class *class)
69 {
70     return class->create == netdev_dummy_create;
71 }
72
73 static struct netdev_dev_dummy *
74 netdev_dev_dummy_cast(const struct netdev_dev *netdev_dev)
75 {
76     ovs_assert(is_dummy_class(netdev_dev_get_class(netdev_dev)));
77     return CONTAINER_OF(netdev_dev, struct netdev_dev_dummy, netdev_dev);
78 }
79
80 static struct netdev_dummy *
81 netdev_dummy_cast(const struct netdev *netdev)
82 {
83     struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
84     ovs_assert(is_dummy_class(netdev_dev_get_class(netdev_dev)));
85     return CONTAINER_OF(netdev, struct netdev_dummy, netdev);
86 }
87
88 static int
89 netdev_dummy_create(const struct netdev_class *class, const char *name,
90                     struct netdev_dev **netdev_devp)
91 {
92     static unsigned int n = 0xaa550000;
93     struct netdev_dev_dummy *netdev_dev;
94
95     netdev_dev = xzalloc(sizeof *netdev_dev);
96     netdev_dev_init(&netdev_dev->netdev_dev, name, class);
97     netdev_dev->hwaddr[0] = 0xaa;
98     netdev_dev->hwaddr[1] = 0x55;
99     netdev_dev->hwaddr[2] = n >> 24;
100     netdev_dev->hwaddr[3] = n >> 16;
101     netdev_dev->hwaddr[4] = n >> 8;
102     netdev_dev->hwaddr[5] = n;
103     netdev_dev->mtu = 1500;
104     netdev_dev->flags = 0;
105     netdev_dev->change_seq = 1;
106     list_init(&netdev_dev->devs);
107
108     shash_add(&dummy_netdev_devs, name, netdev_dev);
109
110     n++;
111
112     *netdev_devp = &netdev_dev->netdev_dev;
113
114     return 0;
115 }
116
117 static void
118 netdev_dummy_destroy(struct netdev_dev *netdev_dev_)
119 {
120     struct netdev_dev_dummy *netdev_dev = netdev_dev_dummy_cast(netdev_dev_);
121
122     shash_find_and_delete(&dummy_netdev_devs,
123                           netdev_dev_get_name(netdev_dev_));
124     free(netdev_dev);
125 }
126
127 static int
128 netdev_dummy_open(struct netdev_dev *netdev_dev_, struct netdev **netdevp)
129 {
130     struct netdev_dev_dummy *netdev_dev = netdev_dev_dummy_cast(netdev_dev_);
131     struct netdev_dummy *netdev;
132
133     netdev = xmalloc(sizeof *netdev);
134     netdev_init(&netdev->netdev, netdev_dev_);
135     list_init(&netdev->recv_queue);
136     netdev->listening = false;
137
138     *netdevp = &netdev->netdev;
139     list_push_back(&netdev_dev->devs, &netdev->node);
140     return 0;
141 }
142
143 static void
144 netdev_dummy_close(struct netdev *netdev_)
145 {
146     struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
147     list_remove(&netdev->node);
148     ofpbuf_list_delete(&netdev->recv_queue);
149     free(netdev);
150 }
151
152 static int
153 netdev_dummy_listen(struct netdev *netdev_)
154 {
155     struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
156     netdev->listening = true;
157     return 0;
158 }
159
160 static int
161 netdev_dummy_recv(struct netdev *netdev_, void *buffer, size_t size)
162 {
163     struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
164     struct ofpbuf *packet;
165     size_t packet_size;
166
167     if (list_is_empty(&netdev->recv_queue)) {
168         return -EAGAIN;
169     }
170
171     packet = ofpbuf_from_list(list_pop_front(&netdev->recv_queue));
172     if (packet->size > size) {
173         return -EMSGSIZE;
174     }
175     packet_size = packet->size;
176
177     memcpy(buffer, packet->data, packet->size);
178     ofpbuf_delete(packet);
179
180     return packet_size;
181 }
182
183 static void
184 netdev_dummy_recv_wait(struct netdev *netdev_)
185 {
186     struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
187     if (!list_is_empty(&netdev->recv_queue)) {
188         poll_immediate_wake();
189     }
190 }
191
192 static int
193 netdev_dummy_drain(struct netdev *netdev_)
194 {
195     struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
196     ofpbuf_list_delete(&netdev->recv_queue);
197     return 0;
198 }
199
200 static int
201 netdev_dummy_set_etheraddr(struct netdev *netdev,
202                            const uint8_t mac[ETH_ADDR_LEN])
203 {
204     struct netdev_dev_dummy *dev =
205         netdev_dev_dummy_cast(netdev_get_dev(netdev));
206
207     if (!eth_addr_equals(dev->hwaddr, mac)) {
208         memcpy(dev->hwaddr, mac, ETH_ADDR_LEN);
209         netdev_dev_dummy_poll_notify(dev);
210     }
211
212     return 0;
213 }
214
215 static int
216 netdev_dummy_get_etheraddr(const struct netdev *netdev,
217                            uint8_t mac[ETH_ADDR_LEN])
218 {
219     const struct netdev_dev_dummy *dev =
220         netdev_dev_dummy_cast(netdev_get_dev(netdev));
221
222     memcpy(mac, dev->hwaddr, ETH_ADDR_LEN);
223     return 0;
224 }
225
226 static int
227 netdev_dummy_get_mtu(const struct netdev *netdev, int *mtup)
228 {
229     const struct netdev_dev_dummy *dev =
230         netdev_dev_dummy_cast(netdev_get_dev(netdev));
231
232     *mtup = dev->mtu;
233     return 0;
234 }
235
236 static int
237 netdev_dummy_set_mtu(const struct netdev *netdev, int mtu)
238 {
239     struct netdev_dev_dummy *dev =
240         netdev_dev_dummy_cast(netdev_get_dev(netdev));
241
242     dev->mtu = mtu;
243     return 0;
244 }
245
246 static int
247 netdev_dummy_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
248 {
249     const struct netdev_dev_dummy *dev =
250         netdev_dev_dummy_cast(netdev_get_dev(netdev));
251
252     *stats = dev->stats;
253     return 0;
254 }
255
256 static int
257 netdev_dummy_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
258 {
259     struct netdev_dev_dummy *dev =
260         netdev_dev_dummy_cast(netdev_get_dev(netdev));
261
262     dev->stats = *stats;
263     return 0;
264 }
265
266 static int
267 netdev_dummy_update_flags(struct netdev *netdev,
268                           enum netdev_flags off, enum netdev_flags on,
269                           enum netdev_flags *old_flagsp)
270 {
271     struct netdev_dev_dummy *dev =
272         netdev_dev_dummy_cast(netdev_get_dev(netdev));
273
274     return netdev_dev_dummy_update_flags(dev, off, on, old_flagsp);
275 }
276
277 static int
278 netdev_dev_dummy_update_flags(struct netdev_dev_dummy *dev,
279                               enum netdev_flags off, enum netdev_flags on,
280                               enum netdev_flags *old_flagsp)
281 {
282     if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) {
283         return EINVAL;
284     }
285
286     *old_flagsp = dev->flags;
287     dev->flags |= on;
288     dev->flags &= ~off;
289     if (*old_flagsp != dev->flags) {
290         netdev_dev_dummy_poll_notify(dev);
291     }
292     return 0;
293 }
294
295 static unsigned int
296 netdev_dummy_change_seq(const struct netdev *netdev)
297 {
298     return netdev_dev_dummy_cast(netdev_get_dev(netdev))->change_seq;
299 }
300 \f
301 /* Helper functions. */
302
303 static void
304 netdev_dev_dummy_poll_notify(struct netdev_dev_dummy *dev)
305 {
306     dev->change_seq++;
307     if (!dev->change_seq) {
308         dev->change_seq++;
309     }
310 }
311
312 static const struct netdev_class dummy_class = {
313     "dummy",
314     NULL,                       /* init */
315     NULL,                       /* run */
316     NULL,                       /* wait */
317
318     netdev_dummy_create,
319     netdev_dummy_destroy,
320     NULL,                       /* get_config */
321     NULL,                       /* set_config */
322     NULL,                       /* get_tunnel_config */
323
324     netdev_dummy_open,
325     netdev_dummy_close,
326
327     netdev_dummy_listen,
328     netdev_dummy_recv,
329     netdev_dummy_recv_wait,
330     netdev_dummy_drain,
331
332     NULL,                       /* send */
333     NULL,                       /* send_wait */
334
335     netdev_dummy_set_etheraddr,
336     netdev_dummy_get_etheraddr,
337     netdev_dummy_get_mtu,
338     netdev_dummy_set_mtu,
339     NULL,                       /* get_ifindex */
340     NULL,                       /* get_carrier */
341     NULL,                       /* get_carrier_resets */
342     NULL,                       /* get_miimon */
343     netdev_dummy_get_stats,
344     netdev_dummy_set_stats,
345
346     NULL,                       /* get_features */
347     NULL,                       /* set_advertisements */
348
349     NULL,                       /* set_policing */
350     NULL,                       /* get_qos_types */
351     NULL,                       /* get_qos_capabilities */
352     NULL,                       /* get_qos */
353     NULL,                       /* set_qos */
354     NULL,                       /* get_queue */
355     NULL,                       /* set_queue */
356     NULL,                       /* delete_queue */
357     NULL,                       /* get_queue_stats */
358     NULL,                       /* dump_queues */
359     NULL,                       /* dump_queue_stats */
360
361     NULL,                       /* get_in4 */
362     NULL,                       /* set_in4 */
363     NULL,                       /* get_in6 */
364     NULL,                       /* add_router */
365     NULL,                       /* get_next_hop */
366     NULL,                       /* get_status */
367     NULL,                       /* arp_lookup */
368
369     netdev_dummy_update_flags,
370
371     netdev_dummy_change_seq
372 };
373
374 static struct ofpbuf *
375 eth_from_packet_or_flow(const char *s)
376 {
377     enum odp_key_fitness fitness;
378     struct ofpbuf *packet;
379     struct ofpbuf odp_key;
380     struct flow flow;
381     int error;
382
383     if (!eth_from_hex(s, &packet)) {
384         return packet;
385     }
386
387     /* Convert string to datapath key.
388      *
389      * It would actually be nicer to parse an OpenFlow-like flow key here, but
390      * the code for that currently calls exit() on parse error.  We have to
391      * settle for parsing a datapath key for now.
392      */
393     ofpbuf_init(&odp_key, 0);
394     error = odp_flow_key_from_string(s, NULL, &odp_key);
395     if (error) {
396         ofpbuf_uninit(&odp_key);
397         return NULL;
398     }
399
400     /* Convert odp_key to flow. */
401     fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
402     if (fitness == ODP_FIT_ERROR) {
403         ofpbuf_uninit(&odp_key);
404         return NULL;
405     }
406
407     packet = ofpbuf_new(0);
408     flow_compose(packet, &flow);
409
410     ofpbuf_uninit(&odp_key);
411     return packet;
412 }
413
414 static void
415 netdev_dummy_receive(struct unixctl_conn *conn,
416                      int argc, const char *argv[], void *aux OVS_UNUSED)
417 {
418     struct netdev_dev_dummy *dummy_dev;
419     int n_listeners;
420     int i;
421
422     dummy_dev = shash_find_data(&dummy_netdev_devs, argv[1]);
423     if (!dummy_dev) {
424         unixctl_command_reply_error(conn, "no such dummy netdev");
425         return;
426     }
427
428     n_listeners = 0;
429     for (i = 2; i < argc; i++) {
430         struct netdev_dummy *dev;
431         struct ofpbuf *packet;
432
433         packet = eth_from_packet_or_flow(argv[i]);
434         if (!packet) {
435             unixctl_command_reply_error(conn, "bad packet syntax");
436             return;
437         }
438
439         n_listeners = 0;
440         LIST_FOR_EACH (dev, node, &dummy_dev->devs) {
441             if (dev->listening) {
442                 struct ofpbuf *copy = ofpbuf_clone(packet);
443                 list_push_back(&dev->recv_queue, &copy->list_node);
444                 n_listeners++;
445             }
446         }
447         ofpbuf_delete(packet);
448     }
449
450     if (!n_listeners) {
451         unixctl_command_reply(conn, "packets queued but nobody listened");
452     } else {
453         unixctl_command_reply(conn, "success");
454     }
455 }
456
457 static void
458 netdev_dev_dummy_set_admin_state(struct netdev_dev_dummy *dev,
459                                  bool admin_state)
460 {
461     enum netdev_flags old_flags;
462
463     if (admin_state) {
464         netdev_dev_dummy_update_flags(dev, 0, NETDEV_UP, &old_flags);
465     } else {
466         netdev_dev_dummy_update_flags(dev, NETDEV_UP, 0, &old_flags);
467     }
468 }
469
470 static void
471 netdev_dummy_set_admin_state(struct unixctl_conn *conn, int argc,
472                              const char *argv[], void *aux OVS_UNUSED)
473 {
474     bool up;
475
476     if (!strcasecmp(argv[argc - 1], "up")) {
477         up = true;
478     } else if ( !strcasecmp(argv[argc - 1], "down")) {
479         up = false;
480     } else {
481         unixctl_command_reply_error(conn, "Invalid Admin State");
482         return;
483     }
484
485     if (argc > 2) {
486         struct netdev_dev_dummy *dummy_dev;
487
488         dummy_dev  = shash_find_data(&dummy_netdev_devs, argv[1]);
489         if (dummy_dev) {
490             netdev_dev_dummy_set_admin_state(dummy_dev, up);
491         } else {
492             unixctl_command_reply_error(conn, "Unknown Dummy Interface");
493             return;
494         }
495     } else {
496         struct shash_node *node;
497
498         SHASH_FOR_EACH (node, &dummy_netdev_devs) {
499             netdev_dev_dummy_set_admin_state(node->data, up);
500         }
501     }
502     unixctl_command_reply(conn, "OK");
503 }
504
505 void
506 netdev_dummy_register(bool override)
507 {
508     unixctl_command_register("netdev-dummy/receive", "NAME PACKET|FLOW...",
509                              2, INT_MAX, netdev_dummy_receive, NULL);
510     unixctl_command_register("netdev-dummy/set-admin-state",
511                              "[netdev] up|down", 1, 2,
512                              netdev_dummy_set_admin_state, NULL);
513
514     if (override) {
515         struct sset types;
516         const char *type;
517
518         sset_init(&types);
519         netdev_enumerate_types(&types);
520         SSET_FOR_EACH (type, &types) {
521             if (!netdev_unregister_provider(type)) {
522                 struct netdev_class *class;
523
524                 class = xmalloc(sizeof *class);
525                 *class = dummy_class;
526                 class->type = xstrdup(type);
527                 netdev_register_provider(class);
528             }
529         }
530         sset_destroy(&types);
531     }
532     netdev_register_provider(&dummy_class);
533 }