Added generic asynchronous operations code.

Removed data_in_len and data_out_len from ata_command structure; the
lengths are implied by the sector count and the presence of the data_in
or data_out pointers.

Changed AoE code to use subcommands by default, and made aoe_issue()
nonblocking (with completion via async_wait()).

src/drivers/ata/aoedev.c

 	struct aoe_device *aoedev
 		= container_of ( ata, struct aoe_device, ata );
 
-	return aoe_issue_split ( &aoedev->aoe, command );
+	aoe_issue ( &aoedev->aoe, command );
+	return async_wait ( &aoedev->aoe.aop );
 }
 
 /**

src/drivers/block/ata.c

 
 #include <stddef.h>
 #include <string.h>
+#include <assert.h>
 #include <byteswap.h>
 #include <gpxe/blockdev.h>
 #include <gpxe/ata.h>
 		command.cb.device |= command.cb.lba.bytes.low_prev;
 	command.cb.cmd_stat = ( ata->lba48 ? ATA_CMD_READ_EXT : ATA_CMD_READ );
 	command.data_in = buffer;
-	command.data_in_len = ( count * blockdev->blksize );
 	return ata_command ( ata, &command );
 }
 
 	command.cb.cmd_stat = ( ata->lba48 ?
 				ATA_CMD_WRITE_EXT : ATA_CMD_WRITE );
 	command.data_out = buffer;
-	command.data_out_len = ( count * blockdev->blksize );
 	return ata_command ( ata, &command );
 }
 
 
 	/* Issue IDENTIFY */
 	memset ( &command, 0, sizeof ( command ) );
-	command.cb.count.native = 1; /* n/a according to spec, but at least
-				      * AoE vblade devices require it. */
+	command.cb.count.native = 1;
 	command.cb.device = ( ata->device | ATA_DEV_OBSOLETE | ATA_DEV_LBA );
 	command.cb.cmd_stat = ATA_CMD_IDENTIFY;
 	command.data_in = virt_to_user ( &identity );
-	command.data_in_len = sizeof ( identity );
+	linker_assert ( sizeof ( identity ) == ATA_SECTOR_SIZE,
+			__ata_identity_bad_size__ );
 	if ( ( rc = ata_command ( ata, &command ) ) != 0 )
 		return rc;
 

src/include/gpxe/aoe.h

 #include <stdint.h>
 #include <gpxe/list.h>
 #include <gpxe/if_ether.h>
+#include <gpxe/retry.h>
+#include <gpxe/async.h>
 #include <gpxe/ata.h>
 
 /** An AoE ATA command */
 	/** Target MAC address */
 	uint8_t target[ETH_ALEN];
 
-	/** Tag for current command */
+	/** Tag for current AoE command */
 	uint32_t tag;
+
 	/** Current ATA command */
 	struct ata_command *command;
-	/** Status of the command */
-	int status;
+	/** Overall status of current ATA command */
+	unsigned int status;
 	/** Byte offset within command's data buffer */
 	unsigned int command_offset;
+	/** Asynchronous operation for this command */
+	struct async_operation aop;
+
+	/** Retransmission timer */
+	struct retry_timer timer;
 };
 
 #define AOE_STATUS_ERR_MASK	0x0f /**< Error portion of status code */ 
 #define AOE_STATUS_PENDING	0x80 /**< Command pending */
-#define AOE_STATUS_UNDERRUN	0x40 /**< Buffer overrun */
-#define AOE_STATUS_OVERRUN	0x20 /**< Buffer underrun */
 
 /** Maximum number of sectors per packet */
 #define AOE_MAX_COUNT 2
 
 extern void aoe_open ( struct aoe_session *aoe );
 extern void aoe_close ( struct aoe_session *aoe );
-extern int aoe_issue ( struct aoe_session *aoe, struct ata_command *command );
-extern int aoe_issue_split ( struct aoe_session *aoe,
-			     struct ata_command *command );
+extern void aoe_issue ( struct aoe_session *aoe, struct ata_command *command );
 
 /** An AoE device */
 struct aoe_device {

src/include/gpxe/async.h

+#ifndef _GPXE_ASYNC_H
+#define _GPXE_ASYNC_H
+
+/** @file
+ *
+ * Asynchronous operations
+ *
+ */
+
+#include <errno.h>
+#include <assert.h>
+
+/** An asynchronous operation */
+struct async_operation {
+	/** Operation status
+	 *
+	 * This is an error code as defined in errno.h, plus an offset
+	 * of EINPROGRESS.  This means that a status value of 0
+	 * corresponds to a return status code of -EINPROGRESS,
+	 * i.e. that the default state of an asynchronous operation is
+	 * "not yet completed".
+	 */
+	int status;
+};
+
+/**
+ * Set asynchronous operation status
+ *
+ * @v aop	Asynchronous operation
+ * @v rc	Return status code
+ */
+static inline __attribute__ (( always_inline )) void
+async_set_status ( struct async_operation *aop, int rc ) {
+	aop->status = ( rc + EINPROGRESS );
+}
+
+/**
+ * Get asynchronous operation status
+ *
+ * @v aop	Asynchronous operation
+ * @ret rc	Return status code
+ */
+static inline __attribute__ (( always_inline )) int
+async_status ( struct async_operation *aop ) {
+	return ( aop->status - EINPROGRESS );
+}
+
+/**
+ * Flag asynchronous operation as complete
+ *
+ * @v aop	Asynchronous operation
+ * @v rc	Return status code
+ */
+static inline __attribute__ (( always_inline )) void
+async_done ( struct async_operation *aop, int rc ) {
+	assert ( rc != -EINPROGRESS );
+	async_set_status ( aop, rc );
+}
+
+extern int async_wait ( struct async_operation *aop );
+
+#endif /* _GPXE_ASYNC_H */

src/include/gpxe/ata.h

 struct ata_command {
 	/** ATA command block */
 	struct ata_cb cb;
-	/** Data-out buffer (may be NULL) */
-	userptr_t data_out;
-	/** Data-out buffer length
+	/** Data-out buffer (may be NULL)
 	 *
-	 * Must be zero if @c data_out is NULL
+	 * If non-NULL, this buffer must be ata_command::cb::count
+	 * sectors in size.
 	 */
-	size_t data_out_len;
-	/** Data-in buffer (may be NULL) */
-	userptr_t data_in;
-	/** Data-in buffer length
+	userptr_t data_out;
+	/** Data-in buffer (may be NULL)
 	 *
-	 * Must be zero if @c data_in is NULL
+	 * If non-NULL, this buffer must be ata_command::cb::count
+	 * sectors in size.
 	 */
-	size_t data_in_len;
+	userptr_t data_in;
 };
 
 /**

src/net/aoe.c

 #include <gpxe/uaccess.h>
 #include <gpxe/ata.h>
 #include <gpxe/netdevice.h>
-#include <gpxe/process.h>
+#include <gpxe/async.h>
 #include <gpxe/aoe.h>
 
 /** @file
 /** List of all AoE sessions */
 static LIST_HEAD ( aoe_sessions );
 
+/**
+ * Mark current AoE command complete
+ *
+ * @v aoe		AoE session
+ * @v rc		Return status code
+ */
+static void aoe_done ( struct aoe_session *aoe, int rc ) {
+
+	/* Record overall command status */
+	aoe->command->cb.cmd_stat = aoe->status;
+	aoe->command = NULL;
+
+	/* Mark async operation as complete */
+	async_done ( &aoe->aop, rc );
+}
+
 /**
  * Send AoE command
  *
 	struct pk_buff *pkb;
 	struct aoehdr *aoehdr;
 	struct aoecmd *aoecmd;
+	unsigned int count;
+	unsigned int data_out_len;
+
+	/* Calculate count and data_out_len for this subcommand */
+	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 );
 
 	/* Create outgoing packet buffer */
 	pkb = alloc_pkb ( ETH_HLEN + sizeof ( *aoehdr ) + sizeof ( *aoecmd ) +
-			  command->data_out_len );
+			  data_out_len );
 	if ( ! pkb )
 		return -ENOMEM;
 	pkb->net_protocol = &aoe_protocol;
 	linker_assert ( AOE_FL_DEV_HEAD	== ATA_DEV_SLAVE, __fix_ata_h__ );
 	aoecmd->aflags = ( ( command->cb.lba48 ? AOE_FL_EXTENDED : 0 ) |
 			   ( command->cb.device & ATA_DEV_SLAVE ) |
-			   ( command->data_out_len ? AOE_FL_WRITE : 0 ) );
+			   ( data_out_len ? AOE_FL_WRITE : 0 ) );
 	aoecmd->err_feat = command->cb.err_feat.bytes.cur;
-	aoecmd->count = command->cb.count.bytes.cur;
+	aoecmd->count = count;
 	aoecmd->cmd_stat = command->cb.cmd_stat;
 	aoecmd->lba.u64 = cpu_to_le64 ( command->cb.lba.native );
 	if ( ! command->cb.lba48 )
 		aoecmd->lba.bytes[3] |= ( command->cb.device & ATA_DEV_MASK );
 
 	/* Fill data payload */
-	copy_from_user ( pkb_put ( pkb, command->data_out_len ),
-			 command->data_out, aoe->command_offset,
-			 command->data_out_len );
+	copy_from_user ( pkb_put ( pkb, data_out_len ), command->data_out,
+			 aoe->command_offset, data_out_len );
 
 	/* Send packet */
 	return net_transmit_via ( pkb, aoe->netdev );
 			     unsigned int len ) {
 	struct aoecmd *aoecmd = aoehdr->arg.command;
 	struct ata_command *command = aoe->command;
-	unsigned int data_in_len;
+	unsigned int rx_data_len;
+	unsigned int count;
+	unsigned int data_len;
 	
 	/* Sanity check */
 	if ( len < ( sizeof ( *aoehdr ) + sizeof ( *aoecmd ) ) )
 		return -EINVAL;
+	rx_data_len = ( len - sizeof ( *aoehdr ) - sizeof ( *aoecmd ) );
 
-	/* Set overall status code */
-	aoe->status = ( ( aoehdr->ver_flags & AOE_FL_ERROR ) ?
-			aoehdr->error : 0 );
+	/* Check for fatal errors */
+	if ( aoehdr->ver_flags & AOE_FL_ERROR ) {
+		aoe_done ( aoe, -EIO );
+		return 0;
+	}
+
+	/* 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 |= aoecmd->cmd_stat;
 
-	/* Copy ATA results */
-	command->cb.err_feat.bytes.cur = aoecmd->err_feat;
-	command->cb.count.bytes.cur = aoecmd->count;
-	command->cb.cmd_stat = aoecmd->cmd_stat;
-	command->cb.lba.native = le64_to_cpu ( aoecmd->lba.u64 );
-	command->cb.lba.bytes.pad = 0;
-	
 	/* Copy data payload */
-	data_in_len = ( len - sizeof ( *aoehdr ) - sizeof ( *aoecmd ) );
-	if ( data_in_len > command->data_in_len ) {
-		data_in_len = command->data_in_len;
-		aoe->status |= AOE_STATUS_OVERRUN;
-	} else if ( data_in_len < command->data_in_len ) {
-		aoe->status |= AOE_STATUS_UNDERRUN;
+	if ( command->data_in ) {
+		if ( rx_data_len > data_len )
+			rx_data_len = data_len;
+		copy_to_user ( command->data_in, aoe->command_offset,
+			       aoecmd->data, rx_data_len );
 	}
-	copy_to_user ( command->data_in, aoe->command_offset,
-		       aoecmd->data, data_in_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 */
+	aoe_send_command ( aoe );
 
 	return 0;
 }
 	list_del ( &aoe->list );
 }
 
-/**
- * Kick an AoE session into life
- *
- * @v aoe		AoE session
- *
- * Transmits an AoE request.  Call this function to issue a new
- * command, or when a retransmission timer expires.
- */
-void aoe_kick ( struct aoe_session *aoe ) {
-	aoe_send_command ( aoe );
-}
-
 /**
  * Issue ATA command via an open AoE session
  *
  * @v aoe		AoE session
  * @v command		ATA command
- * @ret rc		Return status code
  *
- * The ATA command must fit within a single AoE frame (i.e. the sector
- * count must not exceed AOE_MAX_COUNT).
+ * Only one command may be issued concurrently per session.  This call
+ * is non-blocking; use async_wait() to wait for the command to
+ * complete.
  */
-int aoe_issue ( struct aoe_session *aoe, struct ata_command *command ) {
+void aoe_issue ( struct aoe_session *aoe, struct ata_command *command ) {
 	aoe->command = command;
-	aoe->status = AOE_STATUS_PENDING;
-
-	aoe_kick ( aoe );
-	while ( aoe->status & AOE_STATUS_PENDING ) {
-		step();
-	}
-	aoe->command = NULL;
-
-	return ( ( aoe->status & AOE_STATUS_ERR_MASK ) ? -EIO : 0 );
-}
-
-/**
- * Issue ATA command via an open AoE session
- *
- * @v aoe		AoE session
- * @v command		ATA command
- * @ret rc		Return status code
- *
- * The ATA command will be split into several smaller ATA commands,
- * each with a sector count no larger than AOE_MAX_COUNT.
- */
-int aoe_issue_split ( struct aoe_session *aoe, struct ata_command *command ) {
-	struct ata_command subcommand;
-	unsigned int offset;
-	unsigned int count;
-	unsigned int data_len;
-	unsigned int status = 0;
-	int rc = 0;
-
-	/* Split ATA command into AoE-sized subcommands */
-	for ( offset = 0; offset < command->cb.count.native; offset += count ){
-		memcpy ( &subcommand, command, sizeof ( subcommand ) );
-		count = ( command->cb.count.native - offset );
-		if ( count > AOE_MAX_COUNT )
-			count = AOE_MAX_COUNT;
-		data_len = count * ATA_SECTOR_SIZE;
-		if ( subcommand.data_in_len )
-			subcommand.data_in_len = data_len;
-		if ( subcommand.data_out_len )
-			subcommand.data_out_len = data_len;
-		aoe->command_offset = ( offset * ATA_SECTOR_SIZE );
-		subcommand.cb.lba.native += offset;
-		subcommand.cb.count.native = count;
-		if ( ( rc = aoe_issue ( aoe, &subcommand ) ) != 0 )
-			goto done;
-		status |= subcommand.cb.cmd_stat;
-	}
-	command->cb.cmd_stat = status;
-
- done:
+	aoe->status = 0;
 	aoe->command_offset = 0;
-	return rc;
+	aoe_send_command ( aoe );
 }