SCSI block device. More...

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <byteswap.h>
#include <errno.h>
#include <ipxe/list.h>
#include <ipxe/process.h>
#include <ipxe/xfer.h>
#include <ipxe/blockdev.h>
#include <ipxe/scsi.h>

Data Structures
struct	scsi_device
	A SCSI device. More...

struct	scsi_command
	A SCSI command. More...

struct	scsi_command_type
	A SCSI command type. More...

struct	scsi_read_capacity_private
	SCSI READ CAPACITY private data. More...

Macros
#define	SCSI_READY_MAX_RETRIES 10
	Maximum number of TEST UNIT READY retries. More...

#define	EIO_NO_SENSE __einfo_error ( EINFO_EIO_NO_SENSE )

#define	EINFO_EIO_NO_SENSE __einfo_uniqify ( EINFO_EIO, 0x00, "No sense" )

#define	EIO_RECOVERED_ERROR __einfo_error ( EINFO_EIO_RECOVERED_ERROR )

#define	EINFO_EIO_RECOVERED_ERROR __einfo_uniqify ( EINFO_EIO, 0x01, "Recovered error" )

#define	EIO_NOT_READY __einfo_error ( EINFO_EIO_NOT_READY )

#define	EINFO_EIO_NOT_READY __einfo_uniqify ( EINFO_EIO, 0x02, "Not ready" )

#define	EIO_MEDIUM_ERROR __einfo_error ( EINFO_EIO_MEDIUM_ERROR )

#define	EINFO_EIO_MEDIUM_ERROR __einfo_uniqify ( EINFO_EIO, 0x03, "Medium error" )

#define	EIO_HARDWARE_ERROR __einfo_error ( EINFO_EIO_HARDWARE_ERROR )

#define	EINFO_EIO_HARDWARE_ERROR __einfo_uniqify ( EINFO_EIO, 0x04, "Hardware error" )

#define	EIO_ILLEGAL_REQUEST __einfo_error ( EINFO_EIO_ILLEGAL_REQUEST )

#define	EINFO_EIO_ILLEGAL_REQUEST __einfo_uniqify ( EINFO_EIO, 0x05, "Illegal request" )

#define	EIO_UNIT_ATTENTION __einfo_error ( EINFO_EIO_UNIT_ATTENTION )

#define	EINFO_EIO_UNIT_ATTENTION __einfo_uniqify ( EINFO_EIO, 0x06, "Unit attention" )

#define	EIO_DATA_PROTECT __einfo_error ( EINFO_EIO_DATA_PROTECT )

#define	EINFO_EIO_DATA_PROTECT __einfo_uniqify ( EINFO_EIO, 0x07, "Data protect" )

#define	EIO_BLANK_CHECK __einfo_error ( EINFO_EIO_BLANK_CHECK )

#define	EINFO_EIO_BLANK_CHECK __einfo_uniqify ( EINFO_EIO, 0x08, "Blank check" )

#define	EIO_VENDOR_SPECIFIC __einfo_error ( EINFO_EIO_VENDOR_SPECIFIC )

#define	EINFO_EIO_VENDOR_SPECIFIC __einfo_uniqify ( EINFO_EIO, 0x09, "Vendor specific" )

#define	EIO_COPY_ABORTED __einfo_error ( EINFO_EIO_COPY_ABORTED )

#define	EINFO_EIO_COPY_ABORTED __einfo_uniqify ( EINFO_EIO, 0x0a, "Copy aborted" )

#define	EIO_ABORTED_COMMAND __einfo_error ( EINFO_EIO_ABORTED_COMMAND )

#define	EINFO_EIO_ABORTED_COMMAND __einfo_uniqify ( EINFO_EIO, 0x0b, "Aborted command" )

#define	EIO_RESERVED __einfo_error ( EINFO_EIO_RESERVED )

#define	EINFO_EIO_RESERVED __einfo_uniqify ( EINFO_EIO, 0x0c, "Reserved" )

#define	EIO_VOLUME_OVERFLOW __einfo_error ( EINFO_EIO_VOLUME_OVERFLOW )

#define	EINFO_EIO_VOLUME_OVERFLOW __einfo_uniqify ( EINFO_EIO, 0x0d, "Volume overflow" )

#define	EIO_MISCOMPARE __einfo_error ( EINFO_EIO_MISCOMPARE )

#define	EINFO_EIO_MISCOMPARE __einfo_uniqify ( EINFO_EIO, 0x0e, "Miscompare" )

#define	EIO_COMPLETED __einfo_error ( EINFO_EIO_COMPLETED )

#define	EINFO_EIO_COMPLETED __einfo_uniqify ( EINFO_EIO, 0x0f, "Completed" )

#define	EIO_SENSE(key)

Enumerations
enum	scsi_device_flags { SCSIDEV_UNIT_TESTED = 0x0001, SCSIDEV_UNIT_READY = 0x0002 }
	SCSI device flags. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

	FILE_SECBOOT (PERMITTED)

int	scsi_parse_lun (const char lun_string, struct scsi_lun lun)
	Parse SCSI LUN. More...

void	scsi_parse_sense (const void data, size_t len, struct scsi_sns_descriptor sense)
	Parse SCSI sense data. More...

int	scsi_command (struct interface control, struct interface data, struct scsi_cmd *command)
	Issue SCSI command. More...

void	scsi_response (struct interface intf, struct scsi_rsp response)
	Report SCSI response. More...

static struct scsi_device *	scsidev_get (struct scsi_device *scsidev)
	Get reference to SCSI device. More...

static void	scsidev_put (struct scsi_device *scsidev)
	Drop reference to SCSI device. More...

static struct scsi_command *	scsicmd_get (struct scsi_command *scsicmd)
	Get reference to SCSI command. More...

static void	scsicmd_put (struct scsi_command *scsicmd)
	Drop reference to SCSI command. More...

static void *	scsicmd_priv (struct scsi_command *scsicmd)
	Get SCSI command private data. More...

static void	scsicmd_free (struct refcnt *refcnt)
	Free SCSI command. More...

static void	scsicmd_close (struct scsi_command *scsicmd, int rc)
	Close SCSI command. More...

static int	scsicmd_command (struct scsi_command *scsicmd)
	Construct and issue SCSI command. More...

static void	scsicmd_done (struct scsi_command *scsicmd, int rc)
	Handle SCSI command completion. More...

static void	scsicmd_response (struct scsi_command scsicmd, struct scsi_rsp response)
	Handle SCSI response. More...

static void	scsicmd_read_cmd (struct scsi_command scsicmd, struct scsi_cmd command)
	Construct SCSI READ command. More...

static void	scsicmd_write_cmd (struct scsi_command scsicmd, struct scsi_cmd command)
	Construct SCSI WRITE command. More...

static void	scsicmd_read_capacity_cmd (struct scsi_command scsicmd, struct scsi_cmd command)
	Construct SCSI READ CAPACITY command. More...

static void	scsicmd_read_capacity_done (struct scsi_command *scsicmd, int rc)
	Handle SCSI READ CAPACITY command completion. More...

static void	scsicmd_test_unit_ready_cmd (struct scsi_command scsicmd __unused, struct scsi_cmd command)
	Construct SCSI TEST UNIT READY command. More...

static int	scsidev_command (struct scsi_device scsidev, struct interface block, struct scsi_command_type type, uint64_t lba, unsigned int count, void buffer, size_t len)
	Create SCSI command. More...

static int	scsidev_read (struct scsi_device scsidev, struct interface block, uint64_t lba, unsigned int count, void *buffer, size_t len)
	Issue SCSI block read. More...

static int	scsidev_write (struct scsi_device scsidev, struct interface block, uint64_t lba, unsigned int count, void *buffer, size_t len)
	Issue SCSI block write. More...

static int	scsidev_read_capacity (struct scsi_device scsidev, struct interface block)
	Read SCSI device capacity. More...

static int	scsidev_test_unit_ready (struct scsi_device scsidev, struct interface block)
	Test to see if SCSI device is ready. More...

static size_t	scsidev_window (struct scsi_device *scsidev)
	Check SCSI device flow-control window. More...

static void	scsidev_close (struct scsi_device *scsidev, int rc)
	Close SCSI device. More...

static void	scsidev_ready (struct scsi_device *scsidev, int rc)
	Handle SCSI TEST UNIT READY response. More...

static void	scsidev_step (struct scsi_device *scsidev)
	SCSI TEST UNIT READY process. More...

int	scsi_open (struct interface block, struct interface scsi, struct scsi_lun *lun)
	Open SCSI device. More...

Variables
static struct scsi_command_type	scsicmd_read
	SCSI READ command type. More...

static struct scsi_command_type	scsicmd_write
	SCSI WRITE command type. More...

static struct scsi_command_type	scsicmd_read_capacity
	SCSI READ CAPACITY command type. More...

static struct scsi_command_type	scsicmd_test_unit_ready
	SCSI TEST UNIT READY command type. More...

static struct interface_operation	scsicmd_block_op []
	SCSI command block interface operations. More...

static struct interface_descriptor	scsicmd_block_desc
	SCSI command block interface descriptor. More...

static struct interface_operation	scsicmd_scsi_op []
	SCSI command SCSI interface operations. More...

static struct interface_descriptor	scsicmd_scsi_desc
	SCSI command SCSI interface descriptor. More...

static struct interface_operation	scsidev_block_op []
	SCSI device block interface operations. More...

static struct interface_descriptor	scsidev_block_desc
	SCSI device block interface descriptor. More...

static struct interface_operation	scsidev_ready_op []
	SCSI device TEST UNIT READY interface operations. More...

static struct interface_descriptor	scsidev_ready_desc
	SCSI device TEST UNIT READY interface descriptor. More...

static struct interface_operation	scsidev_scsi_op []
	SCSI device SCSI interface operations. More...

static struct interface_descriptor	scsidev_scsi_desc
	SCSI device SCSI interface descriptor. More...

static struct process_descriptor	scsidev_process_desc
	SCSI device process descriptor. More...

Detailed Description

SCSI block device.

Definition in file scsi.c.

Macro Definition Documentation

◆ SCSI_READY_MAX_RETRIES

#define SCSI_READY_MAX_RETRIES 10

Maximum number of TEST UNIT READY retries.

Definition at line 45 of file scsi.c.

◆ EIO_NO_SENSE

#define EIO_NO_SENSE __einfo_error ( EINFO_EIO_NO_SENSE )

Definition at line 48 of file scsi.c.

◆ EINFO_EIO_NO_SENSE

#define EINFO_EIO_NO_SENSE __einfo_uniqify ( EINFO_EIO, 0x00, "No sense" )

Definition at line 49 of file scsi.c.

◆ EIO_RECOVERED_ERROR

#define EIO_RECOVERED_ERROR __einfo_error ( EINFO_EIO_RECOVERED_ERROR )

Definition at line 51 of file scsi.c.

◆ EINFO_EIO_RECOVERED_ERROR

#define EINFO_EIO_RECOVERED_ERROR __einfo_uniqify ( EINFO_EIO, 0x01, "Recovered error" )

Definition at line 52 of file scsi.c.

◆ EIO_NOT_READY

#define EIO_NOT_READY __einfo_error ( EINFO_EIO_NOT_READY )

Definition at line 54 of file scsi.c.

◆ EINFO_EIO_NOT_READY

#define EINFO_EIO_NOT_READY __einfo_uniqify ( EINFO_EIO, 0x02, "Not ready" )

Definition at line 55 of file scsi.c.

◆ EIO_MEDIUM_ERROR

#define EIO_MEDIUM_ERROR __einfo_error ( EINFO_EIO_MEDIUM_ERROR )

Definition at line 57 of file scsi.c.

◆ EINFO_EIO_MEDIUM_ERROR

#define EINFO_EIO_MEDIUM_ERROR __einfo_uniqify ( EINFO_EIO, 0x03, "Medium error" )

Definition at line 58 of file scsi.c.

◆ EIO_HARDWARE_ERROR

#define EIO_HARDWARE_ERROR __einfo_error ( EINFO_EIO_HARDWARE_ERROR )

Definition at line 60 of file scsi.c.

◆ EINFO_EIO_HARDWARE_ERROR

#define EINFO_EIO_HARDWARE_ERROR __einfo_uniqify ( EINFO_EIO, 0x04, "Hardware error" )

Definition at line 61 of file scsi.c.

◆ EIO_ILLEGAL_REQUEST

#define EIO_ILLEGAL_REQUEST __einfo_error ( EINFO_EIO_ILLEGAL_REQUEST )

Definition at line 63 of file scsi.c.

◆ EINFO_EIO_ILLEGAL_REQUEST

#define EINFO_EIO_ILLEGAL_REQUEST __einfo_uniqify ( EINFO_EIO, 0x05, "Illegal request" )

Definition at line 64 of file scsi.c.

◆ EIO_UNIT_ATTENTION

#define EIO_UNIT_ATTENTION __einfo_error ( EINFO_EIO_UNIT_ATTENTION )

Definition at line 66 of file scsi.c.

◆ EINFO_EIO_UNIT_ATTENTION

#define EINFO_EIO_UNIT_ATTENTION __einfo_uniqify ( EINFO_EIO, 0x06, "Unit attention" )

Definition at line 67 of file scsi.c.

◆ EIO_DATA_PROTECT

#define EIO_DATA_PROTECT __einfo_error ( EINFO_EIO_DATA_PROTECT )

Definition at line 69 of file scsi.c.

◆ EINFO_EIO_DATA_PROTECT

#define EINFO_EIO_DATA_PROTECT __einfo_uniqify ( EINFO_EIO, 0x07, "Data protect" )

Definition at line 70 of file scsi.c.

◆ EIO_BLANK_CHECK

#define EIO_BLANK_CHECK __einfo_error ( EINFO_EIO_BLANK_CHECK )

Definition at line 72 of file scsi.c.

◆ EINFO_EIO_BLANK_CHECK

#define EINFO_EIO_BLANK_CHECK __einfo_uniqify ( EINFO_EIO, 0x08, "Blank check" )

Definition at line 73 of file scsi.c.

◆ EIO_VENDOR_SPECIFIC

#define EIO_VENDOR_SPECIFIC __einfo_error ( EINFO_EIO_VENDOR_SPECIFIC )

Definition at line 75 of file scsi.c.

◆ EINFO_EIO_VENDOR_SPECIFIC

#define EINFO_EIO_VENDOR_SPECIFIC __einfo_uniqify ( EINFO_EIO, 0x09, "Vendor specific" )

Definition at line 76 of file scsi.c.

◆ EIO_COPY_ABORTED

#define EIO_COPY_ABORTED __einfo_error ( EINFO_EIO_COPY_ABORTED )

Definition at line 78 of file scsi.c.

◆ EINFO_EIO_COPY_ABORTED

#define EINFO_EIO_COPY_ABORTED __einfo_uniqify ( EINFO_EIO, 0x0a, "Copy aborted" )

Definition at line 79 of file scsi.c.

◆ EIO_ABORTED_COMMAND

#define EIO_ABORTED_COMMAND __einfo_error ( EINFO_EIO_ABORTED_COMMAND )

Definition at line 81 of file scsi.c.

◆ EINFO_EIO_ABORTED_COMMAND

#define EINFO_EIO_ABORTED_COMMAND __einfo_uniqify ( EINFO_EIO, 0x0b, "Aborted command" )

Definition at line 82 of file scsi.c.

◆ EIO_RESERVED

#define EIO_RESERVED __einfo_error ( EINFO_EIO_RESERVED )

Definition at line 84 of file scsi.c.

◆ EINFO_EIO_RESERVED

#define EINFO_EIO_RESERVED __einfo_uniqify ( EINFO_EIO, 0x0c, "Reserved" )

Definition at line 85 of file scsi.c.

◆ EIO_VOLUME_OVERFLOW

#define EIO_VOLUME_OVERFLOW __einfo_error ( EINFO_EIO_VOLUME_OVERFLOW )

Definition at line 87 of file scsi.c.

◆ EINFO_EIO_VOLUME_OVERFLOW

#define EINFO_EIO_VOLUME_OVERFLOW __einfo_uniqify ( EINFO_EIO, 0x0d, "Volume overflow" )

Definition at line 88 of file scsi.c.

◆ EIO_MISCOMPARE

#define EIO_MISCOMPARE __einfo_error ( EINFO_EIO_MISCOMPARE )

Definition at line 90 of file scsi.c.

◆ EINFO_EIO_MISCOMPARE

#define EINFO_EIO_MISCOMPARE __einfo_uniqify ( EINFO_EIO, 0x0e, "Miscompare" )

Definition at line 91 of file scsi.c.

◆ EIO_COMPLETED

#define EIO_COMPLETED __einfo_error ( EINFO_EIO_COMPLETED )

Definition at line 93 of file scsi.c.

◆ EINFO_EIO_COMPLETED

#define EINFO_EIO_COMPLETED __einfo_uniqify ( EINFO_EIO, 0x0f, "Completed" )

Definition at line 94 of file scsi.c.

◆ EIO_SENSE

#define EIO_SENSE ( key )

Value:

EUNIQ ( EINFO_EIO, (key), EIO_NO_SENSE, EIO_RECOVERED_ERROR,    \
                EIO_NOT_READY, EIO_MEDIUM_ERROR, EIO_HARDWARE_ERROR,    \
                EIO_ILLEGAL_REQUEST, EIO_UNIT_ATTENTION,                \
                EIO_DATA_PROTECT, EIO_BLANK_CHECK, EIO_VENDOR_SPECIFIC, \
                EIO_COPY_ABORTED, EIO_ABORTED_COMMAND, EIO_RESERVED,    \
                EIO_VOLUME_OVERFLOW, EIO_MISCOMPARE, EIO_COMPLETED )

Definition at line 96 of file scsi.c.

Enumeration Type Documentation

◆ scsi_device_flags

enum scsi_device_flags

SCSI device flags.

Enumerator
SCSIDEV_UNIT_TESTED	TEST UNIT READY has been issued.
SCSIDEV_UNIT_READY	TEST UNIT READY has completed successfully.

Definition at line 255 of file scsi.c.

                        {
         /** TEST UNIT READY has been issued */
         SCSIDEV_UNIT_TESTED = 0x0001,
         /** TEST UNIT READY has completed successfully */
         SCSIDEV_UNIT_READY = 0x0002,
 };

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ scsi_parse_lun()

int scsi_parse_lun	(	const char *	lun_string,
		struct scsi_lun *	lun
	)

Parse SCSI LUN.

Parameters

lun_string	LUN string representation
lun	LUN to fill in

Return values

rc	Return status code

Definition at line 118 of file scsi.c.

                                                                     {
         char *p;
         int i;
 
         memset ( lun, 0, sizeof ( *lun ) );
         if ( lun_string ) {
                 p = ( char * ) lun_string;
                 for ( i = 0 ; i < 4 ; i++ ) {
                         lun->u16[i] = htons ( strtoul ( p, &p, 16 ) );
                         if ( *p == '\0' )
                                 break;
                         if ( *p != '-' )
                                 return -EINVAL;
                         p++;
                 }
                 if ( *p )
                         return -EINVAL;
         }
 
         return 0;
 }

References EINVAL, htons, lun, memset(), and strtoul().

Referenced by fcp_parse_uri(), ib_srp_parse_lun(), and iscsi_parse_root_path().

◆ scsi_parse_sense()

void scsi_parse_sense	(	const void *	data,
		size_t	len,
		struct scsi_sns_descriptor *	sense
	)

Parse SCSI sense data.

Parameters

data	Raw sense data
len	Length of raw sense data
sense	Descriptor-format sense data to fill in

Definition at line 147 of file scsi.c.

                                                             {
         const union scsi_sns *sns = data;
 
         /* Avoid returning uninitialised data */
         memset ( sense, 0, sizeof ( *sense ) );
 
         /* Copy, assuming descriptor-format data */
         if ( len < sizeof ( sns->desc ) )
                 return;
         memcpy ( sense, &sns->desc, sizeof ( *sense ) );
 
         /* Convert fixed-format to descriptor-format, if applicable */
         if ( len < sizeof ( sns->fixed ) )
                 return;
         if ( ! SCSI_SENSE_FIXED ( sns->code ) )
                 return;
         sense->additional = sns->fixed.additional;
 }

References scsi_sns_fixed::additional, scsi_sns_descriptor::additional, scsi_sns::code, data, scsi_sns::desc, scsi_sns::fixed, len, memcpy(), memset(), and SCSI_SENSE_FIXED.

Referenced by fcpcmd_recv_rsp(), iscsi_rx_scsi_response(), and srp_rsp().

◆ scsi_command()

int scsi_command	(	struct interface *	control,
		struct interface *	data,
		struct scsi_cmd *	command
	)

Issue SCSI command.

Parameters

control	SCSI control interface
data	SCSI data interface
command	SCSI command

Return values

tag	Command tag, or negative error

Definition at line 182 of file scsi.c.

                                               {
         struct interface *dest;
         scsi_command_TYPE ( void * ) *op =
                 intf_get_dest_op ( control, scsi_command, &dest );
         void *object = intf_object ( dest );
         int tap;
 
         if ( op ) {
                 tap = op ( object, data, command );
         } else {
                 /* Default is to fail to issue the command */
                 tap = -EOPNOTSUPP;
         }
 
         intf_put ( dest );
         return tap;
 }

References control, data, dest, EOPNOTSUPP, intf_get_dest_op, intf_object(), intf_put(), op, and scsi_command_TYPE.

◆ scsi_response()

void scsi_response	(	struct interface *	intf,
		struct scsi_rsp *	response
	)

Report SCSI response.

Parameters

interface	SCSI command interface
response	SCSI response

Definition at line 207 of file scsi.c.

                                                                          {
         struct interface *dest;
         scsi_response_TYPE ( void * ) *op =
                 intf_get_dest_op ( intf, scsi_response, &dest );
         void *object = intf_object ( dest );
 
         if ( op ) {
                 op ( object, response );
         } else {
                 /* Default is to ignore the response */
         }
 
         intf_put ( dest );
 }

References dest, interface::intf, intf_get_dest_op, intf_object(), intf_put(), op, scsi_response(), and scsi_response_TYPE.

Referenced by fcpcmd_recv_rsp(), iscsi_scsi_done(), scsi_response(), and srp_rsp().

◆ scsidev_get()

static struct scsi_device* scsidev_get ( struct scsi_device * scsidev )

inlinestatic

Get reference to SCSI device.

Parameters

scsidev SCSI device

Return values

scsidev SCSI device

Definition at line 323 of file scsi.c.

                                             {
         ref_get ( &scsidev->refcnt );
         return scsidev;
 }

References ref_get, and scsi_device::refcnt.

Referenced by scsidev_command().

◆ scsidev_put()

static void scsidev_put ( struct scsi_device * scsidev )

inlinestatic

Drop reference to SCSI device.

Parameters

scsidev SCSI device

Definition at line 334 of file scsi.c.

                                             {
         ref_put ( &scsidev->refcnt );
 }

References ref_put, and scsi_device::refcnt.

Referenced by scsicmd_free().

◆ scsicmd_get()

static struct scsi_command* scsicmd_get ( struct scsi_command * scsicmd )

inlinestatic

Get reference to SCSI command.

Parameters

scsicmd SCSI command

Return values

scsicmd SCSI command

Definition at line 345 of file scsi.c.

                                              {
         ref_get ( &scsicmd->refcnt );
         return scsicmd;
 }

References ref_get, and scsi_command::refcnt.

◆ scsicmd_put()

static void scsicmd_put ( struct scsi_command * scsicmd )

inlinestatic

Drop reference to SCSI command.

Parameters

scsicmd SCSI command

Definition at line 356 of file scsi.c.

                                              {
         ref_put ( &scsicmd->refcnt );
 }

References ref_put, and scsi_command::refcnt.

Referenced by scsicmd_close().

◆ scsicmd_priv()

static void* scsicmd_priv ( struct scsi_command * scsicmd )

inlinestatic

Get SCSI command private data.

Parameters

scsicmd SCSI command

Return values

priv	Private data

Definition at line 367 of file scsi.c.

                                               {
         return scsicmd->priv;
 }

References scsi_command::priv.

Referenced by scsicmd_read_capacity_cmd(), and scsicmd_read_capacity_done().

◆ scsicmd_free()

static void scsicmd_free ( struct refcnt * refcnt )

static

Free SCSI command.

Parameters

refcnt Reference count

Definition at line 376 of file scsi.c.

                                                    {
         struct scsi_command *scsicmd =
                 container_of ( refcnt, struct scsi_command, refcnt );
 
         /* Drop reference to SCSI device */
         scsidev_put ( scsicmd->scsidev );
 
         /* Free command */
         free ( scsicmd );
 }

References container_of, free, scsi_command::scsidev, and scsidev_put().

Referenced by scsidev_command().

◆ scsicmd_close()

static void scsicmd_close	(	struct scsi_command *	scsicmd,
		int	rc
	)

static

Close SCSI command.

Parameters

scsicmd	SCSI command
rc	Reason for close

Definition at line 393 of file scsi.c.

                                                                    {
         struct scsi_device *scsidev = scsicmd->scsidev;
 
         if ( rc != 0 ) {
                 DBGC ( scsidev, "SCSI %p tag %08x closed: %s\n",
                        scsidev, scsicmd->tag, strerror ( rc ) );
         }
 
         /* Remove from list of commands */
         list_del ( &scsicmd->list );
 
         /* Shut down interfaces */
         intfs_shutdown ( rc, &scsicmd->scsi, &scsicmd->block, NULL );
 
         /* Drop list's reference */
         scsicmd_put ( scsicmd );
 }

References scsi_command::block, DBGC, intfs_shutdown(), scsi_command::list, list_del, NULL, rc, scsi_command::scsi, scsicmd_put(), scsi_command::scsidev, strerror(), and scsi_command::tag.

Referenced by scsicmd_read_capacity_done(), scsidev_close(), and scsidev_command().

◆ scsicmd_command()

static int scsicmd_command ( struct scsi_command * scsicmd )

static

Construct and issue SCSI command.

Return values

rc	Return status code

Definition at line 416 of file scsi.c.

                                                             {
         struct scsi_device *scsidev = scsicmd->scsidev;
         struct scsi_cmd command;
         int tag;
         int rc;
 
         /* Construct command */
         memset ( &command, 0, sizeof ( command ) );
         memcpy ( &command.lun, &scsidev->lun, sizeof ( command.lun ) );
         scsicmd->type->cmd ( scsicmd, &command );
 
         /* Issue command */
         if ( ( tag = scsi_command ( &scsidev->scsi, &scsicmd->scsi,
                                     &command ) ) < 0 ) {
                 rc = tag;
                 DBGC ( scsidev, "SCSI %p could not issue command: %s\n",
                        scsidev, strerror ( rc ) );
                 return rc;
         }
 
         /* Record tag */
         if ( scsicmd->tag ) {
                 DBGC ( scsidev, "SCSI %p tag %08x is now tag %08x\n",
                        scsidev, scsicmd->tag, tag );
         }
         scsicmd->tag = tag;
         DBGC2 ( scsidev, "SCSI %p tag %08x %s " SCSI_CDB_FORMAT "\n",
                 scsidev, scsicmd->tag, scsicmd->type->name,
                 SCSI_CDB_DATA ( command.cdb ) );
 
         return 0;
 }

References scsi_command_type::cmd, DBGC, DBGC2, scsi_device::lun, memcpy(), memset(), scsi_command_type::name, rc, scsi_command::scsi, scsi_device::scsi, SCSI_CDB_DATA, SCSI_CDB_FORMAT, scsi_command::scsidev, strerror(), tag, scsi_command::tag, and scsi_command::type.

Referenced by scsicmd_read_capacity_done(), and scsidev_command().

◆ scsicmd_done()

static void scsicmd_done	(	struct scsi_command *	scsicmd,
		int	rc
	)

static

Handle SCSI command completion.

Parameters

scsicmd	SCSI command
rc	Reason for close

Definition at line 455 of file scsi.c.

                                                                   {
 
         /* Restart SCSI interface */
         intf_restart ( &scsicmd->scsi, rc );
 
         /* Hand over to the command completion handler */
         scsicmd->type->done ( scsicmd, rc );
 }

References scsi_command_type::done, intf_restart(), rc, scsi_command::scsi, and scsi_command::type.

Referenced by scsicmd_response().

◆ scsicmd_response()

static void scsicmd_response	(	struct scsi_command *	scsicmd,
		struct scsi_rsp *	response
	)

static

Handle SCSI response.

Parameters

scsicmd	SCSI command
response	SCSI response

Definition at line 470 of file scsi.c.

                                                            {
         struct scsi_device *scsidev = scsicmd->scsidev;
         size_t overrun;
         size_t underrun;
         int rc;
 
         if ( response->status == 0 ) {
                 scsicmd_done ( scsicmd, 0 );
         } else {
                 DBGC ( scsidev, "SCSI %p tag %08x status %02x",
                        scsidev, scsicmd->tag, response->status );
                 if ( response->overrun > 0 ) {
                         overrun = response->overrun;
                         DBGC ( scsidev, " overrun +%zd", overrun );
                 } else if ( response->overrun < 0 ) {
                         underrun = -(response->overrun);
                         DBGC ( scsidev, " underrun -%zd", underrun );
                 }
                 DBGC ( scsidev, " sense %02x key %02x additional %04x\n",
                        ( response->sense.code & SCSI_SENSE_CODE_MASK ),
                        ( response->sense.key & SCSI_SENSE_KEY_MASK ),
                        ntohs ( response->sense.additional ) );
 
                 /* Construct error number from sense data */
                 rc = -EIO_SENSE ( response->sense.key & SCSI_SENSE_KEY_MASK );
                 scsicmd_done ( scsicmd, rc );
         }
 }

References scsi_sns_descriptor::additional, scsi_sns_descriptor::code, DBGC, EIO_SENSE, scsi_sns_descriptor::key, ntohs, scsi_rsp::overrun, rc, SCSI_SENSE_CODE_MASK, SCSI_SENSE_KEY_MASK, scsicmd_done(), scsi_command::scsidev, scsi_rsp::sense, scsi_rsp::status, and scsi_command::tag.

◆ scsicmd_read_cmd()

static void scsicmd_read_cmd	(	struct scsi_command *	scsicmd,
		struct scsi_cmd *	command
	)

static

Construct SCSI READ command.

Parameters

scsicmd	SCSI command
command	SCSI command IU

Definition at line 506 of file scsi.c.

                                                           {
 
         if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
                 /* Use READ (16) */
                 command->cdb.read16.opcode = SCSI_OPCODE_READ_16;
                 command->cdb.read16.lba = cpu_to_be64 ( scsicmd->lba );
                 command->cdb.read16.len = cpu_to_be32 ( scsicmd->count );
         } else {
                 /* Use READ (10) */
                 command->cdb.read10.opcode = SCSI_OPCODE_READ_10;
                 command->cdb.read10.lba = cpu_to_be32 ( scsicmd->lba );
                 command->cdb.read10.len = cpu_to_be16 ( scsicmd->count );
         }
         command->data_in = scsicmd->buffer;
         command->data_in_len = scsicmd->len;
 }

References scsi_command::buffer, scsi_command::count, cpu_to_be16, cpu_to_be32, cpu_to_be64, scsi_command::lba, scsi_command::len, SCSI_MAX_BLOCK_10, SCSI_OPCODE_READ_10, and SCSI_OPCODE_READ_16.

◆ scsicmd_write_cmd()

static void scsicmd_write_cmd	(	struct scsi_command *	scsicmd,
		struct scsi_cmd *	command
	)

static

Construct SCSI WRITE command.

Parameters

scsicmd	SCSI command
command	SCSI command IU

Definition at line 537 of file scsi.c.

                                                            {
 
         if ( ( scsicmd->lba + scsicmd->count ) > SCSI_MAX_BLOCK_10 ) {
                 /* Use WRITE (16) */
                 command->cdb.write16.opcode = SCSI_OPCODE_WRITE_16;
                 command->cdb.write16.lba = cpu_to_be64 ( scsicmd->lba );
                 command->cdb.write16.len = cpu_to_be32 ( scsicmd->count );
         } else {
                 /* Use WRITE (10) */
                 command->cdb.write10.opcode = SCSI_OPCODE_WRITE_10;
                 command->cdb.write10.lba = cpu_to_be32 ( scsicmd->lba );
                 command->cdb.write10.len = cpu_to_be16 ( scsicmd->count );
         }
         command->data_out = scsicmd->buffer;
         command->data_out_len = scsicmd->len;
 }

References scsi_command::buffer, scsi_command::count, cpu_to_be16, cpu_to_be32, cpu_to_be64, scsi_command::lba, scsi_command::len, SCSI_MAX_BLOCK_10, SCSI_OPCODE_WRITE_10, and SCSI_OPCODE_WRITE_16.

◆ scsicmd_read_capacity_cmd()

static void scsicmd_read_capacity_cmd	(	struct scsi_command *	scsicmd,
		struct scsi_cmd *	command
	)

static

Construct SCSI READ CAPACITY command.

Parameters

scsicmd	SCSI command
command	SCSI command IU

Definition at line 581 of file scsi.c.

                                                                    {
         struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
         struct scsi_cdb_read_capacity_16 *readcap16 = &command->cdb.readcap16;
         struct scsi_cdb_read_capacity_10 *readcap10 = &command->cdb.readcap10;
         struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
         struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
 
         if ( priv->use16 ) {
                 /* Use READ CAPACITY (16) */
                 readcap16->opcode = SCSI_OPCODE_SERVICE_ACTION_IN;
                 readcap16->service_action =
                         SCSI_SERVICE_ACTION_READ_CAPACITY_16;
                 readcap16->len = cpu_to_be32 ( sizeof ( *capacity16 ) );
                 command->data_in = capacity16;
                 command->data_in_len = sizeof ( *capacity16 );
         } else {
                 /* Use READ CAPACITY (10) */
                 readcap10->opcode = SCSI_OPCODE_READ_CAPACITY_10;
                 command->data_in = capacity10;
                 command->data_in_len = sizeof ( *capacity10 );
         }
 }

References cpu_to_be32, scsi_cdb_read_capacity_16::len, scsi_cdb_read_capacity_10::opcode, scsi_cdb_read_capacity_16::opcode, priv, SCSI_OPCODE_READ_CAPACITY_10, SCSI_OPCODE_SERVICE_ACTION_IN, SCSI_SERVICE_ACTION_READ_CAPACITY_16, scsicmd_priv(), and scsi_cdb_read_capacity_16::service_action.

◆ scsicmd_read_capacity_done()

static void scsicmd_read_capacity_done	(	struct scsi_command *	scsicmd,
		int	rc
	)

static

Handle SCSI READ CAPACITY command completion.

Parameters

scsicmd	SCSI command
rc	Reason for completion

Definition at line 611 of file scsi.c.

                                                   {
         struct scsi_device *scsidev = scsicmd->scsidev;
         struct scsi_read_capacity_private *priv = scsicmd_priv ( scsicmd );
         struct scsi_capacity_16 *capacity16 = &priv->capacity.capacity16;
         struct scsi_capacity_10 *capacity10 = &priv->capacity.capacity10;
         struct block_device_capacity capacity;
 
         /* Close if command failed */
         if ( rc != 0 ) {
                 scsicmd_close ( scsicmd, rc );
                 return;
         }
 
         /* Extract capacity */
         if ( priv->use16 ) {
                 capacity.blocks = ( be64_to_cpu ( capacity16->lba ) + 1 );
                 capacity.blksize = be32_to_cpu ( capacity16->blksize );
         } else {
                 capacity.blocks = ( be32_to_cpu ( capacity10->lba ) + 1 );
                 capacity.blksize = be32_to_cpu ( capacity10->blksize );
 
                 /* If capacity range was exceeded (i.e. capacity.lba
                  * was 0xffffffff, meaning that blockdev->blocks is
                  * now zero), use READ CAPACITY (16) instead.  READ
                  * CAPACITY (16) is not mandatory, so we can't just
                  * use it straight off.
                  */
                 if ( capacity.blocks == 0 ) {
                         priv->use16 = 1;
                         if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 ) {
                                 scsicmd_close ( scsicmd, rc );
                                 return;
                         }
                         return;
                 }
         }
         capacity.max_count = -1U;
 
         /* Allow transport layer to update capacity */
         block_capacity ( &scsidev->scsi, &capacity );
 
         /* Return capacity to caller */
         block_capacity ( &scsicmd->block, &capacity );
 
         /* Close command */
         scsicmd_close ( scsicmd, 0 );
 }

References be32_to_cpu, be64_to_cpu, block_device_capacity::blksize, scsi_capacity_10::blksize, scsi_capacity_16::blksize, scsi_command::block, block_capacity(), block_device_capacity::blocks, scsi_capacity_10::lba, scsi_capacity_16::lba, block_device_capacity::max_count, priv, rc, scsi_device::scsi, scsicmd_close(), scsicmd_command(), scsicmd_priv(), and scsi_command::scsidev.

◆ scsicmd_test_unit_ready_cmd()

static void scsicmd_test_unit_ready_cmd	(	struct scsi_command *scsicmd	__unused,
		struct scsi_cmd *	command
	)

static

Construct SCSI TEST UNIT READY command.

Parameters

scsicmd	SCSI command
command	SCSI command IU

Definition at line 674 of file scsi.c.

                                                                      {
         struct scsi_cdb_test_unit_ready *testready = &command->cdb.testready;
 
         testready->opcode = SCSI_OPCODE_TEST_UNIT_READY;
 }

References scsi_cdb_test_unit_ready::opcode, and SCSI_OPCODE_TEST_UNIT_READY.

◆ scsidev_command()

static int scsidev_command	(	struct scsi_device *	scsidev,
		struct interface *	block,
		struct scsi_command_type *	type,
		uint64_t	lba,
		unsigned int	count,
		void *	buffer,
		size_t	len
	)

static

Create SCSI command.

Parameters

scsidev	SCSI device
block	Block data interface
type	SCSI command type
lba	Starting logical block address
count	Number of blocks to transfer
buffer	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 721 of file scsi.c.

                                                         {
         struct scsi_command *scsicmd;
         int rc;
 
         /* Allocate and initialise structure */
         scsicmd = zalloc ( sizeof ( *scsicmd ) + type->priv_len );
         if ( ! scsicmd ) {
                 rc = -ENOMEM;
                 goto err_zalloc;
         }
         ref_init ( &scsicmd->refcnt, scsicmd_free );
         intf_init ( &scsicmd->block, &scsicmd_block_desc, &scsicmd->refcnt );
         intf_init ( &scsicmd->scsi, &scsicmd_scsi_desc,
                     &scsicmd->refcnt );
         scsicmd->scsidev = scsidev_get ( scsidev );
         list_add ( &scsicmd->list, &scsidev->cmds );
         scsicmd->type = type;
         scsicmd->lba = lba;
         scsicmd->count = count;
         scsicmd->buffer = buffer;
         scsicmd->len = len;
 
         /* Issue SCSI command */
         if ( ( rc = scsicmd_command ( scsicmd ) ) != 0 )
                 goto err_command;
 
         /* Attach to parent interface, transfer reference to list, and return */
         intf_plug_plug ( &scsicmd->block, block );
         return 0;
 
  err_command:
         scsicmd_close ( scsicmd, rc );
         ref_put ( &scsicmd->refcnt );
  err_zalloc:
         return rc;
 }

References block, scsi_command::block, buffer, scsi_command::buffer, scsi_device::cmds, count, scsi_command::count, ENOMEM, intf_init(), intf_plug_plug(), lba, scsi_command::lba, len, scsi_command::len, scsi_command::list, list_add, rc, ref_init, ref_put, scsi_command::refcnt, scsi_command::scsi, scsicmd_block_desc, scsicmd_close(), scsicmd_command(), scsicmd_free(), scsicmd_scsi_desc, scsi_command::scsidev, scsidev_get(), type, scsi_command::type, and zalloc().

Referenced by scsidev_read(), scsidev_read_capacity(), scsidev_test_unit_ready(), and scsidev_write().

◆ scsidev_read()

static int scsidev_read	(	struct scsi_device *	scsidev,
		struct interface *	block,
		uint64_t	lba,
		unsigned int	count,
		void *	buffer,
		size_t	len
	)

static

Issue SCSI block read.

Parameters

scsidev	SCSI device
block	Block data interface
lba	Starting logical block address
count	Number of blocks to transfer
buffer	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 774 of file scsi.c.

                                                      {
         return scsidev_command ( scsidev, block, &scsicmd_read,
                                  lba, count, buffer, len );
 }

References block, buffer, count, lba, len, scsicmd_read, scsi_command::scsidev, and scsidev_command().

◆ scsidev_write()

static int scsidev_write	(	struct scsi_device *	scsidev,
		struct interface *	block,
		uint64_t	lba,
		unsigned int	count,
		void *	buffer,
		size_t	len
	)

static

Issue SCSI block write.

Parameters

scsidev	SCSI device
block	Block data interface
lba	Starting logical block address
count	Number of blocks to transfer
buffer	Data buffer
len	Length of data buffer

Return values

rc	Return status code

Definition at line 793 of file scsi.c.

                                                       {
         return scsidev_command ( scsidev, block, &scsicmd_write,
                                  lba, count, buffer, len );
 }

References block, buffer, count, lba, len, scsicmd_write, scsi_command::scsidev, and scsidev_command().

◆ scsidev_read_capacity()

static int scsidev_read_capacity	(	struct scsi_device *	scsidev,
		struct interface *	block
	)

static

Read SCSI device capacity.

Parameters

scsidev	SCSI device
block	Block data interface

Return values

rc	Return status code

Definition at line 808 of file scsi.c.

                                                              {
         return scsidev_command ( scsidev, block, &scsicmd_read_capacity,
                                  0, 0, NULL, 0 );
 }

References block, NULL, scsicmd_read_capacity, scsi_command::scsidev, and scsidev_command().

◆ scsidev_test_unit_ready()

static int scsidev_test_unit_ready	(	struct scsi_device *	scsidev,
		struct interface *	block
	)

static

Test to see if SCSI device is ready.

Parameters

scsidev	SCSI device
block	Block data interface

Return values

rc	Return status code

Definition at line 821 of file scsi.c.

                                                                {
         return scsidev_command ( scsidev, block, &scsicmd_test_unit_ready,
                                  0, 0, NULL, 0 );
 }

References block, NULL, scsicmd_test_unit_ready, scsi_command::scsidev, and scsidev_command().

Referenced by scsidev_step().

◆ scsidev_window()

static size_t scsidev_window ( struct scsi_device * scsidev )

static

Check SCSI device flow-control window.

Parameters

scsidev SCSI device

Return values

len	Length of window

Definition at line 833 of file scsi.c.

                                                              {
 
         /* Refuse commands until unit is confirmed ready */
         if ( ! ( scsidev->flags & SCSIDEV_UNIT_READY ) )
                 return 0;
 
         return xfer_window ( &scsidev->scsi );
 }

References scsi_device::flags, scsi_device::scsi, scsi_command::scsidev, SCSIDEV_UNIT_READY, and xfer_window().

◆ scsidev_close()

static void scsidev_close	(	struct scsi_device *	scsidev,
		int	rc
	)

static

Close SCSI device.

Parameters

scsidev	SCSI device
rc	Reason for close

Definition at line 848 of file scsi.c.

                                                                   {
         struct scsi_command *scsicmd;
         struct scsi_command *tmp;
 
         /* Stop process */
         process_del ( &scsidev->process );
 
         /* Shut down interfaces */
         intfs_shutdown ( rc, &scsidev->block, &scsidev->scsi, &scsidev->ready,
                          NULL );
 
         /* Shut down any remaining commands */
         list_for_each_entry_safe ( scsicmd, tmp, &scsidev->cmds, list )
                 scsicmd_close ( scsicmd, rc );
 }

References scsi_device::block, scsi_device::cmds, intfs_shutdown(), scsi_command::list, list_for_each_entry_safe, NULL, scsi_device::process, process_del(), rc, scsi_device::ready, scsi_device::scsi, scsicmd_close(), scsi_command::scsidev, and tmp.

Referenced by scsidev_ready(), and scsidev_step().

◆ scsidev_ready()

static void scsidev_ready	(	struct scsi_device *	scsidev,
		int	rc
	)

static

Handle SCSI TEST UNIT READY response.

Parameters

scsidev	SCSI device
rc	Reason for close

Definition at line 885 of file scsi.c.

                                                                   {
 
         /* Shut down interface */
         intf_restart ( &scsidev->ready, rc );
 
         /* Mark device as ready, if applicable */
         if ( rc == 0 ) {
                 DBGC ( scsidev, "SCSI %p unit is ready\n", scsidev );
                 scsidev->flags |= SCSIDEV_UNIT_READY;
                 xfer_window_changed ( &scsidev->block );
                 return;
         }
         DBGC ( scsidev, "SCSI %p not ready: %s\n", scsidev, strerror ( rc ) );
 
         /* SCSI targets have an annoying habit of returning occasional
          * pointless "error" messages such as "power-on occurred", so
          * we have to be prepared to retry commands.
          *
          * For most commands, we rely on the caller (e.g. the generic
          * SAN device layer) to retry commands as needed.  However, a
          * TEST UNIT READY failure is used as an indication that the
          * whole SCSI device is unavailable and should be closed.  We
          * must therefore perform this retry loop within the SCSI
          * layer.
          */
         if ( scsidev->retries++ < SCSI_READY_MAX_RETRIES ) {
                 DBGC ( scsidev, "SCSI %p retrying (retry %d)\n",
                        scsidev, scsidev->retries );
                 scsidev->flags &= ~SCSIDEV_UNIT_TESTED;
                 process_add ( &scsidev->process );
                 return;
         }
 
         /* Close device */
         DBGC ( scsidev, "SCSI %p never became ready: %s\n",
                scsidev, strerror ( rc ) );
         scsidev_close ( scsidev, rc );
 }

References scsi_device::block, DBGC, scsi_device::flags, intf_restart(), scsi_device::process, process_add(), rc, scsi_device::ready, scsi_device::retries, SCSI_READY_MAX_RETRIES, scsidev_close(), SCSIDEV_UNIT_READY, SCSIDEV_UNIT_TESTED, strerror(), and xfer_window_changed().

◆ scsidev_step()

static void scsidev_step ( struct scsi_device * scsidev )

static

SCSI TEST UNIT READY process.

Parameters

scsidev SCSI device

Definition at line 938 of file scsi.c.

                                                          {
         int rc;
 
         /* Do nothing if we have already issued TEST UNIT READY */
         if ( scsidev->flags & SCSIDEV_UNIT_TESTED )
                 return;
 
         /* Wait until underlying SCSI device is ready */
         if ( xfer_window ( &scsidev->scsi ) == 0 )
                 return;
 
         DBGC ( scsidev, "SCSI %p waiting for unit to become ready\n",
                scsidev );
 
         /* Mark TEST UNIT READY as sent */
         scsidev->flags |= SCSIDEV_UNIT_TESTED;
 
         /* Issue TEST UNIT READY command */
         if ( ( rc = scsidev_test_unit_ready ( scsidev, &scsidev->ready )) !=0){
                 scsidev_close ( scsidev, rc );
                 return;
         }
 }

References DBGC, scsi_device::flags, rc, scsi_device::ready, scsi_device::scsi, scsidev_close(), scsidev_test_unit_ready(), SCSIDEV_UNIT_TESTED, and xfer_window().

◆ scsi_open()

int scsi_open	(	struct interface *	block,
		struct interface *	scsi,
		struct scsi_lun *	lun
	)

Open SCSI device.

Parameters

block	Block control interface
scsi	SCSI control interface
lun	SCSI LUN

Return values

rc	Return status code

Definition at line 985 of file scsi.c.

                                        {
         struct scsi_device *scsidev;
 
         /* Allocate and initialise structure */
         scsidev = zalloc ( sizeof ( *scsidev ) );
         if ( ! scsidev )
                 return -ENOMEM;
         ref_init ( &scsidev->refcnt, NULL );
         intf_init ( &scsidev->block, &scsidev_block_desc, &scsidev->refcnt );
         intf_init ( &scsidev->scsi, &scsidev_scsi_desc, &scsidev->refcnt );
         intf_init ( &scsidev->ready, &scsidev_ready_desc, &scsidev->refcnt );
         process_init ( &scsidev->process, &scsidev_process_desc,
                        &scsidev->refcnt );
         INIT_LIST_HEAD ( &scsidev->cmds );
         memcpy ( &scsidev->lun, lun, sizeof ( scsidev->lun ) );
         DBGC ( scsidev, "SCSI %p created for LUN " SCSI_LUN_FORMAT "\n",
                scsidev, SCSI_LUN_DATA ( scsidev->lun ) );
 
         /* Attach to SCSI and parent interfaces, mortalise self, and return */
         intf_plug_plug ( &scsidev->scsi, scsi );
         intf_plug_plug ( &scsidev->block, block );
         ref_put ( &scsidev->refcnt );
         return 0;
 }

References block, scsi_device::block, scsi_device::cmds, DBGC, ENOMEM, INIT_LIST_HEAD, intf_init(), intf_plug_plug(), lun, scsi_device::lun, memcpy(), NULL, scsi_device::process, process_init(), scsi_device::ready, ref_init, ref_put, scsi_device::refcnt, scsi_device::scsi, SCSI_LUN_DATA, SCSI_LUN_FORMAT, scsidev_block_desc, scsidev_process_desc, scsidev_ready_desc, scsidev_scsi_desc, and zalloc().

Referenced by fcpdev_open(), iscsi_open(), srp_open(), and usbblk_open_uri().

Variable Documentation

◆ scsicmd_read

struct scsi_command_type scsicmd_read

static

Initial value:

= {
        .name = "READ",
        .cmd = scsicmd_read_cmd,
        .done = scsicmd_close,
}

SCSI READ command type.

Definition at line 525 of file scsi.c.

Referenced by scsidev_read().

◆ scsicmd_write

struct scsi_command_type scsicmd_write

static

Initial value:

= {
        .name = "WRITE",
        .cmd = scsicmd_write_cmd,
        .done = scsicmd_close,
}

SCSI WRITE command type.

Definition at line 556 of file scsi.c.

Referenced by scsidev_write().

◆ scsicmd_read_capacity

struct scsi_command_type scsicmd_read_capacity

static

Initial value:

= {
        .name = "READ CAPACITY",
        .priv_len = sizeof ( struct scsi_read_capacity_private ),
        .cmd = scsicmd_read_capacity_cmd,
        .done = scsicmd_read_capacity_done,
}

SCSI READ CAPACITY command type.

Definition at line 661 of file scsi.c.

Referenced by scsidev_read_capacity().

◆ scsicmd_test_unit_ready

struct scsi_command_type scsicmd_test_unit_ready

static

Initial value:

= {
        .name = "TEST UNIT READY",
        .cmd = scsicmd_test_unit_ready_cmd,
        .done = scsicmd_close,
}

SCSI TEST UNIT READY command type.

Definition at line 682 of file scsi.c.

Referenced by scsidev_test_unit_ready().

◆ scsicmd_block_op

struct interface_operation scsicmd_block_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct scsi_command *, scsicmd_close ),
}

SCSI command block interface operations.

Definition at line 689 of file scsi.c.

◆ scsicmd_block_desc

struct interface_descriptor scsicmd_block_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct scsi_command, block,
                             scsicmd_block_op, scsi )

SCSI command block interface descriptor.

Definition at line 694 of file scsi.c.

Referenced by scsidev_command().

◆ scsicmd_scsi_op

struct interface_operation scsicmd_scsi_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct scsi_command *, scsicmd_done ),
        INTF_OP ( scsi_response, struct scsi_command *, scsicmd_response ),
}

SCSI command SCSI interface operations.

Definition at line 699 of file scsi.c.

◆ scsicmd_scsi_desc

struct interface_descriptor scsicmd_scsi_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct scsi_command, scsi,
                             scsicmd_scsi_op, block )

SCSI command SCSI interface descriptor.

Definition at line 705 of file scsi.c.

Referenced by scsidev_command().

◆ scsidev_block_op

struct interface_operation scsidev_block_op[]

static

Initial value:

= {
        INTF_OP ( xfer_window, struct scsi_device *, scsidev_window ),
        INTF_OP ( block_read, struct scsi_device *, scsidev_read ),
        INTF_OP ( block_write, struct scsi_device *, scsidev_write ),
        INTF_OP ( block_read_capacity, struct scsi_device *,
                  scsidev_read_capacity ),
        INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
}

SCSI device block interface operations.

Definition at line 865 of file scsi.c.

◆ scsidev_block_desc

struct interface_descriptor scsidev_block_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct scsi_device, block,
                             scsidev_block_op, scsi )

SCSI device block interface descriptor.

Definition at line 875 of file scsi.c.

Referenced by scsi_open().

◆ scsidev_ready_op

struct interface_operation scsidev_ready_op[]

static

Initial value:

= {
        INTF_OP ( intf_close, struct scsi_device *, scsidev_ready ),
}

SCSI device TEST UNIT READY interface operations.

Definition at line 925 of file scsi.c.

◆ scsidev_ready_desc

struct interface_descriptor scsidev_ready_desc

static

Initial value:

=

INTF_DESC ( struct scsi_device, ready, scsidev_ready_op )

scsi_device

A SCSI device.

Definition: scsi.c:230

INTF_DESC

#define INTF_DESC(object_type, intf, operations)

Define an object interface descriptor.

Definition: interface.h:81

scsidev_ready_op

static struct interface_operation scsidev_ready_op[]

SCSI device TEST UNIT READY interface operations.

Definition: scsi.c:925

SCSI device TEST UNIT READY interface descriptor.

Definition at line 930 of file scsi.c.

Referenced by scsi_open().

◆ scsidev_scsi_op

struct interface_operation scsidev_scsi_op[]

static

Initial value:

= {
        INTF_OP ( xfer_window_changed, struct scsi_device *, scsidev_step ),
        INTF_OP ( intf_close, struct scsi_device *, scsidev_close ),
}

SCSI device SCSI interface operations.

Definition at line 963 of file scsi.c.

◆ scsidev_scsi_desc

struct interface_descriptor scsidev_scsi_desc

static

Initial value:

=
        INTF_DESC_PASSTHRU ( struct scsi_device, scsi,
                             scsidev_scsi_op, block )

SCSI device SCSI interface descriptor.

Definition at line 969 of file scsi.c.

Referenced by scsi_open().

◆ scsidev_process_desc

struct process_descriptor scsidev_process_desc

static

Initial value:

=

PROC_DESC_ONCE ( struct scsi_device, process, scsidev_step )

process

A process.

Definition: process.h:18

scsi_device

A SCSI device.

Definition: scsi.c:230

PROC_DESC_ONCE

#define PROC_DESC_ONCE(object_type, process, _step)

Define a process descriptor for a process that runs only once.

Definition: process.h:98

scsidev_step

static void scsidev_step(struct scsi_device *scsidev)

SCSI TEST UNIT READY process.

Definition: scsi.c:938

SCSI device process descriptor.

Definition at line 974 of file scsi.c.

Referenced by scsi_open().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ SCSI_READY_MAX_RETRIES

◆ EIO_NO_SENSE

◆ EINFO_EIO_NO_SENSE

◆ EIO_RECOVERED_ERROR

◆ EINFO_EIO_RECOVERED_ERROR

◆ EIO_NOT_READY

◆ EINFO_EIO_NOT_READY

◆ EIO_MEDIUM_ERROR

◆ EINFO_EIO_MEDIUM_ERROR

◆ EIO_HARDWARE_ERROR

◆ EINFO_EIO_HARDWARE_ERROR

◆ EIO_ILLEGAL_REQUEST

◆ EINFO_EIO_ILLEGAL_REQUEST

◆ EIO_UNIT_ATTENTION

◆ EINFO_EIO_UNIT_ATTENTION

◆ EIO_DATA_PROTECT

◆ EINFO_EIO_DATA_PROTECT

◆ EIO_BLANK_CHECK

◆ EINFO_EIO_BLANK_CHECK

◆ EIO_VENDOR_SPECIFIC

◆ EINFO_EIO_VENDOR_SPECIFIC

◆ EIO_COPY_ABORTED

◆ EINFO_EIO_COPY_ABORTED

◆ EIO_ABORTED_COMMAND

◆ EINFO_EIO_ABORTED_COMMAND

◆ EIO_RESERVED

◆ EINFO_EIO_RESERVED

◆ EIO_VOLUME_OVERFLOW

◆ EINFO_EIO_VOLUME_OVERFLOW

◆ EIO_MISCOMPARE

◆ EINFO_EIO_MISCOMPARE

◆ EIO_COMPLETED

◆ EINFO_EIO_COMPLETED

◆ EIO_SENSE

Enumeration Type Documentation

◆ scsi_device_flags

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ scsi_parse_lun()

◆ scsi_parse_sense()

◆ scsi_command()

◆ scsi_response()

◆ scsidev_get()

◆ scsidev_put()

◆ scsicmd_get()

◆ scsicmd_put()

◆ scsicmd_priv()

◆ scsicmd_free()

◆ scsicmd_close()

◆ scsicmd_command()

◆ scsicmd_done()

◆ scsicmd_response()

◆ scsicmd_read_cmd()

◆ scsicmd_write_cmd()

◆ scsicmd_read_capacity_cmd()

◆ scsicmd_read_capacity_done()

◆ scsicmd_test_unit_ready_cmd()

◆ scsidev_command()

◆ scsidev_read()

◆ scsidev_write()

◆ scsidev_read_capacity()

◆ scsidev_test_unit_ready()

◆ scsidev_window()

◆ scsidev_close()

◆ scsidev_ready()

◆ scsidev_step()

◆ scsi_open()

Variable Documentation

◆ scsicmd_read

◆ scsicmd_write

◆ scsicmd_read_capacity

◆ scsicmd_test_unit_ready