驱动和应用层的三种通信方式

比眉伴天荒 2022-08-18 15:11 222阅读 0赞

驱动程序和客户应用程序经常需要进行数据交换，但我们知道驱动程序和客户应用程序可能不在同一个地址空间，因此操作系统必须解决两者之间的数据交换。  
驱动层和应用层通信，主要是靠DeviceIoControl函数，下面是该函数的原型：  
BOOL DeviceIoControl (   
HANDLE hDevice, // 设备句柄   
DWORD dwIoControlCode, // IOCTL请求操作代码   
LPVOID lpInBuffer, // 输入缓冲区地址   
DWORD nInBufferSize, // 输入缓冲区大小   
LPVOID lpOutBuffer, // 输出缓冲区地址   
DWORD nOutBufferSize, // 输出缓冲区大小   
LPDWORD lpBytesReturned, // 存放返回字节数的指针   
LPOVERLAPPED lpOverlapped // 用于同步操作的Overlapped结构体指针   
);  
  
dwIoControlCode  
要进行操作的控制码。驱动程序可以通过CTL\_CODE宏来组合定义一个控制码，并在IRP\_MJ\_DEVICE\_CONTROL的实现中进行控制码的操作。在驱动层，irpStack->Parameters.DeviceIoControl.IoControlCode表示了这个控制码。  
  
IOCTL请求有四种缓冲策略，下面一一介绍。   
1、 输入输出缓冲I/O(METHOD\_BUFFERED)  
2、 直接输入缓冲输出I/O(METHOD\_IN\_DIRECT)  
3、 缓冲输入直接输出I/O(METHOD\_OUT\_DIRECT)  
4、 上面三种方法都不是(METHOD\_NEITHER)  
（因为METHOD\_IN\_DIRECT 和 METHOD\_OUT\_DIRECT 是类似的，所以也可以说是三种。）  
为了对这些类型更详细的描述，请看msdn上的解释，我抄录如下：  
  
"缓冲"方法 (METHOD\_BUFFERED)  
备注：在下面的讨论中，"输入"表示数据从用户模式的应用程序到驱动程序，"输出"表示数据从驱动程序到应用程序。  
  
对于读取请求，I/O 管理器分配一个与用户模式的缓冲区大小相同的系统缓冲区。IRP 中的 SystemBuffer 字段包含系统地址。UserBuffer 字段包含初始的用户缓冲区地址。当完成请求时，I/O 管理器将驱动程序已经提供的数据从系统缓冲区复制到用户缓冲区。对于写入请求，会分配一个系统缓冲区并将 SystemBuffer 设置为地址。用户缓冲区的内容会被复制到系统缓冲区，但是不设置 UserBuffer。对于 IOCTL 请求，会分配一个容量大小足以包含输入缓冲区或输出缓冲区的系统缓冲区，并将 SystemBuffer 设置为分配的缓冲区地址。输入缓冲区中的数据复制到系统缓冲区。UserBuffer 字段设置为用户模式输出缓冲区地址。内核模式驱动程序应当只使用系统缓冲区，且不应使用 UserBuffer 中存储的地址。  
  
对于 IOCTL，驱动程序应当从系统缓冲区获取输入并将输出写入到系统缓冲区。当完成请求时，I/O 系统将输出数据从系统缓冲区复制到用户缓冲区。  
  
"直接"方法 (METHOD\_IN/OUT\_DIRECT)  
对于读取和写入请求，用户模式缓冲区会被锁定，并且会创建一个内存描述符列表 (MDL)。MDL 地址会存储在 IRP 的 MdlAddress 字段中。SystemBuffer 和 UserBuffer 均没有任何含义。但是，驱动程序不应当更改这些字段的值。  
  
对于 IOCTL 请求，如果在 METHOD\_IN\_DIRECT 和 METHOD\_OUT\_DIRECT 中同时有一个输出缓冲区，则分配一个系统缓冲区（SystemBuffer 又有了地址）并将输入数据复制到其中。如果有一个输出缓冲区，且它被锁定，则会创建 MDL 并设置 MdlAddress。UserBuffer 字段没有任何含义。  
  
"两者都不"方法 (METHOD\_NEITHER)  
对于读取和写入请求，UserBuffer 字段被设置为指向初始的用户缓冲区。不执行任何其他操作。SystemAddress 和 MdlAddress 没有任何含义。对于 IOCTL 请求，I/O 管理器将 UserBuffer 设置为初始的用户输出缓冲区，而且，它将当前 I/O 栈位置的 Parameters.DeviceIoControl.Type3InputBuffer 设置为用户输入缓冲区。利用该 I/O 方法，由驱动程序来确定如何处理缓冲区：分配系统缓冲区或创建 MDL。  
  
通常，驱动程序在访问用户数据时不应当将 UserBuffer 字段用作地址，即使当用户缓冲区被锁定时也是如此。这是由于在调用驱动程序时，在系统中可能看不到调用用户的地址空间。（对于该规则的一个例外是，在最高层驱动程序将 IRP 向下传递到较低层的驱动程序之前，它可能需要使用 UserBuffer 来复制数据。）如果使用"直接"或"两者都不"方法，在创建 MDL 之后，驱动程序可以使用 MmGetSystemAddressForMdl 函数来获取有效的系统地址以访问用户缓冲区。  
  
  
在驱动层，依传输类型的不同，输入缓冲区的位置亦不同，见下表。  
传输类型 位置  
METHOD\_IN\_DIRECT irp->AssociatedIrp.SystemBuffer  
METHOD\_OUT\_DIRECT irp->AssociatedIrp.SystemBuffer  
METHOD\_BUFFERED irp->AssociatedIrp.SystemBuffer  
METHOD\_NEITHER irpStack->Parameters.DeviceIoControl.Type3InputBuffer  
  
在驱动层，依传输类型的不同，输出缓冲区的位置亦不同，见下表。  
传输类型 位置  
METHOD\_IN\_DIRECT irp->MdlAddress  
METHOD\_OUT\_DIRECT irp->MdlAddress  
METHOD\_BUFFERED irp->AssociatedIrp.SystemBuffer  
METHOD\_NEITHER irp->UserBuffer  
  
所以只要确定了传输方式后，就可以根据各自的位置来读取和写入数据，从而实现应用层和驱动的通信。

下面看驱动层对ioctl控制码的处理代码：

**\[cpp\]** [view plain][] [copy][view plain]

1.  //METHOD\_OUT\_DIREC方式
2.  NTSTATUS COMM\_DirectOutIo(PIRP Irp, PIO\_STACK\_LOCATION pIoStackIrp, **UINT** \*sizeofWrite) 
3.  \{ 
4.   NTSTATUS status = STATUS\_UNSUCCESSFUL; 
5.  **PVOID** pInputBuffer, pOutputBuffer; 
6.  **ULONG** outputLength, inputLength; 
7.  
8.   DbgPrint("COMM\_DirectOutIo\\r\\n"); 
9.  
10.  outputLength = pIoStackIrp->Parameters.DeviceIoControl.OutputBufferLength; 
11.  inputLength = pIoStackIrp->Parameters.DeviceIoControl.InputBufferLength; 
12.  pInputBuffer = Irp->AssociatedIrp.SystemBuffer; 
13.  pOutputBuffer = NULL; 
14. 
15. **if**(Irp->MdlAddress) 
16.  pOutputBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority); 
17. 
18. **if**(pInputBuffer && pOutputBuffer) 
19.  \{ 
20.  DbgPrint("COMM\_DirectOutIo UserModeMessage = '%s'", pInputBuffer); 
21.  RtlCopyMemory(pOutputBuffer, pInputBuffer, outputLength); 
22.  \*sizeofWrite = outputLength; 
23.  status = STATUS\_SUCCESS; 
24.  \} 
25. **return** status; 
26. \} 
27. 
28. // METHOD\_IN\_DIRECT
29. NTSTATUS COMM\_DirectInIo(PIRP Irp, PIO\_STACK\_LOCATION pIoStackIrp, **UINT** \*sizeofWrite) 
30. \{ 
31.  NTSTATUS status = STATUS\_UNSUCCESSFUL; 
32. **PVOID** pInputBuffer, pOutputBuffer; 
33. **ULONG** outputLength, inputLength; 
34. 
35.  DbgPrint("COMM\_DirectInIo\\r\\n"); 
36. 
37.  outputLength = pIoStackIrp->Parameters.DeviceIoControl.OutputBufferLength; 
38.  inputLength = pIoStackIrp->Parameters.DeviceIoControl.InputBufferLength; 
39.  pInputBuffer = Irp->AssociatedIrp.SystemBuffer; 
40.  pOutputBuffer = NULL; 
41. 
42. **if**(Irp->MdlAddress) 
43.  pOutputBuffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority); 
44. 
45. **if**(pInputBuffer && pOutputBuffer) 
46.  \{ 
47.  DbgPrint("COMM\_DirectInIo UserModeMessage = '%s'", pInputBuffer); 
48.  RtlCopyMemory(pOutputBuffer, pInputBuffer, outputLength); 
49.  \*sizeofWrite = outputLength; 
50.  status = STATUS\_SUCCESS; 
51.  \} 
52. **return** status; 
53. \} 
54. 
55. // METHOD\_BUFFERED
56. NTSTATUS COMM\_BufferedIo(PIRP Irp, PIO\_STACK\_LOCATION pIoStackIrp, **UINT** \*sizeofWrite) 
57. \{ 
58.  NTSTATUS status = STATUS\_UNSUCCESSFUL; 
59. **PVOID** pInputBuffer, pOutputBuffer; 
60. **ULONG** outputLength, inputLength; 
61. 
62.  DbgPrint("COMM\_BufferedIo\\r\\n"); 
63. 
64.  outputLength = pIoStackIrp->Parameters.DeviceIoControl.OutputBufferLength; 
65.  inputLength = pIoStackIrp->Parameters.DeviceIoControl.InputBufferLength; 
66.  pInputBuffer = Irp->AssociatedIrp.SystemBuffer; 
67.  pOutputBuffer = Irp->AssociatedIrp.SystemBuffer; 
68. 
69. **if**(pInputBuffer && pOutputBuffer) 
70.  \{ 
71.  DbgPrint("COMM\_BufferedIo UserModeMessage = '%s'", pInputBuffer); 
72.  RtlCopyMemory(pOutputBuffer, pInputBuffer, outputLength); 
73.  \*sizeofWrite = outputLength; 
74.  status = STATUS\_SUCCESS; 
75.  \} 
76. **return** status; 
77. \} 
78. 
79. // METHOD\_NEITHER
80. NTSTATUS COMM\_NeitherIo(PIRP Irp, PIO\_STACK\_LOCATION pIoStackIrp, **UINT** \*sizeofWrite) 
81. \{ 
82.  NTSTATUS status = STATUS\_UNSUCCESSFUL; 
83. **PVOID** pInputBuffer, pOutputBuffer; 
84. **ULONG** outputLength, inputLength; 
85. 
86.  DbgPrint("COMM\_NeitherIo\\r\\n"); 
87. 
88.  outputLength = pIoStackIrp->Parameters.DeviceIoControl.OutputBufferLength; 
89.  inputLength = pIoStackIrp->Parameters.DeviceIoControl.InputBufferLength; 
90.  pInputBuffer = pIoStackIrp->Parameters.DeviceIoControl.Type3InputBuffer; 
91.  pOutputBuffer = Irp->UserBuffer; 
92. 
93. **if**(pInputBuffer && pOutputBuffer) 
94.  \{ 
95.  DbgPrint("COMM\_NeitherIo UserModeMessage = '%s'", pInputBuffer); 
96.  RtlCopyMemory(pOutputBuffer, pInputBuffer, outputLength); 
97.  \*sizeofWrite = outputLength; 
98.  status = STATUS\_SUCCESS; 
99.  \} 
100. **return** status; 
101. \} 
102. 
103. 代码比较简单，都是取得输入的数据，然后把数据直接拷贝到输出，传输给应用层。 
104. 
105. 应用层的代码： 
106. procedure TfrmMain.Send\_Recv\_Data(AInData: String; var AOutData:String; 
107.  IoctlCode: **DWORD**); 
108. var 
109.  dwReturn: **DWORD**; 
110.  inData:array\[0..1023\] of **char**; 
111.  outData:array\[0..1023\] of **char**; 
112. begin 
113.  StrPCopy(inData, AInData); 
114. **if** m\_hCommDevice <> 0 then 
115.  begin 
116.  DeviceIoControl(m\_hCommDevice, IoctlCode, @inData, Length(inData), @outData, Length(outData), dwReturn, nil); 
117.  AOutData := StrPas(@outData); 
118.  end; 
119. end;

上面是进行发送和接受的过程。  
需要通信，只要如下做：

代码:

**\[cpp\]** [view plain][] [copy][view plain]

1.  procedure TfrmMain. btnDirect\_IN\_IOClick (Sender: TObject); 
2.  var 
3.   outData:String; 
4.  begin 
5.   Send\_Recv\_Data(Trim(edtDirect\_in\_in.Text), outData, IOCTL\_COMM\_DIRECT\_IN\_IO); 
6.   edtDirect\_in\_out.Text := outData; 
7.  end;

这是 direct\_in方式通信，其他通信方式类似，大家可以参考代码了，这里就不列举了，由于代码比较简单，我就不多说了，大家还是看代码吧，很好明白。最后，给个测试图：  
  
应用层：

![SouthEast][]

驱动层:

![SouthEast 1][]

[view plain]: http://blog.csdn.net/whatday/article/details/9717909#
[SouthEast]: /images/20220731/cff782120b2b48b8afed94fa3e59cea9.png
[SouthEast 1]: /images/20220731/6dbf6609d23447d1866e4ff7ba6a7ef2.png