windows-server-2003/base/ntos/rtl/amd64/context.c

/*++

Copyright (c) 2000  Microsoft Corporation

Module Name:

    context.c

Abstract:

    This module implements user mode callable context manipulation routines.
    The interfaces exported from this module are portable, but they must
    be re-implemented for each architecture.

Author:

    David N. Cutler (davec) 13-May-2000

Revision History:

--*/

#include "ntrtlp.h"

#if defined(NTOS_KERNEL_RUNTIME)

#pragma alloc_text(PAGE, RtlInitializeContext)
#pragma alloc_text(PAGE, RtlRemoteCall)

#endif

VOID
RtlInitializeContext(
    IN HANDLE Process,
    OUT PCONTEXT Context,
    IN PVOID Parameter OPTIONAL,
    IN PVOID InitialPc OPTIONAL,
    IN PVOID InitialSp OPTIONAL
    )

/*++

Routine Description:

    This function initializes a context record so that it can be used in a
    subsequent call to create thread.

Arguments:

    Process - Supplies a handle to the process in which a thread is being
        created.

    Context - Supplies a pointer to a context record.

    InitialPc - Supplies an initial program counter value.

    InitialSp - Supplies an initial stack pointer value.

Return Value:

    STATUS_BAD_INITIAL_STACK is raised if initial stack pointer value is not
    properly aligned.

--*/

{

    RTL_PAGED_CODE();

    //
    // Check stack alignment.
    //

    if (((ULONG64)InitialSp & 0xf) != 0) {
        RtlRaiseStatus(STATUS_BAD_INITIAL_STACK);
    }

    //
    // Initialize the EFflags field.
    //

    Context->EFlags = EFLAGS_IF_MASK | EFLAGS_AC_MASK;

    //
    // Initialize the integer registers.
    //

    Context->Rax = 0L;
    Context->Rcx = 2L;
    Context->Rbx = 1L;
    Context->Rsp = (ULONG64)InitialSp;
    Context->Rbp = 0L;
    Context->Rsi = 4L;
    Context->Rdi = 5L;
    Context->R8 = 8;
    Context->R9 = 9;
    Context->R10 = 10;
    Context->R11 = 11;
    Context->R12 = 12;
    Context->R13 = 13;
    Context->R14 = 14;
    Context->R15 = 15;

    //
    // Initialize the floating registers.
    //

    Context->Xmm0.Low = 0;
    Context->Xmm0.High = 0;
    Context->Xmm1.Low = 1;
    Context->Xmm1.High = 1;
    Context->Xmm2.Low = 2;
    Context->Xmm2.High = 2;
    Context->Xmm3.Low = 3;
    Context->Xmm3.High = 3;
    Context->Xmm4.Low = 4;
    Context->Xmm4.High = 4;
    Context->Xmm5.Low = 5;
    Context->Xmm5.High = 5;
    Context->Xmm6.Low = 6;
    Context->Xmm6.High = 6;
    Context->Xmm7.Low = 7;
    Context->Xmm7.High = 7;
    Context->Xmm8.Low = 8;
    Context->Xmm8.High = 8;
    Context->Xmm9.Low = 9;
    Context->Xmm9.High = 9;
    Context->Xmm10.Low = 10;
    Context->Xmm10.High = 10;
    Context->Xmm11.Low = 11;
    Context->Xmm11.High = 11;
    Context->Xmm12.Low = 12;
    Context->Xmm12.High = 12;
    Context->Xmm13.Low = 13;
    Context->Xmm13.High = 13;
    Context->Xmm14.Low = 14;
    Context->Xmm14.High = 14;
    Context->Xmm15.Low = 15;
    Context->Xmm15.High = 15;

    Context->MxCsr = INITIAL_MXCSR;

    //
    // Initialize the lagacy floatin point.
    //

    Context->FltSave.ControlWord = 0x23f;
    Context->FltSave.StatusWord = 0;
    Context->FltSave.TagWord = 0xffff;
    Context->FltSave.ErrorOffset = 0;
    Context->FltSave.ErrorSelector = 0;
    Context->FltSave.ErrorOpcode = 0;
    Context->FltSave.DataOffset = 0;
    Context->FltSave.DataSelector = 0;

    //
    // Initialize the program counter.
    //

    Context->Rip = (ULONG64)InitialPc;

    //
    // Set context record flags.
    //

    Context->ContextFlags = CONTEXT_FULL;

    //
    // Set the initial context of the thread in a machine specific way.
    //

    Context->Rcx = (ULONG64)Parameter;

    //
    // Unique stamp to tell wow64 that this is an RtlCreateUserThread context
    // rather than BaseCreateThread context.
    //

    Context->R9 = 0xf0e0d0c0a0908070UI64;

    return;
}

NTSTATUS
RtlRemoteCall(
    HANDLE Process,
    HANDLE Thread,
    PVOID CallSite,
    ULONG ArgumentCount,
    PULONG_PTR Arguments,
    BOOLEAN PassContext,
    BOOLEAN AlreadySuspended
    )

/*++

Routine Description:

    This function calls a procedure in another thread/process, using the
    system functins NtGetContext and NtSetContext. Parameters are passed
    to the target procedure via the nonvolatile registers ().

Arguments:

    Process - Supplies an open handle to the target process.

    Thread - Supplies an open handle to the target thread within the target
        process.

    CallSite - Supplies the address of the procedure to call in the target
        process.

    ArgumentCount - Supplies the number of parameters to pass to the target
        procedure.

    Arguments - Supplies a pointer to the array of parameters to pass.

    PassContext - Supplies a boolean value that determines whether a parameter
        is to be passed that points to a context record.

    AlreadySuspended - Supplies a boolean value that determines whether the
        target thread is already in a suspended or waiting state.

Return Value:

    Status - Status value

--*/

{

    CONTEXT Context;
    ULONG Index;
    ULONG64 NewSp;
    NTSTATUS Status;

    RTL_PAGED_CODE();

    //
    // Check if too many arguments are specified.
    //

    if (ArgumentCount > 4) {
        return STATUS_INVALID_PARAMETER;
    }

    //
    // If necessary, suspend the target thread before getting the thread's
    // current state.
    //

    if (AlreadySuspended == FALSE) {
        Status = NtSuspendThread(Thread, NULL);
        if (!NT_SUCCESS(Status)) {
            return Status;
        }
    }

    //
    // Get the current context of the target thread.
    //

    Context.ContextFlags = CONTEXT_FULL;
    Status = NtGetContextThread(Thread, &Context);
    if (!NT_SUCCESS(Status)) {
        if (AlreadySuspended == FALSE) {
            NtResumeThread(Thread, NULL);
        }

        return Status;
    }

    if (AlreadySuspended != FALSE) {
        Context.Rax = STATUS_ALERTED;
    }

    //
    // Write previous thread context into the stack of the target thread.
    //

    NewSp = Context.Rsp - sizeof(CONTEXT);
	Status = NtWriteVirtualMemory(Process,
				                  (PVOID)NewSp,
				                  &Context,
				                  sizeof(CONTEXT),
				                  NULL);

	if (!NT_SUCCESS(Status)) {
        if (AlreadySuspended == FALSE) {
            NtResumeThread(Thread, NULL);
        }

	    return Status;
	}

    //
    // Pass the parameters to the target thread via the nonvolatile registers
    // R11-R15.
    //

    Context.Rsp = NewSp;
    if (PassContext != FALSE) {
        Context.R11 = NewSp;
        for (Index = 0; Index < ArgumentCount; Index += 1) {
            (&Context.R12)[Index] = Arguments[Index];
        }

    } else {
        for (Index = 0; Index < ArgumentCount; Index += 1) {
            (&Context.R11)[Index] = Arguments[Index];
        }
    }

    //
    // Set the address of the target code into RIP and set the thread context
    // to cause the target procedure to be executed.
    //

    Context.Rip = (ULONG64)CallSite;
    Status = NtSetContextThread(Thread, &Context);
    if (AlreadySuspended == FALSE) {
        NtResumeThread(Thread, NULL);
    }

    return Status;
}