--- /dev/null
+/*
+ * 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.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER );
+
+#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,
+};
Code Review / kvmfornfv.git / blobdiff