drivers/scsi/libfc/fc_lport.c

   1 /*
   2  * Copyright(c) 2007 Intel Corporation. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or modify it
   5  * under the terms and conditions of the GNU General Public License,
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope it will be useful, but WITHOUT
   9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  11  * more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along with
  14  * this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  16  *
  17  * Maintained at www.Open-FCoE.org
  18  */
  19
  20 /*
  21  * PORT LOCKING NOTES
  22  *
  23  * These comments only apply to the 'port code' which consists of the lport,
  24  * disc and rport blocks.
  25  *
  26  * MOTIVATION
  27  *
  28  * The lport, disc and rport blocks all have mutexes that are used to protect
  29  * those objects. The main motivation for these locks is to prevent from
  30  * having an lport reset just before we send a frame. In that scenario the
  31  * lport's FID would get set to zero and then we'd send a frame with an
  32  * invalid SID. We also need to ensure that states don't change unexpectedly
  33  * while processing another state.
  34  *
  35  * HIERARCHY
  36  *
  37  * The following hierarchy defines the locking rules. A greater lock
  38  * may be held before acquiring a lesser lock, but a lesser lock should never
  39  * be held while attempting to acquire a greater lock. Here is the hierarchy-
  40  *
  41  * lport > disc, lport > rport, disc > rport
  42  *
  43  * CALLBACKS
  44  *
  45  * The callbacks cause complications with this scheme. There is a callback
  46  * from the rport (to either lport or disc) and a callback from disc
  47  * (to the lport).
  48  *
  49  * As rports exit the rport state machine a callback is made to the owner of
  50  * the rport to notify success or failure. Since the callback is likely to
  51  * cause the lport or disc to grab its lock we cannot hold the rport lock
  52  * while making the callback. To ensure that the rport is not free'd while
  53  * processing the callback the rport callbacks are serialized through a
  54  * single-threaded workqueue. An rport would never be free'd while in a
  55  * callback handler because no other rport work in this queue can be executed
  56  * at the same time.
  57  *
  58  * When discovery succeeds or fails a callback is made to the lport as
  59  * notification. Currently, successful discovery causes the lport to take no
  60  * action. A failure will cause the lport to reset. There is likely a circular
  61  * locking problem with this implementation.
  62  */
  63
  64 /*
  65  * LPORT LOCKING
  66  *
  67  * The critical sections protected by the lport's mutex are quite broad and
  68  * may be improved upon in the future. The lport code and its locking doesn't
  69  * influence the I/O path, so excessive locking doesn't penalize I/O
  70  * performance.
  71  *
  72  * The strategy is to lock whenever processing a request or response. Note
  73  * that every _enter_* function corresponds to a state change. They generally
  74  * change the lports state and then send a request out on the wire. We lock
  75  * before calling any of these functions to protect that state change. This
  76  * means that the entry points into the lport block manage the locks while
  77  * the state machine can transition between states (i.e. _enter_* functions)
  78  * while always staying protected.
  79  *
  80  * When handling responses we also hold the lport mutex broadly. When the
  81  * lport receives the response frame it locks the mutex and then calls the
  82  * appropriate handler for the particuar response. Generally a response will
  83  * trigger a state change and so the lock must already be held.
  84  *
  85  * Retries also have to consider the locking. The retries occur from a work
  86  * context and the work function will lock the lport and then retry the state
  87  * (i.e. _enter_* function).
  88  */
  89
  90 #include <linux/timer.h>
  91 #include <linux/delay.h>
  92 #include <linux/module.h>
  93 #include <linux/slab.h>
  94 #include <asm/unaligned.h>
  95
  96 #include <scsi/fc/fc_gs.h>
  97
  98 #include <scsi/libfc.h>
  99 #include <scsi/fc_encode.h>
 100 #include <linux/scatterlist.h>
 101
 102 #include "fc_libfc.h"
 103
 104 /* Fabric IDs to use for point-to-point mode, chosen on whims. */
 105 #define FC_LOCAL_PTP_FID_LO   0x010101
 106 #define FC_LOCAL_PTP_FID_HI   0x010102
 107
 108 #define DNS_DELAY             3 /* Discovery delay after RSCN (in seconds)*/
 109
 110 static void fc_lport_error(struct fc_lport *, struct fc_frame *);
 111
 112 static void fc_lport_enter_reset(struct fc_lport *);
 113 static void fc_lport_enter_flogi(struct fc_lport *);
 114 static void fc_lport_enter_dns(struct fc_lport *);
 115 static void fc_lport_enter_ns(struct fc_lport *, enum fc_lport_state);
 116 static void fc_lport_enter_scr(struct fc_lport *);
 117 static void fc_lport_enter_ready(struct fc_lport *);
 118 static void fc_lport_enter_logo(struct fc_lport *);
 119 static void fc_lport_enter_fdmi(struct fc_lport *lport);
 120 static void fc_lport_enter_ms(struct fc_lport *, enum fc_lport_state);
 121
 122 static const char *fc_lport_state_names[] = {
 123         [LPORT_ST_DISABLED] = "disabled",
 124         [LPORT_ST_FLOGI] =    "FLOGI",
 125         [LPORT_ST_DNS] =      "dNS",
 126         [LPORT_ST_RNN_ID] =   "RNN_ID",
 127         [LPORT_ST_RSNN_NN] =  "RSNN_NN",
 128         [LPORT_ST_RSPN_ID] =  "RSPN_ID",
 129         [LPORT_ST_RFT_ID] =   "RFT_ID",
 130         [LPORT_ST_RFF_ID] =   "RFF_ID",
 131         [LPORT_ST_FDMI] =     "FDMI",
 132         [LPORT_ST_RHBA] =     "RHBA",
 133         [LPORT_ST_RPA] =      "RPA",
 134         [LPORT_ST_DHBA] =     "DHBA",
 135         [LPORT_ST_DPRT] =     "DPRT",
 136         [LPORT_ST_SCR] =      "SCR",
 137         [LPORT_ST_READY] =    "Ready",
 138         [LPORT_ST_LOGO] =     "LOGO",
 139         [LPORT_ST_RESET] =    "reset",
 140 };
 141
 142 /**
 143  * struct fc_bsg_info - FC Passthrough managemet structure
 144  * @job:      The passthrough job
 145  * @lport:    The local port to pass through a command
 146  * @rsp_code: The expected response code
 147  * @sg:       job->reply_payload.sg_list
 148  * @nents:    job->reply_payload.sg_cnt
 149  * @offset:   The offset into the response data
 150  */
 151 struct fc_bsg_info {
 152         struct fc_bsg_job *job;
 153         struct fc_lport *lport;
 154         u16 rsp_code;
 155         struct scatterlist *sg;
 156         u32 nents;
 157         size_t offset;
 158 };
 159
 160 /**
 161  * fc_frame_drop() - Dummy frame handler
 162  * @lport: The local port the frame was received on
 163  * @fp:    The received frame
 164  */
 165 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
 166 {
 167         fc_frame_free(fp);
 168         return 0;
 169 }
 170
 171 /**
 172  * fc_lport_rport_callback() - Event handler for rport events
 173  * @lport: The lport which is receiving the event
 174  * @rdata: private remote port data
 175  * @event: The event that occurred
 176  *
 177  * Locking Note: The rport lock should not be held when calling
 178  *               this function.
 179  */
 180 static void fc_lport_rport_callback(struct fc_lport *lport,
 181                                     struct fc_rport_priv *rdata,
 182                                     enum fc_rport_event event)
 183 {
 184         FC_LPORT_DBG(lport, "Received a %d event for port (%6.6x)\n", event,
 185                      rdata->ids.port_id);
 186
 187         mutex_lock(&lport->lp_mutex);
 188         switch (event) {
 189         case RPORT_EV_READY:
 190                 if (lport->state == LPORT_ST_DNS) {
 191                         lport->dns_rdata = rdata;
 192                         fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);
 193                 } else if (lport->state == LPORT_ST_FDMI) {
 194                         lport->ms_rdata = rdata;
 195                         fc_lport_enter_ms(lport, LPORT_ST_DHBA);
 196                 } else {
 197                         FC_LPORT_DBG(lport, "Received an READY event "
 198                                      "on port (%6.6x) for the directory "
 199                                      "server, but the lport is not "
 200                                      "in the DNS or FDMI state, it's in the "
 201                                      "%d state", rdata->ids.port_id,
 202                                      lport->state);
 203                         lport->tt.rport_logoff(rdata);
 204                 }
 205                 break;
 206         case RPORT_EV_LOGO:
 207         case RPORT_EV_FAILED:
 208         case RPORT_EV_STOP:
 209                 if (rdata->ids.port_id == FC_FID_DIR_SERV)
 210                         lport->dns_rdata = NULL;
 211                 else if (rdata->ids.port_id == FC_FID_MGMT_SERV)
 212                         lport->ms_rdata = NULL;
 213                 break;
 214         case RPORT_EV_NONE:
 215                 break;
 216         }
 217         mutex_unlock(&lport->lp_mutex);
 218 }
 219
 220 /**
 221  * fc_lport_state() - Return a string which represents the lport's state
 222  * @lport: The lport whose state is to converted to a string
 223  */
 224 static const char *fc_lport_state(struct fc_lport *lport)
 225 {
 226         const char *cp;
 227
 228         cp = fc_lport_state_names[lport->state];
 229         if (!cp)
 230                 cp = "unknown";
 231         return cp;
 232 }
 233
 234 /**
 235  * fc_lport_ptp_setup() - Create an rport for point-to-point mode
 236  * @lport:       The lport to attach the ptp rport to
 237  * @remote_fid:  The FID of the ptp rport
 238  * @remote_wwpn: The WWPN of the ptp rport
 239  * @remote_wwnn: The WWNN of the ptp rport
 240  */
 241 static void fc_lport_ptp_setup(struct fc_lport *lport,
 242                                u32 remote_fid, u64 remote_wwpn,
 243                                u64 remote_wwnn)
 244 {
 245         mutex_lock(&lport->disc.disc_mutex);
 246         if (lport->ptp_rdata) {
 247                 lport->tt.rport_logoff(lport->ptp_rdata);
 248                 kref_put(&lport->ptp_rdata->kref, lport->tt.rport_destroy);
 249         }
 250         lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid);
 251         kref_get(&lport->ptp_rdata->kref);
 252         lport->ptp_rdata->ids.port_name = remote_wwpn;
 253         lport->ptp_rdata->ids.node_name = remote_wwnn;
 254         mutex_unlock(&lport->disc.disc_mutex);
 255
 256         lport->tt.rport_login(lport->ptp_rdata);
 257
 258         fc_lport_enter_ready(lport);
 259 }
 260
 261 /**
 262  * fc_get_host_port_state() - Return the port state of the given Scsi_Host
 263  * @shost:  The SCSI host whose port state is to be determined
 264  */
 265 void fc_get_host_port_state(struct Scsi_Host *shost)
 266 {
 267         struct fc_lport *lport = shost_priv(shost);
 268
 269         mutex_lock(&lport->lp_mutex);
 270         if (!lport->link_up)
 271                 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
 272         else
 273                 switch (lport->state) {
 274                 case LPORT_ST_READY:
 275                         fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
 276                         break;
 277                 default:
 278                         fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
 279                 }
 280         mutex_unlock(&lport->lp_mutex);
 281 }
 282 EXPORT_SYMBOL(fc_get_host_port_state);
 283
 284 /**
 285  * fc_get_host_speed() - Return the speed of the given Scsi_Host
 286  * @shost: The SCSI host whose port speed is to be determined
 287  */
 288 void fc_get_host_speed(struct Scsi_Host *shost)
 289 {
 290         struct fc_lport *lport = shost_priv(shost);
 291
 292         fc_host_speed(shost) = lport->link_speed;
 293 }
 294 EXPORT_SYMBOL(fc_get_host_speed);
 295
 296 /**
 297  * fc_get_host_stats() - Return the Scsi_Host's statistics
 298  * @shost: The SCSI host whose statistics are to be returned
 299  */
 300 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
 301 {
 302         struct fc_host_statistics *fcoe_stats;
 303         struct fc_lport *lport = shost_priv(shost);
 304         struct timespec v0, v1;
 305         unsigned int cpu;
 306         u64 fcp_in_bytes = 0;
 307         u64 fcp_out_bytes = 0;
 308
 309         fcoe_stats = &lport->host_stats;
 310         memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
 311
 312         jiffies_to_timespec(jiffies, &v0);
 313         jiffies_to_timespec(lport->boot_time, &v1);
 314         fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
 315
 316         for_each_possible_cpu(cpu) {
 317                 struct fcoe_dev_stats *stats;
 318
 319                 stats = per_cpu_ptr(lport->dev_stats, cpu);
 320
 321                 fcoe_stats->tx_frames += stats->TxFrames;
 322                 fcoe_stats->tx_words += stats->TxWords;
 323                 fcoe_stats->rx_frames += stats->RxFrames;
 324                 fcoe_stats->rx_words += stats->RxWords;
 325                 fcoe_stats->error_frames += stats->ErrorFrames;
 326                 fcoe_stats->invalid_crc_count += stats->InvalidCRCCount;
 327                 fcoe_stats->fcp_input_requests += stats->InputRequests;
 328                 fcoe_stats->fcp_output_requests += stats->OutputRequests;
 329                 fcoe_stats->fcp_control_requests += stats->ControlRequests;
 330                 fcp_in_bytes += stats->InputBytes;
 331                 fcp_out_bytes += stats->OutputBytes;
 332                 fcoe_stats->link_failure_count += stats->LinkFailureCount;
 333         }
 334         fcoe_stats->fcp_input_megabytes = div_u64(fcp_in_bytes, 1000000);
 335         fcoe_stats->fcp_output_megabytes = div_u64(fcp_out_bytes, 1000000);
 336         fcoe_stats->lip_count = -1;
 337         fcoe_stats->nos_count = -1;
 338         fcoe_stats->loss_of_sync_count = -1;
 339         fcoe_stats->loss_of_signal_count = -1;
 340         fcoe_stats->prim_seq_protocol_err_count = -1;
 341         fcoe_stats->dumped_frames = -1;
 342         return fcoe_stats;
 343 }
 344 EXPORT_SYMBOL(fc_get_host_stats);
 345
 346 /**
 347  * fc_lport_flogi_fill() - Fill in FLOGI command for request
 348  * @lport: The local port the FLOGI is for
 349  * @flogi: The FLOGI command
 350  * @op:    The opcode
 351  */
 352 static void fc_lport_flogi_fill(struct fc_lport *lport,
 353                                 struct fc_els_flogi *flogi,
 354                                 unsigned int op)
 355 {
 356         struct fc_els_csp *sp;
 357         struct fc_els_cssp *cp;
 358
 359         memset(flogi, 0, sizeof(*flogi));
 360         flogi->fl_cmd = (u8) op;
 361         put_unaligned_be64(lport->wwpn, &flogi->fl_wwpn);
 362         put_unaligned_be64(lport->wwnn, &flogi->fl_wwnn);
 363         sp = &flogi->fl_csp;
 364         sp->sp_hi_ver = 0x20;
 365         sp->sp_lo_ver = 0x20;
 366         sp->sp_bb_cred = htons(10);     /* this gets set by gateway */
 367         sp->sp_bb_data = htons((u16) lport->mfs);
 368         cp = &flogi->fl_cssp[3 - 1];    /* class 3 parameters */
 369         cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ);
 370         if (op != ELS_FLOGI) {
 371                 sp->sp_features = htons(FC_SP_FT_CIRO);
 372                 sp->sp_tot_seq = htons(255);    /* seq. we accept */
 373                 sp->sp_rel_off = htons(0x1f);
 374                 sp->sp_e_d_tov = htonl(lport->e_d_tov);
 375
 376                 cp->cp_rdfs = htons((u16) lport->mfs);
 377                 cp->cp_con_seq = htons(255);
 378                 cp->cp_open_seq = 1;
 379         }
 380 }
 381
 382 /**
 383  * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port
 384  * @lport: The local port to add a new FC-4 type to
 385  * @type:  The new FC-4 type
 386  */
 387 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
 388 {
 389         __be32 *mp;
 390
 391         mp = &lport->fcts.ff_type_map[type / FC_NS_BPW];
 392         *mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW));
 393 }
 394
 395 /**
 396  * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report.
 397  * @lport: Fibre Channel local port receiving the RLIR
 398  * @fp:    The RLIR request frame
 399  *
 400  * Locking Note: The lport lock is expected to be held before calling
 401  * this function.
 402  */
 403 static void fc_lport_recv_rlir_req(struct fc_lport *lport, struct fc_frame *fp)
 404 {
 405         FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
 406                      fc_lport_state(lport));
 407
 408         lport->tt.seq_els_rsp_send(fp, ELS_LS_ACC, NULL);
 409         fc_frame_free(fp);
 410 }
 411
 412 /**
 413  * fc_lport_recv_echo_req() - Handle received ECHO request
 414  * @lport: The local port receiving the ECHO
 415  * @fp:    ECHO request frame
 416  *
 417  * Locking Note: The lport lock is expected to be held before calling
 418  * this function.
 419  */
 420 static void fc_lport_recv_echo_req(struct fc_lport *lport,
 421                                    struct fc_frame *in_fp)
 422 {
 423         struct fc_frame *fp;
 424         unsigned int len;
 425         void *pp;
 426         void *dp;
 427
 428         FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n",
 429                      fc_lport_state(lport));
 430
 431         len = fr_len(in_fp) - sizeof(struct fc_frame_header);
 432         pp = fc_frame_payload_get(in_fp, len);
 433
 434         if (len < sizeof(__be32))
 435                 len = sizeof(__be32);
 436
 437         fp = fc_frame_alloc(lport, len);
 438         if (fp) {
 439                 dp = fc_frame_payload_get(fp, len);
 440                 memcpy(dp, pp, len);
 441                 *((__be32 *)dp) = htonl(ELS_LS_ACC << 24);
 442                 fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);
 443                 lport->tt.frame_send(lport, fp);
 444         }
 445         fc_frame_free(in_fp);
 446 }
 447
 448 /**
 449  * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
 450  * @lport: The local port receiving the RNID
 451  * @fp:    The RNID request frame
 452  *
 453  * Locking Note: The lport lock is expected to be held before calling
 454  * this function.
 455  */
 456 static void fc_lport_recv_rnid_req(struct fc_lport *lport,
 457                                    struct fc_frame *in_fp)
 458 {
 459         struct fc_frame *fp;
 460         struct fc_els_rnid *req;
 461         struct {
 462                 struct fc_els_rnid_resp rnid;
 463                 struct fc_els_rnid_cid cid;
 464                 struct fc_els_rnid_gen gen;
 465         } *rp;
 466         struct fc_seq_els_data rjt_data;
 467         u8 fmt;
 468         size_t len;
 469
 470         FC_LPORT_DBG(lport, "Received RNID request while in state %s\n",
 471                      fc_lport_state(lport));
 472
 473         req = fc_frame_payload_get(in_fp, sizeof(*req));
 474         if (!req) {
 475                 rjt_data.reason = ELS_RJT_LOGIC;
 476                 rjt_data.explan = ELS_EXPL_NONE;
 477                 lport->tt.seq_els_rsp_send(in_fp, ELS_LS_RJT, &rjt_data);
 478         } else {
 479                 fmt = req->rnid_fmt;
 480                 len = sizeof(*rp);
 481                 if (fmt != ELS_RNIDF_GEN ||
 482                     ntohl(lport->rnid_gen.rnid_atype) == 0) {
 483                         fmt = ELS_RNIDF_NONE;   /* nothing to provide */
 484                         len -= sizeof(rp->gen);
 485                 }
 486                 fp = fc_frame_alloc(lport, len);
 487                 if (fp) {
 488                         rp = fc_frame_payload_get(fp, len);
 489                         memset(rp, 0, len);
 490                         rp->rnid.rnid_cmd = ELS_LS_ACC;
 491                         rp->rnid.rnid_fmt = fmt;
 492                         rp->rnid.rnid_cid_len = sizeof(rp->cid);
 493                         rp->cid.rnid_wwpn = htonll(lport->wwpn);
 494                         rp->cid.rnid_wwnn = htonll(lport->wwnn);
 495                         if (fmt == ELS_RNIDF_GEN) {
 496                                 rp->rnid.rnid_sid_len = sizeof(rp->gen);
 497                                 memcpy(&rp->gen, &lport->rnid_gen,
 498                                        sizeof(rp->gen));
 499                         }
 500                         fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);
 501                         lport->tt.frame_send(lport, fp);
 502                 }
 503         }
 504         fc_frame_free(in_fp);
 505 }
 506
 507 /**
 508  * fc_lport_recv_logo_req() - Handle received fabric LOGO request
 509  * @lport: The local port receiving the LOGO
 510  * @fp:    The LOGO request frame
 511  *
 512  * Locking Note: The lport lock is exected to be held before calling
 513  * this function.
 514  */
 515 static void fc_lport_recv_logo_req(struct fc_lport *lport, struct fc_frame *fp)
 516 {
 517         lport->tt.seq_els_rsp_send(fp, ELS_LS_ACC, NULL);
 518         fc_lport_enter_reset(lport);
 519         fc_frame_free(fp);
 520 }
 521
 522 /**
 523  * fc_fabric_login() - Start the lport state machine
 524  * @lport: The local port that should log into the fabric
 525  *
 526  * Locking Note: This function should not be called
 527  *               with the lport lock held.
 528  */
 529 int fc_fabric_login(struct fc_lport *lport)
 530 {
 531         int rc = -1;
 532
 533         mutex_lock(&lport->lp_mutex);
 534         if (lport->state == LPORT_ST_DISABLED ||
 535             lport->state == LPORT_ST_LOGO) {
 536                 fc_lport_state_enter(lport, LPORT_ST_RESET);
 537                 fc_lport_enter_reset(lport);
 538                 rc = 0;
 539         }
 540         mutex_unlock(&lport->lp_mutex);
 541
 542         return rc;
 543 }
 544 EXPORT_SYMBOL(fc_fabric_login);
 545
 546 /**
 547  * __fc_linkup() - Handler for transport linkup events
 548  * @lport: The lport whose link is up
 549  *
 550  * Locking: must be called with the lp_mutex held
 551  */
 552 void __fc_linkup(struct fc_lport *lport)
 553 {
 554         if (!lport->link_up) {
 555                 lport->link_up = 1;
 556
 557                 if (lport->state == LPORT_ST_RESET)
 558                         fc_lport_enter_flogi(lport);
 559         }
 560 }
 561
 562 /**
 563  * fc_linkup() - Handler for transport linkup events
 564  * @lport: The local port whose link is up
 565  */
 566 void fc_linkup(struct fc_lport *lport)
 567 {
 568         printk(KERN_INFO "host%d: libfc: Link up on port (%6.6x)\n",
 569                lport->host->host_no, lport->port_id);
 570
 571         mutex_lock(&lport->lp_mutex);
 572         __fc_linkup(lport);
 573         mutex_unlock(&lport->lp_mutex);
 574 }
 575 EXPORT_SYMBOL(fc_linkup);
 576
 577 /**
 578  * __fc_linkdown() - Handler for transport linkdown events
 579  * @lport: The lport whose link is down
 580  *
 581  * Locking: must be called with the lp_mutex held
 582  */
 583 void __fc_linkdown(struct fc_lport *lport)
 584 {
 585         if (lport->link_up) {
 586                 lport->link_up = 0;
 587                 fc_lport_enter_reset(lport);
 588                 lport->tt.fcp_cleanup(lport);
 589         }
 590 }
 591
 592 /**
 593  * fc_linkdown() - Handler for transport linkdown events
 594  * @lport: The local port whose link is down
 595  */
 596 void fc_linkdown(struct fc_lport *lport)
 597 {
 598         printk(KERN_INFO "host%d: libfc: Link down on port (%6.6x)\n",
 599                lport->host->host_no, lport->port_id);
 600
 601         mutex_lock(&lport->lp_mutex);
 602         __fc_linkdown(lport);
 603         mutex_unlock(&lport->lp_mutex);
 604 }
 605 EXPORT_SYMBOL(fc_linkdown);
 606
 607 /**
 608  * fc_fabric_logoff() - Logout of the fabric
 609  * @lport: The local port to logoff the fabric
 610  *
 611  * Return value:
 612  *      0 for success, -1 for failure
 613  */
 614 int fc_fabric_logoff(struct fc_lport *lport)
 615 {
 616         lport->tt.disc_stop_final(lport);
 617         mutex_lock(&lport->lp_mutex);
 618         if (lport->dns_rdata)
 619                 lport->tt.rport_logoff(lport->dns_rdata);
 620         mutex_unlock(&lport->lp_mutex);
 621         lport->tt.rport_flush_queue();
 622         mutex_lock(&lport->lp_mutex);
 623         fc_lport_enter_logo(lport);
 624         mutex_unlock(&lport->lp_mutex);
 625         cancel_delayed_work_sync(&lport->retry_work);
 626         return 0;
 627 }
 628 EXPORT_SYMBOL(fc_fabric_logoff);
 629
 630 /**
 631  * fc_lport_destroy() - Unregister a fc_lport
 632  * @lport: The local port to unregister
 633  *
 634  * Note:
 635  * exit routine for fc_lport instance
 636  * clean-up all the allocated memory
 637  * and free up other system resources.
 638  *
 639  */
 640 int fc_lport_destroy(struct fc_lport *lport)
 641 {
 642         mutex_lock(&lport->lp_mutex);
 643         lport->state = LPORT_ST_DISABLED;
 644         lport->link_up = 0;
 645         lport->tt.frame_send = fc_frame_drop;
 646         mutex_unlock(&lport->lp_mutex);
 647
 648         lport->tt.fcp_abort_io(lport);
 649         lport->tt.disc_stop_final(lport);
 650         lport->tt.exch_mgr_reset(lport, 0, 0);
 651         cancel_delayed_work_sync(&lport->retry_work);
 652         fc_fc4_del_lport(lport);
 653         return 0;
 654 }
 655 EXPORT_SYMBOL(fc_lport_destroy);
 656
 657 /**
 658  * fc_set_mfs() - Set the maximum frame size for a local port
 659  * @lport: The local port to set the MFS for
 660  * @mfs:   The new MFS
 661  */
 662 int fc_set_mfs(struct fc_lport *lport, u32 mfs)
 663 {
 664         unsigned int old_mfs;
 665         int rc = -EINVAL;
 666
 667         mutex_lock(&lport->lp_mutex);
 668
 669         old_mfs = lport->mfs;
 670
 671         if (mfs >= FC_MIN_MAX_FRAME) {
 672                 mfs &= ~3;
 673                 if (mfs > FC_MAX_FRAME)
 674                         mfs = FC_MAX_FRAME;
 675                 mfs -= sizeof(struct fc_frame_header);
 676                 lport->mfs = mfs;
 677                 rc = 0;
 678         }
 679
 680         if (!rc && mfs < old_mfs)
 681                 fc_lport_enter_reset(lport);
 682
 683         mutex_unlock(&lport->lp_mutex);
 684
 685         return rc;
 686 }
 687 EXPORT_SYMBOL(fc_set_mfs);
 688
 689 /**
 690  * fc_lport_disc_callback() - Callback for discovery events
 691  * @lport: The local port receiving the event
 692  * @event: The discovery event
 693  */
 694 static void fc_lport_disc_callback(struct fc_lport *lport,
 695                                    enum fc_disc_event event)
 696 {
 697         switch (event) {
 698         case DISC_EV_SUCCESS:
 699                 FC_LPORT_DBG(lport, "Discovery succeeded\n");
 700                 break;
 701         case DISC_EV_FAILED:
 702                 printk(KERN_ERR "host%d: libfc: "
 703                        "Discovery failed for port (%6.6x)\n",
 704                        lport->host->host_no, lport->port_id);
 705                 mutex_lock(&lport->lp_mutex);
 706                 fc_lport_enter_reset(lport);
 707                 mutex_unlock(&lport->lp_mutex);
 708                 break;
 709         case DISC_EV_NONE:
 710                 WARN_ON(1);
 711                 break;
 712         }
 713 }
 714
 715 /**
 716  * fc_rport_enter_ready() - Enter the ready state and start discovery
 717  * @lport: The local port that is ready
 718  *
 719  * Locking Note: The lport lock is expected to be held before calling
 720  * this routine.
 721  */
 722 static void fc_lport_enter_ready(struct fc_lport *lport)
 723 {
 724         FC_LPORT_DBG(lport, "Entered READY from state %s\n",
 725                      fc_lport_state(lport));
 726
 727         fc_lport_state_enter(lport, LPORT_ST_READY);
 728         if (lport->vport)
 729                 fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);
 730         fc_vports_linkchange(lport);
 731
 732         if (!lport->ptp_rdata)
 733                 lport->tt.disc_start(fc_lport_disc_callback, lport);
 734 }
 735
 736 /**
 737  * fc_lport_set_port_id() - set the local port Port ID
 738  * @lport: The local port which will have its Port ID set.
 739  * @port_id: The new port ID.
 740  * @fp: The frame containing the incoming request, or NULL.
 741  *
 742  * Locking Note: The lport lock is expected to be held before calling
 743  * this function.
 744  */
 745 static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id,
 746                                  struct fc_frame *fp)
 747 {
 748         if (port_id)
 749                 printk(KERN_INFO "host%d: Assigned Port ID %6.6x\n",
 750                        lport->host->host_no, port_id);
 751
 752         lport->port_id = port_id;
 753
 754         /* Update the fc_host */
 755         fc_host_port_id(lport->host) = port_id;
 756
 757         if (lport->tt.lport_set_port_id)
 758                 lport->tt.lport_set_port_id(lport, port_id, fp);
 759 }
 760
 761 /**
 762  * fc_lport_set_port_id() - set the local port Port ID for point-to-multipoint
 763  * @lport: The local port which will have its Port ID set.
 764  * @port_id: The new port ID.
 765  *
 766  * Called by the lower-level driver when transport sets the local port_id.
 767  * This is used in VN_port to VN_port mode for FCoE, and causes FLOGI and
 768  * discovery to be skipped.
 769  */
 770 void fc_lport_set_local_id(struct fc_lport *lport, u32 port_id)
 771 {
 772         mutex_lock(&lport->lp_mutex);
 773
 774         fc_lport_set_port_id(lport, port_id, NULL);
 775
 776         switch (lport->state) {
 777         case LPORT_ST_RESET:
 778         case LPORT_ST_FLOGI:
 779                 if (port_id)
 780                         fc_lport_enter_ready(lport);
 781                 break;
 782         default:
 783                 break;
 784         }
 785         mutex_unlock(&lport->lp_mutex);
 786 }
 787 EXPORT_SYMBOL(fc_lport_set_local_id);
 788
 789 /**
 790  * fc_lport_recv_flogi_req() - Receive a FLOGI request
 791  * @lport: The local port that received the request
 792  * @rx_fp: The FLOGI frame
 793  *
 794  * A received FLOGI request indicates a point-to-point connection.
 795  * Accept it with the common service parameters indicating our N port.
 796  * Set up to do a PLOGI if we have the higher-number WWPN.
 797  *
 798  * Locking Note: The lport lock is expected to be held before calling
 799  * this function.
 800  */
 801 static void fc_lport_recv_flogi_req(struct fc_lport *lport,
 802                                     struct fc_frame *rx_fp)
 803 {
 804         struct fc_frame *fp;
 805         struct fc_frame_header *fh;
 806         struct fc_els_flogi *flp;
 807         struct fc_els_flogi *new_flp;
 808         u64 remote_wwpn;
 809         u32 remote_fid;
 810         u32 local_fid;
 811
 812         FC_LPORT_DBG(lport, "Received FLOGI request while in state %s\n",
 813                      fc_lport_state(lport));
 814
 815         remote_fid = fc_frame_sid(rx_fp);
 816         flp = fc_frame_payload_get(rx_fp, sizeof(*flp));
 817         if (!flp)
 818                 goto out;
 819         remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
 820         if (remote_wwpn == lport->wwpn) {
 821                 printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "
 822                        "with same WWPN %16.16llx\n",
 823                        lport->host->host_no, remote_wwpn);
 824                 goto out;
 825         }
 826         FC_LPORT_DBG(lport, "FLOGI from port WWPN %16.16llx\n", remote_wwpn);
 827
 828         /*
 829          * XXX what is the right thing to do for FIDs?
 830          * The originator might expect our S_ID to be 0xfffffe.
 831          * But if so, both of us could end up with the same FID.
 832          */
 833         local_fid = FC_LOCAL_PTP_FID_LO;
 834         if (remote_wwpn < lport->wwpn) {
 835                 local_fid = FC_LOCAL_PTP_FID_HI;
 836                 if (!remote_fid || remote_fid == local_fid)
 837                         remote_fid = FC_LOCAL_PTP_FID_LO;
 838         } else if (!remote_fid) {
 839                 remote_fid = FC_LOCAL_PTP_FID_HI;
 840         }
 841
 842         fc_lport_set_port_id(lport, local_fid, rx_fp);
 843
 844         fp = fc_frame_alloc(lport, sizeof(*flp));
 845         if (fp) {
 846                 new_flp = fc_frame_payload_get(fp, sizeof(*flp));
 847                 fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI);
 848                 new_flp->fl_cmd = (u8) ELS_LS_ACC;
 849
 850                 /*
 851                  * Send the response.  If this fails, the originator should
 852                  * repeat the sequence.
 853                  */
 854                 fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
 855                 fh = fc_frame_header_get(fp);
 856                 hton24(fh->fh_s_id, local_fid);
 857                 hton24(fh->fh_d_id, remote_fid);
 858                 lport->tt.frame_send(lport, fp);
 859
 860         } else {
 861                 fc_lport_error(lport, fp);
 862         }
 863         fc_lport_ptp_setup(lport, remote_fid, remote_wwpn,
 864                            get_unaligned_be64(&flp->fl_wwnn));
 865 out:
 866         fc_frame_free(rx_fp);
 867 }
 868
 869 /**
 870  * fc_lport_recv_els_req() - The generic lport ELS request handler
 871  * @lport: The local port that received the request
 872  * @fp:    The request frame
 873  *
 874  * This function will see if the lport handles the request or
 875  * if an rport should handle the request.
 876  *
 877  * Locking Note: This function should not be called with the lport
 878  *               lock held because it will grab the lock.
 879  */
 880 static void fc_lport_recv_els_req(struct fc_lport *lport,
 881                                   struct fc_frame *fp)
 882 {
 883         void (*recv)(struct fc_lport *, struct fc_frame *);
 884
 885         mutex_lock(&lport->lp_mutex);
 886
 887         /*
 888          * Handle special ELS cases like FLOGI, LOGO, and
 889          * RSCN here.  These don't require a session.
 890          * Even if we had a session, it might not be ready.
 891          */
 892         if (!lport->link_up)
 893                 fc_frame_free(fp);
 894         else {
 895                 /*
 896                  * Check opcode.
 897                  */
 898                 recv = lport->tt.rport_recv_req;
 899                 switch (fc_frame_payload_op(fp)) {
 900                 case ELS_FLOGI:
 901                         if (!lport->point_to_multipoint)
 902                                 recv = fc_lport_recv_flogi_req;
 903                         break;
 904                 case ELS_LOGO:
 905                         if (fc_frame_sid(fp) == FC_FID_FLOGI)
 906                                 recv = fc_lport_recv_logo_req;
 907                         break;
 908                 case ELS_RSCN:
 909                         recv = lport->tt.disc_recv_req;
 910                         break;
 911                 case ELS_ECHO:
 912                         recv = fc_lport_recv_echo_req;
 913                         break;
 914                 case ELS_RLIR:
 915                         recv = fc_lport_recv_rlir_req;
 916                         break;
 917                 case ELS_RNID:
 918                         recv = fc_lport_recv_rnid_req;
 919                         break;
 920                 }
 921
 922                 recv(lport, fp);
 923         }
 924         mutex_unlock(&lport->lp_mutex);
 925 }
 926
 927 static int fc_lport_els_prli(struct fc_rport_priv *rdata, u32 spp_len,
 928                              const struct fc_els_spp *spp_in,
 929                              struct fc_els_spp *spp_out)
 930 {
 931         return FC_SPP_RESP_INVL;
 932 }
 933
 934 struct fc4_prov fc_lport_els_prov = {
 935         .prli = fc_lport_els_prli,
 936         .recv = fc_lport_recv_els_req,
 937 };
 938
 939 /**
 940  * fc_lport_recv_req() - The generic lport request handler
 941  * @lport: The lport that received the request
 942  * @fp: The frame the request is in
 943  *
 944  * Locking Note: This function should not be called with the lport
 945  *               lock held because it may grab the lock.
 946  */
 947 static void fc_lport_recv_req(struct fc_lport *lport,
 948                               struct fc_frame *fp)
 949 {
 950         struct fc_frame_header *fh = fc_frame_header_get(fp);
 951         struct fc_seq *sp = fr_seq(fp);
 952         struct fc4_prov *prov;
 953
 954         /*
 955          * Use RCU read lock and module_lock to be sure module doesn't
 956          * deregister and get unloaded while we're calling it.
 957          * try_module_get() is inlined and accepts a NULL parameter.
 958          * Only ELSes and FCP target ops should come through here.
 959          * The locking is unfortunate, and a better scheme is being sought.
 960          */
 961
 962         rcu_read_lock();
 963         if (fh->fh_type >= FC_FC4_PROV_SIZE)
 964                 goto drop;
 965         prov = rcu_dereference(fc_passive_prov[fh->fh_type]);
 966         if (!prov || !try_module_get(prov->module))
 967                 goto drop;
 968         rcu_read_unlock();
 969         prov->recv(lport, fp);
 970         module_put(prov->module);
 971         return;
 972 drop:
 973         rcu_read_unlock();
 974         FC_LPORT_DBG(lport, "dropping unexpected frame type %x\n", fh->fh_type);
 975         fc_frame_free(fp);
 976         lport->tt.exch_done(sp);
 977 }
 978
 979 /**
 980  * fc_lport_reset() - Reset a local port
 981  * @lport: The local port which should be reset
 982  *
 983  * Locking Note: This functions should not be called with the
 984  *               lport lock held.
 985  */
 986 int fc_lport_reset(struct fc_lport *lport)
 987 {
 988         cancel_delayed_work_sync(&lport->retry_work);
 989         mutex_lock(&lport->lp_mutex);
 990         fc_lport_enter_reset(lport);
 991         mutex_unlock(&lport->lp_mutex);
 992         return 0;
 993 }
 994 EXPORT_SYMBOL(fc_lport_reset);
 995
 996 /**
 997  * fc_lport_reset_locked() - Reset the local port w/ the lport lock held
 998  * @lport: The local port to be reset
 999  *
1000  * Locking Note: The lport lock is expected to be held before calling
1001  * this routine.
1002  */
1003 static void fc_lport_reset_locked(struct fc_lport *lport)
1004 {
1005         if (lport->dns_rdata)
1006                 lport->tt.rport_logoff(lport->dns_rdata);
1007
1008         if (lport->ptp_rdata) {
1009                 lport->tt.rport_logoff(lport->ptp_rdata);
1010                 kref_put(&lport->ptp_rdata->kref, lport->tt.rport_destroy);
1011                 lport->ptp_rdata = NULL;
1012         }
1013
1014         lport->tt.disc_stop(lport);
1015
1016         lport->tt.exch_mgr_reset(lport, 0, 0);
1017         fc_host_fabric_name(lport->host) = 0;
1018
1019         if (lport->port_id && (!lport->point_to_multipoint || !lport->link_up))
1020                 fc_lport_set_port_id(lport, 0, NULL);
1021 }
1022
1023 /**
1024  * fc_lport_enter_reset() - Reset the local port
1025  * @lport: The local port to be reset
1026  *
1027  * Locking Note: The lport lock is expected to be held before calling
1028  * this routine.
1029  */
1030 static void fc_lport_enter_reset(struct fc_lport *lport)
1031 {
1032         FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
1033                      fc_lport_state(lport));
1034
1035         if (lport->state == LPORT_ST_DISABLED || lport->state == LPORT_ST_LOGO)
1036                 return;
1037
1038         if (lport->vport) {
1039                 if (lport->link_up)
1040                         fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);
1041                 else
1042                         fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);
1043         }
1044         fc_lport_state_enter(lport, LPORT_ST_RESET);
1045         fc_host_post_event(lport->host, fc_get_event_number(),
1046                            FCH_EVT_LIPRESET, 0);
1047         fc_vports_linkchange(lport);
1048         fc_lport_reset_locked(lport);
1049         if (lport->link_up)
1050                 fc_lport_enter_flogi(lport);
1051 }
1052
1053 /**
1054  * fc_lport_enter_disabled() - Disable the local port
1055  * @lport: The local port to be reset
1056  *
1057  * Locking Note: The lport lock is expected to be held before calling
1058  * this routine.
1059  */
1060 static void fc_lport_enter_disabled(struct fc_lport *lport)
1061 {
1062         FC_LPORT_DBG(lport, "Entered disabled state from %s state\n",
1063                      fc_lport_state(lport));
1064
1065         fc_lport_state_enter(lport, LPORT_ST_DISABLED);
1066         fc_vports_linkchange(lport);
1067         fc_lport_reset_locked(lport);
1068 }
1069
1070 /**
1071  * fc_lport_error() - Handler for any errors
1072  * @lport: The local port that the error was on
1073  * @fp:    The error code encoded in a frame pointer
1074  *
1075  * If the error was caused by a resource allocation failure
1076  * then wait for half a second and retry, otherwise retry
1077  * after the e_d_tov time.
1078  */
1079 static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
1080 {
1081         unsigned long delay = 0;
1082         FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d\n",
1083                      PTR_ERR(fp), fc_lport_state(lport),
1084                      lport->retry_count);
1085
1086         if (PTR_ERR(fp) == -FC_EX_CLOSED)
1087                 return;
1088
1089         /*
1090          * Memory allocation failure, or the exchange timed out
1091          * or we received LS_RJT.
1092          * Retry after delay
1093          */
1094         if (lport->retry_count < lport->max_retry_count) {
1095                 lport->retry_count++;
1096                 if (!fp)
1097                         delay = msecs_to_jiffies(500);
1098                 else
1099                         delay = msecs_to_jiffies(lport->e_d_tov);
1100
1101                 schedule_delayed_work(&lport->retry_work, delay);
1102         } else
1103                 fc_lport_enter_reset(lport);
1104 }
1105
1106 /**
1107  * fc_lport_ns_resp() - Handle response to a name server
1108  *                      registration exchange
1109  * @sp:     current sequence in exchange
1110  * @fp:     response frame
1111  * @lp_arg: Fibre Channel host port instance
1112  *
1113  * Locking Note: This function will be called without the lport lock
1114  * held, but it will lock, call an _enter_* function or fc_lport_error()
1115  * and then unlock the lport.
1116  */
1117 static void fc_lport_ns_resp(struct fc_seq *sp, struct fc_frame *fp,
1118                              void *lp_arg)
1119 {
1120         struct fc_lport *lport = lp_arg;
1121         struct fc_frame_header *fh;
1122         struct fc_ct_hdr *ct;
1123
1124         FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp));
1125
1126         if (fp == ERR_PTR(-FC_EX_CLOSED))
1127                 return;
1128
1129         mutex_lock(&lport->lp_mutex);
1130
1131         if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) {
1132                 FC_LPORT_DBG(lport, "Received a name server response, "
1133                              "but in state %s\n", fc_lport_state(lport));
1134                 if (IS_ERR(fp))
1135                         goto err;
1136                 goto out;
1137         }
1138
1139         if (IS_ERR(fp)) {
1140                 fc_lport_error(lport, fp);
1141                 goto err;
1142         }
1143
1144         fh = fc_frame_header_get(fp);
1145         ct = fc_frame_payload_get(fp, sizeof(*ct));
1146
1147         if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1148             ct->ct_fs_type == FC_FST_DIR &&
1149             ct->ct_fs_subtype == FC_NS_SUBTYPE &&
1150             ntohs(ct->ct_cmd) == FC_FS_ACC)
1151                 switch (lport->state) {
1152                 case LPORT_ST_RNN_ID:
1153                         fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN);
1154                         break;
1155                 case LPORT_ST_RSNN_NN:
1156                         fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID);
1157                         break;
1158                 case LPORT_ST_RSPN_ID:
1159                         fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1160                         break;
1161                 case LPORT_ST_RFT_ID:
1162                         fc_lport_enter_ns(lport, LPORT_ST_RFF_ID);
1163                         break;
1164                 case LPORT_ST_RFF_ID:
1165                         if (lport->fdmi_enabled)
1166                                 fc_lport_enter_fdmi(lport);
1167                         else
1168                                 fc_lport_enter_scr(lport);
1169                         break;
1170                 default:
1171                         /* should have already been caught by state checks */
1172                         break;
1173                 }
1174         else
1175                 fc_lport_error(lport, fp);
1176 out:
1177         fc_frame_free(fp);
1178 err:
1179         mutex_unlock(&lport->lp_mutex);
1180 }
1181
1182 /**
1183  * fc_lport_ms_resp() - Handle response to a management server
1184  *                      exchange
1185  * @sp:     current sequence in exchange
1186  * @fp:     response frame
1187  * @lp_arg: Fibre Channel host port instance
1188  *
1189  * Locking Note: This function will be called without the lport lock
1190  * held, but it will lock, call an _enter_* function or fc_lport_error()
1191  * and then unlock the lport.
1192  */
1193 static void fc_lport_ms_resp(struct fc_seq *sp, struct fc_frame *fp,
1194                              void *lp_arg)
1195 {
1196         struct fc_lport *lport = lp_arg;
1197         struct fc_frame_header *fh;
1198         struct fc_ct_hdr *ct;
1199
1200         FC_LPORT_DBG(lport, "Received a ms %s\n", fc_els_resp_type(fp));
1201
1202         if (fp == ERR_PTR(-FC_EX_CLOSED))
1203                 return;
1204
1205         mutex_lock(&lport->lp_mutex);
1206
1207         if (lport->state < LPORT_ST_RHBA || lport->state > LPORT_ST_DPRT) {
1208                 FC_LPORT_DBG(lport, "Received a management server response, "
1209                              "but in state %s\n", fc_lport_state(lport));
1210                 if (IS_ERR(fp))
1211                         goto err;
1212                 goto out;
1213         }
1214
1215         if (IS_ERR(fp)) {
1216                 fc_lport_error(lport, fp);
1217                 goto err;
1218         }
1219
1220         fh = fc_frame_header_get(fp);
1221         ct = fc_frame_payload_get(fp, sizeof(*ct));
1222
1223         if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1224             ct->ct_fs_type == FC_FST_MGMT &&
1225             ct->ct_fs_subtype == FC_FDMI_SUBTYPE) {
1226                 FC_LPORT_DBG(lport, "Received a management server response, "
1227                                     "reason=%d explain=%d\n",
1228                                     ct->ct_reason,
1229                                     ct->ct_explan);
1230
1231                 switch (lport->state) {
1232                 case LPORT_ST_RHBA:
1233                         if (ntohs(ct->ct_cmd) == FC_FS_ACC)
1234                                 fc_lport_enter_ms(lport, LPORT_ST_RPA);
1235                         else /* Error Skip RPA */
1236                                 fc_lport_enter_scr(lport);
1237                         break;
1238                 case LPORT_ST_RPA:
1239                         fc_lport_enter_scr(lport);
1240                         break;
1241                 case LPORT_ST_DPRT:
1242                         fc_lport_enter_ms(lport, LPORT_ST_RHBA);
1243                         break;
1244                 case LPORT_ST_DHBA:
1245                         fc_lport_enter_ms(lport, LPORT_ST_DPRT);
1246                         break;
1247                 default:
1248                         /* should have already been caught by state checks */
1249                         break;
1250                 }
1251         } else {
1252                 /* Invalid Frame? */
1253                 fc_lport_error(lport, fp);
1254         }
1255 out:
1256         fc_frame_free(fp);
1257 err:
1258         mutex_unlock(&lport->lp_mutex);
1259 }
1260
1261 /**
1262  * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request
1263  * @sp:     current sequence in SCR exchange
1264  * @fp:     response frame
1265  * @lp_arg: Fibre Channel lport port instance that sent the registration request
1266  *
1267  * Locking Note: This function will be called without the lport lock
1268  * held, but it will lock, call an _enter_* function or fc_lport_error
1269  * and then unlock the lport.
1270  */
1271 static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
1272                               void *lp_arg)
1273 {
1274         struct fc_lport *lport = lp_arg;
1275         u8 op;
1276
1277         FC_LPORT_DBG(lport, "Received a SCR %s\n", fc_els_resp_type(fp));
1278
1279         if (fp == ERR_PTR(-FC_EX_CLOSED))
1280                 return;
1281
1282         mutex_lock(&lport->lp_mutex);
1283
1284         if (lport->state != LPORT_ST_SCR) {
1285                 FC_LPORT_DBG(lport, "Received a SCR response, but in state "
1286                              "%s\n", fc_lport_state(lport));
1287                 if (IS_ERR(fp))
1288                         goto err;
1289                 goto out;
1290         }
1291
1292         if (IS_ERR(fp)) {
1293                 fc_lport_error(lport, fp);
1294                 goto err;
1295         }
1296
1297         op = fc_frame_payload_op(fp);
1298         if (op == ELS_LS_ACC)
1299                 fc_lport_enter_ready(lport);
1300         else
1301                 fc_lport_error(lport, fp);
1302
1303 out:
1304         fc_frame_free(fp);
1305 err:
1306         mutex_unlock(&lport->lp_mutex);
1307 }
1308
1309 /**
1310  * fc_lport_enter_scr() - Send a SCR (State Change Register) request
1311  * @lport: The local port to register for state changes
1312  *
1313  * Locking Note: The lport lock is expected to be held before calling
1314  * this routine.
1315  */
1316 static void fc_lport_enter_scr(struct fc_lport *lport)
1317 {
1318         struct fc_frame *fp;
1319
1320         FC_LPORT_DBG(lport, "Entered SCR state from %s state\n",
1321                      fc_lport_state(lport));
1322
1323         fc_lport_state_enter(lport, LPORT_ST_SCR);
1324
1325         fp = fc_frame_alloc(lport, sizeof(struct fc_els_scr));
1326         if (!fp) {
1327                 fc_lport_error(lport, fp);
1328                 return;
1329         }
1330
1331         if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR,
1332                                   fc_lport_scr_resp, lport,
1333                                   2 * lport->r_a_tov))
1334                 fc_lport_error(lport, NULL);
1335 }
1336
1337 /**
1338  * fc_lport_enter_ns() - register some object with the name server
1339  * @lport: Fibre Channel local port to register
1340  *
1341  * Locking Note: The lport lock is expected to be held before calling
1342  * this routine.
1343  */
1344 static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
1345 {
1346         struct fc_frame *fp;
1347         enum fc_ns_req cmd;
1348         int size = sizeof(struct fc_ct_hdr);
1349         size_t len;
1350
1351         FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
1352                      fc_lport_state_names[state],
1353                      fc_lport_state(lport));
1354
1355         fc_lport_state_enter(lport, state);
1356
1357         switch (state) {
1358         case LPORT_ST_RNN_ID:
1359                 cmd = FC_NS_RNN_ID;
1360                 size += sizeof(struct fc_ns_rn_id);
1361                 break;
1362         case LPORT_ST_RSNN_NN:
1363                 len = strnlen(fc_host_symbolic_name(lport->host), 255);
1364                 /* if there is no symbolic name, skip to RFT_ID */
1365                 if (!len)
1366                         return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1367                 cmd = FC_NS_RSNN_NN;
1368                 size += sizeof(struct fc_ns_rsnn) + len;
1369                 break;
1370         case LPORT_ST_RSPN_ID:
1371                 len = strnlen(fc_host_symbolic_name(lport->host), 255);
1372                 /* if there is no symbolic name, skip to RFT_ID */
1373                 if (!len)
1374                         return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1375                 cmd = FC_NS_RSPN_ID;
1376                 size += sizeof(struct fc_ns_rspn) + len;
1377                 break;
1378         case LPORT_ST_RFT_ID:
1379                 cmd = FC_NS_RFT_ID;
1380                 size += sizeof(struct fc_ns_rft);
1381                 break;
1382         case LPORT_ST_RFF_ID:
1383                 cmd = FC_NS_RFF_ID;
1384                 size += sizeof(struct fc_ns_rff_id);
1385                 break;
1386         default:
1387                 fc_lport_error(lport, NULL);
1388                 return;
1389         }
1390
1391         fp = fc_frame_alloc(lport, size);
1392         if (!fp) {
1393                 fc_lport_error(lport, fp);
1394                 return;
1395         }
1396
1397         if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,
1398                                   fc_lport_ns_resp,
1399                                   lport, 3 * lport->r_a_tov))
1400                 fc_lport_error(lport, fp);
1401 }
1402
1403 static struct fc_rport_operations fc_lport_rport_ops = {
1404         .event_callback = fc_lport_rport_callback,
1405 };
1406
1407 /**
1408  * fc_rport_enter_dns() - Create a fc_rport for the name server
1409  * @lport: The local port requesting a remote port for the name server
1410  *
1411  * Locking Note: The lport lock is expected to be held before calling
1412  * this routine.
1413  */
1414 static void fc_lport_enter_dns(struct fc_lport *lport)
1415 {
1416         struct fc_rport_priv *rdata;
1417
1418         FC_LPORT_DBG(lport, "Entered DNS state from %s state\n",
1419                      fc_lport_state(lport));
1420
1421         fc_lport_state_enter(lport, LPORT_ST_DNS);
1422
1423         mutex_lock(&lport->disc.disc_mutex);
1424         rdata = lport->tt.rport_create(lport, FC_FID_DIR_SERV);
1425         mutex_unlock(&lport->disc.disc_mutex);
1426         if (!rdata)
1427                 goto err;
1428
1429         rdata->ops = &fc_lport_rport_ops;
1430         lport->tt.rport_login(rdata);
1431         return;
1432
1433 err:
1434         fc_lport_error(lport, NULL);
1435 }
1436
1437 /**
1438  * fc_lport_enter_ms() - management server commands
1439  * @lport: Fibre Channel local port to register
1440  *
1441  * Locking Note: The lport lock is expected to be held before calling
1442  * this routine.
1443  */
1444 static void fc_lport_enter_ms(struct fc_lport *lport, enum fc_lport_state state)
1445 {
1446         struct fc_frame *fp;
1447         enum fc_fdmi_req cmd;
1448         int size = sizeof(struct fc_ct_hdr);
1449         size_t len;
1450         int numattrs;
1451
1452         FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
1453                      fc_lport_state_names[state],
1454                      fc_lport_state(lport));
1455
1456         fc_lport_state_enter(lport, state);
1457
1458         switch (state) {
1459         case LPORT_ST_RHBA:
1460                 cmd = FC_FDMI_RHBA;
1461                 /* Number of HBA Attributes */
1462                 numattrs = 10;
1463                 len = sizeof(struct fc_fdmi_rhba);
1464                 len -= sizeof(struct fc_fdmi_attr_entry);
1465                 len += (numattrs * FC_FDMI_ATTR_ENTRY_HEADER_LEN);
1466                 len += FC_FDMI_HBA_ATTR_NODENAME_LEN;
1467                 len += FC_FDMI_HBA_ATTR_MANUFACTURER_LEN;
1468                 len += FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN;
1469                 len += FC_FDMI_HBA_ATTR_MODEL_LEN;
1470                 len += FC_FDMI_HBA_ATTR_MODELDESCR_LEN;
1471                 len += FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN;
1472                 len += FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN;
1473                 len += FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN;
1474                 len += FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN;
1475                 len += FC_FDMI_HBA_ATTR_OSNAMEVERSION_LEN;
1476
1477                 size += len;
1478                 break;
1479         case LPORT_ST_RPA:
1480                 cmd = FC_FDMI_RPA;
1481                 /* Number of Port Attributes */
1482                 numattrs = 6;
1483                 len = sizeof(struct fc_fdmi_rpa);
1484                 len -= sizeof(struct fc_fdmi_attr_entry);
1485                 len += (numattrs * FC_FDMI_ATTR_ENTRY_HEADER_LEN);
1486                 len += FC_FDMI_PORT_ATTR_FC4TYPES_LEN;
1487                 len += FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN;
1488                 len += FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN;
1489                 len += FC_FDMI_PORT_ATTR_MAXFRAMESIZE_LEN;
1490                 len += FC_FDMI_PORT_ATTR_OSDEVICENAME_LEN;
1491                 len += FC_FDMI_PORT_ATTR_HOSTNAME_LEN;
1492
1493                 size += len;
1494                 break;
1495         case LPORT_ST_DPRT:
1496                 cmd = FC_FDMI_DPRT;
1497                 len = sizeof(struct fc_fdmi_dprt);
1498                 size += len;
1499                 break;
1500         case LPORT_ST_DHBA:
1501                 cmd = FC_FDMI_DHBA;
1502                 len = sizeof(struct fc_fdmi_dhba);
1503                 size += len;
1504                 break;
1505         default:
1506                 fc_lport_error(lport, NULL);
1507                 return;
1508         }
1509
1510         FC_LPORT_DBG(lport, "Cmd=0x%x Len %d size %d\n",
1511                              cmd, (int)len, size);
1512         fp = fc_frame_alloc(lport, size);
1513         if (!fp) {
1514                 fc_lport_error(lport, fp);
1515                 return;
1516         }
1517
1518         if (!lport->tt.elsct_send(lport, FC_FID_MGMT_SERV, fp, cmd,
1519                                   fc_lport_ms_resp,
1520                                   lport, 3 * lport->r_a_tov))
1521                 fc_lport_error(lport, fp);
1522 }
1523
1524 /**
1525  * fc_rport_enter_fdmi() - Create a fc_rport for the management server
1526  * @lport: The local port requesting a remote port for the management server
1527  *
1528  * Locking Note: The lport lock is expected to be held before calling
1529  * this routine.
1530  */
1531 static void fc_lport_enter_fdmi(struct fc_lport *lport)
1532 {
1533         struct fc_rport_priv *rdata;
1534
1535         FC_LPORT_DBG(lport, "Entered FDMI state from %s state\n",
1536                      fc_lport_state(lport));
1537
1538         fc_lport_state_enter(lport, LPORT_ST_FDMI);
1539
1540         mutex_lock(&lport->disc.disc_mutex);
1541         rdata = lport->tt.rport_create(lport, FC_FID_MGMT_SERV);
1542         mutex_unlock(&lport->disc.disc_mutex);
1543         if (!rdata)
1544                 goto err;
1545
1546         rdata->ops = &fc_lport_rport_ops;
1547         lport->tt.rport_login(rdata);
1548         return;
1549
1550 err:
1551         fc_lport_error(lport, NULL);
1552 }
1553
1554 /**
1555  * fc_lport_timeout() - Handler for the retry_work timer
1556  * @work: The work struct of the local port
1557  */
1558 static void fc_lport_timeout(struct work_struct *work)
1559 {
1560         struct fc_lport *lport =
1561                 container_of(work, struct fc_lport,
1562                              retry_work.work);
1563
1564         mutex_lock(&lport->lp_mutex);
1565
1566         switch (lport->state) {
1567         case LPORT_ST_DISABLED:
1568                 break;
1569         case LPORT_ST_READY:
1570                 break;
1571         case LPORT_ST_RESET:
1572                 break;
1573         case LPORT_ST_FLOGI:
1574                 fc_lport_enter_flogi(lport);
1575                 break;
1576         case LPORT_ST_DNS:
1577                 fc_lport_enter_dns(lport);
1578                 break;
1579         case LPORT_ST_RNN_ID:
1580         case LPORT_ST_RSNN_NN:
1581         case LPORT_ST_RSPN_ID:
1582         case LPORT_ST_RFT_ID:
1583         case LPORT_ST_RFF_ID:
1584                 fc_lport_enter_ns(lport, lport->state);
1585                 break;
1586         case LPORT_ST_FDMI:
1587                 fc_lport_enter_fdmi(lport);
1588                 break;
1589         case LPORT_ST_RHBA:
1590         case LPORT_ST_RPA:
1591         case LPORT_ST_DHBA:
1592         case LPORT_ST_DPRT:
1593                 fc_lport_enter_ms(lport, lport->state);
1594                 break;
1595         case LPORT_ST_SCR:
1596                 fc_lport_enter_scr(lport);
1597                 break;
1598         case LPORT_ST_LOGO:
1599                 fc_lport_enter_logo(lport);
1600                 break;
1601         }
1602
1603         mutex_unlock(&lport->lp_mutex);
1604 }
1605
1606 /**
1607  * fc_lport_logo_resp() - Handle response to LOGO request
1608  * @sp:     The sequence that the LOGO was on
1609  * @fp:     The LOGO frame
1610  * @lp_arg: The lport port that received the LOGO request
1611  *
1612  * Locking Note: This function will be called without the lport lock
1613  * held, but it will lock, call an _enter_* function or fc_lport_error()
1614  * and then unlock the lport.
1615  */
1616 void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
1617                         void *lp_arg)
1618 {
1619         struct fc_lport *lport = lp_arg;
1620         u8 op;
1621
1622         FC_LPORT_DBG(lport, "Received a LOGO %s\n", fc_els_resp_type(fp));
1623
1624         if (fp == ERR_PTR(-FC_EX_CLOSED))
1625                 return;
1626
1627         mutex_lock(&lport->lp_mutex);
1628
1629         if (lport->state != LPORT_ST_LOGO) {
1630                 FC_LPORT_DBG(lport, "Received a LOGO response, but in state "
1631                              "%s\n", fc_lport_state(lport));
1632                 if (IS_ERR(fp))
1633                         goto err;
1634                 goto out;
1635         }
1636
1637         if (IS_ERR(fp)) {
1638                 fc_lport_error(lport, fp);
1639                 goto err;
1640         }
1641
1642         op = fc_frame_payload_op(fp);
1643         if (op == ELS_LS_ACC)
1644                 fc_lport_enter_disabled(lport);
1645         else
1646                 fc_lport_error(lport, fp);
1647
1648 out:
1649         fc_frame_free(fp);
1650 err:
1651         mutex_unlock(&lport->lp_mutex);
1652 }
1653 EXPORT_SYMBOL(fc_lport_logo_resp);
1654
1655 /**
1656  * fc_rport_enter_logo() - Logout of the fabric
1657  * @lport: The local port to be logged out
1658  *
1659  * Locking Note: The lport lock is expected to be held before calling
1660  * this routine.
1661  */
1662 static void fc_lport_enter_logo(struct fc_lport *lport)
1663 {
1664         struct fc_frame *fp;
1665         struct fc_els_logo *logo;
1666
1667         FC_LPORT_DBG(lport, "Entered LOGO state from %s state\n",
1668                      fc_lport_state(lport));
1669
1670         fc_lport_state_enter(lport, LPORT_ST_LOGO);
1671         fc_vports_linkchange(lport);
1672
1673         fp = fc_frame_alloc(lport, sizeof(*logo));
1674         if (!fp) {
1675                 fc_lport_error(lport, fp);
1676                 return;
1677         }
1678
1679         if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO,
1680                                   fc_lport_logo_resp, lport,
1681                                   2 * lport->r_a_tov))
1682                 fc_lport_error(lport, NULL);
1683 }
1684
1685 /**
1686  * fc_lport_flogi_resp() - Handle response to FLOGI request
1687  * @sp:     The sequence that the FLOGI was on
1688  * @fp:     The FLOGI response frame
1689  * @lp_arg: The lport port that received the FLOGI response
1690  *
1691  * Locking Note: This function will be called without the lport lock
1692  * held, but it will lock, call an _enter_* function or fc_lport_error()
1693  * and then unlock the lport.
1694  */
1695 void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
1696                          void *lp_arg)
1697 {
1698         struct fc_lport *lport = lp_arg;
1699         struct fc_frame_header *fh;
1700         struct fc_els_flogi *flp;
1701         u32 did;
1702         u16 csp_flags;
1703         unsigned int r_a_tov;
1704         unsigned int e_d_tov;
1705         u16 mfs;
1706
1707         FC_LPORT_DBG(lport, "Received a FLOGI %s\n", fc_els_resp_type(fp));
1708
1709         if (fp == ERR_PTR(-FC_EX_CLOSED))
1710                 return;
1711
1712         mutex_lock(&lport->lp_mutex);
1713
1714         if (lport->state != LPORT_ST_FLOGI) {
1715                 FC_LPORT_DBG(lport, "Received a FLOGI response, but in state "
1716                              "%s\n", fc_lport_state(lport));
1717                 if (IS_ERR(fp))
1718                         goto err;
1719                 goto out;
1720         }
1721
1722         if (IS_ERR(fp)) {
1723                 fc_lport_error(lport, fp);
1724                 goto err;
1725         }
1726
1727         fh = fc_frame_header_get(fp);
1728         did = fc_frame_did(fp);
1729         if (fh->fh_r_ctl != FC_RCTL_ELS_REP || did == 0 ||
1730             fc_frame_payload_op(fp) != ELS_LS_ACC) {
1731                 FC_LPORT_DBG(lport, "FLOGI not accepted or bad response\n");
1732                 fc_lport_error(lport, fp);
1733                 goto err;
1734         }
1735
1736         flp = fc_frame_payload_get(fp, sizeof(*flp));
1737         if (!flp) {
1738                 FC_LPORT_DBG(lport, "FLOGI bad response\n");
1739                 fc_lport_error(lport, fp);
1740                 goto err;
1741         }
1742
1743         mfs = ntohs(flp->fl_csp.sp_bb_data) &
1744                 FC_SP_BB_DATA_MASK;
1745
1746         if (mfs < FC_SP_MIN_MAX_PAYLOAD || mfs > FC_SP_MAX_MAX_PAYLOAD) {
1747                 FC_LPORT_DBG(lport, "FLOGI bad mfs:%hu response, "
1748                              "lport->mfs:%hu\n", mfs, lport->mfs);
1749                 fc_lport_error(lport, fp);
1750                 goto err;
1751         }
1752
1753         if (mfs <= lport->mfs) {
1754                 lport->mfs = mfs;
1755                 fc_host_maxframe_size(lport->host) = mfs;
1756         }
1757
1758         csp_flags = ntohs(flp->fl_csp.sp_features);
1759         r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov);
1760         e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
1761         if (csp_flags & FC_SP_FT_EDTR)
1762                 e_d_tov /= 1000000;
1763
1764         lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC);
1765
1766         if ((csp_flags & FC_SP_FT_FPORT) == 0) {
1767                 if (e_d_tov > lport->e_d_tov)
1768                         lport->e_d_tov = e_d_tov;
1769                 lport->r_a_tov = 2 * e_d_tov;
1770                 fc_lport_set_port_id(lport, did, fp);
1771                 printk(KERN_INFO "host%d: libfc: "
1772                        "Port (%6.6x) entered "
1773                        "point-to-point mode\n",
1774                        lport->host->host_no, did);
1775                 fc_lport_ptp_setup(lport, fc_frame_sid(fp),
1776                                    get_unaligned_be64(
1777                                            &flp->fl_wwpn),
1778                                    get_unaligned_be64(
1779                                            &flp->fl_wwnn));
1780         } else {
1781                 lport->e_d_tov = e_d_tov;
1782                 lport->r_a_tov = r_a_tov;
1783                 fc_host_fabric_name(lport->host) =
1784                         get_unaligned_be64(&flp->fl_wwnn);
1785                 fc_lport_set_port_id(lport, did, fp);
1786                 fc_lport_enter_dns(lport);
1787         }
1788
1789 out:
1790         fc_frame_free(fp);
1791 err:
1792         mutex_unlock(&lport->lp_mutex);
1793 }
1794 EXPORT_SYMBOL(fc_lport_flogi_resp);
1795
1796 /**
1797  * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager
1798  * @lport: Fibre Channel local port to be logged in to the fabric
1799  *
1800  * Locking Note: The lport lock is expected to be held before calling
1801  * this routine.
1802  */
1803 static void fc_lport_enter_flogi(struct fc_lport *lport)
1804 {
1805         struct fc_frame *fp;
1806
1807         FC_LPORT_DBG(lport, "Entered FLOGI state from %s state\n",
1808                      fc_lport_state(lport));
1809
1810         fc_lport_state_enter(lport, LPORT_ST_FLOGI);
1811
1812         if (lport->point_to_multipoint) {
1813                 if (lport->port_id)
1814                         fc_lport_enter_ready(lport);
1815                 return;
1816         }
1817
1818         fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
1819         if (!fp)
1820                 return fc_lport_error(lport, fp);
1821
1822         if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
1823                                   lport->vport ? ELS_FDISC : ELS_FLOGI,
1824                                   fc_lport_flogi_resp, lport,
1825                                   lport->vport ? 2 * lport->r_a_tov :
1826                                   lport->e_d_tov))
1827                 fc_lport_error(lport, NULL);
1828 }
1829
1830 /**
1831  * fc_lport_config() - Configure a fc_lport
1832  * @lport: The local port to be configured
1833  */
1834 int fc_lport_config(struct fc_lport *lport)
1835 {
1836         INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
1837         mutex_init(&lport->lp_mutex);
1838
1839         fc_lport_state_enter(lport, LPORT_ST_DISABLED);
1840
1841         fc_lport_add_fc4_type(lport, FC_TYPE_FCP);
1842         fc_lport_add_fc4_type(lport, FC_TYPE_CT);
1843         fc_fc4_conf_lport_params(lport, FC_TYPE_FCP);
1844
1845         return 0;
1846 }
1847 EXPORT_SYMBOL(fc_lport_config);
1848
1849 /**
1850  * fc_lport_init() - Initialize the lport layer for a local port
1851  * @lport: The local port to initialize the exchange layer for
1852  */
1853 int fc_lport_init(struct fc_lport *lport)
1854 {
1855         if (!lport->tt.lport_recv)
1856                 lport->tt.lport_recv = fc_lport_recv_req;
1857
1858         if (!lport->tt.lport_reset)
1859                 lport->tt.lport_reset = fc_lport_reset;
1860
1861         fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
1862         fc_host_node_name(lport->host) = lport->wwnn;
1863         fc_host_port_name(lport->host) = lport->wwpn;
1864         fc_host_supported_classes(lport->host) = FC_COS_CLASS3;
1865         memset(fc_host_supported_fc4s(lport->host), 0,
1866                sizeof(fc_host_supported_fc4s(lport->host)));
1867         fc_host_supported_fc4s(lport->host)[2] = 1;
1868         fc_host_supported_fc4s(lport->host)[7] = 1;
1869
1870         /* This value is also unchanging */
1871         memset(fc_host_active_fc4s(lport->host), 0,
1872                sizeof(fc_host_active_fc4s(lport->host)));
1873         fc_host_active_fc4s(lport->host)[2] = 1;
1874         fc_host_active_fc4s(lport->host)[7] = 1;
1875         fc_host_maxframe_size(lport->host) = lport->mfs;
1876         fc_host_supported_speeds(lport->host) = 0;
1877         if (lport->link_supported_speeds & FC_PORTSPEED_1GBIT)
1878                 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_1GBIT;
1879         if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
1880                 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
1881         fc_fc4_add_lport(lport);
1882
1883         return 0;
1884 }
1885 EXPORT_SYMBOL(fc_lport_init);
1886
1887 /**
1888  * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests
1889  * @sp:       The sequence for the FC Passthrough response
1890  * @fp:       The response frame
1891  * @info_arg: The BSG info that the response is for
1892  */
1893 static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp,
1894                               void *info_arg)
1895 {
1896         struct fc_bsg_info *info = info_arg;
1897         struct fc_bsg_job *job = info->job;
1898         struct fc_lport *lport = info->lport;
1899         struct fc_frame_header *fh;
1900         size_t len;
1901         void *buf;
1902
1903         if (IS_ERR(fp)) {
1904                 job->reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ?
1905                         -ECONNABORTED : -ETIMEDOUT;
1906                 job->reply_len = sizeof(uint32_t);
1907                 job->state_flags |= FC_RQST_STATE_DONE;
1908                 job->job_done(job);
1909                 kfree(info);
1910                 return;
1911         }
1912
1913         mutex_lock(&lport->lp_mutex);
1914         fh = fc_frame_header_get(fp);
1915         len = fr_len(fp) - sizeof(*fh);
1916         buf = fc_frame_payload_get(fp, 0);
1917
1918         if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) {
1919                 /* Get the response code from the first frame payload */
1920                 unsigned short cmd = (info->rsp_code == FC_FS_ACC) ?
1921                         ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) :
1922                         (unsigned short)fc_frame_payload_op(fp);
1923
1924                 /* Save the reply status of the job */
1925                 job->reply->reply_data.ctels_reply.status =
1926                         (cmd == info->rsp_code) ?
1927                         FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT;
1928         }
1929
1930         job->reply->reply_payload_rcv_len +=
1931                 fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents,
1932                                          &info->offset, NULL);
1933
1934         if (fr_eof(fp) == FC_EOF_T &&
1935             (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
1936             (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
1937                 if (job->reply->reply_payload_rcv_len >
1938                     job->reply_payload.payload_len)
1939                         job->reply->reply_payload_rcv_len =
1940                                 job->reply_payload.payload_len;
1941                 job->reply->result = 0;
1942                 job->state_flags |= FC_RQST_STATE_DONE;
1943                 job->job_done(job);
1944                 kfree(info);
1945         }
1946         fc_frame_free(fp);
1947         mutex_unlock(&lport->lp_mutex);
1948 }
1949
1950 /**
1951  * fc_lport_els_request() - Send ELS passthrough request
1952  * @job:   The BSG Passthrough job
1953  * @lport: The local port sending the request
1954  * @did:   The destination port id
1955  *
1956  * Locking Note: The lport lock is expected to be held before calling
1957  * this routine.
1958  */
1959 static int fc_lport_els_request(struct fc_bsg_job *job,
1960                                 struct fc_lport *lport,
1961                                 u32 did, u32 tov)
1962 {
1963         struct fc_bsg_info *info;
1964         struct fc_frame *fp;
1965         struct fc_frame_header *fh;
1966         char *pp;
1967         int len;
1968
1969         fp = fc_frame_alloc(lport, job->request_payload.payload_len);
1970         if (!fp)
1971                 return -ENOMEM;
1972
1973         len = job->request_payload.payload_len;
1974         pp = fc_frame_payload_get(fp, len);
1975
1976         sg_copy_to_buffer(job->request_payload.sg_list,
1977                           job->request_payload.sg_cnt,
1978                           pp, len);
1979
1980         fh = fc_frame_header_get(fp);
1981         fh->fh_r_ctl = FC_RCTL_ELS_REQ;
1982         hton24(fh->fh_d_id, did);
1983         hton24(fh->fh_s_id, lport->port_id);
1984         fh->fh_type = FC_TYPE_ELS;
1985         hton24(fh->fh_f_ctl, FC_FCTL_REQ);
1986         fh->fh_cs_ctl = 0;
1987         fh->fh_df_ctl = 0;
1988         fh->fh_parm_offset = 0;
1989
1990         info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
1991         if (!info) {
1992                 fc_frame_free(fp);
1993                 return -ENOMEM;
1994         }
1995
1996         info->job = job;
1997         info->lport = lport;
1998         info->rsp_code = ELS_LS_ACC;
1999         info->nents = job->reply_payload.sg_cnt;
2000         info->sg = job->reply_payload.sg_list;
2001
2002         if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
2003                                      NULL, info, tov)) {
2004                 kfree(info);
2005                 return -ECOMM;
2006         }
2007         return 0;
2008 }
2009
2010 /**
2011  * fc_lport_ct_request() - Send CT Passthrough request
2012  * @job:   The BSG Passthrough job
2013  * @lport: The local port sending the request
2014  * @did:   The destination FC-ID
2015  * @tov:   The timeout period to wait for the response
2016  *
2017  * Locking Note: The lport lock is expected to be held before calling
2018  * this routine.
2019  */
2020 static int fc_lport_ct_request(struct fc_bsg_job *job,
2021                                struct fc_lport *lport, u32 did, u32 tov)
2022 {
2023         struct fc_bsg_info *info;
2024         struct fc_frame *fp;
2025         struct fc_frame_header *fh;
2026         struct fc_ct_req *ct;
2027         size_t len;
2028
2029         fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
2030                             job->request_payload.payload_len);
2031         if (!fp)
2032                 return -ENOMEM;
2033
2034         len = job->request_payload.payload_len;
2035         ct = fc_frame_payload_get(fp, len);
2036
2037         sg_copy_to_buffer(job->request_payload.sg_list,
2038                           job->request_payload.sg_cnt,
2039                           ct, len);
2040
2041         fh = fc_frame_header_get(fp);
2042         fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL;
2043         hton24(fh->fh_d_id, did);
2044         hton24(fh->fh_s_id, lport->port_id);
2045         fh->fh_type = FC_TYPE_CT;
2046         hton24(fh->fh_f_ctl, FC_FCTL_REQ);
2047         fh->fh_cs_ctl = 0;
2048         fh->fh_df_ctl = 0;
2049         fh->fh_parm_offset = 0;
2050
2051         info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
2052         if (!info) {
2053                 fc_frame_free(fp);
2054                 return -ENOMEM;
2055         }
2056
2057         info->job = job;
2058         info->lport = lport;
2059         info->rsp_code = FC_FS_ACC;
2060         info->nents = job->reply_payload.sg_cnt;
2061         info->sg = job->reply_payload.sg_list;
2062
2063         if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp,
2064                                      NULL, info, tov)) {
2065                 kfree(info);
2066                 return -ECOMM;
2067         }
2068         return 0;
2069 }
2070
2071 /**
2072  * fc_lport_bsg_request() - The common entry point for sending
2073  *                          FC Passthrough requests
2074  * @job: The BSG passthrough job
2075  */
2076 int fc_lport_bsg_request(struct fc_bsg_job *job)
2077 {
2078         struct request *rsp = job->req->next_rq;
2079         struct Scsi_Host *shost = job->shost;
2080         struct fc_lport *lport = shost_priv(shost);
2081         struct fc_rport *rport;
2082         struct fc_rport_priv *rdata;
2083         int rc = -EINVAL;
2084         u32 did;
2085
2086         job->reply->reply_payload_rcv_len = 0;
2087         if (rsp)
2088                 rsp->resid_len = job->reply_payload.payload_len;
2089
2090         mutex_lock(&lport->lp_mutex);
2091
2092         switch (job->request->msgcode) {
2093         case FC_BSG_RPT_ELS:
2094                 rport = job->rport;
2095                 if (!rport)
2096                         break;
2097
2098                 rdata = rport->dd_data;
2099                 rc = fc_lport_els_request(job, lport, rport->port_id,
2100                                           rdata->e_d_tov);
2101                 break;
2102
2103         case FC_BSG_RPT_CT:
2104                 rport = job->rport;
2105                 if (!rport)
2106                         break;
2107
2108                 rdata = rport->dd_data;
2109                 rc = fc_lport_ct_request(job, lport, rport->port_id,
2110                                          rdata->e_d_tov);
2111                 break;
2112
2113         case FC_BSG_HST_CT:
2114                 did = ntoh24(job->request->rqst_data.h_ct.port_id);
2115                 if (did == FC_FID_DIR_SERV)
2116                         rdata = lport->dns_rdata;
2117                 else
2118                         rdata = lport->tt.rport_lookup(lport, did);
2119
2120                 if (!rdata)
2121                         break;
2122
2123                 rc = fc_lport_ct_request(job, lport, did, rdata->e_d_tov);
2124                 break;
2125
2126         case FC_BSG_HST_ELS_NOLOGIN:
2127                 did = ntoh24(job->request->rqst_data.h_els.port_id);
2128                 rc = fc_lport_els_request(job, lport, did, lport->e_d_tov);
2129                 break;
2130         }
2131
2132         mutex_unlock(&lport->lp_mutex);
2133         return rc;
2134 }
2135 EXPORT_SYMBOL(fc_lport_bsg_request);