/*
* Copyright (C) 2010 Michael Brown <mbrown@fensystems.co.uk>.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <ipxe/interface.h>
#include <ipxe/xfer.h>
#include <ipxe/iobuf.h>
#include <ipxe/process.h>
#include <ipxe/fc.h>
#include <ipxe/fcels.h>
/** @file
*
* Fibre Channel Extended Link Services
*
*/
/** Fibre Channel ELS transaction debug message format */
#define FCELS_FMT "FCELS %s %s %s %s"
/** Fibre Channel ELS transaction debug message arguments */
#define FCELS_ARGS( els ) \
(els)->port->name, \
( (els)->handler ? (els)->handler->name : "unknown ELS" ), \
( fc_els_is_request ( els ) ? "to" : "from" ), \
fc_id_ntoa ( &(els)->peer_port_id )
struct fc_els_handler fc_els_unknown_handler __fc_els_handler;
/**
* Free Fibre Channel ELS transaction
*
* @v refcnt Reference count
*/
static void fc_els_free ( struct refcnt *refcnt ) {
struct fc_els *els = container_of ( refcnt, struct fc_els, refcnt );
assert ( ! process_running ( &els->process ) );
fc_port_put ( els->port );
free ( els );
}
/**
* Close Fibre Channel ELS transaction
*
* @v els Fibre Channel ELS transaction
* @v rc Reason for close
*/
static void fc_els_close ( struct fc_els *els, int rc ) {
if ( rc != 0 ) {
DBGC ( els, FCELS_FMT " complete (%s)\n",
FCELS_ARGS ( els ), strerror ( rc ) );
}
/* Stop process */
process_del ( &els->process );
/* Shut down interfaces */
intf_shutdown ( &els->xchg, rc );
intf_shutdown ( &els->job, rc );
}
/**
* Detect Fibre Channel ELS frame handler
*
* @v els Fibre Channel ELS transaction
* @v command ELS command code
* @ret handler ELS handler, or NULL
*/
static struct fc_els_handler * fc_els_detect ( struct fc_els *els,
const void *data,
size_t len ) {
const struct fc_els_frame_common *frame = data;
struct fc_els_handler *handler;
int rc;
/* Sanity check */
if ( len < sizeof ( *frame ) )
return NULL;
/* Try each handler in turn */
for_each_table_entry ( handler, FC_ELS_HANDLERS ) {
if ( ( rc = handler->detect ( els, data, len ) ) == 0 )
return handler;
}
return NULL;
}
/**
* Transmit Fibre Channel ELS frame
*
* @v els Fibre Channel ELS transaction
* @v data Data to transmit
* @v len Length of data
* @ret rc Return status code
*/
int fc_els_tx ( struct fc_els *els, const void *data, size_t len ) {
struct xfer_metadata meta;
struct sockaddr_fc dest;
int rc;
DBGC2 ( els, FCELS_FMT " transmitting:\n", FCELS_ARGS ( els ) );
DBGC2_HDA ( els, 0, data, len );
/* Construct metadata */
memset ( &meta, 0, sizeof ( meta ) );
meta.flags = ( fc_els_is_request ( els ) ?
XFER_FL_OVER : ( XFER_FL_RESPONSE | XFER_FL_OUT ) );
meta.dest = fc_fill_sockaddr ( &dest, &els->peer_port_id );
/* Transmit frame */
if ( ( rc = xfer_deliver_raw_meta ( &els->xchg, data, len,
&meta ) ) != 0 ) {
DBGC ( els, FCELS_FMT " could not deliver frame: %s\n",
FCELS_ARGS ( els ), strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Receive Fibre Channel ELS frame
*
* @v els Fibre Channel ELS transaction
* @v iobuf I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*/
static int fc_els_rx ( struct fc_els *els,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct fc_els_frame_common *frame = iobuf->data;
struct sockaddr_fc *src = ( ( struct sockaddr_fc * ) meta->src );
struct sockaddr_fc *dest = ( ( struct sockaddr_fc * ) meta->dest );
size_t len = iob_len ( iobuf );
int rc;
/* Sanity check */
if ( len < sizeof ( *frame ) ) {
DBGC ( els, FCELS_FMT " received underlength frame:\n",
FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, frame, len );
rc = -EINVAL;
goto done;
}
if ( ! src ) {
DBGC ( els, FCELS_FMT " received frame missing source "
"address:\n", FCELS_ARGS ( els ) );
rc = -EINVAL;
goto done;
}
if ( ! dest ) {
DBGC ( els, FCELS_FMT " received frame missing destination "
"address:\n", FCELS_ARGS ( els ) );
rc = -EINVAL;
goto done;
}
/* Check for rejection responses */
if ( fc_els_is_request ( els ) &&
( frame->command != FC_ELS_LS_ACC ) ) {
DBGC ( els, FCELS_FMT " rejected:\n", FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, frame, len );
rc = -EACCES;
goto done;
}
/* Update port IDs */
memcpy ( &els->port_id, &dest->sfc_port_id, sizeof ( els->port_id ) );
memcpy ( &els->peer_port_id, &src->sfc_port_id,
sizeof ( els->peer_port_id ) );
/* Determine handler, if necessary */
if ( ! els->handler )
els->handler = fc_els_detect ( els, frame, len );
if ( ! els->handler )
els->handler = &fc_els_unknown_handler;
DBGC2 ( els, FCELS_FMT " received:\n", FCELS_ARGS ( els ) );
DBGC2_HDA ( els, 0, frame, len );
/* Handle received frame */
if ( ( rc = els->handler->rx ( els, frame, len ) ) != 0 ) {
DBGC ( els, FCELS_FMT " could not handle received frame: "
"%s\n", FCELS_ARGS ( els ), strerror ( rc ) );
DBGC_HDA ( els, 0, frame, len );
goto done;
}
done:
/* Free I/O buffer */
free_iob ( iobuf );
/* Close transaction */
fc_els_close ( els, rc );
return rc;
}
/** Fibre Channel ELS exchange interface operations */
static struct interface_operation fc_els_xchg_op[] = {
INTF_OP ( xfer_deliver, struct fc_els *, fc_els_rx ),
INTF_OP ( intf_close, struct fc_els *, fc_els_close ),
};
/** Fibre Channel ELS exchange interface descriptor */
static struct interface_descriptor fc_els_xchg_desc =
INTF_DESC ( struct fc_els, xchg, fc_els_xchg_op );
/** Fibre Channel ELS job control interface operations */
static struct interface_operation fc_els_job_op[] = {
INTF_OP ( intf_close, struct fc_els *, fc_els_close ),
};
/** Fibre Channel ELS job control interface descriptor */
static struct interface_descriptor fc_els_job_desc =
INTF_DESC ( struct fc_els, job, fc_els_job_op );
/**
* Fibre Channel ELS process
*
* @v els Fibre Channel ELS transaction
*/
static void fc_els_step ( struct fc_els *els ) {
int xchg_id;
int rc;
/* Sanity check */
assert ( fc_els_is_request ( els ) );
/* Create exchange */
if ( ( xchg_id = fc_xchg_originate ( &els->xchg, els->port,
&els->peer_port_id,
FC_TYPE_ELS ) ) < 0 ) {
rc = xchg_id;
DBGC ( els, FCELS_FMT " could not create exchange: %s\n",
FCELS_ARGS ( els ), strerror ( rc ) );
fc_els_close ( els, rc );
return;
}
/* Transmit request */
if ( ( rc = els->handler->tx ( els ) ) != 0 ) {
DBGC ( els, FCELS_FMT " could not transmit request: %s\n",
FCELS_ARGS ( els ), strerror ( rc ) );
fc_els_close ( els, rc );
return;
}
}
/** Fibre Channel ELS process descriptor */
static struct process_descriptor fc_els_process_desc =
PROC_DESC_ONCE ( struct fc_els, process, fc_els_step );
/**
* Create ELS transaction
*
* @v port Fibre Channel port
* @v port_id Local port ID
* @v peer_port_id Peer port ID
* @ret els Fibre Channel ELS transaction, or NULL
*/
static struct fc_els * fc_els_create ( struct fc_port *port,
struct fc_port_id *port_id,
struct fc_port_id *peer_port_id ) {
struct fc_els *els;
/* Allocate and initialise structure */
els = zalloc ( sizeof ( *els ) );
if ( ! els )
return NULL;
ref_init ( &els->refcnt, fc_els_free );
intf_init ( &els->job, &fc_els_job_desc, &els->refcnt );
intf_init ( &els->xchg, &fc_els_xchg_desc, &els->refcnt );
process_init_stopped ( &els->process, &fc_els_process_desc,
&els->refcnt );
els->port = fc_port_get ( port );
memcpy ( &els->port_id, port_id, sizeof ( els->port_id ) );
memcpy ( &els->peer_port_id, peer_port_id,
sizeof ( els->peer_port_id ) );
return els;
}
/**
* Create ELS request
*
* @v job Parent job-control interface
* @v port Fibre Channel port
* @v peer_port_id Peer port ID
* @v handler ELS handler
* @ret rc Return status code
*/
int fc_els_request ( struct interface *job, struct fc_port *port,
struct fc_port_id *peer_port_id,
struct fc_els_handler *handler ) {
struct fc_els *els;
/* Allocate and initialise structure */
els = fc_els_create ( port, &port->port_id, peer_port_id );
if ( ! els )
return -ENOMEM;
els->handler = handler;
els->flags = FC_ELS_REQUEST;
process_add ( &els->process );
/* Attach to parent job interface, mortalise self, and return */
intf_plug_plug ( &els->job, job );
ref_put ( &els->refcnt );
return 0;
}
/**
* Create ELS response
*
* @v xchg Exchange interface
* @v port Fibre Channel port
* @v port_id Local port ID
* @v peer_port_id Peer port ID
* @ret rc Return status code
*/
static int fc_els_respond ( struct interface *xchg, struct fc_port *port,
struct fc_port_id *port_id,
struct fc_port_id *peer_port_id ) {
struct fc_els *els;
/* Allocate and initialise structure */
els = fc_els_create ( port, port_id, peer_port_id );
if ( ! els )
return -ENOMEM;
/* Attach to exchange interface, mortalise self, and return */
intf_plug_plug ( &els->xchg, xchg );
ref_put ( &els->refcnt );
return 0;
}
/** Fibre Channel ELS responder */
struct fc_responder fc_els_responder __fc_responder = {
.type = FC_TYPE_ELS,
.respond = fc_els_respond,
};
/******************************************************************************
*
* Unknown ELS handler
*
******************************************************************************
*/
/**
* Transmit unknown ELS request
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_unknown_tx ( struct fc_els *els __unused ) {
return -ENOTSUP;
}
/**
* Transmit unknown ELS response
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_unknown_tx_response ( struct fc_els *els ) {
struct fc_ls_rjt_frame ls_rjt;
/* Construct LS_RJT */
memset ( &ls_rjt, 0, sizeof ( ls_rjt ) );
ls_rjt.command = FC_ELS_LS_RJT;
ls_rjt.reason = FC_ELS_RJT_UNSUPPORTED;
/* Transmit LS_RJT */
return fc_els_tx ( els, &ls_rjt, sizeof ( ls_rjt ) );
}
/**
* Receive unknown ELS
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_unknown_rx ( struct fc_els *els, void *data, size_t len ) {
int rc;
DBGC ( els, FCELS_FMT ":\n", FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, data, len );
/* Transmit response, if applicable */
if ( ! fc_els_is_request ( els ) ) {
if ( ( rc = fc_els_unknown_tx_response ( els ) ) != 0 )
return rc;
}
return 0;
}
/**
* Detect unknown ELS
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_unknown_detect ( struct fc_els *els __unused,
const void *data __unused,
size_t len __unused ) {
return -ENOTSUP;
}
/** Unknown ELS handler */
struct fc_els_handler fc_els_unknown_handler __fc_els_handler = {
.name = "UNKNOWN",
.tx = fc_els_unknown_tx,
.rx = fc_els_unknown_rx,
.detect = fc_els_unknown_detect,
};
/******************************************************************************
*
* FLOGI
*
******************************************************************************
*/
/**
* Transmit FLOGI
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_flogi_tx ( struct fc_els *els ) {
struct fc_login_frame flogi;
/* Construct FLOGI */
memset ( &flogi, 0, sizeof ( flogi ) );
flogi.command = fc_els_tx_command ( els, FC_ELS_FLOGI );
flogi.common.version = htons ( FC_LOGIN_VERSION );
flogi.common.credit = htons ( FC_LOGIN_DEFAULT_B2B );
flogi.common.flags = htons ( FC_LOGIN_CONTINUOUS_OFFSET );
flogi.common.mtu = htons ( FC_LOGIN_DEFAULT_MTU );
memcpy ( &flogi.port_wwn, &els->port->port_wwn,
sizeof ( flogi.port_wwn ) );
memcpy ( &flogi.node_wwn, &els->port->node_wwn,
sizeof ( flogi.node_wwn ) );
flogi.class3.flags = htons ( FC_LOGIN_CLASS_VALID |
FC_LOGIN_CLASS_SEQUENTIAL );
/* Transmit FLOGI */
return fc_els_tx ( els, &flogi, sizeof ( flogi ) );
}
/**
* Receive FLOGI
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_flogi_rx ( struct fc_els *els, void *data, size_t len ) {
struct fc_login_frame *flogi = data;
int has_fabric;
int rc;
/* Sanity check */
if ( len < sizeof ( *flogi ) ) {
DBGC ( els, FCELS_FMT " received underlength frame:\n",
FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, data, len );
return -EINVAL;
}
/* Extract parameters */
has_fabric = ( flogi->common.flags & htons ( FC_LOGIN_F_PORT ) );
DBGC ( els, FCELS_FMT " has node %s\n", FCELS_ARGS ( els ),
fc_ntoa ( &flogi->node_wwn ) );
DBGC ( els, FCELS_FMT " has port %s\n", FCELS_ARGS ( els ),
fc_ntoa ( &flogi->port_wwn ) );
if ( has_fabric ) {
DBGC ( els, FCELS_FMT " has fabric with", FCELS_ARGS ( els ) );
DBGC ( els, " local ID %s\n", fc_id_ntoa ( &els->port_id ) );
} else {
DBGC ( els, FCELS_FMT " has point-to-point link\n",
FCELS_ARGS ( els ) );
}
/* Log in port */
if ( ( rc = fc_port_login ( els->port, &els->port_id, &flogi->node_wwn,
&flogi->port_wwn, has_fabric ) ) != 0 ) {
DBGC ( els, FCELS_FMT " could not log in port: %s\n",
FCELS_ARGS ( els ), strerror ( rc ) );
return rc;
}
/* Send any responses to the newly-assigned peer port ID, if
* applicable.
*/
if ( ! has_fabric ) {
memcpy ( &els->peer_port_id, &els->port->ptp_link_port_id,
sizeof ( els->peer_port_id ) );
}
/* Transmit response, if applicable */
if ( ! fc_els_is_request ( els ) ) {
if ( ( rc = fc_els_flogi_tx ( els ) ) != 0 )
return rc;
}
return 0;
}
/**
* Detect FLOGI
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_flogi_detect ( struct fc_els *els __unused, const void *data,
size_t len __unused ) {
const struct fc_login_frame *flogi = data;
/* Check for FLOGI */
if ( flogi->command != FC_ELS_FLOGI )
return -EINVAL;
return 0;
}
/** FLOGI ELS handler */
struct fc_els_handler fc_els_flogi_handler __fc_els_handler = {
.name = "FLOGI",
.tx = fc_els_flogi_tx,
.rx = fc_els_flogi_rx,
.detect = fc_els_flogi_detect,
};
/**
* Create FLOGI request
*
* @v parent Parent interface
* @v port Fibre Channel port
* @ret rc Return status code
*/
int fc_els_flogi ( struct interface *parent, struct fc_port *port ) {
return fc_els_request ( parent, port, &fc_f_port_id,
&fc_els_flogi_handler );
}
/******************************************************************************
*
* PLOGI
*
******************************************************************************
*/
/**
* Transmit PLOGI
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_plogi_tx ( struct fc_els *els ) {
struct fc_login_frame plogi;
/* Construct PLOGI */
memset ( &plogi, 0, sizeof ( plogi ) );
plogi.command = fc_els_tx_command ( els, FC_ELS_PLOGI );
plogi.common.version = htons ( FC_LOGIN_VERSION );
plogi.common.credit = htons ( FC_LOGIN_DEFAULT_B2B );
plogi.common.flags = htons ( FC_LOGIN_CONTINUOUS_OFFSET );
plogi.common.mtu = htons ( FC_LOGIN_DEFAULT_MTU );
plogi.common.u.plogi.max_seq = htons ( FC_LOGIN_DEFAULT_MAX_SEQ );
plogi.common.u.plogi.rel_offs = htons ( FC_LOGIN_DEFAULT_REL_OFFS );
plogi.common.e_d_tov = htonl ( FC_LOGIN_DEFAULT_E_D_TOV );
memcpy ( &plogi.port_wwn, &els->port->port_wwn,
sizeof ( plogi.port_wwn ) );
memcpy ( &plogi.node_wwn, &els->port->node_wwn,
sizeof ( plogi.node_wwn ) );
plogi.class3.flags = htons ( FC_LOGIN_CLASS_VALID |
FC_LOGIN_CLASS_SEQUENTIAL );
plogi.class3.mtu = htons ( FC_LOGIN_DEFAULT_MTU );
plogi.class3.max_seq = htons ( FC_LOGIN_DEFAULT_MAX_SEQ );
plogi.class3.max_seq_per_xchg = 1;
/* Transmit PLOGI */
return fc_els_tx ( els, &plogi, sizeof ( plogi ) );
}
/**
* Receive PLOGI
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_plogi_rx ( struct fc_els *els, void *data, size_t len ) {
struct fc_login_frame *plogi = data;
struct fc_peer *peer;
int rc;
/* Sanity checks */
if ( len < sizeof ( *plogi ) ) {
DBGC ( els, FCELS_FMT " received underlength frame:\n",
FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, data, len );
rc = -EINVAL;
goto err_sanity;
}
if ( ! fc_link_ok ( &els->port->link ) ) {
DBGC ( els, FCELS_FMT " received while port link is down\n",
FCELS_ARGS ( els ) );
rc = -EINVAL;
goto err_sanity;
}
/* Extract parameters */
DBGC ( els, FCELS_FMT " has node %s\n", FCELS_ARGS ( els ),
fc_ntoa ( &plogi->node_wwn ) );
DBGC ( els, FCELS_FMT " has port %s as %s\n",
FCELS_ARGS ( els ), fc_ntoa ( &plogi->port_wwn ),
fc_id_ntoa ( &els->peer_port_id ) );
/* Get peer */
peer = fc_peer_get_wwn ( &plogi->port_wwn );
if ( ! peer ) {
DBGC ( els, FCELS_FMT " could not create peer\n",
FCELS_ARGS ( els ) );
rc = -ENOMEM;
goto err_peer_get_wwn;
}
/* Record login */
if ( ( rc = fc_peer_login ( peer, els->port,
&els->peer_port_id ) ) != 0 ) {
DBGC ( els, FCELS_FMT " could not log in peer: %s\n",
FCELS_ARGS ( els ), strerror ( rc ) );
goto err_login;
}
/* Transmit response, if applicable */
if ( ! fc_els_is_request ( els ) ) {
if ( ( rc = fc_els_plogi_tx ( els ) ) != 0 )
goto err_plogi_tx;
}
/* Drop temporary reference to peer */
fc_peer_put ( peer );
return 0;
err_plogi_tx:
err_login:
fc_peer_put ( peer );
err_peer_get_wwn:
err_sanity:
return rc;
}
/**
* Detect PLOGI
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_plogi_detect ( struct fc_els *els __unused, const void *data,
size_t len __unused ) {
const struct fc_login_frame *plogi = data;
/* Check for PLOGI */
if ( plogi->command != FC_ELS_PLOGI )
return -EINVAL;
return 0;
}
/** PLOGI ELS handler */
struct fc_els_handler fc_els_plogi_handler __fc_els_handler = {
.name = "PLOGI",
.tx = fc_els_plogi_tx,
.rx = fc_els_plogi_rx,
.detect = fc_els_plogi_detect,
};
/**
* Create PLOGI request
*
* @v parent Parent interface
* @v port Fibre Channel port
* @v peer_port_id Peer port ID
* @ret rc Return status code
*/
int fc_els_plogi ( struct interface *parent, struct fc_port *port,
struct fc_port_id *peer_port_id ) {
return fc_els_request ( parent, port, peer_port_id,
&fc_els_plogi_handler );
}
/******************************************************************************
*
* LOGO
*
******************************************************************************
*/
/**
* Transmit LOGO request
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_logo_tx ( struct fc_els *els ) {
struct fc_logout_request_frame logo;
/* Construct LOGO */
memset ( &logo, 0, sizeof ( logo ) );
logo.command = FC_ELS_LOGO;
memcpy ( &logo.port_id, &els->port->port_id, sizeof ( logo.port_id ) );
memcpy ( &logo.port_wwn, &els->port->port_wwn,
sizeof ( logo.port_wwn ) );
/* Transmit LOGO */
return fc_els_tx ( els, &logo, sizeof ( logo ) );
}
/**
* Transmit LOGO response
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_logo_tx_response ( struct fc_els *els ) {
struct fc_logout_response_frame logo;
/* Construct LOGO */
memset ( &logo, 0, sizeof ( logo ) );
logo.command = FC_ELS_LS_ACC;
/* Transmit LOGO */
return fc_els_tx ( els, &logo, sizeof ( logo ) );
}
/**
* Log out individual peer or whole port as applicable
*
* @v els Fibre Channel ELS transaction
* @v port_id Peer port ID
*/
static void fc_els_logo_logout ( struct fc_els *els,
struct fc_port_id *peer_port_id ) {
struct fc_peer *peer;
if ( ( memcmp ( peer_port_id, &fc_f_port_id,
sizeof ( *peer_port_id ) ) == 0 ) ||
( memcmp ( peer_port_id, &els->port->port_id,
sizeof ( *peer_port_id ) ) == 0 ) ) {
fc_port_logout ( els->port, 0 );
} else {
peer = fc_peer_get_port_id ( els->port, peer_port_id );
if ( peer ) {
fc_peer_logout ( peer, 0 );
fc_peer_put ( peer );
}
}
}
/**
* Receive LOGO request
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_logo_rx_request ( struct fc_els *els, void *data,
size_t len ) {
struct fc_logout_request_frame *logo = data;
int rc;
/* Sanity check */
if ( len < sizeof ( *logo ) ) {
DBGC ( els, FCELS_FMT " received underlength frame:\n",
FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, data, len );
return -EINVAL;
}
DBGC ( els, FCELS_FMT " has port %s as %s\n", FCELS_ARGS ( els ),
fc_ntoa ( &logo->port_wwn ), fc_id_ntoa ( &logo->port_id ) );
/* Log out individual peer or whole port as applicable */
fc_els_logo_logout ( els, &logo->port_id );
/* Transmit repsonse */
if ( ( rc = fc_els_logo_tx_response ( els ) ) != 0 )
return rc;
return 0;
}
/**
* Receive LOGO response
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_logo_rx_response ( struct fc_els *els, void *data __unused,
size_t len __unused ) {
/* Log out individual peer or whole port as applicable */
fc_els_logo_logout ( els, &els->peer_port_id );
return 0;
}
/**
* Receive LOGO
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_logo_rx ( struct fc_els *els, void *data, size_t len ) {
if ( fc_els_is_request ( els ) ) {
return fc_els_logo_rx_response ( els, data, len );
} else {
return fc_els_logo_rx_request ( els, data, len );
}
}
/**
* Detect LOGO
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_logo_detect ( struct fc_els *els __unused, const void *data,
size_t len __unused ) {
const struct fc_logout_request_frame *logo = data;
/* Check for LOGO */
if ( logo->command != FC_ELS_LOGO )
return -EINVAL;
return 0;
}
/** LOGO ELS handler */
struct fc_els_handler fc_els_logo_handler __fc_els_handler = {
.name = "LOGO",
.tx = fc_els_logo_tx,
.rx = fc_els_logo_rx,
.detect = fc_els_logo_detect,
};
/**
* Create LOGO request
*
* @v parent Parent interface
* @v port Fibre Channel port
* @v peer_port_id Peer port ID
* @ret rc Return status code
*/
int fc_els_logo ( struct interface *parent, struct fc_port *port,
struct fc_port_id *peer_port_id ) {
return fc_els_request ( parent, port, peer_port_id,
&fc_els_logo_handler );
}
/******************************************************************************
*
* PRLI
*
******************************************************************************
*/
/**
* Find PRLI descriptor
*
* @v type Upper-layer protocol type
* @ret descriptor PRLI descriptor, or NULL
*/
static struct fc_els_prli_descriptor *
fc_els_prli_descriptor ( unsigned int type ) {
struct fc_els_prli_descriptor *descriptor;
for_each_table_entry ( descriptor, FC_ELS_PRLI_DESCRIPTORS ) {
if ( descriptor->type == type )
return descriptor;
}
return NULL;
}
/**
* Transmit PRLI
*
* @v els Fibre Channel ELS transaction
* @v descriptor ELS PRLI descriptor
* @v param Service parameters
* @ret rc Return status code
*/
int fc_els_prli_tx ( struct fc_els *els,
struct fc_els_prli_descriptor *descriptor, void *param ) {
struct {
struct fc_prli_frame frame;
uint8_t param[descriptor->param_len];
} __attribute__ (( packed )) prli;
struct fc_ulp *ulp;
int rc;
/* Get ULP */
ulp = fc_ulp_get_port_id_type ( els->port, &els->peer_port_id,
descriptor->type );
if ( ! ulp ) {
rc = -ENOMEM;
goto err_get_port_id_type;
}
/* Build frame for transmission */
memset ( &prli, 0, sizeof ( prli ) );
prli.frame.command = fc_els_tx_command ( els, FC_ELS_PRLI );
prli.frame.page_len =
( sizeof ( prli.frame.page ) + sizeof ( prli.param ) );
prli.frame.len = htons ( sizeof ( prli ) );
prli.frame.page.type = descriptor->type;
if ( fc_els_is_request ( els ) ) {
prli.frame.page.flags |= htons ( FC_PRLI_ESTABLISH );
} else if ( fc_link_ok ( &ulp->link ) ) {
prli.frame.page.flags |= htons ( FC_PRLI_ESTABLISH |
FC_PRLI_RESPONSE_SUCCESS );
}
memcpy ( &prli.param, param, sizeof ( prli.param ) );
/* Transmit frame */
if ( ( rc = fc_els_tx ( els, &prli, sizeof ( prli ) ) ) != 0 )
goto err_tx;
/* Drop temporary reference to ULP */
fc_ulp_put ( ulp );
return 0;
err_tx:
fc_ulp_put ( ulp );
err_get_port_id_type:
return rc;
}
/**
* Receive PRLI
*
* @v els Fibre Channel ELS transaction
* @v descriptor ELS PRLI descriptor
* @v frame ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
int fc_els_prli_rx ( struct fc_els *els,
struct fc_els_prli_descriptor *descriptor,
void *data, size_t len ) {
struct {
struct fc_prli_frame frame;
uint8_t param[descriptor->param_len];
} __attribute__ (( packed )) *prli = data;
struct fc_ulp *ulp;
int rc;
/* Sanity check */
if ( len < sizeof ( *prli ) ) {
DBGC ( els, FCELS_FMT " received underlength frame:\n",
FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, data, len );
rc = -EINVAL;
goto err_sanity;
}
DBGC ( els, FCELS_FMT " has parameters:\n", FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, prli->param, sizeof ( prli->param ) );
/* Get ULP */
ulp = fc_ulp_get_port_id_type ( els->port, &els->peer_port_id,
descriptor->type );
if ( ! ulp ) {
rc = -ENOMEM;
goto err_get_port_id_type;
}
/* Sanity check */
if ( ! fc_link_ok ( &ulp->peer->link ) ) {
DBGC ( els, FCELS_FMT " received while peer link is down\n",
FCELS_ARGS ( els ) );
rc = -EINVAL;
goto err_link;
}
/* Log in ULP, if applicable */
if ( prli->frame.page.flags & htons ( FC_PRLI_ESTABLISH ) ) {
if ( ( rc = fc_ulp_login ( ulp, prli->param,
sizeof ( prli->param ),
fc_els_is_request ( els ) ) ) != 0 ){
DBGC ( els, FCELS_FMT " could not log in ULP: %s\n",
FCELS_ARGS ( els ), strerror ( rc ) );
goto err_login;
}
} else {
if ( fc_els_is_request ( els ) ) {
fc_ulp_logout ( ulp, -EACCES );
} else {
/* This is just an information-gathering PRLI; do not
* log in or out
*/
}
}
/* Transmit response, if applicable */
if ( ! fc_els_is_request ( els ) ) {
if ( ( rc = els->handler->tx ( els ) ) != 0 )
goto err_tx;
}
/* Drop temporary reference to ULP */
fc_ulp_put ( ulp );
return 0;
err_tx:
err_login:
err_link:
fc_ulp_put ( ulp );
err_get_port_id_type:
err_sanity:
return rc;
}
/**
* Detect PRLI
*
* @v els Fibre Channel ELS transaction
* @v descriptor ELS PRLI descriptor
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
int fc_els_prli_detect ( struct fc_els *els __unused,
struct fc_els_prli_descriptor *descriptor,
const void *data, size_t len ) {
const struct {
struct fc_prli_frame frame;
uint8_t param[descriptor->param_len];
} __attribute__ (( packed )) *prli = data;
/* Check for PRLI */
if ( prli->frame.command != FC_ELS_PRLI )
return -EINVAL;
/* Check for sufficient length to contain service parameter page */
if ( len < sizeof ( *prli ) )
return -EINVAL;
/* Check for upper-layer protocol type */
if ( prli->frame.page.type != descriptor->type )
return -EINVAL;
return 0;
}
/**
* Create PRLI request
*
* @v parent Parent interface
* @v port Fibre Channel port
* @v peer_port_id Peer port ID
* @v type Upper-layer protocol type
* @ret rc Return status code
*/
int fc_els_prli ( struct interface *parent, struct fc_port *port,
struct fc_port_id *peer_port_id, unsigned int type ) {
struct fc_els_prli_descriptor *descriptor;
/* Find a PRLI descriptor */
descriptor = fc_els_prli_descriptor ( type );
if ( ! descriptor )
return -ENOTSUP;
return fc_els_request ( parent, port, peer_port_id,
descriptor->handler );
}
/******************************************************************************
*
* RTV
*
******************************************************************************
*/
/**
* Transmit RTV response
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_rtv_tx_response ( struct fc_els *els ) {
struct fc_rtv_response_frame rtv;
/* Construct RTV */
memset ( &rtv, 0, sizeof ( rtv ) );
rtv.command = FC_ELS_LS_ACC;
rtv.e_d_tov = htonl ( FC_LOGIN_DEFAULT_E_D_TOV );
/* Transmit RTV */
return fc_els_tx ( els, &rtv, sizeof ( rtv ) );
}
/**
* Receive RTV
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_rtv_rx ( struct fc_els *els, void *data __unused,
size_t len __unused ) {
int rc;
DBGC ( els, FCELS_FMT "\n", FCELS_ARGS ( els ) );
/* Transmit response */
if ( ! fc_els_is_request ( els ) ) {
if ( ( rc = fc_els_rtv_tx_response ( els ) ) != 0 )
return rc;
}
return 0;
}
/**
* Detect RTV
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_rtv_detect ( struct fc_els *els __unused, const void *data,
size_t len __unused ) {
const struct fc_rtv_request_frame *rtv = data;
/* Check for RTV */
if ( rtv->command != FC_ELS_RTV )
return -EINVAL;
return 0;
}
/** RTV ELS handler */
struct fc_els_handler fc_els_rtv_handler __fc_els_handler = {
.name = "RTV",
.tx = fc_els_unknown_tx,
.rx = fc_els_rtv_rx,
.detect = fc_els_rtv_detect,
};
/******************************************************************************
*
* ECHO
*
******************************************************************************
*/
/** ECHO request data */
struct fc_echo_request_frame {
/** ECHO frame header */
struct fc_echo_frame_header echo;
/** Magic marker */
uint32_t magic;
} __attribute__ (( packed ));
/** ECHO magic marker */
#define FC_ECHO_MAGIC 0x69505845
/**
* Transmit ECHO
*
* @v els Fibre Channel ELS transaction
* @ret rc Return status code
*/
static int fc_els_echo_tx ( struct fc_els *els ) {
struct fc_echo_request_frame echo;
/* Construct ECHO */
memset ( &echo, 0, sizeof ( echo ) );
echo.echo.command = FC_ELS_ECHO;
echo.magic = htonl ( FC_ECHO_MAGIC );
/* Transmit ECHO */
return fc_els_tx ( els, &echo, sizeof ( echo ) );
}
/**
* Receive ECHO request
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_echo_rx_request ( struct fc_els *els, void *data,
size_t len ) {
struct {
struct fc_echo_frame_header echo;
char payload[ len - sizeof ( struct fc_echo_frame_header ) ];
} *echo = data;
int rc;
DBGC ( els, FCELS_FMT "\n", FCELS_ARGS ( els ) );
/* Transmit response */
echo->echo.command = FC_ELS_LS_ACC;
if ( ( rc = fc_els_tx ( els, echo, sizeof ( *echo ) ) ) != 0 )
return rc;
/* Nothing to do */
return 0;
}
/**
* Receive ECHO response
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_echo_rx_response ( struct fc_els *els, void *data,
size_t len ) {
struct fc_echo_request_frame *echo = data;
DBGC ( els, FCELS_FMT "\n", FCELS_ARGS ( els ) );
/* Check response is correct */
if ( ( len != sizeof ( *echo ) ) ||
( echo->magic != htonl ( FC_ECHO_MAGIC ) ) ) {
DBGC ( els, FCELS_FMT " received bad echo response\n",
FCELS_ARGS ( els ) );
DBGC_HDA ( els, 0, data, len );
return -EIO;
}
return 0;
}
/**
* Receive ECHO
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_echo_rx ( struct fc_els *els, void *data, size_t len ) {
if ( fc_els_is_request ( els ) ) {
return fc_els_echo_rx_response ( els, data, len );
} else {
return fc_els_echo_rx_request ( els, data, len );
}
}
/**
* Detect ECHO
*
* @v els Fibre Channel ELS transaction
* @v data ELS frame
* @v len Length of ELS frame
* @ret rc Return status code
*/
static int fc_els_echo_detect ( struct fc_els *els __unused, const void *data,
size_t len __unused ) {
const struct fc_echo_frame_header *echo = data;
/* Check for ECHO */
if ( echo->command != FC_ELS_ECHO )
return -EINVAL;
return 0;
}
/** ECHO ELS handler */
struct fc_els_handler fc_els_echo_handler __fc_els_handler = {
.name = "ECHO",
.tx = fc_els_echo_tx,
.rx = fc_els_echo_rx,
.detect = fc_els_echo_detect,
};