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