lib/netdev-dummy.c

   1 /*
   2  * Copyright (c) 2010, 2011 Nicira Networks.
   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 "list.h"
  24 #include "netdev-provider.h"
  25 #include "packets.h"
  26 #include "shash.h"
  27 #include "vlog.h"
  28
  29 VLOG_DEFINE_THIS_MODULE(netdev_dummy);
  30
  31 struct netdev_dev_dummy {
  32     struct netdev_dev netdev_dev;
  33     uint8_t hwaddr[ETH_ADDR_LEN];
  34     int mtu;
  35     struct netdev_stats stats;
  36     enum netdev_flags flags;
  37     unsigned int change_seq;
  38 };
  39
  40 struct netdev_dummy {
  41     struct netdev netdev;
  42 };
  43
  44 static int netdev_dummy_create(const struct netdev_class *, const char *,
  45                                struct netdev_dev **);
  46 static void netdev_dummy_poll_notify(const struct netdev *);
  47
  48 static bool
  49 is_dummy_class(const struct netdev_class *class)
  50 {
  51     return class->create == netdev_dummy_create;
  52 }
  53
  54 static struct netdev_dev_dummy *
  55 netdev_dev_dummy_cast(const struct netdev_dev *netdev_dev)
  56 {
  57     assert(is_dummy_class(netdev_dev_get_class(netdev_dev)));
  58     return CONTAINER_OF(netdev_dev, struct netdev_dev_dummy, netdev_dev);
  59 }
  60
  61 static struct netdev_dummy *
  62 netdev_dummy_cast(const struct netdev *netdev)
  63 {
  64     struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
  65     assert(is_dummy_class(netdev_dev_get_class(netdev_dev)));
  66     return CONTAINER_OF(netdev, struct netdev_dummy, netdev);
  67 }
  68
  69 static int
  70 netdev_dummy_create(const struct netdev_class *class, const char *name,
  71                     struct netdev_dev **netdev_devp)
  72 {
  73     static unsigned int n = 0xaa550000;
  74     struct netdev_dev_dummy *netdev_dev;
  75
  76     netdev_dev = xzalloc(sizeof *netdev_dev);
  77     netdev_dev_init(&netdev_dev->netdev_dev, name, class);
  78     netdev_dev->hwaddr[0] = 0xaa;
  79     netdev_dev->hwaddr[1] = 0x55;
  80     netdev_dev->hwaddr[2] = n >> 24;
  81     netdev_dev->hwaddr[3] = n >> 16;
  82     netdev_dev->hwaddr[4] = n >> 8;
  83     netdev_dev->hwaddr[5] = n;
  84     netdev_dev->mtu = 1500;
  85     netdev_dev->flags = 0;
  86     netdev_dev->change_seq = 1;
  87
  88     n++;
  89
  90     *netdev_devp = &netdev_dev->netdev_dev;
  91
  92     return 0;
  93 }
  94
  95 static void
  96 netdev_dummy_destroy(struct netdev_dev *netdev_dev_)
  97 {
  98     struct netdev_dev_dummy *netdev_dev = netdev_dev_dummy_cast(netdev_dev_);
  99
 100     free(netdev_dev);
 101 }
 102
 103 static int
 104 netdev_dummy_open(struct netdev_dev *netdev_dev_, struct netdev **netdevp)
 105 {
 106     struct netdev_dummy *netdev;
 107
 108     netdev = xmalloc(sizeof *netdev);
 109     netdev_init(&netdev->netdev, netdev_dev_);
 110
 111     *netdevp = &netdev->netdev;
 112     return 0;
 113 }
 114
 115 static void
 116 netdev_dummy_close(struct netdev *netdev_)
 117 {
 118     struct netdev_dummy *netdev = netdev_dummy_cast(netdev_);
 119     free(netdev);
 120 }
 121
 122 static int
 123 netdev_dummy_listen(struct netdev *netdev_ OVS_UNUSED)
 124 {
 125     /* It's OK to listen on a dummy device.  It just never receives any
 126      * packets. */
 127     return 0;
 128 }
 129
 130 static int
 131 netdev_dummy_recv(struct netdev *netdev_ OVS_UNUSED,
 132                   void *buffer OVS_UNUSED, size_t size OVS_UNUSED)
 133 {
 134     /* A dummy device never receives any packets. */
 135     return -EAGAIN;
 136 }
 137
 138 static int
 139 netdev_dummy_set_etheraddr(struct netdev *netdev,
 140                            const uint8_t mac[ETH_ADDR_LEN])
 141 {
 142     struct netdev_dev_dummy *dev =
 143         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 144
 145     if (!eth_addr_equals(dev->hwaddr, mac)) {
 146         memcpy(dev->hwaddr, mac, ETH_ADDR_LEN);
 147         netdev_dummy_poll_notify(netdev);
 148     }
 149
 150     return 0;
 151 }
 152
 153 static int
 154 netdev_dummy_get_etheraddr(const struct netdev *netdev,
 155                            uint8_t mac[ETH_ADDR_LEN])
 156 {
 157     const struct netdev_dev_dummy *dev =
 158         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 159
 160     memcpy(mac, dev->hwaddr, ETH_ADDR_LEN);
 161     return 0;
 162 }
 163
 164 static int
 165 netdev_dummy_get_mtu(const struct netdev *netdev, int *mtup)
 166 {
 167     const struct netdev_dev_dummy *dev =
 168         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 169
 170     *mtup = dev->mtu;
 171     return 0;
 172 }
 173
 174 static int
 175 netdev_dummy_set_mtu(const struct netdev *netdev, int mtu)
 176 {
 177     struct netdev_dev_dummy *dev =
 178         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 179
 180     dev->mtu = mtu;
 181     return 0;
 182 }
 183
 184 static int
 185 netdev_dummy_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
 186 {
 187     const struct netdev_dev_dummy *dev =
 188         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 189
 190     *stats = dev->stats;
 191     return 0;
 192 }
 193
 194 static int
 195 netdev_dummy_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
 196 {
 197     struct netdev_dev_dummy *dev =
 198         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 199
 200     dev->stats = *stats;
 201     return 0;
 202 }
 203
 204 static int
 205 netdev_dummy_update_flags(struct netdev *netdev,
 206                           enum netdev_flags off, enum netdev_flags on,
 207                           enum netdev_flags *old_flagsp)
 208 {
 209     struct netdev_dev_dummy *dev =
 210         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 211
 212     if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) {
 213         return EINVAL;
 214     }
 215
 216     *old_flagsp = dev->flags;
 217     dev->flags |= on;
 218     dev->flags &= ~off;
 219     if (*old_flagsp != dev->flags) {
 220         netdev_dummy_poll_notify(netdev);
 221     }
 222     return 0;
 223 }
 224
 225 static unsigned int
 226 netdev_dummy_change_seq(const struct netdev *netdev)
 227 {
 228     return netdev_dev_dummy_cast(netdev_get_dev(netdev))->change_seq;
 229 }
 230 \f
 231 /* Helper functions. */
 232
 233 static void
 234 netdev_dummy_poll_notify(const struct netdev *netdev)
 235 {
 236     struct netdev_dev_dummy *dev =
 237         netdev_dev_dummy_cast(netdev_get_dev(netdev));
 238
 239     dev->change_seq++;
 240     if (!dev->change_seq) {
 241         dev->change_seq++;
 242     }
 243 }
 244
 245 static const struct netdev_class dummy_class = {
 246     "dummy",
 247     NULL,                       /* init */
 248     NULL,                       /* run */
 249     NULL,                       /* wait */
 250
 251     netdev_dummy_create,
 252     netdev_dummy_destroy,
 253     NULL,                       /* get_config */
 254     NULL,                       /* set_config */
 255
 256     netdev_dummy_open,
 257     netdev_dummy_close,
 258
 259     netdev_dummy_listen,        /* listen */
 260     netdev_dummy_recv,          /* recv */
 261     NULL,                       /* recv_wait */
 262     NULL,                       /* drain */
 263
 264     NULL,                       /* send */
 265     NULL,                       /* send_wait */
 266
 267     netdev_dummy_set_etheraddr,
 268     netdev_dummy_get_etheraddr,
 269     netdev_dummy_get_mtu,
 270     netdev_dummy_set_mtu,
 271     NULL,                       /* get_ifindex */
 272     NULL,                       /* get_carrier */
 273     NULL,                       /* get_carrier_resets */
 274     NULL,                       /* get_miimon */
 275     netdev_dummy_get_stats,
 276     netdev_dummy_set_stats,
 277
 278     NULL,                       /* get_features */
 279     NULL,                       /* set_advertisements */
 280
 281     NULL,                       /* set_policing */
 282     NULL,                       /* get_qos_types */
 283     NULL,                       /* get_qos_capabilities */
 284     NULL,                       /* get_qos */
 285     NULL,                       /* set_qos */
 286     NULL,                       /* get_queue */
 287     NULL,                       /* set_queue */
 288     NULL,                       /* delete_queue */
 289     NULL,                       /* get_queue_stats */
 290     NULL,                       /* dump_queues */
 291     NULL,                       /* dump_queue_stats */
 292
 293     NULL,                       /* get_in4 */
 294     NULL,                       /* set_in4 */
 295     NULL,                       /* get_in6 */
 296     NULL,                       /* add_router */
 297     NULL,                       /* get_next_hop */
 298     NULL,                       /* get_status */
 299     NULL,                       /* arp_lookup */
 300
 301     netdev_dummy_update_flags,
 302
 303     netdev_dummy_change_seq
 304 };
 305
 306 void
 307 netdev_dummy_register(void)
 308 {
 309     netdev_register_provider(&dummy_class);
 310 }