lotest.c File Reference

Loopback testing. More...

#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>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static	LIST_HEAD (lotest_queue)
	Loopback testing received packets. More...
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)
	Process received packet. More...
static struct io_buffer *	lotest_dequeue (void)
	Dequeue received packet. More...
static const char *	lotest_ntoa (const void *net_addr __unused)
	Transcribe network-layer address. More...
static void	lotest_flush (void)
	Discard all received loopback test packets. More...
static int	loopback_wait (void *data, size_t len)
	Wait for packet to be received. More...
int	loopback_test (struct net_device *sender, struct net_device *receiver, size_t mtu, int broadcast)
	Perform loopback test between two network devices. More...

Variables
static struct net_device *	lotest_receiver
	Current loopback test receiver. More...
static struct net_protocol lotest_protocol	__net_protocol
	Loopback test network-layer protocol. More...

Detailed Description

Loopback testing.

Definition in file lotest.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

LIST_HEAD()

static LIST_HEAD ( lotest_queue  )

static

Loopback testing received packets.

lotest_rx()

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  )

static

Process received packet.

Parameters

iobuf	I/O buffer
netdev	Network device
ll_dest	Link-layer destination address
ll_source	Link-layer source address
flags	Packet flags

Return values

rc	Return status code

Definition at line 62 of file lotest.c.

                                                     {

        /* 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;
}

References free_iob(), io_buffer::list, list_add_tail, lotest_receiver, and netdev.

lotest_dequeue()

static struct io_buffer* lotest_dequeue ( void  )

static

Dequeue received packet.

Return values

iobuf

I/O buffer, or NULL

Definition at line 83 of file lotest.c.

                                                  {
        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;
}

References io_buffer::list, list_del, list_first_entry, and NULL.

Referenced by loopback_wait(), and lotest_flush().

lotest_ntoa()

static const char* lotest_ntoa ( const void *net_addr  __unused )

static

Transcribe network-layer address.

Parameters

net_addr

Network-layer address

Return values

string

Human-readable transcription of address

Definition at line 101 of file lotest.c.

                                                                  {
        return "<INVALID>";
}

lotest_flush()

static void lotest_flush ( void  )

static

Discard all received loopback test packets.

Definition at line 124 of file lotest.c.

                                  {
        struct io_buffer *iobuf;

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

References free_iob(), lotest_dequeue(), and NULL.

Referenced by loopback_test().

loopback_wait()

static int loopback_wait ( void *  data, size_t  len  )

static

Wait for packet to be received.

Parameters

data	Expected data
len	Expected data length

Return values

rc	Return status code

Definition at line 138 of file lotest.c.

                                                    {
        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;
        }
}

References CTRL_C, data, io_buffer::data, DBG, DBG_HDA, ECANCELED, EINVAL, free_iob(), getchar(), iob_disown, iob_len(), iskey(), len, lotest_dequeue(), memcmp(), net_poll(), and printf().

Referenced by loopback_test().

loopback_test()

int loopback_test	(	struct net_device *	sender,
		struct net_device *	receiver,
		size_t	mtu,
		int	broadcast
	)

Perform loopback test between two network devices.

Parameters

sender	Sending network device
receiver	Received network device
mtu	Packet size (excluding link-layer headers)
broadcast	Use broadcast link-layer address

Return values

rc	Return status code

Definition at line 194 of file lotest.c.

                                                {
        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;
}

References alloc_iob(), ENOMEM, free, htonl, iflinkwait(), ifopen(), ifstat(), iob_disown, iob_put, iob_reserve, net_device::ll_addr, loopback_wait(), lotest_flush(), lotest_receiver, malloc(), MAX_LL_HEADER_LEN, memcpy(), mtu, net_device::name, net_tx(), NULL, printf(), random(), rc, sender, seq, and strerror().

Referenced by lotest_exec().

Variable Documentation

lotest_receiver

struct net_device* lotest_receiver

static

Current loopback test receiver.

Definition at line 47 of file lotest.c.

Referenced by loopback_test(), and lotest_rx().

__net_protocol

struct net_protocol lotest_protocol __net_protocol

static

Initial value:

= {
        .name = "LOTEST",
        .rx = lotest_rx,
        .ntoa = lotest_ntoa,
        .net_proto = htons ( 0x6950 ), 
        .net_addr_len = 0,
}

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.

Definition at line 112 of file lotest.c.