ReactOS 0.4.16-dev-297-gc569aee
env_spec.cpp
Go to the documentation of this file.
1
2// Copyright (C) Alexander Telyatnikov, Ivan Keliukh, Yegor Anchishkin, SKIF Software, 1999-2013. Kiev, Ukraine
3// All rights reserved
4// This file was released under the GPLv2 on June 2015.
6/*************************************************************************
7*
8* File: Env_Spec.cpp
9*
10* Module: UDF File System Driver (Kernel mode execution only)
11*
12* Description:
13* Contains environment-secific code to handle physical
14* operations: read, write and device IOCTLS
15*
16*************************************************************************/
17
18#include "udffs.h"
19// define the file specific bug-check id
20#define UDF_BUG_CHECK_ID UDF_FILE_ENV_SPEC
21
22#define MEASURE_IO_PERFORMANCE
23
24#ifdef MEASURE_IO_PERFORMANCE
29#endif //MEASURE_IO_PERFORMANCE
30
31#ifdef DBG
32ULONG UDF_SIMULATE_WRITES=0;
33#endif //DBG
34
35/*
36
37 */
42 IN PIRP Irp,
43 IN PVOID Contxt
44 )
45{
46 UDFPrint(("UDFAsyncCompletionRoutine ctx=%x\n", Contxt));
48 PMDL Mdl, NextMdl;
49
50 Context->IosbToUse = Irp->IoStatus;
51#if 1
52 // Unlock pages that are described by MDL (if any)...
53 Mdl = Irp->MdlAddress;
54 while(Mdl) {
55 MmPrint((" Unlock MDL=%x\n", Mdl));
57 Mdl = Mdl->Next;
58 }
59 // ... and free MDL
60 Mdl = Irp->MdlAddress;
61 while(Mdl) {
62 MmPrint((" Free MDL=%x\n", Mdl));
63 NextMdl = Mdl->Next;
65 Mdl = NextMdl;
66 }
67 Irp->MdlAddress = NULL;
69
70 KeSetEvent( &(Context->event), 0, FALSE );
71
73#else
74 KeSetEvent( &(Context->event), 0, FALSE );
75
76 return STATUS_SUCCESS;
77#endif
78} // end UDFAsyncCompletionRoutine()
79
84 IN PIRP Irp,
85 IN PVOID Contxt
86 )
87{
88 UDFPrint(("UDFSyncCompletionRoutine ctx=%x\n", Contxt));
90
91 Context->IosbToUse = Irp->IoStatus;
92 //KeSetEvent( &(Context->event), 0, FALSE );
93
94 return STATUS_SUCCESS;
95} // end UDFSyncCompletionRoutine()
96
97/*
98NTSTATUS
99UDFSyncCompletionRoutine2(
100 IN PDEVICE_OBJECT DeviceObject,
101 IN PIRP Irp,
102 IN PVOID Contxt
103 )
104{
105 UDFPrint(("UDFSyncCompletionRoutine2\n"));
106 PKEVENT SyncEvent = (PKEVENT)Contxt;
107
108 KeSetEvent( SyncEvent, 0, FALSE );
109
110 return STATUS_SUCCESS;
111} // end UDFSyncCompletionRoutine2()
112*/
113
114/*
115
116 Function: UDFPhReadSynchronous()
117
118 Description:
119 UDFFSD will invoke this rotine to read physical device synchronously/asynchronously
120
121 Expected Interrupt Level (for execution) :
122
123 <= IRQL_DISPATCH_LEVEL
124
125 Return Value: STATUS_SUCCESS/Error
126
127*/
129NTAPI
131 PDEVICE_OBJECT DeviceObject, // the physical device object
137 )
138{
140 LARGE_INTEGER ROffset;
142 PIRP irp;
143 KIRQL CurIrql = KeGetCurrentIrql();
144 PVOID IoBuf = NULL;
145// ULONG i;
146#ifdef MEASURE_IO_PERFORMANCE
147 LONGLONG IoEnterTime;
148 LONGLONG IoExitTime;
149 ULONG dt;
150 ULONG dtm;
151#endif //MEASURE_IO_PERFORMANCE
152#ifdef _BROWSE_UDF_
153 PVCB Vcb = NULL;
154 if(Flags & PH_VCB_IN_RETLEN) {
155 Vcb = (PVCB)(*ReadBytes);
156 }
157#endif //_BROWSE_UDF_
158
159#ifdef MEASURE_IO_PERFORMANCE
160 KeQuerySystemTime((PLARGE_INTEGER)&IoEnterTime);
161#endif //MEASURE_IO_PERFORMANCE
162
163 UDFPrint(("UDFPhRead: Length: %x Lba: %lx\n",Length>>0xb,Offset>>0xb));
164// UDFPrint(("UDFPhRead: Length: %x Lba: %lx\n",Length>>0x9,Offset>>0x9));
165
166 ROffset.QuadPart = Offset;
167 (*ReadBytes) = 0;
168/*
169 // DEBUG !!!
170 Flags |= PH_TMP_BUFFER;
171*/
172 if(Flags & PH_TMP_BUFFER) {
173 IoBuf = Buffer;
174 } else {
176 }
177 if (!IoBuf) {
178 UDFPrint((" !IoBuf\n"));
180 }
182 if (!Context) {
183 UDFPrint((" !Context\n"));
185 }
186 // Create notification event object to be used to signal the request completion.
188
189 if (CurIrql > PASSIVE_LEVEL) {
191 Length, &ROffset, &(Context->IosbToUse) );
192 if (!irp) {
193 UDFPrint((" !irp Async\n"));
195 }
196 MmPrint((" Alloc async Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
198 Context, TRUE, TRUE, TRUE );
199 } else {
201 Length, &ROffset, &(Context->event), &(Context->IosbToUse) );
202 if (!irp) {
203 UDFPrint((" !irp Sync\n"));
205 }
206 MmPrint((" Alloc Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
207 }
208
211
212 if (RC == STATUS_PENDING) {
214 if ((RC = Context->IosbToUse.Status) == STATUS_DATA_OVERRUN) {
215 RC = STATUS_SUCCESS;
216 }
217// *ReadBytes = Context->IosbToUse.Information;
218 } else {
219// *ReadBytes = irp->IoStatus.Information;
220 }
221 if(NT_SUCCESS(RC)) {
222 (*ReadBytes) = Context->IosbToUse.Information;
223 }
224 if(!(Flags & PH_TMP_BUFFER)) {
226 }
227
228 if(NT_SUCCESS(RC)) {
229/*
230 for(i=0; i<(*ReadBytes); i+=2048) {
231 UDFPrint(("IOCRC %8.8x R %x\n", crc32((PUCHAR)Buffer+i, 2048), (ULONG)((Offset+i)/2048) ));
232 }
233*/
234#ifdef _BROWSE_UDF_
235 if(Vcb) {
236 RC = UDFVRead(Vcb, IoBuf, Length >> Vcb->BlockSizeBits, (ULONG)(Offset >> Vcb->BlockSizeBits), Flags);
237 }
238#endif //_BROWSE_UDF_
239 }
240
241try_exit: NOTHING;
242
244 if(IoBuf && !(Flags & PH_TMP_BUFFER)) DbgFreePool(IoBuf);
245
246#ifdef MEASURE_IO_PERFORMANCE
247 KeQuerySystemTime((PLARGE_INTEGER)&IoExitTime);
248 IoReadTime += (IoExitTime-IoEnterTime);
249 dt = (ULONG)((IoExitTime-IoEnterTime)/10/1000);
250 dtm = (ULONG)(((IoExitTime-IoEnterTime)/10)%1000);
251 PerfPrint(("\nUDFPhReadSynchronous() exit: %08X, after %d.%4.4d msec.\n", RC, dt, dtm));
252#else
253 UDFPrint(("UDFPhReadSynchronous() exit: %08X\n", RC));
254#endif //MEASURE_IO_PERFORMANCE
255
256 return(RC);
257} // end UDFPhReadSynchronous()
258
259
260/*
261
262 Function: UDFPhWriteSynchronous()
263
264 Description:
265 UDFFSD will invoke this rotine to write physical device synchronously
266
267 Expected Interrupt Level (for execution) :
268
269 <= IRQL_DISPATCH_LEVEL
270
271 Return Value: STATUS_SUCCESS/Error
272
273*/
275NTAPI
277 PDEVICE_OBJECT DeviceObject, // the physical device object
281 PSIZE_T WrittenBytes,
283 )
284{
286 LARGE_INTEGER ROffset;
288 PIRP irp;
289// LARGE_INTEGER timeout;
290 KIRQL CurIrql = KeGetCurrentIrql();
291 PVOID IoBuf = NULL;
292// ULONG i;
293#ifdef MEASURE_IO_PERFORMANCE
294 LONGLONG IoEnterTime;
295 LONGLONG IoExitTime;
296 ULONG dt;
297 ULONG dtm;
298#endif //MEASURE_IO_PERFORMANCE
299#ifdef _BROWSE_UDF_
300 PVCB Vcb = NULL;
301 if(Flags & PH_VCB_IN_RETLEN) {
302 Vcb = (PVCB)(*WrittenBytes);
303 }
304#endif //_BROWSE_UDF_
305
306#ifdef MEASURE_IO_PERFORMANCE
307 KeQuerySystemTime((PLARGE_INTEGER)&IoEnterTime);
308#endif //MEASURE_IO_PERFORMANCE
309
310#ifdef USE_PERF_PRINT
311 ULONG Lba = (ULONG)(Offset>>0xb);
312// ASSERT(!(Lba & (32-1)));
313 PerfPrint(("UDFPhWrite: Length: %x Lba: %lx\n",Length>>0xb,Lba));
314// UDFPrint(("UDFPhWrite: Length: %x Lba: %lx\n",Length>>0x9,Offset>>0x9));
315#endif //DBG
316
317#ifdef DBG
318 if(UDF_SIMULATE_WRITES) {
319/* FIXME ReactOS
320 If this function is to force a read from the bufffer to simulate any segfaults, then it makes sense.
321 Else, this forloop is useless.
322 UCHAR a;
323 for(ULONG i=0; i<Length; i++) {
324 a = ((PUCHAR)Buffer)[i];
325 }
326*/
327 *WrittenBytes = Length;
328 return STATUS_SUCCESS;
329 }
330#endif //DBG
331
332 ROffset.QuadPart = Offset;
333 (*WrittenBytes) = 0;
334
335/* IoBuf = ExAllocatePool(NonPagedPool, Length);
336 if (!IoBuf) return STATUS_INSUFFICIENT_RESOURCES;
337 RtlCopyMemory(IoBuf, Buffer, Length);*/
338 IoBuf = Buffer;
339
340/* if(Flags & PH_TMP_BUFFER) {
341 IoBuf = Buffer;
342 } else {
343 IoBuf = DbgAllocatePool(NonPagedPool, Length);
344 RtlCopyMemory(IoBuf, Buffer, Length);
345 }*/
346
349 // Create notification event object to be used to signal the request completion.
351
352 if (CurIrql > PASSIVE_LEVEL) {
354 Length, &ROffset, &(Context->IosbToUse) );
356 MmPrint((" Alloc async Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
358 Context, TRUE, TRUE, TRUE );
359 } else {
361 Length, &ROffset, &(Context->event), &(Context->IosbToUse) );
363 MmPrint((" Alloc Irp MDL=%x\n, ctx=%x", irp->MdlAddress, Context));
364 }
365
368/*
369 for(i=0; i<Length; i+=2048) {
370 UDFPrint(("IOCRC %8.8x W %x\n", crc32((PUCHAR)Buffer+i, 2048), (ULONG)((Offset+i)/2048) ));
371 }
372*/
373#ifdef _BROWSE_UDF_
374 if(Vcb) {
375 UDFVWrite(Vcb, IoBuf, Length >> Vcb->BlockSizeBits, (ULONG)(Offset >> Vcb->BlockSizeBits), Flags);
376 }
377#endif //_BROWSE_UDF_
378
379 if (RC == STATUS_PENDING) {
381 if ((RC = Context->IosbToUse.Status) == STATUS_DATA_OVERRUN) {
382 RC = STATUS_SUCCESS;
383 }
384// *WrittenBytes = Context->IosbToUse.Information;
385 } else {
386// *WrittenBytes = irp->IoStatus.Information;
387 }
388 if(NT_SUCCESS(RC)) {
389 (*WrittenBytes) = Context->IosbToUse.Information;
390 }
391
392try_exit: NOTHING;
393
395// if(IoBuf) ExFreePool(IoBuf);
396// if(IoBuf && !(Flags & PH_TMP_BUFFER)) DbgFreePool(IoBuf);
397 if(!NT_SUCCESS(RC)) {
398 UDFPrint(("WriteError\n"));
399 }
400
401#ifdef MEASURE_IO_PERFORMANCE
402 KeQuerySystemTime((PLARGE_INTEGER)&IoExitTime);
403 IoWriteTime += (IoExitTime-IoEnterTime);
404 if (WrittenData > 1024*1024*8) {
405 PerfPrint(("\nUDFPhWriteSynchronous() Relative size=%I64d, time=%I64d.\n", WrittenData, IoRelWriteTime));
407 }
409 IoRelWriteTime += (IoExitTime-IoEnterTime);
410 dt = (ULONG)((IoExitTime-IoEnterTime)/10/1000);
411 dtm = (ULONG)(((IoExitTime-IoEnterTime)/10)%1000);
412 PerfPrint(("\nUDFPhWriteSynchronous() exit: %08X, after %d.%4.4d msec.\n", RC, dt, dtm));
413#else
414 UDFPrint(("nUDFPhWriteSynchronous() exit: %08X\n", RC));
415#endif //MEASURE_IO_PERFORMANCE
416
417 return(RC);
418} // end UDFPhWriteSynchronous()
419
420#if 0
423 PDEVICE_OBJECT DeviceObject, // the physical device object
427 PSIZE_T WrittenBytes,
429 )
430{
431 NTSTATUS RC;
432 //PUCHAR v_buff = NULL;
433 //ULONG ReadBytes;
434
436/*
437 if(!Verify)
438 return RC;
439 v_buff = (PUCHAR)DbgAllocatePoolWithTag(NonPagedPool, Length, 'bNWD');
440 if(!v_buff)
441 return RC;
442 RC = UDFPhReadSynchronous(DeviceObject, v_buff, Length, Offset, &ReadBytes, Flags);
443 if(!NT_SUCCESS(RC)) {
444 BrutePoint();
445 DbgFreePool(v_buff);
446 return RC;
447 }
448 if(RtlCompareMemory(v_buff, Buffer, ReadBytes) == Length) {
449 DbgFreePool(v_buff);
450 return RC;
451 }
452 BrutePoint();
453 DbgFreePool(v_buff);
454 return STATUS_LOST_WRITEBEHIND_DATA;
455*/
456 return RC;
457} // end UDFPhWriteVerifySynchronous()
458#endif //0
459
461NTAPI
464 IN PVCB Vcb,
469 IN BOOLEAN OverrideVerify,
471 )
472{
474 BOOLEAN Acquired;
475
476 Acquired = UDFAcquireResourceExclusiveWithCheck(&(Vcb->IoResource));
477
478 _SEH2_TRY {
479
481 Vcb->TargetDeviceObject,
486 OverrideVerify,
487 Iosb
488 );
489
490 } _SEH2_FINALLY {
491 if(Acquired)
492 UDFReleaseResource(&(Vcb->IoResource));
493 } _SEH2_END;
494
495 return RC;
496} // end UDFTSendIOCTL()
497
498/*
499
500 Function: UDFPhSendIOCTL()
501
502 Description:
503 UDF FSD will invoke this rotine to send IOCTL's to physical
504 device
505
506 Return Value: STATUS_SUCCESS/Error
507
508*/
510NTAPI
518 IN BOOLEAN OverrideVerify,
520 )
521{
523 PIRP irp;
526
527 UDFPrint(("UDFPhDevIOCTL: Code %8x \n",IoControlCode));
528
531 // Check if the user gave us an Iosb.
532
533 // Create notification event object to be used to signal the request completion.
535
538
540 MmPrint((" Alloc Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
541/*
542 if (KeGetCurrentIrql() > PASSIVE_LEVEL) {
543 UDFPrint(("Setting completion routine\n"));
544 IoSetCompletionRoutine( irp, &UDFSyncCompletionRoutine,
545 Context, TRUE, TRUE, TRUE );
546 }
547*/
548 if(OverrideVerify) {
550 }
551
553
554 if (RC == STATUS_PENDING) {
556 UDFPrint(("Enter wait state on evt %x\n", Context));
557
559 timeout.QuadPart = -1000;
560 UDFPrint(("waiting, TO=%I64d\n", timeout.QuadPart));
561 RC = DbgWaitForSingleObject(&(Context->event), &timeout);
562 while(RC == STATUS_TIMEOUT) {
563 timeout.QuadPart *= 2;
564 UDFPrint(("waiting, TO=%I64d\n", timeout.QuadPart));
565 RC = DbgWaitForSingleObject(&(Context->event), &timeout);
566 }
567
568 } else {
570 }
571 if ((RC = Context->IosbToUse.Status) == STATUS_DATA_OVERRUN) {
572 RC = STATUS_SUCCESS;
573 }
574 UDFPrint(("Exit wait state on evt %x, status %8.8x\n", Context, RC));
575/* if(Iosb) {
576 (*Iosb) = Context->IosbToUse;
577 }*/
578 } else {
579 UDFPrint(("No wait completion on evt %x\n", Context));
580/* if(Iosb) {
581 (*Iosb) = irp->IoStatus;
582 }*/
583 }
584
585 if(Iosb) {
586 (*Iosb) = Context->IosbToUse;
587 }
588
589try_exit: NOTHING;
590
592 return(RC);
593} // end UDFPhSendIOCTL()
594
595
596#ifdef UDF_DBG
597VOID
599 PVCB V,
601 ULONG E,
602 ULONG A
603 )
604{
605 if((FI)->ParentFile) {
606 FsRtlNotifyFullReportChange( (V)->NotifyIRPMutex, &((V)->NextNotifyIRP),
607 (PSTRING)&((FI)->Fcb->FCBName->ObjectName),
608 ((FI)->ParentFile->Fcb->FCBName->ObjectName.Length + sizeof(WCHAR)),
609 NULL,NULL,
610 E, A,
611 NULL);
612 } else {
613 FsRtlNotifyFullReportChange( (V)->NotifyIRPMutex, &((V)->NextNotifyIRP),
614 (PSTRING)&((FI)->Fcb->FCBName->ObjectName),
615 0,
616 NULL,NULL,
617 E, A,
618 NULL);
619 }
620} // end UDFNotifyFullReportChange()
621
622VOID
626 )
627{
628/* ReactOS FIXME This is always true, and we return anyway. */
629// if(!FsRtlNotifyVolumeEvent)
630 return;
631 //FsRtlNotifyVolumeEvent(FileObject, EventCode);
632} // end UDFNotifyVolumeEvent()
633#endif // UDF_DBG
634
unsigned char BOOLEAN
struct _UDF_PH_CALL_CONTEXT * PUDF_PH_CALL_CONTEXT
LONG NTSTATUS
Definition: precomp.h:26
_In_ PFCB Fcb
Definition: cdprocs.h:159
#define try_return(S)
Definition: cdprocs.h:2179
struct _VCB * PVCB
Definition: fatstruc.h:557
Definition: ehthrow.cxx:93
Definition: bufpool.h:45
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_TIMEOUT
Definition: d3dkmdt.h:49
#define STATUS_PENDING
Definition: d3dkmdt.h:43
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
static const WCHAR E[]
Definition: oid.c:1253
return Iosb
Definition: create.c:4402
BOOLEAN UDFAcquireResourceExclusiveWithCheck(IN PERESOURCE Resource)
Definition: misc.cpp:2529
static NTSTATUS ReadBytes(IN PDEVICE_OBJECT LowerDevice, OUT PUCHAR Buffer, IN ULONG BufferSize, OUT PULONG_PTR FilledBytes)
Definition: detect.c:67
LONGLONG IoWriteTime
Definition: env_spec.cpp:26
NTSTATUS NTAPI UDFSyncCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
Definition: env_spec.cpp:82
NTSTATUS NTAPI UDFAsyncCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
Definition: env_spec.cpp:40
LONGLONG IoRelWriteTime
Definition: env_spec.cpp:28
NTSTATUS NTAPI UDFPhSendIOCTL(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, OUT PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN OverrideVerify, OUT PIO_STATUS_BLOCK Iosb OPTIONAL)
Definition: env_spec.cpp:511
LONGLONG IoReadTime
Definition: env_spec.cpp:25
NTSTATUS NTAPI UDFTSendIOCTL(IN ULONG IoControlCode, IN PVCB Vcb, IN PVOID InputBuffer, IN ULONG InputBufferLength, OUT PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN OverrideVerify, OUT PIO_STATUS_BLOCK Iosb OPTIONAL)
Definition: env_spec.cpp:462
NTSTATUS NTAPI UDFPhWriteSynchronous(PDEVICE_OBJECT DeviceObject, PVOID Buffer, SIZE_T Length, LONGLONG Offset, PSIZE_T WrittenBytes, ULONG Flags)
Definition: env_spec.cpp:276
NTSTATUS NTAPI UDFPhReadSynchronous(PDEVICE_OBJECT DeviceObject, PVOID Buffer, SIZE_T Length, LONGLONG Offset, PSIZE_T ReadBytes, ULONG Flags)
Definition: env_spec.cpp:130
LONGLONG WrittenData
Definition: env_spec.cpp:27
#define UDFNotifyVolumeEvent(FileObject, EventCode)
Definition: env_spec.h:114
__inline VOID UDFNotifyFullReportChange(PVCB V, PUDF_FILE_INFO FI, ULONG E, ULONG A)
Definition: env_spec.h:99
#define UDFPhWriteVerifySynchronous
Definition: env_spec.h:46
#define UDFReleaseResource(Resource)
Definition: env_spec_w32.h:661
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define DbgAllocatePoolWithTag(a, b, c)
Definition: env_spec_w32.h:333
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define DbgWaitForSingleObject(o, to)
Definition: env_spec_w32.h:479
#define MmPrint(_x_)
Definition: env_spec_w32.h:289
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
#define PerfPrint(_x_)
Definition: env_spec_w32.h:291
#define DbgFreePool
Definition: env_spec_w32.h:334
#define NonPagedPool
Definition: env_spec_w32.h:307
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
#define IoFreeMdl
Definition: fxmdl.h:89
FxIrp * irp
#define NOTHING
Definition: input_list.c:10
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
#define MyAllocatePool__(type, size)
Definition: mem_tools.h:149
#define MyFreePool__(addr)
Definition: mem_tools.h:152
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1435
#define ASSERT(a)
Definition: mode.c:44
_In_ NDIS_STATUS EventCode
Definition: ndis.h:4751
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
@ NotificationEvent
VOID NTAPI FsRtlNotifyFullReportChange(IN PNOTIFY_SYNC NotifySync, IN PLIST_ENTRY NotifyList, IN PSTRING FullTargetName, IN USHORT TargetNameOffset, IN PSTRING StreamName OPTIONAL, IN PSTRING NormalizedParentName OPTIONAL, IN ULONG FilterMatch, IN ULONG Action, IN PVOID TargetContext)
Definition: notify.c:1552
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
PIRP NTAPI IoBuildAsynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:750
PIRP NTAPI IoBuildDeviceIoControlRequest(IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:881
#define IoCallDriver
Definition: irp.c:1225
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
#define Vcb
Definition: cdprocs.h:1415
#define PH_VCB_IN_RETLEN
Definition: phys_lib.h:66
#define PH_TMP_BUFFER
Definition: phys_lib.h:65
#define _SEH2_FINALLY
Definition: pseh2_64.h:114
#define _SEH2_END
Definition: pseh2_64.h:155
#define _SEH2_TRY
Definition: pseh2_64.h:55
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
OSSTATUS UDFVWrite(IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)
Definition: remap.cpp:225
OSSTATUS UDFVRead(IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)
Definition: remap.cpp:375
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
#define STATUS_SUCCESS
Definition: shellext.h:65
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
WCHAR * ObjectName
Definition: ntfs.h:524
Definition: cdstruc.h:498
Definition: dhcpd.h:245
ULONG_PTR * PSIZE_T
Definition: typedefs.h:80
int64_t LONGLONG
Definition: typedefs.h:68
#define NTAPI
Definition: typedefs.h:36
ULONG_PTR SIZE_T
Definition: typedefs.h:80
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_DATA_OVERRUN
Definition: udferr_usr.h:152
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define UDFPrint(Args)
Definition: udffs.h:223
LONGLONG QuadPart
Definition: typedefs.h:114
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
_In_ WDFREQUEST _In_ size_t OutputBufferLength
Definition: wdfio.h:320
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:322
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:863
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:953
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823
* PFILE_OBJECT
Definition: iotypes.h:1998
__wchar_t WCHAR
Definition: xmlstorage.h:180