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