dispatch.c File Reference

#include "ext2fs.h"

Include dependency graph for dispatch.c:

Go to the source code of this file.

Functions
VOID	Ext2OplockComplete (IN PVOID Context, IN PIRP Irp)
VOID	Ext2LockIrp (IN PVOID Context, IN PIRP Irp)
NTSTATUS	Ext2QueueRequest (IN PEXT2_IRP_CONTEXT IrpContext)
VOID	Ext2DeQueueRequest (IN PVOID Context)
NTSTATUS	Ext2DispatchRequest (IN PEXT2_IRP_CONTEXT IrpContext)
NTSTATUS	Ext2BuildRequest (PDEVICE_OBJECT DeviceObject, PIRP Irp)

Variables
PEXT2_GLOBAL	Ext2Global

Function Documentation

Ext2BuildRequest()

NTSTATUS Ext2BuildRequest	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Definition at line 308 of file dispatch.c.

{
    BOOLEAN             AtIrqlPassiveLevel = FALSE;
    BOOLEAN             IsTopLevelIrp = FALSE;
    PEXT2_IRP_CONTEXT   IrpContext = NULL;
    NTSTATUS            Status = STATUS_UNSUCCESSFUL;
 
    _SEH2_TRY {
 
        _SEH2_TRY {
 
#if EXT2_DEBUG
            Ext2DbgPrintCall(DeviceObject, Irp);
#endif
 
            AtIrqlPassiveLevel = (KeGetCurrentIrql() == PASSIVE_LEVEL);
 
            if (AtIrqlPassiveLevel) {
                FsRtlEnterFileSystem();
            }
 
            if (!IoGetTopLevelIrp()) {
                IsTopLevelIrp = TRUE;
                IoSetTopLevelIrp(Irp);
            }
 
            IrpContext = Ext2AllocateIrpContext(DeviceObject, Irp);
 
            if (!IrpContext) {
 
                Status = STATUS_INSUFFICIENT_RESOURCES;
                Irp->IoStatus.Status = Status;
 
                Ext2CompleteRequest(Irp, TRUE, IO_NO_INCREMENT);
 
            } else {
 
                if ((IrpContext->MajorFunction == IRP_MJ_CREATE) &&
                        !AtIrqlPassiveLevel) {
 
                    DbgBreak();
                }
 
                Status = Ext2DispatchRequest(IrpContext);
            }
        } _SEH2_EXCEPT (Ext2ExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
 
            Status = Ext2ExceptionHandler(IrpContext);
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        if (IsTopLevelIrp) {
            IoSetTopLevelIrp(NULL);
        }
 
        if (AtIrqlPassiveLevel) {
            FsRtlExitFileSystem();
        }
    } _SEH2_END;
 
    return Status;
}

Ext2DeQueueRequest()

VOID Ext2DeQueueRequest

(

IN PVOID

Context

)

Definition at line 190 of file dispatch.c.

{
    PEXT2_IRP_CONTEXT IrpContext;
 
    IrpContext = (PEXT2_IRP_CONTEXT) Context;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    _SEH2_TRY {
 
        _SEH2_TRY {
 
            FsRtlEnterFileSystem();
 
            if (!IrpContext->IsTopLevel) {
                IoSetTopLevelIrp((PIRP) FSRTL_FSP_TOP_LEVEL_IRP);
            }
 
            Ext2DispatchRequest(IrpContext);
 
        } _SEH2_EXCEPT (Ext2ExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
 
            Ext2ExceptionHandler(IrpContext);
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        IoSetTopLevelIrp(NULL);
 
        FsRtlExitFileSystem();
    } _SEH2_END;
}

Referenced by Ext2QueueRequest().

Ext2DispatchRequest()

NTSTATUS Ext2DispatchRequest

(

IN PEXT2_IRP_CONTEXT

IrpContext

)

Definition at line 228 of file dispatch.c.

{
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    switch (IrpContext->MajorFunction) {
 
    case IRP_MJ_CREATE:
        return Ext2Create(IrpContext);
 
    case IRP_MJ_CLOSE:
        return Ext2Close(IrpContext);
 
    case IRP_MJ_READ:
        return Ext2Read(IrpContext);
 
    case IRP_MJ_WRITE:
        return Ext2Write(IrpContext);
 
    case IRP_MJ_FLUSH_BUFFERS:
        return Ext2Flush(IrpContext);
 
    case IRP_MJ_QUERY_INFORMATION:
        return Ext2QueryFileInformation(IrpContext);
 
    case IRP_MJ_SET_INFORMATION:
        return Ext2SetFileInformation(IrpContext);
 
    case IRP_MJ_QUERY_VOLUME_INFORMATION:
        return Ext2QueryVolumeInformation(IrpContext);
 
    case IRP_MJ_SET_VOLUME_INFORMATION:
        return Ext2SetVolumeInformation(IrpContext);
 
    case IRP_MJ_DIRECTORY_CONTROL:
        return Ext2DirectoryControl(IrpContext);
 
    case IRP_MJ_FILE_SYSTEM_CONTROL:
        return Ext2FileSystemControl(IrpContext);
 
    case IRP_MJ_DEVICE_CONTROL:
        return Ext2DeviceControl(IrpContext);
 
    case IRP_MJ_LOCK_CONTROL:
        return Ext2LockControl(IrpContext);
 
    case IRP_MJ_CLEANUP:
        return Ext2Cleanup(IrpContext);
 
    case IRP_MJ_SHUTDOWN:
        return Ext2ShutDown(IrpContext);
 
    case IRP_MJ_QUERY_EA:
        return Ext2QueryEa(IrpContext);
 
    case IRP_MJ_SET_EA:
        return Ext2SetEa(IrpContext);
 
#if (_WIN32_WINNT >= 0x0500)
    case IRP_MJ_PNP:
        return Ext2Pnp(IrpContext);
#endif //(_WIN32_WINNT >= 0x0500)
    default:
        DEBUG(DL_ERR, ( "Ext2DispatchRequest: Unexpected major function: %xh\n",
                        IrpContext->MajorFunction));
 
        Ext2CompleteIrpContext(IrpContext, STATUS_DRIVER_INTERNAL_ERROR);
 
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
}

Referenced by Ext2BuildRequest(), and Ext2DeQueueRequest().

Ext2LockIrp()

VOID Ext2LockIrp	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 94 of file dispatch.c.

{
    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;
}

Referenced by Ext2CreateFile(), Ext2QueueRequest(), Ext2ReadFile(), and Ext2WriteFile().

Ext2OplockComplete()

VOID Ext2OplockComplete	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 45 of file dispatch.c.

{
    //
    //  Check on the return value in the Irp.
    //
 
    if (Irp->IoStatus.Status == STATUS_SUCCESS) {
 
        //
        //  queue the Irp context in the workqueue.
        //
 
        Ext2QueueRequest((PEXT2_IRP_CONTEXT)Context);
 
    } else {
 
        //
        //  complete the request in case of failure
        //
 
        Ext2CompleteIrpContext( (PEXT2_IRP_CONTEXT) Context,
                                Irp->IoStatus.Status );
    }
 
    return;
}

Referenced by Ext2CreateFile(), Ext2LockControl(), Ext2ReadFile(), and Ext2WriteFile().

Ext2QueueRequest()

NTSTATUS Ext2QueueRequest

(

IN PEXT2_IRP_CONTEXT

IrpContext

)

Definition at line 158 of file dispatch.c.

{
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    /* set the flags of "can wait" and "queued" */
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_REQUEUED);
 
    /* make sure the buffer is kept valid in system context */
    Ext2LockIrp(IrpContext, IrpContext->Irp);
 
    /* initialize workite*/
    ExInitializeWorkItem(
        &IrpContext->WorkQueueItem,
        Ext2DeQueueRequest,
        IrpContext );
 
    /* dispatch it */
    ExQueueWorkItem(&IrpContext->WorkQueueItem, CriticalWorkQueue);
 
    return STATUS_PENDING;
}

Referenced by Ext2Cleanup(), Ext2Create(), Ext2DeferWrite(), Ext2DeleteReparsePoint(), Ext2ExceptionHandler(), Ext2GetReparsePoint(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2NotifyChangeDirectory(), Ext2OplockComplete(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2QueryVolumeInformation(), Ext2ReadFile(), Ext2ReadVolume(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetReparsePoint(), Ext2SetVolumeInformation(), Ext2ShutDown(), Ext2WriteFile(), and Ext2WriteVolume().

Variable Documentation

Ext2Global

PEXT2_GLOBAL Ext2Global

extern

Definition at line 16 of file init.c.