drivers/scsi/libfc/fc_lport.c

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