/*
 * Copyright (C) 2017 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 );
FILE_SECBOOT ( PERMITTED );

/**
 * @file
 *
 * SAN booting
 *
 */

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <ipxe/xfer.h>
#include <ipxe/open.h>
#include <ipxe/timer.h>
#include <ipxe/process.h>
#include <ipxe/iso9660.h>
#include <ipxe/dhcp.h>
#include <ipxe/settings.h>
#include <ipxe/quiesce.h>
#include <ipxe/sanboot.h>

/**
 * Timeout for block device commands (in ticks)
 *
 * Underlying devices should ideally never become totally stuck.
 * However, if they do, then the blocking SAN APIs provide no means
 * for the caller to cancel the operation, and the machine appears to
 * hang.  Use an overall timeout for all commands to avoid this
 * problem and bounce timeout failures to the caller.
 */
#define SAN_COMMAND_TIMEOUT ( 15 * TICKS_PER_SEC )

/**
 * Default number of times to retry commands
 *
 * We may need to retry commands.  For example, the underlying
 * connection may be closed by the SAN target due to an inactivity
 * timeout, or the SAN target may return pointless "error" messages
 * such as "SCSI power-on occurred".
 */
#define SAN_DEFAULT_RETRIES 10

/**
 * Delay between reopening attempts
 *
 * Some SAN targets will always accept connections instantly and
 * report a temporary unavailability by e.g. failing the TEST UNIT
 * READY command.  Avoid bombarding such targets by introducing a
 * small delay between attempts.
 */
#define SAN_REOPEN_DELAY_SECS 5

/** List of SAN devices */
LIST_HEAD ( san_devices );

/** Number of times to retry commands */
static unsigned long san_retries = SAN_DEFAULT_RETRIES;

/**
 * Find SAN device by drive number
 *
 * @v drive		Drive number
 * @ret sandev		SAN device, or NULL
 */
struct san_device * sandev_find ( unsigned int drive ) {
	struct san_device *sandev;

	list_for_each_entry ( sandev, &san_devices, list ) {
		if ( sandev->drive == drive )
			return sandev;
	}
	return NULL;
}

/**
 * Find next SAN device by drive number
 *
 * @v drive		Minimum drive number
 * @ret sandev		SAN device, or NULL
 */
struct san_device * sandev_next ( unsigned int drive ) {
	struct san_device *sandev;

	list_for_each_entry ( sandev, &san_devices, list ) {
		if ( sandev->drive >= drive )
			return sandev;
	}
	return NULL;
}

/**
 * Free SAN device
 *
 * @v refcnt		Reference count
 */
static void sandev_free ( struct refcnt *refcnt ) {
	struct san_device *sandev =
		container_of ( refcnt, struct san_device, refcnt );
	unsigned int i;

	assert ( ! timer_running ( &sandev->timer ) );
	assert ( ! sandev->active );
	assert ( list_empty ( &sandev->opened ) );
	for ( i = 0 ; i < sandev->paths ; i++ ) {
		uri_put ( sandev->path[i].uri );
		assert ( sandev->path[i].desc == NULL );
	}
	free ( sandev );
}

/**
 * Close SAN device command
 *
 * @v sandev		SAN device
 * @v rc		Reason for close
 */
static void sandev_command_close ( struct san_device *sandev, int rc ) {

	/* Stop timer */
	stop_timer ( &sandev->timer );

	/* Restart interface */
	intf_restart ( &sandev->command, rc );

	/* Record command status */
	sandev->command_rc = rc;
}

/**
 * Record SAN device capacity
 *
 * @v sandev		SAN device
 * @v capacity		SAN device capacity
 */
static void sandev_command_capacity ( struct san_device *sandev,
				      struct block_device_capacity *capacity ) {

	/* Record raw capacity information */
	memcpy ( &sandev->capacity, capacity, sizeof ( sandev->capacity ) );
}

/** SAN device command interface operations */
static struct interface_operation sandev_command_op[] = {
	INTF_OP ( intf_close, struct san_device *, sandev_command_close ),
	INTF_OP ( block_capacity, struct san_device *,
		  sandev_command_capacity ),
};

/** SAN device command interface descriptor */
static struct interface_descriptor sandev_command_desc =
	INTF_DESC ( struct san_device, command, sandev_command_op );

/**
 * Handle SAN device command timeout
 *
 * @v retry		Retry timer
 */
static void sandev_command_expired ( struct retry_timer *timer,
				     int over __unused ) {
	struct san_device *sandev =
		container_of ( timer, struct san_device, timer );

	sandev_command_close ( sandev, -ETIMEDOUT );
}

/**
 * Open SAN path
 *
 * @v sanpath		SAN path
 * @ret rc		Return status code
 */
static int sanpath_open ( struct san_path *sanpath ) {
	struct san_device *sandev = sanpath->sandev;
	int rc;

	/* Sanity check */
	list_check_contains_entry ( sanpath, &sandev->closed, list );

	/* Open interface */
	if ( ( rc = xfer_open_uri ( &sanpath->block, sanpath->uri ) ) != 0 ) {
		DBGC ( sandev->drive, "SAN %#02x.%d could not (re)open URI: "
		       "%s\n", sandev->drive, sanpath->index, strerror ( rc ) );
		return rc;
	}

	/* Update ACPI descriptor, if applicable */
	if ( ! ( sandev->flags & SAN_NO_DESCRIBE ) ) {
		if ( sanpath->desc )
			acpi_del ( sanpath->desc );
		sanpath->desc = acpi_describe ( &sanpath->block );
		if ( sanpath->desc )
			acpi_add ( sanpath->desc );
	}

	/* Start process */
	process_add ( &sanpath->process );

	/* Mark as opened */
	list_del ( &sanpath->list );
	list_add_tail ( &sanpath->list, &sandev->opened );

	/* Record as in progress */
	sanpath->path_rc = -EINPROGRESS;

	return 0;
}

/**
 * Close SAN path
 *
 * @v sanpath		SAN path
 * @v rc		Reason for close
 */
static void sanpath_close ( struct san_path *sanpath, int rc ) {
	struct san_device *sandev = sanpath->sandev;

	/* Record status */
	sanpath->path_rc = rc;

	/* Mark as closed */
	list_del ( &sanpath->list );
	list_add_tail ( &sanpath->list, &sandev->closed );

	/* Stop process */
	process_del ( &sanpath->process );

	/* Restart interfaces, avoiding potential loops */
	if ( sanpath == sandev->active ) {
		intfs_restart ( rc, &sandev->command, &sanpath->block, NULL );
		sandev->active = NULL;
		sandev_command_close ( sandev, rc );
	} else {
		intf_restart ( &sanpath->block, rc );
	}
}

/**
 * Handle closure of underlying block device interface
 *
 * @v sanpath		SAN path
 * @v rc		Reason for close
 */
static void sanpath_block_close ( struct san_path *sanpath, int rc ) {
	struct san_device *sandev = sanpath->sandev;

	/* Any closure is an error from our point of view */
	if ( rc == 0 )
		rc = -ENOTCONN;
	DBGC ( sandev->drive, "SAN %#02x.%d closed: %s\n",
	       sandev->drive, sanpath->index, strerror ( rc ) );

	/* Close path */
	sanpath_close ( sanpath, rc );
}

/**
 * Check flow control window
 *
 * @v sanpath		SAN path
 */
static size_t sanpath_block_window ( struct san_path *sanpath __unused ) {

	/* We are never ready to receive data via this interface.
	 * This prevents objects that support both block and stream
	 * interfaces from attempting to send us stream data.
	 */
	return 0;
}

/**
 * SAN path process
 *
 * @v sanpath		SAN path
 */
static void sanpath_step ( struct san_path *sanpath ) {
	struct san_device *sandev = sanpath->sandev;

	/* Ignore if we are already the active device */
	if ( sanpath == sandev->active )
		return;

	/* Wait until path has become available */
	if ( ! xfer_window ( &sanpath->block ) )
		return;

	/* Record status */
	sanpath->path_rc = 0;

	/* Mark as active path or close as applicable */
	if ( ! sandev->active ) {
		DBGC ( sandev->drive, "SAN %#02x.%d is active\n",
		       sandev->drive, sanpath->index );
		sandev->active = sanpath;
	} else {
		DBGC ( sandev->drive, "SAN %#02x.%d is available\n",
		       sandev->drive, sanpath->index );
		sanpath_close ( sanpath, 0 );
	}
}

/** SAN path block interface operations */
static struct interface_operation sanpath_block_op[] = {
	INTF_OP ( intf_close, struct san_path *, sanpath_block_close ),
	INTF_OP ( xfer_window, struct san_path *, sanpath_block_window ),
	INTF_OP ( xfer_window_changed, struct san_path *, sanpath_step ),
};

/** SAN path block interface descriptor */
static struct interface_descriptor sanpath_block_desc =
	INTF_DESC ( struct san_path, block, sanpath_block_op );

/** SAN path process descriptor */
static struct process_descriptor sanpath_process_desc =
	PROC_DESC_ONCE ( struct san_path, process, sanpath_step );

/**
 * Restart SAN device interface
 *
 * @v sandev		SAN device
 * @v rc		Reason for restart
 */
static void sandev_restart ( struct san_device *sandev, int rc ) {
	struct san_path *sanpath;

	/* Restart all block device interfaces */
	while ( ( sanpath = list_first_entry ( &sandev->opened,
					       struct san_path, list ) ) ) {
		sanpath_close ( sanpath, rc );
	}

	/* Clear active path */
	sandev->active = NULL;

	/* Close any outstanding command */
	sandev_command_close ( sandev, rc );
}

/**
 * (Re)open SAN device
 *
 * @v sandev		SAN device
 * @ret rc		Return status code
 *
 * This function will block until the device is available.
 */
int sandev_reopen ( struct san_device *sandev ) {
	struct san_path *sanpath;
	int rc;

	/* Unquiesce system */
	unquiesce();

	/* Close any outstanding command and restart interfaces */
	sandev_restart ( sandev, -ECONNRESET );
	assert ( sandev->active == NULL );
	assert ( list_empty ( &sandev->opened ) );

	/* Open all paths */
	while ( ( sanpath = list_first_entry ( &sandev->closed,
					       struct san_path, list ) ) ) {
		if ( ( rc = sanpath_open ( sanpath ) ) != 0 )
			goto err_open;
	}

	/* Wait for any device to become available, or for all devices
	 * to fail.
	 */
	while ( sandev->active == NULL ) {
		step();
		if ( list_empty ( &sandev->opened ) ) {
			/* Get status of the first device to be
			 * closed.  Do this on the basis that earlier
			 * errors (e.g. "invalid IQN") are probably
			 * more interesting than later errors
			 * (e.g. "TCP timeout").
			 */
			rc = -ENODEV;
			list_for_each_entry ( sanpath, &sandev->closed, list ) {
				rc = sanpath->path_rc;
				break;
			}
			DBGC ( sandev->drive, "SAN %#02x never became "
			       "available: %s\n", sandev->drive,
			       strerror ( rc ) );
			goto err_none;
		}
	}

	assert ( ! list_empty ( &sandev->opened ) );
	return 0;

 err_none:
 err_open:
	sandev_restart ( sandev, rc );
	return rc;
}

/** SAN device read/write command parameters */
struct san_command_rw_params {
	/** SAN device read/write operation */
	int ( * block_rw ) ( struct interface *control, struct interface *data,
			     uint64_t lba, unsigned int count, void *buffer,
			     size_t len );
	/** Data buffer */
	void *buffer;
	/** Starting LBA */
	uint64_t lba;
	/** Block count */
	unsigned int count;
};

/** SAN device command parameters */
union san_command_params {
	/** Read/write command parameters */
	struct san_command_rw_params rw;
};

/**
 * Initiate SAN device read/write command
 *
 * @v sandev		SAN device
 * @v params		Command parameters
 * @ret rc		Return status code
 */
static int sandev_command_rw ( struct san_device *sandev,
			       const union san_command_params *params ) {
	struct san_path *sanpath = sandev->active;
	size_t len = ( params->rw.count * sandev->capacity.blksize );
	int rc;

	/* Sanity check */
	assert ( sanpath != NULL );

	/* Initiate read/write command */
	if ( ( rc = params->rw.block_rw ( &sanpath->block, &sandev->command,
					  params->rw.lba, params->rw.count,
					  params->rw.buffer, len ) ) != 0 ) {
		DBGC ( sandev->drive, "SAN %#02x.%d could not initiate "
		       "read/write: %s\n", sandev->drive, sanpath->index,
		       strerror ( rc ) );
		return rc;
	}

	return 0;
}

/**
 * Initiate SAN device read capacity command
 *
 * @v sandev		SAN device
 * @v params		Command parameters
 * @ret rc		Return status code
 */
static int
sandev_command_read_capacity ( struct san_device *sandev,
			       const union san_command_params *params __unused){
	struct san_path *sanpath = sandev->active;
	int rc;

	/* Sanity check */
	assert ( sanpath != NULL );

	/* Initiate read capacity command */
	if ( ( rc = block_read_capacity ( &sanpath->block,
					  &sandev->command ) ) != 0 ) {
		DBGC ( sandev->drive, "SAN %#02x.%d could not initiate read "
		       "capacity: %s\n", sandev->drive, sanpath->index,
		       strerror ( rc ) );
		return rc;
	}

	return 0;
}

/**
 * Execute a single SAN device command and wait for completion
 *
 * @v sandev		SAN device
 * @v command		Command
 * @v params		Command parameters (if required)
 * @ret rc		Return status code
 */
static int
sandev_command ( struct san_device *sandev,
		 int ( * command ) ( struct san_device *sandev,
				     const union san_command_params *params ),
		 const union san_command_params *params ) {
	unsigned int retries = 0;
	int rc;

	/* Sanity check */
	assert ( ! timer_running ( &sandev->timer ) );

	/* Unquiesce system */
	unquiesce();

	/* (Re)try command */
	do {

		/* Reopen block device if applicable */
		if ( sandev_needs_reopen ( sandev ) &&
		     ( ( rc = sandev_reopen ( sandev ) ) != 0 ) ) {

			/* Delay reopening attempts */
			sleep_fixed ( SAN_REOPEN_DELAY_SECS );

			/* Retry opening indefinitely for multipath devices */
			if ( sandev->paths <= 1 )
				retries++;

			continue;
		}

		/* Initiate command */
		if ( ( rc = command ( sandev, params ) ) != 0 ) {
			retries++;
			continue;
		}

		/* Start expiry timer */
		start_timer_fixed ( &sandev->timer, SAN_COMMAND_TIMEOUT );

		/* Wait for command to complete */
		while ( timer_running ( &sandev->timer ) )
			step();

		/* Check command status */
		if ( ( rc = sandev->command_rc ) != 0 ) {
			retries++;
			continue;
		}

		return 0;

	} while ( retries <= san_retries );

	/* Sanity check */
	assert ( ! timer_running ( &sandev->timer ) );

	return rc;
}

/**
 * Reset SAN device
 *
 * @v sandev		SAN device
 * @ret rc		Return status code
 */
int sandev_reset ( struct san_device *sandev ) {
	int rc;

	DBGC ( sandev->drive, "SAN %#02x reset\n", sandev->drive );

	/* Close and reopen underlying block device */
	if ( ( rc = sandev_reopen ( sandev ) ) != 0 )
		return rc;

	return 0;
}

/**
 * Read from or write to SAN device
 *
 * @v sandev		SAN device
 * @v lba		Starting logical block address
 * @v count		Number of logical blocks
 * @v buffer		Data buffer
 * @v block_rw		Block read/write method
 * @ret rc		Return status code
 */
static int sandev_rw ( struct san_device *sandev, uint64_t lba,
		       unsigned int count, void *buffer,
		       int ( * block_rw ) ( struct interface *control,
					    struct interface *data,
					    uint64_t lba, unsigned int count,
					    void *buffer, size_t len ) ) {
	union san_command_params params;
	unsigned int remaining;
	size_t frag_len;
	int rc;

	/* Initialise command parameters */
	params.rw.block_rw = block_rw;
	params.rw.buffer = buffer;
	params.rw.lba = ( lba << sandev->blksize_shift );
	params.rw.count = sandev->capacity.max_count;
	remaining = ( count << sandev->blksize_shift );

	/* Read/write fragments */
	while ( remaining ) {

		/* Determine fragment length */
		if ( params.rw.count > remaining )
			params.rw.count = remaining;

		/* Execute command */
		if ( ( rc = sandev_command ( sandev, sandev_command_rw,
					     &params ) ) != 0 )
			return rc;

		/* Move to next fragment */
		frag_len = ( sandev->capacity.blksize * params.rw.count );
		params.rw.buffer += frag_len;
		params.rw.lba += params.rw.count;
		remaining -= params.rw.count;
	}

	return 0;
}

/**
 * Read from SAN device
 *
 * @v sandev		SAN device
 * @v lba		Starting logical block address
 * @v count		Number of logical blocks
 * @v buffer		Data buffer
 * @ret rc		Return status code
 */
int sandev_read ( struct san_device *sandev, uint64_t lba,
		  unsigned int count, void *buffer ) {
	int rc;

	/* Read from device */
	if ( ( rc = sandev_rw ( sandev, lba, count, buffer,
				block_read ) ) != 0 )
		return rc;

	return 0;
}

/**
 * Write to SAN device
 *
 * @v sandev		SAN device
 * @v lba		Starting logical block address
 * @v count		Number of logical blocks
 * @v buffer		Data buffer
 * @ret rc		Return status code
 */
int sandev_write ( struct san_device *sandev, uint64_t lba,
		   unsigned int count, void *buffer ) {
	int rc;

	/* Write to device */
	if ( ( rc = sandev_rw ( sandev, lba, count, buffer,
				block_write ) ) != 0 )
		return rc;

	/* Quiesce system.  This is a heuristic designed to ensure
	 * that the system is quiesced before Windows starts up, since
	 * a Windows SAN boot will typically write a status flag to
	 * the disk as its last action before transferring control to
	 * the native drivers.
	 */
	quiesce();

	return 0;
}

/**
 * Describe SAN device
 *
 * @v sandev		SAN device
 * @ret rc		Return status code
 *
 * Allow connections to progress until all existent path descriptors
 * are complete.
 */
static int sandev_describe ( struct san_device *sandev ) {
	struct san_path *sanpath;
	struct acpi_descriptor *desc;
	int rc;

	/* Wait for all paths to be either described or closed */
	while ( 1 ) {

		/* Allow connections to progress */
		step();

		/* Fail if any closed path has an incomplete descriptor */
		list_for_each_entry ( sanpath, &sandev->closed, list ) {
			desc = sanpath->desc;
			if ( ! desc )
				continue;
			if ( ( rc = desc->model->complete ( desc ) ) != 0 ) {
				DBGC ( sandev->drive, "SAN %#02x.%d could not "
				       "be described: %s\n", sandev->drive,
				       sanpath->index, strerror ( rc ) );
				return rc;
			}
		}

		/* Succeed if no paths have an incomplete descriptor */
		rc = 0;
		list_for_each_entry ( sanpath, &sandev->opened, list ) {
			desc = sanpath->desc;
			if ( ! desc )
				continue;
			if ( ( rc = desc->model->complete ( desc ) ) != 0 )
				break;
		}
		if ( rc == 0 )
			return 0;
	}
}

/**
 * Remove SAN device descriptors
 *
 * @v sandev		SAN device
 */
static void sandev_undescribe ( struct san_device *sandev ) {
	struct san_path *sanpath;
	unsigned int i;

	/* Remove all ACPI descriptors */
	for ( i = 0 ; i < sandev->paths ; i++ ) {
		sanpath = &sandev->path[i];
		if ( sanpath->desc ) {
			acpi_del ( sanpath->desc );
			sanpath->desc = NULL;
		}
	}
}

/**
 * Configure SAN device as a CD-ROM, if applicable
 *
 * @v sandev		SAN device
 * @ret rc		Return status code
 *
 * Both BIOS and UEFI require SAN devices to be accessed with a block
 * size of 2048.  While we could require the user to configure the
 * block size appropriately, this is non-trivial and would impose a
 * substantial learning effort on the user.  Instead, we check for the
 * presence of the ISO9660 primary volume descriptor and, if found,
 * then we force a block size of 2048 and map read/write requests
 * appropriately.
 */
static int sandev_parse_iso9660 ( struct san_device *sandev ) {
	static const struct iso9660_primary_descriptor_fixed primary_check = {
		.type = ISO9660_TYPE_PRIMARY,
		.id = ISO9660_ID,
	};
	union {
		struct iso9660_primary_descriptor primary;
		char bytes[ISO9660_BLKSIZE];
	} *scratch;
	unsigned int blksize;
	unsigned int blksize_shift;
	unsigned int lba;
	unsigned int count;
	int rc;

	/* Calculate required blocksize shift for potential CD-ROM access */
	blksize = sandev->capacity.blksize;
	blksize_shift = 0;
	while ( blksize < ISO9660_BLKSIZE ) {
		blksize <<= 1;
		blksize_shift++;
	}
	if ( blksize > ISO9660_BLKSIZE ) {
		/* Cannot be a CD-ROM.  This is not an error. */
		rc = 0;
		goto invalid_blksize;
	}
	lba = ( ISO9660_PRIMARY_LBA << blksize_shift );
	count = ( 1 << blksize_shift );

	/* Allocate scratch area */
	scratch = malloc ( ISO9660_BLKSIZE );
	if ( ! scratch ) {
		rc = -ENOMEM;
		goto err_alloc;
	}

	/* Read primary volume descriptor */
	if ( ( rc = sandev_read ( sandev, lba, count, scratch ) ) != 0 ) {
		DBGC ( sandev->drive, "SAN %#02x could not read ISO9660 "
		       "primary volume descriptor: %s\n",
		       sandev->drive, strerror ( rc ) );
		goto err_rw;
	}

	/* Configure as CD-ROM if applicable */
	if ( memcmp ( &scratch->primary.fixed, &primary_check,
		      sizeof ( primary_check ) ) == 0 ) {
		DBGC ( sandev->drive, "SAN %#02x contains an ISO9660 "
		       "filesystem; treating as CD-ROM\n", sandev->drive );
		sandev->blksize_shift = blksize_shift;
		sandev->is_cdrom = 1;
	}

 err_rw:
	free ( scratch );
 err_alloc:
 invalid_blksize:
	return rc;
}

/**
 * Allocate SAN device
 *
 * @v uris		List of URIs
 * @v count		Number of URIs
 * @v priv_size		Size of private data
 * @ret sandev		SAN device, or NULL
 */
struct san_device * alloc_sandev ( struct uri **uris, unsigned int count,
				   size_t priv_size ) {
	struct san_device *sandev;
	struct san_path *sanpath;
	size_t size;
	unsigned int i;

	/* Allocate and initialise structure */
	size = ( sizeof ( *sandev ) + ( count * sizeof ( sandev->path[0] ) ) );
	sandev = zalloc ( size + priv_size );
	if ( ! sandev )
		return NULL;
	ref_init ( &sandev->refcnt, sandev_free );
	intf_init ( &sandev->command, &sandev_command_desc, &sandev->refcnt );
	timer_init ( &sandev->timer, sandev_command_expired, &sandev->refcnt );
	sandev->priv = ( ( ( void * ) sandev ) + size );
	sandev->paths = count;
	INIT_LIST_HEAD ( &sandev->opened );
	INIT_LIST_HEAD ( &sandev->closed );
	for ( i = 0 ; i < count ; i++ ) {
		sanpath = &sandev->path[i];
		sanpath->sandev = sandev;
		sanpath->index = i;
		sanpath->uri = uri_get ( uris[i] );
		list_add_tail ( &sanpath->list, &sandev->closed );
		intf_init ( &sanpath->block, &sanpath_block_desc,
			    &sandev->refcnt );
		process_init_stopped ( &sanpath->process, &sanpath_process_desc,
				       &sandev->refcnt );
		sanpath->path_rc = -EINPROGRESS;
	}

	return sandev;
}

/**
 * Register SAN device
 *
 * @v sandev		SAN device
 * @v drive		Drive number
 * @v flags		Flags
 * @ret rc		Return status code
 */
int register_sandev ( struct san_device *sandev, unsigned int drive,
		      unsigned int flags ) {
	struct san_device *before;
	int rc;

	/* Check that drive number is not in use */
	if ( sandev_find ( drive ) != NULL ) {
		DBGC ( sandev->drive, "SAN %#02x is already in use\n", drive );
		rc = -EADDRINUSE;
		goto err_in_use;
	}

	/* Record drive number and flags */
	sandev->drive = drive;
	sandev->flags = flags;

	/* Check that device is capable of being opened (i.e. that all
	 * URIs are well-formed and that at least one path is
	 * working).
	 */
	if ( ( rc = sandev_reopen ( sandev ) ) != 0 )
		goto err_reopen;

	/* Describe device */
	if ( ( rc = sandev_describe ( sandev ) ) != 0 )
		goto err_describe;

	/* Read device capacity */
	if ( ( rc = sandev_command ( sandev, sandev_command_read_capacity,
				     NULL ) ) != 0 )
		goto err_capacity;

	/* Configure as a CD-ROM, if applicable */
	if ( ( rc = sandev_parse_iso9660 ( sandev ) ) != 0 )
		goto err_iso9660;

	/* Add to list of SAN devices, in drive order */
	for_each_sandev ( before ) {
		if ( before->drive > sandev->drive )
			break;
	}
	list_add_tail ( &sandev->list, &before->list );
	DBGC ( sandev->drive, "SAN %#02x registered\n", sandev->drive );

	return 0;

	list_del ( &sandev->list );
 err_iso9660:
 err_capacity:
 err_describe:
 err_reopen:
	sandev_restart ( sandev, rc );
	sandev_undescribe ( sandev );
 err_in_use:
	return rc;
}

/**
 * Unregister SAN device
 *
 * @v sandev		SAN device
 */
void unregister_sandev ( struct san_device *sandev ) {

	/* Sanity check */
	assert ( ! timer_running ( &sandev->timer ) );

	/* Remove from list of SAN devices */
	list_del ( &sandev->list );

	/* Shut down interfaces */
	sandev_restart ( sandev, 0 );

	/* Remove ACPI descriptors */
	sandev_undescribe ( sandev );

	DBGC ( sandev->drive, "SAN %#02x unregistered\n", sandev->drive );
}

/** The "san-drive" setting */
const struct setting san_drive_setting __setting ( SETTING_SANBOOT_EXTRA,
						   san-drive ) = {
	.name = "san-drive",
	.description = "SAN drive number",
	.tag = DHCP_EB_SAN_DRIVE,
	.type = &setting_type_uint8,
};

/**
 * Get default SAN drive number
 *
 * @ret drive		Default drive number
 */
unsigned int san_default_drive ( void ) {
	unsigned long drive;

	/* Use "san-drive" setting, if specified */
	if ( fetch_uint_setting ( NULL, &san_drive_setting, &drive ) >= 0 )
		return drive;

	/* Otherwise, default to booting from first hard disk */
	return SAN_DEFAULT_DRIVE;
}

/** The "san-retries" setting */
const struct setting san_retries_setting __setting ( SETTING_SANBOOT_EXTRA,
						     san-retries ) = {
	.name = "san-retries",
	.description = "SAN retry count",
	.tag = DHCP_EB_SAN_RETRY,
	.type = &setting_type_int8,
};

/**
 * Apply SAN boot settings
 *
 * @ret rc		Return status code
 */
static int sandev_apply ( void ) {

	/* Apply "san-retries" setting */
	if ( fetch_uint_setting ( NULL, &san_retries_setting,
				  &san_retries ) < 0 ) {
		san_retries = SAN_DEFAULT_RETRIES;
	}

	return 0;
}

/** Settings applicator */
struct settings_applicator sandev_applicator __settings_applicator = {
	.apply = sandev_apply,
};