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> 36 #include <linux/slab.h> 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 44 #include "fc_libfc.h" 45 46 #define FC_DISC_RETRY_LIMIT 3 /* max retries */ 47 #define FC_DISC_RETRY_DELAY 500UL /* (msecs) delay */ 48 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 *); 51 static void fc_disc_done(struct fc_disc *, enum fc_disc_event); 52 static void fc_disc_timeout(struct work_struct *); 53 static int fc_disc_single(struct fc_lport *, struct fc_disc_port *); 54 static void fc_disc_restart(struct fc_disc *); 55 56 /** 57 * fc_disc_stop_rports() - Delete all the remote ports associated with the lport 58 * @disc: The discovery job to stop remote ports on 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; 66 struct fc_rport_priv *rdata, *next; 67 68 lport = disc->lport; 69 70 mutex_lock(&disc->disc_mutex); 71 list_for_each_entry_safe(rdata, next, &disc->rports, peers) 72 lport->tt.rport_logoff(rdata); 73 mutex_unlock(&disc->disc_mutex); 74 } 75 76 /** 77 * fc_disc_recv_rscn_req() - Handle Registered State Change Notification (RSCN) 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 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; 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 101 FC_DISC_DBG(disc, "Received an RSCN event\n"); 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: 134 FC_DISC_DBG(disc, "Port address format for port " 135 "(%6.6x)\n", ntoh24(pp->rscn_fid)); 136 dp = kzalloc(sizeof(*dp), GFP_KERNEL); 137 if (!dp) { 138 redisc = 1; 139 break; 140 } 141 dp->lp = lport; 142 dp->port_id = ntoh24(pp->rscn_fid); 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: 149 FC_DISC_DBG(disc, "Address format is (%d)\n", fmt); 150 redisc = 1; 151 break; 152 } 153 } 154 lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL); 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 } 168 if (redisc) { 169 FC_DISC_DBG(disc, "RSCN received: rediscovering\n"); 170 fc_disc_restart(disc); 171 } else { 172 FC_DISC_DBG(disc, "RSCN received: not rediscovering. " 173 "redisc %d state %d in_prog %d\n", 174 redisc, lport->state, disc->pending); 175 } 176 fc_frame_free(fp); 177 return; 178 reject: 179 FC_DISC_DBG(disc, "Received a bad RSCN frame\n"); 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 /** 188 * fc_disc_recv_req() - Handle incoming requests 189 * @sp: The sequence of the request exchange 190 * @fp: The request frame 191 * @lport: The local port receiving the request 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: 211 FC_DISC_DBG(disc, "Received an unsupported request, " 212 "the opcode is (%x)\n", op); 213 break; 214 } 215 } 216 217 /** 218 * fc_disc_restart() - Restart discovery 219 * @disc: The discovery object to be restarted 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 { 226 if (!disc->disc_callback) 227 return; 228 229 FC_DISC_DBG(disc, "Restarting discovery\n"); 230 231 disc->requested = 1; 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; 241 disc->retry_count = 0; 242 fc_disc_gpn_ft_req(disc); 243 } 244 245 /** 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 249 */ 250 static void fc_disc_start(void (*disc_callback)(struct fc_lport *, 251 enum fc_disc_event), 252 struct fc_lport *lport) 253 { 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); 262 disc->disc_callback = disc_callback; 263 fc_disc_restart(disc); 264 mutex_unlock(&disc->disc_mutex); 265 } 266 267 /** 268 * fc_disc_done() - Discovery has been completed 269 * @disc: The discovery context 270 * @event: The discovery completion status 271 * 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 275 */ 276 static void fc_disc_done(struct fc_disc *disc, enum fc_disc_event event) 277 { 278 struct fc_lport *lport = disc->lport; 279 struct fc_rport_priv *rdata; 280 281 FC_DISC_DBG(disc, "Discovery complete\n"); 282 283 disc->pending = 0; 284 if (disc->requested) { 285 fc_disc_restart(disc); 286 return; 287 } 288 289 /* 290 * Go through all remote ports. If they were found in the latest 291 * discovery, reverify or log them in. Otherwise, log them out. 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 } 303 304 mutex_unlock(&disc->disc_mutex); 305 disc->disc_callback(lport, event); 306 mutex_lock(&disc->disc_mutex); 307 } 308 309 /** 310 * fc_disc_error() - Handle error on dNS request 311 * @disc: The discovery context 312 * @fp: The error code encoded as a frame pointer 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; 318 319 FC_DISC_DBG(disc, "Error %ld, retries %d/%d\n", 320 PTR_ERR(fp), disc->retry_count, 321 FC_DISC_RETRY_LIMIT); 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); 341 } else 342 fc_disc_done(disc, DISC_EV_FAILED); 343 } 344 } 345 346 /** 347 * fc_disc_gpn_ft_req() - Send Get Port Names by FC-4 type (GPN_FT) request 348 * @lport: The discovery context 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 371 if (lport->tt.elsct_send(lport, 0, fp, 372 FC_NS_GPN_FT, 373 fc_disc_gpn_ft_resp, 374 disc, 3 * lport->r_a_tov)) 375 return; 376 err: 377 fc_disc_error(disc, NULL); 378 } 379 380 /** 381 * fc_disc_gpn_ft_parse() - Parse the body of the dNS GPN_FT response. 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 385 * 386 * Goes through the list of IDs and names resulting from a request. 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; 396 struct fc_rport_identifiers ids; 397 struct fc_rport_priv *rdata; 398 399 lport = disc->lport; 400 disc->seq_count++; 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; 409 disc->buf_len = 0; 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)) { 440 ids.port_id = ntoh24(np->fp_fid); 441 ids.port_name = ntohll(np->fp_wwpn); 442 443 if (ids.port_id != fc_host_port_id(lport->host) && 444 ids.port_name != lport->wwpn) { 445 rdata = lport->tt.rport_create(lport, ids.port_id); 446 if (rdata) { 447 rdata->ids.port_name = ids.port_name; 448 rdata->disc_id = disc->disc_id; 449 } else { 450 printk(KERN_WARNING "libfc: Failed to allocate " 451 "memory for the newly discovered port " 452 "(%6.6x)\n", ids.port_id); 453 error = -ENOMEM; 454 } 455 } 456 457 if (np->fp_flags & FC_NS_FID_LAST) { 458 fc_disc_done(disc, DISC_EV_SUCCESS); 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) { 473 FC_DISC_DBG(disc, "Partial buffer remains " 474 "for discovery\n"); 475 memcpy(&disc->partial_buf, np, len); 476 } 477 disc->buf_len = (unsigned char) len; 478 } 479 return error; 480 } 481 482 /** 483 * fc_disc_timeout() - Handler for discovery timeouts 484 * @work: Structure holding discovery context that needs to retry discovery 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); 492 fc_disc_gpn_ft_req(disc); 493 mutex_unlock(&disc->disc_mutex); 494 } 495 496 /** 497 * fc_disc_gpn_ft_resp() - Handle a response frame from Get Port Names (GPN_FT) 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 501 * 502 * Locking Note: This function is called without disc mutex held, and 503 * should do all its processing with the mutex held 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; 511 enum fc_disc_event event = DISC_EV_NONE; 512 unsigned int seq_cnt; 513 unsigned int len; 514 int error = 0; 515 516 mutex_lock(&disc->disc_mutex); 517 FC_DISC_DBG(disc, "Received a GPN_FT response\n"); 518 519 if (IS_ERR(fp)) { 520 fc_disc_error(disc, fp); 521 mutex_unlock(&disc->disc_mutex); 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); 529 if (fr_sof(fp) == FC_SOF_I3 && seq_cnt == 0 && disc->seq_count == 0) { 530 cp = fc_frame_payload_get(fp, sizeof(*cp)); 531 if (!cp) { 532 FC_DISC_DBG(disc, "GPN_FT response too short, len %d\n", 533 fr_len(fp)); 534 event = DISC_EV_FAILED; 535 } else if (ntohs(cp->ct_cmd) == FC_FS_ACC) { 536 537 /* Accepted, parse the response. */ 538 len -= sizeof(*cp); 539 error = fc_disc_gpn_ft_parse(disc, cp + 1, len); 540 } else if (ntohs(cp->ct_cmd) == FC_FS_RJT) { 541 FC_DISC_DBG(disc, "GPN_FT rejected reason %x exp %x " 542 "(check zoning)\n", cp->ct_reason, 543 cp->ct_explan); 544 event = DISC_EV_FAILED; 545 if (cp->ct_reason == FC_FS_RJT_UNABL && 546 cp->ct_explan == FC_FS_EXP_FTNR) 547 event = DISC_EV_SUCCESS; 548 } else { 549 FC_DISC_DBG(disc, "GPN_FT unexpected response code " 550 "%x\n", ntohs(cp->ct_cmd)); 551 event = DISC_EV_FAILED; 552 } 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); 555 } else { 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)); 559 event = DISC_EV_FAILED; 560 } 561 if (error) 562 fc_disc_error(disc, fp); 563 else if (event != DISC_EV_NONE) 564 fc_disc_done(disc, event); 565 fc_frame_free(fp); 566 mutex_unlock(&disc->disc_mutex); 567 } 568 569 /** 570 * fc_disc_gpn_id_resp() - Handle a response frame from Get Port Names (GPN_ID) 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 574 * 575 * Locking Note: This function is called without disc mutex held. 576 */ 577 static void fc_disc_gpn_id_resp(struct fc_seq *sp, struct fc_frame *fp, 578 void *rdata_arg) 579 { 580 struct fc_rport_priv *rdata = rdata_arg; 581 struct fc_rport_priv *new_rdata; 582 struct fc_lport *lport; 583 struct fc_disc *disc; 584 struct fc_ct_hdr *cp; 585 struct fc_ns_gid_pn *pn; 586 u64 port_name; 587 588 lport = rdata->local_port; 589 disc = &lport->disc; 590 591 mutex_lock(&disc->disc_mutex); 592 if (PTR_ERR(fp) == -FC_EX_CLOSED) 593 goto out; 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. " 610 "Port-id %6.6x wwpn %llx\n", 611 rdata->ids.port_id, port_name); 612 lport->tt.rport_logoff(rdata); 613 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 } 622 rdata->disc_id = disc->disc_id; 623 lport->tt.rport_login(rdata); 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); 633 } 634 out: 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 641 * @lport: The local port to initiate discovery on 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, 658 fc_disc_gpn_id_resp, rdata, 659 3 * lport->r_a_tov)) 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 667 * @lport: The local port the remote port is associated with 668 * @dp: The port to rediscover 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); 682 } 683 684 /** 685 * fc_disc_stop() - Stop discovery for a given lport 686 * @lport: The local port that discovery should stop on 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 /** 699 * fc_disc_stop_final() - Stop discovery for a given lport 700 * @lport: The lport that discovery should stop on 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 /** 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 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 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; 737 738 return 0; 739 } 740 EXPORT_SYMBOL(fc_disc_init); 741