Win32 Thread Information Block
The Thread Information Block (TIB) or Thread Environment Block (TEB) is a data structure in Win32 on x86 that stores information about the currently running thread. It descended from, and is backward-compatible on 32-bit systems with, a similar structure in OS/2.[1]
The TIB is officially undocumented for Windows 9x. The Windows NT series DDK (as well as the MinGW/ReactOS implementation) includes a struct NT_TIB in winnt.h that documents the subsystem independent part. Even before TIB was effectively documented, many applications have already started using its fields that they are effectively a part of the API. The first field containing the SEH frame, in particular, is directly referenced by the code produced by Microsoft's own compiler.[1] The Win32 subsystem-specific part of the TEB is undocumented, but Wine includes a TEB definition in winternl.h.[2]
The TIB can be used to get a lot of information on the process without calling Win32 API. Examples include emulating GetLastError(), GetVersion(). Through the pointer to the PEB one can obtain access to the import tables (IAT), process startup arguments, image name, etc. It is accessed from the FS segment register on 32-bit Windows and GS on 64-bit Windows.
Contents of the TIB on Windows
This table is based on Wine's work on Microsoft Windows internals.[2]
| Bytes/ Type |
offset (32-bit, FS) | offset (64-bit, GS) | Windows Versions | Description |
|---|---|---|---|---|
| pointer | FS:[0x00] | GS:[0x00] | Win9x and NT | Current Structured Exception Handling (SEH) frame
Note: the 64-bit version of Windows uses stack unwinding done in kernel mode instead. |
| pointer | FS:[0x04] | GS:[0x08] | Win9x and NT | Stack Base / Bottom of stack (high address) |
| pointer | FS:[0x08] | GS:[0x10] | Win9x and NT | Stack Limit / Ceiling of stack (low address) |
| pointer | FS:[0x0C] | GS:[0x18] | NT | SubSystemTib
|
| pointer | FS:[0x10] | GS:[0x20] | NT | Fiber data |
| pointer | FS:[0x14] | GS:[0x28] | Win9x and NT | Arbitrary data slot |
| pointer | FS:[0x18] | GS:[0x30] | Win9x and NT | Linear address of TEB |
| End of NT subsystem independent part; below are Win32-dependent | ||||
| pointer | FS:[0x1C] | GS:[0x38] | NT | Environment Pointer |
| pointer | FS:[0x20] | GS:[0x40] | NT | Process ID (in some Windows distributions this field is used as DebugContext)
|
| pointer | FS:[0x24] | GS:[0x48] | NT | Current thread ID |
| pointer | FS:[0x28] | GS:[0x50] | NT | Active RPC Handle |
| pointer | FS:[0x2C] | GS:[0x58] | Win9x and NT | Linear address of the thread-local storage array |
| pointer | FS:[0x30] | GS:[0x60] | NT | Linear address of Process Environment Block (PEB) |
| 4 | FS:[0x34] | GS:[0x68] | NT | Last error number |
| 4 | FS:[0x38] | GS:[0x6C] | NT | Count of owned critical sections |
| pointer | FS:[0x3C] | GS:[0x70] | NT | Address of CSR Client Thread |
| pointer | FS:[0x40] | GS:[0x78] | NT | Win32 Thread Information |
| 124 | FS:[0x44] | GS:[0x80] | NT, Wine | Win32 client information (NT), user32 private data (Wine), 0x60 = LastError (Win95&98), 0x74 = LastError (WinME) |
| pointer | FS:[0xC0] | GS:[0x100] | NT | Reserved for Wow64. Contains a pointer to FastSysCall in Wow64.
|
| 4 | FS:[0xC4] | GS:[0x108] | NT | Current Locale |
| 4 | FS:[0xC8] | GS:[0x10C] | NT | FP Software Status Register |
| 216 | FS:[0xCC] | GS:[0x110] | NT, Wine | Reserved for OS (NT), kernel32 private data (Wine) herein: FS:[0x124] 4 NT Pointer to KTHREAD (ETHREAD) structure
|
| 4 | FS:[0x1A4] | GS:[0x2C0] | NT | Exception code |
| 18 | FS:[0x1A8] | GS:[0x2C8] | NT | Activation context stack |
| 24 | FS:[0x1BC] | GS:[0x2E8] | NT, Wine | Spare bytes (NT), ntdll private data (Wine) |
| 40 | FS:[0x1D4] | GS:[0x300] | NT, Wine | Reserved for OS (NT), ntdll private data (Wine) |
| 1248 | FS:[0x1FC] | GS:[0x350] | NT, Wine | GDI TEB Batch (OS), vm86 private data (Wine) |
| 4 | FS:[0x6DC] | GS:[0x838] | NT | GDI Region |
| 4 | FS:[0x6E0] | GS:[0x840] | NT | GDI Pen |
| 4 | FS:[0x6E4] | GS:[0x848] | NT | GDI Brush |
| 4 | FS:[0x6E8] | GS:[0x850] | NT | Real Process ID |
| 4 | FS:[0x6EC] | GS:[0x858] | NT | Real Thread ID |
| 4 | FS:[0x6F0] | GS:[0x860] | NT | GDI cached process handle |
| 4 | FS:[0x6F4] | GS:[0x868] | NT | GDI client process ID (PID) |
| 4 | FS:[0x6F8] | GS:[0x86C] | NT | GDI client thread ID (TID) |
| 4 | FS:[0x6FC] | GS:[0x870] | NT | GDI thread locale information |
| 20 | FS:[0x700] | GS:[0x878] | NT | Reserved for user application |
| 1248 | FS:[0x714] | GS:[0x890] | NT | Reserved for GL (See wine ref for internals)[2] |
| 4 | FS:[0xBF4] | GS:[0x1250] | NT | Last Status Value |
| 532 | FS:[0xBF8] | GS:[0x1258] | NT | Static UNICODE_STRING buffer
|
| pointer | FS:[0xE0C] | GS:[0x1478] | NT | Also known as DeallocationStack, it establishes the real start address of the stack buffer, hence the real stack limit: it is a few pages less than the stack limit field (which hides the guard pages used to detect stack overflows).
|
| pointer[] | FS:[0xE10] | GS:[0x1480] | NT | TLS slots, 4/8 bytes per slot, 64 slots |
| 8 | FS:[0xF10] | GS:[0x1680] | NT | TLS links (LIST_ENTRY structure)
|
| 4 | FS:[0xF18] | GS:[0x1690] | NT | VDM |
| 4 | FS:[0xF1C] | GS:[0x1698] | NT | Reserved for RPC |
| 4 | FS:[0xF28] | GS:[0x16B0] | NT | Thread error mode (RtlSetThreadErrorMode)
|
| 4 | FS:[0xF78] | GS:[0x1748] | NT | Guaranteed stack bytes |
| This is not the full table; see wine ref for all fields until FS:[0xfb4] / GS:[17c8].[2] Newer Windows versions extend the size of TIB further, up to 0x1000/0x1838 in Windows 10. Some of the fields appended are removed, leading to conflicting definitions.[3] | ||||
FS (for 32-bit) or GS (for 64-bit) maps to a TIB which is embedded in a data block known as the TDB (thread data base). The TIB contains the thread-specific exception handling chain and pointer to the TLS (thread local storage.) The thread local storage is not the same as C local storage.
Stack information stored in the TIB
A process should be free to move the stack of its threads as long as it updates the information stored in the TIB accordingly. A few fields are key to this matter: stack base, stack limit, deallocation stack, and guaranteed stack bytes, respectively stored at offsets 0x8, 0x10, 0x1478 and 0x1748 in 64 bits. Different Windows kernel functions read and write these values, specially to distinguish stack overflows from other read/write page faults (a read or write to a page guarded among the stack limits in guaranteed stack bytes will generate a stack-overflow exception instead of an access violation). The deallocation stack is important because Windows API allows to change the amount of guarded pages: the function SetThreadStackGuarantee allows both read the current space and to grow it. In order to read it, it reads the GuaranteedStackBytes field, and to grow it, it uses has to uncommit stack pages. Setting stack limits without setting DeallocationStack will probably cause odd behavior in SetThreadStackGuarantee. For example, it will overwrite the stack limits to wrong values. Different libraries call SetThreadStackGuarantee, for example the .NET CLR uses it for setting up the stack of their threads.
Accessing the TIB
The TIB of the current thread can be accessed as an offset of segment register FS (x86) or GS (x64).
It is not common to access the TIB fields by an offset from FS:[0], but rather first getting a linear self-referencing pointer to it stored at FS:[18h]. That pointer can be used with pointer arithmetic or be cast to a struct pointer.
Using Microsoft Windows SDK or similar, a programmer could use an inline function defined in winnt.h named NtCurrentTeb which returns the address of the current Thread Information Block as NT_TIB *.[4]
Alternative methods of access for IA-32 architectures are as follows:
// gcc (AT&T-style inline assembly).
void *getTIB(void) {
register void *pTIB;
#if defined(__x86_64__) || defined(__amd64__)
__asm__("movq %%gs:0x30, %0" : "=r" (pTIB));
#elif defined(__i386__)
__asm__("movl %%fs:0x18, %0" : "=r" (pTIB));
#else
#error unsupported architecture
#endif
return pTIB;
}
// gcc (named address spaces, same as the inline assembly version on -O1 or -ftree-ter).
void *getTIB(void) {
#if defined(__x86_64__) || defined(__amd64__)
#ifndef __SEG_GS
#error unsupported GCC version
#endif
return *(void *__seg_gs *) 0x30;
#elif defined(__i386__)
#ifndef __SEG_FS
#error unsupported GCC version
#endif
return *(void *__seg_fs *) 0x18;
#else
#error unsupported architecture
#endif
}
// Microsoft C
__declspec(naked)
void *getTIB() {
__asm mov EAX, FS:[18h]
__asm ret
}
// Using Microsoft's intrinsics instead of inline assembly (works for both X86 and X64 architectures)
void *getTIB() {
#ifdef _M_IX86
return (void *)__readfsdword(0x18);
#elif _M_AMD64
return (void *)__readgsqword(0x30);
#else
#error unsupported architecture
#endif
}
See also
- Structured Exception Handling
References
- ↑ 1.0 1.1 Pietrek, Matt (May 1996). "Under The Hood". Microsoft Systems Journal. Archived from the original on 2009-06-14. https://web.archive.org/web/20090614054226/http://www.microsoft.com/msj/archive/s2ce.aspx. Retrieved 2010-07-07.
- ↑ 2.0 2.1 2.2 2.3 "wine winternl.h: typedef struct _TEB". wine-mirror. 29 October 2019. https://github.com/wine-mirror/wine/blob/1aff1e6a370ee8c0213a0fd4b220d121da8527aa/include/winternl.h#L347.
- ↑ Chapell, Geoff. "TEB". https://www.geoffchappell.com/studies/windows/win32/ntdll/structs/teb/index.htm.
- ↑ "NtCurrentTeb function". https://docs.microsoft.com/en-us/windows/win32/api/winnt/nf-winnt-ntcurrentteb. Retrieved 20 November 2019.
Further reading
- (pdf) Windows 95 Programming Secrets. IDG. March 1996. pp. 136–138. ISBN 978-1-56884-318-6. https://archive.org/details/windows95systemp00matt/page/136. Retrieved 2010-07-17.
External links
- TEB layout on NTinternals.net
- Structured Exception Handling and the TIB
- Description of the first slots of the TIB
- Description of TEB, field by field
- TEB definitions for various Windows versions
 |  |
