srp.c File Reference

SCSI RDMA Protocol. More...

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/scsi.h>
#include <ipxe/xfer.h>
#include <ipxe/features.h>
#include <ipxe/srp.h>

Go to the source code of this file.

Data Structures
struct	srp_device
	An SRP device. More...
struct	srp_command
	An SRP command. More...

Macros
#define	SRP_MAX_I_T_IU_LEN   80
	Maximum length of any initiator-to-target IU that we will send.
#define	EINFO_SRP_LOGIN_REJ(reason, desc)
#define	EPERM_UNKNOWN   __einfo_error ( EINFO_EPERM_UNKNOWN )
#define	EINFO_EPERM_UNKNOWN
#define	EPERM_INSUFFICIENT_RESOURCES   __einfo_error ( EINFO_EPERM_INSUFFICIENT_RESOURCES )
#define	EINFO_EPERM_INSUFFICIENT_RESOURCES
#define	EPERM_BAD_MAX_I_T_IU_LEN   __einfo_error ( EINFO_EPERM_BAD_MAX_I_T_IU_LEN )
#define	EINFO_EPERM_BAD_MAX_I_T_IU_LEN
#define	EPERM_CANNOT_ASSOCIATE   __einfo_error ( EINFO_EPERM_CANNOT_ASSOCIATE )
#define	EINFO_EPERM_CANNOT_ASSOCIATE
#define	EPERM_UNSUPPORTED_BUFFER_FORMAT   __einfo_error ( EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT )
#define	EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT
#define	EPERM_NO_MULTIPLE_CHANNELS   __einfo_error ( EINFO_EPERM_NO_MULTIPLE_CHANNELS )
#define	EINFO_EPERM_NO_MULTIPLE_CHANNELS
#define	EPERM_NO_MORE_CHANNELS   __einfo_error ( EINFO_EPERM_NO_MORE_CHANNELS )
#define	EINFO_EPERM_NO_MORE_CHANNELS
#define	EPERM_LOGIN_REJ(reason_nibble)

Functions
	FILE_LICENCE (BSD2)
	FILE_SECBOOT (FORBIDDEN)
	FEATURE (FEATURE_PROTOCOL, "SRP", DHCP_EB_FEATURE_SRP, 1)
static struct srp_device *	srpdev_get (struct srp_device *srpdev)
	Get reference to SRP device.
static void	srpdev_put (struct srp_device *srpdev)
	Drop reference to SRP device.
static struct srp_command *	srpcmd_get (struct srp_command *srpcmd)
	Get reference to SRP command.
static void	srpcmd_put (struct srp_command *srpcmd)
	Drop reference to SRP command.
static void	srpcmd_free (struct refcnt *refcnt)
	Free SRP command.
static void	srpcmd_close (struct srp_command *srpcmd, int rc)
	Close SRP command.
static void	srpdev_close (struct srp_device *srpdev, int rc)
	Close SRP device.
static struct srp_command *	srp_find_tag (struct srp_device *srpdev, uint32_t tag)
	Identify SRP command by tag.
static int	srp_new_tag (struct srp_device *srpdev)
	Choose an SRP command tag.
static int	srp_login (struct srp_device *srpdev, union srp_port_id *initiator, union srp_port_id *target, uint32_t tag)
	Transmit SRP login request.
static int	srp_login_rsp (struct srp_device *srpdev, const void *data, size_t len)
	Receive SRP login response.
static int	srp_login_rej (struct srp_device *srpdev, const void *data, size_t len)
	Receive SRP login rejection.
static int	srp_cmd (struct srp_device *srpdev, struct scsi_cmd *command, uint32_t tag)
	Transmit SRP SCSI command.
static int	srp_rsp (struct srp_device *srpdev, const void *data, size_t len)
	Receive SRP SCSI response.
static int	srp_unrecognised (struct srp_device *srpdev, const void *data, size_t len)
	Receive SRP unrecognised response IU.
static int	srpdev_scsi_command (struct srp_device *srpdev, struct interface *parent, struct scsi_cmd *command)
	Issue SRP SCSI command.
static int	srpdev_deliver (struct srp_device *srpdev, struct io_buffer *iobuf, struct xfer_metadata *meta __unused)
	Receive data from SRP socket.
static size_t	srpdev_window (struct srp_device *srpdev)
	Check SRP device flow-control window.
int	srp_open (struct interface *block, struct interface *socket, union srp_port_id *initiator, union srp_port_id *target, uint32_t memory_handle, struct scsi_lun *lun)
	Open SRP device.

Variables
static struct interface_operation	srpcmd_scsi_op []
	SRP command SCSI interface operations.
static struct interface_descriptor	srpcmd_scsi_desc
	SRP command SCSI interface descriptor.
static struct interface_operation	srpdev_socket_op []
	SRP device socket interface operations.
static struct interface_descriptor	srpdev_socket_desc
	SRP device socket interface descriptor.
static struct interface_operation	srpdev_scsi_op []
	SRP device SCSI interface operations.
static struct interface_descriptor	srpdev_scsi_desc
	SRP device SCSI interface descriptor.

Detailed Description

SCSI RDMA Protocol.

Definition in file srp.c.

Macro Definition Documentation

SRP_MAX_I_T_IU_LEN

#define SRP_MAX_I_T_IU_LEN   80

Maximum length of any initiator-to-target IU that we will send.

The longest IU is a SRP_CMD with no additional CDB and two direct data buffer descriptors, which comes to 80 bytes.

Definition at line 56 of file srp.c.

Referenced by srp_cmd(), and srp_login().

EINFO_SRP_LOGIN_REJ

#define EINFO_SRP_LOGIN_REJ	(		reason,
			desc )

Value:

__einfo_uniqify ( EINFO_EPERM, ( (reason) & 0x0f ), desc )

Definition at line 59 of file srp.c.

#define EINFO_SRP_LOGIN_REJ( reason, desc )                                   \
        __einfo_uniqify ( EINFO_EPERM, ( (reason) & 0x0f ), desc )

EPERM_UNKNOWN

#define EPERM_UNKNOWN   __einfo_error ( EINFO_EPERM_UNKNOWN )

Definition at line 61 of file srp.c.

#define EPERM_UNKNOWN                                                         \
        __einfo_error ( EINFO_EPERM_UNKNOWN )

EINFO_EPERM_UNKNOWN

#define EINFO_EPERM_UNKNOWN

Value:

EINFO_SRP_LOGIN_REJ (                         \
SRP_LOGIN_REJ_REASON_UNKNOWN,                                         \
"Unable to establish RDMA channel, no reason specified" )

Definition at line 63 of file srp.c.

#define EINFO_EPERM_UNKNOWN EINFO_SRP_LOGIN_REJ (                             \
        SRP_LOGIN_REJ_REASON_UNKNOWN,                                         \
        "Unable to establish RDMA channel, no reason specified" )

EPERM_INSUFFICIENT_RESOURCES

#define EPERM_INSUFFICIENT_RESOURCES   __einfo_error ( EINFO_EPERM_INSUFFICIENT_RESOURCES )

Definition at line 66 of file srp.c.

#define EPERM_INSUFFICIENT_RESOURCES                                          \
        __einfo_error ( EINFO_EPERM_INSUFFICIENT_RESOURCES )

EINFO_EPERM_INSUFFICIENT_RESOURCES

#define EINFO_EPERM_INSUFFICIENT_RESOURCES

Value:

EINFO_SRP_LOGIN_REJ (         \
SRP_LOGIN_REJ_REASON_INSUFFICIENT_RESOURCES,                          \
"Insufficient RDMA channel resources" )

Definition at line 68 of file srp.c.

#define EINFO_EPERM_INSUFFICIENT_RESOURCES EINFO_SRP_LOGIN_REJ (              \
        SRP_LOGIN_REJ_REASON_INSUFFICIENT_RESOURCES,                          \
        "Insufficient RDMA channel resources" )

EPERM_BAD_MAX_I_T_IU_LEN

#define EPERM_BAD_MAX_I_T_IU_LEN   __einfo_error ( EINFO_EPERM_BAD_MAX_I_T_IU_LEN )

Definition at line 71 of file srp.c.

#define EPERM_BAD_MAX_I_T_IU_LEN                                              \
        __einfo_error ( EINFO_EPERM_BAD_MAX_I_T_IU_LEN )

EINFO_EPERM_BAD_MAX_I_T_IU_LEN

#define EINFO_EPERM_BAD_MAX_I_T_IU_LEN

Value:

EINFO_SRP_LOGIN_REJ (                 \
SRP_LOGIN_REJ_REASON_BAD_MAX_I_T_IU_LEN,                              \
"Requested maximum initiator to target IU length value too large" )

Definition at line 73 of file srp.c.

#define EINFO_EPERM_BAD_MAX_I_T_IU_LEN EINFO_SRP_LOGIN_REJ (                  \
        SRP_LOGIN_REJ_REASON_BAD_MAX_I_T_IU_LEN,                              \
        "Requested maximum initiator to target IU length value too large" )

EPERM_CANNOT_ASSOCIATE

#define EPERM_CANNOT_ASSOCIATE   __einfo_error ( EINFO_EPERM_CANNOT_ASSOCIATE )

Definition at line 76 of file srp.c.

#define EPERM_CANNOT_ASSOCIATE                                                \
        __einfo_error ( EINFO_EPERM_CANNOT_ASSOCIATE )

EINFO_EPERM_CANNOT_ASSOCIATE

#define EINFO_EPERM_CANNOT_ASSOCIATE

Value:

EINFO_SRP_LOGIN_REJ (                 \
SRP_LOGIN_REJ_REASON_CANNOT_ASSOCIATE,                                \
"Unable to associate RDMA channel with specified I_T nexus" )

Definition at line 78 of file srp.c.

#define EINFO_EPERM_CANNOT_ASSOCIATE EINFO_SRP_LOGIN_REJ (                    \
        SRP_LOGIN_REJ_REASON_CANNOT_ASSOCIATE,                                \
        "Unable to associate RDMA channel with specified I_T nexus" )

EPERM_UNSUPPORTED_BUFFER_FORMAT

#define EPERM_UNSUPPORTED_BUFFER_FORMAT   __einfo_error ( EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT )

Definition at line 81 of file srp.c.

#define EPERM_UNSUPPORTED_BUFFER_FORMAT                                       \
        __einfo_error ( EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT )

EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT

#define EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT

Value:

EINFO_SRP_LOGIN_REJ (         \
SRP_LOGIN_REJ_REASON_UNSUPPORTED_BUFFER_FORMAT,                       \
"One or more requested data buffer descriptor formats not supported" )

Definition at line 83 of file srp.c.

#define EINFO_EPERM_UNSUPPORTED_BUFFER_FORMAT EINFO_SRP_LOGIN_REJ (           \
        SRP_LOGIN_REJ_REASON_UNSUPPORTED_BUFFER_FORMAT,                       \
        "One or more requested data buffer descriptor formats not supported" )

EPERM_NO_MULTIPLE_CHANNELS

#define EPERM_NO_MULTIPLE_CHANNELS   __einfo_error ( EINFO_EPERM_NO_MULTIPLE_CHANNELS )

Definition at line 86 of file srp.c.

#define EPERM_NO_MULTIPLE_CHANNELS                                            \
        __einfo_error ( EINFO_EPERM_NO_MULTIPLE_CHANNELS )

EINFO_EPERM_NO_MULTIPLE_CHANNELS

#define EINFO_EPERM_NO_MULTIPLE_CHANNELS

Value:

EINFO_SRP_LOGIN_REJ (                 \
SRP_LOGIN_REJ_REASON_NO_MULTIPLE_CHANNELS,                            \
"SRP target does not support multiple RDMA channels per I_T nexus" )

Definition at line 88 of file srp.c.

#define EINFO_EPERM_NO_MULTIPLE_CHANNELS EINFO_SRP_LOGIN_REJ (                \
        SRP_LOGIN_REJ_REASON_NO_MULTIPLE_CHANNELS,                            \
        "SRP target does not support multiple RDMA channels per I_T nexus" )

EPERM_NO_MORE_CHANNELS

#define EPERM_NO_MORE_CHANNELS   __einfo_error ( EINFO_EPERM_NO_MORE_CHANNELS )

Definition at line 91 of file srp.c.

#define EPERM_NO_MORE_CHANNELS                                                \
        __einfo_error ( EINFO_EPERM_NO_MORE_CHANNELS )

EINFO_EPERM_NO_MORE_CHANNELS

#define EINFO_EPERM_NO_MORE_CHANNELS

Value:

EINFO_SRP_LOGIN_REJ (                 \
SRP_LOGIN_REJ_REASON_NO_MORE_CHANNELS,                                \
"RDMA channel limit reached for this initiator" )

Definition at line 93 of file srp.c.

#define EINFO_EPERM_NO_MORE_CHANNELS EINFO_SRP_LOGIN_REJ (                    \
        SRP_LOGIN_REJ_REASON_NO_MORE_CHANNELS,                                \
        "RDMA channel limit reached for this initiator" )

EPERM_LOGIN_REJ

#define EPERM_LOGIN_REJ

(

reason_nibble

)

Value:

EUNIQ ( EINFO_EPERM, (reason_nibble), EPERM_UNKNOWN,                  \
        EPERM_INSUFFICIENT_RESOURCES, EPERM_BAD_MAX_I_T_IU_LEN,       \
        EPERM_CANNOT_ASSOCIATE, EPERM_UNSUPPORTED_BUFFER_FORMAT,      \
        EPERM_NO_MULTIPLE_CHANNELS, EPERM_NO_MORE_CHANNELS )

Definition at line 96 of file srp.c.

#define EPERM_LOGIN_REJ( reason_nibble )                                      \
        EUNIQ ( EINFO_EPERM, (reason_nibble), EPERM_UNKNOWN,                  \
                EPERM_INSUFFICIENT_RESOURCES, EPERM_BAD_MAX_I_T_IU_LEN,       \
                EPERM_CANNOT_ASSOCIATE, EPERM_UNSUPPORTED_BUFFER_FORMAT,      \
                EPERM_NO_MULTIPLE_CHANNELS, EPERM_NO_MORE_CHANNELS )

Referenced by srp_login_rej().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

BSD2

)

FILE_SECBOOT()

FILE_SECBOOT

(

FORBIDDEN

)

FEATURE()

FEATURE	(	FEATURE_PROTOCOL	,
		"SRP"	,
		DHCP_EB_FEATURE_SRP	,
		1	)

References DHCP_EB_FEATURE_SRP, and FEATURE_PROTOCOL.

srpdev_get()

struct srp_device * srpdev_get ( struct srp_device * srpdev )

inlinestatic

Get reference to SRP device.

Parameters

srpdev

SRP device

Return values

srpdev

SRP device

Definition at line 143 of file srp.c.

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

References ref_get, and srp_device::refcnt.

Referenced by srpdev_scsi_command().

srpdev_put()

void srpdev_put ( struct srp_device * srpdev )

inlinestatic

Drop reference to SRP device.

Parameters

srpdev

SRP device

Definition at line 154 of file srp.c.

                                         {
        ref_put ( &srpdev->refcnt );
}

References ref_put, and srp_device::refcnt.

Referenced by srpcmd_free().

srpcmd_get()

struct srp_command * srpcmd_get ( struct srp_command * srpcmd )

inlinestatic

Get reference to SRP command.

Parameters

srpcmd

SRP command

Return values

srpcmd

SRP command

Definition at line 165 of file srp.c.

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

References ref_get, and srp_command::refcnt.

Referenced by srp_rsp(), and srpdev_close().

srpcmd_put()

void srpcmd_put ( struct srp_command * srpcmd )

inlinestatic

Drop reference to SRP command.

Parameters

srpcmd

SRP command

Definition at line 176 of file srp.c.

                                          {
        ref_put ( &srpcmd->refcnt );
}

References ref_put, and srp_command::refcnt.

Referenced by srp_rsp(), srpcmd_close(), and srpdev_close().

srpcmd_free()

void srpcmd_free ( struct refcnt * refcnt )

static

Free SRP command.

Parameters

refcnt

Reference count

Definition at line 185 of file srp.c.

                                                  {
        struct srp_command *srpcmd =
                container_of ( refcnt, struct srp_command, refcnt );
 
        assert ( list_empty ( &srpcmd->list ) );
 
        srpdev_put ( srpcmd->srpdev );
        free ( srpcmd );
}

References assert, container_of, free, srp_command::list, list_empty, srp_command::srpdev, and srpdev_put().

Referenced by srpdev_scsi_command().

srpcmd_close()

void srpcmd_close ( struct srp_command * srpcmd, int rc )

static

Close SRP command.

Parameters

srpcmd	SRP command
rc	Reason for close

Definition at line 201 of file srp.c.

                                                                {
        struct srp_device *srpdev = srpcmd->srpdev;
 
        if ( rc != 0 ) {
                DBGC ( srpdev, "SRP %p tag %08x closed: %s\n",
                       srpdev, srpcmd->tag, strerror ( rc ) );
        }
 
        /* Remove from list of commands */
        if ( ! list_empty ( &srpcmd->list ) ) {
                list_del ( &srpcmd->list );
                INIT_LIST_HEAD ( &srpcmd->list );
                srpcmd_put ( srpcmd );
        }
 
        /* Shut down interfaces */
        intf_shutdown ( &srpcmd->scsi, rc );
}

References DBGC, INIT_LIST_HEAD, intf_shutdown(), srp_command::list, list_del, list_empty, rc, srp_command::scsi, srpcmd_put(), srp_command::srpdev, strerror(), and srp_command::tag.

Referenced by srp_rsp(), srpdev_close(), and srpdev_scsi_command().

srpdev_close()

void srpdev_close ( struct srp_device * srpdev, int rc )

static

Close SRP device.

Parameters

srpdev	SRP device
rc	Reason for close

Definition at line 226 of file srp.c.

                                                               {
        struct srp_command *srpcmd;
        struct srp_command *tmp;
 
        if ( rc != 0 ) {
                DBGC ( srpdev, "SRP %p closed: %s\n",
                       srpdev, strerror ( rc ) );
        }
 
        /* Shut down interfaces */
        intf_shutdown ( &srpdev->socket, rc );
        intf_shutdown ( &srpdev->scsi, rc );
 
        /* Shut down any active commands */
        list_for_each_entry_safe ( srpcmd, tmp, &srpdev->commands, list ) {
                srpcmd_get ( srpcmd );
                srpcmd_close ( srpcmd, rc );
                srpcmd_put ( srpcmd );
        }
}

References srp_device::commands, DBGC, intf_shutdown(), srp_command::list, list_for_each_entry_safe, rc, srp_device::scsi, srp_device::socket, srpcmd_close(), srpcmd_get(), srpcmd_put(), srp_command::srpdev, strerror(), and tmp.

Referenced by srp_open(), and srpdev_deliver().

srp_find_tag()

struct srp_command * srp_find_tag ( struct srp_device * srpdev, uint32_t tag )

static

Identify SRP command by tag.

Parameters

srpdev	SRP device
tag	Command tag

Return values

srpcmd

SRP command, or NULL

Definition at line 254 of file srp.c.

                                                          {
        struct srp_command *srpcmd;
 
        list_for_each_entry ( srpcmd, &srpdev->commands, list ) {
                if ( srpcmd->tag == tag )
                        return srpcmd;
        }
        return NULL;
}

References srp_device::commands, srp_command::list, list_for_each_entry, NULL, srp_command::srpdev, srp_command::tag, and tag.

Referenced by srp_new_tag(), and srp_rsp().

srp_new_tag()

int srp_new_tag ( struct srp_device * srpdev )

static

Choose an SRP command tag.

Parameters

srpdev

SRP device

Return values

tag	New tag, or negative error

Definition at line 271 of file srp.c.

                                                     {
        static uint16_t tag_idx;
        unsigned int i;
 
        for ( i = 0 ; i < 65536 ; i++ ) {
                tag_idx++;
                if ( srp_find_tag ( srpdev, tag_idx ) == NULL )
                        return tag_idx;
        }
        return -EADDRINUSE;
}

References EADDRINUSE, NULL, srp_find_tag(), and srp_command::srpdev.

Referenced by srp_open(), and srpdev_scsi_command().

srp_login()

int srp_login ( struct srp_device * srpdev, union srp_port_id * initiator, union srp_port_id * target, uint32_t tag )

static

Transmit SRP login request.

Parameters

srpdev	SRP device
initiator	Initiator port ID
target	Target port ID
tag	Command tag

Return values

rc	Return status code

Definition at line 292 of file srp.c.

                                                                 {
        struct io_buffer *iobuf;
        struct srp_login_req *login_req;
        int rc;
 
        /* Allocate I/O buffer */
        iobuf = xfer_alloc_iob ( &srpdev->socket, sizeof ( *login_req ) );
        if ( ! iobuf )
                return -ENOMEM;
 
        /* Construct login request IU */
        login_req = iob_put ( iobuf, sizeof ( *login_req ) );
        memset ( login_req, 0, sizeof ( *login_req ) );
        login_req->type = SRP_LOGIN_REQ;
        login_req->tag.dwords[0] = htonl ( SRP_TAG_MAGIC );
        login_req->tag.dwords[1] = htonl ( tag );
        login_req->max_i_t_iu_len = htonl ( SRP_MAX_I_T_IU_LEN );
        login_req->required_buffer_formats = SRP_LOGIN_REQ_FMT_DDBD;
        memcpy ( &login_req->initiator, initiator,
                 sizeof ( login_req->initiator ) );
        memcpy ( &login_req->target, target, sizeof ( login_req->target ) );
 
        DBGC ( srpdev, "SRP %p tag %08x LOGIN_REQ:\n", srpdev, tag );
        DBGC_HDA ( srpdev, 0, iobuf->data, iob_len ( iobuf ) );
 
        /* Send login request IU */
        if ( ( rc = xfer_deliver_iob ( &srpdev->socket, iobuf ) ) != 0 ) {
                DBGC ( srpdev, "SRP %p tag %08x could not send LOGIN_REQ: "
                       "%s\n", srpdev, tag, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References io_buffer::data, DBGC, DBGC_HDA, srp_tag::dwords, ENOMEM, htonl, srp_login_req::initiator, iob_len(), iob_put, srp_login_req::max_i_t_iu_len, memcpy(), memset(), rc, srp_login_req::required_buffer_formats, srp_device::socket, SRP_LOGIN_REQ, SRP_LOGIN_REQ_FMT_DDBD, SRP_MAX_I_T_IU_LEN, SRP_TAG_MAGIC, strerror(), srp_login_req::tag, tag, srp_login_req::target, srp_login_req::type, xfer_alloc_iob(), and xfer_deliver_iob().

Referenced by srp_open().

srp_login_rsp()

int srp_login_rsp ( struct srp_device * srpdev, const void * data, size_t len )

static

Receive SRP login response.

Parameters

srpdev	SRP device
data	SRP IU
len	Length of SRP IU

Return values

rc	Return status code

Definition at line 336 of file srp.c.

                                                          {
        const struct srp_login_rsp *login_rsp;
 
        /* Sanity check */
        if ( len < sizeof ( *login_rsp ) ) {
                DBGC ( srpdev, "SRP %p LOGIN_RSP too short (%zd bytes)\n",
                       srpdev, len );
                return -EINVAL;
        }
        login_rsp = data;
        DBGC ( srpdev, "SRP %p tag %08x LOGIN_RSP:\n",
               srpdev, ntohl ( login_rsp->tag.dwords[1] ) );
        DBGC_HDA ( srpdev, 0, data, len );
 
        /* Mark as logged in */
        srpdev->logged_in = 1;
        DBGC ( srpdev, "SRP %p logged in\n", srpdev );
 
        /* Notify of window change */
        xfer_window_changed ( &srpdev->scsi );
 
        return 0;
}

References data, DBGC, DBGC_HDA, srp_tag::dwords, EINVAL, len, srp_device::logged_in, ntohl, srp_device::scsi, srp_login_rsp::tag, and xfer_window_changed().

srp_login_rej()

int srp_login_rej ( struct srp_device * srpdev, const void * data, size_t len )

static

Receive SRP login rejection.

Parameters

srpdev	SRP device
data	SRP IU
len	Length of SRP IU

Return values

rc	Return status code

Definition at line 369 of file srp.c.

                                                          {
        const struct srp_login_rej *login_rej;
        uint32_t reason;
 
        /* Sanity check */
        if ( len < sizeof ( *login_rej ) ) {
                DBGC ( srpdev, "SRP %p LOGIN_REJ too short (%zd bytes)\n",
                       srpdev, len );
                return -EINVAL;
        }
        login_rej = data;
        reason = ntohl ( login_rej->reason );
        DBGC ( srpdev, "SRP %p tag %08x LOGIN_REJ reason %08x:\n",
               srpdev, ntohl ( login_rej->tag.dwords[1] ), reason );
        DBGC_HDA ( srpdev, 0, data, len );
 
        /* Login rejection always indicates an error */
        return ( SRP_LOGIN_REJ_REASON_DEFINED ( reason ) ?
                 -EPERM_LOGIN_REJ ( reason ) : -EACCES );
}

References data, DBGC, DBGC_HDA, srp_tag::dwords, EACCES, EINVAL, EPERM_LOGIN_REJ, len, ntohl, reason, srp_login_rej::reason, SRP_LOGIN_REJ_REASON_DEFINED, and srp_login_rej::tag.

srp_cmd()

int srp_cmd ( struct srp_device * srpdev, struct scsi_cmd * command, uint32_t tag )

static

Transmit SRP SCSI command.

Parameters

srpdev	SRP device
command	SCSI command
tag	Command tag

Return values

rc	Return status code

Definition at line 399 of file srp.c.

                                    {
        struct io_buffer *iobuf;
        struct srp_cmd *cmd;
        struct srp_memory_descriptor *data_out;
        struct srp_memory_descriptor *data_in;
        int rc;
 
        /* Sanity check */
        if ( ! srpdev->logged_in ) {
                DBGC ( srpdev, "SRP %p tag %08x cannot send CMD before "
                       "login completes\n", srpdev, tag );
                return -EBUSY;
        }
 
        /* Allocate I/O buffer */
        iobuf = xfer_alloc_iob ( &srpdev->socket, SRP_MAX_I_T_IU_LEN );
        if ( ! iobuf )
                return -ENOMEM;
 
        /* Construct base portion */
        cmd = iob_put ( iobuf, sizeof ( *cmd ) );
        memset ( cmd, 0, sizeof ( *cmd ) );
        cmd->type = SRP_CMD;
        cmd->tag.dwords[0] = htonl ( SRP_TAG_MAGIC );
        cmd->tag.dwords[1] = htonl ( tag );
        memcpy ( &cmd->lun, &command->lun, sizeof ( cmd->lun ) );
        memcpy ( &cmd->cdb, &command->cdb, sizeof ( cmd->cdb ) );
 
        /* Construct data-out descriptor, if present */
        if ( command->data_out.len ) {
                cmd->data_buffer_formats |= SRP_CMD_DO_FMT_DIRECT;
                data_out = iob_put ( iobuf, sizeof ( *data_out ) );
                data_out->address =
                    cpu_to_be64 ( virt_to_phys ( command->data_out.data ) );
                data_out->handle = ntohl ( srpdev->memory_handle );
                data_out->len = ntohl ( command->data_out.len );
        }
 
        /* Construct data-in descriptor, if present */
        if ( command->data_in.len ) {
                cmd->data_buffer_formats |= SRP_CMD_DI_FMT_DIRECT;
                data_in = iob_put ( iobuf, sizeof ( *data_in ) );
                data_in->address =
                     cpu_to_be64 ( virt_to_phys ( command->data_in.data ) );
                data_in->handle = ntohl ( srpdev->memory_handle );
                data_in->len = ntohl ( command->data_in.len );
        }
 
        DBGC2 ( srpdev, "SRP %p tag %08x CMD " SCSI_CDB_FORMAT "\n",
                srpdev, tag, SCSI_CDB_DATA ( cmd->cdb ) );
 
        /* Send IU */
        if ( ( rc = xfer_deliver_iob ( &srpdev->socket, iobuf ) ) != 0 ) {
                DBGC ( srpdev, "SRP %p tag %08x could not send CMD: %s\n",
                       srpdev, tag, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References srp_memory_descriptor::address, cmd, cpu_to_be64, DBGC, DBGC2, EBUSY, ENOMEM, srp_memory_descriptor::handle, htonl, iob_put, srp_memory_descriptor::len, srp_device::logged_in, memcpy(), srp_device::memory_handle, memset(), ntohl, rc, SCSI_CDB_DATA, SCSI_CDB_FORMAT, srp_device::socket, SRP_CMD, SRP_CMD_DI_FMT_DIRECT, SRP_CMD_DO_FMT_DIRECT, SRP_MAX_I_T_IU_LEN, SRP_TAG_MAGIC, strerror(), tag, xfer_alloc_iob(), and xfer_deliver_iob().

srp_rsp()

int srp_rsp ( struct srp_device * srpdev, const void * data, size_t len )

static

Receive SRP SCSI response.

Parameters

srpdev	SRP device
data	SRP IU
len	Length of SRP IU

Return values

rc	Returns status code

Definition at line 470 of file srp.c.

                                                    {
        const struct srp_rsp *rsp;
        struct srp_command *srpcmd;
        struct scsi_rsp response;
        const void *response_data;
        const void *sense_data;
        size_t response_data_len;
        size_t sense_data_len;
        size_t remaining;
        ssize_t data_out_residual_count;
        ssize_t data_in_residual_count;
 
        /* Parse response */
        remaining = len;
        if ( remaining < sizeof ( *rsp ) ) {
                DBGC ( srpdev, "SRP %p RSP too short (%zd bytes)\n",
                       srpdev, len );
                return -EINVAL;
        }
        rsp = data;
        remaining -= sizeof ( *rsp );
        DBGC2 ( srpdev, "SRP %p tag %08x RSP stat %02x dores %08x dires "
                "%08x valid %02x%s%s%s%s%s%s\n",
                srpdev, ntohl ( rsp->tag.dwords[1] ), rsp->status,
                ntohl ( rsp->data_out_residual_count ),
                ntohl ( rsp->data_in_residual_count ), rsp->valid,
                ( ( rsp->valid & SRP_RSP_VALID_DIUNDER ) ? " diunder" : "" ),
                ( ( rsp->valid & SRP_RSP_VALID_DIOVER ) ? " diover" : "" ),
                ( ( rsp->valid & SRP_RSP_VALID_DOUNDER ) ? " dounder" : "" ),
                ( ( rsp->valid & SRP_RSP_VALID_DOOVER ) ? " doover" : "" ),
                ( ( rsp->valid & SRP_RSP_VALID_SNSVALID ) ? " sns" : "" ),
                ( ( rsp->valid & SRP_RSP_VALID_RSPVALID ) ? " rsp" : "" ) );
 
        /* Parse response data */
        response_data_len = srp_rsp_response_data_len ( rsp );
        if ( remaining < response_data_len ) {
                DBGC ( srpdev, "SRP %p RSP overlength response data\n",
                       srpdev );
                return -EINVAL;
        }
        response_data = srp_rsp_response_data ( rsp );
        if ( response_data ) {
                DBGC2 ( srpdev, "SRP %p response data:\n", srpdev );
                DBGC2_HDA ( srpdev, 0, response_data, response_data_len );
        }
        remaining -= response_data_len;
 
        /* Parse sense data */
        sense_data_len = srp_rsp_sense_data_len ( rsp );
        if ( remaining < sense_data_len ) {
                DBGC ( srpdev, "SRP %p RSP overlength sense data\n",
                       srpdev );
                return -EINVAL;
        }
        sense_data = srp_rsp_sense_data ( rsp );
        if ( sense_data ) {
                DBGC2 ( srpdev, "SRP %p sense data:\n", srpdev );
                DBGC2_HDA ( srpdev, 0, sense_data, sense_data_len );
        }
        remaining -= sense_data_len;
 
        /* Identify command by tag */
        srpcmd = srp_find_tag ( srpdev, ntohl ( rsp->tag.dwords[1] ) );
        if ( ! srpcmd ) {
                DBGC ( srpdev, "SRP %p tag %08x unrecognised RSP\n",
                       srpdev, ntohl ( rsp->tag.dwords[1] ) );
                return -ENOENT;
        }
 
        /* Hold command reference for remainder of function */
        srpcmd_get ( srpcmd );
 
        /* Build SCSI response */
        memset ( &response, 0, sizeof ( response ) );
        response.status = rsp->status;
        data_out_residual_count = ntohl ( rsp->data_out_residual_count );
        data_in_residual_count = ntohl ( rsp->data_in_residual_count );
        if ( rsp->valid & SRP_RSP_VALID_DOOVER ) {
                response.overrun = data_out_residual_count;
        } else if ( rsp->valid & SRP_RSP_VALID_DOUNDER ) {
                response.overrun = -(data_out_residual_count);
        } else if ( rsp->valid & SRP_RSP_VALID_DIOVER ) {
                response.overrun = data_in_residual_count;
        } else if ( rsp->valid & SRP_RSP_VALID_DIUNDER ) {
                response.overrun = -(data_in_residual_count);
        }
        scsi_parse_sense ( sense_data, sense_data_len, &response.sense );
 
        /* Report SCSI response */
        scsi_response ( &srpcmd->scsi, &response );
 
        /* Close SCSI command */
        srpcmd_close ( srpcmd, 0 );
 
        /* Drop temporary command reference */
        srpcmd_put ( srpcmd );
 
        return 0;
}

References data, DBGC, DBGC2, DBGC2_HDA, EINVAL, ENOENT, len, memset(), ntohl, scsi_rsp::overrun, rsp, srp_command::scsi, scsi_parse_sense(), scsi_response(), scsi_rsp::sense, srp_find_tag(), srp_rsp_response_data(), srp_rsp_response_data_len(), srp_rsp_sense_data(), srp_rsp_sense_data_len(), SRP_RSP_VALID_DIOVER, SRP_RSP_VALID_DIUNDER, SRP_RSP_VALID_DOOVER, SRP_RSP_VALID_DOUNDER, SRP_RSP_VALID_RSPVALID, SRP_RSP_VALID_SNSVALID, srpcmd_close(), srpcmd_get(), srpcmd_put(), and scsi_rsp::status.

srp_unrecognised()

int srp_unrecognised ( struct srp_device * srpdev, const void * data, size_t len )

static

Receive SRP unrecognised response IU.

Parameters

srpdev	SRP device
data	SRP IU
len	Length of SRP IU

Return values

rc	Returns status code

Definition at line 579 of file srp.c.

                                                             {
        const struct srp_common *common = data;
 
        DBGC ( srpdev, "SRP %p tag %08x unrecognised IU type %02x:\n",
               srpdev, ntohl ( common->tag.dwords[1] ), common->type );
        DBGC_HDA ( srpdev, 0, data, len );
 
        return -ENOTSUP;
}

References common, data, DBGC, DBGC_HDA, ENOTSUP, len, and ntohl.

Referenced by srpdev_deliver().

srpdev_scsi_command()

int srpdev_scsi_command ( struct srp_device * srpdev, struct interface * parent, struct scsi_cmd * command )

static

Issue SRP SCSI command.

Parameters

srpdev	SRP device
parent	Parent interface
command	SCSI command

Return values

tag	Command tag, or negative error

Definition at line 607 of file srp.c.

                                                            {
        struct srp_command *srpcmd;
        int tag;
        int rc;
 
        /* Allocate command tag */
        tag = srp_new_tag ( srpdev );
        if ( tag < 0 ) {
                rc = tag;
                goto err_tag;
        }
 
        /* Allocate and initialise structure */
        srpcmd = zalloc ( sizeof ( *srpcmd ) );
        if ( ! srpcmd ) {
                rc = -ENOMEM;
                goto err_zalloc;
        }
        ref_init ( &srpcmd->refcnt, srpcmd_free );
        intf_init ( &srpcmd->scsi, &srpcmd_scsi_desc, &srpcmd->refcnt );
        srpcmd->srpdev = srpdev_get ( srpdev );
        list_add ( &srpcmd->list, &srpdev->commands );
        srpcmd->tag = tag;
 
        /* Send command IU */
        if ( ( rc = srp_cmd ( srpdev, command, srpcmd->tag ) ) != 0 )
                goto err_cmd;
 
        /* Attach to parent interface, leave reference with command
         * list, and return.
         */
        intf_plug_plug ( &srpcmd->scsi, parent );
        return srpcmd->tag;
 
 err_cmd:
        srpcmd_close ( srpcmd, rc );
 err_zalloc:
 err_tag:
        return rc;
}

References srp_device::commands, ENOMEM, intf_init(), intf_plug_plug(), srp_command::list, list_add, rc, ref_init, srp_command::refcnt, srp_command::scsi, srp_new_tag(), srpcmd_close(), srpcmd_free(), srpcmd_scsi_desc, srp_command::srpdev, srpdev_get(), srp_command::tag, tag, and zalloc().

srpdev_deliver()

int srpdev_deliver ( struct srp_device * srpdev, struct io_buffer * iobuf, struct xfer_metadata *meta __unused )

static

Receive data from SRP socket.

Parameters

srpdev	SRP device
iobuf	Datagram I/O buffer
meta	Data transfer metadata

Return values

rc	Return status code

Definition at line 658 of file srp.c.

                                                                  {
        struct srp_common *common;
        int ( * type ) ( struct srp_device *srp, const void *data, size_t len );
        int rc;
 
        /* Sanity check */
        if ( iob_len ( iobuf ) < sizeof ( *common ) ) {
                DBGC ( srpdev, "SRP %p IU too short (%zd bytes)\n",
                       srpdev, iob_len ( iobuf ) );
                rc = -EINVAL;
                goto err;
        }
        common = iobuf->data;
 
        /* Determine IU type */
        switch ( common->type ) {
        case SRP_LOGIN_RSP:
                type = srp_login_rsp;
                break;
        case SRP_LOGIN_REJ:
                type = srp_login_rej;
                break;
        case SRP_RSP:
                type = srp_rsp;
                break;
        default:
                type = srp_unrecognised;
                break;
        }
 
        /* Handle IU */
        if ( ( rc = type ( srpdev, iobuf->data, iob_len ( iobuf ) ) ) != 0 )
                goto err;
 
        free_iob ( iobuf );
        return 0;
 
 err:
        DBGC ( srpdev, "SRP %p closing due to received IU (%s):\n",
               srpdev, strerror ( rc ) );
        DBGC_HDA ( srpdev, 0, iobuf->data, iob_len ( iobuf ) );
        free_iob ( iobuf );
        srpdev_close ( srpdev, rc );
        return rc;
}

References __unused, common, data, io_buffer::data, DBGC, DBGC_HDA, EINVAL, free_iob(), iob_len(), len, meta, rc, SRP_LOGIN_REJ, SRP_LOGIN_RSP, SRP_RSP, srp_unrecognised(), srpdev_close(), strerror(), and type.

srpdev_window()

size_t srpdev_window ( struct srp_device * srpdev )

static

Check SRP device flow-control window.

Parameters

srpdev

SRP device

Return values

len	Length of window

Definition at line 712 of file srp.c.

                                                          {
        return ( srpdev->logged_in ? ~( ( size_t ) 0 ) : 0 );
}

References srp_device::logged_in.

srp_open()

int srp_open	(	struct interface *	block,
		struct interface *	socket,
		union srp_port_id *	initiator,
		union srp_port_id *	target,
		uint32_t	memory_handle,
		struct scsi_lun *	lun )

Open SRP device.

Parameters

block	Block control interface
socket	Socket interface
initiator	Initiator port ID
target	Target port ID
memory_handle	RDMA memory handle
lun	SCSI LUN

Return values

rc	Return status code

Definition at line 749 of file srp.c.

                                                              {
        struct srp_device *srpdev;
        int tag;
        int rc;
 
        /* Allocate and initialise structure */
        srpdev = zalloc ( sizeof ( *srpdev ) );
        if ( ! srpdev ) {
                rc = -ENOMEM;
                goto err_zalloc;
        }
        ref_init ( &srpdev->refcnt, NULL );
        intf_init ( &srpdev->scsi, &srpdev_scsi_desc, &srpdev->refcnt );
        intf_init ( &srpdev->socket, &srpdev_socket_desc, &srpdev->refcnt );
        INIT_LIST_HEAD ( &srpdev->commands );
        srpdev->memory_handle = memory_handle;
        DBGC ( srpdev, "SRP %p %08x%08x%08x%08x->%08x%08x%08x%08x\n", srpdev,
               ntohl ( initiator->dwords[0] ), ntohl ( initiator->dwords[1] ),
               ntohl ( initiator->dwords[2] ), ntohl ( initiator->dwords[3] ),
               ntohl ( target->dwords[0] ), ntohl ( target->dwords[1] ),
               ntohl ( target->dwords[2] ), ntohl ( target->dwords[3] ) );
 
        /* Attach to socket interface and initiate login */
        intf_plug_plug ( &srpdev->socket, socket );
        tag = srp_new_tag ( srpdev );
        assert ( tag >= 0 ); /* Cannot fail when no commands in progress */
        if ( ( rc = srp_login ( srpdev, initiator, target, tag ) ) != 0 )
                goto err_login;
 
        /* Attach SCSI device to parent interface */
        if ( ( rc = scsi_open ( block, &srpdev->scsi, lun ) ) != 0 ) {
                DBGC ( srpdev, "SRP %p could not create SCSI device: %s\n",
                       srpdev, strerror ( rc ) );
                goto err_scsi_open;
        }
 
        /* Mortalise self and return */
        ref_put ( &srpdev->refcnt );
        return 0;
 
 err_scsi_open:
 err_login:
        srpdev_close ( srpdev, rc );
        ref_put ( &srpdev->refcnt );
 err_zalloc:
        return rc;
}

References assert, block, srp_device::commands, DBGC, srp_port_id::dwords, ENOMEM, INIT_LIST_HEAD, intf_init(), intf_plug_plug(), lun, srp_device::memory_handle, ntohl, NULL, rc, ref_init, ref_put, srp_device::refcnt, srp_device::scsi, scsi_open(), srp_device::socket, srp_login(), srp_new_tag(), srpdev_close(), srpdev_scsi_desc, srpdev_socket_desc, strerror(), tag, and zalloc().

Referenced by ib_srp_open().

Variable Documentation

srpcmd_scsi_op

struct interface_operation srpcmd_scsi_op[]

static

Initial value:

                                 = {
        INTF_OP ( intf_close, struct srp_command *, srpcmd_close ),
}

SRP command SCSI interface operations.

Definition at line 591 of file srp.c.

                                                   {
        INTF_OP ( intf_close, struct srp_command *, srpcmd_close ),
};

srpcmd_scsi_desc

struct interface_descriptor srpcmd_scsi_desc

static

Initial value:

                         =
INTF_DESC ( struct srp_command, scsi, srpcmd_scsi_op )

SRP command SCSI interface descriptor.

Definition at line 596 of file srp.c.

Referenced by srpdev_scsi_command().

srpdev_socket_op

struct interface_operation srpdev_socket_op[]

static

Initial value:

                                 = {
        INTF_OP ( xfer_deliver, struct srp_device *, srpdev_deliver ),
        INTF_OP ( intf_close, struct srp_device *, srpdev_close ),
}

SRP device socket interface operations.

Definition at line 717 of file srp.c.

                                                     {
        INTF_OP ( xfer_deliver, struct srp_device *, srpdev_deliver ),
        INTF_OP ( intf_close, struct srp_device *, srpdev_close ),
};

srpdev_socket_desc

struct interface_descriptor srpdev_socket_desc

static

Initial value:

                         =
INTF_DESC_PASSTHRU ( struct srp_device, socket, srpdev_socket_op,
                     scsi )

SRP device socket interface descriptor.

Definition at line 723 of file srp.c.

Referenced by srp_open().

srpdev_scsi_op

struct interface_operation srpdev_scsi_op[]

static

Initial value:

                                 = {
        INTF_OP ( scsi_command, struct srp_device *, srpdev_scsi_command ),
        INTF_OP ( xfer_window, struct srp_device *, srpdev_window ),
        INTF_OP ( intf_close, struct srp_device *, srpdev_close ),
}

SRP device SCSI interface operations.

Definition at line 728 of file srp.c.

                                                   {
        INTF_OP ( scsi_command, struct srp_device *, srpdev_scsi_command ),
        INTF_OP ( xfer_window, struct srp_device *, srpdev_window ),
        INTF_OP ( intf_close, struct srp_device *, srpdev_close ),
};

srpdev_scsi_desc

struct interface_descriptor srpdev_scsi_desc

static

Initial value:

                         =
INTF_DESC_PASSTHRU ( struct srp_device, scsi, srpdev_scsi_op, socket  )

SRP device SCSI interface descriptor.

Definition at line 735 of file srp.c.

Referenced by srp_open().