Bloque de información de subprocesos Win32 - Win32 Thread Information Block

En informática , el bloque de información de subprocesos de Win32 (TIB) es una estructura de datos en Win32 en x86 que almacena información sobre el subproceso que se está ejecutando actualmente . También se conoce como Thread Environment Block (TEB) para Win32. Descendió y es compatible con versiones anteriores en sistemas de 32 bits con una estructura similar en OS / 2 .

El TIB está oficialmente indocumentado para Windows 9x. El DDK de la serie Windows NT (así como la implementación de MinGW / ReactOS) incluye una estructura NT_TIB en winnt.h que documenta la parte independiente del subsistema. Incluso antes de que TIB fuera documentado de manera efectiva, muchas aplicaciones ya han comenzado a usar sus campos y son efectivamente parte de la API . El primer campo que contiene el marco SEH, en particular, es referenciado directamente por el código producido por el propio compilador de Microsoft. La parte específica del subsistema Win32 del TEB no está documentada, pero Wine incluye una definición de TEB en winternl.h.

El TIB se puede utilizar para obtener mucha información sobre el proceso sin llamar a la API de Win32. Los ejemplos incluyen emular GetLastError (), GetVersion (). A través del puntero al PEB se puede acceder a las tablas de importación (IAT), los argumentos de inicio del proceso, el nombre de la imagen, etc. Se accede desde el registro de segmento FS en Windows de 32 bits y GS en Windows de 64 bits.

Contenido de TIB en Windows

Esta tabla se basa en el trabajo de Wine en los componentes internos de Microsoft Windows .

FS (para 32 bits) o GS (para 64 bits) se asigna a un TIB que está incrustado en un bloque de datos conocido como TDB (base de datos de subprocesos). El TIB contiene la cadena de manejo de excepciones específicas de subprocesos y el puntero al TLS (almacenamiento local de subprocesos). El almacenamiento local de subprocesos no es lo mismo que el almacenamiento local de C.

Apilar información almacenada en el TIB

Un proceso debe tener libertad para mover la pila de sus subprocesos siempre que actualice la información almacenada en el TIB en consecuencia. Algunos campos son clave para este asunto: base de pila, límite de pila, pila de desasignación y bytes de pila garantizados, almacenados respectivamente en las compensaciones 0x8, 0x10, 0x1478 y 0x1748 en 64 bits. Diferentes funciones del kernel de Windows leen y escriben estos valores, especialmente para distinguir los desbordamientos de pila de otras fallas de página de lectura / escritura (una lectura o escritura en una página protegida entre los límites de pila en bytes de pila garantizados generará una excepción de desbordamiento de pila en lugar de un violación). La pila de desasignación es importante porque la API de Windows permite cambiar la cantidad de páginas protegidas: la función SetThreadStackGuarantee permite tanto leer el espacio actual como aumentarlo. Para leerlo, lee el campo GuaranteedStackBytes y, para hacer que crezca, usa tiene que descomprimir las páginas de la pila. Establecer límites de pila sin establecer DeallocationStack probablemente causará un comportamiento extraño en SetThreadStackGuarantee. Por ejemplo, sobrescribirá los límites de la pila con valores incorrectos. Diferentes bibliotecas llaman SetThreadStackGuarantee, por ejemplo, .NET CLR lo usa para configurar la pila de sus subprocesos.

Accediendo al TIB

Se puede acceder al TIB del subproceso actual como un desplazamiento del registro de segmento FS (x86) o GS (x64).

No es común acceder a los campos TIB mediante un desplazamiento de FS:[0] , sino obtener primero un puntero de autorreferencia lineal almacenado en FS:[18h] . Ese puntero se puede usar con aritmética de punteros o convertirse en un puntero de estructura .

Usando Microsoft Windows SDK o similar, un programador podría usar una función en línea definida en winnt.h named NtCurrentTeb que devuelve la dirección del actual Thread Information Block como NT_TIB * .

Los métodos alternativos de acceso para las arquitecturas IA-32 son los siguientes:

// 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
}

Ver también

• Manejo estructurado de excepciones

Referencias

Otras lecturas

• Pietrek, Matt (marzo de 1996). Secretos de programación de Windows 95 (pdf) . IDG. págs.  136-138 . ISBN   978-1-56884-318-6 . Consultado el 17 de julio de 2010 .

enlaces externos

• Diseño TEB en NTinternals.net
• Manejo estructurado de excepciones y TIB
• Descripción de las primeras ranuras del TIB
• Descripción de TEB, campo por campo
• Definiciones de TEB para varias versiones de Windows