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