power.c

Go to the documentation of this file.

/*
 * PROJECT:         ReactOS Win32k subsystem
 * LICENSE:         GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:         Power management of the Win32 kernel-mode subsystem
 * COPYRIGHT:       Copyright 2024 George Bișoc <george.bisoc@reactos.org>
 */
 
/* INCLUDES ******************************************************************/
 
#include <win32k.h>
DBG_DEFAULT_CHANNEL(UserPowerManager);
 
/* GLOBALS *******************************************************************/
 
LIST_ENTRY gPowerCalloutsQueueList;
PFAST_MUTEX gpPowerCalloutMutexLock;
PKEVENT gpPowerRequestCalloutEvent;
PKTHREAD gpPowerCalloutMutexOwnerThread;
 
/* PRIVATE FUNCTIONS *********************************************************/
 
static
VOID
IntHandlePowerEventWorker(
    _In_ PWIN32_POWEREVENT_PARAMETERS pParameters)
{
    PSPOWEREVENTTYPE PwrEventType;
    ULONG Code;
 
    /* Cache the power event parameters and handle the power callout */
    PwrEventType = pParameters->EventNumber;
    Code = pParameters->Code;
    switch (PwrEventType)
    {
        case PsW32SystemTime:
        {
            /*
             * The power manager of the kernel notified us of an impending
             * time change, broadcast this notification to all present windows.
             */
            UserSendNotifyMessage(HWND_BROADCAST,
                                  WM_TIMECHANGE,
                                  0,
                                  0);
            break;
        }
 
        default:
        {
            TRACE("Power event of type %d is currently UNIMPLEMENTED (code %lu)\n", PwrEventType, Code);
            break;
        }
    }
}
 
static
NTSTATUS
IntValidateWin32PowerParams(
    _In_ PWIN32_POWEREVENT_PARAMETERS pParameters)
{
    PSPOWEREVENTTYPE PwrEventType;
 
    /* Capture the event number and check if it is within bounds */
    PwrEventType = pParameters->EventNumber;
    if (PwrEventType < PsW32FullWake || PwrEventType > PsW32MonitorOff)
    {
        TRACE("Unknown event number found -> %d\n", PwrEventType);
        return STATUS_INVALID_PARAMETER;
    }
 
    return STATUS_SUCCESS;
}
 
static
PWIN32POWERCALLOUT
IntGetNextPowerCallout(
    _In_ PWIN32POWERCALLOUT pPowerCallout)
{
    PLIST_ENTRY Entry;
    PWIN32POWERCALLOUT pPowerCalloutEntry = NULL;
 
    /* Ensure the current calling thread owns the power callout lock */
    ASSERT_POWER_CALLOUT_LOCK_ACQUIRED();
 
    /* This list is empty, acknowledge the caller */
    if (IsListEmpty(&gPowerCalloutsQueueList))
    {
        return NULL;
    }
 
    /* The caller supplied a NULL argument, give them the first entry */
    if (!pPowerCallout)
    {
        Entry = gPowerCalloutsQueueList.Flink;
    }
    else
    {
        /* Otherwise give the caller the next power callout entry from the list */
        Entry = pPowerCallout->Link.Flink;
    }
 
    /* Delist the power callout entry from the list and give it to caller */
    pPowerCalloutEntry = CONTAINING_RECORD(Entry, WIN32POWERCALLOUT, Link);
    RemoveEntryList(&pPowerCalloutEntry->Link);
    return pPowerCalloutEntry;
}
 
static
VOID
IntDeployPowerCallout(VOID)
{
    PWIN32POWERCALLOUT pWin32PwrCallout;
 
    /* Lock the entire USER subsystem down as we do particular stuff */
    UserEnterExclusive();
 
    /*
     * FIXME: While we did indeed lock the USER subsystem, there is a risk
     * of the current calling thread might die or hang, so we should probably
     * lock the thread while we deploy our power callout. The thread info
     * provides a thread lock field for this purpose (see the ptl member from
     * the _THREADINFO structure) but ReactOS lacks implementation to handle
     * this. Suppose a thread happens to get into this fate, the power callout
     * would never get signaled...
     */
 
    /* Deploy all the pending power callouts to the appropriate callout workers */
    IntAcquirePowerCalloutLock();
    for (pWin32PwrCallout = IntGetNextPowerCallout(NULL);
         pWin32PwrCallout != NULL;
         pWin32PwrCallout = IntGetNextPowerCallout(pWin32PwrCallout))
    {
        if (pWin32PwrCallout->Type == POWER_CALLOUT_EVENT)
        {
            IntHandlePowerEventWorker(&pWin32PwrCallout->Params);
        }
        else // POWER_CALLOUT_STATE
        {
            ERR("Power state callout management is currently not implemented!\n");
        }
 
        /* We are done with this power callout */
        ExFreePoolWithTag(pWin32PwrCallout, USERTAG_POWER);
    }
 
    /* Release what we locked */
    IntReleasePowerCalloutLock();
    UserLeave();
}
 
static
VOID
IntEnlistPowerCallout(
    _In_ PWIN32POWERCALLOUT pPowerCallout)
{
    PETHREAD CurrentThread;
 
    /* Enlist it to the queue already */
    IntAcquirePowerCalloutLock();
    InsertTailList(&gPowerCalloutsQueueList, &pPowerCallout->Link);
    IntReleasePowerCalloutLock();
 
    /*
     * We have to let CSRSS process this power callout if one of the
     * following conditions is TRUE for the current calling thread:
     *
     * - The process of the calling thread is a system process;
     * - The process of the calling thread is attached;
     * - The current calling thread is not a Win32 thread.
     *
     * For the second point, we cannot process the power callout ourselves
     * as we must lock down USER exclusively for our own purpose, which requires
     * us to be in a critical section. So we do not want to fiddle with a process
     * that is attached with others.
     */
    CurrentThread = PsGetCurrentThread();
    if (PsIsSystemThread(CurrentThread) ||
        KeIsAttachedProcess() ||
        !IntIsThreadWin32Thread(CurrentThread))
    {
        /* Alert CSRSS of the presence of an enqueued power callout */
        KeSetEvent(gpPowerRequestCalloutEvent, EVENT_INCREMENT, FALSE);
        return;
    }
 
    /* Handle this power callout ourselves */
    IntDeployPowerCallout();
}
 
/* PUBLIC FUNCTIONS **********************************************************/
 
NTSTATUS
NTAPI
IntInitWin32PowerManagement(
    _In_ HANDLE hPowerRequestEvent)
{
    NTSTATUS Status;
 
    /* Allocate memory pool for the power callout mutex */
    gpPowerCalloutMutexLock = ExAllocatePoolZero(NonPagedPool,
                                                 sizeof(FAST_MUTEX),
                                                 USERTAG_POWER);
    if (gpPowerCalloutMutexLock == NULL)
    {
        ERR("Failed to allocate pool of memory for the power callout mutex\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Initialize the mutex and owner thread */
    ExInitializeFastMutex(gpPowerCalloutMutexLock);
    gpPowerCalloutMutexOwnerThread = NULL;
 
    /* Initialize the global queue list and the power callout (aka request) event object */
    InitializeListHead(&gPowerCalloutsQueueList);
    Status = ObReferenceObjectByHandle(hPowerRequestEvent,
                                       EVENT_ALL_ACCESS,
                                       *ExEventObjectType,
                                       KernelMode,
                                       (PVOID *)&gpPowerRequestCalloutEvent,
                                       NULL);
    if (!NT_SUCCESS(Status))
    {
        ERR("Failed to reference the power callout event handle (Status 0x%08lx)\n", Status);
        ExFreePoolWithTag(gpPowerCalloutMutexLock, USERTAG_POWER);
        return Status;
    }
 
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
IntWin32PowerManagementCleanup(VOID)
{
    PWIN32POWERCALLOUT pWin32PwrCallout;
 
    /* Dereference the power request event */
    ObDereferenceObject(gpPowerRequestCalloutEvent);
    gpPowerRequestCalloutEvent = NULL;
 
    /*
     * Enumerate all pending power callouts and free them. We do not
     * need to do this with the lock held as the CSR process is tore
     * apart during Win32k cleanup, so future power callouts would not
     * be allowed anyway, therefore we are safe.
     */
    for (pWin32PwrCallout = IntGetNextPowerCallout(NULL);
         pWin32PwrCallout != NULL;
         pWin32PwrCallout = IntGetNextPowerCallout(pWin32PwrCallout))
    {
        ExFreePoolWithTag(pWin32PwrCallout, USERTAG_POWER);
    }
 
    /* Tear apart the power callout lock mutex */
    ExFreePoolWithTag(gpPowerCalloutMutexLock, USERTAG_POWER);
    gpPowerCalloutMutexLock = NULL;
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
IntHandlePowerEvent(
    _In_ PWIN32_POWEREVENT_PARAMETERS pWin32PwrEventParams)
{
    PWIN32POWERCALLOUT pWin32PwrCallout;
    NTSTATUS Status;
 
    /*
     * CSRSS is not running. As a consequence, the USER subsystem is neither
     * up and running as the Client/Server subsystem is responsible to fire
     * up other subsystems. Another case is that the system undergoes shutdown
     * and Win32k cleanup is currently in effect. Either way, just quit.
     */
    if (!gpepCSRSS)
    {
        TRACE("CSRSS is not running, bailing out\n");
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Validate the power event parameters, just to be sure we have not gotten anything else */
    Status = IntValidateWin32PowerParams(pWin32PwrEventParams);
    if (!NT_SUCCESS(Status))
    {
        ERR("Could not deploy power callout, invalid Win32 power parameters!\n");
        return Status;
    }
 
    /* Allocate pool of memory for this power callout */
    pWin32PwrCallout = ExAllocatePoolZero(NonPagedPool,
                                          sizeof(WIN32POWERCALLOUT),
                                          USERTAG_POWER);
    if (pWin32PwrCallout == NULL)
    {
        ERR("Allocating memory for Win32 power callout failed\n");
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Fill the necessary power datum */
    pWin32PwrCallout->Type = POWER_CALLOUT_EVENT;
    pWin32PwrCallout->Params.EventNumber = pWin32PwrEventParams->EventNumber;
    pWin32PwrCallout->Params.Code = pWin32PwrEventParams->Code;
 
    /* Enqueue this power request for later processing */
    IntEnlistPowerCallout(pWin32PwrCallout);
    return STATUS_SUCCESS;
}
 
NTSTATUS
NTAPI
IntHandlePowerState(
    _In_ PWIN32_POWERSTATE_PARAMETERS pWin32PwrStateParams)
{
    /* FIXME */
    ERR("IntHandlePowerState is UNIMPLEMENTED\n");
    return STATUS_NOT_IMPLEMENTED;
}
 
/* EOF */