ReactOS 0.4.16-dev-1946-g52006dd
Macros | Functions | Variables
env_spec.cpp File Reference
#include "udffs.h"
Include dependency graph for env_spec.cpp:

Go to the source code of this file.

Macros

#define UDF_BUG_CHECK_ID   UDF_FILE_ENV_SPEC
 
#define MEASURE_IO_PERFORMANCE
 

Functions

NTSTATUS NTAPI UDFAsyncCompletionRoutine (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
 
NTSTATUS NTAPI UDFSyncCompletionRoutine (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
 
NTSTATUS NTAPI UDFPhReadSynchronous (PDEVICE_OBJECT DeviceObject, PVOID Buffer, SIZE_T Length, LONGLONG Offset, PSIZE_T ReadBytes, ULONG Flags)
 
NTSTATUS NTAPI UDFPhWriteSynchronous (PDEVICE_OBJECT DeviceObject, PVOID Buffer, SIZE_T Length, LONGLONG Offset, PSIZE_T WrittenBytes, ULONG Flags)
 
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)
 
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)
 

Variables

LONGLONG IoReadTime =0
 
LONGLONG IoWriteTime =0
 
LONGLONG WrittenData =0
 
LONGLONG IoRelWriteTime =0
 

Macro Definition Documentation

◆ MEASURE_IO_PERFORMANCE

#define MEASURE_IO_PERFORMANCE

Definition at line 22 of file env_spec.cpp.

◆ UDF_BUG_CHECK_ID

#define UDF_BUG_CHECK_ID   UDF_FILE_ENV_SPEC

Definition at line 20 of file env_spec.cpp.

Function Documentation

◆ UDFAsyncCompletionRoutine()

NTSTATUS NTAPI UDFAsyncCompletionRoutine ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PVOID  Contxt 
)

Definition at line 40 of file env_spec.cpp.

45{
46 UDFPrint(("UDFAsyncCompletionRoutine ctx=%x\n", Contxt));
47 PUDF_PH_CALL_CONTEXT Context = (PUDF_PH_CALL_CONTEXT)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
72 return STATUS_MORE_PROCESSING_REQUIRED;
73#else
74 KeSetEvent( &(Context->event), 0, FALSE );
75
76 return STATUS_SUCCESS;
77#endif
78} // end UDFAsyncCompletionRoutine()
PUDF_PH_CALL_CONTEXT
struct _UDF_PH_CALL_CONTEXT * PUDF_PH_CALL_CONTEXT
Irp
_In_ PIRP Irp
Definition: csq.h:116
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
KeSetEvent
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
MmPrint
#define MmPrint(_x_)
Definition: env_spec_w32.h:289
IoFreeMdl
#define IoFreeMdl
Definition: fxmdl.h:89
MmUnlockPages
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1435
IoFreeIrp
VOID NTAPI IoFreeIrp(IN PIRP Irp)
Definition: irp.c:1666
STATUS_MORE_PROCESSING_REQUIRED
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:68
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_UDF_PH_CALL_CONTEXT
Definition: Sys_spec_lib.h:22
UDFPrint
#define UDFPrint(Args)
Definition: udffs.h:223
Mdl
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
Definition: wdfdmatransaction.h:89

Referenced by UDFPhReadSynchronous(), and UDFPhWriteSynchronous().

◆ UDFPhReadSynchronous()

NTSTATUS NTAPI UDFPhReadSynchronous ( PDEVICE_OBJECT  DeviceObject,
PVOID  Buffer,
SIZE_T  Length,
LONGLONG  Offset,
PSIZE_T  ReadBytes,
ULONG  Flags 
)

Definition at line 130 of file env_spec.cpp.

138{
139 NTSTATUS RC = STATUS_SUCCESS;
140 LARGE_INTEGER ROffset;
141 PUDF_PH_CALL_CONTEXT Context;
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"));
179 return STATUS_INSUFFICIENT_RESOURCES;
180 }
181 Context = (PUDF_PH_CALL_CONTEXT)MyAllocatePool__( NonPagedPool, sizeof(UDF_PH_CALL_CONTEXT) );
182 if (!Context) {
183 UDFPrint((" !Context\n"));
184 try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
185 }
186 // Create notification event object to be used to signal the request completion.
187 KeInitializeEvent(&(Context->event), NotificationEvent, FALSE);
188
189 if (CurIrql > PASSIVE_LEVEL) {
190 irp = IoBuildAsynchronousFsdRequest(IRP_MJ_READ, DeviceObject, IoBuf,
191 Length, &ROffset, &(Context->IosbToUse) );
192 if (!irp) {
193 UDFPrint((" !irp Async\n"));
194 try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
195 }
196 MmPrint((" Alloc async Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
197 IoSetCompletionRoutine( irp, &UDFAsyncCompletionRoutine,
198 Context, TRUE, TRUE, TRUE );
199 } else {
200 irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ, DeviceObject, IoBuf,
201 Length, &ROffset, &(Context->event), &(Context->IosbToUse) );
202 if (!irp) {
203 UDFPrint((" !irp Sync\n"));
204 try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
205 }
206 MmPrint((" Alloc Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
207 }
208
209 (IoGetNextIrpStackLocation(irp))->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
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
241try_exit: NOTHING;
242
243 if(Context) MyFreePool__(Context);
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()
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
try_return
#define try_return(S)
Definition: cdprocs.h:2179
PVCB
struct _VCB * PVCB
Definition: fatstruc.h:557
Buffer
Definition: bufpool.h:45
TRUE
#define TRUE
Definition: types.h:120
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
ReadBytes
static NTSTATUS ReadBytes(IN PDEVICE_OBJECT LowerDevice, OUT PUCHAR Buffer, IN ULONG BufferSize, OUT PULONG_PTR FilledBytes)
Definition: detect.c:67
UDFAsyncCompletionRoutine
NTSTATUS NTAPI UDFAsyncCompletionRoutine(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Contxt)
Definition: env_spec.cpp:40
IoReadTime
LONGLONG IoReadTime
Definition: env_spec.cpp:25
PASSIVE_LEVEL
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
KIRQL
UCHAR KIRQL
Definition: env_spec_w32.h:591
DbgAllocatePoolWithTag
#define DbgAllocatePoolWithTag(a, b, c)
Definition: env_spec_w32.h:333
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
DbgWaitForSingleObject
#define DbgWaitForSingleObject(o, to)
Definition: env_spec_w32.h:479
KeQuerySystemTime
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
KeGetCurrentIrql
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
PerfPrint
#define PerfPrint(_x_)
Definition: env_spec_w32.h:291
DbgFreePool
#define DbgFreePool
Definition: env_spec_w32.h:334
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
irp
FxIrp * irp
Definition: fxrequestapi.cpp:1323
NOTHING
#define NOTHING
Definition: input_list.c:10
IoSetCompletionRoutine
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:490
MyAllocatePool__
#define MyAllocatePool__(type, size)
Definition: mem_tools.h:149
MyFreePool__
#define MyFreePool__(addr)
Definition: mem_tools.h:152
Offset
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NotificationEvent
@ NotificationEvent
Definition: ntdef.template.h:365
IoBuildSynchronousFsdRequest
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
IoBuildAsynchronousFsdRequest
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
IoCallDriver
#define IoCallDriver
Definition: irp.c:1225
Vcb
#define Vcb
Definition: cdprocs.h:1415
PH_VCB_IN_RETLEN
#define PH_VCB_IN_RETLEN
Definition: phys_lib.h:66
PH_TMP_BUFFER
#define PH_TMP_BUFFER
Definition: phys_lib.h:65
IRP_MJ_READ
#define IRP_MJ_READ
Definition: rdpdr.c:46
UDFVRead
OSSTATUS UDFVRead(IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)
Definition: remap.cpp:375
_IRP
Definition: Bus_PDO_EvalMethod.c:105
_VCB
Definition: cdstruc.h:498
STATUS_PENDING
#define STATUS_PENDING
Definition: telnetd.h:14
LONGLONG
int64_t LONGLONG
Definition: typedefs.h:68
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_DATA_OVERRUN
#define STATUS_DATA_OVERRUN
Definition: udferr_usr.h:152
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2061
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
IoGetNextIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2695
SL_OVERRIDE_VERIFY_VOLUME
#define SL_OVERRIDE_VERIFY_VOLUME
Definition: iotypes.h:1823

Referenced by UDFPrepareForReadOperation(), UDFTRead(), and UDFUseStandard().

◆ UDFPhSendIOCTL()

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 at line 511 of file env_spec.cpp.

521{
522 NTSTATUS RC = STATUS_SUCCESS;
523 PIRP irp;
524 PUDF_PH_CALL_CONTEXT Context;
525 LARGE_INTEGER timeout;
526
527 UDFPrint(("UDFPhDevIOCTL: Code %8x \n",IoControlCode));
528
529 Context = (PUDF_PH_CALL_CONTEXT)MyAllocatePool__( NonPagedPool, sizeof(UDF_PH_CALL_CONTEXT) );
530 if (!Context) return STATUS_INSUFFICIENT_RESOURCES;
531 // Check if the user gave us an Iosb.
532
533 // Create notification event object to be used to signal the request completion.
534 KeInitializeEvent(&(Context->event), NotificationEvent, FALSE);
535
536 irp = IoBuildDeviceIoControlRequest(IoControlCode, DeviceObject, InputBuffer ,
537 InputBufferLength, OutputBuffer, OutputBufferLength,FALSE,&(Context->event),&(Context->IosbToUse));
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) {
549 (IoGetNextIrpStackLocation(irp))->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
550 }
551
552 RC = IoCallDriver(DeviceObject, irp);
553
554 if (RC == STATUS_PENDING) {
555 ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
556 UDFPrint(("Enter wait state on evt %x\n", Context));
557
558 if (KeGetCurrentIrql() > PASSIVE_LEVEL) {
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
589try_exit: NOTHING;
590
591 if(Context) MyFreePool__(Context);
592 return(RC);
593} // end UDFPhSendIOCTL()
STATUS_TIMEOUT
#define STATUS_TIMEOUT
Definition: d3dkmdt.h:49
Iosb
return Iosb
Definition: create.c:4403
DISPATCH_LEVEL
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
ASSERT
#define ASSERT(a)
Definition: mode.c:44
IoBuildDeviceIoControlRequest
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
timeout
Definition: dhcpd.h:248
IoControlCode
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
OutputBufferLength
_In_ WDFREQUEST _In_ size_t OutputBufferLength
Definition: wdfio.h:320
InputBufferLength
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:322
OutputBuffer
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:863
InputBuffer
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:953

Referenced by CheckCDType(), UDFCommonClose(), UDFDoDismountSequence(), UDFDoOPC(), UDFEjectReqWaiter(), UDFGetBlockSize(), UDFGetDiskInfo(), UDFInitializeVCB(), UDFMountVolume(), UDFPrepareForReadOperation(), UDFPrepareForWriteOperation(), UDFReadAndProcessFullToc(), UDFReadDiscTrackInfo(), UDFRecoverFromError(), UDFResetDeviceDriver(), UDFSetCaching(), UDFSetMRWMode(), UDFSetSpeeds(), UDFSyncCache(), UDFTSendIOCTL(), UDFUseStandard(), and UDFVerifyVolume().

◆ UDFPhWriteSynchronous()

NTSTATUS NTAPI UDFPhWriteSynchronous ( PDEVICE_OBJECT  DeviceObject,
PVOID  Buffer,
SIZE_T  Length,
LONGLONG  Offset,
PSIZE_T  WrittenBytes,
ULONG  Flags 
)

Definition at line 276 of file env_spec.cpp.

284{
285 NTSTATUS RC = STATUS_SUCCESS;
286 LARGE_INTEGER ROffset;
287 PUDF_PH_CALL_CONTEXT Context;
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
347 Context = (PUDF_PH_CALL_CONTEXT)MyAllocatePool__( NonPagedPool, sizeof(UDF_PH_CALL_CONTEXT) );
348 if (!Context) try_return (RC = STATUS_INSUFFICIENT_RESOURCES);
349 // Create notification event object to be used to signal the request completion.
350 KeInitializeEvent(&(Context->event), NotificationEvent, FALSE);
351
352 if (CurIrql > PASSIVE_LEVEL) {
353 irp = IoBuildAsynchronousFsdRequest(IRP_MJ_WRITE, DeviceObject, IoBuf,
354 Length, &ROffset, &(Context->IosbToUse) );
355 if (!irp) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
356 MmPrint((" Alloc async Irp MDL=%x, ctx=%x\n", irp->MdlAddress, Context));
357 IoSetCompletionRoutine( irp, &UDFAsyncCompletionRoutine,
358 Context, TRUE, TRUE, TRUE );
359 } else {
360 irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, DeviceObject, IoBuf,
361 Length, &ROffset, &(Context->event), &(Context->IosbToUse) );
362 if (!irp) try_return(RC = STATUS_INSUFFICIENT_RESOURCES);
363 MmPrint((" Alloc Irp MDL=%x\n, ctx=%x", irp->MdlAddress, Context));
364 }
365
366 (IoGetNextIrpStackLocation(irp))->Flags |= SL_OVERRIDE_VERIFY_VOLUME;
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
392try_exit: NOTHING;
393
394 if(Context) MyFreePool__(Context);
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));
406 WrittenData = IoRelWriteTime = 0;
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()
IoWriteTime
LONGLONG IoWriteTime
Definition: env_spec.cpp:26
IoRelWriteTime
LONGLONG IoRelWriteTime
Definition: env_spec.cpp:28
WrittenData
LONGLONG WrittenData
Definition: env_spec.cpp:27
IRP_MJ_WRITE
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
UDFVWrite
OSSTATUS UDFVWrite(IN PVCB Vcb, IN void *Buffer, IN uint32 BCount, IN uint32 LBA, IN uint32 Flags)
Definition: remap.cpp:225

◆ UDFSyncCompletionRoutine()

NTSTATUS NTAPI UDFSyncCompletionRoutine ( IN PDEVICE_OBJECT  DeviceObject,
IN PIRP  Irp,
IN PVOID  Contxt 
)

Definition at line 82 of file env_spec.cpp.

87{
88 UDFPrint(("UDFSyncCompletionRoutine ctx=%x\n", Contxt));
89 PUDF_PH_CALL_CONTEXT Context = (PUDF_PH_CALL_CONTEXT)Contxt;
90
91 Context->IosbToUse = Irp->IoStatus;
92 //KeSetEvent( &(Context->event), 0, FALSE );
93
94 return STATUS_SUCCESS;
95} // end UDFSyncCompletionRoutine()

◆ UDFTSendIOCTL()

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 at line 462 of file env_spec.cpp.

472{
473 NTSTATUS RC = STATUS_SUCCESS;
474 BOOLEAN Acquired;
475
476 Acquired = UDFAcquireResourceExclusiveWithCheck(&(Vcb->IoResource));
477
478 _SEH2_TRY {
479
480 RC = UDFPhSendIOCTL(IoControlCode,
481 Vcb->TargetDeviceObject,
482 InputBuffer ,
483 InputBufferLength,
484 OutputBuffer ,
485 OutputBufferLength,
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()
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
UDFAcquireResourceExclusiveWithCheck
BOOLEAN UDFAcquireResourceExclusiveWithCheck(IN PERESOURCE Resource)
Definition: misc.cpp:2529
UDFPhSendIOCTL
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
UDFReleaseResource
#define UDFReleaseResource(Resource)
Definition: env_spec_w32.h:661
_SEH2_FINALLY
#define _SEH2_FINALLY
Definition: pseh2_64.h:130
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71

Referenced by UDFEjectReqWaiter(), UDFStartEjectWaiter(), and UDFVerifyVcb().

Variable Documentation

◆ IoReadTime

LONGLONG IoReadTime =0

Definition at line 25 of file env_spec.cpp.

Referenced by UDFPhReadSynchronous().

◆ IoRelWriteTime

LONGLONG IoRelWriteTime =0

Definition at line 28 of file env_spec.cpp.

Referenced by UDFPhWriteSynchronous().

◆ IoWriteTime

LONGLONG IoWriteTime =0

Definition at line 26 of file env_spec.cpp.

Referenced by UDFPhWriteSynchronous().

◆ WrittenData

LONGLONG WrittenData =0

Definition at line 27 of file env_spec.cpp.

Referenced by UDFPhWriteSynchronous().