Gflags Flag Reference
Overview | Notes | Syntax | UI | Examples | Flags | Related Tools	Run Tool Open Command Prompt

Caution

• The symbolic name of each flag is provided for reference only. Because symbolic names change, they are not a reliable identifier of a global flag.

Buffer DbgPrint output

Suppresses debugger output from DbgPrint(), DbgPrintEx(), KdPrint(), and KdPrintEx() calls. When this output is suppressed, it does not automatically appear in the kernel debugger. However, it can still be accessed by using the !dbgprint debugger extension.

Create kernel mode stack trace database

Creates a run-time stack trace database of kernel operations, such as resource objects and object management operations. This feature works only when using a "checked build," that is, an internal debugging build of the operating system.

Note

• This flag is available as a kernel mode setting, but it is not effective in kernel mode because the kernel is already started.

Create user mode stack trace database

Creates a run-time stack trace database in the address space of a particular process (image file mode) or all processes (systemwide).

Debug initial command

Runs Winlogon in the Windows Symbolic Debugger (Ntsd.exe) with the -d option, which directs its output to the kernel debugger console.

This flag is used for debugging the Client Server Run-time Subsystem (CSRSS), Winlogon.exe, and the Winlogon child processes.

See also: Debug Winlogon, Enable debugging of Win32 subsystem.

Debug Winlogon

Runs Winlogon in the Windows Symbolic Debugger (Ntsd.exe) with the following options:

• -d  Send output to kernel debugger console.
• -g  Ignore first breakpoint.
• -x  Ignore first chance access violations.

See also: Debug Initial Command, Enable debugging of Win32 subsystem.

Disable heap coalesce on free

Leaves adjacent blocks of heap memory separate when they are freed. By default, the system combines ("coalesces") newly freed adjacent blocks into a single block. Combining the blocks takes time, but reduces fragmentation that might force the heap to allocate additional memory when it can't find contiguous memory.

This flag is used to test optimizing strategies. It is not used for debugging.

Disable paging of kernel stacks

Prevents paging of the kernel mode stacks of inactive threads. Generally, the kernel mode stack cannot be paged; it is guaranteed to be resident in memory. However, the system occasionally pages the kernel stacks of inactive threads. This flag prevents these occurrences.

The kernel debugger can provide information about a thread only when its stack is in physical memory. This flag is particularly important when debugging deadlocks and in other cases when every thread must be tracked.

Disable protected DLL verification

This flag appears in Gflags, but it has no effect on the operating system.

Disable stack extension

Prevents the kernel from extending the stacks of the threads in the process beyond the initial memory committed. This is used to simulate low memory conditions (where stack extensions start to fail) and to test the strategic system processes that are expected to run well even with low memory.

Early critical section event creation

Creates event handles when a critical section is initialized, rather than waiting until the event is needed. When the system cannot create an event, it generates the exception during initialization and the calls to enter and leave the critical section do not fail.

Because this flag uses a significant amount of nonpaged pool memory, use it only on very reliable systems that have sufficient memory.

Enable application verifier

Enable bad handles detection

Raises a user mode exception (STATUS_INVALID_HANDLE) whenever a user mode process passes an invalid handle to the Object Manager.

Enable close exception

Raises a user mode exception whenever an invalid handle is passed to the CloseHandle() interface or related interfaces, such as SetEvent(), that take handles as arguments.

Notes

• This flag is still supported, but it has been replaced by Enable bad handles detection, which performs a more comprehensive check of handle use.

Enable debugging of Win32 subsystem

Runs the Client Server Run-time Subsystem, Csrss.exe, in the Windows Symbolic Debugger (Ntsd.exe) with the following options:

• -d  Send output to kernel debugger console.
• -p 1  Attach the debugger to already running Csrss process, as identified by its process ID, 1.

This flag is effective only when the Debug Initial Command (dic) or Debug Winlogon (dwl) flag is also set.

Enable exception logging

Creates a log of exception records in the kernel run-time library. You can access the log from the kernel debugger.

Enable heap free checking

Validates the heap when it is freed.

See also: Enable heap tail checking, Enable heap parameter checking

Enable heap parameter checking

Verifies some aspects of the heap whenever a heap API is called.

See also: Enable heap validation on call

Enable heap tagging

Assigns unique tags to heap allocations. You can display the tag by using the !heap debugger extension with the -t parameter.

For information abou the !heap extension, see the Microsoft Windows 2000 Debugging Tools Kit, which is available from the Microsoft Windows Driver Development Kits (DDK) (http://go.microsoft.com/fwlink/?LinkId=1651) Web site.

See also: Enable heap tagging by DLL

Enable heap tagging by DLL

Assigns a unique tag to heap allocations created by the same DLL. You can display the tag by using the !heap debugger extension with the -t parameter.

For information abou the !heap extension, see the Microsoft Windows 2000 Debugging Tools Kit, which is available from the Microsoft Windows Driver Development Kits (DDK) (http://go.microsoft.com/fwlink/?LinkId=1651) Web site.

See also: Enable heap tagging

Enable heap tail checking

Checks for buffer overruns when the heap is freed. This flag adds a short pattern to the end of each allocation. The Windows heap manager detects the pattern when the block is freed and, if the block was modified, the heap manager breaks into the debugger.

See also: Enable heap free checking, Enable heap parameter checking

Enable heap validation on call

Validates the entire heap each time a heap API is called.

To avoid the high overhead resulting from this flag, use the HeapValidate() API at critical junctures, such as when the heap is destroyed. However, this flag is useful for detecting random corruption in a pool.

See also: Enable heap parameter checking

Enable loading of kernel debugger symbols

Loads kernel symbols into the kernel memory space the next time the system starts. The kernel symbols are used in kernel profiling and by advanced kernel debugging tools.

Enable object handle type tagging

This flag appears in Gflags, but it has no effect on the operating system.

Enable page heap

Adds a guard page and other tracking features to each heap allocation. Available systemwide (registry or kernel mode) or per-program (image file).

Gflags for Windows XP implements full page heap tracking for image files and standard page heap tracking for system allocations. Full page heap tracking places inaccessible pages at the end of an allocation. Standard page heap tracking examines allocations as they are freed. This optimization reduces the huge overhead that would otherwise result from systemwide page heap tracking.

Enable pool tagging

Attaches a four-character tag to every kernel pool allocation. Several tools that diagnose memory leaks and other kernel pool errors require this tag.

Enable system critical breaks

• For per-process (image file) only: Forces a system breakpoint into the debugger whenever the specified process stops abnormally. This flag is effective only when the process calls the RtlSetProcessBreakOnExit() and RtlSetThreadBreakOnExit() interfaces.
• For systemwide (registry or kernel mode): Forces a system breakpoint to the debugger whenever processes that have called the RtlSetProcessBreakOnExit() and RtlSetThreadBreakOnExit() interfaces stop abnormally.

Load DLLs top-down (Win64 only)

Loads DLLs at the highest possible address. This flag is used to test 64-bit code for pointer truncation errors, because the most significant 32 bits of the pointers are not zeroes.

Maintain a list of objects for each type

Collects and maintains a list of the active objects by object type (for example, event, mutex, and semaphore). You can use Open Handles (Oh.exe), a Windows Support Tool, to dump the object lists.

Note

• This flag is available as a kernel mode setting, but it is not effective in kernel mode because the kernel is already started.

Show loader snaps

Captures detailed information about the loading and unloading of executable images and their supporting library modules.

• For systemwide (registry or kernel mode): Whenever a driver is loaded, this flag writes the kernel contents to the kernel debugger console. This feature works only when using a "checked build," that is, an internal debugging build of the operating system.
• For per-process (image file): Whenever a DLL is loaded, this flag writes the loader contents (and data related to DLL loading) to the program debugger console.

Stop on exception

The kernel breaks into the kernel debugger whenever a kernel mode exception occurs. The system passes all first chance exceptions (except for STATUS_PORT_DISCONNECT) with a severity of Warning or Error to the debugger before passing them to a local exception handler.

Stop on hung GUI

This flag appears in Gflags, but it has no effect on the operating system.

Gflags Topics

• GFlags Notes
• GFlags Command-Line Syntax
• GFlags Dialog Box Operation
• Global Flags Reference
• GFlags Examples