VMware ESXi and vSphere Cluster Management

Fibre Channel Components for VMware ESXi

Learn how Fibre Channel SAN components connect VMware ESXi hosts to shared block storage, including HBAs, switches, fabrics, controllers, LUNs, zoning, masking, and multipathing.

Fibre Channel (FC) is a high-speed protocol and transport technology commonly used to provide block storage to servers. In a VMware ESXi environment, FC connects one or more ESXi hosts to a storage-area network (SAN), which then presents logical storage devices from a shared storage system.

A SAN is a dedicated network that provides block-level storage access to servers. Unlike file storage, where a server accesses files through a file-sharing protocol, block storage appears to the operating system as a disk-like device. ESXi can use an FC-presented device to create or mount a VMFS datastore.

Purpose of Fibre Channel Storage in ESXi

FC is typically deployed when multiple ESXi hosts need reliable, shared access to centralized block storage. A storage array can present the same authorized logical unit to several hosts, allowing clustered VMware features and shared datastores to operate when the storage and vSphere configuration support them.

The high-level I/O path is:

1. A virtual machine issues I/O to a virtual disk.
2. ESXi translates that request through its storage stack.
3. An FC host bus adapter (HBA) sends the storage traffic through an FC fabric.
4. The fabric delivers the traffic to a target port on the storage array.
5. A storage controller processes the request against a logical unit, commonly called a LUN.
6. The logical unit is backed by physical disks, a RAID set, or a storage pool.

FC storage is normally shared storage rather than storage dedicated to one server. Sharing is controlled: only hosts and initiator ports authorized by the fabric and the array should be able to access a particular LUN.

FC SAN Component Overview

The components form a layered system rather than a collection of unrelated devices. Physical disks provide capacity; RAID groups or pools organize that capacity; controllers create and serve logical units; switches connect host and storage endpoints; and HBAs give ESXi its FC interfaces.

Storage System or Disk Array

A storage system, also called a disk array, is an enclosure or platform containing physical disks and one or more intelligent storage controllers. It provides centralized capacity and exposes logical block devices to servers.

The capacity visible to ESXi is not normally the same as the total physical disk capacity. Raw capacity is reduced or reorganized by RAID protection, spare capacity, metadata, pool management, snapshots, thin provisioning, and other array features. The array then allocates part of its usable capacity to logical units.

Physical Disks, JBOD, RAID Sets, and Storage Pools

JBOD means “just a bunch of disks.” It generally describes individual disks or a group of disks without a RAID aggregation layer, although vendors may use the term differently. JBOD disks can be exposed individually or used as building blocks by an array.

RAID combines disks to provide a defined balance of usable capacity, performance, and resilience. For example, a mirrored layout preserves data when one member fails, while parity-based layouts use calculated redundancy and may provide more usable capacity with different performance and rebuild characteristics.

A storage pool is an array-managed capacity construct. The array may spread data across disks, allocate extents dynamically, and create logical units from the pool. Some platforms use traditional RAID groups, some use pools, and some combine both concepts. There is no universal implementation sequence that applies to every vendor.

The conceptual relationship is:

Physical disks -> RAID set or storage pool -> logical unit (LUN) -> ESXi device -> VMFS datastore

Logical Units and LUNs

A logical unit is a logical block-storage device created by the array. It has a size, an addressable block range, and access permissions. ESXi can discover it as a storage device when the array presents it through a reachable FC target port.

LUN technically refers to the identifier associated with a logical unit. In everyday administration, “LUN” is also commonly used to mean the logical volume itself. The distinction is useful: the logical unit is the storage object, while the LUN identifier helps a target identify that object to an initiator.

After a LUN is created, the array maps or masks it to selected host initiators or host groups. Following correct fabric connectivity and an ESXi storage rescan, the LUN appears as a block device. An administrator can then format it as a VMFS datastore, mount an existing datastore, or use it for another supported ESXi storage purpose.

Storage Processors and Storage Controllers

A storage processor (SP), storage controller, or controller node is an intelligent component of the array. It receives host I/O, performs storage management, and translates requests for logical units into operations on disks or pools.

Controllers perform several important tasks:

• Provision logical units from RAID groups or storage pools.
• Receive and process host read and write requests.
• Maintain mappings between host initiators and logical units.
• Expose target ports through which hosts reach storage.
• Coordinate caching, protection, metadata, and failure recovery according to the array design.

Enterprise arrays commonly use two or more controllers so that a controller, controller port, or controller-side path can fail without making all storage unavailable. Controller redundancy is useful only when host paths, fabrics, power, and array ports are also designed without a shared single point of failure.

Host Bus Adapters

An FC HBA is a host bus adapter installed in an ESXi server to provide Fibre Channel connectivity. It transmits and receives FC storage traffic and participates in discovery of storage targets and presented LUNs.

Each HBA port has a unique Fibre Channel identity, commonly represented by a World Wide Name (WWN). A port WWN identifies an individual FC port; an adapter may also have a node WWN associated with the device. Storage and switch configuration commonly use the port identities when registering hosts and creating zones.

The HBA is different from a standard Ethernet network interface card. An Ethernet NIC carries IP traffic over Ethernet and is used for management, VM networking, vMotion, and other network functions. A dedicated FC HBA connects directly to an FC SAN and carries FC protocol traffic.

Production hosts commonly use two or more independent HBA ports. Separate ports provide alternate paths if an HBA port, cable, transceiver, switch port, or fabric fails. The paths should be physically and logically independent wherever possible.

FC Switches and Fabrics

An FC switch is a purpose-built switch that forwards traffic using the Fibre Channel protocol. Host HBA ports connect to switch ports as initiators, while storage-array target ports connect to switch ports as targets.

A collection of interconnected or separately operated FC switches is called a fabric. Fabrics provide the switching environment through which initiators discover and communicate with targets. Large fabrics can scale beyond a direct host-to-array connection and can be designed with redundant paths.

An FC switch and an Ethernet switch both interconnect endpoints, but they use different protocols, interfaces, management models, and traffic semantics. An FC switch is not simply an Ethernet switch with a different cable. FCoE, or Fibre Channel over Ethernet, is a related technology that carries FC traffic over Ethernet infrastructure and should not be confused with native FC switching.

Initiators, Targets, Zoning, and LUN Masking

An initiator is a host-side endpoint that starts storage I/O, usually an HBA port. A target is a storage-side endpoint that responds to that I/O, usually an array target port connected to a controller.

Zoning is fabric-level access segmentation. It limits visibility and communication between FC endpoints. LUN masking or LUN mapping is array-side authorization. It determines which registered initiators or hosts can access a particular logical unit.

Both controls are commonly required. A host might see an array target but still be denied the intended LUN because the array has not mapped it. Conversely, a correct array mapping cannot help if the HBA and target cannot communicate through the fabric.

HBA initiator WWN -> FC switch fabric -> array target port -> controller -> mapped LUN

Redundancy and Fault Tolerance

A production FC design normally includes multiple HBA ports, separate FC switches or fabrics, multiple array target ports, and redundant storage controllers. ESXi uses multipathing to maintain or restore access through alternate supported paths when a path fails.

Possible failures include an HBA, cable, SFP or transceiver, switch port, complete switch, array target port, controller, or fabric. Multipathing can continue I/O through an alternate path when the storage platform, host configuration, and path policy support that behavior.

Redundancy is not achieved merely by adding components. Two paths that share one cable, switch, controller port, power source, or maintenance domain may still have a common failure point. Independent fabrics and physically separate paths provide stronger protection.

How ESXi and Virtual Machines Consume FC Storage

ESXi detects an FC-presented LUN as a block storage device. The usual workflow is to discover the device, verify its paths and identity, create or mount a datastore, and place virtual machine files on that datastore.

1. Install and verify the supported FC HBAs in the ESXi host.
2. Record each HBA port WWN.
3. Connect host HBA ports and array target ports to the intended fabrics.
4. Register the host initiator WWNs and create or select an array host object.
5. Create or select RAID-backed capacity or a storage pool, then provision a LUN.
6. Configure zoning between each required initiator and target.
7. Map or mask the LUN to the authorized ESXi hosts.
8. Rescan ESXi storage adapters and verify that the expected device and paths appear.
9. Create a VMFS datastore or mount an existing supported datastore.
10. Place virtual machine configuration files and virtual disks on the datastore.

A guest operating system normally does not know that its virtual disk is backed by Fibre Channel. It sees a virtual SCSI controller and virtual disk presented by the VM. ESXi stores the corresponding VMDK or other virtual disk data on a VMFS datastore, which is backed by the FC LUN.

Guest OS
  -> virtual SCSI controller
  -> VMDK or virtual disk
  -> VMFS datastore
  -> ESXi storage stack
  -> physical FC HBA
  -> FC fabric
  -> array controller
  -> LUN

Annotated FC Topology

The following conceptual design shows two ESXi hosts, dual HBA ports, two independent fabrics, redundant array controllers, and a shared LUN. Each host has a path through fabric A and a separate path through fabric B.

                           Shared storage system
                 +----------------------------------------+
                 | Controller A              Controller B  |
                 | Target ports: TA1, TA2    TB1, TB2      |
                 |        |                         |       |
                 |   RAID set / storage pool              |
                 |        |                                 |
                 |        +---- LUN 10 ----> VMFS datastore  |
                 +----------------------------------------+
                    ^ TA1/TB1                 ^ TA2/TB2
                    |                         |
        +------------------------+  +------------------------+
        | FC fabric / switch A   |  | FC fabric / switch B   |
        +------------------------+  +------------------------+
             ^              ^             ^              ^
             |              |             |              |
 ESXi Host 1 |              | ESXi Host 1 |              |
 HBA1 / I1 --+              | HBA2 / I2 --+              |
                            
 ESXi Host 2 HBA1 / I3 ------+  ESXi Host 2 HBA2 / I4 ------+

I1/I2/I3/I4 = initiator ports
TA1/TB1/TA2/TB2 = storage target ports
Each independent connection is a potential multipath route to LUN 10.

In a carefully configured design, zoning allows each initiator to reach the required target ports, and LUN mapping authorizes the correct hosts to use the LUN. If one cable, HBA port, switch, fabric, target port, or controller path fails, ESXi can use an alternate path when multipathing is configured and supported.

Conceptual Configuration Workflow and Verification

Use the following sequence as a planning checklist. Exact menu names and array procedures vary by vendor.

1. Record the FC HBA WWNs for every ESXi host.
2. Connect HBA ports and storage target ports to the planned fabrics.
3. Create array host objects and register the initiator WWNs.
4. Create or select a RAID-backed pool and provision the required LUN.
5. Configure switch zoning for each host initiator and required storage target.
6. Map or mask the LUN to the authorized ESXi hosts or host group.
7. Rescan ESXi storage adapters.
8. Verify that the expected device and multiple paths are visible.
9. Create or mount the datastore only after confirming the intended device identity.

In the Host Client or vSphere Client, rescan the storage adapters and inspect discovered devices and paths. The following ESXi shell commands are useful verification examples:

esxcli storage core adapter list
esxcli storage core path list
esxcli storage filesystem list

The first command lists storage adapters, the second reviews paths to storage devices, and the third lists mounted datastores. Follow your organization’s access and change-control procedures before modifying zoning, masking, or datastore configuration.

Troubleshooting Common FC Problems

An Expected LUN Does Not Appear

• Confirm that the ESXi FC HBA is detected and operational.
• Check link status, cables, transceivers, and switch port state.
• Verify that the host initiator WWNs and array target WWNs are zoned correctly.
• Confirm that the LUN is mapped or unmasked to the correct host initiators.
• Check that the LUN is online and that the storage controller is healthy.
• Verify that presentation uses the intended fabric and target ports.

Only One Path Is Visible

• Verify that both HBA ports are connected and logged in to their respective fabrics.
• Review zoning on both fabrics.
• Confirm that the array presents the LUN through the required target ports and controllers.
• Check for a failed cable, switch port, SFP or transceiver, HBA port, or array port.
• Review ESXi path information to identify the missing initiator-to-target route.

Targets Are Visible but the Intended LUN Cannot Be Used

• Separate fabric connectivity from LUN authorization during troubleshooting.
• Verify LUN mapping or masking for the host WWNs.
• Check whether the LUN is already in use, formatted for an incompatible purpose, or intentionally not mounted.
• Ensure the correct host group and storage group associations are configured on the array.

Storage Access Is Interrupted After a Failure

• Determine whether alternate paths existed before the failure.
• Check ESXi multipathing status and path states.
• Identify whether both paths shared one switch, controller, cable route, power source, or other dependency.
• After correcting the design, validate failover during a controlled maintenance test.

Key Points

• FC provides SAN-based block storage connectivity between ESXi hosts and storage arrays.
• The array transforms physical disks and RAID or pool capacity into logical units that ESXi can discover as LUNs.
• HBAs are dedicated FC host adapters and identify themselves with WWNs.
• FC switches connect initiators and targets through one or more fabrics.
• Zoning controls fabric communication; LUN masking or mapping controls array-side authorization.
• ESXi multipathing uses alternate supported paths to improve storage availability.
• Virtual machines usually consume FC-backed storage indirectly through virtual SCSI devices, VMDKs, VMFS, ESXi, and the physical FC path.

For the broader platform context, see the VMware ESXi online course, the guide to adding a raw LUN, and the lesson on datastores in virtual SAN.