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