2 * Copyright (c) 2010, 2011, 2012, 2013 Nicira, Inc.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
25 #include "netdev-provider.h"
26 #include "netdev-vport.h"
28 #include "ofp-print.h"
31 #include "poll-loop.h"
37 VLOG_DEFINE_THIS_MODULE(netdev_dummy);
41 uint8_t hwaddr[ETH_ADDR_LEN];
43 struct netdev_stats stats;
44 enum netdev_flags flags;
45 unsigned int change_seq;
48 struct list rxes; /* List of child "netdev_rx_dummy"s. */
51 /* Max 'recv_queue_len' in struct netdev_dummy. */
52 #define NETDEV_DUMMY_MAX_QUEUE 100
54 struct netdev_rx_dummy {
56 struct list node; /* In netdev_dummy's "rxes" list. */
57 struct list recv_queue;
58 int recv_queue_len; /* list_size(&recv_queue). */
62 static struct shash dummy_netdevs = SHASH_INITIALIZER(&dummy_netdevs);
64 static const struct netdev_rx_class netdev_rx_dummy_class;
66 static unixctl_cb_func netdev_dummy_set_admin_state;
67 static int netdev_dummy_create(const struct netdev_class *, const char *,
69 static void netdev_dummy_poll_notify(struct netdev_dummy *);
72 is_dummy_class(const struct netdev_class *class)
74 return class->create == netdev_dummy_create;
77 static struct netdev_dummy *
78 netdev_dummy_cast(const struct netdev *netdev)
80 ovs_assert(is_dummy_class(netdev_get_class(netdev)));
81 return CONTAINER_OF(netdev, struct netdev_dummy, up);
84 static struct netdev_rx_dummy *
85 netdev_rx_dummy_cast(const struct netdev_rx *rx)
87 netdev_rx_assert_class(rx, &netdev_rx_dummy_class);
88 return CONTAINER_OF(rx, struct netdev_rx_dummy, up);
92 netdev_dummy_create(const struct netdev_class *class, const char *name,
93 struct netdev **netdevp)
95 static unsigned int n = 0xaa550000;
96 struct netdev_dummy *netdev;
98 netdev = xzalloc(sizeof *netdev);
99 netdev_init(&netdev->up, name, class);
100 netdev->hwaddr[0] = 0xaa;
101 netdev->hwaddr[1] = 0x55;
102 netdev->hwaddr[2] = n >> 24;
103 netdev->hwaddr[3] = n >> 16;
104 netdev->hwaddr[4] = n >> 8;
105 netdev->hwaddr[5] = n;
108 netdev->change_seq = 1;
109 netdev->ifindex = -EOPNOTSUPP;
110 list_init(&netdev->rxes);
112 shash_add(&dummy_netdevs, name, netdev);
116 *netdevp = &netdev->up;
122 netdev_dummy_destroy(struct netdev *netdev_)
124 struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
126 shash_find_and_delete(&dummy_netdevs,
127 netdev_get_name(netdev_));
132 netdev_dummy_get_config(const struct netdev *netdev_, struct smap *args)
134 struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
136 if (netdev->ifindex >= 0) {
137 smap_add_format(args, "ifindex", "%d", netdev->ifindex);
143 netdev_dummy_set_config(struct netdev *netdev_, const struct smap *args)
145 struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
147 netdev->ifindex = smap_get_int(args, "ifindex", -EOPNOTSUPP);
152 netdev_dummy_rx_open(struct netdev *netdev_, struct netdev_rx **rxp)
154 struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
155 struct netdev_rx_dummy *rx;
157 rx = xmalloc(sizeof *rx);
158 netdev_rx_init(&rx->up, &netdev->up, &netdev_rx_dummy_class);
159 list_push_back(&netdev->rxes, &rx->node);
160 list_init(&rx->recv_queue);
161 rx->recv_queue_len = 0;
168 netdev_rx_dummy_recv(struct netdev_rx *rx_, void *buffer, size_t size)
170 struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_);
171 struct ofpbuf *packet;
174 if (list_is_empty(&rx->recv_queue)) {
178 packet = ofpbuf_from_list(list_pop_front(&rx->recv_queue));
179 rx->recv_queue_len--;
180 if (packet->size > size) {
183 packet_size = packet->size;
185 memcpy(buffer, packet->data, packet->size);
186 ofpbuf_delete(packet);
192 netdev_rx_dummy_destroy(struct netdev_rx *rx_)
194 struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_);
195 list_remove(&rx->node);
196 ofpbuf_list_delete(&rx->recv_queue);
201 netdev_rx_dummy_wait(struct netdev_rx *rx_)
203 struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_);
204 if (!list_is_empty(&rx->recv_queue)) {
205 poll_immediate_wake();
210 netdev_rx_dummy_drain(struct netdev_rx *rx_)
212 struct netdev_rx_dummy *rx = netdev_rx_dummy_cast(rx_);
213 ofpbuf_list_delete(&rx->recv_queue);
214 rx->recv_queue_len = 0;
219 netdev_dummy_send(struct netdev *netdev, const void *buffer OVS_UNUSED,
222 struct netdev_dummy *dev = netdev_dummy_cast(netdev);
224 dev->stats.tx_packets++;
225 dev->stats.tx_bytes += size;
231 netdev_dummy_set_etheraddr(struct netdev *netdev,
232 const uint8_t mac[ETH_ADDR_LEN])
234 struct netdev_dummy *dev = netdev_dummy_cast(netdev);
236 if (!eth_addr_equals(dev->hwaddr, mac)) {
237 memcpy(dev->hwaddr, mac, ETH_ADDR_LEN);
238 netdev_dummy_poll_notify(dev);
245 netdev_dummy_get_etheraddr(const struct netdev *netdev,
246 uint8_t mac[ETH_ADDR_LEN])
248 const struct netdev_dummy *dev = netdev_dummy_cast(netdev);
250 memcpy(mac, dev->hwaddr, ETH_ADDR_LEN);
255 netdev_dummy_get_mtu(const struct netdev *netdev, int *mtup)
257 const struct netdev_dummy *dev = netdev_dummy_cast(netdev);
264 netdev_dummy_set_mtu(const struct netdev *netdev, int mtu)
266 struct netdev_dummy *dev = netdev_dummy_cast(netdev);
273 netdev_dummy_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
275 const struct netdev_dummy *dev = netdev_dummy_cast(netdev);
282 netdev_dummy_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
284 struct netdev_dummy *dev = netdev_dummy_cast(netdev);
291 netdev_dummy_get_ifindex(const struct netdev *netdev)
293 struct netdev_dummy *dev = netdev_dummy_cast(netdev);
299 netdev_dummy_update_flags(struct netdev *netdev_,
300 enum netdev_flags off, enum netdev_flags on,
301 enum netdev_flags *old_flagsp)
303 struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
305 if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) {
309 *old_flagsp = netdev->flags;
311 netdev->flags &= ~off;
312 if (*old_flagsp != netdev->flags) {
313 netdev_dummy_poll_notify(netdev);
319 netdev_dummy_change_seq(const struct netdev *netdev)
321 return netdev_dummy_cast(netdev)->change_seq;
324 /* Helper functions. */
327 netdev_dummy_poll_notify(struct netdev_dummy *dev)
330 if (!dev->change_seq) {
335 static const struct netdev_class dummy_class = {
342 netdev_dummy_destroy,
343 netdev_dummy_get_config,
344 netdev_dummy_set_config,
345 NULL, /* get_tunnel_config */
347 netdev_dummy_rx_open,
349 netdev_dummy_send, /* send */
350 NULL, /* send_wait */
352 netdev_dummy_set_etheraddr,
353 netdev_dummy_get_etheraddr,
354 netdev_dummy_get_mtu,
355 netdev_dummy_set_mtu,
356 netdev_dummy_get_ifindex,
357 NULL, /* get_carrier */
358 NULL, /* get_carrier_resets */
359 NULL, /* get_miimon */
360 netdev_dummy_get_stats,
361 netdev_dummy_set_stats,
363 NULL, /* get_features */
364 NULL, /* set_advertisements */
366 NULL, /* set_policing */
367 NULL, /* get_qos_types */
368 NULL, /* get_qos_capabilities */
371 NULL, /* get_queue */
372 NULL, /* set_queue */
373 NULL, /* delete_queue */
374 NULL, /* get_queue_stats */
375 NULL, /* dump_queues */
376 NULL, /* dump_queue_stats */
381 NULL, /* add_router */
382 NULL, /* get_next_hop */
383 NULL, /* get_status */
384 NULL, /* arp_lookup */
386 netdev_dummy_update_flags,
388 netdev_dummy_change_seq
391 static const struct netdev_rx_class netdev_rx_dummy_class = {
392 netdev_rx_dummy_destroy,
393 netdev_rx_dummy_recv,
394 netdev_rx_dummy_wait,
395 netdev_rx_dummy_drain,
398 static struct ofpbuf *
399 eth_from_packet_or_flow(const char *s)
401 enum odp_key_fitness fitness;
402 struct ofpbuf *packet;
403 struct ofpbuf odp_key;
407 if (!eth_from_hex(s, &packet)) {
411 /* Convert string to datapath key.
413 * It would actually be nicer to parse an OpenFlow-like flow key here, but
414 * the code for that currently calls exit() on parse error. We have to
415 * settle for parsing a datapath key for now.
417 ofpbuf_init(&odp_key, 0);
418 error = odp_flow_key_from_string(s, NULL, &odp_key);
420 ofpbuf_uninit(&odp_key);
424 /* Convert odp_key to flow. */
425 fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
426 if (fitness == ODP_FIT_ERROR) {
427 ofpbuf_uninit(&odp_key);
431 packet = ofpbuf_new(0);
432 flow_compose(packet, &flow);
434 ofpbuf_uninit(&odp_key);
439 netdev_dummy_queue_packet(struct netdev_dummy *dummy,
440 const void *data, size_t size)
442 struct netdev_rx_dummy *rx;
446 LIST_FOR_EACH (rx, node, &dummy->rxes) {
447 if (rx->recv_queue_len < NETDEV_DUMMY_MAX_QUEUE) {
448 struct ofpbuf *copy = ofpbuf_clone_data(data, size);
449 list_push_back(&rx->recv_queue, ©->list_node);
450 rx->recv_queue_len++;
459 netdev_dummy_receive(struct unixctl_conn *conn,
460 int argc, const char *argv[], void *aux OVS_UNUSED)
462 struct netdev_dummy *dummy_dev;
466 dummy_dev = shash_find_data(&dummy_netdevs, argv[1]);
468 unixctl_command_reply_error(conn, "no such dummy netdev");
473 for (i = 2; i < argc; i++) {
474 struct ofpbuf *packet;
476 packet = eth_from_packet_or_flow(argv[i]);
478 unixctl_command_reply_error(conn, "bad packet syntax");
482 dummy_dev->stats.rx_packets++;
483 dummy_dev->stats.rx_bytes += packet->size;
485 n_listeners += netdev_dummy_queue_packet(dummy_dev,
486 packet->data, packet->size);
487 ofpbuf_delete(packet);
491 unixctl_command_reply(conn, "packets queued but nobody listened");
493 unixctl_command_reply(conn, "success");
498 netdev_dummy_set_admin_state__(struct netdev_dummy *dev, bool admin_state)
500 enum netdev_flags old_flags;
503 netdev_dummy_update_flags(&dev->up, 0, NETDEV_UP, &old_flags);
505 netdev_dummy_update_flags(&dev->up, NETDEV_UP, 0, &old_flags);
510 netdev_dummy_set_admin_state(struct unixctl_conn *conn, int argc,
511 const char *argv[], void *aux OVS_UNUSED)
515 if (!strcasecmp(argv[argc - 1], "up")) {
517 } else if ( !strcasecmp(argv[argc - 1], "down")) {
520 unixctl_command_reply_error(conn, "Invalid Admin State");
525 struct netdev_dummy *dummy_dev;
527 dummy_dev = shash_find_data(&dummy_netdevs, argv[1]);
529 netdev_dummy_set_admin_state__(dummy_dev, up);
531 unixctl_command_reply_error(conn, "Unknown Dummy Interface");
535 struct shash_node *node;
537 SHASH_FOR_EACH (node, &dummy_netdevs) {
538 netdev_dummy_set_admin_state__(node->data, up);
541 unixctl_command_reply(conn, "OK");
545 netdev_dummy_register(bool override)
547 unixctl_command_register("netdev-dummy/receive", "NAME PACKET|FLOW...",
548 2, INT_MAX, netdev_dummy_receive, NULL);
549 unixctl_command_register("netdev-dummy/set-admin-state",
550 "[netdev] up|down", 1, 2,
551 netdev_dummy_set_admin_state, NULL);
558 netdev_enumerate_types(&types);
559 SSET_FOR_EACH (type, &types) {
560 if (!netdev_unregister_provider(type)) {
561 struct netdev_class *class;
563 class = xmalloc(sizeof *class);
564 *class = dummy_class;
565 class->type = xstrdup(type);
566 netdev_register_provider(class);
569 sset_destroy(&types);
571 netdev_register_provider(&dummy_class);
573 netdev_vport_tunnel_register();