ExCallback.c File Reference

#include <kmt_test.h>

Include dependency graph for ExCallback.c:

Go to the source code of this file.

Functions
static	PEX_CALLBACK_ROUTINE_BLOCK (NTAPI *ExAllocateCallBack)(IN PEX_CALLBACK_FUNCTION Function
static	VOID (NTAPI *ExFreeCallBack)(IN PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock)
static NTSTATUS NTAPI	ExCallbackFunction (IN PVOID CallbackContext, IN PVOID Argument1 OPTIONAL, IN PVOID Argument2 OPTIONAL)
static VOID	TestPrivateFunctions (VOID)
static VOID NTAPI	CallbackFunction (IN PVOID CallbackContext, IN PVOID Argument1, IN PVOID Argument2)
	START_TEST (ExCallback)

Variables
static IN PVOID	Context
static INT	CallbackArgument1
static INT	CallbackArgument2

Function Documentation

CallbackFunction()

static VOID NTAPI CallbackFunction ( IN PVOID  CallbackContext, IN PVOID  Argument1, IN PVOID  Argument2  )

static

Definition at line 80 of file ExCallback.c.

{
    INT *InvocationCount = CallbackContext;
 
    ok_irql(PASSIVE_LEVEL);
 
    (*InvocationCount)++;
    ok_eq_pointer(Argument1, &CallbackArgument1);
    ok_eq_pointer(Argument2, &CallbackArgument2);
}

ExCallbackFunction()

static NTSTATUS NTAPI ExCallbackFunction ( IN PVOID  CallbackContext, IN PVOID Argument1  OPTIONAL, IN PVOID Argument2  OPTIONAL  )

static

Definition at line 37 of file ExCallback.c.

{
    ok(0, "Callback function unexpectedly called\n");
    return STATUS_SUCCESS;
}

Referenced by TestPrivateFunctions().

PEX_CALLBACK_ROUTINE_BLOCK()

static PEX_CALLBACK_ROUTINE_BLOCK ( NTAPI *  ExAllocateCallBack )

static

START_TEST()

START_TEST

(

ExCallback

)

Definition at line 94 of file ExCallback.c.

{
    NTSTATUS Status;
    PCALLBACK_OBJECT CallbackObject;
    OBJECT_ATTRIBUTES ObjectAttributes;
    UNICODE_STRING CallbackName = RTL_CONSTANT_STRING(L"\\Callback\\KmtestExCallbackTestCallback");
    PVOID CallbackRegistration;
    INT InvocationCount = 0;
 
    TestPrivateFunctions();
 
    /* TODO: Parameter tests */
    /* TODO: Test the three predefined callbacks */
    /* TODO: Test opening an existing callback */
    /* TODO: Test AllowMultipleCallbacks */
    /* TODO: Test calling multiple callbacks */
    /* TODO: Test registering the same function twice */
    /* TODO: Test callback object fields */
    /* TODO: Test callback registration fields */
    InitializeObjectAttributes(&ObjectAttributes,
                               &CallbackName,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
 
    CallbackObject = KmtInvalidPointer;
    Status = ExCreateCallback(&CallbackObject,
                              &ObjectAttributes,
                              TRUE,
                              TRUE);
    ok_eq_hex(Status, STATUS_SUCCESS);
    ok(CallbackObject != NULL && CallbackObject != KmtInvalidPointer,
        "CallbackObject = %p", CallbackObject);
 
    if (skip(NT_SUCCESS(Status), "Creating callback failed\n"))
        return;
 
    CallbackRegistration = ExRegisterCallback(CallbackObject,
                                              CallbackFunction,
                                              &InvocationCount);
    ok(CallbackRegistration != NULL, "CallbackRegistration = NULL\n");
 
    if (!skip(CallbackRegistration != NULL, "Registering callback failed\n"))
    {
        ok_eq_hex(KmtGetPoolTag(CallbackRegistration), 'eRBC');
        ok_eq_int(InvocationCount, 0);
        ExNotifyCallback(CallbackObject,
                         &CallbackArgument1,
                         &CallbackArgument2);
        ok_eq_int(InvocationCount, 1);
        ExNotifyCallback(CallbackObject,
                         &CallbackArgument1,
                         &CallbackArgument2);
        ok_eq_int(InvocationCount, 2);
 
        ExUnregisterCallback(CallbackRegistration);
    }
 
    ObDereferenceObject(CallbackObject);
}

TestPrivateFunctions()

static VOID TestPrivateFunctions ( VOID  )

static

Definition at line 48 of file ExCallback.c.

{
    UNICODE_STRING ExAllocateCallBackName = RTL_CONSTANT_STRING(L"ExAllocateCallBack");
    UNICODE_STRING ExFreeCallBackName = RTL_CONSTANT_STRING(L"ExFreeCallBack");
    PEX_CALLBACK_ROUTINE_BLOCK CallbackBlock;
    INT CallbackContext;
 
    if (!ExAllocateCallBack)
        ExAllocateCallBack = MmGetSystemRoutineAddress(&ExAllocateCallBackName);
    if (!ExFreeCallBack)
        ExFreeCallBack = MmGetSystemRoutineAddress(&ExFreeCallBackName);
 
    if (skip(ExAllocateCallBack && ExFreeCallBack,
             "ExAllocateCallBack and/or ExFreeCallBack unavailable\n"))
        return;
 
    CallbackBlock = ExAllocateCallBack(ExCallbackFunction, &CallbackContext);
    ok(CallbackBlock != NULL, "CallbackBlock = NULL\n");
 
    if (skip(CallbackBlock != NULL, "Allocating callback failed\n"))
        return;
 
    ok_eq_pointer(CallbackBlock->Function, ExCallbackFunction);
    ok_eq_pointer(CallbackBlock->Context, &CallbackContext);
    ok_eq_hex(KmtGetPoolTag(CallbackBlock), 'brbC');
 
    ExFreeCallBack(CallbackBlock);
}

Referenced by START_TEST().

VOID()

static VOID ( NTAPI *  ExFreeCallBack )

static

Variable Documentation

CallbackArgument1

INT CallbackArgument1

static

Definition at line 31 of file ExCallback.c.

Referenced by CallbackFunction(), and START_TEST().

CallbackArgument2

INT CallbackArgument2

static

Definition at line 32 of file ExCallback.c.

Referenced by CallbackFunction(), and START_TEST().

Context

IN PVOID Context

Definition at line 15 of file ExCallback.c.