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/slab.h>
  51 #include <linux/rcupdate.h>
  52 #include <linux/timer.h>
  53 #include <linux/workqueue.h>
  54 #include <asm/unaligned.h>
  55
  56 #include <scsi/libfc.h>
  57 #include <scsi/fc_encode.h>
  58
  59 #include "fc_libfc.h"
  60
  61 struct workqueue_struct *rport_event_queue;
  62
  63 static void fc_rport_enter_plogi(struct fc_rport_priv *);
  64 static void fc_rport_enter_prli(struct fc_rport_priv *);
  65 static void fc_rport_enter_rtv(struct fc_rport_priv *);
  66 static void fc_rport_enter_ready(struct fc_rport_priv *);
  67 static void fc_rport_enter_logo(struct fc_rport_priv *);
  68 static void fc_rport_enter_adisc(struct fc_rport_priv *);
  69
  70 static void fc_rport_recv_plogi_req(struct fc_lport *,
  71                                     struct fc_seq *, struct fc_frame *);
  72 static void fc_rport_recv_prli_req(struct fc_rport_priv *,
  73                                    struct fc_seq *, struct fc_frame *);
  74 static void fc_rport_recv_prlo_req(struct fc_rport_priv *,
  75                                    struct fc_seq *, struct fc_frame *);
  76 static void fc_rport_recv_logo_req(struct fc_lport *,
  77                                    struct fc_seq *, struct fc_frame *);
  78 static void fc_rport_timeout(struct work_struct *);
  79 static void fc_rport_error(struct fc_rport_priv *, struct fc_frame *);
  80 static void fc_rport_error_retry(struct fc_rport_priv *, struct fc_frame *);
  81 static void fc_rport_work(struct work_struct *);
  82
  83 static const char *fc_rport_state_names[] = {
  84         [RPORT_ST_INIT] = "Init",
  85         [RPORT_ST_PLOGI] = "PLOGI",
  86         [RPORT_ST_PRLI] = "PRLI",
  87         [RPORT_ST_RTV] = "RTV",
  88         [RPORT_ST_READY] = "Ready",
  89         [RPORT_ST_LOGO] = "LOGO",
  90         [RPORT_ST_ADISC] = "ADISC",
  91         [RPORT_ST_DELETE] = "Delete",
  92         [RPORT_ST_RESTART] = "Restart",
  93 };
  94
  95 /**
  96  * fc_rport_lookup() - Lookup a remote port by port_id
  97  * @lport:   The local port to lookup the remote port on
  98  * @port_id: The remote port ID to look up
  99  */
 100 static struct fc_rport_priv *fc_rport_lookup(const struct fc_lport *lport,
 101                                              u32 port_id)
 102 {
 103         struct fc_rport_priv *rdata;
 104
 105         list_for_each_entry(rdata, &lport->disc.rports, peers)
 106                 if (rdata->ids.port_id == port_id)
 107                         return rdata;
 108         return NULL;
 109 }
 110
 111 /**
 112  * fc_rport_create() - Create a new remote port
 113  * @lport: The local port this remote port will be associated with
 114  * @ids:   The identifiers for the new remote port
 115  *
 116  * The remote port will start in the INIT state.
 117  *
 118  * Locking note:  must be called with the disc_mutex held.
 119  */
 120 static struct fc_rport_priv *fc_rport_create(struct fc_lport *lport,
 121                                              u32 port_id)
 122 {
 123         struct fc_rport_priv *rdata;
 124
 125         rdata = lport->tt.rport_lookup(lport, port_id);
 126         if (rdata)
 127                 return rdata;
 128
 129         rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
 130         if (!rdata)
 131                 return NULL;
 132
 133         rdata->ids.node_name = -1;
 134         rdata->ids.port_name = -1;
 135         rdata->ids.port_id = port_id;
 136         rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
 137
 138         kref_init(&rdata->kref);
 139         mutex_init(&rdata->rp_mutex);
 140         rdata->local_port = lport;
 141         rdata->rp_state = RPORT_ST_INIT;
 142         rdata->event = RPORT_EV_NONE;
 143         rdata->flags = FC_RP_FLAGS_REC_SUPPORTED;
 144         rdata->e_d_tov = lport->e_d_tov;
 145         rdata->r_a_tov = lport->r_a_tov;
 146         rdata->maxframe_size = FC_MIN_MAX_PAYLOAD;
 147         INIT_DELAYED_WORK(&rdata->retry_work, fc_rport_timeout);
 148         INIT_WORK(&rdata->event_work, fc_rport_work);
 149         if (port_id != FC_FID_DIR_SERV)
 150                 list_add(&rdata->peers, &lport->disc.rports);
 151         return rdata;
 152 }
 153
 154 /**
 155  * fc_rport_destroy() - Free a remote port after last reference is released
 156  * @kref: The remote port's kref
 157  */
 158 static void fc_rport_destroy(struct kref *kref)
 159 {
 160         struct fc_rport_priv *rdata;
 161
 162         rdata = container_of(kref, struct fc_rport_priv, kref);
 163         kfree(rdata);
 164 }
 165
 166 /**
 167  * fc_rport_state() - Return a string identifying the remote port's state
 168  * @rdata: The remote port
 169  */
 170 static const char *fc_rport_state(struct fc_rport_priv *rdata)
 171 {
 172         const char *cp;
 173
 174         cp = fc_rport_state_names[rdata->rp_state];
 175         if (!cp)
 176                 cp = "Unknown";
 177         return cp;
 178 }
 179
 180 /**
 181  * fc_set_rport_loss_tmo() - Set the remote port loss timeout
 182  * @rport:   The remote port that gets a new timeout value
 183  * @timeout: The new timeout value (in seconds)
 184  */
 185 void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
 186 {
 187         if (timeout)
 188                 rport->dev_loss_tmo = timeout + 5;
 189         else
 190                 rport->dev_loss_tmo = 30;
 191 }
 192 EXPORT_SYMBOL(fc_set_rport_loss_tmo);
 193
 194 /**
 195  * fc_plogi_get_maxframe() - Get the maximum payload from the common service
 196  *                           parameters in a FLOGI frame
 197  * @flp:    The FLOGI payload
 198  * @maxval: The maximum frame size upper limit; this may be less than what
 199  *          is in the service parameters
 200  */
 201 static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi *flp,
 202                                           unsigned int maxval)
 203 {
 204         unsigned int mfs;
 205
 206         /*
 207          * Get max payload from the common service parameters and the
 208          * class 3 receive data field size.
 209          */
 210         mfs = ntohs(flp->fl_csp.sp_bb_data) & FC_SP_BB_DATA_MASK;
 211         if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
 212                 maxval = mfs;
 213         mfs = ntohs(flp->fl_cssp[3 - 1].cp_rdfs);
 214         if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
 215                 maxval = mfs;
 216         return maxval;
 217 }
 218
 219 /**
 220  * fc_rport_state_enter() - Change the state of a remote port
 221  * @rdata: The remote port whose state should change
 222  * @new:   The new state
 223  *
 224  * Locking Note: Called with the rport lock held
 225  */
 226 static void fc_rport_state_enter(struct fc_rport_priv *rdata,
 227                                  enum fc_rport_state new)
 228 {
 229         if (rdata->rp_state != new)
 230                 rdata->retries = 0;
 231         rdata->rp_state = new;
 232 }
 233
 234 /**
 235  * fc_rport_work() - Handler for remote port events in the rport_event_queue
 236  * @work: Handle to the remote port being dequeued
 237  */
 238 static void fc_rport_work(struct work_struct *work)
 239 {
 240         u32 port_id;
 241         struct fc_rport_priv *rdata =
 242                 container_of(work, struct fc_rport_priv, event_work);
 243         struct fc_rport_libfc_priv *rpriv;
 244         enum fc_rport_event event;
 245         struct fc_lport *lport = rdata->local_port;
 246         struct fc_rport_operations *rport_ops;
 247         struct fc_rport_identifiers ids;
 248         struct fc_rport *rport;
 249         int restart = 0;
 250
 251         mutex_lock(&rdata->rp_mutex);
 252         event = rdata->event;
 253         rport_ops = rdata->ops;
 254         rport = rdata->rport;
 255
 256         FC_RPORT_DBG(rdata, "work event %u\n", event);
 257
 258         switch (event) {
 259         case RPORT_EV_READY:
 260                 ids = rdata->ids;
 261                 rdata->event = RPORT_EV_NONE;
 262                 kref_get(&rdata->kref);
 263                 mutex_unlock(&rdata->rp_mutex);
 264
 265                 if (!rport)
 266                         rport = fc_remote_port_add(lport->host, 0, &ids);
 267                 if (!rport) {
 268                         FC_RPORT_DBG(rdata, "Failed to add the rport\n");
 269                         lport->tt.rport_logoff(rdata);
 270                         kref_put(&rdata->kref, lport->tt.rport_destroy);
 271                         return;
 272                 }
 273                 mutex_lock(&rdata->rp_mutex);
 274                 if (rdata->rport)
 275                         FC_RPORT_DBG(rdata, "rport already allocated\n");
 276                 rdata->rport = rport;
 277                 rport->maxframe_size = rdata->maxframe_size;
 278                 rport->supported_classes = rdata->supported_classes;
 279
 280                 rpriv = rport->dd_data;
 281                 rpriv->local_port = lport;
 282                 rpriv->rp_state = rdata->rp_state;
 283                 rpriv->flags = rdata->flags;
 284                 rpriv->e_d_tov = rdata->e_d_tov;
 285                 rpriv->r_a_tov = rdata->r_a_tov;
 286                 mutex_unlock(&rdata->rp_mutex);
 287
 288                 if (rport_ops && rport_ops->event_callback) {
 289                         FC_RPORT_DBG(rdata, "callback ev %d\n", event);
 290                         rport_ops->event_callback(lport, rdata, event);
 291                 }
 292                 kref_put(&rdata->kref, lport->tt.rport_destroy);
 293                 break;
 294
 295         case RPORT_EV_FAILED:
 296         case RPORT_EV_LOGO:
 297         case RPORT_EV_STOP:
 298                 port_id = rdata->ids.port_id;
 299                 mutex_unlock(&rdata->rp_mutex);
 300
 301                 if (port_id != FC_FID_DIR_SERV) {
 302                         /*
 303                          * We must drop rp_mutex before taking disc_mutex.
 304                          * Re-evaluate state to allow for restart.
 305                          * A transition to RESTART state must only happen
 306                          * while disc_mutex is held and rdata is on the list.
 307                          */
 308                         mutex_lock(&lport->disc.disc_mutex);
 309                         mutex_lock(&rdata->rp_mutex);
 310                         if (rdata->rp_state == RPORT_ST_RESTART)
 311                                 restart = 1;
 312                         else
 313                                 list_del(&rdata->peers);
 314                         rdata->event = RPORT_EV_NONE;
 315                         mutex_unlock(&rdata->rp_mutex);
 316                         mutex_unlock(&lport->disc.disc_mutex);
 317                 }
 318
 319                 if (rport_ops && rport_ops->event_callback) {
 320                         FC_RPORT_DBG(rdata, "callback ev %d\n", event);
 321                         rport_ops->event_callback(lport, rdata, event);
 322                 }
 323                 cancel_delayed_work_sync(&rdata->retry_work);
 324
 325                 /*
 326                  * Reset any outstanding exchanges before freeing rport.
 327                  */
 328                 lport->tt.exch_mgr_reset(lport, 0, port_id);
 329                 lport->tt.exch_mgr_reset(lport, port_id, 0);
 330
 331                 if (rport) {
 332                         rpriv = rport->dd_data;
 333                         rpriv->rp_state = RPORT_ST_DELETE;
 334                         mutex_lock(&rdata->rp_mutex);
 335                         rdata->rport = NULL;
 336                         mutex_unlock(&rdata->rp_mutex);
 337                         fc_remote_port_delete(rport);
 338                 }
 339                 if (restart) {
 340                         mutex_lock(&rdata->rp_mutex);
 341                         FC_RPORT_DBG(rdata, "work restart\n");
 342                         fc_rport_enter_plogi(rdata);
 343                         mutex_unlock(&rdata->rp_mutex);
 344                 } else
 345                         kref_put(&rdata->kref, lport->tt.rport_destroy);
 346                 break;
 347
 348         default:
 349                 mutex_unlock(&rdata->rp_mutex);
 350                 break;
 351         }
 352 }
 353
 354 /**
 355  * fc_rport_login() - Start the remote port login state machine
 356  * @rdata: The remote port to be logged in to
 357  *
 358  * Locking Note: Called without the rport lock held. This
 359  * function will hold the rport lock, call an _enter_*
 360  * function and then unlock the rport.
 361  *
 362  * This indicates the intent to be logged into the remote port.
 363  * If it appears we are already logged in, ADISC is used to verify
 364  * the setup.
 365  */
 366 int fc_rport_login(struct fc_rport_priv *rdata)
 367 {
 368         mutex_lock(&rdata->rp_mutex);
 369
 370         switch (rdata->rp_state) {
 371         case RPORT_ST_READY:
 372                 FC_RPORT_DBG(rdata, "ADISC port\n");
 373                 fc_rport_enter_adisc(rdata);
 374                 break;
 375         case RPORT_ST_RESTART:
 376                 break;
 377         case RPORT_ST_DELETE:
 378                 FC_RPORT_DBG(rdata, "Restart deleted port\n");
 379                 fc_rport_state_enter(rdata, RPORT_ST_RESTART);
 380                 break;
 381         default:
 382                 FC_RPORT_DBG(rdata, "Login to port\n");
 383                 fc_rport_enter_plogi(rdata);
 384                 break;
 385         }
 386         mutex_unlock(&rdata->rp_mutex);
 387
 388         return 0;
 389 }
 390
 391 /**
 392  * fc_rport_enter_delete() - Schedule a remote port to be deleted
 393  * @rdata: The remote port to be deleted
 394  * @event: The event to report as the reason for deletion
 395  *
 396  * Locking Note: Called with the rport lock held.
 397  *
 398  * Allow state change into DELETE only once.
 399  *
 400  * Call queue_work only if there's no event already pending.
 401  * Set the new event so that the old pending event will not occur.
 402  * Since we have the mutex, even if fc_rport_work() is already started,
 403  * it'll see the new event.
 404  */
 405 static void fc_rport_enter_delete(struct fc_rport_priv *rdata,
 406                                   enum fc_rport_event event)
 407 {
 408         if (rdata->rp_state == RPORT_ST_DELETE)
 409                 return;
 410
 411         FC_RPORT_DBG(rdata, "Delete port\n");
 412
 413         fc_rport_state_enter(rdata, RPORT_ST_DELETE);
 414
 415         if (rdata->event == RPORT_EV_NONE)
 416                 queue_work(rport_event_queue, &rdata->event_work);
 417         rdata->event = event;
 418 }
 419
 420 /**
 421  * fc_rport_logoff() - Logoff and remove a remote port
 422  * @rdata: The remote port to be logged off of
 423  *
 424  * Locking Note: Called without the rport lock held. This
 425  * function will hold the rport lock, call an _enter_*
 426  * function and then unlock the rport.
 427  */
 428 int fc_rport_logoff(struct fc_rport_priv *rdata)
 429 {
 430         mutex_lock(&rdata->rp_mutex);
 431
 432         FC_RPORT_DBG(rdata, "Remove port\n");
 433
 434         if (rdata->rp_state == RPORT_ST_DELETE) {
 435                 FC_RPORT_DBG(rdata, "Port in Delete state, not removing\n");
 436                 goto out;
 437         }
 438
 439         if (rdata->rp_state == RPORT_ST_RESTART)
 440                 FC_RPORT_DBG(rdata, "Port in Restart state, deleting\n");
 441         else
 442                 fc_rport_enter_logo(rdata);
 443
 444         /*
 445          * Change the state to Delete so that we discard
 446          * the response.
 447          */
 448         fc_rport_enter_delete(rdata, RPORT_EV_STOP);
 449 out:
 450         mutex_unlock(&rdata->rp_mutex);
 451         return 0;
 452 }
 453
 454 /**
 455  * fc_rport_enter_ready() - Transition to the RPORT_ST_READY state
 456  * @rdata: The remote port that is ready
 457  *
 458  * Locking Note: The rport lock is expected to be held before calling
 459  * this routine.
 460  */
 461 static void fc_rport_enter_ready(struct fc_rport_priv *rdata)
 462 {
 463         fc_rport_state_enter(rdata, RPORT_ST_READY);
 464
 465         FC_RPORT_DBG(rdata, "Port is Ready\n");
 466
 467         if (rdata->event == RPORT_EV_NONE)
 468                 queue_work(rport_event_queue, &rdata->event_work);
 469         rdata->event = RPORT_EV_READY;
 470 }
 471
 472 /**
 473  * fc_rport_timeout() - Handler for the retry_work timer
 474  * @work: Handle to the remote port that has timed out
 475  *
 476  * Locking Note: Called without the rport lock held. This
 477  * function will hold the rport lock, call an _enter_*
 478  * function and then unlock the rport.
 479  */
 480 static void fc_rport_timeout(struct work_struct *work)
 481 {
 482         struct fc_rport_priv *rdata =
 483                 container_of(work, struct fc_rport_priv, retry_work.work);
 484
 485         mutex_lock(&rdata->rp_mutex);
 486
 487         switch (rdata->rp_state) {
 488         case RPORT_ST_PLOGI:
 489                 fc_rport_enter_plogi(rdata);
 490                 break;
 491         case RPORT_ST_PRLI:
 492                 fc_rport_enter_prli(rdata);
 493                 break;
 494         case RPORT_ST_RTV:
 495                 fc_rport_enter_rtv(rdata);
 496                 break;
 497         case RPORT_ST_LOGO:
 498                 fc_rport_enter_logo(rdata);
 499                 break;
 500         case RPORT_ST_ADISC:
 501                 fc_rport_enter_adisc(rdata);
 502                 break;
 503         case RPORT_ST_READY:
 504         case RPORT_ST_INIT:
 505         case RPORT_ST_DELETE:
 506         case RPORT_ST_RESTART:
 507                 break;
 508         }
 509
 510         mutex_unlock(&rdata->rp_mutex);
 511 }
 512
 513 /**
 514  * fc_rport_error() - Error handler, called once retries have been exhausted
 515  * @rdata: The remote port the error is happened on
 516  * @fp:    The error code encapsulated in a frame pointer
 517  *
 518  * Locking Note: The rport lock is expected to be held before
 519  * calling this routine
 520  */
 521 static void fc_rport_error(struct fc_rport_priv *rdata, struct fc_frame *fp)
 522 {
 523         FC_RPORT_DBG(rdata, "Error %ld in state %s, retries %d\n",
 524                      IS_ERR(fp) ? -PTR_ERR(fp) : 0,
 525                      fc_rport_state(rdata), rdata->retries);
 526
 527         switch (rdata->rp_state) {
 528         case RPORT_ST_PLOGI:
 529         case RPORT_ST_LOGO:
 530                 fc_rport_enter_delete(rdata, RPORT_EV_FAILED);
 531                 break;
 532         case RPORT_ST_RTV:
 533                 fc_rport_enter_ready(rdata);
 534                 break;
 535         case RPORT_ST_PRLI:
 536         case RPORT_ST_ADISC:
 537                 fc_rport_enter_logo(rdata);
 538                 break;
 539         case RPORT_ST_DELETE:
 540         case RPORT_ST_RESTART:
 541         case RPORT_ST_READY:
 542         case RPORT_ST_INIT:
 543                 break;
 544         }
 545 }
 546
 547 /**
 548  * fc_rport_error_retry() - Handler for remote port state retries
 549  * @rdata: The remote port whose state is to be retried
 550  * @fp:    The error code encapsulated in a frame pointer
 551  *
 552  * If the error was an exchange timeout retry immediately,
 553  * otherwise wait for E_D_TOV.
 554  *
 555  * Locking Note: The rport lock is expected to be held before
 556  * calling this routine
 557  */
 558 static void fc_rport_error_retry(struct fc_rport_priv *rdata,
 559                                  struct fc_frame *fp)
 560 {
 561         unsigned long delay = FC_DEF_E_D_TOV;
 562
 563         /* make sure this isn't an FC_EX_CLOSED error, never retry those */
 564         if (PTR_ERR(fp) == -FC_EX_CLOSED)
 565                 return fc_rport_error(rdata, fp);
 566
 567         if (rdata->retries < rdata->local_port->max_rport_retry_count) {
 568                 FC_RPORT_DBG(rdata, "Error %ld in state %s, retrying\n",
 569                              PTR_ERR(fp), fc_rport_state(rdata));
 570                 rdata->retries++;
 571                 /* no additional delay on exchange timeouts */
 572                 if (PTR_ERR(fp) == -FC_EX_TIMEOUT)
 573                         delay = 0;
 574                 schedule_delayed_work(&rdata->retry_work, delay);
 575                 return;
 576         }
 577
 578         return fc_rport_error(rdata, fp);
 579 }
 580
 581 /**
 582  * fc_rport_plogi_recv_resp() - Handler for ELS PLOGI responses
 583  * @sp:        The sequence the PLOGI is on
 584  * @fp:        The PLOGI response frame
 585  * @rdata_arg: The remote port that sent the PLOGI response
 586  *
 587  * Locking Note: This function will be called without the rport lock
 588  * held, but it will lock, call an _enter_* function or fc_rport_error
 589  * and then unlock the rport.
 590  */
 591 static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
 592                                 void *rdata_arg)
 593 {
 594         struct fc_rport_priv *rdata = rdata_arg;
 595         struct fc_lport *lport = rdata->local_port;
 596         struct fc_els_flogi *plp = NULL;
 597         unsigned int tov;
 598         u16 csp_seq;
 599         u16 cssp_seq;
 600         u8 op;
 601
 602         mutex_lock(&rdata->rp_mutex);
 603
 604         FC_RPORT_DBG(rdata, "Received a PLOGI %s\n", fc_els_resp_type(fp));
 605
 606         if (rdata->rp_state != RPORT_ST_PLOGI) {
 607                 FC_RPORT_DBG(rdata, "Received a PLOGI response, but in state "
 608                              "%s\n", fc_rport_state(rdata));
 609                 if (IS_ERR(fp))
 610                         goto err;
 611                 goto out;
 612         }
 613
 614         if (IS_ERR(fp)) {
 615                 fc_rport_error_retry(rdata, fp);
 616                 goto err;
 617         }
 618
 619         op = fc_frame_payload_op(fp);
 620         if (op == ELS_LS_ACC &&
 621             (plp = fc_frame_payload_get(fp, sizeof(*plp))) != NULL) {
 622                 rdata->ids.port_name = get_unaligned_be64(&plp->fl_wwpn);
 623                 rdata->ids.node_name = get_unaligned_be64(&plp->fl_wwnn);
 624
 625                 tov = ntohl(plp->fl_csp.sp_e_d_tov);
 626                 if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
 627                         tov /= 1000000;
 628                 if (tov > rdata->e_d_tov)
 629                         rdata->e_d_tov = tov;
 630                 csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
 631                 cssp_seq = ntohs(plp->fl_cssp[3 - 1].cp_con_seq);
 632                 if (cssp_seq < csp_seq)
 633                         csp_seq = cssp_seq;
 634                 rdata->max_seq = csp_seq;
 635                 rdata->maxframe_size = fc_plogi_get_maxframe(plp, lport->mfs);
 636                 fc_rport_enter_prli(rdata);
 637         } else
 638                 fc_rport_error_retry(rdata, fp);
 639
 640 out:
 641         fc_frame_free(fp);
 642 err:
 643         mutex_unlock(&rdata->rp_mutex);
 644         kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
 645 }
 646
 647 /**
 648  * fc_rport_enter_plogi() - Send Port Login (PLOGI) request
 649  * @rdata: The remote port to send a PLOGI to
 650  *
 651  * Locking Note: The rport lock is expected to be held before calling
 652  * this routine.
 653  */
 654 static void fc_rport_enter_plogi(struct fc_rport_priv *rdata)
 655 {
 656         struct fc_lport *lport = rdata->local_port;
 657         struct fc_frame *fp;
 658
 659         FC_RPORT_DBG(rdata, "Port entered PLOGI state from %s state\n",
 660                      fc_rport_state(rdata));
 661
 662         fc_rport_state_enter(rdata, RPORT_ST_PLOGI);
 663
 664         rdata->maxframe_size = FC_MIN_MAX_PAYLOAD;
 665         fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
 666         if (!fp) {
 667                 fc_rport_error_retry(rdata, fp);
 668                 return;
 669         }
 670         rdata->e_d_tov = lport->e_d_tov;
 671
 672         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PLOGI,
 673                                   fc_rport_plogi_resp, rdata,
 674                                   2 * lport->r_a_tov))
 675                 fc_rport_error_retry(rdata, NULL);
 676         else
 677                 kref_get(&rdata->kref);
 678 }
 679
 680 /**
 681  * fc_rport_prli_resp() - Process Login (PRLI) response handler
 682  * @sp:        The sequence the PRLI response was on
 683  * @fp:        The PRLI response frame
 684  * @rdata_arg: The remote port that sent the PRLI response
 685  *
 686  * Locking Note: This function will be called without the rport lock
 687  * held, but it will lock, call an _enter_* function or fc_rport_error
 688  * and then unlock the rport.
 689  */
 690 static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
 691                                void *rdata_arg)
 692 {
 693         struct fc_rport_priv *rdata = rdata_arg;
 694         struct {
 695                 struct fc_els_prli prli;
 696                 struct fc_els_spp spp;
 697         } *pp;
 698         u32 roles = FC_RPORT_ROLE_UNKNOWN;
 699         u32 fcp_parm = 0;
 700         u8 op;
 701
 702         mutex_lock(&rdata->rp_mutex);
 703
 704         FC_RPORT_DBG(rdata, "Received a PRLI %s\n", fc_els_resp_type(fp));
 705
 706         if (rdata->rp_state != RPORT_ST_PRLI) {
 707                 FC_RPORT_DBG(rdata, "Received a PRLI response, but in state "
 708                              "%s\n", fc_rport_state(rdata));
 709                 if (IS_ERR(fp))
 710                         goto err;
 711                 goto out;
 712         }
 713
 714         if (IS_ERR(fp)) {
 715                 fc_rport_error_retry(rdata, fp);
 716                 goto err;
 717         }
 718
 719         /* reinitialize remote port roles */
 720         rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
 721
 722         op = fc_frame_payload_op(fp);
 723         if (op == ELS_LS_ACC) {
 724                 pp = fc_frame_payload_get(fp, sizeof(*pp));
 725                 if (pp && pp->prli.prli_spp_len >= sizeof(pp->spp)) {
 726                         fcp_parm = ntohl(pp->spp.spp_params);
 727                         if (fcp_parm & FCP_SPPF_RETRY)
 728                                 rdata->flags |= FC_RP_FLAGS_RETRY;
 729                 }
 730
 731                 rdata->supported_classes = FC_COS_CLASS3;
 732                 if (fcp_parm & FCP_SPPF_INIT_FCN)
 733                         roles |= FC_RPORT_ROLE_FCP_INITIATOR;
 734                 if (fcp_parm & FCP_SPPF_TARG_FCN)
 735                         roles |= FC_RPORT_ROLE_FCP_TARGET;
 736
 737                 rdata->ids.roles = roles;
 738                 fc_rport_enter_rtv(rdata);
 739
 740         } else {
 741                 FC_RPORT_DBG(rdata, "Bad ELS response for PRLI command\n");
 742                 fc_rport_enter_delete(rdata, RPORT_EV_FAILED);
 743         }
 744
 745 out:
 746         fc_frame_free(fp);
 747 err:
 748         mutex_unlock(&rdata->rp_mutex);
 749         kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
 750 }
 751
 752 /**
 753  * fc_rport_logo_resp() - Handler for logout (LOGO) responses
 754  * @sp:        The sequence the LOGO was on
 755  * @fp:        The LOGO response frame
 756  * @rdata_arg: The remote port that sent the LOGO response
 757  *
 758  * Locking Note: This function will be called without the rport lock
 759  * held, but it will lock, call an _enter_* function or fc_rport_error
 760  * and then unlock the rport.
 761  */
 762 static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
 763                                void *rdata_arg)
 764 {
 765         struct fc_rport_priv *rdata = rdata_arg;
 766         u8 op;
 767
 768         mutex_lock(&rdata->rp_mutex);
 769
 770         FC_RPORT_DBG(rdata, "Received a LOGO %s\n", fc_els_resp_type(fp));
 771
 772         if (rdata->rp_state != RPORT_ST_LOGO) {
 773                 FC_RPORT_DBG(rdata, "Received a LOGO response, but in state "
 774                              "%s\n", fc_rport_state(rdata));
 775                 if (IS_ERR(fp))
 776                         goto err;
 777                 goto out;
 778         }
 779
 780         if (IS_ERR(fp)) {
 781                 fc_rport_error_retry(rdata, fp);
 782                 goto err;
 783         }
 784
 785         op = fc_frame_payload_op(fp);
 786         if (op != ELS_LS_ACC)
 787                 FC_RPORT_DBG(rdata, "Bad ELS response op %x for LOGO command\n",
 788                              op);
 789         fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
 790
 791 out:
 792         fc_frame_free(fp);
 793 err:
 794         mutex_unlock(&rdata->rp_mutex);
 795         kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
 796 }
 797
 798 /**
 799  * fc_rport_enter_prli() - Send Process Login (PRLI) request
 800  * @rdata: The remote port to send the PRLI request to
 801  *
 802  * Locking Note: The rport lock is expected to be held before calling
 803  * this routine.
 804  */
 805 static void fc_rport_enter_prli(struct fc_rport_priv *rdata)
 806 {
 807         struct fc_lport *lport = rdata->local_port;
 808         struct {
 809                 struct fc_els_prli prli;
 810                 struct fc_els_spp spp;
 811         } *pp;
 812         struct fc_frame *fp;
 813
 814         /*
 815          * If the rport is one of the well known addresses
 816          * we skip PRLI and RTV and go straight to READY.
 817          */
 818         if (rdata->ids.port_id >= FC_FID_DOM_MGR) {
 819                 fc_rport_enter_ready(rdata);
 820                 return;
 821         }
 822
 823         FC_RPORT_DBG(rdata, "Port entered PRLI state from %s state\n",
 824                      fc_rport_state(rdata));
 825
 826         fc_rport_state_enter(rdata, RPORT_ST_PRLI);
 827
 828         fp = fc_frame_alloc(lport, sizeof(*pp));
 829         if (!fp) {
 830                 fc_rport_error_retry(rdata, fp);
 831                 return;
 832         }
 833
 834         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PRLI,
 835                                   fc_rport_prli_resp, rdata,
 836                                   2 * lport->r_a_tov))
 837                 fc_rport_error_retry(rdata, NULL);
 838         else
 839                 kref_get(&rdata->kref);
 840 }
 841
 842 /**
 843  * fc_rport_els_rtv_resp() - Handler for Request Timeout Value (RTV) responses
 844  * @sp:        The sequence the RTV was on
 845  * @fp:        The RTV response frame
 846  * @rdata_arg: The remote port that sent the RTV response
 847  *
 848  * Many targets don't seem to support this.
 849  *
 850  * Locking Note: This function will be called without the rport lock
 851  * held, but it will lock, call an _enter_* function or fc_rport_error
 852  * and then unlock the rport.
 853  */
 854 static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
 855                               void *rdata_arg)
 856 {
 857         struct fc_rport_priv *rdata = rdata_arg;
 858         u8 op;
 859
 860         mutex_lock(&rdata->rp_mutex);
 861
 862         FC_RPORT_DBG(rdata, "Received a RTV %s\n", fc_els_resp_type(fp));
 863
 864         if (rdata->rp_state != RPORT_ST_RTV) {
 865                 FC_RPORT_DBG(rdata, "Received a RTV response, but in state "
 866                              "%s\n", fc_rport_state(rdata));
 867                 if (IS_ERR(fp))
 868                         goto err;
 869                 goto out;
 870         }
 871
 872         if (IS_ERR(fp)) {
 873                 fc_rport_error(rdata, fp);
 874                 goto err;
 875         }
 876
 877         op = fc_frame_payload_op(fp);
 878         if (op == ELS_LS_ACC) {
 879                 struct fc_els_rtv_acc *rtv;
 880                 u32 toq;
 881                 u32 tov;
 882
 883                 rtv = fc_frame_payload_get(fp, sizeof(*rtv));
 884                 if (rtv) {
 885                         toq = ntohl(rtv->rtv_toq);
 886                         tov = ntohl(rtv->rtv_r_a_tov);
 887                         if (tov == 0)
 888                                 tov = 1;
 889                         rdata->r_a_tov = tov;
 890                         tov = ntohl(rtv->rtv_e_d_tov);
 891                         if (toq & FC_ELS_RTV_EDRES)
 892                                 tov /= 1000000;
 893                         if (tov == 0)
 894                                 tov = 1;
 895                         rdata->e_d_tov = tov;
 896                 }
 897         }
 898
 899         fc_rport_enter_ready(rdata);
 900
 901 out:
 902         fc_frame_free(fp);
 903 err:
 904         mutex_unlock(&rdata->rp_mutex);
 905         kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
 906 }
 907
 908 /**
 909  * fc_rport_enter_rtv() - Send Request Timeout Value (RTV) request
 910  * @rdata: The remote port to send the RTV request to
 911  *
 912  * Locking Note: The rport lock is expected to be held before calling
 913  * this routine.
 914  */
 915 static void fc_rport_enter_rtv(struct fc_rport_priv *rdata)
 916 {
 917         struct fc_frame *fp;
 918         struct fc_lport *lport = rdata->local_port;
 919
 920         FC_RPORT_DBG(rdata, "Port entered RTV state from %s state\n",
 921                      fc_rport_state(rdata));
 922
 923         fc_rport_state_enter(rdata, RPORT_ST_RTV);
 924
 925         fp = fc_frame_alloc(lport, sizeof(struct fc_els_rtv));
 926         if (!fp) {
 927                 fc_rport_error_retry(rdata, fp);
 928                 return;
 929         }
 930
 931         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_RTV,
 932                                   fc_rport_rtv_resp, rdata,
 933                                   2 * lport->r_a_tov))
 934                 fc_rport_error_retry(rdata, NULL);
 935         else
 936                 kref_get(&rdata->kref);
 937 }
 938
 939 /**
 940  * fc_rport_enter_logo() - Send a logout (LOGO) request
 941  * @rdata: The remote port to send the LOGO request to
 942  *
 943  * Locking Note: The rport lock is expected to be held before calling
 944  * this routine.
 945  */
 946 static void fc_rport_enter_logo(struct fc_rport_priv *rdata)
 947 {
 948         struct fc_lport *lport = rdata->local_port;
 949         struct fc_frame *fp;
 950
 951         FC_RPORT_DBG(rdata, "Port entered LOGO state from %s state\n",
 952                      fc_rport_state(rdata));
 953
 954         fc_rport_state_enter(rdata, RPORT_ST_LOGO);
 955
 956         fp = fc_frame_alloc(lport, sizeof(struct fc_els_logo));
 957         if (!fp) {
 958                 fc_rport_error_retry(rdata, fp);
 959                 return;
 960         }
 961
 962         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_LOGO,
 963                                   fc_rport_logo_resp, rdata,
 964                                   2 * lport->r_a_tov))
 965                 fc_rport_error_retry(rdata, NULL);
 966         else
 967                 kref_get(&rdata->kref);
 968 }
 969
 970 /**
 971  * fc_rport_els_adisc_resp() - Handler for Address Discovery (ADISC) responses
 972  * @sp:        The sequence the ADISC response was on
 973  * @fp:        The ADISC response frame
 974  * @rdata_arg: The remote port that sent the ADISC response
 975  *
 976  * Locking Note: This function will be called without the rport lock
 977  * held, but it will lock, call an _enter_* function or fc_rport_error
 978  * and then unlock the rport.
 979  */
 980 static void fc_rport_adisc_resp(struct fc_seq *sp, struct fc_frame *fp,
 981                                 void *rdata_arg)
 982 {
 983         struct fc_rport_priv *rdata = rdata_arg;
 984         struct fc_els_adisc *adisc;
 985         u8 op;
 986
 987         mutex_lock(&rdata->rp_mutex);
 988
 989         FC_RPORT_DBG(rdata, "Received a ADISC response\n");
 990
 991         if (rdata->rp_state != RPORT_ST_ADISC) {
 992                 FC_RPORT_DBG(rdata, "Received a ADISC resp but in state %s\n",
 993                              fc_rport_state(rdata));
 994                 if (IS_ERR(fp))
 995                         goto err;
 996                 goto out;
 997         }
 998
 999         if (IS_ERR(fp)) {
1000                 fc_rport_error(rdata, fp);
1001                 goto err;
1002         }
1003
1004         /*
1005          * If address verification failed.  Consider us logged out of the rport.
1006          * Since the rport is still in discovery, we want to be
1007          * logged in, so go to PLOGI state.  Otherwise, go back to READY.
1008          */
1009         op = fc_frame_payload_op(fp);
1010         adisc = fc_frame_payload_get(fp, sizeof(*adisc));
1011         if (op != ELS_LS_ACC || !adisc ||
1012             ntoh24(adisc->adisc_port_id) != rdata->ids.port_id ||
1013             get_unaligned_be64(&adisc->adisc_wwpn) != rdata->ids.port_name ||
1014             get_unaligned_be64(&adisc->adisc_wwnn) != rdata->ids.node_name) {
1015                 FC_RPORT_DBG(rdata, "ADISC error or mismatch\n");
1016                 fc_rport_enter_plogi(rdata);
1017         } else {
1018                 FC_RPORT_DBG(rdata, "ADISC OK\n");
1019                 fc_rport_enter_ready(rdata);
1020         }
1021 out:
1022         fc_frame_free(fp);
1023 err:
1024         mutex_unlock(&rdata->rp_mutex);
1025         kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
1026 }
1027
1028 /**
1029  * fc_rport_enter_adisc() - Send Address Discover (ADISC) request
1030  * @rdata: The remote port to send the ADISC request to
1031  *
1032  * Locking Note: The rport lock is expected to be held before calling
1033  * this routine.
1034  */
1035 static void fc_rport_enter_adisc(struct fc_rport_priv *rdata)
1036 {
1037         struct fc_lport *lport = rdata->local_port;
1038         struct fc_frame *fp;
1039
1040         FC_RPORT_DBG(rdata, "sending ADISC from %s state\n",
1041                      fc_rport_state(rdata));
1042
1043         fc_rport_state_enter(rdata, RPORT_ST_ADISC);
1044
1045         fp = fc_frame_alloc(lport, sizeof(struct fc_els_adisc));
1046         if (!fp) {
1047                 fc_rport_error_retry(rdata, fp);
1048                 return;
1049         }
1050         if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_ADISC,
1051                                   fc_rport_adisc_resp, rdata,
1052                                   2 * lport->r_a_tov))
1053                 fc_rport_error_retry(rdata, NULL);
1054         else
1055                 kref_get(&rdata->kref);
1056 }
1057
1058 /**
1059  * fc_rport_recv_adisc_req() - Handler for Address Discovery (ADISC) requests
1060  * @rdata: The remote port that sent the ADISC request
1061  * @sp:    The sequence the ADISC request was on
1062  * @in_fp: The ADISC request frame
1063  *
1064  * Locking Note:  Called with the lport and rport locks held.
1065  */
1066 static void fc_rport_recv_adisc_req(struct fc_rport_priv *rdata,
1067                                     struct fc_seq *sp, struct fc_frame *in_fp)
1068 {
1069         struct fc_lport *lport = rdata->local_port;
1070         struct fc_frame *fp;
1071         struct fc_exch *ep = fc_seq_exch(sp);
1072         struct fc_els_adisc *adisc;
1073         struct fc_seq_els_data rjt_data;
1074         u32 f_ctl;
1075
1076         FC_RPORT_DBG(rdata, "Received ADISC request\n");
1077
1078         adisc = fc_frame_payload_get(in_fp, sizeof(*adisc));
1079         if (!adisc) {
1080                 rjt_data.fp = NULL;
1081                 rjt_data.reason = ELS_RJT_PROT;
1082                 rjt_data.explan = ELS_EXPL_INV_LEN;
1083                 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1084                 goto drop;
1085         }
1086
1087         fp = fc_frame_alloc(lport, sizeof(*adisc));
1088         if (!fp)
1089                 goto drop;
1090         fc_adisc_fill(lport, fp);
1091         adisc = fc_frame_payload_get(fp, sizeof(*adisc));
1092         adisc->adisc_cmd = ELS_LS_ACC;
1093         sp = lport->tt.seq_start_next(sp);
1094         f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1095         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1096                        FC_TYPE_ELS, f_ctl, 0);
1097         lport->tt.seq_send(lport, sp, fp);
1098 drop:
1099         fc_frame_free(in_fp);
1100 }
1101
1102 /**
1103  * fc_rport_recv_rls_req() - Handle received Read Link Status request
1104  * @rdata: The remote port that sent the RLS request
1105  * @sp: The sequence that the RLS was on
1106  * @rx_fp: The PRLI request frame
1107  *
1108  * Locking Note: The rport lock is expected to be held before calling
1109  * this function.
1110  */
1111 static void fc_rport_recv_rls_req(struct fc_rport_priv *rdata,
1112                                   struct fc_seq *sp, struct fc_frame *rx_fp)
1113
1114 {
1115         struct fc_lport *lport = rdata->local_port;
1116         struct fc_frame *fp;
1117         struct fc_exch *ep = fc_seq_exch(sp);
1118         struct fc_els_rls *rls;
1119         struct fc_els_rls_resp *rsp;
1120         struct fc_els_lesb *lesb;
1121         struct fc_seq_els_data rjt_data;
1122         struct fc_host_statistics *hst;
1123         u32 f_ctl;
1124
1125         FC_RPORT_DBG(rdata, "Received RLS request while in state %s\n",
1126                      fc_rport_state(rdata));
1127
1128         rls = fc_frame_payload_get(rx_fp, sizeof(*rls));
1129         if (!rls) {
1130                 rjt_data.reason = ELS_RJT_PROT;
1131                 rjt_data.explan = ELS_EXPL_INV_LEN;
1132                 goto out_rjt;
1133         }
1134
1135         fp = fc_frame_alloc(lport, sizeof(*rsp));
1136         if (!fp) {
1137                 rjt_data.reason = ELS_RJT_UNAB;
1138                 rjt_data.explan = ELS_EXPL_INSUF_RES;
1139                 goto out_rjt;
1140         }
1141
1142         rsp = fc_frame_payload_get(fp, sizeof(*rsp));
1143         memset(rsp, 0, sizeof(*rsp));
1144         rsp->rls_cmd = ELS_LS_ACC;
1145         lesb = &rsp->rls_lesb;
1146         if (lport->tt.get_lesb) {
1147                 /* get LESB from LLD if it supports it */
1148                 lport->tt.get_lesb(lport, lesb);
1149         } else {
1150                 fc_get_host_stats(lport->host);
1151                 hst = &lport->host_stats;
1152                 lesb->lesb_link_fail = htonl(hst->link_failure_count);
1153                 lesb->lesb_sync_loss = htonl(hst->loss_of_sync_count);
1154                 lesb->lesb_sig_loss = htonl(hst->loss_of_signal_count);
1155                 lesb->lesb_prim_err = htonl(hst->prim_seq_protocol_err_count);
1156                 lesb->lesb_inv_word = htonl(hst->invalid_tx_word_count);
1157                 lesb->lesb_inv_crc = htonl(hst->invalid_crc_count);
1158         }
1159
1160         sp = lport->tt.seq_start_next(sp);
1161         f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
1162         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1163                        FC_TYPE_ELS, f_ctl, 0);
1164         lport->tt.seq_send(lport, sp, fp);
1165         goto out;
1166
1167 out_rjt:
1168         rjt_data.fp = NULL;
1169         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1170 out:
1171         fc_frame_free(rx_fp);
1172 }
1173
1174 /**
1175  * fc_rport_recv_els_req() - Handler for validated ELS requests
1176  * @lport: The local port that received the ELS request
1177  * @sp:    The sequence that the ELS request was on
1178  * @fp:    The ELS request frame
1179  *
1180  * Handle incoming ELS requests that require port login.
1181  * The ELS opcode has already been validated by the caller.
1182  *
1183  * Locking Note: Called with the lport lock held.
1184  */
1185 static void fc_rport_recv_els_req(struct fc_lport *lport,
1186                                   struct fc_seq *sp, struct fc_frame *fp)
1187 {
1188         struct fc_rport_priv *rdata;
1189         struct fc_frame_header *fh;
1190         struct fc_seq_els_data els_data;
1191
1192         els_data.fp = NULL;
1193         els_data.reason = ELS_RJT_UNAB;
1194         els_data.explan = ELS_EXPL_PLOGI_REQD;
1195
1196         fh = fc_frame_header_get(fp);
1197
1198         mutex_lock(&lport->disc.disc_mutex);
1199         rdata = lport->tt.rport_lookup(lport, ntoh24(fh->fh_s_id));
1200         if (!rdata) {
1201                 mutex_unlock(&lport->disc.disc_mutex);
1202                 goto reject;
1203         }
1204         mutex_lock(&rdata->rp_mutex);
1205         mutex_unlock(&lport->disc.disc_mutex);
1206
1207         switch (rdata->rp_state) {
1208         case RPORT_ST_PRLI:
1209         case RPORT_ST_RTV:
1210         case RPORT_ST_READY:
1211         case RPORT_ST_ADISC:
1212                 break;
1213         default:
1214                 mutex_unlock(&rdata->rp_mutex);
1215                 goto reject;
1216         }
1217
1218         switch (fc_frame_payload_op(fp)) {
1219         case ELS_PRLI:
1220                 fc_rport_recv_prli_req(rdata, sp, fp);
1221                 break;
1222         case ELS_PRLO:
1223                 fc_rport_recv_prlo_req(rdata, sp, fp);
1224                 break;
1225         case ELS_ADISC:
1226                 fc_rport_recv_adisc_req(rdata, sp, fp);
1227                 break;
1228         case ELS_RRQ:
1229                 els_data.fp = fp;
1230                 lport->tt.seq_els_rsp_send(sp, ELS_RRQ, &els_data);
1231                 break;
1232         case ELS_REC:
1233                 els_data.fp = fp;
1234                 lport->tt.seq_els_rsp_send(sp, ELS_REC, &els_data);
1235                 break;
1236         case ELS_RLS:
1237                 fc_rport_recv_rls_req(rdata, sp, fp);
1238                 break;
1239         default:
1240                 fc_frame_free(fp);      /* can't happen */
1241                 break;
1242         }
1243
1244         mutex_unlock(&rdata->rp_mutex);
1245         return;
1246
1247 reject:
1248         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
1249         fc_frame_free(fp);
1250 }
1251
1252 /**
1253  * fc_rport_recv_req() - Handler for requests
1254  * @sp:    The sequence the request was on
1255  * @fp:    The request frame
1256  * @lport: The local port that received the request
1257  *
1258  * Locking Note: Called with the lport lock held.
1259  */
1260 void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
1261                        struct fc_lport *lport)
1262 {
1263         struct fc_seq_els_data els_data;
1264
1265         /*
1266          * Handle PLOGI and LOGO requests separately, since they
1267          * don't require prior login.
1268          * Check for unsupported opcodes first and reject them.
1269          * For some ops, it would be incorrect to reject with "PLOGI required".
1270          */
1271         switch (fc_frame_payload_op(fp)) {
1272         case ELS_PLOGI:
1273                 fc_rport_recv_plogi_req(lport, sp, fp);
1274                 break;
1275         case ELS_LOGO:
1276                 fc_rport_recv_logo_req(lport, sp, fp);
1277                 break;
1278         case ELS_PRLI:
1279         case ELS_PRLO:
1280         case ELS_ADISC:
1281         case ELS_RRQ:
1282         case ELS_REC:
1283         case ELS_RLS:
1284                 fc_rport_recv_els_req(lport, sp, fp);
1285                 break;
1286         default:
1287                 fc_frame_free(fp);
1288                 els_data.fp = NULL;
1289                 els_data.reason = ELS_RJT_UNSUP;
1290                 els_data.explan = ELS_EXPL_NONE;
1291                 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
1292                 break;
1293         }
1294 }
1295
1296 /**
1297  * fc_rport_recv_plogi_req() - Handler for Port Login (PLOGI) requests
1298  * @lport: The local port that received the PLOGI request
1299  * @sp:    The sequence that the PLOGI request was on
1300  * @rx_fp: The PLOGI request frame
1301  *
1302  * Locking Note: The rport lock is held before calling this function.
1303  */
1304 static void fc_rport_recv_plogi_req(struct fc_lport *lport,
1305                                     struct fc_seq *sp, struct fc_frame *rx_fp)
1306 {
1307         struct fc_disc *disc;
1308         struct fc_rport_priv *rdata;
1309         struct fc_frame *fp = rx_fp;
1310         struct fc_exch *ep;
1311         struct fc_frame_header *fh;
1312         struct fc_els_flogi *pl;
1313         struct fc_seq_els_data rjt_data;
1314         u32 sid, f_ctl;
1315
1316         rjt_data.fp = NULL;
1317         fh = fc_frame_header_get(fp);
1318         sid = ntoh24(fh->fh_s_id);
1319
1320         FC_RPORT_ID_DBG(lport, sid, "Received PLOGI request\n");
1321
1322         pl = fc_frame_payload_get(fp, sizeof(*pl));
1323         if (!pl) {
1324                 FC_RPORT_ID_DBG(lport, sid, "Received PLOGI too short\n");
1325                 rjt_data.reason = ELS_RJT_PROT;
1326                 rjt_data.explan = ELS_EXPL_INV_LEN;
1327                 goto reject;
1328         }
1329
1330         disc = &lport->disc;
1331         mutex_lock(&disc->disc_mutex);
1332         rdata = lport->tt.rport_create(lport, sid);
1333         if (!rdata) {
1334                 mutex_unlock(&disc->disc_mutex);
1335                 rjt_data.reason = ELS_RJT_UNAB;
1336                 rjt_data.explan = ELS_EXPL_INSUF_RES;
1337                 goto reject;
1338         }
1339
1340         mutex_lock(&rdata->rp_mutex);
1341         mutex_unlock(&disc->disc_mutex);
1342
1343         rdata->ids.port_name = get_unaligned_be64(&pl->fl_wwpn);
1344         rdata->ids.node_name = get_unaligned_be64(&pl->fl_wwnn);
1345
1346         /*
1347          * If the rport was just created, possibly due to the incoming PLOGI,
1348          * set the state appropriately and accept the PLOGI.
1349          *
1350          * If we had also sent a PLOGI, and if the received PLOGI is from a
1351          * higher WWPN, we accept it, otherwise an LS_RJT is sent with reason
1352          * "command already in progress".
1353          *
1354          * XXX TBD: If the session was ready before, the PLOGI should result in
1355          * all outstanding exchanges being reset.
1356          */
1357         switch (rdata->rp_state) {
1358         case RPORT_ST_INIT:
1359                 FC_RPORT_DBG(rdata, "Received PLOGI in INIT state\n");
1360                 break;
1361         case RPORT_ST_PLOGI:
1362                 FC_RPORT_DBG(rdata, "Received PLOGI in PLOGI state\n");
1363                 if (rdata->ids.port_name < lport->wwpn) {
1364                         mutex_unlock(&rdata->rp_mutex);
1365                         rjt_data.reason = ELS_RJT_INPROG;
1366                         rjt_data.explan = ELS_EXPL_NONE;
1367                         goto reject;
1368                 }
1369                 break;
1370         case RPORT_ST_PRLI:
1371         case RPORT_ST_RTV:
1372         case RPORT_ST_READY:
1373         case RPORT_ST_ADISC:
1374                 FC_RPORT_DBG(rdata, "Received PLOGI in logged-in state %d "
1375                              "- ignored for now\n", rdata->rp_state);
1376                 /* XXX TBD - should reset */
1377                 break;
1378         case RPORT_ST_DELETE:
1379         case RPORT_ST_LOGO:
1380         case RPORT_ST_RESTART:
1381                 FC_RPORT_DBG(rdata, "Received PLOGI in state %s - send busy\n",
1382                              fc_rport_state(rdata));
1383                 mutex_unlock(&rdata->rp_mutex);
1384                 rjt_data.reason = ELS_RJT_BUSY;
1385                 rjt_data.explan = ELS_EXPL_NONE;
1386                 goto reject;
1387         }
1388
1389         /*
1390          * Get session payload size from incoming PLOGI.
1391          */
1392         rdata->maxframe_size = fc_plogi_get_maxframe(pl, lport->mfs);
1393         fc_frame_free(rx_fp);
1394
1395         /*
1396          * Send LS_ACC.  If this fails, the originator should retry.
1397          */
1398         sp = lport->tt.seq_start_next(sp);
1399         if (!sp)
1400                 goto out;
1401         fp = fc_frame_alloc(lport, sizeof(*pl));
1402         if (!fp)
1403                 goto out;
1404
1405         fc_plogi_fill(lport, fp, ELS_LS_ACC);
1406         f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1407         ep = fc_seq_exch(sp);
1408         fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1409                        FC_TYPE_ELS, f_ctl, 0);
1410         lport->tt.seq_send(lport, sp, fp);
1411         fc_rport_enter_prli(rdata);
1412 out:
1413         mutex_unlock(&rdata->rp_mutex);
1414         return;
1415
1416 reject:
1417         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1418         fc_frame_free(fp);
1419 }
1420
1421 /**
1422  * fc_rport_recv_prli_req() - Handler for process login (PRLI) requests
1423  * @rdata: The remote port that sent the PRLI request
1424  * @sp:    The sequence that the PRLI was on
1425  * @rx_fp: The PRLI request frame
1426  *
1427  * Locking Note: The rport lock is exected to be held before calling
1428  * this function.
1429  */
1430 static void fc_rport_recv_prli_req(struct fc_rport_priv *rdata,
1431                                    struct fc_seq *sp, struct fc_frame *rx_fp)
1432 {
1433         struct fc_lport *lport = rdata->local_port;
1434         struct fc_exch *ep;
1435         struct fc_frame *fp;
1436         struct fc_frame_header *fh;
1437         struct {
1438                 struct fc_els_prli prli;
1439                 struct fc_els_spp spp;
1440         } *pp;
1441         struct fc_els_spp *rspp;        /* request service param page */
1442         struct fc_els_spp *spp; /* response spp */
1443         unsigned int len;
1444         unsigned int plen;
1445         enum fc_els_rjt_reason reason = ELS_RJT_UNAB;
1446         enum fc_els_rjt_explan explan = ELS_EXPL_NONE;
1447         enum fc_els_spp_resp resp;
1448         struct fc_seq_els_data rjt_data;
1449         u32 f_ctl;
1450         u32 fcp_parm;
1451         u32 roles = FC_RPORT_ROLE_UNKNOWN;
1452         rjt_data.fp = NULL;
1453
1454         fh = fc_frame_header_get(rx_fp);
1455
1456         FC_RPORT_DBG(rdata, "Received PRLI request while in state %s\n",
1457                      fc_rport_state(rdata));
1458
1459         switch (rdata->rp_state) {
1460         case RPORT_ST_PRLI:
1461         case RPORT_ST_RTV:
1462         case RPORT_ST_READY:
1463         case RPORT_ST_ADISC:
1464                 reason = ELS_RJT_NONE;
1465                 break;
1466         default:
1467                 fc_frame_free(rx_fp);
1468                 return;
1469                 break;
1470         }
1471         len = fr_len(rx_fp) - sizeof(*fh);
1472         pp = fc_frame_payload_get(rx_fp, sizeof(*pp));
1473         if (pp == NULL) {
1474                 reason = ELS_RJT_PROT;
1475                 explan = ELS_EXPL_INV_LEN;
1476         } else {
1477                 plen = ntohs(pp->prli.prli_len);
1478                 if ((plen % 4) != 0 || plen > len) {
1479                         reason = ELS_RJT_PROT;
1480                         explan = ELS_EXPL_INV_LEN;
1481                 } else if (plen < len) {
1482                         len = plen;
1483                 }
1484                 plen = pp->prli.prli_spp_len;
1485                 if ((plen % 4) != 0 || plen < sizeof(*spp) ||
1486                     plen > len || len < sizeof(*pp)) {
1487                         reason = ELS_RJT_PROT;
1488                         explan = ELS_EXPL_INV_LEN;
1489                 }
1490                 rspp = &pp->spp;
1491         }
1492         if (reason != ELS_RJT_NONE ||
1493             (fp = fc_frame_alloc(lport, len)) == NULL) {
1494                 rjt_data.reason = reason;
1495                 rjt_data.explan = explan;
1496                 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1497         } else {
1498                 sp = lport->tt.seq_start_next(sp);
1499                 WARN_ON(!sp);
1500                 pp = fc_frame_payload_get(fp, len);
1501                 WARN_ON(!pp);
1502                 memset(pp, 0, len);
1503                 pp->prli.prli_cmd = ELS_LS_ACC;
1504                 pp->prli.prli_spp_len = plen;
1505                 pp->prli.prli_len = htons(len);
1506                 len -= sizeof(struct fc_els_prli);
1507
1508                 /* reinitialize remote port roles */
1509                 rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
1510
1511                 /*
1512                  * Go through all the service parameter pages and build
1513                  * response.  If plen indicates longer SPP than standard,
1514                  * use that.  The entire response has been pre-cleared above.
1515                  */
1516                 spp = &pp->spp;
1517                 while (len >= plen) {
1518                         spp->spp_type = rspp->spp_type;
1519                         spp->spp_type_ext = rspp->spp_type_ext;
1520                         spp->spp_flags = rspp->spp_flags & FC_SPP_EST_IMG_PAIR;
1521                         resp = FC_SPP_RESP_ACK;
1522                         if (rspp->spp_flags & FC_SPP_RPA_VAL)
1523                                 resp = FC_SPP_RESP_NO_PA;
1524                         switch (rspp->spp_type) {
1525                         case 0: /* common to all FC-4 types */
1526                                 break;
1527                         case FC_TYPE_FCP:
1528                                 fcp_parm = ntohl(rspp->spp_params);
1529                                 if (fcp_parm & FCP_SPPF_RETRY)
1530                                         rdata->flags |= FC_RP_FLAGS_RETRY;
1531                                 rdata->supported_classes = FC_COS_CLASS3;
1532                                 if (fcp_parm & FCP_SPPF_INIT_FCN)
1533                                         roles |= FC_RPORT_ROLE_FCP_INITIATOR;
1534                                 if (fcp_parm & FCP_SPPF_TARG_FCN)
1535                                         roles |= FC_RPORT_ROLE_FCP_TARGET;
1536                                 rdata->ids.roles = roles;
1537
1538                                 spp->spp_params =
1539                                         htonl(lport->service_params);
1540                                 break;
1541                         default:
1542                                 resp = FC_SPP_RESP_INVL;
1543                                 break;
1544                         }
1545                         spp->spp_flags |= resp;
1546                         len -= plen;
1547                         rspp = (struct fc_els_spp *)((char *)rspp + plen);
1548                         spp = (struct fc_els_spp *)((char *)spp + plen);
1549                 }
1550
1551                 /*
1552                  * Send LS_ACC.  If this fails, the originator should retry.
1553                  */
1554                 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
1555                 f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1556                 ep = fc_seq_exch(sp);
1557                 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1558                                FC_TYPE_ELS, f_ctl, 0);
1559                 lport->tt.seq_send(lport, sp, fp);
1560
1561                 /*
1562                  * Get lock and re-check state.
1563                  */
1564                 switch (rdata->rp_state) {
1565                 case RPORT_ST_PRLI:
1566                         fc_rport_enter_ready(rdata);
1567                         break;
1568                 case RPORT_ST_READY:
1569                 case RPORT_ST_ADISC:
1570                         break;
1571                 default:
1572                         break;
1573                 }
1574         }
1575         fc_frame_free(rx_fp);
1576 }
1577
1578 /**
1579  * fc_rport_recv_prlo_req() - Handler for process logout (PRLO) requests
1580  * @rdata: The remote port that sent the PRLO request
1581  * @sp:    The sequence that the PRLO was on
1582  * @fp:    The PRLO request frame
1583  *
1584  * Locking Note: The rport lock is exected to be held before calling
1585  * this function.
1586  */
1587 static void fc_rport_recv_prlo_req(struct fc_rport_priv *rdata,
1588                                    struct fc_seq *sp,
1589                                    struct fc_frame *fp)
1590 {
1591         struct fc_lport *lport = rdata->local_port;
1592
1593         struct fc_frame_header *fh;
1594         struct fc_seq_els_data rjt_data;
1595
1596         fh = fc_frame_header_get(fp);
1597
1598         FC_RPORT_DBG(rdata, "Received PRLO request while in state %s\n",
1599                      fc_rport_state(rdata));
1600
1601         rjt_data.fp = NULL;
1602         rjt_data.reason = ELS_RJT_UNAB;
1603         rjt_data.explan = ELS_EXPL_NONE;
1604         lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1605         fc_frame_free(fp);
1606 }
1607
1608 /**
1609  * fc_rport_recv_logo_req() - Handler for logout (LOGO) requests
1610  * @lport: The local port that received the LOGO request
1611  * @sp:    The sequence that the LOGO request was on
1612  * @fp:    The LOGO request frame
1613  *
1614  * Locking Note: The rport lock is exected to be held before calling
1615  * this function.
1616  */
1617 static void fc_rport_recv_logo_req(struct fc_lport *lport,
1618                                    struct fc_seq *sp,
1619                                    struct fc_frame *fp)
1620 {
1621         struct fc_frame_header *fh;
1622         struct fc_rport_priv *rdata;
1623         u32 sid;
1624
1625         lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
1626
1627         fh = fc_frame_header_get(fp);
1628         sid = ntoh24(fh->fh_s_id);
1629
1630         mutex_lock(&lport->disc.disc_mutex);
1631         rdata = lport->tt.rport_lookup(lport, sid);
1632         if (rdata) {
1633                 mutex_lock(&rdata->rp_mutex);
1634                 FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",
1635                              fc_rport_state(rdata));
1636
1637                 fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
1638
1639                 /*
1640                  * If the remote port was created due to discovery, set state
1641                  * to log back in.  It may have seen a stale RSCN about us.
1642                  */
1643                 if (rdata->disc_id)
1644                         fc_rport_state_enter(rdata, RPORT_ST_RESTART);
1645                 mutex_unlock(&rdata->rp_mutex);
1646         } else
1647                 FC_RPORT_ID_DBG(lport, sid,
1648                                 "Received LOGO from non-logged-in port\n");
1649         mutex_unlock(&lport->disc.disc_mutex);
1650         fc_frame_free(fp);
1651 }
1652
1653 /**
1654  * fc_rport_flush_queue() - Flush the rport_event_queue
1655  */
1656 static void fc_rport_flush_queue(void)
1657 {
1658         flush_workqueue(rport_event_queue);
1659 }
1660
1661 /**
1662  * fc_rport_init() - Initialize the remote port layer for a local port
1663  * @lport: The local port to initialize the remote port layer for
1664  */
1665 int fc_rport_init(struct fc_lport *lport)
1666 {
1667         if (!lport->tt.rport_lookup)
1668                 lport->tt.rport_lookup = fc_rport_lookup;
1669
1670         if (!lport->tt.rport_create)
1671                 lport->tt.rport_create = fc_rport_create;
1672
1673         if (!lport->tt.rport_login)
1674                 lport->tt.rport_login = fc_rport_login;
1675
1676         if (!lport->tt.rport_logoff)
1677                 lport->tt.rport_logoff = fc_rport_logoff;
1678
1679         if (!lport->tt.rport_recv_req)
1680                 lport->tt.rport_recv_req = fc_rport_recv_req;
1681
1682         if (!lport->tt.rport_flush_queue)
1683                 lport->tt.rport_flush_queue = fc_rport_flush_queue;
1684
1685         if (!lport->tt.rport_destroy)
1686                 lport->tt.rport_destroy = fc_rport_destroy;
1687
1688         return 0;
1689 }
1690 EXPORT_SYMBOL(fc_rport_init);
1691
1692 /**
1693  * fc_setup_rport() - Initialize the rport_event_queue
1694  */
1695 int fc_setup_rport()
1696 {
1697         rport_event_queue = create_singlethread_workqueue("fc_rport_eq");
1698         if (!rport_event_queue)
1699                 return -ENOMEM;
1700         return 0;
1701 }
1702
1703 /**
1704  * fc_destroy_rport() - Destroy the rport_event_queue
1705  */
1706 void fc_destroy_rport()
1707 {
1708         destroy_workqueue(rport_event_queue);
1709 }
1710
1711 /**
1712  * fc_rport_terminate_io() - Stop all outstanding I/O on a remote port
1713  * @rport: The remote port whose I/O should be terminated
1714  */
1715 void fc_rport_terminate_io(struct fc_rport *rport)
1716 {
1717         struct fc_rport_libfc_priv *rpriv = rport->dd_data;
1718         struct fc_lport *lport = rpriv->local_port;
1719
1720         lport->tt.exch_mgr_reset(lport, 0, rport->port_id);
1721         lport->tt.exch_mgr_reset(lport, rport->port_id, 0);
1722 }
1723 EXPORT_SYMBOL(fc_rport_terminate_io);