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