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_set_etheraddr(struct netdev *netdev,
 209                            const uint8_t mac[ETH_ADDR_LEN])
 210 {
 211     struct netdev_dev_dummy *dev =
 212         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 213
 214     if (!eth_addr_equals(dev->hwaddr, mac)) {
 215         memcpy(dev->hwaddr, mac, ETH_ADDR_LEN);
 216         netdev_dev_dummy_poll_notify(dev);
 217     }
 218
 219     return 0;
 220 }
 221
 222 static int
 223 netdev_dummy_get_etheraddr(const struct netdev *netdev,
 224                            uint8_t mac[ETH_ADDR_LEN])
 225 {
 226     const struct netdev_dev_dummy *dev =
 227         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 228
 229     memcpy(mac, dev->hwaddr, ETH_ADDR_LEN);
 230     return 0;
 231 }
 232
 233 static int
 234 netdev_dummy_get_mtu(const struct netdev *netdev, int *mtup)
 235 {
 236     const struct netdev_dev_dummy *dev =
 237         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 238
 239     *mtup = dev->mtu;
 240     return 0;
 241 }
 242
 243 static int
 244 netdev_dummy_set_mtu(const struct netdev *netdev, int mtu)
 245 {
 246     struct netdev_dev_dummy *dev =
 247         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 248
 249     dev->mtu = mtu;
 250     return 0;
 251 }
 252
 253 static int
 254 netdev_dummy_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
 255 {
 256     const struct netdev_dev_dummy *dev =
 257         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 258
 259     *stats = dev->stats;
 260     return 0;
 261 }
 262
 263 static int
 264 netdev_dummy_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
 265 {
 266     struct netdev_dev_dummy *dev =
 267         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 268
 269     dev->stats = *stats;
 270     return 0;
 271 }
 272
 273 static int
 274 netdev_dummy_update_flags(struct netdev *netdev,
 275                           enum netdev_flags off, enum netdev_flags on,
 276                           enum netdev_flags *old_flagsp)
 277 {
 278     struct netdev_dev_dummy *dev =
 279         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 280
 281     return netdev_dev_dummy_update_flags(dev, off, on, old_flagsp);
 282 }
 283
 284 static int
 285 netdev_dev_dummy_update_flags(struct netdev_dev_dummy *dev,
 286                               enum netdev_flags off, enum netdev_flags on,
 287                               enum netdev_flags *old_flagsp)
 288 {
 289     if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) {
 290         return EINVAL;
 291     }
 292
 293     *old_flagsp = dev->flags;
 294     dev->flags |= on;
 295     dev->flags &= ~off;
 296     if (*old_flagsp != dev->flags) {
 297         netdev_dev_dummy_poll_notify(dev);
 298     }
 299     return 0;
 300 }
 301
 302 static unsigned int
 303 netdev_dummy_change_seq(const struct netdev *netdev)
 304 {
 305     return netdev_dev_dummy_cast(netdev_get_dev(netdev))->change_seq;
 306 }
 307 \f
 308 /* Helper functions. */
 309
 310 static void
 311 netdev_dev_dummy_poll_notify(struct netdev_dev_dummy *dev)
 312 {
 313     dev->change_seq++;
 314     if (!dev->change_seq) {
 315         dev->change_seq++;
 316     }
 317 }
 318
 319 static const struct netdev_class dummy_class = {
 320     "dummy",
 321     NULL,                       /* init */
 322     NULL,                       /* run */
 323     NULL,                       /* wait */
 324
 325     netdev_dummy_create,
 326     netdev_dummy_destroy,
 327     NULL,                       /* get_config */
 328     NULL,                       /* set_config */
 329     NULL,                       /* get_tunnel_config */
 330
 331     netdev_dummy_open,
 332     netdev_dummy_close,
 333
 334     netdev_dummy_listen,
 335     netdev_dummy_recv,
 336     netdev_dummy_recv_wait,
 337     netdev_dummy_drain,
 338
 339     NULL,                       /* send */
 340     NULL,                       /* send_wait */
 341
 342     netdev_dummy_set_etheraddr,
 343     netdev_dummy_get_etheraddr,
 344     netdev_dummy_get_mtu,
 345     netdev_dummy_set_mtu,
 346     NULL,                       /* get_ifindex */
 347     NULL,                       /* get_carrier */
 348     NULL,                       /* get_carrier_resets */
 349     NULL,                       /* get_miimon */
 350     netdev_dummy_get_stats,
 351     netdev_dummy_set_stats,
 352
 353     NULL,                       /* get_features */
 354     NULL,                       /* set_advertisements */
 355
 356     NULL,                       /* set_policing */
 357     NULL,                       /* get_qos_types */
 358     NULL,                       /* get_qos_capabilities */
 359     NULL,                       /* get_qos */
 360     NULL,                       /* set_qos */
 361     NULL,                       /* get_queue */
 362     NULL,                       /* set_queue */
 363     NULL,                       /* delete_queue */
 364     NULL,                       /* get_queue_stats */
 365     NULL,                       /* dump_queues */
 366     NULL,                       /* dump_queue_stats */
 367
 368     NULL,                       /* get_in4 */
 369     NULL,                       /* set_in4 */
 370     NULL,                       /* get_in6 */
 371     NULL,                       /* add_router */
 372     NULL,                       /* get_next_hop */
 373     NULL,                       /* get_status */
 374     NULL,                       /* arp_lookup */
 375
 376     netdev_dummy_update_flags,
 377
 378     netdev_dummy_change_seq
 379 };
 380
 381 static struct ofpbuf *
 382 eth_from_packet_or_flow(const char *s)
 383 {
 384     enum odp_key_fitness fitness;
 385     struct ofpbuf *packet;
 386     struct ofpbuf odp_key;
 387     struct flow flow;
 388     int error;
 389
 390     if (!eth_from_hex(s, &packet)) {
 391         return packet;
 392     }
 393
 394     /* Convert string to datapath key.
 395      *
 396      * It would actually be nicer to parse an OpenFlow-like flow key here, but
 397      * the code for that currently calls exit() on parse error.  We have to
 398      * settle for parsing a datapath key for now.
 399      */
 400     ofpbuf_init(&odp_key, 0);
 401     error = odp_flow_key_from_string(s, NULL, &odp_key);
 402     if (error) {
 403         ofpbuf_uninit(&odp_key);
 404         return NULL;
 405     }
 406
 407     /* Convert odp_key to flow. */
 408     fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
 409     if (fitness == ODP_FIT_ERROR) {
 410         ofpbuf_uninit(&odp_key);
 411         return NULL;
 412     }
 413
 414     packet = ofpbuf_new(0);
 415     flow_compose(packet, &flow);
 416
 417     ofpbuf_uninit(&odp_key);
 418     return packet;
 419 }
 420
 421 static void
 422 netdev_dummy_receive(struct unixctl_conn *conn,
 423                      int argc, const char *argv[], void *aux OVS_UNUSED)
 424 {
 425     struct netdev_dev_dummy *dummy_dev;
 426     int n_listeners;
 427     int i;
 428
 429     dummy_dev = shash_find_data(&dummy_netdev_devs, argv[1]);
 430     if (!dummy_dev) {
 431         unixctl_command_reply_error(conn, "no such dummy netdev");
 432         return;
 433     }
 434
 435     n_listeners = 0;
 436     for (i = 2; i < argc; i++) {
 437         struct netdev_dummy *dev;
 438         struct ofpbuf *packet;
 439
 440         packet = eth_from_packet_or_flow(argv[i]);
 441         if (!packet) {
 442             unixctl_command_reply_error(conn, "bad packet syntax");
 443             return;
 444         }
 445
 446         n_listeners = 0;
 447         LIST_FOR_EACH (dev, node, &dummy_dev->devs) {
 448             if (dev->listening) {
 449                 struct ofpbuf *copy = ofpbuf_clone(packet);
 450                 list_push_back(&dev->recv_queue, &copy->list_node);
 451                 n_listeners++;
 452             }
 453         }
 454         ofpbuf_delete(packet);
 455     }
 456
 457     if (!n_listeners) {
 458         unixctl_command_reply(conn, "packets queued but nobody listened");
 459     } else {
 460         unixctl_command_reply(conn, "success");
 461     }
 462 }
 463
 464 static void
 465 netdev_dev_dummy_set_admin_state(struct netdev_dev_dummy *dev,
 466                                  bool admin_state)
 467 {
 468     enum netdev_flags old_flags;
 469
 470     if (admin_state) {
 471         netdev_dev_dummy_update_flags(dev, 0, NETDEV_UP, &old_flags);
 472     } else {
 473         netdev_dev_dummy_update_flags(dev, NETDEV_UP, 0, &old_flags);
 474     }
 475 }
 476
 477 static void
 478 netdev_dummy_set_admin_state(struct unixctl_conn *conn, int argc,
 479                              const char *argv[], void *aux OVS_UNUSED)
 480 {
 481     bool up;
 482
 483     if (!strcasecmp(argv[argc - 1], "up")) {
 484         up = true;
 485     } else if ( !strcasecmp(argv[argc - 1], "down")) {
 486         up = false;
 487     } else {
 488         unixctl_command_reply_error(conn, "Invalid Admin State");
 489         return;
 490     }
 491
 492     if (argc > 2) {
 493         struct netdev_dev_dummy *dummy_dev;
 494
 495         dummy_dev  = shash_find_data(&dummy_netdev_devs, argv[1]);
 496         if (dummy_dev) {
 497             netdev_dev_dummy_set_admin_state(dummy_dev, up);
 498         } else {
 499             unixctl_command_reply_error(conn, "Unknown Dummy Interface");
 500             return;
 501         }
 502     } else {
 503         struct shash_node *node;
 504
 505         SHASH_FOR_EACH (node, &dummy_netdev_devs) {
 506             netdev_dev_dummy_set_admin_state(node->data, up);
 507         }
 508     }
 509     unixctl_command_reply(conn, "OK");
 510 }
 511
 512 void
 513 netdev_dummy_register(bool override)
 514 {
 515     unixctl_command_register("netdev-dummy/receive", "NAME PACKET|FLOW...",
 516                              2, INT_MAX, netdev_dummy_receive, NULL);
 517     unixctl_command_register("netdev-dummy/set-admin-state",
 518                              "[netdev] up|down", 1, 2,
 519                              netdev_dummy_set_admin_state, NULL);
 520
 521     if (override) {
 522         struct sset types;
 523         const char *type;
 524
 525         sset_init(&types);
 526         netdev_enumerate_types(&types);
 527         SSET_FOR_EACH (type, &types) {
 528             if (!netdev_unregister_provider(type)) {
 529                 struct netdev_class *class;
 530
 531                 class = xmalloc(sizeof *class);
 532                 *class = dummy_class;
 533                 class->type = xstrdup(type);
 534                 netdev_register_provider(class);
 535             }
 536         }
 537         sset_destroy(&types);
 538     }
 539     netdev_register_provider(&dummy_class);
 540
 541     if (FREE_BSD) {
 542         netdev_vport_tunnel_register();
 543     }
 544 }