drivers/scsi/libfc/fc_rport.c

   1 /*
   2  * Copyright(c) 2007 - 2008 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  * RPORT GENERAL INFO
  22  *
  23  * This file contains all processing regarding fc_rports. It contains the
  24  * rport state machine and does all rport interaction with the transport class.
  25  * There should be no other places in libfc that interact directly with the
  26  * transport class in regards to adding and deleting rports.
  27  *
  28  * fc_rport's represent N_Port's within the fabric.
  29  */
  30
  31 /*
  32  * RPORT LOCKING
  33  *
  34  * The rport should never hold the rport mutex and then attempt to acquire
  35  * either the lport or disc mutexes. The rport's mutex is considered lesser
  36  * than both the lport's mutex and the disc mutex. Refer to fc_lport.c for
  37  * more comments on the heirarchy.
  38  *
  39  * The locking strategy is similar to the lport's strategy. The lock protects
  40  * the rport's states and is held and released by the entry points to the rport
  41  * block. All _enter_* functions correspond to rport states and expect the rport
  42  * mutex to be locked before calling them. This means that rports only handle
  43  * one request or response at a time, since they're not critical for the I/O
  44  * path this potential over-use of the mutex is acceptable.
  45  */
  46
  47 #include <linux/kernel.h>
  48 #include <linux/spinlock.h>
  49 #include <linux/interrupt.h>
  50 #include <linux/rcupdate.h>
  51 #include <linux/timer.h>
  52 #include <linux/workqueue.h>
  53 #include <asm/unaligned.h>
  54
  55 #include <scsi/libfc.h>
  56 #include <scsi/fc_encode.h>
  57
  58 struct workqueue_struct *rport_event_queue;
  59
  60 static void fc_rport_enter_plogi(struct fc_rport *);
  61 static void fc_rport_enter_prli(struct fc_rport *);
  62 static void fc_rport_enter_rtv(struct fc_rport *);
  63 static void fc_rport_enter_ready(struct fc_rport *);
  64 static void fc_rport_enter_logo(struct fc_rport *);
  65
  66 static void fc_rport_recv_plogi_req(struct fc_rport *,
  67                                     struct fc_seq *, struct fc_frame *);
  68 static void fc_rport_recv_prli_req(struct fc_rport *,
  69                                    struct fc_seq *, struct fc_frame *);
  70 static void fc_rport_recv_prlo_req(struct fc_rport *,
  71                                    struct fc_seq *, struct fc_frame *);
  72 static void fc_rport_recv_logo_req(struct fc_rport *,
  73                                    struct fc_seq *, struct fc_frame *);
  74 static void fc_rport_timeout(struct work_struct *);
  75 static void fc_rport_error(struct fc_rport *, struct fc_frame *);
  76 static void fc_rport_error_retry(struct fc_rport *, struct fc_frame *);
  77 static void fc_rport_work(struct work_struct *);
  78
  79 static const char *fc_rport_state_names[] = {
  80         [RPORT_ST_NONE] = "None",
  81         [RPORT_ST_INIT] = "Init",
  82         [RPORT_ST_PLOGI] = "PLOGI",
  83         [RPORT_ST_PRLI] = "PRLI",
  84         [RPORT_ST_RTV] = "RTV",
  85         [RPORT_ST_READY] = "Ready",
  86         [RPORT_ST_LOGO] = "LOGO",
  87 };
  88
  89 static void fc_rport_rogue_destroy(struct device *dev)
  90 {
  91         struct fc_rport *rport = dev_to_rport(dev);
  92         FC_RPORT_DBG(rport, "Destroying rogue rport\n");
  93         kfree(rport);
  94 }
  95
  96 struct fc_rport *fc_rport_rogue_create(struct fc_disc_port *dp)
  97 {
  98         struct fc_rport *rport;
  99         struct fc_rport_libfc_priv *rdata;
 100         rport = kzalloc(sizeof(*rport) + sizeof(*rdata), GFP_KERNEL);
 101
 102         if (!rport)
 103                 return NULL;
 104
 105         rdata = RPORT_TO_PRIV(rport);
 106
 107         rport->dd_data = rdata;
 108         rport->port_id = dp->ids.port_id;
 109         rport->port_name = dp->ids.port_name;
 110         rport->node_name = dp->ids.node_name;
 111         rport->roles = dp->ids.roles;
 112         rport->maxframe_size = FC_MIN_MAX_PAYLOAD;
 113         /*
 114          * Note: all this libfc rogue rport code will be removed for
 115          * upstream so it fine that this is really ugly and hacky right now.
 116          */
 117         device_initialize(&rport->dev);
 118         rport->dev.release = fc_rport_rogue_destroy;
 119
 120         mutex_init(&rdata->rp_mutex);
 121         rdata->local_port = dp->lp;
 122         rdata->trans_state = FC_PORTSTATE_ROGUE;
 123         rdata->rp_state = RPORT_ST_INIT;
 124         rdata->event = RPORT_EV_NONE;
 125         rdata->flags = FC_RP_FLAGS_REC_SUPPORTED;
 126         rdata->ops = NULL;
 127         rdata->e_d_tov = dp->lp->e_d_tov;
 128         rdata->r_a_tov = dp->lp->r_a_tov;
 129         INIT_DELAYED_WORK(&rdata->retry_work, fc_rport_timeout);
 130         INIT_WORK(&rdata->event_work, fc_rport_work);
 131         /*
 132          * For good measure, but not necessary as we should only
 133          * add REAL rport to the lport list.
 134          */
 135         INIT_LIST_HEAD(&rdata->peers);
 136
 137         return rport;
 138 }
 139
 140 /**
 141  * fc_rport_state() - return a string for the state the rport is in
 142  * @rport: The rport whose state we want to get a string for
 143  */
 144 static const char *fc_rport_state(struct fc_rport *rport)
 145 {
 146         const char *cp;
 147         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 148
 149         cp = fc_rport_state_names[rdata->rp_state];
 150         if (!cp)
 151                 cp = "Unknown";
 152         return cp;
 153 }
 154
 155 /**
 156  * fc_set_rport_loss_tmo() - Set the remote port loss timeout in seconds.
 157  * @rport: Pointer to Fibre Channel remote port structure
 158  * @timeout: timeout in seconds
 159  */
 160 void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
 161 {
 162         if (timeout)
 163                 rport->dev_loss_tmo = timeout + 5;
 164         else
 165                 rport->dev_loss_tmo = 30;
 166 }
 167 EXPORT_SYMBOL(fc_set_rport_loss_tmo);
 168
 169 /**
 170  * fc_plogi_get_maxframe() - Get max payload from the common service parameters
 171  * @flp: FLOGI payload structure
 172  * @maxval: upper limit, may be less than what is in the service parameters
 173  */
 174 static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi *flp,
 175                                           unsigned int maxval)
 176 {
 177         unsigned int mfs;
 178
 179         /*
 180          * Get max payload from the common service parameters and the
 181          * class 3 receive data field size.
 182          */
 183         mfs = ntohs(flp->fl_csp.sp_bb_data) & FC_SP_BB_DATA_MASK;
 184         if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
 185                 maxval = mfs;
 186         mfs = ntohs(flp->fl_cssp[3 - 1].cp_rdfs);
 187         if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
 188                 maxval = mfs;
 189         return maxval;
 190 }
 191
 192 /**
 193  * fc_rport_state_enter() - Change the rport's state
 194  * @rport: The rport whose state should change
 195  * @new: The new state of the rport
 196  *
 197  * Locking Note: Called with the rport lock held
 198  */
 199 static void fc_rport_state_enter(struct fc_rport *rport,
 200                                  enum fc_rport_state new)
 201 {
 202         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 203         if (rdata->rp_state != new)
 204                 rdata->retries = 0;
 205         rdata->rp_state = new;
 206 }
 207
 208 static void fc_rport_work(struct work_struct *work)
 209 {
 210         u32 port_id;
 211         struct fc_rport_libfc_priv *rdata =
 212                 container_of(work, struct fc_rport_libfc_priv, event_work);
 213         enum fc_rport_event event;
 214         enum fc_rport_trans_state trans_state;
 215         struct fc_lport *lport = rdata->local_port;
 216         struct fc_rport_operations *rport_ops;
 217         struct fc_rport *rport = PRIV_TO_RPORT(rdata);
 218
 219         mutex_lock(&rdata->rp_mutex);
 220         event = rdata->event;
 221         rport_ops = rdata->ops;
 222
 223         if (event == RPORT_EV_CREATED) {
 224                 struct fc_rport *new_rport;
 225                 struct fc_rport_libfc_priv *new_rdata;
 226                 struct fc_rport_identifiers ids;
 227
 228                 ids.port_id = rport->port_id;
 229                 ids.roles = rport->roles;
 230                 ids.port_name = rport->port_name;
 231                 ids.node_name = rport->node_name;
 232
 233                 mutex_unlock(&rdata->rp_mutex);
 234
 235                 new_rport = fc_remote_port_add(lport->host, 0, &ids);
 236                 if (new_rport) {
 237                         /*
 238                          * Switch from the rogue rport to the rport
 239                          * returned by the FC class.
 240                          */
 241                         new_rport->maxframe_size = rport->maxframe_size;
 242
 243                         new_rdata = new_rport->dd_data;
 244                         new_rdata->e_d_tov = rdata->e_d_tov;
 245                         new_rdata->r_a_tov = rdata->r_a_tov;
 246                         new_rdata->ops = rdata->ops;
 247                         new_rdata->local_port = rdata->local_port;
 248                         new_rdata->flags = FC_RP_FLAGS_REC_SUPPORTED;
 249                         new_rdata->trans_state = FC_PORTSTATE_REAL;
 250                         mutex_init(&new_rdata->rp_mutex);
 251                         INIT_DELAYED_WORK(&new_rdata->retry_work,
 252                                           fc_rport_timeout);
 253                         INIT_LIST_HEAD(&new_rdata->peers);
 254                         INIT_WORK(&new_rdata->event_work, fc_rport_work);
 255
 256                         fc_rport_state_enter(new_rport, RPORT_ST_READY);
 257                 } else {
 258                         printk(KERN_WARNING "libfc: Failed to allocate "
 259                                " memory for rport (%6x)\n", ids.port_id);
 260                         event = RPORT_EV_FAILED;
 261                 }
 262                 if (rport->port_id != FC_FID_DIR_SERV)
 263                         if (rport_ops->event_callback)
 264                                 rport_ops->event_callback(lport, rport,
 265                                                           RPORT_EV_FAILED);
 266                 put_device(&rport->dev);
 267                 rport = new_rport;
 268                 rdata = new_rport->dd_data;
 269                 if (rport_ops->event_callback)
 270                         rport_ops->event_callback(lport, rport, event);
 271         } else if ((event == RPORT_EV_FAILED) ||
 272                    (event == RPORT_EV_LOGO) ||
 273                    (event == RPORT_EV_STOP)) {
 274                 trans_state = rdata->trans_state;
 275                 mutex_unlock(&rdata->rp_mutex);
 276                 if (rport_ops->event_callback)
 277                         rport_ops->event_callback(lport, rport, event);
 278                 if (trans_state == FC_PORTSTATE_ROGUE)
 279                         put_device(&rport->dev);
 280                 else {
 281                         port_id = rport->port_id;
 282                         fc_remote_port_delete(rport);
 283                         lport->tt.exch_mgr_reset(lport, 0, port_id);
 284                         lport->tt.exch_mgr_reset(lport, port_id, 0);
 285                 }
 286         } else
 287                 mutex_unlock(&rdata->rp_mutex);
 288 }
 289
 290 /**
 291  * fc_rport_login() - Start the remote port login state machine
 292  * @rport: Fibre Channel remote port
 293  *
 294  * Locking Note: Called without the rport lock held. This
 295  * function will hold the rport lock, call an _enter_*
 296  * function and then unlock the rport.
 297  */
 298 int fc_rport_login(struct fc_rport *rport)
 299 {
 300         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 301
 302         mutex_lock(&rdata->rp_mutex);
 303
 304         FC_RPORT_DBG(rport, "Login to port\n");
 305
 306         fc_rport_enter_plogi(rport);
 307
 308         mutex_unlock(&rdata->rp_mutex);
 309
 310         return 0;
 311 }
 312
 313 /**
 314  * fc_rport_logoff() - Logoff and remove an rport
 315  * @rport: Fibre Channel remote port to be removed
 316  *
 317  * Locking Note: Called without the rport lock held. This
 318  * function will hold the rport lock, call an _enter_*
 319  * function and then unlock the rport.
 320  */
 321 int fc_rport_logoff(struct fc_rport *rport)
 322 {
 323         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 324
 325         mutex_lock(&rdata->rp_mutex);
 326
 327         FC_RPORT_DBG(rport, "Remove port\n");
 328
 329         if (rdata->rp_state == RPORT_ST_NONE) {
 330                 FC_RPORT_DBG(rport, "Port in NONE state, not removing\n");
 331                 mutex_unlock(&rdata->rp_mutex);
 332                 goto out;
 333         }
 334
 335         fc_rport_enter_logo(rport);
 336
 337         /*
 338          * Change the state to NONE so that we discard
 339          * the response.
 340          */
 341         fc_rport_state_enter(rport, RPORT_ST_NONE);
 342
 343         mutex_unlock(&rdata->rp_mutex);
 344
 345         cancel_delayed_work_sync(&rdata->retry_work);
 346
 347         mutex_lock(&rdata->rp_mutex);
 348
 349         rdata->event = RPORT_EV_STOP;
 350         queue_work(rport_event_queue, &rdata->event_work);
 351
 352         mutex_unlock(&rdata->rp_mutex);
 353
 354 out:
 355         return 0;
 356 }
 357
 358 /**
 359  * fc_rport_enter_ready() - The rport is ready
 360  * @rport: Fibre Channel remote port that is ready
 361  *
 362  * Locking Note: The rport lock is expected to be held before calling
 363  * this routine.
 364  */
 365 static void fc_rport_enter_ready(struct fc_rport *rport)
 366 {
 367         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 368
 369         fc_rport_state_enter(rport, RPORT_ST_READY);
 370
 371         FC_RPORT_DBG(rport, "Port is Ready\n");
 372
 373         rdata->event = RPORT_EV_CREATED;
 374         queue_work(rport_event_queue, &rdata->event_work);
 375 }
 376
 377 /**
 378  * fc_rport_timeout() - Handler for the retry_work timer.
 379  * @work: The work struct of the fc_rport_libfc_priv
 380  *
 381  * Locking Note: Called without the rport lock held. This
 382  * function will hold the rport lock, call an _enter_*
 383  * function and then unlock the rport.
 384  */
 385 static void fc_rport_timeout(struct work_struct *work)
 386 {
 387         struct fc_rport_libfc_priv *rdata =
 388                 container_of(work, struct fc_rport_libfc_priv, retry_work.work);
 389         struct fc_rport *rport = PRIV_TO_RPORT(rdata);
 390
 391         mutex_lock(&rdata->rp_mutex);
 392
 393         switch (rdata->rp_state) {
 394         case RPORT_ST_PLOGI:
 395                 fc_rport_enter_plogi(rport);
 396                 break;
 397         case RPORT_ST_PRLI:
 398                 fc_rport_enter_prli(rport);
 399                 break;
 400         case RPORT_ST_RTV:
 401                 fc_rport_enter_rtv(rport);
 402                 break;
 403         case RPORT_ST_LOGO:
 404                 fc_rport_enter_logo(rport);
 405                 break;
 406         case RPORT_ST_READY:
 407         case RPORT_ST_INIT:
 408         case RPORT_ST_NONE:
 409                 break;
 410         }
 411
 412         mutex_unlock(&rdata->rp_mutex);
 413         put_device(&rport->dev);
 414 }
 415
 416 /**
 417  * fc_rport_error() - Error handler, called once retries have been exhausted
 418  * @rport: The fc_rport object
 419  * @fp: The frame pointer
 420  *
 421  * Locking Note: The rport lock is expected to be held before
 422  * calling this routine
 423  */
 424 static void fc_rport_error(struct fc_rport *rport, struct fc_frame *fp)
 425 {
 426         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 427
 428         FC_RPORT_DBG(rport, "Error %ld in state %s, retries %d\n",
 429                      PTR_ERR(fp), fc_rport_state(rport), rdata->retries);
 430
 431         switch (rdata->rp_state) {
 432         case RPORT_ST_PLOGI:
 433         case RPORT_ST_PRLI:
 434         case RPORT_ST_LOGO:
 435                 rdata->event = RPORT_EV_FAILED;
 436                 fc_rport_state_enter(rport, RPORT_ST_NONE);
 437                 queue_work(rport_event_queue,
 438                            &rdata->event_work);
 439                 break;
 440         case RPORT_ST_RTV:
 441                 fc_rport_enter_ready(rport);
 442                 break;
 443         case RPORT_ST_NONE:
 444         case RPORT_ST_READY:
 445         case RPORT_ST_INIT:
 446                 break;
 447         }
 448 }
 449
 450 /**
 451  * fc_rport_error_retry() - Error handler when retries are desired
 452  * @rport: The fc_rport object
 453  * @fp: The frame pointer
 454  *
 455  * If the error was an exchange timeout retry immediately,
 456  * otherwise wait for E_D_TOV.
 457  *
 458  * Locking Note: The rport lock is expected to be held before
 459  * calling this routine
 460  */
 461 static void fc_rport_error_retry(struct fc_rport *rport, struct fc_frame *fp)
 462 {
 463         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 464         unsigned long delay = FC_DEF_E_D_TOV;
 465
 466         /* make sure this isn't an FC_EX_CLOSED error, never retry those */
 467         if (PTR_ERR(fp) == -FC_EX_CLOSED)
 468                 return fc_rport_error(rport, fp);
 469
 470         if (rdata->retries < rdata->local_port->max_rport_retry_count) {
 471                 FC_RPORT_DBG(rport, "Error %ld in state %s, retrying\n",
 472                              PTR_ERR(fp), fc_rport_state(rport));
 473                 rdata->retries++;
 474                 /* no additional delay on exchange timeouts */
 475                 if (PTR_ERR(fp) == -FC_EX_TIMEOUT)
 476                         delay = 0;
 477                 get_device(&rport->dev);
 478                 schedule_delayed_work(&rdata->retry_work, delay);
 479                 return;
 480         }
 481
 482         return fc_rport_error(rport, fp);
 483 }
 484
 485 /**
 486  * fc_rport_plogi_recv_resp() - Handle incoming ELS PLOGI response
 487  * @sp: current sequence in the PLOGI exchange
 488  * @fp: response frame
 489  * @rp_arg: Fibre Channel remote port
 490  *
 491  * Locking Note: This function will be called without the rport lock
 492  * held, but it will lock, call an _enter_* function or fc_rport_error
 493  * and then unlock the rport.
 494  */
 495 static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 496                                 void *rp_arg)
 497 {
 498         struct fc_rport *rport = rp_arg;
 499         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 500         struct fc_lport *lport = rdata->local_port;
 501         struct fc_els_flogi *plp = NULL;
 502         unsigned int tov;
 503         u16 csp_seq;
 504         u16 cssp_seq;
 505         u8 op;
 506
 507         mutex_lock(&rdata->rp_mutex);
 508
 509         FC_RPORT_DBG(rport, "Received a PLOGI response\n");
 510
 511         if (rdata->rp_state != RPORT_ST_PLOGI) {
 512                 FC_RPORT_DBG(rport, "Received a PLOGI response, but in state "
 513                              "%s\n", fc_rport_state(rport));
 514                 if (IS_ERR(fp))
 515                         goto err;
 516                 goto out;
 517         }
 518
 519         if (IS_ERR(fp)) {
 520                 fc_rport_error_retry(rport, fp);
 521                 goto err;
 522         }
 523
 524         op = fc_frame_payload_op(fp);
 525         if (op == ELS_LS_ACC &&
 526             (plp = fc_frame_payload_get(fp, sizeof(*plp))) != NULL) {
 527                 rport->port_name = get_unaligned_be64(&plp->fl_wwpn);
 528                 rport->node_name = get_unaligned_be64(&plp->fl_wwnn);
 529
 530                 tov = ntohl(plp->fl_csp.sp_e_d_tov);
 531                 if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
 532                         tov /= 1000;
 533                 if (tov > rdata->e_d_tov)
 534                         rdata->e_d_tov = tov;
 535                 csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
 536                 cssp_seq = ntohs(plp->fl_cssp[3 - 1].cp_con_seq);
 537                 if (cssp_seq < csp_seq)
 538                         csp_seq = cssp_seq;
 539                 rdata->max_seq = csp_seq;
 540                 rport->maxframe_size =
 541                         fc_plogi_get_maxframe(plp, lport->mfs);
 542
 543                 /*
 544                  * If the rport is one of the well known addresses
 545                  * we skip PRLI and RTV and go straight to READY.
 546                  */
 547                 if (rport->port_id >= FC_FID_DOM_MGR)
 548                         fc_rport_enter_ready(rport);
 549                 else
 550                         fc_rport_enter_prli(rport);
 551         } else
 552                 fc_rport_error_retry(rport, fp);
 553
 554 out:
 555         fc_frame_free(fp);
 556 err:
 557         mutex_unlock(&rdata->rp_mutex);
 558         put_device(&rport->dev);
 559 }
 560
 561 /**
 562  * fc_rport_enter_plogi() - Send Port Login (PLOGI) request to peer
 563  * @rport: Fibre Channel remote port to send PLOGI to
 564  *
 565  * Locking Note: The rport lock is expected to be held before calling
 566  * this routine.
 567  */
 568 static void fc_rport_enter_plogi(struct fc_rport *rport)
 569 {
 570         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 571         struct fc_lport *lport = rdata->local_port;
 572         struct fc_frame *fp;
 573
 574         FC_RPORT_DBG(rport, "Port entered PLOGI state from %s state\n",
 575                      fc_rport_state(rport));
 576
 577         fc_rport_state_enter(rport, RPORT_ST_PLOGI);
 578
 579         rport->maxframe_size = FC_MIN_MAX_PAYLOAD;
 580         fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
 581         if (!fp) {
 582                 fc_rport_error_retry(rport, fp);
 583                 return;
 584         }
 585         rdata->e_d_tov = lport->e_d_tov;
 586
 587         if (!lport->tt.elsct_send(lport, rport, fp, ELS_PLOGI,
 588                                   fc_rport_plogi_resp, rport, lport->e_d_tov))
 589                 fc_rport_error_retry(rport, fp);
 590         else
 591                 get_device(&rport->dev);
 592 }
 593
 594 /**
 595  * fc_rport_prli_resp() - Process Login (PRLI) response handler
 596  * @sp: current sequence in the PRLI exchange
 597  * @fp: response frame
 598  * @rp_arg: Fibre Channel remote port
 599  *
 600  * Locking Note: This function will be called without the rport lock
 601  * held, but it will lock, call an _enter_* function or fc_rport_error
 602  * and then unlock the rport.
 603  */
 604 static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
 605                                void *rp_arg)
 606 {
 607         struct fc_rport *rport = rp_arg;
 608         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 609         struct {
 610                 struct fc_els_prli prli;
 611                 struct fc_els_spp spp;
 612         } *pp;
 613         u32 roles = FC_RPORT_ROLE_UNKNOWN;
 614         u32 fcp_parm = 0;
 615         u8 op;
 616
 617         mutex_lock(&rdata->rp_mutex);
 618
 619         FC_RPORT_DBG(rport, "Received a PRLI response\n");
 620
 621         if (rdata->rp_state != RPORT_ST_PRLI) {
 622                 FC_RPORT_DBG(rport, "Received a PRLI response, but in state "
 623                              "%s\n", fc_rport_state(rport));
 624                 if (IS_ERR(fp))
 625                         goto err;
 626                 goto out;
 627         }
 628
 629         if (IS_ERR(fp)) {
 630                 fc_rport_error_retry(rport, fp);
 631                 goto err;
 632         }
 633
 634         op = fc_frame_payload_op(fp);
 635         if (op == ELS_LS_ACC) {
 636                 pp = fc_frame_payload_get(fp, sizeof(*pp));
 637                 if (pp && pp->prli.prli_spp_len >= sizeof(pp->spp)) {
 638                         fcp_parm = ntohl(pp->spp.spp_params);
 639                         if (fcp_parm & FCP_SPPF_RETRY)
 640                                 rdata->flags |= FC_RP_FLAGS_RETRY;
 641                 }
 642
 643                 rport->supported_classes = FC_COS_CLASS3;
 644                 if (fcp_parm & FCP_SPPF_INIT_FCN)
 645                         roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 646                 if (fcp_parm & FCP_SPPF_TARG_FCN)
 647                         roles |= FC_RPORT_ROLE_FCP_TARGET;
 648
 649                 rport->roles = roles;
 650                 fc_rport_enter_rtv(rport);
 651
 652         } else {
 653                 FC_RPORT_DBG(rport, "Bad ELS response for PRLI command\n");
 654                 rdata->event = RPORT_EV_FAILED;
 655                 fc_rport_state_enter(rport, RPORT_ST_NONE);
 656                 queue_work(rport_event_queue, &rdata->event_work);
 657         }
 658
 659 out:
 660         fc_frame_free(fp);
 661 err:
 662         mutex_unlock(&rdata->rp_mutex);
 663         put_device(&rport->dev);
 664 }
 665
 666 /**
 667  * fc_rport_logo_resp() - Logout (LOGO) response handler
 668  * @sp: current sequence in the LOGO exchange
 669  * @fp: response frame
 670  * @rp_arg: Fibre Channel remote port
 671  *
 672  * Locking Note: This function will be called without the rport lock
 673  * held, but it will lock, call an _enter_* function or fc_rport_error
 674  * and then unlock the rport.
 675  */
 676 static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
 677                                void *rp_arg)
 678 {
 679         struct fc_rport *rport = rp_arg;
 680         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 681         u8 op;
 682
 683         mutex_lock(&rdata->rp_mutex);
 684
 685         FC_RPORT_DBG(rport, "Received a LOGO response\n");
 686
 687         if (rdata->rp_state != RPORT_ST_LOGO) {
 688                 FC_RPORT_DBG(rport, "Received a LOGO response, but in state "
 689                              "%s\n", fc_rport_state(rport));
 690                 if (IS_ERR(fp))
 691                         goto err;
 692                 goto out;
 693         }
 694
 695         if (IS_ERR(fp)) {
 696                 fc_rport_error_retry(rport, fp);
 697                 goto err;
 698         }
 699
 700         op = fc_frame_payload_op(fp);
 701         if (op == ELS_LS_ACC) {
 702                 fc_rport_enter_rtv(rport);
 703         } else {
 704                 FC_RPORT_DBG(rport, "Bad ELS response for LOGO command\n");
 705                 rdata->event = RPORT_EV_LOGO;
 706                 fc_rport_state_enter(rport, RPORT_ST_NONE);
 707                 queue_work(rport_event_queue, &rdata->event_work);
 708         }
 709
 710 out:
 711         fc_frame_free(fp);
 712 err:
 713         mutex_unlock(&rdata->rp_mutex);
 714         put_device(&rport->dev);
 715 }
 716
 717 /**
 718  * fc_rport_enter_prli() - Send Process Login (PRLI) request to peer
 719  * @rport: Fibre Channel remote port to send PRLI to
 720  *
 721  * Locking Note: The rport lock is expected to be held before calling
 722  * this routine.
 723  */
 724 static void fc_rport_enter_prli(struct fc_rport *rport)
 725 {
 726         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 727         struct fc_lport *lport = rdata->local_port;
 728         struct {
 729                 struct fc_els_prli prli;
 730                 struct fc_els_spp spp;
 731         } *pp;
 732         struct fc_frame *fp;
 733
 734         FC_RPORT_DBG(rport, "Port entered PRLI state from %s state\n",
 735                      fc_rport_state(rport));
 736
 737         fc_rport_state_enter(rport, RPORT_ST_PRLI);
 738
 739         fp = fc_frame_alloc(lport, sizeof(*pp));
 740         if (!fp) {
 741                 fc_rport_error_retry(rport, fp);
 742                 return;
 743         }
 744
 745         if (!lport->tt.elsct_send(lport, rport, fp, ELS_PRLI,
 746                                   fc_rport_prli_resp, rport, lport->e_d_tov))
 747                 fc_rport_error_retry(rport, fp);
 748         else
 749                 get_device(&rport->dev);
 750 }
 751
 752 /**
 753  * fc_rport_els_rtv_resp() - Request Timeout Value response handler
 754  * @sp: current sequence in the RTV exchange
 755  * @fp: response frame
 756  * @rp_arg: Fibre Channel remote port
 757  *
 758  * Many targets don't seem to support this.
 759  *
 760  * Locking Note: This function will be called without the rport lock
 761  * held, but it will lock, call an _enter_* function or fc_rport_error
 762  * and then unlock the rport.
 763  */
 764 static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
 765                               void *rp_arg)
 766 {
 767         struct fc_rport *rport = rp_arg;
 768         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 769         u8 op;
 770
 771         mutex_lock(&rdata->rp_mutex);
 772
 773         FC_RPORT_DBG(rport, "Received a RTV response\n");
 774
 775         if (rdata->rp_state != RPORT_ST_RTV) {
 776                 FC_RPORT_DBG(rport, "Received a RTV response, but in state "
 777                              "%s\n", fc_rport_state(rport));
 778                 if (IS_ERR(fp))
 779                         goto err;
 780                 goto out;
 781         }
 782
 783         if (IS_ERR(fp)) {
 784                 fc_rport_error(rport, fp);
 785                 goto err;
 786         }
 787
 788         op = fc_frame_payload_op(fp);
 789         if (op == ELS_LS_ACC) {
 790                 struct fc_els_rtv_acc *rtv;
 791                 u32 toq;
 792                 u32 tov;
 793
 794                 rtv = fc_frame_payload_get(fp, sizeof(*rtv));
 795                 if (rtv) {
 796                         toq = ntohl(rtv->rtv_toq);
 797                         tov = ntohl(rtv->rtv_r_a_tov);
 798                         if (tov == 0)
 799                                 tov = 1;
 800                         rdata->r_a_tov = tov;
 801                         tov = ntohl(rtv->rtv_e_d_tov);
 802                         if (toq & FC_ELS_RTV_EDRES)
 803                                 tov /= 1000000;
 804                         if (tov == 0)
 805                                 tov = 1;
 806                         rdata->e_d_tov = tov;
 807                 }
 808         }
 809
 810         fc_rport_enter_ready(rport);
 811
 812 out:
 813         fc_frame_free(fp);
 814 err:
 815         mutex_unlock(&rdata->rp_mutex);
 816         put_device(&rport->dev);
 817 }
 818
 819 /**
 820  * fc_rport_enter_rtv() - Send Request Timeout Value (RTV) request to peer
 821  * @rport: Fibre Channel remote port to send RTV to
 822  *
 823  * Locking Note: The rport lock is expected to be held before calling
 824  * this routine.
 825  */
 826 static void fc_rport_enter_rtv(struct fc_rport *rport)
 827 {
 828         struct fc_frame *fp;
 829         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 830         struct fc_lport *lport = rdata->local_port;
 831
 832         FC_RPORT_DBG(rport, "Port entered RTV state from %s state\n",
 833                      fc_rport_state(rport));
 834
 835         fc_rport_state_enter(rport, RPORT_ST_RTV);
 836
 837         fp = fc_frame_alloc(lport, sizeof(struct fc_els_rtv));
 838         if (!fp) {
 839                 fc_rport_error_retry(rport, fp);
 840                 return;
 841         }
 842
 843         if (!lport->tt.elsct_send(lport, rport, fp, ELS_RTV,
 844                                      fc_rport_rtv_resp, rport, lport->e_d_tov))
 845                 fc_rport_error_retry(rport, fp);
 846         else
 847                 get_device(&rport->dev);
 848 }
 849
 850 /**
 851  * fc_rport_enter_logo() - Send Logout (LOGO) request to peer
 852  * @rport: Fibre Channel remote port to send LOGO to
 853  *
 854  * Locking Note: The rport lock is expected to be held before calling
 855  * this routine.
 856  */
 857 static void fc_rport_enter_logo(struct fc_rport *rport)
 858 {
 859         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 860         struct fc_lport *lport = rdata->local_port;
 861         struct fc_frame *fp;
 862
 863         FC_RPORT_DBG(rport, "Port entered LOGO state from %s state\n",
 864                      fc_rport_state(rport));
 865
 866         fc_rport_state_enter(rport, RPORT_ST_LOGO);
 867
 868         fp = fc_frame_alloc(lport, sizeof(struct fc_els_logo));
 869         if (!fp) {
 870                 fc_rport_error_retry(rport, fp);
 871                 return;
 872         }
 873
 874         if (!lport->tt.elsct_send(lport, rport, fp, ELS_LOGO,
 875                                   fc_rport_logo_resp, rport, lport->e_d_tov))
 876                 fc_rport_error_retry(rport, fp);
 877         else
 878                 get_device(&rport->dev);
 879 }
 880
 881
 882 /**
 883  * fc_rport_recv_req() - Receive a request from a rport
 884  * @sp: current sequence in the PLOGI exchange
 885  * @fp: response frame
 886  * @rp_arg: Fibre Channel remote port
 887  *
 888  * Locking Note: Called without the rport lock held. This
 889  * function will hold the rport lock, call an _enter_*
 890  * function and then unlock the rport.
 891  */
 892 void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
 893                        struct fc_rport *rport)
 894 {
 895         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 896         struct fc_lport *lport = rdata->local_port;
 897
 898         struct fc_frame_header *fh;
 899         struct fc_seq_els_data els_data;
 900         u8 op;
 901
 902         mutex_lock(&rdata->rp_mutex);
 903
 904         els_data.fp = NULL;
 905         els_data.explan = ELS_EXPL_NONE;
 906         els_data.reason = ELS_RJT_NONE;
 907
 908         fh = fc_frame_header_get(fp);
 909
 910         if (fh->fh_r_ctl == FC_RCTL_ELS_REQ && fh->fh_type == FC_TYPE_ELS) {
 911                 op = fc_frame_payload_op(fp);
 912                 switch (op) {
 913                 case ELS_PLOGI:
 914                         fc_rport_recv_plogi_req(rport, sp, fp);
 915                         break;
 916                 case ELS_PRLI:
 917                         fc_rport_recv_prli_req(rport, sp, fp);
 918                         break;
 919                 case ELS_PRLO:
 920                         fc_rport_recv_prlo_req(rport, sp, fp);
 921                         break;
 922                 case ELS_LOGO:
 923                         fc_rport_recv_logo_req(rport, sp, fp);
 924                         break;
 925                 case ELS_RRQ:
 926                         els_data.fp = fp;
 927                         lport->tt.seq_els_rsp_send(sp, ELS_RRQ, &els_data);
 928                         break;
 929                 case ELS_REC:
 930                         els_data.fp = fp;
 931                         lport->tt.seq_els_rsp_send(sp, ELS_REC, &els_data);
 932                         break;
 933                 default:
 934                         els_data.reason = ELS_RJT_UNSUP;
 935                         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
 936                         break;
 937                 }
 938         }
 939
 940         mutex_unlock(&rdata->rp_mutex);
 941 }
 942
 943 /**
 944  * fc_rport_recv_plogi_req() - Handle incoming Port Login (PLOGI) request
 945  * @rport: Fibre Channel remote port that initiated PLOGI
 946  * @sp: current sequence in the PLOGI exchange
 947  * @fp: PLOGI request frame
 948  *
 949  * Locking Note: The rport lock is exected to be held before calling
 950  * this function.
 951  */
 952 static void fc_rport_recv_plogi_req(struct fc_rport *rport,
 953                                     struct fc_seq *sp, struct fc_frame *rx_fp)
 954 {
 955         struct fc_rport_libfc_priv *rdata = rport->dd_data;
 956         struct fc_lport *lport = rdata->local_port;
 957         struct fc_frame *fp = rx_fp;
 958         struct fc_exch *ep;
 959         struct fc_frame_header *fh;
 960         struct fc_els_flogi *pl;
 961         struct fc_seq_els_data rjt_data;
 962         u32 sid;
 963         u64 wwpn;
 964         u64 wwnn;
 965         enum fc_els_rjt_reason reject = 0;
 966         u32 f_ctl;
 967         rjt_data.fp = NULL;
 968
 969         fh = fc_frame_header_get(fp);
 970
 971         FC_RPORT_DBG(rport, "Received PLOGI request while in state %s\n",
 972                      fc_rport_state(rport));
 973
 974         sid = ntoh24(fh->fh_s_id);
 975         pl = fc_frame_payload_get(fp, sizeof(*pl));
 976         if (!pl) {
 977                 FC_RPORT_DBG(rport, "Received PLOGI too short\n");
 978                 WARN_ON(1);
 979                 /* XXX TBD: send reject? */
 980                 fc_frame_free(fp);
 981                 return;
 982         }
 983         wwpn = get_unaligned_be64(&pl->fl_wwpn);
 984         wwnn = get_unaligned_be64(&pl->fl_wwnn);
 985
 986         /*
 987          * If the session was just created, possibly due to the incoming PLOGI,
 988          * set the state appropriately and accept the PLOGI.
 989          *
 990          * If we had also sent a PLOGI, and if the received PLOGI is from a
 991          * higher WWPN, we accept it, otherwise an LS_RJT is sent with reason
 992          * "command already in progress".
 993          *
 994          * XXX TBD: If the session was ready before, the PLOGI should result in
 995          * all outstanding exchanges being reset.
 996          */
 997         switch (rdata->rp_state) {
 998         case RPORT_ST_INIT:
 999                 FC_RPORT_DBG(rport, "Received PLOGI, wwpn %llx state INIT "
1000                              "- reject\n", (unsigned long long)wwpn);
1001                 reject = ELS_RJT_UNSUP;
1002                 break;
1003         case RPORT_ST_PLOGI:
1004                 FC_RPORT_DBG(rport, "Received PLOGI in PLOGI state %d\n",
1005                              rdata->rp_state);
1006                 if (wwpn < lport->wwpn)
1007                         reject = ELS_RJT_INPROG;
1008                 break;
1009         case RPORT_ST_PRLI:
1010         case RPORT_ST_READY:
1011                 FC_RPORT_DBG(rport, "Received PLOGI in logged-in state %d "
1012                              "- ignored for now\n", rdata->rp_state);
1013                 /* XXX TBD - should reset */
1014                 break;
1015         case RPORT_ST_NONE:
1016         default:
1017                 FC_RPORT_DBG(rport, "Received PLOGI in unexpected "
1018                              "state %d\n", rdata->rp_state);
1019                 fc_frame_free(fp);
1020                 return;
1021                 break;
1022         }
1023
1024         if (reject) {
1025                 rjt_data.reason = reject;
1026                 rjt_data.explan = ELS_EXPL_NONE;
1027                 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1028                 fc_frame_free(fp);
1029         } else {
1030                 fp = fc_frame_alloc(lport, sizeof(*pl));
1031                 if (fp == NULL) {
1032                         fp = rx_fp;
1033                         rjt_data.reason = ELS_RJT_UNAB;
1034                         rjt_data.explan = ELS_EXPL_NONE;
1035                         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1036                         fc_frame_free(fp);
1037                 } else {
1038                         sp = lport->tt.seq_start_next(sp);
1039                         WARN_ON(!sp);
1040                         fc_rport_set_name(rport, wwpn, wwnn);
1041
1042                         /*
1043                          * Get session payload size from incoming PLOGI.
1044                          */
1045                         rport->maxframe_size =
1046                                 fc_plogi_get_maxframe(pl, lport->mfs);
1047                         fc_frame_free(rx_fp);
1048                         fc_plogi_fill(lport, fp, ELS_LS_ACC);
1049
1050                         /*
1051                          * Send LS_ACC.  If this fails,
1052                          * the originator should retry.
1053                          */
1054                         f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
1055                         f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1056                         ep = fc_seq_exch(sp);
1057                         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1058                                        FC_TYPE_ELS, f_ctl, 0);
1059                         lport->tt.seq_send(lport, sp, fp);
1060                         if (rdata->rp_state == RPORT_ST_PLOGI)
1061                                 fc_rport_enter_prli(rport);
1062                 }
1063         }
1064 }
1065
1066 /**
1067  * fc_rport_recv_prli_req() - Handle incoming Process Login (PRLI) request
1068  * @rport: Fibre Channel remote port that initiated PRLI
1069  * @sp: current sequence in the PRLI exchange
1070  * @fp: PRLI request frame
1071  *
1072  * Locking Note: The rport lock is exected to be held before calling
1073  * this function.
1074  */
1075 static void fc_rport_recv_prli_req(struct fc_rport *rport,
1076                                    struct fc_seq *sp, struct fc_frame *rx_fp)
1077 {
1078         struct fc_rport_libfc_priv *rdata = rport->dd_data;
1079         struct fc_lport *lport = rdata->local_port;
1080         struct fc_exch *ep;
1081         struct fc_frame *fp;
1082         struct fc_frame_header *fh;
1083         struct {
1084                 struct fc_els_prli prli;
1085                 struct fc_els_spp spp;
1086         } *pp;
1087         struct fc_els_spp *rspp;        /* request service param page */
1088         struct fc_els_spp *spp; /* response spp */
1089         unsigned int len;
1090         unsigned int plen;
1091         enum fc_els_rjt_reason reason = ELS_RJT_UNAB;
1092         enum fc_els_rjt_explan explan = ELS_EXPL_NONE;
1093         enum fc_els_spp_resp resp;
1094         struct fc_seq_els_data rjt_data;
1095         u32 f_ctl;
1096         u32 fcp_parm;
1097         u32 roles = FC_RPORT_ROLE_UNKNOWN;
1098         rjt_data.fp = NULL;
1099
1100         fh = fc_frame_header_get(rx_fp);
1101
1102         FC_RPORT_DBG(rport, "Received PRLI request while in state %s\n",
1103                      fc_rport_state(rport));
1104
1105         switch (rdata->rp_state) {
1106         case RPORT_ST_PRLI:
1107         case RPORT_ST_READY:
1108                 reason = ELS_RJT_NONE;
1109                 break;
1110         default:
1111                 fc_frame_free(rx_fp);
1112                 return;
1113                 break;
1114         }
1115         len = fr_len(rx_fp) - sizeof(*fh);
1116         pp = fc_frame_payload_get(rx_fp, sizeof(*pp));
1117         if (pp == NULL) {
1118                 reason = ELS_RJT_PROT;
1119                 explan = ELS_EXPL_INV_LEN;
1120         } else {
1121                 plen = ntohs(pp->prli.prli_len);
1122                 if ((plen % 4) != 0 || plen > len) {
1123                         reason = ELS_RJT_PROT;
1124                         explan = ELS_EXPL_INV_LEN;
1125                 } else if (plen < len) {
1126                         len = plen;
1127                 }
1128                 plen = pp->prli.prli_spp_len;
1129                 if ((plen % 4) != 0 || plen < sizeof(*spp) ||
1130                     plen > len || len < sizeof(*pp)) {
1131                         reason = ELS_RJT_PROT;
1132                         explan = ELS_EXPL_INV_LEN;
1133                 }
1134                 rspp = &pp->spp;
1135         }
1136         if (reason != ELS_RJT_NONE ||
1137             (fp = fc_frame_alloc(lport, len)) == NULL) {
1138                 rjt_data.reason = reason;
1139                 rjt_data.explan = explan;
1140                 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1141         } else {
1142                 sp = lport->tt.seq_start_next(sp);
1143                 WARN_ON(!sp);
1144                 pp = fc_frame_payload_get(fp, len);
1145                 WARN_ON(!pp);
1146                 memset(pp, 0, len);
1147                 pp->prli.prli_cmd = ELS_LS_ACC;
1148                 pp->prli.prli_spp_len = plen;
1149                 pp->prli.prli_len = htons(len);
1150                 len -= sizeof(struct fc_els_prli);
1151
1152                 /*
1153                  * Go through all the service parameter pages and build
1154                  * response.  If plen indicates longer SPP than standard,
1155                  * use that.  The entire response has been pre-cleared above.
1156                  */
1157                 spp = &pp->spp;
1158                 while (len >= plen) {
1159                         spp->spp_type = rspp->spp_type;
1160                         spp->spp_type_ext = rspp->spp_type_ext;
1161                         spp->spp_flags = rspp->spp_flags & FC_SPP_EST_IMG_PAIR;
1162                         resp = FC_SPP_RESP_ACK;
1163                         if (rspp->spp_flags & FC_SPP_RPA_VAL)
1164                                 resp = FC_SPP_RESP_NO_PA;
1165                         switch (rspp->spp_type) {
1166                         case 0: /* common to all FC-4 types */
1167                                 break;
1168                         case FC_TYPE_FCP:
1169                                 fcp_parm = ntohl(rspp->spp_params);
1170                                 if (fcp_parm * FCP_SPPF_RETRY)
1171                                         rdata->flags |= FC_RP_FLAGS_RETRY;
1172                                 rport->supported_classes = FC_COS_CLASS3;
1173                                 if (fcp_parm & FCP_SPPF_INIT_FCN)
1174                                         roles |= FC_RPORT_ROLE_FCP_INITIATOR;
1175                                 if (fcp_parm & FCP_SPPF_TARG_FCN)
1176                                         roles |= FC_RPORT_ROLE_FCP_TARGET;
1177                                 rport->roles = roles;
1178
1179                                 spp->spp_params =
1180                                         htonl(lport->service_params);
1181                                 break;
1182                         default:
1183                                 resp = FC_SPP_RESP_INVL;
1184                                 break;
1185                         }
1186                         spp->spp_flags |= resp;
1187                         len -= plen;
1188                         rspp = (struct fc_els_spp *)((char *)rspp + plen);
1189                         spp = (struct fc_els_spp *)((char *)spp + plen);
1190                 }
1191
1192                 /*
1193                  * Send LS_ACC.  If this fails, the originator should retry.
1194                  */
1195                 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
1196                 f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1197                 ep = fc_seq_exch(sp);
1198                 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1199                                FC_TYPE_ELS, f_ctl, 0);
1200                 lport->tt.seq_send(lport, sp, fp);
1201
1202                 /*
1203                  * Get lock and re-check state.
1204                  */
1205                 switch (rdata->rp_state) {
1206                 case RPORT_ST_PRLI:
1207                         fc_rport_enter_ready(rport);
1208                         break;
1209                 case RPORT_ST_READY:
1210                         break;
1211                 default:
1212                         break;
1213                 }
1214         }
1215         fc_frame_free(rx_fp);
1216 }
1217
1218 /**
1219  * fc_rport_recv_prlo_req() - Handle incoming Process Logout (PRLO) request
1220  * @rport: Fibre Channel remote port that initiated PRLO
1221  * @sp: current sequence in the PRLO exchange
1222  * @fp: PRLO request frame
1223  *
1224  * Locking Note: The rport lock is exected to be held before calling
1225  * this function.
1226  */
1227 static void fc_rport_recv_prlo_req(struct fc_rport *rport, struct fc_seq *sp,
1228                                    struct fc_frame *fp)
1229 {
1230         struct fc_rport_libfc_priv *rdata = rport->dd_data;
1231         struct fc_lport *lport = rdata->local_port;
1232
1233         struct fc_frame_header *fh;
1234         struct fc_seq_els_data rjt_data;
1235
1236         fh = fc_frame_header_get(fp);
1237
1238         FC_RPORT_DBG(rport, "Received PRLO request while in state %s\n",
1239                      fc_rport_state(rport));
1240
1241         if (rdata->rp_state == RPORT_ST_NONE) {
1242                 fc_frame_free(fp);
1243                 return;
1244         }
1245
1246         rjt_data.fp = NULL;
1247         rjt_data.reason = ELS_RJT_UNAB;
1248         rjt_data.explan = ELS_EXPL_NONE;
1249         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1250         fc_frame_free(fp);
1251 }
1252
1253 /**
1254  * fc_rport_recv_logo_req() - Handle incoming Logout (LOGO) request
1255  * @rport: Fibre Channel remote port that initiated LOGO
1256  * @sp: current sequence in the LOGO exchange
1257  * @fp: LOGO request frame
1258  *
1259  * Locking Note: The rport lock is exected to be held before calling
1260  * this function.
1261  */
1262 static void fc_rport_recv_logo_req(struct fc_rport *rport, struct fc_seq *sp,
1263                                    struct fc_frame *fp)
1264 {
1265         struct fc_frame_header *fh;
1266         struct fc_rport_libfc_priv *rdata = rport->dd_data;
1267         struct fc_lport *lport = rdata->local_port;
1268
1269         fh = fc_frame_header_get(fp);
1270
1271         FC_RPORT_DBG(rport, "Received LOGO request while in state %s\n",
1272                      fc_rport_state(rport));
1273
1274         if (rdata->rp_state == RPORT_ST_NONE) {
1275                 fc_frame_free(fp);
1276                 return;
1277         }
1278
1279         rdata->event = RPORT_EV_LOGO;
1280         fc_rport_state_enter(rport, RPORT_ST_NONE);
1281         queue_work(rport_event_queue, &rdata->event_work);
1282
1283         lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
1284         fc_frame_free(fp);
1285 }
1286
1287 static void fc_rport_flush_queue(void)
1288 {
1289         flush_workqueue(rport_event_queue);
1290 }
1291
1292 int fc_rport_init(struct fc_lport *lport)
1293 {
1294         if (!lport->tt.rport_create)
1295                 lport->tt.rport_create = fc_rport_rogue_create;
1296
1297         if (!lport->tt.rport_login)
1298                 lport->tt.rport_login = fc_rport_login;
1299
1300         if (!lport->tt.rport_logoff)
1301                 lport->tt.rport_logoff = fc_rport_logoff;
1302
1303         if (!lport->tt.rport_recv_req)
1304                 lport->tt.rport_recv_req = fc_rport_recv_req;
1305
1306         if (!lport->tt.rport_flush_queue)
1307                 lport->tt.rport_flush_queue = fc_rport_flush_queue;
1308
1309         return 0;
1310 }
1311 EXPORT_SYMBOL(fc_rport_init);
1312
1313 int fc_setup_rport(void)
1314 {
1315         rport_event_queue = create_singlethread_workqueue("fc_rport_eq");
1316         if (!rport_event_queue)
1317                 return -ENOMEM;
1318         return 0;
1319 }
1320 EXPORT_SYMBOL(fc_setup_rport);
1321
1322 void fc_destroy_rport(void)
1323 {
1324         destroy_workqueue(rport_event_queue);
1325 }
1326 EXPORT_SYMBOL(fc_destroy_rport);
1327
1328 void fc_rport_terminate_io(struct fc_rport *rport)
1329 {
1330         struct fc_rport_libfc_priv *rdata = rport->dd_data;
1331         struct fc_lport *lport = rdata->local_port;
1332
1333         lport->tt.exch_mgr_reset(lport, 0, rport->port_id);
1334         lport->tt.exch_mgr_reset(lport, rport->port_id, 0);
1335 }
1336 EXPORT_SYMBOL(fc_rport_terminate_io);