lotest.c

Go to the documentation of this file.

/*
 * Copyright (C) 2010 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 * You can also choose to distribute this program under the terms of
 * the Unmodified Binary Distribution Licence (as given in the file
 * COPYING.UBDL), provided that you have satisfied its requirements.
 */

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/iobuf.h>
#include <ipxe/netdevice.h>
#include <ipxe/if_ether.h>
#include <ipxe/keys.h>
#include <ipxe/console.h>
#include <usr/ifmgmt.h>
#include <usr/lotest.h>

/** @file
 *
 * Loopback testing
 *
 */

/** Current loopback test receiver */
static struct net_device *lotest_receiver;

/** Loopback testing received packets */
static LIST_HEAD ( lotest_queue );

/**
 * Process received packet
 *
 * @v iobuf             I/O buffer
 * @v netdev            Network device
 * @v ll_dest           Link-layer destination address
 * @v ll_source         Link-layer source address
 * @v flags             Packet flags
 * @ret rc              Return status code
 */
static int lotest_rx ( struct io_buffer *iobuf,
                       struct net_device *netdev,
                       const void *ll_dest __unused,
                       const void *ll_source __unused,
                       unsigned int flags __unused ) {

        /* Add to received packet queue if currently performing a test */
        if ( netdev == lotest_receiver ) {
                list_add_tail ( &iobuf->list, &lotest_queue );
        } else {
                free_iob ( iobuf );
        }

        return 0;
}

/**
 * Dequeue received packet
 *
 * @ret iobuf           I/O buffer, or NULL
 */
static struct io_buffer * lotest_dequeue ( void ) {
        struct io_buffer *iobuf;

        /* Remove first packet (if any) from received packet queue */
        iobuf = list_first_entry ( &lotest_queue, struct io_buffer, list );
        if ( ! iobuf )
                return NULL;
        list_del ( &iobuf->list );

        return iobuf;
}

/**
 * Transcribe network-layer address
 *
 * @v net_addr          Network-layer address
 * @ret string          Human-readable transcription of address
 */
static const char * lotest_ntoa ( const void *net_addr __unused ) {
        return "<INVALID>";
}

/**
 * Loopback test network-layer protocol
 *
 * Using a dedicated network-layer protocol avoids problems caused by
 * cards supporting features such as IPv4 checksum offload trying to
 * interpret the (randomly generated) network-layer content.
 */
static struct net_protocol lotest_protocol __net_protocol = {
        .name = "LOTEST",
        .rx = lotest_rx,
        .ntoa = lotest_ntoa,
        .net_proto = htons ( 0x6950 ), /* Not a genuine protocol number */
        .net_addr_len = 0,
};

/**
 * Discard all received loopback test packets
 *
 */
static void lotest_flush ( void ) {
        struct io_buffer *iobuf;

        while ( ( iobuf = lotest_dequeue() ) != NULL )
                free_iob ( iobuf );
}

/**
 * Wait for packet to be received
 *
 * @v data              Expected data
 * @v len               Expected data length
 * @ret rc              Return status code
 */
static int loopback_wait ( void *data, size_t len ) {
        struct io_buffer *iobuf;

        /* Poll until packet arrives */
        while ( 1 ) {

                /* Check for cancellation */
                if ( iskey() && ( getchar() == CTRL_C ) )
                        return -ECANCELED;

                /* Poll network devices */
                net_poll();

                /* Dequeue packet, if available */
                iobuf = lotest_dequeue();
                if ( ! iobuf )
                        continue;

                /* Check packet length */
                if ( iob_len ( iobuf ) != len ) {
                        printf ( "\nLength mismatch: sent %zd, received %zd",
                                 len, iob_len ( iobuf ) );
                        DBG ( "\nSent:\n" );
                        DBG_HDA ( 0, data, len );
                        DBG ( "Received:\n" );
                        DBG_HDA ( 0, iobuf->data, iob_len ( iobuf ) );
                        free_iob ( iob_disown ( iobuf ) );
                        return -EINVAL;
                }

                /* Check packet content */
                if ( memcmp ( iobuf->data, data, len ) != 0 ) {
                        printf ( "\nContent mismatch" );
                        DBG ( "\nSent:\n" );
                        DBG_HDA ( 0, data, len );
                        DBG ( "Received:\n" );
                        DBG_HDA ( 0, iobuf->data, iob_len ( iobuf ) );
                        free_iob ( iob_disown ( iobuf ) );
                        return -EINVAL;
                }

                /* Discard packet and return */
                free_iob ( iob_disown ( iobuf ) );
                return 0;
        }
}

/**
 * Perform loopback test between two network devices
 *
 * @v sender            Sending network device
 * @v receiver          Received network device
 * @v mtu               Packet size (excluding link-layer headers)
 * @v broadcast         Use broadcast link-layer address
 * @ret rc              Return status code
 */
int loopback_test ( struct net_device *sender, struct net_device *receiver,
                    size_t mtu, int broadcast ) {
        uint8_t *buf;
        uint32_t *seq;
        struct io_buffer *iobuf;
        const void *ll_dest;
        unsigned int i;
        unsigned int successes;
        int rc;

        /* Open network devices */
        if ( ( rc = ifopen ( sender ) ) != 0 )
                return rc;
        if ( ( rc = ifopen ( receiver ) ) != 0 )
                return rc;

        /* Wait for link-up */
        if ( ( rc = iflinkwait ( sender, 0, 0 ) ) != 0 )
                return rc;
        if ( ( rc = iflinkwait ( receiver, 0, 0 ) ) != 0 )
                return rc;

        /* Allocate data buffer */
        if ( mtu < sizeof ( *seq ) )
                mtu = sizeof ( *seq );
        buf = malloc ( mtu );
        if ( ! buf )
                return -ENOMEM;
        seq = ( ( void * ) buf );

        /* Determine destination address */
        ll_dest = ( broadcast ? sender->ll_broadcast : receiver->ll_addr );

        /* Print initial statistics */
        printf ( "Performing %sloopback test from %s to %s with %zd byte MTU\n",
                 ( broadcast ? "broadcast " : "" ), sender->name,
                 receiver->name, mtu );
        ifstat ( sender );
        ifstat ( receiver );

        /* Start loopback test */
        lotest_flush();
        lotest_receiver = receiver;

        /* Perform loopback test */
        for ( successes = 0 ; ; successes++ ) {

                /* Print running total */
                printf ( "\r%d", successes );

                /* Generate random packet */
                *seq = htonl ( successes );
                for ( i = sizeof ( *seq ) ; i < mtu ; i++ )
                        buf[i] = random();
                iobuf = alloc_iob ( MAX_LL_HEADER_LEN + mtu );
                if ( ! iobuf ) {
                        printf ( "\nFailed to allocate I/O buffer" );
                        rc = -ENOMEM;
                        break;
                }
                iob_reserve ( iobuf, MAX_LL_HEADER_LEN );
                memcpy ( iob_put ( iobuf, mtu ), buf, mtu );

                /* Transmit packet */
                if ( ( rc = net_tx ( iob_disown ( iobuf ), sender,
                                     &lotest_protocol, ll_dest,
                                     sender->ll_addr ) ) != 0 ) {
                        printf ( "\nFailed to transmit packet: %s",
                                 strerror ( rc ) );
                        break;
                }

                /* Wait for received packet */
                if ( ( rc = loopback_wait ( buf, mtu ) ) != 0 )
                        break;
        }

        printf ( "\n");

        /* Stop loopback testing */
        lotest_receiver = NULL;
        lotest_flush();

        /* Dump final statistics */
        ifstat ( sender );
        ifstat ( receiver );

        /* Free buffer */
        free ( buf );

        return 0;
}