Troubleshooting MPIO Installation Failure: Resolving Error 0x800f0922 on Windows Server

Table of Contents

Installing features on a Windows Server operating system is typically a straightforward process, whether through the graphical user interface (GUI) using Server Manager or via command-line tools like PowerShell or DISM. However, sometimes unexpected errors can occur, blocking the successful deployment of essential roles or features. One such issue involves the installation of the Microsoft Multipath I/O (MPIO) feature, which can sometimes fail with error code 0x800f0922. This error indicates a problem during the feature installation process that prevents it from completing successfully.

MPIO is a crucial technology in server environments, particularly where high availability and redundancy are critical for storage access. It provides a resilient data path connection to storage devices by utilizing multiple physical paths. This redundancy ensures that if one path fails, data access is maintained through the remaining paths, enhancing system reliability and performance by balancing the load across available connections. The inability to install MPIO can significantly impact the design and implementation of reliable storage solutions.

Symptoms of MPIO Installation Failure¶

When attempting to install the MPIO feature on a Windows Server, administrators may encounter a specific error message that immediately indicates a problem. This message typically appears within the Server Manager interface or as output from a PowerShell command. The core of the symptom is the installation process halting and reporting a failure status.

The primary error message displayed is:

The request to add or remove features on the specified server failed.
Installation of one or more roles, role services, or features failed. Error: 0x800f0922.

This generic error code, 0x800f0922, points to a failure within the component-based servicing (CBS) infrastructure, which is responsible for installing and servicing Windows features and updates. While the initial message is helpful in identifying that a failure occurred, it doesn’t provide specific details about the root cause. To understand the underlying problem, it is necessary to examine system logs.

Detailed information about feature installation failures is typically recorded in the Component Based Servicing log (CBS.log) located in the C:\Windows\Logs\CBS\ directory. Analysis of this log reveals the specific operation that failed and often includes more granular error codes or descriptions. In the case of the MPIO installation failure with 0x800f0922, the CBS.log often contains entries similar to the following:

<DateTime>, Error CSI 00000001@<DateTime> (F) CMIADAPTER: Inner Error Message from AI HRESULT = 800f0207 [Error,Facility=(000f),Code=519 (0x0207)]
[66]"The device instance cannot be created because it already exists."
<DateTime>, Error CSI 00000002@<DateTime> (F) CMIADAPTER: AI failed. HRESULT = 800f0207 [Error,Facility=(000f),Code=519 (0x0207)]
...
<DateTime>, Error [0x018005] CSI 0000002b (F) Failed execution of queue item Installer: Root Devices ({3d07d150-2f3d-4184-9793-d0fd59b0c885}) with HRESULT 800f0207 [Error,Facility=(000f),Code=519 (0x0207)]. Failure will not be ignored: A rollback will be initiated...

Another valuable log file for diagnosing hardware and device-related installation issues is the device installation text log (SetupAPI.dev.log), located in the C:\Windows\inf\ directory. This log provides insights into the device installation process. For this specific MPIO failure, the SetupAPI.dev.log may show entries indicating a problem creating a root device instance:

>>> [Setup Root Device - Install]
>>> Section start <DateTime>
set: {Install Root Device: ROOT\MPIO\0001} <DateTime>
!!! set: Could not create a device information element for device ROOT\MPIO\0001. HRESULT = 0x800f0207
set: {Install Root Device - exit(0x800f0207)} <DateTime>
<<< Section end <DateTime>
<<< [Exit status: FAILURE(0x00000207)]

Both logs consistently point to an error code 0x800f0207 during the phase of installing ‘Root Devices’, specifically mentioning that a device instance cannot be created because it already exists. This detailed symptomology provides a strong clue about the underlying cause.

Cause of the Installation Failure¶

The analysis of the CBS.log and SetupAPI.dev.log clearly indicates that the MPIO installation process fails because it attempts to create a device instance (ROOT\MPIO\0001), but the system reports that this specific device instance already exists. This conflict prevents the installer from proceeding, leading to the rollback and the eventual error 0x800f0922 being reported by the feature installation process.

The root cause of this conflict is the presence of stale or remnant entries in the Windows Registry related to a previous, potentially incomplete, or failed installation or uninstallation attempt of the MPIO feature. When Windows installs a device, including root devices like the one created for MPIO, it records configuration information, hardware IDs, and device instances within the registry, primarily under the HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\ key.

Specifically, the error messages point to the ROOT\MPIO\0001 device instance. This strongly suggests that the registry key corresponding to this specific instance still exists, even though the MPIO feature might not be fully installed or functional. The MPIO installer, during its setup routine, checks for the existence of this registry key. If it finds the key already present, but not in the state it expects for a fresh installation or upgrade, it interprets this as an attempt to create a duplicate device instance, resulting in the SPAPI_E_DEVINST_ALREADY_EXISTS error (0x800f0207).

Several scenarios could lead to these stale registry entries. An interrupted MPIO installation or removal process is a common culprit. System crashes, power outages, or manual termination of installation/removal processes at critical moments can leave the registry in an inconsistent state. Although Windows has mechanisms for rolling back failed installations, they are not always perfect and can occasionally leave behind orphaned registry keys or files. Furthermore, sometimes third-party storage management software or drivers that interact with MPIO might leave residual configuration data if not uninstalled cleanly. Regardless of how they originated, these lingering registry entries for ROOT\MPIO\0001 are the direct impediment to a successful MPIO installation.

Resolution for Error 0x800f0922¶

The resolution for this specific MPIO installation failure with error 0x800f0922, based on the log analysis indicating a pre-existing device instance entry in the registry, involves manually removing the problematic registry key. By deleting the stale entry for ROOT\MPIO\0001, we clear the conflict that the installer encountered, allowing it to proceed with creating the necessary device instance during a subsequent installation attempt.

Important Warning: Modifying the Windows Registry incorrectly can cause serious system problems, potentially requiring a reinstallation of the operating system. It is strongly recommended to back up the registry before making any changes. If you are unfamiliar with the Registry Editor, consider consulting with a qualified IT professional.

To resolve the issue, follow these steps:

1. Open the Registry Editor: Press Windows Key + R, type regedit, and press Enter. If prompted by User Account Control, click Yes.
2. Navigate to the problematic key: In the Registry Editor window, navigate to the following key:
   HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\MPIO\0001
   You can expand the folders in the left-hand pane to reach this path or paste the path into the address bar at the top of the Registry Editor window (available on newer Windows versions) and press Enter.
3. Backup the key (Recommended): Before deleting the key, right-click on the 0001 key (underneath MPIO) and select “Export”. Save the .reg file to a safe location, such as a USB drive or network share. This file can be used to restore the key later if necessary by double-clicking it.
4. Delete the key: Right-click on the 0001 key (underneath MPIO) and select “Delete”.
5. Confirm Deletion: A confirmation dialog box will appear. Click “Yes” to confirm the deletion of the key and its subkeys.
6. Close Registry Editor: Close the Registry Editor window.
7. Attempt MPIO Installation Again: Now, try installing the MPIO feature again using either Server Manager or PowerShell. The installation should now proceed without encountering the 0x800f0207 error during the device installation phase, and thus complete successfully, resolving the 0x800f0922 error.

For example, using PowerShell, you would run:

Install-WindowsFeature -Name Multipath-IO

Or, within Server Manager, navigate to “Manage” -> “Add Roles and Features”, proceed through the wizard, select “Multipath I/O” under the “Features” section, and complete the installation.

After successfully installing MPIO, it is advisable to restart the server to ensure all changes take effect and the feature is fully initialized. You can verify the MPIO installation by checking the list of installed features in Server Manager or by running Get-WindowsFeature -Name Multipath-IO in PowerShell. Additionally, you can open the MPIO configuration tool (mpiocpl.exe) to check its status and settings.

Status¶

Based on investigations into this specific error pattern observed during MPIO installation attempts leading to error 0x800f0922 and the subsequent diagnosis via system logs, Microsoft has acknowledged this issue. The problem is attributed to the presence of residual configuration data, specifically the mentioned registry key, left behind from previous system states. The resolution provided, which involves cleaning up this specific registry entry, is the confirmed method to address this particular cause of the installation failure. This issue has been identified and confirmed to affect Microsoft products where this scenario of stale MPIO device registry entries occurs.

Explanation of Relevant Error Codes¶

Understanding the error codes encountered during troubleshooting is key to pinpointing the exact nature of the problem. In this scenario, multiple error codes appear in the logs, each providing a piece of the puzzle.

Here is a breakdown of the relevant error codes:

Error Code	Symbol	File	Description
0x800f0922	CBS_E_INSTALLERS_FAILED	cbsapi.h	Processing advanced installers and generic commands failed.
0x800f0207	SPAPI_E_DEVINST_ALREADY_EXISTS	winerror.h	The device instance cannot be created because it already exists.
0x80070002	ERROR_FILE_NOT_FOUND	winerror.h	The system cannot find the file specified.
0x00000207	SE_AUDITID_LPC_INVALID_USE	msaudite.h	Invalid use of LPC port. (Note: This specific symbol/description may not be directly relevant in the context of a device installation error, but the numerical code 0x207 matches the low word of 0x800f0207 and appears in the log, likely a coincidence or different context in the same log).

The error 0x800f0922 is a high-level error from the Component Based Servicing (CBS) stack. It signifies that a failure occurred while executing one or more installers required for the feature or update package. It’s a general indicator that the installation process for the feature itself (Multipath-IO) could not complete because an underlying step failed.

The error 0x800f0207 (SPAPI_E_DEVINST_ALREADY_EXISTS) is a more specific error originating from the SetupAPI component, which handles device installation. This error is crucial as it directly explains why the installation failed: the installer attempted to register or create a device instance (ROOT\MPIO\0001) that the system’s device enumeration subsystem reported as already existing. This confirms the hypothesis that a remnant of a previous MPIO device configuration is present.

The error 0x80070002 (ERROR_FILE_NOT_FOUND) appearing in the CBS logs in this context (e.g., “Not able to add pending.xml.bad to Windows Error Report”) is usually secondary. It indicates that certain log files or temporary files expected by the error reporting mechanism were not found. While these messages are logged, they are typically not the root cause of the MPIO installation failure itself, but rather a minor issue in the cleanup or reporting phase after the primary failure (0x800f0207) has occurred.

By correlating the high-level error (0x800f0922) with the detailed errors in the log files (specifically 0x800f0207 pointing to a device instance conflict), the troubleshooting process effectively narrows down the potential causes to an issue with the device registration state in the registry.

Further Considerations¶

While the registry modification is the direct fix for the identified cause, it’s worth considering how to prevent this in the future. Ensuring clean installations and uninstallations of storage-related software and drivers is important. If encountering recurring issues, examining the system’s history for abrupt shutdowns or failed previous attempts to manage MPIO could provide context.

For complex scenarios where registry editing is undesirable or if the exact key is hard to locate, advanced troubleshooting might involve using tools like Device Manager with “Show hidden devices” enabled to look for greyed-out MPIO devices that might correspond to the stale entry, though directly manipulating devices from here might not resolve a registry enumeration issue like this. The registry fix is the most targeted approach based on the specific 0x800f0207 error referencing ROOT\MPIO\0001.

Always ensure you are running the latest available updates for your Windows Server operating system, as sometimes issues with feature installations or uninstallations are resolved in servicing updates. However, in this particular case, the issue stems from a potential state inconsistency rather than a bug in the installer itself, making the manual cleanup necessary.

Successfully installing MPIO is vital for leveraging advanced storage features like Storage Spaces Direct or connecting to enterprise storage arrays configured for multipathing. Resolving this installation hurdle ensures that the server can properly utilize these technologies, enhancing both performance and resilience of storage I/O.

Were you able to successfully install MPIO after applying the registry fix? Did you encounter any other issues during the process? Share your experience in the comments below!