[ipfire-2.x.git] / src / patches / suse-2.6.27.39 / patches.drivers / open-fcoe-rc1-update

Subject: Update open-FCoE with latest patches from Intel
From: John Fastabend <john.r.fastabend@intel.com>
Date: Fri Dec 5 16:35:38 2008 +0100:
References: bnc#438954

This updates the open-FCoE stack to version 1.0.5.

Signed-off-by: John Fastabend <john.r.fastabend@intel.com>
Acked-by: Hannes Reinecke <hare@suse.de>

diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
index de29ccd..77f8857 100644
--- a/drivers/scsi/fcoe/libfcoe.c
+++ b/drivers/scsi/fcoe/libfcoe.c
@@ -59,7 +59,7 @@ static int debug_fcoe;
 MODULE_AUTHOR("Open-FCoE.org");
 MODULE_DESCRIPTION("FCoE");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("1.0.4");
+MODULE_VERSION("1.0.5");
 
 /* fcoe host list */
 LIST_HEAD(fcoe_hostlist);
@@ -453,10 +453,9 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
 	/* adjust skb netowrk/transport offsets to match mac/fcoe/fc */
 	skb_push(skb, elen + hlen);
 	skb_reset_mac_header(skb);
-	skb_set_network_header(skb, elen);
-	skb_set_transport_header(skb, elen + hlen);
+	skb_reset_network_header(skb);
 	skb->mac_len = elen;
-	skb->protocol = htons(ETH_P_FCOE);
+	skb->protocol = htons(ETH_P_802_3);
 	skb->dev = fc->real_dev;
 
 	/* fill up mac and fcoe headers */
@@ -473,7 +472,7 @@ int fcoe_xmit(struct fc_lport *lp, struct fc_frame *fp)
 	else
 		memcpy(eh->h_source, fc->data_src_addr, ETH_ALEN);
 
-	hp = (struct fcoe_hdr *)skb_network_header(skb);
+	hp = (struct fcoe_hdr *)(eh + 1);
 	memset(hp, 0, sizeof(*hp));
 	if (FC_FCOE_VER)
 		FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
index aee2f9c..0cd8d0c 100644
--- a/drivers/scsi/libfc/fc_disc.c
+++ b/drivers/scsi/libfc/fc_disc.c
@@ -45,9 +45,6 @@ static int fc_disc_debug;
 			FC_DBG(fmt);		\
 	} while (0)
 
-static struct mutex		disc_list_lock;
-static struct list_head		disc_list;
-
 struct fc_disc {
 	unsigned char		retry_count;
 	unsigned char		delay;
@@ -66,7 +63,6 @@ struct fc_disc {
 	struct fc_gpn_ft_resp	partial_buf;	/* partial name buffer */
 	struct delayed_work	disc_work;
 
-	struct list_head	list;
 };
 
 static void fc_disc_gpn_ft_req(struct fc_disc *);
@@ -87,26 +83,23 @@ static void fc_disc_restart(struct fc_disc *);
 struct fc_rport *fc_disc_lookup_rport(const struct fc_lport *lport,
 				      u32 port_id)
 {
-	struct fc_disc *disc;
+	struct fc_disc *disc = lport->disc;
 	struct fc_rport *rport, *found = NULL;
 	struct fc_rport_libfc_priv *rdata;
 	int disc_found = 0;
 
-	mutex_lock(&disc_list_lock);
-	list_for_each_entry(disc, &disc_list, list) {
-		if (disc->lport == lport) {
-			list_for_each_entry(rdata, &disc->rports, peers) {
-				rport = PRIV_TO_RPORT(rdata);
-				if (rport->port_id == port_id) {
-					disc_found = 1;
-					found = rport;
-					get_device(&found->dev);
-					break;
-				}
-			}
+	if (!disc)
+		return NULL;
+
+	list_for_each_entry(rdata, &disc->rports, peers) {
+		rport = PRIV_TO_RPORT(rdata);
+		if (rport->port_id == port_id) {
+			disc_found = 1;
+			found = rport;
+			get_device(&found->dev);
+			break;
 		}
 	}
-	mutex_unlock(&disc_list_lock);
 
 	if (!disc_found) {
 		FC_DEBUG_DISC("The rport (%6x) for lport (%6x) "
@@ -127,19 +120,15 @@ static inline struct fc_disc *fc_disc_alloc(struct fc_lport *lport)
 	struct fc_disc *disc;
 
 	disc = kzalloc(sizeof(struct fc_disc), GFP_KERNEL);
-	INIT_LIST_HEAD(&disc->list);
 	INIT_DELAYED_WORK(&disc->disc_work, fc_disc_timeout);
 	mutex_init(&disc->disc_mutex);
 	INIT_LIST_HEAD(&disc->rports);
 
 	disc->lport = lport;
+	lport->disc = disc;
 	disc->delay = FC_DISC_DELAY;
 	disc->event = DISC_EV_NONE;
 
-	mutex_lock(&disc_list_lock);
-	list_add_tail(&disc->list, &disc_list);
-	mutex_unlock(&disc_list_lock);
-
 	return disc;
 }
 
@@ -182,23 +171,19 @@ static void fc_disc_rport_event(struct fc_lport *lport,
 				enum fc_lport_event event)
 {
 	struct fc_rport_libfc_priv *rdata = rport->dd_data;
-	struct fc_disc *disc;
+	struct fc_disc *disc = lport->disc;
 	int found = 0;
 
 	FC_DEBUG_DISC("Received a %d event for port (%6x)\n", event,
 		      rport->port_id);
 
 	if (event == RPORT_EV_CREATED) {
-		mutex_lock(&disc_list_lock);
-		list_for_each_entry(disc, &disc_list, list) {
-			if (disc->lport == lport) {
-				found = 1;
-				mutex_lock(&disc->disc_mutex);
-				list_add_tail(&rdata->peers, &disc->rports);
-				mutex_unlock(&disc->disc_mutex);
-			}
+		if (disc) {
+			found = 1;
+			mutex_lock(&disc->disc_mutex);
+			list_add_tail(&rdata->peers, &disc->rports);
+			mutex_unlock(&disc->disc_mutex);
 		}
-		mutex_unlock(&disc_list_lock);
 	}
 
 	if (!found)
@@ -323,19 +308,9 @@ static void fc_disc_recv_req(struct fc_seq *sp, struct fc_frame *fp,
 			     struct fc_lport *lport)
 {
 	u8 op;
-	struct fc_disc *disc;
-	int found = 0;
-
-	mutex_lock(&disc_list_lock);
-	list_for_each_entry(disc, &disc_list, list) {
-		if (disc->lport == lport) {
-			found = 1;
-			break;
-		}
-	}
-	mutex_unlock(&disc_list_lock);
+	struct fc_disc *disc = lport->disc;
 
-	if (!found) {
+	if (!disc) {
 		FC_DBG("Received a request for an lport not managed "
 		       "by the discovery engine\n");
 		return;
@@ -394,19 +369,9 @@ static void fc_disc_start(void (*disc_callback)(struct fc_lport *,
 {
 	struct fc_rport *rport;
 	struct fc_rport_identifiers ids;
-	struct fc_disc *disc;
-	int found = 0;
-
-	mutex_lock(&disc_list_lock);
-	list_for_each_entry(disc, &disc_list, list) {
-		if (disc->lport == lport) {
-			found = 1;
-			break;
-		}
-	}
-	mutex_unlock(&disc_list_lock);
+	struct fc_disc *disc = lport->disc;
 
-	if (!found) {
+	if (!disc) {
 		FC_DEBUG_DISC("No existing discovery job, "
 			      "creating one for lport (%6x)\n",
 			      fc_host_port_id(lport->host));
@@ -510,7 +475,7 @@ static int fc_disc_new_target(struct fc_disc *disc,
 				rport = fc_rport_rogue_create(&dp);
 			}
 			if (!rport)
-				error = ENOMEM;
+				error = -ENOMEM;
 		}
 		if (rport) {
 			rp = rport->dd_data;
@@ -577,18 +542,16 @@ static void fc_disc_error(struct fc_disc *disc, struct fc_frame *fp)
 		if (disc->retry_count < FC_DISC_RETRY_LIMIT) {
 			/* go ahead and retry */
 			if (!fp)
-				delay = msecs_to_jiffies(500);
+				delay = msecs_to_jiffies(FC_DISC_RETRY_DELAY);
 			else {
-				delay = jiffies +
-					msecs_to_jiffies(lport->e_d_tov);
+				delay = msecs_to_jiffies(lport->e_d_tov);
 
 				/* timeout faster first time */
 				if (!disc->retry_count)
 					delay /= 4;
 			}
 			disc->retry_count++;
-			schedule_delayed_work(&disc->disc_work,
-					      delay);
+			schedule_delayed_work(&disc->disc_work, delay);
 		} else {
 			/* exceeded retries */
 			disc->event = DISC_EV_FAILED;
@@ -868,16 +831,12 @@ out:
  */
 void fc_disc_stop(struct fc_lport *lport)
 {
-	struct fc_disc *disc, *next;
+	struct fc_disc *disc = lport->disc;
 
-	mutex_lock(&disc_list_lock);
-	list_for_each_entry_safe(disc, next, &disc_list, list) {
-		if (disc->lport == lport) {
-			cancel_delayed_work_sync(&disc->disc_work);
-			fc_disc_stop_rports(disc);
-		}
+	if (disc) {
+		cancel_delayed_work_sync(&disc->disc_work);
+		fc_disc_stop_rports(disc);
 	}
-	mutex_unlock(&disc_list_lock);
 }
 
 /**
@@ -889,18 +848,8 @@ void fc_disc_stop(struct fc_lport *lport)
  */
 void fc_disc_stop_final(struct fc_lport *lport)
 {
-	struct fc_disc *disc, *next;
 	fc_disc_stop(lport);
 	lport->tt.rport_flush_queue();
-
-	mutex_lock(&disc_list_lock);
-	list_for_each_entry_safe(disc, next, &disc_list, list) {
-		if (disc->lport == lport) {
-			list_del(&disc->list);
-			kfree(disc);
-		}
-	}
-	mutex_unlock(&disc_list_lock);
 }
 
 /**
@@ -909,8 +858,6 @@ void fc_disc_stop_final(struct fc_lport *lport)
  */
 int fc_disc_init(struct fc_lport *lport)
 {
-	INIT_LIST_HEAD(&disc_list);
-	mutex_init(&disc_list_lock);
 
 	if (!lport->tt.disc_start)
 		lport->tt.disc_start = fc_disc_start;
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index 04ced7f..2426501 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -42,6 +42,7 @@
 MODULE_AUTHOR("Open-FCoE.org");
 MODULE_DESCRIPTION("libfc");
 MODULE_LICENSE("GPL");
+MODULE_VERSION("1.0.5");
 
 static int fc_fcp_debug;
 
diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
index 083d57b..de16203 100644
--- a/drivers/scsi/libfc/fc_lport.c
+++ b/drivers/scsi/libfc/fc_lport.c
@@ -577,6 +577,8 @@ int fc_fabric_logoff(struct fc_lport *lport)
 {
 	lport->tt.disc_stop_final(lport);
 	mutex_lock(&lport->lp_mutex);
+	kfree(lport->disc);
+	lport->disc = NULL;
 	fc_lport_enter_logo(lport);
 	mutex_unlock(&lport->lp_mutex);
 	return 0;
diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h
index dac03e2..587be50 100644
--- a/include/scsi/libfc.h
+++ b/include/scsi/libfc.h
@@ -570,6 +570,8 @@ struct libfc_function_template {
 	void (*disc_stop_final) (struct fc_lport *);
 };
 
+struct fc_disc;
+
 struct fc_lport {
 	struct list_head list;
 
@@ -578,6 +580,7 @@ struct fc_lport {
 	struct fc_exch_mgr	*emp;
 	struct fc_rport		*dns_rp;
 	struct fc_rport		*ptp_rp;
+	struct fc_disc          *disc;
 	void			*scsi_priv;
 
 	/* Operational Information */
Commit	Line	Data
2cb7cef9 BS	1	Subject: Update open-FCoE with latest patches from Intel
	2	From: John Fastabend <john.r.fastabend@intel.com>
	3	Date: Fri Dec 5 16:35:38 2008 +0100:
	4	References: bnc#438954
	5
	6	This updates the open-FCoE stack to version 1.0.5.
	7
	8	Signed-off-by: John Fastabend <john.r.fastabend@intel.com>
	9	Acked-by: Hannes Reinecke <hare@suse.de>
	10
	11	diff --git a/drivers/scsi/fcoe/libfcoe.c b/drivers/scsi/fcoe/libfcoe.c
	12	index de29ccd..77f8857 100644
	13	--- a/drivers/scsi/fcoe/libfcoe.c
	14	+++ b/drivers/scsi/fcoe/libfcoe.c
	15	@@ -59,7 +59,7 @@ static int debug_fcoe;
	16	MODULE_AUTHOR("Open-FCoE.org");
	17	MODULE_DESCRIPTION("FCoE");
	18	MODULE_LICENSE("GPL");
	19	-MODULE_VERSION("1.0.4");
	20	+MODULE_VERSION("1.0.5");
	21
	22	/* fcoe host list */
	23	LIST_HEAD(fcoe_hostlist);
	24	@@ -453,10 +453,9 @@ int fcoe_xmit(struct fc_lport lp, struct fc_frame fp)
	25	/* adjust skb netowrk/transport offsets to match mac/fcoe/fc */
	26	skb_push(skb, elen + hlen);
	27	skb_reset_mac_header(skb);
	28	- skb_set_network_header(skb, elen);
	29	- skb_set_transport_header(skb, elen + hlen);
	30	+ skb_reset_network_header(skb);
	31	skb->mac_len = elen;
	32	- skb->protocol = htons(ETH_P_FCOE);
	33	+ skb->protocol = htons(ETH_P_802_3);
	34	skb->dev = fc->real_dev;
	35
	36	/* fill up mac and fcoe headers */
	37	@@ -473,7 +472,7 @@ int fcoe_xmit(struct fc_lport lp, struct fc_frame fp)
	38	else
	39	memcpy(eh->h_source, fc->data_src_addr, ETH_ALEN);
	40
	41	- hp = (struct fcoe_hdr *)skb_network_header(skb);
	42	+ hp = (struct fcoe_hdr *)(eh + 1);
	43	memset(hp, 0, sizeof(*hp));
	44	if (FC_FCOE_VER)
	45	FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
	46	diff --git a/drivers/scsi/libfc/fc_disc.c b/drivers/scsi/libfc/fc_disc.c
	47	index aee2f9c..0cd8d0c 100644
	48	--- a/drivers/scsi/libfc/fc_disc.c
	49	+++ b/drivers/scsi/libfc/fc_disc.c
	50	@@ -45,9 +45,6 @@ static int fc_disc_debug;
	51	FC_DBG(fmt); \
	52	} while (0)
	53
	54	-static struct mutex disc_list_lock;
	55	-static struct list_head disc_list;
	56	-
	57	struct fc_disc {
	58	unsigned char retry_count;
	59	unsigned char delay;
	60	@@ -66,7 +63,6 @@ struct fc_disc {
	61	struct fc_gpn_ft_resp partial_buf; /* partial name buffer */
	62	struct delayed_work disc_work;
	63
	64	- struct list_head list;
65	};
66
67	static void fc_disc_gpn_ft_req(struct fc_disc *);
68	@@ -87,26 +83,23 @@ static void fc_disc_restart(struct fc_disc *);
69	struct fc_rport fc_disc_lookup_rport(const struct fc_lport lport,
70	u32 port_id)
71	{
72	- struct fc_disc *disc;
73	+ struct fc_disc *disc = lport->disc;
74	struct fc_rport rport, found = NULL;
75	struct fc_rport_libfc_priv *rdata;
76	int disc_found = 0;
77
78	- mutex_lock(&disc_list_lock);
79	- list_for_each_entry(disc, &disc_list, list) {
80	- if (disc->lport == lport) {
81	- list_for_each_entry(rdata, &disc->rports, peers) {
82	- rport = PRIV_TO_RPORT(rdata);
83	- if (rport->port_id == port_id) {
84	- disc_found = 1;
85	- found = rport;
86	- get_device(&found->dev);
87	- break;
88	- }
89	- }
90	+ if (!disc)
91	+ return NULL;
92	+
93	+ list_for_each_entry(rdata, &disc->rports, peers) {
94	+ rport = PRIV_TO_RPORT(rdata);
95	+ if (rport->port_id == port_id) {
96	+ disc_found = 1;
97	+ found = rport;
98	+ get_device(&found->dev);
99	+ break;
100	}
101	}
102	- mutex_unlock(&disc_list_lock);
103
104	if (!disc_found) {
105	FC_DEBUG_DISC("The rport (%6x) for lport (%6x) "
106	@@ -127,19 +120,15 @@ static inline struct fc_disc fc_disc_alloc(struct fc_lport lport)
107	struct fc_disc *disc;
108
109	disc = kzalloc(sizeof(struct fc_disc), GFP_KERNEL);
110	- INIT_LIST_HEAD(&disc->list);
111	INIT_DELAYED_WORK(&disc->disc_work, fc_disc_timeout);
112	mutex_init(&disc->disc_mutex);
113	INIT_LIST_HEAD(&disc->rports);
114
115	disc->lport = lport;
116	+ lport->disc = disc;
117	disc->delay = FC_DISC_DELAY;
118	disc->event = DISC_EV_NONE;
119
120	- mutex_lock(&disc_list_lock);
121	- list_add_tail(&disc->list, &disc_list);
122	- mutex_unlock(&disc_list_lock);
123	-
124	return disc;
125	}
126
127	@@ -182,23 +171,19 @@ static void fc_disc_rport_event(struct fc_lport *lport,
128	enum fc_lport_event event)
129	{
130	struct fc_rport_libfc_priv *rdata = rport->dd_data;
131	- struct fc_disc *disc;
132	+ struct fc_disc *disc = lport->disc;
133	int found = 0;
134
135	FC_DEBUG_DISC("Received a %d event for port (%6x)\n", event,
136	rport->port_id);
137
138	if (event == RPORT_EV_CREATED) {
139	- mutex_lock(&disc_list_lock);
140	- list_for_each_entry(disc, &disc_list, list) {
141	- if (disc->lport == lport) {
142	- found = 1;
143	- mutex_lock(&disc->disc_mutex);
144	- list_add_tail(&rdata->peers, &disc->rports);
145	- mutex_unlock(&disc->disc_mutex);
146	- }
147	+ if (disc) {
148	+ found = 1;
149	+ mutex_lock(&disc->disc_mutex);
150	+ list_add_tail(&rdata->peers, &disc->rports);
151	+ mutex_unlock(&disc->disc_mutex);
152	}
153	- mutex_unlock(&disc_list_lock);
154	}
155
156	if (!found)
157	@@ -323,19 +308,9 @@ static void fc_disc_recv_req(struct fc_seq sp, struct fc_frame fp,
158	struct fc_lport *lport)
159	{
160	u8 op;
161	- struct fc_disc *disc;
162	- int found = 0;
163	-
164	- mutex_lock(&disc_list_lock);
165	- list_for_each_entry(disc, &disc_list, list) {
166	- if (disc->lport == lport) {
167	- found = 1;
168	- break;
169	- }
170	- }
171	- mutex_unlock(&disc_list_lock);
172	+ struct fc_disc *disc = lport->disc;
173
174	- if (!found) {
175	+ if (!disc) {
176	FC_DBG("Received a request for an lport not managed "
177	"by the discovery engine\n");
178	return;
179	@@ -394,19 +369,9 @@ static void fc_disc_start(void (disc_callback)(struct fc_lport ,
180	{
181	struct fc_rport *rport;
182	struct fc_rport_identifiers ids;
183	- struct fc_disc *disc;
184	- int found = 0;
185	-
186	- mutex_lock(&disc_list_lock);
187	- list_for_each_entry(disc, &disc_list, list) {
188	- if (disc->lport == lport) {
189	- found = 1;
190	- break;
191	- }
192	- }
193	- mutex_unlock(&disc_list_lock);
194	+ struct fc_disc *disc = lport->disc;
195
196	- if (!found) {
197	+ if (!disc) {
198	FC_DEBUG_DISC("No existing discovery job, "
199	"creating one for lport (%6x)\n",
200	fc_host_port_id(lport->host));
201	@@ -510,7 +475,7 @@ static int fc_disc_new_target(struct fc_disc *disc,
202	rport = fc_rport_rogue_create(&dp);
203	}
204	if (!rport)
205	- error = ENOMEM;
206	+ error = -ENOMEM;
207	}
208	if (rport) {
209	rp = rport->dd_data;
210	@@ -577,18 +542,16 @@ static void fc_disc_error(struct fc_disc disc, struct fc_frame fp)
211	if (disc->retry_count < FC_DISC_RETRY_LIMIT) {
212	/* go ahead and retry */
213	if (!fp)
214	- delay = msecs_to_jiffies(500);
215	+ delay = msecs_to_jiffies(FC_DISC_RETRY_DELAY);
216	else {
217	- delay = jiffies +
218	- msecs_to_jiffies(lport->e_d_tov);
219	+ delay = msecs_to_jiffies(lport->e_d_tov);
220
221	/* timeout faster first time */
222	if (!disc->retry_count)
223	delay /= 4;
224	}
225	disc->retry_count++;
226	- schedule_delayed_work(&disc->disc_work,
227	- delay);
228	+ schedule_delayed_work(&disc->disc_work, delay);
229	} else {
230	/* exceeded retries */
231	disc->event = DISC_EV_FAILED;
232	@@ -868,16 +831,12 @@ out:
233	*/
234	void fc_disc_stop(struct fc_lport *lport)
235	{
236	- struct fc_disc disc, next;
237	+ struct fc_disc *disc = lport->disc;
238
239	- mutex_lock(&disc_list_lock);
240	- list_for_each_entry_safe(disc, next, &disc_list, list) {
241	- if (disc->lport == lport) {
242	- cancel_delayed_work_sync(&disc->disc_work);
243	- fc_disc_stop_rports(disc);
244	- }
245	+ if (disc) {
246	+ cancel_delayed_work_sync(&disc->disc_work);
247	+ fc_disc_stop_rports(disc);
248	}
249	- mutex_unlock(&disc_list_lock);
250	}
251
252	/**
253	@@ -889,18 +848,8 @@ void fc_disc_stop(struct fc_lport *lport)
254	*/
255	void fc_disc_stop_final(struct fc_lport *lport)
256	{
257	- struct fc_disc disc, next;
258	fc_disc_stop(lport);
259	lport->tt.rport_flush_queue();
260	-
261	- mutex_lock(&disc_list_lock);
262	- list_for_each_entry_safe(disc, next, &disc_list, list) {
263	- if (disc->lport == lport) {
264	- list_del(&disc->list);
265	- kfree(disc);
266	- }
267	- }
268	- mutex_unlock(&disc_list_lock);
269	}
270
271	/**
272	@@ -909,8 +858,6 @@ void fc_disc_stop_final(struct fc_lport *lport)
273	*/
274	int fc_disc_init(struct fc_lport *lport)
275	{
276	- INIT_LIST_HEAD(&disc_list);
277	- mutex_init(&disc_list_lock);
278
279	if (!lport->tt.disc_start)
280	lport->tt.disc_start = fc_disc_start;
281	diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
282	index 04ced7f..2426501 100644
283	--- a/drivers/scsi/libfc/fc_fcp.c
284	+++ b/drivers/scsi/libfc/fc_fcp.c
285	@@ -42,6 +42,7 @@
286	MODULE_AUTHOR("Open-FCoE.org");
287	MODULE_DESCRIPTION("libfc");
288	MODULE_LICENSE("GPL");
289	+MODULE_VERSION("1.0.5");
290
291	static int fc_fcp_debug;
292
293	diff --git a/drivers/scsi/libfc/fc_lport.c b/drivers/scsi/libfc/fc_lport.c
294	index 083d57b..de16203 100644
295	--- a/drivers/scsi/libfc/fc_lport.c
296	+++ b/drivers/scsi/libfc/fc_lport.c
297	@@ -577,6 +577,8 @@ int fc_fabric_logoff(struct fc_lport *lport)
298	{
299	lport->tt.disc_stop_final(lport);
300	mutex_lock(&lport->lp_mutex);
301	+ kfree(lport->disc);
302	+ lport->disc = NULL;
303	fc_lport_enter_logo(lport);
304	mutex_unlock(&lport->lp_mutex);
305	return 0;
306	diff --git a/include/scsi/libfc.h b/include/scsi/libfc.h
307	index dac03e2..587be50 100644
308	--- a/include/scsi/libfc.h
309	+++ b/include/scsi/libfc.h
310	@@ -570,6 +570,8 @@ struct libfc_function_template {
311	void (disc_stop_final) (struct fc_lport );
312	};
313
314	+struct fc_disc;
315	+
316	struct fc_lport {
317	struct list_head list;
318
319	@@ -578,6 +580,7 @@ struct fc_lport {
320	struct fc_exch_mgr *emp;
321	struct fc_rport *dns_rp;
322	struct fc_rport *ptp_rp;
323	+ struct fc_disc *disc;
324	void *scsi_priv;
325
326	/* Operational Information */