几个驱动重要的结构

DEVICE_OBJECT:

1. typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _DEVICE_OBJECT {
2.     CSHORT Type;
3.     USHORT Size;
4.     LONG ReferenceCount;
5.     struct _DRIVER_OBJECT *DriverObject;
6.     struct _DEVICE_OBJECT *NextDevice;
7.     struct _DEVICE_OBJECT *AttachedDevice;
8.     struct _IRP *CurrentIrp;
9.     PIO_TIMER Timer;
10.     ULONG Flags;                                // See above:  DO_...
11.     ULONG Characteristics;                      // See ntioapi:  FILE_...
12.     __volatile PVPB Vpb;
13.     PVOID DeviceExtension;
14.     DEVICE_TYPE DeviceType;
15.     CCHAR StackSize;
16.     union {
17.         LIST_ENTRY ListEntry;
18.         WAIT_CONTEXT_BLOCK Wcb;
19.     } Queue;
20.     ULONG AlignmentRequirement;
21.     KDEVICE_QUEUE DeviceQueue;
22.     KDPC Dpc;
24.     //
25.     //  The following field is for exclusive use by the filesystem to keep
26.     //  track of the number of Fsp threads currently using the device
27.     //
29.     ULONG ActiveThreadCount;
30.     PSECURITY_DESCRIPTOR SecurityDescriptor;
31.     KEVENT DeviceLock;
33.     USHORT SectorSize;
34.     USHORT Spare1;
36.     struct _DEVOBJ_EXTENSION  *DeviceObjectExtension;
37.     PVOID  Reserved;
39. } DEVICE_OBJECT;
41. typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT;

DRIVER_OBJECT:

1. typedef struct _DRIVER_OBJECT {
2.     CSHORT Type;
3.     CSHORT Size;
5.     //
6.     // The following links all of the devices created by a single driver
7.     // together on a list, and the Flags word provides an extensible flag
8.     // location for driver objects.
9.     //
11.     PDEVICE_OBJECT DeviceObject;
12.     ULONG Flags;
14.     //
15.     // The following section describes where the driver is loaded.  The count
16.     // field is used to count the number of times the driver has had its
17.     // registered reinitialization routine invoked.
18.     //
20.     PVOID DriverStart;
21.     ULONG DriverSize;
22.     PVOID DriverSection;
23.     PDRIVER_EXTENSION DriverExtension;
25.     //
26.     // The driver name field is used by the error log thread
27.     // determine the name of the driver that an I/O request is/was bound.
28.     //
30.     UNICODE_STRING DriverName;
32.     //
33.     // The following section is for registry support.  Thise is a pointer
34.     // to the path to the hardware information in the registry
35.     //
37.     PUNICODE_STRING HardwareDatabase;
39.     //
40.     // The following section contains the optional pointer to an array of
41.     // alternate entry points to a driver for "fast I/O" support.  Fast I/O
42.     // is performed by invoking the driver routine directly with separate
43.     // parameters, rather than using the standard IRP call mechanism.  Note
44.     // that these functions may only be used for synchronous I/O, and when
45.     // the file is cached.
46.     //
48.     PFAST_IO_DISPATCH FastIoDispatch;
50.     //
51.     // The following section describes the entry points to this particular
52.     // driver.  Note that the major function dispatch table must be the last
53.     // field in the object so that it remains extensible.
54.     //
56.     PDRIVER_INITIALIZE DriverInit;
57.     PDRIVER_STARTIO DriverStartIo;
58.     PDRIVER_UNLOAD DriverUnload;
59.     PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
61. } DRIVER_OBJECT;
62. typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT; 

UNICODE_STRING:

1. typedef struct _UNICODE_STRING {
2.     USHORT Length;
3.     USHORT MaximumLength;
4. #ifdef MIDL_PASS
5.     [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT * Buffer;
6. #else // MIDL_PASS
7.     __field_bcount_part(MaximumLength, Length) PWCH   Buffer;
8. #endif // MIDL_PASS
9. } UNICODE_STRING;
10. typedef UNICODE_STRING *PUNICODE_STRING;
11. typedef const UNICODE_STRING *PCUNICODE_STRING;
12. #define UNICODE_NULL ((WCHAR)0) // winnt