ReactOS  0.4.13-dev-92-gf251225
env_spec.cpp
Go to the documentation of this file.
1 // 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
32 ULONG UDF_SIMULATE_WRITES=0;
33 #endif //DBG
34 
35 /*
36 
37  */
39 NTAPI
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));
56  MmUnlockPages(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;
64  IoFreeMdl(Mdl);
65  Mdl = NextMdl;
66  }
67  Irp->MdlAddress = NULL;
68  IoFreeIrp(Irp);
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 
81 NTAPI
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 /*
98 NTSTATUS
99 UDFSyncCompletionRoutine2(
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 */
128 NTSTATUS
129 NTAPI
131  PDEVICE_OBJECT DeviceObject, // the physical device object
132  PVOID Buffer,
133  SIZE_T Length,
136  ULONG Flags
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 {
175  IoBuf = DbgAllocatePoolWithTag(NonPagedPool, Length, 'bNWD');
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 
210  RC = IoCallDriver(DeviceObject, irp);
211 
212  if (RC == STATUS_PENDING) {
213  DbgWaitForSingleObject(&(Context->event), NULL);
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)) {
225  RtlCopyMemory(Buffer, IoBuf, *ReadBytes);
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 
241 try_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 */
274 NTSTATUS
275 NTAPI
277  PDEVICE_OBJECT DeviceObject, // the physical device object
278  PVOID Buffer,
279  SIZE_T Length,
281  PSIZE_T WrittenBytes,
282  ULONG Flags
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 #if defined UDF_DBG || defined 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 
367  RC = IoCallDriver(DeviceObject, irp);
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) {
380  DbgWaitForSingleObject(&(Context->event), NULL);
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 
392 try_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  }
408  WrittenData += Length;
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
421 NTSTATUS
423  PDEVICE_OBJECT DeviceObject, // the physical device object
424  PVOID Buffer,
425  SIZE_T Length,
427  PSIZE_T WrittenBytes,
428  ULONG Flags
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 
460 NTSTATUS
461 NTAPI
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,
482  InputBuffer ,
484  OutputBuffer ,
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 */
509 NTSTATUS
510 NTAPI
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 
539  if (!irp) try_return (RC = STATUS_INSUFFICIENT_RESOURCES);
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 
552  RC = IoCallDriver(DeviceObject, irp);
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 {
569  DbgWaitForSingleObject(&(Context->event), NULL);
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 
589 try_exit: NOTHING;
590 
592  return(RC);
593 } // end UDFPhSendIOCTL()
594 
595 
596 #ifdef UDF_DBG
597 VOID
599  PVCB V,
600  PUDF_FILE_INFO FI,
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 
622 VOID
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 
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
#define IN
Definition: typedefs.h:38
OSSTATUS UDFVRead(IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)
Definition: remap.cpp:375
#define UDFPrint(Args)
Definition: udffs.h:225
struct _UDF_PH_CALL_CONTEXT * PUDF_PH_CALL_CONTEXT
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
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
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG IoControlCode
Definition: fltkernel.h:1383
_In_ NDIS_STATUS EventCode
Definition: ndis.h:4733
#define STATUS_DATA_OVERRUN
Definition: udferr_usr.h:152
#define DbgAllocatePoolWithTag(a, b, c)
Definition: env_spec_w32.h:333
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:63
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
_In_ PIRP Irp
Definition: csq.h:116
#define UDFReleaseResource(Resource)
Definition: env_spec_w32.h:661
LONGLONG IoWriteTime
Definition: env_spec.cpp:26
LONG NTSTATUS
Definition: precomp.h:26
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ ULONG _In_ ULONG OutputBufferLength
Definition: fltkernel.h:1374
Definition: cdstruc.h:504
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1439
Definition: dhcpd.h:245
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:1523
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
GLbitfield GLuint64 timeout
Definition: glext.h:7164
CHAR InputBuffer[80]
Definition: conmgr.c:33
_SEH2_TRY
Definition: create.c:4250
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:515
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
#define STATUS_TIMEOUT
Definition: ntstatus.h:81
UCHAR KIRQL
Definition: env_spec_w32.h:591
LONGLONG IoRelWriteTime
Definition: env_spec.cpp:28
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
ULONG_PTR * PSIZE_T
Definition: typedefs.h:78
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
NTSTATUS NTAPI UDFAsyncCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
Definition: env_spec.cpp:40
LONGLONG IoReadTime
Definition: env_spec.cpp:25
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1779
WCHAR * ObjectName
Definition: ntfs.h:508
Definition: bufpool.h:45
_Must_inspect_result_ __drv_aliasesMem _In_ PDEVICE_OBJECT _In_opt_ PVOID _In_ ULONG _Out_opt_ PVOID OutputBuffer
Definition: iofuncs.h:713
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
__inline VOID UDFNotifyFullReportChange(PVCB V, PUDF_FILE_INFO FI, ULONG E, ULONG A)
Definition: env_spec.h:99
#define DbgWaitForSingleObject(o, to)
Definition: env_spec_w32.h:479
static NTSTATUS ReadBytes(IN PDEVICE_OBJECT LowerDevice, OUT PUCHAR Buffer, IN ULONG BufferSize, OUT PULONG_PTR FilledBytes)
Definition: detect.c:67
#define DbgFreePool
Definition: env_spec_w32.h:334
#define MyAllocatePool__(type, size)
Definition: mem_tools.h:149
int64_t LONGLONG
Definition: typedefs.h:66
LONGLONG WrittenData
Definition: env_spec.cpp:27
__wchar_t WCHAR
Definition: xmlstorage.h:180
return Iosb
Definition: create.c:4426
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define try_return(S)
Definition: cdprocs.h:2189
#define Vcb
Definition: cdprocs.h:1425
#define MyFreePool__(addr)
Definition: mem_tools.h:152
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
#define PerfPrint(_x_)
Definition: env_spec_w32.h:291
#define MmPrint(_x_)
Definition: env_spec_w32.h:289
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
* PFILE_OBJECT
Definition: iotypes.h:1954
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
Definition: ttei1.cpp:12
NTSTATUS NTAPI UDFPhWriteSynchronous(PDEVICE_OBJECT DeviceObject, PVOID Buffer, SIZE_T Length, LONGLONG Offset, PSIZE_T WrittenBytes, ULONG Flags)
Definition: env_spec.cpp:276
#define NOTHING
Definition: env_spec_w32.h:461
struct _VCB * PVCB
Definition: fatstruc.h:553
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2647
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ ULONG InputBufferLength
Definition: fltkernel.h:1372
#define PH_VCB_IN_RETLEN
Definition: phys_lib.h:66
NTSTATUS NTAPI UDFPhReadSynchronous(PDEVICE_OBJECT DeviceObject, PVOID Buffer, SIZE_T Length, LONGLONG Offset, PSIZE_T ReadBytes, ULONG Flags)
Definition: env_spec.cpp:130
NTSTATUS NTAPI UDFSyncCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
Definition: env_spec.cpp:82
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
ULONG_PTR SIZE_T
Definition: typedefs.h:78
static const WCHAR E[]
Definition: oid.c:1253
_SEH2_END
Definition: create.c:4424
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
_SEH2_FINALLY
Definition: create.c:4395
#define UDFPhWriteVerifySynchronous
Definition: env_spec.h:46
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define PH_TMP_BUFFER
Definition: phys_lib.h:65
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 IRP_MJ_READ
Definition: rdpdr.c:46
#define OUT
Definition: typedefs.h:39
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
#define UDFNotifyVolumeEvent(FileObject, EventCode)
Definition: env_spec.h:114
struct tagContext Context
Definition: acpixf.h:1012
unsigned int ULONG
Definition: retypes.h:1
OSSTATUS UDFVWrite(IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)
Definition: remap.cpp:225
BOOLEAN UDFAcquireResourceExclusiveWithCheck(IN PERESOURCE Resource)
Definition: misc.cpp:2529
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
_In_ PFCB Fcb
Definition: cdprocs.h:151
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
return STATUS_SUCCESS
Definition: btrfs.c:2725
LONGLONG QuadPart
Definition: typedefs.h:112
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68