Драйвер виртуального диска

Здраствуйте.
Вот решил написать чтото в стиле Dekart Private Disk, True Crypt, Safe House и тд.
Для реализации задачи нужно сделать небольшой драйвер который создаст диск и будет принимать запросы к диску перенаправляя их утилите написаной на Делфи2007 которая уже в реальном пользовательском режиме будет их (запросы) обрабатывать и возвращать результат.
Драйвера раньше вообще не писал, 3 недели перечитываю Солдатова
Разобрался с драйвером. Небольшая утилитка на Delphi2007 связывается и обменивается IRP. За логикой решил делать так... когда приходят IRP запросы драйверу он помещает их в очередь и возвращает STATUS_PENDING. После чего утилита обращаясь к драйверу, скажем, по IOCTL_DISK_GET_IRP (своя функция) забирает из очереди по одному запросу которые накопились. Но... при обращении утилиты к функции CreateFile:
а) в драйвере вообще не срабатывает событие IRP_MJ_CREATE, хотя в солдатове чёрным по белому сказано "CreateFile=IRP_MJ_CREATE". Точно так же никогда не срабатывает IRP_MJ_CLOSE. В то же время связь с драйвером устанавливается успешно.
б) автоматом формируется несколько IRP пакетов от имени утилиты драйверу (не мной) в момент исполнения CreateFile. Одна из них IOCTL_DISK_GET_DRIVE_GEOMETRY. Вообще не доганяю причём она тут. Это не критично конечно но драйвер то не отличает кто именно ему шлёт запрос и отправляет его в очередь возвращая STATUS_PENDING. Есстественно утилита подвисает так как она ведь и должна ответить на него.

Может кто вкурсе что я делаю не так ? Я себе представлял что CreateFile посылает единственный запрос IRP_MJ_CREATE...

 

После регистрации устройства, user mode прога может сделать CreateFile(), который в ядре превращается в IRP_MJ_CREATE. После открытия устройства прога делает ReadFile(), WriteFile() или DeviceIOControl().

Все эти вызовы становятся IRP в ядре. Теория такая - в ядре всё асинхронно - приходит IRP и ты его обслуживаешь сразу или запихиваешь в Cancel Safe Queue и помечаешь pending. В проге ты можешь делать blocking read/write или overlapped IO.

По поводу IRP_MJ_CREATE - выложи код - у тебя где-то косяк.

 

Код (Text):

1. UNICODE_STRING  symLinkName;
2. UNICODE_STRING        device_name;
3. UCHAR                 drive_letter;
4. LARGE_INTEGER         drive_size;
5.  
6. #pragma code_seg("INIT")
7.  
8. NTSTATUS
9. DriverEntry (
10.     IN PDRIVER_OBJECT   DriverObject,
11.     IN PUNICODE_STRING  RegistryPath
12.     )
13. {
14.     NTSTATUS                    status;
15.     PDEVICE_EXTENSION             device_extension;
16.     PDEVICE_OBJECT              device_object;
17.  
18.  
19.     RtlInitUnicodeString(&device_name, DEVICE_DEVICE_NAME);
20.  
21.     status = IoCreateDevice(
22.         DriverObject,
23.         sizeof(DEVICE_EXTENSION),
24.         &device_name,
25.         FILE_DEVICE_DISK,
26.         0,
27.         FALSE,
28.         &device_object
29.         );
30.  
31.     if (!NT_SUCCESS(status))
32.     {
33.         KdPrint(("Error creating device \n"));
34.         return status;
35.     }
36.  
37.     device_object->Flags |= DO_DIRECT_IO;
38.     device_extension = (PDEVICE_EXTENSION) device_object->DeviceExtension;
39.     device_extension->list_cnt = 0;
40.     InitializeListHead(&device_extension->list_head);
41.     KeInitializeSpinLock(&device_extension->list_lock);
42.     KdPrint(("Device created \n"));
43.  
44.  
45.     /* *** SYMBOLIC LINK INITIALIZATION *** */
46.     drive_letter = 0;
47.     drive_size.QuadPart = 0;
48.     RtlInitUnicodeString(&symLinkName, DEVICE_SYMLINK_NAME);
49.     status = IoCreateSymbolicLink(&symLinkName,&device_name);
50.       if (!NT_SUCCESS(status))
51.       {
52.         KdPrint(("Error creating SymbolicLink \n"));
53.         IoDeleteDevice(device_object);
54.         return status;
55.       }
56.       KdPrint(("SymbolicLink created \n"));
57.  
58.     DriverObject->MajorFunction[IRP_MJ_CREATE]         = FileDiskCreateClose;
59.     DriverObject->MajorFunction[IRP_MJ_CLOSE]          = FileDiskCreateClose;
60.     DriverObject->MajorFunction[IRP_MJ_READ]           = FileDiskReadWrite;
61.     DriverObject->MajorFunction[IRP_MJ_WRITE]          = FileDiskReadWrite;
62.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = FileDiskDeviceControl;
63.  
64.     DriverObject->DriverUnload = FileDiskUnload;
65.  
66.     return STATUS_SUCCESS;
67. }
68.  
69. #pragma code_seg("PAGE")
70.  
71. VOID
72. FileDiskUnload (
73.     IN PDRIVER_OBJECT DriverObject
74.     )
75. {
76.     PDEVICE_OBJECT          device_object;
77.     PDEVICE_EXTENSION       device_extension;
78.  
79.     PAGED_CODE();
80.  
81.     device_object = DriverObject->DeviceObject;
82.     device_extension = (PDEVICE_EXTENSION) device_object->DeviceExtension;
83.     if (drive_letter != 0)
84.         {
85.             DriveLetterDelete();
86.         }
87.     IoDeleteSymbolicLink(&symLinkName);
88.       IoDeleteDevice(device_object);
89. }
90.  
91. NTSTATUS
92. FileDiskCreateClose (
93.     IN PDEVICE_OBJECT   DeviceObject,
94.     IN PIRP             Irp
95.     )
96. {
97.     KdPrint(("Create/Close \n"));
98.  
99.     Irp->IoStatus.Status = STATUS_SUCCESS;
100.     Irp->IoStatus.Information = FILE_OPENED;
101.  
102.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
103.  
104.     return STATUS_SUCCESS;
105. }
106.  
107. #pragma code_seg()
108.  
109. NTSTATUS
110. FileDiskReadWrite (
111.     IN PDEVICE_OBJECT   DeviceObject,
112.     IN PIRP             Irp
113.     )
114. {
115.     NTSTATUS              status;
116.    
117.   KdPrint(("FileDisk: Read/Write \n"));
118. //  status = IRPAddToQue(DeviceObject,Irp);
119.   status = STATUS_INVALID_DEVICE_REQUEST;
120.   if (status != STATUS_PENDING)
121.     {
122.       Irp->IoStatus.Status = status;
123.       IoCompleteRequest(Irp, IO_NO_INCREMENT);
124.     }
125.   return status;
126. }

По поводу того что всё превращается в IRP я знаю. Но как тогда выходит данный результат?
Вот код который исполняется в утилите при нажатии кнопки:

Код (Text):

1. Var Handle : Integer;
2. begin
3.   Handle:=CreateFile(
4.     PChar('\\.\\symFileDisk'),
5.     GENERIC_READ or GENERIC_WRITE,
6.     FILE_SHARE_READ or FILE_SHARE_WRITE,
7.     nil,
8.     Open_Existing,
9.     0,
10.     0);
11.   FileClose(Handle);
12. end;

И всё, больше абсолютно ничего... вот что в этот момент показывает Compuware Monitor под которым запущен драйвер:

Код (Text):

1.     Monitor             Driver started successfully.
2. 71.219      Default         Device created
3. 71.219      Default         SymbolicLink created
4. 78.219      Default         FileDisk: IoControlCode 0x70000
5. 78.219      Default         FileDisk: Read/Write
6. 78.219      Default         FileDisk: IoControlCode 0x70000
7. 78.219      Default         FileDisk: Read/Write
8. 78.219      Default         FileDisk: IoControlCode 0x74804
9. 78.219      Default         FileDisk: IoControlCode 0x70024
10. 78.219      Default         FileDisk: IoControlCode 0x70000
11. 78.219      Default         FileDisk: IoControlCode 0x7405c
12. 78.219      Default         FileDisk: IoControlCode 0x74804

 

Только что попытался изменить тип устройства вместо FILE_DEVICE_DISK поставил FILE_DEVICE_UNKNOWN. При CreateFile() и CloseFile() отрабатывает как и нужно именно IRP_MJ_CREATE и IRP_MJ_CLOSE. Но мне то нужен именно диск... Непонятно както, ведь даже если указан FILE_DEVICE_DISK то я всёравно обращаюсь к нему как к файлу и не запрашиваю никаких IOCTL_DISK_GET_DRIVE_GEOMETRY и тп. :/

 

xneo, IoCreateDevice(FILE_DEVICE_UNKNOWN) даёт тебе устройство для внутреннего использования. То есть, ты сам решаешь что и как ты будешь принимать и посылать. IoCreateDevice(FILE_DEVICE_DISK) регистрирует диск и ты обязан реализовать всё что требует MS спецификация, а иначе это не будет работать как диск.

 

Это я понимаю.
Но почему CreateFile() генерирует целую кучу запросов?

 

С другой стороны если это неизбежно, я могу создать в драйвере 2 устройства ? Первое-диск, второе-unknown... и посылая запросы второму забирать IRP из очереди первого? Просто я себе смутно представляю как ещё можно просто передать данные от драйвера приложению и обратно.

 

Енто, обработать все IRP запросы тебе всё равно придётся, а вот про смешивание... Обычно для этого регистрируется второе устройство.

 

Ребят, посмотрите пожалуйста... За стиль кода сильно не бейте
Регистрируется 2 устройства... 1-FILE_DEVICE_DISK 2-FILE_DEVICE_UNKNOWN
Первое принимает запросы и сохраняет в очередь возвращая STATUS_PENDING, второе используется для связи с утилитой которая по IOCTL_DISK_GET_IRP забирает запросы из очереди и по IOCTL_DISK_SET_IRP отвечает на них.
Забирает пару запросов, отвечает на них... а потом BSOD.
Иногда кричит в BSOD про страничную память.

Код (Text):

1. #include <ntddk.h>
2. #include <ntdddisk.h>
3.  
4. #define     DEVICE_DISK_NAME            L"\\Device\\eStorageDisk"
5. #define     DEVICE_CONTROL_NAME     L"\\Device\\eStorageCtrl"
6. #define     DEVICE_SYMLINK_NAME     L"\\??\\eStorageCtrlSym"
7.  
8. #define     IOCTL_DISK_ASSIGN_LETTER CTL_CODE(FILE_DEVICE_DISK, 0x802, METHOD_BUFFERED, FILE_ANY_ACCESS)
9. #define   IOCTL_DISK_GET_IRP       CTL_CODE(FILE_DEVICE_DISK, 0x803, METHOD_BUFFERED, FILE_ANY_ACCESS)
10. #define   IOCTL_DISK_SET_IRP       CTL_CODE(FILE_DEVICE_DISK, 0x804, METHOD_BUFFERED, FILE_ANY_ACCESS)
11.  
12. const     MaxListQue         = 32;
13. const     IrpBufferSize      = 8192;
14.  
15. const     Dev_Type_Storage   = 1;
16. const     Dev_Type_Control   = 2;
17.  
18. // ***************** S T R U C T U R E S **************************
19.  
20. typedef struct _DEVICE_EXTENSION {
21.     int                 device_type;
22. } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
23.  
24. typedef struct _LAST_REQUEST {
25.   BOOLEAN             empty;
26.   PIRP                irp;
27.   PLIST_ENTRY         request;
28.   PIO_STACK_LOCATION  stack;
29. } LAST_REQUEST, *PLAST_REQUEST;
30.  
31. #pragma pack (1)
32.  
33. typedef struct _IRP_GET_ITEM {
34.   UCHAR               major_func;
35.   UCHAR               minor_func;
36.   ULONG               iocode;
37.   LONGLONG            rw_data_offset;
38.   ULONG               rw_data_length;
39.   UCHAR               buffer[8192];
40. } IRP_GET_ITEM, *PIRP_GET_ITEM;
41.  
42. typedef struct _IRP_SET_ITEM {
43.   ULONG               status;
44.   ULONG               data_length;
45.   UCHAR               buffer[8192];
46. } IRP_SET_ITEM, *PIRP_SET_ITEM;
47.  
48. #pragma pack (4)
49.  
50. // ********************* V A R I A B L E S **************************
51.  
52. UNICODE_STRING              symLinkName;
53. UNICODE_STRING        device_stor_name;
54. UNICODE_STRING        device_ctrl_name;
55. UCHAR                 drive_letter;
56. LIST_ENTRY            list_head;
57. KSPIN_LOCK            list_lock;
58. LAST_REQUEST          last_request;
59. int                   list_cnt;
60. int                   connects_cnt;
61.  
62. NTSTATUS
63. DriverEntry (
64.     IN PDRIVER_OBJECT   DriverObject,
65.     IN PUNICODE_STRING  RegistryPath
66. );
67.  
68. VOID
69. DriverUnload (
70.     IN PDRIVER_OBJECT   DriverObject
71. );
72.  
73. NTSTATUS
74. OnCreate (
75.     IN PDEVICE_OBJECT   DeviceObject,
76.     IN PIRP             Irp
77. );
78.  
79. NTSTATUS
80. OnClose (
81.     IN PDEVICE_OBJECT   DeviceObject,
82.     IN PIRP             Irp
83. );
84.  
85. NTSTATUS
86. OnReadWrite (
87.     IN PDEVICE_OBJECT   DeviceObject,
88.     IN PIRP             Irp
89. );
90.  
91. NTSTATUS
92. OnDeviceControl (
93.     IN PDEVICE_OBJECT   DeviceObject,
94.     IN PIRP             Irp
95. );
96.  
97. NTSTATUS
98. IRPAddToQue (
99.     IN PDEVICE_OBJECT   DeviceObject,
100.     IN PIRP             Irp
101. );
102.    
103. void DriveLetterDelete();
104.  
105. #pragma code_seg("INIT")
106.  
107. NTSTATUS
108. DriverEntry (
109.     IN PDRIVER_OBJECT   DriverObject,
110.     IN PUNICODE_STRING  RegistryPath
111.     )
112. {
113.     NTSTATUS                    status;
114.     PDEVICE_OBJECT              device_stor;
115.     PDEVICE_OBJECT              device_ctrl;
116.     PDEVICE_EXTENSION               device_extension;
117.  
118.     RtlInitUnicodeString(&device_stor_name, DEVICE_DISK_NAME);
119.     status = IoCreateDevice(
120.         DriverObject, sizeof(DEVICE_EXTENSION), &device_stor_name,
121.         FILE_DEVICE_DISK, 0, FALSE, &device_stor);
122.     if (!NT_SUCCESS(status))
123.     {
124.         KdPrint(("Error creating device \n"));
125.         IoDeleteDevice(device_stor);
126.         return status;
127.     }
128.      
129.     RtlInitUnicodeString(&device_ctrl_name, DEVICE_CONTROL_NAME);
130.     status = IoCreateDevice(
131.         DriverObject, sizeof(DEVICE_EXTENSION), &device_ctrl_name,
132.         FILE_DEVICE_UNKNOWN, 0, FALSE, &device_ctrl);
133.     if (!NT_SUCCESS(status))
134.     {
135.         KdPrint(("Error creating device \n"));
136.         IoDeleteDevice(device_stor);
137.         IoDeleteDevice(device_ctrl);
138.         return status;
139.     }
140.  
141.     device_stor->Flags |= DO_BUFFERED_IO;
142.     device_ctrl->Flags |= DO_BUFFERED_IO;
143.     device_extension = (PDEVICE_EXTENSION) device_stor->DeviceExtension;
144.     device_extension->device_type = Dev_Type_Storage;
145.     device_extension = (PDEVICE_EXTENSION) device_ctrl->DeviceExtension;
146.     device_extension->device_type = Dev_Type_Control;
147.    
148.     list_cnt = 0;
149.     connects_cnt = 0;
150.     last_request.empty = TRUE;
151.     InitializeListHead(&list_head);
152.     KeInitializeSpinLock(&list_lock);
153.     KdPrint(("Device created \n"));
154.  
155.     /* *** SYMBOLIC LINK INITIALIZATION *** */
156.     drive_letter = 0;
157.     RtlInitUnicodeString(&symLinkName, DEVICE_SYMLINK_NAME);
158.     status = IoCreateSymbolicLink(&symLinkName,&device_ctrl_name);
159.       if (!NT_SUCCESS(status))
160.       {
161.         KdPrint(("Error creating SymbolicLink \n"));
162.         IoDeleteDevice(device_stor);
163.         IoDeleteDevice(device_ctrl);
164.         return status;
165.       }
166.       KdPrint(("SymbolicLink created \n"));
167.  
168.     DriverObject->MajorFunction[IRP_MJ_CREATE]         = OnCreate;
169.     DriverObject->MajorFunction[IRP_MJ_CLOSE]          = OnClose;
170.     DriverObject->MajorFunction[IRP_MJ_READ]           = OnReadWrite;
171.     DriverObject->MajorFunction[IRP_MJ_WRITE]          = OnReadWrite;
172.     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = OnDeviceControl;
173.  
174.     DriverObject->DriverUnload = DriverUnload;
175.  
176.     return STATUS_SUCCESS;
177. }
178.  
179. #pragma code_seg("PAGE")
180.  
181. VOID
182. DriverUnload (
183.     IN PDRIVER_OBJECT DriverObject
184.     )
185. {
186.     PDEVICE_OBJECT          device_object, next_device_object;
187.  
188.     PAGED_CODE();
189.  
190.     KdPrint(("Unload \n"));
191.  
192.     if (drive_letter != 0)
193.         {
194.             DriveLetterDelete();
195.         }
196.  
197.     KdPrint(("Delete link \n"));
198.     IoDeleteSymbolicLink(&symLinkName);
199.  
200.     device_object = DriverObject->DeviceObject;
201.     while (device_object)
202.       {
203.         KdPrint(("Delete device \n"));
204.         next_device_object = device_object->NextDevice;
205.         IoDeleteDevice(device_object);
206.         device_object = next_device_object;
207.       }
208. }
209.  
210. NTSTATUS
211. OnCreate (
212.     IN PDEVICE_OBJECT   DeviceObject,
213.     IN PIRP             Irp
214.     )
215. {
216.     PDEVICE_EXTENSION   device_extension;
217.  
218.     device_extension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
219.     KdPrint(("Create %#x \n",device_extension->device_type));
220.    
221.     if (device_extension->device_type == Dev_Type_Control)
222.         {
223.           connects_cnt++;
224.         }
225.  
226.     Irp->IoStatus.Status = STATUS_SUCCESS;
227.     Irp->IoStatus.Information = FILE_OPENED;
228.  
229.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
230.  
231.     return STATUS_SUCCESS;
232. }
233.  
234. NTSTATUS
235. OnClose (
236.     IN PDEVICE_OBJECT   DeviceObject,
237.     IN PIRP             Irp
238.     )
239. {
240.     PDEVICE_EXTENSION   device_extension;
241.  
242.     device_extension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
243.     KdPrint(("Close %#x \n",device_extension->device_type));
244.  
245.     if (device_extension->device_type == Dev_Type_Control)
246.         {
247.           connects_cnt--;
248.         }
249.        
250.     Irp->IoStatus.Status = STATUS_SUCCESS;
251.     Irp->IoStatus.Information = FILE_OPENED;
252.  
253.     IoCompleteRequest(Irp, IO_NO_INCREMENT);
254.  
255.     return STATUS_SUCCESS;
256. }
257.  
258. #pragma code_seg()
259.  
260. NTSTATUS
261. OnReadWrite (
262.     IN PDEVICE_OBJECT   DeviceObject,
263.     IN PIRP             Irp
264.     )
265. {
266.     NTSTATUS              status;
267.    
268.   KdPrint(("FileDisk: Read/Write \n"));
269.   status = IRPAddToQue(DeviceObject,Irp);
270.   if (status != STATUS_PENDING)
271.     {
272.       Irp->IoStatus.Status = status;
273.       IoCompleteRequest(Irp, IO_NO_INCREMENT);
274.     }
275.   return status;
276. }
277.  
278. NTSTATUS
279. OnDeviceControl (
280.     IN PDEVICE_OBJECT   DeviceObject,
281.     IN PIRP             Irp
282.     )
283. {
284.     PDEVICE_EXTENSION   device_extension;
285.     PIO_STACK_LOCATION  io_stack;
286.     NTSTATUS            status;
287.     UNICODE_STRING      ustr;
288.     ANSI_STRING         astr;  
289.     PIRP_GET_ITEM       airp_item;
290.     PIRP_SET_ITEM       sirp_item;
291.     ULONG               asize;
292.     ULONG               dsize;
293.     PUCHAR              buffer;
294.     char                dl[7] = "\\??\\ : ";
295.  
296.     device_extension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
297.  
298.     io_stack = IoGetCurrentIrpStackLocation(Irp);
299.  
300.         status = STATUS_INVALID_DEVICE_REQUEST;
301.     Irp->IoStatus.Information = 0;
302.    
303.     switch (io_stack->Parameters.DeviceIoControl.IoControlCode) {
304.         case IOCTL_DISK_ASSIGN_LETTER:
305.             {
306.           status = STATUS_INVALID_PARAMETER;
307.                 if (io_stack->Parameters.DeviceIoControl.InputBufferLength == 1)
308.                     {
309.               dl[6] = 0;
310.               RtlCopyMemory(&dl[4],Irp->AssociatedIrp.SystemBuffer,1);
311.               if ((drive_letter == 0)&&(dl[4] != 0))
312.                 {
313.                     KdPrint(("FileDisk: ASSIGN LETTER \n"));
314.                   RtlInitAnsiString(&astr,(LPCSTR) &dl);
315.                   RtlAnsiStringToUnicodeString(&ustr,&astr, TRUE);
316.                   KdPrint(((PCHAR) &dl,'\n'));
317.                   if (NT_SUCCESS(IoCreateSymbolicLink(&ustr, &device_stor_name)))
318.                     {
319.                         drive_letter = dl[4];
320.                         status = STATUS_SUCCESS;
321.                     }
322.                   RtlFreeUnicodeString(&ustr);                  
323.                 }  
324.               if ((drive_letter != 0)&&(dl[4] == 0))
325.                 {
326.                     KdPrint(("FileDisk: DELETE LETTER \n"));
327.                   DriveLetterDelete();
328.                   status = STATUS_SUCCESS;
329.                 }
330.                     }
331.                 break;
332.         }
333.       case IOCTL_DISK_GET_IRP:
334.         {
335.           if (last_request.empty)
336.             {
337.               if (last_request.request = ExInterlockedRemoveHeadList(&list_head,&list_lock))
338.                 {
339.                     last_request.irp = CONTAINING_RECORD(last_request.request, IRP, Tail.Overlay.ListEntry);
340.                   last_request.stack = IoGetCurrentIrpStackLocation(last_request.irp);
341.                   last_request.empty = FALSE;
342.                 }
343.             }
344.           if (last_request.empty == FALSE)
345.             {
346.               airp_item = Irp->AssociatedIrp.SystemBuffer;
347.               airp_item->major_func = last_request.stack->MajorFunction;
348.               airp_item->minor_func = last_request.stack->MinorFunction;
349.               airp_item->iocode = last_request.stack->Parameters.DeviceIoControl.IoControlCode;
350.               airp_item->rw_data_offset = last_request.stack->Parameters.Read.ByteOffset.QuadPart;
351.               airp_item->rw_data_length = last_request.stack->Parameters.Read.Length;
352.  
353.                 KdPrint(("Get Irp IOCode=%#x \n",last_request.stack->Parameters.DeviceIoControl.IoControlCode));
354.              
355.               asize = sizeof(IRP_GET_ITEM) - IrpBufferSize;
356.               dsize = 0;
357.               if (last_request.stack->MajorFunction == IRP_MJ_WRITE)
358.                 {
359.                     dsize = last_request.stack->Parameters.Write.Length;
360.                     asize = asize + dsize;
361.                 }
362.  
363.                 if (io_stack->Parameters.DeviceIoControl.OutputBufferLength < asize)
364.                     {
365.                         status = STATUS_BUFFER_TOO_SMALL;
366.                     }
367.                     else
368.                     {
369.                         if (dsize > 0)
370.                             {
371. //                              RtlCopyMemory(&airp_item->buffer,last_request.irp->AssociatedIrp.SystemBuffer,dsize);
372.                             }
373.                         Irp->IoStatus.Information = asize;
374.                         status = STATUS_SUCCESS;
375.                     }
376.             }
377.             else
378.             {
379.                 status = STATUS_SUCCESS;               
380.             }          
381.             break;
382.         }
383.       case IOCTL_DISK_SET_IRP:
384.         {
385.           if (io_stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(IRP_SET_ITEM) - IrpBufferSize)
386.             {
387.               KdPrint(("Buffer too small \n"));
388.               status = STATUS_BUFFER_TOO_SMALL;
389.               break;
390.             }
391.           sirp_item = Irp->AssociatedIrp.SystemBuffer;
392.           if (sirp_item->data_length+sizeof(IRP_SET_ITEM)-IrpBufferSize >
393.               io_stack->Parameters.DeviceIoControl.InputBufferLength)
394.             {
395.                 KdPrint(("Wrong Size \n"));
396.                 status = STATUS_INVALID_PARAMETER;
397.               break;               
398.             }
399.           if (last_request.empty == FALSE)
400.             {
401.               KdPrint(("Set Irp Status=%#x IOCode=%#x \n",sirp_item->status,sirp_item->data_length));
402.  
403.                     last_request.irp->IoStatus.Status = sirp_item->status;
404.                     last_request.irp->IoStatus.Information = sirp_item->data_length;
405.                     if (sirp_item->data_length>0)
406.                         {
407.                             KdPrint(("Assign buffer \n"));
408.                   RtlCopyMemory(last_request.irp->AssociatedIrp.SystemBuffer,
409.                                     &sirp_item->buffer,
410.                                     sirp_item->data_length);
411.                         }
412.                     IoCompleteRequest(last_request.irp, IO_NO_INCREMENT);
413.                     last_request.empty = TRUE;
414.                     list_cnt--;
415.                     status = STATUS_SUCCESS;
416.             }
417.             else
418.             {
419.                 KdPrint(("Que is empty \n"));
420.                 status = STATUS_INVALID_PARAMETER;
421.             }
422.             break;
423.         }      
424.      
425.       case IOCTL_DISK_CHECK_VERIFY:
426.       case IOCTL_STORAGE_CHECK_VERIFY:
427.       case IOCTL_STORAGE_CHECK_VERIFY2:
428.       case IOCTL_DISK_GET_DRIVE_GEOMETRY:
429.       case IOCTL_DISK_GET_LENGTH_INFO:
430.       case IOCTL_DISK_GET_PARTITION_INFO:
431.       case IOCTL_DISK_GET_PARTITION_INFO_EX:
432.       case IOCTL_DISK_IS_WRITABLE:
433.       case IOCTL_DISK_MEDIA_REMOVAL:
434.       case IOCTL_STORAGE_MEDIA_REMOVAL:
435.       case IOCTL_DISK_SET_PARTITION_INFO:
436.       case IOCTL_DISK_VERIFY:
437.         {
438.             status = IRPAddToQue(DeviceObject,Irp);            
439.             break;
440.         }
441.     }
442.  
443.     if (status != STATUS_PENDING)
444.     {
445.         Irp->IoStatus.Status = status;
446.         IoCompleteRequest(Irp, IO_NO_INCREMENT);
447.     }
448.  
449.     return status;
450. }
451.  
452. NTSTATUS
453. IRPAddToQue (
454.     IN PDEVICE_OBJECT   DeviceObject,
455.     IN PIRP             Irp
456.     )
457. {
458.     PDEVICE_EXTENSION   device_extension;
459.  
460.     device_extension = (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
461.  
462.     Irp->IoStatus.Information = 0;
463.     if (device_extension->device_type != Dev_Type_Storage)
464.         {
465.         KdPrint(("FileDisk: Cant add to Que control packet \n"));
466.             return STATUS_INVALID_DEVICE_REQUEST;
467.         }
468.  
469.     if ((list_cnt >= MaxListQue) || (connects_cnt <= 0))
470.         {
471.         KdPrint(("FileDisk: Que add error \n"));
472.           return STATUS_NO_MEDIA_IN_DEVICE;
473.         }
474.         else
475.         {
476.         list_cnt++;
477.         KdPrint(("FileDisk: Added to Que, Que size = %#x\n",list_cnt));
478.         IoMarkIrpPending(Irp);
479.  
480.         ExInterlockedInsertTailList(
481.             &list_head,
482.             &Irp->Tail.Overlay.ListEntry,
483.             &list_lock);
484.  
485.         return STATUS_PENDING;
486.       }
487. }
488.  
489. void DriveLetterDelete()
490. {
491.   UNICODE_STRING      ustr;
492.   ANSI_STRING         astr;
493.   char                dl[7] = "\\??\\ : ";
494.  
495.   dl[4] = drive_letter;
496.   dl[6] = 0;
497.   RtlInitAnsiString(&astr,(LPCSTR) &dl);
498.   RtlAnsiStringToUnicodeString(&ustr,&astr, TRUE);
499.   KdPrint(((PCHAR) &dl,'\n'));
500.   if (NT_SUCCESS(IoDeleteSymbolicLink(&ustr)))
501.     {
502.         drive_letter = 0;
503.     }
504.   RtlFreeUnicodeString(&ustr);
505. }

 

Никто ничего не посоветует ?

 

я могу посоветовать заглянуть на сайт либо Freed0m.org (там есть как раз ваш велосипед) или http://www.acc.umu.se/~bosse/

там тоже много по теме.

 

Вау.. за Freed0m.org большое спасибо.