hook_cr.c

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Bitdefender
 * SPDX-License-Identifier: Apache-2.0
 */
#include "hook_cr.h"
#include "callbacks.h"
#include "guests.h"


INTSTATUS
IntHookCrSetHook(
    _In_ DWORD Cr,
    _In_ DWORD Flags,
    _In_ PFUNC_CrWriteHookCallback Callback,
    _In_opt_ void *Context,
    _Out_opt_ HOOK_CR **Hook
    )
{
    INTSTATUS status = INT_STATUS_SUCCESS;

    if (NULL == Callback)
    {
        return INT_STATUS_INVALID_PARAMETER_3;
    }

    HOOK_CR *pHook = HpAllocWithTag(sizeof(*pHook), IC_TAG_CRH);
    if (NULL == pHook)
    {
        return INT_STATUS_INSUFFICIENT_RESOURCES;
    }

    pHook->Callback = Callback;
    pHook->Context = Context;
    pHook->Disabled = FALSE;
    pHook->Flags = Flags;
    pHook->Cr = Cr;

    // Check if we already have a hook on this CR, in which case, we don't have to activate exits on it.
    BOOLEAN bCrAlreadyHooked = FALSE;

    list_for_each(gGuest.CrHooks->CrHooksList, HOOK_CR, pListHook)
    {
        if (Cr == pListHook->Cr)
        {
            bCrAlreadyHooked = TRUE;
            break;
        }
    }

    if (!bCrAlreadyHooked)
    {
        status = IntEnableCrWriteExit(Cr);
        if (!INT_SUCCESS(status))
        {
            ERROR("[ERROR] IntEnableCrWriteExit failed: 0x%08x\n", status);
        }
    }

    if (0 == gGuest.CrHooks->HooksCount++)
    {
        status = IntEnableCrNotifications();
        if (!INT_SUCCESS(status))
        {
            HpFreeAndNullWithTag(&pHook, IC_TAG_CRH);
            return status;
        }
    }

    InsertTailList(&gGuest.CrHooks->CrHooksList, &pHook->Link);

    if (NULL != Hook)
    {
        *Hook = pHook;
    }

    return status;
}


static INTSTATUS
IntHookCrDeleteHook(
    _In_ HOOK_CR *Hook
    )
{
    if (!Hook->Disabled)
    {
        return INT_STATUS_INVALID_PARAMETER_1;
    }

    HpFreeAndNullWithTag(&Hook, IC_TAG_CRH);

    if (0 >= --gGuest.CrHooks->HooksCount)
    {
        return IntDisableCrNotifications();
    }

    return INT_STATUS_SUCCESS;
}


INTSTATUS
IntHookCrRemoveHook(
    _In_ HOOK_CR *Hook
    )
{
    INTSTATUS status = INT_STATUS_SUCCESS;

    if (NULL == Hook)
    {
        return INT_STATUS_INVALID_PARAMETER_1;
    }

    CR_HOOK_STATE *pCrHooksState = gGuest.CrHooks;
    if (NULL == pCrHooksState)
    {
        return INT_STATUS_NOT_INITIALIZED;
    }

    Hook->Disabled = TRUE;

    BOOLEAN bCrStillHooked = FALSE;
    list_for_each(pCrHooksState->CrHooksList, HOOK_CR, pHook)
    {
        if ((pHook != Hook) && (pHook->Cr == Hook->Cr))
        {
            bCrStillHooked = TRUE;
            break;
        }
    }

    if (!bCrStillHooked)
    {
        status = IntDisableCrWriteExit(Hook->Cr);
        if (!INT_SUCCESS(status))
        {
            ERROR("[ERROR] IntDisableCrWriteExit failed: 0x%08x\n", status);
        }
    }

    if (CPU_STATE_CR_WRITE != gVcpu->State)
    {
        RemoveEntryList(&Hook->Link);

        status = IntHookCrDeleteHook(Hook);
        if (!INT_SUCCESS(status))
        {
            ERROR("[ERROR] IntHookCrDeleteHook failed: 0x%08x\n", status);
        }
    }

    return status;
}


static INTSTATUS
IntHookCrRemoveAllHooks(
    void
    )
{
    INTSTATUS status = INT_STATUS_SUCCESS;

    CR_HOOK_STATE *pCrHookState = gGuest.CrHooks;
    if (NULL == pCrHookState)
    {
        return INT_STATUS_NOT_INITIALIZED;
    }

    list_for_each(pCrHookState->CrHooksList, HOOK_CR, pHook)
    {
        status = IntHookCrRemoveHook(pHook);
        if (!INT_SUCCESS(status))
        {
            ERROR("[ERROR] IntHookCrRemoveHook failed: 0x%08x\n", status);
        }
    }

    return status;
}


INTSTATUS
IntHookCrCommit(
    void
    )
{
    INTSTATUS status = INT_STATUS_SUCCESS;

    if (NULL == gGuest.CrHooks)
    {
        return INT_STATUS_NOT_INITIALIZED;
    }

    list_for_each(gGuest.CrHooks->CrHooksList, HOOK_CR, pHook)
    {
        if (pHook->Disabled)
        {
            RemoveEntryList(&pHook->Link);

            status = IntHookCrDeleteHook(pHook);
            if (!INT_SUCCESS(status))
            {
                ERROR("[ERROR] IntHookCrDeleteHook failed: 0x%08x\n", status);
            }
        }
    }

    return status;
}


INTSTATUS
IntHookCrInit(
    void
    )
{
    gGuest.CrHooks = HpAllocWithTag(sizeof(*gGuest.CrHooks), IC_TAG_CRS);
    if (NULL == gGuest.CrHooks)
    {
        return INT_STATUS_INSUFFICIENT_RESOURCES;
    }

    InitializeListHead(&gGuest.CrHooks->CrHooksList);

    return INT_STATUS_SUCCESS;
}


INTSTATUS
IntHookCrUninit(
    void
    )
{
    if (NULL == gGuest.CrHooks)
    {
        return INT_STATUS_NOT_INITIALIZED_HINT;
    }

    IntHookCrRemoveAllHooks();

    HpFreeAndNullWithTag(&gGuest.CrHooks, IC_TAG_CRS);

    return INT_STATUS_SUCCESS;
}