I don’t understand,
See my party code of my diskfilesystemdriver ,
when i uncomment this line /////BEGIN Line incriminating BUG1////////////
I HAVE BSOD.
Thank
My code incrimating :
//////BEGIN Line incriminating BUG1////////////
if ((fileObject == NULL)&& (Irp->MdlAddress != NULL))
{
//effet de bord 140720174
PVOID currentAddress;
KdPrintfd2((“[DrvDispatch] Reads by file=NULL\n”));
/*currentAddress = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
if (currentAddress == NULL) {
KdPrintfd2((“[DrvDispatch] currentAddress=NULL PAS NORMAL\n”));
status= STATUS_INSUFFICIENT_RESOURCES;
goto trierrorop;
}*/
// here we could return the bootsector. If we don’t have one
// the requested read lenght must be returned as requested
Irp->IoStatus.Information = irps->Parameters.Read.Length;
KdPrintfd2((“[DrvDispatch] Offset:%d Reads finished with length:%d\n”,irps->Parameters.Read.ByteOffset.LowPart, Irp->IoStatus.Information));
status = STATUS_SUCCESS;
goto trierrorop;
}
//////END Line incriminating BUG1////////////
My entire code dispatch
NTSTATUS
DrvDispatch (
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp
)
{
PIO_STACK_LOCATION irps;
NTSTATUS status=STATUS_NOT_IMPLEMENTED;
KdPrintf((“[VFUM] control\n”));
irps=NULL;
if (Irp!=NULL)
{
irps = IoGetCurrentIrpStackLocation(Irp);
//if (irps!=NULL)
KdPrintfd((“[VFUM] vfums_control : Device:%x Majorfunction %d irp %x\n”,DeviceObject,irps->MajorFunction,Irp));
{
if (irps->MajorFunction == IRP_MJ_CREATE)
{
KdPrintfd((“[F DRVDISPATCH]IRP_MJ_CREATE \n”));
}
if (irps->MajorFunction==IRP_MJ_SYSTEM_CONTROL)
{
KdPrintfd((“IRP_MJ_SYSTEM_CONTROL\n”));
}
if (irps->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL)
{
KdPrintfd((“IRP_MJ_FILE_SYSTEM_CONTROL\n”));
}
}
/*if ((irps->MajorFunction==IRP_MN_CANCEL_REMOVE_DEVICE) || (irps->MajorFunction==IRP_MN_REMOVE_DEVICE) || (irps->MajorFunction==IRP_MJ_CLOSE) || (irps->MajorFunction==IRP_MN_QUERY_REMOVE_DEVICE) || (irps->MajorFunction==IRP_MN_STOP_DEVICE) || (irps->MajorFunction==IRP_MN_QUERY_STOP_DEVICE))
{
KdPrintf((“[VDUM] DeviceDispatch invalid device OK IRP_MN_REMOVE_DEVICE\n”));
status=STATUS_SUCCESS;
}
else
{
Irp->IoStatus.Status=status=STATUS_NO_MEDIA_IN_DEVICE;
Irp->IoStatus.Information=0;
}*/
//EFFETS DE BORD !!!
if (irps->MajorFunction==IRP_MJ_PNP)
{
KdPrintf((“IRP_MJ_PNP\n”));
status=STATUS_SUCCESS;
switch (irps->MinorFunction) {
case IRP_MN_QUERY_REMOVE_DEVICE:
KdPrintf((" IRP_MN_QUERY_REMOVE_DEVICE\n"));
break;
case IRP_MN_SURPRISE_REMOVAL:
KdPrintf((" IRP_MN_SURPRISE_REMOVAL\n"));
break;
case IRP_MN_REMOVE_DEVICE:
KdPrintf((" IRP_MN_REMOVE_DEVICE\n"));
break;
case IRP_MN_CANCEL_REMOVE_DEVICE:
KdPrintf((" IRP_MN_CANCEL_REMOVE_DEVICE\n"));
break;
case IRP_MN_QUERY_DEVICE_RELATIONS:
KdPrintf((" IRP_MN_QUERY_DEVICE_RELATIONS\n"));
status = STATUS_INVALID_PARAMETER;
break;
default:
KdPrintf((" other minnor function %d\n", irps->MinorFunction));
break;
//IoSkipCurrentIrpStackLocation(Irp);
//status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
}
Irp->IoStatus.Status=status;
goto ANC;
}
if (DeviceObject == DiskGlobal.pdiskcd)
{
KdPrintf((“[CD DISK FAT]\n”));
}
if (DeviceObject == DiskGlobal.pdiskcd)
{
KdPrintf((“[FILE DISK FAT]\n”));
}
///////////////////////
if (DeviceObject==g_devcontrol)
{
PVOID* p=NULL;
KdPrintf((“xxxxxxxx\n”));
if (irps->FileObject!=NULL)
p=irps->FileObject->FsContext2;
KdPrintfd((“Control VFUM irp %x irps %x context %x\n”,Irp,irps,p));
status=controldispatch(DeviceObject,Irp,irps);
Irp->IoStatus.Status=status;
KdPrintfdnotimpl((“Return information AV : %x\n”,Irp->IoStatus.Information));
KdPrintfd((“Control VFUM return status %x\n”,status));
}
#if SUPPORTRAWDISK
else
if (IsRawDisk(DeviceObject)==TRUE)
{
KdPrintfd ((“In RawDisk\n”));
KeEnterCriticalRegion();
status=controldiskrawsystem(DeviceObject,Irp,irps);
KeLeaveCriticalRegion();
if (status==STATUS_PENDING)
return status;
}
#endif
else
{
PPARAMVDF vdf;
KdPrintf((“[VFUM] Virtual disk\n”));
vdf=vdf_GetParam(DeviceObject);
KdPrintfd2((“[VFUM] dispatch_virtualdisk enter : Device:%x Majorfunction %d irp %x vdf=%x \n”,DeviceObject,irps->MajorFunction,vdf));
if (vdf!=NULL)
{
//if ((vdf->used==TRUE) && (vdf->parameter==TRUE))
{
PVOID* p=NULL;
BOOLEAN MOUNTED=((vdf->used==TRUE) && (vdf->parameter==TRUE) && (vdf->dismounting==FALSE));
if (irps->FileObject!=NULL)
p=irps->FileObject->FsContext2;
//KdPrintfd2((“[VFUM] vfums_control_virtualdisk irp %x irps %x context %x vdf=%x\n”,Irp,irps,p,vdf));
//if ((vdf->used==TRUE) && (vdf->parameter==TRUE))
{
FsRtlEnterFileSystem();
/*status=ccreate(DeviceObject,Irp,irps,irps->FileObject);
if (status!=STATUS_SUCCESS)
{
KdPrintf((“CCReate return status %x\n”,status));
goto trierrorop;
}*/
/*if ((irps->MajorFunction==IRP_MJ_CLOSE))
{
status=FatDirectClose(NULL,DeviceObject,Irp,irps);
status=STATUS_SUCCESS;
goto trierrorop;
}*/
/*if ((irps->MajorFunction==IRP_MJ_CLOSE))
{
KdPrintfd((“E IRP_MJ_CLOSE\n”));
IjThreadforclose(vdf,Irp);
KdPrintfd((“Wait thread\n”));
status=WaitObject(&vdf->eventclose,30);
KdPrintfd((“WaitObject from IRP_MJ_CLOSE return status %x\n”,status));
status=STATUS_SUCCESS;
goto trierrorop;
}*/
if ((irps->MajorFunction==IRP_MJ_CLEANUP))
{
PFILE_OBJECT _file;
PCCB fsc;
_file=irps->FileObject;
if (_file==NULL)
{
Irp->IoStatus.Information=0;
status=STATUS_SUCCESS;
goto trierrorop;
}
fsc=(PCCB)_file->FsContext2;
fsc=vdfsValidPointer(vdf,fsc);
__try
{
if (_file->FileName.Buffer!=NULL)
KdPrintfd2((“Cleanup FileName %wZ\n”,&_file->FileName));
}
__except (1)
{
KdPrintfd2((“Exception KdPrintfd2\n”));
}
if ((fsc!=NULL))
{
if (_file->SectionObjectPointer != NULL &&
_file->SectionObjectPointer->DataSectionObject != NULL) {
//fsc->debug2=TRUE;
KdPrintf((“FatCleanup Dump Cache\n”));
if (fsc->Fcb!=NULL)
CcFlushCache(&fsc->Fcb->SectionObjectPointers, NULL, 0, NULL);
KdPrintf((“FatCleanup Dump Cache2\n”));
if (fsc->Fcb!=NULL)
CcPurgeCacheSection(&fsc->Fcb->SectionObjectPointers, NULL, 0, FALSE);
KdPrintf((“FatCleanup Dump Cache3\n”));
if (issection(DeviceObject))
CcUninitializeCacheMap(_file, NULL, NULL);
KdPrintf((“FatCleanup Fin Dump \n”));
//fsc->debug2=FALSE;
}
else
KdPrintf((“FatCleanup not mapping\n”));
_file->Flags |= FO_CLEANUP_COMPLETE;
}
}
if (irps->MajorFunction==IRP_MJ_CLOSE)
{
//if (modevdf2(vdf)==TRUE)
{
if (MOUNTED==FALSE)
{
//SI LE LECTEUR EST DEMONTER IL FAUT LIBERER LE VCB SINON LE LIBERER PLUS TARD POUR QUE LE PROCESSUS
//USER CONNAISSE LE PARAM
PCCB fsc=NULL;
PFILE_OBJECT _file;
//KdPrintfd6((“MUST IT CLOSE ABCDEF\n”));
//PCCB fsc;
_file=irps->FileObject;
fsc=_file->FsContext2;
//A METTRE DANS UTH
ExAcquireResourceExclusiveLite(&vdf->ResourceNextFile, TRUE);
fsc=vdfsValidPointer(vdf,fsc);
if (fsc!=NULL)
{
PsharevdfsFCB fcb=fsc->Fcb;
////RemoveEntryList(&fsc->NextFile); ////EFFET DE BORD 09072017 COMMENT BSOD W10 COMPILER
vdfsDoneCCB(vdf,fsc);
vdfsFreeFCB(fcb);
/*RemoveEntryList(&fsc->NextFile);
vdfsFreeFCB(fsc->Fcb);
vdfsDoneCCB(vdf,fsc);*/
_file->FsContext=NULL;
_file->FsContext2=NULL;
// KdPrintfd2((“Ca Bug \n”));
}
ExReleaseResourceLite(&vdf->ResourceNextFile);
}
}
}
if (MOUNTED)
{
if ((irps->MajorFunction==IRP_MJ_CLOSE))
{
PFILE_OBJECT file;
//PCCB fsc;
file=irps->FileObject;
//fsc=(PCCB)file->FsContext2;
KdPrintfd2((“CLOSE\n”));
if (file->FileName.Buffer!=NULL)KdPrintfd2((“E CLOSE FileName %wZ \n”,&file->FileName));
//if (file->RelatedFileObject!=NULL)
// KdPrintfd2((“E CLOSE RelativeFileName %wZ \n”,&file->RelatedFileObject->FileName.Buffer));
/*if (fsc->debug2==TRUE)
{
KdPrintfd2((“Eh mince probl?me XXX4TOF\n”));
}
else
KdPrintfd2((“Bon XSFDFS44\n”));*/
//ON VEUX LE METTRE DANS LA LIST2
if (modevdf2(vdf)==TRUE)
{
status=PushCMD(DeviceObject,vdf,Irp);
if (status==STATUS_PENDING)
{
KdPrintf((“irp_mj_close status pending\n”));
FsRtlExitFileSystem();
return status;
}
else
if (!NT_SUCCESS(status))
goto trierrorop;
}
}
if ((irps->MajorFunction==IRP_MJ_CREATE))
{
if (modevdf2(vdf)==TRUE)
{
//ON VEUX LE METTRE DANS LA LIST2
status=PushCMD(DeviceObject,vdf,Irp);
if (status==STATUS_PENDING)
{
KdPrintf((“irp_mj_read status pending\n”));
FsRtlExitFileSystem();
return status;
}
else
if (!NT_SUCCESS(status))
goto trierrorop;
}
}
if ((irps->MajorFunction==IRP_MJ_DIRECTORY_CONTROL))
{
if ((irps->MinorFunction==IRP_MN_NOTIFY_CHANGE_DIRECTORY))
{
PPARAMVDF vdf;
PCCB fsc;
ULONG CompletionFilter;
PFILE_OBJECT file;
BOOLEAN WatchTree;
file=irps->FileObject;
KdPrintf((“IRP_MN_NOTIFY_CHANGE_DIRECTORY r?pertoire %wZ bt\n”,&file->FileName));
CompletionFilter = irps->Parameters.NotifyDirectory.CompletionFilter;
WatchTree = (irps->Flags& SL_WATCH_TREE)==SL_WATCH_TREE ;
vdf=(PPARAMVDF)DeviceObject->DeviceExtension;
KdPrintf((“IRP_MN_NOTIFY_CHANGE_DIRECTORY Before Context %x\n”,file->FsContext2));
FsRtlNotifyFullChangeDirectory( vdf->NotifySync,
&vdf->DirNotifyList,
file->FsContext2,
(PSTRING)&file->FileName,
WatchTree,
FALSE,
CompletionFilter,
Irp,
NULL,
NULL );
KdPrintf((“IRP_MN_NOTIFY_CHANGE_DIRECTORY After Context %x\n”,file->FsContext2));
fsc=(PCCB)file->FsContext2;
fsc=vdfsValidPointer(vdf,fsc);
if (fsc!=NULL)
fsc->evchgdirectory=TRUE;
else
KdPrintf((“IRP_MN_NOTIFY_CHANGE_DIRECTORY Not found fsc\n”));
Irp->IoStatus.Status=STATUS_SUCCESS;
status=STATUS_PENDING;
FsRtlExitFileSystem();
goto gty;
}
}
if ((irps->MajorFunction==IRP_MJ_WRITE) || (irps->MajorFunction==IRP_MJ_SET_INFORMATION)) //MODE MTHREAD uniqument
{
if (modevdf2(vdf)==TRUE)
{
PCOM2 ocom=NULL;
PVOID Buffer;
if (irps->MajorFunction==IRP_MJ_WRITE)
{
if (irps->Parameters.Write.Length==0)
{
KdPrintfd2((" writelength NULL\n"));
Irp->IoStatus.Information=0;
status=STATUS_SUCCESS;
goto trierrorop;
}
if (Irp->MdlAddress) {
KdPrintfd2((" use MdlAddress\n"));
Buffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
} else {
KdPrintfd2((" use UserBuffer\n"));
Buffer = Irp->UserBuffer;
}
}
else
Buffer=Irp->AssociatedIrp.SystemBuffer;
status=Pre_PushCMD(DeviceObject,vdf,Irp,&ocom);
//ON VEUX LE METTRE DANS LA LIST2
//status=PushCMD(DeviceObject,vdf,Irp);
if (status==STATUS_PENDING)
{
copypsp(&ocom->in_data,Buffer,irps->Parameters.Write.Length);
_i_p(vdf,ocom);
KdPrintf((“irp_mj_read status pending\n”));
FsRtlExitFileSystem();
return status;
}
else
if (!NT_SUCCESS(status))
goto trierrorop;
}
}
//if ((irps->MajorFunction==IRP_MJ_READ) || (irps->MajorFunction==IRP_MJ_WRITE))
if ((irps->MajorFunction==IRP_MJ_WRITE) || (irps->MajorFunction==IRP_MJ_SET_INFORMATION))
{
PFILE_OBJECT file;
PVOID Buffer;
KdPrintfd2((“WRITE\n”));
if (irps->MajorFunction==IRP_MJ_WRITE)
KdPrintfd((“E IRP_MJ_WRITE\n”));
if (irps->MajorFunction==IRP_MJ_SET_INFORMATION)
KdPrintfd((“E IRP_MJ_SET_INFORMATION\n”));
file=irps->FileObject;
if (file==NULL)
{
KdPrintfd2((“E Write File==NULL\n”));
status=STATUS_INVALID_PARAMETER;
goto trierrorop;
}
if (irps->MajorFunction==IRP_MJ_WRITE)
{
if (irps->Parameters.Write.Length==0)
{
KdPrintfd2((" writelength NULL\n"));
Irp->IoStatus.Information=0;
status=STATUS_SUCCESS;
goto trierrorop;
}
if (Irp->MdlAddress) {
KdPrintfd2((" use MdlAddress\n"));
Buffer = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
} else {
KdPrintfd2((" use UserBuffer\n"));
Buffer = Irp->UserBuffer;
}
}
else
{
KdPrintf((“IK SetInformation %x\n”));
Buffer=Irp->AssociatedIrp.SystemBuffer;
}
if (file!=NULL)
{
DWORD *dw=(DWORD*)Buffer;
PCCB fsc=(PCCB)file->FsContext2;
KdPrintfd2((“[INT] Write Offset %x Data %x\n”,irps->Parameters.Write.ByteOffset.LowPart,*dw));
fsc=vdfsValidPointer(vdf,fsc);
if (fsc==NULL)
{
status=STATUS_INVALID_HANDLE;
goto trierrorop;
}
if (fsc->debug1==TRUE)
KdPrintfd2((" mettre des spin\n"));
fsc->debug1=TRUE;
if (fsc->bufferwrite!=NULL)
{
ExFreePool(fsc->bufferwrite);
}
fsc->bufferwrite=ExAllocatePool(NonPagedPool,fsc->sizewrite=irps->Parameters.Write.Length);
if (fsc->bufferwrite!=NULL)
{
RtlCopyMemory(fsc->bufferwrite,Buffer,fsc->sizewrite);
status=STATUS_SUCCESS;
}
else
{
KdPrintfd2((“Insufficent ressource\n”));
status=STATUS_INSUFFICIENT_RESOURCES;
goto trierrorop;
}
}
else
KdPrintfd2((“File==NULL\n”));
}
if ((irps->MajorFunction==IRP_MJ_READ))
{
PFILE_OBJECT fileObject = irps->FileObject;
ULONG Length;
PMDL mdl;
if ((vdf->used==TRUE) && (vdf->parameter==TRUE))
{
}
else
{
//DISK INUTILISER OU DISCONNECTED
status=STATUS_DEVICE_NOT_READY;
goto trierrorop;
}
if (irps->MajorFunction==IRP_MJ_READ)
Length = irps->Parameters.Read.Length;
else
Length = irps->Parameters.Write.Length;
KdPrintfd2((“Int IRP_MJ_READ Offset %x Length %x\n”,irps->Parameters.Read.ByteOffset.LowPart,Length));
if (irps->Parameters.Read.Length==0)
{
Irp->IoStatus.Information=0;
status=STATUS_SUCCESS;
goto trierrorop;
}
if (irps->MinorFunction == IRP_MN_COMPLETE) {
Irp->MdlAddress = NULL;
KdPrintfd2((“IRP_MN_COMPLETE”));
status = STATUS_SUCCESS;
goto trierrorop;
}
//////BEGIN Line incriminating BUG1////////////
if ((fileObject == NULL)&& (Irp->MdlAddress != NULL))
{
//effet de bord 140720174
PVOID currentAddress;
KdPrintfd2((“[DrvDispatch] Reads by file=NULL\n”));
/*currentAddress = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
if (currentAddress == NULL) {
KdPrintfd2((“[DrvDispatch] currentAddress=NULL PAS NORMAL\n”));
status= STATUS_INSUFFICIENT_RESOURCES;
goto trierrorop;
}*/
// here we could return the bootsector. If we don’t have one
// the requested read lenght must be returned as requested
Irp->IoStatus.Information = irps->Parameters.Read.Length;
KdPrintfd2((“[DrvDispatch] Offset:%d Reads finished with length:%d\n”,irps->Parameters.Read.ByteOffset.LowPart, Irp->IoStatus.Information));
status = STATUS_SUCCESS;
goto trierrorop;
}
//////END Line incriminating BUG1////////////
////A REFLECHIR
if (fileObject == NULL) {
KdPrintfd2((“[DrvDispatch] fileObject == NULL\n”));
status = STATUS_INVALID_DEVICE_REQUEST;
goto trierrorop;;
}
/////
/*mdl = IoAllocateMdl(Irp->UserBuffer, irps->Parameters.QueryDirectory.Length, FALSE, FALSE, Irp);
__try {
MmProbeAndLockPages(Irp->MdlAddress, Irp->RequestorMode, IoWriteAccess);
} __except (EXCEPTION_EXECUTE_HANDLER)
{
KdPrintf((“IRP_MJ_READ or IRP_MJ_WRITE MmProveAndLockPages error\n”));
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
status= STATUS_INSUFFICIENT_RESOURCES;
goto trierrorop;
} */
if (Irp->MdlAddress==NULL)
{
KdPrintfd2((“Int IRP_MJ_READ Irp->MdlAddress==NULL\n”));
status=AllocateMdl(Irp,irps->Parameters.Read.Length);
if (!NT_SUCCESS(status))
{
KdPrintfd2((“Failure Get MDL\n”));
goto trierrorop;
}
else
KdPrintfd2((“OK allocate MDL\n”));
}
else
KdPrintfd2((“Irp->MdlAdress!=NULL\n”));
if (modevdf2(vdf)==TRUE)
{
//ON VEUX LE METTRE DANS LA LIST2
status=PushCMD(DeviceObject,vdf,Irp);
if (status==STATUS_PENDING)
{
KdPrintf((“irp_mj_read status pending\n”));
FsRtlExitFileSystem();
return status;
}
else
if (!NT_SUCCESS(status))
goto trierrorop;
}
//status=STATUS_SUCCESS;
}
if ((irps->MajorFunction==IRP_MJ_QUERY_SECURITY))
{
ULONG bufferLength = irps->Parameters.QuerySecurity.Length;
//BSOD RISK !!!
if (Irp->UserBuffer != NULL && bufferLength > 0) {
// make a MDL for UserBuffer that can be used later on another thread context
if (Irp->MdlAddress == NULL) {
status = AllocateMdl(Irp, bufferLength);
KdPrintfd2((“IRP_MJ_QUERY_SECURITY allocate error mdl %x\n”,status));
if (!NT_SUCCESS(status)) {
goto trierrorop;
//
}
}
}
KdPrintfd2((“IRP_MJ_QUERY_SECURITY ALLOCATE MDL OK with size %d!!!\n”,bufferLength));
status=STATUS_SUCCESS;
///////
}
if ((irps->MajorFunction==IRP_MJ_SET_SECURITY))
{
KdPrintfd2((“IRP_MJ_SET_SECURITY\n”));
}
if ((irps->MajorFunction==IRP_MJ_DEVICE_CONTROL))
{
ULONG Length;
PMDL mdl;
if (irps->Parameters.DeviceIoControl.IoControlCode==IOCTL_REDIR_QUERY_PATH)
{
Length = irps->Parameters.Read.Length;
KdPrintfd2((“Int IRP_MJ_DEVICE_CONTROL Offset %x Length %x\n”,irps->Parameters.Read.ByteOffset.LowPart,Length));
/*mdl = IoAllocateMdl(Irp->UserBuffer, irps->Parameters.QueryDirectory.Length, FALSE, FALSE, Irp);
__try {
MmProbeAndLockPages(Irp->MdlAddress, Irp->RequestorMode, IoWriteAccess);
} __except (EXCEPTION_EXECUTE_HANDLER)
{
KdPrintf((“IRP_MJ_READ or IRP_MJ_WRITE MmProveAndLockPages error\n”));
IoFreeMdl(Irp->MdlAddress);
Irp->MdlAddress = NULL;
status= STATUS_INSUFFICIENT_RESOURCES;
goto trierrorop;
} */
if (Irp->MdlAddress==NULL)
{
KdPrintfd2((“Int IRP_MJ_DEVICE_CONTROL Irp->MdlAddress==NULL\n”));
status=AllocateMdl(Irp,sizeof (QUERY_PATH_RESPONSE));
if (!NT_SUCCESS(status))
goto trierrorop;
}
}
}
if (irps->MajorFunction==IRP_MJ_DIRECTORY_CONTROL)
{
if (irps->MinorFunction==IRP_MN_QUERY_DIRECTORY)
{
UCHAR* Buffer;
int cdebug;
UCHAR cdebug1;
ULONG Length = irps->Parameters.QueryDirectory.Length;
/*est-ce*/
if (Irp->MdlAddress==NULL)
{
KdPrintf((“Int IRP_MN_QUERY_DIRECTORY Irp->MdlAddress==NULL\n”));
status=AllocateMdl(Irp,irps->Parameters.QueryDirectory.Length);
if (!NT_SUCCESS(status))
goto trierrorop;
}
/*Buffer=FatMapUserBuffer(Irp);
//Buffer=NULL;
for (cdebug = 0 ; cdebug < Length; cdebug++)
{
cdebug1=Buffer[cdebug];
}*/
//ON VEUX LE METTRE DANS LA LIST2
if (modevdf2(vdf)==TRUE)
{
status=PushCMD(DeviceObject,vdf,Irp);
if (status==STATUS_PENDING)
{
KdPrintf((“irp_mj_read status pending\n”));
FsRtlExitFileSystem();
return status;
}
else
if (!NT_SUCCESS(status))
goto trierrorop;
}
//status=STATUS_SUCCESS;
}
}
//KIRQL oldirql;
//MUTEX_P(vdf->lock,&oldirql);
//status=vdfdispatch(DeviceObject,Irp,irps);
//PPARAMVDF vd=(PPARAMVD)DeviceObject->DeviceExtension;
IjThread(vdf,Irp);
//Irp->IoStatus.Status=STATUS_PENDING;
status=STATUS_PENDING;
trierrorop:;
if (status!=STATUS_PENDING)
{
if (status==STATUS_NOT_IMPLEMENTED)
{
KdPrintfdnotimpl((“[system] Not Implemented Majorfunction:%x MinorFunction:%x\n”,irps->MajorFunction,irps->MinorFunction));
}
KdPrintfd2((“Error before pushthread %x\n”,status));
Irp->IoStatus.Status=status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
}
//trierror:
FsRtlExitFileSystem();
return status;
}
else
{
KdPrintfd((“DISK UNLOADED !!! FORBIDDEN REQUEST !!!\n”));
Irp->IoStatus.Status=status=STATUS_DEVICE_REMOVED;
if ((irps->MajorFunction==IRP_MJ_CLOSE)
||
(irps->MajorFunction==IRP_MJ_CLEANUP)
)
{
//LE CLOSE POSE PROBLEME DANS FILE PCCB !!!
Irp->IoStatus.Status=status=STATUS_SUCCESS;
}
Irp->IoStatus.Information=0;
FsRtlExitFileSystem();
}
//MUTEX_V(vdf->lock,oldirql);
}
/*else
{
KdPrintfd((“[VFUM] dispatch_virtualdisk : Device:%x Majorfunction %d irp %x not configured or not initialized %d %d \n”,DeviceObject,irps->MajorFunction,Irp,vdf->used,vdf->parameter));
status=STATUS_DEVICE_NOT_READY;
}*/
}
/*else
{
KdPrintfd((“DISK UNLOADED !!! FORBIDDEN REQUEST !!!\n”));
Irp->IoStatus.Status=status=STATUS_DEVICE_REMOVED;
Irp->IoStatus.Information=0;
}*/
}
else
{
KdPrintfd((“Handle not found\n”));
status=STATUS_INVALID_HANDLE;
}
}
//INCRIMINATION BUG ???
//Irp->IoStatus.Status=status;
ANC:;
if (status==STATUS_NOT_IMPLEMENTED)
{
KdPrintfdnotimpl((“[systemg] Not Implemented Majorfunction:%x MinorFunction:%x\n”,irps->MajorFunction,irps->MinorFunction));
}
KdPrintfdnotimpl((“Return information : %x\n”,Irp->IoStatus.Information));
IoCompleteRequest(Irp, IO_NO_INCREMENT);
gty:
return status;
}
else
return STATUS_SUCCESS;
}