typedef struct _DRIVER_OBJECT {
    CSHORT Type;　　　　　　　　　　//类型
    CSHORT Size;　　　　　　　　　　//当前结构体大小.内核中任何一个结构体都是这两个成员开头.

    //
    // The following links all of the devices created by a single driver
    // together on a list, and the Flags word provides an extensible flag
    // location for driver objects.
    //

    PDEVICE_OBJECT DeviceObject;//设备对象指针,存疑?  不是说数据关系是  设备表中有驱动对象吗. 怎么驱动对象表中有设备对象指针.???????
    ULONG Flags;　　　　　　　　　　//通讯协议以及方式.

    //
    // The following section describes where the driver is loaded.  The count
    // field is used to count the number of times the driver has had its
    // registered reinitialization routine invoked.
    //

    PVOID DriverStart;
    ULONG DriverSize;
    PVOID DriverSection;
    PDRIVER_EXTENSION DriverExtension;

    //
    // The driver name field is used by the error log thread
    // determine the name of the driver that an I/O request is/was bound.
    //

    UNICODE_STRING DriverName;

    //
    // The following section is for registry support.  Thise is a pointer
    // to the path to the hardware information in the registry
    //

    PUNICODE_STRING HardwareDatabase;

    //
    // The following section contains the optional pointer to an array of
    // alternate entry points to a driver for "fast I/O" support.  Fast I/O
    // is performed by invoking the driver routine directly with separate
    // parameters, rather than using the standard IRP call mechanism.  Note
    // that these functions may only be used for synchronous I/O, and when
    // the file is cached.
    //

    PFAST_IO_DISPATCH FastIoDispatch;

    //
    // The following section describes the entry points to this particular
    // driver.  Note that the major function dispatch table must be the last
    // field in the object so that it remains extensible.
    //

    PDRIVER_INITIALIZE DriverInit;
    PDRIVER_STARTIO DriverStartIo;
    PDRIVER_UNLOAD DriverUnload;
    PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];　　//提供的公共方法的接口. 创建.打开,关闭.读写控制... 里面存放的是函数指针.单用户操作设备的是否.则会调用这些回调函数指针.

} DRIVER_OBJECT;
typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT; 

typedef struct DECLSPEC_ALIGN(MEMORY_ALLOCATION_ALIGNMENT) _DEVICE_OBJECT {
    CSHORT Type;
    USHORT Size;
    LONG ReferenceCount;
    struct _DRIVER_OBJECT *DriverObject;　　//驱动对象做外键存储
    struct _DEVICE_OBJECT *NextDevice;      //链表.
    struct _DEVICE_OBJECT *AttachedDevice;
    struct _IRP *CurrentIrp;
    PIO_TIMER Timer;
    ULONG Flags;                                // See above:  DO_...
    ULONG Characteristics;                      // See ntioapi:  FILE_...
    __volatile PVPB Vpb;
    PVOID DeviceExtension;
    DEVICE_TYPE DeviceType;
    CCHAR StackSize;
    union {
        LIST_ENTRY ListEntry;
        WAIT_CONTEXT_BLOCK Wcb;
    } Queue;
    ULONG AlignmentRequirement;
    KDEVICE_QUEUE DeviceQueue;
    KDPC Dpc;

    //
    //  The following field is for exclusive use by the filesystem to keep
    //  track of the number of Fsp threads currently using the device
    //

    ULONG ActiveThreadCount;
    PSECURITY_DESCRIPTOR SecurityDescriptor;
    KEVENT DeviceLock;

    USHORT SectorSize;
    USHORT Spare1;

    struct _DEVOBJ_EXTENSION  *DeviceObjectExtension;
    PVOID  Reserved;

} DEVICE_OBJECT;

typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT; 

  pDriverObject->MajorFunction[IRP_MJ_CREATE] = 创建的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_CLOSE] =  关闭的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_READ] =   读取的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_WRITE] =  写入的回调函数指针;
  pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = 控制的回调函数指针;

NTSTATUS 自定义的函数名(__in struct _DEVICE_OBJECT *DeviceObject,
                      __inout struct _IRP *Irp)
{
 
  .........
  return STATUS_SUCCESS;
}

NTSTATUS 
  IoCreateDevice(
    IN PDRIVER_OBJECT  DriverObject,　　　　　　//调用者驱动对象的指针.一般是驱动入口的参数
    IN ULONG  DeviceExtensionSize,         　　//设备扩展大小
    IN PUNICODE_STRING  DeviceName  OPTIONAL, //设备对象名称,注意不是我们ring3下的路径.
    IN DEVICE_TYPE  DeviceType,　　　　　　　　　//我们的设备类型
    IN ULONG  DeviceCharacteristics,　　　　　　//驱动的附加信息.
    IN BOOLEAN  Exclusive,　　　　　　　　　　　　//创建的设备是否其余的可以使用,是否独占
    OUT PDEVICE_OBJECT  *DeviceObject　　      //传出参数,设备的信息.
    );

status = IoCreateDevice(pDriverObject, 
                          0, 
                          &ustrDeviceName,          //设备路径
                          FILE_DEVICE_UNKNOWN,//设备类型设置为不知道
                          FILE_DEVICE_SECURE_OPEN, 
                          FALSE,                           //是否独占
                          &pDevObj);
  if (status != STATUS_SUCCESS)
  {
    return status;
  }        

pDevObj->Flags |= DO_BUFFERED_IO; //指定通讯方式,为缓冲区

 status = IoCreateSymbolicLink(&g_ustrSymbolName, &ustrDeviceName);
  if (status != STATUS_SUCCESS)
  {
    //删除设备
    IoDeleteDevice(pDevObj);
    return status;
  }

RtlInitUnicodeString(&g_ustrSymbolName, L"\\DosDevices\\xxxx名字");

HANDLE hFile = CreateFile("\\\\?\\符号连接名称", 
             GENERIC_WRITE | GENERIC_READ, 
             0, 
             NULL, 
             OPEN_EXISTING, 
             FILE_ATTRIBUTE_NORMAL, 
             NULL);

char szBuf[10];
ReadFile(hFile, szBuff, sizeof(szBuff), &dwBytes, NULL)

typedef struct _IRP {
  .　　　　　　　　　　　　//省略了两个成员,这两个成员一个是类型.一个是大小.
  .
  PMDL  MdlAddress;
  ULONG  Flags;
  union {
    struct _IRP  *MasterIrp;
    .
    .
    PVOID  SystemBuffer;//ring3下的缓冲区.操作系统会填写.我们给里面填写什么内容.那么ring3就读取到什么.
  } AssociatedIrp;
  .
  .
  IO_STATUS_BLOCK  IoStatus;
  KPROCESSOR_MODE  RequestorMode;
  BOOLEAN PendingReturned;
  .
  .
  BOOLEAN  Cancel;
  KIRQL  CancelIrql;
  .
  .
  PDRIVER_CANCEL  CancelRoutine;
  PVOID UserBuffer;
  union {
    struct {
    .
    .
    union {
      KDEVICE_QUEUE_ENTRY DeviceQueueEntry;
      struct {
        PVOID  DriverContext[4];
      };
    };
    .
    .
    PETHREAD  Thread;
    .
    .
    LIST_ENTRY  ListEntry;
    .
    .
    } Overlay;
  .
  .
  } Tail;
} IRP, *PIRP;

IoGetCurrentIrpStackLocation(pIrp)

 //获取当前irp堆栈
  PIO_STACK_LOCATION pIrpStack = NULL;
  PVOID lpBuff = NULL;
  ULONG Length = 0;

  //PsGetCurrentThreadId();
  KdBreakPoint();

  __try
  {
    pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
    //check

    lpBuff = pIrp->AssociatedIrp.SystemBuffer;
    Length = pIrpStack->Parameters.Read.Length;
    
    KdPrint(("[FirstWDK] DispatchRead\n"));
    
    RtlStringCbCopyA(lpBuff, Length, "Hello World!");
    //check


    pIrp->IoStatus.Status = STATUS_SUCCESS;
    pIrp->IoStatus.Information = 6;
    
    //完成Irp请求
    IoCompleteRequest(pIrp, IO_NO_INCREMENT);
    //check
  }
  __except(1)
  {
  }


  return STATUS_SUCCESS;