fileinfo.c

This is a ReiserFs file system driver for Windows NT/2000/XP/Vista.

                            FileObject,
                            (PCC_FILE_SIZES)&(Fcb->Header.AllocationSize),
                            FALSE,
                            &(RfsdGlobal->CacheManagerNoOpCallbacks),
                            Fcb );

                    CacheInitialized = TRUE;
                }

                if ( FEOFI->EndOfFile.QuadPart == 
                     Fcb->Header.AllocationSize.QuadPart) {

                    Status = STATUS_SUCCESS;

                } else if ( FEOFI->EndOfFile.QuadPart > 
                          Fcb->Header.AllocationSize.QuadPart) {

                    LARGE_INTEGER   FileSize = Fcb->Header.FileSize;

                    Status = RfsdExpandFile(IrpContext, Vcb, Fcb, &(FEOFI->EndOfFile));

                    if (NT_SUCCESS(Status)) {

                        Fcb->Header.FileSize.QuadPart = FEOFI->EndOfFile.QuadPart;

                        Fcb->Inode->i_size = FEOFI->EndOfFile.QuadPart;                        

                        Fcb->Header.ValidDataLength.QuadPart = 
                                        (LONGLONG)(0x7fffffffffffffff);

                        RfsdSaveInode( IrpContext,
                                       Vcb,
                                       Fcb->RfsdMcb->Inode,
                                       Fcb->Inode);


                        CcSetFileSizes(FileObject, 
                            (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));

                        SetFlag(FileObject->Flags, FO_FILE_MODIFIED);

                        RfsdZeroHoles( IrpContext, 
                                       Vcb, FileObject, 
                                       FileSize.QuadPart,
                                       Fcb->Header.AllocationSize.QuadPart - 
                                            FileSize.QuadPart );

                        NotifyFilter = FILE_NOTIFY_CHANGE_SIZE |
                                       FILE_NOTIFY_CHANGE_LAST_WRITE ;

                    }
                } else {

                    if (MmCanFileBeTruncated(&(Fcb->SectionObject), &(FEOFI->EndOfFile))) {

                        LARGE_INTEGER EndOfFile = FEOFI->EndOfFile;

                        EndOfFile.QuadPart = EndOfFile.QuadPart + 
                                             (LONGLONG)(Vcb->BlockSize - 1);

                        Status = RfsdTruncateFile(IrpContext, Vcb, Fcb, &(EndOfFile));

                        if (NT_SUCCESS(Status)) {

                            Fcb->Header.FileSize.QuadPart = FEOFI->EndOfFile.QuadPart;
                            Fcb->Inode->i_size = FEOFI->EndOfFile.QuadPart;                            

                            RfsdSaveInode( IrpContext,
                                           Vcb,
                                           Fcb->RfsdMcb->Inode,
                                           Fcb->Inode);

                            CcSetFileSizes(FileObject, 
                                    (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));

                            SetFlag(FileObject->Flags, FO_FILE_MODIFIED);

                            NotifyFilter = FILE_NOTIFY_CHANGE_SIZE |
                                           FILE_NOTIFY_CHANGE_LAST_WRITE ;
                        }

                    } else {

                        Status = STATUS_USER_MAPPED_FILE;
                        __leave;
                    }
                }
            }

            break;

        case FileDispositionInformation:
            {
                PFILE_DISPOSITION_INFORMATION FDI = (PFILE_DISPOSITION_INFORMATION)Buffer;
                
                Status = RfsdSetDispositionInfo(IrpContext, Vcb, Fcb, FDI->DeleteFile);
            }

            break;

        case FileRenameInformation:
            {
                Status = RfsdSetRenameInfo(IrpContext, Vcb, Fcb);
            }

            break;

            //
            // This is the only set file information request supported on read
            // only file systems
            //
        case FilePositionInformation:
            {
                PFILE_POSITION_INFORMATION FilePositionInformation;
                
                if (Length < sizeof(FILE_POSITION_INFORMATION)) {
                    Status = STATUS_INVALID_PARAMETER;
                    __leave;
                }
                
                FilePositionInformation = (PFILE_POSITION_INFORMATION) Buffer;
                
                if ((FlagOn(FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING)) &&
                    (FilePositionInformation->CurrentByteOffset.LowPart &
                    DeviceObject->AlignmentRequirement) ) {
                    Status = STATUS_INVALID_PARAMETER;
                    __leave;
                }
                
                FileObject->CurrentByteOffset =
                    FilePositionInformation->CurrentByteOffset;
                
                Status = STATUS_SUCCESS;
                __leave;
            }

            break;
            
        default:
            Status = STATUS_INVALID_INFO_CLASS;
        }

    } __finally {
        
        if (FcbPagingIoResourceAcquired) {
            ExReleaseResourceForThreadLite(
                &Fcb->PagingIoResource,
                ExGetCurrentResourceThread() );
        }
        
        if (NT_SUCCESS(Status) && (NotifyFilter != 0)) {
            RfsdNotifyReportChange(
                        IrpContext,
                        Vcb,
                        Fcb,
                        NotifyFilter,
                        FILE_ACTION_MODIFIED );

        }

        if (FcbMainResourceAcquired) {
            ExReleaseResourceForThreadLite(
                &Fcb->MainResource,
                ExGetCurrentResourceThread() );
        }
        
        if (VcbResourceAcquired) {
            ExReleaseResourceForThreadLite(
                &Vcb->MainResource,
                ExGetCurrentResourceThread() );
        }
        
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING) {
                RfsdQueueRequest(IrpContext);
            } else {
                RfsdCompleteIrpContext(IrpContext,  Status);
            }
        }
    }
    
    return Status;
}
#endif

#if DISABLED
NTSTATUS
RfsdExpandFile( PRFSD_IRP_CONTEXT IrpContext, 
                PRFSD_VCB Vcb, PRFSD_FCB Fcb,
                PLARGE_INTEGER AllocationSize)
{
DbgBreak();

    ULONG    dwRet = 0;
    NTSTATUS Status = STATUS_SUCCESS;

    if (AllocationSize->QuadPart <= Fcb->Header.AllocationSize.QuadPart) {
        return Status;
    }

    if (((LONGLONG)SUPER_BLOCK->s_free_blocks_count) * Vcb->BlockSize <=
        (AllocationSize->QuadPart - Fcb->Header.AllocationSize.QuadPart)  ) {
        RfsdPrint((DBG_ERROR, "RfsdExpandFile: There is no enough disk space available.\n"));
        return STATUS_DISK_FULL;
    }

    while (NT_SUCCESS(Status) && (AllocationSize->QuadPart > Fcb->Header.AllocationSize.QuadPart)) {
        Status = RfsdExpandInode(IrpContext, Vcb, Fcb, &dwRet);
    }
    
    return Status;
}
#endif

#if DISABLE
NTSTATUS
RfsdTruncateFile( PRFSD_IRP_CONTEXT IrpContext,
                  PRFSD_VCB Vcb, PRFSD_FCB Fcb,
                  PLARGE_INTEGER AllocationSize)
{
DbgBreak();

    NTSTATUS Status = STATUS_SUCCESS;
    
    while (NT_SUCCESS(Status) && (AllocationSize->QuadPart <
                    Fcb->Header.AllocationSize.QuadPart)) {
        Status= RfsdTruncateInode(IrpContext, Vcb, Fcb);
    }

    return Status;
}
#endif

#if DISABLE
NTSTATUS
RfsdSetDispositionInfo(
            PRFSD_IRP_CONTEXT IrpContext,
            PRFSD_VCB Vcb,
            PRFSD_FCB Fcb,
            BOOLEAN bDelete)
{
DbgBreak();

    PIRP    Irp = IrpContext->Irp;
    PIO_STACK_LOCATION IrpSp;

    IrpSp = IoGetCurrentIrpStackLocation(Irp);

    RfsdPrint((DBG_INFO, "RfsdSetDispositionInfo: bDelete=%x\n", bDelete));
    
    if (bDelete) {

        RfsdPrint((DBG_INFO, "RfsdSetDispositionInformation: MmFlushImageSection on %s.\n", 
                             Fcb->AnsiFileName.Buffer));

        if (!MmFlushImageSection( &Fcb->SectionObject,
                                  MmFlushForDelete )) {
            return STATUS_CANNOT_DELETE;
        }

        if (RFSD_IS_ROOT_KEY(Fcb->RfsdMcb->Key)) {
            return STATUS_CANNOT_DELETE;
        }

        if (IsDirectory(Fcb)) {
            if (!RfsdIsDirectoryEmpty(Vcb, Fcb)) {
                return STATUS_DIRECTORY_NOT_EMPTY;
            }
        }

        SetFlag(Fcb->Flags, FCB_DELETE_PENDING);
        IrpSp->FileObject->DeletePending = TRUE;

        if (IsDirectory(Fcb)) {
            FsRtlNotifyFullChangeDirectory( Vcb->NotifySync,
                                            &Vcb->NotifyList,
                                            Fcb,
                                            NULL,
                                            FALSE,
                                            FALSE,
                                            0,
                                            NULL,
                                            NULL,
                                            NULL );
        }

    } else {

        ClearFlag(Fcb->Flags, FCB_DELETE_PENDING);
        IrpSp->FileObject->DeletePending = FALSE;
    }

    return STATUS_SUCCESS;
}  
#endif

#if DISABLED
NTSTATUS
RfsdSetRenameInfo(
            PRFSD_IRP_CONTEXT IrpContext,
            PRFSD_VCB         Vcb,
            PRFSD_FCB         Fcb       )
{
DbgBreak();

    PRFSD_FCB               TargetDcb;
    PRFSD_MCB               TargetMcb;

    PRFSD_MCB               Mcb;
    RFSD_INODE              Inode;

    UNICODE_STRING          FileName;
    
    NTSTATUS                Status;

    PIRP                    Irp;
    PIO_STACK_LOCATION      IrpSp;

    PFILE_OBJECT            FileObject;
    PFILE_OBJECT            TargetObject;
    BOOLEAN                 ReplaceIfExists;

    BOOLEAN                 bMove = FALSE;

    PFILE_RENAME_INFORMATION    FRI;

    if (Fcb->RfsdMcb->Inode == RFSD_ROOT_INO) {
        Status = STATUS_INVALID_PARAMETER;
        goto errorout;
    }

    Irp = IrpContext->Irp;
    IrpSp = IoGetCurrentIrpStackLocation(Irp);

    FileObject = IrpSp->FileObject;
    TargetObject = IrpSp->Parameters.SetFile.FileObject;
    ReplaceIfExists = IrpSp->Parameters.SetFile.ReplaceIfExists;

    FRI = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;

    if (TargetObject == NULL) {

        UNICODE_STRING  NewName;

        NewName.Buffer = FRI->FileName;
        NewName.MaximumLength = NewName.Length = (USHORT)FRI->FileNameLength;

        while (NewName.Length > 0 && NewName.Buffer[NewName.Length/2 - 1] == L'\\') {
            NewName.Buffer[NewName.Length/2 - 1] = 0;
            NewName.Length -= 2;
        }

        while (NewName.Length > 0 && NewName.Buffer[NewName.Length/2 - 1] != L'\\') {
            NewName.Length -= 2;
        }

        NewName.Buffer = (USHORT *)((UCHAR *)NewName.Buffer + NewName.Length);
        NewName.Length = (USHORT)(FRI->FileNameLength - NewName.Length);

        FileName = NewName;

        TargetDcb = NULL;
        TargetMcb = Fcb->RfsdMcb->Parent;
        
        if (FileName.Length >= RFSD_NAME_LEN*sizeof(USHORT)) {
            Status = STATUS_OBJECT_NAME_INVALID;
            goto errorout;
        }

    } else {

        TargetDcb = (PRFSD_FCB)(TargetObject->FsContext);

        if (!TargetDcb || TargetDcb->Vcb != Vcb) {

            DbgBreak();

            Status = STATUS_INVALID_PARAMETER;
            goto errorout;
        }

        TargetMcb = TargetDcb->RfsdMcb;