Remove building with NOCRYPTO option

[minix.git] / minix / net / lwip / ethif.c

/* LWIP service - ethif.c - ethernet interfaces */
/*
 * The most important aspect of this module is to maintain a send queue for the
 * interface.  This send queue consists of packets to send.  At times, the user
 * may request a change to the driver configuration.  While configuration
 * requests would ideally be enqueued in the send queue, this has proven too
 * problematic to work in practice, especially since out-of-memory conditions
 * may prevent configuration requests from being accepted immediately in such a
 * model.  Instead, we take a simple and blunt approach: configuration requests
 * "cut in line" and thus take precedence over pending packets in the send
 * queue.  This may not always be entirely correct: for example, packets may be
 * transmitted with the old ethernet address after the network device has
 * already been reconfigured to receive from a new ethernet address.  However,
 * this should not be a real problem, and we take care explicitly of perhaps
 * the most problematic case: packets not getting checksummed due to checksum
 * offloading configuration changes.
 *
 * Even with this blunt approach, we maintain three concurrent configurations:
 * the active, the pending, and the wanted configuration.  The active one is
 * the last known active configuration at the network driver.  It used not only
 * to report whether the device is in RUNNING state, but also to replay the
 * active configuration to a restarted driver.  The pending configuration is
 * a partially new configuration that has been given to ndev to send to the
 * driver, but not yet acknowledged by the driver.  Finally, the wanted
 * configuration is the latest one that has yet to be given to ndev.
 *
 * Each configuration has a bitmask indicating which part of the configuration
 * has changed, in order to limit work on the driver side.  This is also the
 * reason that the pending and wanted configurations are separate: if e.g. a
 * media change is pending at the driver, and the user also requests a mode
 * change, we do not want the media change to be repeated after it has been
 * acknowleged by the driver, just to change the mode as well.  In this example
 * the pending configuration will have NDEV_SET_MEDIA set, and the wanted
 * configuration will have NDEV_SET_MODE set.  Once acknowledged, the pending
 * bitmask is cleared and the wanted bitmask is tested to see if another
 * configuration change should be given to ndev.  Technically, this could lead
 * to starvation of actual packet transmission, but we expect configuration
 * changes to be very rare, since they are always user initiated.
 *
 * It is important to note for understanding the code that for some fields
 * (mode, flags, caps), the three configurations are cascading: even though the
 * wanted configuration may not have NDEV_SET_MODE set, its mode field will
 * still contain the most recently requested mode; that is, the mode in the
 * pending configuration if that one has NDEV_SET_MODE set, or otherwise the
 * mode in the active configuration.  For that reason, we carefully merge
 * configuration requests into the next level (wanted -> pending -> active),
 * updating just the fields that have been changed by the previous level.  This
 * approach simplifies obtaining current values a lot, but is not very obvious.
 *
 * Also, we never send multiple configuration requests at once, even though
 * ndev would let us do that: we use a single array for the list of multicast
 * ethernet addresses that we send to the driver, which the driver may retrieve
 * (using a memory grant) at any time.  We necessarily recompute the multicast
 * list before sending a configuration request, and thus, sending multiple
 * requests at once may lead to the driver retrieving a corrupted list.
 */

#include "lwip.h"
#include "ethif.h"

#include "lwip/etharp.h"
#include "lwip/ethip6.h"
#include "lwip/igmp.h"
#include "lwip/mld6.h"

#include <net/if_media.h>

#define ETHIF_MAX_MTU   1500            /* maximum MTU value for ethernet */
#define ETHIF_DEF_MTU   ETHIF_MAX_MTU   /* default MTU value that we use */

#define ETHIF_MCAST_MAX 8       /* maximum number of multicast addresses */

struct ethif {
        struct ifdev ethif_ifdev;       /* interface device, MUST be first */
        ndev_id_t ethif_ndev;           /* network device ID */
        unsigned int ethif_flags;       /* interface flags (ETHIFF_) */
        uint32_t ethif_caps;            /* driver capabilities (NDEV_CAPS_) */
        uint32_t ethif_media;           /* driver-reported media type (IFM_) */
        struct ndev_conf ethif_active;  /* active configuration (at driver) */
        struct ndev_conf ethif_pending; /* pending configuration (at ndev) */
        struct ndev_conf ethif_wanted;  /* desired configuration (waiting) */
        struct ndev_hwaddr ethif_mclist[ETHIF_MCAST_MAX]; /* multicast list */
        struct {                        /* send queue (packet/conf refs) */
                struct pbuf *es_head;   /* first (oldest) request reference */
                struct pbuf **es_unsentp; /* ptr-ptr to first unsent request */
                struct pbuf **es_tailp; /* ptr-ptr for adding new requests */
                unsigned int es_count;  /* buffer count, see ETHIF_PBUF_.. */
        } ethif_snd;
        struct {                        /* receive queue (packets) */
                struct pbuf *er_head;   /* first (oldest) request buffer */
                struct pbuf **er_tailp; /* ptr-ptr for adding new requests */
        } ethif_rcv;
        SIMPLEQ_ENTRY(ethif) ethif_next; /* next in free list */
} ethif_array[NR_NDEV]; /* any other value would be suboptimal */

#define ethif_get_name(ethif)   (ifdev_get_name(&(ethif)->ethif_ifdev))
#define ethif_get_netif(ethif)  (ifdev_get_netif(&(ethif)->ethif_ifdev))

#define ETHIFF_DISABLED         0x01    /* driver has disappeared */
#define ETHIFF_FIRST_CONF       0x02    /* first configuration request sent */

/*
 * Send queue limit settings.  Both are counted in number of pbuf objects.
 * ETHIF_PBUF_MIN is the minimum number of pbuf objects that can always be
 * enqueued on a particular interface's send queue.  It should be at least the
 * number of pbufs for one single packet after being reduced to the ndev limit,
 * so NDEV_IOV_MAX (8) is a natural fit.  The ETHIF_PBUF_MAX_n values define
 * the maximum number of pbufs that may be used by all interface send queues
 * combined, whichever of the two is smaller.  The resulting number must be set
 * fairly high, because at any time there may be a lot of active TCP sockets
 * that all generate a (multi-pbuf) packet as a result of a clock tick.  It is
 * currently a function of the size of the buffer pool, capped to a value that
 * is a function of the number of TCP sockets (assuming one packet per socket;
 * up to MSS/BUFSIZE+1 data pbufs, one header pbuf, one extra as margin).  The
 * difference between the per-interface guaranteed minimum and the global
 * maximum is what makes up a pool of "spares", which are really just tokens
 * allowing for enqueuing of that many pbufs.
 */
#define ETHIF_PBUF_MIN          (NDEV_IOV_MAX)
#define ETHIF_PBUF_MAX_1        (mempool_cur_buffers() >> 1)
#define ETHIF_PBUF_MAX_2        (NR_TCPSOCK * (TCP_MSS / MEMPOOL_BUFSIZE + 3))

static unsigned int ethif_spares;

static SIMPLEQ_HEAD(, ethif) ethif_freelist;    /* free ethif objects */

static const struct ifdev_ops ethif_ops;

#ifdef INET6
static ip6_addr_t ethif_ip6addr_allnodes_ll;
#endif /* INET6 */

/*
 * Initialize the ethernet interfaces module.
 */
void
ethif_init(void)
{
        unsigned int slot;

        /* Initialize the list of free ethif objects. */
        SIMPLEQ_INIT(&ethif_freelist);

        for (slot = 0; slot < __arraycount(ethif_array); slot++)
                SIMPLEQ_INSERT_TAIL(&ethif_freelist, &ethif_array[slot],
                    ethif_next);

        /* Initialize the number of in-use spare tokens. */
        ethif_spares = 0;

#ifdef INET6
        /* Preinitialize the link-local all-nodes IPv6 multicast address. */
        ip6_addr_set_allnodes_linklocal(&ethif_ip6addr_allnodes_ll);
#endif /* INET6 */
}

/*
 * As the result of some event, the NetBSD-style interface flags for this
 * interface may have changed.  Recompute and update the flags as appropriate.
 */
static void
ethif_update_ifflags(struct ethif * ethif)
{
        unsigned int ifflags;

        ifflags = ifdev_get_ifflags(&ethif->ethif_ifdev);

        /* These are the flags that we might update here. */
        ifflags &= ~(IFF_RUNNING | IFF_ALLMULTI);

        /*
         * For us, the RUNNING flag indicates that -as far as we know- the
         * network device is fully operational and has its I/O engines running.
         * This is a reflection of the current state, not of any intention, so
         * we look at the active configuration here.  We use the same approach
         * for one other receive state flags here (ALLMULTI).
         */
        if ((ethif->ethif_flags &
            (ETHIFF_DISABLED | ETHIFF_FIRST_CONF)) == 0 &&
             ethif->ethif_active.nconf_mode != NDEV_MODE_DOWN) {
                ifflags |= IFF_RUNNING;

                if (ethif->ethif_active.nconf_mode & NDEV_MODE_MCAST_ALL)
                        ifflags |= IFF_ALLMULTI;
        }

        ifdev_update_ifflags(&ethif->ethif_ifdev, ifflags);
}

/*
 * Add a multicast hardware receive address into the set of hardware addresses
 * in the given configuration, if the given address is not already in the
 * configuration's set.  Adjust the configuration's mode as needed.  Return
 * TRUE If the address was added, and FALSE if the address could not be added
 * due to a full list (of 'max' elements), in which case the mode is changed
 * from receiving from listed multicast addresses to receiving from all
 * multicast addresses.
 */
static int
ethif_add_mcast(struct ndev_conf * nconf, unsigned int max,
        struct ndev_hwaddr * hwaddr)
{
        unsigned int slot;

        /*
         * See if the hardware address is already in the list we produced so
         * far.  This makes the multicast list generation O(n^2) but we do not
         * expect many entries nor is the list size large anyway.
         */
        for (slot = 0; slot < nconf->nconf_mccount; slot++)
                if (!memcmp(&nconf->nconf_mclist[slot], hwaddr,
                    sizeof(*hwaddr)))
                        return TRUE;

        if (nconf->nconf_mccount < max) {
                memcpy(&nconf->nconf_mclist[slot], hwaddr, sizeof(*hwaddr));
                nconf->nconf_mccount++;

                nconf->nconf_mode |= NDEV_MODE_MCAST_LIST;

                return TRUE;
        } else {
                nconf->nconf_mode &= ~NDEV_MODE_MCAST_LIST;
                nconf->nconf_mode |= NDEV_MODE_MCAST_ALL;

                return FALSE;
        }
}

/*
 * Add the ethernet hardware address derived from the given IPv4 multicast
 * address, to the list of multicast addresses.
 */
static int
ethif_add_mcast_v4(struct ndev_conf * nconf, unsigned int max,
        const ip4_addr_t * ip4addr)
{
        struct ndev_hwaddr hwaddr;

        /* 01:00:05:xx:xx:xx with the lower 23 bits of the IPv4 address. */
        hwaddr.nhwa_addr[0] = LL_IP4_MULTICAST_ADDR_0;
        hwaddr.nhwa_addr[1] = LL_IP4_MULTICAST_ADDR_1;
        hwaddr.nhwa_addr[2] = LL_IP4_MULTICAST_ADDR_2;
        hwaddr.nhwa_addr[3] = (ip4_addr_get_u32(ip4addr) >> 16) & 0x7f;
        hwaddr.nhwa_addr[4] = (ip4_addr_get_u32(ip4addr) >>  8) & 0xff;
        hwaddr.nhwa_addr[5] = (ip4_addr_get_u32(ip4addr) >>  0) & 0xff;

        return ethif_add_mcast(nconf, max, &hwaddr);
}

/*
 * Add the ethernet hardware address derived from the given IPv6 multicast
 * address, to the list of multicast addresses.
 */
static int
ethif_add_mcast_v6(struct ndev_conf * nconf, unsigned int max,
        const ip6_addr_t * ip6addr)
{
        struct ndev_hwaddr hwaddr;

        /* 33:33:xx:xx:xx:xx with the lower 32 bits of the IPv6 address. */
        hwaddr.nhwa_addr[0] = LL_IP6_MULTICAST_ADDR_0;
        hwaddr.nhwa_addr[1] = LL_IP6_MULTICAST_ADDR_1;
        memcpy(&hwaddr.nhwa_addr[2], &ip6addr->addr[3], sizeof(uint32_t));

        return ethif_add_mcast(nconf, max, &hwaddr);
}

/*
 * Set up the multicast mode for a configuration that is to be sent to a
 * network driver, generating a multicast receive address list for the driver
 * as applicable.
 */
static void
ethif_gen_mcast(struct ethif * ethif, struct ndev_conf * nconf)
{
        struct igmp_group *group4;
        struct mld_group *group6;
        unsigned int max;

        /* Make sure that multicast is supported at all for this interface. */
        if (!(ethif->ethif_caps & NDEV_CAP_MCAST))
                return;

        /* Make sure the mode is being (re)configured to be up. */
        if (!(nconf->nconf_set & NDEV_SET_MODE) ||
            nconf->nconf_mode == NDEV_MODE_DOWN)
                return;

        /* Recompute the desired multicast flags. */
        nconf->nconf_mode &= ~(NDEV_MODE_MCAST_LIST | NDEV_MODE_MCAST_ALL);

        /* If promiscuous mode is enabled, receive all multicast packets. */
        if (nconf->nconf_mode & NDEV_MODE_PROMISC) {
                nconf->nconf_mode |= NDEV_MODE_MCAST_ALL;

                return;
        }

        /*
         * Map all IGMP/MLD6 multicast addresses to ethernet addresses, merging
         * any duplicates to save slots.  We have to add the MLD6 all-nodes
         * multicast address ourselves, which also means the list is never
         * empty unless compiling with USE_INET6=no.  If the list is too small
         * for all addresses, opt to receive all multicast packets instead.
         */
        nconf->nconf_mclist = ethif->ethif_mclist;
        nconf->nconf_mccount = 0;
        max = __arraycount(ethif->ethif_mclist);

        for (group4 = netif_igmp_data(ethif_get_netif(ethif)); group4 != NULL;
            group4 = group4->next)
                if (!ethif_add_mcast_v4(nconf, max, &group4->group_address))
                        return;

#ifdef INET6
        if (!ethif_add_mcast_v6(nconf, max, &ethif_ip6addr_allnodes_ll))
                return;
#endif /* INET6 */

        for (group6 = netif_mld6_data(ethif_get_netif(ethif)); group6 != NULL;
            group6 = group6->next)
                if (!ethif_add_mcast_v6(nconf, max, &group6->group_address))
                        return;
}

/*
 * Merge a source configuration into a destination configuration, copying any
 * fields intended to be set from the source into the destination and clearing
 * the "set" mask in the source, without changing the source fields, so that
 * the source will reflect the destination's contents.
 */
static void
ethif_merge_conf(struct ndev_conf * dconf, struct ndev_conf * sconf)
{

        dconf->nconf_set |= sconf->nconf_set;

        if (sconf->nconf_set & NDEV_SET_MODE)
                dconf->nconf_mode = sconf->nconf_mode;
        if (sconf->nconf_set & NDEV_SET_CAPS)
                dconf->nconf_caps = sconf->nconf_caps;
        if (sconf->nconf_set & NDEV_SET_FLAGS)
                dconf->nconf_flags = sconf->nconf_flags;
        if (sconf->nconf_set & NDEV_SET_MEDIA)
                dconf->nconf_media = sconf->nconf_media;
        if (sconf->nconf_set & NDEV_SET_HWADDR)
                memcpy(&dconf->nconf_hwaddr, &sconf->nconf_hwaddr,
                    sizeof(dconf->nconf_hwaddr));

        sconf->nconf_set = 0;
}

/*
 * Return TRUE if we can and should try to pass a configuration request to the
 * ndev layer on this interface, or FALSE otherwise.
 */
static int
ethif_can_conf(struct ethif * ethif)
{

        /* Is there a configuration change waiting?  The common case is no. */
        if (ethif->ethif_wanted.nconf_set == 0)
                return FALSE;

        /*
         * Is there a configuration change pending already?  Then wait for it
         * to be acknowledged first.
         */
        if (ethif->ethif_pending.nconf_set != 0)
                return FALSE;

        /* Make sure the interface is in the appropriate state. */
        if (ethif->ethif_flags & ETHIFF_DISABLED)
                return FALSE;

        /* First let all current packet send requests finish. */
        return (ethif->ethif_snd.es_unsentp == &ethif->ethif_snd.es_head);
}

/*
 * Return TRUE if we can and should try to pass the next unsent packet send
 * request to the ndev layer on this interface, or FALSE otherwise.
 */
static int
ethif_can_send(struct ethif * ethif)
{

        /* Is there anything to hand to ndev at all?  The common case is no. */
        if (*ethif->ethif_snd.es_unsentp == NULL)
                return FALSE;

        /*
         * Is there a configuration change pending?  Then we cannot send
         * packets yet.  Always let all configuration changes through first.
         */
        if (ethif->ethif_pending.nconf_set != 0 ||
            ethif->ethif_wanted.nconf_set != 0)
                return FALSE;

        /* Make sure the interface is in the appropriate state. */
        if ((ethif->ethif_flags & (ETHIFF_DISABLED | ETHIFF_FIRST_CONF)) != 0)
                return FALSE;

        return TRUE;
}

/*
 * Return TRUE if we can and should try to receive packets on this interface
 * and are ready to accept received packets, or FALSE otherwise.
 */
static int
ethif_can_recv(struct ethif * ethif)
{

        if ((ethif->ethif_flags & (ETHIFF_DISABLED | ETHIFF_FIRST_CONF)) != 0)
                return FALSE;

        /*
         * We do not check the link status here.  There is no reason not to
         * spawn receive requests, or accept received packets, while the link
         * is reported to be down.
         */
        return ifdev_is_up(&ethif->ethif_ifdev);
}

/*
 * Polling function, invoked after each message loop iteration.  Check whether
 * any configuration change or packets can be sent to the driver, and whether
 * any new packet receive requests can be enqueued at the driver.
 */
static void
ethif_poll(struct ifdev * ifdev)
{
        struct ethif *ethif = (struct ethif *)ifdev;
        struct pbuf *pbuf, *pref;

        /*
         * If a configuration request is desired, see if we can send it to the
         * driver now.  Otherwise, attempt to send any packets if possible.
         * In both cases, a failure of the ndev call indicates that we should
         * try again later.
         */
        if (ethif_can_conf(ethif)) {
                ethif_gen_mcast(ethif, &ethif->ethif_wanted);

                /*
                 * On success, move the wanted configuration into the pending
                 * slot.  Otherwise, try again on the next poll iteration.
                 */
                if (ndev_conf(ethif->ethif_ndev, &ethif->ethif_wanted) == OK)
                        ethif_merge_conf(&ethif->ethif_pending,
                            &ethif->ethif_wanted);
        } else {
                while (ethif_can_send(ethif)) {
                        pref = *ethif->ethif_snd.es_unsentp;

                        if (pref->type == PBUF_REF)
                                pbuf = (struct pbuf *)pref->payload;
                        else
                                pbuf = pref;

                        if (ndev_send(ethif->ethif_ndev, pbuf) == OK)
                                ethif->ethif_snd.es_unsentp =
                                    pchain_end(pref);
                        else
                                break;
                }
        }

        /*
         * Attempt to create additional receive requests for the driver, if
         * applicable.  We currently do not set a limit on the maximum number
         * of concurrently pending receive requests here, because the maximum
         * in ndev is already quite low.  That may have to be changed one day.
         */
        while (ethif_can_recv(ethif) && ndev_can_recv(ethif->ethif_ndev)) {
                /*
                 * Allocate a buffer for the network device driver to copy the
                 * received packet into.  Allocation may fail if no buffers are
                 * available at this time; in that case simply try again later.
                 * We add room for a VLAN tag even though we do not support
                 * such tags just yet.
                 */
                if ((pbuf = pchain_alloc(PBUF_RAW, ETH_PAD_LEN + ETH_HDR_LEN +
                    ETHIF_MAX_MTU + NDEV_ETH_PACKET_TAG)) == NULL)
                        break;

                /*
                 * Effectively throw away two bytes in order to align TCP/IP
                 * header fields to 32 bits.  See the short discussion in
                 * lwipopts.h as to why we are not using lwIP's ETH_PAD_SIZE.
                 */
                util_pbuf_header(pbuf, -ETH_PAD_LEN);

                /*
                 * Send the request to the driver.  This may still fail due to
                 * grant allocation failure, in which case we try again later.
                 */
                if (ndev_recv(ethif->ethif_ndev, pbuf) != OK) {
                        pbuf_free(pbuf);

                        break;
                }

                /*
                 * Hold on to the packet buffer until the receive request
                 * completes or is aborted, or the driver disappears.
                 */
                *ethif->ethif_rcv.er_tailp = pbuf;
                ethif->ethif_rcv.er_tailp = pchain_end(pbuf);
        }
}

/*
 * Complete the link-layer header of the packet by filling in a source address.
 * This is relevant for BPF-generated packets only, and thus we can safely
 * modify the given pbuf.
 */
static void
ethif_hdrcmplt(struct ifdev * ifdev, struct pbuf * pbuf)
{
        struct netif *netif;

        /* Make sure there is an ethernet packet header at all. */
        if (pbuf->len < ETH_HDR_LEN)
                return;

        netif = ifdev_get_netif(ifdev);

        /*
         * Insert the source ethernet address into the packet.  The source
         * address is located right after the destination address at the start
         * of the packet.
         */
        memcpy((uint8_t *)pbuf->payload + netif->hwaddr_len, netif->hwaddr,
            netif->hwaddr_len);
}

/*
 * Return TRUE if the given additional number of spare tokens may be used, or
 * FALSE if the limit has been reached.  Each spare token represents one
 * enqueued pbuf.  The limit must be such that we do not impede normal traffic
 * but also do not spend the entire buffer pool on enqueued packets.
 */
static int
ethif_can_spare(unsigned int spares)
{
        unsigned int max;

        /*
         * Use the configured maximum, which depends on the current size of the
         * buffer pool.
         */
        max = ETHIF_PBUF_MAX_1;

        /*
         * However, limit the total to a value based on the maximum number of
         * TCP packets that can, in the worst case, be expected to queue up at
         * any single moment.
         */
        if (max > ETHIF_PBUF_MAX_2)
                max = ETHIF_PBUF_MAX_2;

        return (spares + ethif_spares <= max - ETHIF_PBUF_MIN * NR_NDEV);
}

/*
 * Process a packet as output on an ethernet interface.
 */
static err_t
ethif_output(struct ifdev * ifdev, struct pbuf * pbuf, struct netif * netif)
{
        struct ethif *ethif = (struct ethif *)ifdev;
        struct pbuf *pref, *pcopy;
        size_t padding;
        unsigned int count, spares;

        /* Packets must never be sent on behalf of another interface. */
        assert(netif == NULL);

        /*
         * The caller already rejects packets while the interface or link is
         * down.  We do want to keep enqueuing packets while the driver is
         * restarting, so do not check ETHIFF_DISABLED or ETHIFF_FIRST_CONF.
         */

        /*
         * Reject oversized packets immediately.  This should not happen.
         * Undersized packets are padded below.
         */
        if (pbuf->tot_len > NDEV_ETH_PACKET_MAX) {
                printf("LWIP: attempt to send oversized ethernet packet "
                    "(size %u)\n", pbuf->tot_len);
                util_stacktrace();

                return ERR_MEM;
        }

        /*
         * The original lwIP idea for processing output packets is that we make
         * a copy of the packet here, so that lwIP is free to do whatever it
         * wants with the original packet (e.g., keep on the TCP retransmission
         * queue).  More recently, lwIP has made progress towards allowing the
         * packet to be referenced only, decreasing the reference count only
         * once the packet has been actually sent.  For many embedded systems,
         * that change now allows zero-copy transmission with direct DMA from
         * the provided packet buffer.  We are not so lucky: we have to make an
         * additional inter-process copy anyway.  We do however use the same
         * referencing system to avoid having to make yet another copy of the
         * packet here.
         *
         * There was previously a check on (pbuf->ref > 1) here, to ensure that
         * we would never enqueue packets that are retransmitted while we were
         * still in the process of sending the initial copy.  Now that for ARP
         * and NDP queuing, packets are referenced rather than copied (lwIP
         * patch #9272), we can no longer perform that check: packets may
         * legitimately have a reference count of 2 at this point.  The second
         * reference will be dropped by the caller immediately after we return.
         */

        /*
         * There are two cases in which we need to make a copy of the packet
         * after all:
         *
         * 1) in the case that the packet needs to be padded in order to reach
         *    the minimum ethernet packet size (for drivers' convenience);
         * 2) in the (much more exceptional) case that the given pbuf chain
         *    exceeds the maximum vector size for network driver requests.
         */
        if (NDEV_ETH_PACKET_MIN > pbuf->tot_len)
                padding = NDEV_ETH_PACKET_MIN - pbuf->tot_len;
        else
                padding = 0;

        count = pbuf_clen(pbuf);

        if (padding != 0 || count > NDEV_IOV_MAX) {
                pcopy = pchain_alloc(PBUF_RAW, pbuf->tot_len + padding);
                if (pcopy == NULL) {
                        ifdev_output_drop(ifdev);

                        return ERR_MEM;
                }

                if (pbuf_copy(pcopy, pbuf) != ERR_OK)
                        panic("unexpected pbuf copy failure");

                if (padding > 0) {
                        /*
                         * This restriction can be lifted if needed, but it
                         * involves hairy pbuf traversal and our standard pool
                         * size should be way in excess of the minimum packet
                         * size.
                         */
                        assert(pcopy->len == pbuf->tot_len + padding);

                        memset((char *)pcopy->payload + pbuf->tot_len, 0,
                            padding);
                }

                count = pbuf_clen(pcopy);
                assert(count <= NDEV_IOV_MAX);

                pbuf = pcopy;
        } else
                pcopy = NULL;

        /*
         * Restrict the size of the send queue, so that it will not exhaust the
         * buffer pool.
         */
        if (ethif->ethif_snd.es_count >= ETHIF_PBUF_MIN)
                spares = count;
        else if (ethif->ethif_snd.es_count + count > ETHIF_PBUF_MIN)
                spares = ethif->ethif_snd.es_count + count - ETHIF_PBUF_MIN;
        else
                spares = 0;

        if (spares > 0 && !ethif_can_spare(spares)) {
                if (pcopy != NULL)
                        pbuf_free(pcopy);

                ifdev_output_drop(ifdev);

                return ERR_MEM;
        }

        /*
         * A side effect of the referencing approach is that we cannot touch
         * the last pbuf's "next" pointer.  Thus, we need another way of
         * linking together the buffers on the send queue.  We use a linked
         * list of PBUF_REF-type buffers for this instead.  However, do this
         * only when we have not made a copy of the original pbuf, because then
         * we might as well use the copy instead.
         */
        if (pcopy == NULL) {
                if ((pref = pbuf_alloc(PBUF_RAW, 0, PBUF_REF)) == NULL) {
                        ifdev_output_drop(ifdev);

                        return ERR_MEM;
                }

                pbuf_ref(pbuf);

                pref->payload = pbuf;
                pref->tot_len = 0;
                pref->len = count;
        } else
                pref = pcopy;

        /* If the send queue was empty so far, set the IFF_OACTIVE flag. */
        if (ethif->ethif_snd.es_head == NULL)
                ifdev_update_ifflags(&ethif->ethif_ifdev,
                    ifdev_get_ifflags(&ethif->ethif_ifdev) | IFF_OACTIVE);

        /*
         * Enqueue the packet on the send queue.  It will be sent from the
         * polling function as soon as possible.  TODO: see if sending it from
         * here makes any performance difference at all.
         */
        *ethif->ethif_snd.es_tailp = pref;
        ethif->ethif_snd.es_tailp = pchain_end(pref);

        ethif->ethif_snd.es_count += count;
        ethif_spares += spares;

        return ERR_OK;
}

/*
 * Transmit an ethernet packet on an ethernet interface, as requested by lwIP.
 */
static err_t
ethif_linkoutput(struct netif * netif, struct pbuf * pbuf)
{
        struct ifdev *ifdev = netif_get_ifdev(netif);

        /*
         * Let ifdev make the callback to our output function, so that it can
         * pass the packet to BPF devices and generically update statistics.
         */
        return ifdev_output(ifdev, pbuf, NULL /*netif*/, TRUE /*to_bpf*/,
            TRUE /*hdrcmplt*/);
}

/*
 * The multicast address list has changed.  See to it that the change will make
 * it to the network driver at some point.
 */
static err_t
ethif_set_mcast(struct ethif * ethif)
{

        /*
         * Simply generate a mode change request, unless the interface is down.
         * Once the mode change request is about to be sent to the driver, we
         * will recompute the multicast settings.
         */
        if (ifdev_is_up(&ethif->ethif_ifdev))
                ethif->ethif_wanted.nconf_set |= NDEV_SET_MODE;

        return ERR_OK;
}

/*
 * An IPv4 multicast address has been added to or removed from the list of IPv4
 * multicast addresses.
 */
static err_t
ethif_set_mcast_v4(struct netif * netif, const ip4_addr_t * group __unused,
        enum netif_mac_filter_action action __unused)
{

        return ethif_set_mcast((struct ethif *)netif_get_ifdev(netif));
}

/*
 * An IPv6 multicast address has been added to or removed from the list of IPv6
 * multicast addresses.
 */
static err_t
ethif_set_mcast_v6(struct netif * netif, const ip6_addr_t * group __unused,
        enum netif_mac_filter_action action __unused)
{

        return ethif_set_mcast((struct ethif *)netif_get_ifdev(netif));
}

/*
 * Initialization function for an ethernet-type netif interface, called from
 * lwIP at interface creation time.
 */
static err_t
ethif_init_netif(struct ifdev * ifdev, struct netif * netif)
{
        struct ethif *ethif = (struct ethif *)ifdev;

        /*
         * Fill in a dummy name.  Since it is only two characters, do not
         * bother trying to reuse part of the given name.  If this name is ever
         * actually used anywhere, the dummy should suffice for debugging.
         */
        netif->name[0] = 'e';
        netif->name[1] = 'n';

        netif->linkoutput = ethif_linkoutput;

        memset(netif->hwaddr, 0, sizeof(netif->hwaddr));

        /*
         * Set the netif flags, partially based on the capabilities reported by
         * the network device driver.  The reason that we do this now is that
         * lwIP tests for some of these flags and starts appropriate submodules
         * (e.g., IGMP) right after returning from this function.  If we set
         * the flags later, we also have to take over management of those
         * submodules, which is something we'd rather avoid.  For this reason
         * in particular, we also do not support capability mask changes after
         * driver restarts - see ethif_enable().
         */
        netif->flags = NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET;

        if (ethif->ethif_caps & NDEV_CAP_BCAST)
                netif->flags |= NETIF_FLAG_BROADCAST;

        if (ethif->ethif_caps & NDEV_CAP_MCAST) {
                /* The IGMP code adds the all-stations multicast entry. */
                netif->igmp_mac_filter = ethif_set_mcast_v4;

                netif->flags |= NETIF_FLAG_IGMP;

                /* For MLD6 we have to add the all-nodes entry ourselves. */
                netif->mld_mac_filter = ethif_set_mcast_v6;

                netif->flags |= NETIF_FLAG_MLD6;
        }

        return ERR_OK;
}

/*
 * The ndev layer reports that a new network device driver has appeared, with
 * the given ndev identifier, a driver-given name, and a certain set of
 * capabilities.  Create a new ethernet interface object for it.  On success,
 * return a pointer to the object (for later callbacks from ndev).  In that
 * case, the ndev layer will always immediately call ethif_enable() afterwards.
 * On failure, return NULL, in which case ndev will forget about the driver.
 */
struct ethif *
ethif_add(ndev_id_t id, const char * name, uint32_t caps)
{
        struct ethif *ethif;
        unsigned int ifflags;
        int r;

        /*
         * First make sure that the interface name is valid, unique, and not
         * reserved for virtual interface types.
         */
        if ((r = ifdev_check_name(name, NULL /*vtype_slot*/)) != OK) {
                /*
                 * There is some risk in printing bad stuff, but this may help
                 * in preventing serious driver writer frustration..
                 */
                printf("LWIP: invalid driver name '%s' (%d)\n", name, r);

                return NULL;
        }

        /* Then see if there is a free ethernet interface object available. */
        if (SIMPLEQ_EMPTY(&ethif_freelist)) {
                printf("LWIP: out of slots for driver name '%s'\n", name);

                return NULL;
        }

        /*
         * All good; set up the interface.  First initialize the object, since
         * adding the interface to lwIP might spawn some activity right away.
         */
        ethif = SIMPLEQ_FIRST(&ethif_freelist);
        SIMPLEQ_REMOVE_HEAD(&ethif_freelist, ethif_next);

        /* Initialize the ethif structure. */
        memset(ethif, 0, sizeof(*ethif));
        ethif->ethif_ndev = id;
        ethif->ethif_flags = ETHIFF_DISABLED;
        ethif->ethif_caps = caps;

        ethif->ethif_snd.es_head = NULL;
        ethif->ethif_snd.es_unsentp = &ethif->ethif_snd.es_head;
        ethif->ethif_snd.es_tailp = &ethif->ethif_snd.es_head;
        ethif->ethif_snd.es_count = 0;

        ethif->ethif_rcv.er_head = NULL;
        ethif->ethif_rcv.er_tailp = &ethif->ethif_rcv.er_head;

        /*
         * Set all the three configurations to the same initial values.  Since
         * any change to the configuration will go through all three, this
         * allows us to obtain various parts of the status (in particular, the
         * mode, flags, enabled capabilities, and media type selection) from
         * any of the three without having to consult the others.  Note that
         * the hardware address is set to a indeterminate initial value, as it
         * is left to the network driver unless specifically overridden.
         */
        ethif->ethif_active.nconf_set = 0;
        ethif->ethif_active.nconf_mode = NDEV_MODE_DOWN;
        ethif->ethif_active.nconf_flags = 0;
        ethif->ethif_active.nconf_caps = 0;
        ethif->ethif_active.nconf_media =
            IFM_MAKEWORD(IFM_ETHER, IFM_AUTO, 0, 0);
        memcpy(&ethif->ethif_pending, &ethif->ethif_active,
            sizeof(ethif->ethif_pending));
        memcpy(&ethif->ethif_wanted, &ethif->ethif_pending,
            sizeof(ethif->ethif_wanted));

        /*
         * Compute the initial NetBSD-style interface flags.  The IFF_SIMPLEX
         * interface flag is always enabled because we do not support network
         * drivers that are receiving their own packets.  In particular, lwIP
         * currently does not deal well with receiving back its own multicast
         * packets, which leads to IPv6 DAD failures.  The other two flags
         * (IFF_BROADCAST, IFF_MULTICAST) denote capabilities, not enabled
         * receipt modes.
         */
        ifflags = IFF_SIMPLEX;
        if (caps & NDEV_CAP_BCAST)
                ifflags |= IFF_BROADCAST;
        if (caps & NDEV_CAP_MCAST)
                ifflags |= IFF_MULTICAST;

        /* Finally, add the interface to ifdev and lwIP.  This cannot fail. */
        ifdev_add(&ethif->ethif_ifdev, name, ifflags, IFT_ETHER, ETH_HDR_LEN,
            ETHARP_HWADDR_LEN, DLT_EN10MB, ETHIF_DEF_MTU,
            ND6_IFF_PERFORMNUD | ND6_IFF_AUTO_LINKLOCAL, &ethif_ops);

        return ethif;
}

/*
 * The link status and/or media type of an ethernet interface has changed.
 */
static void
ethif_set_status(struct ethif * ethif, uint32_t link, uint32_t media)
{
        unsigned int iflink;

        /* We save the media type locally for now. */
        ethif->ethif_media = media;

        /* Let the ifdev module handle the details of the link change. */
        switch (link) {
        case NDEV_LINK_UP:      iflink = LINK_STATE_UP;         break;
        case NDEV_LINK_DOWN:    iflink = LINK_STATE_DOWN;       break;
        default:                iflink = LINK_STATE_UNKNOWN;    break;
        }

        ifdev_update_link(&ethif->ethif_ifdev, iflink);
}

/*
 * The ndev layer reports that a previously added or disabled network device
 * driver has been (re)enabled.  Start by initializing the driver.  Return TRUE
 * if the interface could indeed be enabled, or FALSE if it should be forgotten
 * altogether after all.
 */
int
ethif_enable(struct ethif * ethif, const char * name,
        const struct ndev_hwaddr * hwaddr, uint8_t hwaddr_len, uint32_t caps,
        uint32_t link, uint32_t media)
{
        int r;

        assert(ethif->ethif_flags & ETHIFF_DISABLED);

        /*
         * One disadvantage of keeping service labels and ethernet driver names
         * disjunct is that the ethernet driver may mess with its name between
         * restarts.  Ultimately we may end up renaming our ethernet drivers
         * such that their labels match their names, in which case we no longer
         * need the drivers themselves to produce a name, and we can retire
         * this check.
         */
        if (name != NULL && strcmp(ethif_get_name(ethif), name)) {
                printf("LWIP: driver '%s' restarted with name '%s'\n",
                    ethif_get_name(ethif), name);

                return FALSE;
        }

        /*
         * The hardware address length is just a sanity check for now.  After
         * the initialization reply, we assume the same length is used for all
         * addresses, which is also the maximum, namely 48 bits (six bytes).
         */
        if (hwaddr_len != ETHARP_HWADDR_LEN) {
                printf("LWIP: driver '%s' reports hwaddr length %u\n",
                    ethif_get_name(ethif), hwaddr_len);

                return FALSE;
        }

        /*
         * If the driver has changed its available capabilities as a result of
         * a restart, we have a problem: we may already have configured the
         * interface's netif object to make use of of some of those
         * capabilities.  TODO: we can deal with some cases (e.g., disappearing
         * checksum offloading capabilities) with some effort, and with other
         * cases (e.g., disappearing multicast support) with a LOT more effort.
         */
        if (ethif->ethif_caps != caps) {
                printf("LWIP: driver '%s' changed capabilities\n",
                    ethif_get_name(ethif));

                return FALSE;
        }

        /*
         * Set the hardware address on the interface, unless a request is
         * currently pending to change it, in which case the new address has
         * been set already and we do not want to revert that change.  If not,
         * we always set the address, because it may have changed as part of a
         * driver restart and we do not want to get out of sync with it, nor
         * can we necessarily change it back.
         */
        if (!(ethif->ethif_active.nconf_set & NDEV_SET_HWADDR) &&
            !(ethif->ethif_pending.nconf_set & NDEV_SET_HWADDR))
                ifdev_update_hwaddr(&ethif->ethif_ifdev, hwaddr->nhwa_addr,
                    (name == NULL) /*is_factory*/);

        /*
         * At this point, only one more thing can fail: it is possible that we
         * do not manage to send the first configuration request due to memory
         * shortage.  This is extremely unlikely to happen, so send the conf
         * request first and forget the entire driver if it fails.
         */
        /*
         * Always generate a new multicast list before sending a configuration
         * request, and at no other time (since there may be a grant for it).
         */
        ethif_gen_mcast(ethif, &ethif->ethif_active);

        if ((r = ndev_conf(ethif->ethif_ndev, &ethif->ethif_active)) != OK) {
                printf("LWIP: sending first configuration to '%s' failed "
                    "(%d)\n", ethif_get_name(ethif), r);

                return FALSE;
        }

        ethif_set_status(ethif, link, media);

        ethif->ethif_flags &= ~ETHIFF_DISABLED;
        ethif->ethif_flags |= ETHIFF_FIRST_CONF;

        return TRUE;
}

/*
 * The configuration change stored in the "pending" slot of the given ethif
 * object has been acknowledged by the network device driver (or the driver has
 * died, see ethif_disable()).  Apply changes to the "active" slot of the given
 * ethif object, as well as previously delayed changes to lwIP through netif.
 */
static void
ethif_post_conf(struct ethif * ethif)
{
        struct ndev_conf *nconf;
        unsigned int flags;

        nconf = &ethif->ethif_pending;

        /*
         * Now that the driver configuration has changed, we know that the
         * new checksum settings will be applied to all sent and received
         * packets, and we can disable checksumming flags in netif as desired.
         * Enabling checksumming flags has already been done earlier on.
         */
        if (nconf->nconf_set & NDEV_SET_CAPS) {
                flags = ethif_get_netif(ethif)->chksum_flags;

                if (nconf->nconf_caps & NDEV_CAP_CS_IP4_TX)
                        flags &= ~NETIF_CHECKSUM_GEN_IP;
                if (nconf->nconf_caps & NDEV_CAP_CS_IP4_RX)
                        flags &= ~NETIF_CHECKSUM_CHECK_IP;
                if (nconf->nconf_caps & NDEV_CAP_CS_UDP_TX)
                        flags &= ~NETIF_CHECKSUM_GEN_UDP;
                if (nconf->nconf_caps & NDEV_CAP_CS_UDP_RX)
                        flags &= ~NETIF_CHECKSUM_CHECK_UDP;
                if (nconf->nconf_caps & NDEV_CAP_CS_TCP_TX)
                        flags &= ~NETIF_CHECKSUM_GEN_TCP;
                if (nconf->nconf_caps & NDEV_CAP_CS_TCP_RX)
                        flags &= ~NETIF_CHECKSUM_CHECK_TCP;

                NETIF_SET_CHECKSUM_CTRL(ethif_get_netif(ethif), flags);
        }

        /*
         * Merge any individual parts of the now acknowledged configuration
         * changes into the active configuration.  The result is that we are
         * able to reapply these changes at any time should the network driver
         * be restarted.  In addition, by only setting bits for fields that
         * have actually changed, we can later tell whether the user wanted the
         * change or ethif should just take over what the driver reports after
         * a restart; this is important for HW-address and media settings.
         */
        ethif_merge_conf(&ethif->ethif_active, &ethif->ethif_pending);
}

/*
 * All receive requests have been canceled at the ndev layer, because the
 * network device driver has been restarted or shut down.  Clear the receive
 * queue, freeing any packets in it.
 */
static void
ethif_drain(struct ethif * ethif)
{
        struct pbuf *pbuf, **pnext;

        while ((pbuf = ethif->ethif_rcv.er_head) != NULL) {
                pnext = pchain_end(pbuf);

                if ((ethif->ethif_rcv.er_head = *pnext) == NULL)
                        ethif->ethif_rcv.er_tailp = &ethif->ethif_rcv.er_head;

                *pnext = NULL;
                pbuf_free(pbuf);
        }
}

/*
 * The network device driver has stopped working (i.e., crashed), but has not
 * been shut down completely, and is expect to come back later.
 */
void
ethif_disable(struct ethif * ethif)
{

        /*
         * We assume, optimistically, that a new instance of the driver will be
         * brought up soon after which we can continue operating as before.  As
         * such, we do not want to change most of the user-visible state until
         * we know for sure that our optimism was in vain.  In particular, we
         * do *not* want to change the following parts of the state here:
         *
         *   - the contents of the send queue;
         *   - the state of the interface (up or down);
         *   - the state and media type of the physical link.
         *
         * The main user-visible indication of the crash will be that the
         * interface does not have the IFF_RUNNING flag set.
         */

        /*
         * If a configuration request was pending, it will be lost now.  Highly
         * unintuitively, make the requested configuration the *active* one,
         * just as though the request completed successfully.  This works,
         * because once the driver comes back, the active configuration will be
         * replayed as initial configuration.  Therefore, by pretending that
         * the current request went through, we ensure that it too will be sent
         * to the new instance--before anything else is allowed to happen.
         */
        if (ethif->ethif_pending.nconf_set != 0)
                ethif_post_conf(ethif);

        /*
         * Any packet send requests have been lost, too, and likewise forgotten
         * by ndev.  Thus, we need to forget that we sent any packets, so that
         * they will be resent after the driver comes back up.  That *may*
         * cause packet duplication, but that is preferable over packet loss.
         */
        ethif->ethif_snd.es_unsentp = &ethif->ethif_snd.es_head;

        /*
         * We fully restart the receive queue, because all receive requests
         * have been forgotten by ndev as well now and it is easier to simply
         * reconstruct the receive queue in its entirety later on.
         */
        ethif_drain(ethif);

        /* Make sure we do not attempt to initiate new requests for now. */
        ethif->ethif_flags &= ~ETHIFF_FIRST_CONF;
        ethif->ethif_flags |= ETHIFF_DISABLED;
}

/*
 * Dequeue and discard the packet at the head of the send queue.
 */
static void
ethif_dequeue_send(struct ethif * ethif)
{
        struct pbuf *pref, *pbuf, **pnext;
        unsigned int count, spares;

        /*
         * The send queue is a linked list of reference buffers, each of which
         * links to the actual packet.  Dequeue the first reference buffer.
         */
        pref = ethif->ethif_snd.es_head;
        assert(pref != NULL);

        pnext = pchain_end(pref);

        if (ethif->ethif_snd.es_unsentp == pnext)
                ethif->ethif_snd.es_unsentp = &ethif->ethif_snd.es_head;

        if ((ethif->ethif_snd.es_head = *pnext) == NULL)
                ethif->ethif_snd.es_tailp = &ethif->ethif_snd.es_head;

        /* Do this before possibly calling pbuf_clen() below.. */
        *pnext = NULL;

        /*
         * If we never made a copy of the original packet, we now have it
         * pointed to by a reference buffer.  If so, decrease the reference
         * count of the actual packet, thereby freeing it if lwIP itself was
         * already done with.  Otherwise, the copy of the packet is the
         * reference buffer itself.  In both cases we need to free that buffer.
         */
        if (pref->type == PBUF_REF) {
                pbuf = (struct pbuf *)pref->payload;

                pbuf_free(pbuf);

                count = pref->len;
        } else
                count = pbuf_clen(pref);

        assert(count > 0);
        assert(ethif->ethif_snd.es_count >= count);
        ethif->ethif_snd.es_count -= count;

        if (ethif->ethif_snd.es_count >= ETHIF_PBUF_MIN)
                spares = count;
        else if (ethif->ethif_snd.es_count + count > ETHIF_PBUF_MIN)
                spares = ethif->ethif_snd.es_count + count - ETHIF_PBUF_MIN;
        else
                spares = 0;

        assert(ethif_spares >= spares);
        ethif_spares -= spares;

        /* Free the reference buffer as well. */
        pbuf_free(pref);

        /* If the send queue is now empty, clear the IFF_OACTIVE flag. */
        if (ethif->ethif_snd.es_head == NULL)
                ifdev_update_ifflags(&ethif->ethif_ifdev,
                    ifdev_get_ifflags(&ethif->ethif_ifdev) & ~IFF_OACTIVE);
}

/*
 * The ndev layer reports that a network device driver has been permanently
 * shut down.  Remove the corresponding ethernet interface from the system.
 */
void
ethif_remove(struct ethif * ethif)
{
        int r;

        /* Clear the send and receive queues. */
        while (ethif->ethif_snd.es_head != NULL)
                ethif_dequeue_send(ethif);

        ethif_drain(ethif);

        /* Let the ifdev module deal with most other removal aspects. */
        if ((r = ifdev_remove(&ethif->ethif_ifdev)) != OK)
                panic("unable to remove ethernet interface: %d", r);

        /* Finally, readd the ethif object to the free list. */
        SIMPLEQ_INSERT_HEAD(&ethif_freelist, ethif, ethif_next);
}

/*
 * The ndev layer reports that the (oldest) pending configuration request has
 * completed with the given result.
 */
void
ethif_configured(struct ethif * ethif, int32_t result)
{

        /*
         * The driver is not supposed to return failure in response to a
         * configure result.  If it does, we have no proper way to recover, as
         * we may already have applied part of the new configuration to netif.
         * For now, just report failure and then pretend success.
         */
        if (result < 0) {
                printf("LWIP: driver '%s' replied with conf result %d\n",
                    ethif_get_name(ethif), result);

                result = 0;
        }

        if (ethif->ethif_flags & ETHIFF_FIRST_CONF)
                ethif->ethif_flags &= ~ETHIFF_FIRST_CONF;
        else
                ethif_post_conf(ethif);

        /*
         * For now, the result is simply a boolean value indicating whether the
         * driver is using the all-multicast receive mode instead of the
         * multicast-list receive mode.  We can turn it into a bitmap later.
         */
        if (result != 0) {
                ethif->ethif_active.nconf_mode &= ~NDEV_MODE_MCAST_LIST;
                ethif->ethif_active.nconf_mode |= NDEV_MODE_MCAST_ALL;
        }

        /* The interface flags may have changed now, so update them. */
        ethif_update_ifflags(ethif);

        /* Regular operation will resume from the polling function. */
}

/*
 * The ndev layer reports that the first packet on the send queue has been
 * successfully transmitted with 'result' set to OK, or dropped if 'result' is
 * negative.  The latter may happen if the interface was taken down while there
 * were still packets in transit.
 */
void
ethif_sent(struct ethif * ethif, int32_t result)
{

        ethif_dequeue_send(ethif);

        if (result < 0)
                ifdev_output_drop(&ethif->ethif_ifdev);

        /* More requests may be sent from the polling function now. */
}

/*
 * The ndev layer reports that the first buffer on the receive queue has been
 * filled with a packet of 'result' bytes, or if 'result' is negative, the
 * receive request has been aborted.
 */
void
ethif_received(struct ethif * ethif, int32_t result)
{
        struct pbuf *pbuf, *pwalk, **pnext;
        size_t left;

        /*
         * Start by removing the first buffer chain off the receive queue.  The
         * ndev layer guarantees that there ever was a receive request at all.
         */
        if ((pbuf = ethif->ethif_rcv.er_head) == NULL)
                panic("driver received packet but queue empty");

        pnext = pchain_end(pbuf);

        if ((ethif->ethif_rcv.er_head = *pnext) == NULL)
                ethif->ethif_rcv.er_tailp = &ethif->ethif_rcv.er_head;
        *pnext = NULL;

        /* Decide if we can and should deliver a packet to the layers above. */
        if (result <= 0 || !ethif_can_recv(ethif)) {
                pbuf_free(pbuf);

                return;
        }

        if (result > pbuf->tot_len) {
                printf("LWIP: driver '%s' returned bad packet size (%zd)\n",
                    ethif_get_name(ethif), (ssize_t)result);

                pbuf_free(pbuf);

                return;
        }

        /*
         * The packet often does not use all of the buffers, or at least not
         * all of the last buffer.  Adjust lengths for the buffers that contain
         * part of the packet, and free the remaining (unused) buffers, if any.
         */
        left = (size_t)result;

        for (pwalk = pbuf; ; pwalk = pwalk->next) {
                pwalk->tot_len = left;
                if (pwalk->len > left)
                        pwalk->len = left;
                left -= pwalk->len;
                if (left == 0)
                        break;
        }

        if (pwalk->next != NULL) {
                pbuf_free(pwalk->next);

                pwalk->next = NULL;
        }

        /*
         * Finally, hand off the packet to the layers above.  We go through
         * ifdev so that it can pass the packet to BPF devices and update
         * statistics and all that.
         */
        ifdev_input(&ethif->ethif_ifdev, pbuf, NULL /*netif*/,
            TRUE /*to_bpf*/);
}

/*
 * The ndev layer reports a network driver status update.  If anything has
 * changed since the last status, we may have to take action.  The given
 * statistics counters are relative to the previous status report.
 */
void
ethif_status(struct ethif * ethif, uint32_t link, uint32_t media,
        uint32_t oerror, uint32_t coll, uint32_t ierror, uint32_t iqdrop)
{
        struct if_data *ifdata;

        ethif_set_status(ethif, link, media);

        ifdata = ifdev_get_ifdata(&ethif->ethif_ifdev);
        ifdata->ifi_oerrors += oerror;
        ifdata->ifi_collisions += coll;
        ifdata->ifi_ierrors += ierror;
        ifdata->ifi_iqdrops += iqdrop;
}

/*
 * Set NetBSD-style interface flags (IFF_) for an ethernet interface.
 */
static int
ethif_set_ifflags(struct ifdev * ifdev, unsigned int ifflags)
{
        struct ethif *ethif = (struct ethif *)ifdev;
        uint32_t mode, flags;

        /*
         * We do not support IFF_NOARP at this time, because lwIP does not: the
         * idea of IFF_NOARP is that only static ARP entries are used, but lwIP
         * does not support separating static from dynamic ARP operation.  The
         * flag does not appear to be particularly widely used anyway.
         */
        if ((ifflags & ~(IFF_UP | IFF_DEBUG | IFF_LINK0 | IFF_LINK1 |
            IFF_LINK2)) != 0)
                return EINVAL;

        mode = ethif->ethif_wanted.nconf_mode;
        if ((ifflags & IFF_UP) && mode == NDEV_MODE_DOWN) {
                mode = NDEV_MODE_UP;

                /* Always enable broadcast receipt when supported. */
                if (ethif->ethif_caps & NDEV_CAP_BCAST)
                        mode |= NDEV_MODE_BCAST;

                if (ifdev_is_promisc(ifdev))
                        mode |= NDEV_MODE_PROMISC;

                /*
                 * The multicast flags will be set right before we send the
                 * request to the driver.
                 */
        } else if (!(ifflags & IFF_UP) && mode != NDEV_MODE_DOWN)
                ethif->ethif_wanted.nconf_mode = NDEV_MODE_DOWN;

        if (mode != ethif->ethif_wanted.nconf_mode) {
                ethif->ethif_wanted.nconf_mode = mode;
                ethif->ethif_wanted.nconf_set |= NDEV_SET_MODE;
        }

        /*
         * Some of the interface flags (UP, DEBUG, PROMISC, LINK[0-2]) are a
         * reflection of the intended state as set by userland before, so that
         * a userland utility will never not see the flag it just set (or the
         * other way around).  These flags therefore do not necessarily reflect
         * what is actually going on at that moment.  We cannot have both.
         */
        flags = 0;
        if (ifflags & IFF_DEBUG)
                flags |= NDEV_FLAG_DEBUG;
        if (ifflags & IFF_LINK0)
                flags |= NDEV_FLAG_LINK0;
        if (ifflags & IFF_LINK1)
                flags |= NDEV_FLAG_LINK1;
        if (ifflags & IFF_LINK2)
                flags |= NDEV_FLAG_LINK2;

        if (flags != ethif->ethif_wanted.nconf_flags) {
                ethif->ethif_wanted.nconf_flags = flags;
                ethif->ethif_wanted.nconf_set |= NDEV_SET_FLAGS;
        }

        /* The changes will be picked up from the polling function. */
        return OK;
}

/*
 * Convert a bitmask of ndev-layer capabilities (NDEV_CAP_) to NetBSD-style
 * interface capabilities (IFCAP_).
 */
static uint64_t
ethif_cap_to_ifcap(uint32_t caps)
{
        uint64_t ifcap;

        ifcap = 0;
        if (caps & NDEV_CAP_CS_IP4_TX)
                ifcap |= IFCAP_CSUM_IPv4_Tx;
        if (caps & NDEV_CAP_CS_IP4_RX)
                ifcap |= IFCAP_CSUM_IPv4_Rx;
        if (caps & NDEV_CAP_CS_UDP_TX)
                ifcap |= IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv6_Tx;
        if (caps & NDEV_CAP_CS_UDP_RX)
                ifcap |= IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv6_Rx;
        if (caps & NDEV_CAP_CS_TCP_TX)
                ifcap |= IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv6_Tx;
        if (caps & NDEV_CAP_CS_TCP_RX)
                ifcap |= IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv6_Rx;

        return ifcap;
}

/*
 * Retrieve potential and enabled NetBSD-style interface capabilities (IFCAP_).
 */
static void
ethif_get_ifcap(struct ifdev * ifdev, uint64_t * ifcap, uint64_t * ifena)
{
        struct ethif *ethif = (struct ethif *)ifdev;

        *ifcap = ethif_cap_to_ifcap(ethif->ethif_caps);
        *ifena = ethif_cap_to_ifcap(ethif->ethif_wanted.nconf_caps);
}

/*
 * Set NetBSD-style enabled interface capabilities (IFCAP_).
 */
static int
ethif_set_ifcap(struct ifdev * ifdev, uint64_t ifcap)
{
        struct ethif *ethif = (struct ethif *)ifdev;
        unsigned int flags;
        uint32_t caps;

        if (ifcap & ~(IFCAP_CSUM_IPv4_Tx | IFCAP_CSUM_IPv4_Rx |
            IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv6_Tx |
            IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv6_Rx |
            IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv6_Tx |
            IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv6_Rx))
                return EINVAL;

        /*
         * Some IPv4/IPv6 flags need to be set together in order to be picked
         * up.  Unfortunately, that is all we can do given that lwIP does not
         * distinguish IPv4/IPv6 when it comes to TCP/UDP checksum flags.
         */
        caps = 0;
        if (ifcap & IFCAP_CSUM_IPv4_Tx)
                caps |= NDEV_CAP_CS_IP4_TX;
        if (ifcap & IFCAP_CSUM_IPv4_Rx)
                caps |= NDEV_CAP_CS_IP4_RX;
        if ((ifcap & (IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv6_Tx)) ==
            (IFCAP_CSUM_UDPv4_Tx | IFCAP_CSUM_UDPv6_Tx))
                caps |= NDEV_CAP_CS_UDP_TX;
        if ((ifcap & (IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv6_Rx)) ==
            (IFCAP_CSUM_UDPv4_Rx | IFCAP_CSUM_UDPv6_Rx))
                caps |= NDEV_CAP_CS_UDP_RX;
        if ((ifcap & (IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv6_Tx)) ==
            (IFCAP_CSUM_TCPv4_Tx | IFCAP_CSUM_TCPv6_Tx))
                caps |= NDEV_CAP_CS_TCP_TX;
        if ((ifcap & (IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv6_Rx)) ==
            (IFCAP_CSUM_TCPv4_Rx | IFCAP_CSUM_TCPv6_Rx))
                caps |= NDEV_CAP_CS_TCP_RX;

        /*
         * When changing checksumming capabilities, we have to make sure that
         * we only ever checksum too much and never too little.  This means
         * that we enable any checksum options in netif here, and disable any
         * checksum options in netif only after driver configuration.
         *
         * Note that we have to draw the line somewhere with this kind of
         * self-protection, and that line is short of TCP retransmission: we
         * see it as lwIP's job to compute checksums for retransmitted TCP
         * packets if they were saved across checksum changes.  Even though
         * lwIP may not care, there is little we can do about that anyway.
         */
        if (ethif->ethif_wanted.nconf_caps != caps) {
                flags = ethif_get_netif(ethif)->chksum_flags;

                if (!(caps & NDEV_CAP_CS_IP4_TX))
                        flags |= NETIF_CHECKSUM_GEN_IP;
                if (!(caps & NDEV_CAP_CS_IP4_RX))
                        flags |= NETIF_CHECKSUM_CHECK_IP;
                if (!(caps & NDEV_CAP_CS_UDP_TX))
                        flags |= NETIF_CHECKSUM_GEN_UDP;
                if (!(caps & NDEV_CAP_CS_UDP_RX))
                        flags |= NETIF_CHECKSUM_CHECK_UDP;
                if (!(caps & NDEV_CAP_CS_TCP_TX))
                        flags |= NETIF_CHECKSUM_GEN_TCP;
                if (!(caps & NDEV_CAP_CS_TCP_RX))
                        flags |= NETIF_CHECKSUM_CHECK_TCP;

                NETIF_SET_CHECKSUM_CTRL(ethif_get_netif(ethif), flags);

                ethif->ethif_wanted.nconf_caps = caps;
                ethif->ethif_wanted.nconf_set |= NDEV_SET_CAPS;
        }

        /* The changes will be picked up from the polling function. */
        return OK;
}

/*
 * Retrieve NetBSD-style interface media type (IFM_).  Return both the current
 * media type selection and the driver-reported active media type.
 */
static void
ethif_get_ifmedia(struct ifdev * ifdev, int * ifcurrent, int * ifactive)
{
        struct ethif *ethif = (struct ethif *)ifdev;

        /*
         * For the current select, report back whatever the user gave us, even
         * if it has not reached the driver at all yet.
         */
        *ifcurrent = (int)ethif->ethif_wanted.nconf_media;
        *ifactive = (int)ethif->ethif_media;
}

/*
 * Set current NetBSD-style interface media type (IFM_).
 */
static int
ethif_set_ifmedia(struct ifdev * ifdev, int ifmedia)
{
        struct ethif *ethif = (struct ethif *)ifdev;

        /*
         * We currently completely lack the infrastructure to suspend the
         * current IOCTL call until the driver replies (or disappears).
         * Therefore we have no choice but to return success here, even if the
         * driver cannot accept the change.  The driver does notify us of media
         * changes, so the user may observe the new active media type later.
         * Also note that the new media type may not be the requested type,
         * which is why we do not perform any checks against the wanted or
         * active media types.
         */
        ethif->ethif_wanted.nconf_media = (uint32_t)ifmedia;
        ethif->ethif_wanted.nconf_set |= NDEV_SET_MEDIA;

        /* The change will be picked up from the polling function. */
        return OK;
}

/*
 * Enable or disable promiscuous mode on the interface.
 */
static void
ethif_set_promisc(struct ifdev * ifdev, int promisc)
{
        struct ethif *ethif = (struct ethif *)ifdev;

        if (ethif->ethif_wanted.nconf_mode != NDEV_MODE_DOWN) {
                if (promisc)
                        ethif->ethif_wanted.nconf_mode |= NDEV_MODE_PROMISC;
                else
                        ethif->ethif_wanted.nconf_mode &= ~NDEV_MODE_PROMISC;
                ethif->ethif_wanted.nconf_set |= NDEV_SET_MODE;
        }

        /* The change will be picked up from the polling function. */
}

/*
 * Set the hardware address on the interface.
 */
static int
ethif_set_hwaddr(struct ifdev * ifdev, const uint8_t * hwaddr)
{
        struct ethif *ethif = (struct ethif *)ifdev;

        if (!(ethif->ethif_caps & NDEV_CAP_HWADDR))
                return EINVAL;

        memcpy(&ethif->ethif_wanted.nconf_hwaddr.nhwa_addr, hwaddr,
            ETHARP_HWADDR_LEN);
        ethif->ethif_wanted.nconf_set |= NDEV_SET_HWADDR;

        /* The change will be picked up from the polling function. */
        return OK;
}

/*
 * Set the Maximum Transmission Unit for this interface.  Return TRUE if the
 * new value is acceptable, in which case the caller will do the rest.  Return
 * FALSE otherwise.
 */
static int
ethif_set_mtu(struct ifdev * ifdev __unused, unsigned int mtu)
{

        return (mtu <= ETHIF_MAX_MTU);
}

static const struct ifdev_ops ethif_ops = {
        .iop_init = ethif_init_netif,
        .iop_input = netif_input,
        .iop_output = ethif_output,
        .iop_output_v4 = etharp_output,
        .iop_output_v6 = ethip6_output,
        .iop_hdrcmplt = ethif_hdrcmplt,
        .iop_poll = ethif_poll,
        .iop_set_ifflags = ethif_set_ifflags,
        .iop_get_ifcap = ethif_get_ifcap,
        .iop_set_ifcap = ethif_set_ifcap,
        .iop_get_ifmedia = ethif_get_ifmedia,
        .iop_set_ifmedia = ethif_set_ifmedia,
        .iop_set_promisc = ethif_set_promisc,
        .iop_set_hwaddr = ethif_set_hwaddr,
        .iop_set_mtu = ethif_set_mtu,
};