1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #ifndef _FCPVAR_H 27 #define _FCPVAR_H 28 29 #ifdef __cplusplus 30 extern "C" { 31 #endif 32 33 #include <sys/types.h> 34 35 /* 36 * Maximum number of times FCP will re-issue a REPORTS_LUNS command if the 37 * device couldn't return all of them in the submitted buffer. 38 */ 39 #define FCP_MAX_REPORTLUNS_ATTEMPTS 2 40 /* 41 * Maximum number of LUNs supported. This limit is enforced to accommodate 42 * certain HBAs. 43 */ 44 #define FCP_MAX_LUNS_SUPPORTED 65535 45 46 /* 47 * Stuff to be defined in fc_ulpif.h FIXIT 48 */ 49 #define PORT_DEVICE_CREATE 0x40 50 #define SCMD_REPORT_LUN 0xa0 /* SCSI cmd to report on LUNs */ 51 #define SCMD_INQUIRY_LWWN_SIZE 32 /* Max WWN size */ 52 #define SCMD_INQUIRY_PAGE83 0xF0 /* Internal opcode for page 0x83 */ 53 #define FC4_SCSI_FCP 0x08 /* our (SCSI) FC4 type number */ 54 55 #define FCP_QUEUE_DELAY (4) 56 #define FCP_FAILED_DELAY 20 57 #define FCP_RESET_DELAY 3 /* target reset delay of 3 secs */ 58 #define FCP_OFFLINE_DELAY 20 /* 20 seconds is 2*RA_TOV_els */ 59 60 /* 61 * Highest possible timeout value to indicate 62 * the watch thread to return the I/O 63 */ 64 #define FCP_INVALID_TIMEOUT (0xFFFFFFFF) 65 66 /* 67 * The max inquiry page 83 size as expected in the code today 68 * is 0xf0 bytes. Defining a constant to make it easy incase 69 * this needs to be changed at a later time. 70 */ 71 #define SCMD_MAX_INQUIRY_PAGE83_SIZE 0xF0 72 /* 73 * Events generated for Target drivers; "SUNW,sf:" prefix 74 * is a legacy fcal stuff hardcoded into ssd via the use of 75 * FCAL_INSERT_EVENT defined in an fcal header file; We 76 * just need to continue to use this. 77 */ 78 #define FCAL_INSERT_EVENT "SUNW,sf:DEVICE-INSERTION.1" 79 #define FCAL_REMOVE_EVENT "SUNW,sf:DEVICE-REMOVAL.1" 80 81 /* 82 * for debug trace 83 */ 84 #define FCP_STACK_DEPTH 14 85 86 87 /* 88 * All the stuff above needs to move intp appropriate header files. 89 */ 90 91 #define FCP_NUM_HASH 128 92 93 #define FCP_HASH(x) ((x[0] + x[1] + x[2] + x[3] +\ 94 x[4] + x[5] + x[6] + x[7]) & \ 95 (FCP_NUM_HASH-1)) 96 97 #define FCP_STATEC_MASK (FC_STATE_OFFLINE | FC_STATE_ONLINE |\ 98 FC_STATE_LOOP | FC_STATE_NAMESERVICE |\ 99 FC_STATE_RESET |\ 100 FC_STATE_RESET_REQUESTED |\ 101 FC_STATE_LIP | FC_STATE_DEVICE_CHANGE) 102 103 #define PKT_PRIV_SIZE 2 104 105 #ifdef KSTATS_CODE 106 /* 107 * fcp_stats : Statistics provided for fcp. 108 */ 109 struct fcp_stats { 110 uint_t version; /* version of this struct */ 111 uint_t lip_count; /* lips forced by fcp */ 112 uint_t link_reset_count; /* lip failures, ie, no ONLINE */ 113 /* response after forcing lip */ 114 uint_t ncmds; /* outstanding commands */ 115 uint_t throttle_limit; /* current throttle limit */ 116 char drvr_name[MAXNAMELEN]; /* Name of driver, NULL term. */ 117 }; 118 #endif 119 120 /* 121 * Structure fcp_port 122 * -------------------- 123 * 124 * This structure is the FCP representation of an N_Port on a local FC HBA card. 125 * This is the master structure off of which all the others will be hanging at 126 * some point and is the Solaris per-instance soft-state structure. 127 */ 128 typedef struct fcp_port { 129 /* 130 * This mutex protects the access to this structure (or most of its 131 * fields). 132 */ 133 kmutex_t port_mutex; 134 /* 135 * This is the link to the next fcp_port structure in the global 136 * list. The head of the global list is fcp_port_head and is 137 * defined in fcp.c. This field is NULL for the last element of 138 * the global list. 139 */ 140 struct fcp_port *port_next; 141 /* 142 * This field points to the head of a list of internal requests that 143 * will be retried later. Examples of internal requests are: 144 * 'Send a PRLI ELS', 'Send a PRLO ELS', 'Send a PLOGI ELS' or 145 * 'Send an Inquiry command'. If the submission of the request to the 146 * fp/fctl module failed (for a set of specific reasons) and the 147 * request can be resubmitted later, it is queued here. The watchdog 148 * timer (fcp_watch()) will walk this queue and resubmit the requests. 149 */ 150 struct fcp_ipkt *port_ipkt_list; 151 /* 152 * This seems to be used as a temporary device counter during a 153 * discovery process (or reconfiguration as some comments put it). 154 * It seems to be initialized in fcp_statec_callback() with the 155 * number of devices that fp/fctl saw after the line came up and 156 * is supposed to reached zero when the reconfiguration process is 157 * over. 158 */ 159 int port_tmp_cnt; 160 /* 161 * This is supposed to indicate the state of this port. It is a 162 * bitmap which means several bits can be set simultaneously. The list 163 * of the different bits and their meaning is given further down in 164 * this file. 165 */ 166 uint32_t port_state; 167 /* 168 * This field is initialized at the very end of the function 169 * fcp_handle_port_attach() if the attachment of the port was 170 * successful. It is set to the value stored in lbolt64 at the 171 * time of the attachment. This value is only used in the function 172 * fcp_scsi_bus_config(). It is used to determine the value of the 173 * parameter timeout when ndi_busop_bus_config() and cv_wait() are 174 * called. It actually serves to figure out how long the enumeration 175 * can be delayed (the max value being FCP_INIT_WAIT_TIMEOUT). 176 */ 177 int64_t port_attach_time; 178 /* 179 * This field contains the topology of the SAN the port is connected 180 * to. 181 */ 182 uint32_t port_topology; 183 /* 184 * This field contains the local port ID. It is provided by fp/fctl 185 * when calling fcp_statec_callback() and fcp_port_attach(). This 186 * value is used to build Fibre Channel headers (like for PLOGI or 187 * PRLI). 188 */ 189 uint32_t port_id; 190 /* 191 * This field keeps track of the physical port state (fcp_port being 192 * more like the FCP software port state). The information stored here 193 * is provided by fp/fctl except in two instances: in 194 * fcp_handle_port_attach() and fcp_handle_port_resume(). The values 195 * this field can take are defined in fctl.h. 196 */ 197 uint32_t port_phys_state; 198 /* 199 * This field points to the first element of a list of fcp_reset_elem 200 * structures. Those structures are created when the target driver 201 * calls fcp_reset_target(). The target or the LUN specified by the 202 * target driver is reset by sending a Task Management command. After 203 * the response has been received, a fcp_reset_elem structure is 204 * queued here and will remain queued for FCP_RESET_DELAY. While 205 * the fcp_reset_elem structure is in this queue the LUNs of 206 * the target to reset or the LUN to reset is set to LUN_BUSY state. 207 * In fcp_watch() the timeout is tested. If the timout has expired, 208 * the fcp_reset_elem structure is unqueued and freed, and all the 209 * active commands for the target or LUNs are aborted. 210 */ 211 struct fcp_reset_elem *port_reset_list; 212 /* 213 * This points to the first element of a list of fcp_tgt_elem 214 * structures. This list is a list of targets to offline. The list 215 * is walked in fcp_watch(). After the target is offlined the 216 * structure fcp_tgt_elem is freed. 217 */ 218 struct fcp_tgt_elem *port_offline_tgts; 219 /* 220 * This points to the first element of a list of fcp_lun_elem 221 * structures. This list is a list of LUNs to offline. The list 222 * is walked in fcp_watch(). After the lun is offlined the 223 * structure fcp_lun_elem is freed. 224 */ 225 struct fcp_lun_elem *port_offline_luns; 226 /* 227 * This field is a counter initialized to 1 when the port attaches. 228 * It is incremented when the line goes from online to offline and 229 * vice versa. It is also incremented when the port detaches. The 230 * value stored in this counter is used as a reference in time of the 231 * link state. For example, when the line comes up internal requests 232 * are generated (fcp_ipkt) such as PRLI and INQUIRY. Those requests 233 * are tagged with the value contained in this field at the time the 234 * request is built. When the callback for the request is called, the 235 * current value of port_link_cnt is checked against the one set in 236 * the internal request structure. If they don't match, it means the 237 * the request is not relevant anymore to the current line state and 238 * must be discarded (in between a request is issued and the callback 239 * routine is called the line may have bounced). This is the way FCP 240 * identifies the requests that were hanging out when the state of the 241 * line changed. 242 */ 243 uint32_t port_link_cnt; 244 /* 245 * This field, as its name suggests, specifies a deadline for the 246 * overall discovery process. It is initialized in three cases: 247 * 248 * 1) When the line goes from the offline state to the online state. 249 * 2) When the FP/FCTL called fcp_statec_callback() indicating that 250 * a notification was received from the fabric indicating that a new 251 * port showed up or that one disappeared. 252 * 3) In the fcp_create_on_demand() function (called because of an 253 * ioctl). 254 * 255 * In all instances it is set to: 256 * 257 * fcp_watchdog_time + FCP_ICMD_DEADLINE 258 * 259 * In all those instances a discovery process is started or extended 260 * (2). The value stored in port_deadline is only checked in one 261 * function: fcp_is_retryable(). That function checks if an 262 * internal command (fcp_ipkt) is retryable or not. Usually 263 * there's a counter that limits the number of times a command is 264 * retried (Max value is FCP_MAX_RETRIES). However, even if the 265 * counter hasn't exceeded that value, the command will not be retried 266 * past the deadline. This means that the discovery process has to 267 * be finished before port_deadline. In other words, an internal 268 * command retry capability is limited numerically and in time. 269 */ 270 int port_deadline; 271 /* 272 * This is the Node WWN of the local port. It is initialized 273 * during the port attachment. 274 */ 275 la_wwn_t port_nwwn; 276 /* 277 * This is the Port WWN of the local port. It is initialized during 278 * the port attachment. 279 */ 280 la_wwn_t port_pwwn; 281 /* 282 * This is the fp/fctl port handle. 283 */ 284 opaque_t *port_fp_handle; 285 /* 286 * The following 4 fields handle the queue of fcp_pkt outstanding for 287 * this port. 288 * 289 * port_pkt_mutex Protects the access to the queue 290 * port_pkt_head Points to the head of the queue 291 * port_pkt_tail Points to the tail of the queue 292 * port_npkts Number of commands outstanding (used only when 293 * DEBUG is defined). 294 */ 295 kmutex_t port_pkt_mutex; 296 uint32_t port_npkts; 297 struct fcp_pkt *port_pkt_head; 298 struct fcp_pkt *port_pkt_tail; 299 /* 300 * This field is the counter of allocated and currently active 301 * fcp_ipkt. 302 */ 303 int port_ipkt_cnt; 304 /* 305 * Port instance provided by FP/FCTL. It is actually deduced using 306 * ddi_get_instance() in fcp_port_attach(). 307 */ 308 uint32_t port_instance; 309 /* 310 * Maximum number of exchanges the underlying physical FibreChannel 311 * port can handle. This field is initialized during the port 312 * attachment but is never used. 313 */ 314 uint32_t port_max_exch; 315 /* 316 * This port stores the behavior expected of the underlying FCA driver 317 * when a port reset occurs. The values stored here are defined in the 318 * file fc_types.h. 319 */ 320 fc_reset_action_t port_reset_action; 321 /* 322 * This port stores the DMA behavior of the underlying FCA driver. It 323 * is checked only once in fcp_prepare_pkt() and, as the comment 324 * suggests, to work around an issue with an Intel PCI bridge. 325 */ 326 fc_dma_behavior_t port_cmds_dma_flags; 327 /* 328 * The value stored here indicates if the underlying FCA driver 329 * supports DMA transfers with non SCSI data (Ex: PRLI request). 330 */ 331 fc_fcp_dma_t port_fcp_dma; 332 /* 333 * This field contains the size of the private space required by the 334 * underlying FCA driver in a FibreChannel packet (fc_packet_t). 335 */ 336 uint32_t port_priv_pkt_len; 337 /* 338 * This field contains the port's modlink info. It is provided by 339 * FP/FCTL during the port attachment. 340 */ 341 struct modlinkage port_fp_modlinkage; 342 /* 343 * DMA attributes for data packets, commands and responses. 344 */ 345 ddi_dma_attr_t port_data_dma_attr; 346 ddi_dma_attr_t port_cmd_dma_attr; 347 ddi_dma_attr_t port_resp_dma_attr; 348 ddi_device_acc_attr_t port_dma_acc_attr; 349 /* 350 * Field containing the hba_tran structure registered with SCSA. 351 */ 352 struct scsi_hba_tran *port_tran; 353 /* 354 * Device info structure provided by fp/fctl when the port attaches and 355 * representing the local physical fibre channel port. 356 */ 357 dev_info_t *port_dip; 358 /* 359 * Head of the list of callback routines to call when a bus reset 360 * occurs. This list is populated by the targets drivers by calling 361 * fcp_scsi_reset_notify() (tran_reset_notify(9E)). 362 */ 363 struct scsi_reset_notify_entry *port_reset_notify_listf; 364 /* 365 * for framework event management 366 */ 367 ndi_event_definition_t *port_ndi_event_defs; 368 ndi_event_hdl_t port_ndi_event_hdl; 369 ndi_event_set_t port_ndi_events; 370 /* 371 * hash lists of targets attached to this port. The hashing is based 372 * on the WWN. 373 */ 374 struct fcp_tgt *port_tgt_hash_table[FCP_NUM_HASH]; 375 /* 376 * per-Port control flag. By default mpxio is enabled on ports unless 377 * explicitly disabled through driver.conf. 378 */ 379 int port_mpxio; 380 /* 381 * Value used as a flag to determine if the throttling has been 382 * set/initialized in the FCA driver. 383 */ 384 int port_notify; 385 /* 386 * This field contains a string initialized at attachment time and used 387 * when calling the function the function fc_trace_debug() (through 388 * the macro FCP_TRACE and FCP_DTRACE) to identify the port that 389 * logged the message. 390 */ 391 char port_instbuf[24]; 392 uchar_t port_boot_wwn[FC_WWN_SIZE]; 393 394 #ifdef DEBUG 395 /* 396 * Use once in fcp_finish_init() when calling getpcstack(). 397 */ 398 int port_finish_depth; 399 pc_t port_finish_stack[FCP_STACK_DEPTH]; 400 #endif /* DEBUG */ 401 /* 402 * Condition variable used during the bus enumeration process. 403 */ 404 kcondvar_t port_config_cv; 405 /* 406 * Size (in bytes) required to hold the cookies of a scatter/gather 407 * list. 408 */ 409 int port_dmacookie_sz; 410 } fcp_port_t; 411 412 /* 413 * We need to save the target change count values in a map tag so as 414 * to uniquely identify the cause and handle it better as they change 415 * counts are bound to change upon receiving more state changes. 416 */ 417 typedef int fcp_map_tag_t; 418 419 /* 420 * fcp_state definitions. 421 */ 422 #define FCP_STATE_INIT 0x0001 423 #define FCP_STATE_OFFLINE 0x0002 424 #define FCP_STATE_ONLINE 0x0004 425 #define FCP_STATE_SUSPENDED 0x0008 426 #define FCP_STATE_POWER_DOWN 0x0010 427 #define FCP_STATE_ONLINING 0x0020 428 #define FCP_STATE_DETACHING 0x0040 429 #define FCP_STATE_IN_WATCHDOG 0x0080 430 #define FCP_STATE_IN_MDI 0x0100 /* Not in S8/S9 */ 431 #define FCP_STATE_NS_REG_FAILED 0x0200 /* Diff value from S8/S9 */ 432 /* 433 * FCP_STATE_IN_CB_DEVC indicates that we're handling a state change 434 * notification that will be changing the state of devices. This is an 435 * indication to fcp_scsi_start that the target's status might change. 436 */ 437 #define FCP_STATE_IN_CB_DEVC 0x0400 438 439 /* 440 * FCP_STATE_FCA_IS_NODMA indicates that FCA doesn't support DMA at all 441 */ 442 #define FCP_STATE_FCA_IS_NODMA 0x80000000 443 444 #define FCP_MAX_DEVICES 127 445 446 /* To remember that dip was allocated for a lun on this target. */ 447 448 #define FCP_DEVICE_CREATED 0x1 449 450 #define FCP_EVENT_TAG_INSERT 0 451 #define FCP_EVENT_TAG_REMOVE 1 452 453 /* 454 * fcp_pkt: FCP packet 455 * --------------------- 456 * 457 * This structure is the one initialized/created in the tran_init_pkt(9E). It 458 * embeds the fc_packet structure eventually passed to fp/fctl as well as 459 * the scsi_pkt returned by tran_init_pkt(9E) to the target driver. There is 460 * a 1-to-1 correlation between the scsi_pkt, the fcp_pkt and the 461 * fc_packet. 462 * 463 * This is what a fcp_pkt looks like after allocation: 464 * 465 * +================================+ 466 * +---> | struct scsi_pkt | 467 * | | | 468 * | +--- | pkt_ha_private | 469 * | | | | 470 * | | +================================+ 471 * | | 472 * | | +================================+ 473 * | +--> | struct fcp_pkt | <---------+ 474 * +----- | cmd_pkt | | 475 * | cmd_fp_pkt | ---+ | 476 * +--------->| cmd_fcp_rsp[] | | | 477 * | +------->| cmd_fcp_cmd[] | | | 478 * | | |--------------------------------| | | 479 * | | | struct fc_packet | <--+ | 480 * | | | | | 481 * | | | pkt_ulp_private | ----------+ 482 * | | | pkt_fca_private | -----+ 483 * | | | pkt_data_cookie | ---+ | 484 * | | | pkt_cmdlen | | | 485 * | |(a) | pkt_rsplen | | | 486 * | +--------| .......... pkt_cmd ........... | ---|-|-------+ 487 * | (a) | pkt_cmd_cookie | ---|-|-----+ | 488 * +----------| .......... pkt_resp .......... | ---|-|---+ | | 489 * | pkt_resp_cookie | ---|-|-+ | | | 490 * | pkt_cmd_dma | | | | | | | 491 * | pkt_cmd_acc | | | | | | | 492 * +================================+ | | | | | | 493 * | dma_cookies | <--+ | | | | | 494 * | | | | | | | 495 * +================================+ | | | | | 496 * | fca_private | <----+ | | | | 497 * | | | | | | 498 * +================================+ | | | | 499 * | | | | 500 * | | | | 501 * +================================+ (b) | | | | 502 * | fcp_resp cookies | <------+ | | | 503 * | | | | | 504 * +================================+ | | | 505 * | | | 506 * +================================+ (b) | | | 507 * | fcp_resp | <--------+ | | 508 * | (DMA resources associated) | | | 509 * +================================+ | | 510 * | | 511 * | | 512 * | | 513 * +================================+ (b) | | 514 * | fcp_cmd cookies | <----------+ | 515 * | | | 516 * +================================+ | 517 * | 518 * +================================+ (b) | 519 * | fcp_cmd | <------------+ 520 * | (DMA resources associated) | 521 * +================================+ 522 * 523 * 524 * (a) The underlying FCA does NOT support DMA for this field 525 * (b) The underlying FCA supports DMA for this field 526 */ 527 typedef struct fcp_pkt { 528 /* 529 * The two following fields are used to queue fcp_pkt in the double 530 * link list of the lun structure. The packet is queued in 531 * tran_init_pkt(9E) and unqueued in tran_destroy_pkt(9E). 532 */ 533 struct fcp_pkt *cmd_forw; 534 struct fcp_pkt *cmd_back; 535 /* 536 * This field is used to queue the packet in the single link list of the 537 * port structure. The port keeps a list of all the commands issued 538 * through it and scans it, for example, when all of those commands 539 * have to be aborted. 540 */ 541 struct fcp_pkt *cmd_next; 542 /* 543 * This field points back to the scsi_pkt. 544 */ 545 struct scsi_pkt *cmd_pkt; 546 /* 547 * This field points to the field cmd_fc_packet defined further in this 548 * same structure. 549 */ 550 struct fc_packet *cmd_fp_pkt; 551 /* 552 * Structure where the FCP_CMD information unit is going to be built. 553 */ 554 fcp_cmd_t cmd_fcp_cmd; 555 /* 556 * State of the packet. The values for the state seem to indicate 557 * that it isn't a bitmap. However, in several instances the code 558 * treats it as a bitmap doing a "&= ~FCP_PKT_ISSUED" to it 559 * eventhough the value stored is always checked using "!=" and "==". 560 */ 561 uint_t cmd_state; 562 /* 563 * This field is a bitmap indicating if 564 * the cmd is queued 565 */ 566 uint_t cmd_flags; 567 /* Contains the number of bytes DMA mappped. */ 568 uint_t cmd_dmacount; 569 /* 570 * Contains the timeout value for the packet. This is not a delay or 571 * a delta but an absolute value. 572 */ 573 uint_t cmd_timeout; 574 /* 575 * This array is used to store the FCP_RSP information unit returned by 576 * the device when the underlying FCA cannot DMA it in. 577 */ 578 char cmd_fcp_rsp[FCP_MAX_RSP_IU_SIZE]; 579 /* 580 * This is the fc_packet structure used to forward the request to 581 * fp/fctl. 582 */ 583 struct fc_packet cmd_fc_packet; 584 } fcp_pkt_t; 585 586 /* 587 * fcp_ipkt : Packet for internal commands. 588 * ------------------------------------------ 589 * 590 * +================================+ 591 * | struct fcp_ipkt | <---------+ 592 * | (kmem_zalloc()) | | 593 * | ipkt_fpkt | ---+ | 594 * | | | | 595 * | ipkt_cmdlen = cmd_len | | | 596 * | | | | 597 * | | | | 598 * | | | | 599 * |--------------------------------| | | 600 * | struct fc_packet | <--+ | 601 * | | | 602 * | pkt_ulp_private | ----------+ 603 * | pkt_fca_private | -----+ 604 * | pkt_data_cookie | ---+ | 605 * | pkt_cmdlen | | | 606 * | pkt_rsplen | | | 607 * | pkt_cmd ...................... | ---|-|-------+ 608 * | pkt_cmd_cookie | ---|-|-----+ | 609 * | pkt_resp ..................... | ---|-|---+ | | 610 * | pkt_resp_cookie | ---|-|-+ | | | 611 * | pkt_cmd_dma | | | | | | | 612 * | pkt_cmd_acc | | | | | | | 613 * +================================+ | | | | | | 614 * | dma_cookies | <--+ | | | | | 615 * | | | | | | | 616 * | | | | | | | 617 * | | | | | | | 618 * +================================+ | | | | | 619 * | fca_private | <----+ | | | | 620 * | | | | | | 621 * | | | | | | 622 * | | | | | | 623 * +================================+ | | | | 624 * | | | | 625 * | | | | 626 * +================================+ (b) | | | | 627 * | fcp_resp cookies | <------+ | | | 628 * | | | | | 629 * +================================+ | | | 630 * | | | 631 * +================================+ (b) | | | 632 * | fcp_resp | <--------+ | | 633 * | (DMA resources associated) | | | 634 * +================================+ | | 635 * | | 636 * | | 637 * | | 638 * +================================+ (b) | | 639 * | fcp_cmd cookies | <----------+ | 640 * | | | 641 * +================================+ | 642 * | 643 * +================================+ (b) | 644 * | fcp_cmd | <------------+ 645 * | (DMA resources associated) | 646 * +================================+ 647 * 648 * (a) The underlying FCA does NOT support DMA for this field 649 * (b) The underlying FCA supports DMA for this field 650 */ 651 typedef struct fcp_ipkt { 652 /* 653 * Pointer to the port (fcp_port) in behalf of which this internal 654 * packet was allocated. 655 */ 656 struct fcp_port *ipkt_port; 657 /* 658 * Pointer to the target (fcp_tgt) in behalf of which this internal 659 * packet was allocated. 660 */ 661 struct fcp_tgt *ipkt_tgt; 662 /* 663 * Pointer to the lun (fcp_lun) in behalf of which this internal 664 * packet was allocated. This field is only meaningful when the 665 * internal packet has been allocated for a "scsi passthru" command or 666 * for an internal SCSI command such as REPORT LUNs and INQUIRY. 667 */ 668 struct fcp_lun *ipkt_lun; 669 /* 670 * Fields used to queue the internal packet into the double linked list 671 * of the FCP port (fcp_port). 672 */ 673 struct fcp_ipkt *ipkt_next; 674 struct fcp_ipkt *ipkt_prev; 675 /* 676 * This field points to the field ipkt_fc_packet defined farther in 677 * this same structure. 678 */ 679 struct fc_packet *ipkt_fpkt; 680 /* 681 * This is the timeout value for the internal packet. It seems to 682 * increase with the number of retries. It is initialized like this 683 * in the code: 684 * 685 * icmd->ipkt_restart = fcp_watchdog_time + icmd->ipkt_retries++ 686 * 687 * First time ipkt_retries is zero. As it increases, the timeout 688 * value for the internal packet also increases. 689 */ 690 uint32_t ipkt_restart; 691 /* 692 * Link state counter when the internal packet was built. 693 */ 694 uint32_t ipkt_link_cnt; 695 int ipkt_cause; 696 uint32_t ipkt_cmdlen; 697 uint32_t ipkt_resplen; 698 uint32_t ipkt_datalen; 699 /* 700 * Counter of the times an internal packet has been retried. Its 701 * value is checked against FCP_MAX_RETRIES. 702 */ 703 uint32_t ipkt_retries; 704 uint32_t ipkt_change_cnt; 705 int ipkt_nodma; 706 /* 707 * Semaphore used to wait for completion on. 708 */ 709 ksema_t ipkt_sema; 710 /* 711 * Opcode indicating what internal command the packet contains (PLOGI, 712 * PRLI, INQUIRY...). 713 */ 714 uchar_t ipkt_opcode; 715 /* 716 * FC packet. 717 */ 718 struct fc_packet ipkt_fc_packet; 719 } fcp_ipkt_t; 720 721 /* 722 * cmd_state definitions 723 */ 724 #define FCP_PKT_IDLE 0x1 725 #define FCP_PKT_ISSUED 0x2 726 #define FCP_PKT_ABORTING 0x3 727 728 /* 729 * These are the defined cmd_flags for this structure. 730 */ 731 #define CFLAG_NONE 0x0000 732 #define CFLAG_IS_READ 0x0001 733 #define CFLAG_IN_QUEUE 0x0002 /* command in fcp queue */ 734 735 /* 736 * Target structure 737 * ---------------- 738 * 739 * This structure holds the information relative to a SCSI target. This 740 * structure doesn't represent the object registered with the OS (NDI or 741 * MPxIO...). 742 */ 743 typedef struct fcp_tgt { 744 /* 745 * This field is used to queue the target structure in one of the 746 * buckets of the fcp_port target hash table port_tgt_hash_table[]. 747 */ 748 struct fcp_tgt *tgt_next; 749 /* Points to the fcp_port the target belongs to. */ 750 struct fcp_port *tgt_port; 751 /* 752 * This field is a bitmap indicating the state of the target. Several 753 * bits can be set simultaneously. 754 */ 755 uint32_t tgt_state; 756 /* 757 * State controlling if the LUNs attached to this target will be 758 * automatically onlined or not. 759 */ 760 uint32_t tgt_node_state; 761 /* 762 * Mutex protecting this structure. 763 */ 764 kmutex_t tgt_mutex; 765 /* 766 * List of LUNs (single link list). 767 */ 768 struct fcp_lun *tgt_lun; 769 opaque_t tgt_fca_dev; 770 /* 771 * Number of LUNs in this target. 772 */ 773 uint_t tgt_lun_cnt; 774 /* 775 * Counter of LUNs to probe. It is used during the discovery 776 * process. Starts with the number of LUNs returned by REPORT_LUN 777 * and is decremented until it reaches zero. 778 */ 779 uint_t tgt_tmp_cnt; 780 /* 781 * fp/fctl handle for the "port_device". 782 */ 783 opaque_t tgt_pd_handle; 784 /* 785 * Node World Wide Name. 786 */ 787 la_wwn_t tgt_node_wwn; 788 /* 789 * Port World Wide Name. 790 */ 791 la_wwn_t tgt_port_wwn; 792 /* 793 * Fibre Channel Port ID. 794 */ 795 uint32_t tgt_d_id; 796 /* 797 * Fibre Channel Port ID. Uses bit fields to represent it. 798 */ 799 uint32_t tgt_hard_addr; 800 /* 801 * Becomes 1 when the LUNs are created. 802 */ 803 uchar_t tgt_device_created; 804 /* 805 * Counter of how many REPORT_LUN commands were sent. It is used to 806 * allow the REPORT_LUN command to be sent twice in case the buffer 807 * allocated the first time wasn't big enough. 808 */ 809 uchar_t tgt_report_lun_cnt; 810 /* 811 * This field is incremented each time the field tgt_state is updated. 812 * Its use is similar to the use of the field port_link_cnt in the 813 * fcp_port structure. The internal packets are, for example, tagged 814 * with the value stored here. 815 */ 816 uint32_t tgt_change_cnt; 817 /* 818 * This field contains the cause of the last change in state. 819 */ 820 int tgt_statec_cause; 821 /* 822 * The following two fields indicate whether the remote port is an 823 * FCP initiator or an FCP target. They are treated as booleans. 824 */ 825 uchar_t tgt_icap; /* Initiator */ 826 uchar_t tgt_tcap; /* Target */ 827 #ifdef DEBUG 828 /* 829 * Updated in fcp_call_finish_init_held() when DEBUG is defined 830 */ 831 int tgt_tmp_cnt_depth; 832 pc_t tgt_tmp_cnt_stack[FCP_STACK_DEPTH]; 833 #endif /* DEBUG */ 834 /* 835 * This field holds the timer id of the timer started when a LUN 836 * reconfiguration is needed for the target. The reconfiguration 837 * is done in the timeout function. 838 */ 839 timeout_id_t tgt_tid; 840 int tgt_done; 841 /* 842 * Bitmap used to trace the discovery process. 843 */ 844 uint32_t tgt_trace; 845 /* 846 * This field is used when the code is sorting out which devices 847 * were known which ones are new and which ones went away. 848 */ 849 uint32_t tgt_aux_state; 850 /* 851 * Number of internal packets allocated in behalf of the target. 852 */ 853 int tgt_ipkt_cnt; 854 /* 855 * used to detect user unconfig when auto configuration is enabled. 856 */ 857 uint32_t tgt_manual_config_only; 858 } fcp_tgt_t; 859 860 /* 861 * Target States 862 */ 863 #define FCP_TGT_INIT 0x01 864 #define FCP_TGT_BUSY 0x02 865 #define FCP_TGT_MARK 0x04 866 #define FCP_TGT_OFFLINE 0x08 867 #define FCP_TGT_ORPHAN 0x80 868 #define FCP_TGT_ILLREQ 0x10 869 870 /* 871 * Target Aux Stat 872 */ 873 #define FCP_TGT_TAGGED 0x01 874 875 /* 876 * Target discovery tracing 877 */ 878 #define FCP_TGT_TRACE_1 0x00000001 879 #define FCP_TGT_TRACE_2 0x00000002 880 #define FCP_TGT_TRACE_3 0x00000004 881 #define FCP_TGT_TRACE_4 0x00000008 882 #define FCP_TGT_TRACE_5 0x00000010 883 #define FCP_TGT_TRACE_6 0x00000020 884 #define FCP_TGT_TRACE_7 0x00000040 885 #define FCP_TGT_TRACE_8 0x00000080 886 #define FCP_TGT_TRACE_9 0x00000100 887 #define FCP_TGT_TRACE_10 0x00000200 888 #define FCP_TGT_TRACE_11 0x00000400 889 #define FCP_TGT_TRACE_12 0x00000800 890 #define FCP_TGT_TRACE_13 0x00001000 891 #define FCP_TGT_TRACE_14 0x00002000 892 #define FCP_TGT_TRACE_15 0x00004000 893 #define FCP_TGT_TRACE_16 0x00008000 894 #define FCP_TGT_TRACE_17 0x00010000 895 #define FCP_TGT_TRACE_18 0x00020000 896 #define FCP_TGT_TRACE_19 0x00040000 897 #define FCP_TGT_TRACE_20 0x00080000 898 #define FCP_TGT_TRACE_21 0x00100000 899 #define FCP_TGT_TRACE_22 0x00200000 900 #define FCP_TGT_TRACE_23 0x00400000 901 #define FCP_TGT_TRACE_24 0x00800000 902 #define FCP_TGT_TRACE_25 0x01000000 903 #define FCP_TGT_TRACE_26 0x02000000 904 #define FCP_TGT_TRACE_27 0x04000000 905 #define FCP_TGT_TRACE_28 0x08000000 906 #define FCP_TGT_TRACE_29 0x10000000 907 908 #ifndef __lock_lint 909 910 #define FCP_TGT_TRACE(ptgt, tcount, bit) {\ 911 if (ptgt) {\ 912 if (ptgt->tgt_change_cnt == tcount) {\ 913 ptgt->tgt_trace |= bit;\ 914 }\ 915 }\ 916 } 917 918 #else /* __lock_lint */ 919 920 #define FCP_TGT_TRACE(ptgt, tcount, bit) 921 922 #endif /* __lock_lint */ 923 924 925 /* 926 * state change cause 927 */ 928 #define FCP_CAUSE_TGT_CHANGE 0x01 929 #define FCP_CAUSE_LINK_CHANGE 0x02 930 #define FCP_CAUSE_LINK_DOWN 0x04 931 #define FCP_CAUSE_USER_CREATE 0x08 932 933 934 /* 935 * Target node states (applicable to LUNs behind the target) 936 */ 937 #define FCP_TGT_NODE_NONE 0x00 /* No node exists */ 938 #define FCP_TGT_NODE_ON_DEMAND 0x01 /* create only upon request */ 939 #define FCP_TGT_NODE_PRESENT 0x02 /* Node exists; rediscover it */ 940 941 942 #define FCP_NO_CHANGE 0x1 943 #define FCP_LINK_CHANGE 0x2 944 #define FCP_DEV_CHANGE 0x3 945 946 947 /* hotplug event struct */ 948 struct fcp_hp_event { 949 int (*callback)(); 950 void *arg; 951 }; 952 953 /* 954 * We talk to both NDI and MDI framework to enumerate our child devices. 955 * We internally define a generic child handle and assign either dev_info 956 * or mdi_pathinfo handle depending on the device. 957 */ 958 typedef void *child_info_t; 959 960 #define CIP(child) ((child_info_t *)(child)) 961 #define DIP(child) ((dev_info_t *)(child)) 962 #define PIP(child) ((mdi_pathinfo_t *)(child)) 963 964 /* 965 * LUN structure 966 * ------------- 967 * 968 * This structure holds the information relative to a SCSI LUN. This 969 * structure is the one representing the object registered with the OS (NDI 970 * or MPxIO...). 971 */ 972 typedef struct fcp_lun { 973 /* 974 * Mutex protecting the access to this structure. 975 */ 976 kmutex_t lun_mutex; 977 /* 978 * Logical unit number. It is a SCSI3 format. 979 */ 980 fcp_ent_addr_t lun_addr; 981 /* 982 * The two following fields are respectively the head and tail of a 983 * double link list of fcp_packets. It is populated in 984 * tran_init_pkt(9E) (fcp_scsi_init_pkt) and emptied in 985 * tran_destroy_pkt(9E) (fcp_scsi_destroy_pkt). 986 */ 987 struct fcp_pkt *lun_pkt_head; 988 struct fcp_pkt *lun_pkt_tail; 989 /* 990 * This field is treated like a union. It may contain the dev_info_t 991 * or the mdi_pathinfo_t depending on how the device associated with 992 * this LUN was registered. 993 */ 994 child_info_t *lun_cip; 995 /* 996 * Online/Offline event count. 997 */ 998 int lun_event_count; 999 /* 1000 * Back pointer to the target the LUN belongs to. 1001 */ 1002 struct fcp_tgt *lun_tgt; 1003 /* 1004 * Bit map reflecting the state of the LUN. 1005 */ 1006 uint_t lun_state; 1007 /* 1008 * LUN type (disk, tape...). The value stored here is taken from the 1009 * inquiry data. 1010 */ 1011 uchar_t lun_type; 1012 /* 1013 * This field is incremented each time fcp_scsi_tgt_init() 1014 * (tran_tgt_init(9E)) is called and decremented each time 1015 * fcp_scsi_tgt_free() (tran_tgt_free(9E)) is called. The 1016 * incrementation and decrementation will also have an effect on 1017 * lun_state bit FCP_SCSI_LUN_TGT_INIT. 1018 */ 1019 uchar_t lun_tgt_count; 1020 /* 1021 * LUN number as it is returned by REPORT_LUNS. 1022 */ 1023 uint16_t lun_num; 1024 /* 1025 * Pointer to the next LUN. 1026 */ 1027 struct fcp_lun *lun_next; 1028 /* 1029 * lun level association with scsi_device 1030 */ 1031 struct scsi_device *lun_sd; 1032 /* 1033 * per-Lun control flag. A value of '1' means the LUN is managed by 1034 * mpxio. A value of '0' means the LUN has been physically enumerated 1035 * as a child of corresponding port driver node. 1036 */ 1037 int lun_mpxio; 1038 /* 1039 * Length of the GUID. 1040 */ 1041 size_t lun_guid_size; 1042 /* 1043 * Pointer to a buffer that contains the GUID. 1044 */ 1045 char *lun_guid; 1046 /* 1047 * Pointer to a buffer that contains the old GUID. 1048 */ 1049 char *lun_old_guid; 1050 /* 1051 * Length of the old GUID 1052 */ 1053 size_t lun_old_guid_size; 1054 /* 1055 * Bitmap used to track the LUN discovery process. 1056 */ 1057 uint32_t lun_trace; 1058 /* 1059 * Bitmap representing the SCSI capabilities. 1060 */ 1061 uchar_t lun_cap; 1062 /* 1063 * LUN inquiry data (as returned by the INQUIRY command). 1064 */ 1065 struct scsi_inquiry lun_inq; 1066 } fcp_lun_t; 1067 1068 1069 /* 1070 * Lun discovery tracing 1071 */ 1072 #define FCP_LUN_TRACE_1 0x0000001 1073 #define FCP_LUN_TRACE_2 0x0000002 1074 #define FCP_LUN_TRACE_3 0x0000004 1075 #define FCP_LUN_TRACE_4 0x0000008 1076 #define FCP_LUN_TRACE_5 0x0000010 1077 #define FCP_LUN_TRACE_6 0x0000020 1078 #define FCP_LUN_TRACE_7 0x0000040 1079 #define FCP_LUN_TRACE_8 0x0000080 1080 #define FCP_LUN_TRACE_9 0x0000100 1081 #define FCP_LUN_TRACE_10 0x0000200 1082 #define FCP_LUN_TRACE_11 0x0000400 1083 #define FCP_LUN_TRACE_12 0x0000800 1084 #define FCP_LUN_TRACE_13 0x0001000 1085 #define FCP_LUN_TRACE_14 0x0002000 1086 #define FCP_LUN_TRACE_15 0x0004000 1087 #define FCP_LUN_TRACE_16 0x0008000 1088 #define FCP_LUN_TRACE_17 0x0010000 1089 #define FCP_LUN_TRACE_18 0x0020000 1090 #define FCP_LUN_TRACE_19 0x0040000 1091 #define FCP_LUN_TRACE_20 0x0080000 1092 #define FCP_LUN_TRACE_21 0x0100000 1093 #define FCP_LUN_TRACE_22 0x0200000 1094 #define FCP_LUN_TRACE_23 0x0400000 1095 #define FCP_LUN_TRACE_24 0x0800000 1096 #define FCP_LUN_TRACE_25 0x1000000 1097 #define FCP_LUN_TRACE_26 0x2000000 1098 #define FCP_LUN_TRACE_27 0x4000000 1099 #define FCP_LUN_TRACE_28 0x8000000 1100 1101 1102 #define FCP_LUN_TRACE(plun, bit) {\ 1103 if (plun && plun->lun_tgt) {\ 1104 mutex_enter(&plun->lun_tgt->tgt_mutex);\ 1105 plun->lun_trace |= bit;\ 1106 mutex_exit(&plun->lun_tgt->tgt_mutex);\ 1107 }\ 1108 } 1109 1110 #define FCP_LUN_CAP_RESET 0x01 1111 1112 /* 1113 * Lun State -- these have the same values as the target states so 1114 * that they can be interchanged (in cases where the same state occurs 1115 * for both targets and luns) 1116 */ 1117 1118 #define FCP_LUN_INIT FCP_TGT_INIT 1119 #define FCP_LUN_BUSY FCP_TGT_BUSY 1120 #define FCP_LUN_MARK FCP_TGT_MARK 1121 #define FCP_LUN_OFFLINE FCP_TGT_OFFLINE 1122 #define FCP_SCSI_LUN_TGT_INIT 0x20 /* target/LUNs all inited */ 1123 #define FCP_LUN_DISAPPEARED 0x40 1124 /* 1125 * Use the below flag with caution as it is can cause a delay in 1126 * fcp_scsi_start() which is in the normal I/O performance path 1127 */ 1128 #define FCP_LUN_ONLINING 0x80 1129 /* 1130 * Set the below flag when the DTYPE or GUID of a LUN changes during discovery 1131 */ 1132 #define FCP_LUN_CHANGED 0x100 1133 /* 1134 * This flag is used specifically for the special lun: lun 0. 1135 */ 1136 #define FCP_LUN_DEVICE_NOT_CONNECTED 0x200 1137 1138 /* 1139 * Report Lun Format 1140 */ 1141 struct fcp_reportlun_resp { 1142 uint32_t num_lun; /* num LUNs * 8 */ 1143 uint32_t reserved; 1144 longlong_t lun_string[1]; 1145 }; 1146 1147 /* 1148 * This structure actually represents a request executed by the hot plug task. 1149 */ 1150 struct fcp_hp_elem { 1151 /* 1152 * FCP port concerned by the request. 1153 */ 1154 struct fcp_port *port; 1155 /* 1156 * LUN concerned by the request. 1157 */ 1158 struct fcp_lun *lun; 1159 /* 1160 * dev_info_t or mdi_pathinfo_t pointer. 1161 */ 1162 child_info_t *cip; 1163 /* 1164 * lun_mpxio when the event is submitted 1165 */ 1166 int old_lun_mpxio; 1167 /* 1168 * What to do (offline, online...). 1169 */ 1170 int what; 1171 /* 1172 * FLags used when calling NDI fucntions. 1173 */ 1174 int flags; 1175 /* 1176 * Link state change count when the structure was created. 1177 */ 1178 int link_cnt; 1179 /* 1180 * Target state change count when the structure was created. 1181 */ 1182 int tgt_cnt; 1183 /* 1184 * Online/Offline count when this event was queued. 1185 */ 1186 int event_cnt; 1187 /* 1188 * This is the flag protected by the mutex and condition variable 1189 * defined further in this structure. It is the flag indicating 1190 * that the hot plug task is done with the treatment of the structure. 1191 */ 1192 int wait; 1193 /* 1194 * This is where the result of the request is returned when the sender 1195 * waits for the completion. 1196 */ 1197 int result; 1198 /* 1199 * Condition variable used when wait is true. 1200 */ 1201 kcondvar_t cv; 1202 /* 1203 * Mutex used in conjunction with the previous condition variable. 1204 */ 1205 kmutex_t mutex; 1206 }; 1207 1208 1209 struct fcp_reset_elem { 1210 struct fcp_reset_elem *next; 1211 struct fcp_tgt *tgt; 1212 struct fcp_lun *lun; 1213 clock_t timeout; 1214 uint_t tgt_cnt; 1215 }; 1216 1217 /* 1218 * This structure is used to offline targets. It is queued in the FCP port 1219 * structure single linked list port_offline_tgts and walked by the watchdog 1220 * timer. 1221 */ 1222 struct fcp_tgt_elem { 1223 /* 1224 * Points to the next element of the list. 1225 */ 1226 struct fcp_tgt_elem *next; 1227 /* 1228 * Points to the target to offline. 1229 */ 1230 struct fcp_tgt *ptgt; 1231 /* 1232 * Absolute time after which the target must be offlined. 1233 */ 1234 int time; 1235 /* 1236 * Link state change count when the structure was created. 1237 */ 1238 int link_cnt; 1239 /* 1240 * Target state change count when the structure was created. 1241 */ 1242 int tgt_cnt; 1243 /* 1244 * Flags providing information for the offline (when calling mdi or 1245 * ndi). 1246 */ 1247 int flags; 1248 }; 1249 1250 /* 1251 * This structure is used to offline LUNs. It is queued in the FCP port 1252 * structure single linked list port_offline_luns and walked by the watchdog 1253 * timer. 1254 */ 1255 struct fcp_lun_elem { 1256 /* 1257 * Points to the next element of the list. 1258 */ 1259 struct fcp_lun_elem *next; 1260 /* 1261 * Points to the LUN to offline. 1262 */ 1263 struct fcp_lun *plun; 1264 /* 1265 * Absolute time after which the LUN must be offlined. 1266 */ 1267 int time; 1268 /* 1269 * Link state change count when the structure was created. 1270 */ 1271 int link_cnt; 1272 /* 1273 * Target state change count when the structure was created. 1274 */ 1275 int tgt_cnt; 1276 /* 1277 * Flags providing information for the offline (when calling mdi or 1278 * ndi). 1279 */ 1280 int flags; 1281 }; 1282 1283 /* 1284 * LUN masking 1285 */ 1286 typedef struct fcp_black_list_entry { 1287 /* 1288 * Points to the next element of the list. 1289 */ 1290 struct fcp_black_list_entry *next; 1291 /* 1292 * Port WWN of the target. 1293 */ 1294 la_wwn_t wwn; 1295 /* 1296 * LUN number which need to be masked. 1297 */ 1298 uint32_t lun; 1299 /* 1300 * Counter of access times. 1301 */ 1302 int masked; 1303 } fcp_black_list_entry_t; 1304 1305 #define ADDR2FCP(ap) ((struct fcp_port *) \ 1306 ((ap)->a_hba_tran->tran_hba_private)) 1307 #define ADDR2LUN(ap) ((struct fcp_lun *) \ 1308 scsi_device_hba_private_get(scsi_address_device(ap))) 1309 #define CMD2PKT(cmd) ((cmd)->cmd_pkt) 1310 #define PKT2CMD(pkt) ((struct fcp_pkt *)((pkt)->pkt_ha_private)) 1311 1312 /* 1313 * timeout values 1314 */ 1315 #define FCP_ELS_TIMEOUT 20 /* 20 seconds */ 1316 #define FCP_SCSI_CMD_TIMEOUT 25 /* 30 seconds */ 1317 #define FCP_POLL_TIMEOUT 60 /* 60 seconds */ 1318 #define FCP_TIMEOUT_DELTA 2 /* 2 seconds */ 1319 #define FCP_ICMD_DEADLINE 120 /* 60 seconds */ 1320 #define FCP_MAX_RETRIES 4 1321 1322 1323 #if !defined(__lint) 1324 _NOTE(MUTEX_PROTECTS_DATA(fcp_port::port_mutex, 1325 fcp_port::port_state fcp_tgt::tgt_change_cnt 1326 fcp_port::fcp_next fcp_port::port_tgt_hash_table 1327 fcp_port::port_link_cnt fcp_port::port_reset_list 1328 fcp_port::port_tmp_cnt fcp_port::port_ipkt_list 1329 fcp_tgt::tgt_next)) 1330 1331 _NOTE(MUTEX_PROTECTS_DATA(fcp_port::port_pkt_mutex, 1332 fcp_port::port_pkt_head fcp_port::port_pkt_tail 1333 fcp_port::port_npkts)) 1334 1335 _NOTE(MUTEX_PROTECTS_DATA(fcp_tgt::tgt_mutex, 1336 fcp_tgt::tgt_state fcp_tgt::tgt_device_created 1337 fcp_tgt::tgt_icap fcp_tgt::tgt_tcap 1338 fcp_tgt::tgt_tid fcp_tgt::tgt_pd_handle fcp_tgt::tgt_tmp_cnt 1339 fcp_tgt::tgt_statec_cause fcp_lun::lun_next fcp_lun::lun_state)) 1340 1341 _NOTE(LOCK_ORDER(fcp_port::fcp_mutex fcp_tgt::tgt_mutex)) 1342 _NOTE(LOCK_ORDER(fcp_tgt::tgt_mutex fcp_lun::lun_mutex)) 1343 1344 _NOTE(MUTEX_PROTECTS_DATA(fcp_lun::lun_mutex, 1345 fcp_lun::lun_pkt_head fcp_lun::lun_pkt_tail 1346 fcp_lun::lun_cip fcp_lun::lun_mpxio)) 1347 1348 _NOTE(DATA_READABLE_WITHOUT_LOCK( fcp_tgt::tgt_state)) 1349 _NOTE(DATA_READABLE_WITHOUT_LOCK( fcp_tgt::tgt_pd_handle)) 1350 1351 _NOTE(DATA_READABLE_WITHOUT_LOCK(fcp_tgt::tgt_tid)) 1352 1353 1354 _NOTE(SCHEME_PROTECTS_DATA("Safe Data", 1355 fcp_port::port_dma_acc_attr 1356 fcp_port::port_fcp_dma fcp_port::fcp_tran 1357 fcp_port::port_ndi_events fcp_port::port_ndi_event_defs 1358 fcp_port::port_pkt_cache fcp_port::port_dip fcp_port::port_phys_state 1359 fcp_port::port_reset_action fcp_port::port_cmds_dma_flags 1360 fcp_port::port_fp_handle fcp_port::port_instance 1361 fcp_port::port_fp_modlinkage fcp_port::port_max_exch 1362 fcp_port::port_priv_pkt_len fcp_port::port_id 1363 fcp_port::port_topology fcp_port::port_deadline fcp_port::port_mpxio 1364 fcp_tgt::tgt_d_id fcp_tgt::tgt_hard_addr fcp_tgt::tgt_lun_cnt 1365 fcp_tgt::tgt_port fcp_lun::lun_num fcp_lun::lun_tgt 1366 fcp_lun::lun_type 1367 fcp_lun::lun_guid_size fcp_lun::lun_guid 1368 fcp_hp_elem::lun fcp_hp_elem::flags fcp_hp_elem::cip 1369 fcp_hp_elem::what fcp_hp_elem::tgt_cnt fcp_hp_elem::tgt_cnt 1370 fcp_hp_elem::link_cnt fcp_reset_elem fcp_pkt fcp_ipkt 1371 scsi_pkt scsi_arq_status scsi_device scsi_hba_tran scsi_cdb)) 1372 #endif /* __lint */ 1373 1374 /* 1375 * Local variable "pptr" must exist before using these 1376 */ 1377 #define FCP_CP_IN(s, d, handle, len) \ 1378 { \ 1379 if (!((pptr)->port_state & FCP_STATE_FCA_IS_NODMA)) { \ 1380 ddi_rep_get8((handle), (uint8_t *)(d), \ 1381 (uint8_t *)(s), (len), DDI_DEV_AUTOINCR); \ 1382 } else { \ 1383 bcopy((s), (d), (len)); \ 1384 } \ 1385 } 1386 1387 #define FCP_CP_OUT(s, d, handle, len) \ 1388 { \ 1389 if (!((pptr)->port_state & FCP_STATE_FCA_IS_NODMA)) { \ 1390 ddi_rep_put8((handle), (uint8_t *)(s), \ 1391 (uint8_t *)(d), (len), DDI_DEV_AUTOINCR); \ 1392 } else { \ 1393 bcopy((s), (d), (len)); \ 1394 } \ 1395 } 1396 1397 #define FCP_ONLINE 0x1 1398 #define FCP_OFFLINE 0x2 1399 #define FCP_MPXIO_PATH_CLEAR_BUSY 0x3 1400 #define FCP_MPXIO_PATH_SET_BUSY 0x4 1401 1402 #define FCP_IDLE 0x00 1403 #define FCP_OPEN 0x01 1404 #define FCP_EXCL 0x02 1405 #define FCP_BUSY 0x04 1406 1407 #define LFA(x) (x & 0xFFFF00) 1408 #define FCP_SET 1 1409 #define FCP_RESET 0 1410 1411 /* init() and attach() wait timeout values (in usecs) */ 1412 #define FCP_INIT_WAIT_TIMEOUT 60000000 /* 60 seconds */ 1413 #define FCP_ATTACH_WAIT_TIMEOUT 10000000 /* 10 seconds */ 1414 1415 #ifdef TRUE 1416 #undef TRUE 1417 #endif 1418 #define TRUE 1 1419 1420 #ifdef FALSE 1421 #undef FALSE 1422 #endif 1423 #define FALSE 0 1424 1425 #define UNDEFINED -1 1426 1427 /* for softstate */ 1428 #define FCP_INIT_ITEMS 5 1429 1430 #ifdef __cplusplus 1431 } 1432 #endif 1433 1434 #endif /* _FCPVAR_H */ 1435