1 /* 2 * Copyright(c) 2007 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 * PORT LOCKING NOTES 22 * 23 * These comments only apply to the 'port code' which consists of the lport, 24 * disc and rport blocks. 25 * 26 * MOTIVATION 27 * 28 * The lport, disc and rport blocks all have mutexes that are used to protect 29 * those objects. The main motivation for these locks is to prevent from 30 * having an lport reset just before we send a frame. In that scenario the 31 * lport's FID would get set to zero and then we'd send a frame with an 32 * invalid SID. We also need to ensure that states don't change unexpectedly 33 * while processing another state. 34 * 35 * HEIRARCHY 36 * 37 * The following heirarchy defines the locking rules. A greater lock 38 * may be held before acquiring a lesser lock, but a lesser lock should never 39 * be held while attempting to acquire a greater lock. Here is the heirarchy- 40 * 41 * lport > disc, lport > rport, disc > rport 42 * 43 * CALLBACKS 44 * 45 * The callbacks cause complications with this scheme. There is a callback 46 * from the rport (to either lport or disc) and a callback from disc 47 * (to the lport). 48 * 49 * As rports exit the rport state machine a callback is made to the owner of 50 * the rport to notify success or failure. Since the callback is likely to 51 * cause the lport or disc to grab its lock we cannot hold the rport lock 52 * while making the callback. To ensure that the rport is not free'd while 53 * processing the callback the rport callbacks are serialized through a 54 * single-threaded workqueue. An rport would never be free'd while in a 55 * callback handler becuase no other rport work in this queue can be executed 56 * at the same time. 57 * 58 * When discovery succeeds or fails a callback is made to the lport as 59 * notification. Currently, successful discovery causes the lport to take no 60 * action. A failure will cause the lport to reset. There is likely a circular 61 * locking problem with this implementation. 62 */ 63 64 /* 65 * LPORT LOCKING 66 * 67 * The critical sections protected by the lport's mutex are quite broad and 68 * may be improved upon in the future. The lport code and its locking doesn't 69 * influence the I/O path, so excessive locking doesn't penalize I/O 70 * performance. 71 * 72 * The strategy is to lock whenever processing a request or response. Note 73 * that every _enter_* function corresponds to a state change. They generally 74 * change the lports state and then send a request out on the wire. We lock 75 * before calling any of these functions to protect that state change. This 76 * means that the entry points into the lport block manage the locks while 77 * the state machine can transition between states (i.e. _enter_* functions) 78 * while always staying protected. 79 * 80 * When handling responses we also hold the lport mutex broadly. When the 81 * lport receives the response frame it locks the mutex and then calls the 82 * appropriate handler for the particuar response. Generally a response will 83 * trigger a state change and so the lock must already be held. 84 * 85 * Retries also have to consider the locking. The retries occur from a work 86 * context and the work function will lock the lport and then retry the state 87 * (i.e. _enter_* function). 88 */ 89 90 #include <linux/timer.h> 91 #include <asm/unaligned.h> 92 93 #include <scsi/fc/fc_gs.h> 94 95 #include <scsi/libfc.h> 96 #include <scsi/fc_encode.h> 97 #include <linux/scatterlist.h> 98 99 #include "fc_libfc.h" 100 101 /* Fabric IDs to use for point-to-point mode, chosen on whims. */ 102 #define FC_LOCAL_PTP_FID_LO 0x010101 103 #define FC_LOCAL_PTP_FID_HI 0x010102 104 105 #define DNS_DELAY 3 /* Discovery delay after RSCN (in seconds)*/ 106 107 static void fc_lport_error(struct fc_lport *, struct fc_frame *); 108 109 static void fc_lport_enter_reset(struct fc_lport *); 110 static void fc_lport_enter_flogi(struct fc_lport *); 111 static void fc_lport_enter_dns(struct fc_lport *); 112 static void fc_lport_enter_ns(struct fc_lport *, enum fc_lport_state); 113 static void fc_lport_enter_scr(struct fc_lport *); 114 static void fc_lport_enter_ready(struct fc_lport *); 115 static void fc_lport_enter_logo(struct fc_lport *); 116 117 static const char *fc_lport_state_names[] = { 118 [LPORT_ST_DISABLED] = "disabled", 119 [LPORT_ST_FLOGI] = "FLOGI", 120 [LPORT_ST_DNS] = "dNS", 121 [LPORT_ST_RNN_ID] = "RNN_ID", 122 [LPORT_ST_RSNN_NN] = "RSNN_NN", 123 [LPORT_ST_RSPN_ID] = "RSPN_ID", 124 [LPORT_ST_RFT_ID] = "RFT_ID", 125 [LPORT_ST_RFF_ID] = "RFF_ID", 126 [LPORT_ST_SCR] = "SCR", 127 [LPORT_ST_READY] = "Ready", 128 [LPORT_ST_LOGO] = "LOGO", 129 [LPORT_ST_RESET] = "reset", 130 }; 131 132 /** 133 * struct fc_bsg_info - FC Passthrough managemet structure 134 * @job: The passthrough job 135 * @lport: The local port to pass through a command 136 * @rsp_code: The expected response code 137 * @sg: job->reply_payload.sg_list 138 * @nents: job->reply_payload.sg_cnt 139 * @offset: The offset into the response data 140 */ 141 struct fc_bsg_info { 142 struct fc_bsg_job *job; 143 struct fc_lport *lport; 144 u16 rsp_code; 145 struct scatterlist *sg; 146 u32 nents; 147 size_t offset; 148 }; 149 150 /** 151 * fc_frame_drop() - Dummy frame handler 152 * @lport: The local port the frame was received on 153 * @fp: The received frame 154 */ 155 static int fc_frame_drop(struct fc_lport *lport, struct fc_frame *fp) 156 { 157 fc_frame_free(fp); 158 return 0; 159 } 160 161 /** 162 * fc_lport_rport_callback() - Event handler for rport events 163 * @lport: The lport which is receiving the event 164 * @rdata: private remote port data 165 * @event: The event that occured 166 * 167 * Locking Note: The rport lock should not be held when calling 168 * this function. 169 */ 170 static void fc_lport_rport_callback(struct fc_lport *lport, 171 struct fc_rport_priv *rdata, 172 enum fc_rport_event event) 173 { 174 FC_LPORT_DBG(lport, "Received a %d event for port (%6x)\n", event, 175 rdata->ids.port_id); 176 177 mutex_lock(&lport->lp_mutex); 178 switch (event) { 179 case RPORT_EV_READY: 180 if (lport->state == LPORT_ST_DNS) { 181 lport->dns_rdata = rdata; 182 fc_lport_enter_ns(lport, LPORT_ST_RNN_ID); 183 } else { 184 FC_LPORT_DBG(lport, "Received an READY event " 185 "on port (%6x) for the directory " 186 "server, but the lport is not " 187 "in the DNS state, it's in the " 188 "%d state", rdata->ids.port_id, 189 lport->state); 190 lport->tt.rport_logoff(rdata); 191 } 192 break; 193 case RPORT_EV_LOGO: 194 case RPORT_EV_FAILED: 195 case RPORT_EV_STOP: 196 lport->dns_rdata = NULL; 197 break; 198 case RPORT_EV_NONE: 199 break; 200 } 201 mutex_unlock(&lport->lp_mutex); 202 } 203 204 /** 205 * fc_lport_state() - Return a string which represents the lport's state 206 * @lport: The lport whose state is to converted to a string 207 */ 208 static const char *fc_lport_state(struct fc_lport *lport) 209 { 210 const char *cp; 211 212 cp = fc_lport_state_names[lport->state]; 213 if (!cp) 214 cp = "unknown"; 215 return cp; 216 } 217 218 /** 219 * fc_lport_ptp_setup() - Create an rport for point-to-point mode 220 * @lport: The lport to attach the ptp rport to 221 * @remote_fid: The FID of the ptp rport 222 * @remote_wwpn: The WWPN of the ptp rport 223 * @remote_wwnn: The WWNN of the ptp rport 224 */ 225 static void fc_lport_ptp_setup(struct fc_lport *lport, 226 u32 remote_fid, u64 remote_wwpn, 227 u64 remote_wwnn) 228 { 229 mutex_lock(&lport->disc.disc_mutex); 230 if (lport->ptp_rdata) 231 lport->tt.rport_logoff(lport->ptp_rdata); 232 lport->ptp_rdata = lport->tt.rport_create(lport, remote_fid); 233 lport->ptp_rdata->ids.port_name = remote_wwpn; 234 lport->ptp_rdata->ids.node_name = remote_wwnn; 235 mutex_unlock(&lport->disc.disc_mutex); 236 237 lport->tt.rport_login(lport->ptp_rdata); 238 239 fc_lport_enter_ready(lport); 240 } 241 242 /** 243 * fc_get_host_port_type() - Return the port type of the given Scsi_Host 244 * @shost: The SCSI host whose port type is to be determined 245 */ 246 void fc_get_host_port_type(struct Scsi_Host *shost) 247 { 248 /* TODO - currently just NPORT */ 249 fc_host_port_type(shost) = FC_PORTTYPE_NPORT; 250 } 251 EXPORT_SYMBOL(fc_get_host_port_type); 252 253 /** 254 * fc_get_host_port_state() - Return the port state of the given Scsi_Host 255 * @shost: The SCSI host whose port state is to be determined 256 */ 257 void fc_get_host_port_state(struct Scsi_Host *shost) 258 { 259 struct fc_lport *lport = shost_priv(shost); 260 261 mutex_lock(&lport->lp_mutex); 262 if (!lport->link_up) 263 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 264 else 265 switch (lport->state) { 266 case LPORT_ST_READY: 267 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 268 break; 269 default: 270 fc_host_port_state(shost) = FC_PORTSTATE_OFFLINE; 271 } 272 mutex_unlock(&lport->lp_mutex); 273 } 274 EXPORT_SYMBOL(fc_get_host_port_state); 275 276 /** 277 * fc_get_host_speed() - Return the speed of the given Scsi_Host 278 * @shost: The SCSI host whose port speed is to be determined 279 */ 280 void fc_get_host_speed(struct Scsi_Host *shost) 281 { 282 struct fc_lport *lport = shost_priv(shost); 283 284 fc_host_speed(shost) = lport->link_speed; 285 } 286 EXPORT_SYMBOL(fc_get_host_speed); 287 288 /** 289 * fc_get_host_stats() - Return the Scsi_Host's statistics 290 * @shost: The SCSI host whose statistics are to be returned 291 */ 292 struct fc_host_statistics *fc_get_host_stats(struct Scsi_Host *shost) 293 { 294 struct fc_host_statistics *fcoe_stats; 295 struct fc_lport *lport = shost_priv(shost); 296 struct timespec v0, v1; 297 unsigned int cpu; 298 299 fcoe_stats = &lport->host_stats; 300 memset(fcoe_stats, 0, sizeof(struct fc_host_statistics)); 301 302 jiffies_to_timespec(jiffies, &v0); 303 jiffies_to_timespec(lport->boot_time, &v1); 304 fcoe_stats->seconds_since_last_reset = (v0.tv_sec - v1.tv_sec); 305 306 for_each_possible_cpu(cpu) { 307 struct fcoe_dev_stats *stats; 308 309 stats = per_cpu_ptr(lport->dev_stats, cpu); 310 311 fcoe_stats->tx_frames += stats->TxFrames; 312 fcoe_stats->tx_words += stats->TxWords; 313 fcoe_stats->rx_frames += stats->RxFrames; 314 fcoe_stats->rx_words += stats->RxWords; 315 fcoe_stats->error_frames += stats->ErrorFrames; 316 fcoe_stats->invalid_crc_count += stats->InvalidCRCCount; 317 fcoe_stats->fcp_input_requests += stats->InputRequests; 318 fcoe_stats->fcp_output_requests += stats->OutputRequests; 319 fcoe_stats->fcp_control_requests += stats->ControlRequests; 320 fcoe_stats->fcp_input_megabytes += stats->InputMegabytes; 321 fcoe_stats->fcp_output_megabytes += stats->OutputMegabytes; 322 fcoe_stats->link_failure_count += stats->LinkFailureCount; 323 } 324 fcoe_stats->lip_count = -1; 325 fcoe_stats->nos_count = -1; 326 fcoe_stats->loss_of_sync_count = -1; 327 fcoe_stats->loss_of_signal_count = -1; 328 fcoe_stats->prim_seq_protocol_err_count = -1; 329 fcoe_stats->dumped_frames = -1; 330 return fcoe_stats; 331 } 332 EXPORT_SYMBOL(fc_get_host_stats); 333 334 /** 335 * fc_lport_flogi_fill() - Fill in FLOGI command for request 336 * @lport: The local port the FLOGI is for 337 * @flogi: The FLOGI command 338 * @op: The opcode 339 */ 340 static void fc_lport_flogi_fill(struct fc_lport *lport, 341 struct fc_els_flogi *flogi, 342 unsigned int op) 343 { 344 struct fc_els_csp *sp; 345 struct fc_els_cssp *cp; 346 347 memset(flogi, 0, sizeof(*flogi)); 348 flogi->fl_cmd = (u8) op; 349 put_unaligned_be64(lport->wwpn, &flogi->fl_wwpn); 350 put_unaligned_be64(lport->wwnn, &flogi->fl_wwnn); 351 sp = &flogi->fl_csp; 352 sp->sp_hi_ver = 0x20; 353 sp->sp_lo_ver = 0x20; 354 sp->sp_bb_cred = htons(10); /* this gets set by gateway */ 355 sp->sp_bb_data = htons((u16) lport->mfs); 356 cp = &flogi->fl_cssp[3 - 1]; /* class 3 parameters */ 357 cp->cp_class = htons(FC_CPC_VALID | FC_CPC_SEQ); 358 if (op != ELS_FLOGI) { 359 sp->sp_features = htons(FC_SP_FT_CIRO); 360 sp->sp_tot_seq = htons(255); /* seq. we accept */ 361 sp->sp_rel_off = htons(0x1f); 362 sp->sp_e_d_tov = htonl(lport->e_d_tov); 363 364 cp->cp_rdfs = htons((u16) lport->mfs); 365 cp->cp_con_seq = htons(255); 366 cp->cp_open_seq = 1; 367 } 368 } 369 370 /** 371 * fc_lport_add_fc4_type() - Add a supported FC-4 type to a local port 372 * @lport: The local port to add a new FC-4 type to 373 * @type: The new FC-4 type 374 */ 375 static void fc_lport_add_fc4_type(struct fc_lport *lport, enum fc_fh_type type) 376 { 377 __be32 *mp; 378 379 mp = &lport->fcts.ff_type_map[type / FC_NS_BPW]; 380 *mp = htonl(ntohl(*mp) | 1UL << (type % FC_NS_BPW)); 381 } 382 383 /** 384 * fc_lport_recv_rlir_req() - Handle received Registered Link Incident Report. 385 * @sp: The sequence in the RLIR exchange 386 * @fp: The RLIR request frame 387 * @lport: Fibre Channel local port recieving the RLIR 388 * 389 * Locking Note: The lport lock is expected to be held before calling 390 * this function. 391 */ 392 static void fc_lport_recv_rlir_req(struct fc_seq *sp, struct fc_frame *fp, 393 struct fc_lport *lport) 394 { 395 FC_LPORT_DBG(lport, "Received RLIR request while in state %s\n", 396 fc_lport_state(lport)); 397 398 lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL); 399 fc_frame_free(fp); 400 } 401 402 /** 403 * fc_lport_recv_echo_req() - Handle received ECHO request 404 * @sp: The sequence in the ECHO exchange 405 * @fp: ECHO request frame 406 * @lport: The local port recieving the ECHO 407 * 408 * Locking Note: The lport lock is expected to be held before calling 409 * this function. 410 */ 411 static void fc_lport_recv_echo_req(struct fc_seq *sp, struct fc_frame *in_fp, 412 struct fc_lport *lport) 413 { 414 struct fc_frame *fp; 415 struct fc_exch *ep = fc_seq_exch(sp); 416 unsigned int len; 417 void *pp; 418 void *dp; 419 u32 f_ctl; 420 421 FC_LPORT_DBG(lport, "Received ECHO request while in state %s\n", 422 fc_lport_state(lport)); 423 424 len = fr_len(in_fp) - sizeof(struct fc_frame_header); 425 pp = fc_frame_payload_get(in_fp, len); 426 427 if (len < sizeof(__be32)) 428 len = sizeof(__be32); 429 430 fp = fc_frame_alloc(lport, len); 431 if (fp) { 432 dp = fc_frame_payload_get(fp, len); 433 memcpy(dp, pp, len); 434 *((__be32 *)dp) = htonl(ELS_LS_ACC << 24); 435 sp = lport->tt.seq_start_next(sp); 436 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ; 437 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid, 438 FC_TYPE_ELS, f_ctl, 0); 439 lport->tt.seq_send(lport, sp, fp); 440 } 441 fc_frame_free(in_fp); 442 } 443 444 /** 445 * fc_lport_recv_rnid_req() - Handle received Request Node ID data request 446 * @sp: The sequence in the RNID exchange 447 * @fp: The RNID request frame 448 * @lport: The local port recieving the RNID 449 * 450 * Locking Note: The lport lock is expected to be held before calling 451 * this function. 452 */ 453 static void fc_lport_recv_rnid_req(struct fc_seq *sp, struct fc_frame *in_fp, 454 struct fc_lport *lport) 455 { 456 struct fc_frame *fp; 457 struct fc_exch *ep = fc_seq_exch(sp); 458 struct fc_els_rnid *req; 459 struct { 460 struct fc_els_rnid_resp rnid; 461 struct fc_els_rnid_cid cid; 462 struct fc_els_rnid_gen gen; 463 } *rp; 464 struct fc_seq_els_data rjt_data; 465 u8 fmt; 466 size_t len; 467 u32 f_ctl; 468 469 FC_LPORT_DBG(lport, "Received RNID request while in state %s\n", 470 fc_lport_state(lport)); 471 472 req = fc_frame_payload_get(in_fp, sizeof(*req)); 473 if (!req) { 474 rjt_data.fp = NULL; 475 rjt_data.reason = ELS_RJT_LOGIC; 476 rjt_data.explan = ELS_EXPL_NONE; 477 lport->tt.seq_els_rsp_send(sp, ELS_LS_RJT, &rjt_data); 478 } else { 479 fmt = req->rnid_fmt; 480 len = sizeof(*rp); 481 if (fmt != ELS_RNIDF_GEN || 482 ntohl(lport->rnid_gen.rnid_atype) == 0) { 483 fmt = ELS_RNIDF_NONE; /* nothing to provide */ 484 len -= sizeof(rp->gen); 485 } 486 fp = fc_frame_alloc(lport, len); 487 if (fp) { 488 rp = fc_frame_payload_get(fp, len); 489 memset(rp, 0, len); 490 rp->rnid.rnid_cmd = ELS_LS_ACC; 491 rp->rnid.rnid_fmt = fmt; 492 rp->rnid.rnid_cid_len = sizeof(rp->cid); 493 rp->cid.rnid_wwpn = htonll(lport->wwpn); 494 rp->cid.rnid_wwnn = htonll(lport->wwnn); 495 if (fmt == ELS_RNIDF_GEN) { 496 rp->rnid.rnid_sid_len = sizeof(rp->gen); 497 memcpy(&rp->gen, &lport->rnid_gen, 498 sizeof(rp->gen)); 499 } 500 sp = lport->tt.seq_start_next(sp); 501 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ; 502 f_ctl |= FC_FC_END_SEQ | FC_FC_SEQ_INIT; 503 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid, 504 FC_TYPE_ELS, f_ctl, 0); 505 lport->tt.seq_send(lport, sp, fp); 506 } 507 } 508 fc_frame_free(in_fp); 509 } 510 511 /** 512 * fc_lport_recv_logo_req() - Handle received fabric LOGO request 513 * @sp: The sequence in the LOGO exchange 514 * @fp: The LOGO request frame 515 * @lport: The local port recieving the LOGO 516 * 517 * Locking Note: The lport lock is exected to be held before calling 518 * this function. 519 */ 520 static void fc_lport_recv_logo_req(struct fc_seq *sp, struct fc_frame *fp, 521 struct fc_lport *lport) 522 { 523 lport->tt.seq_els_rsp_send(sp, ELS_LS_ACC, NULL); 524 fc_lport_enter_reset(lport); 525 fc_frame_free(fp); 526 } 527 528 /** 529 * fc_fabric_login() - Start the lport state machine 530 * @lport: The local port that should log into the fabric 531 * 532 * Locking Note: This function should not be called 533 * with the lport lock held. 534 */ 535 int fc_fabric_login(struct fc_lport *lport) 536 { 537 int rc = -1; 538 539 mutex_lock(&lport->lp_mutex); 540 if (lport->state == LPORT_ST_DISABLED) { 541 fc_lport_enter_reset(lport); 542 rc = 0; 543 } 544 mutex_unlock(&lport->lp_mutex); 545 546 return rc; 547 } 548 EXPORT_SYMBOL(fc_fabric_login); 549 550 /** 551 * __fc_linkup() - Handler for transport linkup events 552 * @lport: The lport whose link is up 553 * 554 * Locking: must be called with the lp_mutex held 555 */ 556 void __fc_linkup(struct fc_lport *lport) 557 { 558 if (!lport->link_up) { 559 lport->link_up = 1; 560 561 if (lport->state == LPORT_ST_RESET) 562 fc_lport_enter_flogi(lport); 563 } 564 } 565 566 /** 567 * fc_linkup() - Handler for transport linkup events 568 * @lport: The local port whose link is up 569 */ 570 void fc_linkup(struct fc_lport *lport) 571 { 572 printk(KERN_INFO "host%d: libfc: Link up on port (%6x)\n", 573 lport->host->host_no, fc_host_port_id(lport->host)); 574 575 mutex_lock(&lport->lp_mutex); 576 __fc_linkup(lport); 577 mutex_unlock(&lport->lp_mutex); 578 } 579 EXPORT_SYMBOL(fc_linkup); 580 581 /** 582 * __fc_linkdown() - Handler for transport linkdown events 583 * @lport: The lport whose link is down 584 * 585 * Locking: must be called with the lp_mutex held 586 */ 587 void __fc_linkdown(struct fc_lport *lport) 588 { 589 if (lport->link_up) { 590 lport->link_up = 0; 591 fc_lport_enter_reset(lport); 592 lport->tt.fcp_cleanup(lport); 593 } 594 } 595 596 /** 597 * fc_linkdown() - Handler for transport linkdown events 598 * @lport: The local port whose link is down 599 */ 600 void fc_linkdown(struct fc_lport *lport) 601 { 602 printk(KERN_INFO "host%d: libfc: Link down on port (%6x)\n", 603 lport->host->host_no, fc_host_port_id(lport->host)); 604 605 mutex_lock(&lport->lp_mutex); 606 __fc_linkdown(lport); 607 mutex_unlock(&lport->lp_mutex); 608 } 609 EXPORT_SYMBOL(fc_linkdown); 610 611 /** 612 * fc_fabric_logoff() - Logout of the fabric 613 * @lport: The local port to logoff the fabric 614 * 615 * Return value: 616 * 0 for success, -1 for failure 617 */ 618 int fc_fabric_logoff(struct fc_lport *lport) 619 { 620 lport->tt.disc_stop_final(lport); 621 mutex_lock(&lport->lp_mutex); 622 if (lport->dns_rdata) 623 lport->tt.rport_logoff(lport->dns_rdata); 624 mutex_unlock(&lport->lp_mutex); 625 lport->tt.rport_flush_queue(); 626 mutex_lock(&lport->lp_mutex); 627 fc_lport_enter_logo(lport); 628 mutex_unlock(&lport->lp_mutex); 629 cancel_delayed_work_sync(&lport->retry_work); 630 return 0; 631 } 632 EXPORT_SYMBOL(fc_fabric_logoff); 633 634 /** 635 * fc_lport_destroy() - Unregister a fc_lport 636 * @lport: The local port to unregister 637 * 638 * Note: 639 * exit routine for fc_lport instance 640 * clean-up all the allocated memory 641 * and free up other system resources. 642 * 643 */ 644 int fc_lport_destroy(struct fc_lport *lport) 645 { 646 mutex_lock(&lport->lp_mutex); 647 lport->state = LPORT_ST_DISABLED; 648 lport->link_up = 0; 649 lport->tt.frame_send = fc_frame_drop; 650 mutex_unlock(&lport->lp_mutex); 651 652 lport->tt.fcp_abort_io(lport); 653 lport->tt.disc_stop_final(lport); 654 lport->tt.exch_mgr_reset(lport, 0, 0); 655 return 0; 656 } 657 EXPORT_SYMBOL(fc_lport_destroy); 658 659 /** 660 * fc_set_mfs() - Set the maximum frame size for a local port 661 * @lport: The local port to set the MFS for 662 * @mfs: The new MFS 663 */ 664 int fc_set_mfs(struct fc_lport *lport, u32 mfs) 665 { 666 unsigned int old_mfs; 667 int rc = -EINVAL; 668 669 mutex_lock(&lport->lp_mutex); 670 671 old_mfs = lport->mfs; 672 673 if (mfs >= FC_MIN_MAX_FRAME) { 674 mfs &= ~3; 675 if (mfs > FC_MAX_FRAME) 676 mfs = FC_MAX_FRAME; 677 mfs -= sizeof(struct fc_frame_header); 678 lport->mfs = mfs; 679 rc = 0; 680 } 681 682 if (!rc && mfs < old_mfs) 683 fc_lport_enter_reset(lport); 684 685 mutex_unlock(&lport->lp_mutex); 686 687 return rc; 688 } 689 EXPORT_SYMBOL(fc_set_mfs); 690 691 /** 692 * fc_lport_disc_callback() - Callback for discovery events 693 * @lport: The local port receiving the event 694 * @event: The discovery event 695 */ 696 void fc_lport_disc_callback(struct fc_lport *lport, enum fc_disc_event event) 697 { 698 switch (event) { 699 case DISC_EV_SUCCESS: 700 FC_LPORT_DBG(lport, "Discovery succeeded\n"); 701 break; 702 case DISC_EV_FAILED: 703 printk(KERN_ERR "host%d: libfc: " 704 "Discovery failed for port (%6x)\n", 705 lport->host->host_no, fc_host_port_id(lport->host)); 706 mutex_lock(&lport->lp_mutex); 707 fc_lport_enter_reset(lport); 708 mutex_unlock(&lport->lp_mutex); 709 break; 710 case DISC_EV_NONE: 711 WARN_ON(1); 712 break; 713 } 714 } 715 716 /** 717 * fc_rport_enter_ready() - Enter the ready state and start discovery 718 * @lport: The local port that is ready 719 * 720 * Locking Note: The lport lock is expected to be held before calling 721 * this routine. 722 */ 723 static void fc_lport_enter_ready(struct fc_lport *lport) 724 { 725 FC_LPORT_DBG(lport, "Entered READY from state %s\n", 726 fc_lport_state(lport)); 727 728 fc_lport_state_enter(lport, LPORT_ST_READY); 729 if (lport->vport) 730 fc_vport_set_state(lport->vport, FC_VPORT_ACTIVE); 731 fc_vports_linkchange(lport); 732 733 if (!lport->ptp_rdata) 734 lport->tt.disc_start(fc_lport_disc_callback, lport); 735 } 736 737 /** 738 * fc_lport_set_port_id() - set the local port Port ID 739 * @lport: The local port which will have its Port ID set. 740 * @port_id: The new port ID. 741 * @fp: The frame containing the incoming request, or NULL. 742 * 743 * Locking Note: The lport lock is expected to be held before calling 744 * this function. 745 */ 746 static void fc_lport_set_port_id(struct fc_lport *lport, u32 port_id, 747 struct fc_frame *fp) 748 { 749 if (port_id) 750 printk(KERN_INFO "host%d: Assigned Port ID %6x\n", 751 lport->host->host_no, port_id); 752 753 fc_host_port_id(lport->host) = port_id; 754 if (lport->tt.lport_set_port_id) 755 lport->tt.lport_set_port_id(lport, port_id, fp); 756 } 757 758 /** 759 * fc_lport_recv_flogi_req() - Receive a FLOGI request 760 * @sp_in: The sequence the FLOGI is on 761 * @rx_fp: The FLOGI frame 762 * @lport: The local port that recieved the request 763 * 764 * A received FLOGI request indicates a point-to-point connection. 765 * Accept it with the common service parameters indicating our N port. 766 * Set up to do a PLOGI if we have the higher-number WWPN. 767 * 768 * Locking Note: The lport lock is expected to be held before calling 769 * this function. 770 */ 771 static void fc_lport_recv_flogi_req(struct fc_seq *sp_in, 772 struct fc_frame *rx_fp, 773 struct fc_lport *lport) 774 { 775 struct fc_frame *fp; 776 struct fc_frame_header *fh; 777 struct fc_seq *sp; 778 struct fc_exch *ep; 779 struct fc_els_flogi *flp; 780 struct fc_els_flogi *new_flp; 781 u64 remote_wwpn; 782 u32 remote_fid; 783 u32 local_fid; 784 u32 f_ctl; 785 786 FC_LPORT_DBG(lport, "Received FLOGI request while in state %s\n", 787 fc_lport_state(lport)); 788 789 fh = fc_frame_header_get(rx_fp); 790 remote_fid = ntoh24(fh->fh_s_id); 791 flp = fc_frame_payload_get(rx_fp, sizeof(*flp)); 792 if (!flp) 793 goto out; 794 remote_wwpn = get_unaligned_be64(&flp->fl_wwpn); 795 if (remote_wwpn == lport->wwpn) { 796 printk(KERN_WARNING "host%d: libfc: Received FLOGI from port " 797 "with same WWPN %llx\n", 798 lport->host->host_no, remote_wwpn); 799 goto out; 800 } 801 FC_LPORT_DBG(lport, "FLOGI from port WWPN %llx\n", remote_wwpn); 802 803 /* 804 * XXX what is the right thing to do for FIDs? 805 * The originator might expect our S_ID to be 0xfffffe. 806 * But if so, both of us could end up with the same FID. 807 */ 808 local_fid = FC_LOCAL_PTP_FID_LO; 809 if (remote_wwpn < lport->wwpn) { 810 local_fid = FC_LOCAL_PTP_FID_HI; 811 if (!remote_fid || remote_fid == local_fid) 812 remote_fid = FC_LOCAL_PTP_FID_LO; 813 } else if (!remote_fid) { 814 remote_fid = FC_LOCAL_PTP_FID_HI; 815 } 816 817 fc_lport_set_port_id(lport, local_fid, rx_fp); 818 819 fp = fc_frame_alloc(lport, sizeof(*flp)); 820 if (fp) { 821 sp = lport->tt.seq_start_next(fr_seq(rx_fp)); 822 new_flp = fc_frame_payload_get(fp, sizeof(*flp)); 823 fc_lport_flogi_fill(lport, new_flp, ELS_FLOGI); 824 new_flp->fl_cmd = (u8) ELS_LS_ACC; 825 826 /* 827 * Send the response. If this fails, the originator should 828 * repeat the sequence. 829 */ 830 f_ctl = FC_FC_EX_CTX | FC_FC_LAST_SEQ | FC_FC_END_SEQ; 831 ep = fc_seq_exch(sp); 832 fc_fill_fc_hdr(fp, FC_RCTL_ELS_REP, ep->did, ep->sid, 833 FC_TYPE_ELS, f_ctl, 0); 834 lport->tt.seq_send(lport, sp, fp); 835 836 } else { 837 fc_lport_error(lport, fp); 838 } 839 fc_lport_ptp_setup(lport, remote_fid, remote_wwpn, 840 get_unaligned_be64(&flp->fl_wwnn)); 841 842 out: 843 sp = fr_seq(rx_fp); 844 fc_frame_free(rx_fp); 845 } 846 847 /** 848 * fc_lport_recv_req() - The generic lport request handler 849 * @lport: The local port that received the request 850 * @sp: The sequence the request is on 851 * @fp: The request frame 852 * 853 * This function will see if the lport handles the request or 854 * if an rport should handle the request. 855 * 856 * Locking Note: This function should not be called with the lport 857 * lock held becuase it will grab the lock. 858 */ 859 static void fc_lport_recv_req(struct fc_lport *lport, struct fc_seq *sp, 860 struct fc_frame *fp) 861 { 862 struct fc_frame_header *fh = fc_frame_header_get(fp); 863 void (*recv) (struct fc_seq *, struct fc_frame *, struct fc_lport *); 864 865 mutex_lock(&lport->lp_mutex); 866 867 /* 868 * Handle special ELS cases like FLOGI, LOGO, and 869 * RSCN here. These don't require a session. 870 * Even if we had a session, it might not be ready. 871 */ 872 if (!lport->link_up) 873 fc_frame_free(fp); 874 else if (fh->fh_type == FC_TYPE_ELS && 875 fh->fh_r_ctl == FC_RCTL_ELS_REQ) { 876 /* 877 * Check opcode. 878 */ 879 recv = lport->tt.rport_recv_req; 880 switch (fc_frame_payload_op(fp)) { 881 case ELS_FLOGI: 882 recv = fc_lport_recv_flogi_req; 883 break; 884 case ELS_LOGO: 885 fh = fc_frame_header_get(fp); 886 if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI) 887 recv = fc_lport_recv_logo_req; 888 break; 889 case ELS_RSCN: 890 recv = lport->tt.disc_recv_req; 891 break; 892 case ELS_ECHO: 893 recv = fc_lport_recv_echo_req; 894 break; 895 case ELS_RLIR: 896 recv = fc_lport_recv_rlir_req; 897 break; 898 case ELS_RNID: 899 recv = fc_lport_recv_rnid_req; 900 break; 901 } 902 903 recv(sp, fp, lport); 904 } else { 905 FC_LPORT_DBG(lport, "dropping invalid frame (eof %x)\n", 906 fr_eof(fp)); 907 fc_frame_free(fp); 908 } 909 mutex_unlock(&lport->lp_mutex); 910 911 /* 912 * The common exch_done for all request may not be good 913 * if any request requires longer hold on exhange. XXX 914 */ 915 lport->tt.exch_done(sp); 916 } 917 918 /** 919 * fc_lport_reset() - Reset a local port 920 * @lport: The local port which should be reset 921 * 922 * Locking Note: This functions should not be called with the 923 * lport lock held. 924 */ 925 int fc_lport_reset(struct fc_lport *lport) 926 { 927 cancel_delayed_work_sync(&lport->retry_work); 928 mutex_lock(&lport->lp_mutex); 929 fc_lport_enter_reset(lport); 930 mutex_unlock(&lport->lp_mutex); 931 return 0; 932 } 933 EXPORT_SYMBOL(fc_lport_reset); 934 935 /** 936 * fc_lport_reset_locked() - Reset the local port w/ the lport lock held 937 * @lport: The local port to be reset 938 * 939 * Locking Note: The lport lock is expected to be held before calling 940 * this routine. 941 */ 942 static void fc_lport_reset_locked(struct fc_lport *lport) 943 { 944 if (lport->dns_rdata) 945 lport->tt.rport_logoff(lport->dns_rdata); 946 947 lport->ptp_rdata = NULL; 948 949 lport->tt.disc_stop(lport); 950 951 lport->tt.exch_mgr_reset(lport, 0, 0); 952 fc_host_fabric_name(lport->host) = 0; 953 954 if (fc_host_port_id(lport->host)) 955 fc_lport_set_port_id(lport, 0, NULL); 956 } 957 958 /** 959 * fc_lport_enter_reset() - Reset the local port 960 * @lport: The local port to be reset 961 * 962 * Locking Note: The lport lock is expected to be held before calling 963 * this routine. 964 */ 965 static void fc_lport_enter_reset(struct fc_lport *lport) 966 { 967 FC_LPORT_DBG(lport, "Entered RESET state from %s state\n", 968 fc_lport_state(lport)); 969 970 if (lport->vport) { 971 if (lport->link_up) 972 fc_vport_set_state(lport->vport, FC_VPORT_INITIALIZING); 973 else 974 fc_vport_set_state(lport->vport, FC_VPORT_LINKDOWN); 975 } 976 fc_lport_state_enter(lport, LPORT_ST_RESET); 977 fc_vports_linkchange(lport); 978 fc_lport_reset_locked(lport); 979 if (lport->link_up) 980 fc_lport_enter_flogi(lport); 981 } 982 983 /** 984 * fc_lport_enter_disabled() - Disable the local port 985 * @lport: The local port to be reset 986 * 987 * Locking Note: The lport lock is expected to be held before calling 988 * this routine. 989 */ 990 static void fc_lport_enter_disabled(struct fc_lport *lport) 991 { 992 FC_LPORT_DBG(lport, "Entered disabled state from %s state\n", 993 fc_lport_state(lport)); 994 995 fc_lport_state_enter(lport, LPORT_ST_DISABLED); 996 fc_vports_linkchange(lport); 997 fc_lport_reset_locked(lport); 998 } 999 1000 /** 1001 * fc_lport_error() - Handler for any errors 1002 * @lport: The local port that the error was on 1003 * @fp: The error code encoded in a frame pointer 1004 * 1005 * If the error was caused by a resource allocation failure 1006 * then wait for half a second and retry, otherwise retry 1007 * after the e_d_tov time. 1008 */ 1009 static void fc_lport_error(struct fc_lport *lport, struct fc_frame *fp) 1010 { 1011 unsigned long delay = 0; 1012 FC_LPORT_DBG(lport, "Error %ld in state %s, retries %d\n", 1013 PTR_ERR(fp), fc_lport_state(lport), 1014 lport->retry_count); 1015 1016 if (!fp || PTR_ERR(fp) == -FC_EX_TIMEOUT) { 1017 /* 1018 * Memory allocation failure, or the exchange timed out. 1019 * Retry after delay 1020 */ 1021 if (lport->retry_count < lport->max_retry_count) { 1022 lport->retry_count++; 1023 if (!fp) 1024 delay = msecs_to_jiffies(500); 1025 else 1026 delay = msecs_to_jiffies(lport->e_d_tov); 1027 1028 schedule_delayed_work(&lport->retry_work, delay); 1029 } else { 1030 switch (lport->state) { 1031 case LPORT_ST_DISABLED: 1032 case LPORT_ST_READY: 1033 case LPORT_ST_RESET: 1034 case LPORT_ST_RNN_ID: 1035 case LPORT_ST_RSNN_NN: 1036 case LPORT_ST_RSPN_ID: 1037 case LPORT_ST_RFT_ID: 1038 case LPORT_ST_RFF_ID: 1039 case LPORT_ST_SCR: 1040 case LPORT_ST_DNS: 1041 case LPORT_ST_FLOGI: 1042 case LPORT_ST_LOGO: 1043 fc_lport_enter_reset(lport); 1044 break; 1045 } 1046 } 1047 } 1048 } 1049 1050 /** 1051 * fc_lport_ns_resp() - Handle response to a name server 1052 * registration exchange 1053 * @sp: current sequence in exchange 1054 * @fp: response frame 1055 * @lp_arg: Fibre Channel host port instance 1056 * 1057 * Locking Note: This function will be called without the lport lock 1058 * held, but it will lock, call an _enter_* function or fc_lport_error() 1059 * and then unlock the lport. 1060 */ 1061 static void fc_lport_ns_resp(struct fc_seq *sp, struct fc_frame *fp, 1062 void *lp_arg) 1063 { 1064 struct fc_lport *lport = lp_arg; 1065 struct fc_frame_header *fh; 1066 struct fc_ct_hdr *ct; 1067 1068 FC_LPORT_DBG(lport, "Received a ns %s\n", fc_els_resp_type(fp)); 1069 1070 if (fp == ERR_PTR(-FC_EX_CLOSED)) 1071 return; 1072 1073 mutex_lock(&lport->lp_mutex); 1074 1075 if (lport->state < LPORT_ST_RNN_ID || lport->state > LPORT_ST_RFF_ID) { 1076 FC_LPORT_DBG(lport, "Received a name server response, " 1077 "but in state %s\n", fc_lport_state(lport)); 1078 if (IS_ERR(fp)) 1079 goto err; 1080 goto out; 1081 } 1082 1083 if (IS_ERR(fp)) { 1084 fc_lport_error(lport, fp); 1085 goto err; 1086 } 1087 1088 fh = fc_frame_header_get(fp); 1089 ct = fc_frame_payload_get(fp, sizeof(*ct)); 1090 1091 if (fh && ct && fh->fh_type == FC_TYPE_CT && 1092 ct->ct_fs_type == FC_FST_DIR && 1093 ct->ct_fs_subtype == FC_NS_SUBTYPE && 1094 ntohs(ct->ct_cmd) == FC_FS_ACC) 1095 switch (lport->state) { 1096 case LPORT_ST_RNN_ID: 1097 fc_lport_enter_ns(lport, LPORT_ST_RSNN_NN); 1098 break; 1099 case LPORT_ST_RSNN_NN: 1100 fc_lport_enter_ns(lport, LPORT_ST_RSPN_ID); 1101 break; 1102 case LPORT_ST_RSPN_ID: 1103 fc_lport_enter_ns(lport, LPORT_ST_RFT_ID); 1104 break; 1105 case LPORT_ST_RFT_ID: 1106 fc_lport_enter_ns(lport, LPORT_ST_RFF_ID); 1107 break; 1108 case LPORT_ST_RFF_ID: 1109 fc_lport_enter_scr(lport); 1110 break; 1111 default: 1112 /* should have already been caught by state checks */ 1113 break; 1114 } 1115 else 1116 fc_lport_error(lport, fp); 1117 out: 1118 fc_frame_free(fp); 1119 err: 1120 mutex_unlock(&lport->lp_mutex); 1121 } 1122 1123 /** 1124 * fc_lport_scr_resp() - Handle response to State Change Register (SCR) request 1125 * @sp: current sequence in SCR exchange 1126 * @fp: response frame 1127 * @lp_arg: Fibre Channel lport port instance that sent the registration request 1128 * 1129 * Locking Note: This function will be called without the lport lock 1130 * held, but it will lock, call an _enter_* function or fc_lport_error 1131 * and then unlock the lport. 1132 */ 1133 static void fc_lport_scr_resp(struct fc_seq *sp, struct fc_frame *fp, 1134 void *lp_arg) 1135 { 1136 struct fc_lport *lport = lp_arg; 1137 u8 op; 1138 1139 FC_LPORT_DBG(lport, "Received a SCR %s\n", fc_els_resp_type(fp)); 1140 1141 if (fp == ERR_PTR(-FC_EX_CLOSED)) 1142 return; 1143 1144 mutex_lock(&lport->lp_mutex); 1145 1146 if (lport->state != LPORT_ST_SCR) { 1147 FC_LPORT_DBG(lport, "Received a SCR response, but in state " 1148 "%s\n", fc_lport_state(lport)); 1149 if (IS_ERR(fp)) 1150 goto err; 1151 goto out; 1152 } 1153 1154 if (IS_ERR(fp)) { 1155 fc_lport_error(lport, fp); 1156 goto err; 1157 } 1158 1159 op = fc_frame_payload_op(fp); 1160 if (op == ELS_LS_ACC) 1161 fc_lport_enter_ready(lport); 1162 else 1163 fc_lport_error(lport, fp); 1164 1165 out: 1166 fc_frame_free(fp); 1167 err: 1168 mutex_unlock(&lport->lp_mutex); 1169 } 1170 1171 /** 1172 * fc_lport_enter_scr() - Send a SCR (State Change Register) request 1173 * @lport: The local port to register for state changes 1174 * 1175 * Locking Note: The lport lock is expected to be held before calling 1176 * this routine. 1177 */ 1178 static void fc_lport_enter_scr(struct fc_lport *lport) 1179 { 1180 struct fc_frame *fp; 1181 1182 FC_LPORT_DBG(lport, "Entered SCR state from %s state\n", 1183 fc_lport_state(lport)); 1184 1185 fc_lport_state_enter(lport, LPORT_ST_SCR); 1186 1187 fp = fc_frame_alloc(lport, sizeof(struct fc_els_scr)); 1188 if (!fp) { 1189 fc_lport_error(lport, fp); 1190 return; 1191 } 1192 1193 if (!lport->tt.elsct_send(lport, FC_FID_FCTRL, fp, ELS_SCR, 1194 fc_lport_scr_resp, lport, 1195 2 * lport->r_a_tov)) 1196 fc_lport_error(lport, NULL); 1197 } 1198 1199 /** 1200 * fc_lport_enter_ns() - register some object with the name server 1201 * @lport: Fibre Channel local port to register 1202 * 1203 * Locking Note: The lport lock is expected to be held before calling 1204 * this routine. 1205 */ 1206 static void fc_lport_enter_ns(struct fc_lport *lport, enum fc_lport_state state) 1207 { 1208 struct fc_frame *fp; 1209 enum fc_ns_req cmd; 1210 int size = sizeof(struct fc_ct_hdr); 1211 size_t len; 1212 1213 FC_LPORT_DBG(lport, "Entered %s state from %s state\n", 1214 fc_lport_state_names[state], 1215 fc_lport_state(lport)); 1216 1217 fc_lport_state_enter(lport, state); 1218 1219 switch (state) { 1220 case LPORT_ST_RNN_ID: 1221 cmd = FC_NS_RNN_ID; 1222 size += sizeof(struct fc_ns_rn_id); 1223 break; 1224 case LPORT_ST_RSNN_NN: 1225 len = strnlen(fc_host_symbolic_name(lport->host), 255); 1226 /* if there is no symbolic name, skip to RFT_ID */ 1227 if (!len) 1228 return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID); 1229 cmd = FC_NS_RSNN_NN; 1230 size += sizeof(struct fc_ns_rsnn) + len; 1231 break; 1232 case LPORT_ST_RSPN_ID: 1233 len = strnlen(fc_host_symbolic_name(lport->host), 255); 1234 /* if there is no symbolic name, skip to RFT_ID */ 1235 if (!len) 1236 return fc_lport_enter_ns(lport, LPORT_ST_RFT_ID); 1237 cmd = FC_NS_RSPN_ID; 1238 size += sizeof(struct fc_ns_rspn) + len; 1239 break; 1240 case LPORT_ST_RFT_ID: 1241 cmd = FC_NS_RFT_ID; 1242 size += sizeof(struct fc_ns_rft); 1243 break; 1244 case LPORT_ST_RFF_ID: 1245 cmd = FC_NS_RFF_ID; 1246 size += sizeof(struct fc_ns_rff_id); 1247 break; 1248 default: 1249 fc_lport_error(lport, NULL); 1250 return; 1251 } 1252 1253 fp = fc_frame_alloc(lport, size); 1254 if (!fp) { 1255 fc_lport_error(lport, fp); 1256 return; 1257 } 1258 1259 if (!lport->tt.elsct_send(lport, FC_FID_DIR_SERV, fp, cmd, 1260 fc_lport_ns_resp, 1261 lport, 3 * lport->r_a_tov)) 1262 fc_lport_error(lport, fp); 1263 } 1264 1265 static struct fc_rport_operations fc_lport_rport_ops = { 1266 .event_callback = fc_lport_rport_callback, 1267 }; 1268 1269 /** 1270 * fc_rport_enter_dns() - Create a fc_rport for the name server 1271 * @lport: The local port requesting a remote port for the name server 1272 * 1273 * Locking Note: The lport lock is expected to be held before calling 1274 * this routine. 1275 */ 1276 static void fc_lport_enter_dns(struct fc_lport *lport) 1277 { 1278 struct fc_rport_priv *rdata; 1279 1280 FC_LPORT_DBG(lport, "Entered DNS state from %s state\n", 1281 fc_lport_state(lport)); 1282 1283 fc_lport_state_enter(lport, LPORT_ST_DNS); 1284 1285 mutex_lock(&lport->disc.disc_mutex); 1286 rdata = lport->tt.rport_create(lport, FC_FID_DIR_SERV); 1287 mutex_unlock(&lport->disc.disc_mutex); 1288 if (!rdata) 1289 goto err; 1290 1291 rdata->ops = &fc_lport_rport_ops; 1292 lport->tt.rport_login(rdata); 1293 return; 1294 1295 err: 1296 fc_lport_error(lport, NULL); 1297 } 1298 1299 /** 1300 * fc_lport_timeout() - Handler for the retry_work timer 1301 * @work: The work struct of the local port 1302 */ 1303 static void fc_lport_timeout(struct work_struct *work) 1304 { 1305 struct fc_lport *lport = 1306 container_of(work, struct fc_lport, 1307 retry_work.work); 1308 1309 mutex_lock(&lport->lp_mutex); 1310 1311 switch (lport->state) { 1312 case LPORT_ST_DISABLED: 1313 WARN_ON(1); 1314 break; 1315 case LPORT_ST_READY: 1316 WARN_ON(1); 1317 break; 1318 case LPORT_ST_RESET: 1319 break; 1320 case LPORT_ST_FLOGI: 1321 fc_lport_enter_flogi(lport); 1322 break; 1323 case LPORT_ST_DNS: 1324 fc_lport_enter_dns(lport); 1325 break; 1326 case LPORT_ST_RNN_ID: 1327 case LPORT_ST_RSNN_NN: 1328 case LPORT_ST_RSPN_ID: 1329 case LPORT_ST_RFT_ID: 1330 case LPORT_ST_RFF_ID: 1331 fc_lport_enter_ns(lport, lport->state); 1332 break; 1333 case LPORT_ST_SCR: 1334 fc_lport_enter_scr(lport); 1335 break; 1336 case LPORT_ST_LOGO: 1337 fc_lport_enter_logo(lport); 1338 break; 1339 } 1340 1341 mutex_unlock(&lport->lp_mutex); 1342 } 1343 1344 /** 1345 * fc_lport_logo_resp() - Handle response to LOGO request 1346 * @sp: The sequence that the LOGO was on 1347 * @fp: The LOGO frame 1348 * @lp_arg: The lport port that received the LOGO request 1349 * 1350 * Locking Note: This function will be called without the lport lock 1351 * held, but it will lock, call an _enter_* function or fc_lport_error() 1352 * and then unlock the lport. 1353 */ 1354 void fc_lport_logo_resp(struct fc_seq *sp, struct fc_frame *fp, 1355 void *lp_arg) 1356 { 1357 struct fc_lport *lport = lp_arg; 1358 u8 op; 1359 1360 FC_LPORT_DBG(lport, "Received a LOGO %s\n", fc_els_resp_type(fp)); 1361 1362 if (fp == ERR_PTR(-FC_EX_CLOSED)) 1363 return; 1364 1365 mutex_lock(&lport->lp_mutex); 1366 1367 if (lport->state != LPORT_ST_LOGO) { 1368 FC_LPORT_DBG(lport, "Received a LOGO response, but in state " 1369 "%s\n", fc_lport_state(lport)); 1370 if (IS_ERR(fp)) 1371 goto err; 1372 goto out; 1373 } 1374 1375 if (IS_ERR(fp)) { 1376 fc_lport_error(lport, fp); 1377 goto err; 1378 } 1379 1380 op = fc_frame_payload_op(fp); 1381 if (op == ELS_LS_ACC) 1382 fc_lport_enter_disabled(lport); 1383 else 1384 fc_lport_error(lport, fp); 1385 1386 out: 1387 fc_frame_free(fp); 1388 err: 1389 mutex_unlock(&lport->lp_mutex); 1390 } 1391 EXPORT_SYMBOL(fc_lport_logo_resp); 1392 1393 /** 1394 * fc_rport_enter_logo() - Logout of the fabric 1395 * @lport: The local port to be logged out 1396 * 1397 * Locking Note: The lport lock is expected to be held before calling 1398 * this routine. 1399 */ 1400 static void fc_lport_enter_logo(struct fc_lport *lport) 1401 { 1402 struct fc_frame *fp; 1403 struct fc_els_logo *logo; 1404 1405 FC_LPORT_DBG(lport, "Entered LOGO state from %s state\n", 1406 fc_lport_state(lport)); 1407 1408 fc_lport_state_enter(lport, LPORT_ST_LOGO); 1409 fc_vports_linkchange(lport); 1410 1411 fp = fc_frame_alloc(lport, sizeof(*logo)); 1412 if (!fp) { 1413 fc_lport_error(lport, fp); 1414 return; 1415 } 1416 1417 if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, ELS_LOGO, 1418 fc_lport_logo_resp, lport, 1419 2 * lport->r_a_tov)) 1420 fc_lport_error(lport, NULL); 1421 } 1422 1423 /** 1424 * fc_lport_flogi_resp() - Handle response to FLOGI request 1425 * @sp: The sequence that the FLOGI was on 1426 * @fp: The FLOGI response frame 1427 * @lp_arg: The lport port that received the FLOGI response 1428 * 1429 * Locking Note: This function will be called without the lport lock 1430 * held, but it will lock, call an _enter_* function or fc_lport_error() 1431 * and then unlock the lport. 1432 */ 1433 void fc_lport_flogi_resp(struct fc_seq *sp, struct fc_frame *fp, 1434 void *lp_arg) 1435 { 1436 struct fc_lport *lport = lp_arg; 1437 struct fc_frame_header *fh; 1438 struct fc_els_flogi *flp; 1439 u32 did; 1440 u16 csp_flags; 1441 unsigned int r_a_tov; 1442 unsigned int e_d_tov; 1443 u16 mfs; 1444 1445 FC_LPORT_DBG(lport, "Received a FLOGI %s\n", fc_els_resp_type(fp)); 1446 1447 if (fp == ERR_PTR(-FC_EX_CLOSED)) 1448 return; 1449 1450 mutex_lock(&lport->lp_mutex); 1451 1452 if (lport->state != LPORT_ST_FLOGI) { 1453 FC_LPORT_DBG(lport, "Received a FLOGI response, but in state " 1454 "%s\n", fc_lport_state(lport)); 1455 if (IS_ERR(fp)) 1456 goto err; 1457 goto out; 1458 } 1459 1460 if (IS_ERR(fp)) { 1461 fc_lport_error(lport, fp); 1462 goto err; 1463 } 1464 1465 fh = fc_frame_header_get(fp); 1466 did = ntoh24(fh->fh_d_id); 1467 if (fc_frame_payload_op(fp) == ELS_LS_ACC && did != 0) { 1468 flp = fc_frame_payload_get(fp, sizeof(*flp)); 1469 if (flp) { 1470 mfs = ntohs(flp->fl_csp.sp_bb_data) & 1471 FC_SP_BB_DATA_MASK; 1472 if (mfs >= FC_SP_MIN_MAX_PAYLOAD && 1473 mfs < lport->mfs) 1474 lport->mfs = mfs; 1475 csp_flags = ntohs(flp->fl_csp.sp_features); 1476 r_a_tov = ntohl(flp->fl_csp.sp_r_a_tov); 1477 e_d_tov = ntohl(flp->fl_csp.sp_e_d_tov); 1478 if (csp_flags & FC_SP_FT_EDTR) 1479 e_d_tov /= 1000000; 1480 1481 lport->npiv_enabled = !!(csp_flags & FC_SP_FT_NPIV_ACC); 1482 1483 if ((csp_flags & FC_SP_FT_FPORT) == 0) { 1484 if (e_d_tov > lport->e_d_tov) 1485 lport->e_d_tov = e_d_tov; 1486 lport->r_a_tov = 2 * e_d_tov; 1487 fc_lport_set_port_id(lport, did, fp); 1488 printk(KERN_INFO "host%d: libfc: " 1489 "Port (%6x) entered " 1490 "point-to-point mode\n", 1491 lport->host->host_no, did); 1492 fc_lport_ptp_setup(lport, ntoh24(fh->fh_s_id), 1493 get_unaligned_be64( 1494 &flp->fl_wwpn), 1495 get_unaligned_be64( 1496 &flp->fl_wwnn)); 1497 } else { 1498 lport->e_d_tov = e_d_tov; 1499 lport->r_a_tov = r_a_tov; 1500 fc_host_fabric_name(lport->host) = 1501 get_unaligned_be64(&flp->fl_wwnn); 1502 fc_lport_set_port_id(lport, did, fp); 1503 fc_lport_enter_dns(lport); 1504 } 1505 } 1506 } else { 1507 FC_LPORT_DBG(lport, "Bad FLOGI response\n"); 1508 } 1509 1510 out: 1511 fc_frame_free(fp); 1512 err: 1513 mutex_unlock(&lport->lp_mutex); 1514 } 1515 EXPORT_SYMBOL(fc_lport_flogi_resp); 1516 1517 /** 1518 * fc_rport_enter_flogi() - Send a FLOGI request to the fabric manager 1519 * @lport: Fibre Channel local port to be logged in to the fabric 1520 * 1521 * Locking Note: The lport lock is expected to be held before calling 1522 * this routine. 1523 */ 1524 void fc_lport_enter_flogi(struct fc_lport *lport) 1525 { 1526 struct fc_frame *fp; 1527 1528 FC_LPORT_DBG(lport, "Entered FLOGI state from %s state\n", 1529 fc_lport_state(lport)); 1530 1531 fc_lport_state_enter(lport, LPORT_ST_FLOGI); 1532 1533 fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi)); 1534 if (!fp) 1535 return fc_lport_error(lport, fp); 1536 1537 if (!lport->tt.elsct_send(lport, FC_FID_FLOGI, fp, 1538 lport->vport ? ELS_FDISC : ELS_FLOGI, 1539 fc_lport_flogi_resp, lport, 1540 lport->vport ? 2 * lport->r_a_tov : 1541 lport->e_d_tov)) 1542 fc_lport_error(lport, NULL); 1543 } 1544 1545 /** 1546 * fc_lport_config() - Configure a fc_lport 1547 * @lport: The local port to be configured 1548 */ 1549 int fc_lport_config(struct fc_lport *lport) 1550 { 1551 INIT_DELAYED_WORK(&lport->retry_work, fc_lport_timeout); 1552 mutex_init(&lport->lp_mutex); 1553 1554 fc_lport_state_enter(lport, LPORT_ST_DISABLED); 1555 1556 fc_lport_add_fc4_type(lport, FC_TYPE_FCP); 1557 fc_lport_add_fc4_type(lport, FC_TYPE_CT); 1558 1559 return 0; 1560 } 1561 EXPORT_SYMBOL(fc_lport_config); 1562 1563 /** 1564 * fc_lport_init() - Initialize the lport layer for a local port 1565 * @lport: The local port to initialize the exchange layer for 1566 */ 1567 int fc_lport_init(struct fc_lport *lport) 1568 { 1569 if (!lport->tt.lport_recv) 1570 lport->tt.lport_recv = fc_lport_recv_req; 1571 1572 if (!lport->tt.lport_reset) 1573 lport->tt.lport_reset = fc_lport_reset; 1574 1575 fc_host_port_type(lport->host) = FC_PORTTYPE_NPORT; 1576 fc_host_node_name(lport->host) = lport->wwnn; 1577 fc_host_port_name(lport->host) = lport->wwpn; 1578 fc_host_supported_classes(lport->host) = FC_COS_CLASS3; 1579 memset(fc_host_supported_fc4s(lport->host), 0, 1580 sizeof(fc_host_supported_fc4s(lport->host))); 1581 fc_host_supported_fc4s(lport->host)[2] = 1; 1582 fc_host_supported_fc4s(lport->host)[7] = 1; 1583 1584 /* This value is also unchanging */ 1585 memset(fc_host_active_fc4s(lport->host), 0, 1586 sizeof(fc_host_active_fc4s(lport->host))); 1587 fc_host_active_fc4s(lport->host)[2] = 1; 1588 fc_host_active_fc4s(lport->host)[7] = 1; 1589 fc_host_maxframe_size(lport->host) = lport->mfs; 1590 fc_host_supported_speeds(lport->host) = 0; 1591 if (lport->link_supported_speeds & FC_PORTSPEED_1GBIT) 1592 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_1GBIT; 1593 if (lport->link_supported_speeds & FC_PORTSPEED_10GBIT) 1594 fc_host_supported_speeds(lport->host) |= FC_PORTSPEED_10GBIT; 1595 1596 return 0; 1597 } 1598 EXPORT_SYMBOL(fc_lport_init); 1599 1600 /** 1601 * fc_lport_bsg_resp() - The common response handler for FC Passthrough requests 1602 * @sp: The sequence for the FC Passthrough response 1603 * @fp: The response frame 1604 * @info_arg: The BSG info that the response is for 1605 */ 1606 static void fc_lport_bsg_resp(struct fc_seq *sp, struct fc_frame *fp, 1607 void *info_arg) 1608 { 1609 struct fc_bsg_info *info = info_arg; 1610 struct fc_bsg_job *job = info->job; 1611 struct fc_lport *lport = info->lport; 1612 struct fc_frame_header *fh; 1613 size_t len; 1614 void *buf; 1615 1616 if (IS_ERR(fp)) { 1617 job->reply->result = (PTR_ERR(fp) == -FC_EX_CLOSED) ? 1618 -ECONNABORTED : -ETIMEDOUT; 1619 job->reply_len = sizeof(uint32_t); 1620 job->state_flags |= FC_RQST_STATE_DONE; 1621 job->job_done(job); 1622 kfree(info); 1623 return; 1624 } 1625 1626 mutex_lock(&lport->lp_mutex); 1627 fh = fc_frame_header_get(fp); 1628 len = fr_len(fp) - sizeof(*fh); 1629 buf = fc_frame_payload_get(fp, 0); 1630 1631 if (fr_sof(fp) == FC_SOF_I3 && !ntohs(fh->fh_seq_cnt)) { 1632 /* Get the response code from the first frame payload */ 1633 unsigned short cmd = (info->rsp_code == FC_FS_ACC) ? 1634 ntohs(((struct fc_ct_hdr *)buf)->ct_cmd) : 1635 (unsigned short)fc_frame_payload_op(fp); 1636 1637 /* Save the reply status of the job */ 1638 job->reply->reply_data.ctels_reply.status = 1639 (cmd == info->rsp_code) ? 1640 FC_CTELS_STATUS_OK : FC_CTELS_STATUS_REJECT; 1641 } 1642 1643 job->reply->reply_payload_rcv_len += 1644 fc_copy_buffer_to_sglist(buf, len, info->sg, &info->nents, 1645 &info->offset, KM_BIO_SRC_IRQ, NULL); 1646 1647 if (fr_eof(fp) == FC_EOF_T && 1648 (ntoh24(fh->fh_f_ctl) & (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) == 1649 (FC_FC_LAST_SEQ | FC_FC_END_SEQ)) { 1650 if (job->reply->reply_payload_rcv_len > 1651 job->reply_payload.payload_len) 1652 job->reply->reply_payload_rcv_len = 1653 job->reply_payload.payload_len; 1654 job->reply->result = 0; 1655 job->state_flags |= FC_RQST_STATE_DONE; 1656 job->job_done(job); 1657 kfree(info); 1658 } 1659 fc_frame_free(fp); 1660 mutex_unlock(&lport->lp_mutex); 1661 } 1662 1663 /** 1664 * fc_lport_els_request() - Send ELS passthrough request 1665 * @job: The BSG Passthrough job 1666 * @lport: The local port sending the request 1667 * @did: The destination port id 1668 * 1669 * Locking Note: The lport lock is expected to be held before calling 1670 * this routine. 1671 */ 1672 static int fc_lport_els_request(struct fc_bsg_job *job, 1673 struct fc_lport *lport, 1674 u32 did, u32 tov) 1675 { 1676 struct fc_bsg_info *info; 1677 struct fc_frame *fp; 1678 struct fc_frame_header *fh; 1679 char *pp; 1680 int len; 1681 1682 fp = fc_frame_alloc(lport, job->request_payload.payload_len); 1683 if (!fp) 1684 return -ENOMEM; 1685 1686 len = job->request_payload.payload_len; 1687 pp = fc_frame_payload_get(fp, len); 1688 1689 sg_copy_to_buffer(job->request_payload.sg_list, 1690 job->request_payload.sg_cnt, 1691 pp, len); 1692 1693 fh = fc_frame_header_get(fp); 1694 fh->fh_r_ctl = FC_RCTL_ELS_REQ; 1695 hton24(fh->fh_d_id, did); 1696 hton24(fh->fh_s_id, fc_host_port_id(lport->host)); 1697 fh->fh_type = FC_TYPE_ELS; 1698 hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ | 1699 FC_FC_END_SEQ | FC_FC_SEQ_INIT); 1700 fh->fh_cs_ctl = 0; 1701 fh->fh_df_ctl = 0; 1702 fh->fh_parm_offset = 0; 1703 1704 info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL); 1705 if (!info) { 1706 fc_frame_free(fp); 1707 return -ENOMEM; 1708 } 1709 1710 info->job = job; 1711 info->lport = lport; 1712 info->rsp_code = ELS_LS_ACC; 1713 info->nents = job->reply_payload.sg_cnt; 1714 info->sg = job->reply_payload.sg_list; 1715 1716 if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp, 1717 NULL, info, tov)) 1718 return -ECOMM; 1719 return 0; 1720 } 1721 1722 /** 1723 * fc_lport_ct_request() - Send CT Passthrough request 1724 * @job: The BSG Passthrough job 1725 * @lport: The local port sending the request 1726 * @did: The destination FC-ID 1727 * @tov: The timeout period to wait for the response 1728 * 1729 * Locking Note: The lport lock is expected to be held before calling 1730 * this routine. 1731 */ 1732 static int fc_lport_ct_request(struct fc_bsg_job *job, 1733 struct fc_lport *lport, u32 did, u32 tov) 1734 { 1735 struct fc_bsg_info *info; 1736 struct fc_frame *fp; 1737 struct fc_frame_header *fh; 1738 struct fc_ct_req *ct; 1739 size_t len; 1740 1741 fp = fc_frame_alloc(lport, sizeof(struct fc_ct_hdr) + 1742 job->request_payload.payload_len); 1743 if (!fp) 1744 return -ENOMEM; 1745 1746 len = job->request_payload.payload_len; 1747 ct = fc_frame_payload_get(fp, len); 1748 1749 sg_copy_to_buffer(job->request_payload.sg_list, 1750 job->request_payload.sg_cnt, 1751 ct, len); 1752 1753 fh = fc_frame_header_get(fp); 1754 fh->fh_r_ctl = FC_RCTL_DD_UNSOL_CTL; 1755 hton24(fh->fh_d_id, did); 1756 hton24(fh->fh_s_id, fc_host_port_id(lport->host)); 1757 fh->fh_type = FC_TYPE_CT; 1758 hton24(fh->fh_f_ctl, FC_FC_FIRST_SEQ | 1759 FC_FC_END_SEQ | FC_FC_SEQ_INIT); 1760 fh->fh_cs_ctl = 0; 1761 fh->fh_df_ctl = 0; 1762 fh->fh_parm_offset = 0; 1763 1764 info = kzalloc(sizeof(struct fc_bsg_info), GFP_KERNEL); 1765 if (!info) { 1766 fc_frame_free(fp); 1767 return -ENOMEM; 1768 } 1769 1770 info->job = job; 1771 info->lport = lport; 1772 info->rsp_code = FC_FS_ACC; 1773 info->nents = job->reply_payload.sg_cnt; 1774 info->sg = job->reply_payload.sg_list; 1775 1776 if (!lport->tt.exch_seq_send(lport, fp, fc_lport_bsg_resp, 1777 NULL, info, tov)) 1778 return -ECOMM; 1779 return 0; 1780 } 1781 1782 /** 1783 * fc_lport_bsg_request() - The common entry point for sending 1784 * FC Passthrough requests 1785 * @job: The BSG passthrough job 1786 */ 1787 int fc_lport_bsg_request(struct fc_bsg_job *job) 1788 { 1789 struct request *rsp = job->req->next_rq; 1790 struct Scsi_Host *shost = job->shost; 1791 struct fc_lport *lport = shost_priv(shost); 1792 struct fc_rport *rport; 1793 struct fc_rport_priv *rdata; 1794 int rc = -EINVAL; 1795 u32 did; 1796 1797 job->reply->reply_payload_rcv_len = 0; 1798 rsp->resid_len = job->reply_payload.payload_len; 1799 1800 mutex_lock(&lport->lp_mutex); 1801 1802 switch (job->request->msgcode) { 1803 case FC_BSG_RPT_ELS: 1804 rport = job->rport; 1805 if (!rport) 1806 break; 1807 1808 rdata = rport->dd_data; 1809 rc = fc_lport_els_request(job, lport, rport->port_id, 1810 rdata->e_d_tov); 1811 break; 1812 1813 case FC_BSG_RPT_CT: 1814 rport = job->rport; 1815 if (!rport) 1816 break; 1817 1818 rdata = rport->dd_data; 1819 rc = fc_lport_ct_request(job, lport, rport->port_id, 1820 rdata->e_d_tov); 1821 break; 1822 1823 case FC_BSG_HST_CT: 1824 did = ntoh24(job->request->rqst_data.h_ct.port_id); 1825 if (did == FC_FID_DIR_SERV) 1826 rdata = lport->dns_rdata; 1827 else 1828 rdata = lport->tt.rport_lookup(lport, did); 1829 1830 if (!rdata) 1831 break; 1832 1833 rc = fc_lport_ct_request(job, lport, did, rdata->e_d_tov); 1834 break; 1835 1836 case FC_BSG_HST_ELS_NOLOGIN: 1837 did = ntoh24(job->request->rqst_data.h_els.port_id); 1838 rc = fc_lport_els_request(job, lport, did, lport->e_d_tov); 1839 break; 1840 } 1841 1842 mutex_unlock(&lport->lp_mutex); 1843 return rc; 1844 } 1845 EXPORT_SYMBOL(fc_lport_bsg_request); 1846