/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2009-2011 Spectra Logic Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 * Authors: Justin T. Gibbs     (Spectra Logic Corporation)
 *          Alan Somers         (Spectra Logic Corporation)
 *          John Suykerbuyk     (Spectra Logic Corporation)
 */

#include <sys/cdefs.h>
#include <netinet/tcp.h>
/**
 * \file netback_unit_tests.c
 *
 * \brief Unit tests for the Xen netback driver.
 *
 * Due to the driver's use of static functions, these tests cannot be compiled
 * standalone; they must be #include'd from the driver's .c file.
 */

/** Helper macro used to snprintf to a buffer and update the buffer pointer */
#define SNCATF(buffer, buflen, ...) do {                                \
        size_t new_chars = snprintf(buffer, buflen, __VA_ARGS__);       \
        buffer += new_chars;                                            \
        /* be careful; snprintf's return value can be  > buflen */      \
        buflen -= MIN(buflen, new_chars);                               \
} while (0)

/* STRINGIFY and TOSTRING are used only to help turn __LINE__ into a string */
#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)

/**
 * Writes an error message to buffer if cond is false
 * Note the implied parameters buffer and
 * buflen
 */
#define XNB_ASSERT(cond) ({                                             \
        int passed = (cond);                                            \
        char *_buffer = (buffer);                                       \
        size_t _buflen = (buflen);                                      \
        if (! passed) {                                                 \
                strlcat(_buffer, __func__, _buflen);                    \
                strlcat(_buffer, ":" TOSTRING(__LINE__)                 \
                  " Assertion Error: " #cond "\n", _buflen);            \
        }                                                               \
        })

/**
 * The signature used by all testcases.  If the test writes anything
 * to buffer, then it will be considered a failure
 * \param buffer        Return storage for error messages
 * \param buflen        The space available in the buffer
 */
typedef void testcase_t(char *buffer, size_t buflen);

/**
 * Signature used by setup functions
 * \return nonzero on error
 */
typedef int setup_t(void);

typedef void teardown_t(void);

/** A simple test fixture comprising setup, teardown, and test */
struct test_fixture {
        /** Will be run before the test to allocate and initialize variables */
        setup_t *setup;

        /** Will be run if setup succeeds */
        testcase_t *test;

        /** Cleans up test data whether or not the setup succeeded */
        teardown_t *teardown;
};

typedef struct test_fixture test_fixture_t;

static int      xnb_get1pkt(struct xnb_pkt *pkt, size_t size, uint16_t flags);
static int      xnb_unit_test_runner(test_fixture_t const tests[], int ntests,
                                     char *buffer, size_t buflen);

static int __unused
null_setup(void) { return 0; }

static void __unused
null_teardown(void) { }

static setup_t setup_pvt_data;
static teardown_t teardown_pvt_data;
static testcase_t xnb_ring2pkt_emptyring;
static testcase_t xnb_ring2pkt_1req;
static testcase_t xnb_ring2pkt_2req;
static testcase_t xnb_ring2pkt_3req;
static testcase_t xnb_ring2pkt_extra;
static testcase_t xnb_ring2pkt_partial;
static testcase_t xnb_ring2pkt_wraps;
static testcase_t xnb_txpkt2rsp_emptypkt;
static testcase_t xnb_txpkt2rsp_1req;
static testcase_t xnb_txpkt2rsp_extra;
static testcase_t xnb_txpkt2rsp_long;
static testcase_t xnb_txpkt2rsp_invalid;
static testcase_t xnb_txpkt2rsp_error;
static testcase_t xnb_txpkt2rsp_wraps;
static testcase_t xnb_pkt2mbufc_empty;
static testcase_t xnb_pkt2mbufc_short;
static testcase_t xnb_pkt2mbufc_csum;
static testcase_t xnb_pkt2mbufc_1cluster;
static testcase_t xnb_pkt2mbufc_largecluster;
static testcase_t xnb_pkt2mbufc_2cluster;
static testcase_t xnb_txpkt2gnttab_empty;
static testcase_t xnb_txpkt2gnttab_short;
static testcase_t xnb_txpkt2gnttab_2req;
static testcase_t xnb_txpkt2gnttab_2cluster;
static testcase_t xnb_update_mbufc_short;
static testcase_t xnb_update_mbufc_2req;
static testcase_t xnb_update_mbufc_2cluster;
static testcase_t xnb_mbufc2pkt_empty;
static testcase_t xnb_mbufc2pkt_short;
static testcase_t xnb_mbufc2pkt_1cluster;
static testcase_t xnb_mbufc2pkt_2short;
static testcase_t xnb_mbufc2pkt_long;
static testcase_t xnb_mbufc2pkt_extra;
static testcase_t xnb_mbufc2pkt_nospace;
static testcase_t xnb_rxpkt2gnttab_empty;
static testcase_t xnb_rxpkt2gnttab_short;
static testcase_t xnb_rxpkt2gnttab_2req;
static testcase_t xnb_rxpkt2rsp_empty;
static testcase_t xnb_rxpkt2rsp_short;
static testcase_t xnb_rxpkt2rsp_extra;
static testcase_t xnb_rxpkt2rsp_2short;
static testcase_t xnb_rxpkt2rsp_2slots;
static testcase_t xnb_rxpkt2rsp_copyerror;
static testcase_t xnb_sscanf_llu;
static testcase_t xnb_sscanf_lld;
static testcase_t xnb_sscanf_hhu;
static testcase_t xnb_sscanf_hhd;
static testcase_t xnb_sscanf_hhn;

#if defined(INET) || defined(INET6)
/* TODO: add test cases for xnb_add_mbuf_cksum for IPV6 tcp and udp */
static testcase_t xnb_add_mbuf_cksum_arp;
static testcase_t xnb_add_mbuf_cksum_tcp;
static testcase_t xnb_add_mbuf_cksum_udp;
static testcase_t xnb_add_mbuf_cksum_icmp;
static testcase_t xnb_add_mbuf_cksum_tcp_swcksum;
static void     xnb_fill_eh_and_ip(struct mbuf *m, uint16_t ip_len,
                                   uint16_t ip_id, uint16_t ip_p,
                                   uint16_t ip_off, uint16_t ip_sum);
static void     xnb_fill_tcp(struct mbuf *m);
#endif /* INET || INET6 */

/** Private data used by unit tests */
static struct {
        gnttab_copy_table       gnttab;
        netif_rx_back_ring_t    rxb;
        netif_rx_front_ring_t   rxf;
        netif_tx_back_ring_t    txb;
        netif_tx_front_ring_t   txf;
        struct ifnet*           ifp;
        netif_rx_sring_t*       rxs;
        netif_tx_sring_t*       txs;
} xnb_unit_pvt;

static inline void safe_m_freem(struct mbuf **ppMbuf) {
        if (*ppMbuf != NULL) {
                m_freem(*ppMbuf);
                *ppMbuf = NULL;
        }
}

/**
 * The unit test runner.  It will run every supplied test and return an
 * output message as a string
 * \param tests         An array of tests.  Every test will be attempted.
 * \param ntests        The length of tests
 * \param buffer        Return storage for the result string
 * \param buflen        The length of buffer
 * \return              The number of tests that failed
 */
static int
xnb_unit_test_runner(test_fixture_t const tests[], int ntests, char *buffer,
                     size_t buflen)
{
        int i;
        int n_passes;
        int n_failures = 0;

        for (i = 0; i < ntests; i++) {
                int error = tests[i].setup();
                if (error != 0) {
                        SNCATF(buffer, buflen,
                            "Setup failed for test idx %d\n", i);
                        n_failures++;
                } else {
                        size_t new_chars;

                        tests[i].test(buffer, buflen);
                        new_chars = strnlen(buffer, buflen);
                        buffer += new_chars;
                        buflen -= new_chars;

                        if (new_chars > 0) {
                                n_failures++;
                        }
                }
                tests[i].teardown();
        }

        n_passes = ntests - n_failures;
        if (n_passes > 0) {
                SNCATF(buffer, buflen, "%d Tests Passed\n", n_passes);
        }
        if (n_failures > 0) {
                SNCATF(buffer, buflen, "%d Tests FAILED\n", n_failures);
        }

        return n_failures;
}

/** Number of unit tests.  Must match the length of the tests array below */
#define TOTAL_TESTS     (53)
/**
 * Max memory available for returning results.  400 chars/test should give
 * enough space for a five line error message for every test
 */
#define TOTAL_BUFLEN    (400 * TOTAL_TESTS + 2)

/**
 * Called from userspace by a sysctl.  Runs all internal unit tests, and
 * returns the results to userspace as a string
 * \param oidp  unused
 * \param arg1  pointer to an xnb_softc for a specific xnb device
 * \param arg2  unused
 * \param req   sysctl access structure
 * \return a string via the special SYSCTL_OUT macro.
 */

static int
xnb_unit_test_main(SYSCTL_HANDLER_ARGS) {
        test_fixture_t const tests[TOTAL_TESTS] = {
                {setup_pvt_data, xnb_ring2pkt_emptyring, teardown_pvt_data},
                {setup_pvt_data, xnb_ring2pkt_1req, teardown_pvt_data},
                {setup_pvt_data, xnb_ring2pkt_2req, teardown_pvt_data},
                {setup_pvt_data, xnb_ring2pkt_3req, teardown_pvt_data},
                {setup_pvt_data, xnb_ring2pkt_extra, teardown_pvt_data},
                {setup_pvt_data, xnb_ring2pkt_partial, teardown_pvt_data},
                {setup_pvt_data, xnb_ring2pkt_wraps, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_emptypkt, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_1req, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_extra, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_long, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_invalid, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_error, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2rsp_wraps, teardown_pvt_data},
                {setup_pvt_data, xnb_pkt2mbufc_empty, teardown_pvt_data},
                {setup_pvt_data, xnb_pkt2mbufc_short, teardown_pvt_data},
                {setup_pvt_data, xnb_pkt2mbufc_csum, teardown_pvt_data},
                {setup_pvt_data, xnb_pkt2mbufc_1cluster, teardown_pvt_data},
                {setup_pvt_data, xnb_pkt2mbufc_largecluster, teardown_pvt_data},
                {setup_pvt_data, xnb_pkt2mbufc_2cluster, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2gnttab_empty, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2gnttab_short, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2gnttab_2req, teardown_pvt_data},
                {setup_pvt_data, xnb_txpkt2gnttab_2cluster, teardown_pvt_data},
                {setup_pvt_data, xnb_update_mbufc_short, teardown_pvt_data},
                {setup_pvt_data, xnb_update_mbufc_2req, teardown_pvt_data},
                {setup_pvt_data, xnb_update_mbufc_2cluster, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_empty, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_short, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_1cluster, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_2short, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_long, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_extra, teardown_pvt_data},
                {setup_pvt_data, xnb_mbufc2pkt_nospace, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2gnttab_empty, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2gnttab_short, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2gnttab_2req, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2rsp_empty, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2rsp_short, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2rsp_extra, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2rsp_2short, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2rsp_2slots, teardown_pvt_data},
                {setup_pvt_data, xnb_rxpkt2rsp_copyerror, teardown_pvt_data},
#if defined(INET) || defined(INET6)
                {null_setup, xnb_add_mbuf_cksum_arp, null_teardown},
                {null_setup, xnb_add_mbuf_cksum_icmp, null_teardown},
                {null_setup, xnb_add_mbuf_cksum_tcp, null_teardown},
                {null_setup, xnb_add_mbuf_cksum_tcp_swcksum, null_teardown},
                {null_setup, xnb_add_mbuf_cksum_udp, null_teardown},
#endif
                {null_setup, xnb_sscanf_hhd, null_teardown},
                {null_setup, xnb_sscanf_hhu, null_teardown},
                {null_setup, xnb_sscanf_lld, null_teardown},
                {null_setup, xnb_sscanf_llu, null_teardown},
                {null_setup, xnb_sscanf_hhn, null_teardown},
        };
        /**
         * results is static so that the data will persist after this function
         * returns.  The sysctl code expects us to return a constant string.
         * \todo: the static variable is not thread safe.  Put a mutex around
         * it.
         */
        static char results[TOTAL_BUFLEN];

        /* empty the result strings */
        results[0] = 0;
        xnb_unit_test_runner(tests, TOTAL_TESTS, results, TOTAL_BUFLEN);

        return (SYSCTL_OUT(req, results, strnlen(results, TOTAL_BUFLEN)));
}

static int
setup_pvt_data(void)
{
        int error = 0;

        bzero(xnb_unit_pvt.gnttab, sizeof(xnb_unit_pvt.gnttab));

        xnb_unit_pvt.txs = malloc(PAGE_SIZE, M_XENNETBACK, M_WAITOK|M_ZERO);
        if (xnb_unit_pvt.txs != NULL) {
                SHARED_RING_INIT(xnb_unit_pvt.txs);
                BACK_RING_INIT(&xnb_unit_pvt.txb, xnb_unit_pvt.txs, PAGE_SIZE);
                FRONT_RING_INIT(&xnb_unit_pvt.txf, xnb_unit_pvt.txs, PAGE_SIZE);
        } else {
                error = 1;
        }

        xnb_unit_pvt.ifp = if_alloc(IFT_ETHER);
        if (xnb_unit_pvt.ifp == NULL) {
                error = 1;
        }

        xnb_unit_pvt.rxs = malloc(PAGE_SIZE, M_XENNETBACK, M_WAITOK|M_ZERO);
        if (xnb_unit_pvt.rxs != NULL) {
                SHARED_RING_INIT(xnb_unit_pvt.rxs);
                BACK_RING_INIT(&xnb_unit_pvt.rxb, xnb_unit_pvt.rxs, PAGE_SIZE);
                FRONT_RING_INIT(&xnb_unit_pvt.rxf, xnb_unit_pvt.rxs, PAGE_SIZE);
        } else {
                error = 1;
        }

        return error;
}

static void
teardown_pvt_data(void)
{
        if (xnb_unit_pvt.txs != NULL) {
                free(xnb_unit_pvt.txs, M_XENNETBACK);
        }
        if (xnb_unit_pvt.rxs != NULL) {
                free(xnb_unit_pvt.rxs, M_XENNETBACK);
        }
        if (xnb_unit_pvt.ifp != NULL) {
                if_free(xnb_unit_pvt.ifp);
        }
}

/**
 * Verify that xnb_ring2pkt will not consume any requests from an empty ring
 */
static void
xnb_ring2pkt_emptyring(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 0);
}

/**
 * Verify that xnb_ring2pkt can convert a single request packet correctly
 */
static void
xnb_ring2pkt_1req(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;
        struct netif_tx_request *req;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);

        req->flags = 0;
        req->size = 69; /* arbitrary number for test */
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 1);
        XNB_ASSERT(pkt.size == 69);
        XNB_ASSERT(pkt.car_size == 69);
        XNB_ASSERT(pkt.flags == 0);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.list_len == 1);
        XNB_ASSERT(pkt.car == 0);
}

/**
 * Verify that xnb_ring2pkt can convert a two request packet correctly.
 * This tests handling of the MORE_DATA flag and cdr
 */
static void
xnb_ring2pkt_2req(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;
        struct netif_tx_request *req;
        RING_IDX start_idx = xnb_unit_pvt.txf.req_prod_pvt;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 100;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 40;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 2);
        XNB_ASSERT(pkt.size == 100);
        XNB_ASSERT(pkt.car_size == 60);
        XNB_ASSERT(pkt.flags == 0);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.list_len == 2);
        XNB_ASSERT(pkt.car == start_idx);
        XNB_ASSERT(pkt.cdr == start_idx + 1);
}

/**
 * Verify that xnb_ring2pkt can convert a three request packet correctly
 */
static void
xnb_ring2pkt_3req(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;
        struct netif_tx_request *req;
        RING_IDX start_idx = xnb_unit_pvt.txf.req_prod_pvt;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 200;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 40;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 50;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 3);
        XNB_ASSERT(pkt.size == 200);
        XNB_ASSERT(pkt.car_size == 110);
        XNB_ASSERT(pkt.flags == 0);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.list_len == 3);
        XNB_ASSERT(pkt.car == start_idx);
        XNB_ASSERT(pkt.cdr == start_idx + 1);
        XNB_ASSERT(RING_GET_REQUEST(&xnb_unit_pvt.txb, pkt.cdr + 1) == req);
}

/**
 * Verify that xnb_ring2pkt can read extra inf
 */
static void
xnb_ring2pkt_extra(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;
        struct netif_tx_request *req;
        struct netif_extra_info *ext;
        RING_IDX start_idx = xnb_unit_pvt.txf.req_prod_pvt;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_extra_info | NETTXF_more_data;
        req->size = 150;
        xnb_unit_pvt.txf.req_prod_pvt++;

        ext = (struct netif_extra_info*) RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        ext->flags = 0;
        ext->type = XEN_NETIF_EXTRA_TYPE_GSO;
        ext->u.gso.size = 250;
        ext->u.gso.type = XEN_NETIF_GSO_TYPE_TCPV4;
        ext->u.gso.features = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 50;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 3);
        XNB_ASSERT(pkt.extra.flags == 0);
        XNB_ASSERT(pkt.extra.type == XEN_NETIF_EXTRA_TYPE_GSO);
        XNB_ASSERT(pkt.extra.u.gso.size == 250);
        XNB_ASSERT(pkt.extra.u.gso.type = XEN_NETIF_GSO_TYPE_TCPV4);
        XNB_ASSERT(pkt.size == 150);
        XNB_ASSERT(pkt.car_size == 100);
        XNB_ASSERT(pkt.flags == NETTXF_extra_info);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.list_len == 2);
        XNB_ASSERT(pkt.car == start_idx);
        XNB_ASSERT(pkt.cdr == start_idx + 2);
        XNB_ASSERT(RING_GET_REQUEST(&xnb_unit_pvt.txb, pkt.cdr) == req);
}

/**
 * Verify that xnb_ring2pkt will consume no requests if the entire packet is
 * not yet in the ring
 */
static void
xnb_ring2pkt_partial(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;
        struct netif_tx_request *req;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 150;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 0);
        XNB_ASSERT(! xnb_pkt_is_valid(&pkt));
}

/**
 * Verity that xnb_ring2pkt can read a packet whose requests wrap around
 * the end of the ring
 */
static void
xnb_ring2pkt_wraps(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int num_consumed;
        struct netif_tx_request *req;
        unsigned int rsize;

        /*
         * Manually tweak the ring indices to create a ring with no responses
         * and the next request slot at position 2 from the end
         */
        rsize = RING_SIZE(&xnb_unit_pvt.txf);
        xnb_unit_pvt.txf.req_prod_pvt = rsize - 2;
        xnb_unit_pvt.txf.rsp_cons = rsize - 2;
        xnb_unit_pvt.txs->req_prod = rsize - 2;
        xnb_unit_pvt.txs->req_event = rsize - 1;
        xnb_unit_pvt.txs->rsp_prod = rsize - 2;
        xnb_unit_pvt.txs->rsp_event = rsize - 1;
        xnb_unit_pvt.txb.rsp_prod_pvt = rsize - 2;
        xnb_unit_pvt.txb.req_cons = rsize - 2;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 550;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 100;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 50;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        XNB_ASSERT(num_consumed == 3);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.list_len == 3);
        XNB_ASSERT(RING_GET_REQUEST(&xnb_unit_pvt.txb, pkt.cdr + 1) == req);
}

/**
 * xnb_txpkt2rsp should do nothing for an empty packet
 */
static void
xnb_txpkt2rsp_emptypkt(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        netif_tx_back_ring_t txb_backup = xnb_unit_pvt.txb;
        netif_tx_sring_t txs_backup = *xnb_unit_pvt.txs;
        pkt.list_len = 0;

        /* must call xnb_ring2pkt just to intialize pkt */
        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);
        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 0);
        XNB_ASSERT(
            memcmp(&txb_backup, &xnb_unit_pvt.txb, sizeof(txb_backup)) == 0);
        XNB_ASSERT(
            memcmp(&txs_backup, xnb_unit_pvt.txs, sizeof(txs_backup)) == 0);
}

/**
 * xnb_txpkt2rsp responding to one request
 */
static void
xnb_txpkt2rsp_1req(char *buffer, size_t buflen)
{
        uint16_t num_consumed;
        struct xnb_pkt pkt;
        struct netif_tx_request *req;
        struct netif_tx_response *rsp;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 1000;
        req->flags = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        xnb_unit_pvt.txb.req_cons += num_consumed;

        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 0);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb, xnb_unit_pvt.txf.rsp_cons);

        XNB_ASSERT(
            xnb_unit_pvt.txb.rsp_prod_pvt == xnb_unit_pvt.txs->req_prod);
        XNB_ASSERT(rsp->id == req->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_OKAY);
};

/**
 * xnb_txpkt2rsp responding to 1 data request and 1 extra info
 */
static void
xnb_txpkt2rsp_extra(char *buffer, size_t buflen)
{
        uint16_t num_consumed;
        struct xnb_pkt pkt;
        struct netif_tx_request *req;
        netif_extra_info_t *ext;
        struct netif_tx_response *rsp;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 1000;
        req->flags = NETTXF_extra_info;
        req->id = 69;
        xnb_unit_pvt.txf.req_prod_pvt++;

        ext = (netif_extra_info_t*) RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        ext->type = XEN_NETIF_EXTRA_TYPE_GSO;
        ext->flags = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        xnb_unit_pvt.txb.req_cons += num_consumed;

        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 0);

        XNB_ASSERT(
            xnb_unit_pvt.txb.rsp_prod_pvt == xnb_unit_pvt.txs->req_prod);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb, xnb_unit_pvt.txf.rsp_cons);
        XNB_ASSERT(rsp->id == req->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_OKAY);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb,
            xnb_unit_pvt.txf.rsp_cons + 1);
        XNB_ASSERT(rsp->status == NETIF_RSP_NULL);
};

/**
 * xnb_pkg2rsp responding to 3 data requests and 1 extra info
 */
static void
xnb_txpkt2rsp_long(char *buffer, size_t buflen)
{
        uint16_t num_consumed;
        struct xnb_pkt pkt;
        struct netif_tx_request *req;
        netif_extra_info_t *ext;
        struct netif_tx_response *rsp;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 1000;
        req->flags = NETTXF_extra_info | NETTXF_more_data;
        req->id = 254;
        xnb_unit_pvt.txf.req_prod_pvt++;

        ext = (netif_extra_info_t*) RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        ext->type = XEN_NETIF_EXTRA_TYPE_GSO;
        ext->flags = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 300;
        req->flags = NETTXF_more_data;
        req->id = 1034;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 400;
        req->flags = 0;
        req->id = 34;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        xnb_unit_pvt.txb.req_cons += num_consumed;

        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 0);

        XNB_ASSERT(
            xnb_unit_pvt.txb.rsp_prod_pvt == xnb_unit_pvt.txs->req_prod);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb, xnb_unit_pvt.txf.rsp_cons);
        XNB_ASSERT(rsp->id ==
            RING_GET_REQUEST(&xnb_unit_pvt.txf, 0)->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_OKAY);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb,
            xnb_unit_pvt.txf.rsp_cons + 1);
        XNB_ASSERT(rsp->status == NETIF_RSP_NULL);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb,
            xnb_unit_pvt.txf.rsp_cons + 2);
        XNB_ASSERT(rsp->id ==
            RING_GET_REQUEST(&xnb_unit_pvt.txf, 2)->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_OKAY);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb,
            xnb_unit_pvt.txf.rsp_cons + 3);
        XNB_ASSERT(rsp->id ==
            RING_GET_REQUEST(&xnb_unit_pvt.txf, 3)->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_OKAY);
}

/**
 * xnb_txpkt2rsp responding to an invalid packet.
 * Note: this test will result in an error message being printed to the console
 * such as:
 * xnb(xnb_ring2pkt:1306): Unknown extra info type 255.  Discarding packet
 */
static void
xnb_txpkt2rsp_invalid(char *buffer, size_t buflen)
{
        uint16_t num_consumed;
        struct xnb_pkt pkt;
        struct netif_tx_request *req;
        netif_extra_info_t *ext;
        struct netif_tx_response *rsp;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 1000;
        req->flags = NETTXF_extra_info;
        req->id = 69;
        xnb_unit_pvt.txf.req_prod_pvt++;

        ext = (netif_extra_info_t*) RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        ext->type = 0xFF;       /* Invalid extra type */
        ext->flags = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        xnb_unit_pvt.txb.req_cons += num_consumed;
        XNB_ASSERT(! xnb_pkt_is_valid(&pkt));

        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 0);

        XNB_ASSERT(
            xnb_unit_pvt.txb.rsp_prod_pvt == xnb_unit_pvt.txs->req_prod);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb, xnb_unit_pvt.txf.rsp_cons);
        XNB_ASSERT(rsp->id == req->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_ERROR);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb,
            xnb_unit_pvt.txf.rsp_cons + 1);
        XNB_ASSERT(rsp->status == NETIF_RSP_NULL);
};

/**
 * xnb_txpkt2rsp responding to one request which caused an error
 */
static void
xnb_txpkt2rsp_error(char *buffer, size_t buflen)
{
        uint16_t num_consumed;
        struct xnb_pkt pkt;
        struct netif_tx_request *req;
        struct netif_tx_response *rsp;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->size = 1000;
        req->flags = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        num_consumed = xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
        xnb_unit_pvt.txb.req_cons += num_consumed;

        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 1);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb, xnb_unit_pvt.txf.rsp_cons);

        XNB_ASSERT(
            xnb_unit_pvt.txb.rsp_prod_pvt == xnb_unit_pvt.txs->req_prod);
        XNB_ASSERT(rsp->id == req->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_ERROR);
};

/**
 * xnb_txpkt2rsp's responses wrap around the end of the ring
 */
static void
xnb_txpkt2rsp_wraps(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        struct netif_tx_request *req;
        struct netif_tx_response *rsp;
        unsigned int rsize;

        /*
         * Manually tweak the ring indices to create a ring with no responses
         * and the next request slot at position 2 from the end
         */
        rsize = RING_SIZE(&xnb_unit_pvt.txf);
        xnb_unit_pvt.txf.req_prod_pvt = rsize - 2;
        xnb_unit_pvt.txf.rsp_cons = rsize - 2;
        xnb_unit_pvt.txs->req_prod = rsize - 2;
        xnb_unit_pvt.txs->req_event = rsize - 1;
        xnb_unit_pvt.txs->rsp_prod = rsize - 2;
        xnb_unit_pvt.txs->rsp_event = rsize - 1;
        xnb_unit_pvt.txb.rsp_prod_pvt = rsize - 2;
        xnb_unit_pvt.txb.req_cons = rsize - 2;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 550;
        req->id = 1;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 100;
        req->id = 2;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 50;
        req->id = 3;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        xnb_txpkt2rsp(&pkt, &xnb_unit_pvt.txb, 0);

        XNB_ASSERT(
            xnb_unit_pvt.txb.rsp_prod_pvt == xnb_unit_pvt.txs->req_prod);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.txb,
            xnb_unit_pvt.txf.rsp_cons + 2);
        XNB_ASSERT(rsp->id == req->id);
        XNB_ASSERT(rsp->status == NETIF_RSP_OKAY);
}

/**
 * Helper function used to setup pkt2mbufc tests
 * \param size     size in bytes of the single request to push to the ring
 * \param flags         optional flags to put in the netif request
 * \param[out] pkt the returned packet object
 * \return number of requests consumed from the ring
 */
static int
xnb_get1pkt(struct xnb_pkt *pkt, size_t size, uint16_t flags)
{
        struct netif_tx_request *req;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = flags;
        req->size = size;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        return xnb_ring2pkt(pkt, &xnb_unit_pvt.txb,
                                    xnb_unit_pvt.txb.req_cons);
}

/**
 * xnb_pkt2mbufc on an empty packet
 */
static void
xnb_pkt2mbufc_empty(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;
        pkt.list_len = 0;

        /* must call xnb_ring2pkt just to intialize pkt */
        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);
        pkt.size = 0;
        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_pkt2mbufc on short packet that can fit in an mbuf internal buffer
 */
static void
xnb_pkt2mbufc_short(char *buffer, size_t buflen)
{
        const size_t size = MINCLSIZE - 1;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        xnb_get1pkt(&pkt, size, 0);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        XNB_ASSERT(M_TRAILINGSPACE(pMbuf) >= size);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_pkt2mbufc on short packet whose checksum was validated by the netfron
 */
static void
xnb_pkt2mbufc_csum(char *buffer, size_t buflen)
{
        const size_t size = MINCLSIZE - 1;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        xnb_get1pkt(&pkt, size, NETTXF_data_validated);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        XNB_ASSERT(M_TRAILINGSPACE(pMbuf) >= size);
        XNB_ASSERT(pMbuf->m_pkthdr.csum_flags & CSUM_IP_CHECKED);
        XNB_ASSERT(pMbuf->m_pkthdr.csum_flags & CSUM_IP_VALID);
        XNB_ASSERT(pMbuf->m_pkthdr.csum_flags & CSUM_DATA_VALID);
        XNB_ASSERT(pMbuf->m_pkthdr.csum_flags & CSUM_PSEUDO_HDR);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_pkt2mbufc on packet that can fit in one cluster
 */
static void
xnb_pkt2mbufc_1cluster(char *buffer, size_t buflen)
{
        const size_t size = MINCLSIZE;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        xnb_get1pkt(&pkt, size, 0);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        XNB_ASSERT(M_TRAILINGSPACE(pMbuf) >= size);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_pkt2mbufc on packet that cannot fit in one regular cluster
 */
static void
xnb_pkt2mbufc_largecluster(char *buffer, size_t buflen)
{
        const size_t size = MCLBYTES + 1;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        xnb_get1pkt(&pkt, size, 0);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        XNB_ASSERT(M_TRAILINGSPACE(pMbuf) >= size);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_pkt2mbufc on packet that cannot fit in one clusters
 */
static void
xnb_pkt2mbufc_2cluster(char *buffer, size_t buflen)
{
        const size_t size = 2 * MCLBYTES + 1;
        size_t space = 0;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;
        struct mbuf *m;

        xnb_get1pkt(&pkt, size, 0);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);

        for (m = pMbuf; m != NULL; m = m->m_next) {
                space += M_TRAILINGSPACE(m);
        }
        XNB_ASSERT(space >= size);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_txpkt2gnttab on an empty packet.  Should return empty gnttab
 */
static void
xnb_txpkt2gnttab_empty(char *buffer, size_t buflen)
{
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;
        pkt.list_len = 0;

        /* must call xnb_ring2pkt just to intialize pkt */
        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);
        pkt.size = 0;
        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);
        XNB_ASSERT(n_entries == 0);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_txpkt2gnttab on a short packet, that can fit in one mbuf internal buffer
 * and has one request
 */
static void
xnb_txpkt2gnttab_short(char *buffer, size_t buflen)
{
        const size_t size = MINCLSIZE - 1;
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        struct netif_tx_request *req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = size;
        req->gref = 7;
        req->offset = 17;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);
        XNB_ASSERT(n_entries == 1);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].len == size);
        /* flags should indicate gref's for source */
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].flags & GNTCOPY_source_gref);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.offset == req->offset);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.domid == DOMID_SELF);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].dest.offset == virt_to_offset(
              mtod(pMbuf, vm_offset_t)));
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].dest.u.gmfn ==
                virt_to_mfn(mtod(pMbuf, vm_offset_t)));
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].dest.domid == DOMID_FIRST_RESERVED);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_txpkt2gnttab on a packet with two requests, that can fit into a single
 * mbuf cluster
 */
static void
xnb_txpkt2gnttab_2req(char *buffer, size_t buflen)
{
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        struct netif_tx_request *req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 1900;
        req->gref = 7;
        req->offset = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 500;
        req->gref = 8;
        req->offset = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);

        XNB_ASSERT(n_entries == 2);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].len == 1400);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].dest.offset == virt_to_offset(
              mtod(pMbuf, vm_offset_t)));

        XNB_ASSERT(xnb_unit_pvt.gnttab[1].len == 500);
        XNB_ASSERT(xnb_unit_pvt.gnttab[1].dest.offset == virt_to_offset(
              mtod(pMbuf, vm_offset_t) + 1400));
        safe_m_freem(&pMbuf);
}

/**
 * xnb_txpkt2gnttab on a single request that spans two mbuf clusters
 */
static void
xnb_txpkt2gnttab_2cluster(char *buffer, size_t buflen)
{
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;
        const uint16_t data_this_transaction = (MCLBYTES*2) + 1;

        struct netif_tx_request *req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = data_this_transaction;
        req->gref = 8;
        req->offset = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);
        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        XNB_ASSERT(pMbuf != NULL);
        if (pMbuf == NULL)
                return;

        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);

        if (M_TRAILINGSPACE(pMbuf) == MCLBYTES) {
                /* there should be three mbufs and three gnttab entries */
                XNB_ASSERT(n_entries == 3);
                XNB_ASSERT(xnb_unit_pvt.gnttab[0].len == MCLBYTES);
                XNB_ASSERT(
                    xnb_unit_pvt.gnttab[0].dest.offset == virt_to_offset(
                      mtod(pMbuf, vm_offset_t)));
                XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.offset == 0);

                XNB_ASSERT(xnb_unit_pvt.gnttab[1].len == MCLBYTES);
                XNB_ASSERT(
                    xnb_unit_pvt.gnttab[1].dest.offset == virt_to_offset(
                      mtod(pMbuf->m_next, vm_offset_t)));
                XNB_ASSERT(xnb_unit_pvt.gnttab[1].source.offset == MCLBYTES);

                XNB_ASSERT(xnb_unit_pvt.gnttab[2].len == 1);
                XNB_ASSERT(
                    xnb_unit_pvt.gnttab[2].dest.offset == virt_to_offset(
                      mtod(pMbuf->m_next, vm_offset_t)));
                XNB_ASSERT(xnb_unit_pvt.gnttab[2].source.offset == 2 *
                            MCLBYTES);
        } else if (M_TRAILINGSPACE(pMbuf) == 2 * MCLBYTES) {
                /* there should be two mbufs and two gnttab entries */
                XNB_ASSERT(n_entries == 2);
                XNB_ASSERT(xnb_unit_pvt.gnttab[0].len == 2 * MCLBYTES);
                XNB_ASSERT(
                    xnb_unit_pvt.gnttab[0].dest.offset == virt_to_offset(
                      mtod(pMbuf, vm_offset_t)));
                XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.offset == 0);

                XNB_ASSERT(xnb_unit_pvt.gnttab[1].len == 1);
                XNB_ASSERT(
                    xnb_unit_pvt.gnttab[1].dest.offset == virt_to_offset(
                      mtod(pMbuf->m_next, vm_offset_t)));
                XNB_ASSERT(
                    xnb_unit_pvt.gnttab[1].source.offset == 2 * MCLBYTES);

        } else {
                /* should never get here */
                XNB_ASSERT(0);
        }
        m_freem(pMbuf);
}

/**
 * xnb_update_mbufc on a short packet that only has one gnttab entry
 */
static void
xnb_update_mbufc_short(char *buffer, size_t buflen)
{
        const size_t size = MINCLSIZE - 1;
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        struct netif_tx_request *req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = size;
        req->gref = 7;
        req->offset = 17;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);

        /* Update grant table's status fields as the hypervisor call would */
        xnb_unit_pvt.gnttab[0].status = GNTST_okay;

        xnb_update_mbufc(pMbuf, xnb_unit_pvt.gnttab, n_entries);
        XNB_ASSERT(pMbuf->m_len == size);
        XNB_ASSERT(pMbuf->m_pkthdr.len == size);
        safe_m_freem(&pMbuf);
}

/**
 * xnb_update_mbufc on a packet with two requests, that can fit into a single
 * mbuf cluster
 */
static void
xnb_update_mbufc_2req(char *buffer, size_t buflen)
{
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;

        struct netif_tx_request *req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = NETTXF_more_data;
        req->size = 1900;
        req->gref = 7;
        req->offset = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = 500;
        req->gref = 8;
        req->offset = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);

        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);

        /* Update grant table's status fields as the hypervisor call would */
        xnb_unit_pvt.gnttab[0].status = GNTST_okay;
        xnb_unit_pvt.gnttab[1].status = GNTST_okay;

        xnb_update_mbufc(pMbuf, xnb_unit_pvt.gnttab, n_entries);
        XNB_ASSERT(n_entries == 2);
        XNB_ASSERT(pMbuf->m_pkthdr.len == 1900);
        XNB_ASSERT(pMbuf->m_len == 1900);

        safe_m_freem(&pMbuf);
}

/**
 * xnb_update_mbufc on a single request that spans two mbuf clusters
 */
static void
xnb_update_mbufc_2cluster(char *buffer, size_t buflen)
{
        int i;
        int n_entries;
        struct xnb_pkt pkt;
        struct mbuf *pMbuf;
        const uint16_t data_this_transaction = (MCLBYTES*2) + 1;

        struct netif_tx_request *req = RING_GET_REQUEST(&xnb_unit_pvt.txf,
            xnb_unit_pvt.txf.req_prod_pvt);
        req->flags = 0;
        req->size = data_this_transaction;
        req->gref = 8;
        req->offset = 0;
        xnb_unit_pvt.txf.req_prod_pvt++;

        RING_PUSH_REQUESTS(&xnb_unit_pvt.txf);
        xnb_ring2pkt(&pkt, &xnb_unit_pvt.txb, xnb_unit_pvt.txb.req_cons);

        pMbuf = xnb_pkt2mbufc(&pkt, xnb_unit_pvt.ifp);
        n_entries = xnb_txpkt2gnttab(&pkt, pMbuf, xnb_unit_pvt.gnttab,
            &xnb_unit_pvt.txb, DOMID_FIRST_RESERVED);

        /* Update grant table's status fields */
        for (i = 0; i < n_entries; i++) {
                xnb_unit_pvt.gnttab[0].status = GNTST_okay;
        }
        xnb_update_mbufc(pMbuf, xnb_unit_pvt.gnttab, n_entries);

        if (n_entries == 3) {
                /* there should be three mbufs and three gnttab entries */
                XNB_ASSERT(pMbuf->m_pkthdr.len == data_this_transaction);
                XNB_ASSERT(pMbuf->m_len == MCLBYTES);
                XNB_ASSERT(pMbuf->m_next->m_len == MCLBYTES);
                XNB_ASSERT(pMbuf->m_next->m_next->m_len == 1);
        } else if (n_entries == 2) {
                /* there should be two mbufs and two gnttab entries */
                XNB_ASSERT(n_entries == 2);
                XNB_ASSERT(pMbuf->m_pkthdr.len == data_this_transaction);
                XNB_ASSERT(pMbuf->m_len == 2 * MCLBYTES);
                XNB_ASSERT(pMbuf->m_next->m_len == 1);
        } else {
                /* should never get here */
                XNB_ASSERT(0);
        }
        safe_m_freem(&pMbuf);
}

/** xnb_mbufc2pkt on an empty mbufc */
static void
xnb_mbufc2pkt_empty(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        int free_slots = 64;
        struct mbuf *mbuf;

        mbuf = m_get(M_WAITOK, MT_DATA);
        /*
         * note: it is illegal to set M_PKTHDR on a mbuf with no data.  Doing so
         * will cause m_freem to segfault
         */
        XNB_ASSERT(mbuf->m_len == 0);

        xnb_mbufc2pkt(mbuf, &pkt, 0, free_slots);
        XNB_ASSERT(! xnb_pkt_is_valid(&pkt));

        safe_m_freem(&mbuf);
}

/** xnb_mbufc2pkt on a short mbufc */
static void
xnb_mbufc2pkt_short(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        size_t size = 128;
        int free_slots = 64;
        RING_IDX start = 9;
        struct mbuf *mbuf;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        mbuf->m_len = size;

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.size == size);
        XNB_ASSERT(pkt.car_size == size);
        XNB_ASSERT(! (pkt.flags &
              (NETRXF_more_data | NETRXF_extra_info)));
        XNB_ASSERT(pkt.list_len == 1);
        XNB_ASSERT(pkt.car == start);

        safe_m_freem(&mbuf);
}

/** xnb_mbufc2pkt on a single mbuf with an mbuf cluster */
static void
xnb_mbufc2pkt_1cluster(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        size_t size = MCLBYTES;
        int free_slots = 32;
        RING_IDX start = 12;
        struct mbuf *mbuf;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        mbuf->m_len = size;

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.size == size);
        XNB_ASSERT(pkt.car_size == size);
        XNB_ASSERT(! (pkt.flags &
              (NETRXF_more_data | NETRXF_extra_info)));
        XNB_ASSERT(pkt.list_len == 1);
        XNB_ASSERT(pkt.car == start);

        safe_m_freem(&mbuf);
}

/** xnb_mbufc2pkt on a two-mbuf chain with short data regions */
static void
xnb_mbufc2pkt_2short(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        size_t size1 = MHLEN - 5;
        size_t size2 = MHLEN - 15;
        int free_slots = 32;
        RING_IDX start = 14;
        struct mbuf *mbufc, *mbufc2;

        mbufc = m_getm(NULL, size1, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc != NULL);
        if (mbufc == NULL)
                return;
        mbufc->m_flags |= M_PKTHDR;

        mbufc2 = m_getm(mbufc, size2, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc2 != NULL);
        if (mbufc2 == NULL) {
                safe_m_freem(&mbufc);
                return;
        }
        mbufc2->m_pkthdr.len = size1 + size2;
        mbufc2->m_len = size1;

        xnb_mbufc2pkt(mbufc2, &pkt, start, free_slots);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.size == size1 + size2);
        XNB_ASSERT(pkt.car == start);
        /*
         * The second m_getm may allocate a new mbuf and append
         * it to the chain, or it may simply extend the first mbuf.
         */
        if (mbufc2->m_next != NULL) {
                XNB_ASSERT(pkt.car_size == size1);
                XNB_ASSERT(pkt.list_len == 1);
                XNB_ASSERT(pkt.cdr == start + 1);
        }

        safe_m_freem(&mbufc2);
}

/** xnb_mbufc2pkt on a mbuf chain with >1 mbuf cluster */
static void
xnb_mbufc2pkt_long(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        size_t size = 14 * MCLBYTES / 3;
        size_t size_remaining;
        int free_slots = 15;
        RING_IDX start = 3;
        struct mbuf *mbufc, *m;

        mbufc = m_getm(NULL, size, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc != NULL);
        if (mbufc == NULL)
                return;
        mbufc->m_flags |= M_PKTHDR;

        mbufc->m_pkthdr.len = size;
        size_remaining = size;
        for (m = mbufc; m != NULL; m = m->m_next) {
                m->m_len = MAX(M_TRAILINGSPACE(m), size_remaining);
                size_remaining -= m->m_len;
        }

        xnb_mbufc2pkt(mbufc, &pkt, start, free_slots);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.size == size);
        XNB_ASSERT(pkt.car == start);
        XNB_ASSERT(pkt.car_size = mbufc->m_len);
        /*
         * There should be >1 response in the packet, and there is no
         * extra info.
         */
        XNB_ASSERT(! (pkt.flags & NETRXF_extra_info));
        XNB_ASSERT(pkt.cdr == pkt.car + 1);

        safe_m_freem(&mbufc);
}

/** xnb_mbufc2pkt on a mbuf chain with >1 mbuf cluster and extra info */
static void
xnb_mbufc2pkt_extra(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        size_t size = 14 * MCLBYTES / 3;
        size_t size_remaining;
        int free_slots = 15;
        RING_IDX start = 3;
        struct mbuf *mbufc, *m;

        mbufc = m_getm(NULL, size, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc != NULL);
        if (mbufc == NULL)
                return;

        mbufc->m_flags |= M_PKTHDR;
        mbufc->m_pkthdr.len = size;
        mbufc->m_pkthdr.csum_flags |= CSUM_TSO;
        mbufc->m_pkthdr.tso_segsz = TCP_MSS - 40;
        size_remaining = size;
        for (m = mbufc; m != NULL; m = m->m_next) {
                m->m_len = MAX(M_TRAILINGSPACE(m), size_remaining);
                size_remaining -= m->m_len;
        }

        xnb_mbufc2pkt(mbufc, &pkt, start, free_slots);
        XNB_ASSERT(xnb_pkt_is_valid(&pkt));
        XNB_ASSERT(pkt.size == size);
        XNB_ASSERT(pkt.car == start);
        XNB_ASSERT(pkt.car_size = mbufc->m_len);
        /* There should be >1 response in the packet, there is extra info */
        XNB_ASSERT(pkt.flags & NETRXF_extra_info);
        XNB_ASSERT(pkt.flags & NETRXF_data_validated);
        XNB_ASSERT(pkt.cdr == pkt.car + 2);
        XNB_ASSERT(pkt.extra.u.gso.size = mbufc->m_pkthdr.tso_segsz);
        XNB_ASSERT(pkt.extra.type == XEN_NETIF_EXTRA_TYPE_GSO);
        XNB_ASSERT(! (pkt.extra.flags & XEN_NETIF_EXTRA_FLAG_MORE));

        safe_m_freem(&mbufc);
}

/** xnb_mbufc2pkt with insufficient space in the ring */
static void
xnb_mbufc2pkt_nospace(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        size_t size = 14 * MCLBYTES / 3;
        size_t size_remaining;
        int free_slots = 2;
        RING_IDX start = 3;
        struct mbuf *mbufc, *m;
        int error;

        mbufc = m_getm(NULL, size, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc != NULL);
        if (mbufc == NULL)
                return;
        mbufc->m_flags |= M_PKTHDR;

        mbufc->m_pkthdr.len = size;
        size_remaining = size;
        for (m = mbufc; m != NULL; m = m->m_next) {
                m->m_len = MAX(M_TRAILINGSPACE(m), size_remaining);
                size_remaining -= m->m_len;
        }

        error = xnb_mbufc2pkt(mbufc, &pkt, start, free_slots);
        XNB_ASSERT(error == EAGAIN);
        XNB_ASSERT(! xnb_pkt_is_valid(&pkt));

        safe_m_freem(&mbufc);
}

/**
 * xnb_rxpkt2gnttab on an empty packet.  Should return empty gnttab
 */
static void
xnb_rxpkt2gnttab_empty(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries;
        int free_slots = 60;
        struct mbuf *mbuf;

        mbuf = m_get(M_WAITOK, MT_DATA);

        xnb_mbufc2pkt(mbuf, &pkt, 0, free_slots);
        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        XNB_ASSERT(nr_entries == 0);

        safe_m_freem(&mbuf);
}

/** xnb_rxpkt2gnttab on a short packet without extra data */
static void
xnb_rxpkt2gnttab_short(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        int nr_entries;
        size_t size = 128;
        int free_slots = 60;
        RING_IDX start = 9;
        struct netif_rx_request *req;
        struct mbuf *mbuf;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        mbuf->m_len = size;

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf,
                               xnb_unit_pvt.txf.req_prod_pvt);
        req->gref = 7;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                                      &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        XNB_ASSERT(nr_entries == 1);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].len == size);
        /* flags should indicate gref's for dest */
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].flags & GNTCOPY_dest_gref);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].dest.offset == 0);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.domid == DOMID_SELF);
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.offset == virt_to_offset(
                   mtod(mbuf, vm_offset_t)));
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].source.u.gmfn ==
                   virt_to_mfn(mtod(mbuf, vm_offset_t)));
        XNB_ASSERT(xnb_unit_pvt.gnttab[0].dest.domid == DOMID_FIRST_RESERVED);

        safe_m_freem(&mbuf);
}

/**
 * xnb_rxpkt2gnttab on a packet with two different mbufs in a single chai
 */
static void
xnb_rxpkt2gnttab_2req(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries;
        int i, num_mbufs;
        size_t total_granted_size = 0;
        size_t size = MJUMPAGESIZE + 1;
        int free_slots = 60;
        RING_IDX start = 11;
        struct netif_rx_request *req;
        struct mbuf *mbuf, *m;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        mbuf->m_len = size;

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);

        for (i = 0, m=mbuf; m != NULL; i++, m = m->m_next) {
                req = RING_GET_REQUEST(&xnb_unit_pvt.rxf,
                    xnb_unit_pvt.txf.req_prod_pvt);
                req->gref = i;
                req->id = 5;
        }
        num_mbufs = i;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        XNB_ASSERT(nr_entries >= num_mbufs);
        for (i = 0; i < nr_entries; i++) {
                int end_offset = xnb_unit_pvt.gnttab[i].len +
                        xnb_unit_pvt.gnttab[i].dest.offset;
                XNB_ASSERT(end_offset <= PAGE_SIZE);
                total_granted_size += xnb_unit_pvt.gnttab[i].len;
        }
        XNB_ASSERT(total_granted_size == size);
}

/**
 * xnb_rxpkt2rsp on an empty packet.  Shouldn't make any response
 */
static void
xnb_rxpkt2rsp_empty(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries;
        int nr_reqs;
        int free_slots = 60;
        netif_rx_back_ring_t rxb_backup = xnb_unit_pvt.rxb;
        netif_rx_sring_t rxs_backup = *xnb_unit_pvt.rxs;
        struct mbuf *mbuf;

        mbuf = m_get(M_WAITOK, MT_DATA);

        xnb_mbufc2pkt(mbuf, &pkt, 0, free_slots);
        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        nr_reqs = xnb_rxpkt2rsp(&pkt, xnb_unit_pvt.gnttab, nr_entries,
            &xnb_unit_pvt.rxb);
        XNB_ASSERT(nr_reqs == 0);
        XNB_ASSERT(
            memcmp(&rxb_backup, &xnb_unit_pvt.rxb, sizeof(rxb_backup)) == 0);
        XNB_ASSERT(
            memcmp(&rxs_backup, xnb_unit_pvt.rxs, sizeof(rxs_backup)) == 0);

        safe_m_freem(&mbuf);
}

/**
 * xnb_rxpkt2rsp on a short packet with no extras
 */
static void
xnb_rxpkt2rsp_short(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries, nr_reqs;
        size_t size = 128;
        int free_slots = 60;
        RING_IDX start = 5;
        struct netif_rx_request *req;
        struct netif_rx_response *rsp;
        struct mbuf *mbuf;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        mbuf->m_len = size;

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start);
        req->gref = 7;
        xnb_unit_pvt.rxb.req_cons = start;
        xnb_unit_pvt.rxb.rsp_prod_pvt = start;
        xnb_unit_pvt.rxs->req_prod = start + 1;
        xnb_unit_pvt.rxs->rsp_prod = start;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        nr_reqs = xnb_rxpkt2rsp(&pkt, xnb_unit_pvt.gnttab, nr_entries,
            &xnb_unit_pvt.rxb);

        XNB_ASSERT(nr_reqs == 1);
        XNB_ASSERT(xnb_unit_pvt.rxb.rsp_prod_pvt == start + 1);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start);
        XNB_ASSERT(rsp->id == req->id);
        XNB_ASSERT(rsp->offset == 0);
        XNB_ASSERT((rsp->flags & (NETRXF_more_data | NETRXF_extra_info)) == 0);
        XNB_ASSERT(rsp->status == size);

        safe_m_freem(&mbuf);
}

/**
 * xnb_rxpkt2rsp with extra data
 */
static void
xnb_rxpkt2rsp_extra(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries, nr_reqs;
        size_t size = 14;
        int free_slots = 15;
        RING_IDX start = 3;
        uint16_t id = 49;
        uint16_t gref = 65;
        uint16_t mss = TCP_MSS - 40;
        struct mbuf *mbufc;
        struct netif_rx_request *req;
        struct netif_rx_response *rsp;
        struct netif_extra_info *ext;

        mbufc = m_getm(NULL, size, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc != NULL);
        if (mbufc == NULL)
                return;

        mbufc->m_flags |= M_PKTHDR;
        mbufc->m_pkthdr.len = size;
        mbufc->m_pkthdr.csum_flags |= CSUM_TSO;
        mbufc->m_pkthdr.tso_segsz = mss;
        mbufc->m_len = size;

        xnb_mbufc2pkt(mbufc, &pkt, start, free_slots);
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start);
        req->id = id;
        req->gref = gref;
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start + 1);
        req->id = id + 1;
        req->gref = gref + 1;
        xnb_unit_pvt.rxb.req_cons = start;
        xnb_unit_pvt.rxb.rsp_prod_pvt = start;
        xnb_unit_pvt.rxs->req_prod = start + 2;
        xnb_unit_pvt.rxs->rsp_prod = start;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbufc, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        nr_reqs = xnb_rxpkt2rsp(&pkt, xnb_unit_pvt.gnttab, nr_entries,
            &xnb_unit_pvt.rxb);

        XNB_ASSERT(nr_reqs == 2);
        XNB_ASSERT(xnb_unit_pvt.rxb.rsp_prod_pvt == start + 2);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start);
        XNB_ASSERT(rsp->id == id);
        XNB_ASSERT((rsp->flags & NETRXF_more_data) == 0);
        XNB_ASSERT((rsp->flags & NETRXF_extra_info));
        XNB_ASSERT((rsp->flags & NETRXF_data_validated));
        XNB_ASSERT((rsp->flags & NETRXF_csum_blank));
        XNB_ASSERT(rsp->status == size);

        ext = (struct netif_extra_info*)
                RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start + 1);
        XNB_ASSERT(ext->type == XEN_NETIF_EXTRA_TYPE_GSO);
        XNB_ASSERT(! (ext->flags & XEN_NETIF_EXTRA_FLAG_MORE));
        XNB_ASSERT(ext->u.gso.size == mss);
        XNB_ASSERT(ext->u.gso.type == XEN_NETIF_EXTRA_TYPE_GSO);

        safe_m_freem(&mbufc);
}

/**
 * xnb_rxpkt2rsp on a packet with more than a pages's worth of data.  It should
 * generate two response slot
 */
static void
xnb_rxpkt2rsp_2slots(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries, nr_reqs;
        size_t size = PAGE_SIZE + 100;
        int free_slots = 3;
        uint16_t id1 = 17;
        uint16_t id2 = 37;
        uint16_t gref1 = 24;
        uint16_t gref2 = 34;
        RING_IDX start = 15;
        struct netif_rx_request *req;
        struct netif_rx_response *rsp;
        struct mbuf *mbuf;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        if (mbuf->m_next != NULL) {
                size_t first_len = MIN(M_TRAILINGSPACE(mbuf), size);
                mbuf->m_len = first_len;
                mbuf->m_next->m_len = size - first_len;

        } else {
                mbuf->m_len = size;
        }

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start);
        req->gref = gref1;
        req->id = id1;
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start + 1);
        req->gref = gref2;
        req->id = id2;
        xnb_unit_pvt.rxb.req_cons = start;
        xnb_unit_pvt.rxb.rsp_prod_pvt = start;
        xnb_unit_pvt.rxs->req_prod = start + 2;
        xnb_unit_pvt.rxs->rsp_prod = start;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        nr_reqs = xnb_rxpkt2rsp(&pkt, xnb_unit_pvt.gnttab, nr_entries,
            &xnb_unit_pvt.rxb);

        XNB_ASSERT(nr_reqs == 2);
        XNB_ASSERT(xnb_unit_pvt.rxb.rsp_prod_pvt == start + 2);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start);
        XNB_ASSERT(rsp->id == id1);
        XNB_ASSERT(rsp->offset == 0);
        XNB_ASSERT((rsp->flags & NETRXF_extra_info) == 0);
        XNB_ASSERT(rsp->flags & NETRXF_more_data);
        XNB_ASSERT(rsp->status == PAGE_SIZE);

        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start + 1);
        XNB_ASSERT(rsp->id == id2);
        XNB_ASSERT(rsp->offset == 0);
        XNB_ASSERT((rsp->flags & NETRXF_extra_info) == 0);
        XNB_ASSERT(! (rsp->flags & NETRXF_more_data));
        XNB_ASSERT(rsp->status == size - PAGE_SIZE);

        safe_m_freem(&mbuf);
}

/** xnb_rxpkt2rsp on a grant table with two sub-page entries */
static void
xnb_rxpkt2rsp_2short(char *buffer, size_t buflen) {
        struct xnb_pkt pkt;
        int nr_reqs, nr_entries;
        size_t size1 = MHLEN - 5;
        size_t size2 = MHLEN - 15;
        int free_slots = 32;
        RING_IDX start = 14;
        uint16_t id = 47;
        uint16_t gref = 54;
        struct netif_rx_request *req;
        struct netif_rx_response *rsp;
        struct mbuf *mbufc;

        mbufc = m_getm(NULL, size1, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc != NULL);
        if (mbufc == NULL)
                return;
        mbufc->m_flags |= M_PKTHDR;

        m_getm(mbufc, size2, M_WAITOK, MT_DATA);
        XNB_ASSERT(mbufc->m_next != NULL);
        mbufc->m_pkthdr.len = size1 + size2;
        mbufc->m_len = size1;
        mbufc->m_next->m_len = size2;

        xnb_mbufc2pkt(mbufc, &pkt, start, free_slots);

        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start);
        req->gref = gref;
        req->id = id;
        xnb_unit_pvt.rxb.req_cons = start;
        xnb_unit_pvt.rxb.rsp_prod_pvt = start;
        xnb_unit_pvt.rxs->req_prod = start + 1;
        xnb_unit_pvt.rxs->rsp_prod = start;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbufc, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);

        nr_reqs = xnb_rxpkt2rsp(&pkt, xnb_unit_pvt.gnttab, nr_entries,
            &xnb_unit_pvt.rxb);

        XNB_ASSERT(nr_entries == 2);
        XNB_ASSERT(nr_reqs == 1);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start);
        XNB_ASSERT(rsp->id == id);
        XNB_ASSERT(rsp->status == size1 + size2);
        XNB_ASSERT(rsp->offset == 0);
        XNB_ASSERT(! (rsp->flags & (NETRXF_more_data | NETRXF_extra_info)));

        safe_m_freem(&mbufc);
}

/**
 * xnb_rxpkt2rsp on a long packet with a hypervisor gnttab_copy error
 * Note: this test will result in an error message being printed to the console
 * such as:
 * xnb(xnb_rxpkt2rsp:1720): Got error -1 for hypervisor gnttab_copy status
 */
static void
xnb_rxpkt2rsp_copyerror(char *buffer, size_t buflen)
{
        struct xnb_pkt pkt;
        int nr_entries, nr_reqs;
        int id = 7;
        int gref = 42;
        uint16_t canary = 6859;
        size_t size = 7 * MCLBYTES;
        int free_slots = 9;
        RING_IDX start = 2;
        struct netif_rx_request *req;
        struct netif_rx_response *rsp;
        struct mbuf *mbuf;

        mbuf = m_getm(NULL, size, M_WAITOK, MT_DATA);
        mbuf->m_flags |= M_PKTHDR;
        mbuf->m_pkthdr.len = size;
        mbuf->m_len = size;

        xnb_mbufc2pkt(mbuf, &pkt, start, free_slots);
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start);
        req->gref = gref;
        req->id = id;
        xnb_unit_pvt.rxb.req_cons = start;
        xnb_unit_pvt.rxb.rsp_prod_pvt = start;
        xnb_unit_pvt.rxs->req_prod = start + 1;
        xnb_unit_pvt.rxs->rsp_prod = start;
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start + 1);
        req->gref = canary;
        req->id = canary;

        nr_entries = xnb_rxpkt2gnttab(&pkt, mbuf, xnb_unit_pvt.gnttab,
                        &xnb_unit_pvt.rxb, DOMID_FIRST_RESERVED);
        /* Inject the error*/
        xnb_unit_pvt.gnttab[2].status = GNTST_general_error;

        nr_reqs = xnb_rxpkt2rsp(&pkt, xnb_unit_pvt.gnttab, nr_entries,
            &xnb_unit_pvt.rxb);

        XNB_ASSERT(nr_reqs == 1);
        XNB_ASSERT(xnb_unit_pvt.rxb.rsp_prod_pvt == start + 1);
        rsp = RING_GET_RESPONSE(&xnb_unit_pvt.rxb, start);
        XNB_ASSERT(rsp->id == id);
        XNB_ASSERT(rsp->status == NETIF_RSP_ERROR);
        req = RING_GET_REQUEST(&xnb_unit_pvt.rxf, start + 1);
        XNB_ASSERT(req->gref == canary);
        XNB_ASSERT(req->id == canary);

        safe_m_freem(&mbuf);
}

#if defined(INET) || defined(INET6)
/**
 * xnb_add_mbuf_cksum on an ARP request packet
 */
static void
xnb_add_mbuf_cksum_arp(char *buffer, size_t buflen)
{
        const size_t pkt_len = sizeof(struct ether_header) +
                sizeof(struct ether_arp);
        struct mbuf *mbufc;
        struct ether_header *eh;
        struct ether_arp *ep;
        unsigned char pkt_orig[pkt_len];

        mbufc = m_getm(NULL, pkt_len, M_WAITOK, MT_DATA);
        /* Fill in an example arp request */
        eh = mtod(mbufc, struct ether_header*);
        eh->ether_dhost[0] = 0xff;
        eh->ether_dhost[1] = 0xff;
        eh->ether_dhost[2] = 0xff;
        eh->ether_dhost[3] = 0xff;
        eh->ether_dhost[4] = 0xff;
        eh->ether_dhost[5] = 0xff;
        eh->ether_shost[0] = 0x00;
        eh->ether_shost[1] = 0x15;
        eh->ether_shost[2] = 0x17;
        eh->ether_shost[3] = 0xe9;
        eh->ether_shost[4] = 0x30;
        eh->ether_shost[5] = 0x68;
        eh->ether_type = htons(ETHERTYPE_ARP);
        ep = (struct ether_arp*)(eh + 1);
        ep->ea_hdr.ar_hrd = htons(ARPHRD_ETHER);
        ep->ea_hdr.ar_pro = htons(ETHERTYPE_IP);
        ep->ea_hdr.ar_hln = 6;
        ep->ea_hdr.ar_pln = 4;
        ep->ea_hdr.ar_op = htons(ARPOP_REQUEST);
        ep->arp_sha[0] = 0x00;
        ep->arp_sha[1] = 0x15;
        ep->arp_sha[2] = 0x17;
        ep->arp_sha[3] = 0xe9;
        ep->arp_sha[4] = 0x30;
        ep->arp_sha[5] = 0x68;
        ep->arp_spa[0] = 0xc0;
        ep->arp_spa[1] = 0xa8;
        ep->arp_spa[2] = 0x0a;
        ep->arp_spa[3] = 0x04;
        bzero(&(ep->arp_tha), ETHER_ADDR_LEN);
        ep->arp_tpa[0] = 0xc0;
        ep->arp_tpa[1] = 0xa8;
        ep->arp_tpa[2] = 0x0a;
        ep->arp_tpa[3] = 0x06;

        /* fill in the length field */
        mbufc->m_len = pkt_len;
        mbufc->m_pkthdr.len = pkt_len;
        /* indicate that the netfront uses hw-assisted checksums */
        mbufc->m_pkthdr.csum_flags = CSUM_IP_CHECKED | CSUM_IP_VALID   |
                                CSUM_DATA_VALID | CSUM_PSEUDO_HDR;

        /* Make a backup copy of the packet */
        bcopy(mtod(mbufc, const void*), pkt_orig, pkt_len);

        /* Function under test */
        xnb_add_mbuf_cksum(mbufc);

        /* Verify that the packet's data did not change */
        XNB_ASSERT(bcmp(mtod(mbufc, const void*), pkt_orig, pkt_len) == 0);
        m_freem(mbufc);
}

/**
 * Helper function that populates the ethernet header and IP header used by
 * some of the xnb_add_mbuf_cksum unit tests.  m must already be allocated
 * and must be large enough
 */
static void
xnb_fill_eh_and_ip(struct mbuf *m, uint16_t ip_len, uint16_t ip_id,
                   uint16_t ip_p, uint16_t ip_off, uint16_t ip_sum)
{
        struct ether_header *eh;
        struct ip *iph;

        eh = mtod(m, struct ether_header*);
        eh->ether_dhost[0] = 0x00;
        eh->ether_dhost[1] = 0x16;
        eh->ether_dhost[2] = 0x3e;
        eh->ether_dhost[3] = 0x23;
        eh->ether_dhost[4] = 0x50;
        eh->ether_dhost[5] = 0x0b;
        eh->ether_shost[0] = 0x00;
        eh->ether_shost[1] = 0x16;
        eh->ether_shost[2] = 0x30;
        eh->ether_shost[3] = 0x00;
        eh->ether_shost[4] = 0x00;
        eh->ether_shost[5] = 0x00;
        eh->ether_type = htons(ETHERTYPE_IP);
        iph = (struct ip*)(eh + 1);
        iph->ip_hl = 0x5;       /* 5 dwords == 20 bytes */
        iph->ip_v = 4;          /* IP v4 */
        iph->ip_tos = 0;
        iph->ip_len = htons(ip_len);
        iph->ip_id = htons(ip_id);
        iph->ip_off = htons(ip_off);
        iph->ip_ttl = 64;
        iph->ip_p = ip_p;
        iph->ip_sum = htons(ip_sum);
        iph->ip_src.s_addr = htonl(0xc0a80a04);
        iph->ip_dst.s_addr = htonl(0xc0a80a05);
}

/**
 * xnb_add_mbuf_cksum on an ICMP packet, based on a tcpdump of an actual
 * ICMP packet
 */
static void
xnb_add_mbuf_cksum_icmp(char *buffer, size_t buflen)
{
        const size_t icmp_len = 64;     /* set by ping(1) */
        const size_t pkt_len = sizeof(struct ether_header) +
                sizeof(struct ip) + icmp_len;
        struct mbuf *mbufc;
        struct ether_header *eh;
        struct ip *iph;
        struct icmp *icmph;
        unsigned char pkt_orig[icmp_len];
        uint32_t *tv_field;
        uint8_t *data_payload;
        int i;
        const uint16_t ICMP_CSUM = 0xaed7;
        const uint16_t IP_CSUM = 0xe533;

        mbufc = m_getm(NULL, pkt_len, M_WAITOK, MT_DATA);
        /* Fill in an example ICMP ping request */
        eh = mtod(mbufc, struct ether_header*);
        xnb_fill_eh_and_ip(mbufc, 84, 28, IPPROTO_ICMP, 0, 0);
        iph = (struct ip*)(eh + 1);
        icmph = (struct icmp*)(iph + 1);
        icmph->icmp_type = ICMP_ECHO;
        icmph->icmp_code = 0;
        icmph->icmp_cksum = htons(ICMP_CSUM);
        icmph->icmp_id = htons(31492);
        icmph->icmp_seq = htons(0);
        /*
         * ping(1) uses bcopy to insert a native-endian timeval after icmp_seq.
         * For this test, we will set the bytes individually for portability.
         */
        tv_field = (uint32_t*)(&(icmph->icmp_hun));
        tv_field[0] = 0x4f02cfac;
        tv_field[1] = 0x0007c46a;
        /*
         * Remainder of packet is an incrmenting 8 bit integer, starting with 8
         */
        data_payload = (uint8_t*)(&tv_field[2]);
        for (i = 8; i < 37; i++) {
                *data_payload++ = i;
        }

        /* fill in the length field */
        mbufc->m_len = pkt_len;
        mbufc->m_pkthdr.len = pkt_len;
        /* indicate that the netfront uses hw-assisted checksums */
        mbufc->m_pkthdr.csum_flags = CSUM_IP_CHECKED | CSUM_IP_VALID   |
                                CSUM_DATA_VALID | CSUM_PSEUDO_HDR;

        bcopy(mtod(mbufc, const void*), pkt_orig, icmp_len);
        /* Function under test */
        xnb_add_mbuf_cksum(mbufc);

        /* Check the IP checksum */
        XNB_ASSERT(iph->ip_sum == htons(IP_CSUM));

        /* Check that the ICMP packet did not change */
        XNB_ASSERT(bcmp(icmph, pkt_orig, icmp_len));
        m_freem(mbufc);
}

/**
 * xnb_add_mbuf_cksum on a UDP packet, based on a tcpdump of an actual
 * UDP packet
 */
static void
xnb_add_mbuf_cksum_udp(char *buffer, size_t buflen)
{
        const size_t udp_len = 16;
        const size_t pkt_len = sizeof(struct ether_header) +
                sizeof(struct ip) + udp_len;
        struct mbuf *mbufc;
        struct ether_header *eh;
        struct ip *iph;
        struct udphdr *udp;
        uint8_t *data_payload;
        const uint16_t IP_CSUM = 0xe56b;
        const uint16_t UDP_CSUM = 0xdde2;

        mbufc = m_getm(NULL, pkt_len, M_WAITOK, MT_DATA);
        /* Fill in an example UDP packet made by 'uname | nc -u <host> 2222 */
        eh = mtod(mbufc, struct ether_header*);
        xnb_fill_eh_and_ip(mbufc, 36, 4, IPPROTO_UDP, 0, 0xbaad);
        iph = (struct ip*)(eh + 1);
        udp = (struct udphdr*)(iph + 1);
        udp->uh_sport = htons(0x51ae);
        udp->uh_dport = htons(0x08ae);
        udp->uh_ulen = htons(udp_len);
        udp->uh_sum = htons(0xbaad);  /* xnb_add_mbuf_cksum will fill this in */
        data_payload = (uint8_t*)(udp + 1);
        data_payload[0] = 'F';
        data_payload[1] = 'r';
        data_payload[2] = 'e';
        data_payload[3] = 'e';
        data_payload[4] = 'B';
        data_payload[5] = 'S';
        data_payload[6] = 'D';
        data_payload[7] = '\n';

        /* fill in the length field */
        mbufc->m_len = pkt_len;
        mbufc->m_pkthdr.len = pkt_len;
        /* indicate that the netfront uses hw-assisted checksums */
        mbufc->m_pkthdr.csum_flags = CSUM_IP_CHECKED | CSUM_IP_VALID   |
                                CSUM_DATA_VALID | CSUM_PSEUDO_HDR;

        /* Function under test */
        xnb_add_mbuf_cksum(mbufc);

        /* Check the checksums */
        XNB_ASSERT(iph->ip_sum == htons(IP_CSUM));
        XNB_ASSERT(udp->uh_sum == htons(UDP_CSUM));

        m_freem(mbufc);
}

/**
 * Helper function that populates a TCP packet used by all of the
 * xnb_add_mbuf_cksum tcp unit tests.  m must already be allocated and must be
 * large enough
 */
static void
xnb_fill_tcp(struct mbuf *m)
{
        struct ether_header *eh;
        struct ip *iph;
        struct tcphdr *tcp;
        uint32_t *options;
        uint8_t *data_payload;

        /* Fill in an example TCP packet made by 'uname | nc <host> 2222' */
        eh = mtod(m, struct ether_header*);
        xnb_fill_eh_and_ip(m, 60, 8, IPPROTO_TCP, IP_DF, 0);
        iph = (struct ip*)(eh + 1);
        tcp = (struct tcphdr*)(iph + 1);
        tcp->th_sport = htons(0x9cd9);
        tcp->th_dport = htons(2222);
        tcp->th_seq = htonl(0x00f72b10);
        tcp->th_ack = htonl(0x7f37ba6c);
        tcp_set_flags(tcp, TH_ACK | TH_PUSH);
        tcp->th_off = 8;
        tcp->th_win = htons(0x410);
        /* th_sum is incorrect; will be inserted by function under test */
        tcp->th_sum = htons(0xbaad);
        tcp->th_urp = htons(0);
        /*
         * The following 12 bytes of options encode:
         * [nop, nop, TS val 33247 ecr 3457687679]
         */
        options = (uint32_t*)(tcp + 1);
        options[0] = htonl(0x0101080a);
        options[1] = htonl(0x000081df);
        options[2] = htonl(0xce18207f);
        data_payload = (uint8_t*)(&options[3]);
        data_payload[0] = 'F';
        data_payload[1] = 'r';
        data_payload[2] = 'e';
        data_payload[3] = 'e';
        data_payload[4] = 'B';
        data_payload[5] = 'S';
        data_payload[6] = 'D';
        data_payload[7] = '\n';
}

/**
 * xnb_add_mbuf_cksum on a TCP packet, based on a tcpdump of an actual TCP
 * packet
 */
static void
xnb_add_mbuf_cksum_tcp(char *buffer, size_t buflen)
{
        const size_t payload_len = 8;
        const size_t tcp_options_len = 12;
        const size_t pkt_len = sizeof(struct ether_header) + sizeof(struct ip) +
            sizeof(struct tcphdr) + tcp_options_len + payload_len;
        struct mbuf *mbufc;
        struct ether_header *eh;
        struct ip *iph;
        struct tcphdr *tcp;
        const uint16_t IP_CSUM = 0xa55a;
        const uint16_t TCP_CSUM = 0x2f64;

        mbufc = m_getm(NULL, pkt_len, M_WAITOK, MT_DATA);
        /* Fill in an example TCP packet made by 'uname | nc <host> 2222' */
        xnb_fill_tcp(mbufc);
        eh = mtod(mbufc, struct ether_header*);
        iph = (struct ip*)(eh + 1);
        tcp = (struct tcphdr*)(iph + 1);

        /* fill in the length field */
        mbufc->m_len = pkt_len;
        mbufc->m_pkthdr.len = pkt_len;
        /* indicate that the netfront uses hw-assisted checksums */
        mbufc->m_pkthdr.csum_flags = CSUM_IP_CHECKED | CSUM_IP_VALID   |
                                CSUM_DATA_VALID | CSUM_PSEUDO_HDR;

        /* Function under test */
        xnb_add_mbuf_cksum(mbufc);

        /* Check the checksums */
        XNB_ASSERT(iph->ip_sum == htons(IP_CSUM));
        XNB_ASSERT(tcp->th_sum == htons(TCP_CSUM));

        m_freem(mbufc);
}

/**
 * xnb_add_mbuf_cksum on a TCP packet that does not use HW assisted checksums
 */
static void
xnb_add_mbuf_cksum_tcp_swcksum(char *buffer, size_t buflen)
{
        const size_t payload_len = 8;
        const size_t tcp_options_len = 12;
        const size_t pkt_len = sizeof(struct ether_header) + sizeof(struct ip) +
            sizeof(struct tcphdr) + tcp_options_len + payload_len;
        struct mbuf *mbufc;
        struct ether_header *eh;
        struct ip *iph;
        struct tcphdr *tcp;
        /* Use deliberately bad checksums, and verify that they don't get */
        /* corrected by xnb_add_mbuf_cksum */
        const uint16_t IP_CSUM = 0xdead;
        const uint16_t TCP_CSUM = 0xbeef;

        mbufc = m_getm(NULL, pkt_len, M_WAITOK, MT_DATA);
        /* Fill in an example TCP packet made by 'uname | nc <host> 2222' */
        xnb_fill_tcp(mbufc);
        eh = mtod(mbufc, struct ether_header*);
        iph = (struct ip*)(eh + 1);
        iph->ip_sum = htons(IP_CSUM);
        tcp = (struct tcphdr*)(iph + 1);
        tcp->th_sum = htons(TCP_CSUM);

        /* fill in the length field */
        mbufc->m_len = pkt_len;
        mbufc->m_pkthdr.len = pkt_len;
        /* indicate that the netfront does not use hw-assisted checksums */
        mbufc->m_pkthdr.csum_flags = 0;

        /* Function under test */
        xnb_add_mbuf_cksum(mbufc);

        /* Check that the checksums didn't change */
        XNB_ASSERT(iph->ip_sum == htons(IP_CSUM));
        XNB_ASSERT(tcp->th_sum == htons(TCP_CSUM));

        m_freem(mbufc);
}
#endif /* INET || INET6 */

/**
 * sscanf on unsigned chars
 */
static void
xnb_sscanf_hhu(char *buffer, size_t buflen)
{
        const char mystr[] = "137";
        uint8_t dest[12];
        int i;

        for (i = 0; i < 12; i++)
                dest[i] = 'X';

        XNB_ASSERT(sscanf(mystr, "%hhu", &dest[4]) == 1);
        for (i = 0; i < 12; i++)
                XNB_ASSERT(dest[i] == (i == 4 ? 137 : 'X'));
}

/**
 * sscanf on signed chars
 */
static void
xnb_sscanf_hhd(char *buffer, size_t buflen)
{
        const char mystr[] = "-27";
        int8_t dest[12];
        int i;

        for (i = 0; i < 12; i++)
                dest[i] = 'X';

        XNB_ASSERT(sscanf(mystr, "%hhd", &dest[4]) == 1);
        for (i = 0; i < 12; i++)
                XNB_ASSERT(dest[i] == (i == 4 ? -27 : 'X'));
}

/**
 * sscanf on signed long longs
 */
static void
xnb_sscanf_lld(char *buffer, size_t buflen)
{
        const char mystr[] = "-123456789012345";        /* about -2**47 */
        long long dest[3];
        int i;

        for (i = 0; i < 3; i++)
                dest[i] = (long long)0xdeadbeefdeadbeef;

        XNB_ASSERT(sscanf(mystr, "%lld", &dest[1]) == 1);
        for (i = 0; i < 3; i++)
                XNB_ASSERT(dest[i] == (i != 1 ? (long long)0xdeadbeefdeadbeef :
                    -123456789012345));
}

/**
 * sscanf on unsigned long longs
 */
static void
xnb_sscanf_llu(char *buffer, size_t buflen)
{
        const char mystr[] = "12802747070103273189";
        unsigned long long dest[3];
        int i;

        for (i = 0; i < 3; i++)
                dest[i] = (long long)0xdeadbeefdeadbeef;

        XNB_ASSERT(sscanf(mystr, "%llu", &dest[1]) == 1);
        for (i = 0; i < 3; i++)
                XNB_ASSERT(dest[i] == (i != 1 ? (long long)0xdeadbeefdeadbeef :
                    12802747070103273189ull));
}

/**
 * sscanf on unsigned short short n's
 */
static void
xnb_sscanf_hhn(char *buffer, size_t buflen)
{
        const char mystr[] =
            "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
            "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
            "404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f";
        unsigned char dest[12];
        int i;

        for (i = 0; i < 12; i++)
                dest[i] = (unsigned char)'X';

        XNB_ASSERT(sscanf(mystr,
            "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"
            "202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f"
            "404142434445464748494a4b4c4d4e4f%hhn", &dest[4]) == 0);
        for (i = 0; i < 12; i++)
                XNB_ASSERT(dest[i] == (i == 4 ? 160 : 'X'));
}