1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright(c) 2007 Intel Corporation. All rights reserved.
4 *
5 * Maintained at www.Open-FCoE.org
6 */
7
8 /*
9 * PORT LOCKING NOTES
10 *
11 * These comments only apply to the 'port code' which consists of the lport,
12 * disc and rport blocks.
13 *
14 * MOTIVATION
15 *
16 * The lport, disc and rport blocks all have mutexes that are used to protect
17 * those objects. The main motivation for these locks is to prevent from
18 * having an lport reset just before we send a frame. In that scenario the
19 * lport's FID would get set to zero and then we'd send a frame with an
20 * invalid SID. We also need to ensure that states don't change unexpectedly
21 * while processing another state.
22 *
23 * HIERARCHY
24 *
25 * The following hierarchy defines the locking rules. A greater lock
26 * may be held before acquiring a lesser lock, but a lesser lock should never
27 * be held while attempting to acquire a greater lock. Here is the hierarchy-
28 *
29 * lport > disc, lport > rport, disc > rport
30 *
31 * CALLBACKS
32 *
33 * The callbacks cause complications with this scheme. There is a callback
34 * from the rport (to either lport or disc) and a callback from disc
35 * (to the lport).
36 *
37 * As rports exit the rport state machine a callback is made to the owner of
38 * the rport to notify success or failure. Since the callback is likely to
39 * cause the lport or disc to grab its lock we cannot hold the rport lock
40 * while making the callback. To ensure that the rport is not free'd while
41 * processing the callback the rport callbacks are serialized through a
42 * single-threaded workqueue. An rport would never be free'd while in a
43 * callback handler because no other rport work in this queue can be executed
44 * at the same time.
45 *
46 * When discovery succeeds or fails a callback is made to the lport as
47 * notification. Currently, successful discovery causes the lport to take no
48 * action. A failure will cause the lport to reset. There is likely a circular
49 * locking problem with this implementation.
50 */
51
52 /*
53 * LPORT LOCKING
54 *
55 * The critical sections protected by the lport's mutex are quite broad and
56 * may be improved upon in the future. The lport code and its locking doesn't
57 * influence the I/O path, so excessive locking doesn't penalize I/O
58 * performance.
59 *
60 * The strategy is to lock whenever processing a request or response. Note
61 * that every _enter_* function corresponds to a state change. They generally
62 * change the lports state and then send a request out on the wire. We lock
63 * before calling any of these functions to protect that state change. This
64 * means that the entry points into the lport block manage the locks while
65 * the state machine can transition between states (i.e. _enter_* functions)
66 * while always staying protected.
67 *
68 * When handling responses we also hold the lport mutex broadly. When the
69 * lport receives the response frame it locks the mutex and then calls the
70 * appropriate handler for the particuar response. Generally a response will
71 * trigger a state change and so the lock must already be held.
72 *
73 * Retries also have to consider the locking. The retries occur from a work
74 * context and the work function will lock the lport and then retry the state
75 * (i.e. _enter_* function).
76 */
77
78 #include <linux/timer.h>
79 #include <linux/delay.h>
80 #include <linux/module.h>
81 #include <linux/slab.h>
82 #include <asm/unaligned.h>
83
84 #include <scsi/fc/fc_gs.h>
85
86 #include <scsi/libfc.h>
87 #include <linux/scatterlist.h>
88
89 #include "fc_encode.h"
90 #include "fc_libfc.h"
91
92 /* Fabric IDs to use for point-to-point mode, chosen on whims. */
93 #define FC_LOCAL_PTP_FID_LO 0x010101
94 #define FC_LOCAL_PTP_FID_HI 0x010102
95
96 #define DNS_DELAY 3 /* Discovery delay after RSCN (in seconds)*/
97 #define MAX_CT_PAYLOAD 2048
98 #define DISCOVERED_PORTS 4
99 #define NUMBER_OF_PORTS 1
100
101 static void fc_lport_error(struct fc_lport *, struct fc_frame *);
102
103 static void fc_lport_enter_reset(struct fc_lport *);
104 static void fc_lport_enter_flogi(struct fc_lport *);
105 static void fc_lport_enter_dns(struct fc_lport *);
106 static void fc_lport_enter_ns(struct fc_lport *, enum fc_lport_state);
107 static void fc_lport_enter_scr(struct fc_lport *);
108 static void fc_lport_enter_ready(struct fc_lport *);
109 static void fc_lport_enter_logo(struct fc_lport *);
110 static void fc_lport_enter_fdmi(struct fc_lport *lport);
111 static void fc_lport_enter_ms(struct fc_lport *, enum fc_lport_state);
112
113 static const char *fc_lport_state_names[] = {
114 [LPORT_ST_DISABLED] = "disabled",
115 [LPORT_ST_FLOGI] = "FLOGI",
116 [LPORT_ST_DNS] = "dNS",
117 [LPORT_ST_RNN_ID] = "RNN_ID",
118 [LPORT_ST_RSNN_NN] = "RSNN_NN",
119 [LPORT_ST_RSPN_ID] = "RSPN_ID",
120 [LPORT_ST_RFT_ID] = "RFT_ID",
121 [LPORT_ST_RFF_ID] = "RFF_ID",
122 [LPORT_ST_FDMI] = "FDMI",
123 [LPORT_ST_RHBA] = "RHBA",
124 [LPORT_ST_RPA] = "RPA",
125 [LPORT_ST_DHBA] = "DHBA",
126 [LPORT_ST_DPRT] = "DPRT",
127 [LPORT_ST_SCR] = "SCR",
128 [LPORT_ST_READY] = "Ready",
129 [LPORT_ST_LOGO] = "LOGO",
130 [LPORT_ST_RESET] = "reset",
131 };
132
133 /**
134 * struct fc_bsg_info - FC Passthrough managemet structure
135 * @job: The passthrough job
136 * @lport: The local port to pass through a command
137 * @rsp_code: The expected response code
138 * @sg: job->reply_payload.sg_list
139 * @nents: job->reply_payload.sg_cnt
140 * @offset: The offset into the response data
141 */
142 struct fc_bsg_info {
143 struct bsg_job *job;
144 struct fc_lport *lport;
145 u16 rsp_code;
146 struct scatterlist *sg;
147 u32 nents;
148 size_t offset;
149 };
150
151 /**
152 * fc_frame_drop() - Dummy frame handler
153 * @lport: The local port the frame was received on
154 * @fp: The received frame
155 */
fc_frame_drop(struct fc_lport * lport,struct fc_frame * fp)156 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp)
157 {
158 fc_frame_free(fp);
159 return 0;
160 }
161
162 /**
163 * fc_lport_rport_callback() - Event handler for rport events
164 * @lport: The lport which is receiving the event
165 * @rdata: private remote port data
166 * @event: The event that occurred
167 *
168 * Locking Note: The rport lock should not be held when calling
169 * this function.
170 */
fc_lport_rport_callback(struct fc_lport * lport,struct fc_rport_priv * rdata,enum fc_rport_event event)171 static void fc_lport_rport_callback(struct fc_lport *lport,
172 struct fc_rport_priv *rdata,
173 enum fc_rport_event event)
174 {
175 FC_LPORT_DBG(lport, "Received a %d event for port (%6.6x)\n", event,
176 rdata->ids.port_id);
177
178 mutex_lock(&lport->lp_mutex);
179 switch (event) {
180 case RPORT_EV_READY:
181 if (lport->state == LPORT_ST_DNS) {
182 lport->dns_rdata = rdata;
183 fc_lport_enter_ns(lport, LPORT_ST_RNN_ID);
184 } else if (lport->state == LPORT_ST_FDMI) {
185 lport->ms_rdata = rdata;
186 fc_lport_enter_ms(lport, LPORT_ST_DHBA);
187 } else {
188 FC_LPORT_DBG(lport, "Received an READY event "
189 "on port (%6.6x) for the directory "
190 "server, but the lport is not "
191 "in the DNS or FDMI state, it's in the "
192 "%d state", rdata->ids.port_id,
193 lport->state);
194 fc_rport_logoff(rdata);
195 }
196 break;
197 case RPORT_EV_LOGO:
198 case RPORT_EV_FAILED:
199 case RPORT_EV_STOP:
200 if (rdata->ids.port_id == FC_FID_DIR_SERV)
201 lport->dns_rdata = NULL;
202 else if (rdata->ids.port_id == FC_FID_MGMT_SERV)
203 lport->ms_rdata = NULL;
204 break;
205 case RPORT_EV_NONE:
206 break;
207 }
208 mutex_unlock(&lport->lp_mutex);
209 }
210
211 /**
212 * fc_lport_state() - Return a string which represents the lport's state
213 * @lport: The lport whose state is to converted to a string
214 */
fc_lport_state(struct fc_lport * lport)215 static const char *fc_lport_state(struct fc_lport *lport)
216 {
217 const char *cp;
218
219 cp = fc_lport_state_names[lport->state];
220 if (!cp)
221 cp = "unknown";
222 return cp;
223 }
224
225 /**
226 * fc_lport_ptp_setup() - Create an rport for point-to-point mode
227 * @lport: The lport to attach the ptp rport to
228 * @remote_fid: The FID of the ptp rport
229 * @remote_wwpn: The WWPN of the ptp rport
230 * @remote_wwnn: The WWNN of the ptp rport
231 */
fc_lport_ptp_setup(struct fc_lport * lport,u32 remote_fid,u64 remote_wwpn,u64 remote_wwnn)232 static void fc_lport_ptp_setup(struct fc_lport *lport,
233 u32 remote_fid, u64 remote_wwpn,
234 u64 remote_wwnn)
235 {
236 lockdep_assert_held(&lport->lp_mutex);
237
238 if (lport->ptp_rdata) {
239 fc_rport_logoff(lport->ptp_rdata);
240 kref_put(&lport->ptp_rdata->kref, fc_rport_destroy);
241 }
242 mutex_lock(&lport->disc.disc_mutex);
243 lport->ptp_rdata = fc_rport_create(lport, remote_fid);
244 if (!lport->ptp_rdata) {
245 printk(KERN_WARNING "libfc: Failed to setup lport 0x%x\n",
246 lport->port_id);
247 mutex_unlock(&lport->disc.disc_mutex);
248 return;
249 }
250 kref_get(&lport->ptp_rdata->kref);
251 lport->ptp_rdata->ids.port_name = remote_wwpn;
252 lport->ptp_rdata->ids.node_name = remote_wwnn;
253 mutex_unlock(&lport->disc.disc_mutex);
254
255 fc_rport_login(lport->ptp_rdata);
256
257 fc_lport_enter_ready(lport);
258 }
259
260 /**
261 * fc_get_host_port_state() - Return the port state of the given Scsi_Host
262 * @shost: The SCSI host whose port state is to be determined
263 */
fc_get_host_port_state(struct Scsi_Host * shost)264 void fc_get_host_port_state(struct Scsi_Host *shost)
265 {
266 struct fc_lport *lport = shost_priv(shost);
267
268 mutex_lock(&lport->lp_mutex);
269 if (!lport->link_up)
270 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN;
271 else
272 switch (lport->state) {
273 case LPORT_ST_READY:
274 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE;
275 break;
276 default:
277 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE;
278 }
279 mutex_unlock(&lport->lp_mutex);
280 }
281 EXPORT_SYMBOL(fc_get_host_port_state);
282
283 /**
284 * fc_get_host_speed() - Return the speed of the given Scsi_Host
285 * @shost: The SCSI host whose port speed is to be determined
286 */
fc_get_host_speed(struct Scsi_Host * shost)287 void fc_get_host_speed(struct Scsi_Host *shost)
288 {
289 struct fc_lport *lport = shost_priv(shost);
290
291 fc_host_speed(shost) = lport->link_speed;
292 }
293 EXPORT_SYMBOL(fc_get_host_speed);
294
295 /**
296 * fc_get_host_stats() - Return the Scsi_Host's statistics
297 * @shost: The SCSI host whose statistics are to be returned
298 */
fc_get_host_stats(struct Scsi_Host * shost)299 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost)
300 {
301 struct fc_host_statistics *fc_stats;
302 struct fc_lport *lport = shost_priv(shost);
303 unsigned int cpu;
304 u64 fcp_in_bytes = 0;
305 u64 fcp_out_bytes = 0;
306
307 fc_stats = &lport->host_stats;
308 memset(fc_stats, 0, sizeof(struct fc_host_statistics));
309
310 fc_stats->seconds_since_last_reset = (jiffies - lport->boot_time) / HZ;
311
312 for_each_possible_cpu(cpu) {
313 struct fc_stats *stats;
314
315 stats = per_cpu_ptr(lport->stats, cpu);
316
317 fc_stats->tx_frames += READ_ONCE(stats->TxFrames);
318 fc_stats->tx_words += READ_ONCE(stats->TxWords);
319 fc_stats->rx_frames += READ_ONCE(stats->RxFrames);
320 fc_stats->rx_words += READ_ONCE(stats->RxWords);
321 fc_stats->error_frames += READ_ONCE(stats->ErrorFrames);
322 fc_stats->invalid_crc_count += READ_ONCE(stats->InvalidCRCCount);
323 fc_stats->fcp_input_requests += READ_ONCE(stats->InputRequests);
324 fc_stats->fcp_output_requests += READ_ONCE(stats->OutputRequests);
325 fc_stats->fcp_control_requests += READ_ONCE(stats->ControlRequests);
326 fcp_in_bytes += READ_ONCE(stats->InputBytes);
327 fcp_out_bytes += READ_ONCE(stats->OutputBytes);
328 fc_stats->fcp_packet_alloc_failures += READ_ONCE(stats->FcpPktAllocFails);
329 fc_stats->fcp_packet_aborts += READ_ONCE(stats->FcpPktAborts);
330 fc_stats->fcp_frame_alloc_failures += READ_ONCE(stats->FcpFrameAllocFails);
331 fc_stats->link_failure_count += READ_ONCE(stats->LinkFailureCount);
332 }
333 fc_stats->fcp_input_megabytes = div_u64(fcp_in_bytes, 1000000);
334 fc_stats->fcp_output_megabytes = div_u64(fcp_out_bytes, 1000000);
335 fc_stats->lip_count = -1;
336 fc_stats->nos_count = -1;
337 fc_stats->loss_of_sync_count = -1;
338 fc_stats->loss_of_signal_count = -1;
339 fc_stats->prim_seq_protocol_err_count = -1;
340 fc_stats->dumped_frames = -1;
341
342 /* update exches stats */
343 fc_exch_update_stats(lport);
344
345 return fc_stats;
346 }
347 EXPORT_SYMBOL(fc_get_host_stats);
348
349 /**
350 * fc_lport_flogi_fill() - Fill in FLOGI command for request
351 * @lport: The local port the FLOGI is for
352 * @flogi: The FLOGI command
353 * @op: The opcode
354 */
fc_lport_flogi_fill(struct fc_lport * lport,struct fc_els_flogi * flogi,unsigned int op)355 static void fc_lport_flogi_fill(struct fc_lport *lport,
356 struct fc_els_flogi *flogi,
357 unsigned int op)
358 {
359 struct fc_els_csp *sp;
360 struct fc_els_cssp *cp;
361
362 memset(flogi, 0, sizeof(*flogi));
363 flogi->fl_cmd = (u8) op;
364 put_unaligned_be64(lport->wwpn, &flogi->fl_wwpn);
365 put_unaligned_be64(lport->wwnn, &flogi->fl_wwnn);
366 sp = &flogi->fl_csp;
367 sp->sp_hi_ver = 0x20;
368 sp->sp_lo_ver = 0x20;
369 sp->sp_bb_cred = htons(10); /* this gets set by gateway */
370 sp->sp_bb_data = htons((u16) lport->mfs);
371 cp = &flogi->fl_cssp[3 - 1]; /* class 3 parameters */
372 cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ);
373 if (op != ELS_FLOGI) {
374 sp->sp_features = htons(FC_SP_FT_CIRO);
375 sp->sp_tot_seq = htons(255); /* seq. we accept */
376 sp->sp_rel_off = htons(0x1f);
377 sp->sp_e_d_tov = htonl(lport->e_d_tov);
378
379 cp->cp_rdfs = htons((u16) lport->mfs);
380 cp->cp_con_seq = htons(255);
381 cp->cp_open_seq = 1;
382 }
383 }
384
385 /**
386 * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port
387 * @lport: The local port to add a new FC-4 type to
388 * @type: The new FC-4 type
389 */
fc_lport_add_fc4_type(struct fc_lport * lport,enum fc_fh_type type)390 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type)
391 {
392 __be32 *mp;
393
394 mp = &lport->fcts.ff_type_map[type / FC_NS_BPW];
395 *mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW));
396 }
397
398 /**
399 * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report.
400 * @lport: Fibre Channel local port receiving the RLIR
401 * @fp: The RLIR request frame
402 */
fc_lport_recv_rlir_req(struct fc_lport * lport,struct fc_frame * fp)403 static void fc_lport_recv_rlir_req(struct fc_lport *lport, struct fc_frame *fp)
404 {
405 lockdep_assert_held(&lport->lp_mutex);
406
407 FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n",
408 fc_lport_state(lport));
409
410 fc_seq_els_rsp_send(fp, ELS_LS_ACC, NULL);
411 fc_frame_free(fp);
412 }
413
414 /**
415 * fc_lport_recv_echo_req() - Handle received ECHO request
416 * @lport: The local port receiving the ECHO
417 * @in_fp: ECHO request frame
418 */
fc_lport_recv_echo_req(struct fc_lport * lport,struct fc_frame * in_fp)419 static void fc_lport_recv_echo_req(struct fc_lport *lport,
420 struct fc_frame *in_fp)
421 {
422 struct fc_frame *fp;
423 unsigned int len;
424 void *pp;
425 void *dp;
426
427 lockdep_assert_held(&lport->lp_mutex);
428
429 FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n",
430 fc_lport_state(lport));
431
432 len = fr_len(in_fp) - sizeof(struct fc_frame_header);
433 pp = fc_frame_payload_get(in_fp, len);
434
435 if (len < sizeof(__be32))
436 len = sizeof(__be32);
437
438 fp = fc_frame_alloc(lport, len);
439 if (fp) {
440 dp = fc_frame_payload_get(fp, len);
441 memcpy(dp, pp, len);
442 *((__be32 *)dp) = htonl(ELS_LS_ACC << 24);
443 fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);
444 lport->tt.frame_send(lport, fp);
445 }
446 fc_frame_free(in_fp);
447 }
448
449 /**
450 * fc_lport_recv_rnid_req() - Handle received Request Node ID data request
451 * @lport: The local port receiving the RNID
452 * @in_fp: The RNID request frame
453 */
fc_lport_recv_rnid_req(struct fc_lport * lport,struct fc_frame * in_fp)454 static void fc_lport_recv_rnid_req(struct fc_lport *lport,
455 struct fc_frame *in_fp)
456 {
457 struct fc_frame *fp;
458 struct fc_els_rnid *req;
459 struct {
460 struct fc_els_rnid_resp rnid;
461 struct fc_els_rnid_cid cid;
462 struct fc_els_rnid_gen gen;
463 } *rp;
464 struct fc_seq_els_data rjt_data;
465 u8 fmt;
466 size_t len;
467
468 lockdep_assert_held(&lport->lp_mutex);
469
470 FC_LPORT_DBG(lport, "Received RNID request while in state %s\n",
471 fc_lport_state(lport));
472
473 req = fc_frame_payload_get(in_fp, sizeof(*req));
474 if (!req) {
475 rjt_data.reason = ELS_RJT_LOGIC;
476 rjt_data.explan = ELS_EXPL_NONE;
477 fc_seq_els_rsp_send(in_fp, ELS_LS_RJT, &rjt_data);
478 } else {
479 fmt = req->rnid_fmt;
480 len = sizeof(*rp);
481 if (fmt != ELS_RNIDF_GEN ||
482 ntohl(lport->rnid_gen.rnid_atype) == 0) {
483 fmt = ELS_RNIDF_NONE; /* nothing to provide */
484 len -= sizeof(rp->gen);
485 }
486 fp = fc_frame_alloc(lport, len);
487 if (fp) {
488 rp = fc_frame_payload_get(fp, len);
489 memset(rp, 0, len);
490 rp->rnid.rnid_cmd = ELS_LS_ACC;
491 rp->rnid.rnid_fmt = fmt;
492 rp->rnid.rnid_cid_len = sizeof(rp->cid);
493 rp->cid.rnid_wwpn = htonll(lport->wwpn);
494 rp->cid.rnid_wwnn = htonll(lport->wwnn);
495 if (fmt == ELS_RNIDF_GEN) {
496 rp->rnid.rnid_sid_len = sizeof(rp->gen);
497 memcpy(&rp->gen, &lport->rnid_gen,
498 sizeof(rp->gen));
499 }
500 fc_fill_reply_hdr(fp, in_fp, FC_RCTL_ELS_REP, 0);
501 lport->tt.frame_send(lport, fp);
502 }
503 }
504 fc_frame_free(in_fp);
505 }
506
507 /**
508 * fc_lport_recv_logo_req() - Handle received fabric LOGO request
509 * @lport: The local port receiving the LOGO
510 * @fp: The LOGO request frame
511 */
fc_lport_recv_logo_req(struct fc_lport * lport,struct fc_frame * fp)512 static void fc_lport_recv_logo_req(struct fc_lport *lport, struct fc_frame *fp)
513 {
514 lockdep_assert_held(&lport->lp_mutex);
515
516 fc_seq_els_rsp_send(fp, ELS_LS_ACC, NULL);
517 fc_lport_enter_reset(lport);
518 fc_frame_free(fp);
519 }
520
521 /**
522 * fc_fabric_login() - Start the lport state machine
523 * @lport: The local port that should log into the fabric
524 *
525 * Locking Note: This function should not be called
526 * with the lport lock held.
527 */
fc_fabric_login(struct fc_lport * lport)528 int fc_fabric_login(struct fc_lport *lport)
529 {
530 int rc = -1;
531
532 mutex_lock(&lport->lp_mutex);
533 if (lport->state == LPORT_ST_DISABLED ||
534 lport->state == LPORT_ST_LOGO) {
535 fc_lport_state_enter(lport, LPORT_ST_RESET);
536 fc_lport_enter_reset(lport);
537 rc = 0;
538 }
539 mutex_unlock(&lport->lp_mutex);
540
541 return rc;
542 }
543 EXPORT_SYMBOL(fc_fabric_login);
544
545 /**
546 * __fc_linkup() - Handler for transport linkup events
547 * @lport: The lport whose link is up
548 */
__fc_linkup(struct fc_lport * lport)549 void __fc_linkup(struct fc_lport *lport)
550 {
551 lockdep_assert_held(&lport->lp_mutex);
552
553 if (!lport->link_up) {
554 lport->link_up = 1;
555
556 if (lport->state == LPORT_ST_RESET)
557 fc_lport_enter_flogi(lport);
558 }
559 }
560
561 /**
562 * fc_linkup() - Handler for transport linkup events
563 * @lport: The local port whose link is up
564 */
fc_linkup(struct fc_lport * lport)565 void fc_linkup(struct fc_lport *lport)
566 {
567 printk(KERN_INFO "host%d: libfc: Link up on port (%6.6x)\n",
568 lport->host->host_no, lport->port_id);
569
570 mutex_lock(&lport->lp_mutex);
571 __fc_linkup(lport);
572 mutex_unlock(&lport->lp_mutex);
573 }
574 EXPORT_SYMBOL(fc_linkup);
575
576 /**
577 * __fc_linkdown() - Handler for transport linkdown events
578 * @lport: The lport whose link is down
579 */
__fc_linkdown(struct fc_lport * lport)580 void __fc_linkdown(struct fc_lport *lport)
581 {
582 lockdep_assert_held(&lport->lp_mutex);
583
584 if (lport->link_up) {
585 lport->link_up = 0;
586 fc_lport_enter_reset(lport);
587 lport->tt.fcp_cleanup(lport);
588 }
589 }
590
591 /**
592 * fc_linkdown() - Handler for transport linkdown events
593 * @lport: The local port whose link is down
594 */
fc_linkdown(struct fc_lport * lport)595 void fc_linkdown(struct fc_lport *lport)
596 {
597 printk(KERN_INFO "host%d: libfc: Link down on port (%6.6x)\n",
598 lport->host->host_no, lport->port_id);
599
600 mutex_lock(&lport->lp_mutex);
601 __fc_linkdown(lport);
602 mutex_unlock(&lport->lp_mutex);
603 }
604 EXPORT_SYMBOL(fc_linkdown);
605
606 /**
607 * fc_fabric_logoff() - Logout of the fabric
608 * @lport: The local port to logoff the fabric
609 *
610 * Return value:
611 * 0 for success, -1 for failure
612 */
fc_fabric_logoff(struct fc_lport * lport)613 int fc_fabric_logoff(struct fc_lport *lport)
614 {
615 lport->tt.disc_stop_final(lport);
616 mutex_lock(&lport->lp_mutex);
617 if (lport->dns_rdata)
618 fc_rport_logoff(lport->dns_rdata);
619 mutex_unlock(&lport->lp_mutex);
620 fc_rport_flush_queue();
621 mutex_lock(&lport->lp_mutex);
622 fc_lport_enter_logo(lport);
623 mutex_unlock(&lport->lp_mutex);
624 cancel_delayed_work_sync(&lport->retry_work);
625 return 0;
626 }
627 EXPORT_SYMBOL(fc_fabric_logoff);
628
629 /**
630 * fc_lport_destroy() - Unregister a fc_lport
631 * @lport: The local port to unregister
632 *
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 */
fc_lport_destroy(struct fc_lport * lport)639 int fc_lport_destroy(struct fc_lport *lport)
640 {
641 mutex_lock(&lport->lp_mutex);
642 lport->state = LPORT_ST_DISABLED;
643 lport->link_up = 0;
644 lport->tt.frame_send = fc_frame_drop;
645 mutex_unlock(&lport->lp_mutex);
646
647 lport->tt.fcp_abort_io(lport);
648 lport->tt.disc_stop_final(lport);
649 lport->tt.exch_mgr_reset(lport, 0, 0);
650 cancel_delayed_work_sync(&lport->retry_work);
651 fc_fc4_del_lport(lport);
652 return 0;
653 }
654 EXPORT_SYMBOL(fc_lport_destroy);
655
656 /**
657 * fc_set_mfs() - Set the maximum frame size for a local port
658 * @lport: The local port to set the MFS for
659 * @mfs: The new MFS
660 */
fc_set_mfs(struct fc_lport * lport,u32 mfs)661 int fc_set_mfs(struct fc_lport *lport, u32 mfs)
662 {
663 unsigned int old_mfs;
664 int rc = -EINVAL;
665
666 mutex_lock(&lport->lp_mutex);
667
668 old_mfs = lport->mfs;
669
670 if (mfs >= FC_MIN_MAX_FRAME) {
671 mfs &= ~3;
672 if (mfs > FC_MAX_FRAME)
673 mfs = FC_MAX_FRAME;
674 mfs -= sizeof(struct fc_frame_header);
675 lport->mfs = mfs;
676 rc = 0;
677 }
678
679 if (!rc && mfs < old_mfs)
680 fc_lport_enter_reset(lport);
681
682 mutex_unlock(&lport->lp_mutex);
683
684 return rc;
685 }
686 EXPORT_SYMBOL(fc_set_mfs);
687
688 /**
689 * fc_lport_disc_callback() - Callback for discovery events
690 * @lport: The local port receiving the event
691 * @event: The discovery event
692 */
fc_lport_disc_callback(struct fc_lport * lport,enum fc_disc_event event)693 static void fc_lport_disc_callback(struct fc_lport *lport,
694 enum fc_disc_event event)
695 {
696 switch (event) {
697 case DISC_EV_SUCCESS:
698 FC_LPORT_DBG(lport, "Discovery succeeded\n");
699 break;
700 case DISC_EV_FAILED:
701 printk(KERN_ERR "host%d: libfc: "
702 "Discovery failed for port (%6.6x)\n",
703 lport->host->host_no, lport->port_id);
704 mutex_lock(&lport->lp_mutex);
705 fc_lport_enter_reset(lport);
706 mutex_unlock(&lport->lp_mutex);
707 break;
708 case DISC_EV_NONE:
709 WARN_ON(1);
710 break;
711 }
712 }
713
714 /**
715 * fc_lport_enter_ready() - Enter the ready state and start discovery
716 * @lport: The local port that is ready
717 */
fc_lport_enter_ready(struct fc_lport * lport)718 static void fc_lport_enter_ready(struct fc_lport *lport)
719 {
720 lockdep_assert_held(&lport->lp_mutex);
721
722 FC_LPORT_DBG(lport, "Entered READY from state %s\n",
723 fc_lport_state(lport));
724
725 fc_lport_state_enter(lport, LPORT_ST_READY);
726 if (lport->vport)
727 fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE);
728 fc_vports_linkchange(lport);
729
730 if (!lport->ptp_rdata)
731 lport->tt.disc_start(fc_lport_disc_callback, lport);
732 }
733
734 /**
735 * fc_lport_set_port_id() - set the local port Port ID
736 * @lport: The local port which will have its Port ID set.
737 * @port_id: The new port ID.
738 * @fp: The frame containing the incoming request, or NULL.
739 */
fc_lport_set_port_id(struct fc_lport * lport,u32 port_id,struct fc_frame * fp)740 static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id,
741 struct fc_frame *fp)
742 {
743 lockdep_assert_held(&lport->lp_mutex);
744
745 if (port_id)
746 printk(KERN_INFO "host%d: Assigned Port ID %6.6x\n",
747 lport->host->host_no, port_id);
748
749 lport->port_id = port_id;
750
751 /* Update the fc_host */
752 fc_host_port_id(lport->host) = port_id;
753
754 if (lport->tt.lport_set_port_id)
755 lport->tt.lport_set_port_id(lport, port_id, fp);
756 }
757
758 /**
759 * fc_lport_set_local_id() - set the local port Port ID for point-to-multipoint
760 * @lport: The local port which will have its Port ID set.
761 * @port_id: The new port ID.
762 *
763 * Called by the lower-level driver when transport sets the local port_id.
764 * This is used in VN_port to VN_port mode for FCoE, and causes FLOGI and
765 * discovery to be skipped.
766 */
fc_lport_set_local_id(struct fc_lport * lport,u32 port_id)767 void fc_lport_set_local_id(struct fc_lport *lport, u32 port_id)
768 {
769 mutex_lock(&lport->lp_mutex);
770
771 fc_lport_set_port_id(lport, port_id, NULL);
772
773 switch (lport->state) {
774 case LPORT_ST_RESET:
775 case LPORT_ST_FLOGI:
776 if (port_id)
777 fc_lport_enter_ready(lport);
778 break;
779 default:
780 break;
781 }
782 mutex_unlock(&lport->lp_mutex);
783 }
784 EXPORT_SYMBOL(fc_lport_set_local_id);
785
786 /**
787 * fc_lport_recv_flogi_req() - Receive a FLOGI request
788 * @lport: The local port that received the request
789 * @rx_fp: The FLOGI frame
790 *
791 * A received FLOGI request indicates a point-to-point connection.
792 * Accept it with the common service parameters indicating our N port.
793 * Set up to do a PLOGI if we have the higher-number WWPN.
794 */
fc_lport_recv_flogi_req(struct fc_lport * lport,struct fc_frame * rx_fp)795 static void fc_lport_recv_flogi_req(struct fc_lport *lport,
796 struct fc_frame *rx_fp)
797 {
798 struct fc_frame *fp;
799 struct fc_frame_header *fh;
800 struct fc_els_flogi *flp;
801 struct fc_els_flogi *new_flp;
802 u64 remote_wwpn;
803 u32 remote_fid;
804 u32 local_fid;
805
806 lockdep_assert_held(&lport->lp_mutex);
807
808 FC_LPORT_DBG(lport, "Received FLOGI request while in state %s\n",
809 fc_lport_state(lport));
810
811 remote_fid = fc_frame_sid(rx_fp);
812 flp = fc_frame_payload_get(rx_fp, sizeof(*flp));
813 if (!flp)
814 goto out;
815 remote_wwpn = get_unaligned_be64(&flp->fl_wwpn);
816 if (remote_wwpn == lport->wwpn) {
817 printk(KERN_WARNING "host%d: libfc: Received FLOGI from port "
818 "with same WWPN %16.16llx\n",
819 lport->host->host_no, remote_wwpn);
820 goto out;
821 }
822 FC_LPORT_DBG(lport, "FLOGI from port WWPN %16.16llx\n", remote_wwpn);
823
824 /*
825 * XXX what is the right thing to do for FIDs?
826 * The originator might expect our S_ID to be 0xfffffe.
827 * But if so, both of us could end up with the same FID.
828 */
829 local_fid = FC_LOCAL_PTP_FID_LO;
830 if (remote_wwpn < lport->wwpn) {
831 local_fid = FC_LOCAL_PTP_FID_HI;
832 if (!remote_fid || remote_fid == local_fid)
833 remote_fid = FC_LOCAL_PTP_FID_LO;
834 } else if (!remote_fid) {
835 remote_fid = FC_LOCAL_PTP_FID_HI;
836 }
837
838 fc_lport_set_port_id(lport, local_fid, rx_fp);
839
840 fp = fc_frame_alloc(lport, sizeof(*flp));
841 if (fp) {
842 new_flp = fc_frame_payload_get(fp, sizeof(*flp));
843 fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI);
844 new_flp->fl_cmd = (u8) ELS_LS_ACC;
845
846 /*
847 * Send the response. If this fails, the originator should
848 * repeat the sequence.
849 */
850 fc_fill_reply_hdr(fp, rx_fp, FC_RCTL_ELS_REP, 0);
851 fh = fc_frame_header_get(fp);
852 hton24(fh->fh_s_id, local_fid);
853 hton24(fh->fh_d_id, remote_fid);
854 lport->tt.frame_send(lport, fp);
855
856 } else {
857 fc_lport_error(lport, fp);
858 }
859 fc_lport_ptp_setup(lport, remote_fid, remote_wwpn,
860 get_unaligned_be64(&flp->fl_wwnn));
861 out:
862 fc_frame_free(rx_fp);
863 }
864
865 /**
866 * fc_lport_recv_els_req() - The generic lport ELS request handler
867 * @lport: The local port that received the request
868 * @fp: The request frame
869 *
870 * This function will see if the lport handles the request or
871 * if an rport should handle the request.
872 *
873 * Locking Note: This function should not be called with the lport
874 * lock held because it will grab the lock.
875 */
fc_lport_recv_els_req(struct fc_lport * lport,struct fc_frame * fp)876 static void fc_lport_recv_els_req(struct fc_lport *lport,
877 struct fc_frame *fp)
878 {
879 mutex_lock(&lport->lp_mutex);
880
881 /*
882 * Handle special ELS cases like FLOGI, LOGO, and
883 * RSCN here. These don't require a session.
884 * Even if we had a session, it might not be ready.
885 */
886 if (!lport->link_up)
887 fc_frame_free(fp);
888 else {
889 /*
890 * Check opcode.
891 */
892 switch (fc_frame_payload_op(fp)) {
893 case ELS_FLOGI:
894 if (!lport->point_to_multipoint)
895 fc_lport_recv_flogi_req(lport, fp);
896 else
897 fc_rport_recv_req(lport, fp);
898 break;
899 case ELS_LOGO:
900 if (fc_frame_sid(fp) == FC_FID_FLOGI)
901 fc_lport_recv_logo_req(lport, fp);
902 else
903 fc_rport_recv_req(lport, fp);
904 break;
905 case ELS_RSCN:
906 lport->tt.disc_recv_req(lport, fp);
907 break;
908 case ELS_ECHO:
909 fc_lport_recv_echo_req(lport, fp);
910 break;
911 case ELS_RLIR:
912 fc_lport_recv_rlir_req(lport, fp);
913 break;
914 case ELS_RNID:
915 fc_lport_recv_rnid_req(lport, fp);
916 break;
917 default:
918 fc_rport_recv_req(lport, fp);
919 break;
920 }
921 }
922 mutex_unlock(&lport->lp_mutex);
923 }
924
fc_lport_els_prli(struct fc_rport_priv * rdata,u32 spp_len,const struct fc_els_spp * spp_in,struct fc_els_spp * spp_out)925 static int fc_lport_els_prli(struct fc_rport_priv *rdata, u32 spp_len,
926 const struct fc_els_spp *spp_in,
927 struct fc_els_spp *spp_out)
928 {
929 return FC_SPP_RESP_INVL;
930 }
931
932 struct fc4_prov fc_lport_els_prov = {
933 .prli = fc_lport_els_prli,
934 .recv = fc_lport_recv_els_req,
935 };
936
937 /**
938 * fc_lport_recv() - The generic lport request handler
939 * @lport: The lport that received the request
940 * @fp: The frame the request is in
941 *
942 * Locking Note: This function should not be called with the lport
943 * lock held because it may grab the lock.
944 */
fc_lport_recv(struct fc_lport * lport,struct fc_frame * fp)945 void fc_lport_recv(struct fc_lport *lport, struct fc_frame *fp)
946 {
947 struct fc_frame_header *fh = fc_frame_header_get(fp);
948 struct fc_seq *sp = fr_seq(fp);
949 struct fc4_prov *prov;
950
951 /*
952 * Use RCU read lock and module_lock to be sure module doesn't
953 * deregister and get unloaded while we're calling it.
954 * try_module_get() is inlined and accepts a NULL parameter.
955 * Only ELSes and FCP target ops should come through here.
956 * The locking is unfortunate, and a better scheme is being sought.
957 */
958
959 rcu_read_lock();
960 if (fh->fh_type >= FC_FC4_PROV_SIZE)
961 goto drop;
962 prov = rcu_dereference(fc_passive_prov[fh->fh_type]);
963 if (!prov || !try_module_get(prov->module))
964 goto drop;
965 rcu_read_unlock();
966 prov->recv(lport, fp);
967 module_put(prov->module);
968 return;
969 drop:
970 rcu_read_unlock();
971 FC_LPORT_DBG(lport, "dropping unexpected frame type %x\n", fh->fh_type);
972 fc_frame_free(fp);
973 if (sp)
974 fc_exch_done(sp);
975 }
976 EXPORT_SYMBOL(fc_lport_recv);
977
978 /**
979 * fc_lport_reset() - Reset a local port
980 * @lport: The local port which should be reset
981 *
982 * Locking Note: This functions should not be called with the
983 * lport lock held.
984 */
fc_lport_reset(struct fc_lport * lport)985 int fc_lport_reset(struct fc_lport *lport)
986 {
987 cancel_delayed_work_sync(&lport->retry_work);
988 mutex_lock(&lport->lp_mutex);
989 fc_lport_enter_reset(lport);
990 mutex_unlock(&lport->lp_mutex);
991 return 0;
992 }
993 EXPORT_SYMBOL(fc_lport_reset);
994
995 /**
996 * fc_lport_reset_locked() - Reset the local port w/ the lport lock held
997 * @lport: The local port to be reset
998 */
fc_lport_reset_locked(struct fc_lport * lport)999 static void fc_lport_reset_locked(struct fc_lport *lport)
1000 {
1001 lockdep_assert_held(&lport->lp_mutex);
1002
1003 if (lport->dns_rdata) {
1004 fc_rport_logoff(lport->dns_rdata);
1005 lport->dns_rdata = NULL;
1006 }
1007
1008 if (lport->ptp_rdata) {
1009 fc_rport_logoff(lport->ptp_rdata);
1010 kref_put(&lport->ptp_rdata->kref, fc_rport_destroy);
1011 lport->ptp_rdata = NULL;
1012 }
1013
1014 lport->tt.disc_stop(lport);
1015
1016 lport->tt.exch_mgr_reset(lport, 0, 0);
1017 fc_host_fabric_name(lport->host) = 0;
1018
1019 if (lport->port_id && (!lport->point_to_multipoint || !lport->link_up))
1020 fc_lport_set_port_id(lport, 0, NULL);
1021 }
1022
1023 /**
1024 * fc_lport_enter_reset() - Reset the local port
1025 * @lport: The local port to be reset
1026 */
fc_lport_enter_reset(struct fc_lport * lport)1027 static void fc_lport_enter_reset(struct fc_lport *lport)
1028 {
1029 lockdep_assert_held(&lport->lp_mutex);
1030
1031 FC_LPORT_DBG(lport, "Entered RESET state from %s state\n",
1032 fc_lport_state(lport));
1033
1034 if (lport->state == LPORT_ST_DISABLED || lport->state == LPORT_ST_LOGO)
1035 return;
1036
1037 if (lport->vport) {
1038 if (lport->link_up)
1039 fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING);
1040 else
1041 fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN);
1042 }
1043 fc_lport_state_enter(lport, LPORT_ST_RESET);
1044 fc_host_post_event(lport->host, fc_get_event_number(),
1045 FCH_EVT_LIPRESET, 0);
1046 fc_vports_linkchange(lport);
1047 fc_lport_reset_locked(lport);
1048 if (lport->link_up)
1049 fc_lport_enter_flogi(lport);
1050 }
1051
1052 /**
1053 * fc_lport_enter_disabled() - Disable the local port
1054 * @lport: The local port to be reset
1055 */
fc_lport_enter_disabled(struct fc_lport * lport)1056 static void fc_lport_enter_disabled(struct fc_lport *lport)
1057 {
1058 lockdep_assert_held(&lport->lp_mutex);
1059
1060 FC_LPORT_DBG(lport, "Entered disabled state from %s state\n",
1061 fc_lport_state(lport));
1062
1063 fc_lport_state_enter(lport, LPORT_ST_DISABLED);
1064 fc_vports_linkchange(lport);
1065 fc_lport_reset_locked(lport);
1066 }
1067
1068 /**
1069 * fc_lport_error() - Handler for any errors
1070 * @lport: The local port that the error was on
1071 * @fp: The error code encoded in a frame pointer
1072 *
1073 * If the error was caused by a resource allocation failure
1074 * then wait for half a second and retry, otherwise retry
1075 * after the e_d_tov time.
1076 */
fc_lport_error(struct fc_lport * lport,struct fc_frame * fp)1077 static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp)
1078 {
1079 unsigned long delay = 0;
1080 FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d\n",
1081 IS_ERR(fp) ? -PTR_ERR(fp) : 0, fc_lport_state(lport),
1082 lport->retry_count);
1083
1084 if (PTR_ERR(fp) == -FC_EX_CLOSED)
1085 return;
1086
1087 /*
1088 * Memory allocation failure, or the exchange timed out
1089 * or we received LS_RJT.
1090 * Retry after delay
1091 */
1092 if (lport->retry_count < lport->max_retry_count) {
1093 lport->retry_count++;
1094 if (!fp)
1095 delay = msecs_to_jiffies(500);
1096 else
1097 delay = msecs_to_jiffies(lport->e_d_tov);
1098
1099 schedule_delayed_work(&lport->retry_work, delay);
1100 } else
1101 fc_lport_enter_reset(lport);
1102 }
1103
1104 /**
1105 * fc_lport_ns_resp() - Handle response to a name server
1106 * registration exchange
1107 * @sp: current sequence in exchange
1108 * @fp: response frame
1109 * @lp_arg: Fibre Channel host port instance
1110 *
1111 * Locking Note: This function will be called without the lport lock
1112 * held, but it will lock, call an _enter_* function or fc_lport_error()
1113 * and then unlock the lport.
1114 */
fc_lport_ns_resp(struct fc_seq * sp,struct fc_frame * fp,void * lp_arg)1115 static void fc_lport_ns_resp(struct fc_seq *sp, struct fc_frame *fp,
1116 void *lp_arg)
1117 {
1118 struct fc_lport *lport = lp_arg;
1119 struct fc_frame_header *fh;
1120 struct fc_ct_hdr *ct;
1121
1122 FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp));
1123
1124 if (fp == ERR_PTR(-FC_EX_CLOSED))
1125 return;
1126
1127 mutex_lock(&lport->lp_mutex);
1128
1129 if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) {
1130 FC_LPORT_DBG(lport, "Received a name server response, "
1131 "but in state %s\n", fc_lport_state(lport));
1132 if (IS_ERR(fp))
1133 goto err;
1134 goto out;
1135 }
1136
1137 if (IS_ERR(fp)) {
1138 fc_lport_error(lport, fp);
1139 goto err;
1140 }
1141
1142 fh = fc_frame_header_get(fp);
1143 ct = fc_frame_payload_get(fp, sizeof(*ct));
1144
1145 if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1146 ct->ct_fs_type == FC_FST_DIR &&
1147 ct->ct_fs_subtype == FC_NS_SUBTYPE &&
1148 ntohs(ct->ct_cmd) == FC_FS_ACC)
1149 switch (lport->state) {
1150 case LPORT_ST_RNN_ID:
1151 fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN);
1152 break;
1153 case LPORT_ST_RSNN_NN:
1154 fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID);
1155 break;
1156 case LPORT_ST_RSPN_ID:
1157 fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1158 break;
1159 case LPORT_ST_RFT_ID:
1160 fc_lport_enter_ns(lport, LPORT_ST_RFF_ID);
1161 break;
1162 case LPORT_ST_RFF_ID:
1163 if (lport->fdmi_enabled)
1164 fc_lport_enter_fdmi(lport);
1165 else
1166 fc_lport_enter_scr(lport);
1167 break;
1168 default:
1169 /* should have already been caught by state checks */
1170 break;
1171 }
1172 else
1173 fc_lport_error(lport, fp);
1174 out:
1175 fc_frame_free(fp);
1176 err:
1177 mutex_unlock(&lport->lp_mutex);
1178 }
1179
1180 /**
1181 * fc_lport_ms_resp() - Handle response to a management server
1182 * exchange
1183 * @sp: current sequence in exchange
1184 * @fp: response frame
1185 * @lp_arg: Fibre Channel host port instance
1186 *
1187 * Locking Note: This function will be called without the lport lock
1188 * held, but it will lock, call an _enter_* function or fc_lport_error()
1189 * and then unlock the lport.
1190 */
fc_lport_ms_resp(struct fc_seq * sp,struct fc_frame * fp,void * lp_arg)1191 static void fc_lport_ms_resp(struct fc_seq *sp, struct fc_frame *fp,
1192 void *lp_arg)
1193 {
1194 struct fc_lport *lport = lp_arg;
1195 struct fc_frame_header *fh;
1196 struct fc_ct_hdr *ct;
1197 struct fc_host_attrs *fc_host = shost_to_fc_host(lport->host);
1198 FC_LPORT_DBG(lport, "Received a ms %s\n", fc_els_resp_type(fp));
1199
1200 if (fp == ERR_PTR(-FC_EX_CLOSED))
1201 return;
1202
1203 mutex_lock(&lport->lp_mutex);
1204
1205 if (lport->state < LPORT_ST_RHBA || lport->state > LPORT_ST_DPRT) {
1206 FC_LPORT_DBG(lport, "Received a management server response, "
1207 "but in state %s\n", fc_lport_state(lport));
1208 if (IS_ERR(fp))
1209 goto err;
1210 goto out;
1211 }
1212
1213 if (IS_ERR(fp)) {
1214 fc_lport_error(lport, fp);
1215 goto err;
1216 }
1217
1218 fh = fc_frame_header_get(fp);
1219 ct = fc_frame_payload_get(fp, sizeof(*ct));
1220
1221 if (fh && ct && fh->fh_type == FC_TYPE_CT &&
1222 ct->ct_fs_type == FC_FST_MGMT &&
1223 ct->ct_fs_subtype == FC_FDMI_SUBTYPE) {
1224 FC_LPORT_DBG(lport, "Received a management server response, "
1225 "reason=%d explain=%d\n",
1226 ct->ct_reason,
1227 ct->ct_explan);
1228
1229 switch (lport->state) {
1230 case LPORT_ST_RHBA:
1231 if ((ntohs(ct->ct_cmd) == FC_FS_RJT) && fc_host->fdmi_version == FDMI_V2) {
1232 FC_LPORT_DBG(lport, "Error for FDMI-V2, fall back to FDMI-V1\n");
1233 fc_host->fdmi_version = FDMI_V1;
1234
1235 fc_lport_enter_ms(lport, LPORT_ST_RHBA);
1236
1237 } else if (ntohs(ct->ct_cmd) == FC_FS_ACC)
1238 fc_lport_enter_ms(lport, LPORT_ST_RPA);
1239 else /* Error Skip RPA */
1240 fc_lport_enter_scr(lport);
1241 break;
1242 case LPORT_ST_RPA:
1243 fc_lport_enter_scr(lport);
1244 break;
1245 case LPORT_ST_DPRT:
1246 fc_lport_enter_ms(lport, LPORT_ST_RHBA);
1247 break;
1248 case LPORT_ST_DHBA:
1249 fc_lport_enter_ms(lport, LPORT_ST_DPRT);
1250 break;
1251 default:
1252 /* should have already been caught by state checks */
1253 break;
1254 }
1255 } else {
1256 /* Invalid Frame? */
1257 fc_lport_error(lport, fp);
1258 }
1259 out:
1260 fc_frame_free(fp);
1261 err:
1262 mutex_unlock(&lport->lp_mutex);
1263 }
1264
1265 /**
1266 * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request
1267 * @sp: current sequence in SCR exchange
1268 * @fp: response frame
1269 * @lp_arg: Fibre Channel lport port instance that sent the registration request
1270 *
1271 * Locking Note: This function will be called without the lport lock
1272 * held, but it will lock, call an _enter_* function or fc_lport_error
1273 * and then unlock the lport.
1274 */
fc_lport_scr_resp(struct fc_seq * sp,struct fc_frame * fp,void * lp_arg)1275 static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp,
1276 void *lp_arg)
1277 {
1278 struct fc_lport *lport = lp_arg;
1279 u8 op;
1280
1281 FC_LPORT_DBG(lport, "Received a SCR %s\n", fc_els_resp_type(fp));
1282
1283 if (fp == ERR_PTR(-FC_EX_CLOSED))
1284 return;
1285
1286 mutex_lock(&lport->lp_mutex);
1287
1288 if (lport->state != LPORT_ST_SCR) {
1289 FC_LPORT_DBG(lport, "Received a SCR response, but in state "
1290 "%s\n", fc_lport_state(lport));
1291 if (IS_ERR(fp))
1292 goto err;
1293 goto out;
1294 }
1295
1296 if (IS_ERR(fp)) {
1297 fc_lport_error(lport, fp);
1298 goto err;
1299 }
1300
1301 op = fc_frame_payload_op(fp);
1302 if (op == ELS_LS_ACC)
1303 fc_lport_enter_ready(lport);
1304 else
1305 fc_lport_error(lport, fp);
1306
1307 out:
1308 fc_frame_free(fp);
1309 err:
1310 mutex_unlock(&lport->lp_mutex);
1311 }
1312
1313 /**
1314 * fc_lport_enter_scr() - Send a SCR (State Change Register) request
1315 * @lport: The local port to register for state changes
1316 */
fc_lport_enter_scr(struct fc_lport * lport)1317 static void fc_lport_enter_scr(struct fc_lport *lport)
1318 {
1319 struct fc_frame *fp;
1320
1321 lockdep_assert_held(&lport->lp_mutex);
1322
1323 FC_LPORT_DBG(lport, "Entered SCR state from %s state\n",
1324 fc_lport_state(lport));
1325
1326 fc_lport_state_enter(lport, LPORT_ST_SCR);
1327
1328 fp = fc_frame_alloc(lport, sizeof(struct fc_els_scr));
1329 if (!fp) {
1330 fc_lport_error(lport, fp);
1331 return;
1332 }
1333
1334 if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR,
1335 fc_lport_scr_resp, lport,
1336 2 * lport->r_a_tov))
1337 fc_lport_error(lport, NULL);
1338 }
1339
1340 /**
1341 * fc_lport_enter_ns() - register some object with the name server
1342 * @lport: Fibre Channel local port to register
1343 * @state: Local port state
1344 */
fc_lport_enter_ns(struct fc_lport * lport,enum fc_lport_state state)1345 static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state)
1346 {
1347 struct fc_frame *fp;
1348 enum fc_ns_req cmd;
1349 int size = sizeof(struct fc_ct_hdr);
1350 size_t len;
1351
1352 lockdep_assert_held(&lport->lp_mutex);
1353
1354 FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
1355 fc_lport_state_names[state],
1356 fc_lport_state(lport));
1357
1358 fc_lport_state_enter(lport, state);
1359
1360 switch (state) {
1361 case LPORT_ST_RNN_ID:
1362 cmd = FC_NS_RNN_ID;
1363 size += sizeof(struct fc_ns_rn_id);
1364 break;
1365 case LPORT_ST_RSNN_NN:
1366 len = strnlen(fc_host_symbolic_name(lport->host), 255);
1367 /* if there is no symbolic name, skip to RFT_ID */
1368 if (!len)
1369 return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1370 cmd = FC_NS_RSNN_NN;
1371 size += sizeof(struct fc_ns_rsnn) + len;
1372 break;
1373 case LPORT_ST_RSPN_ID:
1374 len = strnlen(fc_host_symbolic_name(lport->host), 255);
1375 /* if there is no symbolic name, skip to RFT_ID */
1376 if (!len)
1377 return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID);
1378 cmd = FC_NS_RSPN_ID;
1379 size += sizeof(struct fc_ns_rspn) + len;
1380 break;
1381 case LPORT_ST_RFT_ID:
1382 cmd = FC_NS_RFT_ID;
1383 size += sizeof(struct fc_ns_rft);
1384 break;
1385 case LPORT_ST_RFF_ID:
1386 cmd = FC_NS_RFF_ID;
1387 size += sizeof(struct fc_ns_rff_id);
1388 break;
1389 default:
1390 fc_lport_error(lport, NULL);
1391 return;
1392 }
1393
1394 fp = fc_frame_alloc(lport, size);
1395 if (!fp) {
1396 fc_lport_error(lport, fp);
1397 return;
1398 }
1399
1400 if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd,
1401 fc_lport_ns_resp,
1402 lport, 3 * lport->r_a_tov))
1403 fc_lport_error(lport, fp);
1404 }
1405
1406 static struct fc_rport_operations fc_lport_rport_ops = {
1407 .event_callback = fc_lport_rport_callback,
1408 };
1409
1410 /**
1411 * fc_lport_enter_dns() - Create a fc_rport for the name server
1412 * @lport: The local port requesting a remote port for the name server
1413 */
fc_lport_enter_dns(struct fc_lport * lport)1414 static void fc_lport_enter_dns(struct fc_lport *lport)
1415 {
1416 struct fc_rport_priv *rdata;
1417
1418 lockdep_assert_held(&lport->lp_mutex);
1419
1420 FC_LPORT_DBG(lport, "Entered DNS state from %s state\n",
1421 fc_lport_state(lport));
1422
1423 fc_lport_state_enter(lport, LPORT_ST_DNS);
1424
1425 mutex_lock(&lport->disc.disc_mutex);
1426 rdata = fc_rport_create(lport, FC_FID_DIR_SERV);
1427 mutex_unlock(&lport->disc.disc_mutex);
1428 if (!rdata)
1429 goto err;
1430
1431 rdata->ops = &fc_lport_rport_ops;
1432 fc_rport_login(rdata);
1433 return;
1434
1435 err:
1436 fc_lport_error(lport, NULL);
1437 }
1438
1439 /**
1440 * fc_lport_enter_ms() - management server commands
1441 * @lport: Fibre Channel local port to register
1442 * @state: Local port state
1443 */
fc_lport_enter_ms(struct fc_lport * lport,enum fc_lport_state state)1444 static void fc_lport_enter_ms(struct fc_lport *lport, enum fc_lport_state state)
1445 {
1446 struct fc_frame *fp;
1447 enum fc_fdmi_req cmd;
1448 int size = sizeof(struct fc_ct_hdr);
1449 size_t len;
1450 int numattrs;
1451 struct fc_host_attrs *fc_host = shost_to_fc_host(lport->host);
1452 lockdep_assert_held(&lport->lp_mutex);
1453
1454 FC_LPORT_DBG(lport, "Entered %s state from %s state\n",
1455 fc_lport_state_names[state],
1456 fc_lport_state(lport));
1457
1458 fc_lport_state_enter(lport, state);
1459
1460 switch (state) {
1461 case LPORT_ST_RHBA:
1462 cmd = FC_FDMI_RHBA;
1463 /* Number of HBA Attributes */
1464 numattrs = 11;
1465 len = sizeof(struct fc_fdmi_rhba);
1466 len -= sizeof(struct fc_fdmi_attr_entry);
1467
1468 len += FC_FDMI_HBA_ATTR_NODENAME_LEN;
1469 len += FC_FDMI_HBA_ATTR_MANUFACTURER_LEN;
1470 len += FC_FDMI_HBA_ATTR_SERIALNUMBER_LEN;
1471 len += FC_FDMI_HBA_ATTR_MODEL_LEN;
1472 len += FC_FDMI_HBA_ATTR_MODELDESCR_LEN;
1473 len += FC_FDMI_HBA_ATTR_HARDWAREVERSION_LEN;
1474 len += FC_FDMI_HBA_ATTR_DRIVERVERSION_LEN;
1475 len += FC_FDMI_HBA_ATTR_OPTIONROMVERSION_LEN;
1476 len += FC_FDMI_HBA_ATTR_FIRMWAREVERSION_LEN;
1477 len += FC_FDMI_HBA_ATTR_OSNAMEVERSION_LEN;
1478 len += FC_FDMI_HBA_ATTR_MAXCTPAYLOAD_LEN;
1479
1480
1481 if (fc_host->fdmi_version == FDMI_V2) {
1482 numattrs += 7;
1483 len += FC_FDMI_HBA_ATTR_NODESYMBLNAME_LEN;
1484 len += FC_FDMI_HBA_ATTR_VENDORSPECIFICINFO_LEN;
1485 len += FC_FDMI_HBA_ATTR_NUMBEROFPORTS_LEN;
1486 len += FC_FDMI_HBA_ATTR_FABRICNAME_LEN;
1487 len += FC_FDMI_HBA_ATTR_BIOSVERSION_LEN;
1488 len += FC_FDMI_HBA_ATTR_BIOSSTATE_LEN;
1489 len += FC_FDMI_HBA_ATTR_VENDORIDENTIFIER_LEN;
1490 }
1491
1492 len += (numattrs * FC_FDMI_ATTR_ENTRY_HEADER_LEN);
1493
1494 size += len;
1495 break;
1496 case LPORT_ST_RPA:
1497 cmd = FC_FDMI_RPA;
1498 /* Number of Port Attributes */
1499 numattrs = 6;
1500 len = sizeof(struct fc_fdmi_rpa);
1501 len -= sizeof(struct fc_fdmi_attr_entry);
1502 len += FC_FDMI_PORT_ATTR_FC4TYPES_LEN;
1503 len += FC_FDMI_PORT_ATTR_SUPPORTEDSPEED_LEN;
1504 len += FC_FDMI_PORT_ATTR_CURRENTPORTSPEED_LEN;
1505 len += FC_FDMI_PORT_ATTR_MAXFRAMESIZE_LEN;
1506 len += FC_FDMI_PORT_ATTR_OSDEVICENAME_LEN;
1507 len += FC_FDMI_PORT_ATTR_HOSTNAME_LEN;
1508
1509 if (fc_host->fdmi_version == FDMI_V2) {
1510 numattrs += 10;
1511 len += FC_FDMI_PORT_ATTR_NODENAME_LEN;
1512 len += FC_FDMI_PORT_ATTR_PORTNAME_LEN;
1513 len += FC_FDMI_PORT_ATTR_SYMBOLICNAME_LEN;
1514 len += FC_FDMI_PORT_ATTR_PORTTYPE_LEN;
1515 len += FC_FDMI_PORT_ATTR_SUPPORTEDCLASSSRVC_LEN;
1516 len += FC_FDMI_PORT_ATTR_FABRICNAME_LEN;
1517 len += FC_FDMI_PORT_ATTR_CURRENTFC4TYPE_LEN;
1518 len += FC_FDMI_PORT_ATTR_PORTSTATE_LEN;
1519 len += FC_FDMI_PORT_ATTR_DISCOVEREDPORTS_LEN;
1520 len += FC_FDMI_PORT_ATTR_PORTID_LEN;
1521 }
1522
1523 len += (numattrs * FC_FDMI_ATTR_ENTRY_HEADER_LEN);
1524
1525 size += len;
1526 break;
1527 case LPORT_ST_DPRT:
1528 cmd = FC_FDMI_DPRT;
1529 len = sizeof(struct fc_fdmi_dprt);
1530 size += len;
1531 break;
1532 case LPORT_ST_DHBA:
1533 cmd = FC_FDMI_DHBA;
1534 len = sizeof(struct fc_fdmi_dhba);
1535 size += len;
1536 break;
1537 default:
1538 fc_lport_error(lport, NULL);
1539 return;
1540 }
1541
1542 FC_LPORT_DBG(lport, "Cmd=0x%x Len %d size %d\n",
1543 cmd, (int)len, size);
1544 fp = fc_frame_alloc(lport, size);
1545 if (!fp) {
1546 fc_lport_error(lport, fp);
1547 return;
1548 }
1549
1550 if (!lport->tt.elsct_send(lport, FC_FID_MGMT_SERV, fp, cmd,
1551 fc_lport_ms_resp,
1552 lport, 3 * lport->r_a_tov))
1553 fc_lport_error(lport, fp);
1554 }
1555
1556 /**
1557 * fc_lport_enter_fdmi() - Create a fc_rport for the management server
1558 * @lport: The local port requesting a remote port for the management server
1559 */
fc_lport_enter_fdmi(struct fc_lport * lport)1560 static void fc_lport_enter_fdmi(struct fc_lport *lport)
1561 {
1562 struct fc_rport_priv *rdata;
1563
1564 lockdep_assert_held(&lport->lp_mutex);
1565
1566 FC_LPORT_DBG(lport, "Entered FDMI state from %s state\n",
1567 fc_lport_state(lport));
1568
1569 fc_lport_state_enter(lport, LPORT_ST_FDMI);
1570
1571 mutex_lock(&lport->disc.disc_mutex);
1572 rdata = fc_rport_create(lport, FC_FID_MGMT_SERV);
1573 mutex_unlock(&lport->disc.disc_mutex);
1574 if (!rdata)
1575 goto err;
1576
1577 rdata->ops = &fc_lport_rport_ops;
1578 fc_rport_login(rdata);
1579 return;
1580
1581 err:
1582 fc_lport_error(lport, NULL);
1583 }
1584
1585 /**
1586 * fc_lport_timeout() - Handler for the retry_work timer
1587 * @work: The work struct of the local port
1588 */
fc_lport_timeout(struct work_struct * work)1589 static void fc_lport_timeout(struct work_struct *work)
1590 {
1591 struct fc_lport *lport =
1592 container_of(work, struct fc_lport,
1593 retry_work.work);
1594 struct fc_host_attrs *fc_host = shost_to_fc_host(lport->host);
1595
1596 mutex_lock(&lport->lp_mutex);
1597
1598 switch (lport->state) {
1599 case LPORT_ST_DISABLED:
1600 break;
1601 case LPORT_ST_READY:
1602 break;
1603 case LPORT_ST_RESET:
1604 break;
1605 case LPORT_ST_FLOGI:
1606 fc_lport_enter_flogi(lport);
1607 break;
1608 case LPORT_ST_DNS:
1609 fc_lport_enter_dns(lport);
1610 break;
1611 case LPORT_ST_RNN_ID:
1612 case LPORT_ST_RSNN_NN:
1613 case LPORT_ST_RSPN_ID:
1614 case LPORT_ST_RFT_ID:
1615 case LPORT_ST_RFF_ID:
1616 fc_lport_enter_ns(lport, lport->state);
1617 break;
1618 case LPORT_ST_FDMI:
1619 fc_lport_enter_fdmi(lport);
1620 break;
1621 case LPORT_ST_RHBA:
1622 if (fc_host->fdmi_version == FDMI_V2) {
1623 FC_LPORT_DBG(lport, "timeout for FDMI-V2 RHBA,fall back to FDMI-V1\n");
1624 fc_host->fdmi_version = FDMI_V1;
1625 fc_lport_enter_ms(lport, LPORT_ST_RHBA);
1626 break;
1627 }
1628 fallthrough;
1629 case LPORT_ST_RPA:
1630 case LPORT_ST_DHBA:
1631 case LPORT_ST_DPRT:
1632 FC_LPORT_DBG(lport, "Skipping lport state %s to SCR\n",
1633 fc_lport_state(lport));
1634 fallthrough;
1635 case LPORT_ST_SCR:
1636 fc_lport_enter_scr(lport);
1637 break;
1638 case LPORT_ST_LOGO:
1639 fc_lport_enter_logo(lport);
1640 break;
1641 }
1642
1643 mutex_unlock(&lport->lp_mutex);
1644 }
1645
1646 /**
1647 * fc_lport_logo_resp() - Handle response to LOGO request
1648 * @sp: The sequence that the LOGO was on
1649 * @fp: The LOGO frame
1650 * @lp_arg: The lport port that received the LOGO request
1651 *
1652 * Locking Note: This function will be called without the lport lock
1653 * held, but it will lock, call an _enter_* function or fc_lport_error()
1654 * and then unlock the lport.
1655 */
fc_lport_logo_resp(struct fc_seq * sp,struct fc_frame * fp,void * lp_arg)1656 void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp,
1657 void *lp_arg)
1658 {
1659 struct fc_lport *lport = lp_arg;
1660 u8 op;
1661
1662 FC_LPORT_DBG(lport, "Received a LOGO %s\n", fc_els_resp_type(fp));
1663
1664 if (fp == ERR_PTR(-FC_EX_CLOSED))
1665 return;
1666
1667 mutex_lock(&lport->lp_mutex);
1668
1669 if (lport->state != LPORT_ST_LOGO) {
1670 FC_LPORT_DBG(lport, "Received a LOGO response, but in state "
1671 "%s\n", fc_lport_state(lport));
1672 if (IS_ERR(fp))
1673 goto err;
1674 goto out;
1675 }
1676
1677 if (IS_ERR(fp)) {
1678 fc_lport_error(lport, fp);
1679 goto err;
1680 }
1681
1682 op = fc_frame_payload_op(fp);
1683 if (op == ELS_LS_ACC)
1684 fc_lport_enter_disabled(lport);
1685 else
1686 fc_lport_error(lport, fp);
1687
1688 out:
1689 fc_frame_free(fp);
1690 err:
1691 mutex_unlock(&lport->lp_mutex);
1692 }
1693 EXPORT_SYMBOL(fc_lport_logo_resp);
1694
1695 /**
1696 * fc_lport_enter_logo() - Logout of the fabric
1697 * @lport: The local port to be logged out
1698 */
fc_lport_enter_logo(struct fc_lport * lport)1699 static void fc_lport_enter_logo(struct fc_lport *lport)
1700 {
1701 struct fc_frame *fp;
1702 struct fc_els_logo *logo;
1703
1704 lockdep_assert_held(&lport->lp_mutex);
1705
1706 FC_LPORT_DBG(lport, "Entered LOGO state from %s state\n",
1707 fc_lport_state(lport));
1708
1709 fc_lport_state_enter(lport, LPORT_ST_LOGO);
1710 fc_vports_linkchange(lport);
1711
1712 fp = fc_frame_alloc(lport, sizeof(*logo));
1713 if (!fp) {
1714 fc_lport_error(lport, fp);
1715 return;
1716 }
1717
1718 if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO,
1719 fc_lport_logo_resp, lport,
1720 2 * lport->r_a_tov))
1721 fc_lport_error(lport, NULL);
1722 }
1723
1724 /**
1725 * fc_lport_flogi_resp() - Handle response to FLOGI request
1726 * @sp: The sequence that the FLOGI was on
1727 * @fp: The FLOGI response frame
1728 * @lp_arg: The lport port that received the FLOGI response
1729 *
1730 * Locking Note: This function will be called without the lport lock
1731 * held, but it will lock, call an _enter_* function or fc_lport_error()
1732 * and then unlock the lport.
1733 */
fc_lport_flogi_resp(struct fc_seq * sp,struct fc_frame * fp,void * lp_arg)1734 void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp,
1735 void *lp_arg)
1736 {
1737 struct fc_lport *lport = lp_arg;
1738 struct fc_frame_header *fh;
1739 struct fc_els_flogi *flp;
1740 u32 did;
1741 u16 csp_flags;
1742 unsigned int r_a_tov;
1743 unsigned int e_d_tov;
1744 u16 mfs;
1745
1746 FC_LPORT_DBG(lport, "Received a FLOGI %s\n", fc_els_resp_type(fp));
1747
1748 if (fp == ERR_PTR(-FC_EX_CLOSED))
1749 return;
1750
1751 mutex_lock(&lport->lp_mutex);
1752
1753 if (lport->state != LPORT_ST_FLOGI) {
1754 FC_LPORT_DBG(lport, "Received a FLOGI response, but in state "
1755 "%s\n", fc_lport_state(lport));
1756 if (IS_ERR(fp))
1757 goto err;
1758 goto out;
1759 }
1760
1761 if (IS_ERR(fp)) {
1762 fc_lport_error(lport, fp);
1763 goto err;
1764 }
1765
1766 fh = fc_frame_header_get(fp);
1767 did = fc_frame_did(fp);
1768 if (fh->fh_r_ctl != FC_RCTL_ELS_REP || did == 0 ||
1769 fc_frame_payload_op(fp) != ELS_LS_ACC) {
1770 FC_LPORT_DBG(lport, "FLOGI not accepted or bad response\n");
1771 fc_lport_error(lport, fp);
1772 goto out;
1773 }
1774
1775 flp = fc_frame_payload_get(fp, sizeof(*flp));
1776 if (!flp) {
1777 FC_LPORT_DBG(lport, "FLOGI bad response\n");
1778 fc_lport_error(lport, fp);
1779 goto out;
1780 }
1781
1782 mfs = ntohs(flp->fl_csp.sp_bb_data) &
1783 FC_SP_BB_DATA_MASK;
1784
1785 if (mfs < FC_SP_MIN_MAX_PAYLOAD || mfs > FC_SP_MAX_MAX_PAYLOAD) {
1786 FC_LPORT_DBG(lport, "FLOGI bad mfs:%hu response, "
1787 "lport->mfs:%u\n", mfs, lport->mfs);
1788 fc_lport_error(lport, fp);
1789 goto out;
1790 }
1791
1792 if (mfs <= lport->mfs) {
1793 lport->mfs = mfs;
1794 fc_host_maxframe_size(lport->host) = mfs;
1795 }
1796
1797 csp_flags = ntohs(flp->fl_csp.sp_features);
1798 r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov);
1799 e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov);
1800 if (csp_flags & FC_SP_FT_EDTR)
1801 e_d_tov /= 1000000;
1802
1803 lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC);
1804
1805 if ((csp_flags & FC_SP_FT_FPORT) == 0) {
1806 if (e_d_tov > lport->e_d_tov)
1807 lport->e_d_tov = e_d_tov;
1808 lport->r_a_tov = 2 * lport->e_d_tov;
1809 fc_lport_set_port_id(lport, did, fp);
1810 printk(KERN_INFO "host%d: libfc: "
1811 "Port (%6.6x) entered "
1812 "point-to-point mode\n",
1813 lport->host->host_no, did);
1814 fc_lport_ptp_setup(lport, fc_frame_sid(fp),
1815 get_unaligned_be64(
1816 &flp->fl_wwpn),
1817 get_unaligned_be64(
1818 &flp->fl_wwnn));
1819 } else {
1820 if (e_d_tov > lport->e_d_tov)
1821 lport->e_d_tov = e_d_tov;
1822 if (r_a_tov > lport->r_a_tov)
1823 lport->r_a_tov = r_a_tov;
1824 fc_host_fabric_name(lport->host) =
1825 get_unaligned_be64(&flp->fl_wwnn);
1826 fc_lport_set_port_id(lport, did, fp);
1827 fc_lport_enter_dns(lport);
1828 }
1829
1830 out:
1831 fc_frame_free(fp);
1832 err:
1833 mutex_unlock(&lport->lp_mutex);
1834 }
1835 EXPORT_SYMBOL(fc_lport_flogi_resp);
1836
1837 /**
1838 * fc_lport_enter_flogi() - Send a FLOGI request to the fabric manager
1839 * @lport: Fibre Channel local port to be logged in to the fabric
1840 */
fc_lport_enter_flogi(struct fc_lport * lport)1841 static void fc_lport_enter_flogi(struct fc_lport *lport)
1842 {
1843 struct fc_frame *fp;
1844
1845 lockdep_assert_held(&lport->lp_mutex);
1846
1847 FC_LPORT_DBG(lport, "Entered FLOGI state from %s state\n",
1848 fc_lport_state(lport));
1849
1850 fc_lport_state_enter(lport, LPORT_ST_FLOGI);
1851
1852 if (lport->point_to_multipoint) {
1853 if (lport->port_id)
1854 fc_lport_enter_ready(lport);
1855 return;
1856 }
1857
1858 fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
1859 if (!fp)
1860 return fc_lport_error(lport, fp);
1861
1862 if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
1863 lport->vport ? ELS_FDISC : ELS_FLOGI,
1864 fc_lport_flogi_resp, lport,
1865 lport->vport ? 2 * lport->r_a_tov :
1866 lport->e_d_tov))
1867 fc_lport_error(lport, NULL);
1868 }
1869
1870 /**
1871 * fc_lport_config() - Configure a fc_lport
1872 * @lport: The local port to be configured
1873 */
fc_lport_config(struct fc_lport * lport)1874 int fc_lport_config(struct fc_lport *lport)
1875 {
1876 INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout);
1877 mutex_init(&lport->lp_mutex);
1878
1879 fc_lport_state_enter(lport, LPORT_ST_DISABLED);
1880
1881 fc_lport_add_fc4_type(lport, FC_TYPE_FCP);
1882 fc_lport_add_fc4_type(lport, FC_TYPE_CT);
1883 fc_fc4_conf_lport_params(lport, FC_TYPE_FCP);
1884
1885 return 0;
1886 }
1887 EXPORT_SYMBOL(fc_lport_config);
1888
1889 /**
1890 * fc_lport_init() - Initialize the lport layer for a local port
1891 * @lport: The local port to initialize the exchange layer for
1892 */
fc_lport_init(struct fc_lport * lport)1893 int fc_lport_init(struct fc_lport *lport)
1894 {
1895 struct fc_host_attrs *fc_host;
1896
1897 fc_host = shost_to_fc_host(lport->host);
1898
1899 /* Set FDMI version to FDMI-2 specification*/
1900 fc_host->fdmi_version = FDMI_V2;
1901
1902 fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT;
1903 fc_host_node_name(lport->host) = lport->wwnn;
1904 fc_host_port_name(lport->host) = lport->wwpn;
1905 fc_host_supported_classes(lport->host) = FC_COS_CLASS3;
1906 memset(fc_host_supported_fc4s(lport->host), 0,
1907 sizeof(fc_host_supported_fc4s(lport->host)));
1908 fc_host_supported_fc4s(lport->host)[2] = 1;
1909 fc_host_supported_fc4s(lport->host)[7] = 1;
1910 fc_host_num_discovered_ports(lport->host) = 4;
1911
1912 /* This value is also unchanging */
1913 memset(fc_host_active_fc4s(lport->host), 0,
1914 sizeof(fc_host_active_fc4s(lport->host)));
1915 fc_host_active_fc4s(lport->host)[2] = 1;
1916 fc_host_active_fc4s(lport->host)[7] = 1;
1917 fc_host_maxframe_size(lport->host) = lport->mfs;
1918 fc_host_supported_speeds(lport->host) = 0;
1919 if (lport->link_supported_speeds & FC_PORTSPEED_1GBIT)
1920 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_1GBIT;
1921 if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT)
1922 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT;
1923 if (lport->link_supported_speeds & FC_PORTSPEED_40GBIT)
1924 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_40GBIT;
1925 if (lport->link_supported_speeds & FC_PORTSPEED_100GBIT)
1926 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_100GBIT;
1927 if (lport->link_supported_speeds & FC_PORTSPEED_25GBIT)
1928 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_25GBIT;
1929 if (lport->link_supported_speeds & FC_PORTSPEED_50GBIT)
1930 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_50GBIT;
1931 if (lport->link_supported_speeds & FC_PORTSPEED_100GBIT)
1932 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_100GBIT;
1933
1934 fc_fc4_add_lport(lport);
1935
1936 fc_host_num_discovered_ports(lport->host) = DISCOVERED_PORTS;
1937 fc_host_port_state(lport->host) = FC_PORTSTATE_ONLINE;
1938 fc_host_max_ct_payload(lport->host) = MAX_CT_PAYLOAD;
1939 fc_host_num_ports(lport->host) = NUMBER_OF_PORTS;
1940 fc_host_bootbios_state(lport->host) = 0X00000000;
1941 snprintf(fc_host_bootbios_version(lport->host),
1942 FC_SYMBOLIC_NAME_SIZE, "%s", "Unknown");
1943
1944 return 0;
1945 }
1946 EXPORT_SYMBOL(fc_lport_init);
1947
1948 /**
1949 * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests
1950 * @sp: The sequence for the FC Passthrough response
1951 * @fp: The response frame
1952 * @info_arg: The BSG info that the response is for
1953 */
fc_lport_bsg_resp(struct fc_seq * sp,struct fc_frame * fp,void * info_arg)1954 static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp,
1955 void *info_arg)
1956 {
1957 struct fc_bsg_info *info = info_arg;
1958 struct bsg_job *job = info->job;
1959 struct fc_bsg_reply *bsg_reply = job->reply;
1960 struct fc_lport *lport = info->lport;
1961 struct fc_frame_header *fh;
1962 size_t len;
1963 void *buf;
1964
1965 if (IS_ERR(fp)) {
1966 bsg_reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ?
1967 -ECONNABORTED : -ETIMEDOUT;
1968 job->reply_len = sizeof(uint32_t);
1969 bsg_job_done(job, bsg_reply->result,
1970 bsg_reply->reply_payload_rcv_len);
1971 kfree(info);
1972 return;
1973 }
1974
1975 mutex_lock(&lport->lp_mutex);
1976 fh = fc_frame_header_get(fp);
1977 len = fr_len(fp) - sizeof(*fh);
1978 buf = fc_frame_payload_get(fp, 0);
1979
1980 if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) {
1981 /* Get the response code from the first frame payload */
1982 unsigned short cmd = (info->rsp_code == FC_FS_ACC) ?
1983 ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) :
1984 (unsigned short)fc_frame_payload_op(fp);
1985
1986 /* Save the reply status of the job */
1987 bsg_reply->reply_data.ctels_reply.status =
1988 (cmd == info->rsp_code) ?
1989 FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT;
1990 }
1991
1992 bsg_reply->reply_payload_rcv_len +=
1993 fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents,
1994 &info->offset, NULL);
1995
1996 if (fr_eof(fp) == FC_EOF_T &&
1997 (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) ==
1998 (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) {
1999 if (bsg_reply->reply_payload_rcv_len >
2000 job->reply_payload.payload_len)
2001 bsg_reply->reply_payload_rcv_len =
2002 job->reply_payload.payload_len;
2003 bsg_reply->result = 0;
2004 bsg_job_done(job, bsg_reply->result,
2005 bsg_reply->reply_payload_rcv_len);
2006 kfree(info);
2007 }
2008 fc_frame_free(fp);
2009 mutex_unlock(&lport->lp_mutex);
2010 }
2011
2012 /**
2013 * fc_lport_els_request() - Send ELS passthrough request
2014 * @job: The BSG Passthrough job
2015 * @lport: The local port sending the request
2016 * @did: The destination port id
2017 * @tov: The timeout period (in ms)
2018 */
fc_lport_els_request(struct bsg_job * job,struct fc_lport * lport,u32 did,u32 tov)2019 static int fc_lport_els_request(struct bsg_job *job,
2020 struct fc_lport *lport,
2021 u32 did, u32 tov)
2022 {
2023 struct fc_bsg_info *info;
2024 struct fc_frame *fp;
2025 struct fc_frame_header *fh;
2026 char *pp;
2027 int len;
2028
2029 lockdep_assert_held(&lport->lp_mutex);
2030
2031 fp = fc_frame_alloc(lport, job->request_payload.payload_len);
2032 if (!fp)
2033 return -ENOMEM;
2034
2035 len = job->request_payload.payload_len;
2036 pp = fc_frame_payload_get(fp, len);
2037
2038 sg_copy_to_buffer(job->request_payload.sg_list,
2039 job->request_payload.sg_cnt,
2040 pp, len);
2041
2042 fh = fc_frame_header_get(fp);
2043 fh->fh_r_ctl = FC_RCTL_ELS_REQ;
2044 hton24(fh->fh_d_id, did);
2045 hton24(fh->fh_s_id, lport->port_id);
2046 fh->fh_type = FC_TYPE_ELS;
2047 hton24(fh->fh_f_ctl, FC_FCTL_REQ);
2048 fh->fh_cs_ctl = 0;
2049 fh->fh_df_ctl = 0;
2050 fh->fh_parm_offset = 0;
2051
2052 info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
2053 if (!info) {
2054 fc_frame_free(fp);
2055 return -ENOMEM;
2056 }
2057
2058 info->job = job;
2059 info->lport = lport;
2060 info->rsp_code = ELS_LS_ACC;
2061 info->nents = job->reply_payload.sg_cnt;
2062 info->sg = job->reply_payload.sg_list;
2063
2064 if (!fc_exch_seq_send(lport, fp, fc_lport_bsg_resp,
2065 NULL, info, tov)) {
2066 kfree(info);
2067 return -ECOMM;
2068 }
2069 return 0;
2070 }
2071
2072 /**
2073 * fc_lport_ct_request() - Send CT Passthrough request
2074 * @job: The BSG Passthrough job
2075 * @lport: The local port sending the request
2076 * @did: The destination FC-ID
2077 * @tov: The timeout period to wait for the response
2078 */
fc_lport_ct_request(struct bsg_job * job,struct fc_lport * lport,u32 did,u32 tov)2079 static int fc_lport_ct_request(struct bsg_job *job,
2080 struct fc_lport *lport, u32 did, u32 tov)
2081 {
2082 struct fc_bsg_info *info;
2083 struct fc_frame *fp;
2084 struct fc_frame_header *fh;
2085 struct fc_ct_req *ct;
2086 size_t len;
2087
2088 lockdep_assert_held(&lport->lp_mutex);
2089
2090 fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) +
2091 job->request_payload.payload_len);
2092 if (!fp)
2093 return -ENOMEM;
2094
2095 len = job->request_payload.payload_len;
2096 ct = fc_frame_payload_get(fp, len);
2097
2098 sg_copy_to_buffer(job->request_payload.sg_list,
2099 job->request_payload.sg_cnt,
2100 ct, len);
2101
2102 fh = fc_frame_header_get(fp);
2103 fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL;
2104 hton24(fh->fh_d_id, did);
2105 hton24(fh->fh_s_id, lport->port_id);
2106 fh->fh_type = FC_TYPE_CT;
2107 hton24(fh->fh_f_ctl, FC_FCTL_REQ);
2108 fh->fh_cs_ctl = 0;
2109 fh->fh_df_ctl = 0;
2110 fh->fh_parm_offset = 0;
2111
2112 info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL);
2113 if (!info) {
2114 fc_frame_free(fp);
2115 return -ENOMEM;
2116 }
2117
2118 info->job = job;
2119 info->lport = lport;
2120 info->rsp_code = FC_FS_ACC;
2121 info->nents = job->reply_payload.sg_cnt;
2122 info->sg = job->reply_payload.sg_list;
2123
2124 if (!fc_exch_seq_send(lport, fp, fc_lport_bsg_resp,
2125 NULL, info, tov)) {
2126 kfree(info);
2127 return -ECOMM;
2128 }
2129 return 0;
2130 }
2131
2132 /**
2133 * fc_lport_bsg_request() - The common entry point for sending
2134 * FC Passthrough requests
2135 * @job: The BSG passthrough job
2136 */
fc_lport_bsg_request(struct bsg_job * job)2137 int fc_lport_bsg_request(struct bsg_job *job)
2138 {
2139 struct fc_bsg_request *bsg_request = job->request;
2140 struct fc_bsg_reply *bsg_reply = job->reply;
2141 struct Scsi_Host *shost = fc_bsg_to_shost(job);
2142 struct fc_lport *lport = shost_priv(shost);
2143 struct fc_rport *rport;
2144 struct fc_rport_priv *rdata;
2145 int rc = -EINVAL;
2146 u32 did, tov;
2147
2148 bsg_reply->reply_payload_rcv_len = 0;
2149
2150 mutex_lock(&lport->lp_mutex);
2151
2152 switch (bsg_request->msgcode) {
2153 case FC_BSG_RPT_ELS:
2154 rport = fc_bsg_to_rport(job);
2155 if (!rport)
2156 break;
2157
2158 rdata = rport->dd_data;
2159 rc = fc_lport_els_request(job, lport, rport->port_id,
2160 rdata->e_d_tov);
2161 break;
2162
2163 case FC_BSG_RPT_CT:
2164 rport = fc_bsg_to_rport(job);
2165 if (!rport)
2166 break;
2167
2168 rdata = rport->dd_data;
2169 rc = fc_lport_ct_request(job, lport, rport->port_id,
2170 rdata->e_d_tov);
2171 break;
2172
2173 case FC_BSG_HST_CT:
2174 did = ntoh24(bsg_request->rqst_data.h_ct.port_id);
2175 if (did == FC_FID_DIR_SERV) {
2176 rdata = lport->dns_rdata;
2177 if (!rdata)
2178 break;
2179 tov = rdata->e_d_tov;
2180 } else {
2181 rdata = fc_rport_lookup(lport, did);
2182 if (!rdata)
2183 break;
2184 tov = rdata->e_d_tov;
2185 kref_put(&rdata->kref, fc_rport_destroy);
2186 }
2187
2188 rc = fc_lport_ct_request(job, lport, did, tov);
2189 break;
2190
2191 case FC_BSG_HST_ELS_NOLOGIN:
2192 did = ntoh24(bsg_request->rqst_data.h_els.port_id);
2193 rc = fc_lport_els_request(job, lport, did, lport->e_d_tov);
2194 break;
2195 }
2196
2197 mutex_unlock(&lport->lp_mutex);
2198 return rc;
2199 }
2200 EXPORT_SYMBOL(fc_lport_bsg_request);
2201