1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <linux/types.h>
22#include <linux/module.h>
23#include <linux/kernel.h>
24#include <linux/list.h>
25#include <linux/spinlock.h>
26#include <linux/timer.h>
27#include <linux/netdevice.h>
28#include <linux/etherdevice.h>
29#include <linux/ethtool.h>
30#include <linux/if_ether.h>
31#include <linux/if_vlan.h>
32#include <linux/errno.h>
33#include <linux/bitops.h>
34#include <linux/slab.h>
35#include <net/rtnetlink.h>
36
37#include <scsi/fc/fc_els.h>
38#include <scsi/fc/fc_fs.h>
39#include <scsi/fc/fc_fip.h>
40#include <scsi/fc/fc_encaps.h>
41#include <scsi/fc/fc_fcoe.h>
42#include <scsi/fc/fc_fcp.h>
43
44#include <scsi/libfc.h>
45#include <scsi/libfcoe.h>
46
47#include "libfcoe.h"
48
49#define FCOE_CTLR_MIN_FKA 500
50#define FCOE_CTLR_DEF_FKA FIP_DEF_FKA
51
52static void fcoe_ctlr_timeout(unsigned long);
53static void fcoe_ctlr_timer_work(struct work_struct *);
54static void fcoe_ctlr_recv_work(struct work_struct *);
55static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *);
56
57static void fcoe_ctlr_vn_start(struct fcoe_ctlr *);
58static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *, struct sk_buff *);
59static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *);
60static int fcoe_ctlr_vn_lookup(struct fcoe_ctlr *, u32, u8 *);
61
62static u8 fcoe_all_fcfs[ETH_ALEN] = FIP_ALL_FCF_MACS;
63static u8 fcoe_all_enode[ETH_ALEN] = FIP_ALL_ENODE_MACS;
64static u8 fcoe_all_vn2vn[ETH_ALEN] = FIP_ALL_VN2VN_MACS;
65static u8 fcoe_all_p2p[ETH_ALEN] = FIP_ALL_P2P_MACS;
66
67static const char * const fcoe_ctlr_states[] = {
68 [FIP_ST_DISABLED] = "DISABLED",
69 [FIP_ST_LINK_WAIT] = "LINK_WAIT",
70 [FIP_ST_AUTO] = "AUTO",
71 [FIP_ST_NON_FIP] = "NON_FIP",
72 [FIP_ST_ENABLED] = "ENABLED",
73 [FIP_ST_VNMP_START] = "VNMP_START",
74 [FIP_ST_VNMP_PROBE1] = "VNMP_PROBE1",
75 [FIP_ST_VNMP_PROBE2] = "VNMP_PROBE2",
76 [FIP_ST_VNMP_CLAIM] = "VNMP_CLAIM",
77 [FIP_ST_VNMP_UP] = "VNMP_UP",
78};
79
80static const char *fcoe_ctlr_state(enum fip_state state)
81{
82 const char *cp = "unknown";
83
84 if (state < ARRAY_SIZE(fcoe_ctlr_states))
85 cp = fcoe_ctlr_states[state];
86 if (!cp)
87 cp = "unknown";
88 return cp;
89}
90
91
92
93
94
95
96static void fcoe_ctlr_set_state(struct fcoe_ctlr *fip, enum fip_state state)
97{
98 if (state == fip->state)
99 return;
100 if (fip->lp)
101 LIBFCOE_FIP_DBG(fip, "state %s -> %s\n",
102 fcoe_ctlr_state(fip->state), fcoe_ctlr_state(state));
103 fip->state = state;
104}
105
106
107
108
109
110
111
112static inline int fcoe_ctlr_mtu_valid(const struct fcoe_fcf *fcf)
113{
114 return (fcf->flags & FIP_FL_SOL) != 0;
115}
116
117
118
119
120
121
122
123static inline int fcoe_ctlr_fcf_usable(struct fcoe_fcf *fcf)
124{
125 u16 flags = FIP_FL_SOL | FIP_FL_AVAIL;
126
127 return (fcf->flags & flags) == flags;
128}
129
130
131
132
133
134static void fcoe_ctlr_map_dest(struct fcoe_ctlr *fip)
135{
136 if (fip->mode == FIP_MODE_VN2VN)
137 hton24(fip->dest_addr, FIP_VN_FC_MAP);
138 else
139 hton24(fip->dest_addr, FIP_DEF_FC_MAP);
140 hton24(fip->dest_addr + 3, 0);
141 fip->map_dest = 1;
142}
143
144
145
146
147
148void fcoe_ctlr_init(struct fcoe_ctlr *fip, enum fip_state mode)
149{
150 fcoe_ctlr_set_state(fip, FIP_ST_LINK_WAIT);
151 fip->mode = mode;
152 INIT_LIST_HEAD(&fip->fcfs);
153 mutex_init(&fip->ctlr_mutex);
154 spin_lock_init(&fip->ctlr_lock);
155 fip->flogi_oxid = FC_XID_UNKNOWN;
156 setup_timer(&fip->timer, fcoe_ctlr_timeout, (unsigned long)fip);
157 INIT_WORK(&fip->timer_work, fcoe_ctlr_timer_work);
158 INIT_WORK(&fip->recv_work, fcoe_ctlr_recv_work);
159 skb_queue_head_init(&fip->fip_recv_list);
160}
161EXPORT_SYMBOL(fcoe_ctlr_init);
162
163static int fcoe_sysfs_fcf_add(struct fcoe_fcf *new)
164{
165 struct fcoe_ctlr *fip = new->fip;
166 struct fcoe_ctlr_device *ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
167 struct fcoe_fcf_device temp, *fcf_dev;
168 int rc = 0;
169
170 LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",
171 new->fabric_name, new->fcf_mac);
172
173 mutex_lock(&ctlr_dev->lock);
174
175 temp.fabric_name = new->fabric_name;
176 temp.switch_name = new->switch_name;
177 temp.fc_map = new->fc_map;
178 temp.vfid = new->vfid;
179 memcpy(temp.mac, new->fcf_mac, ETH_ALEN);
180 temp.priority = new->pri;
181 temp.fka_period = new->fka_period;
182 temp.selected = 0;
183
184 fcf_dev = fcoe_fcf_device_add(ctlr_dev, &temp);
185 if (unlikely(!fcf_dev)) {
186 rc = -ENOMEM;
187 goto out;
188 }
189
190
191
192
193
194
195
196
197
198
199
200 BUG_ON(fcf_dev->priv);
201
202 fcf_dev->priv = new;
203 new->fcf_dev = fcf_dev;
204
205 list_add(&new->list, &fip->fcfs);
206 fip->fcf_count++;
207
208out:
209 mutex_unlock(&ctlr_dev->lock);
210 return rc;
211}
212
213static void fcoe_sysfs_fcf_del(struct fcoe_fcf *new)
214{
215 struct fcoe_ctlr *fip = new->fip;
216 struct fcoe_ctlr_device *ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
217 struct fcoe_fcf_device *fcf_dev;
218
219 list_del(&new->list);
220 fip->fcf_count--;
221
222 mutex_lock(&ctlr_dev->lock);
223
224 fcf_dev = fcoe_fcf_to_fcf_dev(new);
225 WARN_ON(!fcf_dev);
226 new->fcf_dev = NULL;
227 fcoe_fcf_device_delete(fcf_dev);
228 kfree(new);
229
230 mutex_unlock(&ctlr_dev->lock);
231}
232
233
234
235
236
237
238
239static void fcoe_ctlr_reset_fcfs(struct fcoe_ctlr *fip)
240{
241 struct fcoe_fcf *fcf;
242 struct fcoe_fcf *next;
243
244 fip->sel_fcf = NULL;
245 list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {
246 fcoe_sysfs_fcf_del(fcf);
247 }
248 WARN_ON(fip->fcf_count);
249
250 fip->sel_time = 0;
251}
252
253
254
255
256
257
258
259
260
261
262
263
264
265void fcoe_ctlr_destroy(struct fcoe_ctlr *fip)
266{
267 cancel_work_sync(&fip->recv_work);
268 skb_queue_purge(&fip->fip_recv_list);
269
270 mutex_lock(&fip->ctlr_mutex);
271 fcoe_ctlr_set_state(fip, FIP_ST_DISABLED);
272 fcoe_ctlr_reset_fcfs(fip);
273 mutex_unlock(&fip->ctlr_mutex);
274 del_timer_sync(&fip->timer);
275 cancel_work_sync(&fip->timer_work);
276}
277EXPORT_SYMBOL(fcoe_ctlr_destroy);
278
279
280
281
282
283
284
285
286
287static void fcoe_ctlr_announce(struct fcoe_ctlr *fip)
288{
289 struct fcoe_fcf *sel;
290 struct fcoe_fcf *fcf;
291
292 mutex_lock(&fip->ctlr_mutex);
293 spin_lock_bh(&fip->ctlr_lock);
294
295 kfree_skb(fip->flogi_req);
296 fip->flogi_req = NULL;
297 list_for_each_entry(fcf, &fip->fcfs, list)
298 fcf->flogi_sent = 0;
299
300 spin_unlock_bh(&fip->ctlr_lock);
301 sel = fip->sel_fcf;
302
303 if (sel && !compare_ether_addr(sel->fcf_mac, fip->dest_addr))
304 goto unlock;
305 if (!is_zero_ether_addr(fip->dest_addr)) {
306 printk(KERN_NOTICE "libfcoe: host%d: "
307 "FIP Fibre-Channel Forwarder MAC %pM deselected\n",
308 fip->lp->host->host_no, fip->dest_addr);
309 memset(fip->dest_addr, 0, ETH_ALEN);
310 }
311 if (sel) {
312 printk(KERN_INFO "libfcoe: host%d: FIP selected "
313 "Fibre-Channel Forwarder MAC %pM\n",
314 fip->lp->host->host_no, sel->fcf_mac);
315 memcpy(fip->dest_addr, sel->fcoe_mac, ETH_ALEN);
316 fip->map_dest = 0;
317 }
318unlock:
319 mutex_unlock(&fip->ctlr_mutex);
320}
321
322
323
324
325
326
327
328
329static inline u32 fcoe_ctlr_fcoe_size(struct fcoe_ctlr *fip)
330{
331
332
333
334
335
336 return fip->lp->mfs + sizeof(struct fc_frame_header) +
337 sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof);
338}
339
340
341
342
343
344
345static void fcoe_ctlr_solicit(struct fcoe_ctlr *fip, struct fcoe_fcf *fcf)
346{
347 struct sk_buff *skb;
348 struct fip_sol {
349 struct ethhdr eth;
350 struct fip_header fip;
351 struct {
352 struct fip_mac_desc mac;
353 struct fip_wwn_desc wwnn;
354 struct fip_size_desc size;
355 } __packed desc;
356 } __packed * sol;
357 u32 fcoe_size;
358
359 skb = dev_alloc_skb(sizeof(*sol));
360 if (!skb)
361 return;
362
363 sol = (struct fip_sol *)skb->data;
364
365 memset(sol, 0, sizeof(*sol));
366 memcpy(sol->eth.h_dest, fcf ? fcf->fcf_mac : fcoe_all_fcfs, ETH_ALEN);
367 memcpy(sol->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
368 sol->eth.h_proto = htons(ETH_P_FIP);
369
370 sol->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
371 sol->fip.fip_op = htons(FIP_OP_DISC);
372 sol->fip.fip_subcode = FIP_SC_SOL;
373 sol->fip.fip_dl_len = htons(sizeof(sol->desc) / FIP_BPW);
374 sol->fip.fip_flags = htons(FIP_FL_FPMA);
375 if (fip->spma)
376 sol->fip.fip_flags |= htons(FIP_FL_SPMA);
377
378 sol->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
379 sol->desc.mac.fd_desc.fip_dlen = sizeof(sol->desc.mac) / FIP_BPW;
380 memcpy(sol->desc.mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
381
382 sol->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
383 sol->desc.wwnn.fd_desc.fip_dlen = sizeof(sol->desc.wwnn) / FIP_BPW;
384 put_unaligned_be64(fip->lp->wwnn, &sol->desc.wwnn.fd_wwn);
385
386 fcoe_size = fcoe_ctlr_fcoe_size(fip);
387 sol->desc.size.fd_desc.fip_dtype = FIP_DT_FCOE_SIZE;
388 sol->desc.size.fd_desc.fip_dlen = sizeof(sol->desc.size) / FIP_BPW;
389 sol->desc.size.fd_size = htons(fcoe_size);
390
391 skb_put(skb, sizeof(*sol));
392 skb->protocol = htons(ETH_P_FIP);
393 skb->priority = fip->priority;
394 skb_reset_mac_header(skb);
395 skb_reset_network_header(skb);
396 fip->send(fip, skb);
397
398 if (!fcf)
399 fip->sol_time = jiffies;
400}
401
402
403
404
405
406
407
408void fcoe_ctlr_link_up(struct fcoe_ctlr *fip)
409{
410 mutex_lock(&fip->ctlr_mutex);
411 if (fip->state == FIP_ST_NON_FIP || fip->state == FIP_ST_AUTO) {
412 mutex_unlock(&fip->ctlr_mutex);
413 fc_linkup(fip->lp);
414 } else if (fip->state == FIP_ST_LINK_WAIT) {
415 fcoe_ctlr_set_state(fip, fip->mode);
416 switch (fip->mode) {
417 default:
418 LIBFCOE_FIP_DBG(fip, "invalid mode %d\n", fip->mode);
419
420 case FIP_MODE_AUTO:
421 LIBFCOE_FIP_DBG(fip, "%s", "setting AUTO mode.\n");
422
423 case FIP_MODE_FABRIC:
424 case FIP_MODE_NON_FIP:
425 mutex_unlock(&fip->ctlr_mutex);
426 fc_linkup(fip->lp);
427 fcoe_ctlr_solicit(fip, NULL);
428 break;
429 case FIP_MODE_VN2VN:
430 fcoe_ctlr_vn_start(fip);
431 mutex_unlock(&fip->ctlr_mutex);
432 fc_linkup(fip->lp);
433 break;
434 }
435 } else
436 mutex_unlock(&fip->ctlr_mutex);
437}
438EXPORT_SYMBOL(fcoe_ctlr_link_up);
439
440
441
442
443
444static void fcoe_ctlr_reset(struct fcoe_ctlr *fip)
445{
446 fcoe_ctlr_reset_fcfs(fip);
447 del_timer(&fip->timer);
448 fip->ctlr_ka_time = 0;
449 fip->port_ka_time = 0;
450 fip->sol_time = 0;
451 fip->flogi_oxid = FC_XID_UNKNOWN;
452 fcoe_ctlr_map_dest(fip);
453}
454
455
456
457
458
459
460
461
462
463
464int fcoe_ctlr_link_down(struct fcoe_ctlr *fip)
465{
466 int link_dropped;
467
468 LIBFCOE_FIP_DBG(fip, "link down.\n");
469 mutex_lock(&fip->ctlr_mutex);
470 fcoe_ctlr_reset(fip);
471 link_dropped = fip->state != FIP_ST_LINK_WAIT;
472 fcoe_ctlr_set_state(fip, FIP_ST_LINK_WAIT);
473 mutex_unlock(&fip->ctlr_mutex);
474
475 if (link_dropped)
476 fc_linkdown(fip->lp);
477 return link_dropped;
478}
479EXPORT_SYMBOL(fcoe_ctlr_link_down);
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip,
496 struct fc_lport *lport,
497 int ports, u8 *sa)
498{
499 struct sk_buff *skb;
500 struct fip_kal {
501 struct ethhdr eth;
502 struct fip_header fip;
503 struct fip_mac_desc mac;
504 } __packed * kal;
505 struct fip_vn_desc *vn;
506 u32 len;
507 struct fc_lport *lp;
508 struct fcoe_fcf *fcf;
509
510 fcf = fip->sel_fcf;
511 lp = fip->lp;
512 if (!fcf || (ports && !lp->port_id))
513 return;
514
515 len = sizeof(*kal) + ports * sizeof(*vn);
516 skb = dev_alloc_skb(len);
517 if (!skb)
518 return;
519
520 kal = (struct fip_kal *)skb->data;
521 memset(kal, 0, len);
522 memcpy(kal->eth.h_dest, fcf->fcf_mac, ETH_ALEN);
523 memcpy(kal->eth.h_source, sa, ETH_ALEN);
524 kal->eth.h_proto = htons(ETH_P_FIP);
525
526 kal->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
527 kal->fip.fip_op = htons(FIP_OP_CTRL);
528 kal->fip.fip_subcode = FIP_SC_KEEP_ALIVE;
529 kal->fip.fip_dl_len = htons((sizeof(kal->mac) +
530 ports * sizeof(*vn)) / FIP_BPW);
531 kal->fip.fip_flags = htons(FIP_FL_FPMA);
532 if (fip->spma)
533 kal->fip.fip_flags |= htons(FIP_FL_SPMA);
534
535 kal->mac.fd_desc.fip_dtype = FIP_DT_MAC;
536 kal->mac.fd_desc.fip_dlen = sizeof(kal->mac) / FIP_BPW;
537 memcpy(kal->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
538 if (ports) {
539 vn = (struct fip_vn_desc *)(kal + 1);
540 vn->fd_desc.fip_dtype = FIP_DT_VN_ID;
541 vn->fd_desc.fip_dlen = sizeof(*vn) / FIP_BPW;
542 memcpy(vn->fd_mac, fip->get_src_addr(lport), ETH_ALEN);
543 hton24(vn->fd_fc_id, lport->port_id);
544 put_unaligned_be64(lport->wwpn, &vn->fd_wwpn);
545 }
546 skb_put(skb, len);
547 skb->protocol = htons(ETH_P_FIP);
548 skb->priority = fip->priority;
549 skb_reset_mac_header(skb);
550 skb_reset_network_header(skb);
551 fip->send(fip, skb);
552}
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip, struct fc_lport *lport,
570 u8 dtype, struct sk_buff *skb, u32 d_id)
571{
572 struct fip_encaps_head {
573 struct ethhdr eth;
574 struct fip_header fip;
575 struct fip_encaps encaps;
576 } __packed * cap;
577 struct fc_frame_header *fh;
578 struct fip_mac_desc *mac;
579 struct fcoe_fcf *fcf;
580 size_t dlen;
581 u16 fip_flags;
582 u8 op;
583
584 fh = (struct fc_frame_header *)skb->data;
585 op = *(u8 *)(fh + 1);
586 dlen = sizeof(struct fip_encaps) + skb->len;
587 cap = (struct fip_encaps_head *)skb_push(skb, sizeof(*cap));
588 memset(cap, 0, sizeof(*cap));
589
590 if (lport->point_to_multipoint) {
591 if (fcoe_ctlr_vn_lookup(fip, d_id, cap->eth.h_dest))
592 return -ENODEV;
593 fip_flags = 0;
594 } else {
595 fcf = fip->sel_fcf;
596 if (!fcf)
597 return -ENODEV;
598 fip_flags = fcf->flags;
599 fip_flags &= fip->spma ? FIP_FL_SPMA | FIP_FL_FPMA :
600 FIP_FL_FPMA;
601 if (!fip_flags)
602 return -ENODEV;
603 memcpy(cap->eth.h_dest, fcf->fcf_mac, ETH_ALEN);
604 }
605 memcpy(cap->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
606 cap->eth.h_proto = htons(ETH_P_FIP);
607
608 cap->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
609 cap->fip.fip_op = htons(FIP_OP_LS);
610 if (op == ELS_LS_ACC || op == ELS_LS_RJT)
611 cap->fip.fip_subcode = FIP_SC_REP;
612 else
613 cap->fip.fip_subcode = FIP_SC_REQ;
614 cap->fip.fip_flags = htons(fip_flags);
615
616 cap->encaps.fd_desc.fip_dtype = dtype;
617 cap->encaps.fd_desc.fip_dlen = dlen / FIP_BPW;
618
619 if (op != ELS_LS_RJT) {
620 dlen += sizeof(*mac);
621 mac = (struct fip_mac_desc *)skb_put(skb, sizeof(*mac));
622 memset(mac, 0, sizeof(*mac));
623 mac->fd_desc.fip_dtype = FIP_DT_MAC;
624 mac->fd_desc.fip_dlen = sizeof(*mac) / FIP_BPW;
625 if (dtype != FIP_DT_FLOGI && dtype != FIP_DT_FDISC) {
626 memcpy(mac->fd_mac, fip->get_src_addr(lport), ETH_ALEN);
627 } else if (fip->mode == FIP_MODE_VN2VN) {
628 hton24(mac->fd_mac, FIP_VN_FC_MAP);
629 hton24(mac->fd_mac + 3, fip->port_id);
630 } else if (fip_flags & FIP_FL_SPMA) {
631 LIBFCOE_FIP_DBG(fip, "FLOGI/FDISC sent with SPMA\n");
632 memcpy(mac->fd_mac, fip->ctl_src_addr, ETH_ALEN);
633 } else {
634 LIBFCOE_FIP_DBG(fip, "FLOGI/FDISC sent with FPMA\n");
635
636 }
637 }
638 cap->fip.fip_dl_len = htons(dlen / FIP_BPW);
639
640 skb->protocol = htons(ETH_P_FIP);
641 skb->priority = fip->priority;
642 skb_reset_mac_header(skb);
643 skb_reset_network_header(skb);
644 return 0;
645}
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct fc_lport *lport,
664 struct sk_buff *skb)
665{
666 struct fc_frame *fp;
667 struct fc_frame_header *fh;
668 u16 old_xid;
669 u8 op;
670 u8 mac[ETH_ALEN];
671
672 fp = container_of(skb, struct fc_frame, skb);
673 fh = (struct fc_frame_header *)skb->data;
674 op = *(u8 *)(fh + 1);
675
676 if (op == ELS_FLOGI && fip->mode != FIP_MODE_VN2VN) {
677 old_xid = fip->flogi_oxid;
678 fip->flogi_oxid = ntohs(fh->fh_ox_id);
679 if (fip->state == FIP_ST_AUTO) {
680 if (old_xid == FC_XID_UNKNOWN)
681 fip->flogi_count = 0;
682 fip->flogi_count++;
683 if (fip->flogi_count < 3)
684 goto drop;
685 fcoe_ctlr_map_dest(fip);
686 return 0;
687 }
688 if (fip->state == FIP_ST_NON_FIP)
689 fcoe_ctlr_map_dest(fip);
690 }
691
692 if (fip->state == FIP_ST_NON_FIP)
693 return 0;
694 if (!fip->sel_fcf && fip->mode != FIP_MODE_VN2VN)
695 goto drop;
696 switch (op) {
697 case ELS_FLOGI:
698 op = FIP_DT_FLOGI;
699 if (fip->mode == FIP_MODE_VN2VN)
700 break;
701 spin_lock_bh(&fip->ctlr_lock);
702 kfree_skb(fip->flogi_req);
703 fip->flogi_req = skb;
704 fip->flogi_req_send = 1;
705 spin_unlock_bh(&fip->ctlr_lock);
706 schedule_work(&fip->timer_work);
707 return -EINPROGRESS;
708 case ELS_FDISC:
709 if (ntoh24(fh->fh_s_id))
710 return 0;
711 op = FIP_DT_FDISC;
712 break;
713 case ELS_LOGO:
714 if (fip->mode == FIP_MODE_VN2VN) {
715 if (fip->state != FIP_ST_VNMP_UP)
716 return -EINVAL;
717 if (ntoh24(fh->fh_d_id) == FC_FID_FLOGI)
718 return -EINVAL;
719 } else {
720 if (fip->state != FIP_ST_ENABLED)
721 return 0;
722 if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)
723 return 0;
724 }
725 op = FIP_DT_LOGO;
726 break;
727 case ELS_LS_ACC:
728
729
730
731
732
733
734
735 if (fip->state == FIP_ST_NON_FIP) {
736 if (fip->flogi_oxid == FC_XID_UNKNOWN)
737 return 0;
738 fip->flogi_oxid = FC_XID_UNKNOWN;
739 fc_fcoe_set_mac(mac, fh->fh_d_id);
740 fip->update_mac(lport, mac);
741 }
742
743 case ELS_LS_RJT:
744 op = fr_encaps(fp);
745 if (op)
746 break;
747 return 0;
748 default:
749 if (fip->state != FIP_ST_ENABLED &&
750 fip->state != FIP_ST_VNMP_UP)
751 goto drop;
752 return 0;
753 }
754 LIBFCOE_FIP_DBG(fip, "els_send op %u d_id %x\n",
755 op, ntoh24(fh->fh_d_id));
756 if (fcoe_ctlr_encaps(fip, lport, op, skb, ntoh24(fh->fh_d_id)))
757 goto drop;
758 fip->send(fip, skb);
759 return -EINPROGRESS;
760drop:
761 kfree_skb(skb);
762 return -EINVAL;
763}
764EXPORT_SYMBOL(fcoe_ctlr_els_send);
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783static unsigned long fcoe_ctlr_age_fcfs(struct fcoe_ctlr *fip)
784{
785 struct fcoe_fcf *fcf;
786 struct fcoe_fcf *next;
787 unsigned long next_timer = jiffies + msecs_to_jiffies(FIP_VN_KA_PERIOD);
788 unsigned long deadline;
789 unsigned long sel_time = 0;
790 struct list_head del_list;
791 struct fc_stats *stats;
792
793 INIT_LIST_HEAD(&del_list);
794
795 stats = per_cpu_ptr(fip->lp->stats, get_cpu());
796
797 list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {
798 deadline = fcf->time + fcf->fka_period + fcf->fka_period / 2;
799 if (fip->sel_fcf == fcf) {
800 if (time_after(jiffies, deadline)) {
801 stats->MissDiscAdvCount++;
802 printk(KERN_INFO "libfcoe: host%d: "
803 "Missing Discovery Advertisement "
804 "for fab %16.16llx count %lld\n",
805 fip->lp->host->host_no, fcf->fabric_name,
806 stats->MissDiscAdvCount);
807 } else if (time_after(next_timer, deadline))
808 next_timer = deadline;
809 }
810
811 deadline += fcf->fka_period;
812 if (time_after_eq(jiffies, deadline)) {
813 if (fip->sel_fcf == fcf)
814 fip->sel_fcf = NULL;
815
816
817
818
819
820 list_del(&fcf->list);
821 list_add(&fcf->list, &del_list);
822 stats->VLinkFailureCount++;
823 } else {
824 if (time_after(next_timer, deadline))
825 next_timer = deadline;
826 if (fcoe_ctlr_mtu_valid(fcf) &&
827 (!sel_time || time_before(sel_time, fcf->time)))
828 sel_time = fcf->time;
829 }
830 }
831 put_cpu();
832
833 list_for_each_entry_safe(fcf, next, &del_list, list) {
834
835 fcoe_sysfs_fcf_del(fcf);
836 }
837
838 if (sel_time && !fip->sel_fcf && !fip->sel_time) {
839 sel_time += msecs_to_jiffies(FCOE_CTLR_START_DELAY);
840 fip->sel_time = sel_time;
841 }
842
843 return next_timer;
844}
845
846
847
848
849
850
851
852
853
854
855static int fcoe_ctlr_parse_adv(struct fcoe_ctlr *fip,
856 struct sk_buff *skb, struct fcoe_fcf *fcf)
857{
858 struct fip_header *fiph;
859 struct fip_desc *desc = NULL;
860 struct fip_wwn_desc *wwn;
861 struct fip_fab_desc *fab;
862 struct fip_fka_desc *fka;
863 unsigned long t;
864 size_t rlen;
865 size_t dlen;
866 u32 desc_mask;
867
868 memset(fcf, 0, sizeof(*fcf));
869 fcf->fka_period = msecs_to_jiffies(FCOE_CTLR_DEF_FKA);
870
871 fiph = (struct fip_header *)skb->data;
872 fcf->flags = ntohs(fiph->fip_flags);
873
874
875
876
877 desc_mask = BIT(FIP_DT_PRI) | BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |
878 BIT(FIP_DT_FAB) | BIT(FIP_DT_FKA);
879
880 rlen = ntohs(fiph->fip_dl_len) * 4;
881 if (rlen + sizeof(*fiph) > skb->len)
882 return -EINVAL;
883
884 desc = (struct fip_desc *)(fiph + 1);
885 while (rlen > 0) {
886 dlen = desc->fip_dlen * FIP_BPW;
887 if (dlen < sizeof(*desc) || dlen > rlen)
888 return -EINVAL;
889
890 if ((desc->fip_dtype < 32) &&
891 !(desc_mask & 1U << desc->fip_dtype)) {
892 LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
893 "Descriptors in FIP adv\n");
894 return -EINVAL;
895 }
896 switch (desc->fip_dtype) {
897 case FIP_DT_PRI:
898 if (dlen != sizeof(struct fip_pri_desc))
899 goto len_err;
900 fcf->pri = ((struct fip_pri_desc *)desc)->fd_pri;
901 desc_mask &= ~BIT(FIP_DT_PRI);
902 break;
903 case FIP_DT_MAC:
904 if (dlen != sizeof(struct fip_mac_desc))
905 goto len_err;
906 memcpy(fcf->fcf_mac,
907 ((struct fip_mac_desc *)desc)->fd_mac,
908 ETH_ALEN);
909 memcpy(fcf->fcoe_mac, fcf->fcf_mac, ETH_ALEN);
910 if (!is_valid_ether_addr(fcf->fcf_mac)) {
911 LIBFCOE_FIP_DBG(fip,
912 "Invalid MAC addr %pM in FIP adv\n",
913 fcf->fcf_mac);
914 return -EINVAL;
915 }
916 desc_mask &= ~BIT(FIP_DT_MAC);
917 break;
918 case FIP_DT_NAME:
919 if (dlen != sizeof(struct fip_wwn_desc))
920 goto len_err;
921 wwn = (struct fip_wwn_desc *)desc;
922 fcf->switch_name = get_unaligned_be64(&wwn->fd_wwn);
923 desc_mask &= ~BIT(FIP_DT_NAME);
924 break;
925 case FIP_DT_FAB:
926 if (dlen != sizeof(struct fip_fab_desc))
927 goto len_err;
928 fab = (struct fip_fab_desc *)desc;
929 fcf->fabric_name = get_unaligned_be64(&fab->fd_wwn);
930 fcf->vfid = ntohs(fab->fd_vfid);
931 fcf->fc_map = ntoh24(fab->fd_map);
932 desc_mask &= ~BIT(FIP_DT_FAB);
933 break;
934 case FIP_DT_FKA:
935 if (dlen != sizeof(struct fip_fka_desc))
936 goto len_err;
937 fka = (struct fip_fka_desc *)desc;
938 if (fka->fd_flags & FIP_FKA_ADV_D)
939 fcf->fd_flags = 1;
940 t = ntohl(fka->fd_fka_period);
941 if (t >= FCOE_CTLR_MIN_FKA)
942 fcf->fka_period = msecs_to_jiffies(t);
943 desc_mask &= ~BIT(FIP_DT_FKA);
944 break;
945 case FIP_DT_MAP_OUI:
946 case FIP_DT_FCOE_SIZE:
947 case FIP_DT_FLOGI:
948 case FIP_DT_FDISC:
949 case FIP_DT_LOGO:
950 case FIP_DT_ELP:
951 default:
952 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
953 "in FIP adv\n", desc->fip_dtype);
954
955 if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
956 return -EINVAL;
957 break;
958 }
959 desc = (struct fip_desc *)((char *)desc + dlen);
960 rlen -= dlen;
961 }
962 if (!fcf->fc_map || (fcf->fc_map & 0x10000))
963 return -EINVAL;
964 if (!fcf->switch_name)
965 return -EINVAL;
966 if (desc_mask) {
967 LIBFCOE_FIP_DBG(fip, "adv missing descriptors mask %x\n",
968 desc_mask);
969 return -EINVAL;
970 }
971 return 0;
972
973len_err:
974 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
975 desc->fip_dtype, dlen);
976 return -EINVAL;
977}
978
979
980
981
982
983
984static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
985{
986 struct fcoe_fcf *fcf;
987 struct fcoe_fcf new;
988 unsigned long sol_tov = msecs_to_jiffies(FCOE_CTRL_SOL_TOV);
989 int first = 0;
990 int mtu_valid;
991 int found = 0;
992 int rc = 0;
993
994 if (fcoe_ctlr_parse_adv(fip, skb, &new))
995 return;
996
997 mutex_lock(&fip->ctlr_mutex);
998 first = list_empty(&fip->fcfs);
999 list_for_each_entry(fcf, &fip->fcfs, list) {
1000 if (fcf->switch_name == new.switch_name &&
1001 fcf->fabric_name == new.fabric_name &&
1002 fcf->fc_map == new.fc_map &&
1003 compare_ether_addr(fcf->fcf_mac, new.fcf_mac) == 0) {
1004 found = 1;
1005 break;
1006 }
1007 }
1008 if (!found) {
1009 if (fip->fcf_count >= FCOE_CTLR_FCF_LIMIT)
1010 goto out;
1011
1012 fcf = kmalloc(sizeof(*fcf), GFP_ATOMIC);
1013 if (!fcf)
1014 goto out;
1015
1016 memcpy(fcf, &new, sizeof(new));
1017 fcf->fip = fip;
1018 rc = fcoe_sysfs_fcf_add(fcf);
1019 if (rc) {
1020 printk(KERN_ERR "Failed to allocate sysfs instance "
1021 "for FCF, fab %16.16llx mac %pM\n",
1022 new.fabric_name, new.fcf_mac);
1023 kfree(fcf);
1024 goto out;
1025 }
1026 } else {
1027
1028
1029
1030
1031
1032
1033 fcf->fd_flags = new.fd_flags;
1034 if (!fcoe_ctlr_fcf_usable(fcf))
1035 fcf->flags = new.flags;
1036
1037 if (fcf == fip->sel_fcf && !fcf->fd_flags) {
1038 fip->ctlr_ka_time -= fcf->fka_period;
1039 fip->ctlr_ka_time += new.fka_period;
1040 if (time_before(fip->ctlr_ka_time, fip->timer.expires))
1041 mod_timer(&fip->timer, fip->ctlr_ka_time);
1042 }
1043 fcf->fka_period = new.fka_period;
1044 memcpy(fcf->fcf_mac, new.fcf_mac, ETH_ALEN);
1045 }
1046
1047 mtu_valid = fcoe_ctlr_mtu_valid(fcf);
1048 fcf->time = jiffies;
1049 if (!found)
1050 LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",
1051 fcf->fabric_name, fcf->fcf_mac);
1052
1053
1054
1055
1056
1057 if (!mtu_valid)
1058 fcoe_ctlr_solicit(fip, fcf);
1059
1060
1061
1062
1063
1064
1065
1066 if (first && time_after(jiffies, fip->sol_time + sol_tov))
1067 fcoe_ctlr_solicit(fip, NULL);
1068
1069
1070
1071
1072
1073
1074
1075 if (mtu_valid)
1076 list_move(&fcf->list, &fip->fcfs);
1077
1078
1079
1080
1081
1082 if (mtu_valid && !fip->sel_fcf && fcoe_ctlr_fcf_usable(fcf)) {
1083 fip->sel_time = jiffies +
1084 msecs_to_jiffies(FCOE_CTLR_START_DELAY);
1085 if (!timer_pending(&fip->timer) ||
1086 time_before(fip->sel_time, fip->timer.expires))
1087 mod_timer(&fip->timer, fip->sel_time);
1088 }
1089
1090out:
1091 mutex_unlock(&fip->ctlr_mutex);
1092}
1093
1094
1095
1096
1097
1098
1099static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
1100{
1101 struct fc_lport *lport = fip->lp;
1102 struct fip_header *fiph;
1103 struct fc_frame *fp = (struct fc_frame *)skb;
1104 struct fc_frame_header *fh = NULL;
1105 struct fip_desc *desc;
1106 struct fip_encaps *els;
1107 struct fcoe_fcf *sel;
1108 struct fc_stats *stats;
1109 enum fip_desc_type els_dtype = 0;
1110 u8 els_op;
1111 u8 sub;
1112 u8 granted_mac[ETH_ALEN] = { 0 };
1113 size_t els_len = 0;
1114 size_t rlen;
1115 size_t dlen;
1116 u32 desc_mask = 0;
1117 u32 desc_cnt = 0;
1118
1119 fiph = (struct fip_header *)skb->data;
1120 sub = fiph->fip_subcode;
1121 if (sub != FIP_SC_REQ && sub != FIP_SC_REP)
1122 goto drop;
1123
1124 rlen = ntohs(fiph->fip_dl_len) * 4;
1125 if (rlen + sizeof(*fiph) > skb->len)
1126 goto drop;
1127
1128 desc = (struct fip_desc *)(fiph + 1);
1129 while (rlen > 0) {
1130 desc_cnt++;
1131 dlen = desc->fip_dlen * FIP_BPW;
1132 if (dlen < sizeof(*desc) || dlen > rlen)
1133 goto drop;
1134
1135 if (desc->fip_dtype < 32) {
1136 if ((desc->fip_dtype != FIP_DT_MAC) &&
1137 (desc_mask & 1U << desc->fip_dtype)) {
1138 LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
1139 "Descriptors in FIP ELS\n");
1140 goto drop;
1141 }
1142 desc_mask |= (1 << desc->fip_dtype);
1143 }
1144 switch (desc->fip_dtype) {
1145 case FIP_DT_MAC:
1146 sel = fip->sel_fcf;
1147 if (desc_cnt == 1) {
1148 LIBFCOE_FIP_DBG(fip, "FIP descriptors "
1149 "received out of order\n");
1150 goto drop;
1151 }
1152
1153
1154
1155
1156
1157
1158
1159
1160 if (desc_cnt == 2)
1161 memcpy(granted_mac,
1162 ((struct fip_mac_desc *)desc)->fd_mac,
1163 ETH_ALEN);
1164
1165 if (dlen != sizeof(struct fip_mac_desc))
1166 goto len_err;
1167
1168 if ((desc_cnt == 3) && (sel))
1169 memcpy(sel->fcoe_mac,
1170 ((struct fip_mac_desc *)desc)->fd_mac,
1171 ETH_ALEN);
1172 break;
1173 case FIP_DT_FLOGI:
1174 case FIP_DT_FDISC:
1175 case FIP_DT_LOGO:
1176 case FIP_DT_ELP:
1177 if (desc_cnt != 1) {
1178 LIBFCOE_FIP_DBG(fip, "FIP descriptors "
1179 "received out of order\n");
1180 goto drop;
1181 }
1182 if (fh)
1183 goto drop;
1184 if (dlen < sizeof(*els) + sizeof(*fh) + 1)
1185 goto len_err;
1186 els_len = dlen - sizeof(*els);
1187 els = (struct fip_encaps *)desc;
1188 fh = (struct fc_frame_header *)(els + 1);
1189 els_dtype = desc->fip_dtype;
1190 break;
1191 default:
1192 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
1193 "in FIP adv\n", desc->fip_dtype);
1194
1195 if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
1196 goto drop;
1197 if (desc_cnt <= 2) {
1198 LIBFCOE_FIP_DBG(fip, "FIP descriptors "
1199 "received out of order\n");
1200 goto drop;
1201 }
1202 break;
1203 }
1204 desc = (struct fip_desc *)((char *)desc + dlen);
1205 rlen -= dlen;
1206 }
1207
1208 if (!fh)
1209 goto drop;
1210 els_op = *(u8 *)(fh + 1);
1211
1212 if ((els_dtype == FIP_DT_FLOGI || els_dtype == FIP_DT_FDISC) &&
1213 sub == FIP_SC_REP && fip->mode != FIP_MODE_VN2VN) {
1214 if (els_op == ELS_LS_ACC) {
1215 if (!is_valid_ether_addr(granted_mac)) {
1216 LIBFCOE_FIP_DBG(fip,
1217 "Invalid MAC address %pM in FIP ELS\n",
1218 granted_mac);
1219 goto drop;
1220 }
1221 memcpy(fr_cb(fp)->granted_mac, granted_mac, ETH_ALEN);
1222
1223 if (fip->flogi_oxid == ntohs(fh->fh_ox_id)) {
1224 fip->flogi_oxid = FC_XID_UNKNOWN;
1225 if (els_dtype == FIP_DT_FLOGI)
1226 fcoe_ctlr_announce(fip);
1227 }
1228 } else if (els_dtype == FIP_DT_FLOGI &&
1229 !fcoe_ctlr_flogi_retry(fip))
1230 goto drop;
1231 }
1232
1233 if ((desc_cnt == 0) || ((els_op != ELS_LS_RJT) &&
1234 (!(1U << FIP_DT_MAC & desc_mask)))) {
1235 LIBFCOE_FIP_DBG(fip, "Missing critical descriptors "
1236 "in FIP ELS\n");
1237 goto drop;
1238 }
1239
1240
1241
1242
1243 skb_pull(skb, (u8 *)fh - skb->data);
1244 skb_trim(skb, els_len);
1245 fp = (struct fc_frame *)skb;
1246 fc_frame_init(fp);
1247 fr_sof(fp) = FC_SOF_I3;
1248 fr_eof(fp) = FC_EOF_T;
1249 fr_dev(fp) = lport;
1250 fr_encaps(fp) = els_dtype;
1251
1252 stats = per_cpu_ptr(lport->stats, get_cpu());
1253 stats->RxFrames++;
1254 stats->RxWords += skb->len / FIP_BPW;
1255 put_cpu();
1256
1257 fc_exch_recv(lport, fp);
1258 return;
1259
1260len_err:
1261 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
1262 desc->fip_dtype, dlen);
1263drop:
1264 kfree_skb(skb);
1265}
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
1276 struct fip_header *fh)
1277{
1278 struct fip_desc *desc;
1279 struct fip_mac_desc *mp;
1280 struct fip_wwn_desc *wp;
1281 struct fip_vn_desc *vp;
1282 size_t rlen;
1283 size_t dlen;
1284 struct fcoe_fcf *fcf = fip->sel_fcf;
1285 struct fc_lport *lport = fip->lp;
1286 struct fc_lport *vn_port = NULL;
1287 u32 desc_mask;
1288 int num_vlink_desc;
1289 int reset_phys_port = 0;
1290 struct fip_vn_desc **vlink_desc_arr = NULL;
1291
1292 LIBFCOE_FIP_DBG(fip, "Clear Virtual Link received\n");
1293
1294 if (!fcf || !lport->port_id) {
1295
1296
1297
1298
1299 mutex_lock(&fip->ctlr_mutex);
1300 fcoe_ctlr_reset(fip);
1301 mutex_unlock(&fip->ctlr_mutex);
1302 return;
1303 }
1304
1305
1306
1307
1308 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME);
1309
1310 rlen = ntohs(fh->fip_dl_len) * FIP_BPW;
1311 desc = (struct fip_desc *)(fh + 1);
1312
1313
1314
1315
1316
1317
1318 num_vlink_desc = rlen / sizeof(*vp);
1319 if (num_vlink_desc)
1320 vlink_desc_arr = kmalloc(sizeof(vp) * num_vlink_desc,
1321 GFP_ATOMIC);
1322 if (!vlink_desc_arr)
1323 return;
1324 num_vlink_desc = 0;
1325
1326 while (rlen >= sizeof(*desc)) {
1327 dlen = desc->fip_dlen * FIP_BPW;
1328 if (dlen > rlen)
1329 goto err;
1330
1331 if ((desc->fip_dtype < 32) &&
1332 (desc->fip_dtype != FIP_DT_VN_ID) &&
1333 !(desc_mask & 1U << desc->fip_dtype)) {
1334 LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
1335 "Descriptors in FIP CVL\n");
1336 goto err;
1337 }
1338 switch (desc->fip_dtype) {
1339 case FIP_DT_MAC:
1340 mp = (struct fip_mac_desc *)desc;
1341 if (dlen < sizeof(*mp))
1342 goto err;
1343 if (compare_ether_addr(mp->fd_mac, fcf->fcf_mac))
1344 goto err;
1345 desc_mask &= ~BIT(FIP_DT_MAC);
1346 break;
1347 case FIP_DT_NAME:
1348 wp = (struct fip_wwn_desc *)desc;
1349 if (dlen < sizeof(*wp))
1350 goto err;
1351 if (get_unaligned_be64(&wp->fd_wwn) != fcf->switch_name)
1352 goto err;
1353 desc_mask &= ~BIT(FIP_DT_NAME);
1354 break;
1355 case FIP_DT_VN_ID:
1356 vp = (struct fip_vn_desc *)desc;
1357 if (dlen < sizeof(*vp))
1358 goto err;
1359 vlink_desc_arr[num_vlink_desc++] = vp;
1360 vn_port = fc_vport_id_lookup(lport,
1361 ntoh24(vp->fd_fc_id));
1362 if (vn_port && (vn_port == lport)) {
1363 mutex_lock(&fip->ctlr_mutex);
1364 per_cpu_ptr(lport->stats,
1365 get_cpu())->VLinkFailureCount++;
1366 put_cpu();
1367 fcoe_ctlr_reset(fip);
1368 mutex_unlock(&fip->ctlr_mutex);
1369 }
1370 break;
1371 default:
1372
1373 if (desc->fip_dtype < FIP_DT_VENDOR_BASE)
1374 goto err;
1375 break;
1376 }
1377 desc = (struct fip_desc *)((char *)desc + dlen);
1378 rlen -= dlen;
1379 }
1380
1381
1382
1383
1384 if (desc_mask)
1385 LIBFCOE_FIP_DBG(fip, "missing descriptors mask %x\n",
1386 desc_mask);
1387 else if (!num_vlink_desc) {
1388 LIBFCOE_FIP_DBG(fip, "CVL: no Vx_Port descriptor found\n");
1389
1390
1391
1392
1393 mutex_lock(&fip->ctlr_mutex);
1394 per_cpu_ptr(lport->stats, get_cpu())->VLinkFailureCount++;
1395 put_cpu();
1396 fcoe_ctlr_reset(fip);
1397 mutex_unlock(&fip->ctlr_mutex);
1398
1399 mutex_lock(&lport->lp_mutex);
1400 list_for_each_entry(vn_port, &lport->vports, list)
1401 fc_lport_reset(vn_port);
1402 mutex_unlock(&lport->lp_mutex);
1403
1404 fc_lport_reset(fip->lp);
1405 fcoe_ctlr_solicit(fip, NULL);
1406 } else {
1407 int i;
1408
1409 LIBFCOE_FIP_DBG(fip, "performing Clear Virtual Link\n");
1410 for (i = 0; i < num_vlink_desc; i++) {
1411 vp = vlink_desc_arr[i];
1412 vn_port = fc_vport_id_lookup(lport,
1413 ntoh24(vp->fd_fc_id));
1414 if (!vn_port)
1415 continue;
1416
1417
1418
1419
1420
1421 if (compare_ether_addr(fip->get_src_addr(vn_port),
1422 vp->fd_mac) != 0 ||
1423 get_unaligned_be64(&vp->fd_wwpn) !=
1424 vn_port->wwpn)
1425 continue;
1426
1427 if (vn_port == lport)
1428
1429
1430
1431
1432 reset_phys_port = 1;
1433 else
1434 fc_lport_reset(vn_port);
1435 }
1436
1437 if (reset_phys_port) {
1438 fc_lport_reset(fip->lp);
1439 fcoe_ctlr_solicit(fip, NULL);
1440 }
1441 }
1442
1443err:
1444 kfree(vlink_desc_arr);
1445}
1446
1447
1448
1449
1450
1451
1452
1453
1454void fcoe_ctlr_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
1455{
1456 skb_queue_tail(&fip->fip_recv_list, skb);
1457 schedule_work(&fip->recv_work);
1458}
1459EXPORT_SYMBOL(fcoe_ctlr_recv);
1460
1461
1462
1463
1464
1465
1466
1467
1468static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)
1469{
1470 struct fip_header *fiph;
1471 struct ethhdr *eh;
1472 enum fip_state state;
1473 u16 op;
1474 u8 sub;
1475
1476 if (skb_linearize(skb))
1477 goto drop;
1478 if (skb->len < sizeof(*fiph))
1479 goto drop;
1480 eh = eth_hdr(skb);
1481 if (fip->mode == FIP_MODE_VN2VN) {
1482 if (compare_ether_addr(eh->h_dest, fip->ctl_src_addr) &&
1483 compare_ether_addr(eh->h_dest, fcoe_all_vn2vn) &&
1484 compare_ether_addr(eh->h_dest, fcoe_all_p2p))
1485 goto drop;
1486 } else if (compare_ether_addr(eh->h_dest, fip->ctl_src_addr) &&
1487 compare_ether_addr(eh->h_dest, fcoe_all_enode))
1488 goto drop;
1489 fiph = (struct fip_header *)skb->data;
1490 op = ntohs(fiph->fip_op);
1491 sub = fiph->fip_subcode;
1492
1493 if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER)
1494 goto drop;
1495 if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len)
1496 goto drop;
1497
1498 mutex_lock(&fip->ctlr_mutex);
1499 state = fip->state;
1500 if (state == FIP_ST_AUTO) {
1501 fip->map_dest = 0;
1502 fcoe_ctlr_set_state(fip, FIP_ST_ENABLED);
1503 state = FIP_ST_ENABLED;
1504 LIBFCOE_FIP_DBG(fip, "Using FIP mode\n");
1505 }
1506 mutex_unlock(&fip->ctlr_mutex);
1507
1508 if (fip->mode == FIP_MODE_VN2VN && op == FIP_OP_VN2VN)
1509 return fcoe_ctlr_vn_recv(fip, skb);
1510
1511 if (state != FIP_ST_ENABLED && state != FIP_ST_VNMP_UP &&
1512 state != FIP_ST_VNMP_CLAIM)
1513 goto drop;
1514
1515 if (op == FIP_OP_LS) {
1516 fcoe_ctlr_recv_els(fip, skb);
1517 return 0;
1518 }
1519
1520 if (state != FIP_ST_ENABLED)
1521 goto drop;
1522
1523 if (op == FIP_OP_DISC && sub == FIP_SC_ADV)
1524 fcoe_ctlr_recv_adv(fip, skb);
1525 else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK)
1526 fcoe_ctlr_recv_clr_vlink(fip, fiph);
1527 kfree_skb(skb);
1528 return 0;
1529drop:
1530 kfree_skb(skb);
1531 return -1;
1532}
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547static struct fcoe_fcf *fcoe_ctlr_select(struct fcoe_ctlr *fip)
1548{
1549 struct fcoe_fcf *fcf;
1550 struct fcoe_fcf *best = fip->sel_fcf;
1551
1552 list_for_each_entry(fcf, &fip->fcfs, list) {
1553 LIBFCOE_FIP_DBG(fip, "consider FCF fab %16.16llx "
1554 "VFID %d mac %pM map %x val %d "
1555 "sent %u pri %u\n",
1556 fcf->fabric_name, fcf->vfid, fcf->fcf_mac,
1557 fcf->fc_map, fcoe_ctlr_mtu_valid(fcf),
1558 fcf->flogi_sent, fcf->pri);
1559 if (!fcoe_ctlr_fcf_usable(fcf)) {
1560 LIBFCOE_FIP_DBG(fip, "FCF for fab %16.16llx "
1561 "map %x %svalid %savailable\n",
1562 fcf->fabric_name, fcf->fc_map,
1563 (fcf->flags & FIP_FL_SOL) ? "" : "in",
1564 (fcf->flags & FIP_FL_AVAIL) ?
1565 "" : "un");
1566 continue;
1567 }
1568 if (!best || fcf->pri < best->pri || best->flogi_sent)
1569 best = fcf;
1570 if (fcf->fabric_name != best->fabric_name ||
1571 fcf->vfid != best->vfid ||
1572 fcf->fc_map != best->fc_map) {
1573 LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
1574 "or FC-MAP\n");
1575 return NULL;
1576 }
1577 }
1578 fip->sel_fcf = best;
1579 if (best) {
1580 LIBFCOE_FIP_DBG(fip, "using FCF mac %pM\n", best->fcf_mac);
1581 fip->port_ka_time = jiffies +
1582 msecs_to_jiffies(FIP_VN_KA_PERIOD);
1583 fip->ctlr_ka_time = jiffies + best->fka_period;
1584 if (time_before(fip->ctlr_ka_time, fip->timer.expires))
1585 mod_timer(&fip->timer, fip->ctlr_ka_time);
1586 }
1587 return best;
1588}
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599static int fcoe_ctlr_flogi_send_locked(struct fcoe_ctlr *fip)
1600{
1601 struct sk_buff *skb;
1602 struct sk_buff *skb_orig;
1603 struct fc_frame_header *fh;
1604 int error;
1605
1606 skb_orig = fip->flogi_req;
1607 if (!skb_orig)
1608 return -EINVAL;
1609
1610
1611
1612
1613 skb = skb_clone(skb_orig, GFP_ATOMIC);
1614 if (!skb) {
1615 skb = skb_orig;
1616 fip->flogi_req = NULL;
1617 }
1618 fh = (struct fc_frame_header *)skb->data;
1619 error = fcoe_ctlr_encaps(fip, fip->lp, FIP_DT_FLOGI, skb,
1620 ntoh24(fh->fh_d_id));
1621 if (error) {
1622 kfree_skb(skb);
1623 return error;
1624 }
1625 fip->send(fip, skb);
1626 fip->sel_fcf->flogi_sent = 1;
1627 return 0;
1628}
1629
1630
1631
1632
1633
1634
1635
1636
1637static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *fip)
1638{
1639 struct fcoe_fcf *fcf;
1640 int error;
1641
1642 mutex_lock(&fip->ctlr_mutex);
1643 spin_lock_bh(&fip->ctlr_lock);
1644 LIBFCOE_FIP_DBG(fip, "re-sending FLOGI - reselect\n");
1645 fcf = fcoe_ctlr_select(fip);
1646 if (!fcf || fcf->flogi_sent) {
1647 kfree_skb(fip->flogi_req);
1648 fip->flogi_req = NULL;
1649 error = -ENOENT;
1650 } else {
1651 fcoe_ctlr_solicit(fip, NULL);
1652 error = fcoe_ctlr_flogi_send_locked(fip);
1653 }
1654 spin_unlock_bh(&fip->ctlr_lock);
1655 mutex_unlock(&fip->ctlr_mutex);
1656 return error;
1657}
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668static void fcoe_ctlr_flogi_send(struct fcoe_ctlr *fip)
1669{
1670 struct fcoe_fcf *fcf;
1671
1672 spin_lock_bh(&fip->ctlr_lock);
1673 fcf = fip->sel_fcf;
1674 if (!fcf || !fip->flogi_req_send)
1675 goto unlock;
1676
1677 LIBFCOE_FIP_DBG(fip, "sending FLOGI\n");
1678
1679
1680
1681
1682
1683 if (fcf->flogi_sent) {
1684 LIBFCOE_FIP_DBG(fip, "sending FLOGI - reselect\n");
1685 fcf = fcoe_ctlr_select(fip);
1686 if (!fcf || fcf->flogi_sent) {
1687 LIBFCOE_FIP_DBG(fip, "sending FLOGI - clearing\n");
1688 list_for_each_entry(fcf, &fip->fcfs, list)
1689 fcf->flogi_sent = 0;
1690 fcf = fcoe_ctlr_select(fip);
1691 }
1692 }
1693 if (fcf) {
1694 fcoe_ctlr_flogi_send_locked(fip);
1695 fip->flogi_req_send = 0;
1696 } else
1697 LIBFCOE_FIP_DBG(fip, "No FCF selected - defer send\n");
1698unlock:
1699 spin_unlock_bh(&fip->ctlr_lock);
1700}
1701
1702
1703
1704
1705
1706static void fcoe_ctlr_timeout(unsigned long arg)
1707{
1708 struct fcoe_ctlr *fip = (struct fcoe_ctlr *)arg;
1709
1710 schedule_work(&fip->timer_work);
1711}
1712
1713
1714
1715
1716
1717
1718
1719
1720static void fcoe_ctlr_timer_work(struct work_struct *work)
1721{
1722 struct fcoe_ctlr *fip;
1723 struct fc_lport *vport;
1724 u8 *mac;
1725 u8 reset = 0;
1726 u8 send_ctlr_ka = 0;
1727 u8 send_port_ka = 0;
1728 struct fcoe_fcf *sel;
1729 struct fcoe_fcf *fcf;
1730 unsigned long next_timer;
1731
1732 fip = container_of(work, struct fcoe_ctlr, timer_work);
1733 if (fip->mode == FIP_MODE_VN2VN)
1734 return fcoe_ctlr_vn_timeout(fip);
1735 mutex_lock(&fip->ctlr_mutex);
1736 if (fip->state == FIP_ST_DISABLED) {
1737 mutex_unlock(&fip->ctlr_mutex);
1738 return;
1739 }
1740
1741 fcf = fip->sel_fcf;
1742 next_timer = fcoe_ctlr_age_fcfs(fip);
1743
1744 sel = fip->sel_fcf;
1745 if (!sel && fip->sel_time) {
1746 if (time_after_eq(jiffies, fip->sel_time)) {
1747 sel = fcoe_ctlr_select(fip);
1748 fip->sel_time = 0;
1749 } else if (time_after(next_timer, fip->sel_time))
1750 next_timer = fip->sel_time;
1751 }
1752
1753 if (sel && fip->flogi_req_send)
1754 fcoe_ctlr_flogi_send(fip);
1755 else if (!sel && fcf)
1756 reset = 1;
1757
1758 if (sel && !sel->fd_flags) {
1759 if (time_after_eq(jiffies, fip->ctlr_ka_time)) {
1760 fip->ctlr_ka_time = jiffies + sel->fka_period;
1761 send_ctlr_ka = 1;
1762 }
1763 if (time_after(next_timer, fip->ctlr_ka_time))
1764 next_timer = fip->ctlr_ka_time;
1765
1766 if (time_after_eq(jiffies, fip->port_ka_time)) {
1767 fip->port_ka_time = jiffies +
1768 msecs_to_jiffies(FIP_VN_KA_PERIOD);
1769 send_port_ka = 1;
1770 }
1771 if (time_after(next_timer, fip->port_ka_time))
1772 next_timer = fip->port_ka_time;
1773 }
1774 if (!list_empty(&fip->fcfs))
1775 mod_timer(&fip->timer, next_timer);
1776 mutex_unlock(&fip->ctlr_mutex);
1777
1778 if (reset) {
1779 fc_lport_reset(fip->lp);
1780
1781 fcoe_ctlr_solicit(fip, NULL);
1782 }
1783
1784 if (send_ctlr_ka)
1785 fcoe_ctlr_send_keep_alive(fip, NULL, 0, fip->ctl_src_addr);
1786
1787 if (send_port_ka) {
1788 mutex_lock(&fip->lp->lp_mutex);
1789 mac = fip->get_src_addr(fip->lp);
1790 fcoe_ctlr_send_keep_alive(fip, fip->lp, 1, mac);
1791 list_for_each_entry(vport, &fip->lp->vports, list) {
1792 mac = fip->get_src_addr(vport);
1793 fcoe_ctlr_send_keep_alive(fip, vport, 1, mac);
1794 }
1795 mutex_unlock(&fip->lp->lp_mutex);
1796 }
1797}
1798
1799
1800
1801
1802
1803static void fcoe_ctlr_recv_work(struct work_struct *recv_work)
1804{
1805 struct fcoe_ctlr *fip;
1806 struct sk_buff *skb;
1807
1808 fip = container_of(recv_work, struct fcoe_ctlr, recv_work);
1809 while ((skb = skb_dequeue(&fip->fip_recv_list)))
1810 fcoe_ctlr_recv_handler(fip, skb);
1811}
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_lport *lport,
1829 struct fc_frame *fp)
1830{
1831 struct fc_frame_header *fh;
1832 u8 op;
1833 u8 *sa;
1834
1835 sa = eth_hdr(&fp->skb)->h_source;
1836 fh = fc_frame_header_get(fp);
1837 if (fh->fh_type != FC_TYPE_ELS)
1838 return 0;
1839
1840 op = fc_frame_payload_op(fp);
1841 if (op == ELS_LS_ACC && fh->fh_r_ctl == FC_RCTL_ELS_REP &&
1842 fip->flogi_oxid == ntohs(fh->fh_ox_id)) {
1843
1844 mutex_lock(&fip->ctlr_mutex);
1845 if (fip->state != FIP_ST_AUTO && fip->state != FIP_ST_NON_FIP) {
1846 mutex_unlock(&fip->ctlr_mutex);
1847 return -EINVAL;
1848 }
1849 fcoe_ctlr_set_state(fip, FIP_ST_NON_FIP);
1850 LIBFCOE_FIP_DBG(fip,
1851 "received FLOGI LS_ACC using non-FIP mode\n");
1852
1853
1854
1855
1856
1857
1858
1859 if (!compare_ether_addr(sa, (u8[6])FC_FCOE_FLOGI_MAC)) {
1860 fcoe_ctlr_map_dest(fip);
1861 } else {
1862 memcpy(fip->dest_addr, sa, ETH_ALEN);
1863 fip->map_dest = 0;
1864 }
1865 fip->flogi_oxid = FC_XID_UNKNOWN;
1866 mutex_unlock(&fip->ctlr_mutex);
1867 fc_fcoe_set_mac(fr_cb(fp)->granted_mac, fh->fh_d_id);
1868 } else if (op == ELS_FLOGI && fh->fh_r_ctl == FC_RCTL_ELS_REQ && sa) {
1869
1870
1871
1872 mutex_lock(&fip->ctlr_mutex);
1873 if (fip->state == FIP_ST_AUTO || fip->state == FIP_ST_NON_FIP) {
1874 memcpy(fip->dest_addr, sa, ETH_ALEN);
1875 fip->map_dest = 0;
1876 if (fip->state == FIP_ST_AUTO)
1877 LIBFCOE_FIP_DBG(fip, "received non-FIP FLOGI. "
1878 "Setting non-FIP mode\n");
1879 fcoe_ctlr_set_state(fip, FIP_ST_NON_FIP);
1880 }
1881 mutex_unlock(&fip->ctlr_mutex);
1882 }
1883 return 0;
1884}
1885EXPORT_SYMBOL(fcoe_ctlr_recv_flogi);
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895u64 fcoe_wwn_from_mac(unsigned char mac[MAX_ADDR_LEN],
1896 unsigned int scheme, unsigned int port)
1897{
1898 u64 wwn;
1899 u64 host_mac;
1900
1901
1902 host_mac = ((u64) mac[0] << 40) |
1903 ((u64) mac[1] << 32) |
1904 ((u64) mac[2] << 24) |
1905 ((u64) mac[3] << 16) |
1906 ((u64) mac[4] << 8) |
1907 (u64) mac[5];
1908
1909 WARN_ON(host_mac >= (1ULL << 48));
1910 wwn = host_mac | ((u64) scheme << 60);
1911 switch (scheme) {
1912 case 1:
1913 WARN_ON(port != 0);
1914 break;
1915 case 2:
1916 WARN_ON(port >= 0xfff);
1917 wwn |= (u64) port << 48;
1918 break;
1919 default:
1920 WARN_ON(1);
1921 break;
1922 }
1923
1924 return wwn;
1925}
1926EXPORT_SYMBOL_GPL(fcoe_wwn_from_mac);
1927
1928
1929
1930
1931
1932static inline struct fcoe_rport *fcoe_ctlr_rport(struct fc_rport_priv *rdata)
1933{
1934 return (struct fcoe_rport *)(rdata + 1);
1935}
1936
1937
1938
1939
1940
1941
1942
1943
1944static void fcoe_ctlr_vn_send(struct fcoe_ctlr *fip,
1945 enum fip_vn2vn_subcode sub,
1946 const u8 *dest, size_t min_len)
1947{
1948 struct sk_buff *skb;
1949 struct fip_frame {
1950 struct ethhdr eth;
1951 struct fip_header fip;
1952 struct fip_mac_desc mac;
1953 struct fip_wwn_desc wwnn;
1954 struct fip_vn_desc vn;
1955 } __packed * frame;
1956 struct fip_fc4_feat *ff;
1957 struct fip_size_desc *size;
1958 u32 fcp_feat;
1959 size_t len;
1960 size_t dlen;
1961
1962 len = sizeof(*frame);
1963 dlen = 0;
1964 if (sub == FIP_SC_VN_CLAIM_NOTIFY || sub == FIP_SC_VN_CLAIM_REP) {
1965 dlen = sizeof(struct fip_fc4_feat) +
1966 sizeof(struct fip_size_desc);
1967 len += dlen;
1968 }
1969 dlen += sizeof(frame->mac) + sizeof(frame->wwnn) + sizeof(frame->vn);
1970 len = max(len, min_len + sizeof(struct ethhdr));
1971
1972 skb = dev_alloc_skb(len);
1973 if (!skb)
1974 return;
1975
1976 frame = (struct fip_frame *)skb->data;
1977 memset(frame, 0, len);
1978 memcpy(frame->eth.h_dest, dest, ETH_ALEN);
1979
1980 if (sub == FIP_SC_VN_BEACON) {
1981 hton24(frame->eth.h_source, FIP_VN_FC_MAP);
1982 hton24(frame->eth.h_source + 3, fip->port_id);
1983 } else {
1984 memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
1985 }
1986 frame->eth.h_proto = htons(ETH_P_FIP);
1987
1988 frame->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
1989 frame->fip.fip_op = htons(FIP_OP_VN2VN);
1990 frame->fip.fip_subcode = sub;
1991 frame->fip.fip_dl_len = htons(dlen / FIP_BPW);
1992
1993 frame->mac.fd_desc.fip_dtype = FIP_DT_MAC;
1994 frame->mac.fd_desc.fip_dlen = sizeof(frame->mac) / FIP_BPW;
1995 memcpy(frame->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
1996
1997 frame->wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
1998 frame->wwnn.fd_desc.fip_dlen = sizeof(frame->wwnn) / FIP_BPW;
1999 put_unaligned_be64(fip->lp->wwnn, &frame->wwnn.fd_wwn);
2000
2001 frame->vn.fd_desc.fip_dtype = FIP_DT_VN_ID;
2002 frame->vn.fd_desc.fip_dlen = sizeof(frame->vn) / FIP_BPW;
2003 hton24(frame->vn.fd_mac, FIP_VN_FC_MAP);
2004 hton24(frame->vn.fd_mac + 3, fip->port_id);
2005 hton24(frame->vn.fd_fc_id, fip->port_id);
2006 put_unaligned_be64(fip->lp->wwpn, &frame->vn.fd_wwpn);
2007
2008
2009
2010
2011
2012 if (sub == FIP_SC_VN_CLAIM_NOTIFY || sub == FIP_SC_VN_CLAIM_REP) {
2013 ff = (struct fip_fc4_feat *)(frame + 1);
2014 ff->fd_desc.fip_dtype = FIP_DT_FC4F;
2015 ff->fd_desc.fip_dlen = sizeof(*ff) / FIP_BPW;
2016 ff->fd_fts = fip->lp->fcts;
2017
2018 fcp_feat = 0;
2019 if (fip->lp->service_params & FCP_SPPF_INIT_FCN)
2020 fcp_feat |= FCP_FEAT_INIT;
2021 if (fip->lp->service_params & FCP_SPPF_TARG_FCN)
2022 fcp_feat |= FCP_FEAT_TARG;
2023 fcp_feat <<= (FC_TYPE_FCP * 4) % 32;
2024 ff->fd_ff.fd_feat[FC_TYPE_FCP * 4 / 32] = htonl(fcp_feat);
2025
2026 size = (struct fip_size_desc *)(ff + 1);
2027 size->fd_desc.fip_dtype = FIP_DT_FCOE_SIZE;
2028 size->fd_desc.fip_dlen = sizeof(*size) / FIP_BPW;
2029 size->fd_size = htons(fcoe_ctlr_fcoe_size(fip));
2030 }
2031
2032 skb_put(skb, len);
2033 skb->protocol = htons(ETH_P_FIP);
2034 skb->priority = fip->priority;
2035 skb_reset_mac_header(skb);
2036 skb_reset_network_header(skb);
2037
2038 fip->send(fip, skb);
2039}
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049static void fcoe_ctlr_vn_rport_callback(struct fc_lport *lport,
2050 struct fc_rport_priv *rdata,
2051 enum fc_rport_event event)
2052{
2053 struct fcoe_ctlr *fip = lport->disc.priv;
2054 struct fcoe_rport *frport = fcoe_ctlr_rport(rdata);
2055
2056 LIBFCOE_FIP_DBG(fip, "vn_rport_callback %x event %d\n",
2057 rdata->ids.port_id, event);
2058
2059 mutex_lock(&fip->ctlr_mutex);
2060 switch (event) {
2061 case RPORT_EV_READY:
2062 frport->login_count = 0;
2063 break;
2064 case RPORT_EV_LOGO:
2065 case RPORT_EV_FAILED:
2066 case RPORT_EV_STOP:
2067 frport->login_count++;
2068 if (frport->login_count > FCOE_CTLR_VN2VN_LOGIN_LIMIT) {
2069 LIBFCOE_FIP_DBG(fip,
2070 "rport FLOGI limited port_id %6.6x\n",
2071 rdata->ids.port_id);
2072 lport->tt.rport_logoff(rdata);
2073 }
2074 break;
2075 default:
2076 break;
2077 }
2078 mutex_unlock(&fip->ctlr_mutex);
2079}
2080
2081static struct fc_rport_operations fcoe_ctlr_vn_rport_ops = {
2082 .event_callback = fcoe_ctlr_vn_rport_callback,
2083};
2084
2085
2086
2087
2088
2089
2090
2091static void fcoe_ctlr_disc_stop_locked(struct fc_lport *lport)
2092{
2093 mutex_lock(&lport->disc.disc_mutex);
2094 lport->disc.disc_callback = NULL;
2095 mutex_unlock(&lport->disc.disc_mutex);
2096}
2097
2098
2099
2100
2101
2102
2103
2104
2105static void fcoe_ctlr_disc_stop(struct fc_lport *lport)
2106{
2107 struct fcoe_ctlr *fip = lport->disc.priv;
2108
2109 mutex_lock(&fip->ctlr_mutex);
2110 fcoe_ctlr_disc_stop_locked(lport);
2111 mutex_unlock(&fip->ctlr_mutex);
2112}
2113
2114
2115
2116
2117
2118
2119
2120
2121static void fcoe_ctlr_disc_stop_final(struct fc_lport *lport)
2122{
2123 fcoe_ctlr_disc_stop(lport);
2124 lport->tt.rport_flush_queue();
2125 synchronize_rcu();
2126}
2127
2128
2129
2130
2131
2132
2133
2134static void fcoe_ctlr_vn_restart(struct fcoe_ctlr *fip)
2135{
2136 unsigned long wait;
2137 u32 port_id;
2138
2139 fcoe_ctlr_disc_stop_locked(fip->lp);
2140
2141
2142
2143
2144
2145
2146
2147
2148 port_id = fip->port_id;
2149 if (fip->probe_tries)
2150 port_id = prandom_u32_state(&fip->rnd_state) & 0xffff;
2151 else if (!port_id)
2152 port_id = fip->lp->wwpn & 0xffff;
2153 if (!port_id || port_id == 0xffff)
2154 port_id = 1;
2155 fip->port_id = port_id;
2156
2157 if (fip->probe_tries < FIP_VN_RLIM_COUNT) {
2158 fip->probe_tries++;
2159 wait = prandom_u32() % FIP_VN_PROBE_WAIT;
2160 } else
2161 wait = FIP_VN_RLIM_INT;
2162 mod_timer(&fip->timer, jiffies + msecs_to_jiffies(wait));
2163 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_START);
2164}
2165
2166
2167
2168
2169
2170
2171
2172static void fcoe_ctlr_vn_start(struct fcoe_ctlr *fip)
2173{
2174 fip->probe_tries = 0;
2175 prandom_seed_state(&fip->rnd_state, fip->lp->wwpn);
2176 fcoe_ctlr_vn_restart(fip);
2177}
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188static int fcoe_ctlr_vn_parse(struct fcoe_ctlr *fip,
2189 struct sk_buff *skb,
2190 struct fc_rport_priv *rdata)
2191{
2192 struct fip_header *fiph;
2193 struct fip_desc *desc = NULL;
2194 struct fip_mac_desc *macd = NULL;
2195 struct fip_wwn_desc *wwn = NULL;
2196 struct fip_vn_desc *vn = NULL;
2197 struct fip_size_desc *size = NULL;
2198 struct fcoe_rport *frport;
2199 size_t rlen;
2200 size_t dlen;
2201 u32 desc_mask = 0;
2202 u32 dtype;
2203 u8 sub;
2204
2205 memset(rdata, 0, sizeof(*rdata) + sizeof(*frport));
2206 frport = fcoe_ctlr_rport(rdata);
2207
2208 fiph = (struct fip_header *)skb->data;
2209 frport->flags = ntohs(fiph->fip_flags);
2210
2211 sub = fiph->fip_subcode;
2212 switch (sub) {
2213 case FIP_SC_VN_PROBE_REQ:
2214 case FIP_SC_VN_PROBE_REP:
2215 case FIP_SC_VN_BEACON:
2216 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |
2217 BIT(FIP_DT_VN_ID);
2218 break;
2219 case FIP_SC_VN_CLAIM_NOTIFY:
2220 case FIP_SC_VN_CLAIM_REP:
2221 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |
2222 BIT(FIP_DT_VN_ID) | BIT(FIP_DT_FC4F) |
2223 BIT(FIP_DT_FCOE_SIZE);
2224 break;
2225 default:
2226 LIBFCOE_FIP_DBG(fip, "vn_parse unknown subcode %u\n", sub);
2227 return -EINVAL;
2228 }
2229
2230 rlen = ntohs(fiph->fip_dl_len) * 4;
2231 if (rlen + sizeof(*fiph) > skb->len)
2232 return -EINVAL;
2233
2234 desc = (struct fip_desc *)(fiph + 1);
2235 while (rlen > 0) {
2236 dlen = desc->fip_dlen * FIP_BPW;
2237 if (dlen < sizeof(*desc) || dlen > rlen)
2238 return -EINVAL;
2239
2240 dtype = desc->fip_dtype;
2241 if (dtype < 32) {
2242 if (!(desc_mask & BIT(dtype))) {
2243 LIBFCOE_FIP_DBG(fip,
2244 "unexpected or duplicated desc "
2245 "desc type %u in "
2246 "FIP VN2VN subtype %u\n",
2247 dtype, sub);
2248 return -EINVAL;
2249 }
2250 desc_mask &= ~BIT(dtype);
2251 }
2252
2253 switch (dtype) {
2254 case FIP_DT_MAC:
2255 if (dlen != sizeof(struct fip_mac_desc))
2256 goto len_err;
2257 macd = (struct fip_mac_desc *)desc;
2258 if (!is_valid_ether_addr(macd->fd_mac)) {
2259 LIBFCOE_FIP_DBG(fip,
2260 "Invalid MAC addr %pM in FIP VN2VN\n",
2261 macd->fd_mac);
2262 return -EINVAL;
2263 }
2264 memcpy(frport->enode_mac, macd->fd_mac, ETH_ALEN);
2265 break;
2266 case FIP_DT_NAME:
2267 if (dlen != sizeof(struct fip_wwn_desc))
2268 goto len_err;
2269 wwn = (struct fip_wwn_desc *)desc;
2270 rdata->ids.node_name = get_unaligned_be64(&wwn->fd_wwn);
2271 break;
2272 case FIP_DT_VN_ID:
2273 if (dlen != sizeof(struct fip_vn_desc))
2274 goto len_err;
2275 vn = (struct fip_vn_desc *)desc;
2276 memcpy(frport->vn_mac, vn->fd_mac, ETH_ALEN);
2277 rdata->ids.port_id = ntoh24(vn->fd_fc_id);
2278 rdata->ids.port_name = get_unaligned_be64(&vn->fd_wwpn);
2279 break;
2280 case FIP_DT_FC4F:
2281 if (dlen != sizeof(struct fip_fc4_feat))
2282 goto len_err;
2283 break;
2284 case FIP_DT_FCOE_SIZE:
2285 if (dlen != sizeof(struct fip_size_desc))
2286 goto len_err;
2287 size = (struct fip_size_desc *)desc;
2288 frport->fcoe_len = ntohs(size->fd_size);
2289 break;
2290 default:
2291 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
2292 "in FIP probe\n", dtype);
2293
2294 if (dtype < FIP_DT_VENDOR_BASE)
2295 return -EINVAL;
2296 break;
2297 }
2298 desc = (struct fip_desc *)((char *)desc + dlen);
2299 rlen -= dlen;
2300 }
2301 return 0;
2302
2303len_err:
2304 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
2305 dtype, dlen);
2306 return -EINVAL;
2307}
2308
2309
2310
2311
2312
2313
2314
2315static void fcoe_ctlr_vn_send_claim(struct fcoe_ctlr *fip)
2316{
2317 fcoe_ctlr_vn_send(fip, FIP_SC_VN_CLAIM_NOTIFY, fcoe_all_vn2vn, 0);
2318 fip->sol_time = jiffies;
2319}
2320
2321
2322
2323
2324
2325
2326
2327
2328static void fcoe_ctlr_vn_probe_req(struct fcoe_ctlr *fip,
2329 struct fc_rport_priv *rdata)
2330{
2331 struct fcoe_rport *frport = fcoe_ctlr_rport(rdata);
2332
2333 if (rdata->ids.port_id != fip->port_id)
2334 return;
2335
2336 switch (fip->state) {
2337 case FIP_ST_VNMP_CLAIM:
2338 case FIP_ST_VNMP_UP:
2339 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REP,
2340 frport->enode_mac, 0);
2341 break;
2342 case FIP_ST_VNMP_PROBE1:
2343 case FIP_ST_VNMP_PROBE2:
2344
2345
2346
2347
2348
2349
2350
2351 if (fip->lp->wwpn > rdata->ids.port_name &&
2352 !(frport->flags & FIP_FL_REC_OR_P2P)) {
2353 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REP,
2354 frport->enode_mac, 0);
2355 break;
2356 }
2357
2358 case FIP_ST_VNMP_START:
2359 fcoe_ctlr_vn_restart(fip);
2360 break;
2361 default:
2362 break;
2363 }
2364}
2365
2366
2367
2368
2369
2370
2371
2372
2373static void fcoe_ctlr_vn_probe_reply(struct fcoe_ctlr *fip,
2374 struct fc_rport_priv *rdata)
2375{
2376 if (rdata->ids.port_id != fip->port_id)
2377 return;
2378 switch (fip->state) {
2379 case FIP_ST_VNMP_START:
2380 case FIP_ST_VNMP_PROBE1:
2381 case FIP_ST_VNMP_PROBE2:
2382 case FIP_ST_VNMP_CLAIM:
2383 fcoe_ctlr_vn_restart(fip);
2384 break;
2385 case FIP_ST_VNMP_UP:
2386 fcoe_ctlr_vn_send_claim(fip);
2387 break;
2388 default:
2389 break;
2390 }
2391}
2392
2393
2394
2395
2396
2397
2398
2399
2400static void fcoe_ctlr_vn_add(struct fcoe_ctlr *fip, struct fc_rport_priv *new)
2401{
2402 struct fc_lport *lport = fip->lp;
2403 struct fc_rport_priv *rdata;
2404 struct fc_rport_identifiers *ids;
2405 struct fcoe_rport *frport;
2406 u32 port_id;
2407
2408 port_id = new->ids.port_id;
2409 if (port_id == fip->port_id)
2410 return;
2411
2412 mutex_lock(&lport->disc.disc_mutex);
2413 rdata = lport->tt.rport_create(lport, port_id);
2414 if (!rdata) {
2415 mutex_unlock(&lport->disc.disc_mutex);
2416 return;
2417 }
2418
2419 rdata->ops = &fcoe_ctlr_vn_rport_ops;
2420 rdata->disc_id = lport->disc.disc_id;
2421
2422 ids = &rdata->ids;
2423 if ((ids->port_name != -1 && ids->port_name != new->ids.port_name) ||
2424 (ids->node_name != -1 && ids->node_name != new->ids.node_name))
2425 lport->tt.rport_logoff(rdata);
2426 ids->port_name = new->ids.port_name;
2427 ids->node_name = new->ids.node_name;
2428 mutex_unlock(&lport->disc.disc_mutex);
2429
2430 frport = fcoe_ctlr_rport(rdata);
2431 LIBFCOE_FIP_DBG(fip, "vn_add rport %6.6x %s\n",
2432 port_id, frport->fcoe_len ? "old" : "new");
2433 *frport = *fcoe_ctlr_rport(new);
2434 frport->time = 0;
2435}
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445static int fcoe_ctlr_vn_lookup(struct fcoe_ctlr *fip, u32 port_id, u8 *mac)
2446{
2447 struct fc_lport *lport = fip->lp;
2448 struct fc_rport_priv *rdata;
2449 struct fcoe_rport *frport;
2450 int ret = -1;
2451
2452 rcu_read_lock();
2453 rdata = lport->tt.rport_lookup(lport, port_id);
2454 if (rdata) {
2455 frport = fcoe_ctlr_rport(rdata);
2456 memcpy(mac, frport->enode_mac, ETH_ALEN);
2457 ret = 0;
2458 }
2459 rcu_read_unlock();
2460 return ret;
2461}
2462
2463
2464
2465
2466
2467
2468
2469
2470static void fcoe_ctlr_vn_claim_notify(struct fcoe_ctlr *fip,
2471 struct fc_rport_priv *new)
2472{
2473 struct fcoe_rport *frport = fcoe_ctlr_rport(new);
2474
2475 if (frport->flags & FIP_FL_REC_OR_P2P) {
2476 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);
2477 return;
2478 }
2479 switch (fip->state) {
2480 case FIP_ST_VNMP_START:
2481 case FIP_ST_VNMP_PROBE1:
2482 case FIP_ST_VNMP_PROBE2:
2483 if (new->ids.port_id == fip->port_id)
2484 fcoe_ctlr_vn_restart(fip);
2485 break;
2486 case FIP_ST_VNMP_CLAIM:
2487 case FIP_ST_VNMP_UP:
2488 if (new->ids.port_id == fip->port_id) {
2489 if (new->ids.port_name > fip->lp->wwpn) {
2490 fcoe_ctlr_vn_restart(fip);
2491 break;
2492 }
2493 fcoe_ctlr_vn_send_claim(fip);
2494 break;
2495 }
2496 fcoe_ctlr_vn_send(fip, FIP_SC_VN_CLAIM_REP, frport->enode_mac,
2497 min((u32)frport->fcoe_len,
2498 fcoe_ctlr_fcoe_size(fip)));
2499 fcoe_ctlr_vn_add(fip, new);
2500 break;
2501 default:
2502 break;
2503 }
2504}
2505
2506
2507
2508
2509
2510
2511
2512
2513static void fcoe_ctlr_vn_claim_resp(struct fcoe_ctlr *fip,
2514 struct fc_rport_priv *new)
2515{
2516 LIBFCOE_FIP_DBG(fip, "claim resp from from rport %x - state %s\n",
2517 new->ids.port_id, fcoe_ctlr_state(fip->state));
2518 if (fip->state == FIP_ST_VNMP_UP || fip->state == FIP_ST_VNMP_CLAIM)
2519 fcoe_ctlr_vn_add(fip, new);
2520}
2521
2522
2523
2524
2525
2526
2527
2528
2529static void fcoe_ctlr_vn_beacon(struct fcoe_ctlr *fip,
2530 struct fc_rport_priv *new)
2531{
2532 struct fc_lport *lport = fip->lp;
2533 struct fc_rport_priv *rdata;
2534 struct fcoe_rport *frport;
2535
2536 frport = fcoe_ctlr_rport(new);
2537 if (frport->flags & FIP_FL_REC_OR_P2P) {
2538 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);
2539 return;
2540 }
2541 mutex_lock(&lport->disc.disc_mutex);
2542 rdata = lport->tt.rport_lookup(lport, new->ids.port_id);
2543 if (rdata)
2544 kref_get(&rdata->kref);
2545 mutex_unlock(&lport->disc.disc_mutex);
2546 if (rdata) {
2547 if (rdata->ids.node_name == new->ids.node_name &&
2548 rdata->ids.port_name == new->ids.port_name) {
2549 frport = fcoe_ctlr_rport(rdata);
2550 if (!frport->time && fip->state == FIP_ST_VNMP_UP)
2551 lport->tt.rport_login(rdata);
2552 frport->time = jiffies;
2553 }
2554 kref_put(&rdata->kref, lport->tt.rport_destroy);
2555 return;
2556 }
2557 if (fip->state != FIP_ST_VNMP_UP)
2558 return;
2559
2560
2561
2562
2563
2564
2565 LIBFCOE_FIP_DBG(fip, "beacon from new rport %x. sending claim notify\n",
2566 new->ids.port_id);
2567 if (time_after(jiffies,
2568 fip->sol_time + msecs_to_jiffies(FIP_VN_ANN_WAIT)))
2569 fcoe_ctlr_vn_send_claim(fip);
2570}
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580static unsigned long fcoe_ctlr_vn_age(struct fcoe_ctlr *fip)
2581{
2582 struct fc_lport *lport = fip->lp;
2583 struct fc_rport_priv *rdata;
2584 struct fcoe_rport *frport;
2585 unsigned long next_time;
2586 unsigned long deadline;
2587
2588 next_time = jiffies + msecs_to_jiffies(FIP_VN_BEACON_INT * 10);
2589 mutex_lock(&lport->disc.disc_mutex);
2590 list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {
2591 frport = fcoe_ctlr_rport(rdata);
2592 if (!frport->time)
2593 continue;
2594 deadline = frport->time +
2595 msecs_to_jiffies(FIP_VN_BEACON_INT * 25 / 10);
2596 if (time_after_eq(jiffies, deadline)) {
2597 frport->time = 0;
2598 LIBFCOE_FIP_DBG(fip,
2599 "port %16.16llx fc_id %6.6x beacon expired\n",
2600 rdata->ids.port_name, rdata->ids.port_id);
2601 lport->tt.rport_logoff(rdata);
2602 } else if (time_before(deadline, next_time))
2603 next_time = deadline;
2604 }
2605 mutex_unlock(&lport->disc.disc_mutex);
2606 return next_time;
2607}
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
2618{
2619 struct fip_header *fiph;
2620 enum fip_vn2vn_subcode sub;
2621 struct {
2622 struct fc_rport_priv rdata;
2623 struct fcoe_rport frport;
2624 } buf;
2625 int rc;
2626
2627 fiph = (struct fip_header *)skb->data;
2628 sub = fiph->fip_subcode;
2629
2630 rc = fcoe_ctlr_vn_parse(fip, skb, &buf.rdata);
2631 if (rc) {
2632 LIBFCOE_FIP_DBG(fip, "vn_recv vn_parse error %d\n", rc);
2633 goto drop;
2634 }
2635
2636 mutex_lock(&fip->ctlr_mutex);
2637 switch (sub) {
2638 case FIP_SC_VN_PROBE_REQ:
2639 fcoe_ctlr_vn_probe_req(fip, &buf.rdata);
2640 break;
2641 case FIP_SC_VN_PROBE_REP:
2642 fcoe_ctlr_vn_probe_reply(fip, &buf.rdata);
2643 break;
2644 case FIP_SC_VN_CLAIM_NOTIFY:
2645 fcoe_ctlr_vn_claim_notify(fip, &buf.rdata);
2646 break;
2647 case FIP_SC_VN_CLAIM_REP:
2648 fcoe_ctlr_vn_claim_resp(fip, &buf.rdata);
2649 break;
2650 case FIP_SC_VN_BEACON:
2651 fcoe_ctlr_vn_beacon(fip, &buf.rdata);
2652 break;
2653 default:
2654 LIBFCOE_FIP_DBG(fip, "vn_recv unknown subcode %d\n", sub);
2655 rc = -1;
2656 break;
2657 }
2658 mutex_unlock(&fip->ctlr_mutex);
2659drop:
2660 kfree_skb(skb);
2661 return rc;
2662}
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672static void fcoe_ctlr_disc_recv(struct fc_lport *lport, struct fc_frame *fp)
2673{
2674 struct fc_seq_els_data rjt_data;
2675
2676 rjt_data.reason = ELS_RJT_UNSUP;
2677 rjt_data.explan = ELS_EXPL_NONE;
2678 lport->tt.seq_els_rsp_send(fp, ELS_LS_RJT, &rjt_data);
2679 fc_frame_free(fp);
2680}
2681
2682
2683
2684
2685
2686
2687
2688
2689
2690
2691
2692
2693
2694static void fcoe_ctlr_disc_start(void (*callback)(struct fc_lport *,
2695 enum fc_disc_event),
2696 struct fc_lport *lport)
2697{
2698 struct fc_disc *disc = &lport->disc;
2699 struct fcoe_ctlr *fip = disc->priv;
2700
2701 mutex_lock(&disc->disc_mutex);
2702 disc->disc_callback = callback;
2703 disc->disc_id = (disc->disc_id + 2) | 1;
2704 disc->pending = 1;
2705 schedule_work(&fip->timer_work);
2706 mutex_unlock(&disc->disc_mutex);
2707}
2708
2709
2710
2711
2712
2713
2714
2715
2716
2717static void fcoe_ctlr_vn_disc(struct fcoe_ctlr *fip)
2718{
2719 struct fc_lport *lport = fip->lp;
2720 struct fc_disc *disc = &lport->disc;
2721 struct fc_rport_priv *rdata;
2722 struct fcoe_rport *frport;
2723 void (*callback)(struct fc_lport *, enum fc_disc_event);
2724
2725 mutex_lock(&disc->disc_mutex);
2726 callback = disc->pending ? disc->disc_callback : NULL;
2727 disc->pending = 0;
2728 list_for_each_entry_rcu(rdata, &disc->rports, peers) {
2729 frport = fcoe_ctlr_rport(rdata);
2730 if (frport->time)
2731 lport->tt.rport_login(rdata);
2732 }
2733 mutex_unlock(&disc->disc_mutex);
2734 if (callback)
2735 callback(lport, DISC_EV_SUCCESS);
2736}
2737
2738
2739
2740
2741
2742static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *fip)
2743{
2744 unsigned long next_time;
2745 u8 mac[ETH_ALEN];
2746 u32 new_port_id = 0;
2747
2748 mutex_lock(&fip->ctlr_mutex);
2749 switch (fip->state) {
2750 case FIP_ST_VNMP_START:
2751 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_PROBE1);
2752 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);
2753 next_time = jiffies + msecs_to_jiffies(FIP_VN_PROBE_WAIT);
2754 break;
2755 case FIP_ST_VNMP_PROBE1:
2756 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_PROBE2);
2757 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);
2758 next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);
2759 break;
2760 case FIP_ST_VNMP_PROBE2:
2761 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_CLAIM);
2762 new_port_id = fip->port_id;
2763 hton24(mac, FIP_VN_FC_MAP);
2764 hton24(mac + 3, new_port_id);
2765 fcoe_ctlr_map_dest(fip);
2766 fip->update_mac(fip->lp, mac);
2767 fcoe_ctlr_vn_send_claim(fip);
2768 next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);
2769 break;
2770 case FIP_ST_VNMP_CLAIM:
2771
2772
2773
2774
2775 next_time = fip->sol_time + msecs_to_jiffies(FIP_VN_ANN_WAIT);
2776 if (time_after_eq(jiffies, next_time)) {
2777 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_UP);
2778 fcoe_ctlr_vn_send(fip, FIP_SC_VN_BEACON,
2779 fcoe_all_vn2vn, 0);
2780 next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);
2781 fip->port_ka_time = next_time;
2782 }
2783 fcoe_ctlr_vn_disc(fip);
2784 break;
2785 case FIP_ST_VNMP_UP:
2786 next_time = fcoe_ctlr_vn_age(fip);
2787 if (time_after_eq(jiffies, fip->port_ka_time)) {
2788 fcoe_ctlr_vn_send(fip, FIP_SC_VN_BEACON,
2789 fcoe_all_vn2vn, 0);
2790 fip->port_ka_time = jiffies +
2791 msecs_to_jiffies(FIP_VN_BEACON_INT +
2792 (prandom_u32() % FIP_VN_BEACON_FUZZ));
2793 }
2794 if (time_before(fip->port_ka_time, next_time))
2795 next_time = fip->port_ka_time;
2796 break;
2797 case FIP_ST_LINK_WAIT:
2798 goto unlock;
2799 default:
2800 WARN(1, "unexpected state %d\n", fip->state);
2801 goto unlock;
2802 }
2803 mod_timer(&fip->timer, next_time);
2804unlock:
2805 mutex_unlock(&fip->ctlr_mutex);
2806
2807
2808 if (new_port_id)
2809 fc_lport_set_local_id(fip->lp, new_port_id);
2810}
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824void fcoe_ctlr_mode_set(struct fc_lport *lport, struct fcoe_ctlr *fip,
2825 enum fip_state fip_mode)
2826{
2827 void *priv;
2828
2829 WARN_ON(lport->state != LPORT_ST_RESET &&
2830 lport->state != LPORT_ST_DISABLED);
2831
2832 if (fip_mode == FIP_MODE_VN2VN) {
2833 lport->rport_priv_size = sizeof(struct fcoe_rport);
2834 lport->point_to_multipoint = 1;
2835 lport->tt.disc_recv_req = fcoe_ctlr_disc_recv;
2836 lport->tt.disc_start = fcoe_ctlr_disc_start;
2837 lport->tt.disc_stop = fcoe_ctlr_disc_stop;
2838 lport->tt.disc_stop_final = fcoe_ctlr_disc_stop_final;
2839 priv = fip;
2840 } else {
2841 lport->rport_priv_size = 0;
2842 lport->point_to_multipoint = 0;
2843 lport->tt.disc_recv_req = NULL;
2844 lport->tt.disc_start = NULL;
2845 lport->tt.disc_stop = NULL;
2846 lport->tt.disc_stop_final = NULL;
2847 priv = lport;
2848 }
2849
2850 fc_disc_config(lport, priv);
2851}
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862int fcoe_libfc_config(struct fc_lport *lport, struct fcoe_ctlr *fip,
2863 const struct libfc_function_template *tt, int init_fcp)
2864{
2865
2866 memcpy(&lport->tt, tt, sizeof(*tt));
2867 if (init_fcp && fc_fcp_init(lport))
2868 return -ENOMEM;
2869 fc_exch_init(lport);
2870 fc_elsct_init(lport);
2871 fc_lport_init(lport);
2872 fc_rport_init(lport);
2873 fc_disc_init(lport);
2874 fcoe_ctlr_mode_set(lport, fip, fip->mode);
2875 return 0;
2876}
2877EXPORT_SYMBOL_GPL(fcoe_libfc_config);
2878
2879void fcoe_fcf_get_selected(struct fcoe_fcf_device *fcf_dev)
2880{
2881 struct fcoe_ctlr_device *ctlr_dev = fcoe_fcf_dev_to_ctlr_dev(fcf_dev);
2882 struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev);
2883 struct fcoe_fcf *fcf;
2884
2885 mutex_lock(&fip->ctlr_mutex);
2886 mutex_lock(&ctlr_dev->lock);
2887
2888 fcf = fcoe_fcf_device_priv(fcf_dev);
2889 if (fcf)
2890 fcf_dev->selected = (fcf == fip->sel_fcf) ? 1 : 0;
2891 else
2892 fcf_dev->selected = 0;
2893
2894 mutex_unlock(&ctlr_dev->lock);
2895 mutex_unlock(&fip->ctlr_mutex);
2896}
2897EXPORT_SYMBOL(fcoe_fcf_get_selected);
2898
2899void fcoe_ctlr_set_fip_mode(struct fcoe_ctlr_device *ctlr_dev)
2900{
2901 struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr_dev);
2902 struct fc_lport *lport = ctlr->lp;
2903
2904 mutex_lock(&ctlr->ctlr_mutex);
2905 switch (ctlr_dev->mode) {
2906 case FIP_CONN_TYPE_VN2VN:
2907 ctlr->mode = FIP_MODE_VN2VN;
2908 break;
2909 case FIP_CONN_TYPE_FABRIC:
2910 default:
2911 ctlr->mode = FIP_MODE_FABRIC;
2912 break;
2913 }
2914
2915 mutex_unlock(&ctlr->ctlr_mutex);
2916
2917 fcoe_ctlr_mode_set(lport, ctlr, ctlr->mode);
2918}
2919EXPORT_SYMBOL(fcoe_ctlr_set_fip_mode);
2920