Re: To get the stacksize of current Thread?

"Sha" <shahulalways@hotmail.com> ha scritto nel messaggio
news:%23dts6TzuIHA.1316@TK2MSFTNGP06.phx.gbl...


Hi,

I tried solving your problem, using some *undocumented* stuff... I used some
information freely available from an open-source project, called ReactOS (in
particular, my problem was the definition of _TEB structure to get maximum
stack size).

In fact, MSDN definition of _TEB is useless:

http://msdn.microsoft.com/en-us/library/ms686708.aspx

typedef struct _TEB {
  BYTE Reserved1[1952];
  PVOID Reserved2[412];
  PVOID TlsSlots[64];
  BYTE Reserved3[8];
  PVOID Reserved4[26];
  PVOID ReservedForOle;
  PVOID Reserved5[4];
  PVOID TlsExpansionSlots;
} TEB,
 *PTEB;

ReactOS definition of that structure can be found here:

http://www.reactos.org/generated/doxygen/de/dd0/struct__TEB.html

My code seems to work (or at least it seems to give me some reasonable
results).
For example, I tested my code on a MFC simple project of mine, and I get
current stack size of 40 KB, and maximum stack size of 1 MB.

Here's my code. I commented it, so I won't replicate comments here.

Again, I'd like to point out that some undocumented Windows stuff is used (I
don't know if TEB structure is defined in Windows DDK headers... it is not
in normal Windows SDK headers that come with Visual Studio 2008).

<code>

//========================================================================
// Returns thread's stack current size and maximum size, in bytes.
// by Giovanni Dicanio
// 2008, May 21st
//========================================================================
void GetThreadStackSize(
    DWORD & cbCurrStackSize,
    DWORD & cbMaxStackSize
    )
{
    // Clear output parameters
    cbCurrStackSize = 0;
    cbMaxStackSize = 0;

    //
    // We need to use some structures here.
    //
    // One of them is TEB structure (TEB = Thread Environment Block).
    //
    // It seems that its definition is not included
    // in normal Windows SDK header (maybe it is undocumented?)
    // For some information about TEB structure, see for example ReactOS
    // (kind of Windows NT open-source clone):
    //
    // http://www.reactos.org/generated/doxygen/de/dd0/struct__TEB.html
    //

    // Get information of current thread (undocumented TEB structure)
    LPVOID pTeb = NtCurrentTeb();

    //
    // We need a pointer to the TIB structure. In this structure there
    // are some information about thread stack:
    // StackBase and StackLimit fields.
    //
    // The first field of TEB structure is a pointer to NT_TIB structure
    // (this structure is defined in WinNT.h).
    //
    PNT_TIB pTib = (PNT_TIB) pTeb;

    // Get stack bottom and top pointers from NT_TIB
    BYTE * pStackBottom = (BYTE *)(pTib->StackBase);
    BYTE * pStackTop = (BYTE *)(pTib->StackLimit);

    //
    // To get current stack size, StackBase and StackLimit
    // in NT_TIB structure are fine.
    //
    // But if we need to know maximum stack size,
    // we need a field of TEB structure:
    // DeallocationStack. Its offset in TEB structure is 0xE0C.
    // (see for example aforementioned documentation for ReactOS).
    // DeallocationStack field is the maximum address for stack
    // expansion.
    //
    LPVOID pTebDeallocationStack = (LPVOID)( ((BYTE*)pTeb) + 0xE0C );
    LPVOID pDeallocationStack = *((LPVOID *)pTebDeallocationStack);

    // Cast to BYTE * so we can do proper pointers difference,
    // and get result size in bytes.
    BYTE * pMaxStack = (BYTE *)pDeallocationStack;

    //
    // Using pointer arithmetic, we can do the differences between
    // pointers, and so we can get current stack and maximum stack sizes.
    //

    // Byte count of Current stack =
    // NT_TIB::StackBase - NT_TIB::StackLimit
    cbCurrStackSize = pStackBottom - pStackTop;

    // Byte count of Max Stack size =
    // NT_TIB::StackBase - _TEB::DeallocationStack
    cbMaxStackSize = pStackBottom - pMaxStack;
}

</code>

You can use the above function like this (as previously mentioned, in a
simple test, I got current stack size = 40 KB, and max size = 1 MB):

<code>

    DWORD cbCurrSize;
    DWORD cbMaxSize;
    GetThreadStackSize(cbCurrSize, cbMaxSize);

    // 1 KB = 1024 bytes
    int currSizeKB = cbCurrSize / 1024;
    int maxSizeKB = cbMaxSize / 1024;

    CString stackSizes;
    stackSizes.FormatMessage(
        _T("Stack size (KB): %1!d! (max: %2!d!)"), currSizeKB, maxSizeKB );

    AfxMessageBox( stackSizes );

</code>

HTH,
Giovanni