![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ntddk.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / inc|
Return to ntddk.h CVS log | Up to [WindowsNT SDKs] / ntddk / inc |
1.1 ! root 1: /*++ BUILD Version: 0166 // Increment this if a change has global effects ! 2: ! 3: Copyright (c) 1990-1992 Microsoft Corporation ! 4: ! 5: Module Name: ! 6: ! 7: ntddk.h ! 8: ! 9: Abstract: ! 10: ! 11: This module defines the NT types, constants, and functions that are ! 12: exposed to device drivers. ! 13: ! 14: Revision History: ! 15: ! 16: --*/ ! 17: ! 18: #ifndef _NTDDK_ ! 19: #define _NTDDK_ ! 20: ! 21: #define NT_INCLUDED ! 22: ! 23: #include <excpt.h> ! 24: #include <ntdef.h> ! 25: #include <ntstatus.h> ! 26: #include <bugcodes.h> ! 27: #include <exlevels.h> ! 28: #include <ntiologc.h> ! 29: ! 30: // ! 31: // Define types that are not exported. ! 32: // ! 33: ! 34: typedef struct _KTHREAD *PKTHREAD; ! 35: typedef struct _ETHREAD *PETHREAD; ! 36: typedef struct _EPROCESS *PEPROCESS; ! 37: typedef struct _PEB *PPEB; ! 38: typedef struct _KINTERRUPT *PKINTERRUPT; ! 39: typedef struct _IO_TIMER *PIO_TIMER; ! 40: typedef struct _OBJECT_TYPE *POBJECT_TYPE; ! 41: ! 42: #if defined(_ALPHA_) ! 43: PKTHREAD KeGetCurrentThread(); ! 44: KIRQL KeGetCurrentIrql(); ! 45: #endif // defined(_ALPHA_) ! 46: ! 47: #if defined(MIPS) ! 48: #define KIPCR 0xfffff000 ! 49: #define PCR ((volatile KPCR * const)KIPCR) ! 50: #define KeGetCurrentThread() PCR->CurrentThread ! 51: #define KeGetCurrentIrql() PCR->CurrentIrql ! 52: #endif // defined(MIPS) ! 53: ! 54: #if defined(_M_IX86) ! 55: PKTHREAD KeGetCurrentThread(); ! 56: ! 57: KIRQL KeGetCurrentIrql(); ! 58: #endif // defined(_M_IX86) ! 59: ! 60: #define PsGetCurrentProcess() IoGetCurrentProcess() ! 61: #define PsGetCurrentThread() ((PETHREAD) (KeGetCurrentThread())) ! 62: extern PCCHAR KeNumberProcessors; ! 63: ! 64: #ifndef DBG ! 65: #define DBG 0 ! 66: #endif ! 67: ! 68: #if DBG ! 69: #define IF_DEBUG if (TRUE) ! 70: #else ! 71: #define IF_DEBUG if (FALSE) ! 72: #endif ! 73: ! 74: #if DEVL ! 75: // ! 76: // Global flag set by NtPartyByNumber(6) controls behaviour of ! 77: // NT. See \nt\sdk\inc\ntexapi.h for flag definitions ! 78: // ! 79: ! 80: extern ULONG NtGlobalFlag; ! 81: ! 82: #define IF_NTOS_DEBUG( FlagName ) \ ! 83: if (NtGlobalFlag & (FLG_ ## FlagName)) ! 84: ! 85: #else ! 86: #define IF_NTOS_DEBUG( FlagName ) if (FALSE) ! 87: #endif ! 88: ! 89: // ! 90: // Kernel definitions that need to be here for forward reference purposes ! 91: // ! 92: ! 93: // ! 94: // Processor modes. ! 95: // ! 96: ! 97: typedef CCHAR KPROCESSOR_MODE; ! 98: ! 99: typedef enum _MODE { ! 100: KernelMode, ! 101: UserMode, ! 102: MaximumMode ! 103: } MODE; ! 104: ! 105: // ! 106: // APC function types ! 107: // ! 108: ! 109: // ! 110: // Put in an empty definition for the KAPC so that the ! 111: // routines can reference it before it is declared. ! 112: // ! 113: ! 114: struct _KAPC; ! 115: ! 116: typedef ! 117: VOID ! 118: (*PKNORMAL_ROUTINE) ( ! 119: IN PVOID NormalContext, ! 120: IN PVOID SystemArgument1, ! 121: IN PVOID SystemArgument2 ! 122: ); ! 123: ! 124: typedef ! 125: VOID ! 126: (*PKKERNEL_ROUTINE) ( ! 127: IN struct _KAPC *Apc, ! 128: IN OUT PKNORMAL_ROUTINE *NormalRoutine, ! 129: IN OUT PVOID *NormalContext, ! 130: IN OUT PVOID *SystemArgument1, ! 131: IN OUT PVOID *SystemArgument2 ! 132: ); ! 133: ! 134: typedef ! 135: VOID ! 136: (*PKRUNDOWN_ROUTINE) ( ! 137: IN struct _KAPC *Apc ! 138: ); ! 139: ! 140: typedef ! 141: BOOLEAN ! 142: (*PKSYNCHRONIZE_ROUTINE) ( ! 143: IN PVOID SynchronizeContext ! 144: ); ! 145: ! 146: typedef ! 147: BOOLEAN ! 148: (*PKTRANSFER_ROUTINE) ( ! 149: VOID ! 150: ); ! 151: ! 152: // ! 153: // ! 154: // Asynchronous Procedure Call (APC) object ! 155: // ! 156: ! 157: typedef struct _KAPC { ! 158: CSHORT Type; ! 159: CSHORT Size; ! 160: struct _KPROCESS *Process; ! 161: struct _KTHREAD *Thread; ! 162: LIST_ENTRY ApcListEntry; ! 163: PKKERNEL_ROUTINE KernelRoutine; ! 164: PKRUNDOWN_ROUTINE RundownRoutine; ! 165: PKNORMAL_ROUTINE NormalRoutine; ! 166: PVOID NormalContext; ! 167: PVOID SystemArgument1; ! 168: PVOID SystemArgument2; ! 169: CCHAR ApcStateIndex; ! 170: KPROCESSOR_MODE ApcMode; ! 171: BOOLEAN Inserted; ! 172: } KAPC; ! 173: ! 174: typedef KAPC *PKAPC; ! 175: ! 176: // ! 177: // DPC routine ! 178: // ! 179: ! 180: struct _KDPC; ! 181: ! 182: typedef ! 183: VOID ! 184: (*PKDEFERRED_ROUTINE) ( ! 185: IN struct _KDPC *Dpc, ! 186: IN PVOID DeferredContext, ! 187: IN PVOID SystemArgument1, ! 188: IN PVOID SystemArgument2 ! 189: ); ! 190: ! 191: // ! 192: // Deferred Procedure Call (DPC) object ! 193: // ! 194: ! 195: typedef struct _KDPC { ! 196: CSHORT Type; ! 197: CSHORT Size; ! 198: LIST_ENTRY DpcListEntry; ! 199: PKDEFERRED_ROUTINE DeferredRoutine; ! 200: PVOID DeferredContext; ! 201: PVOID SystemArgument1; ! 202: PVOID SystemArgument2; ! 203: BOOLEAN Inserted; ! 204: } KDPC; ! 205: ! 206: typedef KDPC *PKDPC; ! 207: ! 208: // ! 209: // Power Notify Routine ! 210: // ! 211: ! 212: typedef ! 213: VOID ! 214: (*PKNOTIFY_ROUTINE) ( ! 215: IN PVOID NotifyContext ! 216: ); ! 217: ! 218: // ! 219: // I/O system definitions. ! 220: // ! 221: // Define a Memory Descriptor List (MDL) ! 222: // ! 223: // An MDL describes pages in a virtual buffer in terms of physical pages. The ! 224: // pages associated with the buffer are described in an array that is allocated ! 225: // just after the MDL header structure itself. In a future compiler this will ! 226: // be placed at: ! 227: // ! 228: // ULONG Pages[]; ! 229: // ! 230: // Until this declaration is permitted, however, one simply calculates the ! 231: // base of the array by adding one to the base MDL pointer: ! 232: // ! 233: // Pages = (PULONG) (Mdl + 1); ! 234: // ! 235: // Notice that while in the context of the subject thread, the base virtual ! 236: // address of a buffer mapped by an MDL may be referenced using the following: ! 237: // ! 238: // Mdl->StartVa | Mdl->ByteOffset ! 239: // ! 240: ! 241: typedef struct _MDL { ! 242: struct _MDL *Next; ! 243: CSHORT Size; ! 244: CSHORT MdlFlags; ! 245: struct _EPROCESS *Process; ! 246: PVOID MappedSystemVa; ! 247: PVOID StartVa; ! 248: ULONG ByteCount; ! 249: ULONG ByteOffset; ! 250: } MDL, *PMDL; ! 251: ! 252: #define MDL_MAPPED_TO_SYSTEM_VA 0x0001 ! 253: #define MDL_PAGES_LOCKED 0x0002 ! 254: #define MDL_SOURCE_IS_NONPAGED_POOL 0x0004 ! 255: #define MDL_ALLOCATED_FROM_ZONE 0x0008 ! 256: #define MDL_PARTIAL 0x0010 ! 257: #define MDL_PARTIAL_HAS_BEEN_MAPPED 0x0020 ! 258: #define MDL_IO_PAGE_READ 0x0040 ! 259: #define MDL_WRITE_OPERATION 0x0080 ! 260: #define MDL_PARENT_MAPPED_SYSTEM_VA 0x0100 ! 261: #define MDL_LOCK_HELD 0x0200 ! 262: ! 263: #define MDL_MAPPING_FLAGS (MDL_MAPPED_TO_SYSTEM_VA | \ ! 264: MDL_PAGES_LOCKED | \ ! 265: MDL_SOURCE_IS_NONPAGED_POOL | \ ! 266: MDL_PARTIAL_HAS_BEEN_MAPPED | \ ! 267: MDL_PARENT_MAPPED_SYSTEM_VA | \ ! 268: MDL_LOCK_HELD ) ! 269: ! 270: ! 271: // ! 272: // switch to DBG when appropriate ! 273: // ! 274: ! 275: #if DBG ! 276: #define PAGED_CODE() \ ! 277: if (KeGetCurrentIrql() > APC_LEVEL) { \ ! 278: KdPrint(( "EX: Pageable code called at IRQL %d\n", KeGetCurrentIrql() )); \ ! 279: ASSERT(FALSE); \ ! 280: } ! 281: #else ! 282: #define PAGED_CODE() ! 283: #endif ! 284: ! 285: // ! 286: // Define an access token from a programmer's viewpoint. The structure is ! 287: // completely opaque and the programer is only allowed to have pointers ! 288: // to tokens. ! 289: // ! 290: ! 291: typedef PVOID PACCESS_TOKEN; // winnt ! 292: ! 293: // ! 294: // Pointer to a SECURITY_DESCRIPTOR opaque data type. ! 295: // ! 296: ! 297: typedef PVOID PSECURITY_DESCRIPTOR; // winnt ! 298: ! 299: // ! 300: // Define a pointer to the Security ID data type (an opaque data type) ! 301: // ! 302: ! 303: typedef PVOID PSID; // winnt ! 304: ! 305: typedef ULONG ACCESS_MASK; ! 306: typedef ACCESS_MASK *PACCESS_MASK; ! 307: ! 308: // end_winnt ! 309: // ! 310: // The following are masks for the predefined standard access types ! 311: // ! 312: ! 313: #define DELETE (0x00010000L) ! 314: #define READ_CONTROL (0x00020000L) ! 315: #define WRITE_DAC (0x00040000L) ! 316: #define WRITE_OWNER (0x00080000L) ! 317: #define SYNCHRONIZE (0x00100000L) ! 318: ! 319: #define STANDARD_RIGHTS_REQUIRED (0x000F0000L) ! 320: ! 321: #define STANDARD_RIGHTS_READ (READ_CONTROL) ! 322: #define STANDARD_RIGHTS_WRITE (READ_CONTROL) ! 323: #define STANDARD_RIGHTS_EXECUTE (READ_CONTROL) ! 324: ! 325: #define STANDARD_RIGHTS_ALL (0x001F0000L) ! 326: ! 327: #define SPECIFIC_RIGHTS_ALL (0x0000FFFFL) ! 328: ! 329: // ! 330: // AccessSystemAcl access type ! 331: // ! 332: ! 333: #define ACCESS_SYSTEM_SECURITY (0x01000000L) ! 334: ! 335: // ! 336: // MaximumAllowed access type ! 337: // ! 338: ! 339: #define MAXIMUM_ALLOWED (0x02000000L) ! 340: ! 341: // ! 342: // These are the generic rights. ! 343: // ! 344: ! 345: #define GENERIC_READ (0x80000000L) ! 346: #define GENERIC_WRITE (0x40000000L) ! 347: #define GENERIC_EXECUTE (0x20000000L) ! 348: #define GENERIC_ALL (0x10000000L) ! 349: ! 350: ! 351: // ! 352: // Define the generic mapping array. This is used to denote the ! 353: // mapping of each generic access right to a specific access mask. ! 354: // ! 355: ! 356: typedef struct _GENERIC_MAPPING { ! 357: ACCESS_MASK GenericRead; ! 358: ACCESS_MASK GenericWrite; ! 359: ACCESS_MASK GenericExecute; ! 360: ACCESS_MASK GenericAll; ! 361: } GENERIC_MAPPING; ! 362: typedef GENERIC_MAPPING *PGENERIC_MAPPING; ! 363: ! 364: ! 365: ! 366: //////////////////////////////////////////////////////////////////////// ! 367: // // ! 368: // LUID_AND_ATTRIBUTES // ! 369: // // ! 370: //////////////////////////////////////////////////////////////////////// ! 371: // ! 372: // ! 373: ! 374: ! 375: #ifndef RC_INVOKED ! 376: #pragma pack(4) ! 377: #endif ! 378: ! 379: typedef struct _LUID_AND_ATTRIBUTES { ! 380: LUID Luid; ! 381: ULONG Attributes; ! 382: } LUID_AND_ATTRIBUTES, * PLUID_AND_ATTRIBUTES; ! 383: typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY]; ! 384: typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY; ! 385: ! 386: #ifndef RC_INVOKED ! 387: #pragma pack() ! 388: #endif ! 389: ! 390: // This is the *current* ACL revision ! 391: ! 392: #define ACL_REVISION (2) ! 393: ! 394: // This is the history of ACL revisions. Add a new one whenever ! 395: // ACL_REVISION is updated ! 396: ! 397: #define ACL_REVISION1 (1) ! 398: #define ACL_REVISION2 (2) ! 399: ! 400: typedef struct _ACL { ! 401: UCHAR AclRevision; ! 402: UCHAR Sbz1; ! 403: USHORT AclSize; ! 404: USHORT AceCount; ! 405: USHORT Sbz2; ! 406: } ACL; ! 407: typedef ACL *PACL; ! 408: ! 409: // ! 410: // Current security descriptor revision value ! 411: // ! 412: ! 413: #define SECURITY_DESCRIPTOR_REVISION (1) ! 414: #define SECURITY_DESCRIPTOR_REVISION1 (1) ! 415: ! 416: // ! 417: // Privilege attributes ! 418: // ! 419: ! 420: #define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x00000001L) ! 421: #define SE_PRIVILEGE_ENABLED (0x00000002L) ! 422: #define SE_PRIVILEGE_USED_FOR_ACCESS (0x80000000L) ! 423: ! 424: // ! 425: // Privilege Set Control flags ! 426: // ! 427: ! 428: #define PRIVILEGE_SET_ALL_NECESSARY (1) ! 429: ! 430: // ! 431: // Privilege Set - This is defined for a privilege set of one. ! 432: // If more than one privilege is needed, then this structure ! 433: // will need to be allocated with more space. ! 434: // ! 435: // Note: don't change this structure without fixing the INITIAL_PRIVILEGE_SET ! 436: // structure (defined in se.h) ! 437: // ! 438: ! 439: typedef struct _PRIVILEGE_SET { ! 440: ULONG PrivilegeCount; ! 441: ULONG Control; ! 442: LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY]; ! 443: } PRIVILEGE_SET, * PPRIVILEGE_SET; ! 444: ! 445: // ! 446: // These must be converted to LUIDs before use. ! 447: // ! 448: ! 449: #define SE_MIN_WELL_KNOWN_PRIVILEGE (2L) ! 450: #define SE_CREATE_TOKEN_PRIVILEGE (2L) ! 451: #define SE_ASSIGNPRIMARYTOKEN_PRIVILEGE (3L) ! 452: #define SE_LOCK_MEMORY_PRIVILEGE (4L) ! 453: #define SE_INCREASE_QUOTA_PRIVILEGE (5L) ! 454: #define SE_UNSOLICITED_INPUT_PRIVILEGE (6L) ! 455: #define SE_TCB_PRIVILEGE (7L) ! 456: #define SE_SECURITY_PRIVILEGE (8L) ! 457: #define SE_TAKE_OWNERSHIP_PRIVILEGE (9L) ! 458: #define SE_LOAD_DRIVER_PRIVILEGE (10L) ! 459: #define SE_SYSTEM_PROFILE_PRIVILEGE (11L) ! 460: #define SE_SYSTEMTIME_PRIVILEGE (12L) ! 461: #define SE_PROF_SINGLE_PROCESS_PRIVILEGE (13L) ! 462: #define SE_INC_BASE_PRIORITY_PRIVILEGE (14L) ! 463: #define SE_CREATE_PAGEFILE_PRIVILEGE (15L) ! 464: #define SE_CREATE_PERMANENT_PRIVILEGE (16L) ! 465: #define SE_BACKUP_PRIVILEGE (17L) ! 466: #define SE_RESTORE_PRIVILEGE (18L) ! 467: #define SE_SHUTDOWN_PRIVILEGE (19L) ! 468: #define SE_DEBUG_PRIVILEGE (20L) ! 469: #define SE_AUDIT_PRIVILEGE (21L) ! 470: #define SE_SYSTEM_ENVIRONMENT_PRIVILEGE (22L) ! 471: #define SE_CHANGE_NOTIFY_PRIVILEGE (23L) ! 472: #define SE_REMOTE_SHUTDOWN_PRIVILEGE (24L) ! 473: #define SE_MAX_WELL_KNOWN_PRIVILEGE (SE_REMOTE_SHUTDOWN_PRIVILEGE) ! 474: ! 475: // ! 476: // Impersonation Level ! 477: // ! 478: // Impersonation level is represented by a pair of bits in Windows. ! 479: // If a new impersonation level is added or lowest value is changed from ! 480: // 0 to something else, fix the Windows CreateFile call. ! 481: // ! 482: ! 483: typedef enum _SECURITY_IMPERSONATION_LEVEL { ! 484: SecurityAnonymous, ! 485: SecurityIdentification, ! 486: SecurityImpersonation, ! 487: SecurityDelegation ! 488: } SECURITY_IMPERSONATION_LEVEL, * PSECURITY_IMPERSONATION_LEVEL; ! 489: ! 490: #define SECURITY_MAX_IMPERSONATION_LEVEL SecurityDelegation ! 491: ! 492: #define DEFAULT_IMPERSONATION_LEVEL SecurityImpersonation ! 493: ! 494: // end_nthal ! 495: // ! 496: // Security Tracking Mode ! 497: // ! 498: ! 499: #define SECURITY_DYNAMIC_TRACKING (TRUE) ! 500: #define SECURITY_STATIC_TRACKING (FALSE) ! 501: ! 502: typedef BOOLEAN SECURITY_CONTEXT_TRACKING_MODE, ! 503: * PSECURITY_CONTEXT_TRACKING_MODE; ! 504: ! 505: ! 506: ! 507: // ! 508: // Quality Of Service ! 509: // ! 510: ! 511: typedef struct _SECURITY_QUALITY_OF_SERVICE { ! 512: ULONG Length; ! 513: SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; ! 514: SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode; ! 515: BOOLEAN EffectiveOnly; ! 516: } SECURITY_QUALITY_OF_SERVICE, * PSECURITY_QUALITY_OF_SERVICE; ! 517: ! 518: ! 519: // ! 520: // Used to represent information related to a thread impersonation ! 521: // ! 522: ! 523: typedef struct _SE_IMPERSONATION_STATE { ! 524: PACCESS_TOKEN Token; ! 525: BOOLEAN CopyOnOpen; ! 526: BOOLEAN EffectiveOnly; ! 527: SECURITY_IMPERSONATION_LEVEL Level; ! 528: } SE_IMPERSONATION_STATE, *PSE_IMPERSONATION_STATE; ! 529: ! 530: ! 531: typedef ULONG SECURITY_INFORMATION, *PSECURITY_INFORMATION; ! 532: ! 533: #define OWNER_SECURITY_INFORMATION (0X00000001L) ! 534: #define GROUP_SECURITY_INFORMATION (0X00000002L) ! 535: #define DACL_SECURITY_INFORMATION (0X00000004L) ! 536: #define SACL_SECURITY_INFORMATION (0X00000008L) ! 537: ! 538: #define LOW_PRIORITY 0 // Lowest thread priority level ! 539: #define LOW_REALTIME_PRIORITY 16 // Lowest realtime priority level ! 540: #define HIGH_PRIORITY 31 // Highest thread priority level ! 541: #define MAXIMUM_PRIORITY 32 // Number of thread priority levels ! 542: // begin_winnt ! 543: #define MAXIMUM_WAIT_OBJECTS 64 // Maximum number of wait objects ! 544: ! 545: #define MAXIMUM_SUSPEND_COUNT MAXCHAR // Maximum times thread can be suspended ! 546: // end_winnt ! 547: ! 548: // ! 549: // Thread affinity ! 550: // ! 551: ! 552: typedef ULONG KAFFINITY; ! 553: typedef KAFFINITY *PKAFFINITY; ! 554: ! 555: // ! 556: // Thread priority ! 557: // ! 558: ! 559: typedef LONG KPRIORITY; ! 560: ! 561: // ! 562: // Spin Lock ! 563: // ! 564: ! 565: typedef ULONG KSPIN_LOCK; // winnt ! 566: ! 567: typedef KSPIN_LOCK *PKSPIN_LOCK; ! 568: ! 569: // ! 570: // Interrupt routine (first level dispatch) ! 571: // ! 572: ! 573: typedef ! 574: VOID ! 575: (*PKINTERRUPT_ROUTINE) ( ! 576: VOID ! 577: ); ! 578: ! 579: // begin_winnt ! 580: // ! 581: // for move macros ! 582: // ! 583: #include <string.h> ! 584: // end_winnt ! 585: // ! 586: // If debugging support enabled, define an ASSERT macro that works. Otherwise ! 587: // define the ASSERT macro to expand to an empty expression. ! 588: // ! 589: ! 590: #if DBG ! 591: VOID ! 592: NTAPI ! 593: RtlAssert( ! 594: PVOID FailedAssertion, ! 595: PVOID FileName, ! 596: ULONG LineNumber, ! 597: PCHAR Message ! 598: ); ! 599: ! 600: #define ASSERT( exp ) \ ! 601: if (!(exp)) \ ! 602: RtlAssert( #exp, __FILE__, __LINE__, NULL ) ! 603: ! 604: #define ASSERTMSG( msg, exp ) \ ! 605: if (!(exp)) \ ! 606: RtlAssert( #exp, __FILE__, __LINE__, msg ) ! 607: ! 608: #else ! 609: #define ASSERT( exp ) ! 610: #define ASSERTMSG( msg, exp ) ! 611: #endif // DBG ! 612: ! 613: // ! 614: // Doubly-linked list manipulation routines. Implemented as macros ! 615: // but logically these are procedures. ! 616: // ! 617: ! 618: // ! 619: // VOID ! 620: // InitializeListHead( ! 621: // PLIST_ENTRY ListHead ! 622: // ); ! 623: // ! 624: ! 625: #define InitializeListHead(ListHead) (\ ! 626: (ListHead)->Flink = (ListHead)->Blink = (ListHead)) ! 627: ! 628: // ! 629: // BOOLEAN ! 630: // IsListEmpty( ! 631: // PLIST_ENTRY ListHead ! 632: // ); ! 633: // ! 634: ! 635: #define IsListEmpty(ListHead) \ ! 636: ((ListHead)->Flink == (ListHead)) ! 637: ! 638: // ! 639: // PLIST_ENTRY ! 640: // RemoveHeadList( ! 641: // PLIST_ENTRY ListHead ! 642: // ); ! 643: // ! 644: ! 645: #define RemoveHeadList(ListHead) \ ! 646: (ListHead)->Flink;\ ! 647: {RemoveEntryList((ListHead)->Flink)} ! 648: ! 649: // ! 650: // PLIST_ENTRY ! 651: // RemoveTailList( ! 652: // PLIST_ENTRY ListHead ! 653: // ); ! 654: // ! 655: ! 656: #define RemoveTailList(ListHead) \ ! 657: (ListHead)->Blink;\ ! 658: {RemoveEntryList((ListHead)->Blink)} ! 659: ! 660: // ! 661: // VOID ! 662: // RemoveEntryList( ! 663: // PLIST_ENTRY Entry ! 664: // ); ! 665: // ! 666: ! 667: #define RemoveEntryList(Entry) {\ ! 668: PLIST_ENTRY _EX_Blink;\ ! 669: PLIST_ENTRY _EX_Flink;\ ! 670: _EX_Flink = (Entry)->Flink;\ ! 671: _EX_Blink = (Entry)->Blink;\ ! 672: _EX_Blink->Flink = _EX_Flink;\ ! 673: _EX_Flink->Blink = _EX_Blink;\ ! 674: } ! 675: ! 676: // ! 677: // VOID ! 678: // InsertTailList( ! 679: // PLIST_ENTRY ListHead, ! 680: // PLIST_ENTRY Entry ! 681: // ); ! 682: // ! 683: ! 684: #define InsertTailList(ListHead,Entry) {\ ! 685: PLIST_ENTRY _EX_Blink;\ ! 686: PLIST_ENTRY _EX_ListHead;\ ! 687: _EX_ListHead = (ListHead);\ ! 688: _EX_Blink = _EX_ListHead->Blink;\ ! 689: (Entry)->Flink = _EX_ListHead;\ ! 690: (Entry)->Blink = _EX_Blink;\ ! 691: _EX_Blink->Flink = (Entry);\ ! 692: _EX_ListHead->Blink = (Entry);\ ! 693: } ! 694: ! 695: // ! 696: // VOID ! 697: // InsertHeadList( ! 698: // PLIST_ENTRY ListHead, ! 699: // PLIST_ENTRY Entry ! 700: // ); ! 701: // ! 702: ! 703: #define InsertHeadList(ListHead,Entry) {\ ! 704: PLIST_ENTRY _EX_Flink;\ ! 705: PLIST_ENTRY _EX_ListHead;\ ! 706: _EX_ListHead = (ListHead);\ ! 707: _EX_Flink = _EX_ListHead->Flink;\ ! 708: (Entry)->Flink = _EX_Flink;\ ! 709: (Entry)->Blink = _EX_ListHead;\ ! 710: _EX_Flink->Blink = (Entry);\ ! 711: _EX_ListHead->Flink = (Entry);\ ! 712: } ! 713: ! 714: // ! 715: // ! 716: // PSINGLE_LIST_ENTRY ! 717: // PopEntryList( ! 718: // PSINGLE_LIST_ENTRY ListHead ! 719: // ); ! 720: // ! 721: ! 722: #define PopEntryList(ListHead) \ ! 723: (ListHead)->Next;\ ! 724: {\ ! 725: PSINGLE_LIST_ENTRY FirstEntry;\ ! 726: FirstEntry = (ListHead)->Next;\ ! 727: if (FirstEntry != NULL) { \ ! 728: (ListHead)->Next = FirstEntry->Next;\ ! 729: } \ ! 730: } ! 731: ! 732: ! 733: // ! 734: // VOID ! 735: // PushEntryList( ! 736: // PSINGLE_LIST_ENTRY ListHead, ! 737: // PSINGLE_LIST_ENTRY Entry ! 738: // ); ! 739: // ! 740: ! 741: #define PushEntryList(ListHead,Entry) \ ! 742: (Entry)->Next = (ListHead)->Next; \ ! 743: (ListHead)->Next = (Entry) ! 744: ! 745: // ! 746: // Subroutines for dealing with the Registry ! 747: // ! 748: ! 749: typedef NTSTATUS (*PRTL_QUERY_REGISTRY_ROUTINE)( ! 750: IN PWSTR ValueName, ! 751: IN ULONG ValueType, ! 752: IN PVOID ValueData, ! 753: IN ULONG ValueLength, ! 754: IN PVOID Context, ! 755: IN PVOID EntryContext ! 756: ); ! 757: ! 758: typedef struct _RTL_QUERY_REGISTRY_TABLE { ! 759: PRTL_QUERY_REGISTRY_ROUTINE QueryRoutine; ! 760: ULONG Flags; ! 761: PWSTR Name; ! 762: PVOID EntryContext; ! 763: ULONG DefaultType; ! 764: PVOID DefaultData; ! 765: ULONG DefaultLength; ! 766: ! 767: } RTL_QUERY_REGISTRY_TABLE, *PRTL_QUERY_REGISTRY_TABLE; ! 768: ! 769: ! 770: // ! 771: // The following flags specify how the Name field of a RTL_QUERY_REGISTRY_TABLE ! 772: // entry is interpreted. A NULL name indicates the end of the table. ! 773: // ! 774: ! 775: #define RTL_QUERY_REGISTRY_SUBKEY 0x00000001 // Name is a subkey and remainder of ! 776: // table or until next subkey are value ! 777: // names for that subkey to look at. ! 778: ! 779: #define RTL_QUERY_REGISTRY_TOPKEY 0x00000002 // Reset current key to original key for ! 780: // this and all following table entries. ! 781: ! 782: #define RTL_QUERY_REGISTRY_REQUIRED 0x00000004 // Fail if no match found for this table ! 783: // entry. ! 784: ! 785: #define RTL_QUERY_REGISTRY_NOVALUE 0x00000008 // Used to mark a table entry that has no ! 786: // value name, just wants a call out, not ! 787: // an enumeration of all values. ! 788: ! 789: #define RTL_QUERY_REGISTRY_NOEXPAND 0x00000010 // Used to suppress the expansion of ! 790: // REG_MULTI_SZ into multiple callouts or ! 791: // to prevent the expansion of environment ! 792: // variable values in REG_EXPAND_SZ ! 793: ! 794: #define RTL_QUERY_REGISTRY_DIRECT 0x00000020 // QueryRoutine field ignored. EntryContext ! 795: // field points to location to store value. ! 796: // For null terminated strings, EntryContext ! 797: // points to UNICODE_STRING structure that ! 798: // that describes maximum size of buffer. ! 799: // If .Buffer field is NULL then a buffer is ! 800: // allocated. ! 801: // ! 802: ! 803: #define RTL_QUERY_REGISTRY_DELETE 0x00000040 // Used to delete value keys after they ! 804: // are queried. ! 805: ! 806: NTSTATUS ! 807: NTAPI ! 808: RtlQueryRegistryValues( ! 809: IN ULONG RelativeTo, ! 810: IN PWSTR Path, ! 811: IN PRTL_QUERY_REGISTRY_TABLE QueryTable, ! 812: IN PVOID Context, ! 813: IN PVOID Environment OPTIONAL ! 814: ); ! 815: ! 816: NTSTATUS ! 817: NTAPI ! 818: RtlWriteRegistryValue( ! 819: IN ULONG RelativeTo, ! 820: IN PWSTR Path, ! 821: IN PWSTR ValueName, ! 822: IN ULONG ValueType, ! 823: IN PVOID ValueData, ! 824: IN ULONG ValueLength ! 825: ); ! 826: ! 827: NTSTATUS ! 828: NTAPI ! 829: RtlDeleteRegistryValue( ! 830: IN ULONG RelativeTo, ! 831: IN PWSTR Path, ! 832: IN PWSTR ValueName ! 833: ); ! 834: ! 835: NTSTATUS ! 836: NTAPI ! 837: RtlCreateRegistryKey( ! 838: IN ULONG RelativeTo, ! 839: IN PWSTR Path ! 840: ); ! 841: ! 842: NTSTATUS ! 843: NTAPI ! 844: RtlCheckRegistryKey( ! 845: IN ULONG RelativeTo, ! 846: IN PWSTR Path ! 847: ); ! 848: ! 849: // ! 850: // The following values for the RelativeTo parameter determine what the ! 851: // Path parameter to RtlQueryRegistryValues is relative to. ! 852: // ! 853: ! 854: #define RTL_REGISTRY_ABSOLUTE 0 // Path is a full path ! 855: #define RTL_REGISTRY_SERVICES 1 // \Registry\Machine\System\CurrentControlSet\Services ! 856: #define RTL_REGISTRY_CONTROL 2 // \Registry\Machine\System\CurrentControlSet\Control ! 857: #define RTL_REGISTRY_WINDOWS_NT 3 // \Registry\Machine\Software\Microsoft\Windows NT\CurrentVersion ! 858: #define RTL_REGISTRY_DEVICEMAP 4 // \Registry\Machine\Hardware\DeviceMap ! 859: #define RTL_REGISTRY_USER 5 // \Registry\User\CurrentUser ! 860: #define RTL_REGISTRY_MAXIMUM 6 ! 861: #define RTL_REGISTRY_HANDLE 0x40000000 // Low order bits are registry handle ! 862: #define RTL_REGISTRY_OPTIONAL 0x80000000 // Indicates the key node is optional ! 863: ! 864: NTSTATUS ! 865: RtlIntegerToUnicodeString ( ! 866: ULONG Value, ! 867: ULONG Base, ! 868: PUNICODE_STRING String ! 869: ); ! 870: // ! 871: // String manipulation routines ! 872: // ! 873: ! 874: VOID ! 875: NTAPI ! 876: RtlInitString( ! 877: PSTRING DestinationString, ! 878: PCSZ SourceString ! 879: ); ! 880: ! 881: VOID ! 882: NTAPI ! 883: RtlInitAnsiString( ! 884: PANSI_STRING DestinationString, ! 885: PCSZ SourceString ! 886: ); ! 887: ! 888: VOID ! 889: NTAPI ! 890: RtlInitUnicodeString( ! 891: PUNICODE_STRING DestinationString, ! 892: PCWSTR SourceString ! 893: ); ! 894: ! 895: ! 896: VOID ! 897: NTAPI ! 898: RtlCopyString( ! 899: PSTRING DestinationString, ! 900: PSTRING SourceString ! 901: ); ! 902: ! 903: ! 904: BOOLEAN ! 905: NTAPI ! 906: RtlEqualString( ! 907: PSTRING String1, ! 908: PSTRING String2, ! 909: BOOLEAN CaseInSensitive ! 910: ); ! 911: ! 912: ! 913: VOID ! 914: NTAPI ! 915: RtlUpperString( ! 916: PSTRING DestinationString, ! 917: PSTRING SourceString ! 918: ); ! 919: ! 920: // ! 921: // NLS String functions ! 922: // ! 923: ! 924: NTSTATUS ! 925: NTAPI ! 926: RtlAnsiStringToUnicodeString( ! 927: PUNICODE_STRING DestinationString, ! 928: PANSI_STRING SourceString, ! 929: BOOLEAN AllocateDestinationString ! 930: ); ! 931: ! 932: ! 933: NTSTATUS ! 934: NTAPI ! 935: RtlUnicodeStringToAnsiString( ! 936: PANSI_STRING DestinationString, ! 937: PUNICODE_STRING SourceString, ! 938: BOOLEAN AllocateDestinationString ! 939: ); ! 940: ! 941: ! 942: LONG ! 943: NTAPI ! 944: RtlCompareUnicodeString( ! 945: PUNICODE_STRING String1, ! 946: PUNICODE_STRING String2, ! 947: BOOLEAN CaseInSensitive ! 948: ); ! 949: ! 950: ! 951: BOOLEAN ! 952: NTAPI ! 953: RtlEqualUnicodeString( ! 954: PUNICODE_STRING String1, ! 955: PUNICODE_STRING String2, ! 956: BOOLEAN CaseInSensitive ! 957: ); ! 958: ! 959: ! 960: NTSTATUS ! 961: NTAPI ! 962: RtlUpcaseUnicodeString( ! 963: PUNICODE_STRING DestinationString, ! 964: PUNICODE_STRING SourceString, ! 965: BOOLEAN AllocateDestinationString ! 966: ); ! 967: ! 968: ! 969: VOID ! 970: NTAPI ! 971: RtlCopyUnicodeString( ! 972: PUNICODE_STRING DestinationString, ! 973: PUNICODE_STRING SourceString ! 974: ); ! 975: ! 976: NTSTATUS ! 977: NTAPI ! 978: RtlAppendUnicodeStringToString ( ! 979: PUNICODE_STRING Destination, ! 980: PUNICODE_STRING Source ! 981: ); ! 982: ! 983: NTSTATUS ! 984: NTAPI ! 985: RtlAppendUnicodeToString ( ! 986: PUNICODE_STRING Destination, ! 987: PWSTR Source ! 988: ); ! 989: ! 990: ! 991: VOID ! 992: NTAPI ! 993: RtlFreeUnicodeString( ! 994: PUNICODE_STRING UnicodeString ! 995: ); ! 996: ! 997: VOID ! 998: NTAPI ! 999: RtlFreeAnsiString( ! 1000: PANSI_STRING AnsiString ! 1001: ); ! 1002: ! 1003: ! 1004: ULONG ! 1005: NTAPI ! 1006: RtlAnsiStringToUnicodeSize( ! 1007: PANSI_STRING AnsiString ! 1008: ); ! 1009: ! 1010: // ! 1011: // Fast primitives to compare, move, and zero memory ! 1012: // ! 1013: ! 1014: // begin_winnt ! 1015: #ifdef _M_IX86 ! 1016: #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length)) ! 1017: #define RtlCopyMemory(Destination,Source,Length) memcpy((Destination),(Source),(Length)) ! 1018: #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length)) ! 1019: #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length)) ! 1020: #else ! 1021: #define RtlCopyMemory(Destination,Source,Length) RtlMoveMemory((Destination),(Source),(Length)) ! 1022: VOID ! 1023: NTAPI ! 1024: RtlMoveMemory ( ! 1025: PVOID Destination, ! 1026: CONST VOID *Source, ! 1027: ULONG Length ! 1028: ); ! 1029: ! 1030: VOID ! 1031: NTAPI ! 1032: RtlFillMemory ( ! 1033: PVOID Destination, ! 1034: ULONG Length, ! 1035: UCHAR Fill ! 1036: ); ! 1037: ! 1038: VOID ! 1039: NTAPI ! 1040: RtlZeroMemory ( ! 1041: PVOID Destination, ! 1042: ULONG Length ! 1043: ); ! 1044: #endif ! 1045: // end_winnt ! 1046: ! 1047: ULONG ! 1048: NTAPI ! 1049: RtlCompareMemory ( ! 1050: PVOID Source1, ! 1051: PVOID Source2, ! 1052: ULONG Length ! 1053: ); ! 1054: ! 1055: ! 1056: VOID ! 1057: DbgBreakPoint( ! 1058: VOID ! 1059: ); ! 1060: // ! 1061: // Define kernel debugger print prototypes and macros. ! 1062: // ! 1063: ! 1064: #if DBG ! 1065: ! 1066: #define KdPrint(_x_) DbgPrint _x_ ! 1067: ! 1068: #else ! 1069: ! 1070: #define KdPrint(_x_) ! 1071: ! 1072: #endif ! 1073: ! 1074: #ifndef _DBGNT_ ! 1075: ULONG ! 1076: DbgPrint( ! 1077: PCH Format, ! 1078: ... ! 1079: ); ! 1080: #endif // _DBGNT_ ! 1081: // ! 1082: // Large integer arithmetic routines. ! 1083: // ! 1084: ! 1085: // ! 1086: // Large integer add - 64-bits + 64-bits -> 64-bits ! 1087: // ! 1088: ! 1089: LARGE_INTEGER ! 1090: NTAPI ! 1091: RtlLargeIntegerAdd ( ! 1092: LARGE_INTEGER Addend1, ! 1093: LARGE_INTEGER Addend2 ! 1094: ); ! 1095: ! 1096: // ! 1097: // Enlarged integer multiply - 32-bits * 32-bits -> 64-bits ! 1098: // ! 1099: ! 1100: LARGE_INTEGER ! 1101: NTAPI ! 1102: RtlEnlargedIntegerMultiply ( ! 1103: LONG Multiplicand, ! 1104: LONG Multiplier ! 1105: ); ! 1106: ! 1107: // ! 1108: // Unsigned enlarged integer multiply - 32-bits * 32-bits -> 64-bits ! 1109: // ! 1110: ! 1111: LARGE_INTEGER ! 1112: NTAPI ! 1113: RtlEnlargedUnsignedMultiply ( ! 1114: ULONG Multiplicand, ! 1115: ULONG Multiplier ! 1116: ); ! 1117: ! 1118: // ! 1119: // Enlarged integer divide - 64-bits / 32-bits > 32-bits ! 1120: // ! 1121: ! 1122: ULONG ! 1123: NTAPI ! 1124: RtlEnlargedUnsignedDivide ( ! 1125: IN ULARGE_INTEGER Dividend, ! 1126: IN ULONG Divisor, ! 1127: IN PULONG Remainder ! 1128: ); ! 1129: ! 1130: // ! 1131: // Extended large integer magic divide - 64-bits / 32-bits -> 64-bits ! 1132: // ! 1133: ! 1134: LARGE_INTEGER ! 1135: NTAPI ! 1136: RtlExtendedMagicDivide ( ! 1137: LARGE_INTEGER Dividend, ! 1138: LARGE_INTEGER MagicDivisor, ! 1139: CCHAR ShiftCount ! 1140: ); ! 1141: ! 1142: // ! 1143: // Large Integer divide - 64-bits / 32-bits -> 64-bits ! 1144: // ! 1145: ! 1146: LARGE_INTEGER ! 1147: NTAPI ! 1148: RtlExtendedLargeIntegerDivide ( ! 1149: LARGE_INTEGER Dividend, ! 1150: ULONG Divisor, ! 1151: PULONG Remainder ! 1152: ); ! 1153: ! 1154: // ! 1155: // Large Integer divide - 64-bits / 32-bits -> 64-bits ! 1156: // ! 1157: ! 1158: LARGE_INTEGER ! 1159: NTAPI ! 1160: RtlLargeIntegerDivide ( ! 1161: LARGE_INTEGER Dividend, ! 1162: LARGE_INTEGER Divisor, ! 1163: PLARGE_INTEGER Remainder ! 1164: ); ! 1165: ! 1166: // ! 1167: // Extended integer multiply - 32-bits * 64-bits -> 64-bits ! 1168: // ! 1169: ! 1170: LARGE_INTEGER ! 1171: NTAPI ! 1172: RtlExtendedIntegerMultiply ( ! 1173: LARGE_INTEGER Multiplicand, ! 1174: LONG Multiplier ! 1175: ); ! 1176: ! 1177: // ! 1178: // Large integer negation - -(64-bits) ! 1179: // ! 1180: ! 1181: LARGE_INTEGER ! 1182: NTAPI ! 1183: RtlLargeIntegerNegate ( ! 1184: LARGE_INTEGER Subtrahend ! 1185: ); ! 1186: ! 1187: // ! 1188: // Large integer subtract - 64-bits - 64-bits -> 64-bits. ! 1189: // ! 1190: ! 1191: LARGE_INTEGER ! 1192: NTAPI ! 1193: RtlLargeIntegerSubtract ( ! 1194: LARGE_INTEGER Minuend, ! 1195: LARGE_INTEGER Subtrahend ! 1196: ); ! 1197: ! 1198: // ! 1199: // Large integer and - 64-bite & 64-bits -> 64-bits. ! 1200: // ! 1201: ! 1202: #define RtlLargeIntegerAnd(Result, Source, Mask) \ ! 1203: { \ ! 1204: Result.HighPart = Source.HighPart & Mask.HighPart; \ ! 1205: Result.LowPart = Source.LowPart & Mask.LowPart; \ ! 1206: } ! 1207: ! 1208: ! 1209: // ! 1210: // Large integer conversion routines. ! 1211: // ! 1212: ! 1213: // ! 1214: // Convert signed integer to large integer. ! 1215: // ! 1216: ! 1217: LARGE_INTEGER ! 1218: NTAPI ! 1219: RtlConvertLongToLargeInteger ( ! 1220: LONG SignedInteger ! 1221: ); ! 1222: ! 1223: // ! 1224: // Convert unsigned integer to large integer. ! 1225: // ! 1226: ! 1227: LARGE_INTEGER ! 1228: NTAPI ! 1229: RtlConvertUlongToLargeInteger ( ! 1230: ULONG UnsignedInteger ! 1231: ); ! 1232: ! 1233: ! 1234: // ! 1235: // Large integer shift routines. ! 1236: // ! 1237: ! 1238: LARGE_INTEGER ! 1239: NTAPI ! 1240: RtlLargeIntegerShiftLeft ( ! 1241: LARGE_INTEGER LargeInteger, ! 1242: CCHAR ShiftCount ! 1243: ); ! 1244: ! 1245: LARGE_INTEGER ! 1246: NTAPI ! 1247: RtlLargeIntegerShiftRight ( ! 1248: LARGE_INTEGER LargeInteger, ! 1249: CCHAR ShiftCount ! 1250: ); ! 1251: ! 1252: LARGE_INTEGER ! 1253: NTAPI ! 1254: RtlLargeIntegerArithmeticShift ( ! 1255: LARGE_INTEGER LargeInteger, ! 1256: CCHAR ShiftCount ! 1257: ); ! 1258: ! 1259: // ! 1260: // Large integer comparison routines. ! 1261: // ! 1262: // BOOLEAN ! 1263: // RtlLargeIntegerGreaterThan ( ! 1264: // LARGE_INTEGER Operand1, ! 1265: // LARGE_INTEGER Operand2 ! 1266: // ); ! 1267: // ! 1268: // BOOLEAN ! 1269: // RtlLargeIntegerGreaterThanOrEqualTo ( ! 1270: // LARGE_INTEGER Operand1, ! 1271: // LARGE_INTEGER Operand2 ! 1272: // ); ! 1273: // ! 1274: // BOOLEAN ! 1275: // RtlLargeIntegerEqualTo ( ! 1276: // LARGE_INTEGER Operand1, ! 1277: // LARGE_INTEGER Operand2 ! 1278: // ); ! 1279: // ! 1280: // BOOLEAN ! 1281: // RtlLargeIntegerNotEqualTo ( ! 1282: // LARGE_INTEGER Operand1, ! 1283: // LARGE_INTEGER Operand2 ! 1284: // ); ! 1285: // ! 1286: // BOOLEAN ! 1287: // RtlLargeIntegerLessThan ( ! 1288: // LARGE_INTEGER Operand1, ! 1289: // LARGE_INTEGER Operand2 ! 1290: // ); ! 1291: // ! 1292: // BOOLEAN ! 1293: // RtlLargeIntegerLessThanOrEqualTo ( ! 1294: // LARGE_INTEGER Operand1, ! 1295: // LARGE_INTEGER Operand2 ! 1296: // ); ! 1297: // ! 1298: // BOOLEAN ! 1299: // RtlLargeIntegerGreaterThanZero ( ! 1300: // LARGE_INTEGER Operand ! 1301: // ); ! 1302: // ! 1303: // BOOLEAN ! 1304: // RtlLargeIntegerGreaterOrEqualToZero ( ! 1305: // LARGE_INTEGER Operand ! 1306: // ); ! 1307: // ! 1308: // BOOLEAN ! 1309: // RtlLargeIntegerEqualToZero ( ! 1310: // LARGE_INTEGER Operand ! 1311: // ); ! 1312: // ! 1313: // BOOLEAN ! 1314: // RtlLargeIntegerNotEqualToZero ( ! 1315: // LARGE_INTEGER Operand ! 1316: // ); ! 1317: // ! 1318: // BOOLEAN ! 1319: // RtlLargeIntegerLessThanZero ( ! 1320: // LARGE_INTEGER Operand ! 1321: // ); ! 1322: // ! 1323: // BOOLEAN ! 1324: // RtlLargeIntegerLessOrEqualToZero ( ! 1325: // LARGE_INTEGER Operand ! 1326: // ); ! 1327: // ! 1328: ! 1329: #define RtlLargeIntegerGreaterThan(X,Y) ( \ ! 1330: (((X).HighPart == (Y).HighPart) && ((X).LowPart > (Y).LowPart)) || \ ! 1331: ((X).HighPart > (Y).HighPart) \ ! 1332: ) ! 1333: ! 1334: #define RtlLargeIntegerGreaterThanOrEqualTo(X,Y) ( \ ! 1335: (((X).HighPart == (Y).HighPart) && ((X).LowPart >= (Y).LowPart)) || \ ! 1336: ((X).HighPart > (Y).HighPart) \ ! 1337: ) ! 1338: ! 1339: #define RtlLargeIntegerEqualTo(X,Y) ( \ ! 1340: !(((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \ ! 1341: ) ! 1342: ! 1343: #define RtlLargeIntegerNotEqualTo(X,Y) ( \ ! 1344: (((X).LowPart ^ (Y).LowPart) | ((X).HighPart ^ (Y).HighPart)) \ ! 1345: ) ! 1346: ! 1347: #define RtlLargeIntegerLessThan(X,Y) ( \ ! 1348: (((X).HighPart == (Y).HighPart) && ((X).LowPart < (Y).LowPart)) || \ ! 1349: ((X).HighPart < (Y).HighPart) \ ! 1350: ) ! 1351: ! 1352: #define RtlLargeIntegerLessThanOrEqualTo(X,Y) ( \ ! 1353: (((X).HighPart == (Y).HighPart) && ((X).LowPart <= (Y).LowPart)) || \ ! 1354: ((X).HighPart < (Y).HighPart) \ ! 1355: ) ! 1356: ! 1357: #define RtlLargeIntegerGreaterThanZero(X) ( \ ! 1358: (((X).HighPart == 0) && ((X).LowPart > 0)) || \ ! 1359: ((X).HighPart > 0 ) \ ! 1360: ) ! 1361: ! 1362: #define RtlLargeIntegerGreaterOrEqualToZero(X) ( \ ! 1363: (X).HighPart >= 0 \ ! 1364: ) ! 1365: ! 1366: #define RtlLargeIntegerEqualToZero(X) ( \ ! 1367: !((X).LowPart | (X).HighPart) \ ! 1368: ) ! 1369: ! 1370: #define RtlLargeIntegerNotEqualToZero(X) ( \ ! 1371: ((X).LowPart | (X).HighPart) \ ! 1372: ) ! 1373: ! 1374: #define RtlLargeIntegerLessThanZero(X) ( \ ! 1375: ((X).HighPart < 0) \ ! 1376: ) ! 1377: ! 1378: #define RtlLargeIntegerLessOrEqualToZero(X) ( \ ! 1379: ((X).HighPart < 0) || !((X).LowPart | (X).HighPart) \ ! 1380: ) ! 1381: ! 1382: ! 1383: // ! 1384: // Time conversion routines ! 1385: // ! 1386: ! 1387: typedef struct _TIME_FIELDS { ! 1388: CSHORT Year; // range [1601...] ! 1389: CSHORT Month; // range [1..12] ! 1390: CSHORT Day; // range [1..31] ! 1391: CSHORT Hour; // range [0..23] ! 1392: CSHORT Minute; // range [0..59] ! 1393: CSHORT Second; // range [0..59] ! 1394: CSHORT Milliseconds;// range [0..999] ! 1395: CSHORT Weekday; // range [0..6] == [Sunday..Saturday] ! 1396: } TIME_FIELDS; ! 1397: typedef TIME_FIELDS *PTIME_FIELDS; ! 1398: ! 1399: ! 1400: VOID ! 1401: NTAPI ! 1402: RtlTimeToTimeFields ( ! 1403: PLARGE_INTEGER Time, ! 1404: PTIME_FIELDS TimeFields ! 1405: ); ! 1406: ! 1407: // ! 1408: // The following macros store and retrieve USHORTS and ULONGS from potentially ! 1409: // unaligned addresses, avoiding alignment faults. they should probably be ! 1410: // rewritten in assembler ! 1411: // ! 1412: ! 1413: #define SHORT_SIZE (sizeof(USHORT)) ! 1414: #define SHORT_MASK (SHORT_SIZE - 1) ! 1415: #define LONG_SIZE (sizeof(LONG)) ! 1416: #define LONG_MASK (LONG_SIZE - 1) ! 1417: #define LOWBYTE_MASK 0x00FF ! 1418: ! 1419: #define FIRSTBYTE(VALUE) (VALUE & LOWBYTE_MASK) ! 1420: #define SECONDBYTE(VALUE) ((VALUE >> 8) & LOWBYTE_MASK) ! 1421: #define THIRDBYTE(VALUE) ((VALUE >> 16) & LOWBYTE_MASK) ! 1422: #define FOURTHBYTE(VALUE) ((VALUE >> 24) & LOWBYTE_MASK) ! 1423: ! 1424: // ! 1425: // if MIPS Big Endian, order of bytes is reversed. ! 1426: // ! 1427: ! 1428: #define SHORT_LEAST_SIGNIFICANT_BIT 0 ! 1429: #define SHORT_MOST_SIGNIFICANT_BIT 1 ! 1430: ! 1431: #define LONG_LEAST_SIGNIFICANT_BIT 0 ! 1432: #define LONG_3RD_MOST_SIGNIFICANT_BIT 1 ! 1433: #define LONG_2ND_MOST_SIGNIFICANT_BIT 2 ! 1434: #define LONG_MOST_SIGNIFICANT_BIT 3 ! 1435: ! 1436: //++ ! 1437: // ! 1438: // VOID ! 1439: // RtlStoreUshort ( ! 1440: // PUSHORT ADDRESS ! 1441: // USHORT VALUE ! 1442: // ) ! 1443: // ! 1444: // Routine Description: ! 1445: // ! 1446: // This macro stores a USHORT value in at a particular address, avoiding ! 1447: // alignment faults. ! 1448: // ! 1449: // Arguments: ! 1450: // ! 1451: // ADDRESS - where to store USHORT value ! 1452: // VALUE - USHORT to store ! 1453: // ! 1454: // Return Value: ! 1455: // ! 1456: // none. ! 1457: // ! 1458: //-- ! 1459: ! 1460: #define RtlStoreUshort(ADDRESS,VALUE) \ ! 1461: if ((ULONG)ADDRESS & SHORT_MASK) { \ ! 1462: ((PUCHAR) ADDRESS)[SHORT_LEAST_SIGNIFICANT_BIT] = (UCHAR)(FIRSTBYTE(VALUE)); \ ! 1463: ((PUCHAR) ADDRESS)[SHORT_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(VALUE)); \ ! 1464: } \ ! 1465: else { \ ! 1466: *((PUSHORT) ADDRESS) = (USHORT) VALUE; \ ! 1467: } ! 1468: ! 1469: ! 1470: //++ ! 1471: // ! 1472: // VOID ! 1473: // RtlStoreUlong ( ! 1474: // PULONG ADDRESS ! 1475: // ULONG VALUE ! 1476: // ) ! 1477: // ! 1478: // Routine Description: ! 1479: // ! 1480: // This macro stores a ULONG value in at a particular address, avoiding ! 1481: // alignment faults. ! 1482: // ! 1483: // Arguments: ! 1484: // ! 1485: // ADDRESS - where to store ULONG value ! 1486: // VALUE - ULONG to store ! 1487: // ! 1488: // Return Value: ! 1489: // ! 1490: // none. ! 1491: // ! 1492: // Note: ! 1493: // Depending on the machine, we might want to call storeushort in the ! 1494: // unaligned case. ! 1495: // ! 1496: //-- ! 1497: ! 1498: #define RtlStoreUlong(ADDRESS,VALUE) \ ! 1499: if ((ULONG)ADDRESS & LONG_MASK) { \ ! 1500: ((PUCHAR) ADDRESS)[LONG_LEAST_SIGNIFICANT_BIT ] = (UCHAR)(FIRSTBYTE(VALUE)); \ ! 1501: ((PUCHAR) ADDRESS)[LONG_3RD_MOST_SIGNIFICANT_BIT ] = (UCHAR)(SECONDBYTE(VALUE)); \ ! 1502: ((PUCHAR) ADDRESS)[LONG_2ND_MOST_SIGNIFICANT_BIT ] = (UCHAR)(THIRDBYTE(VALUE)); \ ! 1503: ((PUCHAR) ADDRESS)[LONG_MOST_SIGNIFICANT_BIT ] = (UCHAR)(FOURTHBYTE(VALUE)); \ ! 1504: } \ ! 1505: else { \ ! 1506: *((PULONG) ADDRESS) = (ULONG) VALUE; \ ! 1507: } ! 1508: ! 1509: //++ ! 1510: // ! 1511: // VOID ! 1512: // RtlRetrieveUshort ( ! 1513: // PUSHORT DESTINATION_ADDRESS ! 1514: // PUSHORT SOURCE_ADDRESS ! 1515: // ) ! 1516: // ! 1517: // Routine Description: ! 1518: // ! 1519: // This macro retrieves a USHORT value from the SOURCE address, avoiding ! 1520: // alignment faults. The DESTINATION address is assumed to be aligned. ! 1521: // ! 1522: // Arguments: ! 1523: // ! 1524: // DESTINATION_ADDRESS - where to store USHORT value ! 1525: // SOURCE_ADDRESS - where to retrieve USHORT value from ! 1526: // ! 1527: // Return Value: ! 1528: // ! 1529: // none. ! 1530: // ! 1531: //-- ! 1532: ! 1533: #define RtlRetrieveUshort(DEST_ADDRESS,SRC_ADDRESS) \ ! 1534: if ((ULONG)SRC_ADDRESS & SHORT_MASK) { \ ! 1535: ((PUCHAR) DEST_ADDRESS)[0] = ((PUCHAR) SRC_ADDRESS)[0]; \ ! 1536: ((PUCHAR) DEST_ADDRESS)[1] = ((PUCHAR) SRC_ADDRESS)[1]; \ ! 1537: } \ ! 1538: else { \ ! 1539: *((PUSHORT) DEST_ADDRESS) = *((PUSHORT) SRC_ADDRESS); \ ! 1540: } \ ! 1541: ! 1542: //++ ! 1543: // ! 1544: // VOID ! 1545: // RtlRetrieveUlong ( ! 1546: // PULONG DESTINATION_ADDRESS ! 1547: // PULONG SOURCE_ADDRESS ! 1548: // ) ! 1549: // ! 1550: // Routine Description: ! 1551: // ! 1552: // This macro retrieves a ULONG value from the SOURCE address, avoiding ! 1553: // alignment faults. The DESTINATION address is assumed to be aligned. ! 1554: // ! 1555: // Arguments: ! 1556: // ! 1557: // DESTINATION_ADDRESS - where to store ULONG value ! 1558: // SOURCE_ADDRESS - where to retrieve ULONG value from ! 1559: // ! 1560: // Return Value: ! 1561: // ! 1562: // none. ! 1563: // ! 1564: // Note: ! 1565: // Depending on the machine, we might want to call retrieveushort in the ! 1566: // unaligned case. ! 1567: // ! 1568: //-- ! 1569: ! 1570: #define RtlRetrieveUlong(DEST_ADDRESS,SRC_ADDRESS) \ ! 1571: if ((ULONG)SRC_ADDRESS & LONG_MASK) { \ ! 1572: ((PUCHAR) DEST_ADDRESS)[0] = ((PUCHAR) SRC_ADDRESS)[0]; \ ! 1573: ((PUCHAR) DEST_ADDRESS)[1] = ((PUCHAR) SRC_ADDRESS)[1]; \ ! 1574: ((PUCHAR) DEST_ADDRESS)[2] = ((PUCHAR) SRC_ADDRESS)[2]; \ ! 1575: ((PUCHAR) DEST_ADDRESS)[3] = ((PUCHAR) SRC_ADDRESS)[3]; \ ! 1576: } \ ! 1577: else { \ ! 1578: *((PULONG) DEST_ADDRESS) = *((PULONG) SRC_ADDRESS); \ ! 1579: } ! 1580: // ! 1581: // SecurityDescriptor RTL routine definitions ! 1582: // ! 1583: ! 1584: NTSTATUS ! 1585: NTAPI ! 1586: RtlCreateSecurityDescriptor ( ! 1587: PSECURITY_DESCRIPTOR SecurityDescriptor, ! 1588: ULONG Revision ! 1589: ); ! 1590: ! 1591: NTSTATUS ! 1592: NTAPI ! 1593: RtlSetDaclSecurityDescriptor ( ! 1594: PSECURITY_DESCRIPTOR SecurityDescriptor, ! 1595: BOOLEAN DaclPresent, ! 1596: PACL Dacl, ! 1597: BOOLEAN DaclDefaulted ! 1598: ); ! 1599: ! 1600: // ! 1601: // Define the various device type values. Note that values used by Microsoft ! 1602: // Corporation are in the range 0-32767, and 32768-65535 are reserved for use ! 1603: // by customers. ! 1604: // ! 1605: ! 1606: #define DEVICE_TYPE ULONG ! 1607: ! 1608: #define FILE_DEVICE_BEEP 0x00000001 ! 1609: #define FILE_DEVICE_CD_ROM 0x00000002 ! 1610: #define FILE_DEVICE_CD_ROM_FILE_SYSTEM 0x00000003 ! 1611: #define FILE_DEVICE_CONTROLLER 0x00000004 ! 1612: #define FILE_DEVICE_DATALINK 0x00000005 ! 1613: #define FILE_DEVICE_DFS 0x00000006 ! 1614: #define FILE_DEVICE_DISK 0x00000007 ! 1615: #define FILE_DEVICE_DISK_FILE_SYSTEM 0x00000008 ! 1616: #define FILE_DEVICE_FILE_SYSTEM 0x00000009 ! 1617: #define FILE_DEVICE_INPORT_PORT 0x0000000a ! 1618: #define FILE_DEVICE_KEYBOARD 0x0000000b ! 1619: #define FILE_DEVICE_MAILSLOT 0x0000000c ! 1620: #define FILE_DEVICE_MIDI_IN 0x0000000d ! 1621: #define FILE_DEVICE_MIDI_OUT 0x0000000e ! 1622: #define FILE_DEVICE_MOUSE 0x0000000f ! 1623: #define FILE_DEVICE_MULTI_UNC_PROVIDER 0x00000010 ! 1624: #define FILE_DEVICE_NAMED_PIPE 0x00000011 ! 1625: #define FILE_DEVICE_NETWORK 0x00000012 ! 1626: #define FILE_DEVICE_NETWORK_BROWSER 0x00000013 ! 1627: #define FILE_DEVICE_NETWORK_FILE_SYSTEM 0x00000014 ! 1628: #define FILE_DEVICE_NULL 0x00000015 ! 1629: #define FILE_DEVICE_PARALLEL_PORT 0x00000016 ! 1630: #define FILE_DEVICE_PHYSICAL_NETCARD 0x00000017 ! 1631: #define FILE_DEVICE_PRINTER 0x00000018 ! 1632: #define FILE_DEVICE_SCANNER 0x00000019 ! 1633: #define FILE_DEVICE_SERIAL_MOUSE_PORT 0x0000001a ! 1634: #define FILE_DEVICE_SERIAL_PORT 0x0000001b ! 1635: #define FILE_DEVICE_SCREEN 0x0000001c ! 1636: #define FILE_DEVICE_SOUND 0x0000001d ! 1637: #define FILE_DEVICE_STREAMS 0x0000001e ! 1638: #define FILE_DEVICE_TAPE 0x0000001f ! 1639: #define FILE_DEVICE_TAPE_FILE_SYSTEM 0x00000020 ! 1640: #define FILE_DEVICE_TRANSPORT 0x00000021 ! 1641: #define FILE_DEVICE_UNKNOWN 0x00000022 ! 1642: #define FILE_DEVICE_VIDEO 0x00000023 ! 1643: #define FILE_DEVICE_VIRTUAL_DISK 0x00000024 ! 1644: #define FILE_DEVICE_WAVE_IN 0x00000025 ! 1645: #define FILE_DEVICE_WAVE_OUT 0x00000026 ! 1646: #define FILE_DEVICE_8042_PORT 0x00000027 ! 1647: #define FILE_DEVICE_NETWORK_REDIRECTOR 0x00000028 ! 1648: ! 1649: // ! 1650: // Macro definition for defining IOCTL and FSCTL function control codes. Note ! 1651: // that function codes 0-2047 are reserved for Microsoft Corporation, and ! 1652: // 2048-4095 are reserved for customers. ! 1653: // ! 1654: ! 1655: #define CTL_CODE( DeviceType, Function, Method, Access ) ( \ ! 1656: ((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method) \ ! 1657: ) ! 1658: ! 1659: // ! 1660: // Define the method codes for how buffers are passed for I/O and FS controls ! 1661: // ! 1662: ! 1663: #define METHOD_BUFFERED 0 ! 1664: #define METHOD_IN_DIRECT 1 ! 1665: #define METHOD_OUT_DIRECT 2 ! 1666: #define METHOD_NEITHER 3 ! 1667: ! 1668: // ! 1669: // Define the access check value for any access ! 1670: // ! 1671: // ! 1672: // The FILE_READ_ACCESS and FILE_WRITE_ACCESS constants are also defined in ! 1673: // ntioapi.h as FILE_READ_DATA and FILE_WRITE_DATA. The values for these ! 1674: // constants *MUST* always be in sync. ! 1675: // ! 1676: ! 1677: ! 1678: #define FILE_ANY_ACCESS 0 ! 1679: #define FILE_READ_ACCESS ( 0x0001 ) // file & pipe ! 1680: #define FILE_WRITE_ACCESS ( 0x0002 ) // file & pipe ! 1681: ! 1682: ! 1683: // begin_winnt ! 1684: ! 1685: // ! 1686: // Define access rights to files and directories ! 1687: // ! 1688: ! 1689: // ! 1690: // The FILE_READ_DATA and FILE_WRITE_DATA constants are also defined in ! 1691: // devioctl.h as FILE_READ_ACCESS and FILE_WRITE_ACCESS. The values for these ! 1692: // constants *MUST* always be in sync. ! 1693: // The values are redefined in devioctl.h because they must be available to ! 1694: // both DOS and NT. ! 1695: // ! 1696: ! 1697: #define FILE_READ_DATA ( 0x0001 ) // file & pipe ! 1698: #define FILE_LIST_DIRECTORY ( 0x0001 ) // directory ! 1699: ! 1700: #define FILE_WRITE_DATA ( 0x0002 ) // file & pipe ! 1701: #define FILE_ADD_FILE ( 0x0002 ) // directory ! 1702: ! 1703: #define FILE_APPEND_DATA ( 0x0004 ) // file ! 1704: #define FILE_ADD_SUBDIRECTORY ( 0x0004 ) // directory ! 1705: #define FILE_CREATE_PIPE_INSTANCE ( 0x0004 ) // named pipe ! 1706: ! 1707: #define FILE_READ_EA ( 0x0008 ) // file & directory ! 1708: ! 1709: #define FILE_WRITE_EA ( 0x0010 ) // file & directory ! 1710: ! 1711: #define FILE_EXECUTE ( 0x0020 ) // file ! 1712: #define FILE_TRAVERSE ( 0x0020 ) // directory ! 1713: ! 1714: #define FILE_DELETE_CHILD ( 0x0040 ) // directory ! 1715: ! 1716: #define FILE_READ_ATTRIBUTES ( 0x0080 ) // all ! 1717: ! 1718: #define FILE_WRITE_ATTRIBUTES ( 0x0100 ) // all ! 1719: ! 1720: #define FILE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF) ! 1721: ! 1722: ! 1723: #define FILE_GENERIC_READ (STANDARD_RIGHTS_READ |\ ! 1724: FILE_READ_DATA |\ ! 1725: FILE_READ_ATTRIBUTES |\ ! 1726: FILE_READ_EA |\ ! 1727: SYNCHRONIZE) ! 1728: ! 1729: ! 1730: #define FILE_GENERIC_WRITE (STANDARD_RIGHTS_WRITE |\ ! 1731: FILE_WRITE_DATA |\ ! 1732: FILE_WRITE_ATTRIBUTES |\ ! 1733: FILE_WRITE_EA |\ ! 1734: FILE_APPEND_DATA |\ ! 1735: SYNCHRONIZE) ! 1736: ! 1737: ! 1738: #define FILE_GENERIC_EXECUTE (STANDARD_RIGHTS_EXECUTE |\ ! 1739: FILE_READ_ATTRIBUTES |\ ! 1740: FILE_EXECUTE |\ ! 1741: SYNCHRONIZE) ! 1742: ! 1743: // end_winnt ! 1744: ! 1745: ! 1746: // ! 1747: // Define share access rights to files and directories ! 1748: // ! 1749: ! 1750: #define FILE_SHARE_READ 0x00000001 // winnt ! 1751: #define FILE_SHARE_WRITE 0x00000002 // winnt ! 1752: #define FILE_SHARE_DELETE 0x00000004 ! 1753: #define FILE_SHARE_VALID_FLAGS 0x00000007 ! 1754: ! 1755: // ! 1756: // Define the file attributes values ! 1757: // ! 1758: // Note: 0x00000008 is reserved for use for the old DOS VOLID (volume ID) ! 1759: // and is therefore not considered valid in NT. ! 1760: // ! 1761: // Note: 0x00000010 is reserved for use for the old DOS SUBDIRECTORY flag ! 1762: // and is therefore not considered valid in NT. This flag has ! 1763: // been disassociated with file attributes since the other flags are ! 1764: // protected with READ_ and WRITE_ATTRIBUTES access to the file. ! 1765: // ! 1766: // Note: Note also that the order of these flags is set to allow both the ! 1767: // FAT and the Pinball File Systems to directly set the attributes ! 1768: // flags in attributes words without having to pick each flag out ! 1769: // individually. The order of these flags should not be changed! ! 1770: // ! 1771: ! 1772: #define FILE_ATTRIBUTE_READONLY 0x00000001 // winnt ! 1773: #define FILE_ATTRIBUTE_HIDDEN 0x00000002 // winnt ! 1774: #define FILE_ATTRIBUTE_SYSTEM 0x00000004 // winnt ! 1775: #define FILE_ATTRIBUTE_DIRECTORY 0x00000010 // winnt ! 1776: #define FILE_ATTRIBUTE_ARCHIVE 0x00000020 // winnt ! 1777: #define FILE_ATTRIBUTE_NORMAL 0x00000080 // winnt ! 1778: #define FILE_ATTRIBUTE_TEMPORARY 0x00000100 // winnt ! 1779: #define FILE_ATTRIBUTE_ATOMIC_WRITE 0x00000200 // winnt ! 1780: #define FILE_ATTRIBUTE_XACTION_WRITE 0x00000400 // winnt ! 1781: #define FILE_ATTRIBUTE_VALID_FLAGS 0x000007b7 ! 1782: ! 1783: // ! 1784: // Define the create disposition values ! 1785: // ! 1786: ! 1787: #define FILE_SUPERSEDE 0x00000000 ! 1788: #define FILE_OPEN 0x00000001 ! 1789: #define FILE_CREATE 0x00000002 ! 1790: #define FILE_OPEN_IF 0x00000003 ! 1791: #define FILE_OVERWRITE 0x00000004 ! 1792: #define FILE_OVERWRITE_IF 0x00000005 ! 1793: #define FILE_MAXIMUM_DISPOSITION 0x00000005 ! 1794: ! 1795: // ! 1796: // Define the create/open option flags ! 1797: // ! 1798: ! 1799: #define FILE_DIRECTORY_FILE 0x00000001 ! 1800: #define FILE_WRITE_THROUGH 0x00000002 ! 1801: #define FILE_SEQUENTIAL_ONLY 0x00000004 ! 1802: #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008 ! 1803: #define FILE_SYNCHRONOUS_IO_ALERT 0x00000010 ! 1804: #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020 ! 1805: #define FILE_NON_DIRECTORY_FILE 0x00000040 ! 1806: #define FILE_CREATE_TREE_CONNECTION 0x00000080 ! 1807: #define FILE_COMPLETE_IF_OPLOCKED 0x00000100 ! 1808: #define FILE_NO_EA_KNOWLEDGE 0x00000200 ! 1809: #define FILE_EIGHT_DOT_THREE_ONLY 0x00000400 ! 1810: #define FILE_RANDOM_ACCESS 0x00000800 ! 1811: #define FILE_DELETE_ON_CLOSE 0x00001000 ! 1812: #define FILE_OPEN_BY_FILE_ID 0x00002000 ! 1813: #define FILE_OPEN_FOR_BACKUP_INTENT 0x00004000 ! 1814: #define FILE_VALID_OPTION_FLAGS 0x00007FFF ! 1815: #define FILE_VALID_PIPE_OPTION_FLAGS 0x00000032 ! 1816: #define FILE_VALID_MAILSLOT_OPTION_FLAGS 0x00000032 ! 1817: #define FILE_VALID_SET_FLAGS 0x00001036 ! 1818: ! 1819: // ! 1820: // Define the I/O status information return values for NtCreateFile/NtOpenFile ! 1821: // ! 1822: ! 1823: #define FILE_SUPERSEDED 0x00000000 ! 1824: #define FILE_OPENED 0x00000001 ! 1825: #define FILE_CREATED 0x00000002 ! 1826: #define FILE_OVERWRITTEN 0x00000003 ! 1827: #define FILE_EXISTS 0x00000004 ! 1828: #define FILE_DOES_NOT_EXIST 0x00000005 ! 1829: ! 1830: // ! 1831: // Define special ByteOffset parameters for read and write operations ! 1832: // ! 1833: ! 1834: #define FILE_WRITE_TO_END_OF_FILE 0xffffffff ! 1835: #define FILE_USE_FILE_POINTER_POSITION 0xfffffffe ! 1836: ! 1837: // ! 1838: // Define alignment requirement values ! 1839: // ! 1840: ! 1841: #define FILE_BYTE_ALIGNMENT 0x00000000 ! 1842: #define FILE_WORD_ALIGNMENT 0x00000001 ! 1843: #define FILE_LONG_ALIGNMENT 0x00000003 ! 1844: #define FILE_QUAD_ALIGNMENT 0x00000007 ! 1845: #define FILE_OCTA_ALIGNMENT 0x0000000f ! 1846: #define FILE_32_BYTE_ALIGNMENT 0x0000001f ! 1847: #define FILE_64_BYTE_ALIGNMENT 0x0000003f ! 1848: #define FILE_128_BYTE_ALIGNMENT 0x0000007f ! 1849: #define FILE_256_BYTE_ALIGNMENT 0x000000ff ! 1850: #define FILE_512_BYTE_ALIGNMENT 0x000001ff ! 1851: ! 1852: // ! 1853: // Define the maximum length of a filename string ! 1854: // ! 1855: ! 1856: #define MAXIMUM_FILENAME_LENGTH 256 ! 1857: ! 1858: // ! 1859: // Define the various device characteristics flags ! 1860: // ! 1861: ! 1862: #define FILE_REMOVABLE_MEDIA 0x00000001 ! 1863: #define FILE_READ_ONLY_DEVICE 0x00000002 ! 1864: #define FILE_FLOPPY_DISKETTE 0x00000004 ! 1865: #define FILE_WRITE_ONCE_MEDIA 0x00000008 ! 1866: #define FILE_REMOTE_DEVICE 0x00000010 ! 1867: #define FILE_DEVICE_IS_MOUNTED 0x00000020 ! 1868: ! 1869: // ! 1870: // Define the base asynchronous I/O argument types ! 1871: // ! 1872: ! 1873: typedef struct _IO_STATUS_BLOCK { ! 1874: NTSTATUS Status; ! 1875: ULONG Information; ! 1876: } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK; ! 1877: ! 1878: // ! 1879: // Define an Asynchronous Procedure Call from I/O viewpoint ! 1880: // ! 1881: ! 1882: typedef ! 1883: VOID ! 1884: (*PIO_APC_ROUTINE) ( ! 1885: IN PVOID ApcContext, ! 1886: IN PIO_STATUS_BLOCK IoStatusBlock, ! 1887: IN ULONG Reserved ! 1888: ); ! 1889: ! 1890: // ! 1891: // Define the file information class values ! 1892: // ! 1893: // WARNING: The order of the following values are assumed by the I/O system. ! 1894: // Any changes made here should be reflected there as well. ! 1895: // ! 1896: ! 1897: typedef enum _FILE_INFORMATION_CLASS { ! 1898: FileDirectoryInformation = 1, ! 1899: FileFullDirectoryInformation, ! 1900: FileBothDirectoryInformation, ! 1901: FileBasicInformation, ! 1902: FileStandardInformation, ! 1903: FileInternalInformation, ! 1904: FileEaInformation, ! 1905: FileAccessInformation, ! 1906: FileNameInformation, ! 1907: FileRenameInformation, ! 1908: FileLinkInformation, ! 1909: FileNamesInformation, ! 1910: FileDispositionInformation, ! 1911: FilePositionInformation, ! 1912: FileFullEaInformation, ! 1913: FileModeInformation, ! 1914: FileAlignmentInformation, ! 1915: FileAllInformation, ! 1916: FileAllocationInformation, ! 1917: FileEndOfFileInformation, ! 1918: FileAlternateNameInformation, ! 1919: FileStreamInformation, ! 1920: FilePipeInformation, ! 1921: FilePipeLocalInformation, ! 1922: FilePipeRemoteInformation, ! 1923: FileMailslotQueryInformation, ! 1924: FileMailslotSetInformation, ! 1925: FileMaximumInformation ! 1926: } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS; ! 1927: ! 1928: // ! 1929: // Define the various structures which are returned on query operations ! 1930: // ! 1931: ! 1932: typedef struct _FILE_BASIC_INFORMATION { ! 1933: LARGE_INTEGER CreationTime; ! 1934: LARGE_INTEGER LastAccessTime; ! 1935: LARGE_INTEGER LastWriteTime; ! 1936: LARGE_INTEGER ChangeTime; ! 1937: ULONG FileAttributes; ! 1938: } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION; ! 1939: ! 1940: typedef struct _FILE_STANDARD_INFORMATION { ! 1941: LARGE_INTEGER AllocationSize; ! 1942: LARGE_INTEGER EndOfFile; ! 1943: ULONG NumberOfLinks; ! 1944: BOOLEAN DeletePending; ! 1945: BOOLEAN Directory; ! 1946: } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION; ! 1947: ! 1948: typedef struct _FILE_POSITION_INFORMATION { ! 1949: LARGE_INTEGER CurrentByteOffset; ! 1950: } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION; ! 1951: ! 1952: ! 1953: typedef struct _FILE_FULL_EA_INFORMATION { ! 1954: ULONG NextEntryOffset; ! 1955: UCHAR Flags; ! 1956: UCHAR EaNameLength; ! 1957: USHORT EaValueLength; ! 1958: CHAR EaName[1]; ! 1959: } FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION; ! 1960: ! 1961: // ! 1962: // Define the file system information class values ! 1963: // ! 1964: // WARNING: The order of the following values are assumed by the I/O system. ! 1965: // Any changes made here should be reflected there as well. ! 1966: ! 1967: typedef enum _FSINFOCLASS { ! 1968: FileFsVolumeInformation = 1, ! 1969: FileFsLabelInformation, ! 1970: FileFsSizeInformation, ! 1971: FileFsDeviceInformation, ! 1972: FileFsAttributeInformation, ! 1973: FileFsMaximumInformation ! 1974: } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS; ! 1975: ! 1976: typedef struct _FILE_FS_DEVICE_INFORMATION { ! 1977: DEVICE_TYPE DeviceType; ! 1978: ULONG Characteristics; ! 1979: } FILE_FS_DEVICE_INFORMATION, *PFILE_FS_DEVICE_INFORMATION; ! 1980: ! 1981: // ! 1982: // Define the I/O bus interface types. ! 1983: // ! 1984: ! 1985: typedef enum _INTERFACE_TYPE { ! 1986: Internal, ! 1987: Isa, ! 1988: Eisa, ! 1989: MicroChannel, ! 1990: TurboChannel, ! 1991: PCIBus, ! 1992: VMEBus, ! 1993: NuBus, ! 1994: PCMCIABus, ! 1995: CBus, ! 1996: MPIBus, ! 1997: MPSABus, ! 1998: MaximumInterfaceType ! 1999: }INTERFACE_TYPE, *PINTERFACE_TYPE; ! 2000: ! 2001: // ! 2002: // Define the DMA transfer widths. ! 2003: // ! 2004: ! 2005: typedef enum _DMA_WIDTH { ! 2006: Width8Bits, ! 2007: Width16Bits, ! 2008: Width32Bits, ! 2009: MaximumDmaWidth ! 2010: }DMA_WIDTH, *PDMA_WIDTH; ! 2011: ! 2012: // ! 2013: // Define DMA transfer speeds. ! 2014: // ! 2015: ! 2016: typedef enum _DMA_SPEED { ! 2017: Compatible, ! 2018: TypeA, ! 2019: TypeB, ! 2020: TypeC, ! 2021: MaximumDmaSpeed ! 2022: }DMA_SPEED, *PDMA_SPEED; ! 2023: ! 2024: // ! 2025: // Define I/O Driver error log packet structure. This structure is filled in ! 2026: // by the driver. ! 2027: // ! 2028: ! 2029: typedef struct _IO_ERROR_LOG_PACKET { ! 2030: UCHAR MajorFunctionCode; ! 2031: UCHAR RetryCount; ! 2032: USHORT DumpDataSize; ! 2033: USHORT NumberOfStrings; ! 2034: USHORT StringOffset; ! 2035: USHORT EventCategory; ! 2036: NTSTATUS ErrorCode; ! 2037: ULONG UniqueErrorValue; ! 2038: NTSTATUS FinalStatus; ! 2039: ULONG SequenceNumber; ! 2040: ULONG IoControlCode; ! 2041: LARGE_INTEGER DeviceOffset; ! 2042: ULONG DumpData[1]; ! 2043: }IO_ERROR_LOG_PACKET, *PIO_ERROR_LOG_PACKET; ! 2044: ! 2045: // ! 2046: // Define the I/O error log message. This message is sent by the error log ! 2047: // thread over the lpc port. ! 2048: // ! 2049: ! 2050: typedef struct _IO_ERROR_LOG_MESSAGE { ! 2051: USHORT Type; ! 2052: USHORT Size; ! 2053: USHORT DriverNameLength; ! 2054: LARGE_INTEGER TimeStamp; ! 2055: ULONG DriverNameOffset; ! 2056: IO_ERROR_LOG_PACKET EntryData; ! 2057: }IO_ERROR_LOG_MESSAGE, *PIO_ERROR_LOG_MESSAGE; ! 2058: ! 2059: // ! 2060: // Define the maximum message size that will be sent over the LPC to the ! 2061: // application reading the error log entries. ! 2062: // ! 2063: ! 2064: #define IO_ERROR_LOG_MESSAGE_LENGTH PORT_MAXIMUM_MESSAGE_LENGTH ! 2065: ! 2066: // ! 2067: // Define the maximum packet size a driver can allocate. ! 2068: // ! 2069: ! 2070: #define ERROR_LOG_MAXIMUM_SIZE (IO_ERROR_LOG_MESSAGE_LENGTH + sizeof(IO_ERROR_LOG_PACKET) - \ ! 2071: sizeof(IO_ERROR_LOG_MESSAGE) - (sizeof(WCHAR) * 40)) ! 2072: ! 2073: #define PORT_MAXIMUM_MESSAGE_LENGTH 256 ! 2074: // ! 2075: // Registry Specific Access Rights. ! 2076: // ! 2077: ! 2078: #define KEY_QUERY_VALUE (0x0001) ! 2079: #define KEY_SET_VALUE (0x0002) ! 2080: #define KEY_CREATE_SUB_KEY (0x0004) ! 2081: #define KEY_ENUMERATE_SUB_KEYS (0x0008) ! 2082: #define KEY_NOTIFY (0x0010) ! 2083: #define KEY_CREATE_LINK (0x0020) ! 2084: ! 2085: #define KEY_READ ((STANDARD_RIGHTS_READ |\ ! 2086: KEY_QUERY_VALUE |\ ! 2087: KEY_ENUMERATE_SUB_KEYS |\ ! 2088: KEY_NOTIFY) \ ! 2089: & \ ! 2090: (~SYNCHRONIZE)) ! 2091: ! 2092: ! 2093: #define KEY_WRITE ((STANDARD_RIGHTS_WRITE |\ ! 2094: KEY_SET_VALUE |\ ! 2095: KEY_CREATE_SUB_KEY) \ ! 2096: & \ ! 2097: (~SYNCHRONIZE)) ! 2098: ! 2099: #define KEY_EXECUTE ((KEY_READ) \ ! 2100: & \ ! 2101: (~SYNCHRONIZE)) ! 2102: ! 2103: #define KEY_ALL_ACCESS ((STANDARD_RIGHTS_ALL |\ ! 2104: KEY_QUERY_VALUE |\ ! 2105: KEY_SET_VALUE |\ ! 2106: KEY_CREATE_SUB_KEY |\ ! 2107: KEY_ENUMERATE_SUB_KEYS |\ ! 2108: KEY_NOTIFY |\ ! 2109: KEY_CREATE_LINK) \ ! 2110: & \ ! 2111: (~SYNCHRONIZE)) ! 2112: ! 2113: // ! 2114: // Open/Create Options ! 2115: // ! 2116: ! 2117: #define REG_OPTION_RESERVED (0x00000000L) // Parameter is reserved ! 2118: ! 2119: #define REG_OPTION_NON_VOLATILE (0x00000000L) // Key is preserved ! 2120: // when system is rebooted ! 2121: ! 2122: #define REG_OPTION_VOLATILE (0x00000001L) // Key is not preserved ! 2123: // when system is rebooted ! 2124: ! 2125: #define REG_OPTION_CREATE_LINK (0x00000002L) // Created key is a ! 2126: // symbolic link ! 2127: ! 2128: #define REG_OPTION_BACKUP_RESTORE (0x00000004L) // open for backup or restore ! 2129: // special access rules ! 2130: // privilege required ! 2131: ! 2132: #define REG_LEGAL_OPTION \ ! 2133: (REG_OPTION_RESERVED |\ ! 2134: REG_OPTION_NON_VOLATILE |\ ! 2135: REG_OPTION_VOLATILE |\ ! 2136: REG_OPTION_CREATE_LINK |\ ! 2137: REG_OPTION_BACKUP_RESTORE) ! 2138: ! 2139: // ! 2140: // Key creation/open disposition ! 2141: // ! 2142: ! 2143: #define REG_CREATED_NEW_KEY (0x00000001L) // New Registry Key created ! 2144: #define REG_OPENED_EXISTING_KEY (0x00000002L) // Existing Key opened ! 2145: ! 2146: // ! 2147: // Key restore flags ! 2148: // ! 2149: ! 2150: #define REG_WHOLE_HIVE_VOLATILE (0x00000001L) // Restore whole hive volatile ! 2151: #define REG_REFRESH_HIVE (0x00000002L) // Unwind changes to last flush ! 2152: ! 2153: // ! 2154: // Key query structures ! 2155: // ! 2156: ! 2157: typedef struct _KEY_BASIC_INFORMATION { ! 2158: LARGE_INTEGER LastWriteTime; ! 2159: ULONG TitleIndex; ! 2160: ULONG NameLength; ! 2161: WCHAR Name[1]; // Variable length string ! 2162: } KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION; ! 2163: ! 2164: typedef struct _KEY_NODE_INFORMATION { ! 2165: LARGE_INTEGER LastWriteTime; ! 2166: ULONG TitleIndex; ! 2167: ULONG ClassOffset; ! 2168: ULONG ClassLength; ! 2169: ULONG NameLength; ! 2170: WCHAR Name[1]; // Variable length string ! 2171: // Class[1]; // Variable length string not declared ! 2172: } KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION; ! 2173: ! 2174: typedef struct _KEY_FULL_INFORMATION { ! 2175: LARGE_INTEGER LastWriteTime; ! 2176: ULONG TitleIndex; ! 2177: ULONG ClassOffset; ! 2178: ULONG ClassLength; ! 2179: ULONG SubKeys; ! 2180: ULONG MaxNameLen; ! 2181: ULONG MaxClassLen; ! 2182: ULONG Values; ! 2183: ULONG MaxValueNameLen; ! 2184: ULONG MaxValueDataLen; ! 2185: WCHAR Class[1]; // Variable length ! 2186: } KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION; ! 2187: ! 2188: typedef enum _KEY_INFORMATION_CLASS { ! 2189: KeyBasicInformation, ! 2190: KeyNodeInformation, ! 2191: KeyFullInformation ! 2192: } KEY_INFORMATION_CLASS; ! 2193: ! 2194: typedef struct _KEY_WRITE_TIME_INFORMATION { ! 2195: LARGE_INTEGER LastWriteTime; ! 2196: } KEY_WRITE_TIME_INFORMATION, *PKEY_WRITE_TIME_INFORMATION; ! 2197: ! 2198: typedef enum _KEY_SET_INFORMATION_CLASS { ! 2199: KeyWriteTimeInformation ! 2200: } KEY_SET_INFORMATION_CLASS; ! 2201: ! 2202: // ! 2203: // Value entry query structures ! 2204: // ! 2205: ! 2206: typedef struct _KEY_VALUE_BASIC_INFORMATION { ! 2207: ULONG TitleIndex; ! 2208: ULONG Type; ! 2209: ULONG NameLength; ! 2210: WCHAR Name[1]; // Variable size ! 2211: } KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION; ! 2212: ! 2213: typedef struct _KEY_VALUE_FULL_INFORMATION { ! 2214: ULONG TitleIndex; ! 2215: ULONG Type; ! 2216: ULONG DataOffset; ! 2217: ULONG DataLength; ! 2218: ULONG NameLength; ! 2219: WCHAR Name[1]; // Variable size ! 2220: // Data[1]; // Variable size data not declared ! 2221: } KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION; ! 2222: ! 2223: typedef struct _KEY_VALUE_PARTIAL_INFORMATION { ! 2224: ULONG TitleIndex; ! 2225: ULONG Type; ! 2226: ULONG DataLength; ! 2227: UCHAR Data[1]; // Variable size ! 2228: } KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION; ! 2229: ! 2230: typedef enum _KEY_VALUE_INFORMATION_CLASS { ! 2231: KeyValueBasicInformation, ! 2232: KeyValueFullInformation, ! 2233: KeyValuePartialInformation ! 2234: } KEY_VALUE_INFORMATION_CLASS; ! 2235: ! 2236: ! 2237: #define OBJ_NAME_PATH_SEPARATOR ((WCHAR)L'\\') ! 2238: ! 2239: // ! 2240: // Object Manager Object Type Specific Access Rights. ! 2241: // ! 2242: ! 2243: #define OBJECT_TYPE_CREATE (0x0001) ! 2244: ! 2245: #define OBJECT_TYPE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1) ! 2246: ! 2247: // ! 2248: // Object Manager Directory Specific Access Rights. ! 2249: // ! 2250: ! 2251: #define DIRECTORY_QUERY (0x0001) ! 2252: #define DIRECTORY_TRAVERSE (0x0002) ! 2253: #define DIRECTORY_CREATE_OBJECT (0x0004) ! 2254: #define DIRECTORY_CREATE_SUBDIRECTORY (0x0008) ! 2255: ! 2256: #define DIRECTORY_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0xF) ! 2257: ! 2258: // ! 2259: // Object Manager Symbolic Link Specific Access Rights. ! 2260: // ! 2261: ! 2262: #define SYMBOLIC_LINK_QUERY (0x0001) ! 2263: ! 2264: #define SYMBOLIC_LINK_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x1) ! 2265: ! 2266: typedef struct _OBJECT_NAME_INFORMATION { ! 2267: UNICODE_STRING Name; ! 2268: } OBJECT_NAME_INFORMATION, *POBJECT_NAME_INFORMATION; ! 2269: ! 2270: // ! 2271: // Section Information Structures. ! 2272: // ! 2273: ! 2274: typedef enum _SECTION_INHERIT { ! 2275: ViewShare = 1, ! 2276: ViewUnmap = 2 ! 2277: } SECTION_INHERIT; ! 2278: ! 2279: // ! 2280: // Section Access Rights. ! 2281: // ! 2282: ! 2283: // begin_winnt ! 2284: #define SECTION_QUERY 0x0001 ! 2285: #define SECTION_MAP_WRITE 0x0002 ! 2286: #define SECTION_MAP_READ 0x0004 ! 2287: #define SECTION_MAP_EXECUTE 0x0008 ! 2288: #define SECTION_EXTEND_SIZE 0x0010 ! 2289: ! 2290: #define SECTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY|\ ! 2291: SECTION_MAP_WRITE | \ ! 2292: SECTION_MAP_READ | \ ! 2293: SECTION_MAP_EXECUTE | \ ! 2294: SECTION_EXTEND_SIZE) ! 2295: // end_winnt ! 2296: ! 2297: #define SEGMENT_ALL_ACCESS SECTION_ALL_ACCESS ! 2298: ! 2299: #define PAGE_NOACCESS 0x01 // winnt ! 2300: #define PAGE_READONLY 0x02 // winnt ! 2301: #define PAGE_READWRITE 0x04 // winnt ! 2302: #define PAGE_WRITECOPY 0x08 // winnt ! 2303: #define PAGE_EXECUTE 0x10 // winnt ! 2304: #define PAGE_EXECUTE_READ 0x20 // winnt ! 2305: #define PAGE_EXECUTE_READWRITE 0x40 // winnt ! 2306: #define PAGE_EXECUTE_WRITECOPY 0x80 // winnt ! 2307: #define PAGE_GUARD 0x100 // winnt ! 2308: #define PAGE_NOCACHE 0x200 // winnt ! 2309: ! 2310: #define MEM_TOP_DOWN 0x100000 ! 2311: #define MEM_LARGE_PAGES 0x20000000 ! 2312: #define THREAD_TERMINATE (0x0001) // winnt ! 2313: #define THREAD_SET_INFORMATION (0x0020) // winnt ! 2314: ! 2315: #define THREAD_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \ ! 2316: 0x3FF) ! 2317: ! 2318: // ! 2319: // ClientId ! 2320: // ! 2321: ! 2322: typedef struct _CLIENT_ID { ! 2323: HANDLE UniqueProcess; ! 2324: HANDLE UniqueThread; ! 2325: } CLIENT_ID; ! 2326: typedef CLIENT_ID *PCLIENT_ID; ! 2327: ! 2328: #define NtCurrentProcess() ( (HANDLE) -1 ) ! 2329: ! 2330: #if defined(_X86_) ! 2331: // ! 2332: // Indicate that the i386 compiler supports the pragma textout construct. ! 2333: // ! 2334: ! 2335: #define ALLOC_PRAGMA 1 ! 2336: #define NORMAL_DISPATCH_LENGTH 106 ! 2337: #define DISPATCH_LENGTH NORMAL_DISPATCH_LENGTH ! 2338: // ! 2339: // Interrupt Request Level definitions ! 2340: // ! 2341: ! 2342: #define PASSIVE_LEVEL 0 // Passive release level ! 2343: #define LOW_LEVEL 0 // Lowest interrupt level ! 2344: #define APC_LEVEL 1 // APC interrupt level ! 2345: #define DISPATCH_LEVEL 2 // Dispatcher level ! 2346: ! 2347: #define PROFILE_LEVEL 27 // timer used for profiling. ! 2348: #define CLOCK1_LEVEL 28 // Interval clock 1 level - Not used on x86 ! 2349: #define CLOCK2_LEVEL 28 // Interval clock 2 level ! 2350: #define IPI_LEVEL 29 // Interprocessor interrupt level ! 2351: #define POWER_LEVEL 30 // Power failure level ! 2352: #define HIGH_LEVEL 31 // Highest interrupt level ! 2353: ! 2354: // ! 2355: // Get data cache fill size. ! 2356: // ! 2357: ! 2358: #define KeGetDcacheFillSize() 1L ! 2359: ! 2360: ! 2361: #define KeFlushIoBuffers(Mdl, ReadOperation, DmaOperation) ! 2362: ! 2363: // ! 2364: // i386 Specific portions of mm component ! 2365: // ! 2366: ! 2367: // ! 2368: // Define the page size for the Intel 386 as 4096 (0x1000). ! 2369: // ! 2370: ! 2371: #define PAGE_SIZE (ULONG)0x1000 ! 2372: ! 2373: // ! 2374: // Define the number of trailing zeroes in a page aligned virtual address. ! 2375: // This is used as the shift count when shifting virtual addresses to ! 2376: // virtual page numbers. ! 2377: // ! 2378: ! 2379: #define PAGE_SHIFT 12L ! 2380: ! 2381: // ! 2382: // The highest user address reserves 64K bytes for a guard ! 2383: // page. This allows the probing of address from kernel mode to ! 2384: // only have to check the starting address for strucutures of 64k bytes ! 2385: // or less. ! 2386: // ! 2387: ! 2388: #define MM_HIGHEST_USER_ADDRESS (PVOID)0x7FFEFFFF // temp should be 0xBFFEFFFF ! 2389: ! 2390: #define MM_USER_PROBE_ADDRESS 0x7FFF0000 // starting address of guard page ! 2391: ! 2392: // ! 2393: // The lowest user address reserves the low 64k. ! 2394: // ! 2395: ! 2396: #define MM_LOWEST_USER_ADDRESS (PVOID)0x00010000 ! 2397: ! 2398: // ! 2399: // The lowest address for system space. ! 2400: // ! 2401: ! 2402: #define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xC0800000 ! 2403: ! 2404: // ! 2405: // Result type definition for i386. (Machine specific enumerate type ! 2406: // which is return type for portable exinterlockedincrement/decrement ! 2407: // procedures.) In general, you should use the enumerated type defined ! 2408: // in ex.h instead of directly referencing these constants. ! 2409: // ! 2410: ! 2411: // Flags loaded into AH by LAHF instruction ! 2412: ! 2413: #define EFLAG_SIGN 0x8000 ! 2414: #define EFLAG_ZERO 0x4000 ! 2415: #define EFLAG_SELECT (EFLAG_SIGN | EFLAG_ZERO) ! 2416: ! 2417: #define RESULT_NEGATIVE ((EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT) ! 2418: #define RESULT_ZERO ((~EFLAG_SIGN & EFLAG_ZERO) & EFLAG_SELECT) ! 2419: #define RESULT_POSITIVE ((~EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT) ! 2420: ! 2421: // ! 2422: // Convert various portable ExInterlock apis into their architecural ! 2423: // equivalents. ! 2424: // ! 2425: ! 2426: #define ExInterlockedIncrementLong(Addend,Lock) \ ! 2427: Exi386InterlockedIncrementLong(Addend) ! 2428: ! 2429: #define ExInterlockedDecrementLong(Addend,Lock) \ ! 2430: Exi386InterlockedDecrementLong(Addend) ! 2431: ! 2432: #define ExInterlockedExchangeUlong(Target,Value,Lock) \ ! 2433: Exi386InterlockedExchangeUlong(Target,Value) ! 2434: ! 2435: // ! 2436: // Prototypes for architecural specific versions of Exi386 api ! 2437: // ! 2438: ! 2439: // ! 2440: // Interlocked result type is portable, but its values are machine specific. ! 2441: // Constants for value are in i386.h, mips.h, etc. ! 2442: // ! 2443: ! 2444: typedef enum _INTERLOCKED_RESULT { ! 2445: ResultNegative = RESULT_NEGATIVE, ! 2446: ResultZero = RESULT_ZERO, ! 2447: ResultPositive = RESULT_POSITIVE ! 2448: } INTERLOCKED_RESULT; ! 2449: ! 2450: INTERLOCKED_RESULT ! 2451: Exi386InterlockedIncrementLong ( ! 2452: IN PLONG Addend ! 2453: ); ! 2454: ! 2455: INTERLOCKED_RESULT ! 2456: Exi386InterlockedDecrementLong ( ! 2457: IN PLONG Addend ! 2458: ); ! 2459: ! 2460: ULONG ! 2461: Exi386InterlockedExchangeUlong ( ! 2462: IN PULONG Target, ! 2463: IN ULONG Value ! 2464: ); ! 2465: ! 2466: VOID ! 2467: KeRaiseIrql ( ! 2468: IN KIRQL NewIrql, ! 2469: OUT PKIRQL OldIrql ! 2470: ); ! 2471: ! 2472: VOID ! 2473: KeLowerIrql ( ! 2474: IN KIRQL NewIrql ! 2475: ); ! 2476: ! 2477: ! 2478: #endif // defined(_X86_) ! 2479: ! 2480: ! 2481: #if defined(_MIPS_) ! 2482: ! 2483: // ! 2484: // Indicate that the MIPS compiler supports the pragma textout construct. ! 2485: // ! 2486: ! 2487: #define ALLOC_PRAGMA 1 ! 2488: ! 2489: // ! 2490: // MIPS specific interlocked operation result values. ! 2491: // ! 2492: ! 2493: #define RESULT_ZERO 0 ! 2494: #define RESULT_NEGATIVE -2 ! 2495: #define RESULT_POSITIVE -1 ! 2496: ! 2497: // ! 2498: // Interlocked result type is portable, but its values are machine specific. ! 2499: // Constants for value are in i386.h, mips.h, etc. ! 2500: // ! 2501: ! 2502: typedef enum _INTERLOCKED_RESULT { ! 2503: ResultNegative = RESULT_NEGATIVE, ! 2504: ResultZero = RESULT_ZERO, ! 2505: ResultPositive = RESULT_POSITIVE ! 2506: } INTERLOCKED_RESULT; ! 2507: ! 2508: // ! 2509: // MIPS Interrupt Definitions. ! 2510: // ! 2511: // Define length on interupt object dispatch code in longwords. ! 2512: // ! 2513: ! 2514: #define DISPATCH_LENGTH 4 // Length of dispatch code in instructions ! 2515: ! 2516: // ! 2517: // Define Interrupt Request Levels. ! 2518: // ! 2519: ! 2520: #define PASSIVE_LEVEL 0 // Passive release level ! 2521: #define LOW_LEVEL 0 // Lowest interrupt level ! 2522: #define APC_LEVEL 1 // APC interrupt level ! 2523: #define DISPATCH_LEVEL 2 // Dispatcher level ! 2524: #define IPI_LEVEL 7 // Interprocessor interrupt level ! 2525: #define POWER_LEVEL 7 // Power failure level ! 2526: #define FLOAT_LEVEL 8 // Floating interrupt level ! 2527: #define HIGH_LEVEL 8 // Highest interrupt level ! 2528: ! 2529: #if defined(R3000) ! 2530: ! 2531: #define PROFILE_LEVEL 7 // Profiling level ! 2532: ! 2533: #endif ! 2534: ! 2535: #if defined(R4000) ! 2536: ! 2537: #define PROFILE_LEVEL 8 // Profiling level ! 2538: ! 2539: #endif ! 2540: ! 2541: // ! 2542: // Define profile intervals. ! 2543: // ! 2544: ! 2545: #if defined(R3000) ! 2546: ! 2547: #define DEFAULT_PROFILE_INTERVAL (10 * 1000) // 1 millisecond ! 2548: #define MAXIMUM_PROFILE_INTERVAL (10 * 1000 * 1000) // 1 second ! 2549: #define MINIMUM_PROFILE_INTERVAL (10 * 1000) // 1 millisecond ! 2550: ! 2551: #endif ! 2552: ! 2553: #if defined(R4000) ! 2554: ! 2555: #define DEFAULT_PROFILE_COUNT 0x40000000 // ~= 20 seconds @50mhz ! 2556: #define DEFAULT_PROFILE_INTERVAL (10 * 500) // 500 microseconds ! 2557: #define MAXIMUM_PROFILE_INTERVAL (10 * 1000 * 1000) // 1 second ! 2558: #define MINIMUM_PROFILE_INTERVAL (10 * 40) // 40 microseconds ! 2559: ! 2560: #endif ! 2561: ! 2562: ! 2563: // ! 2564: // Get data cache fill size. ! 2565: // ! 2566: ! 2567: #define KeGetDcacheFillSize() PCR->DcacheFillSize ! 2568: ! 2569: // ! 2570: // Cache and write buffer flush functions. ! 2571: // ! 2572: ! 2573: VOID ! 2574: KeFlushIoBuffers ( ! 2575: IN PMDL Mdl, ! 2576: IN BOOLEAN ReadOperation, ! 2577: IN BOOLEAN DmaOperation ! 2578: ); ! 2579: ! 2580: ! 2581: VOID ! 2582: KeLowerIrql ( ! 2583: KIRQL NewIrql ! 2584: ); ! 2585: ! 2586: VOID ! 2587: KeRaiseIrql ( ! 2588: KIRQL NewIrql, ! 2589: PKIRQL OldIrql ! 2590: ); ! 2591: ! 2592: // ! 2593: // I/O space read and write macros. ! 2594: // ! 2595: ! 2596: #define READ_REGISTER_UCHAR(x) \ ! 2597: *(volatile UCHAR * const)(x) ! 2598: ! 2599: #define READ_REGISTER_USHORT(x) \ ! 2600: *(volatile USHORT * const)(x) ! 2601: ! 2602: #define READ_REGISTER_ULONG(x) \ ! 2603: *(volatile ULONG * const)(x) ! 2604: ! 2605: #define READ_REGISTER_BUFFER_UCHAR(x, y, z) { \ ! 2606: PUCHAR registerBuffer = x; \ ! 2607: PUCHAR readBuffer = y; \ ! 2608: ULONG readCount; \ ! 2609: for (readCount = z; readCount--; readBuffer++, registerBuffer++) { \ ! 2610: *readBuffer = *(volatile UCHAR * const)(registerBuffer); \ ! 2611: } \ ! 2612: } ! 2613: ! 2614: #define READ_REGISTER_BUFFER_USHORT(x, y, z) { \ ! 2615: PUSHORT registerBuffer = x; \ ! 2616: PUSHORT readBuffer = y; \ ! 2617: ULONG readCount; \ ! 2618: for (readCount = z; readCount--; readBuffer++, registerBuffer++) { \ ! 2619: *readBuffer = *(volatile USHORT * const)(registerBuffer); \ ! 2620: } \ ! 2621: } ! 2622: ! 2623: #define READ_REGISTER_BUFFER_ULONG(x, y, z) { \ ! 2624: PULONG registerBuffer = x; \ ! 2625: PULONG readBuffer = y; \ ! 2626: ULONG readCount; \ ! 2627: for (readCount = z; readCount--; readBuffer++, registerBuffer++) { \ ! 2628: *readBuffer = *(volatile ULONG * const)(registerBuffer); \ ! 2629: } \ ! 2630: } ! 2631: ! 2632: #define WRITE_REGISTER_UCHAR(x, y) { \ ! 2633: *(volatile UCHAR * const)(x) = y; \ ! 2634: KeFlushWriteBuffer(); \ ! 2635: } ! 2636: ! 2637: #define WRITE_REGISTER_USHORT(x, y) { \ ! 2638: *(volatile USHORT * const)(x) = y; \ ! 2639: KeFlushWriteBuffer(); \ ! 2640: } ! 2641: ! 2642: #define WRITE_REGISTER_ULONG(x, y) { \ ! 2643: *(volatile ULONG * const)(x) = y; \ ! 2644: KeFlushWriteBuffer(); \ ! 2645: } ! 2646: ! 2647: #define WRITE_REGISTER_BUFFER_UCHAR(x, y, z) { \ ! 2648: PUCHAR registerBuffer = x; \ ! 2649: PUCHAR writeBuffer = y; \ ! 2650: ULONG writeCount; \ ! 2651: for (writeCount = z; writeCount--; writeBuffer++, registerBuffer++) { \ ! 2652: *(volatile UCHAR * const)(registerBuffer) = *writeBuffer; \ ! 2653: } \ ! 2654: KeFlushWriteBuffer(); \ ! 2655: } ! 2656: ! 2657: #define WRITE_REGISTER_BUFFER_USHORT(x, y, z) { \ ! 2658: PUSHORT registerBuffer = x; \ ! 2659: PUSHORT writeBuffer = y; \ ! 2660: ULONG writeCount; \ ! 2661: for (writeCount = z; writeCount--; writeBuffer++, registerBuffer++) { \ ! 2662: *(volatile USHORT * const)(registerBuffer) = *writeBuffer; \ ! 2663: } \ ! 2664: KeFlushWriteBuffer(); \ ! 2665: } ! 2666: ! 2667: #define WRITE_REGISTER_BUFFER_ULONG(x, y, z) { \ ! 2668: PULONG registerBuffer = x; \ ! 2669: PULONG writeBuffer = y; \ ! 2670: ULONG writeCount; \ ! 2671: for (writeCount = z; writeCount--; writeBuffer++, registerBuffer++) { \ ! 2672: *(volatile ULONG * const)(registerBuffer) = *writeBuffer; \ ! 2673: } \ ! 2674: KeFlushWriteBuffer(); \ ! 2675: } ! 2676: ! 2677: ! 2678: #define READ_PORT_UCHAR(x) \ ! 2679: *(volatile UCHAR * const)(x) ! 2680: ! 2681: #define READ_PORT_USHORT(x) \ ! 2682: *(volatile USHORT * const)(x) ! 2683: ! 2684: #define READ_PORT_ULONG(x) \ ! 2685: *(volatile ULONG * const)(x) ! 2686: ! 2687: #define READ_PORT_BUFFER_UCHAR(x, y, z) { \ ! 2688: PUCHAR readBuffer = y; \ ! 2689: ULONG readCount; \ ! 2690: for (readCount = 0; readCount < z; readCount++, readBuffer++) { \ ! 2691: *readBuffer = *(volatile UCHAR * const)(x); \ ! 2692: } \ ! 2693: } ! 2694: ! 2695: #define READ_PORT_BUFFER_USHORT(x, y, z) { \ ! 2696: PUSHORT readBuffer = y; \ ! 2697: ULONG readCount; \ ! 2698: for (readCount = 0; readCount < z; readCount++, readBuffer++) { \ ! 2699: *readBuffer = *(volatile USHORT * const)(x); \ ! 2700: } \ ! 2701: } ! 2702: ! 2703: #define READ_PORT_BUFFER_ULONG(x, y, z) { \ ! 2704: PULONG readBuffer = y; \ ! 2705: ULONG readCount; \ ! 2706: for (readCount = 0; readCount < z; readCount++, readBuffer++) { \ ! 2707: *readBuffer = *(volatile ULONG * const)(x); \ ! 2708: } \ ! 2709: } ! 2710: ! 2711: #define WRITE_PORT_UCHAR(x, y) { \ ! 2712: *(volatile UCHAR * const)(x) = y; \ ! 2713: KeFlushWriteBuffer(); \ ! 2714: } ! 2715: ! 2716: #define WRITE_PORT_USHORT(x, y) { \ ! 2717: *(volatile USHORT * const)(x) = y; \ ! 2718: KeFlushWriteBuffer(); \ ! 2719: } ! 2720: ! 2721: #define WRITE_PORT_ULONG(x, y) { \ ! 2722: *(volatile ULONG * const)(x) = y; \ ! 2723: KeFlushWriteBuffer(); \ ! 2724: } ! 2725: ! 2726: #define WRITE_PORT_BUFFER_UCHAR(x, y, z) { \ ! 2727: PUCHAR writeBuffer = y; \ ! 2728: ULONG writeCount; \ ! 2729: for (writeCount = 0; writeCount < z; writeCount++, writeBuffer++) { \ ! 2730: *(volatile UCHAR * const)(x) = *writeBuffer; \ ! 2731: KeFlushWriteBuffer(); \ ! 2732: } \ ! 2733: } ! 2734: ! 2735: #define WRITE_PORT_BUFFER_USHORT(x, y, z) { \ ! 2736: PUSHORT writeBuffer = y; \ ! 2737: ULONG writeCount; \ ! 2738: for (writeCount = 0; writeCount < z; writeCount++, writeBuffer++) { \ ! 2739: *(volatile USHORT * const)(x) = *writeBuffer; \ ! 2740: KeFlushWriteBuffer(); \ ! 2741: } \ ! 2742: } ! 2743: ! 2744: #define WRITE_PORT_BUFFER_ULONG(x, y, z) { \ ! 2745: PULONG writeBuffer = y; \ ! 2746: ULONG writeCount; \ ! 2747: for (writeCount = 0; writeCount < z; writeCount++, writeBuffer++) { \ ! 2748: *(volatile ULONG * const)(x) = *writeBuffer; \ ! 2749: KeFlushWriteBuffer(); \ ! 2750: } \ ! 2751: } ! 2752: ! 2753: // ! 2754: // Define the page size for the MIPS r3000 and r4000 as 4096 (0x1000). ! 2755: // ! 2756: ! 2757: #define PAGE_SIZE (ULONG)0x1000 ! 2758: ! 2759: // ! 2760: // Define the number of trailing zeroes in a page aligned virtual address. ! 2761: // This is used as the shift count when shifting virtual addresses to ! 2762: // virtual page numbers. ! 2763: // ! 2764: ! 2765: #define PAGE_SHIFT 12L ! 2766: ! 2767: // ! 2768: // The highest user address reserves 64K bytes for a guard page. This ! 2769: // the probing of address from kernel mode to only have to check the ! 2770: // starting address for structures of 64k bytes or less. ! 2771: // ! 2772: ! 2773: #define MM_HIGHEST_USER_ADDRESS (PVOID)0x7FFEFFFF // highest user address ! 2774: #define MM_USER_PROBE_ADDRESS 0x7FFF0000 // starting address of guard page ! 2775: ! 2776: // ! 2777: // The lowest user address reserves the low 64k. ! 2778: // ! 2779: ! 2780: #define MM_LOWEST_USER_ADDRESS (PVOID)0x00010000 ! 2781: ! 2782: // ! 2783: // The lowest address for system space. ! 2784: // ! 2785: ! 2786: #define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xC0800000 ! 2787: #define SYSTEM_BASE 0xc0800000 // start of system space (no typecast) ! 2788: ! 2789: #endif // defined(_MIPS_) ! 2790: ! 2791: #if defined(_ALPHA_) ! 2792: ! 2793: // ! 2794: // Include the alpha instruction definitions ! 2795: // ! 2796: ! 2797: #include "alphaops.h" ! 2798: ! 2799: // ! 2800: // Include reference machine definitions. ! 2801: // ! 2802: ! 2803: #include "alpharef.h" ! 2804: ! 2805: ! 2806: // ! 2807: // Define length of interrupt vector table. ! 2808: // ! 2809: ! 2810: #define MAXIMUM_VECTOR 256 ! 2811: ! 2812: // ! 2813: // Define bus error routine type. ! 2814: // ! 2815: ! 2816: struct _EXCEPTION_RECORD; ! 2817: struct _KEXCEPTION_FRAME; ! 2818: struct _KTRAP_FRAME; ! 2819: ! 2820: typedef ! 2821: BOOLEAN ! 2822: (*PKBUS_ERROR_ROUTINE) ( ! 2823: IN struct _EXCEPTION_RECORD *ExceptionRecord, ! 2824: IN struct _KEXCEPTION_FRAME *ExceptionFrame, ! 2825: IN struct _KTRAP_FRAME *TrapFrame ! 2826: ); ! 2827: ! 2828: ! 2829: #define PCR_MINOR_VERSION 1 ! 2830: #define PCR_MAJOR_VERSION 1 ! 2831: ! 2832: typedef struct _KPCR { ! 2833: ! 2834: // ! 2835: // Major and minor version numbers of the PCR. ! 2836: // ! 2837: ! 2838: ULONG MinorVersion; ! 2839: ULONG MajorVersion; ! 2840: ! 2841: // ! 2842: // Start of the architecturally defined section of the PCR. This section ! 2843: // may be directly addressed by vendor/platform specific PAL/HAL code and will ! 2844: // not change from version to version of NT. ! 2845: ! 2846: // ! 2847: // PALcode information. ! 2848: // ! 2849: ! 2850: ULONGLONG PalBaseAddress; ! 2851: ULONG PalMajorVersion; ! 2852: ULONG PalMinorVersion; ! 2853: ULONG PalSequenceVersion; ! 2854: ULONG PalMajorSpecification; ! 2855: ULONG PalMinorSpecification; ! 2856: ! 2857: // ! 2858: // Firmware restart information. ! 2859: // ! 2860: ! 2861: ULONGLONG FirmwareRestartAddress; ! 2862: PVOID RestartBlock; ! 2863: ! 2864: // ! 2865: // Reserved per-processor region for the PAL (3K bytes). ! 2866: // ! 2867: ! 2868: ULONGLONG PalReserved[384]; ! 2869: ! 2870: // ! 2871: // Panic Stack Address. ! 2872: // ! 2873: ! 2874: ULONG PanicStack; ! 2875: ! 2876: // ! 2877: // Processor parameters. ! 2878: // ! 2879: ! 2880: ULONG ProcessorType; ! 2881: ULONG ProcessorRevision; ! 2882: ULONG PhysicalAddressBits; ! 2883: ULONG MaximumAddressSpaceNumber; ! 2884: ULONG PageSize; ! 2885: ULONG FirstLevelDcacheSize; ! 2886: ULONG FirstLevelDcacheFillSize; ! 2887: ULONG FirstLevelIcacheSize; ! 2888: ULONG FirstLevelIcacheFillSize; ! 2889: ! 2890: // ! 2891: // System Parameters. ! 2892: // ! 2893: ! 2894: ULONG FirmwareRevisionId; ! 2895: UCHAR SystemType[8]; ! 2896: ULONG SystemVariant; ! 2897: ULONG SystemRevision; ! 2898: UCHAR SystemSerialNumber[16]; ! 2899: ULONG CycleClockPeriod; ! 2900: ULONG SecondLevelCacheSize; ! 2901: ULONG SecondLevelCacheFillSize; ! 2902: ULONG ThirdLevelCacheSize; ! 2903: ULONG ThirdLevelCacheFillSize; ! 2904: ULONG FourthLevelCacheSize; ! 2905: ULONG FourthLevelCacheFillSize; ! 2906: ! 2907: // ! 2908: // Pointer to processor control block. ! 2909: // ! 2910: ! 2911: struct _KPRCB *Prcb; ! 2912: ! 2913: // ! 2914: // Processor identification. ! 2915: // ! 2916: ! 2917: CCHAR Number; ! 2918: KAFFINITY SetMember; ! 2919: ! 2920: // ! 2921: // Reserved per-processor region for the HAL (.5K bytes). ! 2922: // ! 2923: ! 2924: ULONGLONG HalReserved[64]; ! 2925: ! 2926: // ! 2927: // IRQL mapping tables. ! 2928: // ! 2929: ! 2930: ULONG IrqlTable[8]; ! 2931: ! 2932: #define SFW_IMT_ENTRIES 4 ! 2933: #define HDW_IMT_ENTRIES 128 ! 2934: ! 2935: struct _IRQLMASK { ! 2936: USHORT IrqlTableIndex; // synchronization irql level ! 2937: USHORT IDTIndex; // vector in IDT ! 2938: } IrqlMask[SFW_IMT_ENTRIES + HDW_IMT_ENTRIES]; ! 2939: ! 2940: // ! 2941: // Interrupt Dispatch Table (IDT). ! 2942: // ! 2943: ! 2944: PKINTERRUPT_ROUTINE InterruptRoutine[MAXIMUM_VECTOR]; ! 2945: ! 2946: // ! 2947: // Reserved vectors mask, these vectors cannot be attached to via ! 2948: // standard interrupt objects. ! 2949: // ! 2950: ! 2951: ULONG ReservedVectors; ! 2952: ! 2953: // ! 2954: // Profiling data. ! 2955: // ! 2956: ! 2957: PLIST_ENTRY ProfileListHead; ! 2958: ULONG ProfileInterval; ! 2959: ULONG ProfileCount; ! 2960: ! 2961: // ! 2962: // Pointer to machine check handler ! 2963: // ! 2964: ! 2965: PKBUS_ERROR_ROUTINE MachineCheckError; ! 2966: ! 2967: // ! 2968: // DPC Stack. ! 2969: // ! 2970: ! 2971: ULONG DpcStack; ! 2972: ! 2973: // ! 2974: // End of the architecturally defined section of the PCR. This section ! 2975: // may be directly addressed by vendor/platform specific HAL code and will ! 2976: // not change from version to version of NT. Some of these values are ! 2977: // reserved for chip-specific palcode. ! 2978: } KPCR, *PKPCR; ! 2979: // ! 2980: // length of dispatch code in interrupt template ! 2981: // ! 2982: #define DISPATCH_LENGTH 4 ! 2983: ! 2984: // ! 2985: // Define IRQL levels across the architecture. ! 2986: // ! 2987: ! 2988: #define PASSIVE_LEVEL 0 ! 2989: #define LOW_LEVEL 0 ! 2990: #define APC_LEVEL 1 ! 2991: #define DISPATCH_LEVEL 2 ! 2992: #define HIGH_LEVEL 7 ! 2993: ! 2994: ! 2995: // ! 2996: // Define Interlocked operation result values. ! 2997: // ! 2998: ! 2999: #define RESULT_ZERO 0 ! 3000: #define RESULT_NEGATIVE 1 ! 3001: #define RESULT_POSITIVE 2 ! 3002: ! 3003: // ! 3004: // Interlocked result type is portable, but its values are machine specific. ! 3005: // Constants for value are in i386.h, mips.h, etc. ! 3006: // ! 3007: ! 3008: typedef enum _INTERLOCKED_RESULT { ! 3009: ResultNegative = RESULT_NEGATIVE, ! 3010: ResultZero = RESULT_ZERO, ! 3011: ResultPositive = RESULT_POSITIVE ! 3012: } INTERLOCKED_RESULT; ! 3013: ! 3014: ! 3015: // there is a lot of other stuff that could go in here ! 3016: // probe macros ! 3017: // others ! 3018: ! 3019: // ! 3020: // Define the page size for the Alpha ev4 and lca as 8k. ! 3021: // ! 3022: ! 3023: #define PAGE_SIZE (ULONG)0x2000 ! 3024: ! 3025: // ! 3026: // Define the number of trailing zeroes in a page aligned virtual address. ! 3027: // This is used as the shift count when shifting virtual addresses to ! 3028: // virtual page numbers. ! 3029: // ! 3030: ! 3031: #define PAGE_SHIFT 13L ! 3032: ! 3033: ! 3034: // ! 3035: // The highest user address reserves 64K bytes for a guard page. This ! 3036: // the probing of address from kernel mode to only have to check the ! 3037: // starting address for structures of 64k bytes or less. ! 3038: // ! 3039: ! 3040: #define MM_HIGHEST_USER_ADDRESS (PVOID)0x7FFEFFFF // highest user address ! 3041: #define MM_USER_PROBE_ADDRESS 0x7FFF0000 // starting address of guard page ! 3042: ! 3043: // ! 3044: // The lowest user address reserves the low 64k. ! 3045: // ! 3046: ! 3047: #define MM_LOWEST_USER_ADDRESS (PVOID)0x00010000 ! 3048: ! 3049: // ! 3050: // The lowest address for system space. ! 3051: // ! 3052: ! 3053: #define MM_LOWEST_SYSTEM_ADDRESS (PVOID)0xC0800000 ! 3054: // ! 3055: // Cache and write buffer flush functions. ! 3056: // ! 3057: ! 3058: VOID ! 3059: KeFlushIoBuffers ( ! 3060: IN PMDL Mdl, ! 3061: IN BOOLEAN ReadOperation, ! 3062: IN BOOLEAN DmaOperation ! 3063: ); ! 3064: ! 3065: VOID ! 3066: KeRaiseIrql ( ! 3067: IN KIRQL NewIrql, ! 3068: OUT PKIRQL OldIrql ! 3069: ); ! 3070: ! 3071: VOID ! 3072: KeLowerIrql ( ! 3073: IN KIRQL NewIrql ! 3074: ); ! 3075: ! 3076: #endif // _ALPHA_ ! 3077: ! 3078: #ifdef _X86_ ! 3079: ! 3080: // ! 3081: // Disable these two pramas that evaluate to "sti" "cli" on x86 so that driver ! 3082: // writers to not leave them inadvertantly in their code. ! 3083: // ! 3084: ! 3085: #if !defined(MIDL_PASS) ! 3086: #if !defined(_CFRONT_PASS_) ! 3087: #if !defined(RC_INVOKED) ! 3088: ! 3089: #pragma warning(disable:4164) // disable C4164 warning so that apps that ! 3090: // build with /Od don't get weird errors ! ! 3091: #pragma function(_enable) ! 3092: #pragma function(_disable) ! 3093: ! 3094: #pragma warning(default:4164) // reenable C4164 warning ! 3095: ! 3096: #endif ! 3097: #endif ! 3098: #endif ! 3099: ! 3100: ! 3101: #ifdef _X86_ ! 3102: ! 3103: // begin_winnt ! 3104: ! 3105: // ! 3106: // Define the size of the 80387 save area, which is in the context frame. ! 3107: // ! 3108: ! 3109: #define SIZE_OF_80387_REGISTERS 80 ! 3110: ! 3111: // ! 3112: // The following flags control the contents of the CONTEXT structure. ! 3113: // ! 3114: ! 3115: #define CONTEXT_i386 0x00010000 // this assumes that i386 and ! 3116: #define CONTEXT_i486 0x00010000 // i486 have identical context records ! 3117: ! 3118: #define CONTEXT_CONTROL (CONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP ! 3119: #define CONTEXT_INTEGER (CONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI ! 3120: #define CONTEXT_SEGMENTS (CONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS ! 3121: #define CONTEXT_FLOATING_POINT (CONTEXT_i386 | 0x00000008L) // 387 state ! 3122: #define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x00000010L) // DB 0-3,6,7 ! 3123: ! 3124: #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER |\ ! 3125: CONTEXT_SEGMENTS) ! 3126: ! 3127: typedef struct _FLOATING_SAVE_AREA { ! 3128: ULONG ControlWord; ! 3129: ULONG StatusWord; ! 3130: ULONG TagWord; ! 3131: ULONG ErrorOffset; ! 3132: ULONG ErrorSelector; ! 3133: ULONG DataOffset; ! 3134: ULONG DataSelector; ! 3135: UCHAR RegisterArea[SIZE_OF_80387_REGISTERS]; ! 3136: ULONG Cr0NpxState; ! 3137: } FLOATING_SAVE_AREA; ! 3138: ! 3139: typedef FLOATING_SAVE_AREA *PFLOATING_SAVE_AREA; ! 3140: ! 3141: // ! 3142: // Context Frame ! 3143: // ! 3144: // This frame has a several purposes: 1) it is used as an argument to ! 3145: // NtContinue, 2) is is used to constuct a call frame for APC delivery, ! 3146: // and 3) it is used in the user level thread creation routines. ! 3147: // ! 3148: // The layout of the record conforms to a standard call frame. ! 3149: // ! 3150: ! 3151: typedef struct _CONTEXT { ! 3152: ! 3153: // ! 3154: // The flags values within this flag control the contents of ! 3155: // a CONTEXT record. ! 3156: // ! 3157: // If the context record is used as an input parameter, then ! 3158: // for each portion of the context record controlled by a flag ! 3159: // whose value is set, it is assumed that that portion of the ! 3160: // context record contains valid context. If the context record ! 3161: // is being used to modify a threads context, then only that ! 3162: // portion of the threads context will be modified. ! 3163: // ! 3164: // If the context record is used as an IN OUT parameter to capture ! 3165: // the context of a thread, then only those portions of the thread's ! 3166: // context corresponding to set flags will be returned. ! 3167: // ! 3168: // The context record is never used as an OUT only parameter. ! 3169: // ! 3170: ! 3171: ULONG ContextFlags; ! 3172: ! 3173: // ! 3174: // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is ! 3175: // set in ContextFlags. Note that CONTEXT_DEBUG_REGISTERS is NOT ! 3176: // included in CONTEXT_FULL. ! 3177: // ! 3178: ! 3179: ULONG Dr0; ! 3180: ULONG Dr1; ! 3181: ULONG Dr2; ! 3182: ULONG Dr3; ! 3183: ULONG Dr6; ! 3184: ULONG Dr7; ! 3185: ! 3186: // ! 3187: // This section is specified/returned if the ! 3188: // ContextFlags word contians the flag CONTEXT_FLOATING_POINT. ! 3189: // ! 3190: ! 3191: FLOATING_SAVE_AREA FloatSave; ! 3192: ! 3193: // ! 3194: // This section is specified/returned if the ! 3195: // ContextFlags word contians the flag CONTEXT_SEGMENTS. ! 3196: // ! 3197: ! 3198: ULONG SegGs; ! 3199: ULONG SegFs; ! 3200: ULONG SegEs; ! 3201: ULONG SegDs; ! 3202: ! 3203: // ! 3204: // This section is specified/returned if the ! 3205: // ContextFlags word contians the flag CONTEXT_INTEGER. ! 3206: // ! 3207: ! 3208: ULONG Edi; ! 3209: ULONG Esi; ! 3210: ULONG Ebx; ! 3211: ULONG Edx; ! 3212: ULONG Ecx; ! 3213: ULONG Eax; ! 3214: ! 3215: // ! 3216: // This section is specified/returned if the ! 3217: // ContextFlags word contians the flag CONTEXT_CONTROL. ! 3218: // ! 3219: ! 3220: ULONG Ebp; ! 3221: ULONG Eip; ! 3222: ULONG SegCs; // MUST BE SANITIZED ! 3223: ULONG EFlags; // MUST BE SANITIZED ! 3224: ULONG Esp; ! 3225: ULONG SegSs; ! 3226: ! 3227: } CONTEXT; ! 3228: ! 3229: ! 3230: ! 3231: typedef CONTEXT *PCONTEXT; ! 3232: ! 3233: // begin_ntminiport ! 3234: ! 3235: #endif //_X86_ ! 3236: ! 3237: // ! 3238: // I/O space read and write macros. ! 3239: // ! 3240: // These have to be actual functions on the 386, because we need ! 3241: // to use assembler, but cannot return a value if we inline it. ! 3242: // ! 3243: // The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space. ! 3244: // (Use x86 move instructions, with LOCK prefix to force correct behavior ! 3245: // w.r.t. caches and write buffers.) ! 3246: // ! 3247: // The READ/WRITE_PORT_* calls manipulate I/O registers in PORT space. ! 3248: // (Use x86 in/out instructions.) ! 3249: // ! 3250: ! 3251: UCHAR ! 3252: READ_REGISTER_UCHAR( ! 3253: PUCHAR Register ! 3254: ); ! 3255: ! 3256: USHORT ! 3257: READ_REGISTER_USHORT( ! 3258: PUSHORT Register ! 3259: ); ! 3260: ! 3261: ULONG ! 3262: READ_REGISTER_ULONG( ! 3263: PULONG Register ! 3264: ); ! 3265: ! 3266: VOID ! 3267: READ_REGISTER_BUFFER_UCHAR( ! 3268: PUCHAR Register, ! 3269: PUCHAR Buffer, ! 3270: ULONG Count ! 3271: ); ! 3272: ! 3273: VOID ! 3274: READ_REGISTER_BUFFER_USHORT( ! 3275: PUSHORT Register, ! 3276: PUSHORT Buffer, ! 3277: ULONG Count ! 3278: ); ! 3279: ! 3280: VOID ! 3281: READ_REGISTER_BUFFER_ULONG( ! 3282: PULONG Register, ! 3283: PULONG Buffer, ! 3284: ULONG Count ! 3285: ); ! 3286: ! 3287: ! 3288: VOID ! 3289: WRITE_REGISTER_UCHAR( ! 3290: PUCHAR Register, ! 3291: UCHAR Value ! 3292: ); ! 3293: ! 3294: VOID ! 3295: WRITE_REGISTER_USHORT( ! 3296: PUSHORT Register, ! 3297: USHORT Value ! 3298: ); ! 3299: ! 3300: VOID ! 3301: WRITE_REGISTER_ULONG( ! 3302: PULONG Register, ! 3303: ULONG Value ! 3304: ); ! 3305: ! 3306: VOID ! 3307: WRITE_REGISTER_BUFFER_UCHAR( ! 3308: PUCHAR Register, ! 3309: PUCHAR Buffer, ! 3310: ULONG Count ! 3311: ); ! 3312: ! 3313: VOID ! 3314: WRITE_REGISTER_BUFFER_USHORT( ! 3315: PUSHORT Register, ! 3316: PUSHORT Buffer, ! 3317: ULONG Count ! 3318: ); ! 3319: ! 3320: VOID ! 3321: WRITE_REGISTER_BUFFER_ULONG( ! 3322: PULONG Register, ! 3323: PULONG Buffer, ! 3324: ULONG Count ! 3325: ); ! 3326: ! 3327: UCHAR ! 3328: READ_PORT_UCHAR( ! 3329: PUCHAR Port ! 3330: ); ! 3331: ! 3332: USHORT ! 3333: READ_PORT_USHORT( ! 3334: PUSHORT Port ! 3335: ); ! 3336: ! 3337: ULONG ! 3338: READ_PORT_ULONG( ! 3339: PULONG Port ! 3340: ); ! 3341: ! 3342: VOID ! 3343: READ_PORT_BUFFER_UCHAR( ! 3344: PUCHAR Port, ! 3345: PUCHAR Buffer, ! 3346: ULONG Count ! 3347: ); ! 3348: ! 3349: VOID ! 3350: READ_PORT_BUFFER_USHORT( ! 3351: PUSHORT Port, ! 3352: PUSHORT Buffer, ! 3353: ULONG Count ! 3354: ); ! 3355: ! 3356: VOID ! 3357: READ_PORT_BUFFER_ULONG( ! 3358: PULONG Port, ! 3359: PULONG Buffer, ! 3360: ULONG Count ! 3361: ); ! 3362: ! 3363: VOID ! 3364: WRITE_PORT_UCHAR( ! 3365: PUCHAR Port, ! 3366: UCHAR Value ! 3367: ); ! 3368: ! 3369: VOID ! 3370: WRITE_PORT_USHORT( ! 3371: PUSHORT Port, ! 3372: USHORT Value ! 3373: ); ! 3374: ! 3375: VOID ! 3376: WRITE_PORT_ULONG( ! 3377: PULONG Port, ! 3378: ULONG Value ! 3379: ); ! 3380: ! 3381: VOID ! 3382: WRITE_PORT_BUFFER_UCHAR( ! 3383: PUCHAR Port, ! 3384: PUCHAR Buffer, ! 3385: ULONG Count ! 3386: ); ! 3387: ! 3388: VOID ! 3389: WRITE_PORT_BUFFER_USHORT( ! 3390: PUSHORT Port, ! 3391: PUSHORT Buffer, ! 3392: ULONG Count ! 3393: ); ! 3394: ! 3395: VOID ! 3396: WRITE_PORT_BUFFER_ULONG( ! 3397: PULONG Port, ! 3398: PULONG Buffer, ! 3399: ULONG Count ! 3400: ); ! 3401: ! 3402: #endif // _X86_ ! 3403: ! 3404: #if defined(_MIPS_) ! 3405: // ! 3406: // Define unsupported "keywords". ! 3407: // ! 3408: ! 3409: #define _cdecl ! 3410: ! 3411: // begin_windbgkd ! 3412: ! 3413: #if defined(_MIPS_) ! 3414: ! 3415: #endif ! 3416: // ! 3417: // Define length of exception code dispatch vector. ! 3418: // ! 3419: ! 3420: #define XCODE_VECTOR_LENGTH 32 ! 3421: ! 3422: // ! 3423: // Define length of interrupt vector table. ! 3424: // ! 3425: ! 3426: #define MAXIMUM_VECTOR 256 ! 3427: ! 3428: // ! 3429: // Define bus error routine type. ! 3430: // ! 3431: ! 3432: struct _EXCEPTION_RECORD; ! 3433: struct _KEXCEPTION_FRAME; ! 3434: struct _KTRAP_FRAME; ! 3435: ! 3436: typedef ! 3437: VOID ! 3438: (*PKBUS_ERROR_ROUTINE) ( ! 3439: IN struct _EXCEPTION_RECORD *ExceptionRecord, ! 3440: IN struct _KEXCEPTION_FRAME *ExceptionFrame, ! 3441: IN struct _KTRAP_FRAME *TrapFrame, ! 3442: IN PVOID VirtualAddress, ! 3443: IN PHYSICAL_ADDRESS PhysicalAddress ! 3444: ); ! 3445: ! 3446: // ! 3447: // Define Processor Control Region Structure. ! 3448: // ! 3449: ! 3450: #define PCR_MINOR_VERSION 1 ! 3451: #define PCR_MAJOR_VERSION 1 ! 3452: ! 3453: typedef struct _KPCR { ! 3454: ! 3455: // ! 3456: // Major and minor version numbers of the PCR. ! 3457: // ! 3458: ! 3459: USHORT MinorVersion; ! 3460: USHORT MajorVersion; ! 3461: ! 3462: // ! 3463: // Start of the architecturally defined section of the PCR. This section ! 3464: // may be directly addressed by vendor/platform specific HAL code and will ! 3465: // not change from version to version of NT. ! 3466: // ! 3467: // Interrupt and error exception vectors. ! 3468: // ! 3469: ! 3470: PKINTERRUPT_ROUTINE InterruptRoutine[MAXIMUM_VECTOR]; ! 3471: PVOID XcodeDispatch[XCODE_VECTOR_LENGTH]; ! 3472: ! 3473: // ! 3474: // First and second level cache parameters. ! 3475: // ! 3476: ! 3477: ULONG FirstLevelDcacheSize; ! 3478: ULONG FirstLevelDcacheFillSize; ! 3479: ULONG FirstLevelIcacheSize; ! 3480: ULONG FirstLevelIcacheFillSize; ! 3481: ULONG SecondLevelDcacheSize; ! 3482: ULONG SecondLevelDcacheFillSize; ! 3483: ULONG SecondLevelIcacheSize; ! 3484: ULONG SecondLevelIcacheFillSize; ! 3485: ! 3486: // ! 3487: // Pointer to processor control block. ! 3488: // ! 3489: ! 3490: struct _KPRCB *Prcb; ! 3491: ! 3492: // ! 3493: // Pointer to the thread environment block. ! 3494: // ! 3495: ! 3496: PVOID Teb; ! 3497: ! 3498: // ! 3499: // Data cache alignment and fill size used for cache flushing and alignment. ! 3500: // These fields are set to the larger of the first and second level data ! 3501: // cache fill sizes. ! 3502: // ! 3503: ! 3504: ULONG DcacheAlignment; ! 3505: ULONG DcacheFillSize; ! 3506: ! 3507: // ! 3508: // Instruction cache alignment and fill size used for cache flushing and ! 3509: // alignment. These fields are set to the larger of the first and second ! 3510: // level data cache fill sizes. ! 3511: // ! 3512: ! 3513: ULONG IcacheAlignment; ! 3514: ULONG IcacheFillSize; ! 3515: ! 3516: // ! 3517: // Processor identification from PrId register. ! 3518: // ! 3519: ! 3520: ULONG ProcessorId; ! 3521: ! 3522: // ! 3523: // Profiling data. ! 3524: // ! 3525: ! 3526: ULONG ProfileInterval; ! 3527: ULONG ProfileCount; ! 3528: ! 3529: // ! 3530: // Stall execution count and scale factor. ! 3531: // ! 3532: ! 3533: ULONG StallExecutionCount; ! 3534: ULONG StallScaleFactor; ! 3535: ! 3536: // ! 3537: // Spare cell. ! 3538: // ! 3539: ! 3540: ULONG Spare; ! 3541: ! 3542: // ! 3543: // Pointers to bus error and parity error routines. ! 3544: // ! 3545: ! 3546: PKBUS_ERROR_ROUTINE DataBusError; ! 3547: PKBUS_ERROR_ROUTINE InstructionBusError; ! 3548: ! 3549: // ! 3550: // Cache policy, right justified, as read from the processor configuration ! 3551: // register at startup. ! 3552: // ! 3553: ! 3554: ULONG CachePolicy; ! 3555: ! 3556: // ! 3557: // IRQL mapping tables. ! 3558: // ! 3559: ! 3560: UCHAR IrqlMask[32]; ! 3561: UCHAR IrqlTable[9]; ! 3562: ! 3563: // ! 3564: // Current IRQL. ! 3565: // ! 3566: ! 3567: UCHAR CurrentIrql; ! 3568: ! 3569: // ! 3570: // Processor affinity mask. ! 3571: // ! 3572: ! 3573: KAFFINITY SetMember; ! 3574: ! 3575: // ! 3576: // Reserved interrupt vector mask. ! 3577: // ! 3578: ! 3579: ULONG ReservedVectors; ! 3580: ! 3581: // ! 3582: // Current state parameters. ! 3583: // ! 3584: ! 3585: struct _KTHREAD *CurrentThread; ! 3586: ! 3587: // ! 3588: // Cache policy, PTE field aligned, as read from the processor configuration ! 3589: // register at startup. ! 3590: // ! 3591: ! 3592: ULONG AlignedCachePolicy; ! 3593: ! 3594: // ! 3595: // Spare cell. ! 3596: // ! 3597: ! 3598: ULONG Spare0; ! 3599: ! 3600: // ! 3601: // Space reserved for the system. ! 3602: // ! 3603: ! 3604: ULONG SystemReserved[16]; ! 3605: ! 3606: // ! 3607: // Space reserved for the HAL ! 3608: // ! 3609: ! 3610: ULONG HalReserved[16]; ! 3611: ! 3612: // ! 3613: // End of the architecturally defined section of the PCR. This section ! 3614: // may be directly addressed by vendor/platform specific HAL code and will ! 3615: // not change from version to version of NT. ! 3616: // ! 3617: } KPCR, *PKPCR; ! 3618: // ! 3619: // The following flags control the contents of the CONTEXT structure. ! 3620: // ! 3621: ! 3622: #define CONTEXT_R4000 0x00010000 // r4000 context ! 3623: ! 3624: #define CONTEXT_CONTROL (CONTEXT_R4000 | 0x00000001L) ! 3625: #define CONTEXT_FLOATING_POINT (CONTEXT_R4000 | 0x00000002L) ! 3626: #define CONTEXT_INTEGER (CONTEXT_R4000 | 0x00000004L) ! 3627: ! 3628: #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER) ! 3629: ! 3630: // ! 3631: // Context Frame ! 3632: // ! 3633: // N.B. This frame must be exactly a multiple of 16 bytes in length. ! 3634: // ! 3635: // This frame has a several purposes: 1) it is used as an argument to ! 3636: // NtContinue, 2) it is used to constuct a call frame for APC delivery, ! 3637: // 3) it is used to construct a call frame for exception dispatching ! 3638: // in user mode, and 4) it is used in the user level thread creation ! 3639: // routines. ! 3640: // ! 3641: // The layout of the record conforms to a standard call frame. ! 3642: // ! 3643: ! 3644: typedef struct _CONTEXT { ! 3645: ! 3646: // ! 3647: // This section is always present and is used as an argument build ! 3648: // area. ! 3649: // ! 3650: ! 3651: ULONG Argument[4]; ! 3652: ! 3653: // ! 3654: // This section is specified/returned if the ContextFlags word contains ! 3655: // the flag CONTEXT_FLOATING_POINT. ! 3656: // ! 3657: ! 3658: ULONG FltF0; ! 3659: ULONG FltF1; ! 3660: ULONG FltF2; ! 3661: ULONG FltF3; ! 3662: ULONG FltF4; ! 3663: ULONG FltF5; ! 3664: ULONG FltF6; ! 3665: ULONG FltF7; ! 3666: ULONG FltF8; ! 3667: ULONG FltF9; ! 3668: ULONG FltF10; ! 3669: ULONG FltF11; ! 3670: ULONG FltF12; ! 3671: ULONG FltF13; ! 3672: ULONG FltF14; ! 3673: ULONG FltF15; ! 3674: ULONG FltF16; ! 3675: ULONG FltF17; ! 3676: ULONG FltF18; ! 3677: ULONG FltF19; ! 3678: ULONG FltF20; ! 3679: ULONG FltF21; ! 3680: ULONG FltF22; ! 3681: ULONG FltF23; ! 3682: ULONG FltF24; ! 3683: ULONG FltF25; ! 3684: ULONG FltF26; ! 3685: ULONG FltF27; ! 3686: ULONG FltF28; ! 3687: ULONG FltF29; ! 3688: ULONG FltF30; ! 3689: ULONG FltF31; ! 3690: ! 3691: // ! 3692: // This section is specified/returned if the ContextFlags word contains ! 3693: // the flag CONTEXT_INTEGER. ! 3694: // ! 3695: // N.B. The registers gp, sp, and ra are defined in this section, but are ! 3696: // considered part of the control context rather than part of the integer ! 3697: // context. ! 3698: // ! 3699: // N.B. Register zero is not stored in the frame. ! 3700: // ! 3701: ! 3702: ULONG IntZero; ! 3703: ULONG IntAt; ! 3704: ULONG IntV0; ! 3705: ULONG IntV1; ! 3706: ULONG IntA0; ! 3707: ULONG IntA1; ! 3708: ULONG IntA2; ! 3709: ULONG IntA3; ! 3710: ULONG IntT0; ! 3711: ULONG IntT1; ! 3712: ULONG IntT2; ! 3713: ULONG IntT3; ! 3714: ULONG IntT4; ! 3715: ULONG IntT5; ! 3716: ULONG IntT6; ! 3717: ULONG IntT7; ! 3718: ULONG IntS0; ! 3719: ULONG IntS1; ! 3720: ULONG IntS2; ! 3721: ULONG IntS3; ! 3722: ULONG IntS4; ! 3723: ULONG IntS5; ! 3724: ULONG IntS6; ! 3725: ULONG IntS7; ! 3726: ULONG IntT8; ! 3727: ULONG IntT9; ! 3728: ULONG IntK0; ! 3729: ULONG IntK1; ! 3730: ULONG IntGp; ! 3731: ULONG IntSp; ! 3732: ULONG IntS8; ! 3733: ULONG IntRa; ! 3734: ULONG IntLo; ! 3735: ULONG IntHi; ! 3736: ! 3737: // ! 3738: // This section is specified/returned if the ContextFlags word contains ! 3739: // the flag CONTEXT_FLOATING_POINT. ! 3740: // ! 3741: ! 3742: ULONG Fsr; ! 3743: ! 3744: // ! 3745: // This section is specified/returned if the ContextFlags word contains ! 3746: // the flag CONTEXT_CONTROL. ! 3747: // ! 3748: // N.B. The registers gp, sp, and ra are defined in the integer section, ! 3749: // but are considered part of the control context rather than part of ! 3750: // the integer context. ! 3751: // ! 3752: ! 3753: ULONG Fir; ! 3754: ULONG Psr; ! 3755: ! 3756: // ! 3757: // The flags values within this flag control the contents of ! 3758: // a CONTEXT record. ! 3759: // ! 3760: // If the context record is used as an input parameter, then ! 3761: // for each portion of the context record controlled by a flag ! 3762: // whose value is set, it is assumed that that portion of the ! 3763: // context record contains valid context. If the context record ! 3764: // is being used to modify a thread's context, then only that ! 3765: // portion of the threads context will be modified. ! 3766: // ! 3767: // If the context record is used as an IN OUT parameter to capture ! 3768: // the context of a thread, then only those portions of the thread's ! 3769: // context corresponding to set flags will be returned. ! 3770: // ! 3771: // The context record is never used as an OUT only parameter. ! 3772: // ! 3773: ! 3774: ULONG ContextFlags; ! 3775: ! 3776: ULONG Fill[2]; ! 3777: } CONTEXT, *PCONTEXT; ! 3778: ! 3779: #endif // defined(_MIPS_) ! 3780: #ifdef _ALPHA_ ! 3781: // ! 3782: // The following flags control the contents of the CONTEXT structure. ! 3783: // ! 3784: ! 3785: #define CONTEXT_PORTABLE_32BIT 0x00100000 ! 3786: #define CONTEXT_ALPHA 0x00020000 ! 3787: ! 3788: #define CONTEXT_CONTROL (CONTEXT_ALPHA | 0x00000001L) ! 3789: #define CONTEXT_FLOATING_POINT (CONTEXT_ALPHA | 0x00000002L) ! 3790: #define CONTEXT_INTEGER (CONTEXT_ALPHA | 0x00000004L) ! 3791: ! 3792: #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER) ! 3793: ! 3794: #ifndef _PORTABLE_32BIT_CONTEXT ! 3795: ! 3796: // ! 3797: // Context Frame ! 3798: // ! 3799: // This frame has a several purposes: 1) it is used as an argument to ! 3800: // NtContinue, 2) it is used to construct a call frame for APC delivery, ! 3801: // 3) it is used to construct a call frame for exception dispatching ! 3802: // in user mode, 4) it is used in the user level thread creation ! 3803: // routines, and 5) it is used to to pass thread state to debuggers. ! 3804: // ! 3805: // N.B. Because this record is used as a call frame, it must be EXACTLY ! 3806: // a multiple of 16 bytes in length. ! 3807: // ! 3808: // There are two variations of the context structure. This is the real one. ! 3809: // ! 3810: ! 3811: typedef struct _CONTEXT { ! 3812: ! 3813: // ! 3814: // This section is specified/returned if the ContextFlags word contains ! 3815: // the flag CONTEXT_FLOATING_POINT. ! 3816: // ! 3817: ! 3818: ULONGLONG FltF0; ! 3819: ULONGLONG FltF1; ! 3820: ULONGLONG FltF2; ! 3821: ULONGLONG FltF3; ! 3822: ULONGLONG FltF4; ! 3823: ULONGLONG FltF5; ! 3824: ULONGLONG FltF6; ! 3825: ULONGLONG FltF7; ! 3826: ULONGLONG FltF8; ! 3827: ULONGLONG FltF9; ! 3828: ULONGLONG FltF10; ! 3829: ULONGLONG FltF11; ! 3830: ULONGLONG FltF12; ! 3831: ULONGLONG FltF13; ! 3832: ULONGLONG FltF14; ! 3833: ULONGLONG FltF15; ! 3834: ULONGLONG FltF16; ! 3835: ULONGLONG FltF17; ! 3836: ULONGLONG FltF18; ! 3837: ULONGLONG FltF19; ! 3838: ULONGLONG FltF20; ! 3839: ULONGLONG FltF21; ! 3840: ULONGLONG FltF22; ! 3841: ULONGLONG FltF23; ! 3842: ULONGLONG FltF24; ! 3843: ULONGLONG FltF25; ! 3844: ULONGLONG FltF26; ! 3845: ULONGLONG FltF27; ! 3846: ULONGLONG FltF28; ! 3847: ULONGLONG FltF29; ! 3848: ULONGLONG FltF30; ! 3849: ULONGLONG FltF31; ! 3850: ! 3851: // ! 3852: // This section is specified/returned if the ContextFlags word contains ! 3853: // the flag CONTEXT_INTEGER. ! 3854: // ! 3855: // N.B. The registers gp, sp, and ra are defined in this section, but are ! 3856: // considered part of the control context rather than part of the integer ! 3857: // context. ! 3858: // ! 3859: ! 3860: ULONGLONG IntV0; // $0: return value register, v0 ! 3861: ULONGLONG IntT0; // $1: temporary registers, t0 - t7 ! 3862: ULONGLONG IntT1; // $2: ! 3863: ULONGLONG IntT2; // $3: ! 3864: ULONGLONG IntT3; // $4: ! 3865: ULONGLONG IntT4; // $5: ! 3866: ULONGLONG IntT5; // $6: ! 3867: ULONGLONG IntT6; // $7: ! 3868: ULONGLONG IntT7; // $8: ! 3869: ULONGLONG IntS0; // $9: nonvolatile registers, s0 - s5 ! 3870: ULONGLONG IntS1; // $10: ! 3871: ULONGLONG IntS2; // $11: ! 3872: ULONGLONG IntS3; // $12: ! 3873: ULONGLONG IntS4; // $13: ! 3874: ULONGLONG IntS5; // $14: ! 3875: ULONGLONG IntFp; // $15: frame pointer register, fp/s6 ! 3876: ULONGLONG IntA0; // $16: argument registers, a0 - a5 ! 3877: ULONGLONG IntA1; // $17: ! 3878: ULONGLONG IntA2; // $18: ! 3879: ULONGLONG IntA3; // $19: ! 3880: ULONGLONG IntA4; // $20: ! 3881: ULONGLONG IntA5; // $21: ! 3882: ULONGLONG IntT8; // $22: temporary registers, t8 - t11 ! 3883: ULONGLONG IntT9; // $23: ! 3884: ULONGLONG IntT10; // $24: ! 3885: ULONGLONG IntT11; // $25: ! 3886: ULONGLONG IntRa; // $26: return address register, ra ! 3887: ULONGLONG IntT12; // $27: temporary register, t12 ! 3888: ULONGLONG IntAt; // $28: assembler temp register, at ! 3889: ULONGLONG IntGp; // $29: global pointer register, gp ! 3890: ULONGLONG IntSp; // $30: stack pointer register, sp ! 3891: ULONGLONG IntZero; // $31: zero register, zero ! 3892: ! 3893: // ! 3894: // This section is specified/returned if the ContextFlags word contains ! 3895: // the flag CONTEXT_FLOATING_POINT. ! 3896: // ! 3897: ! 3898: ULONGLONG Fpcr; // floating point control register ! 3899: ULONGLONG SoftFpcr; // software extension to FPCR ! 3900: ! 3901: // ! 3902: // This section is specified/returned if the ContextFlags word contains ! 3903: // the flag CONTEXT_CONTROL. ! 3904: // ! 3905: // N.B. The registers gp, sp, and ra are defined in the integer section, ! 3906: // but are considered part of the control context rather than part of ! 3907: // the integer context. ! 3908: // ! 3909: ! 3910: ULONGLONG Fir; // (fault instruction) continuation address ! 3911: ULONG Psr; // processor status ! 3912: ! 3913: // ! 3914: // The flags values within this flag control the contents of ! 3915: // a CONTEXT record. ! 3916: // ! 3917: // If the context record is used as an input parameter, then ! 3918: // for each portion of the context record controlled by a flag ! 3919: // whose value is set, it is assumed that that portion of the ! 3920: // context record contains valid context. If the context record ! 3921: // is being used to modify a thread's context, then only that ! 3922: // portion of the threads context will be modified. ! 3923: // ! 3924: // If the context record is used as an IN OUT parameter to capture ! 3925: // the context of a thread, then only those portions of the thread's ! 3926: // context corresponding to set flags will be returned. ! 3927: // ! 3928: // The context record is never used as an OUT only parameter. ! 3929: // ! 3930: ! 3931: ULONG ContextFlags; ! 3932: ULONG Fill[4]; // padding for 16-byte stack frame alignment ! 3933: ! 3934: } CONTEXT, *PCONTEXT; ! 3935: ! 3936: #else ! 3937: ! 3938: // ! 3939: // 32-bit Context Frame ! 3940: // ! 3941: // This alternate version of the Alpha context structure parallels that ! 3942: // of MIPS and IX86 in style for the first 64 entries: 32-bit machines ! 3943: // can operate on the fields, and a value declared as a pointer to an ! 3944: // array of int's can be used to index into the fields. This makes life ! 3945: // with windbg and ntsd vastly easier. ! 3946: // ! 3947: // There are two parts: the first contains the lower 32-bits of each ! 3948: // element in the 64-bit definition above. The second part contains ! 3949: // the upper 32-bits of each 64-bit element above. ! 3950: // ! 3951: // The names in the first part are identical to the 64-bit names. ! 3952: // The second part names are prefixed with "High". ! 3953: // ! 3954: // 1st half: at 32 bits each, (containing the low parts of 64-bit values) ! 3955: // 32 floats, 32 ints, fpcrs, fir, psr, contextflags ! 3956: // 2nd half: at 32 bits each ! 3957: // 32 floats, 32 ints, fpcrs, fir, fill ! 3958: // ! 3959: // There is no external support for the 32-bit version of the context ! 3960: // structure. It is only used internally by windbg and ntsd. ! 3961: // ! 3962: // This structure must be the same size as the 64-bit version above. ! 3963: // ! 3964: ! 3965: typedef struct _CONTEXT { ! 3966: ! 3967: ULONG FltF0; ! 3968: ULONG FltF1; ! 3969: ULONG FltF2; ! 3970: ULONG FltF3; ! 3971: ULONG FltF4; ! 3972: ULONG FltF5; ! 3973: ULONG FltF6; ! 3974: ULONG FltF7; ! 3975: ULONG FltF8; ! 3976: ULONG FltF9; ! 3977: ULONG FltF10; ! 3978: ULONG FltF11; ! 3979: ULONG FltF12; ! 3980: ULONG FltF13; ! 3981: ULONG FltF14; ! 3982: ULONG FltF15; ! 3983: ULONG FltF16; ! 3984: ULONG FltF17; ! 3985: ULONG FltF18; ! 3986: ULONG FltF19; ! 3987: ULONG FltF20; ! 3988: ULONG FltF21; ! 3989: ULONG FltF22; ! 3990: ULONG FltF23; ! 3991: ULONG FltF24; ! 3992: ULONG FltF25; ! 3993: ULONG FltF26; ! 3994: ULONG FltF27; ! 3995: ULONG FltF28; ! 3996: ULONG FltF29; ! 3997: ULONG FltF30; ! 3998: ULONG FltF31; ! 3999: ! 4000: ULONG IntV0; // $0: return value register, v0 ! 4001: ULONG IntT0; // $1: temporary registers, t0 - t7 ! 4002: ULONG IntT1; // $2: ! 4003: ULONG IntT2; // $3: ! 4004: ULONG IntT3; // $4: ! 4005: ULONG IntT4; // $5: ! 4006: ULONG IntT5; // $6: ! 4007: ULONG IntT6; // $7: ! 4008: ULONG IntT7; // $8: ! 4009: ULONG IntS0; // $9: nonvolatile registers, s0 - s5 ! 4010: ULONG IntS1; // $10: ! 4011: ULONG IntS2; // $11: ! 4012: ULONG IntS3; // $12: ! 4013: ULONG IntS4; // $13: ! 4014: ULONG IntS5; // $14: ! 4015: ULONG IntFp; // $15: frame pointer register, fp/s6 ! 4016: ULONG IntA0; // $16: argument registers, a0 - a5 ! 4017: ULONG IntA1; // $17: ! 4018: ULONG IntA2; // $18: ! 4019: ULONG IntA3; // $19: ! 4020: ULONG IntA4; // $20: ! 4021: ULONG IntA5; // $21: ! 4022: ULONG IntT8; // $22: temporary registers, t8 - t11 ! 4023: ULONG IntT9; // $23: ! 4024: ULONG IntT10; // $24: ! 4025: ULONG IntT11; // $25: ! 4026: ULONG IntRa; // $26: return address register, ra ! 4027: ULONG IntT12; // $27: temporary register, t12 ! 4028: ULONG IntAt; // $28: assembler temp register, at ! 4029: ULONG IntGp; // $29: global pointer register, gp ! 4030: ULONG IntSp; // $30: stack pointer register, sp ! 4031: ULONG IntZero; // $31: zero register, zero ! 4032: ! 4033: ULONG Fpcr; // floating point control register ! 4034: ULONG SoftFpcr; // software extension to FPCR ! 4035: ! 4036: ULONG Fir; // (fault instruction) continuation address ! 4037: ! 4038: ULONG Psr; // processor status ! 4039: ULONG ContextFlags; ! 4040: ! 4041: // ! 4042: // Beginning of the "second half". ! 4043: // The name "High" parallels the HighPart of a LargeInteger. ! 4044: // ! 4045: ! 4046: ULONG HighFltF0; ! 4047: ULONG HighFltF1; ! 4048: ULONG HighFltF2; ! 4049: ULONG HighFltF3; ! 4050: ULONG HighFltF4; ! 4051: ULONG HighFltF5; ! 4052: ULONG HighFltF6; ! 4053: ULONG HighFltF7; ! 4054: ULONG HighFltF8; ! 4055: ULONG HighFltF9; ! 4056: ULONG HighFltF10; ! 4057: ULONG HighFltF11; ! 4058: ULONG HighFltF12; ! 4059: ULONG HighFltF13; ! 4060: ULONG HighFltF14; ! 4061: ULONG HighFltF15; ! 4062: ULONG HighFltF16; ! 4063: ULONG HighFltF17; ! 4064: ULONG HighFltF18; ! 4065: ULONG HighFltF19; ! 4066: ULONG HighFltF20; ! 4067: ULONG HighFltF21; ! 4068: ULONG HighFltF22; ! 4069: ULONG HighFltF23; ! 4070: ULONG HighFltF24; ! 4071: ULONG HighFltF25; ! 4072: ULONG HighFltF26; ! 4073: ULONG HighFltF27; ! 4074: ULONG HighFltF28; ! 4075: ULONG HighFltF29; ! 4076: ULONG HighFltF30; ! 4077: ULONG HighFltF31; ! 4078: ! 4079: ULONG HighIntV0; // $0: return value register, v0 ! 4080: ULONG HighIntT0; // $1: temporary registers, t0 - t7 ! 4081: ULONG HighIntT1; // $2: ! 4082: ULONG HighIntT2; // $3: ! 4083: ULONG HighIntT3; // $4: ! 4084: ULONG HighIntT4; // $5: ! 4085: ULONG HighIntT5; // $6: ! 4086: ULONG HighIntT6; // $7: ! 4087: ULONG HighIntT7; // $8: ! 4088: ULONG HighIntS0; // $9: nonvolatile registers, s0 - s5 ! 4089: ULONG HighIntS1; // $10: ! 4090: ULONG HighIntS2; // $11: ! 4091: ULONG HighIntS3; // $12: ! 4092: ULONG HighIntS4; // $13: ! 4093: ULONG HighIntS5; // $14: ! 4094: ULONG HighIntFp; // $15: frame pointer register, fp/s6 ! 4095: ULONG HighIntA0; // $16: argument registers, a0 - a5 ! 4096: ULONG HighIntA1; // $17: ! 4097: ULONG HighIntA2; // $18: ! 4098: ULONG HighIntA3; // $19: ! 4099: ULONG HighIntA4; // $20: ! 4100: ULONG HighIntA5; // $21: ! 4101: ULONG HighIntT8; // $22: temporary registers, t8 - t11 ! 4102: ULONG HighIntT9; // $23: ! 4103: ULONG HighIntT10; // $24: ! 4104: ULONG HighIntT11; // $25: ! 4105: ULONG HighIntRa; // $26: return address register, ra ! 4106: ULONG HighIntT12; // $27: temporary register, t12 ! 4107: ULONG HighIntAt; // $28: assembler temp register, at ! 4108: ULONG HighIntGp; // $29: global pointer register, gp ! 4109: ULONG HighIntSp; // $30: stack pointer register, sp ! 4110: ULONG HighIntZero; // $31: zero register, zero ! 4111: ! 4112: ULONG HighFpcr; // floating point control register ! 4113: ULONG HighSoftFpcr; // software extension to FPCR ! 4114: ULONG HighFir; // processor status ! 4115: ! 4116: double DoNotUseThisField; // to force quadword structure alignment ! 4117: ULONG HighFill[2]; // padding for 16-byte stack frame alignment ! 4118: ! 4119: } CONTEXT, *PCONTEXT; ! 4120: ! 4121: // ! 4122: // These should name the fields in the _PORTABLE_32BIT structure ! 4123: // that overlay the Psr and ContextFlags in the normal structure. ! 4124: // ! 4125: ! 4126: #define _QUAD_PSR_OFFSET HighSoftFpcr ! 4127: #define _QUAD_FLAGS_OFFSET HighFir ! 4128: ! 4129: #endif // _PORTABLE_32BIT_CONTEXT ! 4130: ! 4131: // ! 4132: // I/O space read and write macros. ! 4133: // ! 4134: // These have to be actual functions on Alpha, because we need ! 4135: // to shift the VA and OR in the BYTE ENABLES. ! 4136: // ! 4137: // These can become INLINEs if we require that ALL Alpha systems shift ! 4138: // the same number of bits and have the SAME byte enables. ! 4139: // ! 4140: // The READ/WRITE_REGISTER_* calls manipulate I/O registers in MEMORY space? ! 4141: // ! 4142: // The READ/WRITE_PORT_* calls manipulate I/O registers in PORT space? ! 4143: // ! 4144: ! 4145: UCHAR ! 4146: READ_REGISTER_UCHAR( ! 4147: PUCHAR Register ! 4148: ); ! 4149: ! 4150: USHORT ! 4151: READ_REGISTER_USHORT( ! 4152: PUSHORT Register ! 4153: ); ! 4154: ! 4155: ULONG ! 4156: READ_REGISTER_ULONG( ! 4157: PULONG Register ! 4158: ); ! 4159: ! 4160: VOID ! 4161: READ_REGISTER_BUFFER_UCHAR( ! 4162: PUCHAR Register, ! 4163: PUCHAR Buffer, ! 4164: ULONG Count ! 4165: ); ! 4166: ! 4167: VOID ! 4168: READ_REGISTER_BUFFER_USHORT( ! 4169: PUSHORT Register, ! 4170: PUSHORT Buffer, ! 4171: ULONG Count ! 4172: ); ! 4173: ! 4174: VOID ! 4175: READ_REGISTER_BUFFER_ULONG( ! 4176: PULONG Register, ! 4177: PULONG Buffer, ! 4178: ULONG Count ! 4179: ); ! 4180: ! 4181: ! 4182: VOID ! 4183: WRITE_REGISTER_UCHAR( ! 4184: PUCHAR Register, ! 4185: UCHAR Value ! 4186: ); ! 4187: ! 4188: VOID ! 4189: WRITE_REGISTER_USHORT( ! 4190: PUSHORT Register, ! 4191: USHORT Value ! 4192: ); ! 4193: ! 4194: VOID ! 4195: WRITE_REGISTER_ULONG( ! 4196: PULONG Register, ! 4197: ULONG Value ! 4198: ); ! 4199: ! 4200: VOID ! 4201: WRITE_REGISTER_BUFFER_UCHAR( ! 4202: PUCHAR Register, ! 4203: PUCHAR Buffer, ! 4204: ULONG Count ! 4205: ); ! 4206: ! 4207: VOID ! 4208: WRITE_REGISTER_BUFFER_USHORT( ! 4209: PUSHORT Register, ! 4210: PUSHORT Buffer, ! 4211: ULONG Count ! 4212: ); ! 4213: ! 4214: VOID ! 4215: WRITE_REGISTER_BUFFER_ULONG( ! 4216: PULONG Register, ! 4217: PULONG Buffer, ! 4218: ULONG Count ! 4219: ); ! 4220: ! 4221: UCHAR ! 4222: READ_PORT_UCHAR( ! 4223: PUCHAR Port ! 4224: ); ! 4225: ! 4226: USHORT ! 4227: READ_PORT_USHORT( ! 4228: PUSHORT Port ! 4229: ); ! 4230: ! 4231: ULONG ! 4232: READ_PORT_ULONG( ! 4233: PULONG Port ! 4234: ); ! 4235: ! 4236: VOID ! 4237: READ_PORT_BUFFER_UCHAR( ! 4238: PUCHAR Port, ! 4239: PUCHAR Buffer, ! 4240: ULONG Count ! 4241: ); ! 4242: ! 4243: VOID ! 4244: READ_PORT_BUFFER_USHORT( ! 4245: PUSHORT Port, ! 4246: PUSHORT Buffer, ! 4247: ULONG Count ! 4248: ); ! 4249: ! 4250: VOID ! 4251: READ_PORT_BUFFER_ULONG( ! 4252: PULONG Port, ! 4253: PULONG Buffer, ! 4254: ULONG Count ! 4255: ); ! 4256: ! 4257: VOID ! 4258: WRITE_PORT_UCHAR( ! 4259: PUCHAR Port, ! 4260: UCHAR Value ! 4261: ); ! 4262: ! 4263: VOID ! 4264: WRITE_PORT_USHORT( ! 4265: PUSHORT Port, ! 4266: USHORT Value ! 4267: ); ! 4268: ! 4269: VOID ! 4270: WRITE_PORT_ULONG( ! 4271: PULONG Port, ! 4272: ULONG Value ! 4273: ); ! 4274: ! 4275: VOID ! 4276: WRITE_PORT_BUFFER_UCHAR( ! 4277: PUCHAR Port, ! 4278: PUCHAR Buffer, ! 4279: ULONG Count ! 4280: ); ! 4281: ! 4282: VOID ! 4283: WRITE_PORT_BUFFER_USHORT( ! 4284: PUSHORT Port, ! 4285: PUSHORT Buffer, ! 4286: ULONG Count ! 4287: ); ! 4288: ! 4289: VOID ! 4290: WRITE_PORT_BUFFER_ULONG( ! 4291: PULONG Port, ! 4292: PULONG Buffer, ! 4293: ULONG Count ! 4294: ); ! 4295: ! 4296: #endif // _ALPHA_ // ntddk nthal ! 4297: ! 4298: // begin_winnt ! 4299: // ! 4300: // Predefined Value Types. ! 4301: // ! 4302: ! 4303: #define REG_NONE ( 0 ) // No value type ! 4304: #define REG_SZ ( 1 ) // Unicode nul terminated string ! 4305: #define REG_EXPAND_SZ ( 2 ) // Unicode nul terminated string ! 4306: // (with environment variable references) ! 4307: #define REG_BINARY ( 3 ) // Free form binary ! 4308: #define REG_DWORD ( 4 ) // 32-bit number ! 4309: #define REG_DWORD_LITTLE_ENDIAN ( 4 ) // 32-bit number (same as REG_DWORD) ! 4310: #define REG_DWORD_BIG_ENDIAN ( 5 ) // 32-bit number ! 4311: #define REG_LINK ( 6 ) // Symbolic Link (unicode) ! 4312: #define REG_MULTI_SZ ( 7 ) // Multiple Unicode strings ! 4313: #define REG_RESOURCE_LIST ( 8 ) // Resource list in the resource map ! 4314: #define REG_FULL_RESOURCE_DESCRIPTOR ( 9 ) // Resource list in the hardware description ! 4315: ! 4316: // ! 4317: // Service Types (Bit Mask) ! 4318: // ! 4319: #define SERVICE_KERNEL_DRIVER 0x00000001 ! 4320: #define SERVICE_FILE_SYSTEM_DRIVER 0x00000002 ! 4321: #define SERVICE_ADAPTER 0x00000004 ! 4322: #define SERVICE_RECOGNIZER_DRIVER 0x00000008 ! 4323: ! 4324: #define SERVICE_DRIVER (SERVICE_KERNEL_DRIVER | \ ! 4325: SERVICE_FILE_SYSTEM_DRIVER | \ ! 4326: SERVICE_RECOGNIZER_DRIVER) ! 4327: ! 4328: #define SERVICE_WIN32_OWN_PROCESS 0x00000010 ! 4329: #define SERVICE_WIN32_SHARE_PROCESS 0x00000020 ! 4330: #define SERVICE_WIN32 (SERVICE_WIN32_OWN_PROCESS | \ ! 4331: SERVICE_WIN32_SHARE_PROCESS) ! 4332: ! 4333: #define SERVICE_TYPE_ALL (SERVICE_WIN32 | \ ! 4334: SERVICE_ADAPTER | \ ! 4335: SERVICE_DRIVER) ! 4336: ! 4337: // ! 4338: // Start Type ! 4339: // ! 4340: ! 4341: #define SERVICE_BOOT_START 0x00000000 ! 4342: #define SERVICE_SYSTEM_START 0x00000001 ! 4343: #define SERVICE_AUTO_START 0x00000002 ! 4344: #define SERVICE_DEMAND_START 0x00000003 ! 4345: #define SERVICE_DISABLED 0x00000004 ! 4346: ! 4347: // ! 4348: // Error control type ! 4349: // ! 4350: #define SERVICE_ERROR_IGNORE 0x00000000 ! 4351: #define SERVICE_ERROR_NORMAL 0x00000001 ! 4352: #define SERVICE_ERROR_SEVERE 0x00000002 ! 4353: #define SERVICE_ERROR_CRITICAL 0x00000003 ! 4354: ! 4355: // ! 4356: // ! 4357: // Define the registry driver node enumerations ! 4358: // ! 4359: ! 4360: typedef enum _CM_SERVICE_NODE_TYPE { ! 4361: DriverType = SERVICE_KERNEL_DRIVER, ! 4362: FileSystemType = SERVICE_FILE_SYSTEM_DRIVER, ! 4363: Win32ServiceOwnProcess = SERVICE_WIN32_OWN_PROCESS, ! 4364: Win32ServiceShareProcess = SERVICE_WIN32_SHARE_PROCESS, ! 4365: AdapterType = SERVICE_ADAPTER, ! 4366: RecognizerType = SERVICE_RECOGNIZER_DRIVER ! 4367: } SERVICE_NODE_TYPE; ! 4368: ! 4369: typedef enum _CM_SERVICE_LOAD_TYPE { ! 4370: BootLoad = SERVICE_BOOT_START, ! 4371: SystemLoad = SERVICE_SYSTEM_START, ! 4372: AutoLoad = SERVICE_AUTO_START, ! 4373: DemandLoad = SERVICE_DEMAND_START, ! 4374: DisableLoad = SERVICE_DISABLED ! 4375: } SERVICE_LOAD_TYPE; ! 4376: ! 4377: typedef enum _CM_ERROR_CONTROL_TYPE { ! 4378: IgnoreError = SERVICE_ERROR_IGNORE, ! 4379: NormalError = SERVICE_ERROR_NORMAL, ! 4380: SevereError = SERVICE_ERROR_SEVERE, ! 4381: CriticalError = SERVICE_ERROR_CRITICAL ! 4382: } SERVICE_ERROR_TYPE; ! 4383: ! 4384: // end_winnt ! 4385: ! 4386: // ! 4387: // Resource List definitions ! 4388: // ! 4389: ! 4390: // ! 4391: // Defines the Type in the RESOURCE_DESCRIPTOR ! 4392: // ! 4393: ! 4394: typedef enum _CM_RESOURCE_TYPE { ! 4395: CmResourceTypeNull = 0, // Reserved ! 4396: CmResourceTypePort, ! 4397: CmResourceTypeInterrupt, ! 4398: CmResourceTypeMemory, ! 4399: CmResourceTypeDma, ! 4400: CmResourceTypeDeviceSpecific ! 4401: } CM_RESOURCE_TYPE; ! 4402: ! 4403: // ! 4404: // Defines the ShareDisposition in the RESOURCE_DESCRIPTOR ! 4405: // ! 4406: ! 4407: typedef enum _CM_SHARE_DISPOSITION { ! 4408: CmResourceShareUndetermined = 0, // Reserved ! 4409: CmResourceShareDeviceExclusive, ! 4410: CmResourceShareDriverExclusive, ! 4411: CmResourceShareShared ! 4412: } CM_SHARE_DISPOSITION; ! 4413: ! 4414: // ! 4415: // Define the bit masks for Flags when type is CmResourceTypeInterrupt ! 4416: // ! 4417: ! 4418: #define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE 0 ! 4419: #define CM_RESOURCE_INTERRUPT_LATCHED 1 ! 4420: ! 4421: // ! 4422: // Define the bit masks for Flags when type is CmResourceTypeInterrupt ! 4423: // ! 4424: ! 4425: #define CM_RESOURCE_MEMORY_READ_WRITE 0 ! 4426: #define CM_RESOURCE_MEMORY_READ_ONLY 1 ! 4427: #define CM_RESOURCE_MEMORY_WRITE_ONLY 2 ! 4428: ! 4429: // ! 4430: // Define the bit masks for Flags when type is CmResourceTypePort ! 4431: // ! 4432: ! 4433: #define CM_RESOURCE_PORT_MEMORY 0 ! 4434: #define CM_RESOURCE_PORT_IO 1 ! 4435: ! 4436: // ! 4437: // This structure defines one type of resource used by a driver. ! 4438: // ! 4439: // There can only be *1* DeviceSpecificData block. It must be located at ! 4440: // the end of all resource descriptors in a full descriptor block. ! 4441: // ! 4442: ! 4443: // ! 4444: // BUGBUG Make sure alignment is made properly by compiler; otherwise move ! 4445: // flags back to the top of the structure (common to all members of the ! 4446: // union). ! 4447: // ! 4448: ! 4449: #pragma pack(4) ! 4450: typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR { ! 4451: UCHAR Type; ! 4452: UCHAR ShareDisposition; ! 4453: USHORT Flags; ! 4454: union { ! 4455: ! 4456: // ! 4457: // Range of port numbers, inclusive. These are physical, bus ! 4458: // relative. The value should be the same as the one passed to ! 4459: // HalTranslateBusAddress(). ! 4460: // ! 4461: ! 4462: struct { ! 4463: PHYSICAL_ADDRESS Start; ! 4464: ULONG Length; ! 4465: } Port; ! 4466: ! 4467: // ! 4468: // IRQL and vector. Should be same values as were passed to ! 4469: // HalGetInterruptVector(). ! 4470: // ! 4471: ! 4472: struct { ! 4473: ULONG Level; ! 4474: ULONG Vector; ! 4475: ULONG Affinity; ! 4476: } Interrupt; ! 4477: ! 4478: // ! 4479: // Range of memory addresses, inclusive. These are physical, bus ! 4480: // relative. The value should be the same as the one passed to ! 4481: // HalTranslateBusAddress(). ! 4482: // ! 4483: ! 4484: struct { ! 4485: PHYSICAL_ADDRESS Start; // 64 bit physical addresses. ! 4486: ULONG Length; ! 4487: } Memory; ! 4488: ! 4489: // ! 4490: // Physical DMA channel. ! 4491: // ! 4492: ! 4493: struct { ! 4494: ULONG Channel; ! 4495: ULONG Port; ! 4496: ULONG Reserved1; ! 4497: } Dma; ! 4498: ! 4499: // ! 4500: // Device Specific information defined by the driver. ! 4501: // The DataSize field indicates the size of the data in bytes. The ! 4502: // data is located immediately after the DeviceSpecificData field in ! 4503: // the structure. ! 4504: // ! 4505: ! 4506: struct { ! 4507: ULONG DataSize; ! 4508: ULONG Reserved1; ! 4509: ULONG Reserved2; ! 4510: } DeviceSpecificData; ! 4511: } u; ! 4512: } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR; ! 4513: #pragma pack() ! 4514: ! 4515: // ! 4516: // A Partial Resource List is what can be found in the ARC firmware ! 4517: // or will be generated by ntdetect.com. ! 4518: // The configuration manager will transform this structure into a Full ! 4519: // resource descriptor when it is about to store it in the regsitry. ! 4520: // ! 4521: // Note: There must a be a convention to the order of fields of same type, ! 4522: // (defined on a device by device basis) so that the fields can make sense ! 4523: // to a driver (i.e. when multiple memory ranges are necessary). ! 4524: // ! 4525: ! 4526: typedef struct _CM_PARTIAL_RESOURCE_LIST { ! 4527: USHORT Version; ! 4528: USHORT Revision; ! 4529: ULONG Count; ! 4530: CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1]; ! 4531: } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST; ! 4532: ! 4533: // ! 4534: // A Full Resource Descriptor is what can be found in the registry. ! 4535: // This is what will be returned to a driver when it queries the registry ! 4536: // to get device information; it will be stored under a key in the hardware ! 4537: // description tree. ! 4538: // ! 4539: // Note: The BusNumber and Type are redundant information, but we will keep ! 4540: // it since it allows the driver _not_ to append it when it is creating ! 4541: // a resource list which could possibly span multiple buses. ! 4542: // ! 4543: // Note2: There must a be a convention to the order of fields of same type, ! 4544: // (defined on a device by device basis) so that the fields can make sense ! 4545: // to a driver (i.e. when multiple memory ranges are necessary). ! 4546: // ! 4547: ! 4548: typedef struct _CM_FULL_RESOURCE_DESCRIPTOR { ! 4549: INTERFACE_TYPE InterfaceType; ! 4550: ULONG BusNumber; ! 4551: CM_PARTIAL_RESOURCE_LIST PartialResourceList; ! 4552: } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR; ! 4553: ! 4554: // ! 4555: // The Resource list is what will be stored by the drivers into the ! 4556: // resource map via the IO API. ! 4557: // ! 4558: ! 4559: typedef struct _CM_RESOURCE_LIST { ! 4560: ULONG Count; ! 4561: CM_FULL_RESOURCE_DESCRIPTOR List[1]; ! 4562: } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST; ! 4563: ! 4564: // ! 4565: // Define the structures used to interpret configuration data of ! 4566: // \\Registry\machine\hardware\description tree. ! 4567: // Basically, these structures are used to interpret component ! 4568: // sepcific data. ! 4569: // ! 4570: ! 4571: // ! 4572: // Define DEVICE_FLAGS ! 4573: // ! 4574: ! 4575: typedef struct _DEVICE_FLAGS { ! 4576: ULONG Failed : 1; ! 4577: ULONG ReadOnly : 1; ! 4578: ULONG Removable : 1; ! 4579: ULONG ConsoleIn : 1; ! 4580: ULONG ConsoleOut : 1; ! 4581: ULONG Input : 1; ! 4582: ULONG Output : 1; ! 4583: } DEVICE_FLAGS, *PDEVICE_FLAGS; ! 4584: ! 4585: // ! 4586: // Define Component Information structure ! 4587: // ! 4588: ! 4589: typedef struct _CM_COMPONENT_INFORMATION { ! 4590: DEVICE_FLAGS Flags; ! 4591: ULONG Version; ! 4592: ULONG Key; ! 4593: ULONG AffinityMask; ! 4594: } CM_COMPONENT_INFORMATION, *PCM_COMPONENT_INFORMATION; ! 4595: ! 4596: // ! 4597: // The following structures are used to interpret x86 ! 4598: // DeviceSpecificData of CM_PARTIAL_RESOURCE_DESCRIPTOR. ! 4599: // (Most of the structures are defined by BIOS. They are ! 4600: // not aligned on word (or dword) boundary. ! 4601: // ! 4602: ! 4603: // ! 4604: // Define the Rom Block structure ! 4605: // ! 4606: ! 4607: typedef struct _CM_ROM_BLOCK { ! 4608: ULONG Address; ! 4609: ULONG Size; ! 4610: } CM_ROM_BLOCK, *PCM_ROM_BLOCK; ! 4611: ! 4612: // begin_ntminiport ! 4613: ! 4614: #pragma pack(1) ! 4615: ! 4616: // end_ntminiport ! 4617: ! 4618: // ! 4619: // Define INT13 driver parameter block ! 4620: // ! 4621: ! 4622: typedef struct _CM_INT13_DRIVE_PARAMETER { ! 4623: USHORT DriveSelect; ! 4624: ULONG MaxCylinders; ! 4625: USHORT SectorsPerTrack; ! 4626: USHORT MaxHeads; ! 4627: USHORT NumberDrives; ! 4628: } CM_INT13_DRIVE_PARAMETER, *PCM_INT13_DRIVE_PARAMETER; ! 4629: ! 4630: // begin_ntminiport ! 4631: ! 4632: // ! 4633: // Define Mca POS data block for slot ! 4634: // ! 4635: ! 4636: typedef struct _CM_MCA_POS_DATA { ! 4637: USHORT AdapterId; ! 4638: UCHAR PosData1; ! 4639: UCHAR PosData2; ! 4640: UCHAR PosData3; ! 4641: UCHAR PosData4; ! 4642: } CM_MCA_POS_DATA, *PCM_MCA_POS_DATA; ! 4643: ! 4644: // ! 4645: // Memory configuration of eisa data block structure ! 4646: // ! 4647: ! 4648: typedef struct _EISA_MEMORY_TYPE { ! 4649: UCHAR ReadWrite: 1; ! 4650: UCHAR Cached : 1; ! 4651: UCHAR Reserved0 :1; ! 4652: UCHAR Type:2; ! 4653: UCHAR Shared:1; ! 4654: UCHAR Reserved1 :1; ! 4655: UCHAR MoreEntries : 1; ! 4656: } EISA_MEMORY_TYPE, *PEISA_MEMORY_TYPE; ! 4657: ! 4658: typedef struct _EISA_MEMORY_CONFIGURATION { ! 4659: EISA_MEMORY_TYPE ConfigurationByte; ! 4660: UCHAR DataSize; ! 4661: USHORT AddressLowWord; ! 4662: UCHAR AddressHighByte; ! 4663: USHORT MemorySize; ! 4664: } EISA_MEMORY_CONFIGURATION, *PEISA_MEMORY_CONFIGURATION; ! 4665: ! 4666: ! 4667: // ! 4668: // Interrupt configurationn of eisa data block structure ! 4669: // ! 4670: ! 4671: typedef struct _EISA_IRQ_DESCRIPTOR { ! 4672: UCHAR Interrupt : 4; ! 4673: UCHAR Reserved :1; ! 4674: UCHAR LevelTriggered :1; ! 4675: UCHAR Shared : 1; ! 4676: UCHAR MoreEntries : 1; ! 4677: } EISA_IRQ_DESCRIPTOR, *PEISA_IRQ_DESCRIPTOR; ! 4678: ! 4679: typedef struct _EISA_IRQ_CONFIGURATION { ! 4680: EISA_IRQ_DESCRIPTOR ConfigurationByte; ! 4681: UCHAR Reserved; ! 4682: } EISA_IRQ_CONFIGURATION, *PEISA_IRQ_CONFIGURATION; ! 4683: ! 4684: ! 4685: // ! 4686: // DMA description of eisa data block structure ! 4687: // ! 4688: ! 4689: typedef struct _DMA_CONFIGURATION_BYTE0 { ! 4690: UCHAR Channel : 3; ! 4691: UCHAR Reserved : 3; ! 4692: UCHAR Shared :1; ! 4693: UCHAR MoreEntries :1; ! 4694: } DMA_CONFIGURATION_BYTE0; ! 4695: ! 4696: typedef struct _DMA_CONFIGURATION_BYTE1 { ! 4697: UCHAR Reserved0 : 2; ! 4698: UCHAR TransferSize : 2; ! 4699: UCHAR Timing : 2; ! 4700: UCHAR Reserved1 : 2; ! 4701: } DMA_CONFIGURATION_BYTE1; ! 4702: ! 4703: typedef struct _EISA_DMA_CONFIGURATION { ! 4704: DMA_CONFIGURATION_BYTE0 ConfigurationByte0; ! 4705: DMA_CONFIGURATION_BYTE1 ConfigurationByte1; ! 4706: } EISA_DMA_CONFIGURATION, *PEISA_DMA_CONFIGURATION; ! 4707: ! 4708: ! 4709: // ! 4710: // Port description of eisa data block structure ! 4711: // ! 4712: ! 4713: typedef struct _EISA_PORT_DESCRIPTOR { ! 4714: UCHAR NumberPorts : 5; ! 4715: UCHAR Reserved :1; ! 4716: UCHAR Shared :1; ! 4717: UCHAR MoreEntries : 1; ! 4718: } EISA_PORT_DESCRIPTOR, *PEISA_PORT_DESCRIPTOR; ! 4719: ! 4720: typedef struct _EISA_PORT_CONFIGURATION { ! 4721: EISA_PORT_DESCRIPTOR Configuration; ! 4722: USHORT PortAddress; ! 4723: } EISA_PORT_CONFIGURATION, *PEISA_PORT_CONFIGURATION; ! 4724: ! 4725: ! 4726: // ! 4727: // Eisa slot information definition ! 4728: // N.B. This structure is different from the one defined ! 4729: // in ARC eisa addendum. ! 4730: // ! 4731: ! 4732: typedef struct _CM_EISA_SLOT_INFORMATION { ! 4733: UCHAR ReturnCode; ! 4734: UCHAR ReturnFlags; ! 4735: UCHAR MajorRevision; ! 4736: UCHAR MinorRevision; ! 4737: USHORT Checksum; ! 4738: UCHAR NumberFunctions; ! 4739: UCHAR FunctionInformation; ! 4740: ULONG CompressedId; ! 4741: } CM_EISA_SLOT_INFORMATION, *PCM_EISA_SLOT_INFORMATION; ! 4742: ! 4743: ! 4744: // ! 4745: // Eisa function information definition ! 4746: // ! 4747: ! 4748: typedef struct _CM_EISA_FUNCTION_INFORMATION { ! 4749: ULONG CompressedId; ! 4750: UCHAR IdSlotFlags1; ! 4751: UCHAR IdSlotFlags2; ! 4752: UCHAR MinorRevision; ! 4753: UCHAR MajorRevision; ! 4754: UCHAR Selections[26]; ! 4755: UCHAR FunctionFlags; ! 4756: UCHAR TypeString[80]; ! 4757: EISA_MEMORY_CONFIGURATION EisaMemory[9]; ! 4758: EISA_IRQ_CONFIGURATION EisaIrq[7]; ! 4759: EISA_DMA_CONFIGURATION EisaDma[4]; ! 4760: EISA_PORT_CONFIGURATION EisaPort[20]; ! 4761: UCHAR InitializationData[60]; ! 4762: } CM_EISA_FUNCTION_INFORMATION, *PCM_EISA_FUNCTION_INFORMATION; ! 4763: ! 4764: #pragma pack() ! 4765: ! 4766: // ! 4767: // Masks for EISA function information ! 4768: // ! 4769: ! 4770: #define EISA_FUNCTION_ENABLED 0x80 ! 4771: #define EISA_FREE_FORM_DATA 0x40 ! 4772: #define EISA_HAS_PORT_INIT_ENTRY 0x20 ! 4773: #define EISA_HAS_PORT_RANGE 0x10 ! 4774: #define EISA_HAS_DMA_ENTRY 0x08 ! 4775: #define EISA_HAS_IRQ_ENTRY 0x04 ! 4776: #define EISA_HAS_MEMORY_ENTRY 0x02 ! 4777: #define EISA_HAS_TYPE_ENTRY 0x01 ! 4778: #define EISA_HAS_INFORMATION EISA_HAS_PORT_RANGE + \ ! 4779: EISA_HAS_DMA_ENTRY + \ ! 4780: EISA_HAS_IRQ_ENTRY + \ ! 4781: EISA_HAS_MEMORY_ENTRY + \ ! 4782: EISA_HAS_TYPE_ENTRY ! 4783: ! 4784: // ! 4785: // Masks for EISA memory configuration ! 4786: // ! 4787: ! 4788: #define EISA_MORE_ENTRIES 0x80 ! 4789: #define EISA_SYSTEM_MEMORY 0x00 ! 4790: #define EISA_MEMORY_TYPE_RAM 0x01 ! 4791: ! 4792: // ! 4793: // Returned error code for EISA bios call ! 4794: // ! 4795: ! 4796: #define EISA_INVALID_SLOT 0x80 ! 4797: #define EISA_INVALID_FUNCTION 0x81 ! 4798: #define EISA_INVALID_CONFIGURATION 0x82 ! 4799: #define EISA_EMPTY_SLOT 0x83 ! 4800: #define EISA_INVALID_BIOS_CALL 0x86 ! 4801: ! 4802: // end_ntminiport ! 4803: ! 4804: // ! 4805: // The following structures are used to interpret mips ! 4806: // DeviceSpecificData of CM_PARTIAL_RESOURCE_DESCRIPTOR. ! 4807: // ! 4808: ! 4809: // ! 4810: // Device data records for adapters. ! 4811: // ! 4812: ! 4813: // ! 4814: // The device data record for the Emulex SCSI controller. ! 4815: // ! 4816: ! 4817: typedef struct _CM_SCSI_DEVICE_DATA { ! 4818: USHORT Version; ! 4819: USHORT Revision; ! 4820: UCHAR HostIdentifier; ! 4821: } CM_SCSI_DEVICE_DATA, *PCM_SCSI_DEVICE_DATA; ! 4822: ! 4823: // ! 4824: // Device data records for controllers. ! 4825: // ! 4826: ! 4827: // ! 4828: // The device data record for the Video controller. ! 4829: // ! 4830: ! 4831: typedef struct _CM_VIDEO_DEVICE_DATA { ! 4832: USHORT Version; ! 4833: USHORT Revision; ! 4834: ULONG VideoClock; ! 4835: } CM_VIDEO_DEVICE_DATA, *PCM_VIDEO_DEVICE_DATA; ! 4836: ! 4837: // ! 4838: // The device data record for the SONIC network controller. ! 4839: // ! 4840: ! 4841: typedef struct _CM_SONIC_DEVICE_DATA { ! 4842: USHORT Version; ! 4843: USHORT Revision; ! 4844: USHORT DataConfigurationRegister; ! 4845: UCHAR EthernetAddress[8]; ! 4846: } CM_SONIC_DEVICE_DATA, *PCM_SONIC_DEVICE_DATA; ! 4847: ! 4848: // ! 4849: // The device data record for the serial controller. ! 4850: // ! 4851: ! 4852: typedef struct _CM_SERIAL_DEVICE_DATA { ! 4853: USHORT Version; ! 4854: USHORT Revision; ! 4855: ULONG BaudClock; ! 4856: } CM_SERIAL_DEVICE_DATA, *PCM_SERIAL_DEVICE_DATA; ! 4857: ! 4858: // ! 4859: // Device data records for peripherals. ! 4860: // ! 4861: ! 4862: // ! 4863: // The device data record for the Monitor peripheral. ! 4864: // ! 4865: ! 4866: typedef struct _CM_MONITOR_DEVICE_DATA { ! 4867: USHORT Version; ! 4868: USHORT Revision; ! 4869: USHORT HorizontalScreenSize; ! 4870: USHORT VerticalScreenSize; ! 4871: USHORT HorizontalResolution; ! 4872: USHORT VerticalResolution; ! 4873: USHORT HorizontalDisplayTimeLow; ! 4874: USHORT HorizontalDisplayTime; ! 4875: USHORT HorizontalDisplayTimeHigh; ! 4876: USHORT HorizontalBackPorchLow; ! 4877: USHORT HorizontalBackPorch; ! 4878: USHORT HorizontalBackPorchHigh; ! 4879: USHORT HorizontalFrontPorchLow; ! 4880: USHORT HorizontalFrontPorch; ! 4881: USHORT HorizontalFrontPorchHigh; ! 4882: USHORT HorizontalSyncLow; ! 4883: USHORT HorizontalSync; ! 4884: USHORT HorizontalSyncHigh; ! 4885: USHORT VerticalBackPorchLow; ! 4886: USHORT VerticalBackPorch; ! 4887: USHORT VerticalBackPorchHigh; ! 4888: USHORT VerticalFrontPorchLow; ! 4889: USHORT VerticalFrontPorch; ! 4890: USHORT VerticalFrontPorchHigh; ! 4891: USHORT VerticalSyncLow; ! 4892: USHORT VerticalSync; ! 4893: USHORT VerticalSyncHigh; ! 4894: } CM_MONITOR_DEVICE_DATA, *PCM_MONITOR_DEVICE_DATA; ! 4895: ! 4896: // ! 4897: // The device data record for the Floppy peripheral. ! 4898: // ! 4899: ! 4900: typedef struct _CM_FLOPPY_DEVICE_DATA { ! 4901: USHORT Version; ! 4902: USHORT Revision; ! 4903: CHAR Size[8]; ! 4904: ULONG MaxDensity; ! 4905: ULONG MountDensity; ! 4906: // ! 4907: // New data fields for version >= 2.0 ! 4908: // ! 4909: UCHAR StepRateHeadUnloadTime; ! 4910: UCHAR HeadLoadTime; ! 4911: UCHAR MotorOffTime; ! 4912: UCHAR SectorLengthCode; ! 4913: UCHAR SectorPerTrack; ! 4914: UCHAR ReadWriteGapLength; ! 4915: UCHAR DataTransferLength; ! 4916: UCHAR FormatGapLength; ! 4917: UCHAR FormatFillCharacter; ! 4918: UCHAR HeadSettleTime; ! 4919: UCHAR MotorSettleTime; ! 4920: UCHAR MaximumTrackValue; ! 4921: UCHAR DataTransferRate; ! 4922: } CM_FLOPPY_DEVICE_DATA, *PCM_FLOPPY_DEVICE_DATA; ! 4923: ! 4924: // ! 4925: // The device data record for the Keyboard peripheral. ! 4926: // The KeyboardFlags is defined (by x86 BIOS INT 16h, function 02) as: ! 4927: // bit 7 : Insert on ! 4928: // bit 6 : Caps Lock on ! 4929: // bit 5 : Num Lock on ! 4930: // bit 4 : Scroll Lock on ! 4931: // bit 3 : Alt Key is down ! 4932: // bit 2 : Ctrl Key is down ! 4933: // bit 1 : Left shift key is down ! 4934: // bit 0 : Right shift key is down ! 4935: // ! 4936: ! 4937: typedef struct _CM_KEYBOARD_DEVICE_DATA { ! 4938: USHORT Version; ! 4939: USHORT Revision; ! 4940: UCHAR Type; ! 4941: UCHAR Subtype; ! 4942: USHORT KeyboardFlags; ! 4943: } CM_KEYBOARD_DEVICE_DATA, *PCM_KEYBOARD_DEVICE_DATA; ! 4944: ! 4945: // ! 4946: // Declaration of the structure for disk geometries ! 4947: // ! 4948: ! 4949: typedef struct _CM_DISK_GEOMETRY_DEVICE_DATA { ! 4950: ULONG BytesPerSector; ! 4951: ULONG NumberOfCylinders; ! 4952: ULONG SectorsPerTrack; ! 4953: ULONG NumberOfHeads; ! 4954: } CM_DISK_GEOMETRY_DEVICE_DATA, *PCM_DISK_GEOMETRY_DEVICE_DATA; ! 4955: ! 4956: // ! 4957: // Exception flag definitions. ! 4958: // ! 4959: ! 4960: // begin_winnt ! 4961: #define EXCEPTION_NONCONTINUABLE 0x1 // Noncontinuable exception ! 4962: // end_winnt ! 4963: ! 4964: // ! 4965: // Define maximum number of exception parameters. ! 4966: // ! 4967: ! 4968: // begin_winnt ! 4969: #define EXCEPTION_MAXIMUM_PARAMETERS 15 // maximum number of exception parameters ! 4970: ! 4971: // ! 4972: // Exception record definition. ! 4973: // ! 4974: ! 4975: typedef struct _EXCEPTION_RECORD { ! 4976: /*lint -e18 */ // Don't complain about different definitions ! 4977: NTSTATUS ExceptionCode; ! 4978: /*lint +e18 */ // Resume checking for different definitions ! 4979: ULONG ExceptionFlags; ! 4980: struct _EXCEPTION_RECORD *ExceptionRecord; ! 4981: PVOID ExceptionAddress; ! 4982: ULONG NumberParameters; ! 4983: ULONG ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; ! 4984: } EXCEPTION_RECORD; ! 4985: ! 4986: typedef EXCEPTION_RECORD *PEXCEPTION_RECORD; ! 4987: ! 4988: // ! 4989: // Typedef for pointer returned by exception_info() ! 4990: // ! 4991: ! 4992: typedef struct _EXCEPTION_POINTERS { ! 4993: PEXCEPTION_RECORD ExceptionRecord; ! 4994: PCONTEXT ContextRecord; ! 4995: } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS; ! 4996: // end_winnt ! 4997: ! 4998: // ! 4999: // Define configuration routine types. ! 5000: // ! 5001: // Configuration information. ! 5002: // ! 5003: ! 5004: typedef enum _CONFIGURATION_TYPE { ! 5005: ArcSystem, ! 5006: CentralProcessor, ! 5007: FloatingPointProcessor, ! 5008: PrimaryIcache, ! 5009: PrimaryDcache, ! 5010: SecondaryIcache, ! 5011: SecondaryDcache, ! 5012: SecondaryCache, ! 5013: EisaAdapter, ! 5014: TcAdapter, ! 5015: ScsiAdapter, ! 5016: DtiAdapter, ! 5017: MultiFunctionAdapter, ! 5018: DiskController, ! 5019: TapeController, ! 5020: CdromController, ! 5021: WormController, ! 5022: SerialController, ! 5023: NetworkController, ! 5024: DisplayController, ! 5025: ParallelController, ! 5026: PointerController, ! 5027: KeyboardController, ! 5028: AudioController, ! 5029: OtherController, ! 5030: DiskPeripheral, ! 5031: FloppyDiskPeripheral, ! 5032: TapePeripheral, ! 5033: ModemPeripheral, ! 5034: MonitorPeripheral, ! 5035: PrinterPeripheral, ! 5036: PointerPeripheral, ! 5037: KeyboardPeripheral, ! 5038: TerminalPeripheral, ! 5039: OtherPeripheral, ! 5040: LinePeripheral, ! 5041: NetworkPeripheral, ! 5042: SystemMemory, ! 5043: MaximumType ! 5044: } CONFIGURATION_TYPE, *PCONFIGURATION_TYPE; ! 5045: ! 5046: ! 5047: // ! 5048: // Interrupt modes. ! 5049: // ! 5050: ! 5051: typedef enum _KINTERRUPT_MODE { ! 5052: LevelSensitive, ! 5053: Latched ! 5054: } KINTERRUPT_MODE; ! 5055: ! 5056: // ! 5057: // Wait reasons ! 5058: // ! 5059: ! 5060: typedef enum _KWAIT_REASON { ! 5061: Executive, ! 5062: FreePage, ! 5063: PageIn, ! 5064: PoolAllocation, ! 5065: DelayExecution, ! 5066: Suspended, ! 5067: UserRequest, ! 5068: WrExecutive, ! 5069: WrFreePage, ! 5070: WrPageIn, ! 5071: WrPoolAllocation, ! 5072: WrDelayExecution, ! 5073: WrSuspended, ! 5074: WrUserRequest, ! 5075: WrEventPairHigh, ! 5076: WrEventPairLow, ! 5077: WrLpcReceive, ! 5078: WrLpcReply, ! 5079: WrVirtualMemory, ! 5080: WrPageOut, ! 5081: Spare1, ! 5082: Spare2, ! 5083: Spare3, ! 5084: Spare4, ! 5085: Spare5, ! 5086: Spare6, ! 5087: WrKernel, ! 5088: MaximumWaitReason ! 5089: } KWAIT_REASON; ! 5090: ! 5091: // ! 5092: // Common dispatcher object header ! 5093: // ! 5094: ! 5095: typedef struct _DISPATCHER_HEADER { ! 5096: CSHORT Type; ! 5097: CSHORT Size; ! 5098: LONG SignalState; ! 5099: LIST_ENTRY WaitListHead; ! 5100: } DISPATCHER_HEADER; ! 5101: ! 5102: // ! 5103: // Wait block ! 5104: // ! 5105: ! 5106: typedef struct _KWAIT_BLOCK { ! 5107: LIST_ENTRY WaitListEntry; ! 5108: struct _KTHREAD *Thread; ! 5109: PVOID Object; ! 5110: struct _KWAIT_BLOCK *NextWaitBlock; ! 5111: CSHORT WaitKey; ! 5112: WAIT_TYPE WaitType; ! 5113: } KWAIT_BLOCK, *PKWAIT_BLOCK; ! 5114: ! 5115: // ! 5116: // Thread start function ! 5117: // ! 5118: ! 5119: typedef ! 5120: VOID ! 5121: (*PKSTART_ROUTINE) ( ! 5122: IN PVOID StartContext ! 5123: ); ! 5124: ! 5125: // ! 5126: // Kernel object structure definitions ! 5127: // ! 5128: ! 5129: // ! 5130: // Device Queue object and entry ! 5131: // ! 5132: ! 5133: typedef struct _KDEVICE_QUEUE { ! 5134: CSHORT Type; ! 5135: CSHORT Size; ! 5136: LIST_ENTRY DeviceListHead; ! 5137: KSPIN_LOCK Lock; ! 5138: BOOLEAN Busy; ! 5139: } KDEVICE_QUEUE, *PKDEVICE_QUEUE; ! 5140: ! 5141: typedef struct _KDEVICE_QUEUE_ENTRY { ! 5142: LIST_ENTRY DeviceListEntry; ! 5143: ULONG SortKey; ! 5144: BOOLEAN Inserted; ! 5145: } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY; ! 5146: ! 5147: // ! 5148: // Event object ! 5149: // ! 5150: ! 5151: typedef struct _KEVENT { ! 5152: DISPATCHER_HEADER Header; ! 5153: } KEVENT, *PKEVENT; ! 5154: ! 5155: // ! 5156: // Define the interrupt service function type and the empty struct ! 5157: // type. ! 5158: // ! 5159: typedef ! 5160: BOOLEAN ! 5161: (*PKSERVICE_ROUTINE) ( ! 5162: IN struct _KINTERRUPT *Interrupt, ! 5163: IN PVOID ServiceContext ! 5164: ); ! 5165: // ! 5166: // Mutex object ! 5167: // ! 5168: ! 5169: typedef struct _KMUTEX { ! 5170: DISPATCHER_HEADER Header; ! 5171: LIST_ENTRY MutexListEntry; ! 5172: struct _KTHREAD *OwnerThread; ! 5173: ULONG Level; ! 5174: } KMUTEX; ! 5175: ! 5176: typedef KMUTEX *PKMUTEX; ! 5177: ! 5178: // ! 5179: // Power notify object ! 5180: // ! 5181: ! 5182: typedef struct _KPOWER_NOTIFY { ! 5183: CSHORT Type; ! 5184: CSHORT Size; ! 5185: LIST_ENTRY NotifyListEntry; ! 5186: PKNOTIFY_ROUTINE NotifyRoutine; ! 5187: PVOID NotifyContext; ! 5188: BOOLEAN Inserted; ! 5189: } KPOWER_NOTIFY; ! 5190: ! 5191: typedef KPOWER_NOTIFY *PKPOWER_NOTIFY; ! 5192: ! 5193: // ! 5194: // Power status object ! 5195: // ! 5196: ! 5197: typedef struct _KPOWER_STATUS { ! 5198: CSHORT Type; ! 5199: CSHORT Size; ! 5200: LIST_ENTRY StatusListEntry; ! 5201: PBOOLEAN Status; ! 5202: BOOLEAN Inserted; ! 5203: } KPOWER_STATUS; ! 5204: ! 5205: typedef KPOWER_STATUS *PKPOWER_STATUS; ! 5206: ! 5207: // ! 5208: // Semaphore object ! 5209: // ! 5210: ! 5211: typedef struct _KSEMAPHORE { ! 5212: DISPATCHER_HEADER Header; ! 5213: LONG Limit; ! 5214: } KSEMAPHORE; ! 5215: ! 5216: typedef KSEMAPHORE *PKSEMAPHORE; ! 5217: ! 5218: // ! 5219: // Timer object ! 5220: // ! 5221: ! 5222: typedef struct _KTIMER { ! 5223: DISPATCHER_HEADER Header; ! 5224: ULARGE_INTEGER DueTime; ! 5225: LIST_ENTRY TimerListEntry; ! 5226: struct _KDPC *Dpc; ! 5227: BOOLEAN Inserted; ! 5228: } KTIMER; ! 5229: ! 5230: typedef KTIMER *PKTIMER; ! 5231: ! 5232: // ! 5233: // DPC object ! 5234: // ! 5235: ! 5236: VOID ! 5237: KeInitializeDpc ( ! 5238: IN PKDPC Dpc, ! 5239: IN PKDEFERRED_ROUTINE DeferredRoutine, ! 5240: IN PVOID DeferredContext ! 5241: ); ! 5242: ! 5243: BOOLEAN ! 5244: KeInsertQueueDpc ( ! 5245: IN PKDPC Dpc, ! 5246: IN PVOID SystemArgument1, ! 5247: IN PVOID SystemArgument2 ! 5248: ); ! 5249: ! 5250: BOOLEAN ! 5251: KeRemoveQueueDpc ( ! 5252: IN PKDPC Dpc ! 5253: ); ! 5254: ! 5255: // ! 5256: // Device queue object ! 5257: // ! 5258: ! 5259: VOID ! 5260: KeInitializeDeviceQueue ( ! 5261: IN PKDEVICE_QUEUE DeviceQueue ! 5262: ); ! 5263: ! 5264: BOOLEAN ! 5265: KeInsertDeviceQueue ( ! 5266: IN PKDEVICE_QUEUE DeviceQueue, ! 5267: IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry ! 5268: ); ! 5269: ! 5270: BOOLEAN ! 5271: KeInsertByKeyDeviceQueue ( ! 5272: IN PKDEVICE_QUEUE DeviceQueue, ! 5273: IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry, ! 5274: IN ULONG SortKey ! 5275: ); ! 5276: ! 5277: PKDEVICE_QUEUE_ENTRY ! 5278: KeRemoveDeviceQueue ( ! 5279: IN PKDEVICE_QUEUE DeviceQueue ! 5280: ); ! 5281: ! 5282: PKDEVICE_QUEUE_ENTRY ! 5283: KeRemoveByKeyDeviceQueue ( ! 5284: IN PKDEVICE_QUEUE DeviceQueue, ! 5285: IN ULONG SortKey ! 5286: ); ! 5287: ! 5288: BOOLEAN ! 5289: KeRemoveEntryDeviceQueue ( ! 5290: IN PKDEVICE_QUEUE DeviceQueue, ! 5291: IN PKDEVICE_QUEUE_ENTRY DeviceQueueEntry ! 5292: ); ! 5293: ! 5294: BOOLEAN ! 5295: KeSynchronizeExecution ( ! 5296: IN PKINTERRUPT Interrupt, ! 5297: IN PKSYNCHRONIZE_ROUTINE SynchronizeRoutine, ! 5298: IN PVOID SynchronizeContext ! 5299: ); ! 5300: ! 5301: // ! 5302: // Kernel dispatcher object functions ! 5303: // ! 5304: // Event Object ! 5305: // ! 5306: ! 5307: VOID ! 5308: KeInitializeEvent ( ! 5309: IN PKEVENT Event, ! 5310: IN EVENT_TYPE Type, ! 5311: IN BOOLEAN State ! 5312: ); ! 5313: ! 5314: LONG ! 5315: KeReadStateEvent ( ! 5316: IN PKEVENT Event ! 5317: ); ! 5318: ! 5319: LONG ! 5320: KeResetEvent ( ! 5321: IN PKEVENT Event ! 5322: ); ! 5323: ! 5324: LONG ! 5325: KeSetEvent ( ! 5326: IN PKEVENT Event, ! 5327: IN KPRIORITY Increment, ! 5328: IN BOOLEAN Wait ! 5329: ); ! 5330: ! 5331: // ! 5332: // Mutex object ! 5333: // ! 5334: ! 5335: VOID ! 5336: KeInitializeMutex ( ! 5337: IN PKMUTEX Mutex, ! 5338: IN ULONG Level ! 5339: ); ! 5340: ! 5341: LONG ! 5342: KeReadStateMutex ( ! 5343: IN PKMUTEX ! 5344: ); ! 5345: ! 5346: LONG ! 5347: KeReleaseMutex ( ! 5348: IN PKMUTEX Mutex, ! 5349: IN BOOLEAN Wait ! 5350: ); ! 5351: ! 5352: // ! 5353: // Semaphore object ! 5354: // ! 5355: ! 5356: VOID ! 5357: KeInitializeSemaphore ( ! 5358: IN PKSEMAPHORE Semaphore, ! 5359: IN LONG Count, ! 5360: IN LONG Limit ! 5361: ); ! 5362: ! 5363: LONG ! 5364: KeReadStateSemaphore ( ! 5365: IN PKSEMAPHORE Semaphore ! 5366: ); ! 5367: ! 5368: LONG ! 5369: KeReleaseSemaphore ( ! 5370: IN PKSEMAPHORE Semaphore, ! 5371: IN KPRIORITY Increment, ! 5372: IN LONG Adjustment, ! 5373: IN BOOLEAN Wait ! 5374: ); ! 5375: ! 5376: NTSTATUS ! 5377: KeDelayExecutionThread ( ! 5378: IN KPROCESSOR_MODE WaitMode, ! 5379: IN BOOLEAN Alertable, ! 5380: IN PLARGE_INTEGER Interval ! 5381: ); ! 5382: ! 5383: LONG ! 5384: KeSetBasePriorityThread ( ! 5385: IN PKTHREAD Thread, ! 5386: IN LONG Increment ! 5387: ); ! 5388: ! 5389: KPRIORITY ! 5390: KeSetPriorityThread ( ! 5391: IN PKTHREAD Thread, ! 5392: IN KPRIORITY Priority ! 5393: ); ! 5394: ! 5395: // ! 5396: // Timer object ! 5397: // ! 5398: ! 5399: VOID ! 5400: KeInitializeTimer ( ! 5401: IN PKTIMER Timer ! 5402: ); ! 5403: ! 5404: BOOLEAN ! 5405: KeCancelTimer ( ! 5406: IN PKTIMER ! 5407: ); ! 5408: ! 5409: BOOLEAN ! 5410: KeReadStateTimer ( ! 5411: PKTIMER Timer ! 5412: ); ! 5413: ! 5414: BOOLEAN ! 5415: KeSetTimer ( ! 5416: IN PKTIMER Timer, ! 5417: IN LARGE_INTEGER DueTime, ! 5418: IN PKDPC Dpc OPTIONAL ! 5419: ); ! 5420: ! 5421: ! 5422: NTSTATUS ! 5423: KeWaitForMultipleObjects ( ! 5424: IN ULONG Count, ! 5425: IN PVOID Object[], ! 5426: IN WAIT_TYPE WaitType, ! 5427: IN KWAIT_REASON WaitReason, ! 5428: IN KPROCESSOR_MODE WaitMode, ! 5429: IN BOOLEAN Alertable, ! 5430: IN PLARGE_INTEGER Timeout OPTIONAL, ! 5431: IN PKWAIT_BLOCK WaitBlockArray OPTIONAL ! 5432: ); ! 5433: ! 5434: NTSTATUS ! 5435: KeWaitForSingleObject ( ! 5436: IN PVOID Object, ! 5437: IN KWAIT_REASON WaitReason, ! 5438: IN KPROCESSOR_MODE WaitMode, ! 5439: IN BOOLEAN Alertable, ! 5440: IN PLARGE_INTEGER Timeout OPTIONAL ! 5441: ); ! 5442: ! 5443: // ! 5444: // spin lock functions ! 5445: // ! 5446: ! 5447: VOID ! 5448: KeInitializeSpinLock ( ! 5449: IN PKSPIN_LOCK SpinLock ! 5450: ); ! 5451: ! 5452: VOID ! 5453: KeAcquireSpinLock ( ! 5454: IN PKSPIN_LOCK SpinLock, ! 5455: OUT PKIRQL OldIrql ! 5456: ); ! 5457: ! 5458: VOID ! 5459: KeReleaseSpinLock ( ! 5460: IN PKSPIN_LOCK SpinLock, ! 5461: IN KIRQL NewIrql ! 5462: ); ! 5463: ! 5464: VOID ! 5465: KeAcquireSpinLockAtDpcLevel ( ! 5466: IN PKSPIN_LOCK SpinLock ! 5467: ); ! 5468: ! 5469: VOID ! 5470: KeReleaseSpinLockFromDpcLevel ( ! 5471: IN PKSPIN_LOCK SpinLock ! 5472: ); ! 5473: ! 5474: ! 5475: // ! 5476: // Miscellaneous kernel functions ! 5477: // ! 5478: ! 5479: VOID ! 5480: KeBugCheck ( ! 5481: IN ULONG BugCheckCode ! 5482: ); ! 5483: ! 5484: VOID ! 5485: KeBugCheckEx( ! 5486: IN ULONG BugCheckCode, ! 5487: IN ULONG BugCheckParameter1, ! 5488: IN ULONG BugCheckParameter2, ! 5489: IN ULONG BugCheckParameter3, ! 5490: IN ULONG BugCheckParameter4 ! 5491: ); ! 5492: ! 5493: VOID ! 5494: KeEnterKernelDebugger ( ! 5495: VOID ! 5496: ); ! 5497: ! 5498: ! 5499: VOID ! 5500: KeQuerySystemTime ( ! 5501: OUT PLARGE_INTEGER CurrentTime ! 5502: ); ! 5503: ! 5504: VOID ! 5505: KeQueryTickCount ( ! 5506: OUT PLARGE_INTEGER CurrentCount ! 5507: ); ! 5508: ! 5509: ULONG ! 5510: KeQueryTimeIncrement ( ! 5511: VOID ! 5512: ); ! 5513: ! 5514: // ! 5515: // Define external data. ! 5516: // ! 5517: ! 5518: extern BOOLEAN KdDebuggerNotPresent; ! 5519: extern BOOLEAN KdDebuggerEnabled; ! 5520: ! 5521: // ! 5522: // Interlocked support routine definitions. ! 5523: // ! 5524: ! 5525: LARGE_INTEGER ! 5526: ExInterlockedAddLargeInteger ( ! 5527: IN PLARGE_INTEGER Addend, ! 5528: IN LARGE_INTEGER Increment, ! 5529: IN PKSPIN_LOCK Lock ! 5530: ); ! 5531: ! 5532: ULONG ! 5533: ExInterlockedAddUlong ( ! 5534: IN PULONG Addend, ! 5535: IN ULONG Increment, ! 5536: IN PKSPIN_LOCK Lock ! 5537: ); ! 5538: ! 5539: PLIST_ENTRY ! 5540: ExInterlockedInsertHeadList ( ! 5541: IN PLIST_ENTRY ListHead, ! 5542: IN PLIST_ENTRY ListEntry, ! 5543: IN PKSPIN_LOCK Lock ! 5544: ); ! 5545: ! 5546: PLIST_ENTRY ! 5547: ExInterlockedInsertTailList ( ! 5548: IN PLIST_ENTRY ListHead, ! 5549: IN PLIST_ENTRY ListEntry, ! 5550: IN PKSPIN_LOCK Lock ! 5551: ); ! 5552: ! 5553: PLIST_ENTRY ! 5554: ExInterlockedRemoveHeadList ( ! 5555: IN PLIST_ENTRY ListHead, ! 5556: IN PKSPIN_LOCK Lock ! 5557: ); ! 5558: ! 5559: PSINGLE_LIST_ENTRY ! 5560: ExInterlockedPopEntryList ( ! 5561: IN PSINGLE_LIST_ENTRY ListHead, ! 5562: IN PKSPIN_LOCK Lock ! 5563: ); ! 5564: ! 5565: PSINGLE_LIST_ENTRY ! 5566: ExInterlockedPushEntryList ( ! 5567: IN PSINGLE_LIST_ENTRY ListHead, ! 5568: IN PSINGLE_LIST_ENTRY ListEntry, ! 5569: IN PKSPIN_LOCK Lock ! 5570: ); ! 5571: ! 5572: INTERLOCKED_RESULT ! 5573: ExInterlockedIncrementLong ( ! 5574: IN PLONG Addend, ! 5575: IN PKSPIN_LOCK Lock ! 5576: ); ! 5577: ! 5578: INTERLOCKED_RESULT ! 5579: ExInterlockedDecrementLong ( ! 5580: IN PLONG Addend, ! 5581: IN PKSPIN_LOCK Lock ! 5582: ); ! 5583: ! 5584: ULONG ! 5585: ExInterlockedExchangeUlong ( ! 5586: IN PULONG Target, ! 5587: IN ULONG Value, ! 5588: IN PKSPIN_LOCK Lock ! 5589: ); ! 5590: ! 5591: // ! 5592: // Pool Allocation routines (in pool.c) ! 5593: // ! 5594: ! 5595: typedef enum _POOL_TYPE { ! 5596: NonPagedPool, ! 5597: PagedPool, ! 5598: NonPagedPoolMustSucceed, ! 5599: DontUseThisType, ! 5600: NonPagedPoolCacheAligned, ! 5601: PagedPoolCacheAligned, ! 5602: NonPagedPoolCacheAlignedMustS, ! 5603: MaxPoolType ! 5604: } POOL_TYPE; ! 5605: ! 5606: ! 5607: PVOID ! 5608: ExAllocatePool( ! 5609: IN POOL_TYPE PoolType, ! 5610: IN ULONG NumberOfBytes ! 5611: ); ! 5612: ! 5613: PVOID ! 5614: ExAllocatePoolWithQuota( ! 5615: IN POOL_TYPE PoolType, ! 5616: IN ULONG NumberOfBytes ! 5617: ); ! 5618: ! 5619: VOID ! 5620: ExFreePool( ! 5621: IN PVOID P ! 5622: ); ! 5623: ! 5624: // ! 5625: // Worker Thread ! 5626: // ! 5627: ! 5628: typedef enum _WORK_QUEUE_TYPE { ! 5629: CriticalWorkQueue, ! 5630: DelayedWorkQueue, ! 5631: MaximumWorkQueue ! 5632: } WORK_QUEUE_TYPE; ! 5633: ! 5634: typedef ! 5635: VOID ! 5636: (*PWORKER_THREAD_ROUTINE)( ! 5637: IN PVOID Parameter ! 5638: ); ! 5639: ! 5640: typedef struct _WORK_QUEUE_ITEM { ! 5641: LIST_ENTRY List; ! 5642: PWORKER_THREAD_ROUTINE WorkerRoutine; ! 5643: PVOID Parameter; ! 5644: } WORK_QUEUE_ITEM, *PWORK_QUEUE_ITEM; ! 5645: ! 5646: ! 5647: #define ExInitializeWorkItem(Item, Routine, Context) \ ! 5648: (Item)->WorkerRoutine = (Routine); \ ! 5649: (Item)->Parameter = (Context); \ ! 5650: (Item)->List.Flink = NULL; ! 5651: ! 5652: VOID ! 5653: ExQueueWorkItem( ! 5654: IN PWORK_QUEUE_ITEM WorkItem, ! 5655: IN WORK_QUEUE_TYPE QueueType ! 5656: ); ! 5657: ! 5658: // ! 5659: // Zone Allocation ! 5660: // ! 5661: ! 5662: typedef struct _ZONE_SEGMENT_HEADER { ! 5663: SINGLE_LIST_ENTRY SegmentList; ! 5664: PVOID Reserved; ! 5665: } ZONE_SEGMENT_HEADER, *PZONE_SEGMENT_HEADER; ! 5666: ! 5667: typedef struct _ZONE_HEADER { ! 5668: SINGLE_LIST_ENTRY FreeList; ! 5669: SINGLE_LIST_ENTRY SegmentList; ! 5670: ULONG BlockSize; ! 5671: ULONG TotalSegmentSize; ! 5672: } ZONE_HEADER, *PZONE_HEADER; ! 5673: ! 5674: ! 5675: NTSTATUS ! 5676: ExInitializeZone( ! 5677: IN PZONE_HEADER Zone, ! 5678: IN ULONG BlockSize, ! 5679: IN PVOID InitialSegment, ! 5680: IN ULONG InitialSegmentSize ! 5681: ); ! 5682: ! 5683: NTSTATUS ! 5684: ExExtendZone( ! 5685: IN PZONE_HEADER Zone, ! 5686: IN PVOID Segment, ! 5687: IN ULONG SegmentSize ! 5688: ); ! 5689: ! 5690: //++ ! 5691: // ! 5692: // PVOID ! 5693: // ExAllocateFromZone( ! 5694: // IN PZONE_HEADER Zone ! 5695: // ) ! 5696: // ! 5697: // Routine Description: ! 5698: // ! 5699: // This routine removes an entry from the zone and returns a pointer to it. ! 5700: // ! 5701: // Arguments: ! 5702: // ! 5703: // Zone - Pointer to the zone header controlling the storage from which the ! 5704: // entry is to be allocated. ! 5705: // ! 5706: // Return Value: ! 5707: // ! 5708: // The function value is a pointer to the storage allocated from the zone. ! 5709: // ! 5710: //-- ! 5711: ! 5712: #define ExAllocateFromZone(Zone) \ ! 5713: (PVOID)((Zone)->FreeList.Next); \ ! 5714: if ( (Zone)->FreeList.Next ) (Zone)->FreeList.Next = (Zone)->FreeList.Next->Next ! 5715: ! 5716: ! 5717: //++ ! 5718: // ! 5719: // PVOID ! 5720: // ExFreeToZone( ! 5721: // IN PZONE_HEADER Zone, ! 5722: // IN PVOID Block ! 5723: // ) ! 5724: // ! 5725: // Routine Description: ! 5726: // ! 5727: // This routine places the specified block of storage back onto the free ! 5728: // list in the specified zone. ! 5729: // ! 5730: // Arguments: ! 5731: // ! 5732: // Zone - Pointer to the zone header controlling the storage to which the ! 5733: // entry is to be inserted. ! 5734: // ! 5735: // Block - Pointer to the block of storage to be freed back to the zone. ! 5736: // ! 5737: // Return Value: ! 5738: // ! 5739: // Pointer to previous block of storage that was at the head of the free ! 5740: // list. NULL implies the zone went from no available free blocks to ! 5741: // at least one free block. ! 5742: // ! 5743: //-- ! 5744: ! 5745: #define ExFreeToZone(Zone,Block) \ ! 5746: ( ((PSINGLE_LIST_ENTRY)(Block))->Next = (Zone)->FreeList.Next, \ ! 5747: (Zone)->FreeList.Next = ((PSINGLE_LIST_ENTRY)(Block)), \ ! 5748: ((PSINGLE_LIST_ENTRY)(Block))->Next \ ! 5749: ) ! 5750: ! 5751: ! 5752: //++ ! 5753: // ! 5754: // BOOLEAN ! 5755: // ExIsFullZone( ! 5756: // IN PZONE_HEADER Zone ! 5757: // ) ! 5758: // ! 5759: // Routine Description: ! 5760: // ! 5761: // This routine determines if the specified zone is full or not. A zone ! 5762: // is considered full if the free list is empty. ! 5763: // ! 5764: // Arguments: ! 5765: // ! 5766: // Zone - Pointer to the zone header to be tested. ! 5767: // ! 5768: // Return Value: ! 5769: // ! 5770: // TRUE if the zone is full and FALSE otherwise. ! 5771: // ! 5772: //-- ! 5773: ! 5774: #define ExIsFullZone(Zone) \ ! 5775: ( (Zone)->FreeList.Next == (PSINGLE_LIST_ENTRY)NULL ) ! 5776: ! 5777: //++ ! 5778: // ! 5779: // PVOID ! 5780: // ExInterlockedAllocateFromZone( ! 5781: // IN PZONE_HEADER Zone, ! 5782: // IN PKSPIN_LOCK Lock ! 5783: // ) ! 5784: // ! 5785: // Routine Description: ! 5786: // ! 5787: // This routine removes an entry from the zone and returns a pointer to it. ! 5788: // The removal is performed with the specified lock owned for the sequence ! 5789: // to make it MP-safe. ! 5790: // ! 5791: // Arguments: ! 5792: // ! 5793: // Zone - Pointer to the zone header controlling the storage from which the ! 5794: // entry is to be allocated. ! 5795: // ! 5796: // Lock - Pointer to the spin lock which should be obtained before removing ! 5797: // the entry from the allocation list. The lock is released before ! 5798: // returning to the caller. ! 5799: // ! 5800: // Return Value: ! 5801: // ! 5802: // The function value is a pointer to the storage allocated from the zone. ! 5803: // ! 5804: //-- ! 5805: ! 5806: #define ExInterlockedAllocateFromZone(Zone,Lock) \ ! 5807: (PVOID) ExInterlockedPopEntryList( &(Zone)->FreeList, Lock ) ! 5808: ! 5809: //++ ! 5810: // ! 5811: // PVOID ! 5812: // ExInterlockedFreeToZone( ! 5813: // IN PZONE_HEADER Zone, ! 5814: // IN PVOID Block, ! 5815: // IN PKSPIN_LOCK Lock ! 5816: // ) ! 5817: // ! 5818: // Routine Description: ! 5819: // ! 5820: // This routine places the specified block of storage back onto the free ! 5821: // list in the specified zone. The insertion is performed with the lock ! 5822: // owned for the sequence to make it MP-safe. ! 5823: // ! 5824: // Arguments: ! 5825: // ! 5826: // Zone - Pointer to the zone header controlling the storage to which the ! 5827: // entry is to be inserted. ! 5828: // ! 5829: // Block - Pointer to the block of storage to be freed back to the zone. ! 5830: // ! 5831: // Lock - Pointer to the spin lock which should be obtained before inserting ! 5832: // the entry onto the free list. The lock is released before returning ! 5833: // to the caller. ! 5834: // ! 5835: // Return Value: ! 5836: // ! 5837: // Pointer to previous block of storage that was at the head of the free ! 5838: // list. NULL implies the zone went from no available free blocks to ! 5839: // at least one free block. ! 5840: // ! 5841: //-- ! 5842: ! 5843: #define ExInterlockedFreeToZone(Zone,Block,Lock) \ ! 5844: ExInterlockedPushEntryList( &(Zone)->FreeList, ((PSINGLE_LIST_ENTRY) (Block)), Lock ) ! 5845: ! 5846: // ! 5847: // Shared resource function definitions (in resource.c). ! 5848: // ! 5849: // Note that this structure is opaque, but we'll define it here ! 5850: // so drivers can allocate the proper amount of memory for a resource. ! 5851: // ! 5852: ! 5853: typedef ULONG ERESOURCE_THREAD; ! 5854: typedef ERESOURCE_THREAD *PERESOURCE_THREAD; ! 5855: ! 5856: typedef struct _ERESOURCE { ! 5857: ! 5858: // ! 5859: // First 8 bytes are used to align the next part of the structure ! 5860: // onto 16 bytes. (typical case) ! 5861: // ! 5862: ! 5863: LIST_ENTRY SystemResourcesList; ! 5864: ! 5865: // ! 5866: // Next 128 bits of this structure are field which we know ! 5867: // we will hit to obtain this resource either shared or exclusive ! 5868: // ! 5869: ! 5870: PERESOURCE_THREAD OwnerThreads; ! 5871: PUCHAR OwnerCounts; ! 5872: ! 5873: USHORT TableSize; ! 5874: USHORT ActiveCount; ! 5875: ! 5876: USHORT Flag; ! 5877: USHORT TableRover; // (0 - 128 bits) ! 5878: ! 5879: // ! 5880: // Next 128 bits contain the initial counters and at least the ! 5881: // first initial thread (which is also highly updated) ! 5882: // ! 5883: ! 5884: UCHAR InitialOwnerCounts[4]; ! 5885: ERESOURCE_THREAD InitialOwnerThreads[4]; ! 5886: ! 5887: ULONG Spare1; ! 5888: ! 5889: // ! 5890: // The rest is what ever was left. The spinlock is in with ! 5891: // a part of the stucture we normally don't touch in the ! 5892: // hot paths (read or write) ! 5893: // ! 5894: ! 5895: ULONG ContentionCount; ! 5896: ! 5897: USHORT NumberOfExclusiveWaiters; ! 5898: USHORT NumberOfSharedWaiters; ! 5899: ! 5900: KSEMAPHORE SharedWaiters; ! 5901: KEVENT ExclusiveWaiters; ! 5902: ! 5903: KSPIN_LOCK SpinLock; ! 5904: ! 5905: #ifdef _X86_ ! 5906: ULONG CreatorBackTraceIndex; ! 5907: USHORT Depth; ! 5908: USHORT Reserved; ! 5909: PVOID OwnerBackTrace[ 4 ]; ! 5910: #else ! 5911: ULONG Spare[ 6 ]; ! 5912: #endif ! 5913: ! 5914: } ERESOURCE; ! 5915: typedef ERESOURCE *PERESOURCE; ! 5916: ! 5917: // ! 5918: // Values for ERESOURCE.Flag ! 5919: // ! 5920: #define ResourceNeverExclusive 0x10 ! 5921: #define ResourceReleaseByOtherThread 0x20 ! 5922: #define ResourceOwnedExclusive 0x80 ! 5923: ! 5924: NTSTATUS ! 5925: ExInitializeResource( ! 5926: IN PERESOURCE Resource ! 5927: ); ! 5928: ! 5929: ! 5930: BOOLEAN ! 5931: ExAcquireResourceExclusive( ! 5932: IN PERESOURCE Resource, ! 5933: IN BOOLEAN Wait ! 5934: ); ! 5935: ! 5936: // ! 5937: // VOID ! 5938: // ExReleaseResource( ! 5939: // IN PERESOURCE Resource ! 5940: // ); ! 5941: // ! 5942: ! 5943: #define ExReleaseResource(R) (ExReleaseResourceForThread(R, ExGetCurrentResourceThread())) ! 5944: ! 5945: VOID ! 5946: ExReleaseResourceForThread( ! 5947: IN PERESOURCE Resource, ! 5948: IN ERESOURCE_THREAD ResourceThreadId ! 5949: ); ! 5950: ! 5951: ! 5952: NTSTATUS ! 5953: ExDeleteResource ( ! 5954: IN PERESOURCE Resource ! 5955: ); ! 5956: ! 5957: ! 5958: // ! 5959: // ERESOURCE_THREAD ! 5960: // ExGetCurrentResourceThread( ! 5961: // ); ! 5962: // ! 5963: ! 5964: #define ExGetCurrentResourceThread() ((ULONG)PsGetCurrentThread()) ! 5965: ! 5966: // ! 5967: // Priority increment definitions. The comment for each definition gives ! 5968: // the names of the system services that use the definition when satisfying ! 5969: // a wait. ! 5970: // ! 5971: // ! 5972: // Priority increment when no I/O has been done. This is used by device ! 5973: // and file system drivers when completing an IRP (IoCompleteRequest). ! 5974: // ! 5975: ! 5976: #define IO_NO_INCREMENT 0 ! 5977: ! 5978: // ! 5979: // Priority increment for completing CD-ROM I/O. This is used by CD-ROM device ! 5980: // and file system drivers when completing an IRP (IoCompleteRequest) ! 5981: // ! 5982: ! 5983: #define IO_CD_ROM_INCREMENT 1 ! 5984: ! 5985: // ! 5986: // Priority increment for completing disk I/O. This is used by disk device ! 5987: // and file system drivers when completing an IRP (IoCompleteRequest) ! 5988: // ! 5989: ! 5990: #define IO_DISK_INCREMENT 1 ! 5991: ! 5992: // ! 5993: // Priority increment for completing keyboard I/O. This is used by keyboard ! 5994: // device drivers when completing an IRP (IoCompleteRequest) ! 5995: // ! 5996: ! 5997: #define IO_KEYBOARD_INCREMENT 6 ! 5998: ! 5999: // ! 6000: // Priority increment for completing mailslot I/O. This is used by the mail- ! 6001: // slot file system driver when completing an IRP (IoCompleteRequest). ! 6002: // ! 6003: ! 6004: #define IO_MAILSLOT_INCREMENT 2 ! 6005: ! 6006: // ! 6007: // Priority increment for completing mouse I/O. This is used by mouse device ! 6008: // drivers when completing an IRP (IoCompleteRequest) ! 6009: // ! 6010: ! 6011: #define IO_MOUSE_INCREMENT 6 ! 6012: ! 6013: // ! 6014: // Priority increment for completing named pipe I/O. This is used by the ! 6015: // named pipe file system driver when completing an IRP (IoCompleteRequest). ! 6016: // ! 6017: ! 6018: #define IO_NAMED_PIPE_INCREMENT 2 ! 6019: ! 6020: // ! 6021: // Priority increment for completing network I/O. This is used by network ! 6022: // device and network file system drivers when completing an IRP ! 6023: // (IoCompleteRequest). ! 6024: // ! 6025: ! 6026: #define IO_NETWORK_INCREMENT 2 ! 6027: ! 6028: // ! 6029: // Priority increment for completing parallel I/O. This is used by parallel ! 6030: // device drivers when completing an IRP (IoCompleteRequest) ! 6031: // ! 6032: ! 6033: #define IO_PARALLEL_INCREMENT 1 ! 6034: ! 6035: // ! 6036: // Priority increment for completing serial I/O. This is used by serial device ! 6037: // drivers when completing an IRP (IoCompleteRequest) ! 6038: // ! 6039: ! 6040: #define IO_SERIAL_INCREMENT 2 ! 6041: ! 6042: // ! 6043: // Priority increment for completing sound I/O. This is used by sound device ! 6044: // drivers when completing an IRP (IoCompleteRequest) ! 6045: // ! 6046: ! 6047: #define IO_SOUND_INCREMENT 8 ! 6048: ! 6049: // ! 6050: // Priority increment for completing video I/O. This is used by video device ! 6051: // drivers when completing an IRP (IoCompleteRequest) ! 6052: // ! 6053: ! 6054: #define IO_VIDEO_INCREMENT 1 ! 6055: ! 6056: // ! 6057: // Priority increment used when satisfying a wait on an executive semaphore ! 6058: // (NtReleaseSemaphore) ! 6059: // ! 6060: ! 6061: #define SEMAPHORE_INCREMENT 1 ! 6062: ! 6063: // ! 6064: // Define maximum disk transfer size to be used by MM and Cache Manager, ! 6065: // so that packet-oriented disk drivers can optimize their packet allocation ! 6066: // to this size. ! 6067: // ! 6068: ! 6069: #define MM_MAXIMUM_DISK_IO_SIZE (0x10000) ! 6070: ! 6071: //++ ! 6072: // ! 6073: // ULONG ! 6074: // ROUND_TO_PAGES ( ! 6075: // IN ULONG Size ! 6076: // ) ! 6077: // ! 6078: // Routine Description: ! 6079: // ! 6080: // The ROUND_TO_PAGES macro takes a size in bytes and rounds it up to a ! 6081: // multiple of the page size. ! 6082: // ! 6083: // NOTE: This macro fails for values 0xFFFFFFFF - (PAGE_SIZE - 1). ! 6084: // ! 6085: // Arguments: ! 6086: // ! 6087: // Size - Size in bytes to round up to a page multiple. ! 6088: // ! 6089: // Return Value: ! 6090: // ! 6091: // Returns the size rounded up to a multiple of the page size. ! 6092: // ! 6093: //-- ! 6094: ! 6095: #define ROUND_TO_PAGES(Size) (((ULONG)(Size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1)) ! 6096: ! 6097: //++ ! 6098: // ! 6099: // ULONG ! 6100: // BYTES_TO_PAGES ( ! 6101: // IN ULONG Size ! 6102: // ) ! 6103: // ! 6104: // Routine Description: ! 6105: // ! 6106: // The BYTES_TO_PAGES macro takes the size in bytes and calculates the ! 6107: // number of pages required to contain the bytes. ! 6108: // ! 6109: // Arguments: ! 6110: // ! 6111: // Size - Size in bytes. ! 6112: // ! 6113: // Return Value: ! 6114: // ! 6115: // Returns the number of pages required to contain the specified size. ! 6116: // ! 6117: //-- ! 6118: ! 6119: #define BYTES_TO_PAGES(Size) (((ULONG)(Size) >> PAGE_SHIFT) + \ ! 6120: (((ULONG)(Size) & (PAGE_SIZE - 1)) != 0)) ! 6121: ! 6122: //++ ! 6123: // ! 6124: // ULONG ! 6125: // BYTE_OFFSET ( ! 6126: // IN PVOID Va ! 6127: // ) ! 6128: // ! 6129: // Routine Description: ! 6130: // ! 6131: // The BYTE_OFFSET macro takes a virtual address and returns the byte offset ! 6132: // of that address within the page. ! 6133: // ! 6134: // Arguments: ! 6135: // ! 6136: // Va - Virtual address. ! 6137: // ! 6138: // Return Value: ! 6139: // ! 6140: // Returns the byte offset portion of the virtual address. ! 6141: // ! 6142: //-- ! 6143: ! 6144: #define BYTE_OFFSET(Va) ((ULONG)(Va) & (PAGE_SIZE - 1)) ! 6145: ! 6146: //++ ! 6147: // ! 6148: // PVOID ! 6149: // PAGE_ALIGN ( ! 6150: // IN PVOID Va ! 6151: // ) ! 6152: // ! 6153: // Routine Description: ! 6154: // ! 6155: // The PAGE_ALIGN macro takes a virtual address and returns a page-aligned ! 6156: // virtual address for that page. ! 6157: // ! 6158: // Arguments: ! 6159: // ! 6160: // Va - Virtual address. ! 6161: // ! 6162: // Return Value: ! 6163: // ! 6164: // Returns the page aligned virtual address. ! 6165: // ! 6166: //-- ! 6167: ! 6168: #define PAGE_ALIGN(Va) ((PVOID)((ULONG)(Va) & ~(PAGE_SIZE - 1))) ! 6169: ! 6170: //++ ! 6171: // ! 6172: // ULONG ! 6173: // ADDRESS_AND_SIZE_TO_SPAN_PAGES ( ! 6174: // IN PVOID Va, ! 6175: // IN ULONG Size ! 6176: // ) ! 6177: // ! 6178: // Routine Description: ! 6179: // ! 6180: // The ADDRESS_AND_SIZE_TO_SPAN_PAGES macro takes a virtual address and ! 6181: // size and returns the number of pages spanned by the size. ! 6182: // ! 6183: // Arguments: ! 6184: // ! 6185: // Va - Virtual address. ! 6186: // ! 6187: // Size - Size in bytes. ! 6188: // ! 6189: // Return Value: ! 6190: // ! 6191: // Returns the number of pages spanned by the size. ! 6192: // ! 6193: //-- ! 6194: ! 6195: #define ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va,Size) \ ! 6196: ((((ULONG)((ULONG)(Size) - 1L) >> PAGE_SHIFT) + \ ! 6197: (((((ULONG)(Size-1)&(PAGE_SIZE-1)) + ((ULONG)Va & (PAGE_SIZE -1)))) >> PAGE_SHIFT)) + 1L) ! 6198: ! 6199: ! 6200: //++ ! 6201: // ! 6202: // PVOID ! 6203: // MmGetMdlVirtualAddress ( ! 6204: // IN PMDL Mdl ! 6205: // ) ! 6206: // ! 6207: // Routine Description: ! 6208: // ! 6209: // The MmGetMdlVirtualAddress returns the virual address of the buffer ! 6210: // described by the Mdl. ! 6211: // ! 6212: // Arguments: ! 6213: // ! 6214: // Mdl - Pointer to an MDL. ! 6215: // ! 6216: // Return Value: ! 6217: // ! 6218: // Returns the virtual address of the buffer described by the Mdl ! 6219: // ! 6220: //-- ! 6221: ! 6222: #define MmGetMdlVirtualAddress(Mdl) ((PVOID) ((PCHAR) (Mdl)->StartVa + (Mdl)->ByteOffset)) ! 6223: ! 6224: //++ ! 6225: // ! 6226: // ULONG ! 6227: // MmGetMdlByteCount ( ! 6228: // IN PMDL Mdl ! 6229: // ) ! 6230: // ! 6231: // Routine Description: ! 6232: // ! 6233: // The MmGetMdlByteCount returns the length in bytes of the buffer ! 6234: // described by the Mdl. ! 6235: // ! 6236: // Arguments: ! 6237: // ! 6238: // Mdl - Pointer to an MDL. ! 6239: // ! 6240: // Return Value: ! 6241: // ! 6242: // Returns the byte count of the buffer described by the Mdl ! 6243: // ! 6244: //-- ! 6245: ! 6246: #define MmGetMdlByteCount(Mdl) ((Mdl)->ByteCount) ! 6247: ! 6248: typedef enum _MM_SYSTEM_SIZE { ! 6249: MmSmallSystem, ! 6250: MmMediumSystem, ! 6251: MmLargeSystem ! 6252: } MM_SYSTEMSIZE; ! 6253: ! 6254: MM_SYSTEMSIZE ! 6255: MmQuerySystemSize( ! 6256: VOID ! 6257: ); ! 6258: ! 6259: typedef enum _LOCK_OPERATION { ! 6260: IoReadAccess, ! 6261: IoWriteAccess, ! 6262: IoModifyAccess ! 6263: } LOCK_OPERATION; ! 6264: ! 6265: // ! 6266: // I/O support routines. ! 6267: // ! 6268: ! 6269: VOID ! 6270: MmProbeAndLockPages ( ! 6271: IN OUT PMDL MemoryDescriptorList, ! 6272: IN KPROCESSOR_MODE AccessMode, ! 6273: IN LOCK_OPERATION Operation ! 6274: ); ! 6275: ! 6276: VOID ! 6277: MmUnlockPages ( ! 6278: IN PMDL MemoryDescriptorList ! 6279: ); ! 6280: ! 6281: VOID ! 6282: MmBuildMdlForNonPagedPool ( ! 6283: IN OUT PMDL MemoryDescriptorList ! 6284: ); ! 6285: ! 6286: PVOID ! 6287: MmMapLockedPages ( ! 6288: IN PMDL MemoryDescriptorList, ! 6289: IN KPROCESSOR_MODE AccessMode ! 6290: ); ! 6291: ! 6292: VOID ! 6293: MmUnmapLockedPages ( ! 6294: IN PVOID BaseAddress, ! 6295: IN PMDL MemoryDescriptorList ! 6296: ); ! 6297: ! 6298: ! 6299: PVOID ! 6300: MmMapIoSpace ( ! 6301: IN PHYSICAL_ADDRESS PhysicalAddress, ! 6302: IN ULONG NumberOfBytes, ! 6303: IN BOOLEAN CacheEnable ! 6304: ); ! 6305: ! 6306: VOID ! 6307: MmUnmapIoSpace ( ! 6308: IN PVOID BaseAddress, ! 6309: IN ULONG NumberOfBytes ! 6310: ); ! 6311: ! 6312: PHYSICAL_ADDRESS ! 6313: MmGetPhysicalAddress ( ! 6314: IN PVOID BaseAddress ! 6315: ); ! 6316: ! 6317: PVOID ! 6318: MmAllocateContiguousMemory ( ! 6319: IN ULONG NumberOfBytes, ! 6320: IN PHYSICAL_ADDRESS HighestAcceptableAddress ! 6321: ); ! 6322: ! 6323: VOID ! 6324: MmFreeContiguousMemory ( ! 6325: IN PVOID BaseAddress ! 6326: ); ! 6327: ! 6328: PVOID ! 6329: MmAllocateNonCachedMemory ( ! 6330: IN ULONG NumberOfBytes ! 6331: ); ! 6332: ! 6333: VOID ! 6334: MmFreeNonCachedMemory ( ! 6335: IN PVOID BaseAddress, ! 6336: IN ULONG NumberOfBytes ! 6337: ); ! 6338: ! 6339: BOOLEAN ! 6340: MmIsAddressValid ( ! 6341: IN PVOID VirtualAddress ! 6342: ); ! 6343: ! 6344: BOOLEAN ! 6345: MmIsNonPagedSystemAddressValid ( ! 6346: IN PVOID VirtualAddress ! 6347: ); ! 6348: ! 6349: ! 6350: ULONG ! 6351: MmSizeOfMdl( ! 6352: IN PVOID Base, ! 6353: IN ULONG Length ! 6354: ); ! 6355: ! 6356: PMDL ! 6357: MmCreateMdl( ! 6358: IN PMDL MemoryDescriptorList OPTIONAL, ! 6359: IN PVOID Base, ! 6360: IN ULONG Length ! 6361: ); ! 6362: ! 6363: //++ ! 6364: // ! 6365: // VOID ! 6366: // MmInitializeMdl ( ! 6367: // IN PMDL MemoryDescriptorList, ! 6368: // IN PVOID BaseVa, ! 6369: // IN ULONG Length ! 6370: // ) ! 6371: // ! 6372: // Routine Description: ! 6373: // ! 6374: // This routine initializes the header of a Memory Descriptor List (MDL). ! 6375: // ! 6376: // Arguments: ! 6377: // ! 6378: // MemoryDescriptorList - Pointer to the MDL to initialize. ! 6379: // ! 6380: // BaseVa - Base virtual address mapped by the MDL. ! 6381: // ! 6382: // Length - Length, in bytes, of the buffer mapped by the MDL. ! 6383: // ! 6384: // Return Value: ! 6385: // ! 6386: // None. ! 6387: // ! 6388: //-- ! 6389: ! 6390: #define MmInitializeMdl(MemoryDescriptorList, BaseVa, Length) { \ ! 6391: (MemoryDescriptorList)->Next = (PMDL) NULL; \ ! 6392: (MemoryDescriptorList)->Size = (CSHORT)(sizeof(MDL) + \ ! 6393: (sizeof(ULONG) * ADDRESS_AND_SIZE_TO_SPAN_PAGES((BaseVa), (Length)))); \ ! 6394: (MemoryDescriptorList)->MdlFlags = 0; \ ! 6395: (MemoryDescriptorList)->StartVa = (PVOID) PAGE_ALIGN((BaseVa)); \ ! 6396: (MemoryDescriptorList)->ByteOffset = BYTE_OFFSET((BaseVa)); \ ! 6397: (MemoryDescriptorList)->ByteCount = (Length); \ ! 6398: } ! 6399: ! 6400: //++ ! 6401: // ! 6402: // PVOID ! 6403: // MmGetSystemAddressForMdl ( ! 6404: // IN PMDL MDL ! 6405: // ) ! 6406: // ! 6407: // Routine Description: ! 6408: // ! 6409: // This routine returns the mapped address of an MDL, if the ! 6410: // Mdl is not already mapped or a system address, it is mapped. ! 6411: // ! 6412: // Arguments: ! 6413: // ! 6414: // MemoryDescriptorList - Pointer to the MDL to map. ! 6415: // ! 6416: // Return Value: ! 6417: // ! 6418: // Returns the base address where the pages are mapped. The base address ! 6419: // has the same offset as the virtual address in the MDL. ! 6420: // ! 6421: //-- ! 6422: ! 6423: //#define MmGetSystemAddressForMdl(MDL) ! 6424: // (((MDL)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA)) ? ! 6425: // ((MDL)->MappedSystemVa) : ! 6426: // ((((MDL)->MdlFlags & (MDL_SOURCE_IS_NONPAGED_POOL)) ? ! 6427: // ((PVOID)((ULONG)(MDL)->StartVa | (MDL)->ByteOffset)) : ! 6428: // (MmMapLockedPages((MDL),KernelMode))))) ! 6429: ! 6430: #define MmGetSystemAddressForMdl(MDL) \ ! 6431: (((MDL)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \ ! 6432: MDL_SOURCE_IS_NONPAGED_POOL)) ? \ ! 6433: ((MDL)->MappedSystemVa) : \ ! 6434: (MmMapLockedPages((MDL),KernelMode))) ! 6435: ! 6436: //++ ! 6437: // ! 6438: // VOID ! 6439: // MmPrepareMdlForReuse ( ! 6440: // IN PMDL MDL ! 6441: // ) ! 6442: // ! 6443: // Routine Description: ! 6444: // ! 6445: // This routine will take all of the steps necessary to allow an MDL to be ! 6446: // re-used. ! 6447: // ! 6448: // Arguments: ! 6449: // ! 6450: // MemoryDescriptorList - Pointer to the MDL that will be re-used. ! 6451: // ! 6452: // Return Value: ! 6453: // ! 6454: // None. ! 6455: // ! 6456: //-- ! 6457: ! 6458: #define MmPrepareMdlForReuse(MDL) \ ! 6459: if (((MDL)->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) { \ ! 6460: ASSERT(((MDL)->MdlFlags & MDL_PARTIAL) != 0); \ ! 6461: MmUnmapLockedPages( (MDL)->MappedSystemVa, (MDL) ); \ ! 6462: } else if (((MDL)->MdlFlags & MDL_PARTIAL) == 0) { \ ! 6463: ASSERT(((MDL)->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA) == 0); \ ! 6464: } ! 6465: ! 6466: ! 6467: // ! 6468: // Security operation codes ! 6469: // ! 6470: ! 6471: typedef enum _SECURITY_OPERATION_CODE { ! 6472: SetSecurityDescriptor, ! 6473: QuerySecurityDescriptor, ! 6474: DeleteSecurityDescriptor, ! 6475: AssignSecurityDescriptor ! 6476: } SECURITY_OPERATION_CODE, *PSECURITY_OPERATION_CODE; ! 6477: ! 6478: // ! 6479: // Data structure used to capture subject security context ! 6480: // for access validations and auditing. ! 6481: // ! 6482: // THE FIELDS OF THIS DATA STRUCTURE SHOULD BE CONSIDERED OPAQUE ! 6483: // BY ALL EXCEPT THE SECURITY ROUTINES. ! 6484: // ! 6485: ! 6486: typedef struct _SECURITY_SUBJECT_CONTEXT { ! 6487: PACCESS_TOKEN ClientToken; ! 6488: SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; ! 6489: PACCESS_TOKEN PrimaryToken; ! 6490: PVOID ProcessAuditId; ! 6491: } SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT; ! 6492: ! 6493: /////////////////////////////////////////////////////////////////////////////// ! 6494: // // ! 6495: // ACCESS_STATE and related structures // ! 6496: // // ! 6497: /////////////////////////////////////////////////////////////////////////////// ! 6498: ! 6499: // ! 6500: // Initial Privilege Set - Room for three privileges, which should ! 6501: // be enough for most applications. This structure exists so that ! 6502: // it can be imbedded in an ACCESS_STATE structure. Use PRIVILEGE_SET ! 6503: // for all other references to Privilege sets. ! 6504: // ! 6505: ! 6506: #define INITIAL_PRIVILEGE_COUNT 3 ! 6507: ! 6508: typedef struct _INITIAL_PRIVILEGE_SET { ! 6509: ULONG PrivilegeCount; ! 6510: ULONG Control; ! 6511: LUID_AND_ATTRIBUTES Privilege[INITIAL_PRIVILEGE_COUNT]; ! 6512: } INITIAL_PRIVILEGE_SET, * PINITIAL_PRIVILEGE_SET; ! 6513: ! 6514: ! 6515: ! 6516: // ! 6517: // Combine the information that describes the state ! 6518: // of an access-in-progress into a single structure ! 6519: // ! 6520: ! 6521: ! 6522: typedef struct _ACCESS_STATE { ! 6523: LUID OperationID; ! 6524: BOOLEAN SecurityEvaluated; ! 6525: BOOLEAN AuditHandleCreation; ! 6526: BOOLEAN GenerateOnClose; ! 6527: BOOLEAN PrivilegesAllocated; ! 6528: ULONG Flags; ! 6529: ACCESS_MASK RemainingDesiredAccess; ! 6530: ACCESS_MASK PreviouslyGrantedAccess; ! 6531: ACCESS_MASK OriginalDesiredAccess; ! 6532: SECURITY_SUBJECT_CONTEXT SubjectSecurityContext; ! 6533: PSECURITY_DESCRIPTOR SecurityDescriptor; ! 6534: PPRIVILEGE_SET PrivilegesUsed; ! 6535: union { ! 6536: INITIAL_PRIVILEGE_SET InitialPrivilegeSet; ! 6537: PRIVILEGE_SET PrivilegeSet; ! 6538: } Privileges; ! 6539: } ACCESS_STATE, *PACCESS_STATE; ! 6540: ! 6541: ! 6542: NTSTATUS ! 6543: SeAssignSecurity ( ! 6544: IN PSECURITY_DESCRIPTOR ParentDescriptor OPTIONAL, ! 6545: IN PSECURITY_DESCRIPTOR ExplicitDescriptor, ! 6546: OUT PSECURITY_DESCRIPTOR *NewDescriptor, ! 6547: IN BOOLEAN IsDirectoryObject, ! 6548: IN PSECURITY_SUBJECT_CONTEXT SubjectContext, ! 6549: IN PGENERIC_MAPPING GenericMapping, ! 6550: IN POOL_TYPE PoolType ! 6551: ); ! 6552: ! 6553: NTSTATUS ! 6554: SeDeassignSecurity ( ! 6555: IN OUT PSECURITY_DESCRIPTOR *SecurityDescriptor ! 6556: ); ! 6557: ! 6558: ! 6559: BOOLEAN ! 6560: SeAccessCheck ( ! 6561: IN PSECURITY_DESCRIPTOR SecurityDescriptor, ! 6562: IN PSECURITY_SUBJECT_CONTEXT SubjectSecurityContext, ! 6563: IN BOOLEAN SubjectContextLocked, ! 6564: IN ACCESS_MASK DesiredAccess, ! 6565: IN ACCESS_MASK PreviouslyGrantedAccess, ! 6566: OUT PPRIVILEGE_SET *Privileges OPTIONAL, ! 6567: IN PGENERIC_MAPPING GenericMapping, ! 6568: IN KPROCESSOR_MODE AccessMode, ! 6569: OUT PACCESS_MASK GrantedAccess, ! 6570: OUT PNTSTATUS AccessStatus ! 6571: ); ! 6572: ! 6573: BOOLEAN ! 6574: SeSinglePrivilegeCheck( ! 6575: LUID PrivilegeValue, ! 6576: KPROCESSOR_MODE PreviousMode ! 6577: ); ! 6578: // ! 6579: // System Thread and Process Creation and Termination ! 6580: // ! 6581: ! 6582: NTSTATUS ! 6583: PsCreateSystemThread( ! 6584: OUT PHANDLE ThreadHandle, ! 6585: IN ULONG DesiredAccess, ! 6586: IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, ! 6587: IN HANDLE ProcessHandle OPTIONAL, ! 6588: OUT PCLIENT_ID ClientId OPTIONAL, ! 6589: IN PKSTART_ROUTINE StartRoutine, ! 6590: IN PVOID StartContext ! 6591: ); ! 6592: ! 6593: NTSTATUS ! 6594: PsTerminateSystemThread( ! 6595: IN NTSTATUS ExitStatus ! 6596: ); ! 6597: ! 6598: // ! 6599: // Define I/O system data structure type codes. Each major data structure in ! 6600: // the I/O system has a type code The type field in each structure is at the ! 6601: // same offset. The following values can be used to determine which type of ! 6602: // data structure a pointer refers to. ! 6603: // ! 6604: ! 6605: #define IO_TYPE_ADAPTER 0x00000001 ! 6606: #define IO_TYPE_CONTROLLER 0x00000002 ! 6607: #define IO_TYPE_DEVICE 0x00000003 ! 6608: #define IO_TYPE_DRIVER 0x00000004 ! 6609: #define IO_TYPE_FILE 0x00000005 ! 6610: #define IO_TYPE_IRP 0x00000006 ! 6611: #define IO_TYPE_MASTER_ADAPTER 0x00000007 ! 6612: #define IO_TYPE_OPEN_PACKET 0x00000008 ! 6613: #define IO_TYPE_TIMER 0x00000009 ! 6614: #define IO_TYPE_VPB 0x0000000a ! 6615: #define IO_TYPE_ERROR_LOG 0x0000000b ! 6616: #define IO_TYPE_ERROR_MESSAGE 0x0000000c ! 6617: ! 6618: // ! 6619: // Define the major function codes for IRPs. The lower 128 codes, from 0x00 to ! 6620: // 0x7f are reserved to Microsoft. The upper 128 codes, from 0x80 to 0xff, are ! 6621: // reserved to customers of Microsoft. ! 6622: // ! 6623: ! 6624: #define IRP_MJ_CREATE 0x00 ! 6625: #define IRP_MJ_CREATE_NAMED_PIPE 0x01 ! 6626: #define IRP_MJ_CLOSE 0x02 ! 6627: #define IRP_MJ_READ 0x03 ! 6628: #define IRP_MJ_WRITE 0x04 ! 6629: #define IRP_MJ_QUERY_INFORMATION 0x05 ! 6630: #define IRP_MJ_SET_INFORMATION 0x06 ! 6631: #define IRP_MJ_QUERY_EA 0x07 ! 6632: #define IRP_MJ_SET_EA 0x08 ! 6633: #define IRP_MJ_FLUSH_BUFFERS 0x09 ! 6634: #define IRP_MJ_QUERY_VOLUME_INFORMATION 0x0a ! 6635: #define IRP_MJ_SET_VOLUME_INFORMATION 0x0b ! 6636: #define IRP_MJ_DIRECTORY_CONTROL 0x0c ! 6637: #define IRP_MJ_FILE_SYSTEM_CONTROL 0x0d ! 6638: #define IRP_MJ_DEVICE_CONTROL 0x0e ! 6639: #define IRP_MJ_INTERNAL_DEVICE_CONTROL 0x0f ! 6640: #define IRP_MJ_SHUTDOWN 0x10 ! 6641: #define IRP_MJ_LOCK_CONTROL 0x11 ! 6642: #define IRP_MJ_CLEANUP 0x12 ! 6643: #define IRP_MJ_CREATE_MAILSLOT 0x13 ! 6644: #define IRP_MJ_QUERY_SECURITY 0x14 ! 6645: #define IRP_MJ_SET_SECURITY 0x15 ! 6646: #define IRP_MJ_MAXIMUM_FUNCTION 0x15 ! 6647: ! 6648: // ! 6649: // Make the Scsi major code the same as internal device control. ! 6650: // ! 6651: ! 6652: #define IRP_MJ_SCSI IRP_MJ_INTERNAL_DEVICE_CONTROL ! 6653: ! 6654: // ! 6655: // Define the minor function codes for IRPs. The lower 128 codes, from 0x00 to ! 6656: // 0x7f are reserved to Microsoft. The upper 128 codes, from 0x80 to 0xff, are ! 6657: // reserved to customers of Microsoft. ! 6658: // ! 6659: ! 6660: // ! 6661: // Directory control minor function codes ! 6662: // ! 6663: ! 6664: #define IRP_MN_QUERY_DIRECTORY 0x01 ! 6665: #define IRP_MN_NOTIFY_CHANGE_DIRECTORY 0x02 ! 6666: ! 6667: // ! 6668: // File system control minor function codes. Note that "user request" is ! 6669: // assumed to be zero by both the I/O system and file systems. Do not change ! 6670: // this value. ! 6671: // ! 6672: ! 6673: #define IRP_MN_USER_FS_REQUEST 0x00 ! 6674: #define IRP_MN_MOUNT_VOLUME 0x01 ! 6675: #define IRP_MN_VERIFY_VOLUME 0x02 ! 6676: #define IRP_MN_LOAD_FILE_SYSTEM 0x03 ! 6677: ! 6678: // ! 6679: // Lock control minor function codes ! 6680: // ! 6681: ! 6682: #define IRP_MN_LOCK 0x01 ! 6683: #define IRP_MN_UNLOCK_SINGLE 0x02 ! 6684: #define IRP_MN_UNLOCK_ALL 0x03 ! 6685: #define IRP_MN_UNLOCK_ALL_BY_KEY 0x04 ! 6686: ! 6687: // ! 6688: // Read and Write minor function codes for file systems supporting Lan Manager ! 6689: // software. All of these subfunction codes are invalid if the file has been ! 6690: // opened with FO_NO_INTERMEDIATE_BUFFERING. They are also invalid in combi- ! 6691: // nation with synchronous calls (Irp Flag or file open option). ! 6692: // ! 6693: // Note that "normal" is assumed to be zero by both the I/O system and file ! 6694: // systems. Do not change this value. ! 6695: // ! 6696: ! 6697: #define IRP_MN_NORMAL 0x00 ! 6698: #define IRP_MN_DPC 0x01 ! 6699: #define IRP_MN_MDL 0x02 ! 6700: #define IRP_MN_COMPLETE 0x04 ! 6701: ! 6702: #define IRP_MN_MDL_DPC (IRP_MN_MDL | IRP_MN_DPC) ! 6703: #define IRP_MN_COMPLETE_MDL (IRP_MN_COMPLETE | IRP_MN_MDL) ! 6704: #define IRP_MN_COMPLETE_MDL_DPC (IRP_MN_COMPLETE_MDL | IRP_MN_DPC) ! 6705: ! 6706: // ! 6707: // Device Control Request minor function codes for SCSI support. Note that ! 6708: // user requests are assumed to be zero. ! 6709: // ! 6710: ! 6711: #define IRP_MN_SCSI_CLASS 0x01 ! 6712: ! 6713: // ! 6714: // Define option flags for IoCreateFile. Note that these values must be ! 6715: // exactly the same as the SL_... flags for a create function. Note also ! 6716: // that there are flags that may be passed to IoCreateFile that are not ! 6717: // placed in the stack location for the create IRP. These flags start in ! 6718: // the next byte. ! 6719: // ! 6720: ! 6721: #define IO_FORCE_ACCESS_CHECK 0x0001 ! 6722: #define IO_OPEN_PAGING_FILE 0x0002 ! 6723: #define IO_OPEN_TARGET_DIRECTORY 0x0004 ! 6724: ! 6725: // ! 6726: // Define callout routine type for use in IoQueryDeviceDescription(). ! 6727: // ! 6728: ! 6729: typedef NTSTATUS (*PIO_QUERY_DEVICE_ROUTINE)( ! 6730: IN PVOID Context, ! 6731: IN PUNICODE_STRING PathName, ! 6732: IN INTERFACE_TYPE BusType, ! 6733: IN ULONG BusNumber, ! 6734: IN PKEY_VALUE_FULL_INFORMATION *BusInformation, ! 6735: IN CONFIGURATION_TYPE ControllerType, ! 6736: IN ULONG ControllerNumber, ! 6737: IN PKEY_VALUE_FULL_INFORMATION *ControllerInformation, ! 6738: IN CONFIGURATION_TYPE PeripheralType, ! 6739: IN ULONG PeripheralNumber, ! 6740: IN PKEY_VALUE_FULL_INFORMATION *PeripheralInformation ! 6741: ); ! 6742: ! 6743: // ! 6744: // Defines the order of the information in the array of ! 6745: // PKEY_VALUE_FULL_INFORMATION. ! 6746: // ! 6747: ! 6748: typedef enum _IO_QUERY_DEVICE_DATA_FORMAT { ! 6749: IoQueryDeviceIdentifier = 0, ! 6750: IoQueryDeviceConfigurationData, ! 6751: IoQueryDeviceComponentInformation, ! 6752: IoQueryDeviceMaxData ! 6753: } IO_QUERY_DEVICE_DATA_FORMAT, *PIO_QUERY_DEVICE_DATA_FORMAT; ! 6754: ! 6755: // ! 6756: // Define the objects that can be created by IoCreateFile. ! 6757: // ! 6758: ! 6759: typedef enum _CREATE_FILE_TYPE { ! 6760: CreateFileTypeNone, ! 6761: CreateFileTypeNamedPipe, ! 6762: CreateFileTypeMailslot ! 6763: } CREATE_FILE_TYPE; ! 6764: ! 6765: // ! 6766: // Define the structures used by the I/O system ! 6767: // ! 6768: ! 6769: // ! 6770: // Define empty typedefs for the _IRP, _DEVICE_OBJECT, and _DRIVER_OBJECT ! 6771: // structures so they may be referenced by function types before they are ! 6772: // actually defined. ! 6773: // ! 6774: ! 6775: struct _DEVICE_OBJECT; ! 6776: struct _DRIVER_OBJECT; ! 6777: struct _DRIVE_LAYOUT_INFORMATION; ! 6778: struct _DISK_PARTITION; ! 6779: struct _FILE_OBJECT; ! 6780: struct _IRP; ! 6781: struct _SCSI_REQUEST_BLOCK; ! 6782: ! 6783: // ! 6784: // Define the I/O version of a DPC routine. ! 6785: // ! 6786: ! 6787: typedef ! 6788: VOID ! 6789: (*PIO_DPC_ROUTINE) ( ! 6790: IN PKDPC Dpc, ! 6791: IN struct _DEVICE_OBJECT *DeviceObject, ! 6792: IN struct _IRP *Irp, ! 6793: IN PVOID Context ! 6794: ); ! 6795: ! 6796: // ! 6797: // Define driver timer routine type. ! 6798: // ! 6799: ! 6800: typedef ! 6801: VOID ! 6802: (*PIO_TIMER_ROUTINE) ( ! 6803: IN struct _DEVICE_OBJECT *DeviceObject, ! 6804: IN PVOID Context ! 6805: ); ! 6806: ! 6807: // ! 6808: // Define driver initialization routine type. ! 6809: // ! 6810: ! 6811: typedef ! 6812: NTSTATUS ! 6813: (*PDRIVER_INITIALIZE) ( ! 6814: IN struct _DRIVER_OBJECT *DriverObject, ! 6815: IN PUNICODE_STRING RegistryPath ! 6816: ); ! 6817: ! 6818: // ! 6819: // Define driver reinitialization routine type. ! 6820: // ! 6821: ! 6822: typedef ! 6823: VOID ! 6824: (*PDRIVER_REINITIALIZE) ( ! 6825: IN struct _DRIVER_OBJECT *DriverObject, ! 6826: IN PVOID Context, ! 6827: IN ULONG Count ! 6828: ); ! 6829: ! 6830: // ! 6831: // Define driver cancel routine type. ! 6832: // ! 6833: ! 6834: typedef ! 6835: VOID ! 6836: (*PDRIVER_CANCEL) ( ! 6837: IN struct _DEVICE_OBJECT *DeviceObject, ! 6838: IN struct _IRP *Irp ! 6839: ); ! 6840: ! 6841: // ! 6842: // Define driver dispatch routine type. ! 6843: // ! 6844: ! 6845: typedef ! 6846: NTSTATUS ! 6847: (*PDRIVER_DISPATCH) ( ! 6848: IN struct _DEVICE_OBJECT *DeviceObject, ! 6849: IN struct _IRP *Irp ! 6850: ); ! 6851: ! 6852: // ! 6853: // Define driver start I/O routine type. ! 6854: // ! 6855: ! 6856: typedef ! 6857: VOID ! 6858: (*PDRIVER_STARTIO) ( ! 6859: IN struct _DEVICE_OBJECT *DeviceObject, ! 6860: IN struct _IRP *Irp ! 6861: ); ! 6862: ! 6863: // ! 6864: // Define driver unload routine type. ! 6865: // ! 6866: ! 6867: typedef ! 6868: VOID ! 6869: (*PDRIVER_UNLOAD) ( ! 6870: IN struct _DRIVER_OBJECT *DriverObject ! 6871: ); ! 6872: ! 6873: ! 6874: // ! 6875: // Define fast I/O procedure prototypes. ! 6876: // ! 6877: // Fast I/O read and write procedures. ! 6878: // ! 6879: ! 6880: typedef ! 6881: BOOLEAN ! 6882: (*PFAST_IO_CHECK_IF_POSSIBLE) ( ! 6883: IN struct _FILE_OBJECT *FileObject, ! 6884: IN PLARGE_INTEGER FileOffset, ! 6885: IN ULONG Length, ! 6886: IN BOOLEAN Wait, ! 6887: IN ULONG LockKey, ! 6888: IN BOOLEAN CheckForReadOperation, ! 6889: OUT PIO_STATUS_BLOCK IoStatus ! 6890: ); ! 6891: ! 6892: typedef ! 6893: BOOLEAN ! 6894: (*PFAST_IO_READ) ( ! 6895: IN struct _FILE_OBJECT *FileObject, ! 6896: IN PLARGE_INTEGER FileOffset, ! 6897: IN ULONG Length, ! 6898: IN BOOLEAN Wait, ! 6899: IN ULONG LockKey, ! 6900: OUT PVOID Buffer, ! 6901: OUT PIO_STATUS_BLOCK IoStatus ! 6902: ); ! 6903: ! 6904: typedef ! 6905: BOOLEAN ! 6906: (*PFAST_IO_WRITE) ( ! 6907: IN struct _FILE_OBJECT *FileObject, ! 6908: IN PLARGE_INTEGER FileOffset, ! 6909: IN ULONG Length, ! 6910: IN BOOLEAN Wait, ! 6911: IN ULONG LockKey, ! 6912: IN PVOID Buffer, ! 6913: OUT PIO_STATUS_BLOCK IoStatus ! 6914: ); ! 6915: ! 6916: // ! 6917: // Fast I/O query basic and standard information procedures. ! 6918: // ! 6919: ! 6920: typedef ! 6921: BOOLEAN ! 6922: (*PFAST_IO_QUERY_BASIC_INFO) ( ! 6923: IN struct _FILE_OBJECT *FileObject, ! 6924: IN BOOLEAN Wait, ! 6925: OUT PFILE_BASIC_INFORMATION Buffer, ! 6926: OUT PIO_STATUS_BLOCK IoStatus ! 6927: ); ! 6928: ! 6929: typedef ! 6930: BOOLEAN ! 6931: (*PFAST_IO_QUERY_STANDARD_INFO) ( ! 6932: IN struct _FILE_OBJECT *FileObject, ! 6933: IN BOOLEAN Wait, ! 6934: OUT PFILE_STANDARD_INFORMATION Buffer, ! 6935: OUT PIO_STATUS_BLOCK IoStatus ! 6936: ); ! 6937: ! 6938: // ! 6939: // Fast I/O lock and unlock procedures. ! 6940: // ! 6941: ! 6942: typedef ! 6943: BOOLEAN ! 6944: (*PFAST_IO_LOCK) ( ! 6945: IN struct _FILE_OBJECT *FileObject, ! 6946: IN PLARGE_INTEGER FileOffset, ! 6947: IN PLARGE_INTEGER Length, ! 6948: PEPROCESS ProcessId, ! 6949: ULONG Key, ! 6950: BOOLEAN FailImmediately, ! 6951: BOOLEAN ExclusiveLock, ! 6952: OUT PIO_STATUS_BLOCK IoStatus ! 6953: ); ! 6954: ! 6955: typedef ! 6956: BOOLEAN ! 6957: (*PFAST_IO_UNLOCK_SINGLE) ( ! 6958: IN struct _FILE_OBJECT *FileObject, ! 6959: IN PLARGE_INTEGER FileOffset, ! 6960: IN PLARGE_INTEGER Length, ! 6961: PEPROCESS ProcessId, ! 6962: ULONG Key, ! 6963: OUT PIO_STATUS_BLOCK IoStatus ! 6964: ); ! 6965: ! 6966: typedef ! 6967: BOOLEAN ! 6968: (*PFAST_IO_UNLOCK_ALL) ( ! 6969: IN struct _FILE_OBJECT *FileObject, ! 6970: PEPROCESS ProcessId, ! 6971: OUT PIO_STATUS_BLOCK IoStatus ! 6972: ); ! 6973: ! 6974: typedef ! 6975: BOOLEAN ! 6976: (*PFAST_IO_UNLOCK_ALL_BY_KEY) ( ! 6977: IN struct _FILE_OBJECT *FileObject, ! 6978: PVOID ProcessId, ! 6979: ULONG Key, ! 6980: OUT PIO_STATUS_BLOCK IoStatus ! 6981: ); ! 6982: ! 6983: // ! 6984: // Fast I/O device control procedure. ! 6985: // ! 6986: ! 6987: typedef ! 6988: BOOLEAN ! 6989: (*PFAST_IO_DEVICE_CONTROL) ( ! 6990: IN struct _FILE_OBJECT *FileObject, ! 6991: IN BOOLEAN Wait, ! 6992: IN PVOID InputBuffer OPTIONAL, ! 6993: IN ULONG InputBufferLength, ! 6994: OUT PVOID OutputBuffer OPTIONAL, ! 6995: IN ULONG OutputBufferLength, ! 6996: IN ULONG IoControlCode, ! 6997: OUT PIO_STATUS_BLOCK IoStatus ! 6998: ); ! 6999: ! 7000: // ! 7001: // Define the structure to describe the Fast I/O dispatch routines. ! 7002: // ! 7003: ! 7004: typedef struct _FAST_IO_DISPATCH { ! 7005: ULONG SizeOfFastIoDispatch; ! 7006: PFAST_IO_CHECK_IF_POSSIBLE FastIoCheckIfPossible; ! 7007: PFAST_IO_READ FastIoRead; ! 7008: PFAST_IO_WRITE FastIoWrite; ! 7009: PFAST_IO_QUERY_BASIC_INFO FastIoQueryBasicInfo; ! 7010: PFAST_IO_QUERY_STANDARD_INFO FastIoQueryStandardInfo; ! 7011: PFAST_IO_LOCK FastIoLock; ! 7012: PFAST_IO_UNLOCK_SINGLE FastIoUnlockSingle; ! 7013: PFAST_IO_UNLOCK_ALL FastIoUnlockAll; ! 7014: PFAST_IO_UNLOCK_ALL_BY_KEY FastIoUnlockAllByKey; ! 7015: PFAST_IO_DEVICE_CONTROL FastIoDeviceControl; ! 7016: } FAST_IO_DISPATCH, *PFAST_IO_DISPATCH; ! 7017: ! 7018: // ! 7019: // Define the actions that a driver execution routine may request of the ! 7020: // adapter/controller allocation routines upon return. ! 7021: // ! 7022: ! 7023: typedef enum _IO_ALLOCATION_ACTION { ! 7024: KeepObject = 1, ! 7025: DeallocateObject, ! 7026: DeallocateObjectKeepRegisters ! 7027: } IO_ALLOCATION_ACTION, *PIO_ALLOCATION_ACTION; ! 7028: ! 7029: // ! 7030: // Define device driver adapter/controller execution routine. ! 7031: // ! 7032: ! 7033: typedef ! 7034: IO_ALLOCATION_ACTION ! 7035: (*PDRIVER_CONTROL) ( ! 7036: IN struct _DEVICE_OBJECT *DeviceObject, ! 7037: IN struct _IRP *Irp, ! 7038: IN PVOID MapRegisterBase, ! 7039: IN PVOID Context ! 7040: ); ! 7041: ! 7042: // ! 7043: // Define the I/O system's security context type for use by file system's ! 7044: // when checking access to volumes, files, and directories. ! 7045: // ! 7046: ! 7047: typedef struct _IO_SECURITY_CONTEXT { ! 7048: PSECURITY_QUALITY_OF_SERVICE SecurityQos; ! 7049: PACCESS_STATE AccessState; ! 7050: ACCESS_MASK DesiredAccess; ! 7051: } IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT; ! 7052: ! 7053: // ! 7054: // Define Volume Parameter Block (VPB) flags. ! 7055: // ! 7056: ! 7057: #define VPB_MOUNTED 0x00000001 ! 7058: #define VPB_LOCKED 0x00000002 ! 7059: ! 7060: // ! 7061: // Volume Parameter Block (VPB) ! 7062: // ! 7063: ! 7064: #define MAXIMUM_VOLUME_LABEL_LENGTH (32 * sizeof(WCHAR)) // 32 characters ! 7065: ! 7066: typedef struct _VPB { ! 7067: CSHORT Type; ! 7068: CSHORT Size; ! 7069: USHORT Flags; ! 7070: USHORT VolumeLabelLength; // in bytes ! 7071: struct _DEVICE_OBJECT *DeviceObject; ! 7072: struct _DEVICE_OBJECT *RealDevice; ! 7073: ULONG SerialNumber; ! 7074: ULONG ReferenceCount; ! 7075: WCHAR VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH / sizeof(WCHAR)]; ! 7076: } VPB, *PVPB; ! 7077: ! 7078: // ! 7079: // Define object type specific fields of various objects used by the I/O system ! 7080: // ! 7081: ! 7082: typedef struct _ADAPTER_OBJECT *PADAPTER_OBJECT; ! 7083: ! 7084: // ! 7085: // Define Wait Context Block (WCB) ! 7086: // ! 7087: ! 7088: typedef struct _WAIT_CONTEXT_BLOCK { ! 7089: KDEVICE_QUEUE_ENTRY WaitQueueEntry; ! 7090: PDRIVER_CONTROL DeviceRoutine; ! 7091: PVOID DeviceContext; ! 7092: ULONG NumberOfMapRegisters; ! 7093: PVOID DeviceObject; ! 7094: PVOID CurrentIrp; ! 7095: PKDPC BufferChainingDpc; ! 7096: } WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK; ! 7097: ! 7098: typedef struct _CONTROLLER_OBJECT { ! 7099: CSHORT Type; ! 7100: CSHORT Size; ! 7101: PVOID ControllerExtension; ! 7102: KDEVICE_QUEUE DeviceWaitQueue; ! 7103: ! 7104: ULONG Spare1; ! 7105: LARGE_INTEGER Spare2; ! 7106: ! 7107: } CONTROLLER_OBJECT, *PCONTROLLER_OBJECT; ! 7108: ! 7109: ! 7110: // ! 7111: // Define Device Object (DO) flags ! 7112: // ! 7113: ! 7114: #define DO_UNLOAD_PENDING 0x00000001 ! 7115: #define DO_VERIFY_VOLUME 0x00000002 ! 7116: #define DO_BUFFERED_IO 0x00000004 ! 7117: #define DO_EXCLUSIVE 0x00000008 ! 7118: #define DO_DIRECT_IO 0x00000010 ! 7119: #define DO_MAP_IO_BUFFER 0x00000020 ! 7120: #define DO_DEVICE_HAS_NAME 0x00000040 ! 7121: #define DO_DEVICE_INITIALIZING 0x00000080 ! 7122: #define DO_SYSTEM_BOOT_PARTITION 0x00000100 ! 7123: ! 7124: // ! 7125: // Device Object structure definition ! 7126: // ! 7127: ! 7128: typedef struct _DEVICE_OBJECT { ! 7129: CSHORT Type; ! 7130: USHORT Size; ! 7131: LONG ReferenceCount; ! 7132: struct _DRIVER_OBJECT *DriverObject; ! 7133: struct _DEVICE_OBJECT *NextDevice; ! 7134: struct _DEVICE_OBJECT *AttachedDevice; ! 7135: struct _IRP *CurrentIrp; ! 7136: PIO_TIMER Timer; ! 7137: ULONG Flags; // See above: DO_... ! 7138: ULONG Characteristics; // See ntioapi: FILE_... ! 7139: PVPB Vpb; ! 7140: PVOID DeviceExtension; ! 7141: DEVICE_TYPE DeviceType; ! 7142: CCHAR StackSize; ! 7143: union { ! 7144: LIST_ENTRY ListEntry; ! 7145: WAIT_CONTEXT_BLOCK Wcb; ! 7146: } Queue; ! 7147: ULONG AlignmentRequirement; ! 7148: KDEVICE_QUEUE DeviceQueue; ! 7149: KDPC Dpc; ! 7150: ! 7151: // ! 7152: // The following field is for exclusive use by the filesystem to keep ! 7153: // track of the number of Fsp threads currently using the device ! 7154: // ! 7155: ! 7156: ULONG ActiveThreadCount; ! 7157: PSECURITY_DESCRIPTOR SecurityDescriptor; ! 7158: KEVENT DeviceLock; ! 7159: ! 7160: ULONG Spare1; ! 7161: LARGE_INTEGER Spare2; ! 7162: ! 7163: } DEVICE_OBJECT, *PDEVICE_OBJECT; ! 7164: ! 7165: // ! 7166: // Define Driver Object (DRVO) flags ! 7167: // ! 7168: ! 7169: #define DRVO_UNLOAD_INVOKED 0x00000001 ! 7170: ! 7171: typedef struct _DRIVER_OBJECT { ! 7172: CSHORT Type; ! 7173: CSHORT Size; ! 7174: ! 7175: // ! 7176: // The following links all of the devices created by a single driver ! 7177: // together on a list, and the Flags word provides an extensible flag ! 7178: // location for driver objects. ! 7179: // ! 7180: ! 7181: PDEVICE_OBJECT DeviceObject; ! 7182: ULONG Flags; ! 7183: ! 7184: // ! 7185: // The following section describes where the driver is loaded. The count ! 7186: // field is used to count the number of times the driver has had its ! 7187: // registered reinitialization routine invoked. ! 7188: // ! 7189: ! 7190: PVOID DriverStart; ! 7191: ULONG DriverSize; ! 7192: PVOID DriverSection; ! 7193: ULONG Count; ! 7194: ! 7195: // ! 7196: // The driver name field is used by the error log thread ! 7197: // determine the name of the driver that an I/O request is/was bound. ! 7198: // ! 7199: ! 7200: UNICODE_STRING DriverName; ! 7201: ! 7202: // ! 7203: // The following section is for registry support. Thise is a pointer ! 7204: // to the path to the hardware information in the registry ! 7205: // ! 7206: ! 7207: PUNICODE_STRING HardwareDatabase; ! 7208: ! 7209: // ! 7210: // The following section contains the optional pointer to an array of ! 7211: // alternate entry points to a driver for "fast I/O" support. Fast I/O ! 7212: // is performed by invoking the driver routine directly with separate ! 7213: // parameters, rather than using the standard IRP call mechanism. Note ! 7214: // that these functions may only be used for synchronous I/O, and when ! 7215: // the file is cached. ! 7216: // ! 7217: ! 7218: PFAST_IO_DISPATCH FastIoDispatch; ! 7219: ! 7220: // ! 7221: // The following section describes the entry points to this particular ! 7222: // driver. Note that the major function dispatch table must be the last ! 7223: // field in the object so that it remains extensible. ! 7224: // ! 7225: ! 7226: PDRIVER_INITIALIZE DriverInit; ! 7227: PDRIVER_STARTIO DriverStartIo; ! 7228: PDRIVER_UNLOAD DriverUnload; ! 7229: PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1]; ! 7230: } DRIVER_OBJECT, *PDRIVER_OBJECT; ! 7231: ! 7232: // ! 7233: // The following structure is pointed to by the SectionObject pointer field ! 7234: // of a file object, and is allocated by the various NT file systems. ! 7235: // ! 7236: ! 7237: typedef struct _SECTION_OBJECT_POINTERS { ! 7238: PVOID DataSectionObject; ! 7239: PVOID SharedCacheMap; ! 7240: PVOID ImageSectionObject; ! 7241: } SECTION_OBJECT_POINTERS; ! 7242: typedef SECTION_OBJECT_POINTERS *PSECTION_OBJECT_POINTERS; ! 7243: ! 7244: // ! 7245: // Define File Object (FO) flags ! 7246: // ! 7247: ! 7248: #define FO_FILE_OPEN 0x00000001 ! 7249: #define FO_SYNCHRONOUS_IO 0x00000002 ! 7250: #define FO_ALERTABLE_IO 0x00000004 ! 7251: #define FO_NO_INTERMEDIATE_BUFFERING 0x00000008 ! 7252: #define FO_WRITE_THROUGH 0x00000010 ! 7253: #define FO_SEQUENTIAL_ONLY 0x00000020 ! 7254: #define FO_CACHE_SUPPORTED 0x00000040 ! 7255: #define FO_NAMED_PIPE 0x00000080 ! 7256: #define FO_STREAM_FILE 0x00000100 ! 7257: #define FO_MAILSLOT 0x00000200 ! 7258: #define FO_GENERATE_AUDIT_ON_CLOSE 0x00000400 ! 7259: #define FO_DIRECT_DEVICE_OPEN 0x00000800 ! 7260: #define FO_FILE_MODIFIED 0x00001000 ! 7261: #define FO_FILE_SIZE_CHANGED 0x00002000 ! 7262: #define FO_CLEANUP_COMPLETE 0x00004000 ! 7263: #define FO_TEMPORARY_FILE 0x00008000 ! 7264: #define FO_DELETE_ON_CLOSE 0x00010000 ! 7265: #define FO_OPENED_CASE_SENSITIVE 0x00020000 ! 7266: #define FO_HANDLE_CREATED 0x00040000 ! 7267: #define FO_FILE_FAST_IO_READ 0x00080000 ! 7268: ! 7269: typedef struct _FILE_OBJECT { ! 7270: CSHORT Type; ! 7271: CSHORT Size; ! 7272: PDEVICE_OBJECT DeviceObject; ! 7273: PVPB Vpb; ! 7274: PVOID FsContext; ! 7275: PVOID FsContext2; ! 7276: PSECTION_OBJECT_POINTERS SectionObjectPointer; ! 7277: PVOID PrivateCacheMap; ! 7278: NTSTATUS FinalStatus; ! 7279: struct _FILE_OBJECT *RelatedFileObject; ! 7280: BOOLEAN LockOperation; ! 7281: BOOLEAN DeletePending; ! 7282: BOOLEAN ReadAccess; ! 7283: BOOLEAN WriteAccess; ! 7284: BOOLEAN DeleteAccess; ! 7285: BOOLEAN SharedRead; ! 7286: BOOLEAN SharedWrite; ! 7287: BOOLEAN SharedDelete; ! 7288: ULONG Flags; ! 7289: UNICODE_STRING FileName; ! 7290: LARGE_INTEGER CurrentByteOffset; ! 7291: ULONG Waiters; ! 7292: ULONG Busy; ! 7293: BOOLEAN Spare1; ! 7294: KEVENT Lock; ! 7295: KEVENT Event; ! 7296: } FILE_OBJECT, *PFILE_OBJECT; ! 7297: ! 7298: // ! 7299: // Define I/O Request Packet (IRP) flags ! 7300: // ! 7301: ! 7302: #define IRP_NOCACHE 0x00000001 ! 7303: #define IRP_PAGING_IO 0x00000002 ! 7304: #define IRP_MOUNT_COMPLETION 0x00000002 ! 7305: #define IRP_SYNCHRONOUS_API 0x00000004 ! 7306: #define IRP_ASSOCIATED_IRP 0x00000008 ! 7307: #define IRP_BUFFERED_IO 0x00000010 ! 7308: #define IRP_DEALLOCATE_BUFFER 0x00000020 ! 7309: #define IRP_INPUT_OPERATION 0x00000040 ! 7310: #define IRP_SYNCHRONOUS_PAGING_IO 0x00000040 ! 7311: #define IRP_CREATE_OPERATION 0x00000080 ! 7312: #define IRP_READ_OPERATION 0x00000100 ! 7313: #define IRP_WRITE_OPERATION 0x00000200 ! 7314: #define IRP_CLOSE_OPERATION 0x00000400 ! 7315: #define IRP_DEFER_IO_COMPLETION 0x00000800 ! 7316: #define IRP_OB_QUERY_NAME 0x00001000 ! 7317: ! 7318: // ! 7319: // I/O Request Packet (IRP) definition ! 7320: // ! 7321: ! 7322: typedef struct _IRP { ! 7323: CSHORT Type; ! 7324: USHORT Size; ! 7325: ! 7326: // ! 7327: // Define the common fields used to control the IRP. ! 7328: // ! 7329: ! 7330: // ! 7331: // Define a pointer to the Memory Descriptor List (MDL) for this I/O ! 7332: // request. This field is only used if the I/O is "direct I/O". ! 7333: // ! 7334: ! 7335: PMDL MdlAddress; ! 7336: ! 7337: // ! 7338: // Flags word - used to remember various flags. ! 7339: // ! 7340: ! 7341: ULONG Flags; ! 7342: ! 7343: // ! 7344: // The following union is used for one of three purposes: ! 7345: // ! 7346: // 1. This IRP is an associated IRP. The field is a pointer to a master ! 7347: // IRP. ! 7348: // ! 7349: // 2. This is the master IRP. The field is the count of the number of ! 7350: // IRPs which must complete (associated IRPs) before the master can ! 7351: // complete. ! 7352: // ! 7353: // 3. This operation is being buffered and the field is the address of ! 7354: // the system space buffer. ! 7355: // ! 7356: ! 7357: union { ! 7358: struct _IRP *MasterIrp; ! 7359: LONG IrpCount; ! 7360: PVOID SystemBuffer; ! 7361: } AssociatedIrp; ! 7362: ! 7363: // ! 7364: // Thread list entry - allows queueing the IRP to the thread pending I/O ! 7365: // request packet list. ! 7366: // ! 7367: ! 7368: LIST_ENTRY ThreadListEntry; ! 7369: ! 7370: // ! 7371: // I/O status - final status of operation. ! 7372: // ! 7373: ! 7374: IO_STATUS_BLOCK IoStatus; ! 7375: ! 7376: // ! 7377: // Requestor mode - mode of the original requestor of this operation. ! 7378: // ! 7379: ! 7380: KPROCESSOR_MODE RequestorMode; ! 7381: ! 7382: // ! 7383: // Pending returned - TRUE if pending was initially returned as the ! 7384: // status for this packet. ! 7385: // ! 7386: ! 7387: BOOLEAN PendingReturned; ! 7388: ! 7389: // ! 7390: // Stack state information. ! 7391: // ! 7392: ! 7393: CCHAR StackCount; ! 7394: CCHAR CurrentLocation; ! 7395: ! 7396: // ! 7397: // Cancel - packet has been canceled. ! 7398: // ! 7399: ! 7400: BOOLEAN Cancel; ! 7401: ! 7402: // ! 7403: // Cancel Irql - Irql at which the cancel spinlock was acquired. ! 7404: // ! 7405: ! 7406: KIRQL CancelIrql; ! 7407: ! 7408: // ! 7409: // ApcEnvironment - Used to save the APC environment at the time that the ! 7410: // packet was initialized. ! 7411: // ! 7412: ! 7413: CCHAR ApcEnvironment; ! 7414: ! 7415: // ! 7416: // Zoned - packet was allocated from a zone. ! 7417: // ! 7418: ! 7419: BOOLEAN Zoned; ! 7420: ! 7421: // ! 7422: // User parameters. ! 7423: // ! 7424: ! 7425: PIO_STATUS_BLOCK UserIosb; ! 7426: PKEVENT UserEvent; ! 7427: union { ! 7428: struct { ! 7429: PIO_APC_ROUTINE UserApcRoutine; ! 7430: PVOID UserApcContext; ! 7431: } AsynchronousParameters; ! 7432: LARGE_INTEGER AllocationSize; ! 7433: } Overlay; ! 7434: ! 7435: // ! 7436: // CancelRoutine - Used to contain the address of a cancel routine supplied ! 7437: // by a device driver when the IRP is in a cancelable state. ! 7438: // ! 7439: ! 7440: PDRIVER_CANCEL CancelRoutine; ! 7441: ! 7442: // ! 7443: // Note that the UserBuffer parameter is outside of the stack so that I/O ! 7444: // completion can copy data back into the user's address space without ! 7445: // having to know exactly which service was being invoked. The length ! 7446: // of the copy is stored in the second half of the I/O status block. If ! 7447: // the UserBuffer field is NULL, then no copy is performed. ! 7448: // ! 7449: ! 7450: PVOID UserBuffer; ! 7451: ! 7452: // ! 7453: // Kernel structures ! 7454: // ! 7455: // The following section contains kernel structures which the IRP needs ! 7456: // in order to place various work information in kernel controller system ! 7457: // queues. Because the size and alignment cannot be controlled, they are ! 7458: // placed here at the end so they just hang off and do not affect the ! 7459: // alignment of other fields in the IRP. ! 7460: // ! 7461: ! 7462: union { ! 7463: ! 7464: struct { ! 7465: ! 7466: // ! 7467: // DeviceQueueEntry - The device queue entry field is used to queue ! 7468: // the IRP to the device driver device queue. ! 7469: // ! 7470: ! 7471: KDEVICE_QUEUE_ENTRY DeviceQueueEntry; ! 7472: ! 7473: // ! 7474: // Thread - pointer to caller's Thread Control Block. ! 7475: // ! 7476: ! 7477: PETHREAD Thread; ! 7478: ! 7479: // ! 7480: // Auxillary buffer - pointer to any auxillary buffer that is ! 7481: // required to pass information to a driver that is not contained ! 7482: // in a normal buffer. ! 7483: // ! 7484: ! 7485: PCHAR AuxiliaryBuffer; ! 7486: ! 7487: // ! 7488: // List entry - used to queue the packet to completion queue, among ! 7489: // others. ! 7490: // ! 7491: ! 7492: LIST_ENTRY ListEntry; ! 7493: ! 7494: // ! 7495: // Current stack location - contains a pointer to the current ! 7496: // IO_STACK_LOCATION structure in the IRP stack. This field ! 7497: // should never be directly accessed by drivers. They should ! 7498: // use the standard functions. ! 7499: // ! 7500: ! 7501: struct _IO_STACK_LOCATION *CurrentStackLocation; ! 7502: ! 7503: // ! 7504: // Original file object - pointer to the original file object ! 7505: // that was used to open the file. This field is owned by the ! 7506: // I/O system and should not be used by any other drivers. ! 7507: // ! 7508: ! 7509: PFILE_OBJECT OriginalFileObject; ! 7510: ! 7511: } Overlay; ! 7512: ! 7513: // ! 7514: // APC - This APC control block is used for the special kernel APC as ! 7515: // well as for the caller's APC, if one was specified in the original ! 7516: // argument list. If so, then the APC is reused for the normal APC for ! 7517: // whatever mode the caller was in and the "special" routine that is ! 7518: // invoked before the APC gets control simply deallocates the IRP. ! 7519: // ! 7520: ! 7521: KAPC Apc; ! 7522: ! 7523: } Tail; ! 7524: ! 7525: } IRP, *PIRP; ! 7526: ! 7527: // ! 7528: // Define completion routine types for use in stack locations in an IRP ! 7529: // ! 7530: ! 7531: typedef ! 7532: NTSTATUS ! 7533: (*PIO_COMPLETION_ROUTINE) ( ! 7534: IN PDEVICE_OBJECT DeviceObject, ! 7535: IN PIRP Irp, ! 7536: IN PVOID Context ! 7537: ); ! 7538: ! 7539: // ! 7540: // Define stack location control flags ! 7541: // ! 7542: ! 7543: #define SL_PENDING_RETURNED 0x01 ! 7544: #define SL_INVOKE_ON_CANCEL 0x20 ! 7545: #define SL_INVOKE_ON_SUCCESS 0x40 ! 7546: #define SL_INVOKE_ON_ERROR 0x80 ! 7547: ! 7548: // ! 7549: // Define flags for various functions ! 7550: // ! 7551: ! 7552: // ! 7553: // Create / Create Named Pipe ! 7554: // ! 7555: // The following flags must exactly match those in the IoCreateFile call's ! 7556: // options. The case sensitive flag is added in later, by the parse routine, ! 7557: // and is not an actual option to open. Rather, it is part of the object ! 7558: // manager's attributes structure. ! 7559: // ! 7560: ! 7561: #define SL_FORCE_ACCESS_CHECK 0x01 ! 7562: #define SL_OPEN_PAGING_FILE 0x02 ! 7563: #define SL_OPEN_TARGET_DIRECTORY 0x04 ! 7564: ! 7565: #define SL_CASE_SENSITIVE 0x80 ! 7566: ! 7567: // ! 7568: // Read / Write ! 7569: // ! 7570: ! 7571: #define SL_KEY_SPECIFIED 0x01 ! 7572: #define SL_OVERRIDE_VERIFY_VOLUME 0x02 ! 7573: #define SL_WRITE_THROUGH 0x04 ! 7574: #define SL_FT_SEQUENTIAL_WRITE 0x08 ! 7575: ! 7576: // ! 7577: // Device I/O Control ! 7578: // ! 7579: // ! 7580: // Same SL_OVERRIDE_VERIFY_VOLUME as for read/write above. ! 7581: // ! 7582: ! 7583: // ! 7584: // Lock ! 7585: // ! 7586: ! 7587: #define SL_FAIL_IMMEDIATELY 0x01 ! 7588: #define SL_EXCLUSIVE_LOCK 0x02 ! 7589: ! 7590: // ! 7591: // QueryDirectory / QueryEa ! 7592: // ! 7593: ! 7594: #define SL_RESTART_SCAN 0x01 ! 7595: #define SL_RETURN_SINGLE_ENTRY 0x02 ! 7596: #define SL_INDEX_SPECIFIED 0x04 ! 7597: ! 7598: // ! 7599: // NotifyDirectory ! 7600: // ! 7601: ! 7602: #define SL_WATCH_TREE 0x01 ! 7603: ! 7604: // ! 7605: // FileSystemControl ! 7606: // ! 7607: // minor: mount/verify volume ! 7608: // ! 7609: ! 7610: #define SL_ALLOW_RAW_MOUNT 0x01 ! 7611: ! 7612: // ! 7613: // Define I/O Request Packet (IRP) stack locations ! 7614: // ! 7615: ! 7616: #if !defined(_ALPHA_) ! 7617: #pragma pack(4) ! 7618: #endif ! 7619: typedef struct _IO_STACK_LOCATION { ! 7620: UCHAR MajorFunction; ! 7621: UCHAR MinorFunction; ! 7622: UCHAR Flags; ! 7623: UCHAR Control; ! 7624: ! 7625: // ! 7626: // The following user parameters are based on the service that is being ! 7627: // invoked. Drivers and file systems can determine which set to use based ! 7628: // on the above major and minor function codes. ! 7629: // ! 7630: ! 7631: union { ! 7632: ! 7633: // ! 7634: // System service parameters for: NtCreateFile ! 7635: // ! 7636: ! 7637: struct { ! 7638: PIO_SECURITY_CONTEXT SecurityContext; ! 7639: ULONG Options; ! 7640: USHORT FileAttributes; ! 7641: USHORT ShareAccess; ! 7642: ULONG EaLength; ! 7643: } Create; ! 7644: ! 7645: ! 7646: // ! 7647: // System service parameters for: NtReadFile ! 7648: // ! 7649: ! 7650: struct { ! 7651: ULONG Length; ! 7652: ULONG Key; ! 7653: LARGE_INTEGER ByteOffset; ! 7654: } Read; ! 7655: ! 7656: // ! 7657: // System service parameters for: NtWriteFile ! 7658: // ! 7659: ! 7660: struct { ! 7661: ULONG Length; ! 7662: ULONG Key; ! 7663: LARGE_INTEGER ByteOffset; ! 7664: } Write; ! 7665: ! 7666: ! 7667: // ! 7668: // System service parameters for: NtQueryInformationFile ! 7669: // ! 7670: ! 7671: struct { ! 7672: ULONG Length; ! 7673: FILE_INFORMATION_CLASS FileInformationClass; ! 7674: } QueryFile; ! 7675: ! 7676: // ! 7677: // System service parameters for: NtSetInformationFile ! 7678: // ! 7679: ! 7680: struct { ! 7681: ULONG Length; ! 7682: FILE_INFORMATION_CLASS FileInformationClass; ! 7683: PFILE_OBJECT FileObject; ! 7684: BOOLEAN ReplaceIfExists; ! 7685: BOOLEAN AdvanceOnly; ! 7686: } SetFile; ! 7687: ! 7688: ! 7689: // ! 7690: // System service parameters for: NtQueryVolumeInformationFile ! 7691: // ! 7692: ! 7693: struct { ! 7694: ULONG Length; ! 7695: FS_INFORMATION_CLASS FsInformationClass; ! 7696: } QueryVolume; ! 7697: ! 7698: ! 7699: // ! 7700: // System service parameters for: NtFlushBuffersFile ! 7701: // ! 7702: // No extra user-supplied parameters. ! 7703: // ! 7704: ! 7705: ! 7706: // ! 7707: // System service parameters for: NtDeviceIoControlFile ! 7708: // ! 7709: // Note that the user's output buffer is stored in the UserBuffer field ! 7710: // and the user's input buffer is stored in the SystemBuffer field. ! 7711: // ! 7712: ! 7713: struct { ! 7714: ULONG OutputBufferLength; ! 7715: ULONG InputBufferLength; ! 7716: ULONG IoControlCode; ! 7717: PVOID Type3InputBuffer; ! 7718: } DeviceIoControl; ! 7719: ! 7720: // ! 7721: // System service parameters for: NtQuerySecurityObject ! 7722: // ! 7723: ! 7724: struct { ! 7725: SECURITY_INFORMATION SecurityInformation; ! 7726: ULONG Length; ! 7727: } QuerySecurity; ! 7728: ! 7729: // ! 7730: // System service parameters for: NtSetSecurityObject ! 7731: // ! 7732: ! 7733: struct { ! 7734: SECURITY_INFORMATION SecurityInformation; ! 7735: PSECURITY_DESCRIPTOR SecurityDescriptor; ! 7736: } SetSecurity; ! 7737: ! 7738: // ! 7739: // Non-system service parameters. ! 7740: // ! 7741: // Parameters for MountVolume ! 7742: // ! 7743: ! 7744: struct { ! 7745: PVPB Vpb; ! 7746: PDEVICE_OBJECT DeviceObject; ! 7747: } MountVolume; ! 7748: ! 7749: // ! 7750: // Parameters for VerifyVolume ! 7751: // ! 7752: ! 7753: struct { ! 7754: PVPB Vpb; ! 7755: PDEVICE_OBJECT DeviceObject; ! 7756: } VerifyVolume; ! 7757: ! 7758: // ! 7759: // Parameters for Scsi with internal device contorl. ! 7760: // ! 7761: ! 7762: struct { ! 7763: struct _SCSI_REQUEST_BLOCK *Srb; ! 7764: } Scsi; ! 7765: ! 7766: // ! 7767: // Parameters for Cleanup ! 7768: // ! 7769: // No extra parameters supplied ! 7770: // ! 7771: ! 7772: // ! 7773: // Others - driver-specific ! 7774: // ! 7775: ! 7776: struct { ! 7777: PVOID Argument1; ! 7778: PVOID Argument2; ! 7779: PVOID Argument3; ! 7780: PVOID Argument4; ! 7781: } Others; ! 7782: ! 7783: } Parameters; ! 7784: ! 7785: // ! 7786: // Save a pointer to this device driver's device object for this request ! 7787: // so it can be passed to the completion routine if needed. ! 7788: // ! 7789: ! 7790: PDEVICE_OBJECT DeviceObject; ! 7791: ! 7792: // ! 7793: // The following location contains a pointer to the file object for this ! 7794: // ! 7795: ! 7796: PFILE_OBJECT FileObject; ! 7797: ! 7798: // ! 7799: // The following routine is invoked depending on the flags in the above ! 7800: // flags field. ! 7801: // ! 7802: ! 7803: PIO_COMPLETION_ROUTINE CompletionRoutine; ! 7804: ! 7805: // ! 7806: // The following is used to store the address of the context parameter ! 7807: // that should be passed to the CompletionRoutine. ! 7808: // ! 7809: ! 7810: PVOID Context; ! 7811: ! 7812: } IO_STACK_LOCATION, *PIO_STACK_LOCATION; ! 7813: #if !defined(_ALPHA_) ! 7814: #pragma pack() ! 7815: #endif ! 7816: ! 7817: // ! 7818: // Define the share access structure used by file systems to determine ! 7819: // whether or not another accessor may open the file. ! 7820: // ! 7821: ! 7822: typedef struct _SHARE_ACCESS { ! 7823: ULONG OpenCount; ! 7824: ULONG Readers; ! 7825: ULONG Writers; ! 7826: ULONG Deleters; ! 7827: ULONG SharedRead; ! 7828: ULONG SharedWrite; ! 7829: ULONG SharedDelete; ! 7830: } SHARE_ACCESS, *PSHARE_ACCESS; ! 7831: ! 7832: // begin_nthal ! 7833: ! 7834: // ! 7835: // The following structure is used by drivers that are initializing to ! 7836: // determine the number of devices of a particular type that have already ! 7837: // been initialized. It is also used to track whether or not the AtDisk ! 7838: // address range has already been claimed. Finally, it is used by the ! 7839: // NtQuerySystemInformation system service to return device type counts. ! 7840: // ! 7841: ! 7842: typedef struct _CONFIGURATION_INFORMATION { ! 7843: ! 7844: // ! 7845: // This field indicates the total number of disks in the system. This ! 7846: // number should be used by the driver to determine the name of new ! 7847: // disks. This field should be updated by the driver as it finds new ! 7848: // disks. ! 7849: // ! 7850: ! 7851: ULONG DiskCount; // Count of hard disks thus far ! 7852: ULONG FloppyCount; // Count of floppy disks thus far ! 7853: ULONG CdRomCount; // Count of CD-ROM drives thus far ! 7854: ULONG TapeCount; // Count of tape drives thus far ! 7855: ULONG ScsiPortCount; // Count of SCSI port adapters thus far ! 7856: ULONG SerialCount; // Count of serial devices thus far ! 7857: ULONG ParallelCount; // Count of parallel devices thus far ! 7858: ! 7859: // ! 7860: // These next two fields indicate ownership of one of the two IO address ! 7861: // spaces that are used by WD1003-compatable disk controllers. ! 7862: // ! 7863: ! 7864: BOOLEAN AtDiskPrimaryAddressClaimed; // 0x1F0 - 0x1FF ! 7865: BOOLEAN AtDiskSecondaryAddressClaimed; // 0x170 - 0x17F ! 7866: ! 7867: } CONFIGURATION_INFORMATION, *PCONFIGURATION_INFORMATION; ! 7868: ! 7869: // ! 7870: // Public I/O routine definitions ! 7871: // ! 7872: ! 7873: VOID ! 7874: IoAcquireCancelSpinLock( ! 7875: OUT PKIRQL Irql ! 7876: ); ! 7877: ! 7878: ! 7879: NTSTATUS ! 7880: IoAllocateAdapterChannel( ! 7881: IN PADAPTER_OBJECT AdapterObject, ! 7882: IN PDEVICE_OBJECT DeviceObject, ! 7883: IN ULONG NumberOfMapRegisters, ! 7884: IN PDRIVER_CONTROL ExecutionRoutine, ! 7885: IN PVOID Context ! 7886: ); ! 7887: ! 7888: VOID ! 7889: IoAllocateController( ! 7890: IN PCONTROLLER_OBJECT ControllerObject, ! 7891: IN PDEVICE_OBJECT DeviceObject, ! 7892: IN PDRIVER_CONTROL ExecutionRoutine, ! 7893: IN PVOID Context ! 7894: ); ! 7895: ! 7896: PVOID ! 7897: IoAllocateErrorLogEntry( ! 7898: IN PVOID IoObject, ! 7899: IN UCHAR EntrySize ! 7900: ); ! 7901: ! 7902: PIRP ! 7903: IoAllocateIrp( ! 7904: IN CCHAR StackSize, ! 7905: IN BOOLEAN ChargeQuota ! 7906: ); ! 7907: ! 7908: PMDL ! 7909: IoAllocateMdl( ! 7910: IN PVOID VirtualAddress, ! 7911: IN ULONG Length, ! 7912: IN BOOLEAN SecondaryBuffer, ! 7913: IN BOOLEAN ChargeQuota, ! 7914: IN OUT PIRP Irp OPTIONAL ! 7915: ); ! 7916: ! 7917: //++ ! 7918: // ! 7919: // VOID ! 7920: // IoAssignArcName( ! 7921: // IN PUNICODE_STRING ArcName, ! 7922: // IN PUNICODE_STRING DeviceName ! 7923: // ) ! 7924: // ! 7925: // Routine Description: ! 7926: // ! 7927: // This routine is invoked by drivers of bootable media to create a symbolic ! 7928: // link between the ARC name of their device and its NT name. This allows ! 7929: // the system to determine which device in the system was actually booted ! 7930: // from since the ARC firmware only deals in ARC names, and NT only deals ! 7931: // in NT names. ! 7932: // ! 7933: // Arguments: ! 7934: // ! 7935: // ArcName - Supplies the Unicode string representing the ARC name. ! 7936: // ! 7937: // DeviceName - Supplies the name to which the ARCname refers. ! 7938: // ! 7939: // Return Value: ! 7940: // ! 7941: // None. ! 7942: // ! 7943: //-- ! 7944: ! 7945: #define IoAssignArcName( ArcName, DeviceName ) ( \ ! 7946: IoCreateSymbolicLink( (ArcName), (DeviceName) ) ) ! 7947: ! 7948: NTSTATUS ! 7949: IoAttachDevice( ! 7950: IN PDEVICE_OBJECT SourceDevice, ! 7951: IN PUNICODE_STRING TargetDevice, ! 7952: OUT PDEVICE_OBJECT *AttachedDevice ! 7953: ); ! 7954: ! 7955: NTSTATUS ! 7956: IoAttachDeviceByPointer( ! 7957: IN PDEVICE_OBJECT SourceDevice, ! 7958: IN PDEVICE_OBJECT TargetDevice ! 7959: ); ! 7960: ! 7961: PIRP ! 7962: IoBuildAsynchronousFsdRequest( ! 7963: IN ULONG MajorFunction, ! 7964: IN PDEVICE_OBJECT DeviceObject, ! 7965: IN OUT PVOID Buffer OPTIONAL, ! 7966: IN ULONG Length OPTIONAL, ! 7967: IN PLARGE_INTEGER StartingOffset OPTIONAL, ! 7968: IN PIO_STATUS_BLOCK IoStatusBlock OPTIONAL ! 7969: ); ! 7970: ! 7971: PIRP ! 7972: IoBuildDeviceIoControlRequest( ! 7973: IN ULONG IoControlCode, ! 7974: IN PDEVICE_OBJECT DeviceObject, ! 7975: IN PVOID InputBuffer OPTIONAL, ! 7976: IN ULONG InputBufferLength, ! 7977: OUT PVOID OutputBuffer OPTIONAL, ! 7978: IN ULONG OutputBufferLength, ! 7979: IN BOOLEAN InternalDeviceIoControl, ! 7980: IN PKEVENT Event, ! 7981: OUT PIO_STATUS_BLOCK IoStatusBlock ! 7982: ); ! 7983: ! 7984: VOID ! 7985: IoBuildPartialMdl( ! 7986: IN PMDL SourceMdl, ! 7987: IN OUT PMDL TargetMdl, ! 7988: IN PVOID VirtualAddress, ! 7989: IN ULONG Length ! 7990: ); ! 7991: ! 7992: PIRP ! 7993: IoBuildSynchronousFsdRequest( ! 7994: IN ULONG MajorFunction, ! 7995: IN PDEVICE_OBJECT DeviceObject, ! 7996: IN OUT PVOID Buffer OPTIONAL, ! 7997: IN ULONG Length OPTIONAL, ! 7998: IN PLARGE_INTEGER StartingOffset OPTIONAL, ! 7999: IN PKEVENT Event, ! 8000: OUT PIO_STATUS_BLOCK IoStatusBlock ! 8001: ); ! 8002: ! 8003: NTSTATUS ! 8004: IoCallDriver( ! 8005: IN PDEVICE_OBJECT DeviceObject, ! 8006: IN OUT PIRP Irp ! 8007: ); ! 8008: ! 8009: BOOLEAN ! 8010: IoCancelIrp( ! 8011: IN PIRP Irp ! 8012: ); ! 8013: ! 8014: ! 8015: NTSTATUS ! 8016: IoCheckShareAccess( ! 8017: IN ACCESS_MASK DesiredAccess, ! 8018: IN ULONG DesiredShareAccess, ! 8019: IN OUT PFILE_OBJECT FileObject, ! 8020: IN OUT PSHARE_ACCESS ShareAccess, ! 8021: IN BOOLEAN Update ! 8022: ); ! 8023: ! 8024: VOID ! 8025: IoCompleteRequest( ! 8026: IN PIRP Irp, ! 8027: IN CCHAR PriorityBoost ! 8028: ); ! 8029: ! 8030: NTSTATUS ! 8031: IoConnectInterrupt( ! 8032: OUT PKINTERRUPT *InterruptObject, ! 8033: IN PKSERVICE_ROUTINE ServiceRoutine, ! 8034: IN PVOID ServiceContext, ! 8035: IN PKSPIN_LOCK SpinLock OPTIONAL, ! 8036: IN ULONG Vector, ! 8037: IN KIRQL Irql, ! 8038: IN KIRQL SynchronizeIrql, ! 8039: IN KINTERRUPT_MODE InterruptMode, ! 8040: IN BOOLEAN ShareVector, ! 8041: IN KAFFINITY ProcessorEnableMask, ! 8042: IN BOOLEAN FloatingSave ! 8043: ); ! 8044: ! 8045: PCONTROLLER_OBJECT ! 8046: IoCreateController( ! 8047: IN ULONG Size ! 8048: ); ! 8049: ! 8050: NTSTATUS ! 8051: IoCreateDevice( ! 8052: IN PDRIVER_OBJECT DriverObject, ! 8053: IN ULONG DeviceExtensionSize, ! 8054: IN PUNICODE_STRING DeviceName OPTIONAL, ! 8055: IN DEVICE_TYPE DeviceType, ! 8056: IN ULONG DeviceCharacteristics, ! 8057: IN BOOLEAN Exclusive, ! 8058: OUT PDEVICE_OBJECT *DeviceObject ! 8059: ); ! 8060: ! 8061: ! 8062: NTSTATUS ! 8063: IoCreateSymbolicLink( ! 8064: IN PUNICODE_STRING SymbolicLinkName, ! 8065: IN PUNICODE_STRING DeviceName ! 8066: ); ! 8067: ! 8068: PKEVENT ! 8069: IoCreateSynchronizationEvent( ! 8070: IN PUNICODE_STRING EventName, ! 8071: OUT PHANDLE EventHandle ! 8072: ); ! 8073: ! 8074: NTSTATUS ! 8075: IoCreateUnprotectedSymbolicLink( ! 8076: IN PUNICODE_STRING SymbolicLinkName, ! 8077: IN PUNICODE_STRING DeviceName ! 8078: ); ! 8079: ! 8080: //++ ! 8081: // ! 8082: // VOID ! 8083: // IoDeassignArcName( ! 8084: // IN PUNICODE_STRING ArcName ! 8085: // ) ! 8086: // ! 8087: // Routine Description: ! 8088: // ! 8089: // This routine is invoked by drivers to deassign an ARC name that they ! 8090: // created to a device. This is generally only called if the driver is ! 8091: // deleting the device object, which means that the driver is probably ! 8092: // unloading. ! 8093: // ! 8094: // Arguments: ! 8095: // ! 8096: // ArcName - Supplies the ARC name to be removed. ! 8097: // ! 8098: // Return Value: ! 8099: // ! 8100: // None. ! 8101: // ! 8102: //-- ! 8103: ! 8104: #define IoDeassignArcName( ArcName ) ( \ ! 8105: IoDeleteSymbolicLink( (ArcName) ) ) ! 8106: ! 8107: VOID ! 8108: IoDeleteController( ! 8109: IN PCONTROLLER_OBJECT ControllerObject ! 8110: ); ! 8111: ! 8112: VOID ! 8113: IoDeleteDevice( ! 8114: IN PDEVICE_OBJECT DeviceObject ! 8115: ); ! 8116: ! 8117: NTSTATUS ! 8118: IoDeleteSymbolicLink( ! 8119: IN PUNICODE_STRING SymbolicLinkName ! 8120: ); ! 8121: ! 8122: VOID ! 8123: IoDetachDevice( ! 8124: IN OUT PDEVICE_OBJECT TargetDevice ! 8125: ); ! 8126: ! 8127: VOID ! 8128: IoDisconnectInterrupt( ! 8129: IN PKINTERRUPT InterruptObject ! 8130: ); ! 8131: ! 8132: VOID ! 8133: IoFreeController( ! 8134: IN PCONTROLLER_OBJECT ControllerObject ! 8135: ); ! 8136: ! 8137: VOID ! 8138: IoFreeIrp( ! 8139: IN PIRP Irp ! 8140: ); ! 8141: ! 8142: VOID ! 8143: IoFreeMdl( ! 8144: IN PMDL Mdl ! 8145: ); ! 8146: ! 8147: PCONFIGURATION_INFORMATION ! 8148: IoGetConfigurationInformation( VOID ); ! 8149: ! 8150: //++ ! 8151: // ! 8152: // PIO_STACK_LOCATION ! 8153: // IoGetCurrentIrpStackLocation( ! 8154: // IN PIRP Irp ! 8155: // ) ! 8156: // ! 8157: // Routine Description: ! 8158: // ! 8159: // This routine is invoked to return a pointer to the current stack location ! 8160: // in an I/O Request Packet (IRP). ! 8161: // ! 8162: // Arguments: ! 8163: // ! 8164: // Irp - Pointer to the I/O Request Packet. ! 8165: // ! 8166: // Return Value: ! 8167: // ! 8168: // The function value is a pointer to the current stack location in the ! 8169: // packet. ! 8170: // ! 8171: //-- ! 8172: ! 8173: #define IoGetCurrentIrpStackLocation( Irp ) ( (Irp)->Tail.Overlay.CurrentStackLocation ) ! 8174: ! 8175: // end_nthal ! 8176: ! 8177: PEPROCESS ! 8178: IoGetCurrentProcess( ! 8179: VOID ! 8180: ); ! 8181: ! 8182: // begin_nthal ! 8183: ! 8184: NTSTATUS ! 8185: IoGetDeviceObjectPointer( ! 8186: IN PUNICODE_STRING ObjectName, ! 8187: IN ACCESS_MASK DesiredAccess, ! 8188: OUT PFILE_OBJECT *FileObject, ! 8189: OUT PDEVICE_OBJECT *DeviceObject ! 8190: ); ! 8191: ! 8192: //++ ! 8193: // ! 8194: // PIO_STACK_LOCATION ! 8195: // IoGetNextIrpStackLocation( ! 8196: // IN PIRP Irp ! 8197: // ) ! 8198: // ! 8199: // Routine Description: ! 8200: // ! 8201: // This routine is invoked to return a pointer to the next stack location ! 8202: // in an I/O Request Packet (IRP). ! 8203: // ! 8204: // Arguments: ! 8205: // ! 8206: // Irp - Pointer to the I/O Request Packet. ! 8207: // ! 8208: // Return Value: ! 8209: // ! 8210: // The function value is a pointer to the next stack location in the packet. ! 8211: // ! 8212: //-- ! 8213: ! 8214: #define IoGetNextIrpStackLocation( Irp ) (\ ! 8215: (Irp)->Tail.Overlay.CurrentStackLocation - 1 ) ! 8216: ! 8217: PDEVICE_OBJECT ! 8218: IoGetRelatedDeviceObject( ! 8219: IN PFILE_OBJECT FileObject ! 8220: ); ! 8221: ! 8222: ! 8223: //++ ! 8224: // ! 8225: // VOID ! 8226: // IoInitializeDpcRequest( ! 8227: // IN PDEVICE_OBJECT DeviceObject, ! 8228: // IN PIO_DPC_ROUTINE DpcRoutine ! 8229: // ) ! 8230: // ! 8231: // Routine Description: ! 8232: // ! 8233: // This routine is invoked to initialize the DPC in a device object for a ! 8234: // device driver during its initialization routine. The DPC is used later ! 8235: // when the driver interrupt service routine requests that a DPC routine ! 8236: // be queued for later execution. ! 8237: // ! 8238: // Arguments: ! 8239: // ! 8240: // DeviceObject - Pointer to the device object that the request is for. ! 8241: // ! 8242: // DpcRoutine - Address of the driver's DPC routine to be executed when ! 8243: // the DPC is dequeued for processing. ! 8244: // ! 8245: // Return Value: ! 8246: // ! 8247: // None. ! 8248: // ! 8249: //-- ! 8250: ! 8251: #define IoInitializeDpcRequest( DeviceObject, DpcRoutine ) (\ ! 8252: KeInitializeDpc( &(DeviceObject)->Dpc, \ ! 8253: (PKDEFERRED_ROUTINE) (DpcRoutine), \ ! 8254: (DeviceObject) ) ) ! 8255: ! 8256: VOID ! 8257: IoInitializeIrp( ! 8258: IN OUT PIRP Irp, ! 8259: IN USHORT PacketSize, ! 8260: IN CCHAR StackSize ! 8261: ); ! 8262: ! 8263: NTSTATUS ! 8264: IoInitializeTimer( ! 8265: IN PDEVICE_OBJECT DeviceObject, ! 8266: IN PIO_TIMER_ROUTINE TimerRoutine, ! 8267: IN PVOID Context ! 8268: ); ! 8269: ! 8270: ! 8271: //++ ! 8272: // ! 8273: // BOOLEAN ! 8274: // IoIsErrorUserInduced( ! 8275: // IN NTSTATUS Status ! 8276: // ) ! 8277: // ! 8278: // Routine Description: ! 8279: // ! 8280: // This routine is invoked to determine if an error was as a ! 8281: // result of user actions. Typically these error are related ! 8282: // to removable media and will result in a pop-up. ! 8283: // ! 8284: // Arguments: ! 8285: // ! 8286: // Status - The status value to check. ! 8287: // ! 8288: // Return Value: ! 8289: // ! 8290: // The function value is TRUE if the user induced the error, ! 8291: // otherwise FALSE is returned. ! 8292: // ! 8293: //-- ! 8294: #define IoIsErrorUserInduced( Status ) ((BOOLEAN) \ ! 8295: (((Status) == STATUS_DEVICE_NOT_READY) || \ ! 8296: ((Status) == STATUS_IO_TIMEOUT) || \ ! 8297: ((Status) == STATUS_MEDIA_WRITE_PROTECTED) || \ ! 8298: ((Status) == STATUS_NO_MEDIA_IN_DEVICE) || \ ! 8299: ((Status) == STATUS_VERIFY_REQUIRED) || \ ! 8300: ((Status) == STATUS_UNRECOGNIZED_MEDIA) || \ ! 8301: ((Status) == STATUS_WRONG_VOLUME))) ! 8302: ! 8303: ! 8304: PIRP ! 8305: IoMakeAssociatedIrp( ! 8306: IN PIRP Irp, ! 8307: IN CCHAR StackSize ! 8308: ); ! 8309: ! 8310: //++ ! 8311: // ! 8312: // VOID ! 8313: // IoMarkIrpPending( ! 8314: // IN OUT PIRP Irp ! 8315: // ) ! 8316: // ! 8317: // Routine Description: ! 8318: // ! 8319: // This routine marks the specified I/O Request Packet (IRP) to indicate ! 8320: // that an initial status of STATUS_PENDING was returned to the caller. ! 8321: // This is used so that I/O completion can determine whether or not to ! 8322: // fully complete the I/O operation requested by the packet. ! 8323: // ! 8324: // Arguments: ! 8325: // ! 8326: // Irp - Pointer to the I/O Request Packet to be marked pending. ! 8327: // ! 8328: // Return Value: ! 8329: // ! 8330: // None. ! 8331: // ! 8332: //-- ! 8333: ! 8334: #define IoMarkIrpPending( Irp ) ( \ ! 8335: IoGetCurrentIrpStackLocation( (Irp) )->Control |= SL_PENDING_RETURNED ) ! 8336: ! 8337: NTSTATUS ! 8338: IoQueryDeviceDescription( ! 8339: IN PINTERFACE_TYPE BusType OPTIONAL, ! 8340: IN PULONG BusNumber OPTIONAL, ! 8341: IN PCONFIGURATION_TYPE ControllerType OPTIONAL, ! 8342: IN PULONG ControllerNumber OPTIONAL, ! 8343: IN PCONFIGURATION_TYPE PeripheralType OPTIONAL, ! 8344: IN PULONG PeripheralNumber OPTIONAL, ! 8345: IN PIO_QUERY_DEVICE_ROUTINE CalloutRoutine, ! 8346: IN PVOID Context ! 8347: ); ! 8348: VOID ! 8349: IoRaiseHardError( ! 8350: IN PIRP Irp, ! 8351: IN PVPB Vpb OPTIONAL, ! 8352: IN PDEVICE_OBJECT RealDeviceObject ! 8353: ); ! 8354: ! 8355: VOID ! 8356: IoRaiseInformationalHardError( ! 8357: IN NTSTATUS ErrorStatus, ! 8358: IN PUNICODE_STRING String OPTIONAL, ! 8359: IN PKTHREAD Thread OPTIONAL ! 8360: ); ! 8361: ! 8362: VOID ! 8363: IoRegisterDriverReinitialization( ! 8364: IN PDRIVER_OBJECT DriverObject, ! 8365: IN PDRIVER_REINITIALIZE DriverReinitializationRoutine, ! 8366: IN PVOID Context ! 8367: ); ! 8368: ! 8369: NTSTATUS ! 8370: IoRegisterShutdownNotification( ! 8371: IN PDEVICE_OBJECT DeviceObject ! 8372: ); ! 8373: ! 8374: VOID ! 8375: IoReleaseCancelSpinLock( ! 8376: IN KIRQL Irql ! 8377: ); ! 8378: ! 8379: ! 8380: VOID ! 8381: IoRemoveShareAccess( ! 8382: IN PFILE_OBJECT FileObject, ! 8383: IN OUT PSHARE_ACCESS ShareAccess ! 8384: ); ! 8385: ! 8386: ! 8387: NTSTATUS ! 8388: IoReportResourceUsage( ! 8389: IN PUNICODE_STRING DriverClassName OPTIONAL, ! 8390: IN PDRIVER_OBJECT DriverObject, ! 8391: IN PCM_RESOURCE_LIST DriverList OPTIONAL, ! 8392: IN ULONG DriverListSize OPTIONAL, ! 8393: IN PDEVICE_OBJECT DeviceObject, ! 8394: IN PCM_RESOURCE_LIST DeviceList OPTIONAL, ! 8395: IN ULONG DeviceListSize OPTIONAL, ! 8396: IN BOOLEAN OverrideConflict, ! 8397: OUT PBOOLEAN ConflictDetected ! 8398: ); ! 8399: ! 8400: //++ ! 8401: // ! 8402: // VOID ! 8403: // IoRequestDpc( ! 8404: // IN PDEVICE_OBJECT DeviceObject, ! 8405: // IN PIRP Irp, ! 8406: // IN PVOID Context ! 8407: // ) ! 8408: // ! 8409: // Routine Description: ! 8410: // ! 8411: // This routine is invoked by the device driver's interrupt service routine ! 8412: // to request that a DPC routine be queued for later execution at a lower ! 8413: // IRQL. ! 8414: // ! 8415: // Arguments: ! 8416: // ! 8417: // DeviceObject - Device object for which the request is being processed. ! 8418: // ! 8419: // Irp - Pointer to the current I/O Request Packet (IRP) for the specified ! 8420: // device. ! 8421: // ! 8422: // Context - Provides a general context parameter to be passed to the ! 8423: // DPC routine. ! 8424: // ! 8425: // Return Value: ! 8426: // ! 8427: // None. ! 8428: // ! 8429: //-- ! 8430: ! 8431: #define IoRequestDpc( DeviceObject, Irp, Context ) ( \ ! 8432: KeInsertQueueDpc( &(DeviceObject)->Dpc, (Irp), (Context) ) ) ! 8433: ! 8434: //++ ! 8435: // ! 8436: // VOID ! 8437: // IoSetCancelRoutine( ! 8438: // IN PIRP Irp, ! 8439: // IN PDRIVER_CANCEL CancelRoutine ! 8440: // ) ! 8441: // ! 8442: // Routine Description: ! 8443: // ! 8444: // This routine is invoked to set the address of a cancel routine which ! 8445: // is to be invoked when an I/O packet has been canceled. ! 8446: // ! 8447: // Arguments: ! 8448: // ! 8449: // Irp - Pointer to the I/O Request Packet itself. ! 8450: // ! 8451: // CancelRoutine - Address of the cancel routine that is to be invoked ! 8452: // if the IRP is cancelled. ! 8453: // ! 8454: // Return Value: ! 8455: // ! 8456: // None. ! 8457: // ! 8458: // Note: ! 8459: // ! 8460: // The I/O cancel spin lock must be held when this routine is invoked. ! 8461: // ! 8462: //-- ! 8463: ! 8464: #define IoSetCancelRoutine( Irp, NewCancelRoutine ) ( \ ! 8465: (Irp)->CancelRoutine = (NewCancelRoutine) ) ! 8466: ! 8467: //++ ! 8468: // ! 8469: // VOID ! 8470: // IoSetCompletionRoutine( ! 8471: // IN PIRP Irp, ! 8472: // IN PIO_COMPLETION_ROUTINE CompletionRoutine, ! 8473: // IN PVOID Context, ! 8474: // IN BOOLEAN InvokeOnSuccess, ! 8475: // IN BOOLEAN InvokeOnError, ! 8476: // IN BOOLEAN InvokeOnCancel ! 8477: // ) ! 8478: // ! 8479: // Routine Description: ! 8480: // ! 8481: // This routine is invoked to set the address of a completion routine which ! 8482: // is to be invoked when an I/O packet has been completed by a lower-level ! 8483: // driver. ! 8484: // ! 8485: // Arguments: ! 8486: // ! 8487: // Irp - Pointer to the I/O Request Packet itself. ! 8488: // ! 8489: // CompletionRoutine - Address of the completion routine that is to be ! 8490: // invoked once the next level driver completes the packet. ! 8491: // ! 8492: // Context - Specifies a context parameter to be passed to the completion ! 8493: // routine. ! 8494: // ! 8495: // InvokeOnSuccess - Specifies that the completion routine is invoked when the ! 8496: // operation is successfully completed. ! 8497: // ! 8498: // InvokeOnError - Specifies that the completion routine is invoked when the ! 8499: // operation completes with an error status. ! 8500: // ! 8501: // InvokeOnCancel - Specifies that the completion routine is invoked when the ! 8502: // operation is being canceled. ! 8503: // ! 8504: // Return Value: ! 8505: // ! 8506: // None. ! 8507: // ! 8508: //-- ! 8509: ! 8510: #define IoSetCompletionRoutine( Irp, Routine, CompletionContext, Success, Error, Cancel ) { \ ! 8511: PIO_STACK_LOCATION irpSp; \ ! 8512: ASSERT( (Success) | (Error) | (Cancel) ? (Routine) != NULL : TRUE ); \ ! 8513: irpSp = IoGetNextIrpStackLocation( (Irp) ); \ ! 8514: irpSp->CompletionRoutine = (Routine); \ ! 8515: irpSp->Context = (CompletionContext); \ ! 8516: irpSp->Control = 0; \ ! 8517: if ((Success)) { irpSp->Control = SL_INVOKE_ON_SUCCESS; } \ ! 8518: if ((Error)) { irpSp->Control |= SL_INVOKE_ON_ERROR; } \ ! 8519: if ((Cancel)) { irpSp->Control |= SL_INVOKE_ON_CANCEL; } } ! 8520: ! 8521: VOID ! 8522: IoSetHardErrorOrVerifyDevice( ! 8523: IN PIRP Irp, ! 8524: IN PDEVICE_OBJECT DeviceObject ! 8525: ); ! 8526: ! 8527: ! 8528: //++ ! 8529: // ! 8530: // VOID ! 8531: // IoSetNextIrpStackLocation ( ! 8532: // IN OUT PIRP Irp ! 8533: // ) ! 8534: // ! 8535: // Routine Description: ! 8536: // ! 8537: // This routine is invoked to set the current IRP stack location to ! 8538: // the next stack location, i.e. it "pushes" the stack. ! 8539: // ! 8540: // Arguments: ! 8541: // ! 8542: // Irp - Pointer to the I/O Request Packet (IRP). ! 8543: // ! 8544: // Return Value: ! 8545: // ! 8546: // None. ! 8547: // ! 8548: //-- ! 8549: ! 8550: #define IoSetNextIrpStackLocation( Irp ) { \ ! 8551: (Irp)->CurrentLocation--; \ ! 8552: (Irp)->Tail.Overlay.CurrentStackLocation--; } ! 8553: ! 8554: VOID ! 8555: IoSetShareAccess( ! 8556: IN ACCESS_MASK DesiredAccess, ! 8557: IN ULONG DesiredShareAccess, ! 8558: IN OUT PFILE_OBJECT FileObject, ! 8559: OUT PSHARE_ACCESS ShareAccess ! 8560: ); ! 8561: ! 8562: ! 8563: //++ ! 8564: // ! 8565: // USHORT ! 8566: // IoSizeOfIrp( ! 8567: // IN CCHAR StackSize ! 8568: // ) ! 8569: // ! 8570: // Routine Description: ! 8571: // ! 8572: // Determines the size of an IRP given the number of stack locations ! 8573: // the IRP will have. ! 8574: // ! 8575: // Arguments: ! 8576: // ! 8577: // StackSize - Number of stack locations for the IRP. ! 8578: // ! 8579: // Return Value: ! 8580: // ! 8581: // Size in bytes of the IRP. ! 8582: // ! 8583: //-- ! 8584: ! 8585: #define IoSizeOfIrp( StackSize ) \ ! 8586: ((USHORT) (sizeof( IRP ) + ((StackSize) * (sizeof( IO_STACK_LOCATION ))))) ! 8587: ! 8588: VOID ! 8589: IoStartNextPacket( ! 8590: IN PDEVICE_OBJECT DeviceObject, ! 8591: IN BOOLEAN Cancelable ! 8592: ); ! 8593: ! 8594: VOID ! 8595: IoStartNextPacketByKey( ! 8596: IN PDEVICE_OBJECT DeviceObject, ! 8597: IN BOOLEAN Cancelable, ! 8598: IN ULONG Key ! 8599: ); ! 8600: ! 8601: VOID ! 8602: IoStartPacket( ! 8603: IN PDEVICE_OBJECT DeviceObject, ! 8604: IN PIRP Irp, ! 8605: IN PULONG Key OPTIONAL, ! 8606: IN PDRIVER_CANCEL CancelFunction OPTIONAL ! 8607: ); ! 8608: ! 8609: VOID ! 8610: IoStartTimer( ! 8611: IN PDEVICE_OBJECT DeviceObject ! 8612: ); ! 8613: ! 8614: VOID ! 8615: IoStopTimer( ! 8616: IN PDEVICE_OBJECT DeviceObject ! 8617: ); ! 8618: ! 8619: VOID ! 8620: IoUnregisterShutdownNotification( ! 8621: IN PDEVICE_OBJECT DeviceObject ! 8622: ); ! 8623: ! 8624: VOID ! 8625: IoUpdateShareAccess( ! 8626: IN PFILE_OBJECT FileObject, ! 8627: IN OUT PSHARE_ACCESS ShareAccess ! 8628: ); ! 8629: ! 8630: VOID ! 8631: IoWriteErrorLogEntry( ! 8632: IN PVOID ElEntry ! 8633: ); ! 8634: // ! 8635: // The following definitions are for HAL structures. ! 8636: // ! 8637: ! 8638: // begin_ntminiport ! 8639: // ! 8640: // Define types of bus information. ! 8641: // ! 8642: ! 8643: typedef enum _BUS_DATA_TYPE { ! 8644: Cmos, ! 8645: EisaConfiguration, ! 8646: Pos, ! 8647: CbusConfiguration, ! 8648: PCIConfiguration, ! 8649: VMEConfiguration, ! 8650: NuBusConfiguration, ! 8651: PCMCIAConfiguration, ! 8652: MPIConfiguration, ! 8653: MPSAConfiguration, ! 8654: MaximumBusDataType ! 8655: } BUS_DATA_TYPE, *PBUS_DATA_TYPE; ! 8656: ! 8657: // ! 8658: // Define the device description structure. ! 8659: // ! 8660: ! 8661: typedef struct _DEVICE_DESCRIPTION { ! 8662: ULONG Version; ! 8663: BOOLEAN Master; ! 8664: BOOLEAN ScatterGather; ! 8665: BOOLEAN DemandMode; ! 8666: BOOLEAN AutoInitialize; ! 8667: BOOLEAN Dma32BitAddresses; ! 8668: ULONG BusNumber; ! 8669: ULONG DmaChannel; ! 8670: INTERFACE_TYPE InterfaceType; ! 8671: DMA_WIDTH DmaWidth; ! 8672: DMA_SPEED DmaSpeed; ! 8673: ULONG MaximumLength; ! 8674: ULONG DmaPort; ! 8675: } DEVICE_DESCRIPTION, *PDEVICE_DESCRIPTION; ! 8676: ! 8677: // ! 8678: // Define the supported version numbers for the device description structure. ! 8679: // ! 8680: ! 8681: #define DEVICE_DESCRIPTION_VERSION 0 ! 8682: ! 8683: // ! 8684: // The following function prototypes are for HAL routines with a prefix of Hal. ! 8685: // ! 8686: // General functions. ! 8687: // ! 8688: ! 8689: VOID ! 8690: HalAcquireDisplayOwnership ( ! 8691: VOID ! 8692: ); ! 8693: ! 8694: #if defined(_MIPS_) || defined(_ALPHA_) ! 8695: ! 8696: ULONG ! 8697: HalGetDmaAlignmentRequirement ( ! 8698: VOID ! 8699: ); ! 8700: ! 8701: #endif ! 8702: ! 8703: #if defined(_M_IX86) ! 8704: ! 8705: #define HalGetDmaAlignmentRequirement() 1L ! 8706: ! 8707: #endif ! 8708: ! 8709: VOID ! 8710: KeFlushWriteBuffer ( ! 8711: VOID ! 8712: ); ! 8713: ! 8714: // ! 8715: // I/O driver configuration functions. ! 8716: // ! 8717: ! 8718: ULONG ! 8719: HalGetInterruptVector( ! 8720: IN INTERFACE_TYPE InterfaceType, ! 8721: IN ULONG BusNumber, ! 8722: IN ULONG BusInterruptLevel, ! 8723: IN ULONG BusInterruptVector, ! 8724: OUT PKIRQL Irql, ! 8725: OUT PKAFFINITY Affinity ! 8726: ); ! 8727: ! 8728: BOOLEAN ! 8729: HalTranslateBusAddress( ! 8730: IN INTERFACE_TYPE InterfaceType, ! 8731: IN ULONG BusNumber, ! 8732: IN PHYSICAL_ADDRESS BusAddress, ! 8733: IN OUT PULONG AddressSpace, ! 8734: OUT PPHYSICAL_ADDRESS TranslatedAddress ! 8735: ); ! 8736: ! 8737: PVOID ! 8738: HalAllocateCommonBuffer( ! 8739: IN PADAPTER_OBJECT AdapterObject, ! 8740: IN ULONG Length, ! 8741: OUT PPHYSICAL_ADDRESS LogicalAddress, ! 8742: IN BOOLEAN CacheEnabled ! 8743: ); ! 8744: ! 8745: VOID ! 8746: HalFreeCommonBuffer( ! 8747: IN PADAPTER_OBJECT AdapterObject, ! 8748: IN ULONG Length, ! 8749: IN PHYSICAL_ADDRESS LogicalAddress, ! 8750: IN PVOID VirtualAddress, ! 8751: IN BOOLEAN CacheEnabled ! 8752: ); ! 8753: ! 8754: ULONG ! 8755: HalGetBusData( ! 8756: IN BUS_DATA_TYPE BusDataType, ! 8757: IN ULONG BusNumber, ! 8758: IN ULONG SlotNumber, ! 8759: IN PVOID Buffer, ! 8760: IN ULONG Length ! 8761: ); ! 8762: ! 8763: PADAPTER_OBJECT ! 8764: HalGetAdapter( ! 8765: IN PDEVICE_DESCRIPTION DeviceDescription, ! 8766: IN OUT PULONG NumberOfMapRegisters ! 8767: ); ! 8768: ! 8769: // ! 8770: // The following function prototypes are for HAL routines with a prefix of Io. ! 8771: // ! 8772: // DMA adapter object functions. ! 8773: // ! 8774: ! 8775: ULONG ! 8776: HalReadDmaCounter( ! 8777: IN PADAPTER_OBJECT AdapterObject ! 8778: ); ! 8779: ! 8780: BOOLEAN ! 8781: IoFlushAdapterBuffers( ! 8782: IN PADAPTER_OBJECT AdapterObject, ! 8783: IN PMDL Mdl, ! 8784: IN PVOID MapRegisterBase, ! 8785: IN PVOID CurrentVa, ! 8786: IN ULONG Length, ! 8787: IN BOOLEAN WriteToDevice ! 8788: ); ! 8789: ! 8790: VOID ! 8791: IoFreeAdapterChannel( ! 8792: IN PADAPTER_OBJECT AdapterObject ! 8793: ); ! 8794: ! 8795: VOID ! 8796: IoFreeMapRegisters( ! 8797: IN PADAPTER_OBJECT AdapterObject, ! 8798: IN PVOID MapRegisterBase, ! 8799: IN ULONG NumberOfMapRegisters ! 8800: ); ! 8801: ! 8802: PHYSICAL_ADDRESS ! 8803: IoMapTransfer( ! 8804: IN PADAPTER_OBJECT AdapterObject, ! 8805: IN PMDL Mdl, ! 8806: IN PVOID MapRegisterBase, ! 8807: IN PVOID CurrentVa, ! 8808: IN OUT PULONG Length, ! 8809: IN BOOLEAN WriteToDevice ! 8810: ); ! 8811: ! 8812: NTSTATUS ! 8813: IoReadPartitionTable( ! 8814: IN PDEVICE_OBJECT DeviceObject, ! 8815: IN ULONG SectorSize, ! 8816: IN BOOLEAN ReturnRecognizedPartitions, ! 8817: OUT struct _DRIVE_LAYOUT_INFORMATION **PartitionBuffer ! 8818: ); ! 8819: ! 8820: NTSTATUS ! 8821: IoSetPartitionInformation( ! 8822: IN PDEVICE_OBJECT DeviceObject, ! 8823: IN ULONG SectorSize, ! 8824: IN ULONG PartitionNumber, ! 8825: IN ULONG PartitionType ! 8826: ); ! 8827: ! 8828: NTSTATUS ! 8829: IoWritePartitionTable( ! 8830: IN PDEVICE_OBJECT DeviceObject, ! 8831: IN ULONG SectorSize, ! 8832: IN ULONG SectorsPerTrack, ! 8833: IN ULONG NumberOfHeads, ! 8834: IN struct _DRIVE_LAYOUT_INFORMATION *PartitionBuffer ! 8835: ); ! 8836: ! 8837: // ! 8838: // Performance counter function. ! 8839: // ! 8840: ! 8841: LARGE_INTEGER ! 8842: KeQueryPerformanceCounter ( ! 8843: IN PLARGE_INTEGER PerformanceFrequency OPTIONAL ! 8844: ); ! 8845: ! 8846: // ! 8847: // Stall processor execution function. ! 8848: // ! 8849: ! 8850: VOID ! 8851: KeStallExecutionProcessor ( ! 8852: IN ULONG MicroSeconds ! 8853: ); ! 8854: ! 8855: // ! 8856: // Determine if there is a complete device failure on an error. ! 8857: // ! 8858: ! 8859: BOOLEAN ! 8860: FsRtlIsTotalDeviceFailure( ! 8861: IN NTSTATUS Status ! 8862: ); ! 8863: ! 8864: // ! 8865: // Object Manager types ! 8866: // ! 8867: ! 8868: typedef struct _OBJECT_HANDLE_INFORMATION { ! 8869: ULONG HandleAttributes; ! 8870: ACCESS_MASK GrantedAccess; ! 8871: } OBJECT_HANDLE_INFORMATION, *POBJECT_HANDLE_INFORMATION; ! 8872: ! 8873: NTSTATUS ! 8874: ObReferenceObjectByHandle( ! 8875: IN HANDLE Handle, ! 8876: IN ACCESS_MASK DesiredAccess, ! 8877: IN POBJECT_TYPE ObjectType OPTIONAL, ! 8878: IN KPROCESSOR_MODE AccessMode, ! 8879: OUT PVOID *Object, ! 8880: OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL ! 8881: ); ! 8882: NTSTATUS ! 8883: ObReferenceObjectByPointer( ! 8884: IN PVOID Object, ! 8885: IN ACCESS_MASK DesiredAccess, ! 8886: IN POBJECT_TYPE ObjectType, ! 8887: IN KPROCESSOR_MODE AccessMode ! 8888: ); ! 8889: VOID ! 8890: ObDereferenceObject( ! 8891: IN PVOID Object ! 8892: ); ! 8893: ! 8894: // ! 8895: // Define exported ZwXxx routines to device drivers. ! 8896: // ! 8897: ! 8898: NTSTATUS ! 8899: ZwClose( ! 8900: IN HANDLE Handle ! 8901: ); ! 8902: ! 8903: NTSTATUS ! 8904: ZwCreateDirectoryObject( ! 8905: OUT PHANDLE DirectoryHandle, ! 8906: IN ACCESS_MASK DesiredAccess, ! 8907: IN POBJECT_ATTRIBUTES ObjectAttributes ! 8908: ); ! 8909: ! 8910: NTSTATUS ! 8911: ZwMakeTemporaryObject( ! 8912: IN HANDLE Handle ! 8913: ); ! 8914: ! 8915: NTSTATUS ! 8916: ZwOpenSection( ! 8917: OUT PHANDLE SectionHandle, ! 8918: IN ACCESS_MASK DesiredAccess, ! 8919: IN POBJECT_ATTRIBUTES ObjectAttributes ! 8920: ); ! 8921: ! 8922: NTSTATUS ! 8923: ZwMapViewOfSection( ! 8924: IN HANDLE SectionHandle, ! 8925: IN HANDLE ProcessHandle, ! 8926: IN OUT PVOID *BaseAddress, ! 8927: IN ULONG ZeroBits, ! 8928: IN ULONG CommitSize, ! 8929: IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, ! 8930: IN OUT PULONG ViewSize, ! 8931: IN SECTION_INHERIT InheritDisposition, ! 8932: IN ULONG AllocationType, ! 8933: IN ULONG Protect ! 8934: ); ! 8935: ! 8936: NTSTATUS ! 8937: ZwUnmapViewOfSection( ! 8938: IN HANDLE ProcessHandle, ! 8939: IN PVOID BaseAddress ! 8940: ); ! 8941: ! 8942: NTSTATUS ! 8943: ZwCreateKey( ! 8944: OUT PHANDLE KeyHandle, ! 8945: IN ACCESS_MASK DesiredAccess, ! 8946: IN POBJECT_ATTRIBUTES ObjectAttributes, ! 8947: IN ULONG TitleIndex, ! 8948: IN PUNICODE_STRING Class OPTIONAL, ! 8949: IN ULONG CreateOptions, ! 8950: OUT PULONG Disposition OPTIONAL ! 8951: ); ! 8952: ! 8953: NTSTATUS ! 8954: ZwOpenKey( ! 8955: OUT PHANDLE KeyHandle, ! 8956: IN ACCESS_MASK DesiredAccess, ! 8957: IN POBJECT_ATTRIBUTES ObjectAttributes ! 8958: ); ! 8959: ! 8960: NTSTATUS ! 8961: ZwEnumerateKey( ! 8962: IN HANDLE KeyHandle, ! 8963: IN ULONG Index, ! 8964: IN KEY_INFORMATION_CLASS KeyInformationClass, ! 8965: OUT PVOID KeyInformation, ! 8966: IN ULONG Length, ! 8967: OUT PULONG ResultLength ! 8968: ); ! 8969: ! 8970: NTSTATUS ! 8971: ZwEnumerateValueKey( ! 8972: IN HANDLE KeyHandle, ! 8973: IN ULONG Index, ! 8974: IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, ! 8975: OUT PVOID KeyValueInformation, ! 8976: IN ULONG Length, ! 8977: OUT PULONG ResultLength ! 8978: ); ! 8979: ! 8980: NTSTATUS ! 8981: ZwFlushKey( ! 8982: IN HANDLE KeyHandle ! 8983: ); ! 8984: ! 8985: NTSTATUS ! 8986: NTAPI ! 8987: ZwQueryKey( ! 8988: IN HANDLE KeyHandle, ! 8989: IN KEY_INFORMATION_CLASS KeyInformationClass, ! 8990: OUT PVOID KeyInformation, ! 8991: IN ULONG Length, ! 8992: OUT PULONG ResultLength ! 8993: ); ! 8994: ! 8995: NTSTATUS ! 8996: ZwQueryValueKey( ! 8997: IN HANDLE KeyHandle, ! 8998: OUT PUNICODE_STRING ValueName, ! 8999: IN KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass, ! 9000: OUT PVOID KeyValueInformation, ! 9001: IN ULONG Length, ! 9002: OUT PULONG ResultLength ! 9003: ); ! 9004: ! 9005: NTSTATUS ! 9006: ZwSetValueKey( ! 9007: IN HANDLE KeyHandle, ! 9008: IN PUNICODE_STRING ValueName, ! 9009: IN ULONG TitleIndex OPTIONAL, ! 9010: IN ULONG Type, ! 9011: IN PVOID Data, ! 9012: IN ULONG DataSize ! 9013: ); ! 9014: ! 9015: ! 9016: #endif // _NTDDK_
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.