diff --git a/fcoe-sparc.patch b/fcoe-sparc.patch new file mode 100644 index 0000000..eafc0a2 --- /dev/null +++ b/fcoe-sparc.patch @@ -0,0 +1,1494 @@ +diff -Naurd fcoe-utils-1.0.14.orig/fcnsq.c fcoe-utils-1.0.14/fcnsq.c +--- fcoe-utils-1.0.14.orig/fcnsq.c 2010-05-18 23:50:48.000000000 +0200 ++++ fcoe-utils-1.0.14/fcnsq.c 2011-02-23 15:05:18.289429317 +0100 +@@ -39,9 +39,9 @@ + typedef __u64 u64; + #include + #include +-#include +-#include +-#include ++#include "fc_gs.h" ++#include "fc_ns.h" ++#include "scsi_bsg_fc.h" + + static bool quiet = false; + +diff -Naurd fcoe-utils-1.0.14.orig/fcping.c fcoe-utils-1.0.14/fcping.c +--- fcoe-utils-1.0.14.orig/fcping.c 2010-05-18 23:50:48.000000000 +0200 ++++ fcoe-utils-1.0.14/fcping.c 2011-02-23 15:05:18.289429317 +0100 +@@ -49,10 +49,10 @@ + #include "fc_types.h" + typedef uint8_t u8; + #include +-#include +-#include +-#include +-#include ++#include "fc_ns.h" ++#include "fc_gs.h" ++#include "fc_els.h" ++#include "scsi_bsg_fc.h" + + #include "fcoe_utils.h" + +diff -Naurd fcoe-utils-1.0.14.orig/fcrls.c fcoe-utils-1.0.14/fcrls.c +--- fcoe-utils-1.0.14.orig/fcrls.c 2010-05-18 23:50:48.000000000 +0200 ++++ fcoe-utils-1.0.14/fcrls.c 2011-02-23 15:05:34.781471067 +0100 +@@ -40,8 +40,8 @@ + typedef __u64 u64; + #include + #include +-#include +-#include ++#include "fc_els.h" ++#include "scsi_bsg_fc.h" + + #define ntoh24(n) (u32) ((n)[0] << 16 | (n)[1] << 8 | (n)[2]) + #define hton24(h) { (h) >> 16 & 0xff, (h) >> 8 & 0xff, (h) & 0xff } +diff -Naurd fcoe-utils-1.0.14.orig/include/fc_els.h fcoe-utils-1.0.14/include/fc_els.h +--- fcoe-utils-1.0.14.orig/include/fc_els.h 1970-01-01 01:00:00.000000000 +0100 ++++ fcoe-utils-1.0.14/include/fc_els.h 2011-02-23 15:05:18.302052163 +0100 +@@ -0,0 +1,820 @@ ++/* ++ * Copyright(c) 2007 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU General Public License, ++ * version 2, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope 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 St - Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Maintained at www.Open-FCoE.org ++ */ ++ ++#ifndef _FC_ELS_H_ ++#define _FC_ELS_H_ ++ ++#include ++ ++/* ++ * Fibre Channel Switch - Enhanced Link Services definitions. ++ * From T11 FC-LS Rev 1.2 June 7, 2005. ++ */ ++ ++/* ++ * ELS Command codes - byte 0 of the frame payload ++ */ ++enum fc_els_cmd { ++ ELS_LS_RJT = 0x01, /* ESL reject */ ++ ELS_LS_ACC = 0x02, /* ESL Accept */ ++ ELS_PLOGI = 0x03, /* N_Port login */ ++ ELS_FLOGI = 0x04, /* F_Port login */ ++ ELS_LOGO = 0x05, /* Logout */ ++ ELS_ABTX = 0x06, /* Abort exchange - obsolete */ ++ ELS_RCS = 0x07, /* read connection status */ ++ ELS_RES = 0x08, /* read exchange status block */ ++ ELS_RSS = 0x09, /* read sequence status block */ ++ ELS_RSI = 0x0a, /* read sequence initiative */ ++ ELS_ESTS = 0x0b, /* establish streaming */ ++ ELS_ESTC = 0x0c, /* estimate credit */ ++ ELS_ADVC = 0x0d, /* advise credit */ ++ ELS_RTV = 0x0e, /* read timeout value */ ++ ELS_RLS = 0x0f, /* read link error status block */ ++ ELS_ECHO = 0x10, /* echo */ ++ ELS_TEST = 0x11, /* test */ ++ ELS_RRQ = 0x12, /* reinstate recovery qualifier */ ++ ELS_REC = 0x13, /* read exchange concise */ ++ ELS_SRR = 0x14, /* sequence retransmission request */ ++ ELS_PRLI = 0x20, /* process login */ ++ ELS_PRLO = 0x21, /* process logout */ ++ ELS_SCN = 0x22, /* state change notification */ ++ ELS_TPLS = 0x23, /* test process login state */ ++ ELS_TPRLO = 0x24, /* third party process logout */ ++ ELS_LCLM = 0x25, /* login control list mgmt (obs) */ ++ ELS_GAID = 0x30, /* get alias_ID */ ++ ELS_FACT = 0x31, /* fabric activate alias_id */ ++ ELS_FDACDT = 0x32, /* fabric deactivate alias_id */ ++ ELS_NACT = 0x33, /* N-port activate alias_id */ ++ ELS_NDACT = 0x34, /* N-port deactivate alias_id */ ++ ELS_QOSR = 0x40, /* quality of service request */ ++ ELS_RVCS = 0x41, /* read virtual circuit status */ ++ ELS_PDISC = 0x50, /* discover N_port service params */ ++ ELS_FDISC = 0x51, /* discover F_port service params */ ++ ELS_ADISC = 0x52, /* discover address */ ++ ELS_RNC = 0x53, /* report node cap (obs) */ ++ ELS_FARP_REQ = 0x54, /* FC ARP request */ ++ ELS_FARP_REPL = 0x55, /* FC ARP reply */ ++ ELS_RPS = 0x56, /* read port status block */ ++ ELS_RPL = 0x57, /* read port list */ ++ ELS_RPBC = 0x58, /* read port buffer condition */ ++ ELS_FAN = 0x60, /* fabric address notification */ ++ ELS_RSCN = 0x61, /* registered state change notification */ ++ ELS_SCR = 0x62, /* state change registration */ ++ ELS_RNFT = 0x63, /* report node FC-4 types */ ++ ELS_CSR = 0x68, /* clock synch. request */ ++ ELS_CSU = 0x69, /* clock synch. update */ ++ ELS_LINIT = 0x70, /* loop initialize */ ++ ELS_LSTS = 0x72, /* loop status */ ++ ELS_RNID = 0x78, /* request node ID data */ ++ ELS_RLIR = 0x79, /* registered link incident report */ ++ ELS_LIRR = 0x7a, /* link incident record registration */ ++ ELS_SRL = 0x7b, /* scan remote loop */ ++ ELS_SBRP = 0x7c, /* set bit-error reporting params */ ++ ELS_RPSC = 0x7d, /* report speed capabilities */ ++ ELS_QSA = 0x7e, /* query security attributes */ ++ ELS_EVFP = 0x7f, /* exchange virt. fabrics params */ ++ ELS_LKA = 0x80, /* link keep-alive */ ++ ELS_AUTH_ELS = 0x90, /* authentication ELS */ ++}; ++ ++/* ++ * Initializer useful for decoding table. ++ * Please keep this in sync with the above definitions. ++ */ ++#define FC_ELS_CMDS_INIT { \ ++ [ELS_LS_RJT] = "LS_RJT", \ ++ [ELS_LS_ACC] = "LS_ACC", \ ++ [ELS_PLOGI] = "PLOGI", \ ++ [ELS_FLOGI] = "FLOGI", \ ++ [ELS_LOGO] = "LOGO", \ ++ [ELS_ABTX] = "ABTX", \ ++ [ELS_RCS] = "RCS", \ ++ [ELS_RES] = "RES", \ ++ [ELS_RSS] = "RSS", \ ++ [ELS_RSI] = "RSI", \ ++ [ELS_ESTS] = "ESTS", \ ++ [ELS_ESTC] = "ESTC", \ ++ [ELS_ADVC] = "ADVC", \ ++ [ELS_RTV] = "RTV", \ ++ [ELS_RLS] = "RLS", \ ++ [ELS_ECHO] = "ECHO", \ ++ [ELS_TEST] = "TEST", \ ++ [ELS_RRQ] = "RRQ", \ ++ [ELS_REC] = "REC", \ ++ [ELS_SRR] = "SRR", \ ++ [ELS_PRLI] = "PRLI", \ ++ [ELS_PRLO] = "PRLO", \ ++ [ELS_SCN] = "SCN", \ ++ [ELS_TPLS] = "TPLS", \ ++ [ELS_TPRLO] = "TPRLO", \ ++ [ELS_LCLM] = "LCLM", \ ++ [ELS_GAID] = "GAID", \ ++ [ELS_FACT] = "FACT", \ ++ [ELS_FDACDT] = "FDACDT", \ ++ [ELS_NACT] = "NACT", \ ++ [ELS_NDACT] = "NDACT", \ ++ [ELS_QOSR] = "QOSR", \ ++ [ELS_RVCS] = "RVCS", \ ++ [ELS_PDISC] = "PDISC", \ ++ [ELS_FDISC] = "FDISC", \ ++ [ELS_ADISC] = "ADISC", \ ++ [ELS_RNC] = "RNC", \ ++ [ELS_FARP_REQ] = "FARP_REQ", \ ++ [ELS_FARP_REPL] = "FARP_REPL", \ ++ [ELS_RPS] = "RPS", \ ++ [ELS_RPL] = "RPL", \ ++ [ELS_RPBC] = "RPBC", \ ++ [ELS_FAN] = "FAN", \ ++ [ELS_RSCN] = "RSCN", \ ++ [ELS_SCR] = "SCR", \ ++ [ELS_RNFT] = "RNFT", \ ++ [ELS_CSR] = "CSR", \ ++ [ELS_CSU] = "CSU", \ ++ [ELS_LINIT] = "LINIT", \ ++ [ELS_LSTS] = "LSTS", \ ++ [ELS_RNID] = "RNID", \ ++ [ELS_RLIR] = "RLIR", \ ++ [ELS_LIRR] = "LIRR", \ ++ [ELS_SRL] = "SRL", \ ++ [ELS_SBRP] = "SBRP", \ ++ [ELS_RPSC] = "RPSC", \ ++ [ELS_QSA] = "QSA", \ ++ [ELS_EVFP] = "EVFP", \ ++ [ELS_LKA] = "LKA", \ ++ [ELS_AUTH_ELS] = "AUTH_ELS", \ ++} ++ ++/* ++ * LS_ACC payload. ++ */ ++struct fc_els_ls_acc { ++ __u8 la_cmd; /* command code ELS_LS_ACC */ ++ __u8 la_resv[3]; /* reserved */ ++}; ++ ++/* ++ * ELS reject payload. ++ */ ++struct fc_els_ls_rjt { ++ __u8 er_cmd; /* command code ELS_LS_RJT */ ++ __u8 er_resv[4]; /* reserved must be zero */ ++ __u8 er_reason; /* reason (enum fc_els_rjt_reason below) */ ++ __u8 er_explan; /* explanation (enum fc_els_rjt_explan below) */ ++ __u8 er_vendor; /* vendor specific code */ ++}; ++ ++/* ++ * ELS reject reason codes (er_reason). ++ */ ++enum fc_els_rjt_reason { ++ ELS_RJT_NONE = 0, /* no reject - not to be sent */ ++ ELS_RJT_INVAL = 0x01, /* invalid ELS command code */ ++ ELS_RJT_LOGIC = 0x03, /* logical error */ ++ ELS_RJT_BUSY = 0x05, /* logical busy */ ++ ELS_RJT_PROT = 0x07, /* protocol error */ ++ ELS_RJT_UNAB = 0x09, /* unable to perform command request */ ++ ELS_RJT_UNSUP = 0x0b, /* command not supported */ ++ ELS_RJT_INPROG = 0x0e, /* command already in progress */ ++ ELS_RJT_VENDOR = 0xff, /* vendor specific error */ ++}; ++ ++ ++/* ++ * reason code explanation (er_explan). ++ */ ++enum fc_els_rjt_explan { ++ ELS_EXPL_NONE = 0x00, /* No additional explanation */ ++ ELS_EXPL_SPP_OPT_ERR = 0x01, /* service parameter error - options */ ++ ELS_EXPL_SPP_ICTL_ERR = 0x03, /* service parm error - initiator ctl */ ++ ELS_EXPL_AH = 0x11, /* invalid association header */ ++ ELS_EXPL_AH_REQ = 0x13, /* association_header required */ ++ ELS_EXPL_SID = 0x15, /* invalid originator S_ID */ ++ ELS_EXPL_OXID_RXID = 0x17, /* invalid OX_ID-RX_ID combination */ ++ ELS_EXPL_INPROG = 0x19, /* Request already in progress */ ++ ELS_EXPL_PLOGI_REQD = 0x1e, /* N_Port login required */ ++ ELS_EXPL_INSUF_RES = 0x29, /* insufficient resources */ ++ ELS_EXPL_UNAB_DATA = 0x2a, /* unable to supply requested data */ ++ ELS_EXPL_UNSUPR = 0x2c, /* Request not supported */ ++ ELS_EXPL_INV_LEN = 0x2d, /* Invalid payload length */ ++ /* TBD - above definitions incomplete */ ++}; ++ ++/* ++ * Common service parameters (N ports). ++ */ ++struct fc_els_csp { ++ __u8 sp_hi_ver; /* highest version supported (obs.) */ ++ __u8 sp_lo_ver; /* highest version supported (obs.) */ ++ __be16 sp_bb_cred; /* buffer-to-buffer credits */ ++ __be16 sp_features; /* common feature flags */ ++ __be16 sp_bb_data; /* b-b state number and data field sz */ ++ union { ++ struct { ++ __be16 _sp_tot_seq; /* total concurrent sequences */ ++ __be16 _sp_rel_off; /* rel. offset by info cat */ ++ } sp_plogi; ++ struct { ++ __be32 _sp_r_a_tov; /* resource alloc. timeout msec */ ++ } sp_flogi_acc; ++ } sp_u; ++ __be32 sp_e_d_tov; /* error detect timeout value */ ++}; ++#define sp_tot_seq sp_u.sp_plogi._sp_tot_seq ++#define sp_rel_off sp_u.sp_plogi._sp_rel_off ++#define sp_r_a_tov sp_u.sp_flogi_acc._sp_r_a_tov ++ ++#define FC_SP_BB_DATA_MASK 0xfff /* mask for data field size in sp_bb_data */ ++ ++/* ++ * Minimum and maximum values for max data field size in service parameters. ++ */ ++#define FC_SP_MIN_MAX_PAYLOAD FC_MIN_MAX_PAYLOAD ++#define FC_SP_MAX_MAX_PAYLOAD FC_MAX_PAYLOAD ++ ++/* ++ * sp_features ++ */ ++#define FC_SP_FT_NPIV 0x8000 /* multiple N_Port_ID support (FLOGI) */ ++#define FC_SP_FT_CIRO 0x8000 /* continuously increasing rel off (PLOGI) */ ++#define FC_SP_FT_CLAD 0x8000 /* clean address (in FLOGI LS_ACC) */ ++#define FC_SP_FT_RAND 0x4000 /* random relative offset */ ++#define FC_SP_FT_VAL 0x2000 /* valid vendor version level */ ++#define FC_SP_FT_NPIV_ACC 0x2000 /* NPIV assignment (FLOGI LS_ACC) */ ++#define FC_SP_FT_FPORT 0x1000 /* F port (1) vs. N port (0) */ ++#define FC_SP_FT_ABB 0x0800 /* alternate BB_credit management */ ++#define FC_SP_FT_EDTR 0x0400 /* E_D_TOV Resolution is nanoseconds */ ++#define FC_SP_FT_MCAST 0x0200 /* multicast */ ++#define FC_SP_FT_BCAST 0x0100 /* broadcast */ ++#define FC_SP_FT_HUNT 0x0080 /* hunt group */ ++#define FC_SP_FT_SIMP 0x0040 /* dedicated simplex */ ++#define FC_SP_FT_SEC 0x0020 /* reserved for security */ ++#define FC_SP_FT_CSYN 0x0010 /* clock synch. supported */ ++#define FC_SP_FT_RTTOV 0x0008 /* R_T_TOV value 100 uS, else 100 mS */ ++#define FC_SP_FT_HALF 0x0004 /* dynamic half duplex */ ++#define FC_SP_FT_SEQC 0x0002 /* SEQ_CNT */ ++#define FC_SP_FT_PAYL 0x0001 /* FLOGI payload length 256, else 116 */ ++ ++/* ++ * Class-specific service parameters. ++ */ ++struct fc_els_cssp { ++ __be16 cp_class; /* class flags */ ++ __be16 cp_init; /* initiator flags */ ++ __be16 cp_recip; /* recipient flags */ ++ __be16 cp_rdfs; /* receive data field size */ ++ __be16 cp_con_seq; /* concurrent sequences */ ++ __be16 cp_ee_cred; /* N-port end-to-end credit */ ++ __u8 cp_resv1; /* reserved */ ++ __u8 cp_open_seq; /* open sequences per exchange */ ++ __u8 _cp_resv2[2]; /* reserved */ ++}; ++ ++/* ++ * cp_class flags. ++ */ ++#define FC_CPC_VALID 0x8000 /* class valid */ ++#define FC_CPC_IMIX 0x4000 /* intermix mode */ ++#define FC_CPC_SEQ 0x0800 /* sequential delivery */ ++#define FC_CPC_CAMP 0x0200 /* camp-on */ ++#define FC_CPC_PRI 0x0080 /* priority */ ++ ++/* ++ * cp_init flags. ++ * (TBD: not all flags defined here). ++ */ ++#define FC_CPI_CSYN 0x0010 /* clock synch. capable */ ++ ++/* ++ * cp_recip flags. ++ */ ++#define FC_CPR_CSYN 0x0008 /* clock synch. capable */ ++ ++/* ++ * NFC_ELS_FLOGI: Fabric login request. ++ * NFC_ELS_PLOGI: Port login request (same format). ++ */ ++struct fc_els_flogi { ++ __u8 fl_cmd; /* command */ ++ __u8 _fl_resvd[3]; /* must be zero */ ++ struct fc_els_csp fl_csp; /* common service parameters */ ++ __be64 fl_wwpn; /* port name */ ++ __be64 fl_wwnn; /* node name */ ++ struct fc_els_cssp fl_cssp[4]; /* class 1-4 service parameters */ ++ __u8 fl_vend[16]; /* vendor version level */ ++} __attribute__((__packed__)); ++ ++/* ++ * Process login service parameter page. ++ */ ++struct fc_els_spp { ++ __u8 spp_type; /* type code or common service params */ ++ __u8 spp_type_ext; /* type code extension */ ++ __u8 spp_flags; ++ __u8 _spp_resvd; ++ __be32 spp_orig_pa; /* originator process associator */ ++ __be32 spp_resp_pa; /* responder process associator */ ++ __be32 spp_params; /* service parameters */ ++}; ++ ++/* ++ * spp_flags. ++ */ ++#define FC_SPP_OPA_VAL 0x80 /* originator proc. assoc. valid */ ++#define FC_SPP_RPA_VAL 0x40 /* responder proc. assoc. valid */ ++#define FC_SPP_EST_IMG_PAIR 0x20 /* establish image pair */ ++#define FC_SPP_RESP_MASK 0x0f /* mask for response code (below) */ ++ ++/* ++ * SPP response code in spp_flags - lower 4 bits. ++ */ ++enum fc_els_spp_resp { ++ FC_SPP_RESP_ACK = 1, /* request executed */ ++ FC_SPP_RESP_RES = 2, /* unable due to lack of resources */ ++ FC_SPP_RESP_INIT = 3, /* initialization not complete */ ++ FC_SPP_RESP_NO_PA = 4, /* unknown process associator */ ++ FC_SPP_RESP_CONF = 5, /* configuration precludes image pair */ ++ FC_SPP_RESP_COND = 6, /* request completed conditionally */ ++ FC_SPP_RESP_MULT = 7, /* unable to handle multiple SPPs */ ++ FC_SPP_RESP_INVL = 8, /* SPP is invalid */ ++}; ++ ++/* ++ * ELS_RRQ - Reinstate Recovery Qualifier ++ */ ++struct fc_els_rrq { ++ __u8 rrq_cmd; /* command (0x12) */ ++ __u8 rrq_zero[3]; /* specified as zero - part of cmd */ ++ __u8 rrq_resvd; /* reserved */ ++ __u8 rrq_s_id[3]; /* originator FID */ ++ __be16 rrq_ox_id; /* originator exchange ID */ ++ __be16 rrq_rx_id; /* responders exchange ID */ ++}; ++ ++/* ++ * ELS_REC - Read exchange concise. ++ */ ++struct fc_els_rec { ++ __u8 rec_cmd; /* command (0x13) */ ++ __u8 rec_zero[3]; /* specified as zero - part of cmd */ ++ __u8 rec_resvd; /* reserved */ ++ __u8 rec_s_id[3]; /* originator FID */ ++ __be16 rec_ox_id; /* originator exchange ID */ ++ __be16 rec_rx_id; /* responders exchange ID */ ++}; ++ ++/* ++ * ELS_REC LS_ACC payload. ++ */ ++struct fc_els_rec_acc { ++ __u8 reca_cmd; /* accept (0x02) */ ++ __u8 reca_zero[3]; /* specified as zero - part of cmd */ ++ __be16 reca_ox_id; /* originator exchange ID */ ++ __be16 reca_rx_id; /* responders exchange ID */ ++ __u8 reca_resvd1; /* reserved */ ++ __u8 reca_ofid[3]; /* originator FID */ ++ __u8 reca_resvd2; /* reserved */ ++ __u8 reca_rfid[3]; /* responder FID */ ++ __be32 reca_fc4value; /* FC4 value */ ++ __be32 reca_e_stat; /* ESB (exchange status block) status */ ++}; ++ ++/* ++ * ELS_PRLI - Process login request and response. ++ */ ++struct fc_els_prli { ++ __u8 prli_cmd; /* command */ ++ __u8 prli_spp_len; /* length of each serv. parm. page */ ++ __be16 prli_len; /* length of entire payload */ ++ /* service parameter pages follow */ ++}; ++ ++/* ++ * ELS_ADISC payload ++ */ ++struct fc_els_adisc { ++ __u8 adisc_cmd; ++ __u8 adisc_resv[3]; ++ __u8 adisc_resv1; ++ __u8 adisc_hard_addr[3]; ++ __be64 adisc_wwpn; ++ __be64 adisc_wwnn; ++ __u8 adisc_resv2; ++ __u8 adisc_port_id[3]; ++} __attribute__((__packed__)); ++ ++/* ++ * ELS_LOGO - process or fabric logout. ++ */ ++struct fc_els_logo { ++ __u8 fl_cmd; /* command code */ ++ __u8 fl_zero[3]; /* specified as zero - part of cmd */ ++ __u8 fl_resvd; /* reserved */ ++ __u8 fl_n_port_id[3];/* N port ID */ ++ __be64 fl_n_port_wwn; /* port name */ ++}; ++ ++/* ++ * ELS_RTV - read timeout value. ++ */ ++struct fc_els_rtv { ++ __u8 rtv_cmd; /* command code 0x0e */ ++ __u8 rtv_zero[3]; /* specified as zero - part of cmd */ ++}; ++ ++/* ++ * LS_ACC for ELS_RTV - read timeout value. ++ */ ++struct fc_els_rtv_acc { ++ __u8 rtv_cmd; /* command code 0x02 */ ++ __u8 rtv_zero[3]; /* specified as zero - part of cmd */ ++ __be32 rtv_r_a_tov; /* resource allocation timeout value */ ++ __be32 rtv_e_d_tov; /* error detection timeout value */ ++ __be32 rtv_toq; /* timeout qualifier (see below) */ ++}; ++ ++/* ++ * rtv_toq bits. ++ */ ++#define FC_ELS_RTV_EDRES (1 << 26) /* E_D_TOV resolution is nS else mS */ ++#define FC_ELS_RTV_RTTOV (1 << 19) /* R_T_TOV is 100 uS else 100 mS */ ++ ++/* ++ * ELS_SCR - state change registration payload. ++ */ ++struct fc_els_scr { ++ __u8 scr_cmd; /* command code */ ++ __u8 scr_resv[6]; /* reserved */ ++ __u8 scr_reg_func; /* registration function (see below) */ ++}; ++ ++enum fc_els_scr_func { ++ ELS_SCRF_FAB = 1, /* fabric-detected registration */ ++ ELS_SCRF_NPORT = 2, /* Nx_Port-detected registration */ ++ ELS_SCRF_FULL = 3, /* full registration */ ++ ELS_SCRF_CLEAR = 255, /* remove any current registrations */ ++}; ++ ++/* ++ * ELS_RSCN - registered state change notification payload. ++ */ ++struct fc_els_rscn { ++ __u8 rscn_cmd; /* RSCN opcode (0x61) */ ++ __u8 rscn_page_len; /* page length (4) */ ++ __be16 rscn_plen; /* payload length including this word */ ++ ++ /* followed by 4-byte generic affected Port_ID pages */ ++}; ++ ++struct fc_els_rscn_page { ++ __u8 rscn_page_flags; /* event and address format */ ++ __u8 rscn_fid[3]; /* fabric ID */ ++}; ++ ++#define ELS_RSCN_EV_QUAL_BIT 2 /* shift count for event qualifier */ ++#define ELS_RSCN_EV_QUAL_MASK 0xf /* mask for event qualifier */ ++#define ELS_RSCN_ADDR_FMT_BIT 0 /* shift count for address format */ ++#define ELS_RSCN_ADDR_FMT_MASK 0x3 /* mask for address format */ ++ ++enum fc_els_rscn_ev_qual { ++ ELS_EV_QUAL_NONE = 0, /* unspecified */ ++ ELS_EV_QUAL_NS_OBJ = 1, /* changed name server object */ ++ ELS_EV_QUAL_PORT_ATTR = 2, /* changed port attribute */ ++ ELS_EV_QUAL_SERV_OBJ = 3, /* changed service object */ ++ ELS_EV_QUAL_SW_CONFIG = 4, /* changed switch configuration */ ++ ELS_EV_QUAL_REM_OBJ = 5, /* removed object */ ++}; ++ ++enum fc_els_rscn_addr_fmt { ++ ELS_ADDR_FMT_PORT = 0, /* rscn_fid is a port address */ ++ ELS_ADDR_FMT_AREA = 1, /* rscn_fid is a area address */ ++ ELS_ADDR_FMT_DOM = 2, /* rscn_fid is a domain address */ ++ ELS_ADDR_FMT_FAB = 3, /* anything on fabric may have changed */ ++}; ++ ++/* ++ * ELS_RNID - request Node ID. ++ */ ++struct fc_els_rnid { ++ __u8 rnid_cmd; /* RNID opcode (0x78) */ ++ __u8 rnid_resv[3]; /* reserved */ ++ __u8 rnid_fmt; /* data format */ ++ __u8 rnid_resv2[3]; /* reserved */ ++}; ++ ++/* ++ * Node Identification Data formats (rnid_fmt) ++ */ ++enum fc_els_rnid_fmt { ++ ELS_RNIDF_NONE = 0, /* no specific identification data */ ++ ELS_RNIDF_GEN = 0xdf, /* general topology discovery format */ ++}; ++ ++/* ++ * ELS_RNID response. ++ */ ++struct fc_els_rnid_resp { ++ __u8 rnid_cmd; /* response code (LS_ACC) */ ++ __u8 rnid_resv[3]; /* reserved */ ++ __u8 rnid_fmt; /* data format */ ++ __u8 rnid_cid_len; /* common ID data length */ ++ __u8 rnid_resv2; /* reserved */ ++ __u8 rnid_sid_len; /* specific ID data length */ ++}; ++ ++struct fc_els_rnid_cid { ++ __be64 rnid_wwpn; /* N port name */ ++ __be64 rnid_wwnn; /* node name */ ++}; ++ ++struct fc_els_rnid_gen { ++ __u8 rnid_vend_id[16]; /* vendor-unique ID */ ++ __be32 rnid_atype; /* associated type (see below) */ ++ __be32 rnid_phys_port; /* physical port number */ ++ __be32 rnid_att_nodes; /* number of attached nodes */ ++ __u8 rnid_node_mgmt; /* node management (see below) */ ++ __u8 rnid_ip_ver; /* IP version (see below) */ ++ __be16 rnid_prot_port; /* UDP / TCP port number */ ++ __be32 rnid_ip_addr[4]; /* IP address */ ++ __u8 rnid_resvd[2]; /* reserved */ ++ __be16 rnid_vend_spec; /* vendor-specific field */ ++}; ++ ++enum fc_els_rnid_atype { ++ ELS_RNIDA_UNK = 0x01, /* unknown */ ++ ELS_RNIDA_OTHER = 0x02, /* none of the following */ ++ ELS_RNIDA_HUB = 0x03, ++ ELS_RNIDA_SWITCH = 0x04, ++ ELS_RNIDA_GATEWAY = 0x05, ++ ELS_RNIDA_CONV = 0x06, /* Obsolete, do not use this value */ ++ ELS_RNIDA_HBA = 0x07, /* Obsolete, do not use this value */ ++ ELS_RNIDA_PROXY = 0x08, /* Obsolete, do not use this value */ ++ ELS_RNIDA_STORAGE = 0x09, ++ ELS_RNIDA_HOST = 0x0a, ++ ELS_RNIDA_SUBSYS = 0x0b, /* storage subsystem (e.g., RAID) */ ++ ELS_RNIDA_ACCESS = 0x0e, /* access device (e.g. media changer) */ ++ ELS_RNIDA_NAS = 0x11, /* NAS server */ ++ ELS_RNIDA_BRIDGE = 0x12, /* bridge */ ++ ELS_RNIDA_VIRT = 0x13, /* virtualization device */ ++ ELS_RNIDA_MF = 0xff, /* multifunction device (bits below) */ ++ ELS_RNIDA_MF_HUB = 1UL << 31, /* hub */ ++ ELS_RNIDA_MF_SW = 1UL << 30, /* switch */ ++ ELS_RNIDA_MF_GW = 1UL << 29, /* gateway */ ++ ELS_RNIDA_MF_ST = 1UL << 28, /* storage */ ++ ELS_RNIDA_MF_HOST = 1UL << 27, /* host */ ++ ELS_RNIDA_MF_SUB = 1UL << 26, /* storage subsystem */ ++ ELS_RNIDA_MF_ACC = 1UL << 25, /* storage access dev */ ++ ELS_RNIDA_MF_WDM = 1UL << 24, /* wavelength division mux */ ++ ELS_RNIDA_MF_NAS = 1UL << 23, /* NAS server */ ++ ELS_RNIDA_MF_BR = 1UL << 22, /* bridge */ ++ ELS_RNIDA_MF_VIRT = 1UL << 21, /* virtualization device */ ++}; ++ ++enum fc_els_rnid_mgmt { ++ ELS_RNIDM_SNMP = 0, ++ ELS_RNIDM_TELNET = 1, ++ ELS_RNIDM_HTTP = 2, ++ ELS_RNIDM_HTTPS = 3, ++ ELS_RNIDM_XML = 4, /* HTTP + XML */ ++}; ++ ++enum fc_els_rnid_ipver { ++ ELS_RNIDIP_NONE = 0, /* no IP support or node mgmt. */ ++ ELS_RNIDIP_V4 = 1, /* IPv4 */ ++ ELS_RNIDIP_V6 = 2, /* IPv6 */ ++}; ++ ++/* ++ * ELS RPL - Read Port List. ++ */ ++struct fc_els_rpl { ++ __u8 rpl_cmd; /* command */ ++ __u8 rpl_resv[5]; /* reserved - must be zero */ ++ __be16 rpl_max_size; /* maximum response size or zero */ ++ __u8 rpl_resv1; /* reserved - must be zero */ ++ __u8 rpl_index[3]; /* starting index */ ++}; ++ ++/* ++ * Port number block in RPL response. ++ */ ++struct fc_els_pnb { ++ __be32 pnb_phys_pn; /* physical port number */ ++ __u8 pnb_resv; /* reserved */ ++ __u8 pnb_port_id[3]; /* port ID */ ++ __be64 pnb_wwpn; /* port name */ ++}; ++ ++/* ++ * RPL LS_ACC response. ++ */ ++struct fc_els_rpl_resp { ++ __u8 rpl_cmd; /* ELS_LS_ACC */ ++ __u8 rpl_resv1; /* reserved - must be zero */ ++ __be16 rpl_plen; /* payload length */ ++ __u8 rpl_resv2; /* reserved - must be zero */ ++ __u8 rpl_llen[3]; /* list length */ ++ __u8 rpl_resv3; /* reserved - must be zero */ ++ __u8 rpl_index[3]; /* starting index */ ++ struct fc_els_pnb rpl_pnb[1]; /* variable number of PNBs */ ++}; ++ ++/* ++ * Link Error Status Block. ++ */ ++struct fc_els_lesb { ++ __be32 lesb_link_fail; /* link failure count */ ++ __be32 lesb_sync_loss; /* loss of synchronization count */ ++ __be32 lesb_sig_loss; /* loss of signal count */ ++ __be32 lesb_prim_err; /* primitive sequence error count */ ++ __be32 lesb_inv_word; /* invalid transmission word count */ ++ __be32 lesb_inv_crc; /* invalid CRC count */ ++}; ++ ++/* ++ * ELS RPS - Read Port Status Block request. ++ */ ++struct fc_els_rps { ++ __u8 rps_cmd; /* command */ ++ __u8 rps_resv[2]; /* reserved - must be zero */ ++ __u8 rps_flag; /* flag - see below */ ++ __be64 rps_port_spec; /* port selection */ ++}; ++ ++enum fc_els_rps_flag { ++ FC_ELS_RPS_DID = 0x00, /* port identified by D_ID of req. */ ++ FC_ELS_RPS_PPN = 0x01, /* port_spec is physical port number */ ++ FC_ELS_RPS_WWPN = 0x02, /* port_spec is port WWN */ ++}; ++ ++/* ++ * ELS RPS LS_ACC response. ++ */ ++struct fc_els_rps_resp { ++ __u8 rps_cmd; /* command - LS_ACC */ ++ __u8 rps_resv[2]; /* reserved - must be zero */ ++ __u8 rps_flag; /* flag - see below */ ++ __u8 rps_resv2[2]; /* reserved */ ++ __be16 rps_status; /* port status - see below */ ++ struct fc_els_lesb rps_lesb; /* link error status block */ ++}; ++ ++enum fc_els_rps_resp_flag { ++ FC_ELS_RPS_LPEV = 0x01, /* L_port extension valid */ ++}; ++ ++enum fc_els_rps_resp_status { ++ FC_ELS_RPS_PTP = 1 << 5, /* point-to-point connection */ ++ FC_ELS_RPS_LOOP = 1 << 4, /* loop mode */ ++ FC_ELS_RPS_FAB = 1 << 3, /* fabric present */ ++ FC_ELS_RPS_NO_SIG = 1 << 2, /* loss of signal */ ++ FC_ELS_RPS_NO_SYNC = 1 << 1, /* loss of synchronization */ ++ FC_ELS_RPS_RESET = 1 << 0, /* in link reset protocol */ ++}; ++ ++/* ++ * ELS LIRR - Link Incident Record Registration request. ++ */ ++struct fc_els_lirr { ++ __u8 lirr_cmd; /* command */ ++ __u8 lirr_resv[3]; /* reserved - must be zero */ ++ __u8 lirr_func; /* registration function */ ++ __u8 lirr_fmt; /* FC-4 type of RLIR requested */ ++ __u8 lirr_resv2[2]; /* reserved - must be zero */ ++}; ++ ++enum fc_els_lirr_func { ++ ELS_LIRR_SET_COND = 0x01, /* set - conditionally receive */ ++ ELS_LIRR_SET_UNCOND = 0x02, /* set - unconditionally receive */ ++ ELS_LIRR_CLEAR = 0xff /* clear registration */ ++}; ++ ++/* ++ * ELS SRL - Scan Remote Loop request. ++ */ ++struct fc_els_srl { ++ __u8 srl_cmd; /* command */ ++ __u8 srl_resv[3]; /* reserved - must be zero */ ++ __u8 srl_flag; /* flag - see below */ ++ __u8 srl_flag_param[3]; /* flag parameter */ ++}; ++ ++enum fc_els_srl_flag { ++ FC_ELS_SRL_ALL = 0x00, /* scan all FL ports */ ++ FC_ELS_SRL_ONE = 0x01, /* scan specified loop */ ++ FC_ELS_SRL_EN_PER = 0x02, /* enable periodic scanning (param) */ ++ FC_ELS_SRL_DIS_PER = 0x03, /* disable periodic scanning */ ++}; ++ ++/* ++ * ELS RLS - Read Link Error Status Block request. ++ */ ++struct fc_els_rls { ++ __u8 rls_cmd; /* command */ ++ __u8 rls_resv[4]; /* reserved - must be zero */ ++ __u8 rls_port_id[3]; /* port ID */ ++}; ++ ++/* ++ * ELS RLS LS_ACC Response. ++ */ ++struct fc_els_rls_resp { ++ __u8 rls_cmd; /* ELS_LS_ACC */ ++ __u8 rls_resv[3]; /* reserved - must be zero */ ++ struct fc_els_lesb rls_lesb; /* link error status block */ ++}; ++ ++/* ++ * ELS RLIR - Registered Link Incident Report. ++ * This is followed by the CLIR and the CLID, described below. ++ */ ++struct fc_els_rlir { ++ __u8 rlir_cmd; /* command */ ++ __u8 rlir_resv[3]; /* reserved - must be zero */ ++ __u8 rlir_fmt; /* format (FC4-type if type specific) */ ++ __u8 rlir_clr_len; /* common link incident record length */ ++ __u8 rlir_cld_len; /* common link incident desc. length */ ++ __u8 rlir_slr_len; /* spec. link incident record length */ ++}; ++ ++/* ++ * CLIR - Common Link Incident Record Data. - Sent via RLIR. ++ */ ++struct fc_els_clir { ++ __be64 clir_wwpn; /* incident port name */ ++ __be64 clir_wwnn; /* incident port node name */ ++ __u8 clir_port_type; /* incident port type */ ++ __u8 clir_port_id[3]; /* incident port ID */ ++ ++ __be64 clir_conn_wwpn; /* connected port name */ ++ __be64 clir_conn_wwnn; /* connected node name */ ++ __be64 clir_fab_name; /* fabric name */ ++ __be32 clir_phys_port; /* physical port number */ ++ __be32 clir_trans_id; /* transaction ID */ ++ __u8 clir_resv[3]; /* reserved */ ++ __u8 clir_ts_fmt; /* time stamp format */ ++ __be64 clir_timestamp; /* time stamp */ ++}; ++ ++/* ++ * CLIR clir_ts_fmt - time stamp format values. ++ */ ++enum fc_els_clir_ts_fmt { ++ ELS_CLIR_TS_UNKNOWN = 0, /* time stamp field unknown */ ++ ELS_CLIR_TS_SEC_FRAC = 1, /* time in seconds and fractions */ ++ ELS_CLIR_TS_CSU = 2, /* time in clock synch update format */ ++}; ++ ++/* ++ * Common Link Incident Descriptor - sent via RLIR. ++ */ ++struct fc_els_clid { ++ __u8 clid_iq; /* incident qualifier flags */ ++ __u8 clid_ic; /* incident code */ ++ __be16 clid_epai; /* domain/area of ISL */ ++}; ++ ++/* ++ * CLID incident qualifier flags. ++ */ ++enum fc_els_clid_iq { ++ ELS_CLID_SWITCH = 0x20, /* incident port is a switch node */ ++ ELS_CLID_E_PORT = 0x10, /* incident is an ISL (E) port */ ++ ELS_CLID_SEV_MASK = 0x0c, /* severity 2-bit field mask */ ++ ELS_CLID_SEV_INFO = 0x00, /* report is informational */ ++ ELS_CLID_SEV_INOP = 0x08, /* link not operational */ ++ ELS_CLID_SEV_DEG = 0x04, /* link degraded but operational */ ++ ELS_CLID_LASER = 0x02, /* subassembly is a laser */ ++ ELS_CLID_FRU = 0x01, /* format can identify a FRU */ ++}; ++ ++/* ++ * CLID incident code. ++ */ ++enum fc_els_clid_ic { ++ ELS_CLID_IC_IMPL = 1, /* implicit incident */ ++ ELS_CLID_IC_BER = 2, /* bit-error-rate threshold exceeded */ ++ ELS_CLID_IC_LOS = 3, /* loss of synch or signal */ ++ ELS_CLID_IC_NOS = 4, /* non-operational primitive sequence */ ++ ELS_CLID_IC_PST = 5, /* primitive sequence timeout */ ++ ELS_CLID_IC_INVAL = 6, /* invalid primitive sequence */ ++ ELS_CLID_IC_LOOP_TO = 7, /* loop initialization time out */ ++ ELS_CLID_IC_LIP = 8, /* receiving LIP */ ++}; ++ ++#endif /* _FC_ELS_H_ */ +diff -Naurd fcoe-utils-1.0.14.orig/include/fc_gs.h fcoe-utils-1.0.14/include/fc_gs.h +--- fcoe-utils-1.0.14.orig/include/fc_gs.h 1970-01-01 01:00:00.000000000 +0100 ++++ fcoe-utils-1.0.14/include/fc_gs.h 2011-02-23 15:05:18.302052163 +0100 +@@ -0,0 +1,96 @@ ++/* ++ * Copyright(c) 2007 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU General Public License, ++ * version 2, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope 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 St - Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Maintained at www.Open-FCoE.org ++ */ ++ ++#ifndef _FC_GS_H_ ++#define _FC_GS_H_ ++ ++#include ++ ++/* ++ * Fibre Channel Services - Common Transport. ++ * From T11.org FC-GS-2 Rev 5.3 November 1998. ++ */ ++ ++struct fc_ct_hdr { ++ __u8 ct_rev; /* revision */ ++ __u8 ct_in_id[3]; /* N_Port ID of original requestor */ ++ __u8 ct_fs_type; /* type of fibre channel service */ ++ __u8 ct_fs_subtype; /* subtype */ ++ __u8 ct_options; ++ __u8 _ct_resvd1; ++ __be16 ct_cmd; /* command / response code */ ++ __be16 ct_mr_size; /* maximum / residual size */ ++ __u8 _ct_resvd2; ++ __u8 ct_reason; /* reject reason */ ++ __u8 ct_explan; /* reason code explanation */ ++ __u8 ct_vendor; /* vendor unique data */ ++}; ++ ++#define FC_CT_HDR_LEN 16 /* expected sizeof (struct fc_ct_hdr) */ ++ ++enum fc_ct_rev { ++ FC_CT_REV = 1 /* common transport revision */ ++}; ++ ++/* ++ * ct_fs_type values. ++ */ ++enum fc_ct_fs_type { ++ FC_FST_ALIAS = 0xf8, /* alias service */ ++ FC_FST_MGMT = 0xfa, /* management service */ ++ FC_FST_TIME = 0xfb, /* time service */ ++ FC_FST_DIR = 0xfc, /* directory service */ ++}; ++ ++/* ++ * ct_cmd: Command / response codes ++ */ ++enum fc_ct_cmd { ++ FC_FS_RJT = 0x8001, /* reject */ ++ FC_FS_ACC = 0x8002, /* accept */ ++}; ++ ++/* ++ * FS_RJT reason codes. ++ */ ++enum fc_ct_reason { ++ FC_FS_RJT_CMD = 0x01, /* invalid command code */ ++ FC_FS_RJT_VER = 0x02, /* invalid version level */ ++ FC_FS_RJT_LOG = 0x03, /* logical error */ ++ FC_FS_RJT_IUSIZ = 0x04, /* invalid IU size */ ++ FC_FS_RJT_BSY = 0x05, /* logical busy */ ++ FC_FS_RJT_PROTO = 0x07, /* protocol error */ ++ FC_FS_RJT_UNABL = 0x09, /* unable to perform command request */ ++ FC_FS_RJT_UNSUP = 0x0b, /* command not supported */ ++}; ++ ++/* ++ * FS_RJT reason code explanations. ++ */ ++enum fc_ct_explan { ++ FC_FS_EXP_NONE = 0x00, /* no additional explanation */ ++ FC_FS_EXP_PID = 0x01, /* port ID not registered */ ++ FC_FS_EXP_PNAM = 0x02, /* port name not registered */ ++ FC_FS_EXP_NNAM = 0x03, /* node name not registered */ ++ FC_FS_EXP_COS = 0x04, /* class of service not registered */ ++ FC_FS_EXP_FTNR = 0x07, /* FC-4 types not registered */ ++ /* definitions not complete */ ++}; ++ ++#endif /* _FC_GS_H_ */ +diff -Naurd fcoe-utils-1.0.14.orig/include/fc_ns.h fcoe-utils-1.0.14/include/fc_ns.h +--- fcoe-utils-1.0.14.orig/include/fc_ns.h 1970-01-01 01:00:00.000000000 +0100 ++++ fcoe-utils-1.0.14/include/fc_ns.h 2011-02-23 15:05:18.305426345 +0100 +@@ -0,0 +1,192 @@ ++/* ++ * Copyright(c) 2007 Intel Corporation. All rights reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms and conditions of the GNU General Public License, ++ * version 2, as published by the Free Software Foundation. ++ * ++ * This program is distributed in the hope 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 St - Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Maintained at www.Open-FCoE.org ++ */ ++ ++#ifndef _FC_NS_H_ ++#define _FC_NS_H_ ++ ++#include ++ ++/* ++ * Fibre Channel Services - Name Service (dNS) ++ * From T11.org FC-GS-2 Rev 5.3 November 1998. ++ */ ++ ++/* ++ * Common-transport sub-type for Name Server. ++ */ ++#define FC_NS_SUBTYPE 2 /* fs_ct_hdr.ct_fs_subtype */ ++ ++/* ++ * Name server Requests. ++ * Note: this is an incomplete list, some unused requests are omitted. ++ */ ++enum fc_ns_req { ++ FC_NS_GA_NXT = 0x0100, /* get all next */ ++ FC_NS_GI_A = 0x0101, /* get identifiers - scope */ ++ FC_NS_GPN_ID = 0x0112, /* get port name by ID */ ++ FC_NS_GNN_ID = 0x0113, /* get node name by ID */ ++ FC_NS_GID_PN = 0x0121, /* get ID for port name */ ++ FC_NS_GID_NN = 0x0131, /* get IDs for node name */ ++ FC_NS_GID_FT = 0x0171, /* get IDs by FC4 type */ ++ FC_NS_GPN_FT = 0x0172, /* get port names by FC4 type */ ++ FC_NS_GID_PT = 0x01a1, /* get IDs by port type */ ++ FC_NS_RPN_ID = 0x0212, /* reg port name for ID */ ++ FC_NS_RNN_ID = 0x0213, /* reg node name for ID */ ++ FC_NS_RFT_ID = 0x0217, /* reg FC4 type for ID */ ++ FC_NS_RSPN_ID = 0x0218, /* reg symbolic port name */ ++ FC_NS_RFF_ID = 0x021f, /* reg FC4 Features for ID */ ++ FC_NS_RSNN_NN = 0x0239, /* reg symbolic node name */ ++}; ++ ++/* ++ * Port type values. ++ */ ++enum fc_ns_pt { ++ FC_NS_UNID_PORT = 0x00, /* unidentified */ ++ FC_NS_N_PORT = 0x01, /* N port */ ++ FC_NS_NL_PORT = 0x02, /* NL port */ ++ FC_NS_FNL_PORT = 0x03, /* F/NL port */ ++ FC_NS_NX_PORT = 0x7f, /* Nx port */ ++ FC_NS_F_PORT = 0x81, /* F port */ ++ FC_NS_FL_PORT = 0x82, /* FL port */ ++ FC_NS_E_PORT = 0x84, /* E port */ ++ FC_NS_B_PORT = 0x85, /* B port */ ++}; ++ ++/* ++ * Port type object. ++ */ ++struct fc_ns_pt_obj { ++ __u8 pt_type; ++}; ++ ++/* ++ * Port ID object ++ */ ++struct fc_ns_fid { ++ __u8 fp_flags; /* flags for responses only */ ++ __u8 fp_fid[3]; ++}; ++ ++/* ++ * fp_flags in port ID object, for responses only. ++ */ ++#define FC_NS_FID_LAST 0x80 /* last object */ ++ ++/* ++ * FC4-types object. ++ */ ++#define FC_NS_TYPES 256 /* number of possible FC-4 types */ ++#define FC_NS_BPW 32 /* bits per word in bitmap */ ++ ++struct fc_ns_fts { ++ __be32 ff_type_map[FC_NS_TYPES / FC_NS_BPW]; /* bitmap of FC-4 types */ ++}; ++ ++/* ++ * GID_PT request. ++ */ ++struct fc_ns_gid_pt { ++ __u8 fn_pt_type; ++ __u8 fn_domain_id_scope; ++ __u8 fn_area_id_scope; ++ __u8 fn_resvd; ++}; ++ ++/* ++ * GID_FT or GPN_FT request. ++ */ ++struct fc_ns_gid_ft { ++ __u8 fn_resvd; ++ __u8 fn_domain_id_scope; ++ __u8 fn_area_id_scope; ++ __u8 fn_fc4_type; ++}; ++ ++/* ++ * GPN_FT response. ++ */ ++struct fc_gpn_ft_resp { ++ __u8 fp_flags; /* see fp_flags definitions above */ ++ __u8 fp_fid[3]; /* port ID */ ++ __be32 fp_resvd; ++ __be64 fp_wwpn; /* port name */ ++}; ++ ++/* ++ * GID_PN request ++ */ ++struct fc_ns_gid_pn { ++ __be64 fn_wwpn; /* port name */ ++}; ++ ++/* ++ * GID_PN response ++ */ ++struct fc_gid_pn_resp { ++ __u8 fp_resvd; ++ __u8 fp_fid[3]; /* port ID */ ++}; ++ ++/* ++ * RFT_ID request - register FC-4 types for ID. ++ */ ++struct fc_ns_rft_id { ++ struct fc_ns_fid fr_fid; /* port ID object */ ++ struct fc_ns_fts fr_fts; /* FC-4 types object */ ++}; ++ ++/* ++ * RPN_ID request - register port name for ID. ++ * RNN_ID request - register node name for ID. ++ */ ++struct fc_ns_rn_id { ++ struct fc_ns_fid fr_fid; /* port ID object */ ++ __be64 fr_wwn; /* node name or port name */ ++} __attribute__((__packed__)); ++ ++/* ++ * RSNN_NN request - register symbolic node name ++ */ ++struct fc_ns_rsnn { ++ __be64 fr_wwn; /* node name */ ++ __u8 fr_name_len; ++ char fr_name[]; ++} __attribute__((__packed__)); ++ ++/* ++ * RSPN_ID request - register symbolic port name ++ */ ++struct fc_ns_rspn { ++ struct fc_ns_fid fr_fid; /* port ID object */ ++ __u8 fr_name_len; ++ char fr_name[]; ++} __attribute__((__packed__)); ++ ++/* ++ * RFF_ID request - register FC-4 Features for ID. ++ */ ++struct fc_ns_rff_id { ++ struct fc_ns_fid fr_fid; /* port ID object */ ++ __u8 fr_resvd[2]; ++ __u8 fr_feat; /* FC-4 Feature bits */ ++ __u8 fr_type; /* FC-4 type */ ++} __attribute__((__packed__)); ++ ++#endif /* _FC_NS_H_ */ +diff -Naurd fcoe-utils-1.0.14.orig/include/scsi_bsg_fc.h fcoe-utils-1.0.14/include/scsi_bsg_fc.h +--- fcoe-utils-1.0.14.orig/include/scsi_bsg_fc.h 1970-01-01 01:00:00.000000000 +0100 ++++ fcoe-utils-1.0.14/include/scsi_bsg_fc.h 2011-02-23 15:05:18.310052287 +0100 +@@ -0,0 +1,322 @@ ++/* ++ * FC Transport BSG Interface ++ * ++ * Copyright (C) 2008 James Smart, Emulex Corporation ++ * ++ * 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 ++ * (at your option) 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ */ ++ ++#ifndef SCSI_BSG_FC_H ++#define SCSI_BSG_FC_H ++ ++/* ++ * This file intended to be included by both kernel and user space ++ */ ++ ++#include ++ ++/* ++ * FC Transport SGIO v4 BSG Message Support ++ */ ++ ++/* Default BSG request timeout (in seconds) */ ++#define FC_DEFAULT_BSG_TIMEOUT (10 * HZ) ++ ++ ++/* ++ * Request Message Codes supported by the FC Transport ++ */ ++ ++/* define the class masks for the message codes */ ++#define FC_BSG_CLS_MASK 0xF0000000 /* find object class */ ++#define FC_BSG_HST_MASK 0x80000000 /* fc host class */ ++#define FC_BSG_RPT_MASK 0x40000000 /* fc rport class */ ++ ++ /* fc_host Message Codes */ ++#define FC_BSG_HST_ADD_RPORT (FC_BSG_HST_MASK | 0x00000001) ++#define FC_BSG_HST_DEL_RPORT (FC_BSG_HST_MASK | 0x00000002) ++#define FC_BSG_HST_ELS_NOLOGIN (FC_BSG_HST_MASK | 0x00000003) ++#define FC_BSG_HST_CT (FC_BSG_HST_MASK | 0x00000004) ++#define FC_BSG_HST_VENDOR (FC_BSG_HST_MASK | 0x000000FF) ++ ++ /* fc_rport Message Codes */ ++#define FC_BSG_RPT_ELS (FC_BSG_RPT_MASK | 0x00000001) ++#define FC_BSG_RPT_CT (FC_BSG_RPT_MASK | 0x00000002) ++ ++ ++ ++/* ++ * FC Address Identifiers in Message Structures : ++ * ++ * Whenever a command payload contains a FC Address Identifier ++ * (aka port_id), the value is effectively in big-endian ++ * order, thus the array elements are decoded as follows: ++ * element [0] is bits 23:16 of the FC Address Identifier ++ * element [1] is bits 15:8 of the FC Address Identifier ++ * element [2] is bits 7:0 of the FC Address Identifier ++ */ ++ ++ ++/* ++ * FC Host Messages ++ */ ++ ++/* FC_BSG_HST_ADDR_PORT : */ ++ ++/* Request: ++ * This message requests the FC host to login to the remote port ++ * at the specified N_Port_Id. The remote port is to be enumerated ++ * with the transport upon completion of the login. ++ */ ++struct fc_bsg_host_add_rport { ++ uint8_t reserved; ++ ++ /* FC Address Identier of the remote port to login to */ ++ uint8_t port_id[3]; ++}; ++ ++/* Response: ++ * There is no additional response data - fc_bsg_reply->result is sufficient ++ */ ++ ++ ++/* FC_BSG_HST_DEL_RPORT : */ ++ ++/* Request: ++ * This message requests the FC host to remove an enumerated ++ * remote port and to terminate the login to it. ++ * ++ * Note: The driver is free to reject this request if it desires to ++ * remain logged in with the remote port. ++ */ ++struct fc_bsg_host_del_rport { ++ uint8_t reserved; ++ ++ /* FC Address Identier of the remote port to logout of */ ++ uint8_t port_id[3]; ++}; ++ ++/* Response: ++ * There is no additional response data - fc_bsg_reply->result is sufficient ++ */ ++ ++ ++/* FC_BSG_HST_ELS_NOLOGIN : */ ++ ++/* Request: ++ * This message requests the FC_Host to send an ELS to a specific ++ * N_Port_ID. The host does not need to log into the remote port, ++ * nor does it need to enumerate the rport for further traffic ++ * (although, the FC host is free to do so if it desires). ++ */ ++struct fc_bsg_host_els { ++ /* ++ * ELS Command Code being sent (must be the same as byte 0 ++ * of the payload) ++ */ ++ uint8_t command_code; ++ ++ /* FC Address Identier of the remote port to send the ELS to */ ++ uint8_t port_id[3]; ++}; ++ ++/* Response: ++ */ ++/* fc_bsg_ctels_reply->status values */ ++#define FC_CTELS_STATUS_OK 0x00000000 ++#define FC_CTELS_STATUS_REJECT 0x00000001 ++#define FC_CTELS_STATUS_P_RJT 0x00000002 ++#define FC_CTELS_STATUS_F_RJT 0x00000003 ++#define FC_CTELS_STATUS_P_BSY 0x00000004 ++#define FC_CTELS_STATUS_F_BSY 0x00000006 ++struct fc_bsg_ctels_reply { ++ /* ++ * Note: An ELS LS_RJT may be reported in 2 ways: ++ * a) A status of FC_CTELS_STATUS_OK is returned. The caller ++ * is to look into the ELS receive payload to determine ++ * LS_ACC or LS_RJT (by contents of word 0). The reject ++ * data will be in word 1. ++ * b) A status of FC_CTELS_STATUS_REJECT is returned, The ++ * rjt_data field will contain valid data. ++ * ++ * Note: ELS LS_ACC is determined by an FC_CTELS_STATUS_OK, and ++ * the receive payload word 0 indicates LS_ACC ++ * (e.g. value is 0x02xxxxxx). ++ * ++ * Note: Similarly, a CT Reject may be reported in 2 ways: ++ * a) A status of FC_CTELS_STATUS_OK is returned. The caller ++ * is to look into the CT receive payload to determine ++ * Accept or Reject (by contents of word 2). The reject ++ * data will be in word 3. ++ * b) A status of FC_CTELS_STATUS_REJECT is returned, The ++ * rjt_data field will contain valid data. ++ * ++ * Note: x_RJT/BSY status will indicae that the rjt_data field ++ * is valid and contains the reason/explanation values. ++ */ ++ uint32_t status; /* See FC_CTELS_STATUS_xxx */ ++ ++ /* valid if status is not FC_CTELS_STATUS_OK */ ++ struct { ++ uint8_t action; /* fragment_id for CT REJECT */ ++ uint8_t reason_code; ++ uint8_t reason_explanation; ++ uint8_t vendor_unique; ++ } rjt_data; ++}; ++ ++ ++/* FC_BSG_HST_CT : */ ++ ++/* Request: ++ * This message requests that a CT Request be performed with the ++ * indicated N_Port_ID. The driver is responsible for logging in with ++ * the fabric and/or N_Port_ID, etc as per FC rules. This request does ++ * not mandate that the driver must enumerate the destination in the ++ * transport. The driver is allowed to decide whether to enumerate it, ++ * and whether to tear it down after the request. ++ */ ++struct fc_bsg_host_ct { ++ uint8_t reserved; ++ ++ /* FC Address Identier of the remote port to send the ELS to */ ++ uint8_t port_id[3]; ++ ++ /* ++ * We need words 0-2 of the generic preamble for the LLD's ++ */ ++ uint32_t preamble_word0; /* revision & IN_ID */ ++ uint32_t preamble_word1; /* GS_Type, GS_SubType, Options, Rsvd */ ++ uint32_t preamble_word2; /* Cmd Code, Max Size */ ++ ++}; ++/* Response: ++ * ++ * The reply structure is an fc_bsg_ctels_reply structure ++ */ ++ ++ ++/* FC_BSG_HST_VENDOR : */ ++ ++/* Request: ++ * Note: When specifying vendor_id, be sure to read the Vendor Type and ID ++ * formatting requirements specified in scsi_netlink.h ++ */ ++struct fc_bsg_host_vendor { ++ /* ++ * Identifies the vendor that the message is formatted for. This ++ * should be the recipient of the message. ++ */ ++ uint64_t vendor_id; ++ ++ /* start of vendor command area */ ++ uint32_t vendor_cmd[0]; ++}; ++ ++/* Response: ++ */ ++struct fc_bsg_host_vendor_reply { ++ /* start of vendor response area */ ++ uint32_t vendor_rsp[0]; ++}; ++ ++ ++ ++/* ++ * FC Remote Port Messages ++ */ ++ ++/* FC_BSG_RPT_ELS : */ ++ ++/* Request: ++ * This message requests that an ELS be performed with the rport. ++ */ ++struct fc_bsg_rport_els { ++ /* ++ * ELS Command Code being sent (must be the same as ++ * byte 0 of the payload) ++ */ ++ uint8_t els_code; ++}; ++ ++/* Response: ++ * ++ * The reply structure is an fc_bsg_ctels_reply structure ++ */ ++ ++ ++/* FC_BSG_RPT_CT : */ ++ ++/* Request: ++ * This message requests that a CT Request be performed with the rport. ++ */ ++struct fc_bsg_rport_ct { ++ /* ++ * We need words 0-2 of the generic preamble for the LLD's ++ */ ++ uint32_t preamble_word0; /* revision & IN_ID */ ++ uint32_t preamble_word1; /* GS_Type, GS_SubType, Options, Rsvd */ ++ uint32_t preamble_word2; /* Cmd Code, Max Size */ ++}; ++/* Response: ++ * ++ * The reply structure is an fc_bsg_ctels_reply structure ++ */ ++ ++ ++ ++ ++/* request (CDB) structure of the sg_io_v4 */ ++struct fc_bsg_request { ++ uint32_t msgcode; ++ union { ++ struct fc_bsg_host_add_rport h_addrport; ++ struct fc_bsg_host_del_rport h_delrport; ++ struct fc_bsg_host_els h_els; ++ struct fc_bsg_host_ct h_ct; ++ struct fc_bsg_host_vendor h_vendor; ++ ++ struct fc_bsg_rport_els r_els; ++ struct fc_bsg_rport_ct r_ct; ++ } rqst_data; ++} __attribute__((packed)); ++ ++ ++/* response (request sense data) structure of the sg_io_v4 */ ++struct fc_bsg_reply { ++ /* ++ * The completion result. Result exists in two forms: ++ * if negative, it is an -Exxx system errno value. There will ++ * be no further reply information supplied. ++ * else, it's the 4-byte scsi error result, with driver, host, ++ * msg and status fields. The per-msgcode reply structure ++ * will contain valid data. ++ */ ++ uint32_t result; ++ ++ /* If there was reply_payload, how much was recevied ? */ ++ uint32_t reply_payload_rcv_len; ++ ++ union { ++ struct fc_bsg_host_vendor_reply vendor_reply; ++ ++ struct fc_bsg_ctels_reply ctels_reply; ++ } reply_data; ++}; ++ ++ ++#endif /* SCSI_BSG_FC_H */ ++ diff --git a/fcoe-utils.spec b/fcoe-utils.spec index 8609720..c3f9b72 100644 --- a/fcoe-utils.spec +++ b/fcoe-utils.spec @@ -1,6 +1,6 @@ Name: fcoe-utils Version: 1.0.14 -Release: 4%{?dist} +Release: 5%{?dist} Summary: Fibre Channel over Ethernet utilities Group: Applications/System @@ -19,10 +19,14 @@ Patch2: fcoe-utils-1.0.8-includes.patch Patch3: fcoe-utils-1.0.8-init-LSB.patch Patch4: fcoe-utils-1.0.12-makefile-data-hook.patch Patch5: fcoe-utils-1.0.14-no-vconfig.patch +Patch6: fcoe-sparc.patch BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) ExcludeArch: s390 ppc -BuildRequires: libhbaapi-devel lldpad-devel libtool automake kernel-devel +BuildRequires: libhbaapi-devel lldpad-devel libtool automake +%ifnarch sparc sparcv9 +BuildRequires: kernel-devel +%endif Requires: lldpad libhbalinux >= 1.0.9 iproute device-mapper-multipath Requires(post): chkconfig Requires(preun): chkconfig initscripts @@ -42,6 +46,13 @@ fcoemon - service to configure DCB Ethernet QOS filters, works with dcbd or lldp %patch4 -p1 -b .data-hook %patch5 -p1 -b .no-vconfig +# we dont build a kernel on 32 bit sparc so have no kernel-devel +# patch in a copy of the headers for use. +# userland is entirely 32 bit and kernel is 64 bit +%ifarch sparc sparcv9 +%patch6 -p1 -b .sparc +%endif + %build ./bootstrap.sh %configure @@ -115,6 +126,9 @@ fi %changelog +* Wed Feb 23 2011 Dennis Gilmore - 1.0.14-5 +- patch in headers used from kernel-devel on 32 bit sparc + * Tue Feb 08 2011 Fedora Release Engineering - 1.0.14-4 - Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild