blob: e6ea4f11953074ff364dfc26042c5d59ca063ca4 [file] [log] [blame]
Robert Love42e9a922008-12-09 15:10:17 -08001/*
2 * Copyright(c) 2007 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 * PORT LOCKING NOTES
22 *
23 * These comments only apply to the 'port code' which consists of the lport,
24 * disc and rport blocks.
25 *
26 * MOTIVATION
27 *
28 * The lport, disc and rport blocks all have mutexes that are used to protect
29 * those objects. The main motivation for these locks is to prevent from
30 * having an lport reset just before we send a frame. In that scenario the
31 * lport's FID would get set to zero and then we'd send a frame with an
32 * invalid SID. We also need to ensure that states don't change unexpectedly
33 * while processing another state.
34 *
35 * HEIRARCHY
36 *
37 * The following heirarchy defines the locking rules. A greater lock
38 * may be held before acquiring a lesser lock, but a lesser lock should never
39 * be held while attempting to acquire a greater lock. Here is the heirarchy-
40 *
41 * lport > disc, lport > rport, disc > rport
42 *
43 * CALLBACKS
44 *
45 * The callbacks cause complications with this scheme. There is a callback
46 * from the rport (to either lport or disc) and a callback from disc
47 * (to the lport).
48 *
49 * As rports exit the rport state machine a callback is made to the owner of
50 * the rport to notify success or failure. Since the callback is likely to
51 * cause the lport or disc to grab its lock we cannot hold the rport lock
52 * while making the callback. To ensure that the rport is not free'd while
53 * processing the callback the rport callbacks are serialized through a
54 * single-threaded workqueue. An rport would never be free'd while in a
55 * callback handler becuase no other rport work in this queue can be executed
56 * at the same time.
57 *
58 * When discovery succeeds or fails a callback is made to the lport as
59 * notification. Currently, succesful discovery causes the lport to take no
60 * action. A failure will cause the lport to reset. There is likely a circular
61 * locking problem with this implementation.
62 */
63
64/*
65 * LPORT LOCKING
66 *
67 * The critical sections protected by the lport's mutex are quite broad and
68 * may be improved upon in the future. The lport code and its locking doesn't
69 * influence the I/O path, so excessive locking doesn't penalize I/O
70 * performance.
71 *
72 * The strategy is to lock whenever processing a request or response. Note
73 * that every _enter_* function corresponds to a state change. They generally
74 * change the lports state and then send a request out on the wire. We lock
75 * before calling any of these functions to protect that state change. This
76 * means that the entry points into the lport block manage the locks while
77 * the state machine can transition between states (i.e. _enter_* functions)
78 * while always staying protected.
79 *
80 * When handling responses we also hold the lport mutex broadly. When the
81 * lport receives the response frame it locks the mutex and then calls the
82 * appropriate handler for the particuar response. Generally a response will
83 * trigger a state change and so the lock must already be held.
84 *
85 * Retries also have to consider the locking. The retries occur from a work
86 * context and the work function will lock the lport and then retry the state
87 * (i.e. _enter_* function).
88 */
89
90#include <linux/timer.h>
91#include <asm/unaligned.h>
92
93#include <scsi/fc/fc_gs.h>
94
95#include <scsi/libfc.h>
96#include <scsi/fc_encode.h>
97
98/* Fabric IDs to use for point-to-point mode, chosen on whims. */
99#define FC_LOCAL_PTP_FID_LO 0x010101
100#define FC_LOCAL_PTP_FID_HI 0x010102
101
102#define DNS_DELAY 3 /* Discovery delay after RSCN (in seconds)*/
103
104static int fc_lport_debug;
105
106#define FC_DEBUG_LPORT(fmt...) \
107 do { \
108 if (fc_lport_debug) \
109 FC_DBG(fmt); \
110 } while (0)
111
112static void fc_lport_error(struct fc_lport *, struct fc_frame *);
113
114static void fc_lport_enter_reset(struct fc_lport *);
115static void fc_lport_enter_flogi(struct fc_lport *);
116static void fc_lport_enter_dns(struct fc_lport *);
117static void fc_lport_enter_rpn_id(struct fc_lport *);
118static void fc_lport_enter_rft_id(struct fc_lport *);
119static void fc_lport_enter_scr(struct fc_lport *);
120static void fc_lport_enter_ready(struct fc_lport *);
121static void fc_lport_enter_logo(struct fc_lport *);
122
123static const char *fc_lport_state_names[] = {
124 [LPORT_ST_NONE] = "none",
125 [LPORT_ST_FLOGI] = "FLOGI",
126 [LPORT_ST_DNS] = "dNS",
127 [LPORT_ST_RPN_ID] = "RPN_ID",
128 [LPORT_ST_RFT_ID] = "RFT_ID",
129 [LPORT_ST_SCR] = "SCR",
130 [LPORT_ST_READY] = "Ready",
131 [LPORT_ST_LOGO] = "LOGO",
132 [LPORT_ST_RESET] = "reset",
133};
134
135static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
136{
137 fc_frame_free(fp);
138 return 0;
139}
140
141/**
142 * fc_lport_rport_callback - Event handler for rport events
143 * @lport: The lport which is receiving the event
144 * @rport: The rport which the event has occured on
145 * @event: The event that occured
146 *
147 * Locking Note: The rport lock should not be held when calling
148 * this function.
149 */
150static void fc_lport_rport_callback(struct fc_lport *lport,
151 struct fc_rport *rport,
152 enum fc_rport_event event)
153{
154 FC_DEBUG_LPORT("Received a %d event for port (%6x)\n", event,
155 rport->port_id);
156
157 switch (event) {
158 case RPORT_EV_CREATED:
159 if (rport->port_id == FC_FID_DIR_SERV) {
160 mutex_lock(&lport->lp_mutex);
161 if (lport->state == LPORT_ST_DNS) {
162 lport->dns_rp = rport;
163 fc_lport_enter_rpn_id(lport);
164 } else {
165 FC_DEBUG_LPORT("Received an CREATED event on "
166 "port (%6x) for the directory "
167 "server, but the lport is not "
168 "in the DNS state, it's in the "
169 "%d state", rport->port_id,
170 lport->state);
171 lport->tt.rport_logoff(rport);
172 }
173 mutex_unlock(&lport->lp_mutex);
174 } else
175 FC_DEBUG_LPORT("Received an event for port (%6x) "
176 "which is not the directory server\n",
177 rport->port_id);
178 break;
179 case RPORT_EV_LOGO:
180 case RPORT_EV_FAILED:
181 case RPORT_EV_STOP:
182 if (rport->port_id == FC_FID_DIR_SERV) {
183 mutex_lock(&lport->lp_mutex);
184 lport->dns_rp = NULL;
185 mutex_unlock(&lport->lp_mutex);
186
187 } else
188 FC_DEBUG_LPORT("Received an event for port (%6x) "
189 "which is not the directory server\n",
190 rport->port_id);
191 break;
192 case RPORT_EV_NONE:
193 break;
194 }
195}
196
197/**
198 * fc_lport_state - Return a string which represents the lport's state
199 * @lport: The lport whose state is to converted to a string
200 */
201static const char *fc_lport_state(struct fc_lport *lport)
202{
203 const char *cp;
204
205 cp = fc_lport_state_names[lport->state];
206 if (!cp)
207 cp = "unknown";
208 return cp;
209}
210
211/**
212 * fc_lport_ptp_setup - Create an rport for point-to-point mode
213 * @lport: The lport to attach the ptp rport to
214 * @fid: The FID of the ptp rport
215 * @remote_wwpn: The WWPN of the ptp rport
216 * @remote_wwnn: The WWNN of the ptp rport
217 */
218static void fc_lport_ptp_setup(struct fc_lport *lport,
219 u32 remote_fid, u64 remote_wwpn,
220 u64 remote_wwnn)
221{
222 struct fc_disc_port dp;
223
224 dp.lp = lport;
225 dp.ids.port_id = remote_fid;
226 dp.ids.port_name = remote_wwpn;
227 dp.ids.node_name = remote_wwnn;
228 dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
229
230 if (lport->ptp_rp) {
231 lport->tt.rport_logoff(lport->ptp_rp);
232 lport->ptp_rp = NULL;
233 }
234
235 lport->ptp_rp = fc_rport_rogue_create(&dp);
236
237 lport->tt.rport_login(lport->ptp_rp);
238
239 fc_lport_enter_ready(lport);
240}
241
242void fc_get_host_port_type(struct Scsi_Host *shost)
243{
244 /* TODO - currently just NPORT */
245 fc_host_port_type(shost) = FC_PORTTYPE_NPORT;
246}
247EXPORT_SYMBOL(fc_get_host_port_type);
248
249void fc_get_host_port_state(struct Scsi_Host *shost)
250{
251 struct fc_lport *lp = shost_priv(shost);
252
Vasu Devbc0e17f2009-02-27 10:54:57 -0800253 if (lp->link_up)
Robert Love42e9a922008-12-09 15:10:17 -0800254 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
255 else
256 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
257}
258EXPORT_SYMBOL(fc_get_host_port_state);
259
260void fc_get_host_speed(struct Scsi_Host *shost)
261{
262 struct fc_lport *lport = shost_priv(shost);
263
264 fc_host_speed(shost) = lport->link_speed;
265}
266EXPORT_SYMBOL(fc_get_host_speed);
267
268struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
269{
270 int i;
271 struct fc_host_statistics *fcoe_stats;
272 struct fc_lport *lp = shost_priv(shost);
273 struct timespec v0, v1;
274
275 fcoe_stats = &lp->host_stats;
276 memset(fcoe_stats, 0, sizeof(struct fc_host_statistics));
277
278 jiffies_to_timespec(jiffies, &v0);
279 jiffies_to_timespec(lp->boot_time, &v1);
280 fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec);
281
282 for_each_online_cpu(i) {
283 struct fcoe_dev_stats *stats = lp->dev_stats[i];
284 if (stats == NULL)
285 continue;
286 fcoe_stats->tx_frames += stats->TxFrames;
287 fcoe_stats->tx_words += stats->TxWords;
288 fcoe_stats->rx_frames += stats->RxFrames;
289 fcoe_stats->rx_words += stats->RxWords;
290 fcoe_stats->error_frames += stats->ErrorFrames;
291 fcoe_stats->invalid_crc_count += stats->InvalidCRCCount;
292 fcoe_stats->fcp_input_requests += stats->InputRequests;
293 fcoe_stats->fcp_output_requests += stats->OutputRequests;
294 fcoe_stats->fcp_control_requests += stats->ControlRequests;
295 fcoe_stats->fcp_input_megabytes += stats->InputMegabytes;
296 fcoe_stats->fcp_output_megabytes += stats->OutputMegabytes;
297 fcoe_stats->link_failure_count += stats->LinkFailureCount;
298 }
299 fcoe_stats->lip_count = -1;
300 fcoe_stats->nos_count = -1;
301 fcoe_stats->loss_of_sync_count = -1;
302 fcoe_stats->loss_of_signal_count = -1;
303 fcoe_stats->prim_seq_protocol_err_count = -1;
304 fcoe_stats->dumped_frames = -1;
305 return fcoe_stats;
306}
307EXPORT_SYMBOL(fc_get_host_stats);
308
309/*
310 * Fill in FLOGI command for request.
311 */
312static void
313fc_lport_flogi_fill(struct fc_lport *lport, struct fc_els_flogi *flogi,
314 unsigned int op)
315{
316 struct fc_els_csp *sp;
317 struct fc_els_cssp *cp;
318
319 memset(flogi, 0, sizeof(*flogi));
320 flogi->fl_cmd = (u8) op;
321 put_unaligned_be64(lport->wwpn, &flogi->fl_wwpn);
322 put_unaligned_be64(lport->wwnn, &flogi->fl_wwnn);
323 sp = &flogi->fl_csp;
324 sp->sp_hi_ver = 0x20;
325 sp->sp_lo_ver = 0x20;
326 sp->sp_bb_cred = htons(10); /* this gets set by gateway */
327 sp->sp_bb_data = htons((u16) lport->mfs);
328 cp = &flogi->fl_cssp[3 - 1]; /* class 3 parameters */
329 cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ);
330 if (op != ELS_FLOGI) {
331 sp->sp_features = htons(FC_SP_FT_CIRO);
332 sp->sp_tot_seq = htons(255); /* seq. we accept */
333 sp->sp_rel_off = htons(0x1f);
334 sp->sp_e_d_tov = htonl(lport->e_d_tov);
335
336 cp->cp_rdfs = htons((u16) lport->mfs);
337 cp->cp_con_seq = htons(255);
338 cp->cp_open_seq = 1;
339 }
340}
341
342/*
343 * Add a supported FC-4 type.
344 */
345static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
346{
347 __be32 *mp;
348
349 mp = &lport->fcts.ff_type_map[type / FC_NS_BPW];
350 *mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW));
351}
352
353/**
354 * fc_lport_recv_rlir_req - Handle received Registered Link Incident Report.
355 * @lport: Fibre Channel local port recieving the RLIR
356 * @sp: current sequence in the RLIR exchange
357 * @fp: RLIR request frame
358 *
359 * Locking Note: The lport lock is exected to be held before calling
360 * this function.
361 */
362static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp,
363 struct fc_lport *lport)
364{
365 FC_DEBUG_LPORT("Received RLIR request while in state %s\n",
366 fc_lport_state(lport));
367
368 lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
369 fc_frame_free(fp);
370}
371
372/**
373 * fc_lport_recv_echo_req - Handle received ECHO request
374 * @lport: Fibre Channel local port recieving the ECHO
375 * @sp: current sequence in the ECHO exchange
376 * @fp: ECHO request frame
377 *
378 * Locking Note: The lport lock is exected to be held before calling
379 * this function.
380 */
381static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp,
382 struct fc_lport *lport)
383{
384 struct fc_frame *fp;
385 struct fc_exch *ep = fc_seq_exch(sp);
386 unsigned int len;
387 void *pp;
388 void *dp;
389 u32 f_ctl;
390
391 FC_DEBUG_LPORT("Received RLIR request while in state %s\n",
392 fc_lport_state(lport));
393
394 len = fr_len(in_fp) - sizeof(struct fc_frame_header);
395 pp = fc_frame_payload_get(in_fp, len);
396
397 if (len < sizeof(__be32))
398 len = sizeof(__be32);
399
400 fp = fc_frame_alloc(lport, len);
401 if (fp) {
402 dp = fc_frame_payload_get(fp, len);
403 memcpy(dp, pp, len);
404 *((u32 *)dp) = htonl(ELS_LS_ACC << 24);
405 sp = lport->tt.seq_start_next(sp);
406 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
407 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
408 FC_TYPE_ELS, f_ctl, 0);
409 lport->tt.seq_send(lport, sp, fp);
410 }
411 fc_frame_free(in_fp);
412}
413
414/**
415 * fc_lport_recv_echo_req - Handle received Request Node ID data request
416 * @lport: Fibre Channel local port recieving the RNID
417 * @sp: current sequence in the RNID exchange
418 * @fp: RNID request frame
419 *
420 * Locking Note: The lport lock is exected to be held before calling
421 * this function.
422 */
423static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp,
424 struct fc_lport *lport)
425{
426 struct fc_frame *fp;
427 struct fc_exch *ep = fc_seq_exch(sp);
428 struct fc_els_rnid *req;
429 struct {
430 struct fc_els_rnid_resp rnid;
431 struct fc_els_rnid_cid cid;
432 struct fc_els_rnid_gen gen;
433 } *rp;
434 struct fc_seq_els_data rjt_data;
435 u8 fmt;
436 size_t len;
437 u32 f_ctl;
438
439 FC_DEBUG_LPORT("Received RNID request while in state %s\n",
440 fc_lport_state(lport));
441
442 req = fc_frame_payload_get(in_fp, sizeof(*req));
443 if (!req) {
444 rjt_data.fp = NULL;
445 rjt_data.reason = ELS_RJT_LOGIC;
446 rjt_data.explan = ELS_EXPL_NONE;
447 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
448 } else {
449 fmt = req->rnid_fmt;
450 len = sizeof(*rp);
451 if (fmt != ELS_RNIDF_GEN ||
452 ntohl(lport->rnid_gen.rnid_atype) == 0) {
453 fmt = ELS_RNIDF_NONE; /* nothing to provide */
454 len -= sizeof(rp->gen);
455 }
456 fp = fc_frame_alloc(lport, len);
457 if (fp) {
458 rp = fc_frame_payload_get(fp, len);
459 memset(rp, 0, len);
460 rp->rnid.rnid_cmd = ELS_LS_ACC;
461 rp->rnid.rnid_fmt = fmt;
462 rp->rnid.rnid_cid_len = sizeof(rp->cid);
463 rp->cid.rnid_wwpn = htonll(lport->wwpn);
464 rp->cid.rnid_wwnn = htonll(lport->wwnn);
465 if (fmt == ELS_RNIDF_GEN) {
466 rp->rnid.rnid_sid_len = sizeof(rp->gen);
467 memcpy(&rp->gen, &lport->rnid_gen,
468 sizeof(rp->gen));
469 }
470 sp = lport->tt.seq_start_next(sp);
471 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
472 f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
473 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
474 FC_TYPE_ELS, f_ctl, 0);
475 lport->tt.seq_send(lport, sp, fp);
476 }
477 }
478 fc_frame_free(in_fp);
479}
480
481/**
482 * fc_lport_recv_adisc_req - Handle received Address Discovery Request
483 * @lport: Fibre Channel local port recieving the ADISC
484 * @sp: current sequence in the ADISC exchange
485 * @fp: ADISC request frame
486 *
487 * Locking Note: The lport lock is expected to be held before calling
488 * this function.
489 */
490static void fc_lport_recv_adisc_req(struct fc_seq *sp, struct fc_frame *in_fp,
491 struct fc_lport *lport)
492{
493 struct fc_frame *fp;
494 struct fc_exch *ep = fc_seq_exch(sp);
495 struct fc_els_adisc *req, *rp;
496 struct fc_seq_els_data rjt_data;
497 size_t len;
498 u32 f_ctl;
499
500 FC_DEBUG_LPORT("Received ADISC request while in state %s\n",
501 fc_lport_state(lport));
502
503 req = fc_frame_payload_get(in_fp, sizeof(*req));
504 if (!req) {
505 rjt_data.fp = NULL;
506 rjt_data.reason = ELS_RJT_LOGIC;
507 rjt_data.explan = ELS_EXPL_NONE;
508 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data);
509 } else {
510 len = sizeof(*rp);
511 fp = fc_frame_alloc(lport, len);
512 if (fp) {
513 rp = fc_frame_payload_get(fp, len);
514 memset(rp, 0, len);
515 rp->adisc_cmd = ELS_LS_ACC;
516 rp->adisc_wwpn = htonll(lport->wwpn);
517 rp->adisc_wwnn = htonll(lport->wwnn);
518 hton24(rp->adisc_port_id,
519 fc_host_port_id(lport->host));
520 sp = lport->tt.seq_start_next(sp);
521 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ;
522 f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT;
523 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
524 FC_TYPE_ELS, f_ctl, 0);
525 lport->tt.seq_send(lport, sp, fp);
526 }
527 }
528 fc_frame_free(in_fp);
529}
530
531/**
532 * fc_lport_recv_logo_req - Handle received fabric LOGO request
533 * @lport: Fibre Channel local port recieving the LOGO
534 * @sp: current sequence in the LOGO exchange
535 * @fp: LOGO request frame
536 *
537 * Locking Note: The lport lock is exected to be held before calling
538 * this function.
539 */
540static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp,
541 struct fc_lport *lport)
542{
543 lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL);
544 fc_lport_enter_reset(lport);
545 fc_frame_free(fp);
546}
547
548/**
549 * fc_fabric_login - Start the lport state machine
550 * @lport: The lport that should log into the fabric
551 *
552 * Locking Note: This function should not be called
553 * with the lport lock held.
554 */
555int fc_fabric_login(struct fc_lport *lport)
556{
557 int rc = -1;
558
559 mutex_lock(&lport->lp_mutex);
560 if (lport->state == LPORT_ST_NONE) {
561 fc_lport_enter_reset(lport);
562 rc = 0;
563 }
564 mutex_unlock(&lport->lp_mutex);
565
566 return rc;
567}
568EXPORT_SYMBOL(fc_fabric_login);
569
570/**
571 * fc_linkup - Handler for transport linkup events
572 * @lport: The lport whose link is up
573 */
574void fc_linkup(struct fc_lport *lport)
575{
576 FC_DEBUG_LPORT("Link is up for port (%6x)\n",
577 fc_host_port_id(lport->host));
578
579 mutex_lock(&lport->lp_mutex);
Vasu Devbc0e17f2009-02-27 10:54:57 -0800580 if (!lport->link_up) {
581 lport->link_up = 1;
Robert Love42e9a922008-12-09 15:10:17 -0800582
583 if (lport->state == LPORT_ST_RESET)
584 fc_lport_enter_flogi(lport);
585 }
586 mutex_unlock(&lport->lp_mutex);
587}
588EXPORT_SYMBOL(fc_linkup);
589
590/**
591 * fc_linkdown - Handler for transport linkdown events
592 * @lport: The lport whose link is down
593 */
594void fc_linkdown(struct fc_lport *lport)
595{
596 mutex_lock(&lport->lp_mutex);
597 FC_DEBUG_LPORT("Link is down for port (%6x)\n",
598 fc_host_port_id(lport->host));
599
Vasu Devbc0e17f2009-02-27 10:54:57 -0800600 if (lport->link_up) {
601 lport->link_up = 0;
Robert Love42e9a922008-12-09 15:10:17 -0800602 fc_lport_enter_reset(lport);
603 lport->tt.fcp_cleanup(lport);
604 }
605 mutex_unlock(&lport->lp_mutex);
606}
607EXPORT_SYMBOL(fc_linkdown);
608
609/**
Robert Love42e9a922008-12-09 15:10:17 -0800610 * fc_fabric_logoff - Logout of the fabric
611 * @lport: fc_lport pointer to logoff the fabric
612 *
613 * Return value:
614 * 0 for success, -1 for failure
615 **/
616int fc_fabric_logoff(struct fc_lport *lport)
617{
618 lport->tt.disc_stop_final(lport);
619 mutex_lock(&lport->lp_mutex);
620 fc_lport_enter_logo(lport);
621 mutex_unlock(&lport->lp_mutex);
Steve Maf7db2c152009-02-27 10:55:13 -0800622 cancel_delayed_work_sync(&lport->retry_work);
Robert Love42e9a922008-12-09 15:10:17 -0800623 return 0;
624}
625EXPORT_SYMBOL(fc_fabric_logoff);
626
627/**
628 * fc_lport_destroy - unregister a fc_lport
629 * @lport: fc_lport pointer to unregister
630 *
631 * Return value:
632 * None
633 * Note:
634 * exit routine for fc_lport instance
635 * clean-up all the allocated memory
636 * and free up other system resources.
637 *
638 **/
639int fc_lport_destroy(struct fc_lport *lport)
640{
641 lport->tt.frame_send = fc_frame_drop;
642 lport->tt.fcp_abort_io(lport);
Abhijeet Joglekar1f6ff362009-02-27 10:54:35 -0800643 lport->tt.exch_mgr_reset(lport, 0, 0);
Robert Love42e9a922008-12-09 15:10:17 -0800644 return 0;
645}
646EXPORT_SYMBOL(fc_lport_destroy);
647
648/**
649 * fc_set_mfs - sets up the mfs for the corresponding fc_lport
650 * @lport: fc_lport pointer to unregister
651 * @mfs: the new mfs for fc_lport
652 *
653 * Set mfs for the given fc_lport to the new mfs.
654 *
655 * Return: 0 for success
656 *
657 **/
658int fc_set_mfs(struct fc_lport *lport, u32 mfs)
659{
660 unsigned int old_mfs;
661 int rc = -EINVAL;
662
663 mutex_lock(&lport->lp_mutex);
664
665 old_mfs = lport->mfs;
666
667 if (mfs >= FC_MIN_MAX_FRAME) {
668 mfs &= ~3;
669 if (mfs > FC_MAX_FRAME)
670 mfs = FC_MAX_FRAME;
671 mfs -= sizeof(struct fc_frame_header);
672 lport->mfs = mfs;
673 rc = 0;
674 }
675
676 if (!rc && mfs < old_mfs)
677 fc_lport_enter_reset(lport);
678
679 mutex_unlock(&lport->lp_mutex);
680
681 return rc;
682}
683EXPORT_SYMBOL(fc_set_mfs);
684
685/**
686 * fc_lport_disc_callback - Callback for discovery events
687 * @lport: FC local port
688 * @event: The discovery event
689 */
690void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event)
691{
692 switch (event) {
693 case DISC_EV_SUCCESS:
694 FC_DEBUG_LPORT("Got a SUCCESS event for port (%6x)\n",
695 fc_host_port_id(lport->host));
696 break;
697 case DISC_EV_FAILED:
698 FC_DEBUG_LPORT("Got a FAILED event for port (%6x)\n",
699 fc_host_port_id(lport->host));
700 mutex_lock(&lport->lp_mutex);
701 fc_lport_enter_reset(lport);
702 mutex_unlock(&lport->lp_mutex);
703 break;
704 case DISC_EV_NONE:
705 WARN_ON(1);
706 break;
707 }
708}
709
710/**
711 * fc_rport_enter_ready - Enter the ready state and start discovery
712 * @lport: Fibre Channel local port that is ready
713 *
714 * Locking Note: The lport lock is expected to be held before calling
715 * this routine.
716 */
717static void fc_lport_enter_ready(struct fc_lport *lport)
718{
719 FC_DEBUG_LPORT("Port (%6x) entered Ready from state %s\n",
720 fc_host_port_id(lport->host), fc_lport_state(lport));
721
722 fc_lport_state_enter(lport, LPORT_ST_READY);
723
724 lport->tt.disc_start(fc_lport_disc_callback, lport);
725}
726
727/**
728 * fc_lport_recv_flogi_req - Receive a FLOGI request
729 * @sp_in: The sequence the FLOGI is on
730 * @rx_fp: The frame the FLOGI is in
731 * @lport: The lport that recieved the request
732 *
733 * A received FLOGI request indicates a point-to-point connection.
734 * Accept it with the common service parameters indicating our N port.
735 * Set up to do a PLOGI if we have the higher-number WWPN.
736 *
737 * Locking Note: The lport lock is exected to be held before calling
738 * this function.
739 */
740static void fc_lport_recv_flogi_req(struct fc_seq *sp_in,
741 struct fc_frame *rx_fp,
742 struct fc_lport *lport)
743{
744 struct fc_frame *fp;
745 struct fc_frame_header *fh;
746 struct fc_seq *sp;
747 struct fc_exch *ep;
748 struct fc_els_flogi *flp;
749 struct fc_els_flogi *new_flp;
750 u64 remote_wwpn;
751 u32 remote_fid;
752 u32 local_fid;
753 u32 f_ctl;
754
755 FC_DEBUG_LPORT("Received FLOGI request while in state %s\n",
756 fc_lport_state(lport));
757
758 fh = fc_frame_header_get(rx_fp);
759 remote_fid = ntoh24(fh->fh_s_id);
760 flp = fc_frame_payload_get(rx_fp, sizeof(*flp));
761 if (!flp)
762 goto out;
763 remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
764 if (remote_wwpn == lport->wwpn) {
765 FC_DBG("FLOGI from port with same WWPN %llx "
766 "possible configuration error\n", remote_wwpn);
767 goto out;
768 }
769 FC_DBG("FLOGI from port WWPN %llx\n", remote_wwpn);
770
771 /*
772 * XXX what is the right thing to do for FIDs?
773 * The originator might expect our S_ID to be 0xfffffe.
774 * But if so, both of us could end up with the same FID.
775 */
776 local_fid = FC_LOCAL_PTP_FID_LO;
777 if (remote_wwpn < lport->wwpn) {
778 local_fid = FC_LOCAL_PTP_FID_HI;
779 if (!remote_fid || remote_fid == local_fid)
780 remote_fid = FC_LOCAL_PTP_FID_LO;
781 } else if (!remote_fid) {
782 remote_fid = FC_LOCAL_PTP_FID_HI;
783 }
784
785 fc_host_port_id(lport->host) = local_fid;
786
787 fp = fc_frame_alloc(lport, sizeof(*flp));
788 if (fp) {
789 sp = lport->tt.seq_start_next(fr_seq(rx_fp));
790 new_flp = fc_frame_payload_get(fp, sizeof(*flp));
791 fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI);
792 new_flp->fl_cmd = (u8) ELS_LS_ACC;
793
794 /*
795 * Send the response. If this fails, the originator should
796 * repeat the sequence.
797 */
798 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ;
799 ep = fc_seq_exch(sp);
800 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid,
801 FC_TYPE_ELS, f_ctl, 0);
802 lport->tt.seq_send(lport, sp, fp);
803
804 } else {
805 fc_lport_error(lport, fp);
806 }
807 fc_lport_ptp_setup(lport, remote_fid, remote_wwpn,
808 get_unaligned_be64(&flp->fl_wwnn));
809
810 lport->tt.disc_start(fc_lport_disc_callback, lport);
811
812out:
813 sp = fr_seq(rx_fp);
814 fc_frame_free(rx_fp);
815}
816
817/**
818 * fc_lport_recv_req - The generic lport request handler
819 * @lport: The lport that received the request
820 * @sp: The sequence the request is on
821 * @fp: The frame the request is in
822 *
823 * This function will see if the lport handles the request or
824 * if an rport should handle the request.
825 *
826 * Locking Note: This function should not be called with the lport
827 * lock held becuase it will grab the lock.
828 */
829static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp,
830 struct fc_frame *fp)
831{
832 struct fc_frame_header *fh = fc_frame_header_get(fp);
833 void (*recv) (struct fc_seq *, struct fc_frame *, struct fc_lport *);
834 struct fc_rport *rport;
835 u32 s_id;
836 u32 d_id;
837 struct fc_seq_els_data rjt_data;
838
839 mutex_lock(&lport->lp_mutex);
840
841 /*
842 * Handle special ELS cases like FLOGI, LOGO, and
843 * RSCN here. These don't require a session.
844 * Even if we had a session, it might not be ready.
845 */
846 if (fh->fh_type == FC_TYPE_ELS && fh->fh_r_ctl == FC_RCTL_ELS_REQ) {
847 /*
848 * Check opcode.
849 */
850 recv = NULL;
851 switch (fc_frame_payload_op(fp)) {
852 case ELS_FLOGI:
853 recv = fc_lport_recv_flogi_req;
854 break;
855 case ELS_LOGO:
856 fh = fc_frame_header_get(fp);
857 if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI)
858 recv = fc_lport_recv_logo_req;
859 break;
860 case ELS_RSCN:
861 recv = lport->tt.disc_recv_req;
862 break;
863 case ELS_ECHO:
864 recv = fc_lport_recv_echo_req;
865 break;
866 case ELS_RLIR:
867 recv = fc_lport_recv_rlir_req;
868 break;
869 case ELS_RNID:
870 recv = fc_lport_recv_rnid_req;
871 break;
872 case ELS_ADISC:
873 recv = fc_lport_recv_adisc_req;
874 break;
875 }
876
877 if (recv)
878 recv(sp, fp, lport);
879 else {
880 /*
881 * Find session.
882 * If this is a new incoming PLOGI, we won't find it.
883 */
884 s_id = ntoh24(fh->fh_s_id);
885 d_id = ntoh24(fh->fh_d_id);
886
887 rport = lport->tt.rport_lookup(lport, s_id);
888 if (rport)
889 lport->tt.rport_recv_req(sp, fp, rport);
890 else {
891 rjt_data.fp = NULL;
892 rjt_data.reason = ELS_RJT_UNAB;
893 rjt_data.explan = ELS_EXPL_NONE;
894 lport->tt.seq_els_rsp_send(sp,
895 ELS_LS_RJT,
896 &rjt_data);
897 fc_frame_free(fp);
898 }
899 }
900 } else {
901 FC_DBG("dropping invalid frame (eof %x)\n", fr_eof(fp));
902 fc_frame_free(fp);
903 }
904 mutex_unlock(&lport->lp_mutex);
905
906 /*
907 * The common exch_done for all request may not be good
908 * if any request requires longer hold on exhange. XXX
909 */
910 lport->tt.exch_done(sp);
911}
912
913/**
914 * fc_lport_reset - Reset an lport
915 * @lport: The lport which should be reset
916 *
917 * Locking Note: This functions should not be called with the
918 * lport lock held.
919 */
920int fc_lport_reset(struct fc_lport *lport)
921{
Steve Maf7db2c152009-02-27 10:55:13 -0800922 cancel_delayed_work_sync(&lport->retry_work);
Robert Love42e9a922008-12-09 15:10:17 -0800923 mutex_lock(&lport->lp_mutex);
924 fc_lport_enter_reset(lport);
925 mutex_unlock(&lport->lp_mutex);
926 return 0;
927}
928EXPORT_SYMBOL(fc_lport_reset);
929
930/**
931 * fc_rport_enter_reset - Reset the local port
932 * @lport: Fibre Channel local port to be reset
933 *
934 * Locking Note: The lport lock is expected to be held before calling
935 * this routine.
936 */
937static void fc_lport_enter_reset(struct fc_lport *lport)
938{
939 FC_DEBUG_LPORT("Port (%6x) entered RESET state from %s state\n",
940 fc_host_port_id(lport->host), fc_lport_state(lport));
941
942 fc_lport_state_enter(lport, LPORT_ST_RESET);
943
944 if (lport->dns_rp)
945 lport->tt.rport_logoff(lport->dns_rp);
946
947 if (lport->ptp_rp) {
948 lport->tt.rport_logoff(lport->ptp_rp);
949 lport->ptp_rp = NULL;
950 }
951
952 lport->tt.disc_stop(lport);
953
Abhijeet Joglekar1f6ff362009-02-27 10:54:35 -0800954 lport->tt.exch_mgr_reset(lport, 0, 0);
Robert Love42e9a922008-12-09 15:10:17 -0800955 fc_host_fabric_name(lport->host) = 0;
956 fc_host_port_id(lport->host) = 0;
957
Vasu Devbc0e17f2009-02-27 10:54:57 -0800958 if (lport->link_up)
Robert Love42e9a922008-12-09 15:10:17 -0800959 fc_lport_enter_flogi(lport);
960}
961
962/**
963 * fc_lport_error - Handler for any errors
964 * @lport: The fc_lport object
965 * @fp: The frame pointer
966 *
967 * If the error was caused by a resource allocation failure
968 * then wait for half a second and retry, otherwise retry
969 * after the e_d_tov time.
970 */
971static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
972{
973 unsigned long delay = 0;
974 FC_DEBUG_LPORT("Error %ld in state %s, retries %d\n",
975 PTR_ERR(fp), fc_lport_state(lport),
976 lport->retry_count);
977
978 if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) {
979 /*
980 * Memory allocation failure, or the exchange timed out.
981 * Retry after delay
982 */
983 if (lport->retry_count < lport->max_retry_count) {
984 lport->retry_count++;
985 if (!fp)
986 delay = msecs_to_jiffies(500);
987 else
988 delay = msecs_to_jiffies(lport->e_d_tov);
989
990 schedule_delayed_work(&lport->retry_work, delay);
991 } else {
992 switch (lport->state) {
993 case LPORT_ST_NONE:
994 case LPORT_ST_READY:
995 case LPORT_ST_RESET:
996 case LPORT_ST_RPN_ID:
997 case LPORT_ST_RFT_ID:
998 case LPORT_ST_SCR:
999 case LPORT_ST_DNS:
1000 case LPORT_ST_FLOGI:
1001 case LPORT_ST_LOGO:
1002 fc_lport_enter_reset(lport);
1003 break;
1004 }
1005 }
1006 }
1007}
1008
1009/**
1010 * fc_lport_rft_id_resp - Handle response to Register Fibre
1011 * Channel Types by ID (RPN_ID) request
1012 * @sp: current sequence in RPN_ID exchange
1013 * @fp: response frame
1014 * @lp_arg: Fibre Channel host port instance
1015 *
1016 * Locking Note: This function will be called without the lport lock
1017 * held, but it will lock, call an _enter_* function or fc_lport_error
1018 * and then unlock the lport.
1019 */
1020static void fc_lport_rft_id_resp(struct fc_seq *sp, struct fc_frame *fp,
1021 void *lp_arg)
1022{
1023 struct fc_lport *lport = lp_arg;
1024 struct fc_frame_header *fh;
1025 struct fc_ct_hdr *ct;
1026
1027 if (fp == ERR_PTR(-FC_EX_CLOSED))
1028 return;
1029
1030 mutex_lock(&lport->lp_mutex);
1031
1032 FC_DEBUG_LPORT("Received a RFT_ID response\n");
1033
1034 if (lport->state != LPORT_ST_RFT_ID) {
1035 FC_DBG("Received a RFT_ID response, but in state %s\n",
1036 fc_lport_state(lport));
1037 goto out;
1038 }
1039
1040 if (IS_ERR(fp)) {
1041 fc_lport_error(lport, fp);
1042 goto err;
1043 }
1044
1045 fh = fc_frame_header_get(fp);
1046 ct = fc_frame_payload_get(fp, sizeof(*ct));
1047
1048 if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1049 ct->ct_fs_type == FC_FST_DIR &&
1050 ct->ct_fs_subtype == FC_NS_SUBTYPE &&
1051 ntohs(ct->ct_cmd) == FC_FS_ACC)
1052 fc_lport_enter_scr(lport);
1053 else
1054 fc_lport_error(lport, fp);
1055out:
1056 fc_frame_free(fp);
1057err:
1058 mutex_unlock(&lport->lp_mutex);
1059}
1060
1061/**
1062 * fc_lport_rpn_id_resp - Handle response to Register Port
1063 * Name by ID (RPN_ID) request
1064 * @sp: current sequence in RPN_ID exchange
1065 * @fp: response frame
1066 * @lp_arg: Fibre Channel host port instance
1067 *
1068 * Locking Note: This function will be called without the lport lock
1069 * held, but it will lock, call an _enter_* function or fc_lport_error
1070 * and then unlock the lport.
1071 */
1072static void fc_lport_rpn_id_resp(struct fc_seq *sp, struct fc_frame *fp,
1073 void *lp_arg)
1074{
1075 struct fc_lport *lport = lp_arg;
1076 struct fc_frame_header *fh;
1077 struct fc_ct_hdr *ct;
1078
1079 if (fp == ERR_PTR(-FC_EX_CLOSED))
1080 return;
1081
1082 mutex_lock(&lport->lp_mutex);
1083
1084 FC_DEBUG_LPORT("Received a RPN_ID response\n");
1085
1086 if (lport->state != LPORT_ST_RPN_ID) {
1087 FC_DBG("Received a RPN_ID response, but in state %s\n",
1088 fc_lport_state(lport));
1089 goto out;
1090 }
1091
1092 if (IS_ERR(fp)) {
1093 fc_lport_error(lport, fp);
1094 goto err;
1095 }
1096
1097 fh = fc_frame_header_get(fp);
1098 ct = fc_frame_payload_get(fp, sizeof(*ct));
1099 if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1100 ct->ct_fs_type == FC_FST_DIR &&
1101 ct->ct_fs_subtype == FC_NS_SUBTYPE &&
1102 ntohs(ct->ct_cmd) == FC_FS_ACC)
1103 fc_lport_enter_rft_id(lport);
1104 else
1105 fc_lport_error(lport, fp);
1106
1107out:
1108 fc_frame_free(fp);
1109err:
1110 mutex_unlock(&lport->lp_mutex);
1111}
1112
1113/**
1114 * fc_lport_scr_resp - Handle response to State Change Register (SCR) request
1115 * @sp: current sequence in SCR exchange
1116 * @fp: response frame
1117 * @lp_arg: Fibre Channel lport port instance that sent the registration request
1118 *
1119 * Locking Note: This function will be called without the lport lock
1120 * held, but it will lock, call an _enter_* function or fc_lport_error
1121 * and then unlock the lport.
1122 */
1123static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
1124 void *lp_arg)
1125{
1126 struct fc_lport *lport = lp_arg;
1127 u8 op;
1128
1129 if (fp == ERR_PTR(-FC_EX_CLOSED))
1130 return;
1131
1132 mutex_lock(&lport->lp_mutex);
1133
1134 FC_DEBUG_LPORT("Received a SCR response\n");
1135
1136 if (lport->state != LPORT_ST_SCR) {
1137 FC_DBG("Received a SCR response, but in state %s\n",
1138 fc_lport_state(lport));
1139 goto out;
1140 }
1141
1142 if (IS_ERR(fp)) {
1143 fc_lport_error(lport, fp);
1144 goto err;
1145 }
1146
1147 op = fc_frame_payload_op(fp);
1148 if (op == ELS_LS_ACC)
1149 fc_lport_enter_ready(lport);
1150 else
1151 fc_lport_error(lport, fp);
1152
1153out:
1154 fc_frame_free(fp);
1155err:
1156 mutex_unlock(&lport->lp_mutex);
1157}
1158
1159/**
1160 * fc_lport_enter_scr - Send a State Change Register (SCR) request
1161 * @lport: Fibre Channel local port to register for state changes
1162 *
1163 * Locking Note: The lport lock is expected to be held before calling
1164 * this routine.
1165 */
1166static void fc_lport_enter_scr(struct fc_lport *lport)
1167{
1168 struct fc_frame *fp;
1169
1170 FC_DEBUG_LPORT("Port (%6x) entered SCR state from %s state\n",
1171 fc_host_port_id(lport->host), fc_lport_state(lport));
1172
1173 fc_lport_state_enter(lport, LPORT_ST_SCR);
1174
1175 fp = fc_frame_alloc(lport, sizeof(struct fc_els_scr));
1176 if (!fp) {
1177 fc_lport_error(lport, fp);
1178 return;
1179 }
1180
1181 if (!lport->tt.elsct_send(lport, NULL, fp, ELS_SCR,
1182 fc_lport_scr_resp, lport, lport->e_d_tov))
1183 fc_lport_error(lport, fp);
1184}
1185
1186/**
1187 * fc_lport_enter_rft_id - Register FC4-types with the name server
1188 * @lport: Fibre Channel local port to register
1189 *
1190 * Locking Note: The lport lock is expected to be held before calling
1191 * this routine.
1192 */
1193static void fc_lport_enter_rft_id(struct fc_lport *lport)
1194{
1195 struct fc_frame *fp;
1196 struct fc_ns_fts *lps;
1197 int i;
1198
1199 FC_DEBUG_LPORT("Port (%6x) entered RFT_ID state from %s state\n",
1200 fc_host_port_id(lport->host), fc_lport_state(lport));
1201
1202 fc_lport_state_enter(lport, LPORT_ST_RFT_ID);
1203
1204 lps = &lport->fcts;
1205 i = sizeof(lps->ff_type_map) / sizeof(lps->ff_type_map[0]);
1206 while (--i >= 0)
1207 if (ntohl(lps->ff_type_map[i]) != 0)
1208 break;
1209 if (i < 0) {
1210 /* nothing to register, move on to SCR */
1211 fc_lport_enter_scr(lport);
1212 return;
1213 }
1214
1215 fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
1216 sizeof(struct fc_ns_rft));
1217 if (!fp) {
1218 fc_lport_error(lport, fp);
1219 return;
1220 }
1221
1222 if (!lport->tt.elsct_send(lport, NULL, fp, FC_NS_RFT_ID,
1223 fc_lport_rft_id_resp,
1224 lport, lport->e_d_tov))
1225 fc_lport_error(lport, fp);
1226}
1227
1228/**
1229 * fc_rport_enter_rft_id - Register port name with the name server
1230 * @lport: Fibre Channel local port to register
1231 *
1232 * Locking Note: The lport lock is expected to be held before calling
1233 * this routine.
1234 */
1235static void fc_lport_enter_rpn_id(struct fc_lport *lport)
1236{
1237 struct fc_frame *fp;
1238
1239 FC_DEBUG_LPORT("Port (%6x) entered RPN_ID state from %s state\n",
1240 fc_host_port_id(lport->host), fc_lport_state(lport));
1241
1242 fc_lport_state_enter(lport, LPORT_ST_RPN_ID);
1243
1244 fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
1245 sizeof(struct fc_ns_rn_id));
1246 if (!fp) {
1247 fc_lport_error(lport, fp);
1248 return;
1249 }
1250
1251 if (!lport->tt.elsct_send(lport, NULL, fp, FC_NS_RPN_ID,
1252 fc_lport_rpn_id_resp,
1253 lport, lport->e_d_tov))
1254 fc_lport_error(lport, fp);
1255}
1256
1257static struct fc_rport_operations fc_lport_rport_ops = {
1258 .event_callback = fc_lport_rport_callback,
1259};
1260
1261/**
1262 * fc_rport_enter_dns - Create a rport to the name server
1263 * @lport: Fibre Channel local port requesting a rport for the name server
1264 *
1265 * Locking Note: The lport lock is expected to be held before calling
1266 * this routine.
1267 */
1268static void fc_lport_enter_dns(struct fc_lport *lport)
1269{
1270 struct fc_rport *rport;
1271 struct fc_rport_libfc_priv *rdata;
1272 struct fc_disc_port dp;
1273
1274 dp.ids.port_id = FC_FID_DIR_SERV;
1275 dp.ids.port_name = -1;
1276 dp.ids.node_name = -1;
1277 dp.ids.roles = FC_RPORT_ROLE_UNKNOWN;
1278 dp.lp = lport;
1279
1280 FC_DEBUG_LPORT("Port (%6x) entered DNS state from %s state\n",
1281 fc_host_port_id(lport->host), fc_lport_state(lport));
1282
1283 fc_lport_state_enter(lport, LPORT_ST_DNS);
1284
1285 rport = fc_rport_rogue_create(&dp);
1286 if (!rport)
1287 goto err;
1288
1289 rdata = rport->dd_data;
1290 rdata->ops = &fc_lport_rport_ops;
1291 lport->tt.rport_login(rport);
1292 return;
1293
1294err:
1295 fc_lport_error(lport, NULL);
1296}
1297
1298/**
1299 * fc_lport_timeout - Handler for the retry_work timer.
1300 * @work: The work struct of the fc_lport
1301 */
1302static void fc_lport_timeout(struct work_struct *work)
1303{
1304 struct fc_lport *lport =
1305 container_of(work, struct fc_lport,
1306 retry_work.work);
1307
1308 mutex_lock(&lport->lp_mutex);
1309
1310 switch (lport->state) {
1311 case LPORT_ST_NONE:
1312 case LPORT_ST_READY:
1313 case LPORT_ST_RESET:
1314 WARN_ON(1);
1315 break;
1316 case LPORT_ST_FLOGI:
1317 fc_lport_enter_flogi(lport);
1318 break;
1319 case LPORT_ST_DNS:
1320 fc_lport_enter_dns(lport);
1321 break;
1322 case LPORT_ST_RPN_ID:
1323 fc_lport_enter_rpn_id(lport);
1324 break;
1325 case LPORT_ST_RFT_ID:
1326 fc_lport_enter_rft_id(lport);
1327 break;
1328 case LPORT_ST_SCR:
1329 fc_lport_enter_scr(lport);
1330 break;
1331 case LPORT_ST_LOGO:
1332 fc_lport_enter_logo(lport);
1333 break;
1334 }
1335
1336 mutex_unlock(&lport->lp_mutex);
1337}
1338
1339/**
1340 * fc_lport_logo_resp - Handle response to LOGO request
1341 * @sp: current sequence in LOGO exchange
1342 * @fp: response frame
1343 * @lp_arg: Fibre Channel lport port instance that sent the LOGO request
1344 *
1345 * Locking Note: This function will be called without the lport lock
1346 * held, but it will lock, call an _enter_* function or fc_lport_error
1347 * and then unlock the lport.
1348 */
1349static void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
1350 void *lp_arg)
1351{
1352 struct fc_lport *lport = lp_arg;
1353 u8 op;
1354
1355 if (fp == ERR_PTR(-FC_EX_CLOSED))
1356 return;
1357
1358 mutex_lock(&lport->lp_mutex);
1359
1360 FC_DEBUG_LPORT("Received a LOGO response\n");
1361
1362 if (lport->state != LPORT_ST_LOGO) {
1363 FC_DBG("Received a LOGO response, but in state %s\n",
1364 fc_lport_state(lport));
1365 goto out;
1366 }
1367
1368 if (IS_ERR(fp)) {
1369 fc_lport_error(lport, fp);
1370 goto err;
1371 }
1372
1373 op = fc_frame_payload_op(fp);
1374 if (op == ELS_LS_ACC)
1375 fc_lport_enter_reset(lport);
1376 else
1377 fc_lport_error(lport, fp);
1378
1379out:
1380 fc_frame_free(fp);
1381err:
1382 mutex_unlock(&lport->lp_mutex);
1383}
1384
1385/**
1386 * fc_rport_enter_logo - Logout of the fabric
1387 * @lport: Fibre Channel local port to be logged out
1388 *
1389 * Locking Note: The lport lock is expected to be held before calling
1390 * this routine.
1391 */
1392static void fc_lport_enter_logo(struct fc_lport *lport)
1393{
1394 struct fc_frame *fp;
1395 struct fc_els_logo *logo;
1396
1397 FC_DEBUG_LPORT("Port (%6x) entered LOGO state from %s state\n",
1398 fc_host_port_id(lport->host), fc_lport_state(lport));
1399
1400 fc_lport_state_enter(lport, LPORT_ST_LOGO);
1401
1402 /* DNS session should be closed so we can release it here */
1403 if (lport->dns_rp)
1404 lport->tt.rport_logoff(lport->dns_rp);
1405
1406 fp = fc_frame_alloc(lport, sizeof(*logo));
1407 if (!fp) {
1408 fc_lport_error(lport, fp);
1409 return;
1410 }
1411
1412 if (!lport->tt.elsct_send(lport, NULL, fp, ELS_LOGO, fc_lport_logo_resp,
1413 lport, lport->e_d_tov))
1414 fc_lport_error(lport, fp);
1415}
1416
1417/**
1418 * fc_lport_flogi_resp - Handle response to FLOGI request
1419 * @sp: current sequence in FLOGI exchange
1420 * @fp: response frame
1421 * @lp_arg: Fibre Channel lport port instance that sent the FLOGI request
1422 *
1423 * Locking Note: This function will be called without the lport lock
1424 * held, but it will lock, call an _enter_* function or fc_lport_error
1425 * and then unlock the lport.
1426 */
1427static void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
1428 void *lp_arg)
1429{
1430 struct fc_lport *lport = lp_arg;
1431 struct fc_frame_header *fh;
1432 struct fc_els_flogi *flp;
1433 u32 did;
1434 u16 csp_flags;
1435 unsigned int r_a_tov;
1436 unsigned int e_d_tov;
1437 u16 mfs;
1438
1439 if (fp == ERR_PTR(-FC_EX_CLOSED))
1440 return;
1441
1442 mutex_lock(&lport->lp_mutex);
1443
1444 FC_DEBUG_LPORT("Received a FLOGI response\n");
1445
1446 if (lport->state != LPORT_ST_FLOGI) {
1447 FC_DBG("Received a FLOGI response, but in state %s\n",
1448 fc_lport_state(lport));
1449 goto out;
1450 }
1451
1452 if (IS_ERR(fp)) {
1453 fc_lport_error(lport, fp);
1454 goto err;
1455 }
1456
1457 fh = fc_frame_header_get(fp);
1458 did = ntoh24(fh->fh_d_id);
1459 if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) {
1460
1461 FC_DEBUG_LPORT("Assigned fid %x\n", did);
1462 fc_host_port_id(lport->host) = did;
1463
1464 flp = fc_frame_payload_get(fp, sizeof(*flp));
1465 if (flp) {
1466 mfs = ntohs(flp->fl_csp.sp_bb_data) &
1467 FC_SP_BB_DATA_MASK;
1468 if (mfs >= FC_SP_MIN_MAX_PAYLOAD &&
1469 mfs < lport->mfs)
1470 lport->mfs = mfs;
1471 csp_flags = ntohs(flp->fl_csp.sp_features);
1472 r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov);
1473 e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
1474 if (csp_flags & FC_SP_FT_EDTR)
1475 e_d_tov /= 1000000;
1476 if ((csp_flags & FC_SP_FT_FPORT) == 0) {
1477 if (e_d_tov > lport->e_d_tov)
1478 lport->e_d_tov = e_d_tov;
1479 lport->r_a_tov = 2 * e_d_tov;
1480 FC_DBG("Point-to-Point mode\n");
1481 fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id),
1482 get_unaligned_be64(
1483 &flp->fl_wwpn),
1484 get_unaligned_be64(
1485 &flp->fl_wwnn));
1486 } else {
1487 lport->e_d_tov = e_d_tov;
1488 lport->r_a_tov = r_a_tov;
1489 fc_host_fabric_name(lport->host) =
1490 get_unaligned_be64(&flp->fl_wwnn);
1491 fc_lport_enter_dns(lport);
1492 }
1493 }
1494
1495 if (flp) {
1496 csp_flags = ntohs(flp->fl_csp.sp_features);
1497 if ((csp_flags & FC_SP_FT_FPORT) == 0) {
1498 lport->tt.disc_start(fc_lport_disc_callback,
1499 lport);
1500 }
1501 }
1502 } else {
1503 FC_DBG("bad FLOGI response\n");
1504 }
1505
1506out:
1507 fc_frame_free(fp);
1508err:
1509 mutex_unlock(&lport->lp_mutex);
1510}
1511
1512/**
1513 * fc_rport_enter_flogi - Send a FLOGI request to the fabric manager
1514 * @lport: Fibre Channel local port to be logged in to the fabric
1515 *
1516 * Locking Note: The lport lock is expected to be held before calling
1517 * this routine.
1518 */
1519void fc_lport_enter_flogi(struct fc_lport *lport)
1520{
1521 struct fc_frame *fp;
1522
1523 FC_DEBUG_LPORT("Processing FLOGI state\n");
1524
1525 fc_lport_state_enter(lport, LPORT_ST_FLOGI);
1526
1527 fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
1528 if (!fp)
1529 return fc_lport_error(lport, fp);
1530
1531 if (!lport->tt.elsct_send(lport, NULL, fp, ELS_FLOGI,
1532 fc_lport_flogi_resp, lport, lport->e_d_tov))
1533 fc_lport_error(lport, fp);
1534}
1535
1536/* Configure a fc_lport */
1537int fc_lport_config(struct fc_lport *lport)
1538{
1539 INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
1540 mutex_init(&lport->lp_mutex);
1541
1542 fc_lport_state_enter(lport, LPORT_ST_NONE);
1543
1544 fc_lport_add_fc4_type(lport, FC_TYPE_FCP);
1545 fc_lport_add_fc4_type(lport, FC_TYPE_CT);
1546
1547 return 0;
1548}
1549EXPORT_SYMBOL(fc_lport_config);
1550
1551int fc_lport_init(struct fc_lport *lport)
1552{
1553 if (!lport->tt.lport_recv)
1554 lport->tt.lport_recv = fc_lport_recv_req;
1555
1556 if (!lport->tt.lport_reset)
1557 lport->tt.lport_reset = fc_lport_reset;
1558
1559 fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
1560 fc_host_node_name(lport->host) = lport->wwnn;
1561 fc_host_port_name(lport->host) = lport->wwpn;
1562 fc_host_supported_classes(lport->host) = FC_COS_CLASS3;
1563 memset(fc_host_supported_fc4s(lport->host), 0,
1564 sizeof(fc_host_supported_fc4s(lport->host)));
1565 fc_host_supported_fc4s(lport->host)[2] = 1;
1566 fc_host_supported_fc4s(lport->host)[7] = 1;
1567
1568 /* This value is also unchanging */
1569 memset(fc_host_active_fc4s(lport->host), 0,
1570 sizeof(fc_host_active_fc4s(lport->host)));
1571 fc_host_active_fc4s(lport->host)[2] = 1;
1572 fc_host_active_fc4s(lport->host)[7] = 1;
1573 fc_host_maxframe_size(lport->host) = lport->mfs;
1574 fc_host_supported_speeds(lport->host) = 0;
1575 if (lport->link_supported_speeds & FC_PORTSPEED_1GBIT)
1576 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_1GBIT;
1577 if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
1578 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
1579
1580 return 0;
1581}
1582EXPORT_SYMBOL(fc_lport_init);