1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* Copyright (c) 2008-2009 Cisco Systems, Inc. All rights reserved.
4	* Copyright (c) 2009 Intel Corporation. All rights reserved.
5	*
6	* Maintained at www.Open-FCoE.org
7	*/
8
9	#include <linux/types.h>
10	#include <linux/module.h>
11	#include <linux/kernel.h>
12	#include <linux/list.h>
13	#include <linux/spinlock.h>
14	#include <linux/timer.h>
15	#include <linux/netdevice.h>
16	#include <linux/etherdevice.h>
17	#include <linux/ethtool.h>
18	#include <linux/if_ether.h>
19	#include <linux/if_vlan.h>
20	#include <linux/errno.h>
21	#include <linux/bitops.h>
22	#include <linux/slab.h>
23	#include <net/rtnetlink.h>
24
25	#include <scsi/fc/fc_els.h>
26	#include <scsi/fc/fc_fs.h>
27	#include <scsi/fc/fc_fip.h>
28	#include <scsi/fc/fc_encaps.h>
29	#include <scsi/fc/fc_fcoe.h>
30	#include <scsi/fc/fc_fcp.h>
31
32	#include <scsi/libfc.h>
33	#include <scsi/libfcoe.h>
34
35	#include "libfcoe.h"
36
37	#define FCOE_CTLR_MIN_FKA 500 /* min keep alive (mS) */
38	#define FCOE_CTLR_DEF_FKA FIP_DEF_FKA /* default keep alive (mS) */
39
40	static void fcoe_ctlr_timeout(struct timer_list *);
41	static void fcoe_ctlr_timer_work(struct work_struct *);
42	static void fcoe_ctlr_recv_work(struct work_struct *);
43	static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *);
44
45	static void fcoe_ctlr_vn_start(struct fcoe_ctlr *);
46	static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *, struct sk_buff *);
47	static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *);
48	static int fcoe_ctlr_vn_lookup(struct fcoe_ctlr *, u32, u8 *);
49
50	static int fcoe_ctlr_vlan_recv(struct fcoe_ctlr *, struct sk_buff *);
51
52	static u8 fcoe_all_fcfs[ETH_ALEN] = FIP_ALL_FCF_MACS;
53	static u8 fcoe_all_enode[ETH_ALEN] = FIP_ALL_ENODE_MACS;
54	static u8 fcoe_all_vn2vn[ETH_ALEN] = FIP_ALL_VN2VN_MACS;
55	static u8 fcoe_all_p2p[ETH_ALEN] = FIP_ALL_P2P_MACS;
56
57	static const char * const fcoe_ctlr_states[] = {
58	[FIP_ST_DISABLED] = "DISABLED",
59	[FIP_ST_LINK_WAIT] = "LINK_WAIT",
60	[FIP_ST_AUTO] = "AUTO",
61	[FIP_ST_NON_FIP] = "NON_FIP",
62	[FIP_ST_ENABLED] = "ENABLED",
63	[FIP_ST_VNMP_START] = "VNMP_START",
64	[FIP_ST_VNMP_PROBE1] = "VNMP_PROBE1",
65	[FIP_ST_VNMP_PROBE2] = "VNMP_PROBE2",
66	[FIP_ST_VNMP_CLAIM] = "VNMP_CLAIM",
67	[FIP_ST_VNMP_UP] = "VNMP_UP",
68	};
69
70	static const char *fcoe_ctlr_state(enum fip_state state)
71	{
72	const char *cp = "unknown";
73
74	if (state < ARRAY_SIZE(fcoe_ctlr_states))
75	cp = fcoe_ctlr_states[state];
76	if (!cp)
77	cp = "unknown";
78	return cp;
79	}
80
81	/**
82	* fcoe_ctlr_set_state() - Set and do debug printing for the new FIP state.
83	* @fip: The FCoE controller
84	* @state: The new state
85	*/
86	static void fcoe_ctlr_set_state(struct fcoe_ctlr *fip, enum fip_state state)
87	{
88	if (state == fip->state)
89	return;
90	if (fip->lp)
91	LIBFCOE_FIP_DBG(fip, "state %s -> %s\n",
92	fcoe_ctlr_state(fip->state), fcoe_ctlr_state(state));
93	fip->state = state;
94	}
95
96	/**
97	* fcoe_ctlr_mtu_valid() - Check if a FCF's MTU is valid
98	* @fcf: The FCF to check
99	*
100	* Return non-zero if FCF fcoe_size has been validated.
101	*/
102	static inline int fcoe_ctlr_mtu_valid(const struct fcoe_fcf *fcf)
103	{
104	return (fcf->flags & FIP_FL_SOL) != 0;
105	}
106
107	/**
108	* fcoe_ctlr_fcf_usable() - Check if a FCF is usable
109	* @fcf: The FCF to check
110	*
111	* Return non-zero if the FCF is usable.
112	*/
113	static inline int fcoe_ctlr_fcf_usable(struct fcoe_fcf *fcf)
114	{
115	u16 flags = FIP_FL_SOL | FIP_FL_AVAIL;
116
117	return (fcf->flags & flags) == flags;
118	}
119
120	/**
121	* fcoe_ctlr_map_dest() - Set flag and OUI for mapping destination addresses
122	* @fip: The FCoE controller
123	*/
124	static void fcoe_ctlr_map_dest(struct fcoe_ctlr *fip)
125	{
126	if (fip->mode == FIP_MODE_VN2VN)
127	hton24(p: fip->dest_addr, FIP_VN_FC_MAP);
128	else
129	hton24(p: fip->dest_addr, FIP_DEF_FC_MAP);
130	hton24(p: fip->dest_addr + 3, v: 0);
131	fip->map_dest = 1;
132	}
133
134	/**
135	* fcoe_ctlr_init() - Initialize the FCoE Controller instance
136	* @fip: The FCoE controller to initialize
137	* @mode: FIP mode to set
138	*/
139	void fcoe_ctlr_init(struct fcoe_ctlr *fip, enum fip_mode mode)
140	{
141	fcoe_ctlr_set_state(fip, state: FIP_ST_LINK_WAIT);
142	fip->mode = mode;
143	fip->fip_resp = false;
144	INIT_LIST_HEAD(list: &fip->fcfs);
145	mutex_init(&fip->ctlr_mutex);
146	spin_lock_init(&fip->ctlr_lock);
147	fip->flogi_oxid = FC_XID_UNKNOWN;
148	timer_setup(&fip->timer, fcoe_ctlr_timeout, 0);
149	INIT_WORK(&fip->timer_work, fcoe_ctlr_timer_work);
150	INIT_WORK(&fip->recv_work, fcoe_ctlr_recv_work);
151	skb_queue_head_init(list: &fip->fip_recv_list);
152	}
153	EXPORT_SYMBOL(fcoe_ctlr_init);
154
155	/**
156	* fcoe_sysfs_fcf_add() - Add a fcoe_fcf{,_device} to a fcoe_ctlr{,_device}
157	* @new: The newly discovered FCF
158	*
159	* Called with fip->ctlr_mutex held
160	*/
161	static int fcoe_sysfs_fcf_add(struct fcoe_fcf *new)
162	{
163	struct fcoe_ctlr *fip = new->fip;
164	struct fcoe_ctlr_device *ctlr_dev;
165	struct fcoe_fcf_device *temp, *fcf_dev;
166	int rc = -ENOMEM;
167
168	LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",
169	new->fabric_name, new->fcf_mac);
170
171	temp = kzalloc(size: sizeof(*temp), GFP_KERNEL);
172	if (!temp)
173	goto out;
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; /* default to unselected */
183
184	/*
185	* If ctlr_dev doesn't exist then it means we're a libfcoe user
186	* who doesn't use fcoe_syfs and didn't allocate a fcoe_ctlr_device.
187	* fnic would be an example of a driver with this behavior. In this
188	* case we want to add the fcoe_fcf to the fcoe_ctlr list, but we
189	* don't want to make sysfs changes.
190	*/
191
192	ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);
193	if (ctlr_dev) {
194	mutex_lock(&ctlr_dev->lock);
195	fcf_dev = fcoe_fcf_device_add(ctlr_dev, temp);
196	if (unlikely(!fcf_dev)) {
197	rc = -ENOMEM;
198	mutex_unlock(lock: &ctlr_dev->lock);
199	goto out;
200	}
201
202	/*
203	* The fcoe_sysfs layer can return a CONNECTED fcf that
204	* has a priv (fcf was never deleted) or a CONNECTED fcf
205	* that doesn't have a priv (fcf was deleted). However,
206	* libfcoe will always delete FCFs before trying to add
207	* them. This is ensured because both recv_adv and
208	* age_fcfs are protected by the the fcoe_ctlr's mutex.
209	* This means that we should never get a FCF with a
210	* non-NULL priv pointer.
211	*/
212	BUG_ON(fcf_dev->priv);
213
214	fcf_dev->priv = new;
215	new->fcf_dev = fcf_dev;
216	mutex_unlock(lock: &ctlr_dev->lock);
217	}
218
219	list_add(new: &new->list, head: &fip->fcfs);
220	fip->fcf_count++;
221	rc = 0;
222
223	out:
224	kfree(objp: temp);
225	return rc;
226	}
227
228	/**
229	* fcoe_sysfs_fcf_del() - Remove a fcoe_fcf{,_device} to a fcoe_ctlr{,_device}
230	* @new: The FCF to be removed
231	*
232	* Called with fip->ctlr_mutex held
233	*/
234	static void fcoe_sysfs_fcf_del(struct fcoe_fcf *new)
235	{
236	struct fcoe_ctlr *fip = new->fip;
237	struct fcoe_ctlr_device *cdev;
238	struct fcoe_fcf_device *fcf_dev;
239
240	list_del(entry: &new->list);
241	fip->fcf_count--;
242
243	/*
244	* If ctlr_dev doesn't exist then it means we're a libfcoe user
245	* who doesn't use fcoe_syfs and didn't allocate a fcoe_ctlr_device
246	* or a fcoe_fcf_device.
247	*
248	* fnic would be an example of a driver with this behavior. In this
249	* case we want to remove the fcoe_fcf from the fcoe_ctlr list (above),
250	* but we don't want to make sysfs changes.
251	*/
252	cdev = fcoe_ctlr_to_ctlr_dev(fip);
253	if (cdev) {
254	mutex_lock(&cdev->lock);
255	fcf_dev = fcoe_fcf_to_fcf_dev(new);
256	WARN_ON(!fcf_dev);
257	new->fcf_dev = NULL;
258	fcoe_fcf_device_delete(fcf_dev);
259	mutex_unlock(lock: &cdev->lock);
260	}
261	kfree(objp: new);
262	}
263
264	/**
265	* fcoe_ctlr_reset_fcfs() - Reset and free all FCFs for a controller
266	* @fip: The FCoE controller whose FCFs are to be reset
267	*
268	* Called with &fcoe_ctlr lock held.
269	*/
270	static void fcoe_ctlr_reset_fcfs(struct fcoe_ctlr *fip)
271	{
272	struct fcoe_fcf *fcf;
273	struct fcoe_fcf *next;
274
275	fip->sel_fcf = NULL;
276	list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {
277	fcoe_sysfs_fcf_del(new: fcf);
278	}
279	WARN_ON(fip->fcf_count);
280
281	fip->sel_time = 0;
282	}
283
284	/**
285	* fcoe_ctlr_destroy() - Disable and tear down a FCoE controller
286	* @fip: The FCoE controller to tear down
287	*
288	* This is called by FCoE drivers before freeing the &fcoe_ctlr.
289	*
290	* The receive handler will have been deleted before this to guarantee
291	* that no more recv_work will be scheduled.
292	*
293	* The timer routine will simply return once we set FIP_ST_DISABLED.
294	* This guarantees that no further timeouts or work will be scheduled.
295	*/
296	void fcoe_ctlr_destroy(struct fcoe_ctlr *fip)
297	{
298	cancel_work_sync(work: &fip->recv_work);
299	skb_queue_purge(list: &fip->fip_recv_list);
300
301	mutex_lock(&fip->ctlr_mutex);
302	fcoe_ctlr_set_state(fip, state: FIP_ST_DISABLED);
303	fcoe_ctlr_reset_fcfs(fip);
304	mutex_unlock(lock: &fip->ctlr_mutex);
305	del_timer_sync(timer: &fip->timer);
306	cancel_work_sync(work: &fip->timer_work);
307	}
308	EXPORT_SYMBOL(fcoe_ctlr_destroy);
309
310	/**
311	* fcoe_ctlr_announce() - announce new FCF selection
312	* @fip: The FCoE controller
313	*
314	* Also sets the destination MAC for FCoE and control packets
315	*
316	* Called with neither ctlr_mutex nor ctlr_lock held.
317	*/
318	static void fcoe_ctlr_announce(struct fcoe_ctlr *fip)
319	{
320	struct fcoe_fcf *sel;
321	struct fcoe_fcf *fcf;
322
323	mutex_lock(&fip->ctlr_mutex);
324	spin_lock_bh(lock: &fip->ctlr_lock);
325
326	kfree_skb(skb: fip->flogi_req);
327	fip->flogi_req = NULL;
328	list_for_each_entry(fcf, &fip->fcfs, list)
329	fcf->flogi_sent = 0;
330
331	spin_unlock_bh(lock: &fip->ctlr_lock);
332	sel = fip->sel_fcf;
333
334	if (sel && ether_addr_equal(addr1: sel->fcf_mac, addr2: fip->dest_addr))
335	goto unlock;
336	if (!is_zero_ether_addr(addr: fip->dest_addr)) {
337	printk(KERN_NOTICE "libfcoe: host%d: "
338	"FIP Fibre-Channel Forwarder MAC %pM deselected\n",
339	fip->lp->host->host_no, fip->dest_addr);
340	eth_zero_addr(addr: fip->dest_addr);
341	}
342	if (sel) {
343	printk(KERN_INFO "libfcoe: host%d: FIP selected "
344	"Fibre-Channel Forwarder MAC %pM\n",
345	fip->lp->host->host_no, sel->fcf_mac);
346	memcpy(fip->dest_addr, sel->fcoe_mac, ETH_ALEN);
347	fip->map_dest = 0;
348	}
349	unlock:
350	mutex_unlock(lock: &fip->ctlr_mutex);
351	}
352
353	/**
354	* fcoe_ctlr_fcoe_size() - Return the maximum FCoE size required for VN_Port
355	* @fip: The FCoE controller to get the maximum FCoE size from
356	*
357	* Returns the maximum packet size including the FCoE header and trailer,
358	* but not including any Ethernet or VLAN headers.
359	*/
360	static inline u32 fcoe_ctlr_fcoe_size(struct fcoe_ctlr *fip)
361	{
362	/*
363	* Determine the max FCoE frame size allowed, including
364	* FCoE header and trailer.
365	* Note: lp->mfs is currently the payload size, not the frame size.
366	*/
367	return fip->lp->mfs + sizeof(struct fc_frame_header) +
368	sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof);
369	}
370
371	/**
372	* fcoe_ctlr_solicit() - Send a FIP solicitation
373	* @fip: The FCoE controller to send the solicitation on
374	* @fcf: The destination FCF (if NULL, a multicast solicitation is sent)
375	*/
376	static void fcoe_ctlr_solicit(struct fcoe_ctlr *fip, struct fcoe_fcf *fcf)
377	{
378	struct sk_buff *skb;
379	struct fip_sol {
380	struct ethhdr eth;
381	struct fip_header fip;
382	struct {
383	struct fip_mac_desc mac;
384	struct fip_wwn_desc wwnn;
385	struct fip_size_desc size;
386	} __packed desc;
387	} __packed * sol;
388	u32 fcoe_size;
389
390	skb = dev_alloc_skb(length: sizeof(*sol));
391	if (!skb)
392	return;
393
394	sol = (struct fip_sol *)skb->data;
395
396	memset(sol, 0, sizeof(*sol));
397	memcpy(sol->eth.h_dest, fcf ? fcf->fcf_mac : fcoe_all_fcfs, ETH_ALEN);
398	memcpy(sol->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
399	sol->eth.h_proto = htons(ETH_P_FIP);
400
401	sol->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
402	sol->fip.fip_op = htons(FIP_OP_DISC);
403	sol->fip.fip_subcode = FIP_SC_SOL;
404	sol->fip.fip_dl_len = htons(sizeof(sol->desc) / FIP_BPW);
405	sol->fip.fip_flags = htons(FIP_FL_FPMA);
406	if (fip->spma)
407	sol->fip.fip_flags |= htons(FIP_FL_SPMA);
408
409	sol->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
410	sol->desc.mac.fd_desc.fip_dlen = sizeof(sol->desc.mac) / FIP_BPW;
411	memcpy(sol->desc.mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
412
413	sol->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
414	sol->desc.wwnn.fd_desc.fip_dlen = sizeof(sol->desc.wwnn) / FIP_BPW;
415	put_unaligned_be64(val: fip->lp->wwnn, p: &sol->desc.wwnn.fd_wwn);
416
417	fcoe_size = fcoe_ctlr_fcoe_size(fip);
418	sol->desc.size.fd_desc.fip_dtype = FIP_DT_FCOE_SIZE;
419	sol->desc.size.fd_desc.fip_dlen = sizeof(sol->desc.size) / FIP_BPW;
420	sol->desc.size.fd_size = htons(fcoe_size);
421
422	skb_put(skb, len: sizeof(*sol));
423	skb->protocol = htons(ETH_P_FIP);
424	skb->priority = fip->priority;
425	skb_reset_mac_header(skb);
426	skb_reset_network_header(skb);
427	fip->send(fip, skb);
428
429	if (!fcf)
430	fip->sol_time = jiffies;
431	}
432
433	/**
434	* fcoe_ctlr_link_up() - Start FCoE controller
435	* @fip: The FCoE controller to start
436	*
437	* Called from the LLD when the network link is ready.
438	*/
439	void fcoe_ctlr_link_up(struct fcoe_ctlr *fip)
440	{
441	mutex_lock(&fip->ctlr_mutex);
442	if (fip->state == FIP_ST_NON_FIP || fip->state == FIP_ST_AUTO) {
443	mutex_unlock(lock: &fip->ctlr_mutex);
444	fc_linkup(fip->lp);
445	} else if (fip->state == FIP_ST_LINK_WAIT) {
446	if (fip->mode == FIP_MODE_NON_FIP)
447	fcoe_ctlr_set_state(fip, state: FIP_ST_NON_FIP);
448	else
449	fcoe_ctlr_set_state(fip, state: FIP_ST_AUTO);
450	switch (fip->mode) {
451	default:
452	LIBFCOE_FIP_DBG(fip, "invalid mode %d\n", fip->mode);
453	fallthrough;
454	case FIP_MODE_AUTO:
455	LIBFCOE_FIP_DBG(fip, "%s", "setting AUTO mode.\n");
456	fallthrough;
457	case FIP_MODE_FABRIC:
458	case FIP_MODE_NON_FIP:
459	mutex_unlock(lock: &fip->ctlr_mutex);
460	fc_linkup(fip->lp);
461	fcoe_ctlr_solicit(fip, NULL);
462	break;
463	case FIP_MODE_VN2VN:
464	fcoe_ctlr_vn_start(fip);
465	mutex_unlock(lock: &fip->ctlr_mutex);
466	fc_linkup(fip->lp);
467	break;
468	}
469	} else
470	mutex_unlock(lock: &fip->ctlr_mutex);
471	}
472	EXPORT_SYMBOL(fcoe_ctlr_link_up);
473
474	/**
475	* fcoe_ctlr_reset() - Reset a FCoE controller
476	* @fip: The FCoE controller to reset
477	*/
478	static void fcoe_ctlr_reset(struct fcoe_ctlr *fip)
479	{
480	fcoe_ctlr_reset_fcfs(fip);
481	del_timer(timer: &fip->timer);
482	fip->ctlr_ka_time = 0;
483	fip->port_ka_time = 0;
484	fip->sol_time = 0;
485	fip->flogi_oxid = FC_XID_UNKNOWN;
486	fcoe_ctlr_map_dest(fip);
487	}
488
489	/**
490	* fcoe_ctlr_link_down() - Stop a FCoE controller
491	* @fip: The FCoE controller to be stopped
492	*
493	* Returns non-zero if the link was up and now isn't.
494	*
495	* Called from the LLD when the network link is not ready.
496	* There may be multiple calls while the link is down.
497	*/
498	int fcoe_ctlr_link_down(struct fcoe_ctlr *fip)
499	{
500	int link_dropped;
501
502	LIBFCOE_FIP_DBG(fip, "link down.\n");
503	mutex_lock(&fip->ctlr_mutex);
504	fcoe_ctlr_reset(fip);
505	link_dropped = fip->state != FIP_ST_LINK_WAIT;
506	fcoe_ctlr_set_state(fip, state: FIP_ST_LINK_WAIT);
507	mutex_unlock(lock: &fip->ctlr_mutex);
508
509	if (link_dropped)
510	fc_linkdown(fip->lp);
511	return link_dropped;
512	}
513	EXPORT_SYMBOL(fcoe_ctlr_link_down);
514
515	/**
516	* fcoe_ctlr_send_keep_alive() - Send a keep-alive to the selected FCF
517	* @fip: The FCoE controller to send the FKA on
518	* @lport: libfc fc_lport to send from
519	* @ports: 0 for controller keep-alive, 1 for port keep-alive
520	* @sa: The source MAC address
521	*
522	* A controller keep-alive is sent every fka_period (typically 8 seconds).
523	* The source MAC is the native MAC address.
524	*
525	* A port keep-alive is sent every 90 seconds while logged in.
526	* The source MAC is the assigned mapped source address.
527	* The destination is the FCF's F-port.
528	*/
529	static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip,
530	struct fc_lport *lport,
531	int ports, u8 *sa)
532	{
533	struct sk_buff *skb;
534	struct fip_kal {
535	struct ethhdr eth;
536	struct fip_header fip;
537	struct fip_mac_desc mac;
538	} __packed * kal;
539	struct fip_vn_desc *vn;
540	u32 len;
541	struct fc_lport *lp;
542	struct fcoe_fcf *fcf;
543
544	fcf = fip->sel_fcf;
545	lp = fip->lp;
546	if (!fcf || (ports && !lp->port_id))
547	return;
548
549	len = sizeof(*kal) + ports * sizeof(*vn);
550	skb = dev_alloc_skb(length: len);
551	if (!skb)
552	return;
553
554	kal = (struct fip_kal *)skb->data;
555	memset(kal, 0, len);
556	memcpy(kal->eth.h_dest, fcf->fcf_mac, ETH_ALEN);
557	memcpy(kal->eth.h_source, sa, ETH_ALEN);
558	kal->eth.h_proto = htons(ETH_P_FIP);
559
560	kal->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
561	kal->fip.fip_op = htons(FIP_OP_CTRL);
562	kal->fip.fip_subcode = FIP_SC_KEEP_ALIVE;
563	kal->fip.fip_dl_len = htons((sizeof(kal->mac) +
564	ports * sizeof(*vn)) / FIP_BPW);
565	kal->fip.fip_flags = htons(FIP_FL_FPMA);
566	if (fip->spma)
567	kal->fip.fip_flags |= htons(FIP_FL_SPMA);
568
569	kal->mac.fd_desc.fip_dtype = FIP_DT_MAC;
570	kal->mac.fd_desc.fip_dlen = sizeof(kal->mac) / FIP_BPW;
571	memcpy(kal->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
572	if (ports) {
573	vn = (struct fip_vn_desc *)(kal + 1);
574	vn->fd_desc.fip_dtype = FIP_DT_VN_ID;
575	vn->fd_desc.fip_dlen = sizeof(*vn) / FIP_BPW;
576	memcpy(vn->fd_mac, fip->get_src_addr(lport), ETH_ALEN);
577	hton24(p: vn->fd_fc_id, v: lport->port_id);
578	put_unaligned_be64(val: lport->wwpn, p: &vn->fd_wwpn);
579	}
580	skb_put(skb, len);
581	skb->protocol = htons(ETH_P_FIP);
582	skb->priority = fip->priority;
583	skb_reset_mac_header(skb);
584	skb_reset_network_header(skb);
585	fip->send(fip, skb);
586	}
587
588	/**
589	* fcoe_ctlr_encaps() - Encapsulate an ELS frame for FIP, without sending it
590	* @fip: The FCoE controller for the ELS frame
591	* @lport: The local port
592	* @dtype: The FIP descriptor type for the frame
593	* @skb: The FCoE ELS frame including FC header but no FCoE headers
594	* @d_id: The destination port ID.
595	*
596	* Returns non-zero error code on failure.
597	*
598	* The caller must check that the length is a multiple of 4.
599	*
600	* The @skb must have enough headroom (28 bytes) and tailroom (8 bytes).
601	* Headroom includes the FIP encapsulation description, FIP header, and
602	* Ethernet header. The tailroom is for the FIP MAC descriptor.
603	*/
604	static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip, struct fc_lport *lport,
605	u8 dtype, struct sk_buff *skb, u32 d_id)
606	{
607	struct fip_encaps_head {
608	struct ethhdr eth;
609	struct fip_header fip;
610	struct fip_encaps encaps;
611	} __packed * cap;
612	struct fc_frame_header *fh;
613	struct fip_mac_desc *mac;
614	struct fcoe_fcf *fcf;
615	size_t dlen;
616	u16 fip_flags;
617	u8 op;
618
619	fh = (struct fc_frame_header *)skb->data;
620	op = *(u8 *)(fh + 1);
621	dlen = sizeof(struct fip_encaps) + skb->len; /* len before push */
622	cap = skb_push(skb, len: sizeof(*cap));
623	memset(cap, 0, sizeof(*cap));
624
625	if (lport->point_to_multipoint) {
626	if (fcoe_ctlr_vn_lookup(fip, d_id, cap->eth.h_dest))
627	return -ENODEV;
628	fip_flags = 0;
629	} else {
630	fcf = fip->sel_fcf;
631	if (!fcf)
632	return -ENODEV;
633	fip_flags = fcf->flags;
634	fip_flags &= fip->spma ? FIP_FL_SPMA | FIP_FL_FPMA :
635	FIP_FL_FPMA;
636	if (!fip_flags)
637	return -ENODEV;
638	memcpy(cap->eth.h_dest, fcf->fcf_mac, ETH_ALEN);
639	}
640	memcpy(cap->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
641	cap->eth.h_proto = htons(ETH_P_FIP);
642
643	cap->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
644	cap->fip.fip_op = htons(FIP_OP_LS);
645	if (op == ELS_LS_ACC || op == ELS_LS_RJT)
646	cap->fip.fip_subcode = FIP_SC_REP;
647	else
648	cap->fip.fip_subcode = FIP_SC_REQ;
649	cap->fip.fip_flags = htons(fip_flags);
650
651	cap->encaps.fd_desc.fip_dtype = dtype;
652	cap->encaps.fd_desc.fip_dlen = dlen / FIP_BPW;
653
654	if (op != ELS_LS_RJT) {
655	dlen += sizeof(*mac);
656	mac = skb_put_zero(skb, len: sizeof(*mac));
657	mac->fd_desc.fip_dtype = FIP_DT_MAC;
658	mac->fd_desc.fip_dlen = sizeof(*mac) / FIP_BPW;
659	if (dtype != FIP_DT_FLOGI && dtype != FIP_DT_FDISC) {
660	memcpy(mac->fd_mac, fip->get_src_addr(lport), ETH_ALEN);
661	} else if (fip->mode == FIP_MODE_VN2VN) {
662	hton24(p: mac->fd_mac, FIP_VN_FC_MAP);
663	hton24(p: mac->fd_mac + 3, v: fip->port_id);
664	} else if (fip_flags & FIP_FL_SPMA) {
665	LIBFCOE_FIP_DBG(fip, "FLOGI/FDISC sent with SPMA\n");
666	memcpy(mac->fd_mac, fip->ctl_src_addr, ETH_ALEN);
667	} else {
668	LIBFCOE_FIP_DBG(fip, "FLOGI/FDISC sent with FPMA\n");
669	/* FPMA only FLOGI. Must leave the MAC desc zeroed. */
670	}
671	}
672	cap->fip.fip_dl_len = htons(dlen / FIP_BPW);
673
674	skb->protocol = htons(ETH_P_FIP);
675	skb->priority = fip->priority;
676	skb_reset_mac_header(skb);
677	skb_reset_network_header(skb);
678	return 0;
679	}
680
681	/**
682	* fcoe_ctlr_els_send() - Send an ELS frame encapsulated by FIP if appropriate.
683	* @fip: FCoE controller.
684	* @lport: libfc fc_lport to send from
685	* @skb: FCoE ELS frame including FC header but no FCoE headers.
686	*
687	* Returns a non-zero error code if the frame should not be sent.
688	* Returns zero if the caller should send the frame with FCoE encapsulation.
689	*
690	* The caller must check that the length is a multiple of 4.
691	* The SKB must have enough headroom (28 bytes) and tailroom (8 bytes).
692	* The the skb must also be an fc_frame.
693	*
694	* This is called from the lower-level driver with spinlocks held,
695	* so we must not take a mutex here.
696	*/
697	int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct fc_lport *lport,
698	struct sk_buff *skb)
699	{
700	struct fc_frame *fp;
701	struct fc_frame_header *fh;
702	u16 old_xid;
703	u8 op;
704	u8 mac[ETH_ALEN];
705
706	fp = container_of(skb, struct fc_frame, skb);
707	fh = (struct fc_frame_header *)skb->data;
708	op = *(u8 *)(fh + 1);
709
710	if (op == ELS_FLOGI && fip->mode != FIP_MODE_VN2VN) {
711	old_xid = fip->flogi_oxid;
712	fip->flogi_oxid = ntohs(fh->fh_ox_id);
713	if (fip->state == FIP_ST_AUTO) {
714	if (old_xid == FC_XID_UNKNOWN)
715	fip->flogi_count = 0;
716	fip->flogi_count++;
717	if (fip->flogi_count < 3)
718	goto drop;
719	fcoe_ctlr_map_dest(fip);
720	return 0;
721	}
722	if (fip->state == FIP_ST_NON_FIP)
723	fcoe_ctlr_map_dest(fip);
724	}
725
726	if (fip->state == FIP_ST_NON_FIP)
727	return 0;
728	if (!fip->sel_fcf && fip->mode != FIP_MODE_VN2VN)
729	goto drop;
730	switch (op) {
731	case ELS_FLOGI:
732	op = FIP_DT_FLOGI;
733	if (fip->mode == FIP_MODE_VN2VN)
734	break;
735	spin_lock_bh(lock: &fip->ctlr_lock);
736	kfree_skb(skb: fip->flogi_req);
737	fip->flogi_req = skb;
738	fip->flogi_req_send = 1;
739	spin_unlock_bh(lock: &fip->ctlr_lock);
740	schedule_work(work: &fip->timer_work);
741	return -EINPROGRESS;
742	case ELS_FDISC:
743	if (ntoh24(p: fh->fh_s_id))
744	return 0;
745	op = FIP_DT_FDISC;
746	break;
747	case ELS_LOGO:
748	if (fip->mode == FIP_MODE_VN2VN) {
749	if (fip->state != FIP_ST_VNMP_UP)
750	goto drop;
751	if (ntoh24(p: fh->fh_d_id) == FC_FID_FLOGI)
752	goto drop;
753	} else {
754	if (fip->state != FIP_ST_ENABLED)
755	return 0;
756	if (ntoh24(p: fh->fh_d_id) != FC_FID_FLOGI)
757	return 0;
758	}
759	op = FIP_DT_LOGO;
760	break;
761	case ELS_LS_ACC:
762	/*
763	* If non-FIP, we may have gotten an SID by accepting an FLOGI
764	* from a point-to-point connection. Switch to using
765	* the source mac based on the SID. The destination
766	* MAC in this case would have been set by receiving the
767	* FLOGI.
768	*/
769	if (fip->state == FIP_ST_NON_FIP) {
770	if (fip->flogi_oxid == FC_XID_UNKNOWN)
771	return 0;
772	fip->flogi_oxid = FC_XID_UNKNOWN;
773	fc_fcoe_set_mac(mac, did: fh->fh_d_id);
774	fip->update_mac(lport, mac);
775	}
776	fallthrough;
777	case ELS_LS_RJT:
778	op = fr_encaps(fp);
779	if (op)
780	break;
781	return 0;
782	default:
783	if (fip->state != FIP_ST_ENABLED &&
784	fip->state != FIP_ST_VNMP_UP)
785	goto drop;
786	return 0;
787	}
788	LIBFCOE_FIP_DBG(fip, "els_send op %u d_id %x\n",
789	op, ntoh24(fh->fh_d_id));
790	if (fcoe_ctlr_encaps(fip, lport, dtype: op, skb, d_id: ntoh24(p: fh->fh_d_id)))
791	goto drop;
792	fip->send(fip, skb);
793	return -EINPROGRESS;
794	drop:
795	LIBFCOE_FIP_DBG(fip, "drop els_send op %u d_id %x\n",
796	op, ntoh24(fh->fh_d_id));
797	kfree_skb(skb);
798	return -EINVAL;
799	}
800	EXPORT_SYMBOL(fcoe_ctlr_els_send);
801
802	/**
803	* fcoe_ctlr_age_fcfs() - Reset and free all old FCFs for a controller
804	* @fip: The FCoE controller to free FCFs on
805	*
806	* Called with lock held and preemption disabled.
807	*
808	* An FCF is considered old if we have missed two advertisements.
809	* That is, there have been no valid advertisement from it for 2.5
810	* times its keep-alive period.
811	*
812	* In addition, determine the time when an FCF selection can occur.
813	*
814	* Also, increment the MissDiscAdvCount when no advertisement is received
815	* for the corresponding FCF for 1.5 * FKA_ADV_PERIOD (FC-BB-5 LESB).
816	*
817	* Returns the time in jiffies for the next call.
818	*/
819	static unsigned long fcoe_ctlr_age_fcfs(struct fcoe_ctlr *fip)
820	{
821	struct fcoe_fcf *fcf;
822	struct fcoe_fcf *next;
823	unsigned long next_timer = jiffies + msecs_to_jiffies(FIP_VN_KA_PERIOD);
824	unsigned long deadline;
825	unsigned long sel_time = 0;
826	struct list_head del_list;
827
828	INIT_LIST_HEAD(list: &del_list);
829
830	list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {
831	deadline = fcf->time + fcf->fka_period + fcf->fka_period / 2;
832	if (fip->sel_fcf == fcf) {
833	if (time_after(jiffies, deadline)) {
834	u64 miss_cnt;
835
836	miss_cnt = this_cpu_inc_return(fip->lp->stats->MissDiscAdvCount);
837	printk(KERN_INFO "libfcoe: host%d: "
838	"Missing Discovery Advertisement "
839	"for fab %16.16llx count %lld\n",
840	fip->lp->host->host_no, fcf->fabric_name,
841	miss_cnt);
842	} else if (time_after(next_timer, deadline))
843	next_timer = deadline;
844	}
845
846	deadline += fcf->fka_period;
847	if (time_after_eq(jiffies, deadline)) {
848	if (fip->sel_fcf == fcf)
849	fip->sel_fcf = NULL;
850	/*
851	* Move to delete list so we can call
852	* fcoe_sysfs_fcf_del (which can sleep)
853	* after the put_cpu().
854	*/
855	list_del(entry: &fcf->list);
856	list_add(new: &fcf->list, head: &del_list);
857	this_cpu_inc(fip->lp->stats->VLinkFailureCount);
858	} else {
859	if (time_after(next_timer, deadline))
860	next_timer = deadline;
861	if (fcoe_ctlr_mtu_valid(fcf) &&
862	(!sel_time || time_before(sel_time, fcf->time)))
863	sel_time = fcf->time;
864	}
865	}
866
867	list_for_each_entry_safe(fcf, next, &del_list, list) {
868	/* Removes fcf from current list */
869	fcoe_sysfs_fcf_del(new: fcf);
870	}
871
872	if (sel_time && !fip->sel_fcf && !fip->sel_time) {
873	sel_time += msecs_to_jiffies(FCOE_CTLR_START_DELAY);
874	fip->sel_time = sel_time;
875	}
876
877	return next_timer;
878	}
879
880	/**
881	* fcoe_ctlr_parse_adv() - Decode a FIP advertisement into a new FCF entry
882	* @fip: The FCoE controller receiving the advertisement
883	* @skb: The received FIP advertisement frame
884	* @fcf: The resulting FCF entry
885	*
886	* Returns zero on a valid parsed advertisement,
887	* otherwise returns non zero value.
888	*/
889	static int fcoe_ctlr_parse_adv(struct fcoe_ctlr *fip,
890	struct sk_buff *skb, struct fcoe_fcf *fcf)
891	{
892	struct fip_header *fiph;
893	struct fip_desc *desc = NULL;
894	struct fip_wwn_desc *wwn;
895	struct fip_fab_desc *fab;
896	struct fip_fka_desc *fka;
897	unsigned long t;
898	size_t rlen;
899	size_t dlen;
900	u32 desc_mask;
901
902	memset(fcf, 0, sizeof(*fcf));
903	fcf->fka_period = msecs_to_jiffies(FCOE_CTLR_DEF_FKA);
904
905	fiph = (struct fip_header *)skb->data;
906	fcf->flags = ntohs(fiph->fip_flags);
907
908	/*
909	* mask of required descriptors. validating each one clears its bit.
910	*/
911	desc_mask = BIT(FIP_DT_PRI) | BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |
912	BIT(FIP_DT_FAB) | BIT(FIP_DT_FKA);
913
914	rlen = ntohs(fiph->fip_dl_len) * 4;
915	if (rlen + sizeof(*fiph) > skb->len)
916	return -EINVAL;
917
918	desc = (struct fip_desc *)(fiph + 1);
919	while (rlen > 0) {
920	dlen = desc->fip_dlen * FIP_BPW;
921	if (dlen < sizeof(*desc) || dlen > rlen)
922	return -EINVAL;
923	/* Drop Adv if there are duplicate critical descriptors */
924	if ((desc->fip_dtype < 32) &&
925	!(desc_mask & 1U << desc->fip_dtype)) {
926	LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
927	"Descriptors in FIP adv\n");
928	return -EINVAL;
929	}
930	switch (desc->fip_dtype) {
931	case FIP_DT_PRI:
932	if (dlen != sizeof(struct fip_pri_desc))
933	goto len_err;
934	fcf->pri = ((struct fip_pri_desc *)desc)->fd_pri;
935	desc_mask &= ~BIT(FIP_DT_PRI);
936	break;
937	case FIP_DT_MAC:
938	if (dlen != sizeof(struct fip_mac_desc))
939	goto len_err;
940	memcpy(fcf->fcf_mac,
941	((struct fip_mac_desc *)desc)->fd_mac,
942	ETH_ALEN);
943	memcpy(fcf->fcoe_mac, fcf->fcf_mac, ETH_ALEN);
944	if (!is_valid_ether_addr(addr: fcf->fcf_mac)) {
945	LIBFCOE_FIP_DBG(fip,
946	"Invalid MAC addr %pM in FIP adv\n",
947	fcf->fcf_mac);
948	return -EINVAL;
949	}
950	desc_mask &= ~BIT(FIP_DT_MAC);
951	break;
952	case FIP_DT_NAME:
953	if (dlen != sizeof(struct fip_wwn_desc))
954	goto len_err;
955	wwn = (struct fip_wwn_desc *)desc;
956	fcf->switch_name = get_unaligned_be64(p: &wwn->fd_wwn);
957	desc_mask &= ~BIT(FIP_DT_NAME);
958	break;
959	case FIP_DT_FAB:
960	if (dlen != sizeof(struct fip_fab_desc))
961	goto len_err;
962	fab = (struct fip_fab_desc *)desc;
963	fcf->fabric_name = get_unaligned_be64(p: &fab->fd_wwn);
964	fcf->vfid = ntohs(fab->fd_vfid);
965	fcf->fc_map = ntoh24(p: fab->fd_map);
966	desc_mask &= ~BIT(FIP_DT_FAB);
967	break;
968	case FIP_DT_FKA:
969	if (dlen != sizeof(struct fip_fka_desc))
970	goto len_err;
971	fka = (struct fip_fka_desc *)desc;
972	if (fka->fd_flags & FIP_FKA_ADV_D)
973	fcf->fd_flags = 1;
974	t = ntohl(fka->fd_fka_period);
975	if (t >= FCOE_CTLR_MIN_FKA)
976	fcf->fka_period = msecs_to_jiffies(m: t);
977	desc_mask &= ~BIT(FIP_DT_FKA);
978	break;
979	case FIP_DT_MAP_OUI:
980	case FIP_DT_FCOE_SIZE:
981	case FIP_DT_FLOGI:
982	case FIP_DT_FDISC:
983	case FIP_DT_LOGO:
984	case FIP_DT_ELP:
985	default:
986	LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
987	"in FIP adv\n", desc->fip_dtype);
988	/* standard says ignore unknown descriptors >= 128 */
989	if (desc->fip_dtype < FIP_DT_NON_CRITICAL)
990	return -EINVAL;
991	break;
992	}
993	desc = (struct fip_desc *)((char *)desc + dlen);
994	rlen -= dlen;
995	}
996	if (!fcf->fc_map || (fcf->fc_map & 0x10000))
997	return -EINVAL;
998	if (!fcf->switch_name)
999	return -EINVAL;
1000	if (desc_mask) {
1001	LIBFCOE_FIP_DBG(fip, "adv missing descriptors mask %x\n",
1002	desc_mask);
1003	return -EINVAL;
1004	}
1005	return 0;
1006
1007	len_err:
1008	LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
1009	desc->fip_dtype, dlen);
1010	return -EINVAL;
1011	}
1012
1013	/**
1014	* fcoe_ctlr_recv_adv() - Handle an incoming advertisement
1015	* @fip: The FCoE controller receiving the advertisement
1016	* @skb: The received FIP packet
1017	*/
1018	static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)
1019	{
1020	struct fcoe_fcf *fcf;
1021	struct fcoe_fcf new;
1022	unsigned long sol_tov = msecs_to_jiffies(FCOE_CTLR_SOL_TOV);
1023	int first = 0;
1024	int mtu_valid;
1025	int found = 0;
1026	int rc = 0;
1027
1028	if (fcoe_ctlr_parse_adv(fip, skb, fcf: &new))
1029	return;
1030
1031	mutex_lock(&fip->ctlr_mutex);
1032	first = list_empty(head: &fip->fcfs);
1033	list_for_each_entry(fcf, &fip->fcfs, list) {
1034	if (fcf->switch_name == new.switch_name &&
1035	fcf->fabric_name == new.fabric_name &&
1036	fcf->fc_map == new.fc_map &&
1037	ether_addr_equal(addr1: fcf->fcf_mac, addr2: new.fcf_mac)) {
1038	found = 1;
1039	break;
1040	}
1041	}
1042	if (!found) {
1043	if (fip->fcf_count >= FCOE_CTLR_FCF_LIMIT)
1044	goto out;
1045
1046	fcf = kmalloc(size: sizeof(*fcf), GFP_ATOMIC);
1047	if (!fcf)
1048	goto out;
1049
1050	memcpy(fcf, &new, sizeof(new));
1051	fcf->fip = fip;
1052	rc = fcoe_sysfs_fcf_add(new: fcf);
1053	if (rc) {
1054	printk(KERN_ERR "Failed to allocate sysfs instance "
1055	"for FCF, fab %16.16llx mac %pM\n",
1056	new.fabric_name, new.fcf_mac);
1057	kfree(objp: fcf);
1058	goto out;
1059	}
1060	} else {
1061	/*
1062	* Update the FCF's keep-alive descriptor flags.
1063	* Other flag changes from new advertisements are
1064	* ignored after a solicited advertisement is
1065	* received and the FCF is selectable (usable).
1066	*/
1067	fcf->fd_flags = new.fd_flags;
1068	if (!fcoe_ctlr_fcf_usable(fcf))
1069	fcf->flags = new.flags;
1070
1071	if (fcf == fip->sel_fcf && !fcf->fd_flags) {
1072	fip->ctlr_ka_time -= fcf->fka_period;
1073	fip->ctlr_ka_time += new.fka_period;
1074	if (time_before(fip->ctlr_ka_time, fip->timer.expires))
1075	mod_timer(timer: &fip->timer, expires: fip->ctlr_ka_time);
1076	}
1077	fcf->fka_period = new.fka_period;
1078	memcpy(fcf->fcf_mac, new.fcf_mac, ETH_ALEN);
1079	}
1080
1081	mtu_valid = fcoe_ctlr_mtu_valid(fcf);
1082	fcf->time = jiffies;
1083	if (!found)
1084	LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",
1085	fcf->fabric_name, fcf->fcf_mac);
1086
1087	/*
1088	* If this advertisement is not solicited and our max receive size
1089	* hasn't been verified, send a solicited advertisement.
1090	*/
1091	if (!mtu_valid)
1092	fcoe_ctlr_solicit(fip, fcf);
1093
1094	/*
1095	* If its been a while since we did a solicit, and this is
1096	* the first advertisement we've received, do a multicast
1097	* solicitation to gather as many advertisements as we can
1098	* before selection occurs.
1099	*/
1100	if (first && time_after(jiffies, fip->sol_time + sol_tov))
1101	fcoe_ctlr_solicit(fip, NULL);
1102
1103	/*
1104	* Put this FCF at the head of the list for priority among equals.
1105	* This helps in the case of an NPV switch which insists we use
1106	* the FCF that answers multicast solicitations, not the others that
1107	* are sending periodic multicast advertisements.
1108	*/
1109	if (mtu_valid)
1110	list_move(list: &fcf->list, head: &fip->fcfs);
1111
1112	/*
1113	* If this is the first validated FCF, note the time and
1114	* set a timer to trigger selection.
1115	*/
1116	if (mtu_valid && !fip->sel_fcf && !fip->sel_time &&
1117	fcoe_ctlr_fcf_usable(fcf)) {
1118	fip->sel_time = jiffies +
1119	msecs_to_jiffies(FCOE_CTLR_START_DELAY);
1120	if (!timer_pending(timer: &fip->timer) ||
1121	time_before(fip->sel_time, fip->timer.expires))
1122	mod_timer(timer: &fip->timer, expires: fip->sel_time);
1123	}
1124
1125	out:
1126	mutex_unlock(lock: &fip->ctlr_mutex);
1127	}
1128
1129	/**
1130	* fcoe_ctlr_recv_els() - Handle an incoming FIP encapsulated ELS frame
1131	* @fip: The FCoE controller which received the packet
1132	* @skb: The received FIP packet
1133	*/
1134	static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)
1135	{
1136	struct fc_lport *lport = fip->lp;
1137	struct fip_header *fiph;
1138	struct fc_frame *fp = (struct fc_frame *)skb;
1139	struct fc_frame_header *fh = NULL;
1140	struct fip_desc *desc;
1141	struct fip_encaps *els;
1142	struct fcoe_fcf *sel;
1143	enum fip_desc_type els_dtype = 0;
1144	u8 els_op;
1145	u8 sub;
1146	u8 granted_mac[ETH_ALEN] = { 0 };
1147	size_t els_len = 0;
1148	size_t rlen;
1149	size_t dlen;
1150	u32 desc_mask = 0;
1151	u32 desc_cnt = 0;
1152
1153	fiph = (struct fip_header *)skb->data;
1154	sub = fiph->fip_subcode;
1155	if (sub != FIP_SC_REQ && sub != FIP_SC_REP)
1156	goto drop;
1157
1158	rlen = ntohs(fiph->fip_dl_len) * 4;
1159	if (rlen + sizeof(*fiph) > skb->len)
1160	goto drop;
1161
1162	desc = (struct fip_desc *)(fiph + 1);
1163	while (rlen > 0) {
1164	desc_cnt++;
1165	dlen = desc->fip_dlen * FIP_BPW;
1166	if (dlen < sizeof(*desc) || dlen > rlen)
1167	goto drop;
1168	/* Drop ELS if there are duplicate critical descriptors */
1169	if (desc->fip_dtype < 32) {
1170	if ((desc->fip_dtype != FIP_DT_MAC) &&
1171	(desc_mask & 1U << desc->fip_dtype)) {
1172	LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
1173	"Descriptors in FIP ELS\n");
1174	goto drop;
1175	}
1176	desc_mask |= (1 << desc->fip_dtype);
1177	}
1178	switch (desc->fip_dtype) {
1179	case FIP_DT_MAC:
1180	sel = fip->sel_fcf;
1181	if (desc_cnt == 1) {
1182	LIBFCOE_FIP_DBG(fip, "FIP descriptors "
1183	"received out of order\n");
1184	goto drop;
1185	}
1186	/*
1187	* Some switch implementations send two MAC descriptors,
1188	* with first MAC(granted_mac) being the FPMA, and the
1189	* second one(fcoe_mac) is used as destination address
1190	* for sending/receiving FCoE packets. FIP traffic is
1191	* sent using fip_mac. For regular switches, both
1192	* fip_mac and fcoe_mac would be the same.
1193	*/
1194	if (desc_cnt == 2)
1195	memcpy(granted_mac,
1196	((struct fip_mac_desc *)desc)->fd_mac,
1197	ETH_ALEN);
1198
1199	if (dlen != sizeof(struct fip_mac_desc))
1200	goto len_err;
1201
1202	if ((desc_cnt == 3) && (sel))
1203	memcpy(sel->fcoe_mac,
1204	((struct fip_mac_desc *)desc)->fd_mac,
1205	ETH_ALEN);
1206	break;
1207	case FIP_DT_FLOGI:
1208	case FIP_DT_FDISC:
1209	case FIP_DT_LOGO:
1210	case FIP_DT_ELP:
1211	if (desc_cnt != 1) {
1212	LIBFCOE_FIP_DBG(fip, "FIP descriptors "
1213	"received out of order\n");
1214	goto drop;
1215	}
1216	if (fh)
1217	goto drop;
1218	if (dlen < sizeof(*els) + sizeof(*fh) + 1)
1219	goto len_err;
1220	els_len = dlen - sizeof(*els);
1221	els = (struct fip_encaps *)desc;
1222	fh = (struct fc_frame_header *)(els + 1);
1223	els_dtype = desc->fip_dtype;
1224	break;
1225	default:
1226	LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
1227	"in FIP adv\n", desc->fip_dtype);
1228	/* standard says ignore unknown descriptors >= 128 */
1229	if (desc->fip_dtype < FIP_DT_NON_CRITICAL)
1230	goto drop;
1231	if (desc_cnt <= 2) {
1232	LIBFCOE_FIP_DBG(fip, "FIP descriptors "
1233	"received out of order\n");
1234	goto drop;
1235	}
1236	break;
1237	}
1238	desc = (struct fip_desc *)((char *)desc + dlen);
1239	rlen -= dlen;
1240	}
1241
1242	if (!fh)
1243	goto drop;
1244	els_op = *(u8 *)(fh + 1);
1245
1246	if ((els_dtype == FIP_DT_FLOGI || els_dtype == FIP_DT_FDISC) &&
1247	sub == FIP_SC_REP && fip->mode != FIP_MODE_VN2VN) {
1248	if (els_op == ELS_LS_ACC) {
1249	if (!is_valid_ether_addr(addr: granted_mac)) {
1250	LIBFCOE_FIP_DBG(fip,
1251	"Invalid MAC address %pM in FIP ELS\n",
1252	granted_mac);
1253	goto drop;
1254	}
1255	memcpy(fr_cb(fp)->granted_mac, granted_mac, ETH_ALEN);
1256
1257	if (fip->flogi_oxid == ntohs(fh->fh_ox_id)) {
1258	fip->flogi_oxid = FC_XID_UNKNOWN;
1259	if (els_dtype == FIP_DT_FLOGI)
1260	fcoe_ctlr_announce(fip);
1261	}
1262	} else if (els_dtype == FIP_DT_FLOGI &&
1263	!fcoe_ctlr_flogi_retry(fip))
1264	goto drop; /* retrying FLOGI so drop reject */
1265	}
1266
1267	if ((desc_cnt == 0) || ((els_op != ELS_LS_RJT) &&
1268	(!(1U << FIP_DT_MAC & desc_mask)))) {
1269	LIBFCOE_FIP_DBG(fip, "Missing critical descriptors "
1270	"in FIP ELS\n");
1271	goto drop;
1272	}
1273
1274	/*
1275	* Convert skb into an fc_frame containing only the ELS.
1276	*/
1277	skb_pull(skb, len: (u8 *)fh - skb->data);
1278	skb_trim(skb, len: els_len);
1279	fp = (struct fc_frame *)skb;
1280	fc_frame_init(fp);
1281	fr_sof(fp) = FC_SOF_I3;
1282	fr_eof(fp) = FC_EOF_T;
1283	fr_dev(fp) = lport;
1284	fr_encaps(fp) = els_dtype;
1285
1286	this_cpu_inc(lport->stats->RxFrames);
1287	this_cpu_add(lport->stats->RxWords, skb->len / FIP_BPW);
1288
1289	fc_exch_recv(lport, fp);
1290	return;
1291
1292	len_err:
1293	LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
1294	desc->fip_dtype, dlen);
1295	drop:
1296	kfree_skb(skb);
1297	}
1298
1299	/**
1300	* fcoe_ctlr_recv_clr_vlink() - Handle an incoming link reset frame
1301	* @fip: The FCoE controller that received the frame
1302	* @skb: The received FIP packet
1303	*
1304	* There may be multiple VN_Port descriptors.
1305	* The overall length has already been checked.
1306	*/
1307	static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,
1308	struct sk_buff *skb)
1309	{
1310	struct fip_desc *desc;
1311	struct fip_mac_desc *mp;
1312	struct fip_wwn_desc *wp;
1313	struct fip_vn_desc *vp;
1314	size_t rlen;
1315	size_t dlen;
1316	struct fcoe_fcf *fcf = fip->sel_fcf;
1317	struct fc_lport *lport = fip->lp;
1318	struct fc_lport *vn_port = NULL;
1319	u32 desc_mask;
1320	int num_vlink_desc;
1321	int reset_phys_port = 0;
1322	struct fip_vn_desc **vlink_desc_arr = NULL;
1323	struct fip_header *fh = (struct fip_header *)skb->data;
1324	struct ethhdr *eh = eth_hdr(skb);
1325
1326	LIBFCOE_FIP_DBG(fip, "Clear Virtual Link received\n");
1327
1328	if (!fcf) {
1329	/*
1330	* We are yet to select best FCF, but we got CVL in the
1331	* meantime. reset the ctlr and let it rediscover the FCF
1332	*/
1333	LIBFCOE_FIP_DBG(fip, "Resetting fcoe_ctlr as FCF has not been "
1334	"selected yet\n");
1335	mutex_lock(&fip->ctlr_mutex);
1336	fcoe_ctlr_reset(fip);
1337	mutex_unlock(lock: &fip->ctlr_mutex);
1338	return;
1339	}
1340
1341	/*
1342	* If we've selected an FCF check that the CVL is from there to avoid
1343	* processing CVLs from an unexpected source. If it is from an
1344	* unexpected source drop it on the floor.
1345	*/
1346	if (!ether_addr_equal(addr1: eh->h_source, addr2: fcf->fcf_mac)) {
1347	LIBFCOE_FIP_DBG(fip, "Dropping CVL due to source address "
1348	"mismatch with FCF src=%pM\n", eh->h_source);
1349	return;
1350	}
1351
1352	/*
1353	* If we haven't logged into the fabric but receive a CVL we should
1354	* reset everything and go back to solicitation.
1355	*/
1356	if (!lport->port_id) {
1357	LIBFCOE_FIP_DBG(fip, "lport not logged in, resoliciting\n");
1358	mutex_lock(&fip->ctlr_mutex);
1359	fcoe_ctlr_reset(fip);
1360	mutex_unlock(lock: &fip->ctlr_mutex);
1361	fc_lport_reset(fip->lp);
1362	fcoe_ctlr_solicit(fip, NULL);
1363	return;
1364	}
1365
1366	/*
1367	* mask of required descriptors. Validating each one clears its bit.
1368	*/
1369	desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME);
1370
1371	rlen = ntohs(fh->fip_dl_len) * FIP_BPW;
1372	desc = (struct fip_desc *)(fh + 1);
1373
1374	/*
1375	* Actually need to subtract 'sizeof(*mp) - sizeof(*wp)' from 'rlen'
1376	* before determining max Vx_Port descriptor but a buggy FCF could have
1377	* omitted either or both MAC Address and Name Identifier descriptors
1378	*/
1379	num_vlink_desc = rlen / sizeof(*vp);
1380	if (num_vlink_desc)
1381	vlink_desc_arr = kmalloc_array(n: num_vlink_desc, size: sizeof(vp),
1382	GFP_ATOMIC);
1383	if (!vlink_desc_arr)
1384	return;
1385	num_vlink_desc = 0;
1386
1387	while (rlen >= sizeof(*desc)) {
1388	dlen = desc->fip_dlen * FIP_BPW;
1389	if (dlen > rlen)
1390	goto err;
1391	/* Drop CVL if there are duplicate critical descriptors */
1392	if ((desc->fip_dtype < 32) &&
1393	(desc->fip_dtype != FIP_DT_VN_ID) &&
1394	!(desc_mask & 1U << desc->fip_dtype)) {
1395	LIBFCOE_FIP_DBG(fip, "Duplicate Critical "
1396	"Descriptors in FIP CVL\n");
1397	goto err;
1398	}
1399	switch (desc->fip_dtype) {
1400	case FIP_DT_MAC:
1401	mp = (struct fip_mac_desc *)desc;
1402	if (dlen < sizeof(*mp))
1403	goto err;
1404	if (!ether_addr_equal(addr1: mp->fd_mac, addr2: fcf->fcf_mac))
1405	goto err;
1406	desc_mask &= ~BIT(FIP_DT_MAC);
1407	break;
1408	case FIP_DT_NAME:
1409	wp = (struct fip_wwn_desc *)desc;
1410	if (dlen < sizeof(*wp))
1411	goto err;
1412	if (get_unaligned_be64(p: &wp->fd_wwn) != fcf->switch_name)
1413	goto err;
1414	desc_mask &= ~BIT(FIP_DT_NAME);
1415	break;
1416	case FIP_DT_VN_ID:
1417	vp = (struct fip_vn_desc *)desc;
1418	if (dlen < sizeof(*vp))
1419	goto err;
1420	vlink_desc_arr[num_vlink_desc++] = vp;
1421	vn_port = fc_vport_id_lookup(lport,
1422	port_id: ntoh24(p: vp->fd_fc_id));
1423	if (vn_port && (vn_port == lport)) {
1424	mutex_lock(&fip->ctlr_mutex);
1425	this_cpu_inc(lport->stats->VLinkFailureCount);
1426	fcoe_ctlr_reset(fip);
1427	mutex_unlock(lock: &fip->ctlr_mutex);
1428	}
1429	break;
1430	default:
1431	/* standard says ignore unknown descriptors >= 128 */
1432	if (desc->fip_dtype < FIP_DT_NON_CRITICAL)
1433	goto err;
1434	break;
1435	}
1436	desc = (struct fip_desc *)((char *)desc + dlen);
1437	rlen -= dlen;
1438	}
1439
1440	/*
1441	* reset only if all required descriptors were present and valid.
1442	*/
1443	if (desc_mask)
1444	LIBFCOE_FIP_DBG(fip, "missing descriptors mask %x\n",
1445	desc_mask);
1446	else if (!num_vlink_desc) {
1447	LIBFCOE_FIP_DBG(fip, "CVL: no Vx_Port descriptor found\n");
1448	/*
1449	* No Vx_Port description. Clear all NPIV ports,
1450	* followed by physical port
1451	*/
1452	mutex_lock(&fip->ctlr_mutex);
1453	this_cpu_inc(lport->stats->VLinkFailureCount);
1454	fcoe_ctlr_reset(fip);
1455	mutex_unlock(lock: &fip->ctlr_mutex);
1456
1457	mutex_lock(&lport->lp_mutex);
1458	list_for_each_entry(vn_port, &lport->vports, list)
1459	fc_lport_reset(vn_port);
1460	mutex_unlock(lock: &lport->lp_mutex);
1461
1462	fc_lport_reset(fip->lp);
1463	fcoe_ctlr_solicit(fip, NULL);
1464	} else {
1465	int i;
1466
1467	LIBFCOE_FIP_DBG(fip, "performing Clear Virtual Link\n");
1468	for (i = 0; i < num_vlink_desc; i++) {
1469	vp = vlink_desc_arr[i];
1470	vn_port = fc_vport_id_lookup(lport,
1471	port_id: ntoh24(p: vp->fd_fc_id));
1472	if (!vn_port)
1473	continue;
1474
1475	/*
1476	* 'port_id' is already validated, check MAC address and
1477	* wwpn
1478	*/
1479	if (!ether_addr_equal(addr1: fip->get_src_addr(vn_port),
1480	addr2: vp->fd_mac) ||
1481	get_unaligned_be64(p: &vp->fd_wwpn) !=
1482	vn_port->wwpn)
1483	continue;
1484
1485	if (vn_port == lport)
1486	/*
1487	* Physical port, defer processing till all
1488	* listed NPIV ports are cleared
1489	*/
1490	reset_phys_port = 1;
1491	else /* NPIV port */
1492	fc_lport_reset(vn_port);
1493	}
1494
1495	if (reset_phys_port) {
1496	fc_lport_reset(fip->lp);
1497	fcoe_ctlr_solicit(fip, NULL);
1498	}
1499	}
1500
1501	err:
1502	kfree(objp: vlink_desc_arr);
1503	}
1504
1505	/**
1506	* fcoe_ctlr_recv() - Receive a FIP packet
1507	* @fip: The FCoE controller that received the packet
1508	* @skb: The received FIP packet
1509	*
1510	* This may be called from either NET_RX_SOFTIRQ or IRQ.
1511	*/
1512	void fcoe_ctlr_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
1513	{
1514	skb = skb_share_check(skb, GFP_ATOMIC);
1515	if (!skb)
1516	return;
1517	skb_queue_tail(list: &fip->fip_recv_list, newsk: skb);
1518	schedule_work(work: &fip->recv_work);
1519	}
1520	EXPORT_SYMBOL(fcoe_ctlr_recv);
1521
1522	/**
1523	* fcoe_ctlr_recv_handler() - Receive a FIP frame
1524	* @fip: The FCoE controller that received the frame
1525	* @skb: The received FIP frame
1526	*
1527	* Returns non-zero if the frame is dropped.
1528	*/
1529	static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)
1530	{
1531	struct fip_header *fiph;
1532	struct ethhdr *eh;
1533	enum fip_state state;
1534	bool fip_vlan_resp = false;
1535	u16 op;
1536	u8 sub;
1537
1538	if (skb_linearize(skb))
1539	goto drop;
1540	if (skb->len < sizeof(*fiph))
1541	goto drop;
1542	eh = eth_hdr(skb);
1543	if (fip->mode == FIP_MODE_VN2VN) {
1544	if (!ether_addr_equal(addr1: eh->h_dest, addr2: fip->ctl_src_addr) &&
1545	!ether_addr_equal(addr1: eh->h_dest, addr2: fcoe_all_vn2vn) &&
1546	!ether_addr_equal(addr1: eh->h_dest, addr2: fcoe_all_p2p))
1547	goto drop;
1548	} else if (!ether_addr_equal(addr1: eh->h_dest, addr2: fip->ctl_src_addr) &&
1549	!ether_addr_equal(addr1: eh->h_dest, addr2: fcoe_all_enode))
1550	goto drop;
1551	fiph = (struct fip_header *)skb->data;
1552	op = ntohs(fiph->fip_op);
1553	sub = fiph->fip_subcode;
1554
1555	if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER)
1556	goto drop;
1557	if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len)
1558	goto drop;
1559
1560	mutex_lock(&fip->ctlr_mutex);
1561	state = fip->state;
1562	if (state == FIP_ST_AUTO) {
1563	fip->map_dest = 0;
1564	fcoe_ctlr_set_state(fip, state: FIP_ST_ENABLED);
1565	state = FIP_ST_ENABLED;
1566	LIBFCOE_FIP_DBG(fip, "Using FIP mode\n");
1567	}
1568	fip_vlan_resp = fip->fip_resp;
1569	mutex_unlock(lock: &fip->ctlr_mutex);
1570
1571	if (fip->mode == FIP_MODE_VN2VN && op == FIP_OP_VN2VN)
1572	return fcoe_ctlr_vn_recv(fip, skb);
1573
1574	if (fip_vlan_resp && op == FIP_OP_VLAN) {
1575	LIBFCOE_FIP_DBG(fip, "fip vlan discovery\n");
1576	return fcoe_ctlr_vlan_recv(fip, skb);
1577	}
1578
1579	if (state != FIP_ST_ENABLED && state != FIP_ST_VNMP_UP &&
1580	state != FIP_ST_VNMP_CLAIM)
1581	goto drop;
1582
1583	if (op == FIP_OP_LS) {
1584	fcoe_ctlr_recv_els(fip, skb); /* consumes skb */
1585	return 0;
1586	}
1587
1588	if (state != FIP_ST_ENABLED)
1589	goto drop;
1590
1591	if (op == FIP_OP_DISC && sub == FIP_SC_ADV)
1592	fcoe_ctlr_recv_adv(fip, skb);
1593	else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK)
1594	fcoe_ctlr_recv_clr_vlink(fip, skb);
1595	kfree_skb(skb);
1596	return 0;
1597	drop:
1598	kfree_skb(skb);
1599	return -1;
1600	}
1601
1602	/**
1603	* fcoe_ctlr_select() - Select the best FCF (if possible)
1604	* @fip: The FCoE controller
1605	*
1606	* Returns the selected FCF, or NULL if none are usable.
1607	*
1608	* If there are conflicting advertisements, no FCF can be chosen.
1609	*
1610	* If there is already a selected FCF, this will choose a better one or
1611	* an equivalent one that hasn't already been sent a FLOGI.
1612	*
1613	* Called with lock held.
1614	*/
1615	static struct fcoe_fcf *fcoe_ctlr_select(struct fcoe_ctlr *fip)
1616	{
1617	struct fcoe_fcf *fcf;
1618	struct fcoe_fcf *best = fip->sel_fcf;
1619
1620	list_for_each_entry(fcf, &fip->fcfs, list) {
1621	LIBFCOE_FIP_DBG(fip, "consider FCF fab %16.16llx "
1622	"VFID %d mac %pM map %x val %d "
1623	"sent %u pri %u\n",
1624	fcf->fabric_name, fcf->vfid, fcf->fcf_mac,
1625	fcf->fc_map, fcoe_ctlr_mtu_valid(fcf),
1626	fcf->flogi_sent, fcf->pri);
1627	if (!fcoe_ctlr_fcf_usable(fcf)) {
1628	LIBFCOE_FIP_DBG(fip, "FCF for fab %16.16llx "
1629	"map %x %svalid %savailable\n",
1630	fcf->fabric_name, fcf->fc_map,
1631	(fcf->flags & FIP_FL_SOL) ? "" : "in",
1632	(fcf->flags & FIP_FL_AVAIL) ?
1633	"" : "un");
1634	continue;
1635	}
1636	if (!best || fcf->pri < best->pri || best->flogi_sent)
1637	best = fcf;
1638	if (fcf->fabric_name != best->fabric_name ||
1639	fcf->vfid != best->vfid ||
1640	fcf->fc_map != best->fc_map) {
1641	LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "
1642	"or FC-MAP\n");
1643	return NULL;
1644	}
1645	}
1646	fip->sel_fcf = best;
1647	if (best) {
1648	LIBFCOE_FIP_DBG(fip, "using FCF mac %pM\n", best->fcf_mac);
1649	fip->port_ka_time = jiffies +
1650	msecs_to_jiffies(FIP_VN_KA_PERIOD);
1651	fip->ctlr_ka_time = jiffies + best->fka_period;
1652	if (time_before(fip->ctlr_ka_time, fip->timer.expires))
1653	mod_timer(timer: &fip->timer, expires: fip->ctlr_ka_time);
1654	}
1655	return best;
1656	}
1657
1658	/**
1659	* fcoe_ctlr_flogi_send_locked() - send FIP-encapsulated FLOGI to current FCF
1660	* @fip: The FCoE controller
1661	*
1662	* Returns non-zero error if it could not be sent.
1663	*
1664	* Called with ctlr_mutex and ctlr_lock held.
1665	* Caller must verify that fip->sel_fcf is not NULL.
1666	*/
1667	static int fcoe_ctlr_flogi_send_locked(struct fcoe_ctlr *fip)
1668	{
1669	struct sk_buff *skb;
1670	struct sk_buff *skb_orig;
1671	struct fc_frame_header *fh;
1672	int error;
1673
1674	skb_orig = fip->flogi_req;
1675	if (!skb_orig)
1676	return -EINVAL;
1677
1678	/*
1679	* Clone and send the FLOGI request. If clone fails, use original.
1680	*/
1681	skb = skb_clone(skb: skb_orig, GFP_ATOMIC);
1682	if (!skb) {
1683	skb = skb_orig;
1684	fip->flogi_req = NULL;
1685	}
1686	fh = (struct fc_frame_header *)skb->data;
1687	error = fcoe_ctlr_encaps(fip, lport: fip->lp, dtype: FIP_DT_FLOGI, skb,
1688	d_id: ntoh24(p: fh->fh_d_id));
1689	if (error) {
1690	kfree_skb(skb);
1691	return error;
1692	}
1693	fip->send(fip, skb);
1694	fip->sel_fcf->flogi_sent = 1;
1695	return 0;
1696	}
1697
1698	/**
1699	* fcoe_ctlr_flogi_retry() - resend FLOGI request to a new FCF if possible
1700	* @fip: The FCoE controller
1701	*
1702	* Returns non-zero error code if there's no FLOGI request to retry or
1703	* no alternate FCF available.
1704	*/
1705	static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *fip)
1706	{
1707	struct fcoe_fcf *fcf;
1708	int error;
1709
1710	mutex_lock(&fip->ctlr_mutex);
1711	spin_lock_bh(lock: &fip->ctlr_lock);
1712	LIBFCOE_FIP_DBG(fip, "re-sending FLOGI - reselect\n");
1713	fcf = fcoe_ctlr_select(fip);
1714	if (!fcf || fcf->flogi_sent) {
1715	kfree_skb(skb: fip->flogi_req);
1716	fip->flogi_req = NULL;
1717	error = -ENOENT;
1718	} else {
1719	fcoe_ctlr_solicit(fip, NULL);
1720	error = fcoe_ctlr_flogi_send_locked(fip);
1721	}
1722	spin_unlock_bh(lock: &fip->ctlr_lock);
1723	mutex_unlock(lock: &fip->ctlr_mutex);
1724	return error;
1725	}
1726
1727
1728	/**
1729	* fcoe_ctlr_flogi_send() - Handle sending of FIP FLOGI.
1730	* @fip: The FCoE controller that timed out
1731	*
1732	* Done here because fcoe_ctlr_els_send() can't get mutex.
1733	*
1734	* Called with ctlr_mutex held. The caller must not hold ctlr_lock.
1735	*/
1736	static void fcoe_ctlr_flogi_send(struct fcoe_ctlr *fip)
1737	{
1738	struct fcoe_fcf *fcf;
1739
1740	spin_lock_bh(lock: &fip->ctlr_lock);
1741	fcf = fip->sel_fcf;
1742	if (!fcf || !fip->flogi_req_send)
1743	goto unlock;
1744
1745	LIBFCOE_FIP_DBG(fip, "sending FLOGI\n");
1746
1747	/*
1748	* If this FLOGI is being sent due to a timeout retry
1749	* to the same FCF as before, select a different FCF if possible.
1750	*/
1751	if (fcf->flogi_sent) {
1752	LIBFCOE_FIP_DBG(fip, "sending FLOGI - reselect\n");
1753	fcf = fcoe_ctlr_select(fip);
1754	if (!fcf || fcf->flogi_sent) {
1755	LIBFCOE_FIP_DBG(fip, "sending FLOGI - clearing\n");
1756	list_for_each_entry(fcf, &fip->fcfs, list)
1757	fcf->flogi_sent = 0;
1758	fcf = fcoe_ctlr_select(fip);
1759	}
1760	}
1761	if (fcf) {
1762	fcoe_ctlr_flogi_send_locked(fip);
1763	fip->flogi_req_send = 0;
1764	} else /* XXX */
1765	LIBFCOE_FIP_DBG(fip, "No FCF selected - defer send\n");
1766	unlock:
1767	spin_unlock_bh(lock: &fip->ctlr_lock);
1768	}
1769
1770	/**
1771	* fcoe_ctlr_timeout() - FIP timeout handler
1772	* @t: Timer context use to obtain the controller reference
1773	*/
1774	static void fcoe_ctlr_timeout(struct timer_list *t)
1775	{
1776	struct fcoe_ctlr *fip = from_timer(fip, t, timer);
1777
1778	schedule_work(work: &fip->timer_work);
1779	}
1780
1781	/**
1782	* fcoe_ctlr_timer_work() - Worker thread function for timer work
1783	* @work: Handle to a FCoE controller
1784	*
1785	* Ages FCFs. Triggers FCF selection if possible.
1786	* Sends keep-alives and resets.
1787	*/
1788	static void fcoe_ctlr_timer_work(struct work_struct *work)
1789	{
1790	struct fcoe_ctlr *fip;
1791	struct fc_lport *vport;
1792	u8 *mac;
1793	u8 reset = 0;
1794	u8 send_ctlr_ka = 0;
1795	u8 send_port_ka = 0;
1796	struct fcoe_fcf *sel;
1797	struct fcoe_fcf *fcf;
1798	unsigned long next_timer;
1799
1800	fip = container_of(work, struct fcoe_ctlr, timer_work);
1801	if (fip->mode == FIP_MODE_VN2VN)
1802	return fcoe_ctlr_vn_timeout(fip);
1803	mutex_lock(&fip->ctlr_mutex);
1804	if (fip->state == FIP_ST_DISABLED) {
1805	mutex_unlock(lock: &fip->ctlr_mutex);
1806	return;
1807	}
1808
1809	fcf = fip->sel_fcf;
1810	next_timer = fcoe_ctlr_age_fcfs(fip);
1811
1812	sel = fip->sel_fcf;
1813	if (!sel && fip->sel_time) {
1814	if (time_after_eq(jiffies, fip->sel_time)) {
1815	sel = fcoe_ctlr_select(fip);
1816	fip->sel_time = 0;
1817	} else if (time_after(next_timer, fip->sel_time))
1818	next_timer = fip->sel_time;
1819	}
1820
1821	if (sel && fip->flogi_req_send)
1822	fcoe_ctlr_flogi_send(fip);
1823	else if (!sel && fcf)
1824	reset = 1;
1825
1826	if (sel && !sel->fd_flags) {
1827	if (time_after_eq(jiffies, fip->ctlr_ka_time)) {
1828	fip->ctlr_ka_time = jiffies + sel->fka_period;
1829	send_ctlr_ka = 1;
1830	}
1831	if (time_after(next_timer, fip->ctlr_ka_time))
1832	next_timer = fip->ctlr_ka_time;
1833
1834	if (time_after_eq(jiffies, fip->port_ka_time)) {
1835	fip->port_ka_time = jiffies +
1836	msecs_to_jiffies(FIP_VN_KA_PERIOD);
1837	send_port_ka = 1;
1838	}
1839	if (time_after(next_timer, fip->port_ka_time))
1840	next_timer = fip->port_ka_time;
1841	}
1842	if (!list_empty(head: &fip->fcfs))
1843	mod_timer(timer: &fip->timer, expires: next_timer);
1844	mutex_unlock(lock: &fip->ctlr_mutex);
1845
1846	if (reset) {
1847	fc_lport_reset(fip->lp);
1848	/* restart things with a solicitation */
1849	fcoe_ctlr_solicit(fip, NULL);
1850	}
1851
1852	if (send_ctlr_ka)
1853	fcoe_ctlr_send_keep_alive(fip, NULL, ports: 0, sa: fip->ctl_src_addr);
1854
1855	if (send_port_ka) {
1856	mutex_lock(&fip->lp->lp_mutex);
1857	mac = fip->get_src_addr(fip->lp);
1858	fcoe_ctlr_send_keep_alive(fip, lport: fip->lp, ports: 1, sa: mac);
1859	list_for_each_entry(vport, &fip->lp->vports, list) {
1860	mac = fip->get_src_addr(vport);
1861	fcoe_ctlr_send_keep_alive(fip, lport: vport, ports: 1, sa: mac);
1862	}
1863	mutex_unlock(lock: &fip->lp->lp_mutex);
1864	}
1865	}
1866
1867	/**
1868	* fcoe_ctlr_recv_work() - Worker thread function for receiving FIP frames
1869	* @recv_work: Handle to a FCoE controller
1870	*/
1871	static void fcoe_ctlr_recv_work(struct work_struct *recv_work)
1872	{
1873	struct fcoe_ctlr *fip;
1874	struct sk_buff *skb;
1875
1876	fip = container_of(recv_work, struct fcoe_ctlr, recv_work);
1877	while ((skb = skb_dequeue(list: &fip->fip_recv_list)))
1878	fcoe_ctlr_recv_handler(fip, skb);
1879	}
1880
1881	/**
1882	* fcoe_ctlr_recv_flogi() - Snoop pre-FIP receipt of FLOGI response
1883	* @fip: The FCoE controller
1884	* @lport: The local port
1885	* @fp: The FC frame to snoop
1886	*
1887	* Snoop potential response to FLOGI or even incoming FLOGI.
1888	*
1889	* The caller has checked that we are waiting for login as indicated
1890	* by fip->flogi_oxid != FC_XID_UNKNOWN.
1891	*
1892	* The caller is responsible for freeing the frame.
1893	* Fill in the granted_mac address.
1894	*
1895	* Return non-zero if the frame should not be delivered to libfc.
1896	*/
1897	int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_lport *lport,
1898	struct fc_frame *fp)
1899	{
1900	struct fc_frame_header *fh;
1901	u8 op;
1902	u8 *sa;
1903
1904	sa = eth_hdr(skb: &fp->skb)->h_source;
1905	fh = fc_frame_header_get(fp);
1906	if (fh->fh_type != FC_TYPE_ELS)
1907	return 0;
1908
1909	op = fc_frame_payload_op(fp);
1910	if (op == ELS_LS_ACC && fh->fh_r_ctl == FC_RCTL_ELS_REP &&
1911	fip->flogi_oxid == ntohs(fh->fh_ox_id)) {
1912
1913	mutex_lock(&fip->ctlr_mutex);
1914	if (fip->state != FIP_ST_AUTO && fip->state != FIP_ST_NON_FIP) {
1915	mutex_unlock(lock: &fip->ctlr_mutex);
1916	return -EINVAL;
1917	}
1918	fcoe_ctlr_set_state(fip, state: FIP_ST_NON_FIP);
1919	LIBFCOE_FIP_DBG(fip,
1920	"received FLOGI LS_ACC using non-FIP mode\n");
1921
1922	/*
1923	* FLOGI accepted.
1924	* If the src mac addr is FC_OUI-based, then we mark the
1925	* address_mode flag to use FC_OUI-based Ethernet DA.
1926	* Otherwise we use the FCoE gateway addr
1927	*/
1928	if (ether_addr_equal(addr1: sa, addr2: (u8[6])FC_FCOE_FLOGI_MAC)) {
1929	fcoe_ctlr_map_dest(fip);
1930	} else {
1931	memcpy(fip->dest_addr, sa, ETH_ALEN);
1932	fip->map_dest = 0;
1933	}
1934	fip->flogi_oxid = FC_XID_UNKNOWN;
1935	mutex_unlock(lock: &fip->ctlr_mutex);
1936	fc_fcoe_set_mac(fr_cb(fp)->granted_mac, did: fh->fh_d_id);
1937	} else if (op == ELS_FLOGI && fh->fh_r_ctl == FC_RCTL_ELS_REQ && sa) {
1938	/*
1939	* Save source MAC for point-to-point responses.
1940	*/
1941	mutex_lock(&fip->ctlr_mutex);
1942	if (fip->state == FIP_ST_AUTO || fip->state == FIP_ST_NON_FIP) {
1943	memcpy(fip->dest_addr, sa, ETH_ALEN);
1944	fip->map_dest = 0;
1945	if (fip->state == FIP_ST_AUTO)
1946	LIBFCOE_FIP_DBG(fip, "received non-FIP FLOGI. "
1947	"Setting non-FIP mode\n");
1948	fcoe_ctlr_set_state(fip, state: FIP_ST_NON_FIP);
1949	}
1950	mutex_unlock(lock: &fip->ctlr_mutex);
1951	}
1952	return 0;
1953	}
1954	EXPORT_SYMBOL(fcoe_ctlr_recv_flogi);
1955
1956	/**
1957	* fcoe_wwn_from_mac() - Converts a 48-bit IEEE MAC address to a 64-bit FC WWN
1958	* @mac: The MAC address to convert
1959	* @scheme: The scheme to use when converting
1960	* @port: The port indicator for converting
1961	*
1962	* Returns: u64 fc world wide name
1963	*/
1964	u64 fcoe_wwn_from_mac(unsigned char mac[ETH_ALEN],
1965	unsigned int scheme, unsigned int port)
1966	{
1967	u64 wwn;
1968	u64 host_mac;
1969
1970	/* The MAC is in NO, so flip only the low 48 bits */
1971	host_mac = ((u64) mac[0] << 40) |
1972	((u64) mac[1] << 32) |
1973	((u64) mac[2] << 24) |
1974	((u64) mac[3] << 16) |
1975	((u64) mac[4] << 8) |
1976	(u64) mac[5];
1977
1978	WARN_ON(host_mac >= (1ULL << 48));
1979	wwn = host_mac | ((u64) scheme << 60);
1980	switch (scheme) {
1981	case 1:
1982	WARN_ON(port != 0);
1983	break;
1984	case 2:
1985	WARN_ON(port >= 0xfff);
1986	wwn |= (u64) port << 48;
1987	break;
1988	default:
1989	WARN_ON(1);
1990	break;
1991	}
1992
1993	return wwn;
1994	}
1995	EXPORT_SYMBOL_GPL(fcoe_wwn_from_mac);
1996
1997	/**
1998	* fcoe_ctlr_rport() - return the fcoe_rport for a given fc_rport_priv
1999	* @rdata: libfc remote port
2000	*/
2001	static inline struct fcoe_rport *fcoe_ctlr_rport(struct fc_rport_priv *rdata)
2002	{
2003	return container_of(rdata, struct fcoe_rport, rdata);
2004	}
2005
2006	/**
2007	* fcoe_ctlr_vn_send() - Send a FIP VN2VN Probe Request or Reply.
2008	* @fip: The FCoE controller
2009	* @sub: sub-opcode for probe request, reply, or advertisement.
2010	* @dest: The destination Ethernet MAC address
2011	* @min_len: minimum size of the Ethernet payload to be sent
2012	*/
2013	static void fcoe_ctlr_vn_send(struct fcoe_ctlr *fip,
2014	enum fip_vn2vn_subcode sub,
2015	const u8 *dest, size_t min_len)
2016	{
2017	struct sk_buff *skb;
2018	struct fip_vn2vn_probe_frame {
2019	struct ethhdr eth;
2020	struct fip_header fip;
2021	struct fip_mac_desc mac;
2022	struct fip_wwn_desc wwnn;
2023	struct fip_vn_desc vn;
2024	} __packed * frame;
2025	struct fip_fc4_feat *ff;
2026	struct fip_size_desc *size;
2027	u32 fcp_feat;
2028	size_t len;
2029	size_t dlen;
2030
2031	len = sizeof(*frame);
2032	dlen = 0;
2033	if (sub == FIP_SC_VN_CLAIM_NOTIFY || sub == FIP_SC_VN_CLAIM_REP) {
2034	dlen = sizeof(struct fip_fc4_feat) +
2035	sizeof(struct fip_size_desc);
2036	len += dlen;
2037	}
2038	dlen += sizeof(frame->mac) + sizeof(frame->wwnn) + sizeof(frame->vn);
2039	len = max(len, min_len + sizeof(struct ethhdr));
2040
2041	skb = dev_alloc_skb(length: len);
2042	if (!skb)
2043	return;
2044
2045	frame = (struct fip_vn2vn_probe_frame *)skb->data;
2046	memset(frame, 0, len);
2047	memcpy(frame->eth.h_dest, dest, ETH_ALEN);
2048
2049	if (sub == FIP_SC_VN_BEACON) {
2050	hton24(p: frame->eth.h_source, FIP_VN_FC_MAP);
2051	hton24(p: frame->eth.h_source + 3, v: fip->port_id);
2052	} else {
2053	memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
2054	}
2055	frame->eth.h_proto = htons(ETH_P_FIP);
2056
2057	frame->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
2058	frame->fip.fip_op = htons(FIP_OP_VN2VN);
2059	frame->fip.fip_subcode = sub;
2060	frame->fip.fip_dl_len = htons(dlen / FIP_BPW);
2061
2062	frame->mac.fd_desc.fip_dtype = FIP_DT_MAC;
2063	frame->mac.fd_desc.fip_dlen = sizeof(frame->mac) / FIP_BPW;
2064	memcpy(frame->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
2065
2066	frame->wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
2067	frame->wwnn.fd_desc.fip_dlen = sizeof(frame->wwnn) / FIP_BPW;
2068	put_unaligned_be64(val: fip->lp->wwnn, p: &frame->wwnn.fd_wwn);
2069
2070	frame->vn.fd_desc.fip_dtype = FIP_DT_VN_ID;
2071	frame->vn.fd_desc.fip_dlen = sizeof(frame->vn) / FIP_BPW;
2072	hton24(p: frame->vn.fd_mac, FIP_VN_FC_MAP);
2073	hton24(p: frame->vn.fd_mac + 3, v: fip->port_id);
2074	hton24(p: frame->vn.fd_fc_id, v: fip->port_id);
2075	put_unaligned_be64(val: fip->lp->wwpn, p: &frame->vn.fd_wwpn);
2076
2077	/*
2078	* For claims, add FC-4 features.
2079	* TBD: Add interface to get fc-4 types and features from libfc.
2080	*/
2081	if (sub == FIP_SC_VN_CLAIM_NOTIFY || sub == FIP_SC_VN_CLAIM_REP) {
2082	ff = (struct fip_fc4_feat *)(frame + 1);
2083	ff->fd_desc.fip_dtype = FIP_DT_FC4F;
2084	ff->fd_desc.fip_dlen = sizeof(*ff) / FIP_BPW;
2085	ff->fd_fts = fip->lp->fcts;
2086
2087	fcp_feat = 0;
2088	if (fip->lp->service_params & FCP_SPPF_INIT_FCN)
2089	fcp_feat |= FCP_FEAT_INIT;
2090	if (fip->lp->service_params & FCP_SPPF_TARG_FCN)
2091	fcp_feat |= FCP_FEAT_TARG;
2092	fcp_feat <<= (FC_TYPE_FCP * 4) % 32;
2093	ff->fd_ff.fd_feat[FC_TYPE_FCP * 4 / 32] = htonl(fcp_feat);
2094
2095	size = (struct fip_size_desc *)(ff + 1);
2096	size->fd_desc.fip_dtype = FIP_DT_FCOE_SIZE;
2097	size->fd_desc.fip_dlen = sizeof(*size) / FIP_BPW;
2098	size->fd_size = htons(fcoe_ctlr_fcoe_size(fip));
2099	}
2100
2101	skb_put(skb, len);
2102	skb->protocol = htons(ETH_P_FIP);
2103	skb->priority = fip->priority;
2104	skb_reset_mac_header(skb);
2105	skb_reset_network_header(skb);
2106
2107	fip->send(fip, skb);
2108	}
2109
2110	/**
2111	* fcoe_ctlr_vn_rport_callback - Event handler for rport events.
2112	* @lport: The lport which is receiving the event
2113	* @rdata: remote port private data
2114	* @event: The event that occurred
2115	*
2116	* Locking Note: The rport lock must not be held when calling this function.
2117	*/
2118	static void fcoe_ctlr_vn_rport_callback(struct fc_lport *lport,
2119	struct fc_rport_priv *rdata,
2120	enum fc_rport_event event)
2121	{
2122	struct fcoe_ctlr *fip = lport->disc.priv;
2123	struct fcoe_rport *frport = fcoe_ctlr_rport(rdata);
2124
2125	LIBFCOE_FIP_DBG(fip, "vn_rport_callback %x event %d\n",
2126	rdata->ids.port_id, event);
2127
2128	mutex_lock(&fip->ctlr_mutex);
2129	switch (event) {
2130	case RPORT_EV_READY:
2131	frport->login_count = 0;
2132	break;
2133	case RPORT_EV_LOGO:
2134	case RPORT_EV_FAILED:
2135	case RPORT_EV_STOP:
2136	frport->login_count++;
2137	if (frport->login_count > FCOE_CTLR_VN2VN_LOGIN_LIMIT) {
2138	LIBFCOE_FIP_DBG(fip,
2139	"rport FLOGI limited port_id %6.6x\n",
2140	rdata->ids.port_id);
2141	fc_rport_logoff(rdata);
2142	}
2143	break;
2144	default:
2145	break;
2146	}
2147	mutex_unlock(lock: &fip->ctlr_mutex);
2148	}
2149
2150	static struct fc_rport_operations fcoe_ctlr_vn_rport_ops = {
2151	.event_callback = fcoe_ctlr_vn_rport_callback,
2152	};
2153
2154	/**
2155	* fcoe_ctlr_disc_stop_locked() - stop discovery in VN2VN mode
2156	* @lport: The local port
2157	*
2158	* Called with ctlr_mutex held.
2159	*/
2160	static void fcoe_ctlr_disc_stop_locked(struct fc_lport *lport)
2161	{
2162	struct fc_rport_priv *rdata;
2163
2164	mutex_lock(&lport->disc.disc_mutex);
2165	list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {
2166	if (kref_get_unless_zero(kref: &rdata->kref)) {
2167	fc_rport_logoff(rdata);
2168	kref_put(kref: &rdata->kref, release: fc_rport_destroy);
2169	}
2170	}
2171	lport->disc.disc_callback = NULL;
2172	mutex_unlock(lock: &lport->disc.disc_mutex);
2173	}
2174
2175	/**
2176	* fcoe_ctlr_disc_stop() - stop discovery in VN2VN mode
2177	* @lport: The local port
2178	*
2179	* Called through the local port template for discovery.
2180	* Called without the ctlr_mutex held.
2181	*/
2182	static void fcoe_ctlr_disc_stop(struct fc_lport *lport)
2183	{
2184	struct fcoe_ctlr *fip = lport->disc.priv;
2185
2186	mutex_lock(&fip->ctlr_mutex);
2187	fcoe_ctlr_disc_stop_locked(lport);
2188	mutex_unlock(lock: &fip->ctlr_mutex);
2189	}
2190
2191	/**
2192	* fcoe_ctlr_disc_stop_final() - stop discovery for shutdown in VN2VN mode
2193	* @lport: The local port
2194	*
2195	* Called through the local port template for discovery.
2196	* Called without the ctlr_mutex held.
2197	*/
2198	static void fcoe_ctlr_disc_stop_final(struct fc_lport *lport)
2199	{
2200	fcoe_ctlr_disc_stop(lport);
2201	fc_rport_flush_queue();
2202	synchronize_rcu();
2203	}
2204
2205	/**
2206	* fcoe_ctlr_vn_restart() - VN2VN probe restart with new port_id
2207	* @fip: The FCoE controller
2208	*
2209	* Called with fcoe_ctlr lock held.
2210	*/
2211	static void fcoe_ctlr_vn_restart(struct fcoe_ctlr *fip)
2212	{
2213	unsigned long wait;
2214	u32 port_id;
2215
2216	fcoe_ctlr_disc_stop_locked(lport: fip->lp);
2217
2218	/*
2219	* Get proposed port ID.
2220	* If this is the first try after link up, use any previous port_id.
2221	* If there was none, use the low bits of the port_name.
2222	* On subsequent tries, get the next random one.
2223	* Don't use reserved IDs, use another non-zero value, just as random.
2224	*/
2225	port_id = fip->port_id;
2226	if (fip->probe_tries)
2227	port_id = prandom_u32_state(state: &fip->rnd_state) & 0xffff;
2228	else if (!port_id)
2229	port_id = fip->lp->wwpn & 0xffff;
2230	if (!port_id || port_id == 0xffff)
2231	port_id = 1;
2232	fip->port_id = port_id;
2233
2234	if (fip->probe_tries < FIP_VN_RLIM_COUNT) {
2235	fip->probe_tries++;
2236	wait = get_random_u32_below(FIP_VN_PROBE_WAIT);
2237	} else
2238	wait = FIP_VN_RLIM_INT;
2239	mod_timer(timer: &fip->timer, expires: jiffies + msecs_to_jiffies(m: wait));
2240	fcoe_ctlr_set_state(fip, state: FIP_ST_VNMP_START);
2241	}
2242
2243	/**
2244	* fcoe_ctlr_vn_start() - Start in VN2VN mode
2245	* @fip: The FCoE controller
2246	*
2247	* Called with fcoe_ctlr lock held.
2248	*/
2249	static void fcoe_ctlr_vn_start(struct fcoe_ctlr *fip)
2250	{
2251	fip->probe_tries = 0;
2252	prandom_seed_state(state: &fip->rnd_state, seed: fip->lp->wwpn);
2253	fcoe_ctlr_vn_restart(fip);
2254	}
2255
2256	/**
2257	* fcoe_ctlr_vn_parse - parse probe request or response
2258	* @fip: The FCoE controller
2259	* @skb: incoming packet
2260	* @frport: parsed FCoE rport from the probe request
2261	*
2262	* Returns non-zero error number on error.
2263	* Does not consume the packet.
2264	*/
2265	static int fcoe_ctlr_vn_parse(struct fcoe_ctlr *fip,
2266	struct sk_buff *skb,
2267	struct fcoe_rport *frport)
2268	{
2269	struct fip_header *fiph;
2270	struct fip_desc *desc = NULL;
2271	struct fip_mac_desc *macd = NULL;
2272	struct fip_wwn_desc *wwn = NULL;
2273	struct fip_vn_desc *vn = NULL;
2274	struct fip_size_desc *size = NULL;
2275	size_t rlen;
2276	size_t dlen;
2277	u32 desc_mask = 0;
2278	u32 dtype;
2279	u8 sub;
2280
2281	fiph = (struct fip_header *)skb->data;
2282	frport->flags = ntohs(fiph->fip_flags);
2283
2284	sub = fiph->fip_subcode;
2285	switch (sub) {
2286	case FIP_SC_VN_PROBE_REQ:
2287	case FIP_SC_VN_PROBE_REP:
2288	case FIP_SC_VN_BEACON:
2289	desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |
2290	BIT(FIP_DT_VN_ID);
2291	break;
2292	case FIP_SC_VN_CLAIM_NOTIFY:
2293	case FIP_SC_VN_CLAIM_REP:
2294	desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |
2295	BIT(FIP_DT_VN_ID) | BIT(FIP_DT_FC4F) |
2296	BIT(FIP_DT_FCOE_SIZE);
2297	break;
2298	default:
2299	LIBFCOE_FIP_DBG(fip, "vn_parse unknown subcode %u\n", sub);
2300	return -EINVAL;
2301	}
2302
2303	rlen = ntohs(fiph->fip_dl_len) * 4;
2304	if (rlen + sizeof(*fiph) > skb->len)
2305	return -EINVAL;
2306
2307	desc = (struct fip_desc *)(fiph + 1);
2308	while (rlen > 0) {
2309	dlen = desc->fip_dlen * FIP_BPW;
2310	if (dlen < sizeof(*desc) || dlen > rlen)
2311	return -EINVAL;
2312
2313	dtype = desc->fip_dtype;
2314	if (dtype < 32) {
2315	if (!(desc_mask & BIT(dtype))) {
2316	LIBFCOE_FIP_DBG(fip,
2317	"unexpected or duplicated desc "
2318	"desc type %u in "
2319	"FIP VN2VN subtype %u\n",
2320	dtype, sub);
2321	return -EINVAL;
2322	}
2323	desc_mask &= ~BIT(dtype);
2324	}
2325
2326	switch (dtype) {
2327	case FIP_DT_MAC:
2328	if (dlen != sizeof(struct fip_mac_desc))
2329	goto len_err;
2330	macd = (struct fip_mac_desc *)desc;
2331	if (!is_valid_ether_addr(addr: macd->fd_mac)) {
2332	LIBFCOE_FIP_DBG(fip,
2333	"Invalid MAC addr %pM in FIP VN2VN\n",
2334	macd->fd_mac);
2335	return -EINVAL;
2336	}
2337	memcpy(frport->enode_mac, macd->fd_mac, ETH_ALEN);
2338	break;
2339	case FIP_DT_NAME:
2340	if (dlen != sizeof(struct fip_wwn_desc))
2341	goto len_err;
2342	wwn = (struct fip_wwn_desc *)desc;
2343	frport->rdata.ids.node_name =
2344	get_unaligned_be64(p: &wwn->fd_wwn);
2345	break;
2346	case FIP_DT_VN_ID:
2347	if (dlen != sizeof(struct fip_vn_desc))
2348	goto len_err;
2349	vn = (struct fip_vn_desc *)desc;
2350	memcpy(frport->vn_mac, vn->fd_mac, ETH_ALEN);
2351	frport->rdata.ids.port_id = ntoh24(p: vn->fd_fc_id);
2352	frport->rdata.ids.port_name =
2353	get_unaligned_be64(p: &vn->fd_wwpn);
2354	break;
2355	case FIP_DT_FC4F:
2356	if (dlen != sizeof(struct fip_fc4_feat))
2357	goto len_err;
2358	break;
2359	case FIP_DT_FCOE_SIZE:
2360	if (dlen != sizeof(struct fip_size_desc))
2361	goto len_err;
2362	size = (struct fip_size_desc *)desc;
2363	frport->fcoe_len = ntohs(size->fd_size);
2364	break;
2365	default:
2366	LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
2367	"in FIP probe\n", dtype);
2368	/* standard says ignore unknown descriptors >= 128 */
2369	if (dtype < FIP_DT_NON_CRITICAL)
2370	return -EINVAL;
2371	break;
2372	}
2373	desc = (struct fip_desc *)((char *)desc + dlen);
2374	rlen -= dlen;
2375	}
2376	return 0;
2377
2378	len_err:
2379	LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
2380	dtype, dlen);
2381	return -EINVAL;
2382	}
2383
2384	/**
2385	* fcoe_ctlr_vn_send_claim() - send multicast FIP VN2VN Claim Notification.
2386	* @fip: The FCoE controller
2387	*
2388	* Called with ctlr_mutex held.
2389	*/
2390	static void fcoe_ctlr_vn_send_claim(struct fcoe_ctlr *fip)
2391	{
2392	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_CLAIM_NOTIFY, dest: fcoe_all_vn2vn, min_len: 0);
2393	fip->sol_time = jiffies;
2394	}
2395
2396	/**
2397	* fcoe_ctlr_vn_probe_req() - handle incoming VN2VN probe request.
2398	* @fip: The FCoE controller
2399	* @frport: parsed FCoE rport from the probe request
2400	*
2401	* Called with ctlr_mutex held.
2402	*/
2403	static void fcoe_ctlr_vn_probe_req(struct fcoe_ctlr *fip,
2404	struct fcoe_rport *frport)
2405	{
2406	if (frport->rdata.ids.port_id != fip->port_id)
2407	return;
2408
2409	switch (fip->state) {
2410	case FIP_ST_VNMP_CLAIM:
2411	case FIP_ST_VNMP_UP:
2412	LIBFCOE_FIP_DBG(fip, "vn_probe_req: send reply, state %x\n",
2413	fip->state);
2414	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_PROBE_REP,
2415	dest: frport->enode_mac, min_len: 0);
2416	break;
2417	case FIP_ST_VNMP_PROBE1:
2418	case FIP_ST_VNMP_PROBE2:
2419	/*
2420	* Decide whether to reply to the Probe.
2421	* Our selected address is never a "recorded" one, so
2422	* only reply if our WWPN is greater and the
2423	* Probe's REC bit is not set.
2424	* If we don't reply, we will change our address.
2425	*/
2426	if (fip->lp->wwpn > frport->rdata.ids.port_name &&
2427	!(frport->flags & FIP_FL_REC_OR_P2P)) {
2428	LIBFCOE_FIP_DBG(fip, "vn_probe_req: "
2429	"port_id collision\n");
2430	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_PROBE_REP,
2431	dest: frport->enode_mac, min_len: 0);
2432	break;
2433	}
2434	fallthrough;
2435	case FIP_ST_VNMP_START:
2436	LIBFCOE_FIP_DBG(fip, "vn_probe_req: "
2437	"restart VN2VN negotiation\n");
2438	fcoe_ctlr_vn_restart(fip);
2439	break;
2440	default:
2441	LIBFCOE_FIP_DBG(fip, "vn_probe_req: ignore state %x\n",
2442	fip->state);
2443	break;
2444	}
2445	}
2446
2447	/**
2448	* fcoe_ctlr_vn_probe_reply() - handle incoming VN2VN probe reply.
2449	* @fip: The FCoE controller
2450	* @frport: parsed FCoE rport from the probe request
2451	*
2452	* Called with ctlr_mutex held.
2453	*/
2454	static void fcoe_ctlr_vn_probe_reply(struct fcoe_ctlr *fip,
2455	struct fcoe_rport *frport)
2456	{
2457	if (frport->rdata.ids.port_id != fip->port_id)
2458	return;
2459	switch (fip->state) {
2460	case FIP_ST_VNMP_START:
2461	case FIP_ST_VNMP_PROBE1:
2462	case FIP_ST_VNMP_PROBE2:
2463	case FIP_ST_VNMP_CLAIM:
2464	LIBFCOE_FIP_DBG(fip, "vn_probe_reply: restart state %x\n",
2465	fip->state);
2466	fcoe_ctlr_vn_restart(fip);
2467	break;
2468	case FIP_ST_VNMP_UP:
2469	LIBFCOE_FIP_DBG(fip, "vn_probe_reply: send claim notify\n");
2470	fcoe_ctlr_vn_send_claim(fip);
2471	break;
2472	default:
2473	break;
2474	}
2475	}
2476
2477	/**
2478	* fcoe_ctlr_vn_add() - Add a VN2VN entry to the list, based on a claim reply.
2479	* @fip: The FCoE controller
2480	* @new: newly-parsed FCoE rport as a template for new rdata
2481	*
2482	* Called with ctlr_mutex held.
2483	*/
2484	static void fcoe_ctlr_vn_add(struct fcoe_ctlr *fip, struct fcoe_rport *new)
2485	{
2486	struct fc_lport *lport = fip->lp;
2487	struct fc_rport_priv *rdata;
2488	struct fc_rport_identifiers *ids;
2489	struct fcoe_rport *frport;
2490	u32 port_id;
2491
2492	port_id = new->rdata.ids.port_id;
2493	if (port_id == fip->port_id)
2494	return;
2495
2496	mutex_lock(&lport->disc.disc_mutex);
2497	rdata = fc_rport_create(lport, port_id);
2498	if (!rdata) {
2499	mutex_unlock(lock: &lport->disc.disc_mutex);
2500	return;
2501	}
2502	mutex_lock(&rdata->rp_mutex);
2503	mutex_unlock(lock: &lport->disc.disc_mutex);
2504
2505	rdata->ops = &fcoe_ctlr_vn_rport_ops;
2506	rdata->disc_id = lport->disc.disc_id;
2507
2508	ids = &rdata->ids;
2509	if ((ids->port_name != -1 &&
2510	ids->port_name != new->rdata.ids.port_name) ||
2511	(ids->node_name != -1 &&
2512	ids->node_name != new->rdata.ids.node_name)) {
2513	mutex_unlock(lock: &rdata->rp_mutex);
2514	LIBFCOE_FIP_DBG(fip, "vn_add rport logoff %6.6x\n", port_id);
2515	fc_rport_logoff(rdata);
2516	mutex_lock(&rdata->rp_mutex);
2517	}
2518	ids->port_name = new->rdata.ids.port_name;
2519	ids->node_name = new->rdata.ids.node_name;
2520	mutex_unlock(lock: &rdata->rp_mutex);
2521
2522	frport = fcoe_ctlr_rport(rdata);
2523	LIBFCOE_FIP_DBG(fip, "vn_add rport %6.6x %s state %d\n",
2524	port_id, frport->fcoe_len ? "old" : "new",
2525	rdata->rp_state);
2526	frport->fcoe_len = new->fcoe_len;
2527	frport->flags = new->flags;
2528	frport->login_count = new->login_count;
2529	memcpy(frport->enode_mac, new->enode_mac, ETH_ALEN);
2530	memcpy(frport->vn_mac, new->vn_mac, ETH_ALEN);
2531	frport->time = 0;
2532	}
2533
2534	/**
2535	* fcoe_ctlr_vn_lookup() - Find VN remote port's MAC address
2536	* @fip: The FCoE controller
2537	* @port_id: The port_id of the remote VN_node
2538	* @mac: buffer which will hold the VN_NODE destination MAC address, if found.
2539	*
2540	* Returns non-zero error if no remote port found.
2541	*/
2542	static int fcoe_ctlr_vn_lookup(struct fcoe_ctlr *fip, u32 port_id, u8 *mac)
2543	{
2544	struct fc_lport *lport = fip->lp;
2545	struct fc_rport_priv *rdata;
2546	struct fcoe_rport *frport;
2547	int ret = -1;
2548
2549	rdata = fc_rport_lookup(lport, port_id);
2550	if (rdata) {
2551	frport = fcoe_ctlr_rport(rdata);
2552	memcpy(mac, frport->enode_mac, ETH_ALEN);
2553	ret = 0;
2554	kref_put(kref: &rdata->kref, release: fc_rport_destroy);
2555	}
2556	return ret;
2557	}
2558
2559	/**
2560	* fcoe_ctlr_vn_claim_notify() - handle received FIP VN2VN Claim Notification
2561	* @fip: The FCoE controller
2562	* @new: newly-parsed FCoE rport as a template for new rdata
2563	*
2564	* Called with ctlr_mutex held.
2565	*/
2566	static void fcoe_ctlr_vn_claim_notify(struct fcoe_ctlr *fip,
2567	struct fcoe_rport *new)
2568	{
2569	if (new->flags & FIP_FL_REC_OR_P2P) {
2570	LIBFCOE_FIP_DBG(fip, "send probe req for P2P/REC\n");
2571	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_PROBE_REQ, dest: fcoe_all_vn2vn, min_len: 0);
2572	return;
2573	}
2574	switch (fip->state) {
2575	case FIP_ST_VNMP_START:
2576	case FIP_ST_VNMP_PROBE1:
2577	case FIP_ST_VNMP_PROBE2:
2578	if (new->rdata.ids.port_id == fip->port_id) {
2579	LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "
2580	"restart, state %d\n",
2581	fip->state);
2582	fcoe_ctlr_vn_restart(fip);
2583	}
2584	break;
2585	case FIP_ST_VNMP_CLAIM:
2586	case FIP_ST_VNMP_UP:
2587	if (new->rdata.ids.port_id == fip->port_id) {
2588	if (new->rdata.ids.port_name > fip->lp->wwpn) {
2589	LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "
2590	"restart, port_id collision\n");
2591	fcoe_ctlr_vn_restart(fip);
2592	break;
2593	}
2594	LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "
2595	"send claim notify\n");
2596	fcoe_ctlr_vn_send_claim(fip);
2597	break;
2598	}
2599	LIBFCOE_FIP_DBG(fip, "vn_claim_notify: send reply to %x\n",
2600	new->rdata.ids.port_id);
2601	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_CLAIM_REP, dest: new->enode_mac,
2602	min((u32)new->fcoe_len,
2603	fcoe_ctlr_fcoe_size(fip)));
2604	fcoe_ctlr_vn_add(fip, new);
2605	break;
2606	default:
2607	LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "
2608	"ignoring claim from %x\n",
2609	new->rdata.ids.port_id);
2610	break;
2611	}
2612	}
2613
2614	/**
2615	* fcoe_ctlr_vn_claim_resp() - handle received Claim Response
2616	* @fip: The FCoE controller that received the frame
2617	* @new: newly-parsed FCoE rport from the Claim Response
2618	*
2619	* Called with ctlr_mutex held.
2620	*/
2621	static void fcoe_ctlr_vn_claim_resp(struct fcoe_ctlr *fip,
2622	struct fcoe_rport *new)
2623	{
2624	LIBFCOE_FIP_DBG(fip, "claim resp from from rport %x - state %s\n",
2625	new->rdata.ids.port_id, fcoe_ctlr_state(fip->state));
2626	if (fip->state == FIP_ST_VNMP_UP || fip->state == FIP_ST_VNMP_CLAIM)
2627	fcoe_ctlr_vn_add(fip, new);
2628	}
2629
2630	/**
2631	* fcoe_ctlr_vn_beacon() - handle received beacon.
2632	* @fip: The FCoE controller that received the frame
2633	* @new: newly-parsed FCoE rport from the Beacon
2634	*
2635	* Called with ctlr_mutex held.
2636	*/
2637	static void fcoe_ctlr_vn_beacon(struct fcoe_ctlr *fip,
2638	struct fcoe_rport *new)
2639	{
2640	struct fc_lport *lport = fip->lp;
2641	struct fc_rport_priv *rdata;
2642	struct fcoe_rport *frport;
2643
2644	if (new->flags & FIP_FL_REC_OR_P2P) {
2645	LIBFCOE_FIP_DBG(fip, "p2p beacon while in vn2vn mode\n");
2646	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_PROBE_REQ, dest: fcoe_all_vn2vn, min_len: 0);
2647	return;
2648	}
2649	rdata = fc_rport_lookup(lport, port_id: new->rdata.ids.port_id);
2650	if (rdata) {
2651	if (rdata->ids.node_name == new->rdata.ids.node_name &&
2652	rdata->ids.port_name == new->rdata.ids.port_name) {
2653	frport = fcoe_ctlr_rport(rdata);
2654
2655	LIBFCOE_FIP_DBG(fip, "beacon from rport %x\n",
2656	rdata->ids.port_id);
2657	if (!frport->time && fip->state == FIP_ST_VNMP_UP) {
2658	LIBFCOE_FIP_DBG(fip, "beacon expired "
2659	"for rport %x\n",
2660	rdata->ids.port_id);
2661	fc_rport_login(rdata);
2662	}
2663	frport->time = jiffies;
2664	}
2665	kref_put(kref: &rdata->kref, release: fc_rport_destroy);
2666	return;
2667	}
2668	if (fip->state != FIP_ST_VNMP_UP)
2669	return;
2670
2671	/*
2672	* Beacon from a new neighbor.
2673	* Send a claim notify if one hasn't been sent recently.
2674	* Don't add the neighbor yet.
2675	*/
2676	LIBFCOE_FIP_DBG(fip, "beacon from new rport %x. sending claim notify\n",
2677	new->rdata.ids.port_id);
2678	if (time_after(jiffies,
2679	fip->sol_time + msecs_to_jiffies(FIP_VN_ANN_WAIT)))
2680	fcoe_ctlr_vn_send_claim(fip);
2681	}
2682
2683	/**
2684	* fcoe_ctlr_vn_age() - Check for VN_ports without recent beacons
2685	* @fip: The FCoE controller
2686	*
2687	* Called with ctlr_mutex held.
2688	* Called only in state FIP_ST_VNMP_UP.
2689	* Returns the soonest time for next age-out or a time far in the future.
2690	*/
2691	static unsigned long fcoe_ctlr_vn_age(struct fcoe_ctlr *fip)
2692	{
2693	struct fc_lport *lport = fip->lp;
2694	struct fc_rport_priv *rdata;
2695	struct fcoe_rport *frport;
2696	unsigned long next_time;
2697	unsigned long deadline;
2698
2699	next_time = jiffies + msecs_to_jiffies(FIP_VN_BEACON_INT * 10);
2700	mutex_lock(&lport->disc.disc_mutex);
2701	list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {
2702	if (!kref_get_unless_zero(kref: &rdata->kref))
2703	continue;
2704	frport = fcoe_ctlr_rport(rdata);
2705	if (!frport->time) {
2706	kref_put(kref: &rdata->kref, release: fc_rport_destroy);
2707	continue;
2708	}
2709	deadline = frport->time +
2710	msecs_to_jiffies(FIP_VN_BEACON_INT * 25 / 10);
2711	if (time_after_eq(jiffies, deadline)) {
2712	frport->time = 0;
2713	LIBFCOE_FIP_DBG(fip,
2714	"port %16.16llx fc_id %6.6x beacon expired\n",
2715	rdata->ids.port_name, rdata->ids.port_id);
2716	fc_rport_logoff(rdata);
2717	} else if (time_before(deadline, next_time))
2718	next_time = deadline;
2719	kref_put(kref: &rdata->kref, release: fc_rport_destroy);
2720	}
2721	mutex_unlock(lock: &lport->disc.disc_mutex);
2722	return next_time;
2723	}
2724
2725	/**
2726	* fcoe_ctlr_vn_recv() - Receive a FIP frame
2727	* @fip: The FCoE controller that received the frame
2728	* @skb: The received FIP frame
2729	*
2730	* Returns non-zero if the frame is dropped.
2731	* Always consumes the frame.
2732	*/
2733	static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
2734	{
2735	struct fip_header *fiph;
2736	enum fip_vn2vn_subcode sub;
2737	struct fcoe_rport frport = { };
2738	int rc, vlan_id = 0;
2739
2740	fiph = (struct fip_header *)skb->data;
2741	sub = fiph->fip_subcode;
2742
2743	if (fip->lp->vlan)
2744	vlan_id = skb_vlan_tag_get_id(skb);
2745
2746	if (vlan_id && vlan_id != fip->lp->vlan) {
2747	LIBFCOE_FIP_DBG(fip, "vn_recv drop frame sub %x vlan %d\n",
2748	sub, vlan_id);
2749	rc = -EAGAIN;
2750	goto drop;
2751	}
2752
2753	rc = fcoe_ctlr_vn_parse(fip, skb, frport: &frport);
2754	if (rc) {
2755	LIBFCOE_FIP_DBG(fip, "vn_recv vn_parse error %d\n", rc);
2756	goto drop;
2757	}
2758
2759	mutex_lock(&fip->ctlr_mutex);
2760	switch (sub) {
2761	case FIP_SC_VN_PROBE_REQ:
2762	fcoe_ctlr_vn_probe_req(fip, frport: &frport);
2763	break;
2764	case FIP_SC_VN_PROBE_REP:
2765	fcoe_ctlr_vn_probe_reply(fip, frport: &frport);
2766	break;
2767	case FIP_SC_VN_CLAIM_NOTIFY:
2768	fcoe_ctlr_vn_claim_notify(fip, new: &frport);
2769	break;
2770	case FIP_SC_VN_CLAIM_REP:
2771	fcoe_ctlr_vn_claim_resp(fip, new: &frport);
2772	break;
2773	case FIP_SC_VN_BEACON:
2774	fcoe_ctlr_vn_beacon(fip, new: &frport);
2775	break;
2776	default:
2777	LIBFCOE_FIP_DBG(fip, "vn_recv unknown subcode %d\n", sub);
2778	rc = -1;
2779	break;
2780	}
2781	mutex_unlock(lock: &fip->ctlr_mutex);
2782	drop:
2783	kfree_skb(skb);
2784	return rc;
2785	}
2786
2787	/**
2788	* fcoe_ctlr_vlan_parse - parse vlan discovery request or response
2789	* @fip: The FCoE controller
2790	* @skb: incoming packet
2791	* @frport: parsed FCoE rport from the probe request
2792	*
2793	* Returns non-zero error number on error.
2794	* Does not consume the packet.
2795	*/
2796	static int fcoe_ctlr_vlan_parse(struct fcoe_ctlr *fip,
2797	struct sk_buff *skb,
2798	struct fcoe_rport *frport)
2799	{
2800	struct fip_header *fiph;
2801	struct fip_desc *desc = NULL;
2802	struct fip_mac_desc *macd = NULL;
2803	struct fip_wwn_desc *wwn = NULL;
2804	size_t rlen;
2805	size_t dlen;
2806	u32 desc_mask = 0;
2807	u32 dtype;
2808	u8 sub;
2809
2810	fiph = (struct fip_header *)skb->data;
2811	frport->flags = ntohs(fiph->fip_flags);
2812
2813	sub = fiph->fip_subcode;
2814	switch (sub) {
2815	case FIP_SC_VL_REQ:
2816	desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME);
2817	break;
2818	default:
2819	LIBFCOE_FIP_DBG(fip, "vn_parse unknown subcode %u\n", sub);
2820	return -EINVAL;
2821	}
2822
2823	rlen = ntohs(fiph->fip_dl_len) * 4;
2824	if (rlen + sizeof(*fiph) > skb->len)
2825	return -EINVAL;
2826
2827	desc = (struct fip_desc *)(fiph + 1);
2828	while (rlen > 0) {
2829	dlen = desc->fip_dlen * FIP_BPW;
2830	if (dlen < sizeof(*desc) || dlen > rlen)
2831	return -EINVAL;
2832
2833	dtype = desc->fip_dtype;
2834	if (dtype < 32) {
2835	if (!(desc_mask & BIT(dtype))) {
2836	LIBFCOE_FIP_DBG(fip,
2837	"unexpected or duplicated desc "
2838	"desc type %u in "
2839	"FIP VN2VN subtype %u\n",
2840	dtype, sub);
2841	return -EINVAL;
2842	}
2843	desc_mask &= ~BIT(dtype);
2844	}
2845
2846	switch (dtype) {
2847	case FIP_DT_MAC:
2848	if (dlen != sizeof(struct fip_mac_desc))
2849	goto len_err;
2850	macd = (struct fip_mac_desc *)desc;
2851	if (!is_valid_ether_addr(addr: macd->fd_mac)) {
2852	LIBFCOE_FIP_DBG(fip,
2853	"Invalid MAC addr %pM in FIP VN2VN\n",
2854	macd->fd_mac);
2855	return -EINVAL;
2856	}
2857	memcpy(frport->enode_mac, macd->fd_mac, ETH_ALEN);
2858	break;
2859	case FIP_DT_NAME:
2860	if (dlen != sizeof(struct fip_wwn_desc))
2861	goto len_err;
2862	wwn = (struct fip_wwn_desc *)desc;
2863	frport->rdata.ids.node_name =
2864	get_unaligned_be64(p: &wwn->fd_wwn);
2865	break;
2866	default:
2867	LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "
2868	"in FIP probe\n", dtype);
2869	/* standard says ignore unknown descriptors >= 128 */
2870	if (dtype < FIP_DT_NON_CRITICAL)
2871	return -EINVAL;
2872	break;
2873	}
2874	desc = (struct fip_desc *)((char *)desc + dlen);
2875	rlen -= dlen;
2876	}
2877	return 0;
2878
2879	len_err:
2880	LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",
2881	dtype, dlen);
2882	return -EINVAL;
2883	}
2884
2885	/**
2886	* fcoe_ctlr_vlan_send() - Send a FIP VLAN Notification
2887	* @fip: The FCoE controller
2888	* @sub: sub-opcode for vlan notification or vn2vn vlan notification
2889	* @dest: The destination Ethernet MAC address
2890	*/
2891	static void fcoe_ctlr_vlan_send(struct fcoe_ctlr *fip,
2892	enum fip_vlan_subcode sub,
2893	const u8 *dest)
2894	{
2895	struct sk_buff *skb;
2896	struct fip_vlan_notify_frame {
2897	struct ethhdr eth;
2898	struct fip_header fip;
2899	struct fip_mac_desc mac;
2900	struct fip_vlan_desc vlan;
2901	} __packed * frame;
2902	size_t len;
2903	size_t dlen;
2904
2905	len = sizeof(*frame);
2906	dlen = sizeof(frame->mac) + sizeof(frame->vlan);
2907	len = max(len, sizeof(struct ethhdr));
2908
2909	skb = dev_alloc_skb(length: len);
2910	if (!skb)
2911	return;
2912
2913	LIBFCOE_FIP_DBG(fip, "fip %s vlan notification, vlan %d\n",
2914	fip->mode == FIP_MODE_VN2VN ? "vn2vn" : "fcf",
2915	fip->lp->vlan);
2916
2917	frame = (struct fip_vlan_notify_frame *)skb->data;
2918	memset(frame, 0, len);
2919	memcpy(frame->eth.h_dest, dest, ETH_ALEN);
2920
2921	memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);
2922	frame->eth.h_proto = htons(ETH_P_FIP);
2923
2924	frame->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
2925	frame->fip.fip_op = htons(FIP_OP_VLAN);
2926	frame->fip.fip_subcode = sub;
2927	frame->fip.fip_dl_len = htons(dlen / FIP_BPW);
2928
2929	frame->mac.fd_desc.fip_dtype = FIP_DT_MAC;
2930	frame->mac.fd_desc.fip_dlen = sizeof(frame->mac) / FIP_BPW;
2931	memcpy(frame->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);
2932
2933	frame->vlan.fd_desc.fip_dtype = FIP_DT_VLAN;
2934	frame->vlan.fd_desc.fip_dlen = sizeof(frame->vlan) / FIP_BPW;
2935	put_unaligned_be16(val: fip->lp->vlan, p: &frame->vlan.fd_vlan);
2936
2937	skb_put(skb, len);
2938	skb->protocol = htons(ETH_P_FIP);
2939	skb->priority = fip->priority;
2940	skb_reset_mac_header(skb);
2941	skb_reset_network_header(skb);
2942
2943	fip->send(fip, skb);
2944	}
2945
2946	/**
2947	* fcoe_ctlr_vlan_disc_reply() - send FIP VLAN Discovery Notification.
2948	* @fip: The FCoE controller
2949	* @frport: The newly-parsed FCoE rport from the Discovery Request
2950	*
2951	* Called with ctlr_mutex held.
2952	*/
2953	static void fcoe_ctlr_vlan_disc_reply(struct fcoe_ctlr *fip,
2954	struct fcoe_rport *frport)
2955	{
2956	enum fip_vlan_subcode sub = FIP_SC_VL_NOTE;
2957
2958	if (fip->mode == FIP_MODE_VN2VN)
2959	sub = FIP_SC_VL_VN2VN_NOTE;
2960
2961	fcoe_ctlr_vlan_send(fip, sub, dest: frport->enode_mac);
2962	}
2963
2964	/**
2965	* fcoe_ctlr_vlan_recv - vlan request receive handler for VN2VN mode.
2966	* @fip: The FCoE controller
2967	* @skb: The received FIP packet
2968	*/
2969	static int fcoe_ctlr_vlan_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)
2970	{
2971	struct fip_header *fiph;
2972	enum fip_vlan_subcode sub;
2973	struct fcoe_rport frport = { };
2974	int rc;
2975
2976	fiph = (struct fip_header *)skb->data;
2977	sub = fiph->fip_subcode;
2978	rc = fcoe_ctlr_vlan_parse(fip, skb, frport: &frport);
2979	if (rc) {
2980	LIBFCOE_FIP_DBG(fip, "vlan_recv vlan_parse error %d\n", rc);
2981	goto drop;
2982	}
2983	mutex_lock(&fip->ctlr_mutex);
2984	if (sub == FIP_SC_VL_REQ)
2985	fcoe_ctlr_vlan_disc_reply(fip, frport: &frport);
2986	mutex_unlock(lock: &fip->ctlr_mutex);
2987
2988	drop:
2989	kfree_skb(skb);
2990	return rc;
2991	}
2992
2993	/**
2994	* fcoe_ctlr_disc_recv - discovery receive handler for VN2VN mode.
2995	* @lport: The local port
2996	* @fp: The received frame
2997	*
2998	* This should never be called since we don't see RSCNs or other
2999	* fabric-generated ELSes.
3000	*/
3001	static void fcoe_ctlr_disc_recv(struct fc_lport *lport, struct fc_frame *fp)
3002	{
3003	struct fc_seq_els_data rjt_data;
3004
3005	rjt_data.reason = ELS_RJT_UNSUP;
3006	rjt_data.explan = ELS_EXPL_NONE;
3007	fc_seq_els_rsp_send(fp, ELS_LS_RJT, &rjt_data);
3008	fc_frame_free(fp);
3009	}
3010
3011	/*
3012	* fcoe_ctlr_disc_start - start discovery for VN2VN mode.
3013	*
3014	* This sets a flag indicating that remote ports should be created
3015	* and started for the peers we discover. We use the disc_callback
3016	* pointer as that flag. Peers already discovered are created here.
3017	*
3018	* The lport lock is held during this call. The callback must be done
3019	* later, without holding either the lport or discovery locks.
3020	* The fcoe_ctlr lock may also be held during this call.
3021	*/
3022	static void fcoe_ctlr_disc_start(void (*callback)(struct fc_lport *,
3023	enum fc_disc_event),
3024	struct fc_lport *lport)
3025	{
3026	struct fc_disc *disc = &lport->disc;
3027	struct fcoe_ctlr *fip = disc->priv;
3028
3029	mutex_lock(&disc->disc_mutex);
3030	disc->disc_callback = callback;
3031	disc->disc_id = (disc->disc_id + 2) | 1;
3032	disc->pending = 1;
3033	schedule_work(work: &fip->timer_work);
3034	mutex_unlock(lock: &disc->disc_mutex);
3035	}
3036
3037	/**
3038	* fcoe_ctlr_vn_disc() - report FIP VN_port discovery results after claim state.
3039	* @fip: The FCoE controller
3040	*
3041	* Starts the FLOGI and PLOGI login process to each discovered rport for which
3042	* we've received at least one beacon.
3043	* Performs the discovery complete callback.
3044	*/
3045	static void fcoe_ctlr_vn_disc(struct fcoe_ctlr *fip)
3046	{
3047	struct fc_lport *lport = fip->lp;
3048	struct fc_disc *disc = &lport->disc;
3049	struct fc_rport_priv *rdata;
3050	struct fcoe_rport *frport;
3051	void (*callback)(struct fc_lport *, enum fc_disc_event);
3052
3053	mutex_lock(&disc->disc_mutex);
3054	callback = disc->pending ? disc->disc_callback : NULL;
3055	disc->pending = 0;
3056	list_for_each_entry_rcu(rdata, &disc->rports, peers) {
3057	if (!kref_get_unless_zero(kref: &rdata->kref))
3058	continue;
3059	frport = fcoe_ctlr_rport(rdata);
3060	if (frport->time)
3061	fc_rport_login(rdata);
3062	kref_put(kref: &rdata->kref, release: fc_rport_destroy);
3063	}
3064	mutex_unlock(lock: &disc->disc_mutex);
3065	if (callback)
3066	callback(lport, DISC_EV_SUCCESS);
3067	}
3068
3069	/**
3070	* fcoe_ctlr_vn_timeout - timer work function for VN2VN mode.
3071	* @fip: The FCoE controller
3072	*/
3073	static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *fip)
3074	{
3075	unsigned long next_time;
3076	u8 mac[ETH_ALEN];
3077	u32 new_port_id = 0;
3078
3079	mutex_lock(&fip->ctlr_mutex);
3080	switch (fip->state) {
3081	case FIP_ST_VNMP_START:
3082	fcoe_ctlr_set_state(fip, state: FIP_ST_VNMP_PROBE1);
3083	LIBFCOE_FIP_DBG(fip, "vn_timeout: send 1st probe request\n");
3084	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_PROBE_REQ, dest: fcoe_all_vn2vn, min_len: 0);
3085	next_time = jiffies + msecs_to_jiffies(FIP_VN_PROBE_WAIT);
3086	break;
3087	case FIP_ST_VNMP_PROBE1:
3088	fcoe_ctlr_set_state(fip, state: FIP_ST_VNMP_PROBE2);
3089	LIBFCOE_FIP_DBG(fip, "vn_timeout: send 2nd probe request\n");
3090	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_PROBE_REQ, dest: fcoe_all_vn2vn, min_len: 0);
3091	next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);
3092	break;
3093	case FIP_ST_VNMP_PROBE2:
3094	fcoe_ctlr_set_state(fip, state: FIP_ST_VNMP_CLAIM);
3095	new_port_id = fip->port_id;
3096	hton24(p: mac, FIP_VN_FC_MAP);
3097	hton24(p: mac + 3, v: new_port_id);
3098	fcoe_ctlr_map_dest(fip);
3099	fip->update_mac(fip->lp, mac);
3100	LIBFCOE_FIP_DBG(fip, "vn_timeout: send claim notify\n");
3101	fcoe_ctlr_vn_send_claim(fip);
3102	next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);
3103	break;
3104	case FIP_ST_VNMP_CLAIM:
3105	/*
3106	* This may be invoked either by starting discovery so don't
3107	* go to the next state unless it's been long enough.
3108	*/
3109	next_time = fip->sol_time + msecs_to_jiffies(FIP_VN_ANN_WAIT);
3110	if (time_after_eq(jiffies, next_time)) {
3111	fcoe_ctlr_set_state(fip, state: FIP_ST_VNMP_UP);
3112	LIBFCOE_FIP_DBG(fip, "vn_timeout: send vn2vn beacon\n");
3113	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_BEACON,
3114	dest: fcoe_all_vn2vn, min_len: 0);
3115	next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);
3116	fip->port_ka_time = next_time;
3117	}
3118	fcoe_ctlr_vn_disc(fip);
3119	break;
3120	case FIP_ST_VNMP_UP:
3121	next_time = fcoe_ctlr_vn_age(fip);
3122	if (time_after_eq(jiffies, fip->port_ka_time)) {
3123	LIBFCOE_FIP_DBG(fip, "vn_timeout: send vn2vn beacon\n");
3124	fcoe_ctlr_vn_send(fip, sub: FIP_SC_VN_BEACON,
3125	dest: fcoe_all_vn2vn, min_len: 0);
3126	fip->port_ka_time = jiffies +
3127	msecs_to_jiffies(FIP_VN_BEACON_INT +
3128	get_random_u32_below(FIP_VN_BEACON_FUZZ));
3129	}
3130	if (time_before(fip->port_ka_time, next_time))
3131	next_time = fip->port_ka_time;
3132	break;
3133	case FIP_ST_LINK_WAIT:
3134	goto unlock;
3135	default:
3136	WARN(1, "unexpected state %d\n", fip->state);
3137	goto unlock;
3138	}
3139	mod_timer(timer: &fip->timer, expires: next_time);
3140	unlock:
3141	mutex_unlock(lock: &fip->ctlr_mutex);
3142
3143	/* If port ID is new, notify local port after dropping ctlr_mutex */
3144	if (new_port_id)
3145	fc_lport_set_local_id(fip->lp, port_id: new_port_id);
3146	}
3147
3148	/**
3149	* fcoe_ctlr_mode_set() - Set or reset the ctlr's mode
3150	* @lport: The local port to be (re)configured
3151	* @fip: The FCoE controller whose mode is changing
3152	* @fip_mode: The new fip mode
3153	*
3154	* Note that the we shouldn't be changing the libfc discovery settings
3155	* (fc_disc_config) while an lport is going through the libfc state
3156	* machine. The mode can only be changed when a fcoe_ctlr device is
3157	* disabled, so that should ensure that this routine is only called
3158	* when nothing is happening.
3159	*/
3160	static void fcoe_ctlr_mode_set(struct fc_lport *lport, struct fcoe_ctlr *fip,
3161	enum fip_mode fip_mode)
3162	{
3163	void *priv;
3164
3165	WARN_ON(lport->state != LPORT_ST_RESET &&
3166	lport->state != LPORT_ST_DISABLED);
3167
3168	if (fip_mode == FIP_MODE_VN2VN) {
3169	lport->rport_priv_size = sizeof(struct fcoe_rport);
3170	lport->point_to_multipoint = 1;
3171	lport->tt.disc_recv_req = fcoe_ctlr_disc_recv;
3172	lport->tt.disc_start = fcoe_ctlr_disc_start;
3173	lport->tt.disc_stop = fcoe_ctlr_disc_stop;
3174	lport->tt.disc_stop_final = fcoe_ctlr_disc_stop_final;
3175	priv = fip;
3176	} else {
3177	lport->rport_priv_size = 0;
3178	lport->point_to_multipoint = 0;
3179	lport->tt.disc_recv_req = NULL;
3180	lport->tt.disc_start = NULL;
3181	lport->tt.disc_stop = NULL;
3182	lport->tt.disc_stop_final = NULL;
3183	priv = lport;
3184	}
3185
3186	fc_disc_config(lport, priv);
3187	}
3188
3189	/**
3190	* fcoe_libfc_config() - Sets up libfc related properties for local port
3191	* @lport: The local port to configure libfc for
3192	* @fip: The FCoE controller in use by the local port
3193	* @tt: The libfc function template
3194	* @init_fcp: If non-zero, the FCP portion of libfc should be initialized
3195	*
3196	* Returns : 0 for success
3197	*/
3198	int fcoe_libfc_config(struct fc_lport *lport, struct fcoe_ctlr *fip,
3199	const struct libfc_function_template *tt, int init_fcp)
3200	{
3201	/* Set the function pointers set by the LLDD */
3202	memcpy(&lport->tt, tt, sizeof(*tt));
3203	if (init_fcp && fc_fcp_init(lport))
3204	return -ENOMEM;
3205	fc_exch_init(lport);
3206	fc_elsct_init(lport);
3207	fc_lport_init(lport);
3208	fc_disc_init(lport);
3209	fcoe_ctlr_mode_set(lport, fip, fip_mode: fip->mode);
3210	return 0;
3211	}
3212	EXPORT_SYMBOL_GPL(fcoe_libfc_config);
3213
3214	void fcoe_fcf_get_selected(struct fcoe_fcf_device *fcf_dev)
3215	{
3216	struct fcoe_ctlr_device *ctlr_dev = fcoe_fcf_dev_to_ctlr_dev(fcf_dev);
3217	struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr: ctlr_dev);
3218	struct fcoe_fcf *fcf;
3219
3220	mutex_lock(&fip->ctlr_mutex);
3221	mutex_lock(&ctlr_dev->lock);
3222
3223	fcf = fcoe_fcf_device_priv(fcf_dev);
3224	if (fcf)
3225	fcf_dev->selected = (fcf == fip->sel_fcf) ? 1 : 0;
3226	else
3227	fcf_dev->selected = 0;
3228
3229	mutex_unlock(lock: &ctlr_dev->lock);
3230	mutex_unlock(lock: &fip->ctlr_mutex);
3231	}
3232	EXPORT_SYMBOL(fcoe_fcf_get_selected);
3233
3234	void fcoe_ctlr_set_fip_mode(struct fcoe_ctlr_device *ctlr_dev)
3235	{
3236	struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr: ctlr_dev);
3237	struct fc_lport *lport = ctlr->lp;
3238
3239	mutex_lock(&ctlr->ctlr_mutex);
3240	switch (ctlr_dev->mode) {
3241	case FIP_CONN_TYPE_VN2VN:
3242	ctlr->mode = FIP_MODE_VN2VN;
3243	break;
3244	case FIP_CONN_TYPE_FABRIC:
3245	default:
3246	ctlr->mode = FIP_MODE_FABRIC;
3247	break;
3248	}
3249
3250	mutex_unlock(lock: &ctlr->ctlr_mutex);
3251
3252	fcoe_ctlr_mode_set(lport, fip: ctlr, fip_mode: ctlr->mode);
3253	}
3254	EXPORT_SYMBOL(fcoe_ctlr_set_fip_mode);
3255