blob: 5b88ef27e000af4734937b16d97ecd7df39470e8 [file] [log] [blame]
/*
* 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;
}