cmhook.c File Reference

#include "ntoskrnl.h"
#include "debug.h"

Include dependency graph for cmhook.c:

Go to the source code of this file.

Classes
struct	_REGISTRY_CALLBACK

Macros
#define	NDEBUG

Typedefs
typedef struct _REGISTRY_CALLBACK	REGISTRY_CALLBACK
typedef struct _REGISTRY_CALLBACK *	PREGISTRY_CALLBACK

Functions
VOID NTAPI	CmpInitCallback (VOID)
NTSTATUS	CmiCallRegisteredCallbacks (IN REG_NOTIFY_CLASS Argument1, IN PVOID Argument2)
NTSTATUS NTAPI	CmRegisterCallback (IN PEX_CALLBACK_FUNCTION Function, IN PVOID Context, IN OUT PLARGE_INTEGER Cookie)
NTSTATUS NTAPI	CmUnRegisterCallback (IN LARGE_INTEGER Cookie)

Variables
ULONG	CmpCallBackCount = 0
EX_CALLBACK	CmpCallBackVector [100]
LIST_ENTRY	CmiCallbackHead
FAST_MUTEX	CmiCallbackLock

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file cmhook.c.

Typedef Documentation

PREGISTRY_CALLBACK

typedef struct _REGISTRY_CALLBACK * PREGISTRY_CALLBACK

REGISTRY_CALLBACK

typedef struct _REGISTRY_CALLBACK REGISTRY_CALLBACK

Function Documentation

CmiCallRegisteredCallbacks()

NTSTATUS CmiCallRegisteredCallbacks	(	IN REG_NOTIFY_CLASS	Argument1,
		IN PVOID	Argument2
	)

Definition at line 59 of file cmhook.c.

{
    PLIST_ENTRY CurrentEntry;
    NTSTATUS Status = STATUS_SUCCESS;
    PREGISTRY_CALLBACK CurrentCallback;
    PAGED_CODE();

    ExAcquireFastMutex(&CmiCallbackLock);

    for (CurrentEntry = CmiCallbackHead.Flink;
         CurrentEntry != &CmiCallbackHead;
         CurrentEntry = CurrentEntry->Flink)
    {
        CurrentCallback = CONTAINING_RECORD(CurrentEntry, REGISTRY_CALLBACK, ListEntry);
        if (!CurrentCallback->PendingDelete &&
            ExAcquireRundownProtection(&CurrentCallback->RundownRef))
        {
            /* don't hold locks during the callbacks! */
            ExReleaseFastMutex(&CmiCallbackLock);

            Status = CurrentCallback->Function(CurrentCallback->Context,
                                         (PVOID)Argument1,
                                         Argument2);

            ExAcquireFastMutex(&CmiCallbackLock);

            /* don't release the rundown protection before holding the callback lock
            so the pointer to the next callback isn't cleared in case this callback
            get's deleted */
            ExReleaseRundownProtection(&CurrentCallback->RundownRef);
            if(!NT_SUCCESS(Status))
            {
                /* one callback returned failure, don't call any more callbacks */
                break;
            }
        }
    }

    ExReleaseFastMutex(&CmiCallbackLock);

    return Status;
}

Referenced by CmpDeleteKeyObject(), NtDeleteKey(), NtDeleteValueKey(), NtEnumerateKey(), NtEnumerateValueKey(), NtQueryKey(), NtQueryValueKey(), and NtSetValueKey().

CmpInitCallback()

VOID NTAPI CmpInitCallback

(

VOID

)

Definition at line 38 of file cmhook.c.

{
    ULONG i;
    PAGED_CODE();

    /* Reset counter */
    CmpCallBackCount = 0;

    /* Loop all the callbacks */
    for (i = 0; i < CMP_MAX_CALLBACKS; i++)
    {
        /* Initialize this one */
        ExInitializeCallBack(&CmpCallBackVector[i]);
    }

    /* ROS: Initialize old-style callbacks for now */
    InitializeListHead(&CmiCallbackHead);
    ExInitializeFastMutex(&CmiCallbackLock);
}

Referenced by CmInitSystem1().

CmRegisterCallback()

NTSTATUS NTAPI CmRegisterCallback	(	IN PEX_CALLBACK_FUNCTION	Function,
		IN PVOID	Context,
		IN OUT PLARGE_INTEGER	Cookie
	)

Definition at line 110 of file cmhook.c.

{
    PREGISTRY_CALLBACK Callback;
    PAGED_CODE();
    ASSERT(Function && Cookie);

    Callback = ExAllocatePoolWithTag(PagedPool,
                                     sizeof(REGISTRY_CALLBACK),
                                     'bcMC');
    if (Callback == NULL)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    /* initialize the callback */
    ExInitializeRundownProtection(&Callback->RundownRef);
    Callback->Function = Function;
    Callback->Context = Context;
    Callback->PendingDelete = FALSE;

    /* add it to the callback list and receive a cookie for the callback */
    ExAcquireFastMutex(&CmiCallbackLock);

    /* FIXME - to receive a unique cookie we'll just return the pointer to the
       callback object */
    Callback->Cookie.QuadPart = (ULONG_PTR)Callback;
    InsertTailList(&CmiCallbackHead, &Callback->ListEntry);

    ExReleaseFastMutex(&CmiCallbackLock);

    *Cookie = Callback->Cookie;
    return STATUS_SUCCESS;
}

CmUnRegisterCallback()

NTSTATUS NTAPI CmUnRegisterCallback

(

IN LARGE_INTEGER

Cookie

)

Definition at line 151 of file cmhook.c.

{
    PLIST_ENTRY CurrentEntry;
    PREGISTRY_CALLBACK CurrentCallback;
    PAGED_CODE();

    ExAcquireFastMutex(&CmiCallbackLock);

    for (CurrentEntry = CmiCallbackHead.Flink;
         CurrentEntry != &CmiCallbackHead;
         CurrentEntry = CurrentEntry->Flink)
    {
        CurrentCallback = CONTAINING_RECORD(CurrentEntry, REGISTRY_CALLBACK, ListEntry);
        if (CurrentCallback->Cookie.QuadPart == Cookie.QuadPart)
        {
            if (!CurrentCallback->PendingDelete)
            {
                /* found the callback, don't unlink it from the list yet so we don't screw
                the calling loop */
                CurrentCallback->PendingDelete = TRUE;
                ExReleaseFastMutex(&CmiCallbackLock);

                /* if the callback is currently executing, wait until it finished */
                ExWaitForRundownProtectionRelease(&CurrentCallback->RundownRef);

                /* time to unlink it. It's now safe because every attempt to acquire a
                runtime protection on this callback will fail */
                ExAcquireFastMutex(&CmiCallbackLock);
                RemoveEntryList(&CurrentCallback->ListEntry);
                ExReleaseFastMutex(&CmiCallbackLock);

                /* free the callback */
                ExFreePoolWithTag(CurrentCallback, 'bcMC');
                return STATUS_SUCCESS;
            }
            else
            {
                /* pending delete, pretend like it already is deleted */
                ExReleaseFastMutex(&CmiCallbackLock);
                return STATUS_UNSUCCESSFUL;
            }
        }
    }

    ExReleaseFastMutex(&CmiCallbackLock);

    return STATUS_UNSUCCESSFUL;
}

Variable Documentation

CmiCallbackHead

LIST_ENTRY CmiCallbackHead

Definition at line 20 of file cmhook.c.

Referenced by CmiCallRegisteredCallbacks(), CmpInitCallback(), CmRegisterCallback(), and CmUnRegisterCallback().

CmiCallbackLock

FAST_MUTEX CmiCallbackLock

Definition at line 21 of file cmhook.c.

Referenced by CmiCallRegisteredCallbacks(), CmpInitCallback(), CmRegisterCallback(), and CmUnRegisterCallback().

CmpCallBackCount

ULONG CmpCallBackCount = 0

Definition at line 17 of file cmhook.c.

Referenced by CmpInitCallback().

CmpCallBackVector

EX_CALLBACK CmpCallBackVector[100]

Definition at line 18 of file cmhook.c.

Referenced by CmpInitCallback().