scsi.c File Reference

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>

Go to the source code of this file.

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.
#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.
void	scsi_parse_sense (const void *data, size_t len, struct scsi_sns_descriptor *sense)
	Parse SCSI sense data.
int	scsi_command (struct interface *control, struct interface *data, struct scsi_cmd *command)
	Issue SCSI command.
void	scsi_response (struct interface *intf, struct scsi_rsp *response)
	Report SCSI response.
static struct scsi_device *	scsidev_get (struct scsi_device *scsidev)
	Get reference to SCSI device.
static void	scsidev_put (struct scsi_device *scsidev)
	Drop reference to SCSI device.
static struct scsi_command *	scsicmd_get (struct scsi_command *scsicmd)
	Get reference to SCSI command.
static void	scsicmd_put (struct scsi_command *scsicmd)
	Drop reference to SCSI command.
static void *	scsicmd_priv (struct scsi_command *scsicmd)
	Get SCSI command private data.
static void	scsicmd_free (struct refcnt *refcnt)
	Free SCSI command.
static void	scsicmd_close (struct scsi_command *scsicmd, int rc)
	Close SCSI command.
static int	scsicmd_command (struct scsi_command *scsicmd)
	Construct and issue SCSI command.
static void	scsicmd_done (struct scsi_command *scsicmd, int rc)
	Handle SCSI command completion.
static void	scsicmd_response (struct scsi_command *scsicmd, struct scsi_rsp *response)
	Handle SCSI response.
static void	scsicmd_read_cmd (struct scsi_command *scsicmd, struct scsi_cmd *command)
	Construct SCSI READ command.
static void	scsicmd_write_cmd (struct scsi_command *scsicmd, struct scsi_cmd *command)
	Construct SCSI WRITE command.
static void	scsicmd_read_capacity_cmd (struct scsi_command *scsicmd, struct scsi_cmd *command)
	Construct SCSI READ CAPACITY command.
static void	scsicmd_read_capacity_done (struct scsi_command *scsicmd, int rc)
	Handle SCSI READ CAPACITY command completion.
static void	scsicmd_test_unit_ready_cmd (struct scsi_command *scsicmd __unused, struct scsi_cmd *command)
	Construct SCSI TEST UNIT READY 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)
	Create SCSI command.
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.
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.
static int	scsidev_read_capacity (struct scsi_device *scsidev, struct interface *block)
	Read SCSI device capacity.
static int	scsidev_test_unit_ready (struct scsi_device *scsidev, struct interface *block)
	Test to see if SCSI device is ready.
static size_t	scsidev_window (struct scsi_device *scsidev)
	Check SCSI device flow-control window.
static void	scsidev_close (struct scsi_device *scsidev, int rc)
	Close SCSI device.
static void	scsidev_ready (struct scsi_device *scsidev, int rc)
	Handle SCSI TEST UNIT READY response.
static void	scsidev_step (struct scsi_device *scsidev)
	SCSI TEST UNIT READY process.
int	scsi_open (struct interface *block, struct interface *scsi, struct scsi_lun *lun)
	Open SCSI device.

Variables
static struct scsi_command_type	scsicmd_read
	SCSI READ command type.
static struct scsi_command_type	scsicmd_write
	SCSI WRITE command type.
static struct scsi_command_type	scsicmd_read_capacity
	SCSI READ CAPACITY command type.
static struct scsi_command_type	scsicmd_test_unit_ready
	SCSI TEST UNIT READY command type.
static struct interface_operation	scsicmd_block_op []
	SCSI command block interface operations.
static struct interface_descriptor	scsicmd_block_desc
	SCSI command block interface descriptor.
static struct interface_operation	scsicmd_scsi_op []
	SCSI command SCSI interface operations.
static struct interface_descriptor	scsicmd_scsi_desc
	SCSI command SCSI interface descriptor.
static struct interface_operation	scsidev_block_op []
	SCSI device block interface operations.
static struct interface_descriptor	scsidev_block_desc
	SCSI device block interface descriptor.
static struct interface_operation	scsidev_ready_op []
	SCSI device TEST UNIT READY interface operations.
static struct interface_descriptor	scsidev_ready_desc
	SCSI device TEST UNIT READY interface descriptor.
static struct interface_operation	scsidev_scsi_op []
	SCSI device SCSI interface operations.
static struct interface_descriptor	scsidev_scsi_desc
	SCSI device SCSI interface descriptor.
static struct process_descriptor	scsidev_process_desc
	SCSI device process descriptor.

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.

Referenced by scsidev_ready().

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

#define EIO_SENSE( key )                                                \
        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 )

Referenced by scsicmd_response().

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_descriptor::additional, scsi_sns_fixed::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()

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()

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()

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()

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()

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()

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()

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()

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(), scsi_command::tag, tag, and scsi_command::type.

Referenced by scsicmd_read_capacity_done(), and scsidev_command().

scsicmd_done()

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()

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()

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()

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()

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()

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()

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 __unused, scsi_cdb_test_unit_ready::opcode, and SCSI_OPCODE_TEST_UNIT_READY.

scsidev_command()

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(), scsi_command::type, type, and zalloc().

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

scsidev_read()

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()

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()

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()

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()

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()

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()

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()

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

scsidev_ready_desc

struct interface_descriptor scsidev_ready_desc

static

Initial value:

=
        INTF_DESC ( struct scsi_device, ready, scsidev_ready_op )

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.

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

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 )

SCSI device process descriptor.

Definition at line 974 of file scsi.c.

Referenced by scsi_open().