lib/netdev.c

   1 /*
   2  * Copyright (c) 2008, 2009 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 #include "netdev.h"
  19
  20 #include <assert.h>
  21 #include <errno.h>
  22 #include <inttypes.h>
  23 #include <netinet/in.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <unistd.h>
  27
  28 #include "coverage.h"
  29 #include "dynamic-string.h"
  30 #include "fatal-signal.h"
  31 #include "list.h"
  32 #include "netdev-provider.h"
  33 #include "ofpbuf.h"
  34 #include "packets.h"
  35 #include "poll-loop.h"
  36 #include "shash.h"
  37 #include "svec.h"
  38
  39 #define THIS_MODULE VLM_netdev
  40 #include "vlog.h"
  41
  42 static const struct netdev_class *netdev_classes[] = {
  43     &netdev_linux_class,
  44     &netdev_tap_class,
  45     &netdev_gre_class,
  46 };
  47 static int n_netdev_classes = ARRAY_SIZE(netdev_classes);
  48
  49 /* All created network devices. */
  50 static struct shash netdev_obj_shash = SHASH_INITIALIZER(&netdev_obj_shash);
  51
  52 /* All open network devices. */
  53 static struct list netdev_list = LIST_INITIALIZER(&netdev_list);
  54
  55 /* This is set pretty low because we probably won't learn anything from the
  56  * additional log messages. */
  57 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
  58
  59 static void restore_all_flags(void *aux);
  60 static int restore_flags(struct netdev *netdev);
  61
  62 /* Attempts to initialize the netdev module.  Returns 0 if successful,
  63  * otherwise a positive errno value.
  64  *
  65  * Calling this function is optional.  If not called explicitly, it will
  66  * automatically be called upon the first attempt to open or create a
  67  * network device. */
  68 int
  69 netdev_initialize(void)
  70 {
  71     static int status = -1;
  72     if (status < 0) {
  73         int i, j;
  74
  75         fatal_signal_add_hook(restore_all_flags, NULL, true);
  76
  77         status = 0;
  78         for (i = j = 0; i < n_netdev_classes; i++) {
  79             const struct netdev_class *class = netdev_classes[i];
  80             if (class->init) {
  81                 int retval = class->init();
  82                 if (!retval) {
  83                     netdev_classes[j++] = class;
  84                 } else {
  85                     VLOG_ERR("failed to initialize %s network device "
  86                              "class: %s", class->type, strerror(retval));
  87                     if (!status) {
  88                         status = retval;
  89                     }
  90                 }
  91             } else {
  92                 netdev_classes[j++] = class;
  93             }
  94         }
  95         n_netdev_classes = j;
  96     }
  97     return status;
  98 }
  99
 100 /* Performs periodic work needed by all the various kinds of netdevs.
 101  *
 102  * If your program opens any netdevs, it must call this function within its
 103  * main poll loop. */
 104 void
 105 netdev_run(void)
 106 {
 107     int i;
 108     for (i = 0; i < n_netdev_classes; i++) {
 109         const struct netdev_class *class = netdev_classes[i];
 110         if (class->run) {
 111             class->run();
 112         }
 113     }
 114 }
 115
 116 /* Arranges for poll_block() to wake up when netdev_run() needs to be called.
 117  *
 118  * If your program opens any netdevs, it must call this function within its
 119  * main poll loop. */
 120 void
 121 netdev_wait(void)
 122 {
 123     int i;
 124     for (i = 0; i < n_netdev_classes; i++) {
 125         const struct netdev_class *class = netdev_classes[i];
 126         if (class->wait) {
 127             class->wait();
 128         }
 129     }
 130 }
 131
 132 /* Attempts to create a network device object of 'type' with 'name'.  'type'
 133  * corresponds to the 'type' field used in the netdev_class * structure.
 134  * Arguments for creation are provided in 'args', which may be empty or NULL
 135  * if none are needed. */
 136 int
 137 netdev_create(const char *name, const char *type, const struct shash *args)
 138 {
 139     struct shash empty_args = SHASH_INITIALIZER(&empty_args);
 140     int i;
 141
 142     netdev_initialize();
 143
 144     if (!args) {
 145         args = &empty_args;
 146     }
 147
 148     if (shash_find(&netdev_obj_shash, name)) {
 149         VLOG_WARN("attempted to create a netdev object with bound name: %s",
 150                 name);
 151         return EEXIST;
 152     }
 153
 154     for (i = 0; i < n_netdev_classes; i++) {
 155         const struct netdev_class *class = netdev_classes[i];
 156         if (!strcmp(type, class->type)) {
 157             return class->create(name, type, args, true);
 158         }
 159     }
 160
 161     VLOG_WARN("could not create netdev object of unknown type: %s", type);
 162
 163     return EINVAL;
 164 }
 165
 166 /* Destroys netdev object 'name'.  Netdev objects maintain a reference count
 167  * which is incremented on netdev_open() and decremented on netdev_close().
 168  * If 'name' has a non-zero reference count, it will not destroy the object
 169  * and return EBUSY. */
 170 int
 171 netdev_destroy(const char *name)
 172 {
 173     struct shash_node *node;
 174     struct netdev_obj *netdev_obj;
 175
 176     node = shash_find(&netdev_obj_shash, name);
 177     if (!node) {
 178         return ENODEV;
 179     }
 180
 181     netdev_obj = node->data;
 182     if (netdev_obj->ref_cnt != 0) {
 183         VLOG_WARN("attempt to destroy netdev object with %d open handles: %s",
 184                 netdev_obj->ref_cnt, name);
 185 #if 0  /* Temp hack */
 186         return EBUSY;
 187 #endif
 188     }
 189
 190     shash_delete(&netdev_obj_shash, node);
 191     netdev_obj->class->destroy(netdev_obj);
 192
 193     return 0;
 194 }
 195
 196 /* Reconfigures the device object 'name' with 'args'.  'args' may be empty
 197  * or NULL if none are needed. */
 198 int
 199 netdev_reconfigure(const char *name, const struct shash *args)
 200 {
 201     struct shash empty_args = SHASH_INITIALIZER(&empty_args);
 202     struct netdev_obj *netdev_obj;
 203
 204     if (!args) {
 205         args = &empty_args;
 206     }
 207
 208     netdev_obj = shash_find_data(&netdev_obj_shash, name);
 209     if (!netdev_obj) {
 210         return ENODEV;
 211     }
 212
 213     if (netdev_obj->class->reconfigure) {
 214         return netdev_obj->class->reconfigure(netdev_obj, args);
 215     }
 216
 217     return 0;
 218 }
 219
 220 /* Opens the network device named 'name' (e.g. "eth0") and returns zero if
 221  * successful, otherwise a positive errno value.  On success, sets '*netdevp'
 222  * to the new network device, otherwise to null.
 223  *
 224  * 'ethertype' may be a 16-bit Ethernet protocol value in host byte order to
 225  * capture frames of that type received on the device.  It may also be one of
 226  * the 'enum netdev_pseudo_ethertype' values to receive frames in one of those
 227  * categories. */
 228 int
 229 netdev_open(const char *name, int ethertype, struct netdev **netdevp)
 230 {
 231     struct netdev_obj *netdev_obj;
 232     struct netdev *netdev = NULL;
 233     int error;
 234     int i;
 235
 236     netdev_initialize();
 237
 238     netdev_obj = shash_find_data(&netdev_obj_shash, name);
 239     if (netdev_obj) {
 240         error = netdev_obj->class->open(name, ethertype, &netdev);
 241     } else {
 242         /* Default to "system". */
 243         error = EAFNOSUPPORT;
 244         for (i = 0; i < n_netdev_classes; i++) {
 245             const struct netdev_class *class = netdev_classes[i];
 246             if (!strcmp(class->type, "system")) {
 247                 struct shash empty_args = SHASH_INITIALIZER(&empty_args);
 248
 249                 /* Dynamically create the netdev object, but indicate
 250                  * that it should be destroyed when the the last user
 251                  * closes its handle. */
 252                 error = class->create(name, "system", &empty_args, false);
 253                 if (!error) {
 254                     error = class->open(name, ethertype, &netdev);
 255                     netdev_obj = shash_find_data(&netdev_obj_shash, name);
 256                 }
 257                 break;
 258             }
 259         }
 260     }
 261     if (!error) {
 262         netdev_obj->ref_cnt++;
 263     }
 264
 265     *netdevp = error ? NULL : netdev;
 266     return error;
 267 }
 268
 269 /* Closes and destroys 'netdev'. */
 270 void
 271 netdev_close(struct netdev *netdev)
 272 {
 273     if (netdev) {
 274         struct netdev_obj *netdev_obj;
 275         char *name = netdev->name;
 276         int error;
 277
 278         netdev_obj = shash_find_data(&netdev_obj_shash, name);
 279 #if 0
 280         assert(netdev_obj);
 281 #else
 282         if (netdev_obj) {
 283 #endif
 284         if (netdev_obj->ref_cnt > 0) {
 285             netdev_obj->ref_cnt--;
 286         } else {
 287             VLOG_WARN("netdev %s closed too many times", name);
 288         }
 289
 290         /* If the reference count for the netdev object is zero, and it
 291          * was dynamically created by netdev_open(), destroy it. */
 292         if (!netdev_obj->ref_cnt && !netdev_obj->created) {
 293             netdev_destroy(name);
 294         }
 295 #if 1
 296         }
 297 #endif
 298
 299         /* Restore flags that we changed, if any. */
 300         error = restore_flags(netdev);
 301         list_remove(&netdev->node);
 302         if (error) {
 303             VLOG_WARN("failed to restore network device flags on %s: %s",
 304                       name, strerror(error));
 305         }
 306
 307         /* Free. */
 308         netdev->class->close(netdev);
 309         free(name);
 310     }
 311 }
 312
 313 /* Returns true if a network device named 'name' exists and may be opened,
 314  * otherwise false. */
 315 bool
 316 netdev_exists(const char *name)
 317 {
 318     struct netdev *netdev;
 319     int error;
 320
 321     error = netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev);
 322     if (!error) {
 323         netdev_close(netdev);
 324         return true;
 325     } else {
 326         if (error != ENODEV) {
 327             VLOG_WARN("failed to open network device %s: %s",
 328                       name, strerror(error));
 329         }
 330         return false;
 331     }
 332 }
 333
 334 /* Initializes 'svec' with a list of the names of all known network devices. */
 335 int
 336 netdev_enumerate(struct svec *svec)
 337 {
 338     int error;
 339     int i;
 340
 341     svec_init(svec);
 342
 343     netdev_initialize();
 344
 345     error = 0;
 346     for (i = 0; i < n_netdev_classes; i++) {
 347         const struct netdev_class *class = netdev_classes[i];
 348         if (class->enumerate) {
 349             int retval = class->enumerate(svec);
 350             if (retval) {
 351                 VLOG_WARN("failed to enumerate %s network devices: %s",
 352                           class->type, strerror(retval));
 353                 if (!error) {
 354                     error = retval;
 355                 }
 356             }
 357         }
 358     }
 359     return error;
 360 }
 361
 362 /* Attempts to receive a packet from 'netdev' into 'buffer', which the caller
 363  * must have initialized with sufficient room for the packet.  The space
 364  * required to receive any packet is ETH_HEADER_LEN bytes, plus VLAN_HEADER_LEN
 365  * bytes, plus the device's MTU (which may be retrieved via netdev_get_mtu()).
 366  * (Some devices do not allow for a VLAN header, in which case VLAN_HEADER_LEN
 367  * need not be included.)
 368  *
 369  * If a packet is successfully retrieved, returns 0.  In this case 'buffer' is
 370  * guaranteed to contain at least ETH_TOTAL_MIN bytes.  Otherwise, returns a
 371  * positive errno value.  Returns EAGAIN immediately if no packet is ready to
 372  * be returned.
 373  */
 374 int
 375 netdev_recv(struct netdev *netdev, struct ofpbuf *buffer)
 376 {
 377     int retval;
 378
 379     assert(buffer->size == 0);
 380     assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
 381
 382     retval = netdev->class->recv(netdev,
 383                                  buffer->data, ofpbuf_tailroom(buffer));
 384     if (retval >= 0) {
 385         COVERAGE_INC(netdev_received);
 386         buffer->size += retval;
 387         if (buffer->size < ETH_TOTAL_MIN) {
 388             ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
 389         }
 390         return 0;
 391     } else {
 392         return -retval;
 393     }
 394 }
 395
 396 /* Registers with the poll loop to wake up from the next call to poll_block()
 397  * when a packet is ready to be received with netdev_recv() on 'netdev'. */
 398 void
 399 netdev_recv_wait(struct netdev *netdev)
 400 {
 401     netdev->class->recv_wait(netdev);
 402 }
 403
 404 /* Discards all packets waiting to be received from 'netdev'. */
 405 int
 406 netdev_drain(struct netdev *netdev)
 407 {
 408     return netdev->class->drain(netdev);
 409 }
 410
 411 /* Sends 'buffer' on 'netdev'.  Returns 0 if successful, otherwise a positive
 412  * errno value.  Returns EAGAIN without blocking if the packet cannot be queued
 413  * immediately.  Returns EMSGSIZE if a partial packet was transmitted or if
 414  * the packet is too big or too small to transmit on the device.
 415  *
 416  * The caller retains ownership of 'buffer' in all cases.
 417  *
 418  * The kernel maintains a packet transmission queue, so the caller is not
 419  * expected to do additional queuing of packets. */
 420 int
 421 netdev_send(struct netdev *netdev, const struct ofpbuf *buffer)
 422 {
 423     int error = netdev->class->send(netdev, buffer->data, buffer->size);
 424     if (!error) {
 425         COVERAGE_INC(netdev_sent);
 426     }
 427     return error;
 428 }
 429
 430 /* Registers with the poll loop to wake up from the next call to poll_block()
 431  * when the packet transmission queue has sufficient room to transmit a packet
 432  * with netdev_send().
 433  *
 434  * The kernel maintains a packet transmission queue, so the client is not
 435  * expected to do additional queuing of packets.  Thus, this function is
 436  * unlikely to ever be used.  It is included for completeness. */
 437 void
 438 netdev_send_wait(struct netdev *netdev)
 439 {
 440     return netdev->class->send_wait(netdev);
 441 }
 442
 443 /* Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
 444  * otherwise a positive errno value. */
 445 int
 446 netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN])
 447 {
 448     return netdev->class->set_etheraddr(netdev, mac);
 449 }
 450
 451 /* Retrieves 'netdev''s MAC address.  If successful, returns 0 and copies the
 452  * the MAC address into 'mac'.  On failure, returns a positive errno value and
 453  * clears 'mac' to all-zeros. */
 454 int
 455 netdev_get_etheraddr(const struct netdev *netdev, uint8_t mac[ETH_ADDR_LEN])
 456 {
 457     return netdev->class->get_etheraddr(netdev, mac);
 458 }
 459
 460 /* Returns the name of the network device that 'netdev' represents,
 461  * e.g. "eth0".  The caller must not modify or free the returned string. */
 462 const char *
 463 netdev_get_name(const struct netdev *netdev)
 464 {
 465     return netdev->name;
 466 }
 467
 468 /* Retrieves the MTU of 'netdev'.  The MTU is the maximum size of transmitted
 469  * (and received) packets, in bytes, not including the hardware header; thus,
 470  * this is typically 1500 bytes for Ethernet devices.
 471  *
 472  * If successful, returns 0 and stores the MTU size in '*mtup'.  On failure,
 473  * returns a positive errno value and stores ETH_PAYLOAD_MAX (1500) in
 474  * '*mtup'. */
 475 int
 476 netdev_get_mtu(const struct netdev *netdev, int *mtup)
 477 {
 478     int error = netdev->class->get_mtu(netdev, mtup);
 479     if (error) {
 480         VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: %s",
 481                      netdev_get_name(netdev), strerror(error));
 482         *mtup = ETH_PAYLOAD_MAX;
 483     }
 484     return error;
 485 }
 486
 487 /* Returns the ifindex of 'netdev', if successful, as a positive number.  On
 488  * failure, returns a negative errno value.
 489  *
 490  * The desired semantics of the ifindex value are a combination of those
 491  * specified by POSIX for if_nametoindex() and by SNMP for ifIndex.  An ifindex
 492  * value should be unique within a host and remain stable at least until
 493  * reboot.  SNMP says an ifindex "ranges between 1 and the value of ifNumber"
 494  * but many systems do not follow this rule anyhow.
 495  */
 496 int
 497 netdev_get_ifindex(const struct netdev *netdev)
 498 {
 499     return netdev->class->get_ifindex(netdev);
 500 }
 501
 502 /* Stores the features supported by 'netdev' into each of '*current',
 503  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
 504  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
 505  * successful, otherwise a positive errno value.  On failure, all of the
 506  * passed-in values are set to 0. */
 507 int
 508 netdev_get_features(struct netdev *netdev,
 509                     uint32_t *current, uint32_t *advertised,
 510                     uint32_t *supported, uint32_t *peer)
 511 {
 512     uint32_t dummy[4];
 513     int error;
 514
 515     if (!current) {
 516         current = &dummy[0];
 517     }
 518     if (!advertised) {
 519         advertised = &dummy[1];
 520     }
 521     if (!supported) {
 522         supported = &dummy[2];
 523     }
 524     if (!peer) {
 525         peer = &dummy[3];
 526     }
 527
 528     error = netdev->class->get_features(netdev, current, advertised, supported,
 529                                         peer);
 530     if (error) {
 531         *current = *advertised = *supported = *peer = 0;
 532     }
 533     return error;
 534 }
 535
 536 /* Set the features advertised by 'netdev' to 'advertise'.  Returns 0 if
 537  * successful, otherwise a positive errno value. */
 538 int
 539 netdev_set_advertisements(struct netdev *netdev, uint32_t advertise)
 540 {
 541     return (netdev->class->set_advertisements
 542             ? netdev->class->set_advertisements(netdev, advertise)
 543             : EOPNOTSUPP);
 544 }
 545
 546 /* If 'netdev' has an assigned IPv4 address, sets '*address' to that address
 547  * and '*netmask' to its netmask and returns 0.  Otherwise, returns a positive
 548  * errno value and sets '*address' to 0 (INADDR_ANY).
 549  *
 550  * The following error values have well-defined meanings:
 551  *
 552  *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address.
 553  *
 554  *   - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
 555  *
 556  * 'address' or 'netmask' or both may be null, in which case the address or netmask
 557  * is not reported. */
 558 int
 559 netdev_get_in4(const struct netdev *netdev,
 560                struct in_addr *address_, struct in_addr *netmask_)
 561 {
 562     struct in_addr address;
 563     struct in_addr netmask;
 564     int error;
 565
 566     error = (netdev->class->get_in4
 567              ? netdev->class->get_in4(netdev, &address, &netmask)
 568              : EOPNOTSUPP);
 569     if (address_) {
 570         address_->s_addr = error ? 0 : address.s_addr;
 571     }
 572     if (netmask_) {
 573         netmask_->s_addr = error ? 0 : netmask.s_addr;
 574     }
 575     return error;
 576 }
 577
 578 /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
 579  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
 580  * positive errno value. */
 581 int
 582 netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask)
 583 {
 584     return (netdev->class->set_in4
 585             ? netdev->class->set_in4(netdev, addr, mask)
 586             : EOPNOTSUPP);
 587 }
 588
 589 /* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds
 590  * to 'netdev'. */
 591 int
 592 netdev_add_router(struct netdev *netdev, struct in_addr router)
 593 {
 594     COVERAGE_INC(netdev_add_router);
 595     return (netdev->class->add_router
 596             ? netdev->class->add_router(netdev, router)
 597             : EOPNOTSUPP);
 598 }
 599
 600 /* Looks up the next hop for 'host' for the TCP/IP stack that corresponds to
 601  * 'netdev'.  If a route cannot not be determined, sets '*next_hop' to 0,
 602  * '*netdev_name' to null, and returns a positive errno value.  Otherwise, if a
 603  * next hop is found, stores the next hop gateway's address (0 if 'host' is on
 604  * a directly connected network) in '*next_hop' and a copy of the name of the
 605  * device to reach 'host' in '*netdev_name', and returns 0.  The caller is
 606  * responsible for freeing '*netdev_name' (by calling free()). */
 607 int
 608 netdev_get_next_hop(const struct netdev *netdev,
 609                     const struct in_addr *host, struct in_addr *next_hop,
 610                     char **netdev_name)
 611 {
 612     int error = (netdev->class->get_next_hop
 613                  ? netdev->class->get_next_hop(host, next_hop, netdev_name)
 614                  : EOPNOTSUPP);
 615     if (error) {
 616         next_hop->s_addr = 0;
 617         *netdev_name = NULL;
 618     }
 619     return error;
 620 }
 621
 622 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address and
 623  * returns 0.  Otherwise, returns a positive errno value and sets '*in6' to
 624  * all-zero-bits (in6addr_any).
 625  *
 626  * The following error values have well-defined meanings:
 627  *
 628  *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address.
 629  *
 630  *   - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'.
 631  *
 632  * 'in6' may be null, in which case the address itself is not reported. */
 633 int
 634 netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6)
 635 {
 636     struct in6_addr dummy;
 637     int error;
 638
 639     error = (netdev->class->get_in6
 640              ? netdev->class->get_in6(netdev, in6 ? in6 : &dummy)
 641              : EOPNOTSUPP);
 642     if (error && in6) {
 643         memset(in6, 0, sizeof *in6);
 644     }
 645     return error;
 646 }
 647
 648 /* On 'netdev', turns off the flags in 'off' and then turns on the flags in
 649  * 'on'.  If 'permanent' is true, the changes will persist; otherwise, they
 650  * will be reverted when 'netdev' is closed or the program exits.  Returns 0 if
 651  * successful, otherwise a positive errno value. */
 652 static int
 653 do_update_flags(struct netdev *netdev, enum netdev_flags off,
 654                 enum netdev_flags on, enum netdev_flags *old_flagsp,
 655                 bool permanent)
 656 {
 657     enum netdev_flags old_flags;
 658     int error;
 659
 660     error = netdev->class->update_flags(netdev, off & ~on, on, &old_flags);
 661     if (error) {
 662         VLOG_WARN_RL(&rl, "failed to %s flags for network device %s: %s",
 663                      off || on ? "set" : "get", netdev_get_name(netdev),
 664                      strerror(error));
 665         old_flags = 0;
 666     } else if ((off || on) && !permanent) {
 667         enum netdev_flags new_flags = (old_flags & ~off) | on;
 668         enum netdev_flags changed_flags = old_flags ^ new_flags;
 669         if (changed_flags) {
 670             if (!netdev->changed_flags) {
 671                 netdev->save_flags = old_flags;
 672             }
 673             netdev->changed_flags |= changed_flags;
 674         }
 675     }
 676     if (old_flagsp) {
 677         *old_flagsp = old_flags;
 678     }
 679     return error;
 680 }
 681
 682 /* Obtains the current flags for 'netdev' and stores them into '*flagsp'.
 683  * Returns 0 if successful, otherwise a positive errno value.  On failure,
 684  * stores 0 into '*flagsp'. */
 685 int
 686 netdev_get_flags(const struct netdev *netdev_, enum netdev_flags *flagsp)
 687 {
 688     struct netdev *netdev = (struct netdev *) netdev_;
 689     return do_update_flags(netdev, 0, 0, flagsp, false);
 690 }
 691
 692 /* Sets the flags for 'netdev' to 'flags'.
 693  * If 'permanent' is true, the changes will persist; otherwise, they
 694  * will be reverted when 'netdev' is closed or the program exits.
 695  * Returns 0 if successful, otherwise a positive errno value. */
 696 int
 697 netdev_set_flags(struct netdev *netdev, enum netdev_flags flags,
 698                  bool permanent)
 699 {
 700     return do_update_flags(netdev, -1, flags, NULL, permanent);
 701 }
 702
 703 /* Turns on the specified 'flags' on 'netdev'.
 704  * If 'permanent' is true, the changes will persist; otherwise, they
 705  * will be reverted when 'netdev' is closed or the program exits.
 706  * Returns 0 if successful, otherwise a positive errno value. */
 707 int
 708 netdev_turn_flags_on(struct netdev *netdev, enum netdev_flags flags,
 709                      bool permanent)
 710 {
 711     return do_update_flags(netdev, 0, flags, NULL, permanent);
 712 }
 713
 714 /* Turns off the specified 'flags' on 'netdev'.
 715  * If 'permanent' is true, the changes will persist; otherwise, they
 716  * will be reverted when 'netdev' is closed or the program exits.
 717  * Returns 0 if successful, otherwise a positive errno value. */
 718 int
 719 netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
 720                       bool permanent)
 721 {
 722     return do_update_flags(netdev, flags, 0, NULL, permanent);
 723 }
 724
 725 /* Looks up the ARP table entry for 'ip' on 'netdev'.  If one exists and can be
 726  * successfully retrieved, it stores the corresponding MAC address in 'mac' and
 727  * returns 0.  Otherwise, it returns a positive errno value; in particular,
 728  * ENXIO indicates that there is no ARP table entry for 'ip' on 'netdev'. */
 729 int
 730 netdev_arp_lookup(const struct netdev *netdev,
 731                   uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
 732 {
 733     int error = (netdev->class->arp_lookup
 734                  ? netdev->class->arp_lookup(netdev, ip, mac)
 735                  : EOPNOTSUPP);
 736     if (error) {
 737         memset(mac, 0, ETH_ADDR_LEN);
 738     }
 739     return error;
 740 }
 741
 742 /* Sets 'carrier' to true if carrier is active (link light is on) on
 743  * 'netdev'. */
 744 int
 745 netdev_get_carrier(const struct netdev *netdev, bool *carrier)
 746 {
 747     int error = (netdev->class->get_carrier
 748                  ? netdev->class->get_carrier(netdev, carrier)
 749                  : EOPNOTSUPP);
 750     if (error) {
 751         *carrier = false;
 752     }
 753     return error;
 754 }
 755
 756 /* Retrieves current device stats for 'netdev'. */
 757 int
 758 netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
 759 {
 760     int error;
 761
 762     COVERAGE_INC(netdev_get_stats);
 763     error = (netdev->class->get_stats
 764              ? netdev->class->get_stats(netdev, stats)
 765              : EOPNOTSUPP);
 766     if (error) {
 767         memset(stats, 0xff, sizeof *stats);
 768     }
 769     return error;
 770 }
 771
 772 /* Attempts to set input rate limiting (policing) policy, such that up to
 773  * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative burst
 774  * size of 'kbits' kb. */
 775 int
 776 netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate,
 777                     uint32_t kbits_burst)
 778 {
 779     return (netdev->class->set_policing
 780             ? netdev->class->set_policing(netdev, kbits_rate, kbits_burst)
 781             : EOPNOTSUPP);
 782 }
 783
 784 /* If 'netdev' is a VLAN network device (e.g. one created with vconfig(8)),
 785  * sets '*vlan_vid' to the VLAN VID associated with that device and returns 0.
 786  * Otherwise returns a errno value (specifically ENOENT if 'netdev_name' is the
 787  * name of a network device that is not a VLAN device) and sets '*vlan_vid' to
 788  * -1. */
 789 int
 790 netdev_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
 791 {
 792     int error = (netdev->class->get_vlan_vid
 793                  ? netdev->class->get_vlan_vid(netdev, vlan_vid)
 794                  : ENOENT);
 795     if (error) {
 796         *vlan_vid = 0;
 797     }
 798     return error;
 799 }
 800
 801 /* Returns a network device that has 'in4' as its IP address, if one exists,
 802  * otherwise a null pointer. */
 803 struct netdev *
 804 netdev_find_dev_by_in4(const struct in_addr *in4)
 805 {
 806     struct netdev *netdev;
 807     struct svec dev_list;
 808     size_t i;
 809
 810     netdev_enumerate(&dev_list);
 811     for (i = 0; i < dev_list.n; i++) {
 812         const char *name = dev_list.names[i];
 813         struct in_addr dev_in4;
 814
 815         if (!netdev_open(name, NETDEV_ETH_TYPE_NONE, &netdev)
 816             && !netdev_get_in4(netdev, &dev_in4, NULL)
 817             && dev_in4.s_addr == in4->s_addr) {
 818             goto exit;
 819         }
 820         netdev_close(netdev);
 821     }
 822     netdev = NULL;
 823
 824 exit:
 825     svec_destroy(&dev_list);
 826     return netdev;
 827 }
 828 \f
 829 /* Initializes 'netdev_obj' as a netdev object named 'name' of the
 830  * specified 'class'.
 831  *
 832  * This function adds 'netdev_obj' to a netdev-owned shash, so it is
 833  * very important that 'netdev_obj' only be freed after calling
 834  * netdev_destroy().  */
 835 void
 836 netdev_obj_init(struct netdev_obj *netdev_obj, const char *name,
 837                 const struct netdev_class *class, bool created)
 838 {
 839     assert(!shash_find(&netdev_obj_shash, name));
 840
 841     netdev_obj->class = class;
 842     netdev_obj->ref_cnt = 0;
 843     netdev_obj->created = created;
 844     netdev_obj->name = xstrdup(name);
 845     shash_add(&netdev_obj_shash, name, netdev_obj);
 846 }
 847
 848 /* Returns the class type of 'netdev_obj'.
 849  *
 850  * The caller must not free the returned value. */
 851 const char *netdev_obj_get_type(const struct netdev_obj *netdev_obj)
 852 {
 853     return netdev_obj->class->type;
 854 }
 855
 856 /* Returns the name of 'netdev_obj'.
 857  *
 858  * The caller must not free the returned value. */
 859 const char *netdev_obj_get_name(const struct netdev_obj *netdev_obj)
 860 {
 861     return netdev_obj->name;
 862 }
 863
 864 /* Initializes 'netdev' as a netdev named 'name' of the specified 'class'.
 865  *
 866  * This function adds 'netdev' to a netdev-owned linked list, so it is very
 867  * important that 'netdev' only be freed after calling netdev_close(). */
 868 void
 869 netdev_init(struct netdev *netdev, const char *name,
 870             const struct netdev_class *class)
 871 {
 872     netdev->class = class;
 873     netdev->name = xstrdup(name);
 874     netdev->save_flags = 0;
 875     netdev->changed_flags = 0;
 876     list_push_back(&netdev_list, &netdev->node);
 877 }
 878
 879 /* Returns the class type of 'netdev'.
 880  *
 881  * The caller must not free the returned value. */
 882 const char *netdev_get_type(const struct netdev *netdev)
 883 {
 884     return netdev->class->type;
 885 }
 886
 887 /* Initializes 'notifier' as a netdev notifier for 'netdev', for which
 888  * notification will consist of calling 'cb', with auxiliary data 'aux'. */
 889 void
 890 netdev_notifier_init(struct netdev_notifier *notifier, struct netdev *netdev,
 891                      void (*cb)(struct netdev_notifier *), void *aux)
 892 {
 893     notifier->netdev = netdev;
 894     notifier->cb = cb;
 895     notifier->aux = aux;
 896 }
 897 \f
 898 /* Tracks changes in the status of a set of network devices. */
 899 struct netdev_monitor {
 900     struct shash polled_netdevs;
 901     struct shash changed_netdevs;
 902 };
 903
 904 /* Creates and returns a new structure for monitor changes in the status of
 905  * network devices. */
 906 struct netdev_monitor *
 907 netdev_monitor_create(void)
 908 {
 909     struct netdev_monitor *monitor = xmalloc(sizeof *monitor);
 910     shash_init(&monitor->polled_netdevs);
 911     shash_init(&monitor->changed_netdevs);
 912     return monitor;
 913 }
 914
 915 /* Destroys 'monitor'. */
 916 void
 917 netdev_monitor_destroy(struct netdev_monitor *monitor)
 918 {
 919     if (monitor) {
 920         struct shash_node *node;
 921
 922         SHASH_FOR_EACH (node, &monitor->polled_netdevs) {
 923             struct netdev_notifier *notifier = node->data;
 924             notifier->netdev->class->poll_remove(notifier);
 925         }
 926
 927         shash_destroy(&monitor->polled_netdevs);
 928         shash_destroy(&monitor->changed_netdevs);
 929         free(monitor);
 930     }
 931 }
 932
 933 static void
 934 netdev_monitor_cb(struct netdev_notifier *notifier)
 935 {
 936     struct netdev_monitor *monitor = notifier->aux;
 937     const char *name = netdev_get_name(notifier->netdev);
 938     if (!shash_find(&monitor->changed_netdevs, name)) {
 939         shash_add(&monitor->changed_netdevs, name, NULL);
 940     }
 941 }
 942
 943 /* Attempts to add 'netdev' as a netdev monitored by 'monitor'.  Returns 0 if
 944  * successful, otherwise a positive errno value.
 945  *
 946  * Adding a given 'netdev' to a monitor multiple times is equivalent to adding
 947  * it once. */
 948 int
 949 netdev_monitor_add(struct netdev_monitor *monitor, struct netdev *netdev)
 950 {
 951     const char *netdev_name = netdev_get_name(netdev);
 952     int error = 0;
 953     if (!shash_find(&monitor->polled_netdevs, netdev_name)
 954         && netdev->class->poll_add)
 955     {
 956         struct netdev_notifier *notifier;
 957         error = netdev->class->poll_add(netdev, netdev_monitor_cb, monitor,
 958                                         &notifier);
 959         if (!error) {
 960             assert(notifier->netdev == netdev);
 961             shash_add(&monitor->polled_netdevs, netdev_name, notifier);
 962         }
 963     }
 964     return error;
 965 }
 966
 967 /* Removes 'netdev' from the set of netdevs monitored by 'monitor'.  (This has
 968  * no effect if 'netdev' is not in the set of devices monitored by
 969  * 'monitor'.) */
 970 void
 971 netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev)
 972 {
 973     const char *netdev_name = netdev_get_name(netdev);
 974     struct shash_node *node;
 975
 976     node = shash_find(&monitor->polled_netdevs, netdev_name);
 977     if (node) {
 978         /* Cancel future notifications. */
 979         struct netdev_notifier *notifier = node->data;
 980         netdev->class->poll_remove(notifier);
 981         shash_delete(&monitor->polled_netdevs, node);
 982
 983         /* Drop any pending notification. */
 984         node = shash_find(&monitor->changed_netdevs, netdev_name);
 985         if (node) {
 986             shash_delete(&monitor->changed_netdevs, node);
 987         }
 988     }
 989 }
 990
 991 /* Checks for changes to netdevs in the set monitored by 'monitor'.  If any of
 992  * the attributes (Ethernet address, carrier status, speed or peer-advertised
 993  * speed, flags, etc.) of a network device monitored by 'monitor' has changed,
 994  * sets '*devnamep' to the name of a device that has changed and returns 0.
 995  * The caller is responsible for freeing '*devnamep' (with free()).
 996  *
 997  * If no devices have changed, sets '*devnamep' to NULL and returns EAGAIN.
 998  */
 999 int
1000 netdev_monitor_poll(struct netdev_monitor *monitor, char **devnamep)
1001 {
1002     struct shash_node *node = shash_first(&monitor->changed_netdevs);
1003     if (!node) {
1004         *devnamep = NULL;
1005         return EAGAIN;
1006     } else {
1007         *devnamep = xstrdup(node->name);
1008         shash_delete(&monitor->changed_netdevs, node);
1009         return 0;
1010     }
1011 }
1012
1013 /* Registers with the poll loop to wake up from the next call to poll_block()
1014  * when netdev_monitor_poll(monitor) would indicate that a device has
1015  * changed. */
1016 void
1017 netdev_monitor_poll_wait(const struct netdev_monitor *monitor)
1018 {
1019     if (!shash_is_empty(&monitor->changed_netdevs)) {
1020         poll_immediate_wake();
1021     } else {
1022         /* XXX Nothing needed here for netdev_linux, but maybe other netdev
1023          * classes need help. */
1024     }
1025 }
1026 \f
1027 /* Restore the network device flags on 'netdev' to those that were active
1028  * before we changed them.  Returns 0 if successful, otherwise a positive
1029  * errno value.
1030  *
1031  * To avoid reentry, the caller must ensure that fatal signals are blocked. */
1032 static int
1033 restore_flags(struct netdev *netdev)
1034 {
1035     if (netdev->changed_flags) {
1036         enum netdev_flags restore = netdev->save_flags & netdev->changed_flags;
1037         enum netdev_flags old_flags;
1038         return netdev->class->update_flags(netdev,
1039                                            netdev->changed_flags & ~restore,
1040                                            restore, &old_flags);
1041     }
1042     return 0;
1043 }
1044
1045 /* Retores all the flags on all network devices that we modified.  Called from
1046  * a signal handler, so it does not attempt to report error conditions. */
1047 static void
1048 restore_all_flags(void *aux UNUSED)
1049 {
1050     struct netdev *netdev;
1051     LIST_FOR_EACH (netdev, struct netdev, node, &netdev_list) {
1052         restore_flags(netdev);
1053     }
1054 }