Commit | Line | Data |
---|---|---|
42e9a92f RL |
1 | /* |
2 | * Copyright(c) 2007 - 2008 Intel Corporation. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify it | |
5 | * under the terms and conditions of the GNU General Public License, | |
6 | * version 2, as published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope it will be useful, but WITHOUT | |
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
11 | * more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License along with | |
14 | * this program; if not, write to the Free Software Foundation, Inc., | |
15 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
16 | * | |
17 | * Maintained at www.Open-FCoE.org | |
18 | */ | |
19 | ||
20 | /* | |
21 | * Target Discovery | |
22 | * | |
23 | * This block discovers all FC-4 remote ports, including FCP initiators. It | |
24 | * also handles RSCN events and re-discovery if necessary. | |
25 | */ | |
26 | ||
27 | /* | |
28 | * DISC LOCKING | |
29 | * | |
30 | * The disc mutex is can be locked when acquiring rport locks, but may not | |
31 | * be held when acquiring the lport lock. Refer to fc_lport.c for more | |
32 | * details. | |
33 | */ | |
34 | ||
35 | #include <linux/timer.h> | |
5a0e3ad6 | 36 | #include <linux/slab.h> |
42e9a92f RL |
37 | #include <linux/err.h> |
38 | #include <asm/unaligned.h> | |
39 | ||
40 | #include <scsi/fc/fc_gs.h> | |
41 | ||
42 | #include <scsi/libfc.h> | |
43 | ||
8866a5d9 RL |
44 | #include "fc_libfc.h" |
45 | ||
42e9a92f RL |
46 | #define FC_DISC_RETRY_LIMIT 3 /* max retries */ |
47 | #define FC_DISC_RETRY_DELAY 500UL /* (msecs) delay */ | |
48 | ||
42e9a92f RL |
49 | static void fc_disc_gpn_ft_req(struct fc_disc *); |
50 | static void fc_disc_gpn_ft_resp(struct fc_seq *, struct fc_frame *, void *); | |
786681b9 | 51 | static void fc_disc_done(struct fc_disc *, enum fc_disc_event); |
42e9a92f | 52 | static void fc_disc_timeout(struct work_struct *); |
2ab7e1ec | 53 | static int fc_disc_single(struct fc_lport *, struct fc_disc_port *); |
42e9a92f RL |
54 | static void fc_disc_restart(struct fc_disc *); |
55 | ||
42e9a92f | 56 | /** |
3a3b42bf RL |
57 | * fc_disc_stop_rports() - Delete all the remote ports associated with the lport |
58 | * @disc: The discovery job to stop remote ports on | |
42e9a92f RL |
59 | * |
60 | * Locking Note: This function expects that the lport mutex is locked before | |
61 | * calling it. | |
62 | */ | |
63 | void fc_disc_stop_rports(struct fc_disc *disc) | |
64 | { | |
65 | struct fc_lport *lport; | |
ab28f1fd | 66 | struct fc_rport_priv *rdata, *next; |
42e9a92f RL |
67 | |
68 | lport = disc->lport; | |
69 | ||
70 | mutex_lock(&disc->disc_mutex); | |
9e9d0452 | 71 | list_for_each_entry_safe(rdata, next, &disc->rports, peers) |
9fb9d328 | 72 | lport->tt.rport_logoff(rdata); |
42e9a92f RL |
73 | mutex_unlock(&disc->disc_mutex); |
74 | } | |
75 | ||
42e9a92f | 76 | /** |
34f42a07 | 77 | * fc_disc_recv_rscn_req() - Handle Registered State Change Notification (RSCN) |
3a3b42bf RL |
78 | * @sp: The sequence of the RSCN exchange |
79 | * @fp: The RSCN frame | |
80 | * @lport: The local port that the request will be sent on | |
42e9a92f RL |
81 | * |
82 | * Locking Note: This function expects that the disc_mutex is locked | |
83 | * before it is called. | |
84 | */ | |
85 | static void fc_disc_recv_rscn_req(struct fc_seq *sp, struct fc_frame *fp, | |
86 | struct fc_disc *disc) | |
87 | { | |
88 | struct fc_lport *lport; | |
42e9a92f RL |
89 | struct fc_els_rscn *rp; |
90 | struct fc_els_rscn_page *pp; | |
91 | struct fc_seq_els_data rjt_data; | |
92 | unsigned int len; | |
93 | int redisc = 0; | |
94 | enum fc_els_rscn_ev_qual ev_qual; | |
95 | enum fc_els_rscn_addr_fmt fmt; | |
96 | LIST_HEAD(disc_ports); | |
97 | struct fc_disc_port *dp, *next; | |
98 | ||
99 | lport = disc->lport; | |
100 | ||
7414705e | 101 | FC_DISC_DBG(disc, "Received an RSCN event\n"); |
42e9a92f RL |
102 | |
103 | /* make sure the frame contains an RSCN message */ | |
104 | rp = fc_frame_payload_get(fp, sizeof(*rp)); | |
105 | if (!rp) | |
106 | goto reject; | |
107 | /* make sure the page length is as expected (4 bytes) */ | |
108 | if (rp->rscn_page_len != sizeof(*pp)) | |
109 | goto reject; | |
110 | /* get the RSCN payload length */ | |
111 | len = ntohs(rp->rscn_plen); | |
112 | if (len < sizeof(*rp)) | |
113 | goto reject; | |
114 | /* make sure the frame contains the expected payload */ | |
115 | rp = fc_frame_payload_get(fp, len); | |
116 | if (!rp) | |
117 | goto reject; | |
118 | /* payload must be a multiple of the RSCN page size */ | |
119 | len -= sizeof(*rp); | |
120 | if (len % sizeof(*pp)) | |
121 | goto reject; | |
122 | ||
123 | for (pp = (void *)(rp + 1); len > 0; len -= sizeof(*pp), pp++) { | |
124 | ev_qual = pp->rscn_page_flags >> ELS_RSCN_EV_QUAL_BIT; | |
125 | ev_qual &= ELS_RSCN_EV_QUAL_MASK; | |
126 | fmt = pp->rscn_page_flags >> ELS_RSCN_ADDR_FMT_BIT; | |
127 | fmt &= ELS_RSCN_ADDR_FMT_MASK; | |
128 | /* | |
129 | * if we get an address format other than port | |
130 | * (area, domain, fabric), then do a full discovery | |
131 | */ | |
132 | switch (fmt) { | |
133 | case ELS_ADDR_FMT_PORT: | |
7414705e | 134 | FC_DISC_DBG(disc, "Port address format for port " |
ce8b5df0 | 135 | "(%6.6x)\n", ntoh24(pp->rscn_fid)); |
42e9a92f RL |
136 | dp = kzalloc(sizeof(*dp), GFP_KERNEL); |
137 | if (!dp) { | |
138 | redisc = 1; | |
139 | break; | |
140 | } | |
141 | dp->lp = lport; | |
9737e6a7 | 142 | dp->port_id = ntoh24(pp->rscn_fid); |
42e9a92f RL |
143 | list_add_tail(&dp->peers, &disc_ports); |
144 | break; | |
145 | case ELS_ADDR_FMT_AREA: | |
146 | case ELS_ADDR_FMT_DOM: | |
147 | case ELS_ADDR_FMT_FAB: | |
148 | default: | |
7414705e | 149 | FC_DISC_DBG(disc, "Address format is (%d)\n", fmt); |
42e9a92f RL |
150 | redisc = 1; |
151 | break; | |
152 | } | |
153 | } | |
154 | lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL); | |
2ab7e1ec JE |
155 | |
156 | /* | |
157 | * If not doing a complete rediscovery, do GPN_ID on | |
158 | * the individual ports mentioned in the list. | |
159 | * If any of these get an error, do a full rediscovery. | |
160 | * In any case, go through the list and free the entries. | |
161 | */ | |
162 | list_for_each_entry_safe(dp, next, &disc_ports, peers) { | |
163 | list_del(&dp->peers); | |
164 | if (!redisc) | |
165 | redisc = fc_disc_single(lport, dp); | |
166 | kfree(dp); | |
167 | } | |
42e9a92f | 168 | if (redisc) { |
7414705e | 169 | FC_DISC_DBG(disc, "RSCN received: rediscovering\n"); |
42e9a92f RL |
170 | fc_disc_restart(disc); |
171 | } else { | |
7414705e RL |
172 | FC_DISC_DBG(disc, "RSCN received: not rediscovering. " |
173 | "redisc %d state %d in_prog %d\n", | |
174 | redisc, lport->state, disc->pending); | |
42e9a92f RL |
175 | } |
176 | fc_frame_free(fp); | |
177 | return; | |
178 | reject: | |
7414705e | 179 | FC_DISC_DBG(disc, "Received a bad RSCN frame\n"); |
42e9a92f RL |
180 | rjt_data.fp = NULL; |
181 | rjt_data.reason = ELS_RJT_LOGIC; | |
182 | rjt_data.explan = ELS_EXPL_NONE; | |
183 | lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data); | |
184 | fc_frame_free(fp); | |
185 | } | |
186 | ||
187 | /** | |
34f42a07 | 188 | * fc_disc_recv_req() - Handle incoming requests |
3a3b42bf RL |
189 | * @sp: The sequence of the request exchange |
190 | * @fp: The request frame | |
191 | * @lport: The local port receiving the request | |
42e9a92f RL |
192 | * |
193 | * Locking Note: This function is called from the EM and will lock | |
194 | * the disc_mutex before calling the handler for the | |
195 | * request. | |
196 | */ | |
197 | static void fc_disc_recv_req(struct fc_seq *sp, struct fc_frame *fp, | |
198 | struct fc_lport *lport) | |
199 | { | |
200 | u8 op; | |
201 | struct fc_disc *disc = &lport->disc; | |
202 | ||
203 | op = fc_frame_payload_op(fp); | |
204 | switch (op) { | |
205 | case ELS_RSCN: | |
206 | mutex_lock(&disc->disc_mutex); | |
207 | fc_disc_recv_rscn_req(sp, fp, disc); | |
208 | mutex_unlock(&disc->disc_mutex); | |
209 | break; | |
210 | default: | |
7414705e RL |
211 | FC_DISC_DBG(disc, "Received an unsupported request, " |
212 | "the opcode is (%x)\n", op); | |
42e9a92f RL |
213 | break; |
214 | } | |
215 | } | |
216 | ||
217 | /** | |
34f42a07 | 218 | * fc_disc_restart() - Restart discovery |
3a3b42bf | 219 | * @disc: The discovery object to be restarted |
42e9a92f RL |
220 | * |
221 | * Locking Note: This function expects that the disc mutex | |
222 | * is already locked. | |
223 | */ | |
224 | static void fc_disc_restart(struct fc_disc *disc) | |
225 | { | |
935d0fce JE |
226 | if (!disc->disc_callback) |
227 | return; | |
228 | ||
7414705e | 229 | FC_DISC_DBG(disc, "Restarting discovery\n"); |
42e9a92f | 230 | |
42e9a92f | 231 | disc->requested = 1; |
0f6c6149 JE |
232 | if (disc->pending) |
233 | return; | |
234 | ||
235 | /* | |
236 | * Advance disc_id. This is an arbitrary non-zero number that will | |
237 | * match the value in the fc_rport_priv after discovery for all | |
238 | * freshly-discovered remote ports. Avoid wrapping to zero. | |
239 | */ | |
240 | disc->disc_id = (disc->disc_id + 2) | 1; | |
3667d7e7 | 241 | disc->retry_count = 0; |
0f6c6149 | 242 | fc_disc_gpn_ft_req(disc); |
42e9a92f RL |
243 | } |
244 | ||
245 | /** | |
3a3b42bf RL |
246 | * fc_disc_start() - Start discovery on a local port |
247 | * @lport: The local port to have discovery started on | |
248 | * @disc_callback: Callback function to be called when discovery is complete | |
42e9a92f RL |
249 | */ |
250 | static void fc_disc_start(void (*disc_callback)(struct fc_lport *, | |
251 | enum fc_disc_event), | |
252 | struct fc_lport *lport) | |
253 | { | |
42e9a92f RL |
254 | struct fc_disc *disc = &lport->disc; |
255 | ||
256 | /* | |
257 | * At this point we may have a new disc job or an existing | |
258 | * one. Either way, let's lock when we make changes to it | |
259 | * and send the GPN_FT request. | |
260 | */ | |
261 | mutex_lock(&disc->disc_mutex); | |
42e9a92f | 262 | disc->disc_callback = disc_callback; |
29d898e9 | 263 | fc_disc_restart(disc); |
42e9a92f RL |
264 | mutex_unlock(&disc->disc_mutex); |
265 | } | |
266 | ||
42e9a92f | 267 | /** |
34f42a07 | 268 | * fc_disc_done() - Discovery has been completed |
3a3b42bf RL |
269 | * @disc: The discovery context |
270 | * @event: The discovery completion status | |
786681b9 | 271 | * |
0d228c0f AJ |
272 | * Locking Note: This function expects that the disc mutex is locked before |
273 | * it is called. The discovery callback is then made with the lock released, | |
274 | * and the lock is re-taken before returning from this function | |
42e9a92f | 275 | */ |
786681b9 | 276 | static void fc_disc_done(struct fc_disc *disc, enum fc_disc_event event) |
42e9a92f RL |
277 | { |
278 | struct fc_lport *lport = disc->lport; | |
0f6c6149 | 279 | struct fc_rport_priv *rdata; |
42e9a92f | 280 | |
7414705e | 281 | FC_DISC_DBG(disc, "Discovery complete\n"); |
42e9a92f | 282 | |
0f6c6149 JE |
283 | disc->pending = 0; |
284 | if (disc->requested) { | |
285 | fc_disc_restart(disc); | |
286 | return; | |
287 | } | |
288 | ||
289 | /* | |
3a3b42bf RL |
290 | * Go through all remote ports. If they were found in the latest |
291 | * discovery, reverify or log them in. Otherwise, log them out. | |
0f6c6149 JE |
292 | * Skip ports which were never discovered. These are the dNS port |
293 | * and ports which were created by PLOGI. | |
294 | */ | |
295 | list_for_each_entry(rdata, &disc->rports, peers) { | |
296 | if (!rdata->disc_id) | |
297 | continue; | |
298 | if (rdata->disc_id == disc->disc_id) | |
299 | lport->tt.rport_login(rdata); | |
300 | else | |
301 | lport->tt.rport_logoff(rdata); | |
302 | } | |
0d228c0f AJ |
303 | |
304 | mutex_unlock(&disc->disc_mutex); | |
305 | disc->disc_callback(lport, event); | |
306 | mutex_lock(&disc->disc_mutex); | |
42e9a92f RL |
307 | } |
308 | ||
309 | /** | |
34f42a07 | 310 | * fc_disc_error() - Handle error on dNS request |
3a3b42bf RL |
311 | * @disc: The discovery context |
312 | * @fp: The error code encoded as a frame pointer | |
42e9a92f RL |
313 | */ |
314 | static void fc_disc_error(struct fc_disc *disc, struct fc_frame *fp) | |
315 | { | |
316 | struct fc_lport *lport = disc->lport; | |
317 | unsigned long delay = 0; | |
7414705e RL |
318 | |
319 | FC_DISC_DBG(disc, "Error %ld, retries %d/%d\n", | |
320 | PTR_ERR(fp), disc->retry_count, | |
321 | FC_DISC_RETRY_LIMIT); | |
42e9a92f RL |
322 | |
323 | if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) { | |
324 | /* | |
325 | * Memory allocation failure, or the exchange timed out, | |
326 | * retry after delay. | |
327 | */ | |
328 | if (disc->retry_count < FC_DISC_RETRY_LIMIT) { | |
329 | /* go ahead and retry */ | |
330 | if (!fp) | |
331 | delay = msecs_to_jiffies(FC_DISC_RETRY_DELAY); | |
332 | else { | |
333 | delay = msecs_to_jiffies(lport->e_d_tov); | |
334 | ||
335 | /* timeout faster first time */ | |
336 | if (!disc->retry_count) | |
337 | delay /= 4; | |
338 | } | |
339 | disc->retry_count++; | |
340 | schedule_delayed_work(&disc->disc_work, delay); | |
786681b9 JE |
341 | } else |
342 | fc_disc_done(disc, DISC_EV_FAILED); | |
42e9a92f RL |
343 | } |
344 | } | |
345 | ||
346 | /** | |
34f42a07 | 347 | * fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request |
3a3b42bf | 348 | * @lport: The discovery context |
42e9a92f RL |
349 | * |
350 | * Locking Note: This function expects that the disc_mutex is locked | |
351 | * before it is called. | |
352 | */ | |
353 | static void fc_disc_gpn_ft_req(struct fc_disc *disc) | |
354 | { | |
355 | struct fc_frame *fp; | |
356 | struct fc_lport *lport = disc->lport; | |
357 | ||
358 | WARN_ON(!fc_lport_test_ready(lport)); | |
359 | ||
360 | disc->pending = 1; | |
361 | disc->requested = 0; | |
362 | ||
363 | disc->buf_len = 0; | |
364 | disc->seq_count = 0; | |
365 | fp = fc_frame_alloc(lport, | |
366 | sizeof(struct fc_ct_hdr) + | |
367 | sizeof(struct fc_ns_gid_ft)); | |
368 | if (!fp) | |
369 | goto err; | |
370 | ||
a46f327a | 371 | if (lport->tt.elsct_send(lport, 0, fp, |
42e9a92f RL |
372 | FC_NS_GPN_FT, |
373 | fc_disc_gpn_ft_resp, | |
b94f8951 | 374 | disc, 3 * lport->r_a_tov)) |
42e9a92f RL |
375 | return; |
376 | err: | |
8f550f93 | 377 | fc_disc_error(disc, NULL); |
42e9a92f RL |
378 | } |
379 | ||
380 | /** | |
786681b9 | 381 | * fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response. |
3a3b42bf RL |
382 | * @lport: The local port the GPN_FT was received on |
383 | * @buf: The GPN_FT response buffer | |
384 | * @len: The size of response buffer | |
786681b9 JE |
385 | * |
386 | * Goes through the list of IDs and names resulting from a request. | |
42e9a92f RL |
387 | */ |
388 | static int fc_disc_gpn_ft_parse(struct fc_disc *disc, void *buf, size_t len) | |
389 | { | |
390 | struct fc_lport *lport; | |
391 | struct fc_gpn_ft_resp *np; | |
392 | char *bp; | |
393 | size_t plen; | |
394 | size_t tlen; | |
395 | int error = 0; | |
795d86f5 | 396 | struct fc_rport_identifiers ids; |
ab28f1fd | 397 | struct fc_rport_priv *rdata; |
42e9a92f RL |
398 | |
399 | lport = disc->lport; | |
a1c1e4e7 | 400 | disc->seq_count++; |
42e9a92f RL |
401 | |
402 | /* | |
403 | * Handle partial name record left over from previous call. | |
404 | */ | |
405 | bp = buf; | |
406 | plen = len; | |
407 | np = (struct fc_gpn_ft_resp *)bp; | |
408 | tlen = disc->buf_len; | |
81a67b97 | 409 | disc->buf_len = 0; |
42e9a92f RL |
410 | if (tlen) { |
411 | WARN_ON(tlen >= sizeof(*np)); | |
412 | plen = sizeof(*np) - tlen; | |
413 | WARN_ON(plen <= 0); | |
414 | WARN_ON(plen >= sizeof(*np)); | |
415 | if (plen > len) | |
416 | plen = len; | |
417 | np = &disc->partial_buf; | |
418 | memcpy((char *)np + tlen, bp, plen); | |
419 | ||
420 | /* | |
421 | * Set bp so that the loop below will advance it to the | |
422 | * first valid full name element. | |
423 | */ | |
424 | bp -= tlen; | |
425 | len += tlen; | |
426 | plen += tlen; | |
427 | disc->buf_len = (unsigned char) plen; | |
428 | if (plen == sizeof(*np)) | |
429 | disc->buf_len = 0; | |
430 | } | |
431 | ||
432 | /* | |
433 | * Handle full name records, including the one filled from above. | |
434 | * Normally, np == bp and plen == len, but from the partial case above, | |
435 | * bp, len describe the overall buffer, and np, plen describe the | |
436 | * partial buffer, which if would usually be full now. | |
437 | * After the first time through the loop, things return to "normal". | |
438 | */ | |
439 | while (plen >= sizeof(*np)) { | |
795d86f5 JE |
440 | ids.port_id = ntoh24(np->fp_fid); |
441 | ids.port_name = ntohll(np->fp_wwpn); | |
795d86f5 JE |
442 | |
443 | if (ids.port_id != fc_host_port_id(lport->host) && | |
444 | ids.port_name != lport->wwpn) { | |
9737e6a7 RL |
445 | rdata = lport->tt.rport_create(lport, ids.port_id); |
446 | if (rdata) { | |
447 | rdata->ids.port_name = ids.port_name; | |
0f6c6149 | 448 | rdata->disc_id = disc->disc_id; |
9737e6a7 | 449 | } else { |
7414705e RL |
450 | printk(KERN_WARNING "libfc: Failed to allocate " |
451 | "memory for the newly discovered port " | |
ce8b5df0 | 452 | "(%6.6x)\n", ids.port_id); |
81a67b97 JE |
453 | error = -ENOMEM; |
454 | } | |
42e9a92f RL |
455 | } |
456 | ||
457 | if (np->fp_flags & FC_NS_FID_LAST) { | |
786681b9 | 458 | fc_disc_done(disc, DISC_EV_SUCCESS); |
42e9a92f RL |
459 | len = 0; |
460 | break; | |
461 | } | |
462 | len -= sizeof(*np); | |
463 | bp += sizeof(*np); | |
464 | np = (struct fc_gpn_ft_resp *)bp; | |
465 | plen = len; | |
466 | } | |
467 | ||
468 | /* | |
469 | * Save any partial record at the end of the buffer for next time. | |
470 | */ | |
471 | if (error == 0 && len > 0 && len < sizeof(*np)) { | |
472 | if (np != &disc->partial_buf) { | |
7414705e RL |
473 | FC_DISC_DBG(disc, "Partial buffer remains " |
474 | "for discovery\n"); | |
42e9a92f RL |
475 | memcpy(&disc->partial_buf, np, len); |
476 | } | |
477 | disc->buf_len = (unsigned char) len; | |
42e9a92f RL |
478 | } |
479 | return error; | |
480 | } | |
481 | ||
34f42a07 | 482 | /** |
3a3b42bf RL |
483 | * fc_disc_timeout() - Handler for discovery timeouts |
484 | * @work: Structure holding discovery context that needs to retry discovery | |
42e9a92f RL |
485 | */ |
486 | static void fc_disc_timeout(struct work_struct *work) | |
487 | { | |
488 | struct fc_disc *disc = container_of(work, | |
489 | struct fc_disc, | |
490 | disc_work.work); | |
491 | mutex_lock(&disc->disc_mutex); | |
3667d7e7 | 492 | fc_disc_gpn_ft_req(disc); |
42e9a92f RL |
493 | mutex_unlock(&disc->disc_mutex); |
494 | } | |
495 | ||
496 | /** | |
34f42a07 | 497 | * fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT) |
3a3b42bf RL |
498 | * @sp: The sequence that the GPN_FT response was received on |
499 | * @fp: The GPN_FT response frame | |
500 | * @lp_arg: The discovery context | |
42e9a92f | 501 | * |
0d228c0f AJ |
502 | * Locking Note: This function is called without disc mutex held, and |
503 | * should do all its processing with the mutex held | |
42e9a92f RL |
504 | */ |
505 | static void fc_disc_gpn_ft_resp(struct fc_seq *sp, struct fc_frame *fp, | |
506 | void *disc_arg) | |
507 | { | |
508 | struct fc_disc *disc = disc_arg; | |
509 | struct fc_ct_hdr *cp; | |
510 | struct fc_frame_header *fh; | |
a1c1e4e7 | 511 | enum fc_disc_event event = DISC_EV_NONE; |
42e9a92f | 512 | unsigned int seq_cnt; |
42e9a92f | 513 | unsigned int len; |
a1c1e4e7 | 514 | int error = 0; |
42e9a92f | 515 | |
0d228c0f | 516 | mutex_lock(&disc->disc_mutex); |
7414705e | 517 | FC_DISC_DBG(disc, "Received a GPN_FT response\n"); |
42e9a92f RL |
518 | |
519 | if (IS_ERR(fp)) { | |
520 | fc_disc_error(disc, fp); | |
0d228c0f | 521 | mutex_unlock(&disc->disc_mutex); |
42e9a92f RL |
522 | return; |
523 | } | |
524 | ||
525 | WARN_ON(!fc_frame_is_linear(fp)); /* buffer must be contiguous */ | |
526 | fh = fc_frame_header_get(fp); | |
527 | len = fr_len(fp) - sizeof(*fh); | |
528 | seq_cnt = ntohs(fh->fh_seq_cnt); | |
a1c1e4e7 | 529 | if (fr_sof(fp) == FC_SOF_I3 && seq_cnt == 0 && disc->seq_count == 0) { |
42e9a92f RL |
530 | cp = fc_frame_payload_get(fp, sizeof(*cp)); |
531 | if (!cp) { | |
7414705e RL |
532 | FC_DISC_DBG(disc, "GPN_FT response too short, len %d\n", |
533 | fr_len(fp)); | |
883a337c | 534 | event = DISC_EV_FAILED; |
42e9a92f RL |
535 | } else if (ntohs(cp->ct_cmd) == FC_FS_ACC) { |
536 | ||
34f42a07 | 537 | /* Accepted, parse the response. */ |
42e9a92f | 538 | len -= sizeof(*cp); |
a1c1e4e7 | 539 | error = fc_disc_gpn_ft_parse(disc, cp + 1, len); |
42e9a92f | 540 | } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) { |
7414705e RL |
541 | FC_DISC_DBG(disc, "GPN_FT rejected reason %x exp %x " |
542 | "(check zoning)\n", cp->ct_reason, | |
543 | cp->ct_explan); | |
a1c1e4e7 | 544 | event = DISC_EV_FAILED; |
c762608b JE |
545 | if (cp->ct_reason == FC_FS_RJT_UNABL && |
546 | cp->ct_explan == FC_FS_EXP_FTNR) | |
547 | event = DISC_EV_SUCCESS; | |
42e9a92f | 548 | } else { |
7414705e RL |
549 | FC_DISC_DBG(disc, "GPN_FT unexpected response code " |
550 | "%x\n", ntohs(cp->ct_cmd)); | |
883a337c | 551 | event = DISC_EV_FAILED; |
42e9a92f | 552 | } |
a1c1e4e7 JE |
553 | } else if (fr_sof(fp) == FC_SOF_N3 && seq_cnt == disc->seq_count) { |
554 | error = fc_disc_gpn_ft_parse(disc, fh + 1, len); | |
42e9a92f | 555 | } else { |
7414705e RL |
556 | FC_DISC_DBG(disc, "GPN_FT unexpected frame - out of sequence? " |
557 | "seq_cnt %x expected %x sof %x eof %x\n", | |
558 | seq_cnt, disc->seq_count, fr_sof(fp), fr_eof(fp)); | |
883a337c | 559 | event = DISC_EV_FAILED; |
42e9a92f | 560 | } |
a1c1e4e7 JE |
561 | if (error) |
562 | fc_disc_error(disc, fp); | |
563 | else if (event != DISC_EV_NONE) | |
564 | fc_disc_done(disc, event); | |
42e9a92f | 565 | fc_frame_free(fp); |
0d228c0f | 566 | mutex_unlock(&disc->disc_mutex); |
42e9a92f RL |
567 | } |
568 | ||
569 | /** | |
2ab7e1ec | 570 | * fc_disc_gpn_id_resp() - Handle a response frame from Get Port Names (GPN_ID) |
3a3b42bf RL |
571 | * @sp: The sequence the GPN_ID is on |
572 | * @fp: The response frame | |
573 | * @rdata_arg: The remote port that sent the GPN_ID response | |
42e9a92f | 574 | * |
2ab7e1ec | 575 | * Locking Note: This function is called without disc mutex held. |
42e9a92f | 576 | */ |
2ab7e1ec JE |
577 | static void fc_disc_gpn_id_resp(struct fc_seq *sp, struct fc_frame *fp, |
578 | void *rdata_arg) | |
42e9a92f | 579 | { |
2ab7e1ec JE |
580 | struct fc_rport_priv *rdata = rdata_arg; |
581 | struct fc_rport_priv *new_rdata; | |
42e9a92f | 582 | struct fc_lport *lport; |
2ab7e1ec JE |
583 | struct fc_disc *disc; |
584 | struct fc_ct_hdr *cp; | |
585 | struct fc_ns_gid_pn *pn; | |
586 | u64 port_name; | |
42e9a92f | 587 | |
2ab7e1ec JE |
588 | lport = rdata->local_port; |
589 | disc = &lport->disc; | |
42e9a92f | 590 | |
2ab7e1ec JE |
591 | mutex_lock(&disc->disc_mutex); |
592 | if (PTR_ERR(fp) == -FC_EX_CLOSED) | |
42e9a92f | 593 | goto out; |
2ab7e1ec JE |
594 | if (IS_ERR(fp)) |
595 | goto redisc; | |
596 | ||
597 | cp = fc_frame_payload_get(fp, sizeof(*cp)); | |
598 | if (!cp) | |
599 | goto redisc; | |
600 | if (ntohs(cp->ct_cmd) == FC_FS_ACC) { | |
601 | if (fr_len(fp) < sizeof(struct fc_frame_header) + | |
602 | sizeof(*cp) + sizeof(*pn)) | |
603 | goto redisc; | |
604 | pn = (struct fc_ns_gid_pn *)(cp + 1); | |
605 | port_name = get_unaligned_be64(&pn->fn_wwpn); | |
606 | if (rdata->ids.port_name == -1) | |
607 | rdata->ids.port_name = port_name; | |
608 | else if (rdata->ids.port_name != port_name) { | |
609 | FC_DISC_DBG(disc, "GPN_ID accepted. WWPN changed. " | |
ce8b5df0 | 610 | "Port-id %6.6x wwpn %llx\n", |
2ab7e1ec JE |
611 | rdata->ids.port_id, port_name); |
612 | lport->tt.rport_logoff(rdata); | |
42e9a92f | 613 | |
2ab7e1ec JE |
614 | new_rdata = lport->tt.rport_create(lport, |
615 | rdata->ids.port_id); | |
616 | if (new_rdata) { | |
617 | new_rdata->disc_id = disc->disc_id; | |
618 | lport->tt.rport_login(new_rdata); | |
619 | } | |
620 | goto out; | |
621 | } | |
0f6c6149 | 622 | rdata->disc_id = disc->disc_id; |
9fb9d328 | 623 | lport->tt.rport_login(rdata); |
2ab7e1ec JE |
624 | } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) { |
625 | FC_DISC_DBG(disc, "GPN_ID rejected reason %x exp %x\n", | |
626 | cp->ct_reason, cp->ct_explan); | |
627 | lport->tt.rport_logoff(rdata); | |
628 | } else { | |
629 | FC_DISC_DBG(disc, "GPN_ID unexpected response code %x\n", | |
630 | ntohs(cp->ct_cmd)); | |
631 | redisc: | |
632 | fc_disc_restart(disc); | |
42e9a92f | 633 | } |
42e9a92f | 634 | out: |
2ab7e1ec JE |
635 | mutex_unlock(&disc->disc_mutex); |
636 | kref_put(&rdata->kref, lport->tt.rport_destroy); | |
637 | } | |
638 | ||
639 | /** | |
640 | * fc_disc_gpn_id_req() - Send Get Port Names by ID (GPN_ID) request | |
3a3b42bf | 641 | * @lport: The local port to initiate discovery on |
2ab7e1ec JE |
642 | * @rdata: remote port private data |
643 | * | |
644 | * Locking Note: This function expects that the disc_mutex is locked | |
645 | * before it is called. | |
646 | * On failure, an error code is returned. | |
647 | */ | |
648 | static int fc_disc_gpn_id_req(struct fc_lport *lport, | |
649 | struct fc_rport_priv *rdata) | |
650 | { | |
651 | struct fc_frame *fp; | |
652 | ||
653 | fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) + | |
654 | sizeof(struct fc_ns_fid)); | |
655 | if (!fp) | |
656 | return -ENOMEM; | |
657 | if (!lport->tt.elsct_send(lport, rdata->ids.port_id, fp, FC_NS_GPN_ID, | |
b94f8951 JE |
658 | fc_disc_gpn_id_resp, rdata, |
659 | 3 * lport->r_a_tov)) | |
2ab7e1ec JE |
660 | return -ENOMEM; |
661 | kref_get(&rdata->kref); | |
662 | return 0; | |
663 | } | |
664 | ||
665 | /** | |
666 | * fc_disc_single() - Discover the directory information for a single target | |
3a3b42bf RL |
667 | * @lport: The local port the remote port is associated with |
668 | * @dp: The port to rediscover | |
2ab7e1ec JE |
669 | * |
670 | * Locking Note: This function expects that the disc_mutex is locked | |
671 | * before it is called. | |
672 | */ | |
673 | static int fc_disc_single(struct fc_lport *lport, struct fc_disc_port *dp) | |
674 | { | |
675 | struct fc_rport_priv *rdata; | |
676 | ||
677 | rdata = lport->tt.rport_create(lport, dp->port_id); | |
678 | if (!rdata) | |
679 | return -ENOMEM; | |
680 | rdata->disc_id = 0; | |
681 | return fc_disc_gpn_id_req(lport, rdata); | |
42e9a92f RL |
682 | } |
683 | ||
684 | /** | |
34f42a07 | 685 | * fc_disc_stop() - Stop discovery for a given lport |
3a3b42bf | 686 | * @lport: The local port that discovery should stop on |
42e9a92f RL |
687 | */ |
688 | void fc_disc_stop(struct fc_lport *lport) | |
689 | { | |
690 | struct fc_disc *disc = &lport->disc; | |
691 | ||
692 | if (disc) { | |
693 | cancel_delayed_work_sync(&disc->disc_work); | |
694 | fc_disc_stop_rports(disc); | |
695 | } | |
696 | } | |
697 | ||
698 | /** | |
34f42a07 | 699 | * fc_disc_stop_final() - Stop discovery for a given lport |
3a3b42bf | 700 | * @lport: The lport that discovery should stop on |
42e9a92f RL |
701 | * |
702 | * This function will block until discovery has been | |
703 | * completely stopped and all rports have been deleted. | |
704 | */ | |
705 | void fc_disc_stop_final(struct fc_lport *lport) | |
706 | { | |
707 | fc_disc_stop(lport); | |
708 | lport->tt.rport_flush_queue(); | |
709 | } | |
710 | ||
711 | /** | |
3a3b42bf RL |
712 | * fc_disc_init() - Initialize the discovery layer for a local port |
713 | * @lport: The local port that needs the discovery layer to be initialized | |
42e9a92f RL |
714 | */ |
715 | int fc_disc_init(struct fc_lport *lport) | |
716 | { | |
717 | struct fc_disc *disc; | |
718 | ||
719 | if (!lport->tt.disc_start) | |
720 | lport->tt.disc_start = fc_disc_start; | |
721 | ||
722 | if (!lport->tt.disc_stop) | |
723 | lport->tt.disc_stop = fc_disc_stop; | |
724 | ||
725 | if (!lport->tt.disc_stop_final) | |
726 | lport->tt.disc_stop_final = fc_disc_stop_final; | |
727 | ||
728 | if (!lport->tt.disc_recv_req) | |
729 | lport->tt.disc_recv_req = fc_disc_recv_req; | |
730 | ||
42e9a92f RL |
731 | disc = &lport->disc; |
732 | INIT_DELAYED_WORK(&disc->disc_work, fc_disc_timeout); | |
733 | mutex_init(&disc->disc_mutex); | |
734 | INIT_LIST_HEAD(&disc->rports); | |
735 | ||
736 | disc->lport = lport; | |
42e9a92f RL |
737 | |
738 | return 0; | |
739 | } | |
740 | EXPORT_SYMBOL(fc_disc_init); |