aoe.c File Reference

AoE protocol. More...

#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <gpxe/list.h>
#include <gpxe/if_ether.h>
#include <gpxe/ethernet.h>
#include <gpxe/iobuf.h>
#include <gpxe/uaccess.h>
#include <gpxe/ata.h>
#include <gpxe/netdevice.h>
#include <gpxe/process.h>
#include <gpxe/features.h>
#include <gpxe/aoe.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
	FEATURE (FEATURE_PROTOCOL,"AoE", DHCP_EB_FEATURE_AOE, 1)
static	LIST_HEAD (aoe_sessions)
	List of all AoE sessions.
static void	aoe_free (struct refcnt *refcnt)
static void	aoe_done (struct aoe_session *aoe, int rc)
	Mark current AoE command complete.
static int	aoe_send_command (struct aoe_session *aoe)
	Send AoE command.
static void	aoe_timer_expired (struct retry_timer *timer, int fail)
	Handle AoE retry timer expiry.
static int	aoe_rx_cfg (struct aoe_session *aoe, const void *ll_source)
	Handle AoE configuration command response.
static int	aoe_rx_ata (struct aoe_session *aoe, struct aoeata *aoeata, size_t len)
	Handle AoE ATA command response.
static int	aoe_rx (struct io_buffer *iobuf, struct net_device *netdev __unused, const void *ll_source)
	Process incoming AoE packets.
static int	aoe_command (struct ata_device *ata, struct ata_command *command)
	Issue ATA command via an open AoE session.
static int	aoe_discover (struct aoe_session *aoe)
	Issue AoE config query for AoE target discovery.
static int	aoe_detached_command (struct ata_device *ata __unused, struct ata_command *command __unused)
void	aoe_detach (struct ata_device *ata)
static int	aoe_parse_root_path (struct aoe_session *aoe, const char *root_path)
int	aoe_attach (struct ata_device *ata, struct net_device *netdev, const char *root_path)
Variables
struct net_protocol	aoe_protocol
struct net_protocol aoe_protocol	__net_protocol
	AoE protocol.

---

Detailed Description

AoE protocol.

Definition in file aoe.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

FEATURE	(	FEATURE_PROTOCOL	,
		"AoE"	,
		DHCP_EB_FEATURE_AOE	,
		1
	)

static LIST_HEAD

(

aoe_sessions

)

[static]

List of all AoE sessions.

static void aoe_free

(

struct refcnt *

refcnt

)

[static]

Definition at line 52 of file aoe.c.

References container_of, free(), aoe_session::netdev, and netdev_put().

Referenced by aoe_attach().

                                               {
        struct aoe_session *aoe =
                container_of ( refcnt, struct aoe_session, refcnt );

        netdev_put ( aoe->netdev );
        free ( aoe );
}

static void aoe_done	(	struct aoe_session *	aoe,
		int	rc
	)			[static]

Mark current AoE command complete.

Parameters:

	aoe	AoE session
	rc	Return status code

Definition at line 66 of file aoe.c.

References ata_command::cb, ata_cb::cmd_stat, aoe_session::command, NULL, aoe_session::rc, ata_command::rc, aoe_session::status, stop_timer(), and aoe_session::timer.

Referenced by aoe_rx(), aoe_rx_ata(), aoe_rx_cfg(), aoe_send_command(), and aoe_timer_expired().

                                                         {

        /* Record overall command status */
        if ( aoe->command ) {
                aoe->command->cb.cmd_stat = aoe->status;
                aoe->command->rc = rc;
                aoe->command = NULL;
        }

        /* Stop retransmission timer */
        stop_timer ( &aoe->timer );

        /* Mark operation as complete */
        aoe->rc = rc;
}

static int aoe_send_command

(

struct aoe_session *

aoe

)

[static]

Send AoE command.

Parameters:

aoe

AoE session

Return values:

rc

Return status code

This transmits an AoE command packet. It does not wait for a response.

Definition at line 91 of file aoe.c.

References aoeata::aflags, alloc_iob(), AOE_CMD_ATA, AOE_CMD_CONFIG, aoe_session::aoe_cmd_type, aoe_done(), AOE_FL_DEV_HEAD, AOE_FL_EXTENDED, AOE_FL_WRITE, AOE_MAX_COUNT, aoe_protocol, AOE_VERSION, assert, aoecmd::ata, ATA_DEV_MASK, ATA_DEV_SLAVE, ATA_SECTOR_SIZE, aoeata::bytes, ata_fifo::bytes, ata_command::cb, aoecmd::cfg, ata_cb::cmd_stat, aoeata::cmd_stat, aoehdr::command, aoe_session::command, aoe_session::command_offset, copy_from_user(), ata_cb::count, aoeata::count, cpu_to_le64, ata_fifo::cur, ata_command::data_out, ata_cb::device, ENETUNREACH, ENOMEM, ENOTSUP, ata_cb::err_feat, aoeata::err_feat, ETH_HLEN, htonl, htons, iob_put, iob_reserve, ata_cb::lba, aoeata::lba, ata_cb::lba48, linker_assert, aoe_session::major, aoehdr::major, memset(), aoe_session::minor, aoehdr::minor, ata_lba::native, ata_fifo::native, net_tx(), aoe_session::netdev, start_timer(), aoe_session::tag, aoehdr::tag, aoe_session::target, aoe_session::timer, aoeata::u64, and aoehdr::ver_flags.

Referenced by aoe_command(), aoe_discover(), aoe_rx_ata(), and aoe_timer_expired().

                                                        {
        struct ata_command *command = aoe->command;
        struct io_buffer *iobuf;
        struct aoehdr *aoehdr;
        union aoecmd *aoecmd;
        struct aoeata *aoeata;
        unsigned int count;
        unsigned int data_out_len;
        unsigned int aoecmdlen;

        /* Fail immediately if we have no netdev to send on */
        if ( ! aoe->netdev ) {
                aoe_done ( aoe, -ENETUNREACH );
                return -ENETUNREACH;
        }

        /* If we are transmitting anything that requires a response,
         * start the retransmission timer.  Do this before attempting
         * to allocate the I/O buffer, in case allocation itself
         * fails.
         */
        start_timer ( &aoe->timer );

        /* Calculate count and data_out_len for this subcommand */
        switch ( aoe->aoe_cmd_type ) {
        case AOE_CMD_ATA:
                count = command->cb.count.native;
                if ( count > AOE_MAX_COUNT )
                        count = AOE_MAX_COUNT;
                data_out_len = ( command->data_out ?
                                 ( count * ATA_SECTOR_SIZE ) : 0 );
                aoecmdlen = sizeof ( aoecmd->ata );
                break;
        case AOE_CMD_CONFIG:
                count = 0;
                data_out_len = 0;
                aoecmdlen = sizeof ( aoecmd->cfg );
                break;
        default:
                return -ENOTSUP;
        }

        /* Create outgoing I/O buffer */
        iobuf = alloc_iob ( ETH_HLEN + sizeof ( *aoehdr ) +
                            aoecmdlen + data_out_len );

        if ( ! iobuf )
                return -ENOMEM;
        iob_reserve ( iobuf, ETH_HLEN );
        aoehdr = iob_put ( iobuf, sizeof ( *aoehdr ) );
        aoecmd = iob_put ( iobuf, aoecmdlen );
        memset ( aoehdr, 0, ( sizeof ( *aoehdr ) + aoecmdlen ) );

        /* Fill AoE header */
        aoehdr->ver_flags = AOE_VERSION;
        aoehdr->major = htons ( aoe->major );
        aoehdr->minor = aoe->minor;
        aoehdr->command = aoe->aoe_cmd_type;
        aoehdr->tag = htonl ( ++aoe->tag );

        /* Fill AoE payload */
        switch ( aoe->aoe_cmd_type ) {
        case AOE_CMD_ATA:
                /* Fill AoE command */
                aoeata = &aoecmd->ata;
                linker_assert ( AOE_FL_DEV_HEAD == ATA_DEV_SLAVE,
                                __fix_ata_h__ );
                aoeata->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 )|
                                   ( command->cb.device & ATA_DEV_SLAVE ) |
                                   ( data_out_len ? AOE_FL_WRITE : 0 ) );
                aoeata->err_feat = command->cb.err_feat.bytes.cur;
                aoeata->count = count;
                aoeata->cmd_stat = command->cb.cmd_stat;
                aoeata->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
                if ( ! command->cb.lba48 )
                        aoeata->lba.bytes[3] |=
                                ( command->cb.device & ATA_DEV_MASK );

                /* Fill data payload */
                copy_from_user ( iob_put ( iobuf, data_out_len ),
                                 command->data_out, aoe->command_offset,
                                 data_out_len );
                break;
        case AOE_CMD_CONFIG:
                /* Nothing to do */
                break;
        default:
                assert ( 0 );
        }

        /* Send packet */
        return net_tx ( iobuf, aoe->netdev, &aoe_protocol, aoe->target );
}

static void aoe_timer_expired	(	struct retry_timer *	timer,
		int	fail
	)			[static]

Handle AoE retry timer expiry.

Parameters:

	timer	AoE retry timer
	fail	Failure indicator

Definition at line 191 of file aoe.c.

References aoe_done(), aoe_send_command(), container_of, and ETIMEDOUT.

Referenced by aoe_attach().

                                                                      {
        struct aoe_session *aoe =
                container_of ( timer, struct aoe_session, timer );

        if ( fail ) {
                aoe_done ( aoe, -ETIMEDOUT );
        } else {
                aoe_send_command ( aoe );
        }
}

static int aoe_rx_cfg	(	struct aoe_session *	aoe,
		const void *	ll_source
	)			[static]

Handle AoE configuration command response.

Parameters:

	aoe	AoE session
	ll_source	Link-layer source address

Return values:

rc

Return status code

Definition at line 209 of file aoe.c.

References aoe_done(), DBGC, eth_ntoa(), memcpy, and aoe_session::target.

Referenced by aoe_rx().

                                                                         {

        /* Record target MAC address */
        memcpy ( aoe->target, ll_source, sizeof ( aoe->target ) );
        DBGC ( aoe, "AoE %p target MAC address %s\n",
               aoe, eth_ntoa ( aoe->target ) );

        /* Mark config request as complete */
        aoe_done ( aoe, 0 );

        return 0;
}

static int aoe_rx_ata	(	struct aoe_session *	aoe,
		struct aoeata *	aoeata,
		size_t	len
	)			[static]

Handle AoE ATA command response.

Parameters:

	aoe	AoE session
	aoeata	AoE ATA command
	len	Length of AoE ATA command

Return values:

rc

Return status code

Definition at line 230 of file aoe.c.

References aoe_done(), AOE_MAX_COUNT, aoe_send_command(), ATA_SECTOR_SIZE, ata_command::cb, aoeata::cmd_stat, aoe_session::command, aoe_session::command_offset, copy_to_user(), ata_cb::count, aoeata::data, ata_command::data_in, EINVAL, ata_cb::lba, ata_lba::native, ata_fifo::native, aoe_session::status, stop_timer(), and aoe_session::timer.

Referenced by aoe_rx().

                                     {
        struct ata_command *command = aoe->command;
        unsigned int rx_data_len;
        unsigned int count;
        unsigned int data_len;

        /* Sanity check */
        if ( len < sizeof ( *aoeata ) ) {
                /* Ignore packet; allow timer to trigger retransmit */
                return -EINVAL;
        }
        rx_data_len = ( len - sizeof ( *aoeata ) );

        /* Calculate count and data_len for this subcommand */
        count = command->cb.count.native;
        if ( count > AOE_MAX_COUNT )
                count = AOE_MAX_COUNT;
        data_len = count * ATA_SECTOR_SIZE;

        /* Merge into overall ATA status */
        aoe->status |= aoeata->cmd_stat;

        /* Copy data payload */
        if ( command->data_in ) {
                if ( rx_data_len > data_len )
                        rx_data_len = data_len;
                copy_to_user ( command->data_in, aoe->command_offset,
                               aoeata->data, rx_data_len );
        }

        /* Update ATA command and offset */
        aoe->command_offset += data_len;
        command->cb.lba.native += count;
        command->cb.count.native -= count;

        /* Check for operation complete */
        if ( ! command->cb.count.native ) {
                aoe_done ( aoe, 0 );
                return 0;
        }

        /* Transmit next portion of request */
        stop_timer ( &aoe->timer );
        aoe_send_command ( aoe );

        return 0;
}

static int aoe_rx	(	struct io_buffer *	iobuf,
		struct net_device *netdev	__unused,
		const void *	ll_source
	)			[static]

Process incoming AoE packets.

Parameters:

	iobuf	I/O buffer
	netdev	Network device
	ll_source	Link-layer source address

Return values:

rc

Return status code

Definition at line 288 of file aoe.c.

References AOE_CMD_ATA, AOE_CMD_CONFIG, aoe_done(), AOE_FL_ERROR, AOE_FL_RESPONSE, aoe_rx_ata(), aoe_rx_cfg(), AOE_VERSION, AOE_VERSION_MASK, aoehdr::command, io_buffer::data, DBGC, EINVAL, EIO, EPROTONOSUPPORT, free_iob(), iob_len(), iob_pull, aoe_session::list, list_for_each_entry, aoe_session::major, aoehdr::major, aoe_session::minor, aoehdr::minor, ntohl, ntohs, aoe_session::rc, aoe_session::tag, aoehdr::tag, and aoehdr::ver_flags.

                                            {
        struct aoehdr *aoehdr = iobuf->data;
        struct aoe_session *aoe;
        int rc = 0;

        /* Sanity checks */
        if ( iob_len ( iobuf ) < sizeof ( *aoehdr ) ) {
                rc = -EINVAL;
                goto done;
        }
        if ( ( aoehdr->ver_flags & AOE_VERSION_MASK ) != AOE_VERSION ) {
                rc = -EPROTONOSUPPORT;
                goto done;
        }
        if ( ! ( aoehdr->ver_flags & AOE_FL_RESPONSE ) ) {
                /* Ignore AoE requests that we happen to see */
                goto done;
        }
        iob_pull ( iobuf, sizeof ( *aoehdr ) );

        /* Demultiplex amongst active AoE sessions */
        list_for_each_entry ( aoe, &aoe_sessions, list ) {
                if ( ntohs ( aoehdr->major ) != aoe->major )
                        continue;
                if ( aoehdr->minor != aoe->minor )
                        continue;
                if ( ntohl ( aoehdr->tag ) != aoe->tag )
                        continue;
                if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
                        aoe_done ( aoe, -EIO );
                        break;
                }
                switch ( aoehdr->command ) {
                case AOE_CMD_ATA:
                        rc = aoe_rx_ata ( aoe, iobuf->data, iob_len ( iobuf ));
                        break;
                case AOE_CMD_CONFIG:
                        rc = aoe_rx_cfg ( aoe, ll_source );
                        break;
                default:
                        DBGC ( aoe, "AoE %p ignoring command %02x\n",
                               aoe, aoehdr->command );
                        break;
                }
                break;
        }

 done:
        free_iob ( iobuf );
        return rc;
}

static int aoe_command	(	struct ata_device *	ata,
		struct ata_command *	command
	)			[static]

Issue ATA command via an open AoE session.

Parameters:

	ata	ATA device
	command	ATA command

Return values:

rc

Return status code

Definition at line 356 of file aoe.c.

References AOE_CMD_ATA, aoe_session::aoe_cmd_type, aoe_send_command(), ata_device::backend, aoe_session::command, aoe_session::command_offset, container_of, and aoe_session::status.

Referenced by aoe_attach().

                                                       {
        struct aoe_session *aoe =
                container_of ( ata->backend, struct aoe_session, refcnt );

        aoe->command = command;
        aoe->status = 0;
        aoe->command_offset = 0;
        aoe->aoe_cmd_type = AOE_CMD_ATA;

        aoe_send_command ( aoe );

        return 0;
}

static int aoe_discover

(

struct aoe_session *

aoe

)

[static]

Issue AoE config query for AoE target discovery.

Parameters:

aoe

AoE session

Return values:

rc

Return status code

Definition at line 377 of file aoe.c.

References AOE_CMD_CONFIG, aoe_session::aoe_cmd_type, aoe_send_command(), aoe_session::command, EINPROGRESS, NULL, aoe_session::rc, aoe_session::status, and step().

Referenced by aoe_attach().

                                                    {
        int rc;

        aoe->status = 0;
        aoe->aoe_cmd_type = AOE_CMD_CONFIG;
        aoe->command = NULL;

        aoe_send_command ( aoe );

        aoe->rc = -EINPROGRESS;
        while ( aoe->rc == -EINPROGRESS )
                step();
        rc = aoe->rc;

        return rc;
}

static int aoe_detached_command	(	struct ata_device *ata	__unused,
		struct ata_command *command	__unused
	)			[static]

Definition at line 394 of file aoe.c.

References ENODEV.

Referenced by aoe_detach().

                                                                         {
        return -ENODEV;
}

void aoe_detach

(

struct ata_device *

ata

)

Definition at line 399 of file aoe.c.

References aoe_detached_command(), ata_device::backend, ata_device::command, container_of, aoe_session::list, list_del, NULL, ref_put(), stop_timer(), and aoe_session::timer.

Referenced by aoeboot().

                                           {
        struct aoe_session *aoe =
                container_of ( ata->backend, struct aoe_session, refcnt );

        stop_timer ( &aoe->timer );
        ata->command = aoe_detached_command;
        list_del ( &aoe->list );
        ref_put ( ata->backend );
        ata->backend = NULL;
}

static int aoe_parse_root_path	(	struct aoe_session *	aoe,
		const char *	root_path
	)			[static]

Definition at line 410 of file aoe.c.

References EINVAL, aoe_session::major, aoe_session::minor, strncmp(), and strtoul().

Referenced by aoe_attach().

                                                         {
        char *ptr;

        if ( strncmp ( root_path, "aoe:", 4 ) != 0 )
                return -EINVAL;
        ptr = ( ( char * ) root_path + 4 );

        if ( *ptr++ != 'e' )
                return -EINVAL;

        aoe->major = strtoul ( ptr, &ptr, 10 );
        if ( *ptr++ != '.' )
                return -EINVAL;

        aoe->minor = strtoul ( ptr, &ptr, 10 );
        if ( *ptr )
                return -EINVAL;

        return 0;
}

int aoe_attach	(	struct ata_device *	ata,
		struct net_device *	netdev,
		const char *	root_path
	)

Definition at line 432 of file aoe.c.

References aoe_command(), aoe_discover(), aoe_free(), aoe_parse_root_path(), AOE_TAG_MAGIC, aoe_timer_expired(), ata_device::backend, ata_device::command, ENOMEM, retry_timer::expired, refcnt::free, aoe_session::list, list_add, net_device::ll_broadcast, memcpy, aoe_session::netdev, netdev_get(), aoe_session::rc, ref_get(), ref_put(), aoe_session::refcnt, aoe_session::tag, aoe_session::target, aoe_session::timer, and zalloc().

Referenced by aoeboot().

                                         {
        struct aoe_session *aoe;
        int rc;

        /* Allocate and initialise structure */
        aoe = zalloc ( sizeof ( *aoe ) );
        if ( ! aoe )
                return -ENOMEM;
        aoe->refcnt.free = aoe_free;
        aoe->netdev = netdev_get ( netdev );
        memcpy ( aoe->target, netdev->ll_broadcast, sizeof ( aoe->target ) );
        aoe->tag = AOE_TAG_MAGIC;
        aoe->timer.expired = aoe_timer_expired;

        /* Parse root path */
        if ( ( rc = aoe_parse_root_path ( aoe, root_path ) ) != 0 )
                goto err;

        /* Attach parent interface, transfer reference to connection
         * list, and return
         */
        ata->backend = ref_get ( &aoe->refcnt );
        ata->command = aoe_command;
        list_add ( &aoe->list, &aoe_sessions );

        /* Send discovery packet to find the target MAC address.
         * Ideally, this ought to be done asynchronously, but the
         * block device interface does not yet support asynchronous
         * operation.
         */
        if ( ( rc = aoe_discover( aoe ) ) != 0 )
               goto err;

        return 0;

 err:
        ref_put ( &aoe->refcnt );
        return rc;
}

---

Variable Documentation

struct net_protocol aoe_protocol

Definition at line 47 of file aoe.c.

Referenced by aoe_send_command().

struct net_protocol aoe_protocol __net_protocol

Initial value:

 {
        .name = "AoE",
        .net_proto = htons ( ETH_P_AOE ),
        .rx = aoe_rx,
}

AoE protocol.

Definition at line 343 of file aoe.c.