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