自学教程：C++ IsFlagOn函数代码示例

NTSTATUSExt2FlushFiles(    IN PEXT2_IRP_CONTEXT    IrpContext,    IN PEXT2_VCB            Vcb,    IN BOOLEAN              bShutDown){    IO_STATUS_BLOCK    IoStatus;    PEXT2_FCB       Fcb;    PLIST_ENTRY     ListEntry;    if (IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||            IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {        return STATUS_SUCCESS;    }    IoStatus.Status = STATUS_SUCCESS;    DEBUG(DL_INF, ( "Flushing Files .../n"));    // Flush all Fcbs in Vcb list queue.    for (ListEntry = Vcb->FcbList.Flink;            ListEntry != &Vcb->FcbList;            ListEntry = ListEntry->Flink ) {        Fcb = CONTAINING_RECORD(ListEntry, EXT2_FCB, Next);        ExAcquireResourceExclusiveLite(            &Fcb->MainResource, TRUE);        IoStatus.Status = Ext2FlushFile(IrpContext, Fcb, NULL);        ExReleaseResourceLite(&Fcb->MainResource);    }    return IoStatus.Status;}

VOIDExt2QueueCloseRequest (IN PEXT2_IRP_CONTEXT IrpContext){    ASSERT(IrpContext);    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));    if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE)) {        if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_FILE_BUSY)) {            Ext2Sleep(500); /* 0.5 sec*/        } else {            Ext2Sleep(50);  /* 0.05 sec*/        }    } else {        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE);        IrpContext->Fcb = (PEXT2_FCB) IrpContext->FileObject->FsContext;        IrpContext->Ccb = (PEXT2_CCB) IrpContext->FileObject->FsContext2;    }    ExInitializeWorkItem(        &IrpContext->WorkQueueItem,        Ext2DeQueueCloseRequest,        IrpContext);    ExQueueWorkItem(&IrpContext->WorkQueueItem, DelayedWorkQueue);}

NTSTATUSExt2ReadWriteBlockAsyncCompletionRoutine (    IN PDEVICE_OBJECT DeviceObject,    IN PIRP Irp,    IN PVOID Context){    PEXT2_RW_CONTEXT pContext = (PEXT2_RW_CONTEXT)Context;    PIO_STACK_LOCATION iosp;    ASSERT(FALSE == pContext->Wait);    if (Irp != pContext->MasterIrp && !NT_SUCCESS(Irp->IoStatus.Status)) {        pContext->MasterIrp->IoStatus = Irp->IoStatus;    }    if (InterlockedDecrement(&pContext->Blocks) == 0) {        if (NT_SUCCESS(pContext->MasterIrp->IoStatus.Status)) {            /* set written bytes to status information */            pContext->MasterIrp->IoStatus.Information = pContext->Length;            if (pContext->FileObject != NULL && !IsFlagOn(pContext->MasterIrp->Flags, IRP_PAGING_IO)) {                /* modify FileObject flags, skip this for volume direct access */                SetFlag( pContext->FileObject->Flags,                         IsFlagOn(pContext->Flags, EXT2_RW_CONTEXT_WRITE) ?                         FO_FILE_MODIFIED : FO_FILE_FAST_IO_READ);                /* update Current Byteoffset */                if (IsFlagOn(pContext->FileObject->Flags, FO_SYNCHRONOUS_IO)) {                    iosp = IoGetCurrentIrpStackLocation(pContext->MasterIrp);                    pContext->FileObject->CurrentByteOffset.QuadPart =                        iosp->Parameters.Read.ByteOffset.QuadPart +  pContext->Length;                }            }        } else {            pContext->MasterIrp->IoStatus.Information = 0;        }        /* release the locked resource acquired by the caller */        if (pContext->Resource) {            ExReleaseResourceForThread(pContext->Resource, pContext->ThreadId);        }        Ext2FreePool(pContext, EXT2_RWC_MAGIC);        DEC_MEM_COUNT(PS_RW_CONTEXT, pContext, sizeof(EXT2_RW_CONTEXT));    }    return STATUS_SUCCESS;}

__drv_mustHoldCriticalRegionNTSTATUSFFSPurgeFile(	IN PFFS_FCB Fcb,	IN BOOLEAN  FlushBeforePurge){	IO_STATUS_BLOCK    IoStatus;    PAGED_CODE();	ASSERT(Fcb != NULL);	ASSERT((Fcb->Identifier.Type == FFSFCB) &&			(Fcb->Identifier.Size == sizeof(FFS_FCB)));	if(!IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY) && FlushBeforePurge &&			!IsFlagOn(Fcb->Vcb->Flags, VCB_WRITE_PROTECTED))	{		FFSPrint((DBG_INFO, "FFSPurgeFile: CcFlushCache on %s./n", 					Fcb->AnsiFileName.Buffer));		ExAcquireSharedStarveExclusive(&Fcb->PagingIoResource, TRUE);		ExReleaseResourceLite(&Fcb->PagingIoResource);		CcFlushCache(&Fcb->SectionObject, NULL, 0, &IoStatus);		ClearFlag(Fcb->Flags, FCB_FILE_MODIFIED);	}	if (Fcb->SectionObject.ImageSectionObject)	{		FFSPrint((DBG_INFO, "FFSPurgeFile: MmFlushImageSection on %s./n", 					Fcb->AnsiFileName.Buffer));		MmFlushImageSection(&Fcb->SectionObject, MmFlushForWrite);	}	if (Fcb->SectionObject.DataSectionObject)	{		FFSPrint((DBG_INFO, "FFSPurgeFile: CcPurgeCacheSection on %s./n",					Fcb->AnsiFileName.Buffer));		CcPurgeCacheSection(&Fcb->SectionObject, NULL, 0, FALSE);	}	return STATUS_SUCCESS;}

BOOLEANFFSZeroHoles(	IN PFFS_IRP_CONTEXT IrpContext,	IN PFFS_VCB         Vcb,	IN PFILE_OBJECT     FileObject,	IN LONGLONG         Offset,	IN LONGLONG         Count){	LARGE_INTEGER StartAddr = {0, 0};	LARGE_INTEGER EndAddr = {0, 0};	StartAddr.QuadPart = (Offset + (SECTOR_SIZE - 1)) &		~((LONGLONG)SECTOR_SIZE - 1);	EndAddr.QuadPart = (Offset + Count + (SECTOR_SIZE - 1)) &		~((LONGLONG)SECTOR_SIZE - 1);	if (StartAddr.QuadPart < EndAddr.QuadPart)	{		return CcZeroData(FileObject,				&StartAddr,				&EndAddr,				IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));	}	return TRUE;}

VOIDFFSQueueCloseRequest(	IN PFFS_IRP_CONTEXT IrpContext){    PAGED_CODE();	ASSERT(IrpContext);	ASSERT((IrpContext->Identifier.Type == FFSICX) &&			(IrpContext->Identifier.Size == sizeof(FFS_IRP_CONTEXT)));	if (!IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE))	{		SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE);		IrpContext->Fcb = (PFFS_FCB)IrpContext->FileObject->FsContext;		IrpContext->Ccb = (PFFS_CCB)IrpContext->FileObject->FsContext2;		IrpContext->FileObject = NULL;	}	// IsSynchronous means we can block (so we don't requeue it)	IrpContext->IsSynchronous = TRUE;	ExInitializeWorkItem(			&IrpContext->WorkQueueItem,			FFSDeQueueCloseRequest,			IrpContext);	ExQueueWorkItem(&IrpContext->WorkQueueItem, CriticalWorkQueue);}

NTSTATUSExt2CompleteIrpContext (    IN PEXT2_IRP_CONTEXT IrpContext,    IN NTSTATUS Status ){    PIRP    Irp = NULL;    BOOLEAN bPrint;    Irp = IrpContext->Irp;    if (Irp != NULL) {        if (NT_ERROR(Status)) {            Irp->IoStatus.Information = 0;        }        Irp->IoStatus.Status = Status;        bPrint = !IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_REQUEUED);        Ext2CompleteRequest(            Irp, bPrint, (CCHAR)(NT_SUCCESS(Status)?                                 IO_DISK_INCREMENT : IO_NO_INCREMENT) );        IrpContext->Irp = NULL;    }    Ext2FreeIrpContext(IrpContext);    return Status;}

BOOLEANExt2FastIoWrite (    IN PFILE_OBJECT         FileObject,    IN PLARGE_INTEGER       FileOffset,    IN ULONG                Length,    IN BOOLEAN              Wait,    IN ULONG                LockKey,    OUT PVOID               Buffer,    OUT PIO_STATUS_BLOCK    IoStatus,    IN PDEVICE_OBJECT       DeviceObject){    PEXT2_FCB   Fcb = NULL;    BOOLEAN     Status = FALSE;    BOOLEAN     Locked = FALSE;    Fcb = (PEXT2_FCB) FileObject->FsContext;    if (Fcb == NULL)        return FALSE;    __try {        FsRtlEnterFileSystem();        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));        if (IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY)) {            __leave;        }        ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);        Locked = TRUE;        if (IsEndOfFile(*FileOffset) || ((LONGLONG)(Fcb->Inode->i_size) <                                         (FileOffset->QuadPart + Length)) ) {        } else {            ExReleaseResourceLite(&Fcb->MainResource);            Locked = FALSE;            Status = FsRtlCopyWrite(FileObject, FileOffset, Length, Wait,                                    LockKey, Buffer, IoStatus, DeviceObject);        }    } __finally {        if (Locked) {            ExReleaseResourceLite(&Fcb->MainResource);        }        FsRtlExitFileSystem();    }    DEBUG(DL_IO, ("Ext2FastIoWrite: %wZ Offset: %I64xh Length: %xh Key: %xh Status=%d/n",                   &Fcb->Mcb->ShortName,  FileOffset->QuadPart, Length, LockKey, Status));    return Status;}

VOIDFFSRefreshMcb(	PFFS_VCB Vcb,	PFFS_MCB Mcb){	ASSERT (IsFlagOn(Mcb->Flags, MCB_IN_TREE));	RemoveEntryList(&(Mcb->Link));	InsertTailList(&(Vcb->McbList), &(Mcb->Link));}

NTSTATUSFFSGetPartition(	IN PDEVICE_OBJECT DeviceObject,	OUT ULONGLONG     *StartOffset){    CHAR                  Buffer[2048];    PIRP                  Irp;    IO_STATUS_BLOCK       IoStatus;    KEVENT                Event;    NTSTATUS              Status;    PARTITION_INFORMATION *PartInfo;    PAGED_CODE();    if (IsFlagOn(DeviceObject->Characteristics, FILE_FLOPPY_DISKETTE))    {        *StartOffset = 0;        return STATUS_SUCCESS;    }    KeInitializeEvent(&Event, NotificationEvent, FALSE);    Irp = IoBuildDeviceIoControlRequest(			IOCTL_DISK_GET_PARTITION_INFO,			DeviceObject,			NULL,			0,			Buffer,			2048,			FALSE,			&Event,			&IoStatus);    if (!Irp)	{		return STATUS_INSUFFICIENT_RESOURCES;	}    Status = IoCallDriver(DeviceObject, Irp);    if (!NT_SUCCESS(Status))	{		return Status;	}    Status = KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);    if (!NT_SUCCESS(Status))	{		return Status;	}    PartInfo = (PARTITION_INFORMATION *)Buffer;    *StartOffset = PartInfo->StartingOffset.QuadPart;    return Status;}

VOIDExt2DestroyMdl (IN PMDL Mdl){    ASSERT (Mdl != NULL);    while (Mdl) {        PMDL Next;        Next = Mdl->Next;        if (IsFlagOn(Mdl->MdlFlags, MDL_PAGES_LOCKED)) {            MmUnlockPages (Mdl);        }        IoFreeMdl (Mdl);        Mdl = Next;    }}

BOOLEANFFSDeleteMcbNode(	PFFS_VCB Vcb,	PFFS_MCB McbTree,	PFFS_MCB FFSMcb){	PFFS_MCB   TmpMcb;    PAGED_CODE();	if(!IsFlagOn(FFSMcb->Flags, MCB_IN_TREE))	{		return TRUE;	}	if (FFSMcb->Parent)	{		if (FFSMcb->Parent->Child == FFSMcb)		{			FFSMcb->Parent->Child = FFSMcb->Next;		}		else		{			TmpMcb = FFSMcb->Parent->Child;			while (TmpMcb && TmpMcb->Next != FFSMcb)				TmpMcb = TmpMcb->Next;			if (TmpMcb)			{				TmpMcb->Next = FFSMcb->Next;			}			else			{				// error				return FALSE;			}		}	}	else if (FFSMcb->Child)	{		return FALSE;	}	RemoveEntryList(&(FFSMcb->Link));	ClearFlag(FFSMcb->Flags, MCB_IN_TREE);	return TRUE;}

NTSTATUSExt2FlushFile (    IN PEXT2_IRP_CONTEXT    IrpContext,    IN PEXT2_FCB            Fcb,    IN PEXT2_CCB            Ccb){    IO_STATUS_BLOCK     IoStatus;    ASSERT(Fcb != NULL);    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));    _SEH2_TRY {        /* update timestamp and achieve attribute */        if (Ccb != NULL) {            if (!IsFlagOn(Ccb->Flags, CCB_LAST_WRITE_UPDATED)) {                LARGE_INTEGER   SysTime;                KeQuerySystemTime(&SysTime);                Fcb->Inode->i_mtime = Ext2LinuxTime(SysTime);                Fcb->Mcb->LastWriteTime = Ext2NtTime(Fcb->Inode->i_mtime);                Ext2SaveInode(IrpContext, Fcb->Vcb, Fcb->Inode);            }        }        if (IsDirectory(Fcb)) {            IoStatus.Status = STATUS_SUCCESS;            _SEH2_LEAVE;        }        DEBUG(DL_INF, ( "Ext2FlushFile: Flushing File Inode=%xh %S .../n",                        Fcb->Inode->i_ino, Fcb->Mcb->ShortName.Buffer));        CcFlushCache(&(Fcb->SectionObject), NULL, 0, &IoStatus);        ClearFlag(Fcb->Flags, FCB_FILE_MODIFIED);    } _SEH2_FINALLY {        /* do cleanup here */    } _SEH2_END;    return IoStatus.Status;}

VOIDExt2StartFloppyFlushDpc (    PEXT2_VCB   Vcb,    PEXT2_FCB   Fcb,    PFILE_OBJECT FileObject ){    LARGE_INTEGER          OneSecond;    PEXT2_FLPFLUSH_CONTEXT Context;    ASSERT(IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK));    Context = Ext2AllocatePool(                  NonPagedPool,                  sizeof(EXT2_FLPFLUSH_CONTEXT),                  EXT2_FLPFLUSH_MAGIC              );    if (!Context) {        DEBUG(DL_ERR, ( "Ex2StartFloppy...: failed to allocate Context/n"));        DbgBreak();        return;    }    KeInitializeTimer(&Context->Timer);    KeInitializeDpc( &Context->Dpc,                     Ext2FloppyFlushDpc,                     Context );    ExInitializeWorkItem( &Context->Item,                          Ext2FloppyFlush,                          Context );    Context->Vcb = Vcb;    Context->Fcb = Fcb;    Context->FileObject = FileObject;    if (FileObject) {        ObReferenceObject(FileObject);    }    OneSecond.QuadPart = (LONGLONG)-1*1000*1000*10;    KeSetTimer( &Context->Timer,                OneSecond,                &Context->Dpc );}

FAST_IO_POSSIBLEExt2IsFastIoPossible(    IN PEXT2_FCB Fcb){    FAST_IO_POSSIBLE IsPossible = FastIoIsNotPossible;    if (!Fcb || !FsRtlOplockIsFastIoPossible(&Fcb->Oplock))        return IsPossible;    IsPossible = FastIoIsQuestionable;    if (!FsRtlAreThereCurrentFileLocks(&Fcb->FileLockAnchor)) {        if (!IsFlagOn(Fcb->Vcb->Flags, VCB_READ_ONLY)) {            IsPossible = FastIoIsPossible;        }    }    return IsPossible;}

VOIDFFSAddMcbNode(	PFFS_VCB Vcb,	PFFS_MCB Parent,	PFFS_MCB Child){	PFFS_MCB TmpMcb = Parent->Child;    PAGED_CODE();	if(IsFlagOn(Child->Flags, MCB_IN_TREE))	{		FFSBreakPoint();		FFSPrint((DBG_ERROR, "FFSAddMcbNode: Child Mcb is alreay in the tree./n"));		return;	}	if (TmpMcb)	{		ASSERT(TmpMcb->Parent == Parent);		while (TmpMcb->Next)		{			TmpMcb = TmpMcb->Next;			ASSERT(TmpMcb->Parent == Parent);		}		TmpMcb->Next = Child;		Child->Parent = Parent;		Child->Next = NULL;	}	else	{		Parent->Child = Child;		Child->Parent = Parent;		Child->Next = NULL;	}	InsertTailList(&(Vcb->McbList), &(Child->Link));	SetFlag(Child->Flags, MCB_IN_TREE);}

VOIDFFSStartFloppyFlushDpc(	PFFS_VCB     Vcb,	PFFS_FCB     Fcb,	PFILE_OBJECT FileObject){	LARGE_INTEGER          OneSecond;	PFFS_FLPFLUSH_CONTEXT Context;	ASSERT(IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK));	Context = ExAllocatePool(NonPagedPool, sizeof(PFFS_FLPFLUSH_CONTEXT));	if (!Context)	{		FFSBreakPoint();		return;	}	KeInitializeTimer(&Context->Timer);	KeInitializeDpc(&Context->Dpc,			FFSFloppyFlushDpc,			Context);	Context->Vcb = Vcb;	Context->Fcb = Fcb;	Context->FileObject = FileObject;	if (FileObject)	{		ObReferenceObject(FileObject);	}	OneSecond.QuadPart = (LONGLONG) - 1 * 1000 * 1000 * 10;	KeSetTimer(&Context->Timer,			OneSecond,			&Context->Dpc);}

INTExt2CheckJournal(    PEXT2_VCB          Vcb,    PULONG             jNo){    struct ext3_super_block* esb = NULL;    /* check ext3 super block */    esb = (struct ext3_super_block *)Vcb->SuperBlock;    if (IsFlagOn(esb->s_feature_incompat,                 EXT3_FEATURE_INCOMPAT_RECOVER)) {        SetLongFlag(Vcb->Flags, VCB_JOURNAL_RECOVER);    }    /* must stop here if volume is read-only */    if (IsVcbReadOnly(Vcb)) {        goto errorout;    }    /* journal is external ? */    if (esb->s_journal_inum == 0) {        goto errorout;    }    /* oops: volume is corrupted */    if (esb->s_journal_dev) {        goto errorout;    }    /* return the journal inode number */    *jNo = esb->s_journal_inum;    return TRUE;errorout:    return FALSE;}

NTSTATUSFFSWriteVolume(	IN PFFS_IRP_CONTEXT IrpContext){	NTSTATUS            Status = STATUS_UNSUCCESSFUL;	PFFS_VCB            Vcb  = NULL;	PFFS_CCB            Ccb = NULL;	PFFS_FCBVCB         FcbOrVcb  = NULL;	PFILE_OBJECT        FileObject  = NULL;	PDEVICE_OBJECT      DeviceObject  = NULL;	PIRP                Irp  = NULL;	PIO_STACK_LOCATION  IoStackLocation  = NULL;	ULONG               Length;	LARGE_INTEGER       ByteOffset;	BOOLEAN             PagingIo;	BOOLEAN             Nocache;	BOOLEAN             SynchronousIo;	BOOLEAN             MainResourceAcquired = FALSE;	BOOLEAN             PagingIoResourceAcquired = FALSE;	BOOLEAN             bDeferred = FALSE;	PUCHAR              Buffer = NULL;	__try	{		ASSERT(IrpContext);		ASSERT((IrpContext->Identifier.Type == FFSICX) &&				(IrpContext->Identifier.Size == sizeof(FFS_IRP_CONTEXT)));		DeviceObject = IrpContext->DeviceObject;		Vcb = (PFFS_VCB)DeviceObject->DeviceExtension;		ASSERT(Vcb != NULL);		ASSERT((Vcb->Identifier.Type == FFSVCB) &&				(Vcb->Identifier.Size == sizeof(FFS_VCB)));		FileObject = IrpContext->FileObject;		FcbOrVcb = (PFFS_FCBVCB)FileObject->FsContext;		ASSERT(FcbOrVcb);		if (!(FcbOrVcb->Identifier.Type == FFSVCB && (PVOID)FcbOrVcb == (PVOID)Vcb))		{			Status = STATUS_INVALID_DEVICE_REQUEST;			__leave;		}		Ccb = (PFFS_CCB)FileObject->FsContext2;		Irp = IrpContext->Irp;		IoStackLocation = IoGetCurrentIrpStackLocation(Irp);		Length = IoStackLocation->Parameters.Write.Length;		ByteOffset = IoStackLocation->Parameters.Write.ByteOffset;		PagingIo = (Irp->Flags & IRP_PAGING_IO ? TRUE : FALSE);		Nocache = (Irp->Flags & IRP_NOCACHE ? TRUE : FALSE);		SynchronousIo = (FileObject->Flags & FO_SYNCHRONOUS_IO ? TRUE : FALSE);		FFSPrint((DBG_INFO, "FFSWriteVolume: Off=%I64xh Len=%xh Paging=%xh Nocache=%xh/n",					ByteOffset.QuadPart, Length, PagingIo, Nocache));		if (Length == 0)		{			Irp->IoStatus.Information = 0;			Status = STATUS_SUCCESS;			__leave;		}		// For the case of "Direct Access Storage Device", we		// need flush/purge the cache		if (Ccb != NULL)		{			ExAcquireResourceExclusive(&Vcb->MainResource, TRUE);			MainResourceAcquired = TRUE;			Status = FFSPurgeVolume(Vcb, TRUE);			ExReleaseResource(&Vcb->MainResource);			MainResourceAcquired = FALSE;			if(!IsFlagOn(Ccb->Flags, CCB_ALLOW_EXTENDED_DASD_IO))			{				if (ByteOffset.QuadPart + Length > Vcb->Header.FileSize.QuadPart)				{					Length = (ULONG)(Vcb->Header.FileSize.QuadPart - ByteOffset.QuadPart);				}			}//.........这里部分代码省略.........

NTSTATUSFFSWrite(	IN PFFS_IRP_CONTEXT IrpContext){	NTSTATUS            Status;	PFFS_FCBVCB         FcbOrVcb;	PDEVICE_OBJECT      DeviceObject;	PFILE_OBJECT        FileObject;	PFFS_VCB            Vcb;	BOOLEAN             bCompleteRequest = TRUE;	ASSERT(IrpContext);	ASSERT((IrpContext->Identifier.Type == FFSICX) &&			(IrpContext->Identifier.Size == sizeof(FFS_IRP_CONTEXT)));	__try	{		if (FlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE))		{			Status = FFSWriteComplete(IrpContext);			bCompleteRequest = FALSE;		}		else		{			DeviceObject = IrpContext->DeviceObject;			if (DeviceObject == FFSGlobal->DeviceObject)			{				Status = STATUS_INVALID_DEVICE_REQUEST;				__leave;			}			Vcb = (PFFS_VCB)DeviceObject->DeviceExtension;			if (Vcb->Identifier.Type != FFSVCB ||					Vcb->Identifier.Size != sizeof(FFS_VCB))			{				Status = STATUS_INVALID_PARAMETER;				__leave;			}			ASSERT(IsMounted(Vcb));			if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING))			{				Status = STATUS_TOO_LATE;				__leave;			}			if (IsFlagOn(Vcb->Flags, VCB_READ_ONLY))			{				Status = STATUS_MEDIA_WRITE_PROTECTED;				__leave;			}			FileObject = IrpContext->FileObject;			FcbOrVcb = (PFFS_FCBVCB)FileObject->FsContext;			if (FcbOrVcb->Identifier.Type == FFSVCB)			{				Status = FFSWriteVolume(IrpContext);				if (!NT_SUCCESS(Status))				{					FFSBreakPoint();				}				bCompleteRequest = FALSE;			}			else if (FcbOrVcb->Identifier.Type == FFSFCB)			{				Status = FFSWriteFile(IrpContext);				if (!NT_SUCCESS(Status))				{					FFSBreakPoint();				}				bCompleteRequest = FALSE;			}			else			{				Status = STATUS_INVALID_PARAMETER;			}		}	}	__finally	{		if (bCompleteRequest)		{			FFSCompleteIrpContext(IrpContext, Status);		}	}	return Status;}

NTSTATUSDokanDispatchDeviceControl(__in PDEVICE_OBJECT DeviceObject, __in PIRP Irp)/*++Routine Description:        This device control dispatcher handles IOCTLs.Arguments:        DeviceObject - Context for the activity.        Irp          - The device control argument block.Return Value:        NTSTATUS--*/{  PDokanVCB vcb;  PDokanDCB dcb;  PIO_STACK_LOCATION irpSp;  NTSTATUS status = STATUS_NOT_IMPLEMENTED;  ULONG controlCode = 0;  ULONG outputLength = 0;  // {DCA0E0A5-D2CA-4f0f-8416-A6414657A77A}  // GUID dokanGUID = { 0xdca0e0a5, 0xd2ca, 0x4f0f, { 0x84, 0x16, 0xa6, 0x41,  // 0x46, 0x57, 0xa7, 0x7a } };  __try {    Irp->IoStatus.Information = 0;    irpSp = IoGetCurrentIrpStackLocation(Irp);    outputLength = irpSp->Parameters.DeviceIoControl.OutputBufferLength;    controlCode = irpSp->Parameters.DeviceIoControl.IoControlCode;    if (controlCode != IOCTL_EVENT_WAIT && controlCode != IOCTL_EVENT_INFO &&        controlCode != IOCTL_KEEPALIVE) {      DDbgPrint("==> DokanDispatchIoControl/n");      DDbgPrint("  ProcessId %lu/n", IoGetRequestorProcessId(Irp));    }    if (DeviceObject->DriverObject == NULL ||        DeviceObject->ReferenceCount < 0) {      status = STATUS_DEVICE_DOES_NOT_EXIST;      __leave;    }    vcb = DeviceObject->DeviceExtension;    PrintIdType(vcb);    if (GetIdentifierType(vcb) == DGL) {      status = GlobalDeviceControl(DeviceObject, Irp);      __leave;    } else if (GetIdentifierType(vcb) == DCB) {      status = DiskDeviceControlWithLock(DeviceObject, Irp);      __leave;    } else if (GetIdentifierType(vcb) != VCB) {      status = STATUS_INVALID_PARAMETER;      __leave;    }    dcb = vcb->Dcb;    switch (irpSp->Parameters.DeviceIoControl.IoControlCode) {    case IOCTL_EVENT_WAIT:      DDbgPrint("  IOCTL_EVENT_WAIT/n");      status = DokanRegisterPendingIrpForEvent(DeviceObject, Irp);      break;    case IOCTL_EVENT_INFO:      // DDbgPrint("  IOCTL_EVENT_INFO/n");      status = DokanCompleteIrp(DeviceObject, Irp);      break;    case IOCTL_EVENT_RELEASE:      DDbgPrint("  IOCTL_EVENT_RELEASE/n");      status = DokanEventRelease(DeviceObject, Irp);      break;    case IOCTL_EVENT_WRITE:      DDbgPrint("  IOCTL_EVENT_WRITE/n");      status = DokanEventWrite(DeviceObject, Irp);      break;    case IOCTL_KEEPALIVE:      DDbgPrint("  IOCTL_KEEPALIVE/n");      if (IsFlagOn(vcb->Flags, VCB_MOUNTED)) {        ExEnterCriticalRegionAndAcquireResourceExclusive(&dcb->Resource);        DokanUpdateTimeout(&dcb->TickCount, DOKAN_KEEPALIVE_TIMEOUT);        ExReleaseResourceAndLeaveCriticalRegion(&dcb->Resource);        status = STATUS_SUCCESS;      } else {        DDbgPrint(" device is not mounted/n");        status = STATUS_INSUFFICIENT_RESOURCES;      }      break;//.........这里部分代码省略.........

__drv_mustHoldCriticalRegionNTSTATUSRfsdCleanup (IN PRFSD_IRP_CONTEXT IrpContext){    PDEVICE_OBJECT  DeviceObject;    NTSTATUS        Status = STATUS_SUCCESS;    PRFSD_VCB       Vcb = 0;    BOOLEAN         VcbResourceAcquired = FALSE;    PFILE_OBJECT    FileObject;    PRFSD_FCB       Fcb = 0;    BOOLEAN         FcbResourceAcquired = FALSE;    BOOLEAN         FcbPagingIoAcquired = FALSE;    PRFSD_CCB       Ccb;    PIRP            Irp;    PAGED_CODE();    _SEH2_TRY {        ASSERT(IrpContext != NULL);                ASSERT((IrpContext->Identifier.Type == RFSDICX) &&            (IrpContext->Identifier.Size == sizeof(RFSD_IRP_CONTEXT)));                DeviceObject = IrpContext->DeviceObject;                if (DeviceObject == RfsdGlobal->DeviceObject) {            Status = STATUS_SUCCESS;            _SEH2_LEAVE;        }                Vcb = (PRFSD_VCB) DeviceObject->DeviceExtension;                ASSERT(Vcb != NULL);                ASSERT((Vcb->Identifier.Type == RFSDVCB) &&            (Vcb->Identifier.Size == sizeof(RFSD_VCB)));        if (!IsFlagOn(Vcb->Flags, VCB_INITIALIZED)) {            Status = STATUS_SUCCESS;            _SEH2_LEAVE;        }#ifdef _MSC_VER#pragma prefast( suppress: 28137, "by design" )#endif        if (!ExAcquireResourceExclusiveLite(                 &Vcb->MainResource,                 IrpContext->IsSynchronous                 ))  {            Status = STATUS_PENDING;            _SEH2_LEAVE;        }        VcbResourceAcquired = TRUE;                FileObject = IrpContext->FileObject;                Fcb = (PRFSD_FCB) FileObject->FsContext;                if (!Fcb) {            Status = STATUS_SUCCESS;            _SEH2_LEAVE;        }                if (Fcb->Identifier.Type == RFSDVCB) {            if (IsFlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&                (Vcb->LockFile == FileObject) ) {                ClearFlag(Vcb->Flags, VCB_VOLUME_LOCKED);                Vcb->LockFile = NULL;                RfsdClearVpbFlag(Vcb->Vpb, VPB_LOCKED);            }            Vcb->OpenHandleCount--;            if (!Vcb->OpenHandleCount) {                IoRemoveShareAccess(FileObject, &Vcb->ShareAccess);            }            Status = STATUS_SUCCESS;            _SEH2_LEAVE;        }                ASSERT((Fcb->Identifier.Type == RFSDFCB) &&            (Fcb->Identifier.Size == sizeof(RFSD_FCB)));/*        if ( !IsFlagOn(Vcb->Flags, VCB_READ_ONLY) &&             !IsFlagOn(Fcb->Flags, FCB_PAGE_FILE))*/        {#ifdef _MSC_VER#pragma prefast( suppress: 28137, "by design" )#endif            if (!ExAcquireResourceExclusiveLite(                     &Fcb->MainResource,                     IrpContext->IsSynchronous                     ))            {//.........这里部分代码省略.........

NTSTATUSExt2Flush (IN PEXT2_IRP_CONTEXT IrpContext){    NTSTATUS                Status = STATUS_SUCCESS;    PIRP                    Irp = NULL;    PIO_STACK_LOCATION      IrpSp = NULL;    PEXT2_VCB               Vcb = NULL;    PEXT2_FCB               Fcb = NULL;    PEXT2_FCBVCB            FcbOrVcb = NULL;    PEXT2_CCB               Ccb = NULL;    PFILE_OBJECT            FileObject = NULL;    PDEVICE_OBJECT          DeviceObject = NULL;    BOOLEAN                 MainResourceAcquired = FALSE;    __try {        ASSERT(IrpContext);        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));        DeviceObject = IrpContext->DeviceObject;        //        // This request is not allowed on the main device object        //        if (IsExt2FsDevice(DeviceObject)) {            Status = STATUS_INVALID_DEVICE_REQUEST;            __leave;        }        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;        ASSERT(Vcb != NULL);        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));        ASSERT(IsMounted(Vcb));        if ( IsFlagOn(Vcb->Flags, VCB_READ_ONLY) ||                IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {            Status =  STATUS_SUCCESS;            __leave;        }        Irp = IrpContext->Irp;        IrpSp = IoGetCurrentIrpStackLocation(Irp);        FileObject = IrpContext->FileObject;        FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;        ASSERT(FcbOrVcb != NULL);        Ccb = (PEXT2_CCB) FileObject->FsContext2;        if (Ccb == NULL) {            Status =  STATUS_SUCCESS;            __leave;        }        MainResourceAcquired =            ExAcquireResourceExclusiveLite(&FcbOrVcb->MainResource,                                           IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));        ASSERT(MainResourceAcquired);        DEBUG(DL_INF, ("Ext2Flush-pre:  total mcb records=%u/n",                       FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));        if (FcbOrVcb->Identifier.Type == EXT2VCB) {            Ext2VerifyVcb(IrpContext, Vcb);            Status = Ext2FlushFiles(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);            if (NT_SUCCESS(Status)) {                __leave;            }            Status = Ext2FlushVolume(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);            if (NT_SUCCESS(Status) && IsFlagOn(Vcb->Volume->Flags, FO_FILE_MODIFIED)) {                ClearFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);            }        } else if (FcbOrVcb->Identifier.Type == EXT2FCB) {            Fcb = (PEXT2_FCB)(FcbOrVcb);            Status = Ext2FlushFile(IrpContext, Fcb, Ccb);            if (NT_SUCCESS(Status)) {                if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {                    Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;                    ClearFlag(FileObject->Flags, FO_FILE_MODIFIED);                }            }        }        DEBUG(DL_INF, ("Ext2Flush-post: total mcb records=%u/n",                       FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));    } __finally {//.........这里部分代码省略.........

VOIDExt2LockIrp (    IN PVOID Context,    IN PIRP Irp){    PIO_STACK_LOCATION IrpSp;    PEXT2_IRP_CONTEXT IrpContext;    if (Irp == NULL) {        return;    }    IrpSp = IoGetCurrentIrpStackLocation(Irp);    IrpContext = (PEXT2_IRP_CONTEXT) Context;    if ( IrpContext->MajorFunction == IRP_MJ_READ ||            IrpContext->MajorFunction == IRP_MJ_WRITE ) {        //        //  lock the user's buffer to MDL, if the I/O is bufferred        //        if (!IsFlagOn(IrpContext->MinorFunction, IRP_MN_MDL)) {            Ext2LockUserBuffer( Irp, IrpSp->Parameters.Write.Length,                                (IrpContext->MajorFunction == IRP_MJ_READ) ?                                IoWriteAccess : IoReadAccess );        }    } else if (IrpContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL               && IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {        ULONG Length = ((PEXTENDED_IO_STACK_LOCATION) IrpSp)->Parameters.QueryDirectory.Length;        Ext2LockUserBuffer(Irp, Length, IoWriteAccess);    } else if (IrpContext->MajorFunction == IRP_MJ_QUERY_EA) {        ULONG Length = ((PEXTENDED_IO_STACK_LOCATION) IrpSp)->Parameters.QueryEa.Length;        Ext2LockUserBuffer(Irp, Length, IoWriteAccess);    } else if (IrpContext->MajorFunction == IRP_MJ_SET_EA) {        ULONG Length = ((PEXTENDED_IO_STACK_LOCATION) IrpSp)->Parameters.SetEa.Length;        Ext2LockUserBuffer(Irp, Length, IoReadAccess);    } else if ( (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&                (IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST) ) {        PEXTENDED_IO_STACK_LOCATION EIrpSp = (PEXTENDED_IO_STACK_LOCATION)IrpSp;        if ( (EIrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_VOLUME_BITMAP) ||                (EIrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTERS) ||                (EIrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTER_BASE) ) {            ULONG Length = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;            Ext2LockUserBuffer(Irp, Length, IoWriteAccess);        }    }    //  Mark the request as pending status    IoMarkIrpPending( Irp );    return;}

NTSTATUSExt2Read (IN PEXT2_IRP_CONTEXT IrpContext){    NTSTATUS            Status;    PEXT2_VCB           Vcb;    PEXT2_FCBVCB        FcbOrVcb;    PDEVICE_OBJECT      DeviceObject;    PFILE_OBJECT        FileObject;    BOOLEAN             bCompleteRequest;    ASSERT(IrpContext);    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));    __try {        if (FlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE)) {            Status =  Ext2ReadComplete(IrpContext);            bCompleteRequest = FALSE;        } else {            DeviceObject = IrpContext->DeviceObject;            if (IsExt2FsDevice(DeviceObject)) {                Status = STATUS_INVALID_DEVICE_REQUEST;                bCompleteRequest = TRUE;                __leave;            }            Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;            if (Vcb->Identifier.Type != EXT2VCB ||                    Vcb->Identifier.Size != sizeof(EXT2_VCB) ) {                Status = STATUS_INVALID_DEVICE_REQUEST;                bCompleteRequest = TRUE;                __leave;            }            FileObject = IrpContext->FileObject;            if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&                Vcb->LockFile != FileObject ) {                Status = STATUS_ACCESS_DENIED;                __leave;            }            FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;            if (FcbOrVcb->Identifier.Type == EXT2VCB) {                Status = Ext2ReadVolume(IrpContext);                bCompleteRequest = FALSE;            } else if (FcbOrVcb->Identifier.Type == EXT2FCB) {                if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {                    Status = STATUS_TOO_LATE;                    bCompleteRequest = TRUE;                    __leave;                }                Status = Ext2ReadFile(IrpContext);                bCompleteRequest = FALSE;            } else {                DEBUG(DL_ERR, ( "Ext2Read: Inavlid FileObject (Vcb or Fcb corrupted)/n"));                DbgBreak();                Status = STATUS_INVALID_PARAMETER;                bCompleteRequest = TRUE;            }        }    } __finally {        if (bCompleteRequest) {            Ext2CompleteIrpContext(IrpContext, Status);        }    }    return Status;}

NTSTATUSExt2ReadVolume (IN PEXT2_IRP_CONTEXT IrpContext){    NTSTATUS            Status = STATUS_UNSUCCESSFUL;    PEXT2_VCB           Vcb = NULL;    PEXT2_CCB           Ccb = NULL;    PEXT2_FCBVCB        FcbOrVcb = NULL;    PFILE_OBJECT        FileObject = NULL;    PDEVICE_OBJECT      DeviceObject = NULL;    PIRP                Irp = NULL;    PIO_STACK_LOCATION  IoStackLocation = NULL;    ULONG               Length;    LARGE_INTEGER       ByteOffset;    BOOLEAN             PagingIo;    BOOLEAN             Nocache;    BOOLEAN             SynchronousIo;    BOOLEAN             MainResourceAcquired = FALSE;    PUCHAR              Buffer = NULL;    EXT2_EXTENT         BlockArray;    __try {        ASSERT(IrpContext);        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));        DeviceObject = IrpContext->DeviceObject;        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;        ASSERT(Vcb != NULL);        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));        FileObject = IrpContext->FileObject;        FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;        ASSERT(FcbOrVcb);        if (!(FcbOrVcb->Identifier.Type == EXT2VCB && (PVOID)FcbOrVcb == (PVOID)Vcb)) {            Status = STATUS_INVALID_DEVICE_REQUEST;            __leave;        }        Ccb = (PEXT2_CCB) FileObject->FsContext2;        Irp = IrpContext->Irp;        Irp->IoStatus.Information = 0;        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);        Length = IoStackLocation->Parameters.Read.Length;        ByteOffset = IoStackLocation->Parameters.Read.ByteOffset;        PagingIo = IsFlagOn(Irp->Flags, IRP_PAGING_IO);        Nocache = IsFlagOn(Irp->Flags, IRP_NOCACHE) || (Ccb != NULL);        SynchronousIo = IsFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO);        if (PagingIo) {            ASSERT(Nocache);        }        if (Length == 0) {            Irp->IoStatus.Information = 0;            Status = STATUS_SUCCESS;            __leave;        }        if (FlagOn(IrpContext->MinorFunction, IRP_MN_DPC)) {            ClearFlag(IrpContext->MinorFunction, IRP_MN_DPC);            Status = STATUS_PENDING;            __leave;        }        if (ByteOffset.QuadPart >=                Vcb->PartitionInformation.PartitionLength.QuadPart  ) {            Irp->IoStatus.Information = 0;            Status = STATUS_END_OF_FILE;            __leave;        }        if (ByteOffset.QuadPart + Length > Vcb->Header.FileSize.QuadPart) {            Length = (ULONG)(Vcb->Header.FileSize.QuadPart - ByteOffset.QuadPart);        }        /*         *  User direct volume access         */        if (Ccb != NULL && !PagingIo) {            if (!ExAcquireResourceExclusiveLite(                        &Vcb->MainResource,                        IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {                Status = STATUS_PENDING;                __leave;            }            MainResourceAcquired = TRUE;//.........这里部分代码省略.........

NTSTATUSExt2ReadFile(IN PEXT2_IRP_CONTEXT IrpContext){    NTSTATUS            Status = STATUS_UNSUCCESSFUL;    PEXT2_VCB           Vcb = NULL;    PEXT2_FCB           Fcb = NULL;    PEXT2_CCB           Ccb = NULL;    PFILE_OBJECT        FileObject = NULL;    PDEVICE_OBJECT      DeviceObject = NULL;    PIRP                Irp = NULL;    PIO_STACK_LOCATION  IoStackLocation = NULL;    ULONG               Length;    ULONG               ReturnedLength = 0;    LARGE_INTEGER       ByteOffset;    BOOLEAN             OpPostIrp = FALSE;    BOOLEAN             PagingIo;    BOOLEAN             Nocache;    BOOLEAN             SynchronousIo;    BOOLEAN             MainResourceAcquired = FALSE;    BOOLEAN             PagingIoResourceAcquired = FALSE;    PUCHAR              Buffer;    __try {        ASSERT(IrpContext);        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));        DeviceObject = IrpContext->DeviceObject;        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;        ASSERT(Vcb != NULL);        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));        FileObject = IrpContext->FileObject;        Fcb = (PEXT2_FCB) FileObject->FsContext;        ASSERT(Fcb);        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));        Ccb = (PEXT2_CCB) FileObject->FsContext2;        Irp = IrpContext->Irp;        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);        Length = IoStackLocation->Parameters.Read.Length;        ByteOffset = IoStackLocation->Parameters.Read.ByteOffset;        PagingIo = IsFlagOn(Irp->Flags, IRP_PAGING_IO);        Nocache = IsFlagOn(Irp->Flags, IRP_NOCACHE);        SynchronousIo = IsFlagOn(FileObject->Flags, FO_SYNCHRONOUS_IO);        if (PagingIo) {            ASSERT(Nocache);        }        DEBUG(DL_INF, ("Ext2ReadFile: reading %wZ Off=%I64xh Len=%xh Paging=%xh Nocache=%xh/n",                       &Fcb->Mcb->ShortName, ByteOffset.QuadPart, Length, PagingIo, Nocache));        if ((IsSymLink(Fcb) && IsFileDeleted(Fcb->Mcb->Target)) ||            IsFileDeleted(Fcb->Mcb)) {            Status = STATUS_FILE_DELETED;            __leave;        }        if (Length == 0) {            Irp->IoStatus.Information = 0;            Status = STATUS_SUCCESS;            __leave;        }        if (Nocache &&                (ByteOffset.LowPart & (SECTOR_SIZE - 1) ||                 Length & (SECTOR_SIZE - 1))) {            Status = STATUS_INVALID_PARAMETER;            DbgBreak();            __leave;        }        if (FlagOn(IrpContext->MinorFunction, IRP_MN_DPC)) {            ClearFlag(IrpContext->MinorFunction, IRP_MN_DPC);            Status = STATUS_PENDING;            DbgBreak();            __leave;        }        if (!PagingIo && Nocache && (FileObject->SectionObjectPointer->DataSectionObject != NULL)) {            CcFlushCache( FileObject->SectionObjectPointer,                          &ByteOffset,                          Length,                          &Irp->IoStatus );            if (!NT_SUCCESS(Irp->IoStatus.Status)) {                __leave;//.........这里部分代码省略.........

//.........这里部分代码省略.........	AllocSize = ((LONGLONG)(FFSDataBlocks(Vcb, Totalblocks)) << BLOCK_BITS);	if ((LONGLONG)offset >= AllocSize)	{		FFSPrint((DBG_ERROR, "FFSv1WriteInode: beyond the file range./n"));		return STATUS_SUCCESS;	}	if ((LONGLONG)offset + size > AllocSize)	{		size = (ULONG)(AllocSize - offset);	}	blocks = FFSv1BuildBDL(IrpContext, Vcb, dinode1, offset, size, &ffs_bdl);	if (blocks <= 0)	{		return STATUS_SUCCESS;	}#if DBG	{		ULONG   dwTotal = 0;		FFSPrint((DBG_INFO, "FFSv1WriteInode: BDLCount = %xh Size=%xh Off=%xh/n",					blocks, size, offset));		for(i = 0; i < blocks; i++)		{			FFSPrint((DBG_INFO, "FFSv1WriteInode: Lba=%I64xh Len=%xh Off=%xh/n",						ffs_bdl[i].Lba, ffs_bdl[i].Length, ffs_bdl[i].Offset));			dwTotal += ffs_bdl[i].Length;		}		if (dwTotal != size)		{			FFSBreakPoint();		}		FFSPrint((DBG_INFO, "FFSv1WriteInode: Total = %xh (WriteToDisk=%x)/n",					dwTotal, bWriteToDisk));	}#endif	if (bWriteToDisk)	{#if 0		for(i = 0; i < blocks; i++)		{			{				CcFlushCache(&(Vcb->SectionObject),						(PLARGE_INTEGER)&(ffs_bdl[i].Lba),						ffs_bdl[i].Length,						NULL);				if (Vcb->SectionObject.DataSectionObject != NULL)				{					ExAcquireSharedStarveExclusive(&Vcb->PagingIoResource, TRUE);					ExReleaseResource(&Vcb->PagingIoResource);					CcPurgeCacheSection(&(Vcb->SectionObject),							(PLARGE_INTEGER)&(ffs_bdl[i].Lba),							ffs_bdl[i].Length,							FALSE);				}			}		}#endif		// assume offset is aligned.		Status = FFSReadWriteBlocks(IrpContext, Vcb, ffs_bdl, size, blocks, FALSE);	}	else	{		for(i = 0; i < blocks; i++)		{			if(!FFSSaveBuffer(IrpContext, Vcb, ffs_bdl[i].Lba, ffs_bdl[i].Length, (PVOID)((PUCHAR)Buffer + ffs_bdl[i].Offset)))				goto errorout;		}		if (IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK))		{			FFSPrint((DBG_USER, "FFSv1WriteInode is starting FlushingDpc.../n"));			FFSStartFloppyFlushDpc(Vcb, NULL, NULL);		}		Status = STATUS_SUCCESS;	}errorout:	if (ffs_bdl)		ExFreePool(ffs_bdl);	if (NT_SUCCESS(Status))	{		if (dwRet) *dwRet = size;	}	return Status;}

NTSTATUSFFSWriteFile(	IN PFFS_IRP_CONTEXT IrpContext){	NTSTATUS            Status = STATUS_UNSUCCESSFUL;	PFFS_VCB            Vcb  = NULL;	PFFS_FCB            Fcb  = NULL;	PFFS_CCB            Ccb =  NULL;	PFILE_OBJECT        FileObject  = NULL;	PFILE_OBJECT        CacheObject;	PDEVICE_OBJECT      DeviceObject  = NULL;	PIRP                Irp  = NULL;	PIO_STACK_LOCATION  IoStackLocation  = NULL;	ULONG               Length;	ULONG               ReturnedLength = 0;	LARGE_INTEGER       ByteOffset;	BOOLEAN             PagingIo;	BOOLEAN             Nocache;	BOOLEAN             SynchronousIo;	BOOLEAN             MainResourceAcquired = FALSE;	BOOLEAN             PagingIoResourceAcquired = FALSE;	BOOLEAN             bNeedExtending = FALSE;	BOOLEAN             bAppendFile = FALSE;	BOOLEAN             bDeferred = FALSE;	PUCHAR              Buffer = NULL;	__try	{		ASSERT(IrpContext);		ASSERT((IrpContext->Identifier.Type == FFSICX) &&				(IrpContext->Identifier.Size == sizeof(FFS_IRP_CONTEXT)));		DeviceObject = IrpContext->DeviceObject;		Vcb = (PFFS_VCB)DeviceObject->DeviceExtension;		ASSERT(Vcb != NULL);		ASSERT((Vcb->Identifier.Type == FFSVCB) &&				(Vcb->Identifier.Size == sizeof(FFS_VCB)));		FileObject = IrpContext->FileObject;		Fcb = (PFFS_FCB)FileObject->FsContext;		ASSERT(Fcb);		ASSERT((Fcb->Identifier.Type == FFSFCB) &&				(Fcb->Identifier.Size == sizeof(FFS_FCB)));		Ccb = (PFFS_CCB)FileObject->FsContext2;		Irp = IrpContext->Irp;		IoStackLocation = IoGetCurrentIrpStackLocation(Irp);		Length = IoStackLocation->Parameters.Write.Length;		ByteOffset = IoStackLocation->Parameters.Write.ByteOffset;		PagingIo = (Irp->Flags & IRP_PAGING_IO ? TRUE : FALSE);		Nocache = (Irp->Flags & IRP_NOCACHE ? TRUE : FALSE);		SynchronousIo = (FileObject->Flags & FO_SYNCHRONOUS_IO ? TRUE : FALSE);		FFSPrint((DBG_INFO, "FFSWriteFile: Off=%I64xh Len=%xh Paging=%xh Nocache=%xh/n",					ByteOffset.QuadPart, Length, PagingIo, Nocache));		/*		if (IsFlagOn(Fcb->Flags, FCB_FILE_DELETED))		{			Status = STATUS_FILE_DELETED;			__leave;		}		if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING))		{			Status = STATUS_DELETE_PENDING;			__leave;		}		*/		if (Length == 0)		{			Irp->IoStatus.Information = 0;			Status = STATUS_SUCCESS;			__leave;		}		if (Nocache &&				(ByteOffset.LowPart & (SECTOR_SIZE - 1) ||				 Length & (SECTOR_SIZE - 1)))		{//.........这里部分代码省略.........

VOIDExt2MediaEjectControl (    IN PEXT2_IRP_CONTEXT IrpContext,    IN PEXT2_VCB Vcb,    IN BOOLEAN bPrevent){    PIRP                    Irp;    KEVENT                  Event;    NTSTATUS                Status;    PREVENT_MEDIA_REMOVAL   Prevent;    IO_STATUS_BLOCK         IoStatus;    ExAcquireResourceExclusiveLite(        &Vcb->MainResource,        TRUE            );    if (bPrevent != IsFlagOn(Vcb->Flags, VCB_REMOVAL_PREVENTED)) {        if (bPrevent) {            SetFlag(Vcb->Flags, VCB_REMOVAL_PREVENTED);        } else {            ClearFlag(Vcb->Flags, VCB_REMOVAL_PREVENTED);        }    }    ExReleaseResourceLite(&Vcb->MainResource);    Prevent.PreventMediaRemoval = bPrevent;    KeInitializeEvent( &Event, NotificationEvent, FALSE );    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_MEDIA_REMOVAL,                                         Vcb->TargetDeviceObject,                                         &Prevent,                                         sizeof(PREVENT_MEDIA_REMOVAL),                                         NULL,                                         0,                                         FALSE,                                         NULL,                                         &IoStatus );    if (Irp != NULL) {        IoSetCompletionRoutine( Irp,                                Ext2MediaEjectControlCompletion,                                &Event,                                TRUE,                                TRUE,                                TRUE );        Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);        if (Status == STATUS_PENDING) {            Status = KeWaitForSingleObject( &Event,                                            Executive,                                            KernelMode,                                            FALSE,                                            NULL );        }    }}