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_dev *dev_,
 320                           enum netdev_flags off, enum netdev_flags on,
 321                           enum netdev_flags *old_flagsp)
 322 {
 323     struct netdev_dev_dummy *dev = netdev_dev_dummy_cast(dev_);
 324
 325     return netdev_dev_dummy_update_flags(dev, off, on, old_flagsp);
 326 }
 327
 328 static int
 329 netdev_dev_dummy_update_flags(struct netdev_dev_dummy *dev,
 330                               enum netdev_flags off, enum netdev_flags on,
 331                               enum netdev_flags *old_flagsp)
 332 {
 333     if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) {
 334         return EINVAL;
 335     }
 336
 337     *old_flagsp = dev->flags;
 338     dev->flags |= on;
 339     dev->flags &= ~off;
 340     if (*old_flagsp != dev->flags) {
 341         netdev_dev_dummy_poll_notify(dev);
 342     }
 343     return 0;
 344 }
 345
 346 static unsigned int
 347 netdev_dummy_change_seq(const struct netdev *netdev)
 348 {
 349     return netdev_dev_dummy_cast(netdev_get_dev(netdev))->change_seq;
 350 }
 351 \f
 352 /* Helper functions. */
 353
 354 static void
 355 netdev_dev_dummy_poll_notify(struct netdev_dev_dummy *dev)
 356 {
 357     dev->change_seq++;
 358     if (!dev->change_seq) {
 359         dev->change_seq++;
 360     }
 361 }
 362
 363 static const struct netdev_class dummy_class = {
 364     "dummy",
 365     NULL,                       /* init */
 366     NULL,                       /* run */
 367     NULL,                       /* wait */
 368
 369     netdev_dummy_create,
 370     netdev_dummy_destroy,
 371     netdev_dummy_get_config,
 372     netdev_dummy_set_config,
 373     NULL,                       /* get_tunnel_config */
 374
 375     netdev_dummy_open,
 376     netdev_dummy_close,
 377
 378     netdev_dummy_listen,
 379     netdev_dummy_recv,
 380     netdev_dummy_recv_wait,
 381     netdev_dummy_drain,
 382
 383     netdev_dummy_send,          /* send */
 384     NULL,                       /* send_wait */
 385
 386     netdev_dummy_set_etheraddr,
 387     netdev_dummy_get_etheraddr,
 388     netdev_dummy_get_mtu,
 389     netdev_dummy_set_mtu,
 390     netdev_dummy_get_ifindex,
 391     NULL,                       /* get_carrier */
 392     NULL,                       /* get_carrier_resets */
 393     NULL,                       /* get_miimon */
 394     netdev_dummy_get_stats,
 395     netdev_dummy_set_stats,
 396
 397     NULL,                       /* get_features */
 398     NULL,                       /* set_advertisements */
 399
 400     NULL,                       /* set_policing */
 401     NULL,                       /* get_qos_types */
 402     NULL,                       /* get_qos_capabilities */
 403     NULL,                       /* get_qos */
 404     NULL,                       /* set_qos */
 405     NULL,                       /* get_queue */
 406     NULL,                       /* set_queue */
 407     NULL,                       /* delete_queue */
 408     NULL,                       /* get_queue_stats */
 409     NULL,                       /* dump_queues */
 410     NULL,                       /* dump_queue_stats */
 411
 412     NULL,                       /* get_in4 */
 413     NULL,                       /* set_in4 */
 414     NULL,                       /* get_in6 */
 415     NULL,                       /* add_router */
 416     NULL,                       /* get_next_hop */
 417     NULL,                       /* get_status */
 418     NULL,                       /* arp_lookup */
 419
 420     netdev_dummy_update_flags,
 421
 422     netdev_dummy_change_seq
 423 };
 424
 425 static struct ofpbuf *
 426 eth_from_packet_or_flow(const char *s)
 427 {
 428     enum odp_key_fitness fitness;
 429     struct ofpbuf *packet;
 430     struct ofpbuf odp_key;
 431     struct flow flow;
 432     int error;
 433
 434     if (!eth_from_hex(s, &packet)) {
 435         return packet;
 436     }
 437
 438     /* Convert string to datapath key.
 439      *
 440      * It would actually be nicer to parse an OpenFlow-like flow key here, but
 441      * the code for that currently calls exit() on parse error.  We have to
 442      * settle for parsing a datapath key for now.
 443      */
 444     ofpbuf_init(&odp_key, 0);
 445     error = odp_flow_key_from_string(s, NULL, &odp_key);
 446     if (error) {
 447         ofpbuf_uninit(&odp_key);
 448         return NULL;
 449     }
 450
 451     /* Convert odp_key to flow. */
 452     fitness = odp_flow_key_to_flow(odp_key.data, odp_key.size, &flow);
 453     if (fitness == ODP_FIT_ERROR) {
 454         ofpbuf_uninit(&odp_key);
 455         return NULL;
 456     }
 457
 458     packet = ofpbuf_new(0);
 459     flow_compose(packet, &flow);
 460
 461     ofpbuf_uninit(&odp_key);
 462     return packet;
 463 }
 464
 465 static void
 466 netdev_dummy_receive(struct unixctl_conn *conn,
 467                      int argc, const char *argv[], void *aux OVS_UNUSED)
 468 {
 469     struct netdev_dev_dummy *dummy_dev;
 470     int n_listeners;
 471     int i;
 472
 473     dummy_dev = shash_find_data(&dummy_netdev_devs, argv[1]);
 474     if (!dummy_dev) {
 475         unixctl_command_reply_error(conn, "no such dummy netdev");
 476         return;
 477     }
 478
 479     n_listeners = 0;
 480     for (i = 2; i < argc; i++) {
 481         struct netdev_dummy *dev;
 482         struct ofpbuf *packet;
 483
 484         packet = eth_from_packet_or_flow(argv[i]);
 485         if (!packet) {
 486             unixctl_command_reply_error(conn, "bad packet syntax");
 487             return;
 488         }
 489
 490         dummy_dev->stats.rx_packets++;
 491         dummy_dev->stats.rx_bytes += packet->size;
 492
 493         n_listeners = 0;
 494         LIST_FOR_EACH (dev, node, &dummy_dev->devs) {
 495             if (dev->listening) {
 496                 struct ofpbuf *copy = ofpbuf_clone(packet);
 497                 list_push_back(&dev->recv_queue, &copy->list_node);
 498                 n_listeners++;
 499             }
 500         }
 501         ofpbuf_delete(packet);
 502     }
 503
 504     if (!n_listeners) {
 505         unixctl_command_reply(conn, "packets queued but nobody listened");
 506     } else {
 507         unixctl_command_reply(conn, "success");
 508     }
 509 }
 510
 511 static void
 512 netdev_dev_dummy_set_admin_state(struct netdev_dev_dummy *dev,
 513                                  bool admin_state)
 514 {
 515     enum netdev_flags old_flags;
 516
 517     if (admin_state) {
 518         netdev_dev_dummy_update_flags(dev, 0, NETDEV_UP, &old_flags);
 519     } else {
 520         netdev_dev_dummy_update_flags(dev, NETDEV_UP, 0, &old_flags);
 521     }
 522 }
 523
 524 static void
 525 netdev_dummy_set_admin_state(struct unixctl_conn *conn, int argc,
 526                              const char *argv[], void *aux OVS_UNUSED)
 527 {
 528     bool up;
 529
 530     if (!strcasecmp(argv[argc - 1], "up")) {
 531         up = true;
 532     } else if ( !strcasecmp(argv[argc - 1], "down")) {
 533         up = false;
 534     } else {
 535         unixctl_command_reply_error(conn, "Invalid Admin State");
 536         return;
 537     }
 538
 539     if (argc > 2) {
 540         struct netdev_dev_dummy *dummy_dev;
 541
 542         dummy_dev  = shash_find_data(&dummy_netdev_devs, argv[1]);
 543         if (dummy_dev) {
 544             netdev_dev_dummy_set_admin_state(dummy_dev, up);
 545         } else {
 546             unixctl_command_reply_error(conn, "Unknown Dummy Interface");
 547             return;
 548         }
 549     } else {
 550         struct shash_node *node;
 551
 552         SHASH_FOR_EACH (node, &dummy_netdev_devs) {
 553             netdev_dev_dummy_set_admin_state(node->data, up);
 554         }
 555     }
 556     unixctl_command_reply(conn, "OK");
 557 }
 558
 559 void
 560 netdev_dummy_register(bool override)
 561 {
 562     unixctl_command_register("netdev-dummy/receive", "NAME PACKET|FLOW...",
 563                              2, INT_MAX, netdev_dummy_receive, NULL);
 564     unixctl_command_register("netdev-dummy/set-admin-state",
 565                              "[netdev] up|down", 1, 2,
 566                              netdev_dummy_set_admin_state, NULL);
 567
 568     if (override) {
 569         struct sset types;
 570         const char *type;
 571
 572         sset_init(&types);
 573         netdev_enumerate_types(&types);
 574         SSET_FOR_EACH (type, &types) {
 575             if (!netdev_unregister_provider(type)) {
 576                 struct netdev_class *class;
 577
 578                 class = xmalloc(sizeof *class);
 579                 *class = dummy_class;
 580                 class->type = xstrdup(type);
 581                 netdev_register_provider(class);
 582             }
 583         }
 584         sset_destroy(&types);
 585     }
 586     netdev_register_provider(&dummy_class);
 587
 588     if (FREE_BSD) {
 589         netdev_vport_tunnel_register();
 590     }
 591 }