Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
fc_rport.c
Go to the documentation of this file.
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 hierarchy.
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 <linux/export.h>
55 #include <asm/unaligned.h>
56 
57 #include <scsi/libfc.h>
58 #include <scsi/fc_encode.h>
59 
60 #include "fc_libfc.h"
61 
62 static struct workqueue_struct *rport_event_queue;
63 
64 static void fc_rport_enter_flogi(struct fc_rport_priv *);
65 static void fc_rport_enter_plogi(struct fc_rport_priv *);
66 static void fc_rport_enter_prli(struct fc_rport_priv *);
67 static void fc_rport_enter_rtv(struct fc_rport_priv *);
68 static void fc_rport_enter_ready(struct fc_rport_priv *);
69 static void fc_rport_enter_logo(struct fc_rport_priv *);
70 static void fc_rport_enter_adisc(struct fc_rport_priv *);
71 
72 static void fc_rport_recv_plogi_req(struct fc_lport *, struct fc_frame *);
73 static void fc_rport_recv_prli_req(struct fc_rport_priv *, struct fc_frame *);
74 static void fc_rport_recv_prlo_req(struct fc_rport_priv *, struct fc_frame *);
75 static void fc_rport_recv_logo_req(struct fc_lport *, struct fc_frame *);
76 static void fc_rport_timeout(struct work_struct *);
77 static void fc_rport_error(struct fc_rport_priv *, struct fc_frame *);
78 static void fc_rport_error_retry(struct fc_rport_priv *, struct fc_frame *);
79 static void fc_rport_work(struct work_struct *);
80 
81 static const char *fc_rport_state_names[] = {
82  [RPORT_ST_INIT] = "Init",
83  [RPORT_ST_FLOGI] = "FLOGI",
84  [RPORT_ST_PLOGI_WAIT] = "PLOGI_WAIT",
85  [RPORT_ST_PLOGI] = "PLOGI",
86  [RPORT_ST_PRLI] = "PRLI",
87  [RPORT_ST_RTV] = "RTV",
88  [RPORT_ST_READY] = "Ready",
89  [RPORT_ST_ADISC] = "ADISC",
90  [RPORT_ST_DELETE] = "Delete",
91 };
92 
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_rcu(rdata, &lport->disc.rports, peers)
106  if (rdata->ids.port_id == port_id)
107  return rdata;
108  return NULL;
109 }
110 
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) + lport->rport_priv_size, 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;
144  rdata->e_d_tov = lport->e_d_tov;
145  rdata->r_a_tov = lport->r_a_tov;
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  rdata->lld_event_callback = lport->tt.rport_event_callback;
151  list_add_rcu(&rdata->peers, &lport->disc.rports);
152  }
153  return rdata;
154 }
155 
160 static void fc_rport_destroy(struct kref *kref)
161 {
162  struct fc_rport_priv *rdata;
163 
164  rdata = container_of(kref, struct fc_rport_priv, kref);
165  kfree_rcu(rdata, rcu);
166 }
167 
172 static const char *fc_rport_state(struct fc_rport_priv *rdata)
173 {
174  const char *cp;
175 
176  cp = fc_rport_state_names[rdata->rp_state];
177  if (!cp)
178  cp = "Unknown";
179  return cp;
180 }
181 
187 void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
188 {
189  if (timeout)
190  rport->dev_loss_tmo = timeout;
191  else
192  rport->dev_loss_tmo = 1;
193 }
195 
203 static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi *flp,
204  unsigned int maxval)
205 {
206  unsigned int mfs;
207 
208  /*
209  * Get max payload from the common service parameters and the
210  * class 3 receive data field size.
211  */
212  mfs = ntohs(flp->fl_csp.sp_bb_data) & FC_SP_BB_DATA_MASK;
213  if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
214  maxval = mfs;
215  mfs = ntohs(flp->fl_cssp[3 - 1].cp_rdfs);
216  if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
217  maxval = mfs;
218  return maxval;
219 }
220 
228 static void fc_rport_state_enter(struct fc_rport_priv *rdata,
229  enum fc_rport_state new)
230 {
231  if (rdata->rp_state != new)
232  rdata->retries = 0;
233  rdata->rp_state = new;
234 }
235 
240 static void fc_rport_work(struct work_struct *work)
241 {
242  u32 port_id;
243  struct fc_rport_priv *rdata =
244  container_of(work, struct fc_rport_priv, event_work);
245  struct fc_rport_libfc_priv *rpriv;
246  enum fc_rport_event event;
247  struct fc_lport *lport = rdata->local_port;
248  struct fc_rport_operations *rport_ops;
249  struct fc_rport_identifiers ids;
250  struct fc_rport *rport;
251  struct fc4_prov *prov;
252  u8 type;
253 
254  mutex_lock(&rdata->rp_mutex);
255  event = rdata->event;
256  rport_ops = rdata->ops;
257  rport = rdata->rport;
258 
259  FC_RPORT_DBG(rdata, "work event %u\n", event);
260 
261  switch (event) {
262  case RPORT_EV_READY:
263  ids = rdata->ids;
264  rdata->event = RPORT_EV_NONE;
265  rdata->major_retries = 0;
266  kref_get(&rdata->kref);
267  mutex_unlock(&rdata->rp_mutex);
268 
269  if (!rport)
270  rport = fc_remote_port_add(lport->host, 0, &ids);
271  if (!rport) {
272  FC_RPORT_DBG(rdata, "Failed to add the rport\n");
273  lport->tt.rport_logoff(rdata);
274  kref_put(&rdata->kref, lport->tt.rport_destroy);
275  return;
276  }
277  mutex_lock(&rdata->rp_mutex);
278  if (rdata->rport)
279  FC_RPORT_DBG(rdata, "rport already allocated\n");
280  rdata->rport = rport;
281  rport->maxframe_size = rdata->maxframe_size;
282  rport->supported_classes = rdata->supported_classes;
283 
284  rpriv = rport->dd_data;
285  rpriv->local_port = lport;
286  rpriv->rp_state = rdata->rp_state;
287  rpriv->flags = rdata->flags;
288  rpriv->e_d_tov = rdata->e_d_tov;
289  rpriv->r_a_tov = rdata->r_a_tov;
290  mutex_unlock(&rdata->rp_mutex);
291 
292  if (rport_ops && rport_ops->event_callback) {
293  FC_RPORT_DBG(rdata, "callback ev %d\n", event);
294  rport_ops->event_callback(lport, rdata, event);
295  }
296  if (rdata->lld_event_callback) {
297  FC_RPORT_DBG(rdata, "lld callback ev %d\n", event);
298  rdata->lld_event_callback(lport, rdata, event);
299  }
300  kref_put(&rdata->kref, lport->tt.rport_destroy);
301  break;
302 
303  case RPORT_EV_FAILED:
304  case RPORT_EV_LOGO:
305  case RPORT_EV_STOP:
306  if (rdata->prli_count) {
307  mutex_lock(&fc_prov_mutex);
308  for (type = 1; type < FC_FC4_PROV_SIZE; type++) {
309  prov = fc_passive_prov[type];
310  if (prov && prov->prlo)
311  prov->prlo(rdata);
312  }
313  mutex_unlock(&fc_prov_mutex);
314  }
315  port_id = rdata->ids.port_id;
316  mutex_unlock(&rdata->rp_mutex);
317 
318  if (rport_ops && rport_ops->event_callback) {
319  FC_RPORT_DBG(rdata, "callback ev %d\n", event);
320  rport_ops->event_callback(lport, rdata, event);
321  }
322  if (rdata->lld_event_callback) {
323  FC_RPORT_DBG(rdata, "lld callback ev %d\n", event);
324  rdata->lld_event_callback(lport, rdata, event);
325  }
327 
328  /*
329  * Reset any outstanding exchanges before freeing rport.
330  */
331  lport->tt.exch_mgr_reset(lport, 0, port_id);
332  lport->tt.exch_mgr_reset(lport, port_id, 0);
333 
334  if (rport) {
335  rpriv = rport->dd_data;
336  rpriv->rp_state = RPORT_ST_DELETE;
337  mutex_lock(&rdata->rp_mutex);
338  rdata->rport = NULL;
339  mutex_unlock(&rdata->rp_mutex);
340  fc_remote_port_delete(rport);
341  }
342 
343  mutex_lock(&lport->disc.disc_mutex);
344  mutex_lock(&rdata->rp_mutex);
345  if (rdata->rp_state == RPORT_ST_DELETE) {
346  if (port_id == FC_FID_DIR_SERV) {
347  rdata->event = RPORT_EV_NONE;
348  mutex_unlock(&rdata->rp_mutex);
349  kref_put(&rdata->kref, lport->tt.rport_destroy);
350  } else if ((rdata->flags & FC_RP_STARTED) &&
351  rdata->major_retries <
352  lport->max_rport_retry_count) {
353  rdata->major_retries++;
354  rdata->event = RPORT_EV_NONE;
355  FC_RPORT_DBG(rdata, "work restart\n");
356  fc_rport_enter_flogi(rdata);
357  mutex_unlock(&rdata->rp_mutex);
358  } else {
359  FC_RPORT_DBG(rdata, "work delete\n");
360  list_del_rcu(&rdata->peers);
361  mutex_unlock(&rdata->rp_mutex);
362  kref_put(&rdata->kref, lport->tt.rport_destroy);
363  }
364  } else {
365  /*
366  * Re-open for events. Reissue READY event if ready.
367  */
368  rdata->event = RPORT_EV_NONE;
369  if (rdata->rp_state == RPORT_ST_READY)
370  fc_rport_enter_ready(rdata);
371  mutex_unlock(&rdata->rp_mutex);
372  }
373  mutex_unlock(&lport->disc.disc_mutex);
374  break;
375 
376  default:
377  mutex_unlock(&rdata->rp_mutex);
378  break;
379  }
380 }
381 
394 static int fc_rport_login(struct fc_rport_priv *rdata)
395 {
396  mutex_lock(&rdata->rp_mutex);
397 
398  rdata->flags |= FC_RP_STARTED;
399  switch (rdata->rp_state) {
400  case RPORT_ST_READY:
401  FC_RPORT_DBG(rdata, "ADISC port\n");
402  fc_rport_enter_adisc(rdata);
403  break;
404  case RPORT_ST_DELETE:
405  FC_RPORT_DBG(rdata, "Restart deleted port\n");
406  break;
407  default:
408  FC_RPORT_DBG(rdata, "Login to port\n");
409  fc_rport_enter_flogi(rdata);
410  break;
411  }
412  mutex_unlock(&rdata->rp_mutex);
413 
414  return 0;
415 }
416 
431 static void fc_rport_enter_delete(struct fc_rport_priv *rdata,
432  enum fc_rport_event event)
433 {
434  if (rdata->rp_state == RPORT_ST_DELETE)
435  return;
436 
437  FC_RPORT_DBG(rdata, "Delete port\n");
438 
439  fc_rport_state_enter(rdata, RPORT_ST_DELETE);
440 
441  if (rdata->event == RPORT_EV_NONE)
442  queue_work(rport_event_queue, &rdata->event_work);
443  rdata->event = event;
444 }
445 
454 static int fc_rport_logoff(struct fc_rport_priv *rdata)
455 {
456  mutex_lock(&rdata->rp_mutex);
457 
458  FC_RPORT_DBG(rdata, "Remove port\n");
459 
460  rdata->flags &= ~FC_RP_STARTED;
461  if (rdata->rp_state == RPORT_ST_DELETE) {
462  FC_RPORT_DBG(rdata, "Port in Delete state, not removing\n");
463  goto out;
464  }
465  fc_rport_enter_logo(rdata);
466 
467  /*
468  * Change the state to Delete so that we discard
469  * the response.
470  */
471  fc_rport_enter_delete(rdata, RPORT_EV_STOP);
472 out:
473  mutex_unlock(&rdata->rp_mutex);
474  return 0;
475 }
476 
484 static void fc_rport_enter_ready(struct fc_rport_priv *rdata)
485 {
486  fc_rport_state_enter(rdata, RPORT_ST_READY);
487 
488  FC_RPORT_DBG(rdata, "Port is Ready\n");
489 
490  if (rdata->event == RPORT_EV_NONE)
491  queue_work(rport_event_queue, &rdata->event_work);
492  rdata->event = RPORT_EV_READY;
493 }
494 
503 static void fc_rport_timeout(struct work_struct *work)
504 {
505  struct fc_rport_priv *rdata =
506  container_of(work, struct fc_rport_priv, retry_work.work);
507 
508  mutex_lock(&rdata->rp_mutex);
509 
510  switch (rdata->rp_state) {
511  case RPORT_ST_FLOGI:
512  fc_rport_enter_flogi(rdata);
513  break;
514  case RPORT_ST_PLOGI:
515  fc_rport_enter_plogi(rdata);
516  break;
517  case RPORT_ST_PRLI:
518  fc_rport_enter_prli(rdata);
519  break;
520  case RPORT_ST_RTV:
521  fc_rport_enter_rtv(rdata);
522  break;
523  case RPORT_ST_ADISC:
524  fc_rport_enter_adisc(rdata);
525  break;
526  case RPORT_ST_PLOGI_WAIT:
527  case RPORT_ST_READY:
528  case RPORT_ST_INIT:
529  case RPORT_ST_DELETE:
530  break;
531  }
532 
533  mutex_unlock(&rdata->rp_mutex);
534 }
535 
544 static void fc_rport_error(struct fc_rport_priv *rdata, struct fc_frame *fp)
545 {
546  FC_RPORT_DBG(rdata, "Error %ld in state %s, retries %d\n",
547  IS_ERR(fp) ? -PTR_ERR(fp) : 0,
548  fc_rport_state(rdata), rdata->retries);
549 
550  switch (rdata->rp_state) {
551  case RPORT_ST_FLOGI:
552  case RPORT_ST_PLOGI:
553  rdata->flags &= ~FC_RP_STARTED;
554  fc_rport_enter_delete(rdata, RPORT_EV_FAILED);
555  break;
556  case RPORT_ST_RTV:
557  fc_rport_enter_ready(rdata);
558  break;
559  case RPORT_ST_PRLI:
560  case RPORT_ST_ADISC:
561  fc_rport_enter_logo(rdata);
562  break;
563  case RPORT_ST_PLOGI_WAIT:
564  case RPORT_ST_DELETE:
565  case RPORT_ST_READY:
566  case RPORT_ST_INIT:
567  break;
568  }
569 }
570 
582 static void fc_rport_error_retry(struct fc_rport_priv *rdata,
583  struct fc_frame *fp)
584 {
585  unsigned long delay = FC_DEF_E_D_TOV;
586 
587  /* make sure this isn't an FC_EX_CLOSED error, never retry those */
588  if (PTR_ERR(fp) == -FC_EX_CLOSED)
589  goto out;
590 
591  if (rdata->retries < rdata->local_port->max_rport_retry_count) {
592  FC_RPORT_DBG(rdata, "Error %ld in state %s, retrying\n",
593  PTR_ERR(fp), fc_rport_state(rdata));
594  rdata->retries++;
595  /* no additional delay on exchange timeouts */
596  if (PTR_ERR(fp) == -FC_EX_TIMEOUT)
597  delay = 0;
598  schedule_delayed_work(&rdata->retry_work, delay);
599  return;
600  }
601 
602 out:
603  fc_rport_error(rdata, fp);
604 }
605 
616 static int fc_rport_login_complete(struct fc_rport_priv *rdata,
617  struct fc_frame *fp)
618 {
619  struct fc_lport *lport = rdata->local_port;
620  struct fc_els_flogi *flogi;
621  unsigned int e_d_tov;
622  u16 csp_flags;
623 
624  flogi = fc_frame_payload_get(fp, sizeof(*flogi));
625  if (!flogi)
626  return -EINVAL;
627 
628  csp_flags = ntohs(flogi->fl_csp.sp_features);
629 
630  if (fc_frame_payload_op(fp) == ELS_FLOGI) {
631  if (csp_flags & FC_SP_FT_FPORT) {
632  FC_RPORT_DBG(rdata, "Fabric bit set in FLOGI\n");
633  return -EINVAL;
634  }
635  } else {
636 
637  /*
638  * E_D_TOV is not valid on an incoming FLOGI request.
639  */
640  e_d_tov = ntohl(flogi->fl_csp.sp_e_d_tov);
641  if (csp_flags & FC_SP_FT_EDTR)
642  e_d_tov /= 1000000;
643  if (e_d_tov > rdata->e_d_tov)
644  rdata->e_d_tov = e_d_tov;
645  }
646  rdata->maxframe_size = fc_plogi_get_maxframe(flogi, lport->mfs);
647  return 0;
648 }
649 
656 static void fc_rport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
657  void *rp_arg)
658 {
659  struct fc_rport_priv *rdata = rp_arg;
660  struct fc_lport *lport = rdata->local_port;
661  struct fc_els_flogi *flogi;
662  unsigned int r_a_tov;
663 
664  FC_RPORT_DBG(rdata, "Received a FLOGI %s\n", fc_els_resp_type(fp));
665 
666  if (fp == ERR_PTR(-FC_EX_CLOSED))
667  goto put;
668 
669  mutex_lock(&rdata->rp_mutex);
670 
671  if (rdata->rp_state != RPORT_ST_FLOGI) {
672  FC_RPORT_DBG(rdata, "Received a FLOGI response, but in state "
673  "%s\n", fc_rport_state(rdata));
674  if (IS_ERR(fp))
675  goto err;
676  goto out;
677  }
678 
679  if (IS_ERR(fp)) {
680  fc_rport_error(rdata, fp);
681  goto err;
682  }
683 
684  if (fc_frame_payload_op(fp) != ELS_LS_ACC)
685  goto bad;
686  if (fc_rport_login_complete(rdata, fp))
687  goto bad;
688 
689  flogi = fc_frame_payload_get(fp, sizeof(*flogi));
690  if (!flogi)
691  goto bad;
692  r_a_tov = ntohl(flogi->fl_csp.sp_r_a_tov);
693  if (r_a_tov > rdata->r_a_tov)
694  rdata->r_a_tov = r_a_tov;
695 
696  if (rdata->ids.port_name < lport->wwpn)
697  fc_rport_enter_plogi(rdata);
698  else
699  fc_rport_state_enter(rdata, RPORT_ST_PLOGI_WAIT);
700 out:
701  fc_frame_free(fp);
702 err:
703  mutex_unlock(&rdata->rp_mutex);
704 put:
705  kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
706  return;
707 bad:
708  FC_RPORT_DBG(rdata, "Bad FLOGI response\n");
709  fc_rport_error_retry(rdata, fp);
710  goto out;
711 }
712 
720 static void fc_rport_enter_flogi(struct fc_rport_priv *rdata)
721 {
722  struct fc_lport *lport = rdata->local_port;
723  struct fc_frame *fp;
724 
725  if (!lport->point_to_multipoint)
726  return fc_rport_enter_plogi(rdata);
727 
728  FC_RPORT_DBG(rdata, "Entered FLOGI state from %s state\n",
729  fc_rport_state(rdata));
730 
731  fc_rport_state_enter(rdata, RPORT_ST_FLOGI);
732 
733  fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
734  if (!fp)
735  return fc_rport_error_retry(rdata, fp);
736 
737  if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_FLOGI,
738  fc_rport_flogi_resp, rdata,
739  2 * lport->r_a_tov))
740  fc_rport_error_retry(rdata, NULL);
741  else
742  kref_get(&rdata->kref);
743 }
744 
750 static void fc_rport_recv_flogi_req(struct fc_lport *lport,
751  struct fc_frame *rx_fp)
752 {
753  struct fc_disc *disc;
754  struct fc_els_flogi *flp;
755  struct fc_rport_priv *rdata;
756  struct fc_frame *fp = rx_fp;
757  struct fc_seq_els_data rjt_data;
758  u32 sid;
759 
760  sid = fc_frame_sid(fp);
761 
762  FC_RPORT_ID_DBG(lport, sid, "Received FLOGI request\n");
763 
764  disc = &lport->disc;
765  mutex_lock(&disc->disc_mutex);
766 
767  if (!lport->point_to_multipoint) {
768  rjt_data.reason = ELS_RJT_UNSUP;
769  rjt_data.explan = ELS_EXPL_NONE;
770  goto reject;
771  }
772 
773  flp = fc_frame_payload_get(fp, sizeof(*flp));
774  if (!flp) {
775  rjt_data.reason = ELS_RJT_LOGIC;
776  rjt_data.explan = ELS_EXPL_INV_LEN;
777  goto reject;
778  }
779 
780  rdata = lport->tt.rport_lookup(lport, sid);
781  if (!rdata) {
782  rjt_data.reason = ELS_RJT_FIP;
783  rjt_data.explan = ELS_EXPL_NOT_NEIGHBOR;
784  goto reject;
785  }
786  mutex_lock(&rdata->rp_mutex);
787 
788  FC_RPORT_DBG(rdata, "Received FLOGI in %s state\n",
789  fc_rport_state(rdata));
790 
791  switch (rdata->rp_state) {
792  case RPORT_ST_INIT:
793  /*
794  * If received the FLOGI request on RPORT which is INIT state
795  * (means not transition to FLOGI either fc_rport timeout
796  * function didn;t trigger or this end hasn;t received
797  * beacon yet from other end. In that case only, allow RPORT
798  * state machine to continue, otherwise fall through which
799  * causes the code to send reject response.
800  * NOTE; Not checking for FIP->state such as VNMP_UP or
801  * VNMP_CLAIM because if FIP state is not one of those,
802  * RPORT wouldn;t have created and 'rport_lookup' would have
803  * failed anyway in that case.
804  */
805  if (lport->point_to_multipoint)
806  break;
807  case RPORT_ST_DELETE:
808  mutex_unlock(&rdata->rp_mutex);
809  rjt_data.reason = ELS_RJT_FIP;
810  rjt_data.explan = ELS_EXPL_NOT_NEIGHBOR;
811  goto reject;
812  case RPORT_ST_FLOGI:
813  case RPORT_ST_PLOGI_WAIT:
814  case RPORT_ST_PLOGI:
815  break;
816  case RPORT_ST_PRLI:
817  case RPORT_ST_RTV:
818  case RPORT_ST_READY:
819  case RPORT_ST_ADISC:
820  /*
821  * Set the remote port to be deleted and to then restart.
822  * This queues work to be sure exchanges are reset.
823  */
824  fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
825  mutex_unlock(&rdata->rp_mutex);
826  rjt_data.reason = ELS_RJT_BUSY;
827  rjt_data.explan = ELS_EXPL_NONE;
828  goto reject;
829  }
830  if (fc_rport_login_complete(rdata, fp)) {
831  mutex_unlock(&rdata->rp_mutex);
832  rjt_data.reason = ELS_RJT_LOGIC;
833  rjt_data.explan = ELS_EXPL_NONE;
834  goto reject;
835  }
836 
837  fp = fc_frame_alloc(lport, sizeof(*flp));
838  if (!fp)
839  goto out;
840 
841  fc_flogi_fill(lport, fp);
842  flp = fc_frame_payload_get(fp, sizeof(*flp));
843  flp->fl_cmd = ELS_LS_ACC;
844 
845  fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
846  lport->tt.frame_send(lport, fp);
847 
848  if (rdata->ids.port_name < lport->wwpn)
849  fc_rport_enter_plogi(rdata);
850  else
851  fc_rport_state_enter(rdata, RPORT_ST_PLOGI_WAIT);
852 out:
853  mutex_unlock(&rdata->rp_mutex);
854  mutex_unlock(&disc->disc_mutex);
855  fc_frame_free(rx_fp);
856  return;
857 
858 reject:
859  mutex_unlock(&disc->disc_mutex);
860  lport->tt.seq_els_rsp_send(rx_fp, ELS_LS_RJT, &rjt_data);
861  fc_frame_free(rx_fp);
862 }
863 
874 static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
875  void *rdata_arg)
876 {
877  struct fc_rport_priv *rdata = rdata_arg;
878  struct fc_lport *lport = rdata->local_port;
879  struct fc_els_flogi *plp = NULL;
880  u16 csp_seq;
881  u16 cssp_seq;
882  u8 op;
883 
884  mutex_lock(&rdata->rp_mutex);
885 
886  FC_RPORT_DBG(rdata, "Received a PLOGI %s\n", fc_els_resp_type(fp));
887 
888  if (rdata->rp_state != RPORT_ST_PLOGI) {
889  FC_RPORT_DBG(rdata, "Received a PLOGI response, but in state "
890  "%s\n", fc_rport_state(rdata));
891  if (IS_ERR(fp))
892  goto err;
893  goto out;
894  }
895 
896  if (IS_ERR(fp)) {
897  fc_rport_error_retry(rdata, fp);
898  goto err;
899  }
900 
901  op = fc_frame_payload_op(fp);
902  if (op == ELS_LS_ACC &&
903  (plp = fc_frame_payload_get(fp, sizeof(*plp))) != NULL) {
904  rdata->ids.port_name = get_unaligned_be64(&plp->fl_wwpn);
905  rdata->ids.node_name = get_unaligned_be64(&plp->fl_wwnn);
906 
907  /* save plogi response sp_features for further reference */
908  rdata->sp_features = ntohs(plp->fl_csp.sp_features);
909 
910  if (lport->point_to_multipoint)
911  fc_rport_login_complete(rdata, fp);
912  csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
913  cssp_seq = ntohs(plp->fl_cssp[3 - 1].cp_con_seq);
914  if (cssp_seq < csp_seq)
915  csp_seq = cssp_seq;
916  rdata->max_seq = csp_seq;
917  rdata->maxframe_size = fc_plogi_get_maxframe(plp, lport->mfs);
918  fc_rport_enter_prli(rdata);
919  } else
920  fc_rport_error_retry(rdata, fp);
921 
922 out:
923  fc_frame_free(fp);
924 err:
925  mutex_unlock(&rdata->rp_mutex);
926  kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
927 }
928 
936 static void fc_rport_enter_plogi(struct fc_rport_priv *rdata)
937 {
938  struct fc_lport *lport = rdata->local_port;
939  struct fc_frame *fp;
940 
941  FC_RPORT_DBG(rdata, "Port entered PLOGI state from %s state\n",
942  fc_rport_state(rdata));
943 
944  fc_rport_state_enter(rdata, RPORT_ST_PLOGI);
945 
947  fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
948  if (!fp) {
949  FC_RPORT_DBG(rdata, "%s frame alloc failed\n", __func__);
950  fc_rport_error_retry(rdata, fp);
951  return;
952  }
953  rdata->e_d_tov = lport->e_d_tov;
954 
955  if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PLOGI,
956  fc_rport_plogi_resp, rdata,
957  2 * lport->r_a_tov))
958  fc_rport_error_retry(rdata, NULL);
959  else
960  kref_get(&rdata->kref);
961 }
962 
973 static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
974  void *rdata_arg)
975 {
976  struct fc_rport_priv *rdata = rdata_arg;
977  struct {
978  struct fc_els_prli prli;
979  struct fc_els_spp spp;
980  } *pp;
981  struct fc_els_spp temp_spp;
982  struct fc4_prov *prov;
984  u32 fcp_parm = 0;
985  u8 op;
986  u8 resp_code = 0;
987 
988  mutex_lock(&rdata->rp_mutex);
989 
990  FC_RPORT_DBG(rdata, "Received a PRLI %s\n", fc_els_resp_type(fp));
991 
992  if (rdata->rp_state != RPORT_ST_PRLI) {
993  FC_RPORT_DBG(rdata, "Received a PRLI response, but in state "
994  "%s\n", fc_rport_state(rdata));
995  if (IS_ERR(fp))
996  goto err;
997  goto out;
998  }
999 
1000  if (IS_ERR(fp)) {
1001  fc_rport_error_retry(rdata, fp);
1002  goto err;
1003  }
1004 
1005  /* reinitialize remote port roles */
1006  rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
1007 
1008  op = fc_frame_payload_op(fp);
1009  if (op == ELS_LS_ACC) {
1010  pp = fc_frame_payload_get(fp, sizeof(*pp));
1011  if (!pp)
1012  goto out;
1013 
1014  resp_code = (pp->spp.spp_flags & FC_SPP_RESP_MASK);
1015  FC_RPORT_DBG(rdata, "PRLI spp_flags = 0x%x\n",
1016  pp->spp.spp_flags);
1017  rdata->spp_type = pp->spp.spp_type;
1018  if (resp_code != FC_SPP_RESP_ACK) {
1019  if (resp_code == FC_SPP_RESP_CONF)
1020  fc_rport_error(rdata, fp);
1021  else
1022  fc_rport_error_retry(rdata, fp);
1023  goto out;
1024  }
1025  if (pp->prli.prli_spp_len < sizeof(pp->spp))
1026  goto out;
1027 
1028  fcp_parm = ntohl(pp->spp.spp_params);
1029  if (fcp_parm & FCP_SPPF_RETRY)
1030  rdata->flags |= FC_RP_FLAGS_RETRY;
1031  if (fcp_parm & FCP_SPPF_CONF_COMPL)
1032  rdata->flags |= FC_RP_FLAGS_CONF_REQ;
1033 
1034  prov = fc_passive_prov[FC_TYPE_FCP];
1035  if (prov) {
1036  memset(&temp_spp, 0, sizeof(temp_spp));
1037  prov->prli(rdata, pp->prli.prli_spp_len,
1038  &pp->spp, &temp_spp);
1039  }
1040 
1042  if (fcp_parm & FCP_SPPF_INIT_FCN)
1043  roles |= FC_RPORT_ROLE_FCP_INITIATOR;
1044  if (fcp_parm & FCP_SPPF_TARG_FCN)
1045  roles |= FC_RPORT_ROLE_FCP_TARGET;
1046 
1047  rdata->ids.roles = roles;
1048  fc_rport_enter_rtv(rdata);
1049 
1050  } else {
1051  FC_RPORT_DBG(rdata, "Bad ELS response for PRLI command\n");
1052  fc_rport_error_retry(rdata, fp);
1053  }
1054 
1055 out:
1056  fc_frame_free(fp);
1057 err:
1058  mutex_unlock(&rdata->rp_mutex);
1059  kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
1060 }
1061 
1069 static void fc_rport_enter_prli(struct fc_rport_priv *rdata)
1070 {
1071  struct fc_lport *lport = rdata->local_port;
1072  struct {
1073  struct fc_els_prli prli;
1074  struct fc_els_spp spp;
1075  } *pp;
1076  struct fc_frame *fp;
1077  struct fc4_prov *prov;
1078 
1079  /*
1080  * If the rport is one of the well known addresses
1081  * we skip PRLI and RTV and go straight to READY.
1082  */
1083  if (rdata->ids.port_id >= FC_FID_DOM_MGR) {
1084  fc_rport_enter_ready(rdata);
1085  return;
1086  }
1087 
1088  FC_RPORT_DBG(rdata, "Port entered PRLI state from %s state\n",
1089  fc_rport_state(rdata));
1090 
1091  fc_rport_state_enter(rdata, RPORT_ST_PRLI);
1092 
1093  fp = fc_frame_alloc(lport, sizeof(*pp));
1094  if (!fp) {
1095  fc_rport_error_retry(rdata, fp);
1096  return;
1097  }
1098 
1099  fc_prli_fill(lport, fp);
1100 
1101  prov = fc_passive_prov[FC_TYPE_FCP];
1102  if (prov) {
1103  pp = fc_frame_payload_get(fp, sizeof(*pp));
1104  prov->prli(rdata, sizeof(pp->spp), NULL, &pp->spp);
1105  }
1106 
1107  fc_fill_fc_hdr(fp, FC_RCTL_ELS_REQ, rdata->ids.port_id,
1108  fc_host_port_id(lport->host), FC_TYPE_ELS,
1110 
1111  if (!lport->tt.exch_seq_send(lport, fp, fc_rport_prli_resp,
1112  NULL, rdata, 2 * lport->r_a_tov))
1113  fc_rport_error_retry(rdata, NULL);
1114  else
1115  kref_get(&rdata->kref);
1116 }
1117 
1130 static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
1131  void *rdata_arg)
1132 {
1133  struct fc_rport_priv *rdata = rdata_arg;
1134  u8 op;
1135 
1136  mutex_lock(&rdata->rp_mutex);
1137 
1138  FC_RPORT_DBG(rdata, "Received a RTV %s\n", fc_els_resp_type(fp));
1139 
1140  if (rdata->rp_state != RPORT_ST_RTV) {
1141  FC_RPORT_DBG(rdata, "Received a RTV response, but in state "
1142  "%s\n", fc_rport_state(rdata));
1143  if (IS_ERR(fp))
1144  goto err;
1145  goto out;
1146  }
1147 
1148  if (IS_ERR(fp)) {
1149  fc_rport_error(rdata, fp);
1150  goto err;
1151  }
1152 
1153  op = fc_frame_payload_op(fp);
1154  if (op == ELS_LS_ACC) {
1155  struct fc_els_rtv_acc *rtv;
1156  u32 toq;
1157  u32 tov;
1158 
1159  rtv = fc_frame_payload_get(fp, sizeof(*rtv));
1160  if (rtv) {
1161  toq = ntohl(rtv->rtv_toq);
1162  tov = ntohl(rtv->rtv_r_a_tov);
1163  if (tov == 0)
1164  tov = 1;
1165  rdata->r_a_tov = tov;
1166  tov = ntohl(rtv->rtv_e_d_tov);
1167  if (toq & FC_ELS_RTV_EDRES)
1168  tov /= 1000000;
1169  if (tov == 0)
1170  tov = 1;
1171  rdata->e_d_tov = tov;
1172  }
1173  }
1174 
1175  fc_rport_enter_ready(rdata);
1176 
1177 out:
1178  fc_frame_free(fp);
1179 err:
1180  mutex_unlock(&rdata->rp_mutex);
1181  kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
1182 }
1183 
1191 static void fc_rport_enter_rtv(struct fc_rport_priv *rdata)
1192 {
1193  struct fc_frame *fp;
1194  struct fc_lport *lport = rdata->local_port;
1195 
1196  FC_RPORT_DBG(rdata, "Port entered RTV state from %s state\n",
1197  fc_rport_state(rdata));
1198 
1199  fc_rport_state_enter(rdata, RPORT_ST_RTV);
1200 
1201  fp = fc_frame_alloc(lport, sizeof(struct fc_els_rtv));
1202  if (!fp) {
1203  fc_rport_error_retry(rdata, fp);
1204  return;
1205  }
1206 
1207  if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_RTV,
1208  fc_rport_rtv_resp, rdata,
1209  2 * lport->r_a_tov))
1210  fc_rport_error_retry(rdata, NULL);
1211  else
1212  kref_get(&rdata->kref);
1213 }
1214 
1221 static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
1222  void *lport_arg)
1223 {
1224  struct fc_lport *lport = lport_arg;
1225 
1226  FC_RPORT_ID_DBG(lport, fc_seq_exch(sp)->did,
1227  "Received a LOGO %s\n", fc_els_resp_type(fp));
1228  if (IS_ERR(fp))
1229  return;
1230  fc_frame_free(fp);
1231 }
1232 
1240 static void fc_rport_enter_logo(struct fc_rport_priv *rdata)
1241 {
1242  struct fc_lport *lport = rdata->local_port;
1243  struct fc_frame *fp;
1244 
1245  FC_RPORT_DBG(rdata, "Port sending LOGO from %s state\n",
1246  fc_rport_state(rdata));
1247 
1248  fp = fc_frame_alloc(lport, sizeof(struct fc_els_logo));
1249  if (!fp)
1250  return;
1251  (void)lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_LOGO,
1252  fc_rport_logo_resp, lport, 0);
1253 }
1254 
1265 static void fc_rport_adisc_resp(struct fc_seq *sp, struct fc_frame *fp,
1266  void *rdata_arg)
1267 {
1268  struct fc_rport_priv *rdata = rdata_arg;
1269  struct fc_els_adisc *adisc;
1270  u8 op;
1271 
1272  mutex_lock(&rdata->rp_mutex);
1273 
1274  FC_RPORT_DBG(rdata, "Received a ADISC response\n");
1275 
1276  if (rdata->rp_state != RPORT_ST_ADISC) {
1277  FC_RPORT_DBG(rdata, "Received a ADISC resp but in state %s\n",
1278  fc_rport_state(rdata));
1279  if (IS_ERR(fp))
1280  goto err;
1281  goto out;
1282  }
1283 
1284  if (IS_ERR(fp)) {
1285  fc_rport_error(rdata, fp);
1286  goto err;
1287  }
1288 
1289  /*
1290  * If address verification failed. Consider us logged out of the rport.
1291  * Since the rport is still in discovery, we want to be
1292  * logged in, so go to PLOGI state. Otherwise, go back to READY.
1293  */
1294  op = fc_frame_payload_op(fp);
1295  adisc = fc_frame_payload_get(fp, sizeof(*adisc));
1296  if (op != ELS_LS_ACC || !adisc ||
1297  ntoh24(adisc->adisc_port_id) != rdata->ids.port_id ||
1298  get_unaligned_be64(&adisc->adisc_wwpn) != rdata->ids.port_name ||
1299  get_unaligned_be64(&adisc->adisc_wwnn) != rdata->ids.node_name) {
1300  FC_RPORT_DBG(rdata, "ADISC error or mismatch\n");
1301  fc_rport_enter_flogi(rdata);
1302  } else {
1303  FC_RPORT_DBG(rdata, "ADISC OK\n");
1304  fc_rport_enter_ready(rdata);
1305  }
1306 out:
1307  fc_frame_free(fp);
1308 err:
1309  mutex_unlock(&rdata->rp_mutex);
1310  kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
1311 }
1312 
1320 static void fc_rport_enter_adisc(struct fc_rport_priv *rdata)
1321 {
1322  struct fc_lport *lport = rdata->local_port;
1323  struct fc_frame *fp;
1324 
1325  FC_RPORT_DBG(rdata, "sending ADISC from %s state\n",
1326  fc_rport_state(rdata));
1327 
1328  fc_rport_state_enter(rdata, RPORT_ST_ADISC);
1329 
1330  fp = fc_frame_alloc(lport, sizeof(struct fc_els_adisc));
1331  if (!fp) {
1332  fc_rport_error_retry(rdata, fp);
1333  return;
1334  }
1335  if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_ADISC,
1336  fc_rport_adisc_resp, rdata,
1337  2 * lport->r_a_tov))
1338  fc_rport_error_retry(rdata, NULL);
1339  else
1340  kref_get(&rdata->kref);
1341 }
1342 
1350 static void fc_rport_recv_adisc_req(struct fc_rport_priv *rdata,
1351  struct fc_frame *in_fp)
1352 {
1353  struct fc_lport *lport = rdata->local_port;
1354  struct fc_frame *fp;
1355  struct fc_els_adisc *adisc;
1356  struct fc_seq_els_data rjt_data;
1357 
1358  FC_RPORT_DBG(rdata, "Received ADISC request\n");
1359 
1360  adisc = fc_frame_payload_get(in_fp, sizeof(*adisc));
1361  if (!adisc) {
1362  rjt_data.reason = ELS_RJT_PROT;
1363  rjt_data.explan = ELS_EXPL_INV_LEN;
1364  lport->tt.seq_els_rsp_send(in_fp, ELS_LS_RJT, &rjt_data);
1365  goto drop;
1366  }
1367 
1368  fp = fc_frame_alloc(lport, sizeof(*adisc));
1369  if (!fp)
1370  goto drop;
1371  fc_adisc_fill(lport, fp);
1372  adisc = fc_frame_payload_get(fp, sizeof(*adisc));
1373  adisc->adisc_cmd = ELS_LS_ACC;
1374  fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);
1375  lport->tt.frame_send(lport, fp);
1376 drop:
1377  fc_frame_free(in_fp);
1378 }
1379 
1388 static void fc_rport_recv_rls_req(struct fc_rport_priv *rdata,
1389  struct fc_frame *rx_fp)
1390 
1391 {
1392  struct fc_lport *lport = rdata->local_port;
1393  struct fc_frame *fp;
1394  struct fc_els_rls *rls;
1395  struct fc_els_rls_resp *rsp;
1396  struct fc_els_lesb *lesb;
1397  struct fc_seq_els_data rjt_data;
1398  struct fc_host_statistics *hst;
1399 
1400  FC_RPORT_DBG(rdata, "Received RLS request while in state %s\n",
1401  fc_rport_state(rdata));
1402 
1403  rls = fc_frame_payload_get(rx_fp, sizeof(*rls));
1404  if (!rls) {
1405  rjt_data.reason = ELS_RJT_PROT;
1406  rjt_data.explan = ELS_EXPL_INV_LEN;
1407  goto out_rjt;
1408  }
1409 
1410  fp = fc_frame_alloc(lport, sizeof(*rsp));
1411  if (!fp) {
1412  rjt_data.reason = ELS_RJT_UNAB;
1413  rjt_data.explan = ELS_EXPL_INSUF_RES;
1414  goto out_rjt;
1415  }
1416 
1417  rsp = fc_frame_payload_get(fp, sizeof(*rsp));
1418  memset(rsp, 0, sizeof(*rsp));
1419  rsp->rls_cmd = ELS_LS_ACC;
1420  lesb = &rsp->rls_lesb;
1421  if (lport->tt.get_lesb) {
1422  /* get LESB from LLD if it supports it */
1423  lport->tt.get_lesb(lport, lesb);
1424  } else {
1425  fc_get_host_stats(lport->host);
1426  hst = &lport->host_stats;
1427  lesb->lesb_link_fail = htonl(hst->link_failure_count);
1428  lesb->lesb_sync_loss = htonl(hst->loss_of_sync_count);
1432  lesb->lesb_inv_crc = htonl(hst->invalid_crc_count);
1433  }
1434 
1435  fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
1436  lport->tt.frame_send(lport, fp);
1437  goto out;
1438 
1439 out_rjt:
1440  lport->tt.seq_els_rsp_send(rx_fp, ELS_LS_RJT, &rjt_data);
1441 out:
1442  fc_frame_free(rx_fp);
1443 }
1444 
1455 static void fc_rport_recv_els_req(struct fc_lport *lport, struct fc_frame *fp)
1456 {
1457  struct fc_rport_priv *rdata;
1458  struct fc_seq_els_data els_data;
1459 
1460  mutex_lock(&lport->disc.disc_mutex);
1461  rdata = lport->tt.rport_lookup(lport, fc_frame_sid(fp));
1462  if (!rdata) {
1463  mutex_unlock(&lport->disc.disc_mutex);
1464  goto reject;
1465  }
1466  mutex_lock(&rdata->rp_mutex);
1467  mutex_unlock(&lport->disc.disc_mutex);
1468 
1469  switch (rdata->rp_state) {
1470  case RPORT_ST_PRLI:
1471  case RPORT_ST_RTV:
1472  case RPORT_ST_READY:
1473  case RPORT_ST_ADISC:
1474  break;
1475  default:
1476  mutex_unlock(&rdata->rp_mutex);
1477  goto reject;
1478  }
1479 
1480  switch (fc_frame_payload_op(fp)) {
1481  case ELS_PRLI:
1482  fc_rport_recv_prli_req(rdata, fp);
1483  break;
1484  case ELS_PRLO:
1485  fc_rport_recv_prlo_req(rdata, fp);
1486  break;
1487  case ELS_ADISC:
1488  fc_rport_recv_adisc_req(rdata, fp);
1489  break;
1490  case ELS_RRQ:
1491  lport->tt.seq_els_rsp_send(fp, ELS_RRQ, NULL);
1492  fc_frame_free(fp);
1493  break;
1494  case ELS_REC:
1495  lport->tt.seq_els_rsp_send(fp, ELS_REC, NULL);
1496  fc_frame_free(fp);
1497  break;
1498  case ELS_RLS:
1499  fc_rport_recv_rls_req(rdata, fp);
1500  break;
1501  default:
1502  fc_frame_free(fp); /* can't happen */
1503  break;
1504  }
1505 
1506  mutex_unlock(&rdata->rp_mutex);
1507  return;
1508 
1509 reject:
1510  els_data.reason = ELS_RJT_UNAB;
1511  els_data.explan = ELS_EXPL_PLOGI_REQD;
1512  lport->tt.seq_els_rsp_send(fp, ELS_LS_RJT, &els_data);
1513  fc_frame_free(fp);
1514 }
1515 
1523 static void fc_rport_recv_req(struct fc_lport *lport, struct fc_frame *fp)
1524 {
1525  struct fc_seq_els_data els_data;
1526 
1527  /*
1528  * Handle FLOGI, PLOGI and LOGO requests separately, since they
1529  * don't require prior login.
1530  * Check for unsupported opcodes first and reject them.
1531  * For some ops, it would be incorrect to reject with "PLOGI required".
1532  */
1533  switch (fc_frame_payload_op(fp)) {
1534  case ELS_FLOGI:
1535  fc_rport_recv_flogi_req(lport, fp);
1536  break;
1537  case ELS_PLOGI:
1538  fc_rport_recv_plogi_req(lport, fp);
1539  break;
1540  case ELS_LOGO:
1541  fc_rport_recv_logo_req(lport, fp);
1542  break;
1543  case ELS_PRLI:
1544  case ELS_PRLO:
1545  case ELS_ADISC:
1546  case ELS_RRQ:
1547  case ELS_REC:
1548  case ELS_RLS:
1549  fc_rport_recv_els_req(lport, fp);
1550  break;
1551  default:
1552  els_data.reason = ELS_RJT_UNSUP;
1553  els_data.explan = ELS_EXPL_NONE;
1554  lport->tt.seq_els_rsp_send(fp, ELS_LS_RJT, &els_data);
1555  fc_frame_free(fp);
1556  break;
1557  }
1558 }
1559 
1567 static void fc_rport_recv_plogi_req(struct fc_lport *lport,
1568  struct fc_frame *rx_fp)
1569 {
1570  struct fc_disc *disc;
1571  struct fc_rport_priv *rdata;
1572  struct fc_frame *fp = rx_fp;
1573  struct fc_els_flogi *pl;
1574  struct fc_seq_els_data rjt_data;
1575  u32 sid;
1576 
1577  sid = fc_frame_sid(fp);
1578 
1579  FC_RPORT_ID_DBG(lport, sid, "Received PLOGI request\n");
1580 
1581  pl = fc_frame_payload_get(fp, sizeof(*pl));
1582  if (!pl) {
1583  FC_RPORT_ID_DBG(lport, sid, "Received PLOGI too short\n");
1584  rjt_data.reason = ELS_RJT_PROT;
1585  rjt_data.explan = ELS_EXPL_INV_LEN;
1586  goto reject;
1587  }
1588 
1589  disc = &lport->disc;
1590  mutex_lock(&disc->disc_mutex);
1591  rdata = lport->tt.rport_create(lport, sid);
1592  if (!rdata) {
1593  mutex_unlock(&disc->disc_mutex);
1594  rjt_data.reason = ELS_RJT_UNAB;
1595  rjt_data.explan = ELS_EXPL_INSUF_RES;
1596  goto reject;
1597  }
1598 
1599  mutex_lock(&rdata->rp_mutex);
1600  mutex_unlock(&disc->disc_mutex);
1601 
1602  rdata->ids.port_name = get_unaligned_be64(&pl->fl_wwpn);
1603  rdata->ids.node_name = get_unaligned_be64(&pl->fl_wwnn);
1604 
1605  /*
1606  * If the rport was just created, possibly due to the incoming PLOGI,
1607  * set the state appropriately and accept the PLOGI.
1608  *
1609  * If we had also sent a PLOGI, and if the received PLOGI is from a
1610  * higher WWPN, we accept it, otherwise an LS_RJT is sent with reason
1611  * "command already in progress".
1612  *
1613  * XXX TBD: If the session was ready before, the PLOGI should result in
1614  * all outstanding exchanges being reset.
1615  */
1616  switch (rdata->rp_state) {
1617  case RPORT_ST_INIT:
1618  FC_RPORT_DBG(rdata, "Received PLOGI in INIT state\n");
1619  break;
1620  case RPORT_ST_PLOGI_WAIT:
1621  FC_RPORT_DBG(rdata, "Received PLOGI in PLOGI_WAIT state\n");
1622  break;
1623  case RPORT_ST_PLOGI:
1624  FC_RPORT_DBG(rdata, "Received PLOGI in PLOGI state\n");
1625  if (rdata->ids.port_name < lport->wwpn) {
1626  mutex_unlock(&rdata->rp_mutex);
1627  rjt_data.reason = ELS_RJT_INPROG;
1628  rjt_data.explan = ELS_EXPL_NONE;
1629  goto reject;
1630  }
1631  break;
1632  case RPORT_ST_PRLI:
1633  case RPORT_ST_RTV:
1634  case RPORT_ST_READY:
1635  case RPORT_ST_ADISC:
1636  FC_RPORT_DBG(rdata, "Received PLOGI in logged-in state %d "
1637  "- ignored for now\n", rdata->rp_state);
1638  /* XXX TBD - should reset */
1639  break;
1640  case RPORT_ST_FLOGI:
1641  case RPORT_ST_DELETE:
1642  FC_RPORT_DBG(rdata, "Received PLOGI in state %s - send busy\n",
1643  fc_rport_state(rdata));
1644  mutex_unlock(&rdata->rp_mutex);
1645  rjt_data.reason = ELS_RJT_BUSY;
1646  rjt_data.explan = ELS_EXPL_NONE;
1647  goto reject;
1648  }
1649 
1650  /*
1651  * Get session payload size from incoming PLOGI.
1652  */
1653  rdata->maxframe_size = fc_plogi_get_maxframe(pl, lport->mfs);
1654 
1655  /*
1656  * Send LS_ACC. If this fails, the originator should retry.
1657  */
1658  fp = fc_frame_alloc(lport, sizeof(*pl));
1659  if (!fp)
1660  goto out;
1661 
1662  fc_plogi_fill(lport, fp, ELS_LS_ACC);
1663  fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
1664  lport->tt.frame_send(lport, fp);
1665  fc_rport_enter_prli(rdata);
1666 out:
1667  mutex_unlock(&rdata->rp_mutex);
1668  fc_frame_free(rx_fp);
1669  return;
1670 
1671 reject:
1672  lport->tt.seq_els_rsp_send(fp, ELS_LS_RJT, &rjt_data);
1673  fc_frame_free(fp);
1674 }
1675 
1684 static void fc_rport_recv_prli_req(struct fc_rport_priv *rdata,
1685  struct fc_frame *rx_fp)
1686 {
1687  struct fc_lport *lport = rdata->local_port;
1688  struct fc_frame *fp;
1689  struct {
1690  struct fc_els_prli prli;
1691  struct fc_els_spp spp;
1692  } *pp;
1693  struct fc_els_spp *rspp; /* request service param page */
1694  struct fc_els_spp *spp; /* response spp */
1695  unsigned int len;
1696  unsigned int plen;
1697  enum fc_els_spp_resp resp;
1698  enum fc_els_spp_resp passive;
1699  struct fc_seq_els_data rjt_data;
1700  struct fc4_prov *prov;
1701 
1702  FC_RPORT_DBG(rdata, "Received PRLI request while in state %s\n",
1703  fc_rport_state(rdata));
1704 
1705  len = fr_len(rx_fp) - sizeof(struct fc_frame_header);
1706  pp = fc_frame_payload_get(rx_fp, sizeof(*pp));
1707  if (!pp)
1708  goto reject_len;
1709  plen = ntohs(pp->prli.prli_len);
1710  if ((plen % 4) != 0 || plen > len || plen < 16)
1711  goto reject_len;
1712  if (plen < len)
1713  len = plen;
1714  plen = pp->prli.prli_spp_len;
1715  if ((plen % 4) != 0 || plen < sizeof(*spp) ||
1716  plen > len || len < sizeof(*pp) || plen < 12)
1717  goto reject_len;
1718  rspp = &pp->spp;
1719 
1720  fp = fc_frame_alloc(lport, len);
1721  if (!fp) {
1722  rjt_data.reason = ELS_RJT_UNAB;
1723  rjt_data.explan = ELS_EXPL_INSUF_RES;
1724  goto reject;
1725  }
1726  pp = fc_frame_payload_get(fp, len);
1727  WARN_ON(!pp);
1728  memset(pp, 0, len);
1729  pp->prli.prli_cmd = ELS_LS_ACC;
1730  pp->prli.prli_spp_len = plen;
1731  pp->prli.prli_len = htons(len);
1732  len -= sizeof(struct fc_els_prli);
1733 
1734  /*
1735  * Go through all the service parameter pages and build
1736  * response. If plen indicates longer SPP than standard,
1737  * use that. The entire response has been pre-cleared above.
1738  */
1739  spp = &pp->spp;
1740  mutex_lock(&fc_prov_mutex);
1741  while (len >= plen) {
1742  rdata->spp_type = rspp->spp_type;
1743  spp->spp_type = rspp->spp_type;
1744  spp->spp_type_ext = rspp->spp_type_ext;
1745  resp = 0;
1746 
1747  if (rspp->spp_type < FC_FC4_PROV_SIZE) {
1748  prov = fc_active_prov[rspp->spp_type];
1749  if (prov)
1750  resp = prov->prli(rdata, plen, rspp, spp);
1751  prov = fc_passive_prov[rspp->spp_type];
1752  if (prov) {
1753  passive = prov->prli(rdata, plen, rspp, spp);
1754  if (!resp || passive == FC_SPP_RESP_ACK)
1755  resp = passive;
1756  }
1757  }
1758  if (!resp) {
1759  if (spp->spp_flags & FC_SPP_EST_IMG_PAIR)
1760  resp |= FC_SPP_RESP_CONF;
1761  else
1762  resp |= FC_SPP_RESP_INVL;
1763  }
1764  spp->spp_flags |= resp;
1765  len -= plen;
1766  rspp = (struct fc_els_spp *)((char *)rspp + plen);
1767  spp = (struct fc_els_spp *)((char *)spp + plen);
1768  }
1769  mutex_unlock(&fc_prov_mutex);
1770 
1771  /*
1772  * Send LS_ACC. If this fails, the originator should retry.
1773  */
1774  fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
1775  lport->tt.frame_send(lport, fp);
1776 
1777  switch (rdata->rp_state) {
1778  case RPORT_ST_PRLI:
1779  fc_rport_enter_ready(rdata);
1780  break;
1781  default:
1782  break;
1783  }
1784  goto drop;
1785 
1786 reject_len:
1787  rjt_data.reason = ELS_RJT_PROT;
1788  rjt_data.explan = ELS_EXPL_INV_LEN;
1789 reject:
1790  lport->tt.seq_els_rsp_send(rx_fp, ELS_LS_RJT, &rjt_data);
1791 drop:
1792  fc_frame_free(rx_fp);
1793 }
1794 
1803 static void fc_rport_recv_prlo_req(struct fc_rport_priv *rdata,
1804  struct fc_frame *rx_fp)
1805 {
1806  struct fc_lport *lport = rdata->local_port;
1807  struct fc_frame *fp;
1808  struct {
1809  struct fc_els_prlo prlo;
1810  struct fc_els_spp spp;
1811  } *pp;
1812  struct fc_els_spp *rspp; /* request service param page */
1813  struct fc_els_spp *spp; /* response spp */
1814  unsigned int len;
1815  unsigned int plen;
1816  struct fc_seq_els_data rjt_data;
1817 
1818  FC_RPORT_DBG(rdata, "Received PRLO request while in state %s\n",
1819  fc_rport_state(rdata));
1820 
1821  len = fr_len(rx_fp) - sizeof(struct fc_frame_header);
1822  pp = fc_frame_payload_get(rx_fp, sizeof(*pp));
1823  if (!pp)
1824  goto reject_len;
1825  plen = ntohs(pp->prlo.prlo_len);
1826  if (plen != 20)
1827  goto reject_len;
1828  if (plen < len)
1829  len = plen;
1830 
1831  rspp = &pp->spp;
1832 
1833  fp = fc_frame_alloc(lport, len);
1834  if (!fp) {
1835  rjt_data.reason = ELS_RJT_UNAB;
1836  rjt_data.explan = ELS_EXPL_INSUF_RES;
1837  goto reject;
1838  }
1839 
1840  pp = fc_frame_payload_get(fp, len);
1841  WARN_ON(!pp);
1842  memset(pp, 0, len);
1843  pp->prlo.prlo_cmd = ELS_LS_ACC;
1844  pp->prlo.prlo_obs = 0x10;
1845  pp->prlo.prlo_len = htons(len);
1846  spp = &pp->spp;
1847  spp->spp_type = rspp->spp_type;
1848  spp->spp_type_ext = rspp->spp_type_ext;
1849  spp->spp_flags = FC_SPP_RESP_ACK;
1850 
1851  fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
1852 
1853  fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
1854  lport->tt.frame_send(lport, fp);
1855  goto drop;
1856 
1857 reject_len:
1858  rjt_data.reason = ELS_RJT_PROT;
1859  rjt_data.explan = ELS_EXPL_INV_LEN;
1860 reject:
1861  lport->tt.seq_els_rsp_send(rx_fp, ELS_LS_RJT, &rjt_data);
1862 drop:
1863  fc_frame_free(rx_fp);
1864 }
1865 
1874 static void fc_rport_recv_logo_req(struct fc_lport *lport, struct fc_frame *fp)
1875 {
1876  struct fc_rport_priv *rdata;
1877  u32 sid;
1878 
1879  lport->tt.seq_els_rsp_send(fp, ELS_LS_ACC, NULL);
1880 
1881  sid = fc_frame_sid(fp);
1882 
1883  mutex_lock(&lport->disc.disc_mutex);
1884  rdata = lport->tt.rport_lookup(lport, sid);
1885  if (rdata) {
1886  mutex_lock(&rdata->rp_mutex);
1887  FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",
1888  fc_rport_state(rdata));
1889 
1890  fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
1891  mutex_unlock(&rdata->rp_mutex);
1892  } else
1893  FC_RPORT_ID_DBG(lport, sid,
1894  "Received LOGO from non-logged-in port\n");
1895  mutex_unlock(&lport->disc.disc_mutex);
1896  fc_frame_free(fp);
1897 }
1898 
1902 static void fc_rport_flush_queue(void)
1903 {
1904  flush_workqueue(rport_event_queue);
1905 }
1906 
1911 int fc_rport_init(struct fc_lport *lport)
1912 {
1913  if (!lport->tt.rport_lookup)
1914  lport->tt.rport_lookup = fc_rport_lookup;
1915 
1916  if (!lport->tt.rport_create)
1917  lport->tt.rport_create = fc_rport_create;
1918 
1919  if (!lport->tt.rport_login)
1920  lport->tt.rport_login = fc_rport_login;
1921 
1922  if (!lport->tt.rport_logoff)
1923  lport->tt.rport_logoff = fc_rport_logoff;
1924 
1925  if (!lport->tt.rport_recv_req)
1926  lport->tt.rport_recv_req = fc_rport_recv_req;
1927 
1928  if (!lport->tt.rport_flush_queue)
1929  lport->tt.rport_flush_queue = fc_rport_flush_queue;
1930 
1931  if (!lport->tt.rport_destroy)
1932  lport->tt.rport_destroy = fc_rport_destroy;
1933 
1934  return 0;
1935 }
1937 
1948 static int fc_rport_fcp_prli(struct fc_rport_priv *rdata, u32 spp_len,
1949  const struct fc_els_spp *rspp,
1950  struct fc_els_spp *spp)
1951 {
1952  struct fc_lport *lport = rdata->local_port;
1953  u32 fcp_parm;
1954 
1955  fcp_parm = ntohl(rspp->spp_params);
1956  rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
1957  if (fcp_parm & FCP_SPPF_INIT_FCN)
1958  rdata->ids.roles |= FC_RPORT_ROLE_FCP_INITIATOR;
1959  if (fcp_parm & FCP_SPPF_TARG_FCN)
1960  rdata->ids.roles |= FC_RPORT_ROLE_FCP_TARGET;
1961  if (fcp_parm & FCP_SPPF_RETRY)
1962  rdata->flags |= FC_RP_FLAGS_RETRY;
1964 
1966  return 0;
1967 
1968  spp->spp_flags |= rspp->spp_flags & FC_SPP_EST_IMG_PAIR;
1969 
1970  /*
1971  * OR in our service parameters with other providers (target), if any.
1972  */
1973  fcp_parm = ntohl(spp->spp_params);
1974  spp->spp_params = htonl(fcp_parm | lport->service_params);
1975  return FC_SPP_RESP_ACK;
1976 }
1977 
1978 /*
1979  * FC-4 provider ops for FCP initiator.
1980  */
1982  .prli = fc_rport_fcp_prli,
1983 };
1984 
1992 static int fc_rport_t0_prli(struct fc_rport_priv *rdata, u32 spp_len,
1993  const struct fc_els_spp *rspp,
1994  struct fc_els_spp *spp)
1995 {
1996  if (rspp->spp_flags & FC_SPP_EST_IMG_PAIR)
1997  return FC_SPP_RESP_INVL;
1998  return FC_SPP_RESP_ACK;
1999 }
2000 
2001 /*
2002  * FC-4 provider ops for type 0 service parameters.
2003  *
2004  * This handles the special case of type 0 which is always successful
2005  * but doesn't do anything otherwise.
2006  */
2008  .prli = fc_rport_t0_prli,
2009 };
2010 
2015 {
2016  rport_event_queue = create_singlethread_workqueue("fc_rport_eq");
2017  if (!rport_event_queue)
2018  return -ENOMEM;
2019  return 0;
2020 }
2021 
2026 {
2027  destroy_workqueue(rport_event_queue);
2028 }
2029 
2034 void fc_rport_terminate_io(struct fc_rport *rport)
2035 {
2036  struct fc_rport_libfc_priv *rpriv = rport->dd_data;
2037  struct fc_lport *lport = rpriv->local_port;
2038 
2039  lport->tt.exch_mgr_reset(lport, 0, rport->port_id);
2040  lport->tt.exch_mgr_reset(lport, rport->port_id, 0);
2041 }