windows-xp/Source/XPSP1/NT/drivers/storage/ramdisk/utils.c

/*++

Copyright (c) 2001  Microsoft Corporation

Module Name:

    utils.c

Abstract:

    This file contains utility code for the RAM disk driver.

Author:

    Chuck Lenzmeier (ChuckL) 2001

Environment:

    Kernel mode only.

Notes:

Revision History:

--*/

#include "precomp.h"
#pragma hdrstop

#ifdef ALLOC_PRAGMA

#if defined(POOL_DBG)
#pragma alloc_text( INIT, RamdiskInitializePoolDebug )
#endif // POOL_DBG

#endif // ALLOC_PRAGMA

NTSTATUS
SendIrpToThread (
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp
    )

/*++

Routine Description:

    This routine sends an IRP off to the worker thread so that it can be
    processed in thread context.

Arguments:

    DeviceObject - a pointer to the object that represents the device on which
        I/O is to be performed

    Irp - a pointer to the I/O Request Packet for this request

Return Value:

    None.

--*/

{
    PIO_WORKITEM workItem;

    //
    // Mark the IRP pending. Queue the IRP to a worker thread.
    //

    IoMarkIrpPending( Irp );

    workItem = IoAllocateWorkItem( DeviceObject );

    if ( workItem != NULL ) {

        //
        // Save the work item pointer so the worker thread can find it.
        //

        Irp->Tail.Overlay.DriverContext[0] = workItem;

        IoQueueWorkItem( workItem, RamdiskWorkerThread, DelayedWorkQueue, Irp );

        return STATUS_PENDING;
    }

    return STATUS_INSUFFICIENT_RESOURCES;

} // SendIrpToThread

PUCHAR
RamdiskMapPages (
    IN PDISK_EXTENSION DiskExtension,
    IN ULONGLONG Offset,
    IN ULONG RequestedLength,
    OUT PULONG ActualLength
    )

/*++

Routine Description:

    This routine maps pages of a RAM disk image into the system process.

Arguments:

    DiskExtension - a pointer to the device extension for the target device
        object

    Offset - the offset into the RAM disk image at which the mapping is to
        start

    RequestedLength - the desired length of the mapping

    ActualLength - returns the actual length of the mapping. This will be less
        than or equal to RequestedLength. If less than, the caller will need
        to call again to get the remainder of the desired range mapped.
        Because the number of available ranges may be limited, the caller
        should execute the required operation on one segment of the range and
        unmap it before mapping the next segment.

Return Value:

    PUCHAR - a pointer to the mapped space; NULL if the mapping failed

--*/

{
    NTSTATUS status;
    PUCHAR va;
    ULONGLONG diskRelativeOffset;
    ULONGLONG fileRelativeOffset;
    ULONG viewRelativeOffset;

    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                ("RamdiskMapPages: offset %I64x, length %x\n", Offset, RequestedLength) );

    //
    // The input Offset is relative to the start of the disk image, which
    // may not be the same as the start of the file or memory block. Capture
    // Offset into diskRelativeOffset, then calculate fileRelativeOffset as
    // the offset from the start of the file or memory block.
    //

    diskRelativeOffset = Offset;
    fileRelativeOffset = DiskExtension->DiskOffset + diskRelativeOffset;

    if ( RAMDISK_IS_FILE_BACKED(DiskExtension->DiskType) ) {

        //
        // For a file-backed RAM disk, we need to map the range into memory.
        //

        while ( TRUE ) {
        
            PLIST_ENTRY listEntry;
            PVIEW view;
    
            //
            // Lock the list of view descriptors.
            //
    
            KeEnterCriticalRegion();
            ExAcquireFastMutex( &DiskExtension->Mutex );
    
            //
            // Walk the list of view descriptors. Look for one that includes the
            // start of the range we're mapping.
            //
    
            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("RamdiskMapPages: looking for matching view; file offset %I64x\n",
                        fileRelativeOffset) );

            listEntry = DiskExtension->ViewsByOffset.Flink;
    
            while ( listEntry != &DiskExtension->ViewsByOffset ) {
    
                view = CONTAINING_RECORD( listEntry, VIEW, ByOffsetListEntry );
    
                DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                            ("RamdiskMapPages: view %p; offset %I64x, length %x\n",
                                view, view->Offset, view->Length) );

                ASSERT( (view->Offset + view->Length) >= view->Offset );

                if ( (view->Offset <= fileRelativeOffset) &&
                     (view->Offset + view->Length) > fileRelativeOffset ) {
    
                    //
                    // This view includes the start of our range. Reference it.
                    //
    
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: choosing existing view %p; offset %I64x, length %x\n",
                                    view, view->Offset, view->Length) );
    
                    if ( !view->Permanent ) {
                    
                        view->ReferenceCount++;

                        DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                    ("RamdiskMapPages: view %p; new refcount %x\n",
                                        view, view->ReferenceCount) );
        
                    } else {

                        DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                    ("RamdiskMapPages: view %p is permanent\n", view) );
                    }

                    //
                    // Move the view to the front of the MRU list.
                    //
    
                    RemoveEntryList( &view->ByMruListEntry );
                    InsertHeadList( &DiskExtension->ViewsByMru, &view->ByMruListEntry );
    
                    ExReleaseFastMutex( &DiskExtension->Mutex );
                    KeLeaveCriticalRegion();

                    //
                    // Calculate the amount of data that the caller can look
                    // at in this range. Usually this will be the requested
                    // amount, but if the caller's offset is close to the end
                    // of a view, the caller will only be able to look at data
                    // up to the end of the view.
                    //

                    viewRelativeOffset = (ULONG)(fileRelativeOffset - view->Offset);

                    *ActualLength = view->Length - viewRelativeOffset;
                    if ( *ActualLength > RequestedLength ) {
                        *ActualLength = RequestedLength;
                    }

                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: requested length %x; mapped length %x\n",
                                    RequestedLength, *ActualLength) );
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: view base %p; returned VA %p\n",
                                    view->Address,
                                    view->Address + viewRelativeOffset) );

                    //
                    // Return the virtual address corresponding to the caller's
                    // specified offset, which will usually be offset from the
                    // base of the view.
                    //

                    return view->Address + viewRelativeOffset;
                }
    
                //
                // This view does not include the start of our range. If the view
                // starts above the start of our range, then our range is not
                // currently mapped.
                //
    
                if ( view->Offset > fileRelativeOffset ) {
    
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("%s", "RamdiskMapPages: view too high; our range not mapped\n") );

                    break;
                }
    
                //
                // Check the next view in the list.
                //
    
                listEntry = listEntry->Flink;
            }
    
            //
            // We didn't find a view that maps the start of our range. Look for a
            // free view descriptor.
            //

            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("%s", "RamdiskMapPages: looking for free view\n") );

            listEntry = DiskExtension->ViewsByMru.Blink;
      
            while ( listEntry != &DiskExtension->ViewsByMru ) {
      
                view = CONTAINING_RECORD( listEntry, VIEW, ByMruListEntry );
      
                DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                            ("RamdiskMapPages: view %p; permanent %x, refcount %x\n",
                                view, view->Permanent, view->ReferenceCount) );

                if ( !view->Permanent && (view->ReferenceCount == 0) ) {
      
                    //
                    // This view descriptor is free. If it's currently mapped,
                    // unmap it.
                    //
      
                    PVOID mappedAddress;
                    ULONGLONG mappedOffset;
                    SIZE_T mappedLength;
      
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: view %p is free\n", view) );

                    if ( view->Address != NULL ) {
      
                        DBGPRINT( DBG_WINDOW, DBG_VERBOSE,
                                    ("RamdiskMapPages: unmapping view %p; offset %I64x, "
                                     "length %x, addr %p\n", view, view->Offset,
                                     view->Length, view->Address) );

                        MmUnmapViewOfSection( PsGetCurrentProcess(), view->Address );

                        //
                        // Reset the view descriptor and move it to the tail of
                        // the MRU list and the head of the by-offset list. We
                        // do this here in case we have to bail later (because
                        // mapping a new view fails).
                        //

                        view->Offset = 0;
                        view->Length = 0;
                        view->Address = NULL;
      
                        RemoveEntryList( listEntry );
                        InsertTailList( &DiskExtension->ViewsByMru, listEntry );

                        RemoveEntryList( &view->ByOffsetListEntry );
                        InsertHeadList( &DiskExtension->ViewsByOffset, &view->ByOffsetListEntry );
                    }
      
                    //
                    // Map a view to include the start of our range. Round the
                    // caller's offset down to the start of a view range.
                    //
      
                    mappedOffset = fileRelativeOffset & ~(ULONGLONG)(DiskExtension->ViewLength - 1);
                    mappedLength = DiskExtension->ViewLength;
                    if ( (mappedOffset + mappedLength) > DiskExtension->FileRelativeEndOfDisk) {
                        mappedLength = (SIZE_T)(DiskExtension->FileRelativeEndOfDisk - mappedOffset);
                    }
                    mappedAddress = NULL;
      
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: remapping view %p; offset %I64x, "
                                 "length %x\n", view, mappedOffset, mappedLength) );

                    status = MmMapViewOfSection(
                                DiskExtension->SectionObject,
                                PsGetCurrentProcess(),
                                &mappedAddress,
                                0,
                                0,
                                (PLARGE_INTEGER)&mappedOffset,
                                &mappedLength,
                                ViewUnmap,
                                0,
                                PAGE_READWRITE
                                );
      
                    if ( !NT_SUCCESS(status) ) {
      
                        //
                        // Unable to map the range. Inform the caller by returning
                        // NULL.
                        //
                        // ISSUE: Think about unmapping another region to see if
                        // mapping will then succeed.
                        //
      
                        DBGPRINT( DBG_WINDOW, DBG_ERROR,
                                    ("RamdiskMapPages: unable to map view: %x\n", status) );
    
                        ExReleaseFastMutex( &DiskExtension->Mutex );
                        KeLeaveCriticalRegion();
        
                        return NULL;
                    }
      
                    DBGPRINT( DBG_WINDOW, DBG_VERBOSE,
                                ("RamdiskMapPages: remapped view %p; offset %I64x, "
                                 "length %x, addr %p\n", view, mappedOffset, mappedLength,
                                 mappedAddress) );

                    //
                    // Capture the mapped range information into the view
                    // descriptor. Set the reference count to 1. Insert the
                    // view at the front of the MRU list, and at the
                    // appropriate point in the by-offset list.
                    //

                    view->Offset = mappedOffset;
                    view->Length = (ULONG)mappedLength;
                    view->Address = mappedAddress;
      
                    ASSERT( (view->Offset + view->Length) >= view->Offset );

                    view->ReferenceCount = 1;
      
                    RemoveEntryList( &view->ByMruListEntry );
                    InsertHeadList( &DiskExtension->ViewsByMru, &view->ByMruListEntry );

                    //
                    // Remove the view descriptor from its current point in
                    // the by-offset list (at or near the front, because it's
                    // currently unmapped). Scan from the tail of the by-offset
                    // list (highest offset down), looking for the first view
                    // that has an offset less than or equal to the new view.
                    // Insert the new view after that view. (If there are no
                    // views with an offset <= this one, it goes at the front
                    // of the list.)
                    //

                    RemoveEntryList( &view->ByOffsetListEntry );

                    listEntry = DiskExtension->ViewsByOffset.Blink;
            
                    while ( listEntry != &DiskExtension->ViewsByOffset ) {
            
                        PVIEW view2 = CONTAINING_RECORD( listEntry, VIEW, ByOffsetListEntry );
            
                        if ( view2->Offset <= view->Offset ) {

                            break;
                        }
            
                        listEntry = listEntry->Blink;
                    }

                    InsertHeadList( listEntry, &view->ByOffsetListEntry );

                    ExReleaseFastMutex( &DiskExtension->Mutex );
                    KeLeaveCriticalRegion();
      
                    //
                    // Calculate the amount of data that the caller can look
                    // at in this range. Usually this will be the requested
                    // amount, but if the caller's offset is close to the end
                    // of a view, the caller will only be able to look at data
                    // up to the end of the view.
                    //

                    viewRelativeOffset = (ULONG)(fileRelativeOffset - view->Offset);

                    *ActualLength = view->Length - viewRelativeOffset;
                    if ( *ActualLength > RequestedLength ) {
                        *ActualLength = RequestedLength;
                    }
      
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: requested length %x; mapped length %x\n",
                                    RequestedLength, *ActualLength) );
                    DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                                ("RamdiskMapPages: view base %p; returned VA %p\n",
                                    view->Address,
                                    view->Address + viewRelativeOffset) );
    
                    //
                    // Return the virtual address corresponding to the caller's
                    // specified offset, which will usually be offset from the
                    // base of the view.
                    //

                    return view->Address + viewRelativeOffset;
                }
      
                //
                // This view is not free. Try the previous view in the MRU list.
                //
      
                listEntry = listEntry->Blink;
            }
      
            //
            // We were unable to find a free view descriptor. Wait for one to
            // become available and start over.
            //
            // Before leaving the critical section, increment the count of
            // waiters. Then leave the critical section and wait on the
            // semaphore. The unmap code uses the waiter count to determine
            // how many times to release the semaphore. In this way, all
            // threads that are waiting or have decided to wait when the
            // unmap code runs will be awakened.
            //
      
            DiskExtension->ViewWaiterCount++;
      
            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("RamdiskMapPages: can't find free view, so waiting; new waiter count %x\n",
                            DiskExtension->ViewWaiterCount) );

            ExReleaseFastMutex( &DiskExtension->Mutex );
            KeLeaveCriticalRegion();
            
            status = KeWaitForSingleObject(
                        &DiskExtension->ViewSemaphore,
                        Executive,
                        KernelMode,
                        FALSE,
                        NULL );

            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("%s", "RamdiskMapPages: done waiting for free view\n") );
        }

    } else if ( DiskExtension->DiskType == RAMDISK_TYPE_BOOT_DISK ) {

        //
        // For a boot disk RAM disk, the image is contained in contiguous
        // reserved physical pages. Use MmMapIoSpace to get a virtual
        // address that corresponds to the physical address.
        //

        ULONG mappingSize;
        PHYSICAL_ADDRESS physicalAddress;
        PUCHAR mappedAddress;

        //
        // Determine how many pages must be mapped. Determine the base
        // physical address of the desired range. Map the range.
        //

        mappingSize = ADDRESS_AND_SIZE_TO_SPAN_PAGES(fileRelativeOffset, RequestedLength) * PAGE_SIZE;
    
        physicalAddress.QuadPart = (DiskExtension->BasePage +
                                    (fileRelativeOffset / PAGE_SIZE)) * PAGE_SIZE;
    
        mappedAddress = MmMapIoSpace( physicalAddress, mappingSize, MmCached );

        if ( mappedAddress == NULL ) {

            //
            // Unable to map the physical pages. Return NULL.
            //

            va = NULL;

        } else {

            //
            // Add the offset in the page to the returned virtual address.
            //

            va = mappedAddress + (fileRelativeOffset & (PAGE_SIZE - 1));
        }

        *ActualLength = RequestedLength;

    } else {

        //
        // For a virtual floppy RAM disk, the image is contained in contiguous
        // virtual memory. 
        //

        ASSERT( DiskExtension->DiskType == RAMDISK_TYPE_VIRTUAL_FLOPPY );

        va = (PUCHAR)DiskExtension->BaseAddress + fileRelativeOffset;

        *ActualLength = RequestedLength;
    }

    return va;

} // RamdiskMapPages

VOID
RamdiskUnmapPages (
    IN PDISK_EXTENSION DiskExtension,
    IN PUCHAR Va,
    IN ULONGLONG Offset,
    IN ULONG Length
    )

/*++

Routine Description:

    This routine unmaps previously mapped pages of a RAM disk image.

Arguments:

    DiskExtension - a pointer to the device extension for the target device
        object

    Va - the virtual address assigned to the mapping. This is unused for
        file-backed RAM disks.

    Offset - the offset into the RAM disk image at which the mapping starts

    Length - the length of the mapping

Return Value:

    None.

--*/

{
    ULONGLONG diskRelativeOffset;
    ULONGLONG fileRelativeOffset;
    ULONG viewRelativeOffset;

    //
    // The input Offset is relative to the start of the disk image, which
    // may not be the same as the start of the file or memory block. Capture
    // Offset into diskRelativeOffset, then calculate fileRelativeOffset as
    // the offset from the start of the file or memory block.
    //

    diskRelativeOffset = Offset;
    fileRelativeOffset = DiskExtension->DiskOffset + diskRelativeOffset;

    if ( RAMDISK_IS_FILE_BACKED(DiskExtension->DiskType) ) {

        //
        // For a file-backed RAM disk, we need to decrement the reference
        // count on all views that cover the specified range.
        //
        // Note: In the current implementation, no caller ever maps more
        // than one range at a time, and therefore no call to this routine
        // will need to dereference more than one view. But this routine
        // is written to allow for ranges that cover multiple views.
        //

        PLIST_ENTRY listEntry;
        PVIEW view;
        ULONGLONG rangeStart = fileRelativeOffset;
        ULONGLONG rangeEnd = fileRelativeOffset + Length;
        BOOLEAN wakeWaiters = FALSE;

        //
        // Lock the list of view descriptors.
        //

        KeEnterCriticalRegion();
        ExAcquireFastMutex( &DiskExtension->Mutex );

        //
        // Walk the list of view descriptors. For each one that includes the
        // range that we're unmapping, decrement the reference count.
        //

        listEntry = DiskExtension->ViewsByOffset.Flink;

        while ( Length != 0 ) {

            ASSERT( listEntry != &DiskExtension->ViewsByOffset );

            view = CONTAINING_RECORD( listEntry, VIEW, ByOffsetListEntry );

            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("RamdiskUnmapPages: view %p; offset %I64x, length %x\n",
                            view, view->Offset, view->Length) );

            if ( (view->Offset + view->Length) <= rangeStart ) {

                //
                // This view lies entirely below our range. Move on.
                //

                DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                            ("%s", "RamdiskMapPages: view too low; skipping\n") );

                listEntry = listEntry->Flink;

                ASSERT( listEntry != &DiskExtension->ViewsByOffset );

                continue;
            }

            //
            // This view does not lie below our range. Since the view list
            // is ordered by offset, and we have length left to unmap, this
            // view must NOT lie entirely ABOVE our range.
            //

            ASSERT( view->Offset < rangeEnd );

            //
            // Decrement the reference count for this view. If the count goes
            // to zero, we need to inform any waiters that at least one free
            // view is available.
            //
            // ISSUE: Note that unreferenced views remain mapped indefinitely.
            // We only unmap a view when we need to map a different view. If
            // a RAM disk goes idle, its views remain mapped, using up virtual
            // address space in the system process. With the current default
            // view count and length, this is 8 MB of VA. This is probably
            // not enough to make it worthwhile to implement a timer to unmap
            // idle views.
            //

            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("RamdiskUnmapPages: dereferencing view %p; offset %I64x, length %x\n",
                            view, view->Offset, view->Length) );

            if ( !view->Permanent ) {

                view->ReferenceCount--;

                if ( view->ReferenceCount == 0 ) {
                    wakeWaiters = TRUE;
                }

                DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                            ("RamdiskUnmapPages: view %p; new refcount %x\n",
                                view, view->ReferenceCount) );

            } else {

                DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                            ("RamdiskUnmapPages: view %p is permanent\n", view) );
            }

            //
            // Subtract the length of this view from the amount we're
            // unmapping. If the view fully encompasses our range, we're done.
            //

            if ( (view->Offset + view->Length) >= rangeEnd ) {

                Length = 0;

            } else {

                viewRelativeOffset = (ULONG)(fileRelativeOffset - view->Offset);
                Length -= view->Length - viewRelativeOffset;
                Offset = view->Offset + view->Length;

                ASSERT( Length != 0 );

                //
                // Move to the next view.
                //

                listEntry = listEntry->Flink;
            }
        }

        //
        // If one or more views are now free, and there are threads waiting,
        // wake them up now.
        //

        if ( wakeWaiters && (DiskExtension->ViewWaiterCount != 0) ) {

            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("RamdiskUnmapPages: waking %x waiters\n",
                            DiskExtension->ViewWaiterCount) );

            KeReleaseSemaphore(
                &DiskExtension->ViewSemaphore,
                0,
                DiskExtension->ViewWaiterCount,
                FALSE
                );

            DiskExtension->ViewWaiterCount = 0;
        }

        ExReleaseFastMutex( &DiskExtension->Mutex );
        KeLeaveCriticalRegion();

    } else if ( DiskExtension->DiskType == RAMDISK_TYPE_BOOT_DISK ) {

        //
        // For a boot disk RAM disk, use MmUnmapIoSpace to undo what
        // RamdiskMapPages did.
        //

        PUCHAR mappedAddress;
        ULONG mappingSize;

        //
        // The actual mapped address is at the base of the page given by Va.
        // The actual length of the mapping is based on the number of pages
        // covered by the range specified by Offset and Length.
        //

        mappedAddress = Va - (fileRelativeOffset & (PAGE_SIZE - 1));
        mappingSize = ADDRESS_AND_SIZE_TO_SPAN_PAGES(fileRelativeOffset, Length) * PAGE_SIZE;

        MmUnmapIoSpace( mappedAddress, mappingSize );
    }

    return;

} // RamdiskUnmapPages

NTSTATUS
RamdiskFlushViews (
    IN PDISK_EXTENSION DiskExtension
    )
{
    NTSTATUS status;
    NTSTATUS returnStatus;
    IO_STATUS_BLOCK iosb;
    PLIST_ENTRY listEntry;
    PVIEW view;
    SIZE_T viewLength;

    PAGED_CODE();

    DBGPRINT( DBG_WINDOW, DBG_PAINFUL, ("%s", "RamdiskFlushViews\n") );

    ASSERT( RAMDISK_IS_FILE_BACKED(DiskExtension->DiskType) );

    //
    // Lock the list of view descriptors.
    //

    //
    // Walk the list of view descriptors. For each one that is currently
    // mapped, flush its virtual memory to the backing file.
    //

    returnStatus = STATUS_SUCCESS;

    KeEnterCriticalRegion();
    ExAcquireFastMutex( &DiskExtension->Mutex );

    listEntry = DiskExtension->ViewsByOffset.Flink;

    while ( listEntry != &DiskExtension->ViewsByOffset ) {

        view = CONTAINING_RECORD( listEntry, VIEW, ByOffsetListEntry );

        DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                    ("RamdiskFlushViews: view %p; addr %p, offset %I64x, length %x\n",
                        view, view->Address, view->Offset, view->Length) );

        if ( view->Address != NULL ) {

            //
            // This view is mapped. Flush it.
            //

            DBGPRINT( DBG_WINDOW, DBG_PAINFUL,
                        ("%s", "RamdiskMapPages: view mapped; flushing\n") );

            viewLength = view->Length;

            status = ZwFlushVirtualMemory(
                        NtCurrentProcess(),
                        &view->Address,
                        &viewLength,
                        &iosb
                        );

            if ( NT_SUCCESS(status) ) {
                status = iosb.Status;
            }

            if ( !NT_SUCCESS(status) ) {

                DBGPRINT( DBG_WINDOW, DBG_ERROR,
                            ("RamdiskFlushViews: ZwFlushVirtualMemory failed: %x\n", status) );

                if ( returnStatus == STATUS_SUCCESS ) {
                    returnStatus = status;
                }
            }
        }

        //
        // Move to the next view.
        //

        listEntry = listEntry->Flink;
    }

    ExReleaseFastMutex( &DiskExtension->Mutex );
    KeLeaveCriticalRegion();

    return returnStatus;

} // RamdiskFlushViews

//
// Pool allocation debugging code.
//

#if defined(POOL_DBG)

//
// Allocations owned by the driver (both allocated by and deallocated by the
// driver) have the following header.
//

typedef struct _MY_POOL {
    union {
        CHAR Signature[8];
        ULONG SigLong[2];
    } ;
    LIST_ENTRY ListEntry;
    PVOID File;
    ULONG Line;
    POOL_TYPE Type;
} MY_POOL, *PMY_POOL;

#define MY_SIGNATURE "RaMdIsK"

LIST_ENTRY RamdiskNonpagedPoolList;
LIST_ENTRY RamdiskPagedPoolList;
FAST_MUTEX RamdiskPoolMutex;
KSPIN_LOCK RamdiskPoolSpinLock;

VOID
RamdiskInitializePoolDebug (
    VOID
    )
{
    InitializeListHead( &RamdiskNonpagedPoolList );
    InitializeListHead( &RamdiskPagedPoolList );
    ExInitializeFastMutex( &RamdiskPoolMutex );
    KeInitializeSpinLock( &RamdiskPoolSpinLock );

    return;

} // RamdiskInitializePoolDebug

PVOID
RamdiskAllocatePoolWithTag (
    POOL_TYPE PoolType,
    SIZE_T Size,
    ULONG Tag,
    LOGICAL Private,
    PCHAR File,
    ULONG Line
    )
{
    PMY_POOL myPool;
    KIRQL oldIrql;
    HRESULT result;

    if ( !Private ) {

        //
        // This is not a private allocation (it will be deallocated by some
        // other piece of code). We can't put a header on it.
        //

        myPool = ExAllocatePoolWithTag( PoolType, Size, Tag );

        DBGPRINT( DBG_POOL, DBG_PAINFUL,
                    ("Allocated %d bytes at %p for %s/%d\n", Size, myPool + 1, File, Line) );

        return myPool;
    }

    //
    // Allocate the requested space plus room for our header.
    //

    myPool = ExAllocatePoolWithTag( PoolType, sizeof(MY_POOL) + Size, Tag );

    if ( myPool == NULL ) {
        return NULL;
    }

    //
    // Fill in the header.
    //

    result = StringCbCopyA( myPool->Signature, sizeof( myPool->Signature ), MY_SIGNATURE );
    ASSERT( result == S_OK );

    myPool->File = File;
    myPool->Line = Line;
    myPool->Type = PoolType;

    //
    // Link the block into the appropriate list. If nonpaged pool, we must use
    // a spin lock to guard the list, because deallocation might happen at
    // raised IRQL. The paged pool list can be guarded by a mutex.
    //
    // NB: BASE_POOL_TYPE_MASK is defined in ntos\inc\pool.h.
    //

#define BASE_POOL_TYPE_MASK 1

    if ( (PoolType & BASE_POOL_TYPE_MASK) == NonPagedPool ) {

        KeAcquireSpinLock( &RamdiskPoolSpinLock, &oldIrql );

        InsertTailList( &RamdiskNonpagedPoolList, &myPool->ListEntry );

        KeReleaseSpinLock( &RamdiskPoolSpinLock, oldIrql );

    } else {

        KeEnterCriticalRegion();
        ExAcquireFastMutex( &RamdiskPoolMutex );

        InsertTailList( &RamdiskPagedPoolList, &myPool->ListEntry );

        ExReleaseFastMutex( &RamdiskPoolMutex );
        KeLeaveCriticalRegion();
    }

    //
    // Return a pointer to the caller's area, not to our header.
    //

    DBGPRINT( DBG_POOL, DBG_PAINFUL,
                ("Allocated %d bytes at %p for %s/%d\n", Size, myPool + 1, File, Line) );

    return myPool + 1;

} // RamdiskAllocatePoolWithTag

VOID
RamdiskFreePool (
    PVOID Address,
    LOGICAL Private,
    PCHAR File,
    ULONG Line
    )
{
    PMY_POOL myPool;
    PLIST_ENTRY list;
    PLIST_ENTRY listEntry;
    LOGICAL found;
    KIRQL oldIrql;

    //
    // The following line is here to get PREfast to stop complaining about the
    // call to KeReleaseSpinLock using an uninitialized variable.
    //

    oldIrql = 0;

    DBGPRINT( DBG_POOL, DBG_PAINFUL,
                ("Freeing pool at %p for %s/%d\n", Address, File, Line) );

    if ( !Private ) {

        //
        // This is not a private allocation (it was allocated by some other
        // piece of code). It doesn't have our header.
        //

        ExFreePool( Address );
        return;
    }

    //
    // Get the address of our header. Check that the header has our signature.
    //

    myPool = (PMY_POOL)Address - 1;

    if ( strcmp( myPool->Signature, MY_SIGNATURE ) != 0 ) {

        DbgPrint( "%s", "RAMDISK: Attempt to free pool block not owned by ramdisk.sys!!!\n" );
        DbgPrint( "  address: %p, freeing file: %s, line: %d\n", Address, File, Line );
        ASSERT( FALSE );

        //
        // Since it doesn't look like our header, assume that it wasn't
        // really a private allocation.
        //

        ExFreePool( Address );
        return;

    }

    //
    // Remove the block from the allocation list. First, acquire the
    // appropriate lock.
    //

    if ( (myPool->Type & BASE_POOL_TYPE_MASK) == NonPagedPool ) {

        list = &RamdiskNonpagedPoolList;

        KeAcquireSpinLock( &RamdiskPoolSpinLock, &oldIrql );

    } else {

        list = &RamdiskPagedPoolList;

        KeEnterCriticalRegion();
        ExAcquireFastMutex( &RamdiskPoolMutex );
    }

    //
    // Search the list for this block.
    //

    found = FALSE;

    for ( listEntry = list->Flink;
          listEntry != list;
          listEntry = listEntry->Flink ) {

        if ( listEntry == &myPool->ListEntry ) {

            //
            // Found this block. Remove it from the list and leave the loop.
            //

            RemoveEntryList( listEntry );
            found = TRUE;
            break;
        }
    }

    //
    // Release the lock.
    //

    if ( (myPool->Type & BASE_POOL_TYPE_MASK) == NonPagedPool ) {
    
        KeReleaseSpinLock( &RamdiskPoolSpinLock, oldIrql );

    } else {

        ExReleaseFastMutex( &RamdiskPoolMutex );
        KeLeaveCriticalRegion();
    }

    if ( !found ) {

        //
        // Didn't find the block in the list. Complain.
        //

        DbgPrint( "%s", "RAMDISK: Attempt to free pool block not in allocation list!!!\n" );
        DbgPrint( "  address: %p, freeing file: %s, line: %d\n", myPool, File, Line );
        DbgPrint( "  allocating file: %s, line: %d\n", myPool->File, myPool->Line );
        ASSERT( FALSE );
    }

    //
    // Free the pool block.
    //

    ExFreePool( myPool );

    return;

} // RamdiskFreePool

#endif // defined(POOL_DBG)