blob: 49abb839a2239895dd22825c8ef1db36da44a3af [file] [log] [blame]
Robert Love42e9a922008-12-09 15:10:17 -08001/*
2 * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved.
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms and conditions of the GNU General Public License,
6 * version 2, as published by the Free Software Foundation.
7 *
8 * This program is distributed in the hope it will be useful, but WITHOUT
9 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
11 * more details.
12 *
13 * You should have received a copy of the GNU General Public License along with
14 * this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
16 *
17 * Maintained at www.Open-FCoE.org
18 */
19
20/*
21 * RPORT GENERAL INFO
22 *
23 * This file contains all processing regarding fc_rports. It contains the
24 * rport state machine and does all rport interaction with the transport class.
25 * There should be no other places in libfc that interact directly with the
26 * transport class in regards to adding and deleting rports.
27 *
28 * fc_rport's represent N_Port's within the fabric.
29 */
30
31/*
32 * RPORT LOCKING
33 *
34 * The rport should never hold the rport mutex and then attempt to acquire
35 * either the lport or disc mutexes. The rport's mutex is considered lesser
36 * than both the lport's mutex and the disc mutex. Refer to fc_lport.c for
37 * more comments on the heirarchy.
38 *
39 * The locking strategy is similar to the lport's strategy. The lock protects
40 * the rport's states and is held and released by the entry points to the rport
41 * block. All _enter_* functions correspond to rport states and expect the rport
42 * mutex to be locked before calling them. This means that rports only handle
43 * one request or response at a time, since they're not critical for the I/O
44 * path this potential over-use of the mutex is acceptable.
45 */
46
47#include <linux/kernel.h>
48#include <linux/spinlock.h>
49#include <linux/interrupt.h>
50#include <linux/rcupdate.h>
51#include <linux/timer.h>
52#include <linux/workqueue.h>
53#include <asm/unaligned.h>
54
55#include <scsi/libfc.h>
56#include <scsi/fc_encode.h>
57
Robert Love42e9a922008-12-09 15:10:17 -080058struct workqueue_struct *rport_event_queue;
59
Joe Eykholt9fb9d322009-08-25 14:00:50 -070060static void fc_rport_enter_plogi(struct fc_rport_priv *);
61static void fc_rport_enter_prli(struct fc_rport_priv *);
62static void fc_rport_enter_rtv(struct fc_rport_priv *);
63static void fc_rport_enter_ready(struct fc_rport_priv *);
64static void fc_rport_enter_logo(struct fc_rport_priv *);
Joe Eykholt370c3bd2009-08-25 14:03:47 -070065static void fc_rport_enter_adisc(struct fc_rport_priv *);
Robert Love42e9a922008-12-09 15:10:17 -080066
Joe Eykholt3ac6f982009-08-25 14:03:26 -070067static void fc_rport_recv_plogi_req(struct fc_lport *,
Robert Love42e9a922008-12-09 15:10:17 -080068 struct fc_seq *, struct fc_frame *);
Joe Eykholt9fb9d322009-08-25 14:00:50 -070069static void fc_rport_recv_prli_req(struct fc_rport_priv *,
Robert Love42e9a922008-12-09 15:10:17 -080070 struct fc_seq *, struct fc_frame *);
Joe Eykholt9fb9d322009-08-25 14:00:50 -070071static void fc_rport_recv_prlo_req(struct fc_rport_priv *,
Robert Love42e9a922008-12-09 15:10:17 -080072 struct fc_seq *, struct fc_frame *);
Joe Eykholt83fe6a92009-08-25 14:03:31 -070073static void fc_rport_recv_logo_req(struct fc_lport *,
Robert Love42e9a922008-12-09 15:10:17 -080074 struct fc_seq *, struct fc_frame *);
75static void fc_rport_timeout(struct work_struct *);
Joe Eykholt9fb9d322009-08-25 14:00:50 -070076static void fc_rport_error(struct fc_rport_priv *, struct fc_frame *);
77static void fc_rport_error_retry(struct fc_rport_priv *, struct fc_frame *);
Robert Love42e9a922008-12-09 15:10:17 -080078static void fc_rport_work(struct work_struct *);
79
80static const char *fc_rport_state_names[] = {
Robert Love42e9a922008-12-09 15:10:17 -080081 [RPORT_ST_INIT] = "Init",
82 [RPORT_ST_PLOGI] = "PLOGI",
83 [RPORT_ST_PRLI] = "PRLI",
84 [RPORT_ST_RTV] = "RTV",
85 [RPORT_ST_READY] = "Ready",
86 [RPORT_ST_LOGO] = "LOGO",
Joe Eykholt370c3bd2009-08-25 14:03:47 -070087 [RPORT_ST_ADISC] = "ADISC",
Joe Eykholt14194052009-07-29 17:04:43 -070088 [RPORT_ST_DELETE] = "Delete",
Robert Love42e9a922008-12-09 15:10:17 -080089};
90
Joe Eykholt9e9d0452009-08-25 14:01:18 -070091/**
Joe Eykholt8025b5d2009-08-25 14:02:06 -070092 * fc_rport_lookup() - lookup a remote port by port_id
93 * @lport: Fibre Channel host port instance
94 * @port_id: remote port port_id to match
95 */
96static struct fc_rport_priv *fc_rport_lookup(const struct fc_lport *lport,
97 u32 port_id)
98{
99 struct fc_rport_priv *rdata;
100
101 list_for_each_entry(rdata, &lport->disc.rports, peers)
102 if (rdata->ids.port_id == port_id &&
103 rdata->rp_state != RPORT_ST_DELETE)
104 return rdata;
105 return NULL;
106}
107
108/**
Robert Love9737e6a2009-08-25 14:02:59 -0700109 * fc_rport_create() - Create a new remote port
110 * @lport: The local port that the new remote port is for
111 * @port_id: The port ID for the new remote port
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700112 *
Joe Eykholt48f00902009-08-25 14:01:50 -0700113 * Locking note: must be called with the disc_mutex held.
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700114 */
115static struct fc_rport_priv *fc_rport_create(struct fc_lport *lport,
Robert Love9737e6a2009-08-25 14:02:59 -0700116 u32 port_id)
Robert Love42e9a922008-12-09 15:10:17 -0800117{
Joe Eykholtab28f1f2009-08-25 14:00:34 -0700118 struct fc_rport_priv *rdata;
Robert Love42e9a922008-12-09 15:10:17 -0800119
Robert Love9737e6a2009-08-25 14:02:59 -0700120 rdata = lport->tt.rport_lookup(lport, port_id);
Joe Eykholt19f97e32009-08-25 14:01:55 -0700121 if (rdata)
122 return rdata;
123
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700124 rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
125 if (!rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800126 return NULL;
127
Robert Love9737e6a2009-08-25 14:02:59 -0700128 rdata->ids.node_name = -1;
129 rdata->ids.port_name = -1;
130 rdata->ids.port_id = port_id;
131 rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
132
Joe Eykholtf211fa52009-08-25 14:01:01 -0700133 kref_init(&rdata->kref);
Robert Love42e9a922008-12-09 15:10:17 -0800134 mutex_init(&rdata->rp_mutex);
Joe Eykholt795d86f2009-08-25 14:00:39 -0700135 rdata->local_port = lport;
Robert Love42e9a922008-12-09 15:10:17 -0800136 rdata->rp_state = RPORT_ST_INIT;
137 rdata->event = RPORT_EV_NONE;
138 rdata->flags = FC_RP_FLAGS_REC_SUPPORTED;
Joe Eykholt795d86f2009-08-25 14:00:39 -0700139 rdata->e_d_tov = lport->e_d_tov;
140 rdata->r_a_tov = lport->r_a_tov;
Joe Eykholtf211fa52009-08-25 14:01:01 -0700141 rdata->maxframe_size = FC_MIN_MAX_PAYLOAD;
Robert Love42e9a922008-12-09 15:10:17 -0800142 INIT_DELAYED_WORK(&rdata->retry_work, fc_rport_timeout);
143 INIT_WORK(&rdata->event_work, fc_rport_work);
Robert Love9737e6a2009-08-25 14:02:59 -0700144 if (port_id != FC_FID_DIR_SERV)
Joe Eykholt48f00902009-08-25 14:01:50 -0700145 list_add(&rdata->peers, &lport->disc.rports);
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700146 return rdata;
Robert Love42e9a922008-12-09 15:10:17 -0800147}
148
149/**
Joe Eykholtf211fa52009-08-25 14:01:01 -0700150 * fc_rport_destroy() - free a remote port after last reference is released.
151 * @kref: pointer to kref inside struct fc_rport_priv
152 */
153static void fc_rport_destroy(struct kref *kref)
154{
155 struct fc_rport_priv *rdata;
Joe Eykholtf211fa52009-08-25 14:01:01 -0700156
157 rdata = container_of(kref, struct fc_rport_priv, kref);
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700158 kfree(rdata);
Joe Eykholtf211fa52009-08-25 14:01:01 -0700159}
160
161/**
Robert Love34f42a02009-02-27 10:55:45 -0800162 * fc_rport_state() - return a string for the state the rport is in
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700163 * @rdata: remote port private data
Robert Love42e9a922008-12-09 15:10:17 -0800164 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700165static const char *fc_rport_state(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800166{
167 const char *cp;
Robert Love42e9a922008-12-09 15:10:17 -0800168
169 cp = fc_rport_state_names[rdata->rp_state];
170 if (!cp)
171 cp = "Unknown";
172 return cp;
173}
174
175/**
Robert Love34f42a02009-02-27 10:55:45 -0800176 * fc_set_rport_loss_tmo() - Set the remote port loss timeout in seconds.
Robert Love42e9a922008-12-09 15:10:17 -0800177 * @rport: Pointer to Fibre Channel remote port structure
178 * @timeout: timeout in seconds
179 */
180void fc_set_rport_loss_tmo(struct fc_rport *rport, u32 timeout)
181{
182 if (timeout)
183 rport->dev_loss_tmo = timeout + 5;
184 else
185 rport->dev_loss_tmo = 30;
186}
187EXPORT_SYMBOL(fc_set_rport_loss_tmo);
188
189/**
Robert Love34f42a02009-02-27 10:55:45 -0800190 * fc_plogi_get_maxframe() - Get max payload from the common service parameters
Robert Love42e9a922008-12-09 15:10:17 -0800191 * @flp: FLOGI payload structure
192 * @maxval: upper limit, may be less than what is in the service parameters
193 */
Robert Loveb2ab99c2009-02-27 10:55:50 -0800194static unsigned int fc_plogi_get_maxframe(struct fc_els_flogi *flp,
195 unsigned int maxval)
Robert Love42e9a922008-12-09 15:10:17 -0800196{
197 unsigned int mfs;
198
199 /*
200 * Get max payload from the common service parameters and the
201 * class 3 receive data field size.
202 */
203 mfs = ntohs(flp->fl_csp.sp_bb_data) & FC_SP_BB_DATA_MASK;
204 if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
205 maxval = mfs;
206 mfs = ntohs(flp->fl_cssp[3 - 1].cp_rdfs);
207 if (mfs >= FC_SP_MIN_MAX_PAYLOAD && mfs < maxval)
208 maxval = mfs;
209 return maxval;
210}
211
212/**
Robert Love34f42a02009-02-27 10:55:45 -0800213 * fc_rport_state_enter() - Change the rport's state
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700214 * @rdata: The rport whose state should change
Robert Love42e9a922008-12-09 15:10:17 -0800215 * @new: The new state of the rport
216 *
217 * Locking Note: Called with the rport lock held
218 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700219static void fc_rport_state_enter(struct fc_rport_priv *rdata,
Robert Love42e9a922008-12-09 15:10:17 -0800220 enum fc_rport_state new)
221{
Robert Love42e9a922008-12-09 15:10:17 -0800222 if (rdata->rp_state != new)
223 rdata->retries = 0;
224 rdata->rp_state = new;
225}
226
227static void fc_rport_work(struct work_struct *work)
228{
Abhijeet Joglekar571f8242009-02-27 10:54:41 -0800229 u32 port_id;
Joe Eykholtab28f1f2009-08-25 14:00:34 -0700230 struct fc_rport_priv *rdata =
231 container_of(work, struct fc_rport_priv, event_work);
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700232 struct fc_rport_libfc_priv *rp;
Robert Love42e9a922008-12-09 15:10:17 -0800233 enum fc_rport_event event;
Robert Love42e9a922008-12-09 15:10:17 -0800234 struct fc_lport *lport = rdata->local_port;
235 struct fc_rport_operations *rport_ops;
Joe Eykholt629f4422009-08-25 14:01:06 -0700236 struct fc_rport_identifiers ids;
Joe Eykholtf211fa52009-08-25 14:01:01 -0700237 struct fc_rport *rport;
Robert Love42e9a922008-12-09 15:10:17 -0800238
239 mutex_lock(&rdata->rp_mutex);
240 event = rdata->event;
241 rport_ops = rdata->ops;
Joe Eykholtf211fa52009-08-25 14:01:01 -0700242 rport = rdata->rport;
Robert Love42e9a922008-12-09 15:10:17 -0800243
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700244 FC_RPORT_DBG(rdata, "work event %u\n", event);
245
Joe Eykholt629f4422009-08-25 14:01:06 -0700246 switch (event) {
Joe Eykholt4c0f62b2009-08-25 14:01:12 -0700247 case RPORT_EV_READY:
Joe Eykholtf211fa52009-08-25 14:01:01 -0700248 ids = rdata->ids;
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700249 rdata->event = RPORT_EV_NONE;
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700250 kref_get(&rdata->kref);
Robert Love42e9a922008-12-09 15:10:17 -0800251 mutex_unlock(&rdata->rp_mutex);
252
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700253 if (!rport)
254 rport = fc_remote_port_add(lport->host, 0, &ids);
255 if (!rport) {
256 FC_RPORT_DBG(rdata, "Failed to add the rport\n");
257 lport->tt.rport_logoff(rdata);
258 kref_put(&rdata->kref, lport->tt.rport_destroy);
259 return;
Robert Love42e9a922008-12-09 15:10:17 -0800260 }
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700261 mutex_lock(&rdata->rp_mutex);
262 if (rdata->rport)
263 FC_RPORT_DBG(rdata, "rport already allocated\n");
264 rdata->rport = rport;
265 rport->maxframe_size = rdata->maxframe_size;
266 rport->supported_classes = rdata->supported_classes;
267
268 rp = rport->dd_data;
269 rp->local_port = lport;
270 rp->rp_state = rdata->rp_state;
271 rp->flags = rdata->flags;
272 rp->e_d_tov = rdata->e_d_tov;
273 rp->r_a_tov = rdata->r_a_tov;
274 mutex_unlock(&rdata->rp_mutex);
275
Joe Eykholt83455922009-08-25 14:02:01 -0700276 if (rport_ops && rport_ops->event_callback) {
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700277 FC_RPORT_DBG(rdata, "callback ev %d\n", event);
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700278 rport_ops->event_callback(lport, rdata, event);
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700279 }
280 kref_put(&rdata->kref, lport->tt.rport_destroy);
Joe Eykholt629f4422009-08-25 14:01:06 -0700281 break;
282
283 case RPORT_EV_FAILED:
284 case RPORT_EV_LOGO:
285 case RPORT_EV_STOP:
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700286 port_id = rdata->ids.port_id;
Robert Love42e9a922008-12-09 15:10:17 -0800287 mutex_unlock(&rdata->rp_mutex);
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700288
Joe Eykholt48f00902009-08-25 14:01:50 -0700289 if (port_id != FC_FID_DIR_SERV) {
290 mutex_lock(&lport->disc.disc_mutex);
291 list_del(&rdata->peers);
292 mutex_unlock(&lport->disc.disc_mutex);
293 }
294
Joe Eykholt83455922009-08-25 14:02:01 -0700295 if (rport_ops && rport_ops->event_callback) {
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700296 FC_RPORT_DBG(rdata, "callback ev %d\n", event);
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700297 rport_ops->event_callback(lport, rdata, event);
Abhijeet Joglekar571f8242009-02-27 10:54:41 -0800298 }
Joe Eykholt9e9d0452009-08-25 14:01:18 -0700299 cancel_delayed_work_sync(&rdata->retry_work);
300
301 /*
302 * Reset any outstanding exchanges before freeing rport.
303 */
304 lport->tt.exch_mgr_reset(lport, 0, port_id);
305 lport->tt.exch_mgr_reset(lport, port_id, 0);
306
307 if (rport) {
308 rp = rport->dd_data;
309 rp->rp_state = RPORT_ST_DELETE;
310 mutex_lock(&rdata->rp_mutex);
311 rdata->rport = NULL;
312 mutex_unlock(&rdata->rp_mutex);
313 fc_remote_port_delete(rport);
314 }
315 kref_put(&rdata->kref, lport->tt.rport_destroy);
Joe Eykholt629f4422009-08-25 14:01:06 -0700316 break;
317
318 default:
Robert Love42e9a922008-12-09 15:10:17 -0800319 mutex_unlock(&rdata->rp_mutex);
Joe Eykholt629f4422009-08-25 14:01:06 -0700320 break;
321 }
Robert Love42e9a922008-12-09 15:10:17 -0800322}
323
324/**
Robert Love34f42a02009-02-27 10:55:45 -0800325 * fc_rport_login() - Start the remote port login state machine
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700326 * @rdata: private remote port
Robert Love42e9a922008-12-09 15:10:17 -0800327 *
328 * Locking Note: Called without the rport lock held. This
329 * function will hold the rport lock, call an _enter_*
330 * function and then unlock the rport.
Joe Eykholt370c3bd2009-08-25 14:03:47 -0700331 *
332 * This indicates the intent to be logged into the remote port.
333 * If it appears we are already logged in, ADISC is used to verify
334 * the setup.
Robert Love42e9a922008-12-09 15:10:17 -0800335 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700336int fc_rport_login(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800337{
Robert Love42e9a922008-12-09 15:10:17 -0800338 mutex_lock(&rdata->rp_mutex);
339
Joe Eykholt370c3bd2009-08-25 14:03:47 -0700340 switch (rdata->rp_state) {
341 case RPORT_ST_READY:
342 FC_RPORT_DBG(rdata, "ADISC port\n");
343 fc_rport_enter_adisc(rdata);
344 break;
345 default:
346 FC_RPORT_DBG(rdata, "Login to port\n");
347 fc_rport_enter_plogi(rdata);
348 break;
349 }
Robert Love42e9a922008-12-09 15:10:17 -0800350 mutex_unlock(&rdata->rp_mutex);
351
352 return 0;
353}
354
355/**
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700356 * fc_rport_enter_delete() - schedule a remote port to be deleted.
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700357 * @rdata: private remote port
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700358 * @event: event to report as the reason for deletion
359 *
360 * Locking Note: Called with the rport lock held.
361 *
362 * Allow state change into DELETE only once.
363 *
364 * Call queue_work only if there's no event already pending.
365 * Set the new event so that the old pending event will not occur.
366 * Since we have the mutex, even if fc_rport_work() is already started,
367 * it'll see the new event.
368 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700369static void fc_rport_enter_delete(struct fc_rport_priv *rdata,
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700370 enum fc_rport_event event)
371{
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700372 if (rdata->rp_state == RPORT_ST_DELETE)
373 return;
374
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700375 FC_RPORT_DBG(rdata, "Delete port\n");
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700376
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700377 fc_rport_state_enter(rdata, RPORT_ST_DELETE);
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700378
379 if (rdata->event == RPORT_EV_NONE)
380 queue_work(rport_event_queue, &rdata->event_work);
381 rdata->event = event;
382}
383
384/**
Robert Love34f42a02009-02-27 10:55:45 -0800385 * fc_rport_logoff() - Logoff and remove an rport
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700386 * @rdata: private remote port
Robert Love42e9a922008-12-09 15:10:17 -0800387 *
388 * Locking Note: Called without the rport lock held. This
389 * function will hold the rport lock, call an _enter_*
390 * function and then unlock the rport.
391 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700392int fc_rport_logoff(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800393{
Robert Love42e9a922008-12-09 15:10:17 -0800394 mutex_lock(&rdata->rp_mutex);
395
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700396 FC_RPORT_DBG(rdata, "Remove port\n");
Robert Love42e9a922008-12-09 15:10:17 -0800397
Joe Eykholt14194052009-07-29 17:04:43 -0700398 if (rdata->rp_state == RPORT_ST_DELETE) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700399 FC_RPORT_DBG(rdata, "Port in Delete state, not removing\n");
Abhijeet Joglekarb4c6f542009-04-21 16:27:04 -0700400 mutex_unlock(&rdata->rp_mutex);
401 goto out;
402 }
403
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700404 fc_rport_enter_logo(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800405
406 /*
Joe Eykholt14194052009-07-29 17:04:43 -0700407 * Change the state to Delete so that we discard
Robert Love42e9a922008-12-09 15:10:17 -0800408 * the response.
409 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700410 fc_rport_enter_delete(rdata, RPORT_EV_STOP);
Robert Love42e9a922008-12-09 15:10:17 -0800411 mutex_unlock(&rdata->rp_mutex);
412
Abhijeet Joglekarb4c6f542009-04-21 16:27:04 -0700413out:
Robert Love42e9a922008-12-09 15:10:17 -0800414 return 0;
415}
416
417/**
Robert Love34f42a02009-02-27 10:55:45 -0800418 * fc_rport_enter_ready() - The rport is ready
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700419 * @rdata: private remote port
Robert Love42e9a922008-12-09 15:10:17 -0800420 *
421 * Locking Note: The rport lock is expected to be held before calling
422 * this routine.
423 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700424static void fc_rport_enter_ready(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800425{
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700426 fc_rport_state_enter(rdata, RPORT_ST_READY);
Robert Love42e9a922008-12-09 15:10:17 -0800427
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700428 FC_RPORT_DBG(rdata, "Port is Ready\n");
Robert Love42e9a922008-12-09 15:10:17 -0800429
Joe Eykholt5f7ea3b2009-07-29 17:04:49 -0700430 if (rdata->event == RPORT_EV_NONE)
431 queue_work(rport_event_queue, &rdata->event_work);
Joe Eykholt4c0f62b2009-08-25 14:01:12 -0700432 rdata->event = RPORT_EV_READY;
Robert Love42e9a922008-12-09 15:10:17 -0800433}
434
435/**
Robert Love34f42a02009-02-27 10:55:45 -0800436 * fc_rport_timeout() - Handler for the retry_work timer.
Joe Eykholtab28f1f2009-08-25 14:00:34 -0700437 * @work: The work struct of the fc_rport_priv
Robert Love42e9a922008-12-09 15:10:17 -0800438 *
439 * Locking Note: Called without the rport lock held. This
440 * function will hold the rport lock, call an _enter_*
441 * function and then unlock the rport.
442 */
443static void fc_rport_timeout(struct work_struct *work)
444{
Joe Eykholtab28f1f2009-08-25 14:00:34 -0700445 struct fc_rport_priv *rdata =
446 container_of(work, struct fc_rport_priv, retry_work.work);
Robert Love42e9a922008-12-09 15:10:17 -0800447
448 mutex_lock(&rdata->rp_mutex);
449
450 switch (rdata->rp_state) {
451 case RPORT_ST_PLOGI:
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700452 fc_rport_enter_plogi(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800453 break;
454 case RPORT_ST_PRLI:
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700455 fc_rport_enter_prli(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800456 break;
457 case RPORT_ST_RTV:
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700458 fc_rport_enter_rtv(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800459 break;
460 case RPORT_ST_LOGO:
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700461 fc_rport_enter_logo(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800462 break;
Joe Eykholt370c3bd2009-08-25 14:03:47 -0700463 case RPORT_ST_ADISC:
464 fc_rport_enter_adisc(rdata);
465 break;
Robert Love42e9a922008-12-09 15:10:17 -0800466 case RPORT_ST_READY:
467 case RPORT_ST_INIT:
Joe Eykholt14194052009-07-29 17:04:43 -0700468 case RPORT_ST_DELETE:
Robert Love42e9a922008-12-09 15:10:17 -0800469 break;
470 }
471
472 mutex_unlock(&rdata->rp_mutex);
Robert Love42e9a922008-12-09 15:10:17 -0800473}
474
475/**
Robert Love34f42a02009-02-27 10:55:45 -0800476 * fc_rport_error() - Error handler, called once retries have been exhausted
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700477 * @rdata: private remote port
Robert Love42e9a922008-12-09 15:10:17 -0800478 * @fp: The frame pointer
479 *
Robert Love42e9a922008-12-09 15:10:17 -0800480 * Locking Note: The rport lock is expected to be held before
481 * calling this routine
482 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700483static void fc_rport_error(struct fc_rport_priv *rdata, struct fc_frame *fp)
Robert Love42e9a922008-12-09 15:10:17 -0800484{
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700485 FC_RPORT_DBG(rdata, "Error %ld in state %s, retries %d\n",
Joe Eykholtcdbe6df2009-08-25 14:01:39 -0700486 IS_ERR(fp) ? -PTR_ERR(fp) : 0,
487 fc_rport_state(rdata), rdata->retries);
Robert Love42e9a922008-12-09 15:10:17 -0800488
Chris Leech6755db12009-02-27 10:55:02 -0800489 switch (rdata->rp_state) {
490 case RPORT_ST_PLOGI:
Chris Leech6755db12009-02-27 10:55:02 -0800491 case RPORT_ST_LOGO:
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700492 fc_rport_enter_delete(rdata, RPORT_EV_FAILED);
Chris Leech6755db12009-02-27 10:55:02 -0800493 break;
494 case RPORT_ST_RTV:
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700495 fc_rport_enter_ready(rdata);
Chris Leech6755db12009-02-27 10:55:02 -0800496 break;
Joe Eykholt370c3bd2009-08-25 14:03:47 -0700497 case RPORT_ST_PRLI:
498 case RPORT_ST_ADISC:
499 fc_rport_enter_logo(rdata);
500 break;
Joe Eykholt14194052009-07-29 17:04:43 -0700501 case RPORT_ST_DELETE:
Chris Leech6755db12009-02-27 10:55:02 -0800502 case RPORT_ST_READY:
503 case RPORT_ST_INIT:
504 break;
Robert Love42e9a922008-12-09 15:10:17 -0800505 }
506}
507
508/**
Robert Love34f42a02009-02-27 10:55:45 -0800509 * fc_rport_error_retry() - Error handler when retries are desired
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700510 * @rdata: private remote port data
Chris Leech6755db12009-02-27 10:55:02 -0800511 * @fp: The frame pointer
512 *
513 * If the error was an exchange timeout retry immediately,
514 * otherwise wait for E_D_TOV.
515 *
516 * Locking Note: The rport lock is expected to be held before
517 * calling this routine
518 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700519static void fc_rport_error_retry(struct fc_rport_priv *rdata,
520 struct fc_frame *fp)
Chris Leech6755db12009-02-27 10:55:02 -0800521{
Chris Leech6755db12009-02-27 10:55:02 -0800522 unsigned long delay = FC_DEF_E_D_TOV;
523
524 /* make sure this isn't an FC_EX_CLOSED error, never retry those */
525 if (PTR_ERR(fp) == -FC_EX_CLOSED)
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700526 return fc_rport_error(rdata, fp);
Chris Leech6755db12009-02-27 10:55:02 -0800527
Abhijeet Joglekara3666952009-05-01 10:01:26 -0700528 if (rdata->retries < rdata->local_port->max_rport_retry_count) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700529 FC_RPORT_DBG(rdata, "Error %ld in state %s, retrying\n",
530 PTR_ERR(fp), fc_rport_state(rdata));
Chris Leech6755db12009-02-27 10:55:02 -0800531 rdata->retries++;
532 /* no additional delay on exchange timeouts */
533 if (PTR_ERR(fp) == -FC_EX_TIMEOUT)
534 delay = 0;
Chris Leech6755db12009-02-27 10:55:02 -0800535 schedule_delayed_work(&rdata->retry_work, delay);
536 return;
537 }
538
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700539 return fc_rport_error(rdata, fp);
Chris Leech6755db12009-02-27 10:55:02 -0800540}
541
542/**
Robert Love34f42a02009-02-27 10:55:45 -0800543 * fc_rport_plogi_recv_resp() - Handle incoming ELS PLOGI response
Robert Love42e9a922008-12-09 15:10:17 -0800544 * @sp: current sequence in the PLOGI exchange
545 * @fp: response frame
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700546 * @rdata_arg: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800547 *
548 * Locking Note: This function will be called without the rport lock
549 * held, but it will lock, call an _enter_* function or fc_rport_error
550 * and then unlock the rport.
551 */
552static void fc_rport_plogi_resp(struct fc_seq *sp, struct fc_frame *fp,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700553 void *rdata_arg)
Robert Love42e9a922008-12-09 15:10:17 -0800554{
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700555 struct fc_rport_priv *rdata = rdata_arg;
Robert Love42e9a922008-12-09 15:10:17 -0800556 struct fc_lport *lport = rdata->local_port;
Robert Lovea29e7642009-04-21 16:27:41 -0700557 struct fc_els_flogi *plp = NULL;
Robert Love42e9a922008-12-09 15:10:17 -0800558 unsigned int tov;
559 u16 csp_seq;
560 u16 cssp_seq;
561 u8 op;
562
563 mutex_lock(&rdata->rp_mutex);
564
Joe Eykholtf657d292009-08-25 14:03:21 -0700565 FC_RPORT_DBG(rdata, "Received a PLOGI %s\n", fc_els_resp_type(fp));
Robert Love42e9a922008-12-09 15:10:17 -0800566
567 if (rdata->rp_state != RPORT_ST_PLOGI) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700568 FC_RPORT_DBG(rdata, "Received a PLOGI response, but in state "
569 "%s\n", fc_rport_state(rdata));
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700570 if (IS_ERR(fp))
571 goto err;
Robert Love42e9a922008-12-09 15:10:17 -0800572 goto out;
573 }
574
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700575 if (IS_ERR(fp)) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700576 fc_rport_error_retry(rdata, fp);
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700577 goto err;
578 }
579
Robert Love42e9a922008-12-09 15:10:17 -0800580 op = fc_frame_payload_op(fp);
581 if (op == ELS_LS_ACC &&
582 (plp = fc_frame_payload_get(fp, sizeof(*plp))) != NULL) {
Joe Eykholtf211fa52009-08-25 14:01:01 -0700583 rdata->ids.port_name = get_unaligned_be64(&plp->fl_wwpn);
584 rdata->ids.node_name = get_unaligned_be64(&plp->fl_wwnn);
Robert Love42e9a922008-12-09 15:10:17 -0800585
586 tov = ntohl(plp->fl_csp.sp_e_d_tov);
587 if (ntohs(plp->fl_csp.sp_features) & FC_SP_FT_EDTR)
588 tov /= 1000;
589 if (tov > rdata->e_d_tov)
590 rdata->e_d_tov = tov;
591 csp_seq = ntohs(plp->fl_csp.sp_tot_seq);
592 cssp_seq = ntohs(plp->fl_cssp[3 - 1].cp_con_seq);
593 if (cssp_seq < csp_seq)
594 csp_seq = cssp_seq;
595 rdata->max_seq = csp_seq;
Joe Eykholtf211fa52009-08-25 14:01:01 -0700596 rdata->maxframe_size = fc_plogi_get_maxframe(plp, lport->mfs);
Joe Eykholt3ac6f982009-08-25 14:03:26 -0700597 fc_rport_enter_prli(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800598 } else
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700599 fc_rport_error_retry(rdata, fp);
Robert Love42e9a922008-12-09 15:10:17 -0800600
601out:
602 fc_frame_free(fp);
603err:
604 mutex_unlock(&rdata->rp_mutex);
Joe Eykholtf211fa52009-08-25 14:01:01 -0700605 kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
Robert Love42e9a922008-12-09 15:10:17 -0800606}
607
608/**
Robert Love34f42a02009-02-27 10:55:45 -0800609 * fc_rport_enter_plogi() - Send Port Login (PLOGI) request to peer
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700610 * @rdata: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800611 *
612 * Locking Note: The rport lock is expected to be held before calling
613 * this routine.
614 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700615static void fc_rport_enter_plogi(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800616{
Robert Love42e9a922008-12-09 15:10:17 -0800617 struct fc_lport *lport = rdata->local_port;
618 struct fc_frame *fp;
619
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700620 FC_RPORT_DBG(rdata, "Port entered PLOGI state from %s state\n",
621 fc_rport_state(rdata));
Robert Love42e9a922008-12-09 15:10:17 -0800622
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700623 fc_rport_state_enter(rdata, RPORT_ST_PLOGI);
Robert Love42e9a922008-12-09 15:10:17 -0800624
Joe Eykholtf211fa52009-08-25 14:01:01 -0700625 rdata->maxframe_size = FC_MIN_MAX_PAYLOAD;
Robert Love42e9a922008-12-09 15:10:17 -0800626 fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
627 if (!fp) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700628 fc_rport_error_retry(rdata, fp);
Robert Love42e9a922008-12-09 15:10:17 -0800629 return;
630 }
631 rdata->e_d_tov = lport->e_d_tov;
632
Joe Eykholtf211fa52009-08-25 14:01:01 -0700633 if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PLOGI,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700634 fc_rport_plogi_resp, rdata, lport->e_d_tov))
Chris Leech8f550f92009-10-21 16:28:09 -0700635 fc_rport_error_retry(rdata, NULL);
Robert Love42e9a922008-12-09 15:10:17 -0800636 else
Joe Eykholtf211fa52009-08-25 14:01:01 -0700637 kref_get(&rdata->kref);
Robert Love42e9a922008-12-09 15:10:17 -0800638}
639
640/**
Robert Love34f42a02009-02-27 10:55:45 -0800641 * fc_rport_prli_resp() - Process Login (PRLI) response handler
Robert Love42e9a922008-12-09 15:10:17 -0800642 * @sp: current sequence in the PRLI exchange
643 * @fp: response frame
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700644 * @rdata_arg: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800645 *
646 * Locking Note: This function will be called without the rport lock
647 * held, but it will lock, call an _enter_* function or fc_rport_error
648 * and then unlock the rport.
649 */
650static void fc_rport_prli_resp(struct fc_seq *sp, struct fc_frame *fp,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700651 void *rdata_arg)
Robert Love42e9a922008-12-09 15:10:17 -0800652{
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700653 struct fc_rport_priv *rdata = rdata_arg;
Robert Love42e9a922008-12-09 15:10:17 -0800654 struct {
655 struct fc_els_prli prli;
656 struct fc_els_spp spp;
657 } *pp;
658 u32 roles = FC_RPORT_ROLE_UNKNOWN;
659 u32 fcp_parm = 0;
660 u8 op;
661
662 mutex_lock(&rdata->rp_mutex);
663
Joe Eykholtf657d292009-08-25 14:03:21 -0700664 FC_RPORT_DBG(rdata, "Received a PRLI %s\n", fc_els_resp_type(fp));
Robert Love42e9a922008-12-09 15:10:17 -0800665
666 if (rdata->rp_state != RPORT_ST_PRLI) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700667 FC_RPORT_DBG(rdata, "Received a PRLI response, but in state "
668 "%s\n", fc_rport_state(rdata));
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700669 if (IS_ERR(fp))
670 goto err;
Robert Love42e9a922008-12-09 15:10:17 -0800671 goto out;
672 }
673
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700674 if (IS_ERR(fp)) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700675 fc_rport_error_retry(rdata, fp);
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700676 goto err;
677 }
678
Robert Love6bd054c2009-08-25 14:03:04 -0700679 /* reinitialize remote port roles */
680 rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
681
Robert Love42e9a922008-12-09 15:10:17 -0800682 op = fc_frame_payload_op(fp);
683 if (op == ELS_LS_ACC) {
684 pp = fc_frame_payload_get(fp, sizeof(*pp));
685 if (pp && pp->prli.prli_spp_len >= sizeof(pp->spp)) {
686 fcp_parm = ntohl(pp->spp.spp_params);
687 if (fcp_parm & FCP_SPPF_RETRY)
688 rdata->flags |= FC_RP_FLAGS_RETRY;
689 }
690
Joe Eykholtf211fa52009-08-25 14:01:01 -0700691 rdata->supported_classes = FC_COS_CLASS3;
Robert Love42e9a922008-12-09 15:10:17 -0800692 if (fcp_parm & FCP_SPPF_INIT_FCN)
693 roles |= FC_RPORT_ROLE_FCP_INITIATOR;
694 if (fcp_parm & FCP_SPPF_TARG_FCN)
695 roles |= FC_RPORT_ROLE_FCP_TARGET;
696
Joe Eykholtf211fa52009-08-25 14:01:01 -0700697 rdata->ids.roles = roles;
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700698 fc_rport_enter_rtv(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800699
700 } else {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700701 FC_RPORT_DBG(rdata, "Bad ELS response for PRLI command\n");
702 fc_rport_enter_delete(rdata, RPORT_EV_FAILED);
Robert Love42e9a922008-12-09 15:10:17 -0800703 }
704
705out:
706 fc_frame_free(fp);
707err:
708 mutex_unlock(&rdata->rp_mutex);
Joe Eykholtf211fa52009-08-25 14:01:01 -0700709 kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
Robert Love42e9a922008-12-09 15:10:17 -0800710}
711
712/**
Robert Love34f42a02009-02-27 10:55:45 -0800713 * fc_rport_logo_resp() - Logout (LOGO) response handler
Robert Love42e9a922008-12-09 15:10:17 -0800714 * @sp: current sequence in the LOGO exchange
715 * @fp: response frame
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700716 * @rdata_arg: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800717 *
718 * Locking Note: This function will be called without the rport lock
719 * held, but it will lock, call an _enter_* function or fc_rport_error
720 * and then unlock the rport.
721 */
722static void fc_rport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700723 void *rdata_arg)
Robert Love42e9a922008-12-09 15:10:17 -0800724{
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700725 struct fc_rport_priv *rdata = rdata_arg;
Robert Love42e9a922008-12-09 15:10:17 -0800726 u8 op;
727
728 mutex_lock(&rdata->rp_mutex);
729
Joe Eykholtf657d292009-08-25 14:03:21 -0700730 FC_RPORT_DBG(rdata, "Received a LOGO %s\n", fc_els_resp_type(fp));
Robert Love42e9a922008-12-09 15:10:17 -0800731
Robert Love42e9a922008-12-09 15:10:17 -0800732 if (rdata->rp_state != RPORT_ST_LOGO) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700733 FC_RPORT_DBG(rdata, "Received a LOGO response, but in state "
734 "%s\n", fc_rport_state(rdata));
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700735 if (IS_ERR(fp))
736 goto err;
Robert Love42e9a922008-12-09 15:10:17 -0800737 goto out;
738 }
739
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700740 if (IS_ERR(fp)) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700741 fc_rport_error_retry(rdata, fp);
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700742 goto err;
743 }
744
Robert Love42e9a922008-12-09 15:10:17 -0800745 op = fc_frame_payload_op(fp);
Joe Eykholt68a17502009-08-25 14:03:42 -0700746 if (op != ELS_LS_ACC)
747 FC_RPORT_DBG(rdata, "Bad ELS response op %x for LOGO command\n",
748 op);
749 fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
Robert Love42e9a922008-12-09 15:10:17 -0800750
751out:
752 fc_frame_free(fp);
753err:
754 mutex_unlock(&rdata->rp_mutex);
Joe Eykholtf211fa52009-08-25 14:01:01 -0700755 kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
Robert Love42e9a922008-12-09 15:10:17 -0800756}
757
758/**
Robert Love34f42a02009-02-27 10:55:45 -0800759 * fc_rport_enter_prli() - Send Process Login (PRLI) request to peer
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700760 * @rdata: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800761 *
762 * Locking Note: The rport lock is expected to be held before calling
763 * this routine.
764 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700765static void fc_rport_enter_prli(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800766{
Robert Love42e9a922008-12-09 15:10:17 -0800767 struct fc_lport *lport = rdata->local_port;
768 struct {
769 struct fc_els_prli prli;
770 struct fc_els_spp spp;
771 } *pp;
772 struct fc_frame *fp;
773
Joe Eykholt3ac6f982009-08-25 14:03:26 -0700774 /*
775 * If the rport is one of the well known addresses
776 * we skip PRLI and RTV and go straight to READY.
777 */
778 if (rdata->ids.port_id >= FC_FID_DOM_MGR) {
779 fc_rport_enter_ready(rdata);
780 return;
781 }
782
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700783 FC_RPORT_DBG(rdata, "Port entered PRLI state from %s state\n",
784 fc_rport_state(rdata));
Robert Love42e9a922008-12-09 15:10:17 -0800785
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700786 fc_rport_state_enter(rdata, RPORT_ST_PRLI);
Robert Love42e9a922008-12-09 15:10:17 -0800787
788 fp = fc_frame_alloc(lport, sizeof(*pp));
789 if (!fp) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700790 fc_rport_error_retry(rdata, fp);
Robert Love42e9a922008-12-09 15:10:17 -0800791 return;
792 }
793
Joe Eykholtf211fa52009-08-25 14:01:01 -0700794 if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_PRLI,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700795 fc_rport_prli_resp, rdata, lport->e_d_tov))
Chris Leech8f550f92009-10-21 16:28:09 -0700796 fc_rport_error_retry(rdata, NULL);
Robert Love42e9a922008-12-09 15:10:17 -0800797 else
Joe Eykholtf211fa52009-08-25 14:01:01 -0700798 kref_get(&rdata->kref);
Robert Love42e9a922008-12-09 15:10:17 -0800799}
800
801/**
Robert Love34f42a02009-02-27 10:55:45 -0800802 * fc_rport_els_rtv_resp() - Request Timeout Value response handler
Robert Love42e9a922008-12-09 15:10:17 -0800803 * @sp: current sequence in the RTV exchange
804 * @fp: response frame
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700805 * @rdata_arg: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800806 *
807 * Many targets don't seem to support this.
808 *
809 * Locking Note: This function will be called without the rport lock
810 * held, but it will lock, call an _enter_* function or fc_rport_error
811 * and then unlock the rport.
812 */
813static void fc_rport_rtv_resp(struct fc_seq *sp, struct fc_frame *fp,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700814 void *rdata_arg)
Robert Love42e9a922008-12-09 15:10:17 -0800815{
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700816 struct fc_rport_priv *rdata = rdata_arg;
Robert Love42e9a922008-12-09 15:10:17 -0800817 u8 op;
818
819 mutex_lock(&rdata->rp_mutex);
820
Joe Eykholtf657d292009-08-25 14:03:21 -0700821 FC_RPORT_DBG(rdata, "Received a RTV %s\n", fc_els_resp_type(fp));
Robert Love42e9a922008-12-09 15:10:17 -0800822
823 if (rdata->rp_state != RPORT_ST_RTV) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700824 FC_RPORT_DBG(rdata, "Received a RTV response, but in state "
825 "%s\n", fc_rport_state(rdata));
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700826 if (IS_ERR(fp))
827 goto err;
Robert Love42e9a922008-12-09 15:10:17 -0800828 goto out;
829 }
830
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700831 if (IS_ERR(fp)) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700832 fc_rport_error(rdata, fp);
Abhijeet Joglekar76f68042009-04-21 16:26:58 -0700833 goto err;
834 }
835
Robert Love42e9a922008-12-09 15:10:17 -0800836 op = fc_frame_payload_op(fp);
837 if (op == ELS_LS_ACC) {
838 struct fc_els_rtv_acc *rtv;
839 u32 toq;
840 u32 tov;
841
842 rtv = fc_frame_payload_get(fp, sizeof(*rtv));
843 if (rtv) {
844 toq = ntohl(rtv->rtv_toq);
845 tov = ntohl(rtv->rtv_r_a_tov);
846 if (tov == 0)
847 tov = 1;
848 rdata->r_a_tov = tov;
849 tov = ntohl(rtv->rtv_e_d_tov);
850 if (toq & FC_ELS_RTV_EDRES)
851 tov /= 1000000;
852 if (tov == 0)
853 tov = 1;
854 rdata->e_d_tov = tov;
855 }
856 }
857
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700858 fc_rport_enter_ready(rdata);
Robert Love42e9a922008-12-09 15:10:17 -0800859
860out:
861 fc_frame_free(fp);
862err:
863 mutex_unlock(&rdata->rp_mutex);
Joe Eykholtf211fa52009-08-25 14:01:01 -0700864 kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
Robert Love42e9a922008-12-09 15:10:17 -0800865}
866
867/**
Robert Love34f42a02009-02-27 10:55:45 -0800868 * fc_rport_enter_rtv() - Send Request Timeout Value (RTV) request to peer
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700869 * @rdata: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800870 *
871 * Locking Note: The rport lock is expected to be held before calling
872 * this routine.
873 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700874static void fc_rport_enter_rtv(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800875{
876 struct fc_frame *fp;
Robert Love42e9a922008-12-09 15:10:17 -0800877 struct fc_lport *lport = rdata->local_port;
878
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700879 FC_RPORT_DBG(rdata, "Port entered RTV state from %s state\n",
880 fc_rport_state(rdata));
Robert Love42e9a922008-12-09 15:10:17 -0800881
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700882 fc_rport_state_enter(rdata, RPORT_ST_RTV);
Robert Love42e9a922008-12-09 15:10:17 -0800883
884 fp = fc_frame_alloc(lport, sizeof(struct fc_els_rtv));
885 if (!fp) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700886 fc_rport_error_retry(rdata, fp);
Robert Love42e9a922008-12-09 15:10:17 -0800887 return;
888 }
889
Joe Eykholtf211fa52009-08-25 14:01:01 -0700890 if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_RTV,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700891 fc_rport_rtv_resp, rdata, lport->e_d_tov))
Chris Leech8f550f92009-10-21 16:28:09 -0700892 fc_rport_error_retry(rdata, NULL);
Robert Love42e9a922008-12-09 15:10:17 -0800893 else
Joe Eykholtf211fa52009-08-25 14:01:01 -0700894 kref_get(&rdata->kref);
Robert Love42e9a922008-12-09 15:10:17 -0800895}
896
897/**
Robert Love34f42a02009-02-27 10:55:45 -0800898 * fc_rport_enter_logo() - Send Logout (LOGO) request to peer
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700899 * @rdata: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -0800900 *
901 * Locking Note: The rport lock is expected to be held before calling
902 * this routine.
903 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700904static void fc_rport_enter_logo(struct fc_rport_priv *rdata)
Robert Love42e9a922008-12-09 15:10:17 -0800905{
Robert Love42e9a922008-12-09 15:10:17 -0800906 struct fc_lport *lport = rdata->local_port;
907 struct fc_frame *fp;
908
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700909 FC_RPORT_DBG(rdata, "Port entered LOGO state from %s state\n",
910 fc_rport_state(rdata));
Robert Love42e9a922008-12-09 15:10:17 -0800911
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700912 fc_rport_state_enter(rdata, RPORT_ST_LOGO);
Robert Love42e9a922008-12-09 15:10:17 -0800913
914 fp = fc_frame_alloc(lport, sizeof(struct fc_els_logo));
915 if (!fp) {
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700916 fc_rport_error_retry(rdata, fp);
Robert Love42e9a922008-12-09 15:10:17 -0800917 return;
918 }
919
Joe Eykholtf211fa52009-08-25 14:01:01 -0700920 if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_LOGO,
Joe Eykholt9fb9d322009-08-25 14:00:50 -0700921 fc_rport_logo_resp, rdata, lport->e_d_tov))
Chris Leech8f550f92009-10-21 16:28:09 -0700922 fc_rport_error_retry(rdata, NULL);
Robert Love42e9a922008-12-09 15:10:17 -0800923 else
Joe Eykholtf211fa52009-08-25 14:01:01 -0700924 kref_get(&rdata->kref);
Robert Love42e9a922008-12-09 15:10:17 -0800925}
926
Robert Love42e9a922008-12-09 15:10:17 -0800927/**
Joe Eykholt370c3bd2009-08-25 14:03:47 -0700928 * fc_rport_els_adisc_resp() - Address Discovery response handler
929 * @sp: current sequence in the ADISC exchange
930 * @fp: response frame
931 * @rdata_arg: remote port private.
932 *
933 * Locking Note: This function will be called without the rport lock
934 * held, but it will lock, call an _enter_* function or fc_rport_error
935 * and then unlock the rport.
936 */
937static void fc_rport_adisc_resp(struct fc_seq *sp, struct fc_frame *fp,
938 void *rdata_arg)
939{
940 struct fc_rport_priv *rdata = rdata_arg;
941 struct fc_els_adisc *adisc;
942 u8 op;
943
944 mutex_lock(&rdata->rp_mutex);
945
946 FC_RPORT_DBG(rdata, "Received a ADISC response\n");
947
948 if (rdata->rp_state != RPORT_ST_ADISC) {
949 FC_RPORT_DBG(rdata, "Received a ADISC resp but in state %s\n",
950 fc_rport_state(rdata));
951 if (IS_ERR(fp))
952 goto err;
953 goto out;
954 }
955
956 if (IS_ERR(fp)) {
957 fc_rport_error(rdata, fp);
958 goto err;
959 }
960
961 /*
962 * If address verification failed. Consider us logged out of the rport.
963 * Since the rport is still in discovery, we want to be
964 * logged in, so go to PLOGI state. Otherwise, go back to READY.
965 */
966 op = fc_frame_payload_op(fp);
967 adisc = fc_frame_payload_get(fp, sizeof(*adisc));
968 if (op != ELS_LS_ACC || !adisc ||
969 ntoh24(adisc->adisc_port_id) != rdata->ids.port_id ||
970 get_unaligned_be64(&adisc->adisc_wwpn) != rdata->ids.port_name ||
971 get_unaligned_be64(&adisc->adisc_wwnn) != rdata->ids.node_name) {
972 FC_RPORT_DBG(rdata, "ADISC error or mismatch\n");
973 fc_rport_enter_plogi(rdata);
974 } else {
975 FC_RPORT_DBG(rdata, "ADISC OK\n");
976 fc_rport_enter_ready(rdata);
977 }
978out:
979 fc_frame_free(fp);
980err:
981 mutex_unlock(&rdata->rp_mutex);
982 kref_put(&rdata->kref, rdata->local_port->tt.rport_destroy);
983}
984
985/**
986 * fc_rport_enter_adisc() - Send Address Discover (ADISC) request to peer
987 * @rdata: remote port private data
988 *
989 * Locking Note: The rport lock is expected to be held before calling
990 * this routine.
991 */
992static void fc_rport_enter_adisc(struct fc_rport_priv *rdata)
993{
994 struct fc_lport *lport = rdata->local_port;
995 struct fc_frame *fp;
996
997 FC_RPORT_DBG(rdata, "sending ADISC from %s state\n",
998 fc_rport_state(rdata));
999
1000 fc_rport_state_enter(rdata, RPORT_ST_ADISC);
1001
1002 fp = fc_frame_alloc(lport, sizeof(struct fc_els_adisc));
1003 if (!fp) {
1004 fc_rport_error_retry(rdata, fp);
1005 return;
1006 }
1007 if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, ELS_ADISC,
1008 fc_rport_adisc_resp, rdata, lport->e_d_tov))
Chris Leech8f550f92009-10-21 16:28:09 -07001009 fc_rport_error_retry(rdata, NULL);
Joe Eykholt370c3bd2009-08-25 14:03:47 -07001010 else
1011 kref_get(&rdata->kref);
1012}
1013
1014/**
Joe Eykholt8abbe3a2009-08-25 14:03:52 -07001015 * fc_rport_recv_adisc_req() - Handle incoming Address Discovery (ADISC) Request
1016 * @rdata: remote port private
1017 * @sp: current sequence in the ADISC exchange
1018 * @in_fp: ADISC request frame
1019 *
1020 * Locking Note: Called with the lport and rport locks held.
1021 */
1022static void fc_rport_recv_adisc_req(struct fc_rport_priv *rdata,
1023 struct fc_seq *sp, struct fc_frame *in_fp)
1024{
1025 struct fc_lport *lport = rdata->local_port;
1026 struct fc_frame *fp;
1027 struct fc_exch *ep = fc_seq_exch(sp);
1028 struct fc_els_adisc *adisc;
1029 struct fc_seq_els_data rjt_data;
1030 u32 f_ctl;
1031
1032 FC_RPORT_DBG(rdata, "Received ADISC request\n");
1033
1034 adisc = fc_frame_payload_get(in_fp, sizeof(*adisc));
1035 if (!adisc) {
1036 rjt_data.fp = NULL;
1037 rjt_data.reason = ELS_RJT_PROT;
1038 rjt_data.explan = ELS_EXPL_INV_LEN;
1039 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1040 goto drop;
1041 }
1042
1043 fp = fc_frame_alloc(lport, sizeof(*adisc));
1044 if (!fp)
1045 goto drop;
1046 fc_adisc_fill(lport, fp);
1047 adisc = fc_frame_payload_get(fp, sizeof(*adisc));
1048 adisc->adisc_cmd = ELS_LS_ACC;
1049 sp = lport->tt.seq_start_next(sp);
1050 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1051 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1052 FC_TYPE_ELS, f_ctl, 0);
1053 lport->tt.seq_send(lport, sp, fp);
1054drop:
1055 fc_frame_free(in_fp);
1056}
1057
1058/**
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001059 * fc_rport_recv_els_req() - handle a validated ELS request.
1060 * @lport: Fibre Channel local port
Robert Love42e9a922008-12-09 15:10:17 -08001061 * @sp: current sequence in the PLOGI exchange
1062 * @fp: response frame
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001063 *
1064 * Handle incoming ELS requests that require port login.
1065 * The ELS opcode has already been validated by the caller.
Robert Love42e9a922008-12-09 15:10:17 -08001066 *
Joe Eykholt131203a2009-08-25 14:03:10 -07001067 * Locking Note: Called with the lport lock held.
Robert Love42e9a922008-12-09 15:10:17 -08001068 */
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001069static void fc_rport_recv_els_req(struct fc_lport *lport,
1070 struct fc_seq *sp, struct fc_frame *fp)
Robert Love42e9a922008-12-09 15:10:17 -08001071{
Joe Eykholt131203a2009-08-25 14:03:10 -07001072 struct fc_rport_priv *rdata;
Robert Love42e9a922008-12-09 15:10:17 -08001073 struct fc_frame_header *fh;
1074 struct fc_seq_els_data els_data;
Robert Love42e9a922008-12-09 15:10:17 -08001075
Robert Love42e9a922008-12-09 15:10:17 -08001076 els_data.fp = NULL;
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001077 els_data.reason = ELS_RJT_UNAB;
1078 els_data.explan = ELS_EXPL_PLOGI_REQD;
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001079
Robert Love42e9a922008-12-09 15:10:17 -08001080 fh = fc_frame_header_get(fp);
1081
Joe Eykholt25b37b92009-08-25 14:03:15 -07001082 mutex_lock(&lport->disc.disc_mutex);
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001083 rdata = lport->tt.rport_lookup(lport, ntoh24(fh->fh_s_id));
Joe Eykholt131203a2009-08-25 14:03:10 -07001084 if (!rdata) {
Joe Eykholt25b37b92009-08-25 14:03:15 -07001085 mutex_unlock(&lport->disc.disc_mutex);
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001086 goto reject;
Joe Eykholt131203a2009-08-25 14:03:10 -07001087 }
1088 mutex_lock(&rdata->rp_mutex);
Joe Eykholt25b37b92009-08-25 14:03:15 -07001089 mutex_unlock(&lport->disc.disc_mutex);
Joe Eykholt131203a2009-08-25 14:03:10 -07001090
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001091 switch (rdata->rp_state) {
1092 case RPORT_ST_PRLI:
1093 case RPORT_ST_RTV:
1094 case RPORT_ST_READY:
Joe Eykholt370c3bd2009-08-25 14:03:47 -07001095 case RPORT_ST_ADISC:
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001096 break;
1097 default:
1098 mutex_unlock(&rdata->rp_mutex);
1099 goto reject;
1100 }
1101
1102 switch (fc_frame_payload_op(fp)) {
Joe Eykholt131203a2009-08-25 14:03:10 -07001103 case ELS_PRLI:
1104 fc_rport_recv_prli_req(rdata, sp, fp);
1105 break;
1106 case ELS_PRLO:
1107 fc_rport_recv_prlo_req(rdata, sp, fp);
1108 break;
Joe Eykholt8abbe3a2009-08-25 14:03:52 -07001109 case ELS_ADISC:
1110 fc_rport_recv_adisc_req(rdata, sp, fp);
1111 break;
Joe Eykholt131203a2009-08-25 14:03:10 -07001112 case ELS_RRQ:
1113 els_data.fp = fp;
1114 lport->tt.seq_els_rsp_send(sp, ELS_RRQ, &els_data);
1115 break;
1116 case ELS_REC:
1117 els_data.fp = fp;
1118 lport->tt.seq_els_rsp_send(sp, ELS_REC, &els_data);
1119 break;
1120 default:
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001121 fc_frame_free(fp); /* can't happen */
Joe Eykholt131203a2009-08-25 14:03:10 -07001122 break;
Robert Love42e9a922008-12-09 15:10:17 -08001123 }
1124
1125 mutex_unlock(&rdata->rp_mutex);
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001126 return;
1127
1128reject:
1129 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
1130 fc_frame_free(fp);
1131}
1132
1133/**
1134 * fc_rport_recv_req() - Handle a received ELS request from a rport
1135 * @sp: current sequence in the PLOGI exchange
1136 * @fp: response frame
1137 * @lport: Fibre Channel local port
1138 *
1139 * Locking Note: Called with the lport lock held.
1140 */
1141void fc_rport_recv_req(struct fc_seq *sp, struct fc_frame *fp,
1142 struct fc_lport *lport)
1143{
1144 struct fc_seq_els_data els_data;
1145
1146 /*
1147 * Handle PLOGI and LOGO requests separately, since they
1148 * don't require prior login.
1149 * Check for unsupported opcodes first and reject them.
1150 * For some ops, it would be incorrect to reject with "PLOGI required".
1151 */
1152 switch (fc_frame_payload_op(fp)) {
1153 case ELS_PLOGI:
1154 fc_rport_recv_plogi_req(lport, sp, fp);
1155 break;
1156 case ELS_LOGO:
1157 fc_rport_recv_logo_req(lport, sp, fp);
1158 break;
1159 case ELS_PRLI:
1160 case ELS_PRLO:
Joe Eykholt8abbe3a2009-08-25 14:03:52 -07001161 case ELS_ADISC:
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001162 case ELS_RRQ:
1163 case ELS_REC:
1164 fc_rport_recv_els_req(lport, sp, fp);
1165 break;
1166 default:
1167 fc_frame_free(fp);
1168 els_data.fp = NULL;
1169 els_data.reason = ELS_RJT_UNSUP;
1170 els_data.explan = ELS_EXPL_NONE;
1171 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &els_data);
1172 break;
1173 }
Robert Love42e9a922008-12-09 15:10:17 -08001174}
1175
1176/**
Robert Love34f42a02009-02-27 10:55:45 -08001177 * fc_rport_recv_plogi_req() - Handle incoming Port Login (PLOGI) request
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001178 * @lport: local port
Robert Love42e9a922008-12-09 15:10:17 -08001179 * @sp: current sequence in the PLOGI exchange
1180 * @fp: PLOGI request frame
1181 *
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001182 * Locking Note: The rport lock is held before calling this function.
Robert Love42e9a922008-12-09 15:10:17 -08001183 */
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001184static void fc_rport_recv_plogi_req(struct fc_lport *lport,
Robert Love42e9a922008-12-09 15:10:17 -08001185 struct fc_seq *sp, struct fc_frame *rx_fp)
1186{
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001187 struct fc_disc *disc;
1188 struct fc_rport_priv *rdata;
Robert Love42e9a922008-12-09 15:10:17 -08001189 struct fc_frame *fp = rx_fp;
1190 struct fc_exch *ep;
1191 struct fc_frame_header *fh;
1192 struct fc_els_flogi *pl;
1193 struct fc_seq_els_data rjt_data;
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001194 u32 sid, f_ctl;
1195
Robert Love42e9a922008-12-09 15:10:17 -08001196 rjt_data.fp = NULL;
Robert Love42e9a922008-12-09 15:10:17 -08001197 fh = fc_frame_header_get(fp);
Robert Love42e9a922008-12-09 15:10:17 -08001198 sid = ntoh24(fh->fh_s_id);
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001199
1200 FC_RPORT_ID_DBG(lport, sid, "Received PLOGI request\n");
1201
Robert Love42e9a922008-12-09 15:10:17 -08001202 pl = fc_frame_payload_get(fp, sizeof(*pl));
1203 if (!pl) {
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001204 FC_RPORT_ID_DBG(lport, sid, "Received PLOGI too short\n");
1205 rjt_data.reason = ELS_RJT_PROT;
1206 rjt_data.explan = ELS_EXPL_INV_LEN;
1207 goto reject;
Robert Love42e9a922008-12-09 15:10:17 -08001208 }
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001209
1210 disc = &lport->disc;
1211 mutex_lock(&disc->disc_mutex);
1212 rdata = lport->tt.rport_create(lport, sid);
1213 if (!rdata) {
1214 mutex_unlock(&disc->disc_mutex);
1215 rjt_data.reason = ELS_RJT_UNAB;
1216 rjt_data.explan = ELS_EXPL_INSUF_RES;
1217 goto reject;
1218 }
1219
1220 mutex_lock(&rdata->rp_mutex);
1221 mutex_unlock(&disc->disc_mutex);
1222
1223 rdata->ids.port_name = get_unaligned_be64(&pl->fl_wwpn);
1224 rdata->ids.node_name = get_unaligned_be64(&pl->fl_wwnn);
Robert Love42e9a922008-12-09 15:10:17 -08001225
1226 /*
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001227 * If the rport was just created, possibly due to the incoming PLOGI,
Robert Love42e9a922008-12-09 15:10:17 -08001228 * set the state appropriately and accept the PLOGI.
1229 *
1230 * If we had also sent a PLOGI, and if the received PLOGI is from a
1231 * higher WWPN, we accept it, otherwise an LS_RJT is sent with reason
1232 * "command already in progress".
1233 *
1234 * XXX TBD: If the session was ready before, the PLOGI should result in
1235 * all outstanding exchanges being reset.
1236 */
1237 switch (rdata->rp_state) {
1238 case RPORT_ST_INIT:
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001239 FC_RPORT_DBG(rdata, "Received PLOGI in INIT state\n");
Robert Love42e9a922008-12-09 15:10:17 -08001240 break;
1241 case RPORT_ST_PLOGI:
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001242 FC_RPORT_DBG(rdata, "Received PLOGI in PLOGI state\n");
1243 if (rdata->ids.port_name < lport->wwpn) {
1244 mutex_unlock(&rdata->rp_mutex);
1245 rjt_data.reason = ELS_RJT_INPROG;
1246 rjt_data.explan = ELS_EXPL_NONE;
1247 goto reject;
1248 }
Robert Love42e9a922008-12-09 15:10:17 -08001249 break;
1250 case RPORT_ST_PRLI:
1251 case RPORT_ST_READY:
Joe Eykholt370c3bd2009-08-25 14:03:47 -07001252 case RPORT_ST_ADISC:
1253 FC_RPORT_DBG(rdata, "Received PLOGI in logged-in state %d "
1254 "- ignored for now\n", rdata->rp_state);
1255 /* XXX TBD - should reset */
Robert Love42e9a922008-12-09 15:10:17 -08001256 break;
Joe Eykholt14194052009-07-29 17:04:43 -07001257 case RPORT_ST_DELETE:
Robert Love42e9a922008-12-09 15:10:17 -08001258 default:
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001259 FC_RPORT_DBG(rdata, "Received PLOGI in unexpected state %d\n",
1260 rdata->rp_state);
1261 fc_frame_free(rx_fp);
1262 goto out;
Robert Love42e9a922008-12-09 15:10:17 -08001263 }
1264
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001265 /*
1266 * Get session payload size from incoming PLOGI.
1267 */
1268 rdata->maxframe_size = fc_plogi_get_maxframe(pl, lport->mfs);
1269 fc_frame_free(rx_fp);
Robert Love42e9a922008-12-09 15:10:17 -08001270
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001271 /*
1272 * Send LS_ACC. If this fails, the originator should retry.
1273 */
1274 sp = lport->tt.seq_start_next(sp);
1275 if (!sp)
1276 goto out;
1277 fp = fc_frame_alloc(lport, sizeof(*pl));
1278 if (!fp)
1279 goto out;
Robert Love42e9a922008-12-09 15:10:17 -08001280
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001281 fc_plogi_fill(lport, fp, ELS_LS_ACC);
1282 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1283 ep = fc_seq_exch(sp);
1284 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1285 FC_TYPE_ELS, f_ctl, 0);
1286 lport->tt.seq_send(lport, sp, fp);
1287 fc_rport_enter_prli(rdata);
1288out:
1289 mutex_unlock(&rdata->rp_mutex);
1290 return;
1291
1292reject:
1293 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1294 fc_frame_free(fp);
Robert Love42e9a922008-12-09 15:10:17 -08001295}
1296
1297/**
Robert Love34f42a02009-02-27 10:55:45 -08001298 * fc_rport_recv_prli_req() - Handle incoming Process Login (PRLI) request
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001299 * @rdata: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -08001300 * @sp: current sequence in the PRLI exchange
1301 * @fp: PRLI request frame
1302 *
1303 * Locking Note: The rport lock is exected to be held before calling
1304 * this function.
1305 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001306static void fc_rport_recv_prli_req(struct fc_rport_priv *rdata,
Robert Love42e9a922008-12-09 15:10:17 -08001307 struct fc_seq *sp, struct fc_frame *rx_fp)
1308{
Robert Love42e9a922008-12-09 15:10:17 -08001309 struct fc_lport *lport = rdata->local_port;
1310 struct fc_exch *ep;
1311 struct fc_frame *fp;
1312 struct fc_frame_header *fh;
1313 struct {
1314 struct fc_els_prli prli;
1315 struct fc_els_spp spp;
1316 } *pp;
1317 struct fc_els_spp *rspp; /* request service param page */
1318 struct fc_els_spp *spp; /* response spp */
1319 unsigned int len;
1320 unsigned int plen;
1321 enum fc_els_rjt_reason reason = ELS_RJT_UNAB;
1322 enum fc_els_rjt_explan explan = ELS_EXPL_NONE;
1323 enum fc_els_spp_resp resp;
1324 struct fc_seq_els_data rjt_data;
1325 u32 f_ctl;
1326 u32 fcp_parm;
1327 u32 roles = FC_RPORT_ROLE_UNKNOWN;
1328 rjt_data.fp = NULL;
1329
1330 fh = fc_frame_header_get(rx_fp);
1331
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001332 FC_RPORT_DBG(rdata, "Received PRLI request while in state %s\n",
1333 fc_rport_state(rdata));
Robert Love42e9a922008-12-09 15:10:17 -08001334
1335 switch (rdata->rp_state) {
1336 case RPORT_ST_PRLI:
Joe Eykholt3ac6f982009-08-25 14:03:26 -07001337 case RPORT_ST_RTV:
Robert Love42e9a922008-12-09 15:10:17 -08001338 case RPORT_ST_READY:
Joe Eykholt370c3bd2009-08-25 14:03:47 -07001339 case RPORT_ST_ADISC:
Robert Love42e9a922008-12-09 15:10:17 -08001340 reason = ELS_RJT_NONE;
1341 break;
1342 default:
Abhijeet Joglekarb4c6f542009-04-21 16:27:04 -07001343 fc_frame_free(rx_fp);
1344 return;
Robert Love42e9a922008-12-09 15:10:17 -08001345 break;
1346 }
1347 len = fr_len(rx_fp) - sizeof(*fh);
1348 pp = fc_frame_payload_get(rx_fp, sizeof(*pp));
1349 if (pp == NULL) {
1350 reason = ELS_RJT_PROT;
1351 explan = ELS_EXPL_INV_LEN;
1352 } else {
1353 plen = ntohs(pp->prli.prli_len);
1354 if ((plen % 4) != 0 || plen > len) {
1355 reason = ELS_RJT_PROT;
1356 explan = ELS_EXPL_INV_LEN;
1357 } else if (plen < len) {
1358 len = plen;
1359 }
1360 plen = pp->prli.prli_spp_len;
1361 if ((plen % 4) != 0 || plen < sizeof(*spp) ||
1362 plen > len || len < sizeof(*pp)) {
1363 reason = ELS_RJT_PROT;
1364 explan = ELS_EXPL_INV_LEN;
1365 }
1366 rspp = &pp->spp;
1367 }
1368 if (reason != ELS_RJT_NONE ||
1369 (fp = fc_frame_alloc(lport, len)) == NULL) {
1370 rjt_data.reason = reason;
1371 rjt_data.explan = explan;
1372 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1373 } else {
1374 sp = lport->tt.seq_start_next(sp);
1375 WARN_ON(!sp);
1376 pp = fc_frame_payload_get(fp, len);
1377 WARN_ON(!pp);
1378 memset(pp, 0, len);
1379 pp->prli.prli_cmd = ELS_LS_ACC;
1380 pp->prli.prli_spp_len = plen;
1381 pp->prli.prli_len = htons(len);
1382 len -= sizeof(struct fc_els_prli);
1383
Robert Love6bd054c2009-08-25 14:03:04 -07001384 /* reinitialize remote port roles */
1385 rdata->ids.roles = FC_RPORT_ROLE_UNKNOWN;
1386
Robert Love42e9a922008-12-09 15:10:17 -08001387 /*
1388 * Go through all the service parameter pages and build
1389 * response. If plen indicates longer SPP than standard,
1390 * use that. The entire response has been pre-cleared above.
1391 */
1392 spp = &pp->spp;
1393 while (len >= plen) {
1394 spp->spp_type = rspp->spp_type;
1395 spp->spp_type_ext = rspp->spp_type_ext;
1396 spp->spp_flags = rspp->spp_flags & FC_SPP_EST_IMG_PAIR;
1397 resp = FC_SPP_RESP_ACK;
1398 if (rspp->spp_flags & FC_SPP_RPA_VAL)
1399 resp = FC_SPP_RESP_NO_PA;
1400 switch (rspp->spp_type) {
1401 case 0: /* common to all FC-4 types */
1402 break;
1403 case FC_TYPE_FCP:
1404 fcp_parm = ntohl(rspp->spp_params);
Joe Eykholt85b58932009-10-21 16:26:45 -07001405 if (fcp_parm & FCP_SPPF_RETRY)
Robert Love42e9a922008-12-09 15:10:17 -08001406 rdata->flags |= FC_RP_FLAGS_RETRY;
Joe Eykholtf211fa52009-08-25 14:01:01 -07001407 rdata->supported_classes = FC_COS_CLASS3;
Robert Love42e9a922008-12-09 15:10:17 -08001408 if (fcp_parm & FCP_SPPF_INIT_FCN)
1409 roles |= FC_RPORT_ROLE_FCP_INITIATOR;
1410 if (fcp_parm & FCP_SPPF_TARG_FCN)
1411 roles |= FC_RPORT_ROLE_FCP_TARGET;
Joe Eykholtf211fa52009-08-25 14:01:01 -07001412 rdata->ids.roles = roles;
Robert Love42e9a922008-12-09 15:10:17 -08001413
1414 spp->spp_params =
1415 htonl(lport->service_params);
1416 break;
1417 default:
1418 resp = FC_SPP_RESP_INVL;
1419 break;
1420 }
1421 spp->spp_flags |= resp;
1422 len -= plen;
1423 rspp = (struct fc_els_spp *)((char *)rspp + plen);
1424 spp = (struct fc_els_spp *)((char *)spp + plen);
1425 }
1426
1427 /*
1428 * Send LS_ACC. If this fails, the originator should retry.
1429 */
1430 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
1431 f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
1432 ep = fc_seq_exch(sp);
1433 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
1434 FC_TYPE_ELS, f_ctl, 0);
1435 lport->tt.seq_send(lport, sp, fp);
1436
1437 /*
1438 * Get lock and re-check state.
1439 */
1440 switch (rdata->rp_state) {
1441 case RPORT_ST_PRLI:
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001442 fc_rport_enter_ready(rdata);
Robert Love42e9a922008-12-09 15:10:17 -08001443 break;
1444 case RPORT_ST_READY:
Joe Eykholt370c3bd2009-08-25 14:03:47 -07001445 case RPORT_ST_ADISC:
Robert Love42e9a922008-12-09 15:10:17 -08001446 break;
1447 default:
1448 break;
1449 }
1450 }
1451 fc_frame_free(rx_fp);
1452}
1453
1454/**
Robert Love34f42a02009-02-27 10:55:45 -08001455 * fc_rport_recv_prlo_req() - Handle incoming Process Logout (PRLO) request
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001456 * @rdata: private remote port data
Robert Love42e9a922008-12-09 15:10:17 -08001457 * @sp: current sequence in the PRLO exchange
1458 * @fp: PRLO request frame
1459 *
1460 * Locking Note: The rport lock is exected to be held before calling
1461 * this function.
1462 */
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001463static void fc_rport_recv_prlo_req(struct fc_rport_priv *rdata,
1464 struct fc_seq *sp,
Robert Love42e9a922008-12-09 15:10:17 -08001465 struct fc_frame *fp)
1466{
Robert Love42e9a922008-12-09 15:10:17 -08001467 struct fc_lport *lport = rdata->local_port;
1468
1469 struct fc_frame_header *fh;
1470 struct fc_seq_els_data rjt_data;
1471
1472 fh = fc_frame_header_get(fp);
1473
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001474 FC_RPORT_DBG(rdata, "Received PRLO request while in state %s\n",
1475 fc_rport_state(rdata));
Robert Love42e9a922008-12-09 15:10:17 -08001476
1477 rjt_data.fp = NULL;
1478 rjt_data.reason = ELS_RJT_UNAB;
1479 rjt_data.explan = ELS_EXPL_NONE;
1480 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
1481 fc_frame_free(fp);
1482}
1483
1484/**
Robert Love34f42a02009-02-27 10:55:45 -08001485 * fc_rport_recv_logo_req() - Handle incoming Logout (LOGO) request
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001486 * @lport: local port.
Robert Love42e9a922008-12-09 15:10:17 -08001487 * @sp: current sequence in the LOGO exchange
1488 * @fp: LOGO request frame
1489 *
1490 * Locking Note: The rport lock is exected to be held before calling
1491 * this function.
1492 */
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001493static void fc_rport_recv_logo_req(struct fc_lport *lport,
Joe Eykholt9fb9d322009-08-25 14:00:50 -07001494 struct fc_seq *sp,
Robert Love42e9a922008-12-09 15:10:17 -08001495 struct fc_frame *fp)
1496{
1497 struct fc_frame_header *fh;
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001498 struct fc_rport_priv *rdata;
1499 u32 sid;
Robert Love42e9a922008-12-09 15:10:17 -08001500
Joe Eykholtfeab4ae2009-08-25 14:03:36 -07001501 lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
1502
Robert Love42e9a922008-12-09 15:10:17 -08001503 fh = fc_frame_header_get(fp);
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001504 sid = ntoh24(fh->fh_s_id);
Robert Love42e9a922008-12-09 15:10:17 -08001505
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001506 mutex_lock(&lport->disc.disc_mutex);
1507 rdata = lport->tt.rport_lookup(lport, sid);
1508 if (rdata) {
1509 mutex_lock(&rdata->rp_mutex);
1510 FC_RPORT_DBG(rdata, "Received LOGO request while in state %s\n",
1511 fc_rport_state(rdata));
Joe Eykholtfeab4ae2009-08-25 14:03:36 -07001512
1513 /*
1514 * If the remote port was created due to discovery,
1515 * log back in. It may have seen a stale RSCN about us.
1516 */
1517 if (rdata->rp_state != RPORT_ST_DELETE && rdata->disc_id)
1518 fc_rport_enter_plogi(rdata);
1519 else
1520 fc_rport_enter_delete(rdata, RPORT_EV_LOGO);
Joe Eykholt83fe6a92009-08-25 14:03:31 -07001521 mutex_unlock(&rdata->rp_mutex);
1522 } else
1523 FC_RPORT_ID_DBG(lport, sid,
1524 "Received LOGO from non-logged-in port\n");
1525 mutex_unlock(&lport->disc.disc_mutex);
Robert Love42e9a922008-12-09 15:10:17 -08001526 fc_frame_free(fp);
1527}
1528
1529static void fc_rport_flush_queue(void)
1530{
1531 flush_workqueue(rport_event_queue);
1532}
1533
Robert Love42e9a922008-12-09 15:10:17 -08001534int fc_rport_init(struct fc_lport *lport)
1535{
Joe Eykholt8025b5d2009-08-25 14:02:06 -07001536 if (!lport->tt.rport_lookup)
1537 lport->tt.rport_lookup = fc_rport_lookup;
1538
Robert Love5101ff92009-02-27 10:55:18 -08001539 if (!lport->tt.rport_create)
Joe Eykholt9e9d0452009-08-25 14:01:18 -07001540 lport->tt.rport_create = fc_rport_create;
Robert Love5101ff92009-02-27 10:55:18 -08001541
Robert Love42e9a922008-12-09 15:10:17 -08001542 if (!lport->tt.rport_login)
1543 lport->tt.rport_login = fc_rport_login;
1544
1545 if (!lport->tt.rport_logoff)
1546 lport->tt.rport_logoff = fc_rport_logoff;
1547
1548 if (!lport->tt.rport_recv_req)
1549 lport->tt.rport_recv_req = fc_rport_recv_req;
1550
1551 if (!lport->tt.rport_flush_queue)
1552 lport->tt.rport_flush_queue = fc_rport_flush_queue;
1553
Joe Eykholtf211fa52009-08-25 14:01:01 -07001554 if (!lport->tt.rport_destroy)
1555 lport->tt.rport_destroy = fc_rport_destroy;
1556
Robert Love42e9a922008-12-09 15:10:17 -08001557 return 0;
1558}
1559EXPORT_SYMBOL(fc_rport_init);
1560
Randy Dunlapb0d428a2009-04-27 21:49:31 -07001561int fc_setup_rport(void)
Robert Love42e9a922008-12-09 15:10:17 -08001562{
1563 rport_event_queue = create_singlethread_workqueue("fc_rport_eq");
1564 if (!rport_event_queue)
1565 return -ENOMEM;
1566 return 0;
1567}
Robert Love42e9a922008-12-09 15:10:17 -08001568
Randy Dunlapb0d428a2009-04-27 21:49:31 -07001569void fc_destroy_rport(void)
Robert Love42e9a922008-12-09 15:10:17 -08001570{
1571 destroy_workqueue(rport_event_queue);
1572}
Robert Love42e9a922008-12-09 15:10:17 -08001573
1574void fc_rport_terminate_io(struct fc_rport *rport)
1575{
Joe Eykholtab28f1f2009-08-25 14:00:34 -07001576 struct fc_rport_libfc_priv *rp = rport->dd_data;
1577 struct fc_lport *lport = rp->local_port;
Robert Love42e9a922008-12-09 15:10:17 -08001578
Abhijeet Joglekar1f6ff362009-02-27 10:54:35 -08001579 lport->tt.exch_mgr_reset(lport, 0, rport->port_id);
1580 lport->tt.exch_mgr_reset(lport, rport->port_id, 0);
Robert Love42e9a922008-12-09 15:10:17 -08001581}
1582EXPORT_SYMBOL(fc_rport_terminate_io);