Hi,
bug kernel of this function CcPurgeCacheSection.
In my virtual disk file system , i execute two same filename executable (ex. n:\notepad.exe) and in
IRP_MJ_CLEANUP , this function CcPurgeCacheSection freeze (don’t respond without bluescreen) then my driver is blocked by function CcPurgeCacheSection.
Thank you for help
All my LIST_ENTRY and handle are initialized else it’s bluescreen
fcp.c
PsharevdfsFCB
vdfsAllocateFCB(
__in PPARAMVDF vdf
)
{
PsharevdfsFCB fcb = ExAllocatePool(NonPagedPool,sizeof(sharevdfsFCB));
if (fcb == NULL) {
return NULL;
}
ASSERT(fcb != NULL);
RtlZeroMemory(fcb, sizeof(sharevdfsFCB));
//fcb->Identifier.Type = FCB;
//fcb->Identifier.Size = sizeof(DokanFCB);
fcb->vdf = vdf;
ExInitializeResourceLite(&fcb->MainResource);
ExInitializeResourceLite(&fcb->PagingIoResource);
ExInitializeFastMutex(&fcb->AdvancedFCBHeaderMutex);
#if _WIN32_WINNT >= 0x0501
FsRtlSetupAdvancedHeader(&fcb->AdvancedFCBHeader, &fcb->AdvancedFCBHeaderMutex);
#else
if (DokanFsRtlTeardownPerStreamContexts) {
FsRtlSetupAdvancedHeader(&fcb->AdvancedFCBHeader, &fcb->AdvancedFCBHeaderMutex);
}
#endif
fcb->AdvancedFCBHeader.ValidDataLength.LowPart = 0xffffffff;
fcb->AdvancedFCBHeader.ValidDataLength.HighPart = 0x7fffffff;
fcb->AdvancedFCBHeader.Resource = &fcb->MainResource;
fcb->AdvancedFCBHeader.PagingIoResource = &fcb->PagingIoResource;
fcb->AdvancedFCBHeader.AllocationSize.QuadPart = 4096;
fcb->AdvancedFCBHeader.FileSize.QuadPart = 4096;
fcb->AdvancedFCBHeader.IsFastIoPossible = FastIoIsNotPossible;
ExInitializeResourceLite(&fcb->Resource);
KdPrintfd2((“Allocate FCB:InsertTail\n”));
InitializeListHead(&fcb->NextCCB);
InsertTailList(&vdf->NextFCB, &fcb->NextFCB);
KdPrintfd2((“OK Allocate FCB:InsertTail\n”));
//InterlockedIncrement(&vdf->FcbAllocated);
return fcb;
}
PCCB vdfsAllocateCCB(PFILE_OBJECT file,PsharevdfsFCB fcb)
{
PCCB ccb;
ccb = (PCCB)ExAllocatePool(NonPagedPool,sizeof (TCCB));
RtlZeroMemory(ccb,sizeof (TCCB));
ccb->Fcb=fcb;
ccb->file=file;
InitializeListHead(&ccb->NextCCB);
InsertTailList(&fcb->NextCCB, &ccb->NextCCB);
return ccb;
}
void vdfsDoneCCB(PCCB ccb)
{
KeEnterCriticalRegion();
RemoveEntryList(&ccb->NextCCB);
ExFreePool(ccb);
KeLeaveCriticalRegion();
}
PsharevdfsFCB
vdfsGetFCB(
__in PPARAMVDF vdf,
__in PWCHAR FileName,
__in ULONG FileNameLength)
{
PLIST_ENTRY thisEntry, nextEntry, listHead;
PsharevdfsFCB fcb = NULL;
ULONG pos;
KeEnterCriticalRegion();
//ExAcquireResourceExclusiveLite(&vdf->Resource, TRUE);
// search the FCB which is already allocated
// (being used now)
listHead = &vdf->NextFCB;
//KdPrintfd2((“Search File %ws\n”,FileName));
for (thisEntry = listHead->Flink;
thisEntry != listHead;
thisEntry = nextEntry) {
nextEntry = thisEntry->Flink;
fcb = CONTAINING_RECORD(thisEntry, sharevdfsFCB, NextFCB);
__try
{
//KdPrintfd2((“File : (%ws)\n”,fcb->FileName.Buffer));
}
__except(1)
{
}
if (fcb->FileName.Length == FileNameLength) {
// FileNameLength in bytes
for (pos = 0; pos < FileNameLength/sizeof(WCHAR); ++pos) {
if (fcb->FileName.Buffer[pos] != FileName[pos])
break;
}
// we have the FCB which is already allocated and used
if (pos == FileNameLength/sizeof(WCHAR))
break;
}
fcb = NULL;
}
// we don’t have FCB
if (fcb == NULL) {
KdPrintfd2((" Allocate FCB \n"));
fcb = vdfsAllocateFCB(vdf);
// no memory?
if (fcb == NULL) {
ExFreePool(FileName);
//ExReleaseResourceLite(&Vcb->Resource);
KeLeaveCriticalRegion();
return NULL;
}
ASSERT(fcb != NULL);
fcb->FileName.Buffer = FileName;
fcb->FileName.Length = (USHORT)FileNameLength;
fcb->FileName.MaximumLength = (USHORT)FileNameLength;
// we already have FCB
} else {
// FileName (argument) is never used and must be freed
KdPrintfd2((“Trouv?\n”));
ExFreePool(FileName);
}
//ExReleaseResourceLite(&Vcb->Resource);
KeLeaveCriticalRegion();
InterlockedIncrement(&fcb->FileCount);
//KdPrintfd2((“FileCount %x\n”,fcb->FileCount));
return fcb;
}
NTSTATUS
vdfsFreeFCB(
__in PsharevdfsFCB Fcb
)
{
PPARAMVDF vcb;
ASSERT(Fcb != NULL);
vcb = Fcb->vdf;
KeEnterCriticalRegion();
// ExAcquireResourceExclusiveLite(&vcb->Resource, TRUE);
ExAcquireResourceExclusiveLite(&Fcb->Resource, TRUE);
Fcb->FileCount–;
//
KdPrintfd2((“vdfsFreeFCB FileCount %x\n”,Fcb->FileCount));
KdPrintfd2((“vdfsFreeFCB (%ws) \n”,Fcb->FileName.Buffer));
if (Fcb->FileCount == 0) {
KdPrintfd2((“Close vdfsFreeFCB (%ws) \n”,Fcb->FileName.Buffer));
RemoveEntryList(&Fcb->NextFCB);
//KdPrintfd2((" Free FCB:%X\n", Fcb));
ExFreePool(Fcb->FileName.Buffer);
#if _WIN32_WINNT >= 0x0501
FsRtlTeardownPerStreamContexts(&Fcb->AdvancedFCBHeader);
#else
if (DokanFsRtlTeardownPerStreamContexts) {
DokanFsRtlTeardownPerStreamContexts(&Fcb->AdvancedFCBHeader);
}
#endif
ExReleaseResourceLite(&Fcb->Resource);
ExDeleteResourceLite(&Fcb->Resource);
ExDeleteResourceLite(&Fcb->MainResource);
ExDeleteResourceLite(&Fcb->PagingIoResource);
//InterlockedIncrement(&vcb->FcbFreed);
ExFreePool(Fcb);
} else {
ExReleaseResourceLite(&Fcb->Resource);
}
//ExReleaseResourceLite(&vcb->Resource);
KeLeaveCriticalRegion();
return STATUS_SUCCESS;
}
function.c
NTSTATUS FatCommonCreate(HANDLE hProcess, PDEVICE_OBJECT DeviceObject,PIRP irp,PIO_STACK_LOCATION irps)
{
__try
{
TCREATEFILE cf;
WCHAR *csfilename;
WCHAR *csrelativefilename;
WORD lencsfilename;
WORD lencsrelativefilename;
PFILE_OBJECT _file;
PFILE_OBJECT _relatedfile;
PFILE_OBJECT relatedFileObject;
ULONG fileNameLength = 0;
PWCHAR fileName;
PPARAMVDF vdf;
NTSTATUS status;
NTSTATUS error;
CHAR* c;
int size;
KdPrintfd((“FatCommonCreate\n”));
vdf=vdf_GetParam(DeviceObject);
cf.Options=irps->Parameters.Create.Options;
cf.FileAttributes=irps->Parameters.Create.FileAttributes;
cf.ShareAccess=irps->Parameters.Create.ShareAccess;
cf.EaLength=irps->Parameters.Create.EaLength;
_file=irps->FileObject;
if (_file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
return STATUS_INTERNAL_ERROR;
}
csfilename=_file->FileName.Buffer;
lencsfilename=_file->FileName.Length;
lencsrelativefilename=2;
//csrelativefilename=“”;
relatedFileObject=_relatedfile=_file->RelatedFileObject;
if (_relatedfile==NULL)
{
KdPrintf((“relatedfile=NULL Why ?\n”));
_relatedfile=_file;
csrelativefilename=&nib;
}
else
{
csrelativefilename=_relatedfile->FileName.Buffer;
lencsrelativefilename=_relatedfile->FileName.Length;
}
size=lencsfilename+2+lencsrelativefilename+2;
KdPrintfd((“FatCommonCreate FileName %ws RelatedFileName %ws vdf:%x\n”,csfilename,csrelativefilename,vdf));
//size=size<<1;
c=(CHAR*)ExAllocatePoolWithTag(NonPagedPool,size+128,40);
if (c!=NULL)
{
POUTCREATE cc=NULL;
PVOID paramold;
KdPrintf2((“memset c,0\n”));
memset(c,0,size);
KdPrintf2((“memcpy(c+0,file->FileName.Buffer,file->FileName.Length*2);\n”));
if (csfilename!=NULL)memcpy(c+0,csfilename,lencsfilename*1);
KdPrintf2((“memcpy(c+(1+(file->FileName.Length*2)),relatedfile->FileName.Buffer);\n”));
if (csrelativefilename!=NULL)memcpy(c+(2+(lencsfilename*1)),csrelativefilename,lencsrelativefilename*1);
FillHandle(hProcess,&cf.h,irp,irps);
paramold=vdf->bufferstruct;
KdPrintf2((“Calluser\n”));
status=CallUser(vdf,CMD_CREATEFILE,sizeof (TCREATEFILE),&cf,size,c,&error);
KdPrintf2((“ExFreePool\n”));
//ExFreePool(c);
if (vdf->updatestruct==TRUE)
cc=(POUTCREATE)vdf->bufferstruct;
else
KdPrintf((“FatCommonCreate on n’a rien fait\n”));
KdPrintf((“FatCommonCreate set status %x\n”,error));
if (cc==NULL)
{
ExFreePool(c);
return STATUS_INVALID_PARAMETER;
}
else
{
irp->IoStatus.Information=cc->Information;
KdPrintf((“Set Information %x\n”,irp->IoStatus.Information));
}
if (error==STATUS_SUCCESS)
{
int sn=min(sizeof(TOUTCREATE),vdf->sizebufferstruct);
KdPrintf2((“FatCommonCreate Fix FsContext2\n”));
//irps->FileObject->FsContext2=paramold;
/*if (cc!=NULL)
memcpy(&irps->FileObject->FsContext2,&cc->context,sn);
if (irps->FileObject->FsContext2==NULL)
{
KdPrintf((“FatCommonCreate Why Fscontext is equal NULL\n”));
}
else
KdPrintf((“FatCommonCreate Fscontext equal (%x)\n”,irps->FileObject->FsContext2));*/
//if (cc->section==TRUE)
{
//AJOUT
//
PsharevdfsFCB fsc=NULL;
PCCB ccb=NULL;
#if moi
fsc=(PFSC)ExAllocatePoolWithTagZero(NonPagedPool,sizeof (vdfsFCB),0xfeea);
#else
fileNameLength = _file->FileName.Length;
if (relatedFileObject) {
fileNameLength += relatedFileObject->FileName.Length;
/*if (fileObject->FileName.Length > 0 &&
fileObject->FileName.Buffer[0] == ‘\’) {
DDbgPrint(" when RelatedFileObject is specified, the file name should be relative path\n");
status = STATUS_OBJECT_NAME_INVALID;
__leave;
}*/
if (relatedFileObject->FileName.Length > 0 &&
relatedFileObject->FileName.Buffer[relatedFileObject->FileName.Length/sizeof(WCHAR)-1] != ‘\’) {
//needBackSlashAfterRelatedFile = TRUE;
fileNameLength += sizeof(WCHAR);
}
}
fileName = ExAllocatePool(NonPagedPool,fileNameLength + sizeof(WCHAR)+256);
if (fileName == NULL) {
status = STATUS_INSUFFICIENT_RESOURCES;
__leave;
}
RtlZeroMemory(fileName, fileNameLength + sizeof(WCHAR)+256);
if (relatedFileObject != NULL) {
KdPrintfd((" RelatedFileName:%wZ\n", &relatedFileObject->FileName));
// copy the file name of related file object
RtlCopyMemory(fileName,
relatedFileObject->FileName.Buffer,
relatedFileObject->FileName.Length);
/* if (needBackSlashAfterRelatedFile) {
((PWCHAR)fileName)[relatedFileObject->FileName.Length/sizeof(WCHAR)] = ‘\’;
}*/
// copy the file name of fileObject
RtlCopyMemory((PCHAR)fileName +
relatedFileObject->FileName.Length +
sizeof (WCHAR),
//(needBackSlashAfterRelatedFile? sizeof(WCHAR) : 0),
_file->FileName.Buffer,
_file->FileName.Length);
} else {
// if related file object is not specifed, copy the file name of file object
RtlCopyMemory(fileName,
_file->FileName.Buffer,
_file->FileName.Length);
}
fsc=vdfsGetFCB(vdf,fileName,fileNameLength);
#endif
//AdvancedFCBHeader=ExAllocatePoolWithTag(NonPagedPool,len=sizeof (AdvancedFCBHeader),0xfeed);
if (fsc!=NULL)
{
#if moi
if (cc->section==TRUE)
{
#endif
#if moi
ExInitializeResourceLite(&fsc->MainResource);
ExInitializeResourceLite(&fsc->PagingIoResource);
ExInitializeFastMutex(&fsc->HeaderMutex);
ExInitializeResourceLite(&fsc->Resource);
FsRtlSetupAdvancedHeader(&fsc->FCBHeader, &fsc->HeaderMutex);
if (irps->Flags & SL_OPEN_PAGING_FILE) {
fsc->FCBHeader.Flags2 |= FSRTL_FLAG2_IS_PAGING_FILE;
fsc->FCBHeader.Flags2 &= ~FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS;
}
// ExAcquireResourceExclusiveLite(&fcs->Resource, TRUE);
//RtlZeroMemory(AdvancedFCBHeader,len);
fsc->FCBHeader.ValidDataLength.LowPart = 0xffffffff;
fsc->FCBHeader.ValidDataLength.HighPart = 0x7fffffff;
fsc->FCBHeader.Resource = &fsc->MainResource;
fsc->FCBHeader.PagingIoResource = &fsc->PagingIoResource;
fsc->FCBHeader.AllocationSize.QuadPart = 4096;
fsc->FCBHeader.FileSize.QuadPart = 4096;
fsc->FCBHeader.IsFastIoPossible = FastIoIsNotPossible;
#endif
//fsc->Context=(PVOID)cc->context;
//if (cc->section==TRUE)
_file->SectionObjectPointer=&fsc->SectionObjectPointers;
_file->FsContext=&fsc->AdvancedFCBHeader;
_file->PrivateCacheMap=NULL;
}
else
{
//KdPrintf((“No section\n”));
KdPrintf((“FatCommonCreate fsc=NULL\n”));
return STATUS_INSUFFICIENT_RESOURCES;
}
if (irps->Flags & SL_OPEN_PAGING_FILE) {
KdPrintf((“Opened mode ImageFile\n”));
fsc->AdvancedFCBHeader.Flags2 |= FSRTL_FLAG2_IS_PAGING_FILE;
fsc->AdvancedFCBHeader.Flags2 &= ~FSRTL_FLAG2_SUPPORTS_FILTER_CONTEXTS;
}
if (relatedFileObject != NULL) {
_file->Vpb = relatedFileObject->Vpb;
} else {
_file->Vpb = DeviceObject->Vpb;
}
ccb=vdfsAllocateCCB(_file,fsc);
ccb->section=cc->section;
ccb->bufferwrite=NULL;
ccb->sizewrite=0;
ccb->debug1=FALSE;
//_file->FsContext2=fsc;
_file->FsContext2=ccb;
ccb->evchgdirectory=FALSE;
InsertTailList(&vdf->NextFile,&ccb->NextFile);
if (cc->Information==FILE_CREATED)
{
vdfsNotifyReportChange(fsc, FILE_NOTIFY_CHANGE_FILE_NAME, FILE_ACTION_ADDED);
}
//ExReleaseResourceLite(&fcs->Resource);
#if moi
}
else
{
KdPrintf((“FatCommonCreate fsc=NULL\n”));
return STATUS_INSUFFICIENT_RESOURCES;
}
#endif
}
{
PCCB fsc=NULL;
fsc=(PCCB)_file->FsContext2;
fsc->Context=cc->context;
}
{
}
}
ExFreePool(c);
KdPrintf2((“Fin\n”));
if (error==STATUS_TIMEOUT)
return STATUS_DEVICE_NOT_READY;
else
return error;
}
else
return STATUS_INSUFFICIENT_RESOURCES;
//status=CallUser(
}
__except (1)
{
KdPrintf((“FatCommmonCreate exception\n”));
return STATUS_INTERNAL_ERROR;
}
return STATUS_SUCCESS;
}
NTSTATUS FatCleanup(HANDLE hProcess, PDEVICE_OBJECT DeviceObject,PIRP irp,PIO_STACK_LOCATION irps)
{
__try
{
PCCB fsc;
PPARAMVDF vdf;
NTSTATUS status;
NTSTATUS error;
WCHAR *csfilename;
WCHAR *csrelativefilename;
WORD lencsfilename;
WORD lencsrelativefilename;
PFILE_OBJECT _file;
PFILE_OBJECT _relatedfile;
UCHAR* c;
int size;
KdPrintfd((“FatCleanup\n”));
/*file=irps->FileObject;
relatedfile=file->RelatedFileObject;
if (file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
return STATUS_INTERNAL_ERROR;
}
relatedfile=file->RelatedFileObject;
if (relatedfile==NULL)
{
KdPrintf((“relatedfile=NULL Why ?\n”));
relatedfile=file;
}*/
KdPrintfd2((“Cleanup\n”));
_file=irps->FileObject;
if (_file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
KdPrintf((“Errcleanup1\n”));
return STATUS_SUCCESS;
}
vdf=vdf_GetParam(DeviceObject);
irp->IoStatus.Information=0;
fsc=(PCCB)_file->FsContext2;
if ((fsc!=NULL))
{
if (_file->SectionObjectPointer != NULL &&
_file->SectionObjectPointer->DataSectionObject != NULL) {
KdPrintf((“FatCleanup Dump Cache\n”));
CcFlushCache(&fsc->Fcb->SectionObjectPointers, NULL, 0, NULL);
KdPrintf((“FatCleanup Dump Cache2\n”));
CcPurgeCacheSection(&fsc->Fcb->SectionObjectPointers, NULL, 0, FALSE);
KdPrintf((“FatCleanup Dump Cache3\n”));
CcUninitializeCacheMap(_file, NULL, NULL);
KdPrintf((“FatCleanup Fin Dump \n”));
}
else
KdPrintf((“FatCleanup not mapping\n”));
_file->Flags |= FO_CLEANUP_COMPLETE;
}
if (vdf==NULL)
{
KdPrintf((“FatCleanup : vdf==NULL”));
KdPrintf((“Errcleanup2\n”));
return STATUS_SUCCESS;
}
_file=irps->FileObject;
if (_file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
KdPrintf((“Errcleanup3\n”));
return STATUS_INTERNAL_ERROR;
}
csfilename=_file->FileName.Buffer;
lencsfilename=_file->FileName.Length;
lencsrelativefilename=2;
//csrelativefilename=“”;
_relatedfile=_file->RelatedFileObject;
if (_relatedfile==NULL)
{
KdPrintf((“relatedfile=NULL Why ?\n”));
_relatedfile=_file;
csrelativefilename=&nib;
}
else
{
csrelativefilename=_relatedfile->FileName.Buffer;
lencsrelativefilename=_relatedfile->FileName.Length;
}
size=lencsfilename+2+lencsrelativefilename+2;
KdPrintfd2((“FatCleanup FileName %ws RelatedFileName %ws vdf:%x\n”,csfilename,csrelativefilename,vdf));
//size=file->FileName.Length+2+relatedfile->FileName.Length+2;
//size=size<<1;
c=(WCHAR*)ExAllocatePoolWithTag(NonPagedPool,size+128,43);
if (c!=NULL)
{
THANDLES h;
KdPrintf2((“memset c,0\n”));
memset(c,0,size);
KdPrintf2((“memcpy(c+0,file->FileName.Buffer,file->FileName.Length*2);\n”));
if (csfilename!=NULL)memcpy(c+0,csfilename,lencsfilename*1);
KdPrintf2((“memcpy(c+(1+(file->FileName.Length*2)),relatedfile->FileName.Buffer);\n”));
if (csrelativefilename!=NULL)memcpy(c+(2+(lencsfilename*1)),csrelativefilename,lencsrelativefilename*1);
FillHandle(hProcess,&h,irp,irps);
KdPrintf2((“Calluser\n”));
status=CallUser(vdf,CMD_CLEANUP,sizeof (THANDLES),&h,size,c,&error);
KdPrintf2((“ExFreePool\n”));
ExFreePool(c);
KdPrintf2((“Fin\n”));
if (error==STATUS_TIMEOUT)
return STATUS_DEVICE_NOT_READY;
else
return error;
}
else
{
KdPrintf((“Errcleanup7\n”));
return STATUS_INSUFFICIENT_RESOURCES;
}
}
__except (1)
{
KdPrintf((“FatCleanup exception\n”));
KdPrintf((“Errcleanup6\n”));
return STATUS_INTERNAL_ERROR;
}
return STATUS_SUCCESS;
}
NTSTATUS FatCommonClose(HANDLE hProcess, PDEVICE_OBJECT DeviceObject,PIRP irp,PIO_STACK_LOCATION irps)
{
__try
{
PPARAMVDF vdf;
NTSTATUS status;
NTSTATUS error;
WCHAR *csfilename;
WCHAR *csrelativefilename;
WORD lencsfilename;
WORD lencsrelativefilename;
PFILE_OBJECT _file;
PFILE_OBJECT _relatedfile;
UCHAR* c;
int size;
//KdPrintfd2((“FatCommonClose\n”));
/*file=irps->FileObject;
relatedfile=file->RelatedFileObject;
if (file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
return STATUS_INTERNAL_ERROR;
}
relatedfile=file->RelatedFileObject;
if (relatedfile==NULL)
{
KdPrintf((“relatedfile=NULL Why ?\n”));
relatedfile=file;
}*/
KdPrintfd2((“Close\n”));
vdf=vdf_GetParam(DeviceObject);
if (vdf==NULL)
{
KdPrintf((“FatCommonClose : vdf==NULL”));
KdPrintf((“Errclose3\n”));
return STATUS_SUCCESS;
}
if ((vdf->parameter==FALSE) || (vdf->used==FALSE))
return STATUS_SUCCESS;
_file=irps->FileObject;
if (_file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
KdPrintf((“Errclose2\n”));
return STATUS_SUCCESS;;
}
csfilename=_file->FileName.Buffer;
lencsfilename=_file->FileName.Length;
lencsrelativefilename=2;
//csrelativefilename=“”;
_relatedfile=_file->RelatedFileObject;
if (_relatedfile==NULL)
{
KdPrintf((“relatedfile=NULL Why ?\n”));
_relatedfile=_file;
csrelativefilename=&nib;
}
else
{
csrelativefilename=_relatedfile->FileName.Buffer;
lencsrelativefilename=_relatedfile->FileName.Length;
}
size=lencsfilename+2+lencsrelativefilename+2;
KdPrintfd2((“FatCommonClose FileName %ws RelatedFileName %ws vdf:%x\n”,csfilename,csrelativefilename,vdf));
//size=file->FileName.Length+2+relatedfile->FileName.Length+2;
//size=size<<1;
c=(WCHAR*)ExAllocatePoolWithTag(NonPagedPool,size+128,43);
if (c!=NULL)
{
THANDLES h;
KdPrintf2((“memset c,0\n”));
memset(c,0,size);
KdPrintf2((“memcpy(c+0,file->FileName.Buffer,file->FileName.Length*2);\n”));
if (csfilename!=NULL)memcpy(c+0,csfilename,lencsfilename*1);
KdPrintf2((“memcpy(c+(1+(file->FileName.Length*2)),relatedfile->FileName.Buffer);\n”));
if (csrelativefilename!=NULL)memcpy(c+(2+(lencsfilename*1)),csrelativefilename,lencsrelativefilename*1);
FillHandle(hProcess,&h,irp,irps);
KdPrintf2((“Calluser\n”));
status=CallUser(vdf,CMD_CLOSEFILE,sizeof (THANDLES),&h,size,c,&error);
KdPrintf2((“ExFreePool\n”));
ExFreePool(c);
KdPrintf2((“Fin\n”));
{
PCCB fsc=NULL;
fsc=_file->FsContext2;
/*if (fsc!=NULL)
{
__try
{
if ((fsc->bufferwrite!=NULL) && (fsc->sizewrite>0))
ExFreePool(fsc->bufferwrite);
if (fsc->section==TRUE)
{
FsRtlTeardownPerStreamContexts(&fsc->FCBHeader);
//ExReleaseResourceLite(&fsc->Resource, TRUE);
ExDeleteResourceLite(&fsc->PagingIoResource);
ExDeleteResourceLite(&fsc->MainResource);
ExDeleteResourceLite(&fsc->Resource);
}
ExFreePool(fsc);
}
__except (1)
{
KdPrintf((“Errclose2\n”));
KdPrintf((“FatClose Exception ExFreeePool fsc\n”));
}
}*/
//KdPrintfd2((“call vdfsFreeFCB\n”));
//if ((vdf->used==TRUE) && (vdf->parameter==TRUE))
{
RemoveEntryList(&fsc->NextFile);
vdfsFreeFCB(fsc->Fcb);
vdfsDoneCCB(fsc);
_file->FsContext=NULL;
_file->FsContext2=NULL;
// KdPrintfd2((“Ca Bug \n”));
}
}
if (error==STATUS_TIMEOUT)
return STATUS_SUCCESS;
else
return STATUS_SUCCESS;
}
else
{
KdPrintf((“Errclose1\n”));
return STATUS_SUCCESS;;
}
}
__except (1)
{
KdPrintfd((“FatCommmonClose exception\n”));
return STATUS_SUCCESS;;
}
return STATUS_SUCCESS;
}
NTSTATUS vdfdispatch(HANDLE hProcess,PDEVICE_OBJECT DeviceObject,PIRP irp,PIO_STACK_LOCATION irps)
{
NTSTATUS status;
status=STATUS_NOT_IMPLEMENTED;
switch (irps->MajorFunction)
{
case IRP_MJ_CREATE:
KdPrintfd((“IRP_MJ_CREATE irp:%x irps:%x\n”,irp,irps));
status = FatCommonCreate(hProcess, DeviceObject,irp,irps );
break;
case IRP_MJ_READ:
KdPrintfd((“IRP_MJ_READ irp:%x irps:%x\n”,irp,irps));
status = FatCommonRead(hProcess, DeviceObject,irp,irps );
break;
case IRP_MJ_WRITE:
KdPrintfd((“IRP_MJ_WRITE irp:%x irps:%x\n”,irp,irps));
status = FatCommonWrite(hProcess, DeviceObject,irp,irps );
break;
case IRP_MJ_CLOSE:
KdPrintfd((“IRP_MJ_CLOSE irp:%x irps:%x\n”,irp,irps));
status = FatCommonClose(hProcess, DeviceObject,irp,irps);
status=STATUS_SUCCESS;
if (status!=STATUS_SUCCESS)
KdPrintf((“ERRORINCLOSE\n”));
break;
case IRP_MJ_CLEANUP:
{
PPARAMVDF vdf=DeviceObject->DeviceExtension;
PCCB fsc;
KdPrintfd((“IRP_MJ_CLEANUP irp:%x irps:%x\n”,irp,irps));
if (irps->FileObject!=NULL)
{
KdPrintf((" IRP_MJ_CLEANUP ->FsContext2 before = %x\n",irps->FileObject->FsContext2));
if (irps->FileObject!=NULL)
{
fsc=irps->FileObject->FsContext2;
if (fsc!=NULL)
{
if (fsc->evchgdirectory)
{
KdPrintfd2((“IRP_MJ_CLEANUP ok directory cleanup (%ws)\n”,fsc->Fcb->FileName));
FsRtlNotifyCleanup( vdf->NotifySync,
&vdf->DirNotifyList,
irps->FileObject->FsContext2 );
}
}
else
KdPrintf((“IRP_MJ_CLEANUP fsc=NULL\n”));
}
KdPrintf((" IRP_MJ_CLEANUP ->FsContext2 after = %x\n",irps->FileObject->FsContext2));
}
status=FatCleanup(hProcess,DeviceObject,irp,irps);
status=STATUS_SUCCESS;
if (status!=STATUS_SUCCESS)
KdPrintfd2((“ERRORINCLEANUP\n”));
//status=STATUS_SUCCESS;
}
break;
case IRP_MJ_DEVICE_CONTROL:
KdPrintfd((“IRP_MJ_DEVICE_CONTROL irp:%x irps:%x\n”,irp,irps));
status=FatDiskControl(hProcess,DeviceObject,irp,irps);
//status= STATUS_NOT_IMPLEMENTED;
break;
case IRP_MJ_QUERY_INFORMATION:
KdPrintfd((“IRP_MJ_QUERY_INFORMATION irp:%x irps:%x\n”,irp,irps));
status=FatQueryInformation(hProcess,DeviceObject,irp,irps);
//return STATUS_NOT_IMPLEMENTED;
break;
case IRP_MJ_SET_INFORMATION:
KdPrintfd((“IRP_MJ_SET_INFORMATION irp:%x irps:%x\n”,irp,irps));
status=FatSetInformation(hProcess,DeviceObject,irp,irps);
break;
case IRP_MJ_QUERY_SECURITY:
KdPrintfd((“IRP_MJ_QUERY_SECURITY irp:%x irps:%x\n”,irp,irps));
//status=FsdCommonQuerySecurity(DeviceObject,irp,irps);
return STATUS_NOT_IMPLEMENTED;
break;
case IRP_MJ_FILE_SYSTEM_CONTROL:
{
KdPrintfd((“IRP_MJ_FILE_SYSTEM_CONTROL irp:%x irps:%x\n”,irp,irps));
status=FatFileSystemControl(hProcess,DeviceObject,irp,irps);
//return STATUS_NOT_IMPLEMENTED;
}
break;
case IRP_MJ_QUERY_VOLUME_INFORMATION:
{
KdPrintfd((“IRP_MJ_QUERY_VOLUME_INFORMATION irp:%x irps:%x\n”,irp,irps));
//FILE_FS_VOLUME_INFORMATION
status=FatQueryVolumeInformation(hProcess,DeviceObject,irp,irps);
}
break;
case IRP_MJ_DIRECTORY_CONTROL:
{
//KdPrintfd((“IRP_MJ_DIRECTORY_CONTROL irp:%x irps:%x\n”,irp,irps));
switch (irps->MinorFunction)
{
case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
{
PPARAMVDF vdf;
ULONG CompletionFilter;
PFILE_OBJECT file;
BOOLEAN WatchTree;
CompletionFilter = irps->Parameters.NotifyDirectory.CompletionFilter;
WatchTree = BooleanFlagOn( irps->Flags, SL_WATCH_TREE );
vdf=(PPARAMVDF)DeviceObject->DeviceExtension;
KdPrintfd((“IRP_MN_NOTIFY_CHANGE_DIRECTORY irp:%x irps:%x\n”,irp,irps));
WaitObjectms(&vdf->delaychangedir,100);
return STATUS_NOT_IMPLEMENTED;
status=FatNotifyChangeDirectory(hProcess,DeviceObject,irp,irps);
file=irps->FileObject;
if (file==NULL)
{
KdPrintf((“file=NULL Why ?\n”));
return STATUS_INTERNAL_ERROR;
}
if (status==STATUS_SUCCESS)
{
/* FsRtlNotifyFullChangeDirectory( vdf->NotifySync,
&vdf->DirNotifyList,
vdf,
(PSTRING)&file->FileName,
WatchTree,
FALSE,
CompletionFilter,
irp,
NULL,
NULL );*/
// status = STATUS_PENDING;
}
KdPrintf((“IRP_MN_NOTIFY_CHANGE_DIRECTORY return status %x\n”,status));
//return STATUS_INVALID_PARAMETER;
//return STATUS_PENDING;
}
break;
case IRP_MN_QUERY_DIRECTORY:
KdPrintfd((“IRP_MN_NOTIFY_QUERY_DIRECTORY irp:%x irps:%x\n”,irp,irps));
status=FatQueryDirectory(hProcess,DeviceObject,irp,irps);
break;
}
}
break;
}
return status;
}