Windows is currently pending a reboot operation

Whenever you install software, updates or make configuration changes, it’s common for Windows to need a reboot. Many OS tasks sometimes force Windows to require a reboot. When a reboot is pending, Windows add some registry values to show that. In this blog post, you’re going to learn how to check for a pending reboot and how to build a PowerShell script to automate the task.

Windows Needs Rebooted

When you’re in on the console, you can notice a reboot is pending by some popup box or notification as shown below.

From that notification, you can restart Windows and be done with it. But, what if you can’t immediately reboot a machine when it needs to? What if you’ve just installed updates on a production server and that server can’t be rebooted right now?

The reboot must wait.

Time goes by and by then the reboot may be forgotten about altogether! By the time you realize, many servers or workstations need to be rebooted but which ones?

Pending Reboot Flags are in the Registry

A pending reboot is defined in many places. Scroll right to see the values and conditions. A Windows computer is pending a reboot if any of the conditions in this table are true.

If you have the Microsoft System Center Configuration Manager (SCCM) client installed, you may also see these methods in WMI.

Once you know each method to check for a pending reboot, there are many different ways to check registry values. You could open up regedit.exe and manually mouse through each registry key.

Manually checking via the registry works but we’re human. What if you forget to check one registry path or just forget which ones to check? There’s a much better way to do this. You can create a script or function to do this for you. In my case, I prefer PowerShell so that’s what I’ll use.

By using a PowerShell script, you can query one or all computers in our domain or manually provide the server names to see if they are pending a reboot. You can then make a decision to whether to reboot them then or make a list to reboot later. The choice is yours.

To use my PowerShell method, you’ll need to ensure PowerShell Remoting is set up and available on your servers.

Testing for a a Pending Reboot (The Easy Way)

If you don’t want to learn how to check these registry keys and build a tool like this in PowerShell, I’ve made it easy for you. Simply open up your PowerShell console and type Install-Script Test-PendingReboot. Install-Script will download my PowerShell script from the PowerShell Gallery to C:Program FilesWindowsPowerShellScripts. Then run the script as shown below.

PS51> Test-PendingReboot.ps1 -ComputerName localhost

ComputerName IsPendingReboot
------------ ---------------
localhost              False

You can provide as many servers as you want via the ComputerName parameter. The script will return True or False along with the server name.

This tool checks all of the registry keys in the above table for you.

If you’d like to add conditions I’ve missed or correct any mistakes I’ve made, feel free to issue a pull request on GitHub to fix it.

If you want to learn how to build a tool like this, read on!

First, you’ll need to define all of the computers you’d like to test a reboot on. There are many different ways to do this but for this demonstration, I’ll define them manually via an array.

$servers = 'SRV1','SRV2','SRV3'

Now create a foreach loop to iterate over each of them.

foreach ($computer in $ComputerName)

}

Next, I recommend using PowerShell Remoting and checking each registry key and value condition inside of a single PSSession. Create a PSSession for every server.

foreach ($computer in $ComputerName)
    $session = New-PSSession
}

Once you have a PSSession created, you’ll then need to run the checks.

Since you’ll be running many different checks using the same code such as:

• Testing if a registry key exists
• Testing if a registry value exists
• Testing if a registry value is not null

I recommend creating simple functions for each of these checks. This allows you to call a function instead of duplicating code. The Test-PendingReboot script builds all of these helper functions into a single scriptblock as shown below.

function Test-RegistryKey {
        [OutputType('bool')]
        [CmdletBinding()]
        param
        (
            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Key
        )
    
        $ErrorActionPreference = 'Stop'

        if (Get-Item -Path $Key -ErrorAction Ignore) {
            $true
        }
    }

    function Test-RegistryValue {
        [OutputType('bool')]
        [CmdletBinding()]
        param
        (
            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Key,

            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Value
        )
    
        $ErrorActionPreference = 'Stop'

        if (Get-ItemProperty -Path $Key -Name $Value -ErrorAction Ignore) {
            $true
        }
    }

    function Test-RegistryValueNotNull {
        [OutputType('bool')]
        [CmdletBinding()]
        param
        (
            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Key,

            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Value
        )
    
        $ErrorActionPreference = 'Stop'

        if (($regVal = Get-ItemProperty -Path $Key -Name $Value -ErrorAction Ignore) -and $regVal.($Value)) {
            $true
        }
    }

Inside of that same scriptblock, define each condition referencing the helper functions you just created.

$tests = @(
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionComponent Based ServicingRebootPending' }
        { Test-RegistryKey -Key 'HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingRebootInProgress' }
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto UpdateRebootRequired' }
        { Test-RegistryKey -Key 'HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingPackagesPending' }
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto UpdatePostRebootReporting' }
        { Test-RegistryValueNotNull -Key 'HKLM:SYSTEMCurrentControlSetControlSession Manager' -Value 'PendingFileRenameOperations' }
        { Test-RegistryValueNotNull -Key 'HKLM:SYSTEMCurrentControlSetControlSession Manager' -Value 'PendingFileRenameOperations2' }
        { 
            # Added test to check first if key exists, using "ErrorAction ignore" will incorrectly return $true
            'HKLM:SOFTWAREMicrosoftUpdates' | Where-Object { test-path $_ -PathType Container } | ForEach-Object {            
                (Get-ItemProperty -Path $_ -Name 'UpdateExeVolatile' -ErrorAction Ignore | Select-Object -ExpandProperty UpdateExeVolatile) -ne 0 
            }
        }
        { Test-RegistryValue -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRunOnce' -Value 'DVDRebootSignal' }
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftServerManagerCurrentRebootAttemps' }
        { Test-RegistryValue -Key 'HKLM:SYSTEMCurrentControlSetServicesNetlogon' -Value 'JoinDomain' }
        { Test-RegistryValue -Key 'HKLM:SYSTEMCurrentControlSetServicesNetlogon' -Value 'AvoidSpnSet' }
        {
            # Added test to check first if keys exists, if not each group will return $Null
            # May need to evaluate what it means if one or both of these keys do not exist
            ( 'HKLM:SYSTEMCurrentControlSetControlComputerNameActiveComputerName' | Where-Object { test-path $_ } | %{ (Get-ItemProperty -Path $_ ).ComputerName } ) -ne 
            ( 'HKLM:SYSTEMCurrentControlSetControlComputerNameComputerName' | Where-Object { Test-Path $_ } | %{ (Get-ItemProperty -Path $_ ).ComputerName } )
        }
        {
            # Added test to check first if key exists
            'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateServicesPending' | Where-Object { 
                (Test-Path $_) -and (Get-ChildItem -Path $_) } | ForEach-Object { $true }
        }
    )

You can now create a foreach loop inside of your $servers foreach loop that reads each test executes each test.

foreach ($test in $tests) {
	if (& $test) {
		$true
		break
	}
}

When you run the code, the script returns an output like this:

ComputerName IsPendingReboot
------------ ---------------
Server1              False
Server2              True

You can create this output by ensuring the foreach loop returns a single object per server. You should know that if any of the registry values exist, then the server is pending a reboot. Knowing this, you then need to return True if any of the values exist and False if none of them exist.

Wrap all of this up into a script and it should look like this (with some minor additions like Credential).

[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateNotNullOrEmpty()]
    [string[]]$ComputerName,
	
    [Parameter()]
    [ValidateNotNullOrEmpty()]
    [pscredential]$Credential
)

$ErrorActionPreference = 'Stop'

$scriptBlock = {

    $VerbosePreference = $using:VerbosePreference
    function Test-RegistryKey {
        [OutputType('bool')]
        [CmdletBinding()]
        param
        (
            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Key
        )
    
        $ErrorActionPreference = 'Stop'

        if (Get-Item -Path $Key -ErrorAction Ignore) {
            $true
        }
    }

    function Test-RegistryValue {
        [OutputType('bool')]
        [CmdletBinding()]
        param
        (
            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Key,

            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Value
        )
    
        $ErrorActionPreference = 'Stop'

        if (Get-ItemProperty -Path $Key -Name $Value -ErrorAction Ignore) {
            $true
        }
    }

    function Test-RegistryValueNotNull {
        [OutputType('bool')]
        [CmdletBinding()]
        param
        (
            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Key,

            [Parameter(Mandatory)]
            [ValidateNotNullOrEmpty()]
            [string]$Value
        )
    
        $ErrorActionPreference = 'Stop'

        if (($regVal = Get-ItemProperty -Path $Key -Name $Value -ErrorAction Ignore) -and $regVal.($Value)) {
            $true
        }
    }

    # Added "test-path" to each test that did not leverage a custom function from above since
    # an exception is thrown when Get-ItemProperty or Get-ChildItem are passed a nonexistant key path
    $tests = @(
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionComponent Based ServicingRebootPending' }
        { Test-RegistryKey -Key 'HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingRebootInProgress' }
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto UpdateRebootRequired' }
        { Test-RegistryKey -Key 'HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingPackagesPending' }
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto UpdatePostRebootReporting' }
        { Test-RegistryValueNotNull -Key 'HKLM:SYSTEMCurrentControlSetControlSession Manager' -Value 'PendingFileRenameOperations' }
        { Test-RegistryValueNotNull -Key 'HKLM:SYSTEMCurrentControlSetControlSession Manager' -Value 'PendingFileRenameOperations2' }
        { 
            # Added test to check first if key exists, using "ErrorAction ignore" will incorrectly return $true
            'HKLM:SOFTWAREMicrosoftUpdates' | Where-Object { test-path $_ -PathType Container } | ForEach-Object {            
                (Get-ItemProperty -Path $_ -Name 'UpdateExeVolatile' | Select-Object -ExpandProperty UpdateExeVolatile) -ne 0 
            }
        }
        { Test-RegistryValue -Key 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionRunOnce' -Value 'DVDRebootSignal' }
        { Test-RegistryKey -Key 'HKLM:SOFTWAREMicrosoftServerManagerCurrentRebootAttemps' }
        { Test-RegistryValue -Key 'HKLM:SYSTEMCurrentControlSetServicesNetlogon' -Value 'JoinDomain' }
        { Test-RegistryValue -Key 'HKLM:SYSTEMCurrentControlSetServicesNetlogon' -Value 'AvoidSpnSet' }
        {
            # Added test to check first if keys exists, if not each group will return $Null
            # May need to evaluate what it means if one or both of these keys do not exist
            ( 'HKLM:SYSTEMCurrentControlSetControlComputerNameActiveComputerName' | Where-Object { test-path $_ } | %{ (Get-ItemProperty -Path $_ ).ComputerName } ) -ne 
            ( 'HKLM:SYSTEMCurrentControlSetControlComputerNameComputerName' | Where-Object { Test-Path $_ } | %{ (Get-ItemProperty -Path $_ ).ComputerName } )
        }
        {
            # Added test to check first if key exists
            'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateServicesPending' | Where-Object { 
                (Test-Path $_) -and (Get-ChildItem -Path $_) } | ForEach-Object { $true }
        }
    )

    foreach ($test in $tests) {
        Write-Verbose "Running scriptblock: [$($test.ToString())]"
        if (& $test) {
            $true
            break
        }
    }
}

foreach ($computer in $ComputerName) {
    try {
        $connParams = @{
            'ComputerName' = $computer
        }
        if ($PSBoundParameters.ContainsKey('Credential')) {
            $connParams.Credential = $Credential
        }

        $output = @{
            ComputerName    = $computer
            IsPendingReboot = $false
        }

        $psRemotingSession = New-PSSession @connParams
        
        if (-not ($output.IsPendingReboot = Invoke-Command -Session $psRemotingSession -ScriptBlock $scriptBlock)) {
            $output.IsPendingReboot = $false
        }
        [pscustomobject]$output
    } catch {
        Write-Error -Message $_.Exception.Message
    } finally {
        if (Get-Variable -Name 'psRemotingSession' -ErrorAction Ignore) {
            $psRemotingSession | Remove-PSSession
        }
    }
}

You can now execute it like this:

PS51> .Test-PendingReboot.ps1 -Server SRV1,SRV2,SRV3,etc

Summary

You should now have a quick way to test pending reboot across Windows servers. You can see that by using PowerShell, you can consolidate down many tedious steps into one script. This script allows you to quickly test for a pending reboot across many servers at once.

If you know of any other indications to check for a pending reboot, please let me know.

Hello Ricky,

I keep getting the «reboot required» with the new pending reboot detection feature

Indeed, the launch condition is triggered if a reboot is pending on the system.

There isn’t an option to see what are the rules that are checked by the launch condition. However, please allow me to try and explain this and hopefully this will help you troubleshoot the problem on your end.

As most Windows settings, a (pending) system reboot can be detected with the help of the registries. Here is a list with the values that can be manually checked to see if a system reboot is pending:

Key: HKLM:SOFTWAREMicrosoftUpdates
Value: UpdateExeVolatile
Condition: Value is anything other than 0

HKLM:SYSTEMCurrentControlSetControlSession Manager
PendingFileRenameOperations
value exists

Key: HKLM:SYSTEMCurrentControlSetControlSession Manager
Value: PendingFileRenameOperations2
Condition: value exists

Key: HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto UpdateRebootRequired
Value: NA
Condition: key exists

Key: HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateServicesPending
Value: NA
Condition: Any GUID subkeys exist

Key: HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto UpdatePostRebootReporting
Value: NA
Condition: key exists

Key: HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingRebootPending
Value: NA
Condition: key exists

Key: HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingRebootInProgress
Value: NA
Condition: key exists

Key: HKLM:SoftwareMicrosoftWindowsCurrentVersionComponent Based ServicingPackagesPending
Value: NA
Condition: key exists

Key: HKLM:SOFTWAREMicrosoftServerManagerCurrentRebootAttempts
Value: NA
Condition: key exists

Key: HKLM:SYSTEMCurrentControlSetServicesNetlogon
Value: JoinDomain
Condition: value exists

Key: HKLM:SYSTEMCurrentControlSetServicesNetlogon
Value:AvoidSpnSet
Condition: value exists

Important: Please test this on a virtual machine

Beside that, we can also automatically detect a pending reboot using the «PendingReboot» PowerShell module, which contains the «Test-PendingReboot» cmdlet (this script simply checks the above specified registry entries).

Here are the steps that you can follow in order to achieve it:

1. open an elevated PowerSell session.

2. Install-Module PendingReboot

3. make sure that scripts can run on the machine. By default, the execution policy may be set to «Restricted». We can change it to «Unrestricted» so we can run the script (Set-ExecutionPolicy -ExecutionPolicy «Unrestricted»).

4. Import-Module PendingReboot

5. Test-PendingReboot -detailed

That should show you the details about the pending reboot. Beside that, after the check is done, you can manually open the registry editor (win+R -> regedit.exe) and check it.

Hope this will help you troubleshoot your scenario.

Best regards,
Catalin

Use PowerShell to test if a Windows server is pending a reboot.

To prevent service interruptions, you have to schedule Windows server reboots. With the help of PowerShell, you can check whether a particular Windows server requires a reboot or not.

Unfortunately, we can’t always keep our servers up 24/7. In Windowsland especially, a reboot now and then is required. There are many different reasons a server may need a reboot, like software that needs to modify something currently running, a locked file that refuses to let go without a boot, or perhaps a service that can only apply a change at boot time.

The solution to a needed reboot is simple: reboot it! But it’s not always that simple. Servers are serving users, and users don’t like it when their services go down at any time. Also, if you manage a lot of servers, you may want to schedule a maintenance window to reboot them all at once rather than as needed. In such a case, you need to know which ones need rebooting and which ones don’t. How to determine that isn’t too clear on a Windows server.

There is no one area to look at to tell whether a Windows server needs a reboot. The flags are spread out amongst a few different registry keys. Luckily, we can use a PowerShell script to query these registry values and return a simple True or False to indicate if one or more servers need a three-finger salute.

Before we get to the PowerShell, you need to understand where to look. There are three (or more I’m not aware of) registry values you should check to see whether a reboot is needed or not.

• The RebootPending value at

  HKLM:SOFTWAREMicrosoftWindowsCurrentVersionComponent Based Servicing

• The RebootRequired value at

  HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto Update

• The PendingFileRenameOperations value at

  HKLM:SYSTEMCurrentControlSetControlSession Manager

Knowing these registry values, we then create the PowerShell code to check for them on a remote server. We’ll do this over PowerShell Remoting, so I’m assuming it is available on your servers.

The server is pending a reboot if the RebootPending and RebootRequired values exist. Let’s build some code to check for these registry values’ existence. I’m getting a little fancy here by creating an array of hash tables. I’m doing this because it makes it easier to add more checks if one day you find out you need to check other registry values. Using an array like this will allow me to loop over each test quickly.

Also, notice below I’m ignoring errors because if it throws an error, I’m going to assume the value does not exist.

$pendingRebootTests = @(
    @{
        Name = 'RebootPending'
        Test = { Get-ItemProperty -Path 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionComponent Based Servicing'  Name 'RebootPending' -ErrorAction Ignore }
        TestType = 'ValueExists'
    }
    @{
        Name = 'RebootRequired'
        Test = { Get-ItemProperty -Path 'HKLM:SOFTWAREMicrosoftWindowsCurrentVersionWindowsUpdateAuto Update'  Name 'RebootRequired' -ErrorAction Ignore }
        TestType = 'ValueExists'
    }
    @{
        Name = 'PendingFileRenameOperations'
        Test = { Get-ItemProperty -Path 'HKLM:SYSTEMCurrentControlSetControlSession Manager' -Name 'PendingFileRenameOperations' -ErrorAction Ignore }
        TestType = 'NonNullValue'
    }
)

Now that we have the code built to run the tests, let’s create a PowerShell Remoting session and run these scriptblocks on a server.

## Create a PowerShell Remoting session
$session = New-PSSession -Computer SRV1
foreach ($test in $pendingRebootTests) {
    Invoke-Command -Session $session -ScriptBlock $test.Test
}

This will run the code on all the servers but won’t return a simple True or False as we need. To do this, we need to add some if/then logic to it. Since only two of the tests need to return True or False if the registry key exists or not, we’ll use the TestType key in each hash table to make that distinction.

Subscribe to 4sysops newsletter!

$session = New-PSSession -Computer SRV1
foreach ($test in $pendingRebootTests) {
    $result = Invoke-Command -Session $session -ScriptBlock $test.Test
    if ($test.TestType -eq 'ValueExists' -and $result) {
        $true
    } elseif ($test.TestType -eq 'NonNullValue' -and $result -and $result.($test.Name)) {
        $true
    } else {
        $false
    }
}
$session | Remove-PSSession

At this point, we can get an output from this server with the results of each of the checks we’ve done. This function is also built to expand upon by adding additional servers if need be.