[UDFS]
[reactos.git] / reactos / drivers / filesystems / udfs / env_spec.cpp
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.
5 ////////////////////////////////////////////////////////////////////
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
25 LONGLONG IoReadTime=0;
26 LONGLONG IoWriteTime=0;
27 LONGLONG WrittenData=0;
28 LONGLONG IoRelWriteTime=0;
29 #endif //MEASURE_IO_PERFORMANCE
30
31 #ifdef DBG
32 ULONG UDF_SIMULATE_WRITES=0;
33 #endif //DBG
34
35 /*
36
37 */
38 NTSTATUS
39 NTAPI
40 UDFAsyncCompletionRoutine(
41 IN PDEVICE_OBJECT DeviceObject,
42 IN PIRP Irp,
43 IN PVOID Contxt
44 )
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()
79
80 NTSTATUS
81 NTAPI
82 UDFSyncCompletionRoutine(
83 IN PDEVICE_OBJECT DeviceObject,
84 IN PIRP Irp,
85 IN PVOID Contxt
86 )
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()
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
130 UDFPhReadSynchronous(
131 PDEVICE_OBJECT DeviceObject, // the physical device object
132 PVOID Buffer,
133 ULONG Length,
134 LONGLONG Offset,
135 PULONG ReadBytes,
136 ULONG Flags
137 )
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
241 try_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()
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
276 UDFPhWriteSynchronous(
277 PDEVICE_OBJECT DeviceObject, // the physical device object
278 PVOID Buffer,
279 ULONG Length,
280 LONGLONG Offset,
281 PULONG WrittenBytes,
282 ULONG Flags
283 )
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 #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
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
392 try_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()
419
420 #if 0
421 NTSTATUS
422 UDFPhWriteVerifySynchronous(
423 PDEVICE_OBJECT DeviceObject, // the physical device object
424 PVOID Buffer,
425 ULONG Length,
426 LONGLONG Offset,
427 PULONG WrittenBytes,
428 ULONG Flags
429 )
430 {
431 NTSTATUS RC;
432 //PUCHAR v_buff = NULL;
433 //ULONG ReadBytes;
434
435 RC = UDFPhWriteSynchronous(DeviceObject, Buffer, Length, Offset, WrittenBytes, Flags);
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
462 UDFTSendIOCTL(
463 IN ULONG IoControlCode,
464 IN PVCB Vcb,
465 IN PVOID InputBuffer ,
466 IN ULONG InputBufferLength,
467 OUT PVOID OutputBuffer ,
468 IN ULONG OutputBufferLength,
469 IN BOOLEAN OverrideVerify,
470 OUT PIO_STATUS_BLOCK Iosb OPTIONAL
471 )
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()
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
511 UDFPhSendIOCTL(
512 IN ULONG IoControlCode,
513 IN PDEVICE_OBJECT DeviceObject,
514 IN PVOID InputBuffer ,
515 IN ULONG InputBufferLength,
516 OUT PVOID OutputBuffer ,
517 IN ULONG OutputBufferLength,
518 IN BOOLEAN OverrideVerify,
519 OUT PIO_STATUS_BLOCK Iosb OPTIONAL
520 )
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
589 try_exit: NOTHING;
590
591 if(Context) MyFreePool__(Context);
592 return(RC);
593 } // end UDFPhSendIOCTL()
594
595
596 #ifdef UDF_DBG
597 VOID
598 UDFNotifyFullReportChange(
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
623 UDFNotifyVolumeEvent(
624 IN PFILE_OBJECT FileObject,
625 IN ULONG EventCode
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