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