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