Last hacks before move to TraceFS analysis SharedCacheMap based Cc.

[captive.git] / src / libcaptive / cc / map.c

/* $Id$
 * reactos Cache Manager mapper emulation of libcaptive
 * Copyright (C) 2002-2003 Jan Kratochvil <project-captive@jankratochvil.net>
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; exactly version 2 of June 1991 is required
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


#include "config.h"

#include "reactos/ddk/ccfuncs.h"        /* self */
#include <glib/gmessages.h>
#include <glib/ghash.h>
#include <glib/gmem.h>
#include <sys/mman.h>
#include "reactos/ddk/mmfuncs.h"        /* for MmCreateMdl() */
#include "reactos/ddk/kefuncs.h"        /* for KeInitializeEvent() */
#include "reactos/ddk/iofuncs.h"        /* for IoPageRead() */
#include "captive/macros.h"
#include <sys/types.h>
#include <sys/shm.h>
#include <unistd.h>
#include <glib/glist.h>
#include "reactos/internal/io.h"        /* for IoSynchronousPageWrite() */
#include <glib/gmain.h>
#include "captive/leave.h"
#include <glib/gtree.h>
#include "reactos/ddk/obfuncs.h"        /* for ObReferenceObject() */


/* CONFIG: */

#define CAPTIVE_PUBLIC_BCB_NODETYPECODE 0xDE45  /* FIXME: unknown, undocumented */
/* Prepare linear mapped space by CcInitializeCacheMap()?
 * NT-5.1sp will map the same pages of a file to the same memory location
 * either by CcMap*() or CcPin*().
 * We do a separate mapping for each Bcb protected by bounding unmapped pages
 * with IPC shm shared pages if a file page is mapped multiple times.
 * I am not aware how they can reserve enough virtual memory space during
 * client with mapping requests of increasing range tendency.
 * This define will try to pre-map the file as one linear are during 
 * CcInitializeCacheMap() according to its (CC_FILE_SIZES *)FileSizes
 * but TODO the range is currently left unused in further mapping functions.
 */
/* #define CAPTIVE_FILE_INITIALIZED_CACHE_IS_LINEAR 1 */


/* Does each privbcb put one reference count on its FileObject?
 * Causes ntfs.sys of NT-5.1sp1:
 *      Assertion 'Header->ValidDataLength.QuadPart == Li0.QuadPart' failed at d:\xpsp1\base\fs\ntfs\write.c line 1749
 */
/* #define CAPTIVE_PRIVBCB_REFERENCES_FILEOBJECT 1 */


/* Flush all the buffers directly on the fly.
 * For details see the comment in libcaptive/client/init.c/captive_shutdown().
 */
gboolean captive_cc_unmounting=FALSE;


/* map: (FILE_OBJECT *)FileObject -> (struct fileobject_cached *) */
static GHashTable *fileobject_cached_hash;

struct fileobject_cached {
        CACHE_MANAGER_CALLBACKS CallBacks;
        VOID *LazyWriterContext;
#ifdef CAPTIVE_FILE_INITIALIZED_CACHE_IS_LINEAR
        PVOID Bcb;
#endif
        };

static void fileobject_cached_hash_value_destroy_func(struct fileobject_cached *value)
{
        g_return_if_fail(value!=NULL);

        g_free(value);
}

static void fileobject_cached_hash_init(void)
{
        if (fileobject_cached_hash)
                return;
        fileobject_cached_hash=g_hash_table_new_full(
                        g_direct_hash,  /* hash_func */
                        g_direct_equal, /* key_equal_func */
                        NULL,   /* key_destroy_func */
                        (GDestroyNotify)fileobject_cached_hash_value_destroy_func);     /* value_destroy_func */
}


/**
 * CcInitializeCacheMap:
 * @FileObject: Existing file to set callbacks for. Ignored by libcaptive.
 * %NULL value is forbidden.
 * @FileSizes: Some file sizes suggestions. Ignored by libcaptive.
 * %NULL value is forbidden.
 * @PinAccess: CcPin*() functions will be used with @FileObject? Ignored by libcaptive.
 * @CallBacks: Provided callback functions for readahead/writebehind. Ignored by libcaptive.
 * %NULL value is forbidden.
 * @LazyWriterContext: Value passed to functions of @CallBacks to bind with @FileObject.
 * %NULL value is permitted.
 *
 * Provides support of readahead/writebehind in W32. Function should be called
 * by W32 filesystem to offer its functions to W32 kernel. These functions
 * are never called by libcaptive, this call is a NOP in libcaptive.
 *
 * VERIFIED: Double CcInitializeCacheMap() without CcUninitializeCacheMap().
 */
VOID CcInitializeCacheMap(IN PFILE_OBJECT FileObject,
                IN PCC_FILE_SIZES FileSizes,IN BOOLEAN PinAccess,IN PCACHE_MANAGER_CALLBACKS CallBacks,IN PVOID LazyWriterContext)
{
struct fileobject_cached *fileobject_cached;
#ifdef CAPTIVE_FILE_INITIALIZED_CACHE_IS_LINEAR
guint64 size64;
LARGE_INTEGER FileOffset0;
PVOID Buffer_trash;
BOOLEAN errboolean;
#endif

        g_return_if_fail(FileObject!=NULL);
        g_return_if_fail(FileSizes!=NULL);
        g_return_if_fail(CallBacks!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,"
                        "FileSizes->AllocationSize=0x%llX,FileSizes->FileSize=0x%llX,FileSizes->ValidDataLength=0x%llX,"
                        "PinAccess=%d,CallBacks=%p,LazyWriterContext=%p",G_STRLOC,
                        FileObject,(guint64)FileSizes->AllocationSize.QuadPart,(guint64)FileSizes->FileSize.QuadPart,
                        (guint64)FileSizes->ValidDataLength.QuadPart,(gint)PinAccess,CallBacks,LazyWriterContext);

        fileobject_cached_hash_init();

        /* TODO:thread */

        /* Double reinitialization without CcUninitializeCacheMap()
         * is done by both fastfat.sys and ntfs.sys of NT-5.1sp1.
         */
#if 0
        g_assert(g_hash_table_lookup(fileobject_cached_hash,FileObject)==NULL);
#endif

        captive_new(fileobject_cached);
        fileobject_cached->CallBacks=*CallBacks;
        fileobject_cached->LazyWriterContext=LazyWriterContext;

        g_hash_table_insert(fileobject_cached_hash,
                        FileObject,     /* key */
                        fileobject_cached);     /* value */

#if CAPTIVE_FILE_INITIALIZED_CACHE_IS_LINEAR
        size64=MAX(MAX(FileSizes->AllocationSize.QuadPart,FileSizes->FileSize.QuadPart),
                        (FileSizes->ValidDataLength.QuadPart==G_MAXINT64 ? 0 : FileSizes->ValidDataLength.QuadPart));
        g_assert(((ULONG)size64)==size64);
        FileOffset0.QuadPart=0;

        errboolean=CcMapData(FileObject,&FileOffset0,size64,MAP_WAIT,&fileobject_cached->Bcb,&Buffer_trash);
        g_assert(errboolean==TRUE);
#endif
}


BOOLEAN captive_cc_FileObject_delete(FILE_OBJECT *FileObject);
struct private_bcb;
static void CcUninitializeCacheMap_private_bcb_hash_foreach(
                PUBLIC_BCB *PublicBcb,  /* key */
                struct private_bcb *privbcb,    /* value */
                FILE_OBJECT *FileObject);       /* user_data */
extern GHashTable *private_bcb_hash;

/**
 * CcUninitializeCacheMap:
 * @FileObject: File to close caching for.
 * %NULL value is forbidden.
 * @TruncateSize: Current file size if @FileObject was truncated to it in the meantime.
 * @UninitializeCompleteEvent: Optional event to signal after physical write to disk.
 * %NULL value is permitted.
 *
 * Close the cachine facilities from CcInitializeCacheMap().
 * It is valid to pass @FileObject without being registered by CcInitializeCacheMap().
 *
 * FIXME; What to do with files with dirty blocks? Currently we fail assertion on them
 * although I think W32 would drop such buffers (purge them - not flush them).
 *
 * Returns: %TRUE if the caching was closed successfuly.
 * %FALSE if @FileObject wasn't registered by CcInitializeCacheMap().
 */
BOOLEAN CcUninitializeCacheMap(IN PFILE_OBJECT FileObject,
                IN PLARGE_INTEGER TruncateSize OPTIONAL,IN PCACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent OPTIONAL)
{
BOOLEAN r;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        /* assert current size ==*TruncateSize if TruncateSize */

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,TruncateSize=0x%llX,UninitializeCompleteEvent=%p",
                        G_STRLOC,FileObject,(guint64)(!TruncateSize ? -1 : TruncateSize->QuadPart),UninitializeCompleteEvent);

        /* TODO:thread */
        /* Here it will check for any dirty blocks and it will fail g_assert() on them.
         * I think it may happen for BCBs to exist dirty for 'FileObject' and they
         * should be silently discarded if CcUninitializeCacheMap() but currently
         * the assertion is left here as some debugging aid.
         */
#if 0
        r=captive_cc_FileObject_delete(FileObject);
#else
        r=g_hash_table_remove(fileobject_cached_hash,FileObject);
        g_hash_table_foreach(
                        private_bcb_hash,       /* hash_table */
                        (GHFunc)CcUninitializeCacheMap_private_bcb_hash_foreach,        /* func */
                        FileObject);    /* user_data */
#endif

        /* FIXME: should we do KePulseEvent? Are we allowed to signal from inside CcUninitializeCacheMap() ? */
        if (UninitializeCompleteEvent)
                KeSetEvent(
                                &UninitializeCompleteEvent->Event,      /* Event */
                                IO_NO_INCREMENT,        /* Increment */
                                FALSE); /* Wait */

        return r;
}


static gboolean validate_Bcb(const PUBLIC_BCB *PublicBcb)
{
        g_return_val_if_fail(PublicBcb!=NULL,FALSE);
        g_return_val_if_fail(PublicBcb->NodeTypeCode==CAPTIVE_PUBLIC_BCB_NODETYPECODE,FALSE);
        g_return_val_if_fail(PublicBcb->NodeByteSize==sizeof(*PublicBcb),FALSE);
        g_return_val_if_fail(PublicBcb->MappedLength>0,FALSE);
        g_return_val_if_fail(PublicBcb->MappedFileOffset.QuadPart>=0,FALSE);

        return TRUE;
}


/* position in file */
struct page_position {
        FILE_OBJECT *FileObject;
        LARGE_INTEGER FileOffset;       /* always PAGE_SIZE aligned */
        int shmid;
        GList *privbcb_list;    /* each mapped page has its one private_bcb */
        gboolean building;      /* data are not yet read; prevention for CcMapData() reentrancy */
        };

/* map: (struct page_position *)pagepos -> (struct page_position *)pagepos */
static GHashTable *page_position_hash;

static gboolean validate_page_position(const struct page_position *pagepos)
{
int errint;
struct shmid_ds shmid_ds;

        g_return_val_if_fail(pagepos!=NULL,FALSE);
        g_return_val_if_fail(pagepos->FileObject!=NULL,FALSE);
        g_return_val_if_fail(pagepos->FileOffset.QuadPart>=0,FALSE);
        g_return_val_if_fail(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(pagepos->FileOffset.QuadPart,PAGE_SIZE),FALSE);
        /* 'pagepos->shmid' may be -1 */
        /* 'pagepos->privbcb_list' may be empty */
        /* either deleted or alive */
        /* shmid exists only for >=2 mappings, it is simple mmap() for single mapping */
        g_return_val_if_fail((pagepos->shmid==-1)==(pagepos->privbcb_list==NULL || pagepos->privbcb_list->next==NULL),FALSE);

        if (pagepos->shmid!=-1) {
                errint=shmctl(pagepos->shmid,
                                IPC_STAT,       /* cmd */
                                &shmid_ds);     /* buf */
                g_return_val_if_fail(errint==0,FALSE);

                g_return_val_if_fail(shmid_ds.shm_perm.uid==geteuid(),FALSE);
                g_return_val_if_fail(shmid_ds.shm_perm.gid==getegid(),FALSE);
                g_return_val_if_fail(shmid_ds.shm_perm.cuid==geteuid(),FALSE);
                g_return_val_if_fail(shmid_ds.shm_perm.cgid==getegid(),FALSE);
                /* 'shm_perm.mode' was seen with sticky bit 01000: */
                g_return_val_if_fail((shmid_ds.shm_perm.mode&0777)==0600,FALSE);
                g_return_val_if_fail(shmid_ds.shm_segsz==PAGE_SIZE,FALSE);
                /* Do not check 'shmid_ds.shm_cpid' and 'shmid_ds.shm_lpid' against getpid()
                 * as we may run as different PIDs in different threads synchronized by client/ .
                 */
                g_return_val_if_fail(shmid_ds.shm_nattch==g_list_length(pagepos->privbcb_list),FALSE);
                }

        return TRUE;
}

static guint page_position_hash_hash_func(const struct page_position *key)
{
        g_return_val_if_fail(validate_page_position(key),0);

        return ((guint)key->FileObject)^(key->FileOffset.QuadPart);
}

static gboolean page_position_hash_key_equal_func(const struct page_position *a,const struct page_position *b)
{
        g_return_val_if_fail(validate_page_position(a),FALSE);
        g_return_val_if_fail(validate_page_position(b),FALSE);

        return (a->FileObject==b->FileObject && a->FileOffset.QuadPart==b->FileOffset.QuadPart);
}

static void page_position_hash_key_destroy_func(struct page_position *key)
{
        g_return_if_fail(validate_page_position(key));
        g_assert(key->privbcb_list==NULL);
        g_assert(key->shmid==-1);

        g_free(key);
}

static void page_position_hash_init(void)
{
        if (page_position_hash)
                return;
        page_position_hash=g_hash_table_new_full(
                        (GHashFunc)page_position_hash_hash_func,        /* hash_func */
                        (GEqualFunc)page_position_hash_key_equal_func,  /* key_equal_func */
                        (GDestroyNotify)page_position_hash_key_destroy_func,    /* key_destroy_func */
                        NULL);  /* value_destroy_func */
}


struct private_bcb {
        PUBLIC_BCB *PublicBcb;  /* ->MappedLength, ->MappedFileOffset */
        FILE_OBJECT *FileObject;
        gint ref_count;
        gboolean leave_func_pending;
        /* we save it here as 'PublicBcb' may be already destroyed in private_bcb_hash_value_destroy_func(): */
        ULONG MappedLength;     /* It is the real requested size; it is not PAGE_SIZE aligned. */
        /* we save it here as 'PublicBcb' may be already destroyed in private_bcb_hash_value_destroy_func(): */
        LARGE_INTEGER MappedFileOffset; /* It is the real requested offset; it is not PAGE_SIZE aligned. */
        gpointer base;  /* It is the pointer corresponding to MappedFileOffset; it is not PAGE_SIZE aligned. */
        gboolean dirty;
        LARGE_INTEGER lsn; gboolean lsn_valid;
        gboolean forbid_CcUnpinData_leave_func_finalize_remove;
        };


/* map: (struct private_bcb *)privbcb -> (struct private_bcb *)privbcb */
static GTree *private_bcb_lsn_tree;

/* Such debugging messages are too much expensive.
 * Use to track for deallocated privbcb-s/PublicBcb-s.
 */
/* #define DEBUG_PRIVATE_BCB_LSN_TREE_KEY_COMPARE_FUNC 1 */

/* Although 'private_bcb_lsn_tree' contains only nodes with 'lsn_valid' TRUE
 * compare_func cannot expect such arguments as it may be used to lookup
 * privbcb unlisted in 'private_bcb_lsn_tree'.
 */
static gint private_bcb_lsn_tree_key_compare_func(struct private_bcb *a,struct private_bcb *b,gpointer user_data /* NULL */)
{
gint64 a_lsn,b_lsn;
gint r;

#ifdef DEBUG_PRIVATE_BCB_LSN_TREE_KEY_COMPARE_FUNC
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb a=%p,privbcb b=%p",G_STRLOC,a,b);
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb a->PublicBcb=%p",G_STRLOC,a->PublicBcb);
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb b->PublicBcb=%p",G_STRLOC,b->PublicBcb);
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb a->PublicBcb->MappedLength=%u",G_STRLOC,(unsigned)a->PublicBcb->MappedLength);
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb b->PublicBcb->MappedLength=%u",G_STRLOC,(unsigned)b->PublicBcb->MappedLength);
#endif

        g_return_val_if_fail(a!=NULL,0);
        g_return_val_if_fail(validate_Bcb(a->PublicBcb),0);
        g_assert(!a->lsn_valid || a->lsn.QuadPart!=(LONGLONG)G_MAXINT64);       /* Forbid defined LSN as G_MAXINT64 */
        g_return_val_if_fail(b!=NULL,0);
        g_return_val_if_fail(validate_Bcb(b->PublicBcb),0);
        g_assert(!b->lsn_valid || b->lsn.QuadPart!=(LONGLONG)G_MAXINT64);       /* Forbid defined LSN as G_MAXINT64 */

        if (a==b) {     /* LSN would be apparently the same in such case :-) */
#ifdef DEBUG_PRIVATE_BCB_LSN_TREE_KEY_COMPARE_FUNC
                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: return 0 (a==b)",G_STRLOC);
#endif
                return 0;
                }

        a_lsn=(!a->lsn_valid ? (LONGLONG)G_MAXINT64 : a->lsn.QuadPart);
        b_lsn=(!b->lsn_valid ? (LONGLONG)G_MAXINT64 : b->lsn.QuadPart);

        /* Forbid the same LSNs if both defined */
        g_assert(a_lsn==(LONGLONG)G_MAXINT64 || a_lsn!=b_lsn);

        if ((r=(a_lsn>b_lsn)-(a_lsn<b_lsn))) {
#ifdef DEBUG_PRIVATE_BCB_LSN_TREE_KEY_COMPARE_FUNC
                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: return %d (lsn !=)",G_STRLOC,r);
#endif
                return r;
                }

#ifdef DEBUG_PRIVATE_BCB_LSN_TREE_KEY_COMPARE_FUNC
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: return (ptr !=)",G_STRLOC);
#endif
        return (a>b)-(a<b);
}

static void private_bcb_lsn_tree_init(void)
{
        if (private_bcb_lsn_tree)
                return;
        private_bcb_lsn_tree=g_tree_new(
                        (GCompareFunc)private_bcb_lsn_tree_key_compare_func);   /* key_compare_func */
}


static gboolean captive_privbcb_flush_ordered(struct private_bcb *privbcb_req);

static void CcUninitializeCacheMap_private_bcb_hash_foreach(
                PUBLIC_BCB *PublicBcb,  /* key */
                struct private_bcb *privbcb,    /* value */
                FILE_OBJECT *FileObject)        /* user_data */
{
        g_return_if_fail(validate_Bcb(PublicBcb));
        g_return_if_fail(privbcb!=NULL);
        g_return_if_fail(PublicBcb==privbcb->PublicBcb);
        g_return_if_fail(FileObject!=NULL);

        if (privbcb->FileObject!=FileObject)
                return;

        captive_privbcb_flush_ordered(privbcb);
}


enum privbcb_item {
        PRIVBCB_ITEM_NOP,       /* for sanity checks */
        PRIVBCB_ITEM_DIRTY,
        PRIVBCB_ITEM_LSN_VALID,
        PRIVBCB_ITEM_LEAVE_FUNC_PENDING,
        PRIVBCB_ITEM_REF_COUNT,
        PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,      /* no protections against 'leave_func_pending' */
        };

static void privbcb_set(struct private_bcb *privbcb,enum privbcb_item item,gint value)
{
        g_return_if_fail(privbcb!=NULL);

        private_bcb_lsn_tree_init();

        g_assert((privbcb->lsn_valid ? privbcb : NULL)==g_tree_lookup(private_bcb_lsn_tree,privbcb));
        switch (item) {
                case PRIVBCB_ITEM_NOP:
                        break;
                case PRIVBCB_ITEM_DIRTY:
                        g_assert(TRUE==value || FALSE==value);
                        privbcb->dirty=value;
                        break;
                case PRIVBCB_ITEM_LSN_VALID:
                        /* Never change 'privbcb->lsn_valid' while it is linked in 'private_bcb_lsn_tree'
                         * as it could become unreachable due to private_bcb_lsn_tree_key_compare_func()
                         * behaviour wrt 'privbcb->lsn_valid'!
                         */
                        g_tree_remove(private_bcb_lsn_tree,privbcb);
                        g_assert(TRUE==value || FALSE==value);
                        privbcb->lsn_valid=value;
                        if (privbcb->lsn_valid)
                                g_tree_insert(private_bcb_lsn_tree,
                                                privbcb,        /* key */
                                                privbcb);       /* value */
                        break;
                case PRIVBCB_ITEM_LEAVE_FUNC_PENDING:
                        g_assert(TRUE==value || FALSE==value);
                        privbcb->leave_func_pending=value;
                        if (value)
                                g_assert(privbcb->ref_count==1);
                        break;
                case PRIVBCB_ITEM_REF_COUNT:
                        /* Forbid reincarnation of 'leave_func_pending' privbcb. */
                        g_assert(!privbcb->leave_func_pending);
                        g_assert(privbcb->ref_count>=1);
                        privbcb->ref_count+=value;
                        g_assert(privbcb->ref_count>=1);
                        break;
                case PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR:
                        g_assert(privbcb->ref_count>=0);
                        privbcb->ref_count+=value;
                        g_assert(privbcb->ref_count>=0);
                        break;
                default: g_assert_not_reached();
                }
        g_assert((privbcb->lsn_valid ? privbcb : NULL)==g_tree_lookup(private_bcb_lsn_tree,privbcb));
}


/* map: (PUBLIC_BCB *)PublicBcb -> (struct private_bcb *)privbcb */
static GHashTable *private_bcb_hash;

static void private_bcb_hash_key_destroy_func(PUBLIC_BCB *key)
{
        g_return_if_fail(validate_Bcb(key));

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: g_free: PublicBcb=%p",G_STRLOC,key);

        g_free(key);
}

static void private_bcb_hash_value_destroy_func(struct private_bcb *value)
{
struct page_position pagepos_local;
gboolean errbool;
int errint;
size_t offset;
gpointer base_aligned;

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: g_free: privbcb=%p (->PublicBcb=%p)",G_STRLOC,value,value->PublicBcb);

        g_return_if_fail(value!=NULL);
        /* We cannot do 'validate_Bcb(value->PublicBcb)' here as 'value->PublicBcb'
         * may got already destroyed by 'private_bcb_hash_key_destroy_func(key)'
         */
        g_return_if_fail(value->PublicBcb!=NULL);
        g_return_if_fail(value->FileObject!=NULL);
        g_return_if_fail(value->ref_count==0);
        g_return_if_fail(value->MappedLength>0);
        g_return_if_fail(value->MappedFileOffset.QuadPart>=0);
        g_return_if_fail(value->base!=NULL);
        g_return_if_fail(value->dirty==FALSE);
        /* Ensure we are not registered in 'private_bcb_lsn_tree'. */
        g_return_if_fail(value->lsn_valid==FALSE);

        page_position_hash_init();

        base_aligned=((char *)value->base)-CAPTIVE_ROUND_DOWN_EXCEEDING64(value->MappedFileOffset.QuadPart,PAGE_SIZE);

        pagepos_local.FileObject=value->FileObject;
        pagepos_local.privbcb_list=NULL;
        pagepos_local.shmid=-1;
        for (
                        offset=0;
                        offset<value->MappedLength;
                        offset+=PAGE_SIZE) {
struct page_position *pagepos;

                pagepos_local.FileOffset.QuadPart=CAPTIVE_ROUND_DOWN64(value->MappedFileOffset.QuadPart+offset,PAGE_SIZE);
                pagepos=g_hash_table_lookup(page_position_hash,&pagepos_local);
                g_assert(validate_page_position(pagepos));
                g_assert(pagepos->privbcb_list!=NULL);
                if (pagepos->privbcb_list->next==NULL) {        /* single mapping by mmap(), no shm */
                        g_assert(pagepos->shmid==-1);
                        errint=munmap(((char *)base_aligned)+offset,PAGE_SIZE);
                        g_assert(errint==0);
                        }
                else if (pagepos->privbcb_list->next->next==NULL) {     /* mapping 2 -> 1, convert shm to mmap() */
struct private_bcb *privbcb_other;
gint64 privbcb_other_offset_relative;
gpointer mapped_other,errptr;

                        g_assert(pagepos->shmid!=-1);
                        if (value==pagepos->privbcb_list->data)
                                privbcb_other=pagepos->privbcb_list->next->data;
                        else {
                                privbcb_other=pagepos->privbcb_list->data;
                                g_assert(value==pagepos->privbcb_list->next->data);
                                }
                        privbcb_other_offset_relative=pagepos->FileOffset.QuadPart-privbcb_other->MappedFileOffset.QuadPart;
                        /* privbcb_other_offset_relative may be negative up to -PAGE_SIZE
                         * as 'MappedFileOffset' and 'base' are not page-aligned.
                         */
                        mapped_other=privbcb_other->base+privbcb_other_offset_relative;
                        /* TODO:thread; shmdt()..mmap() window */
                        errint=shmdt(mapped_other);
                        g_assert(errint==0);
                        errptr=mmap(
                                        mapped_other,   /* start */
                                        PAGE_SIZE,      /* length */
                                        PROT_READ|PROT_WRITE,   /* prot */
                                        MAP_PRIVATE|MAP_ANONYMOUS,      /* flags */
                                        -1,     /* fd; ignored due to MAP_ANONYMOUS */
                                        0);     /* offset; ignored due to MAP_ANONYMOUS */
                        g_assert(errptr==mapped_other);
                        memcpy(mapped_other,((char *)base_aligned)+offset,PAGE_SIZE);
                        errint=shmdt(((char *)base_aligned)+offset);    /* destroys shm */
                        g_assert(errint==0);
                        /* It should be destroyed automatically as IPC_RMID should be pending from its foundation. */
                        pagepos->shmid=-1;
                        }
                else {  /* mappings (>=3) -> (>=2) */
                        g_assert(pagepos->shmid!=-1);
                        errint=shmdt(((char *)base_aligned)+offset);
                        g_assert(errint==0);
                        }

                g_assert(g_list_find(pagepos->privbcb_list,value)!=NULL);
                pagepos->privbcb_list=g_list_remove(pagepos->privbcb_list,value);
                g_assert(g_list_find(pagepos->privbcb_list,value)==NULL);

                if (pagepos->privbcb_list==NULL) {      /* last mapping by mmap() removed */
                        g_assert(pagepos->shmid==-1);
                        errbool=g_hash_table_remove(page_position_hash,&pagepos_local);
                        g_assert(errbool==TRUE);
                        }
                else    /* mapping is now >=1, either by mmap() or shm */
                        g_assert(validate_page_position(pagepos));
                }

#ifdef CAPTIVE_PRIVBCB_REFERENCES_FILEOBJECT
        ObDereferenceObject(value->FileObject);
#endif

        g_free(value);
}

static void private_bcb_hash_init(void)
{
        if (private_bcb_hash)
                return;
        private_bcb_hash=g_hash_table_new_full(
                        g_direct_hash,  /* hash_func */
                        g_direct_equal, /* key_equal_func */
                        (GDestroyNotify)private_bcb_hash_key_destroy_func,      /* key_destroy_func */
                        (GDestroyNotify)private_bcb_hash_value_destroy_func);   /* value_destroy_func */
}


static void CcUnpinData_leave_unregister(struct private_bcb *privbcb);
static gboolean captive_privbcb_flush_ordered(struct private_bcb *privbcb_req);

static gboolean captive_cc_FileObject_delete_private_bcb_hash_foreach(
                PUBLIC_BCB *PublicBcb,  /* key */
                struct private_bcb *privbcb,  /* value */
                FILE_OBJECT *FileObject)  /* user_data */
{
        g_return_val_if_fail(validate_Bcb(PublicBcb),FALSE);    /* meaning: do not remove this 'privbcb' */
        g_return_val_if_fail(privbcb!=NULL,FALSE);      /* meaning: do not remove this 'privbcb' */
        g_return_val_if_fail(PublicBcb==privbcb->PublicBcb,FALSE);      /* meaning: do not remove this 'privbcb' */
        g_return_val_if_fail(FileObject!=NULL,FALSE);   /* meaning: do not remove this 'privbcb' */

        if (FileObject && privbcb->FileObject!=FileObject)
                return FALSE;   /* do not remove this 'privbcb' */

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,PublicBcb=%p,privbcb=%p,privbcb->ref_count=%d"
                                        ",privbcb->leave_func_pending=%d,privbcb->dirty=%d,privbcb->lsn=%" G_GINT64_FORMAT,G_STRLOC,
                        FileObject,PublicBcb,privbcb,privbcb->ref_count,
                                        privbcb->leave_func_pending,privbcb->dirty,(gint64)(!privbcb->lsn_valid ? -1 : privbcb->lsn.QuadPart));

        /* It is not OK to leave it in 'private_bcb_hash' as although it is protected
         * against privbcb reincarnation its pagepos items could be reincarnated.
         */
        if (privbcb->leave_func_pending) {
#if 0
                g_assert_not_reached();
                captive_privbcb_flush_ordered(privbcb);
                return FALSE;   /* do not remove this 'privbcb' */
                g_assert_not_reached();
                g_assert(privbcb->dirty==FALSE);
#endif
                CcUnpinData_leave_unregister(privbcb);
                g_assert(privbcb->leave_func_pending==FALSE);
                }

        /* Do not reuse captive_privbcb_flush_ordered() destructor here as we cannot
         * call g_hash_table_remove() from inside g_hash_table_foreach_remove() callback.
         */

        g_assert(privbcb->dirty==FALSE);        /* it would be fatal */

        g_assert(privbcb->leave_func_pending==FALSE);
        /* Force 'ref_count' drop to 0 to pass private_bcb_hash_value_destroy_func(). */
        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,-privbcb->ref_count);
        /* Unset LSN to unlink from 'private_bcb_lsn_tree'. */
        privbcb_set(privbcb,PRIVBCB_ITEM_LSN_VALID,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: WARNING: Deleting file with pending (fortunately non-dirty) BCBs"
                        "; privbcb=%p,PublicBcb=%p,FileObject=%p,FileOffset=0x%llX,Length=0x%lX",G_STRLOC,
                        privbcb,PublicBcb,privbcb->FileObject,(guint64)privbcb->MappedFileOffset.QuadPart,(gulong)privbcb->MappedLength);

        return TRUE;    /* remove this 'privbcb' */
}

BOOLEAN captive_cc_FileObject_delete(FILE_OBJECT *FileObject)
{
struct fileobject_cached *fileobject_cached;
BOOLEAN r=TRUE;

        /* 'FileObject' may be NULL to check/clear the whole cache. */

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p",G_STRLOC,FileObject);

        fileobject_cached_hash_init();
        private_bcb_hash_init();

        if (!FileObject || !(fileobject_cached=g_hash_table_lookup(fileobject_cached_hash,FileObject)))
                r=FALSE;
        else {
#ifdef CAPTIVE_FILE_INITIALIZED_CACHE_IS_LINEAR
                CcUnpinData(fileobject_cached->Bcb);
#endif
                g_hash_table_remove(fileobject_cached_hash,FileObject);
                }

        g_hash_table_foreach_remove(
                        private_bcb_hash,       /* hash_table */
                        (GHRFunc)captive_cc_FileObject_delete_private_bcb_hash_foreach, /* func */
                        FileObject);    /* user_data */

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: returning r=%d",G_STRLOC,r);

        return r;
}


static gboolean captive_privbcb_flush_unordered(struct private_bcb *privbcb);

static void captive_cc_flush_private_bcb_hash_foreach(
                PUBLIC_BCB *PublicBcb,  /* key */
                struct private_bcb *privbcb,  /* value */
                gboolean *flushedp)     /* user_data */
{
gboolean errbool;

        g_return_if_fail(validate_Bcb(PublicBcb));
        g_return_if_fail(privbcb!=NULL);
        g_return_if_fail(PublicBcb==privbcb->PublicBcb);

        if (!privbcb->dirty)    /* OK */
                return;

        /* Such privbcb should have been flushed by captive_privbcb_flush_ordered(NULL) before
         * to ensure its LSN ordering.
         */
        g_assert(!privbcb->lsn_valid);

        *flushedp=TRUE;
        errbool=captive_privbcb_flush_unordered(privbcb);
        g_assert(errbool==TRUE);
}

void captive_cc_flush(void)
{
gboolean flushed;

        fileobject_cached_hash_init();
        private_bcb_hash_init();

        do {
                /* Trace it by g_tree first to attempt to keep LSN ordering */
                flushed=captive_privbcb_flush_ordered(NULL);
                g_hash_table_foreach(
                                private_bcb_hash,       /* hash_table */
                                (GHFunc)captive_cc_flush_private_bcb_hash_foreach,      /* func */
                                &flushed);      /* user_data */
                captive_leave();
                } while (flushed);

        /* We must not call: captive_cc_FileObject_delete(NULL);
         * here as it would destroy all the Bcbs needed for the forthcoming
         * IoShutdownRegisteredFileSystems().
         */
}


static ULONG captive_Cc_IoPageRead(FILE_OBJECT *FileObject,gpointer address,ULONG length,LARGE_INTEGER *FileOffset)
{
MDL *Mdl;
KEVENT Event;
IO_STATUS_BLOCK IoStatus;
NTSTATUS err;

        g_return_val_if_fail(FileObject!=NULL,0);
        g_return_val_if_fail(address!=0,0);
        g_return_val_if_fail(length!=0,0);
        g_return_val_if_fail(FileOffset!=NULL,0);

        /* VolumeRead on ext2fsd.sys will return IoStatus.Information==0 although it
         * successfuly read the data. Workaround it - preclear (not postclear) the
         * buffer and do not make any other assumptions about the data read.
         */
        memset(address,0,length);       /* pre-clear the buffer */
        Mdl=MmCreateMdl(NULL,address,length);   /* FIXME: Deprecated in favor of IoAllocateMdl() */
        g_assert(Mdl!=NULL);
        MmBuildMdlForNonPagedPool(Mdl);
        KeInitializeEvent(&Event,NotificationEvent,FALSE);
        IoStatus.Information=0; /* preventive pre-clear for buggy filesystems */
        err=IoPageRead(FileObject,Mdl,FileOffset,&Event,&IoStatus);
        g_assert(NT_SUCCESS(err));
        g_assert(NT_SUCCESS(IoStatus.Status));
        /* It is not == as the file may be shorter than requested */
        g_assert(IoStatus.Information<=length);
        IoFreeMdl(Mdl);

        /* Forbidden, see the comment above about ext2fsd.sys.
         * memset(((char *)address)+IoStatus.Information,0,(length-IoStatus.Information));
         */

        return IoStatus.Information;    /* may be shorter than real! */
}


static struct private_bcb *captive_privbcb_find(IN PFILE_OBJECT FileObject,IN PLARGE_INTEGER FileOffset,IN ULONG Length,
                PUBLIC_BCB *Bcb_find)
{
struct page_position pagepos_local,*pagepos;
struct private_bcb *privbcb,*privbcb_listitem;
GList *privbcb_list;

        g_return_val_if_fail(FileObject!=NULL,NULL);
        g_return_val_if_fail(FileOffset!=NULL,NULL);
        /* 'Bcb_find' may be NULL */

        page_position_hash_init();

        pagepos_local.FileObject=FileObject;
        pagepos_local.FileOffset.QuadPart=CAPTIVE_ROUND_DOWN64(FileOffset->QuadPart,PAGE_SIZE);
        pagepos_local.privbcb_list=NULL;
        pagepos_local.shmid=-1;
        if (!(pagepos=g_hash_table_lookup(page_position_hash,&pagepos_local)))
                return NULL;
        g_assert(validate_page_position(pagepos));
        g_assert(pagepos->privbcb_list!=NULL);

        privbcb=NULL;
        for (privbcb_list=pagepos->privbcb_list;privbcb_list;privbcb_list=privbcb_list->next) {
                privbcb_listitem=privbcb_list->data;
                if (1
                                && privbcb_listitem->MappedFileOffset.QuadPart==FileOffset->QuadPart
                                && privbcb_listitem->MappedLength==Length
                                && (!Bcb_find || Bcb_find==privbcb_listitem->PublicBcb)) {
                        g_assert(privbcb==NULL);        /* appropriate 'Bcb_find'-matching privbcb found twice */
                        privbcb=privbcb_listitem;
                        if (!Bcb_find)
                                break;
                        }
                }
        if (!privbcb)
                return NULL;

        /* Sanity check 'privbcb': */
        g_return_val_if_fail(FileObject==privbcb->FileObject,FALSE);

        return privbcb;
}


/**
 * CcMapData:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @FileOffset: The @FileObject file offset from where to map the region from.
 * Negative value is forbidden.
 * @Length: Requested length of the region to map from @FileObject.
 * FIXME: Value %0 is currently forbidden by libcaptive; it should be allowed.
 * @Flags: %MAP_WAIT means whether disk waiting is permitted for this function.
 * Value without %MAP_WAIT is currently forbidden by libcaptive as we have no on-demand loading implemented.
 * %MAP_NO_READ will leave the pages unread (libcaptive: unread pages zeroed,
 * already mapped pages shared with existing content) - needed by ntfs.sys of NT-5.1sp1
 * as during file write it will %MAP_NO_READ and consequently push the data there;
 * any request for the same file range read in the meantime will destroy the prepared data!
 * @Bcb: Returns initialized #PUBLIC_BCB to refer to the mapped region.
 * The memory region can be larger than requested as it is %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 * @Buffer: Returns the mapped memory region start address.
 * This address may not be %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 *
 * Maps the specified region of @FileObject to automatically chosen address space.
 * FIXME: No on-demand loading implemented yet - the whole region is read at the time of this function call.
 *
 * WARNING: If you modify the data in the returned @Buffer you must call some CcPinMappedData()
 * or CcPinRead() afterwards. W32 docs say you should never modify the data in any way from this function
 * but W32 filesystems apparently do not conform to it. If you do not take care of the
 * modified data by some dirty-marking facility such data will be carelessly dropped without
 * their commit to the disk.
 *
 * This call does not set the buffer as dirty - such buffer will not be flushed automatically.
 *
 * Every call to this function must be matched by a one corresponding CcUnpinData() call.
 *
 * We can be called as full CcMapData() (e.g. CcPinRead() from fastfat.sys)
 * even if such mapping for such file already exists.
 * We should probably create a new #Bcb for the same space,
 * at least ntfs.sys of NT-5.1sp1 appears to expect it. Bleech.
 *
 * Returns: %TRUE if the region was successfuly mapped.
 * @Bcb with the initialized new memory region.
 * @Buffer with the address of the exact byte specified by @FileOffset.
 */
BOOLEAN CcMapData(IN PFILE_OBJECT FileObject,
                IN PLARGE_INTEGER FileOffset,IN ULONG Length,IN ULONG Flags,OUT PVOID *Bcb,OUT PVOID *Buffer)
{
PUBLIC_BCB **PublicBcbp,*PublicBcb;
struct page_position pagepos_local;
LARGE_INTEGER FileOffset_bottom,FileOffset_top;
gpointer base_aligned;
size_t length_mapped_aligned;
gint length_pages_aligned;
struct page_position **pagepos_array;
int errint;
gpointer errptr;
struct private_bcb *privbcb;
gboolean after_eof=FALSE;       /* Did we reached the end of file already? */

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(FileOffset!=NULL,FALSE);
        g_return_val_if_fail(FileOffset->QuadPart>=0,FALSE);
        g_return_val_if_fail(Length>0,FALSE);   /* FIXME: not handled below; 0 should be allowed */
        g_return_val_if_fail(Flags&MAP_WAIT,FALSE);     /* FIXME: on-demand loading not yet implemented */
        g_return_val_if_fail(!(Flags&~(MAP_WAIT|MAP_NO_READ)),FALSE);   /* unknown flags? */
        g_return_val_if_fail(Bcb!=NULL,FALSE);
        g_return_val_if_fail(Buffer!=NULL,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,FileOffset=0x%llX,Length=0x%lX,Flags=0x%lX",G_STRLOC,
                        FileObject,(guint64)FileOffset->QuadPart,(gulong)Length,(gulong)Flags);

        if (Flags&MAP_NO_READ) {
                g_assert(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(FileOffset->QuadPart,PAGE_SIZE));    /* NOT IMPLEMENTED YET */
                /* It may not be aligned as this function is prepared by 'after_eof' for incomplete tails.
                 * It is being used at least by ntfs.sys of NT-5.1sp1 CcCopyWrite().
                 */
#if 0
                g_assert(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(FileOffset->QuadPart+Length,PAGE_SIZE));     /* NOT IMPLEMENTED YET */
#endif
                }

        g_return_val_if_fail(FileObject->SectionObjectPointers!=NULL,FALSE);
        g_return_val_if_fail(FileObject->DeviceObject!=NULL,FALSE);
#if 0   /* SectorSize can be really weird but we do not use it anyway */
        /* Is PAGE_SIZE aligned with 'FileObject->DeviceObject->SectorSize'?
         * 'SectorSize' may not yet be initialized during mount operation
         * and 'FileObject->DeviceObject->Vpb' may exist in such case.
         */
        g_return_val_if_fail(0
                                        || FileObject->DeviceObject->SectorSize==0      /* prevent division by 0 */
                                        || 0==CAPTIVE_ROUND_DOWN_EXCEEDING(PAGE_SIZE,FileObject->DeviceObject->SectorSize),
                        FALSE);
#endif

        page_position_hash_init();
        private_bcb_hash_init();

        PublicBcbp=(PUBLIC_BCB **)Bcb;
        /* extend 'FileOffset' and 'Length' to page boundaries */
        FileOffset_bottom.QuadPart=CAPTIVE_ROUND_DOWN64(FileOffset->QuadPart,PAGE_SIZE);
        FileOffset_top.QuadPart=CAPTIVE_ROUND_UP64(FileOffset->QuadPart+Length,PAGE_SIZE);
        length_mapped_aligned=(FileOffset_top.QuadPart-FileOffset_bottom.QuadPart);
        g_assert(0==CAPTIVE_ROUND_DOWN_EXCEEDING(length_mapped_aligned,PAGE_SIZE));
        length_pages_aligned=length_mapped_aligned/PAGE_SIZE;

        /* We can be called as full CcMapData() (e.g. CcPinRead() from fastfat.sys)
         * even if such mapping for such file already exists.
         * We should probably create a new Bcb for the same space,
         * at least ntfs.sys of NT-5.1sp1 appears to expect it. Bleech.
         */
        if ((privbcb=captive_privbcb_find(FileObject,FileOffset,Length,NULL)))
                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,FileOffset=0x%llX,Length=0x%lX already mapped by privbcb %p",
                                G_STRLOC,FileObject,(guint64)FileOffset->QuadPart,(gulong)Length,privbcb);

        /* Create 'base_aligned'; referenced as unaligned by 'privbcb'. */
        /* TODO: on-demand loading */
        /* Although we do zeroed-page mapping here we just reserve the linear
         * space by it.
         */
        base_aligned=mmap(
                        NULL,   /* start */
                        PAGE_SIZE+length_mapped_aligned+PAGE_SIZE,      /* length; leading and trailing boundary check pages */
                        PROT_READ|PROT_WRITE,   /* prot; read/write must be possible although write is not guaranteed to be flushed yet */
                        MAP_PRIVATE|MAP_ANONYMOUS,      /* flags */
                        -1,     /* fd; ignored due to MAP_ANONYMOUS */
                        0);     /* offset; ignored due to MAP_ANONYMOUS */
        g_assert(base_aligned!=NULL);

        base_aligned+=PAGE_SIZE;
        errint=munmap(base_aligned-PAGE_SIZE,PAGE_SIZE);        /* unmap leading boundary check page */
        g_assert(errint==0);
        errint=munmap(base_aligned+length_mapped_aligned,PAGE_SIZE);    /* unmap trailing boundary check page */
        g_assert(errint==0);

        /* Create 'PublicBcb'; referenced by 'privbcb'. */
        captive_new(PublicBcb);
        PublicBcb->NodeTypeCode=CAPTIVE_PUBLIC_BCB_NODETYPECODE;
        PublicBcb->NodeByteSize=sizeof(*PublicBcb);     /* we have no extensions there */
        PublicBcb->MappedLength=Length;
        PublicBcb->MappedFileOffset=*FileOffset;

        /* Create 'privbcb'; referenced by created 'pagepos'es. */
        captive_new(privbcb);
        privbcb->PublicBcb=PublicBcb;
        privbcb->FileObject=FileObject;
        privbcb->ref_count=1;
        privbcb->leave_func_pending=FALSE;
        privbcb->MappedLength=PublicBcb->MappedLength;
        privbcb->MappedFileOffset=PublicBcb->MappedFileOffset;
        privbcb->base=base_aligned+CAPTIVE_ROUND_DOWN_EXCEEDING64(FileOffset->QuadPart,PAGE_SIZE);
        privbcb->dirty=FALSE;
        privbcb->lsn_valid=FALSE;
        privbcb->forbid_CcUnpinData_leave_func_finalize_remove=FALSE;
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: g_hash_table_insert: PublicBcb=%p,privbcb=%p",G_STRLOC,
                        PublicBcb,privbcb);
        g_hash_table_insert(private_bcb_hash,
                        PublicBcb,      /* key */
                        privbcb);       /* value */

#ifdef CAPTIVE_PRIVBCB_REFERENCES_FILEOBJECT
        ObReferenceObject(FileObject);
#endif

        privbcb_set(privbcb,PRIVBCB_ITEM_NOP,0);        /* just for the assertions */

        /* We MUST NOT call captive_Cc_IoPageRead() inside our pagepos filling loop
         * below as captive_Cc_IoPageRead() has very big consequences as it calls
         * the filesystem code and we may get reentrancy.
         * Therefore we store all missing page read requests to 'pagepos_array' and we
         * fill them when all the memory structures are in consistent state.
         * We can also coalescence the requests more easily this way.
         */
        captive_newn_alloca(pagepos_array,length_pages_aligned);

        pagepos_local.FileObject=FileObject;
        pagepos_local.shmid=-1;
        pagepos_local.privbcb_list=NULL;
        {
size_t offset;

                for (
                                offset=0;
                                offset<length_mapped_aligned;
                                offset+=PAGE_SIZE) {
gpointer pageaddr;
struct page_position *pagepos;

                        pagepos_local.FileOffset.QuadPart=FileOffset_bottom.QuadPart+offset;
                        pageaddr=(gpointer)(((char *)base_aligned)+offset);
                        if (!(pagepos=g_hash_table_lookup(page_position_hash,&pagepos_local))) {
                                captive_new(pagepos);
                                *pagepos=pagepos_local;
                                pagepos->shmid=-1;
                                pagepos->privbcb_list=NULL;
                                pagepos->building=TRUE;
                                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: read of offset %llu to new pagepos %p of pure mmap() to address %p",
                                                G_STRLOC,(unsigned long long)offset,pagepos,pageaddr);
                                }
                        else if (pagepos->privbcb_list->next==NULL) {  /* exactly one item (no IPC shm yet) */
                                g_assert(pagepos->shmid==-1);
                                if (-1==(pagepos->shmid=shmget(IPC_PRIVATE,PAGE_SIZE,IPC_CREAT|IPC_CREAT|0600)))
                                        g_error("%s: Failed shmget(2), you may be out of maximum system IPC shared pages",G_STRLOC);
                                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: created shmid %d out of mmap() for offset %llu to existing pagepos %p to address %p",
                                                G_STRLOC,pagepos->shmid,(unsigned long long)offset,pagepos,pageaddr);
                                /* Reentrancy occured? */
                                g_assert(Flags&MAP_NO_READ || !pagepos->building);
                                }
                        else {  /* already >=2 mappings, already IPC shared mem */
                                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: already shared shmid of offset %llu by existing pagepos %p shmid %d to address %p",
                                                G_STRLOC,(unsigned long long)offset,pagepos,pagepos->shmid,pageaddr);
                                g_assert(pagepos->shmid!=-1);
                                g_assert(pagepos->privbcb_list!=NULL);
                                /* Reentrancy occured? */
                                g_assert(Flags&MAP_NO_READ || !pagepos->building);
                                }
                        pagepos_array[offset/PAGE_SIZE]=pagepos;
                        if (pagepos->privbcb_list) {    /* Not the first one - some shm in use now? */
                                /* It appears as shmat(2) cannot override previously mmap(2)ed memory;
                                 * mmap(2) is still needed to get linear block of memory assignment.
                                 */
                                /* TODO:thread; munmap()..shmat() window */
                                errint=munmap(pageaddr,PAGE_SIZE);
                                g_assert(errint==0);
                                errptr=shmat(pagepos->shmid,
                                                pageaddr,       /* shmaddr */
                                                0);     /* shmflg; !SHM_RDONLY==r/w */
                                g_assert(errptr==pageaddr);
                                }

                        g_assert(g_list_find(pagepos->privbcb_list,privbcb)==NULL);
                        pagepos->privbcb_list=g_list_prepend(pagepos->privbcb_list,privbcb);    /* order not important */
                        g_assert(g_list_find(pagepos->privbcb_list,privbcb)!=NULL);
                        if (pagepos->privbcb_list->next==NULL) {        /* exactly one item (we just added it now) */

                                g_assert(pagepos->shmid==-1);
                                g_hash_table_insert(page_position_hash,
                                                pagepos,        /* key */
                                                pagepos);       /* value */
                                }
                        else if (pagepos->privbcb_list->next->next==NULL) {     /* second mapping - new shm */
struct private_bcb *privbcb_orig;
gint64 privbcb_orig_offset_relative;
gpointer mapped_orig;

                                g_assert(pagepos->shmid!=-1);
                                errint=shmctl(pagepos->shmid,
                                                IPC_RMID,       /* cmd */
                                                NULL);  /* buf */
                                g_assert(errint==0);
                                g_assert(pagepos->privbcb_list->data==privbcb); /* our privbcb should be the first */
                                g_assert(pagepos->privbcb_list->next!=NULL);    /* we have exactly two items in the list */
                                g_assert(pagepos->privbcb_list->next->next==NULL);      /* we have exactly two items in the list */
                                privbcb_orig=pagepos->privbcb_list->next->data;
                                privbcb_orig_offset_relative=pagepos->FileOffset.QuadPart-privbcb_orig->MappedFileOffset.QuadPart;
                                /* privbcb_orig_offset_relative may be negative up to -PAGE_SIZE
                                 * as 'MappedFileOffset' and 'base' are not page-aligned.
                                 */
                                mapped_orig=privbcb_orig->base+privbcb_orig_offset_relative;
                                memcpy(pageaddr,mapped_orig,PAGE_SIZE);
                                /* TODO:thread; munmap()..shmat() window */
                                errint=munmap(mapped_orig,PAGE_SIZE);
                                g_assert(errint==0);
                                errptr=shmat(pagepos->shmid,
                                                mapped_orig,    /* shmaddr */
                                                0);     /* shmflg; !SHM_RDONLY==r/w */
                                g_assert(errptr==mapped_orig);
                                }
                        g_assert(validate_page_position(pagepos));
                        }
                }

        /* Fill in the missing pages content todo-list by stored 'pagepos_array' '->building' flags: */
        if (!(Flags&MAP_NO_READ)) {
size_t offset_start,offset_end;

                for (
                                offset_start=0;
                                offset_start<length_mapped_aligned;
                                offset_start=offset_end) {
struct page_position *pagepos_start;
size_t offset_built;
gpointer pageaddr;
ULONG got;

                        offset_end=offset_start+PAGE_SIZE;
                        pagepos_start=pagepos_array[offset_start/PAGE_SIZE];
                        if (!pagepos_start->building)
                                continue;
                        g_assert(offset_start==pagepos_start->FileOffset.QuadPart-FileOffset_bottom.QuadPart);
                        pageaddr=(gpointer)(((char *)base_aligned)+offset_start);
                        /* Coalescence of the requests. */
                        for (
                                        offset_end=offset_start+PAGE_SIZE;
                                        offset_end<length_mapped_aligned;
                                        offset_end+=PAGE_SIZE) {
struct page_position *pagepos_end;

                                pagepos_end=pagepos_array[offset_end/PAGE_SIZE];
                                g_assert(offset_end==pagepos_end->FileOffset.QuadPart-FileOffset_bottom.QuadPart);
                                if (!pagepos_end->building)
                                        break;
                                }
                        /* Read the range content: */
                        got=captive_Cc_IoPageRead(FileObject,pageaddr,offset_end-offset_start,&pagepos_start->FileOffset);
                        if (after_eof)
                                g_assert(got==0);
                        else
                                g_assert(got<=offset_end-offset_start);
                        after_eof=(got<offset_end-offset_start);
                        /* Unmark 'building' flags. */
                        for (
                                        offset_built=offset_start;
                                        offset_built<offset_end;
                                        offset_built+=PAGE_SIZE) {
struct page_position *pagepos_built;

                                pagepos_built=pagepos_array[offset_built/PAGE_SIZE];
                                g_assert(offset_built==pagepos_built->FileOffset.QuadPart-FileOffset_bottom.QuadPart);
                                g_assert(pagepos_built->building==TRUE);
                                pagepos_built->building=FALSE;
                                }
                        }
                }

        /* offset _into_ page, may not be PAGE_SIZE aligned: */
        *Buffer=privbcb->base;
        *PublicBcbp=PublicBcb;
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,
                        "%s: result: privbcb=%p,privbcb->base=%p,privbcb->base+privbcb->MappedLength=%p,privbcb->MappedLength=0x%lX",
                        G_STRLOC,privbcb,privbcb->base,((char *)privbcb->base)+privbcb->MappedLength,(unsigned long)privbcb->MappedLength);
        g_assert(validate_Bcb(PublicBcb)==TRUE);
        if (FileObject->Flags & FO_STREAM_FILE) {
                /* IoCreateStreamFileObjectLite() result is mapped many times. */
                g_assert(!FileObject->SectionObjectPointers->SharedCacheMap);
                }
        else {
                g_assert(!FileObject->SectionObjectPointers->SharedCacheMap);
                FileObject->SectionObjectPointers->SharedCacheMap=PublicBcb;
                }

        return TRUE;
}


/**
 * CcPinMappedData:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @MappedFileOffset: The @FileObject file offset from where to map the region from.
 * Negative value is forbidden.
 * @MappedLength: Requested length of the region to map from @FileObject.
 * FIXME: Value %0 is currently forbidden by libcaptive; it should be allowed.
 * @Wait: Whether disk waiting is permitted for this function.
 * Value currently ignored by libcaptive as the data must have been mapped by CcMapData() already anyway.
 * @Flags: %PIN_WAIT means whether disk waiting is permitted for this function.
 * Value without %PIN_WAIT is currently permtted by libcaptive as the data must have been mapped by CcMapData() already anyway.
 * %PIN_NO_READ is the same as %MAP_NO_READ - see CcMapData().
 * FIXME: %PIN_EXCLUSIVE for exclusive @Bcb access is now ignored by libcaptive.
 * %PIN_IF_BCB if @Bcb should never be created; function is successful only if @Bcb already exists.
 * @Bcb: Returns initialized #PUBLIC_BCB to refer to the mapped region.
 * The memory region can be larger than requested as it is %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 * @Buffer: Returns the mapped memory region start address.
 * This address may not be %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 *
 * This function will allow you to modify the data mapped by CcMapData().
 * libcaptive does not differentiate this function with CcMapData().
 *
 * This call does not set the buffer as dirty - such buffer will not be flushed automatically.
 *
 * NEVER re-read any memory from FileObject here!
 * at least fastfat.sys directory create relies on the fact of CcPinRead()
 * with already modified buffers to be left intact.
 *
 * This call will proceed as CcPinRead() if such #Bcb does not yet exist.
 * This is IMO just a bug workaround for a peruse by fastfat.sys FatLocateVolumeLabel().
 *
 * Every call to this function must be matched by a one corresponding CcUnpinData() call.
 *
 * Returns: %TRUE if the region was successfuly mapped.
 * @Bcb with the initialized new memory region.
 * @Buffer with the address of the exact byte specified by @FileOffset.
 */
BOOLEAN CcPinMappedData
                (IN PFILE_OBJECT FileObject,IN PLARGE_INTEGER FileOffset,IN ULONG Length,IN ULONG Flags,OUT PVOID *Bcb)
{
struct private_bcb *privbcb;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(FileOffset!=NULL,FALSE);
        g_return_val_if_fail(FileOffset->QuadPart>=0,FALSE);
        g_return_val_if_fail(Length>0,FALSE);   /* FIXME: not handled below; 0 should be allowed */
        /* 'Flags&PIN_WAIT' ignored as we already must have the data mapped */
        g_return_val_if_fail(!(Flags&~(PIN_WAIT|PIN_EXCLUSIVE|PIN_NO_READ|PIN_IF_BCB)),FALSE);  /* unknown flags? */
        g_return_val_if_fail(Bcb!=NULL,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,FileOffset=0x%llX,Length=0x%lX,Flags=0x%lX",G_STRLOC,
                        FileObject,(guint64)FileOffset->QuadPart,(gulong)Length,(gulong)Flags);

        privbcb=captive_privbcb_find(FileObject,FileOffset,Length,NULL);
        if (!privbcb && (Flags & PIN_IF_BCB))   /* BCB does not exist */
                return FALSE;
        /* Appropriate privbcb not found.
         * This IMO should not happen and it is a bug in the client.
         * Unfortuantely fastfat.sys FatLocateVolumeLabel() will CcPinMappedData()
         * the volume label dirent without any previous CcMapData() or CcPinRead() !
         */
        if (!privbcb) {
PVOID Buffer;

                return CcPinRead(
                                FileObject,
                                FileOffset,
                                Length,
                                0               /* Flags */
                                                | (Flags&PIN_NO_READ ? MAP_NO_READ : 0)
                                                | (Flags&PIN_WAIT    ? MAP_WAIT    : 0),
                                Bcb,
                                &Buffer);
                }

        /* NEVER re-read any memory from FileObject here! */

        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT,+1);

        /* Memory already mapped by CcMapData(). */
        *Bcb=privbcb->PublicBcb;
        return TRUE;
}


/**
 * CcPinRead:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @FileOffset: The @FileObject file offset from where to map the region from.
 * Negative value is forbidden.
 * @Length: Requested length of the region to map from @FileObject.
 * FIXME: Value %0 is currently forbidden by libcaptive; it should be allowed.
 * @Flags: %PIN_WAIT means whether disk waiting is permitted for this function.
 * Value without %PIN_WAIT is currently permtted by libcaptive as the data must have been mapped by CcMapData() already anyway.
 * %PIN_NO_READ is the same as %MAP_NO_READ - see CcMapData().
 * FIXME: %PIN_EXCLUSIVE for exclusive @Bcb access is now ignored by libcaptive.
 * %PIN_IF_BCB if @Bcb should never be created; function is successful only if @Bcb already exists.
 * @Bcb: Returns initialized #PUBLIC_BCB to refer to the mapped region.
 * The memory region can be larger than requested as it is %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 * @Buffer: Returns the mapped memory region start address.
 * This address may not be %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 *
 * Merely a shortcut call for CcMapData() and CcPinMappedData() afterwards.
 * See these two functions for the details. It has a difference to subsequent
 * calling of CcMapData() and CcPinMappedData() instead as this call counts
 * only as one function for a corresponding CcUnpinData() call.
 *
 * This call does not set the buffer as dirty - such buffer will not be flushed automatically.
 *
 * Every call to this function must be matched by a one corresponding CcUnpinData() call.
 *
 * Returns: %TRUE if the region was successfuly mapped.
 * @Bcb with the initialized new memory region.
 * @Buffer with the address of the exact byte specified by @FileOffset.
 */
BOOLEAN CcPinRead(IN PFILE_OBJECT FileObject,
                IN PLARGE_INTEGER FileOffset,IN ULONG Length,IN ULONG Flags,OUT PVOID *Bcb,OUT PVOID *Buffer)
{
PVOID Bcb_CcPinMappedData;
gboolean errbool;
gboolean count_CcMapData;
struct private_bcb *privbcb;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(FileOffset!=NULL,FALSE);
        g_return_val_if_fail(FileOffset->QuadPart>=0,FALSE);
        g_return_val_if_fail(Length>0,FALSE);   /* FIXME: not handled below; 0 should be allowed */
        /* 'Flags&PIN_WAIT' ignored as we already must have the data mapped */
        g_return_val_if_fail(!(Flags&~(PIN_WAIT|PIN_EXCLUSIVE|PIN_NO_READ|PIN_IF_BCB)),FALSE);  /* unknown flags? */
        g_return_val_if_fail(Bcb!=NULL,FALSE);
        g_return_val_if_fail(Buffer!=NULL,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,FileOffset=0x%llX,Length=0x%lX,Flags=0x%lX",G_STRLOC,
                        FileObject,(guint64)FileOffset->QuadPart,(gulong)Length,(gulong)Flags);

        if (!(Flags&PIN_IF_BCB)) {
                errbool=CcMapData(FileObject,FileOffset,Length,
                                0               /* Flags */
                                                | (Flags&PIN_NO_READ ? MAP_NO_READ : 0)
                                                | (Flags&PIN_WAIT    ? MAP_WAIT    : 0),
                                Bcb,Buffer);
                g_return_val_if_fail(errbool==TRUE,FALSE);
                count_CcMapData=TRUE;
                }
        else
                count_CcMapData=FALSE;

        errbool=CcPinMappedData(FileObject,FileOffset,Length,Flags,&Bcb_CcPinMappedData);
        if (!(Flags&PIN_IF_BCB)) {
                g_return_val_if_fail(errbool==TRUE,FALSE);
                g_return_val_if_fail(Bcb_CcPinMappedData==*Bcb,FALSE);
                }
        else {
                if (errbool==FALSE)     /* FALSE permitted; We may fail if Bcb does not exist yet. */
                        return FALSE;
                *Bcb=Bcb_CcPinMappedData;
                }

        privbcb=captive_privbcb_find(FileObject,FileOffset,Length,*Bcb);
        g_assert(privbcb!=NULL);
        g_assert(privbcb->ref_count>=1);
        g_assert(privbcb->PublicBcb==*Bcb);
        if (count_CcMapData) {
                /* CcPinRead() must always reference-count only by 1 despite any sub-called functions! */
                g_assert(privbcb->ref_count>=2);
                privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT,-1);
                }

        return TRUE;
}


static void logging_notify_privbcb_flush(struct private_bcb *privbcb);

/* Returns: The block was dirty and it was flushed to disk.
 */
static gboolean captive_privbcb_flush_unordered(struct private_bcb *privbcb)
{
MDL *Mdl;
KEVENT Event;
IO_STATUS_BLOCK IoStatus;
NTSTATUS err;
gpointer base_sectoraligned;
gsize length_sectoraligned;
LARGE_INTEGER FileOffset_sectoraligned;
gsize sectorsize;
struct fileobject_cached *fileobject_cached;
IRP *saved_TopLevelIrp;
static gint64 last_written_lsn=G_MININT64;

        g_assert(privbcb->ref_count>0);

        if (!privbcb->dirty)
                return FALSE;

        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,+1);
        logging_notify_privbcb_flush(privbcb);
        g_assert(privbcb->ref_count>=2);
        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,-1);

        if (privbcb->lsn_valid) {
                if (!(last_written_lsn<=privbcb->lsn.QuadPart))
                        g_error("%s: last_written_lsn=%" G_GINT64_FORMAT " !<= privbcb->lsn=%" G_GINT64_FORMAT,G_STRLOC,
                                        last_written_lsn,(gint64)privbcb->lsn.QuadPart);
                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: LSN write: last_written_lsn was %" G_GINT64_FORMAT ", is %" G_GINT64_FORMAT,
                                G_STRLOC,last_written_lsn,(gint64)privbcb->lsn.QuadPart);
                last_written_lsn=privbcb->lsn.QuadPart;
                }

        /* Prepare NULL TopLevelIrp for fileobject_cached->CallBacks.{AcquireForLazyWrite,ReleaseFromLazyWrite}
         */
        saved_TopLevelIrp=IoGetTopLevelIrp();
        IoSetTopLevelIrp(NULL);

        fileobject_cached_hash_init();
        if ((fileobject_cached=g_hash_table_lookup(fileobject_cached_hash,privbcb->FileObject)))
                (*fileobject_cached->CallBacks.AcquireForLazyWrite)(
                                fileobject_cached->LazyWriterContext,   /* Context */
                                TRUE);  /* Wait */

        g_assert(privbcb->FileObject->DeviceObject!=NULL);

        /* We can get 0=='privbcb->FileObject->DeviceObject->SectorSize' during mount of ext2fsd.sys.
         * FIXME: We are unable to find the correct sectorsize for a filesystem as
         * even the 'CommonFcb' below contains invalid information.
         * As we need to have 'sectorsize' <=filesystem_blocksize at least for ext2fsd.sys
         * we choose PAGE_SIZE - the maximum libcaptive can with its design and also the maximum
         * size ever needed for ext2fsd.sys (PAGE_SIZE is the maximum ext2 block size).
         */
        sectorsize=PAGE_SIZE;
#if 0
        sectorsize=privbcb->FileObject->DeviceObject->SectorSize;
        if (privbcb->FileObject->FsContext) {
REACTOS_COMMON_FCB_HEADER *CommonFcb=(REACTOS_COMMON_FCB_HEADER *)privbcb->FileObject->FsContext;

                /* FIXME: Check CommonFcb->Type */
                /* 'AllocationSize' can be less than 'sectorsize' if the total file length is smaller.
                 * Observed with ext2fsd.sys volume-file.
                 */
                if (sectorsize<CommonFcb->AllocationSize.QuadPart)
                        sectorsize=CommonFcb->AllocationSize.QuadPart;
                }
#endif

        /* Is PAGE_SIZE aligned with 'privbcb->FileObject->DeviceObject->SectorSize'? */
        g_assert(sectorsize>0);
        g_assert(0==CAPTIVE_ROUND_DOWN_EXCEEDING(PAGE_SIZE,sectorsize));
        /* We align here directly the 'privbcb->base' which is not correct.
         * We should rather aligned according to 'privbcb->MappedOffset' but
         * as 'privbcb->base' with PAGE_SIZE alignment is just a possibly
         * better alignment than 'privbcb->FileObject->DeviceObject->SectorSize' it must the same operation.
         */
        g_assert(CAPTIVE_ROUND_DOWN_EXCEEDING(privbcb->base,sectorsize)
                                 ==CAPTIVE_ROUND_DOWN_EXCEEDING64(privbcb->MappedFileOffset.QuadPart,sectorsize));
        base_sectoraligned  =CAPTIVE_ROUND_DOWN(privbcb->base,sectorsize);
        length_sectoraligned=CAPTIVE_ROUND_UP(((char *)privbcb->base)+privbcb->MappedLength,sectorsize)
                        -((char *)base_sectoraligned);
        g_assert(0==CAPTIVE_ROUND_DOWN_EXCEEDING(length_sectoraligned,sectorsize));
        FileOffset_sectoraligned.QuadPart=CAPTIVE_ROUND_DOWN64(privbcb->MappedFileOffset.QuadPart,sectorsize);

        Mdl=MmCreateMdl(NULL,base_sectoraligned,length_sectoraligned);
        g_assert(Mdl!=NULL);
        MmBuildMdlForNonPagedPool(Mdl);

        KeInitializeEvent(&Event,NotificationEvent,FALSE);

        /* Use rather IoSynchronousPageWrite() than IoPageWrite() to prevent STATUS_PENDING. */
        err=IoSynchronousPageWrite(privbcb->FileObject,Mdl,&FileOffset_sectoraligned,&Event,&IoStatus);
        g_assert(NT_SUCCESS(err));
        g_assert(NT_SUCCESS(IoStatus.Status));
        /* We should write at least the unaligned mapped data although we
         * do not need to successfuly write the whole aligned amount.
         * FIXME: Also we can get just value 0 if the write is considered 'not dirty'
         * during FAT write by fastfat.sys.
         * We can also get just value 8 during write of PAGE_SIZE aligned block
         * of privbcb->MappedLength 512 during flush of LSNed buffer on captive_leave(),
         * probably no assumptions can be made about the returned value at all.
         */
#if 0
        g_assert(IoStatus.Information==0 || IoStatus.Information>=CAPTIVE_ROUND_DOWN_EXCEEDING(privbcb->base,sectorsize)
                        +privbcb->MappedLength);
#endif
        g_assert(IoStatus.Information<=length_sectoraligned);

        if (fileobject_cached)
                (*fileobject_cached->CallBacks.ReleaseFromLazyWrite)(
                                fileobject_cached->LazyWriterContext);  /* Context */

        /* Restore TopLevelIrp for fileobject_cached->CallBacks.{AcquireForLazyWrite,ReleaseFromLazyWrite}
         */
        g_assert(NULL==IoGetTopLevelIrp());
        IoSetTopLevelIrp(saved_TopLevelIrp);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: 'dirty' flush: FileObject=%p,MappedFileOffset=0x%llX,MappedLength=0x%lX,base=%p"
                        "; base_sectoraligned=%p,FileOffset_sectoraligned=0x%llX,length_sectoraligned=0x%lX; ->Information=0x%lX",G_STRLOC,
                        privbcb->FileObject,(guint64)privbcb->MappedFileOffset.QuadPart,(gulong)privbcb->MappedLength,privbcb->base,
                        base_sectoraligned,(guint64)FileOffset_sectoraligned.QuadPart,(gulong)length_sectoraligned,
                        (gulong)IoStatus.Information);

        privbcb_set(privbcb,PRIVBCB_ITEM_DIRTY,FALSE);
        return TRUE;
}

struct captive_privbcb_flush_ordered_param {
        struct private_bcb *privbcb_req;
        struct private_bcb *found;      /* return */
        };

static gboolean captive_privbcb_flush_ordered_foreach_get_first(struct private_bcb *key,struct private_bcb *value,
                struct captive_privbcb_flush_ordered_param *captive_privbcb_flush_ordered_param /* data */)
{
        g_return_val_if_fail(key!=NULL,TRUE);   /* meaning: stop the traversal */
        g_return_val_if_fail(value!=NULL,TRUE); /* meaning: stop the traversal */
        g_return_val_if_fail(key==value,TRUE);  /* meaning: stop the traversal */
        g_return_val_if_fail(validate_Bcb(key->PublicBcb),TRUE);        /* meaning: stop the traversal */
        g_return_val_if_fail(captive_privbcb_flush_ordered_param!=NULL,TRUE);   /* meaning: stop the traversal */
        g_return_val_if_fail(captive_privbcb_flush_ordered_param->found==NULL,TRUE);    /* meaning: stop the traversal */

        g_assert(key->lsn_valid==TRUE);

        if (key==captive_privbcb_flush_ordered_param->privbcb_req) {
                captive_privbcb_flush_ordered_param->found=key;
                return TRUE;    /* stop the traversal */
                }

        if (!key->dirty)
                return FALSE;   /* continue the traversal */

        captive_privbcb_flush_ordered_param->found=key; /* first dirty LSNed buffer */
        return TRUE;    /* stop the traversal */
}

/* Use 'privbcb==NULL' to flush all LSNed entries of cache.
 * WARNING: Non-LSNed entries will NOT be flushed!
 * Returns: Anything was really flushed to disk.
 */
static gboolean captive_privbcb_flush_ordered(struct private_bcb *privbcb_req)
{
struct private_bcb *privbcb;
struct captive_privbcb_flush_ordered_param captive_privbcb_flush_ordered_param;
gboolean errbool;
gboolean r=FALSE;

        if ((privbcb=privbcb_req) && !privbcb->dirty)
                return FALSE;

        if ((privbcb=privbcb_req) && !privbcb->lsn_valid) {
                r=captive_privbcb_flush_unordered(privbcb);
                g_assert(r==TRUE);
                return r;
                }

        private_bcb_lsn_tree_init();

        for (;;) {
                captive_privbcb_flush_ordered_param.privbcb_req=privbcb_req;
                captive_privbcb_flush_ordered_param.found=NULL;
                g_tree_foreach(private_bcb_lsn_tree,
                                (GTraverseFunc)captive_privbcb_flush_ordered_foreach_get_first, /* func */
                                &captive_privbcb_flush_ordered_param);  /* user_data */
                if (captive_privbcb_flush_ordered_param.found==NULL) {
                        g_assert(privbcb_req==NULL);    /* Global LSN-ordered flush has no more entries. */
                        break;
                        }
                privbcb=captive_privbcb_flush_ordered_param.found;

                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,
                                "%s: privbcb->FileObject=%p,privbcb->MappedFileOffset=0x%llX,privbcb->MappedLength=0x%lX,privbcb->ref_count=%d"
                                ",privbcb->leave_func_pending=%d",G_STRLOC,
                                privbcb->FileObject,(guint64)privbcb->MappedFileOffset.QuadPart,(gulong)privbcb->MappedLength,(int)privbcb->ref_count,
                                (int)privbcb->leave_func_pending);

                if (privbcb->dirty) {
                        errbool=captive_privbcb_flush_unordered(privbcb);
                        g_assert(errbool==TRUE);
                        r=TRUE;
                        continue;       /* Restart as anything could change by calling W32 hassle. */
                        }

                if (privbcb!=privbcb_req)
                        continue;       /* We just flushed a LSNed buffer not yet requested to be destroyed. */

                g_assert(privbcb==g_tree_lookup(private_bcb_lsn_tree,privbcb));
                break;
                }

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: return %d",G_STRLOC,(int)r);
        return r;
}


static void CcUnpinData_leave_func_finalize(struct private_bcb *privbcb)
{
gboolean errbool;

        g_assert(privbcb->dirty==FALSE);
        g_assert(privbcb->lsn_valid==FALSE);
        g_assert(NULL==g_tree_lookup(private_bcb_lsn_tree,privbcb));
        g_assert(privbcb->leave_func_pending==TRUE);
        g_assert(privbcb->ref_count==1);
        privbcb_set(privbcb,PRIVBCB_ITEM_LEAVE_FUNC_PENDING,FALSE);
        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,-1);
        if (!privbcb->forbid_CcUnpinData_leave_func_finalize_remove) {
                errbool=g_hash_table_remove(private_bcb_hash,privbcb->PublicBcb);
                g_assert(errbool==TRUE);
                }
}


static void CcUnpinData_leave_func_privbcb_destroy_func(struct private_bcb *privbcb)    /* NULL to traverse the whole tree */
{
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb=%p,privbcb->ref_count=%d,privbcb->leave_func_pending=%d"
                        ",privbcb->lsn_valid=%d",G_STRLOC,
                        privbcb,(!privbcb ? -1 : privbcb->ref_count),(!privbcb ? -1 : privbcb->leave_func_pending),
                        (!privbcb ? -1 : privbcb->lsn_valid));

        g_assert(privbcb->leave_func_pending==TRUE);
        g_assert(privbcb->ref_count==1);
        captive_privbcb_flush_ordered(privbcb);
        privbcb_set(privbcb,PRIVBCB_ITEM_LSN_VALID,FALSE);
        CcUnpinData_leave_func_finalize(privbcb);
        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: return",G_STRLOC);
}


/* map: (PUBLIC_BCB *)PublicBcb -> (struct private_bcb *)privbcb */
static GHashTable *private_bcb_unpin_leave_hash;

static void private_bcb_unpin_leave_hash_init(void)
{
        if (private_bcb_unpin_leave_hash)
                return;
        private_bcb_unpin_leave_hash=g_hash_table_new_full(
                        g_direct_hash,  /* hash_func */
                        g_direct_equal, /* key_equal_func */
                        NULL,   /* key_destroy_func */
                        (GDestroyNotify)CcUnpinData_leave_func_privbcb_destroy_func);   /* value_destroy_func */
}


static void CcUnpinData_leave_unregister(struct private_bcb *privbcb)
{
gboolean errbool;

        g_return_if_fail(privbcb!=NULL);

        g_return_if_fail(private_bcb_unpin_leave_hash!=NULL);

        g_assert(privbcb->forbid_CcUnpinData_leave_func_finalize_remove==FALSE);
        privbcb->forbid_CcUnpinData_leave_func_finalize_remove=TRUE;
        g_assert(privbcb==g_hash_table_lookup(private_bcb_unpin_leave_hash,privbcb->PublicBcb));
        errbool=g_hash_table_remove(private_bcb_unpin_leave_hash,privbcb->PublicBcb);
        g_assert(errbool==TRUE);
        g_assert(NULL==g_hash_table_lookup(private_bcb_unpin_leave_hash,privbcb->PublicBcb));
}


static void CcUnpinData_leave_func(struct private_bcb *privbcb /* user_data; unused */)
{
GHashTable *private_bcb_unpin_leave_hash_local;

        if (!private_bcb_unpin_leave_hash)
                return;

        private_bcb_unpin_leave_hash_local=private_bcb_unpin_leave_hash;
        private_bcb_unpin_leave_hash=NULL;

        g_hash_table_destroy(private_bcb_unpin_leave_hash_local);       /* utilize value_destroy_func */
}


/**
 * CcUnpinData:
 * @Bcb: Initialized #PUBLIC_BCB structure.
 * %NULL value is forbidden.
 *
 * Dereferences @Bcb with the possible cleanup operations if you were the last owner.
 *
 * This call does not set the buffer as dirty although it will flush the buffers
 * already set as dirty. Any flushes will be postponed after return from #IRP
 * handling by the filesystem driver.
 */
VOID CcUnpinData(IN PVOID Bcb)
{
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_if_fail(validate_Bcb(Bcb));

        private_bcb_hash_init();

        PublicBcb=(PUBLIC_BCB *)Bcb;
        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_if_fail(privbcb!=NULL);
        g_assert(!privbcb->leave_func_pending);

        g_assert(privbcb->FileObject->SectionObjectPointers!=NULL);
        if (privbcb->FileObject->Flags & FO_STREAM_FILE) {
                /* IoCreateStreamFileObjectLite() result is mapped many times. */
                g_assert(!privbcb->FileObject->SectionObjectPointers->SharedCacheMap);
                }
        else
                g_assert(privbcb->FileObject->SectionObjectPointers->SharedCacheMap==PublicBcb);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,
                        "%s: privbcb->FileObject=%p,privbcb->MappedFileOffset=0x%llX,privbcb->MappedLength=0x%lX,privbcb->ref_count=%d"
                        ",privbcb->leave_func_pending=%d",G_STRLOC,
                        privbcb->FileObject,(guint64)privbcb->MappedFileOffset.QuadPart,(gulong)privbcb->MappedLength,(int)privbcb->ref_count,
                        (int)privbcb->leave_func_pending);

        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,-1);
        if (privbcb->ref_count>0)
                return;

        if (!(privbcb->FileObject->Flags & FO_STREAM_FILE))
                privbcb->FileObject->SectionObjectPointers->SharedCacheMap=NULL;

        /* Caboom: lfs (log file system) of ntfs.sys-NT5.1sp1 will do:
         * CcPinRead(); CcUnpinData(); access Buffer (wanna-crash);
         * Therefore we must postpone the buffer unmapping to some idle function...
         * I expect it a bug in ntfs.sys.
         */
        if (!privbcb->leave_func_pending) {
                privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT_DESTRUCTOR,+1);      /* '+1' gets decreased by 'leave_func_pending'. */
                privbcb_set(privbcb,PRIVBCB_ITEM_LEAVE_FUNC_PENDING,TRUE);
                if (!private_bcb_unpin_leave_hash) {
                        private_bcb_unpin_leave_hash_init();
                        g_assert(private_bcb_unpin_leave_hash!=NULL);
                        captive_leave_register(
                                        (captive_leave_func)CcUnpinData_leave_func,     /* func */
                                        NULL);  /* data; unused */
                        }
                g_hash_table_insert(private_bcb_unpin_leave_hash,PublicBcb,privbcb);
                }

        if (captive_cc_unmounting)
                captive_leave();
}


/**
 * CcRepinBcb:
 * @Bcb: #PUBLIB_BCB to be repinned.
 * %NULL value is forbidden.
 *
 * Increases usecount on @Bcb. You must call CcUnpinRepinnedBcb() for such @Bcb
 * afterwards before returning from the #IRP handling.
 *
 * libcaptive does not differentiate between CcUnpinData() and CcUnpinRepinnedBcb().
 * W32 differentiates.
 *
 * This call does not set the buffer as dirty - such buffer will not be flushed automatically.
 *
 */
VOID CcRepinBcb(IN PVOID Bcb)
{
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_if_fail(validate_Bcb(Bcb));

        private_bcb_hash_init();

        PublicBcb=(PUBLIC_BCB *)Bcb;
        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_if_fail(privbcb!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: Bcb=%p; privbcb->FileObject=%p",G_STRLOC,
                        Bcb,privbcb->FileObject);

        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT,+1);
}


/**
 * CcUnpinRepinnedBcb:
 * @Bcb: #PUBLIB_BCB to be unpinned from CcRepinBcb().
 * %NULL value is forbidden.
 * @WriteThrough: %TRUE if the buffer should be flushed before finishing this function.
 * @IoStatus: #PIO_STATUS_BLOCK to return status of this operation.
 * %NULL value is forbidden. libcaptive always returns %STATUS_SUCCESS here.
 *
 * Dereferencing of @Bcb after application of CcRepinBcb().
 *
 * This call does not set the buffer as dirty although it will flush the buffers
 * already set as dirty. Any flushes will be postponed after return from #IRP
 * handling by the filesystem driver if not requested to be synchronous by @WriteThrough.
 */
VOID CcUnpinRepinnedBcb(IN PVOID Bcb,IN BOOLEAN WriteThrough,IN PIO_STATUS_BLOCK IoStatus)
{
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_if_fail(validate_Bcb(Bcb));
        g_return_if_fail(IoStatus!=NULL);

        private_bcb_hash_init();

        PublicBcb=(PUBLIC_BCB *)Bcb;
        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_if_fail(privbcb!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: Bcb=%p,WriteThrough=%d,IoStatus=%p; privbcb->FileObject=%p",G_STRLOC,
                        Bcb,(gint)WriteThrough,IoStatus,privbcb->FileObject);

        if (WriteThrough)
                captive_privbcb_flush_ordered(privbcb);

        IoStatus->Status=STATUS_SUCCESS;
        IoStatus->Information=privbcb->MappedLength;

        CcUnpinData(Bcb);
}

/**
 * CcSetDirtyPinnedData:
 * @Bcb: #PUBLIB_BCB to be unpinned from CcRepinBcb().
 * %NULL value is forbidden.
 * @Lsn: Optional LSN (Linear Sequence Number) to assign to @Bcb.
 * %NULL pointer is permitted.
 *
 * This call will set the buffer as dirty - such buffer will be flushed automatically.
 *
 * You should call it only on CcPin*() buffers - not just CcMapData() buffers
 * although libcaptive does not differentiate it.
 */
VOID CcSetDirtyPinnedData(IN PVOID Bcb,IN PLARGE_INTEGER Lsn OPTIONAL)
{
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_if_fail(validate_Bcb(Bcb));

        private_bcb_hash_init();

        PublicBcb=(PUBLIC_BCB *)Bcb;
        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_if_fail(privbcb!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: Bcb=%p,Lsn=0x%llX; privbcb->FileObject=%p",G_STRLOC,
                        Bcb,(guint64)(!Lsn ? -1 : Lsn->QuadPart),privbcb->FileObject);

        /* 'privbcb->ref_count' not to be increased by this function. */

        if (Lsn) {
                /* Unset it first to not to get into unreachable privbcb in 'private_bcb_lsn_tree'. */
                privbcb_set(privbcb,PRIVBCB_ITEM_LSN_VALID,FALSE);
                privbcb->lsn=*Lsn;
                privbcb_set(privbcb,PRIVBCB_ITEM_LSN_VALID,TRUE);
                }
        else {
                /* FIXME: Unset 'lsn_valid' if !Lsn ? Undocumented by W32. */
                g_assert(privbcb->lsn_valid==FALSE);    /* NOT IMPLEMENTED YET */
                }

        privbcb_set(privbcb,PRIVBCB_ITEM_DIRTY,TRUE);
}


struct CcSetFileSizes_param {
        PFILE_OBJECT FileObject;
        PCC_FILE_SIZES FileSizes;
        };

/* map: (PUBLIC_BCB *)PublicBcb -> (struct private_bcb *)privbcb */
static void CcSetFileSizes_private_bcb_hash_foreach(
                PUBLIC_BCB *PublicBcb,  /* key */
                struct private_bcb *privbcb,    /* value */
                struct CcSetFileSizes_param *CcSetFileSizes_param)      /* user_data */
{
        g_return_if_fail(validate_Bcb(PublicBcb));
        g_return_if_fail(privbcb!=NULL);
        g_return_if_fail(CcSetFileSizes_param!=NULL);

        if (privbcb->FileObject!=CcSetFileSizes_param->FileObject)
                return;

        /* size changes behind our cached range? */
        if (1
                        && CcSetFileSizes_param->FileSizes->AllocationSize .QuadPart>=privbcb->MappedFileOffset.QuadPart+privbcb->MappedLength
                        && CcSetFileSizes_param->FileSizes->FileSize       .QuadPart>=privbcb->MappedFileOffset.QuadPart+privbcb->MappedLength
                        && CcSetFileSizes_param->FileSizes->ValidDataLength.QuadPart>=privbcb->MappedFileOffset.QuadPart+privbcb->MappedLength)
                return;

        /* FIXME: check BCB && 'struct page_position' invalidities */
        g_assert_not_reached(); /* NOT IMPLEMENTED YET */
}

/**
 * CcSetFileSizes:
 * @FileObject: Initialized open #FileObject to update file sizes of.
 * %NULL value is forbidden.
 * @FileSizes: New file sizes to update cache to.
 * %NULL value is forbidden.
 * 
 * Update cache properties after file sizes were updated.
 * Probably only the exceeding pages need to be unmapped and BCBs updated
 * if FileSizes->AllocationSize gets shrunk.
 *
 * FIXME: Currently a NOP with no effect by libcaptive.
 */
VOID CcSetFileSizes(IN PFILE_OBJECT FileObject,IN PCC_FILE_SIZES FileSizes)
{
struct CcSetFileSizes_param CcSetFileSizes_param;

        g_return_if_fail(FileObject!=NULL);
        g_return_if_fail(FileSizes!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,"
                        "FileSizes->AllocationSize=0x%llX,FileSizes->FileSize=0x%llX,FileSizes->ValidDataLength=0x%llX",G_STRLOC,
                        FileObject,(guint64)FileSizes->AllocationSize.QuadPart,(guint64)FileSizes->FileSize.QuadPart,
                        (guint64)FileSizes->ValidDataLength.QuadPart);

        CcSetFileSizes_param.FileObject=FileObject;
        CcSetFileSizes_param.FileSizes=FileSizes;
        g_hash_table_foreach(
                        private_bcb_hash,       /* hash_table */
                        (GHFunc)CcSetFileSizes_private_bcb_hash_foreach,        /* func */
                        &CcSetFileSizes_param); /* user_data */
}


/**
 * CcPurgeCacheSection:
 * @SectionObjectPointer: Pointer specifying file to purge;
 * %NULL value is forbidden.
 * libcaptive interprets only #SharedCacheMap field as #PUBLIC_BCB pointer.
 * Field #SharedCacheMap value %NULL is permitted; libcaptive does a NOP with %TRUE return code in such case.
 * @FileOffset: Starting offset of the ranger to purge.
 * %NULL pointer is permitted and it means to purge the whole whole.
 * FIXME: Non %NULL pointer is NOT IMPLEMENTED YET by libcaptive.
 * @Length: Length of the range to purge. Ignored if @FileOffset==NULL.
 * @UninitializeCacheMaps: Purge also private cache maps (FIXME: ???).
 *
 * Drop any caching for shrunken file which is not being deleted.
 * libcaptive will no longer consider such #BCB as dirty.
 *
 * Undocumented: It is required during %FSCTL_LOCK_VOLUME by ntfs.sys of NT-5.1sp1
 * to return %TRUE value if #SharedCacheMap value is %NULL.
 *
 * Returns: %TRUE if the range was purged successfuly.
 */
BOOLEAN CcPurgeCacheSection(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
                IN PLARGE_INTEGER FileOffset OPTIONAL,IN ULONG Length,IN BOOLEAN UninitializeCacheMaps)
{
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_val_if_fail(SectionObjectPointer!=NULL,FALSE);
        if (SectionObjectPointer->SharedCacheMap==NULL)
                return TRUE;    /* nothing to purge; never return FALSE for ntfs.sys of NT-5.1sp1! */
        g_return_val_if_fail(FileOffset==NULL,FALSE);   /* NOT IMPLEMENTED YET */

        PublicBcb=SectionObjectPointer->SharedCacheMap;
        g_return_val_if_fail(validate_Bcb(PublicBcb),FALSE);

        private_bcb_hash_init();

        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_val_if_fail(privbcb!=NULL,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: SectionObjectPointer=%p(Bcb=%p,privbcb=%p,privbcb->FileObject=%p),"
                        "FileOffset=0x%llX,Length=0x%lX,UninitializeCacheMaps=%d",G_STRLOC,
                        SectionObjectPointer,PublicBcb,privbcb,privbcb->FileObject,
                        (guint64)(!FileOffset ? -1 : FileOffset->QuadPart),(gulong)Length,(gint)UninitializeCacheMaps);

        g_assert_not_reached();

        privbcb_set(privbcb,PRIVBCB_ITEM_DIRTY,FALSE);  /* purge it */

        return TRUE;
}


/**
 * CcCopyRead:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @FileOffset: The @FileObject file offset from where to map the region from.
 * Negative value is forbidden.
 * @Length: Requested length of the region to map from @FileObject.
 * Value %0 is permitted (no effect of this function call).
 * @Wait: Whether disk waiting is permitted for this function.
 * Value %FALSE is currently forbidden by libcaptive as we have no on-demand loading implemented.
 * @Buffer: Address of memory region with already allocated memory of size @Length.
 * This address may not be %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 * @IoStatus: #PIO_STATUS_BLOCK to return status of this operation.
 * %NULL pointer is forbidden.
 *
 * Reads the specified region of @FileObject to the given @Buffer.
 * No on-demand loading is in effect.
 *
 * Returns: %TRUE if the region was successfuly filled with @Length bytes.
 * @IoStatus.Status initialized by %STATUS_SUCCESS if successful.
 * @IoStatus.Information initialized by @Length if successful.
 */
BOOLEAN CcCopyRead(IN PFILE_OBJECT FileObject,
                IN PLARGE_INTEGER FileOffset,IN ULONG Length,IN BOOLEAN Wait,OUT PVOID Buffer,OUT PIO_STATUS_BLOCK IoStatus)
{
PVOID MappedBcb;
PVOID MappedBuffer;
gboolean errbool;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(FileOffset!=NULL,FALSE);
        g_return_val_if_fail(Wait==TRUE || Wait==FALSE,FALSE);  /* Prevent 'Wait' upgrade to 'Flags'. */
        g_return_val_if_fail(Buffer!=NULL,FALSE);
        g_return_val_if_fail(IoStatus!=NULL,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,FileOffset=0x%llX,Length=0x%lX,Wait=%d",G_STRLOC,
                        FileObject,(guint64)FileOffset->QuadPart,(gulong)Length,(gint)Wait);

        IoStatus->Status=STATUS_UNSUCCESSFUL;
        IoStatus->Information=0;

        if (Length) {
                errbool=CcPinRead(
                                FileObject,     /* FileObject */
                                FileOffset,     /* FileOffset */
                                Length, /* Length */
                                0               /* Flags; !PIN_NO_READ */
                                                | (Wait ? PIN_WAIT : 0),
                                &MappedBcb,     /* Bcb */
                                &MappedBuffer); /* Buffer */
                g_return_val_if_fail(errbool==TRUE,FALSE);

                memcpy(Buffer,MappedBuffer,Length);

                CcUnpinData(MappedBcb); /* no error code */
                }

        IoStatus->Status=STATUS_SUCCESS;
        IoStatus->Information=Length;

        return TRUE;
}


/**
 * CcCopyWrite:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @FileOffset: The @FileObject file offset from where to map the region from.
 * Negative value is forbidden.
 * @Length: Requested length of the region to map from @FileObject.
 * Value %0 is permitted (no effect of this function call).
 * @Wait: Whether disk waiting is permitted for this function.
 * Value %FALSE is currently forbidden by libcaptive as we have no on-demand loading implemented.
 * @Buffer: Address of memory region with already allocated memory of size @Length.
 * This address may not be %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 *
 * Writes the specified region of the given @Buffer to @FileObject.
 *
 * Returns: %TRUE if the region was successfuly written with @Length bytes.
 */
BOOLEAN CcCopyWrite(IN PFILE_OBJECT FileObject,
                IN PLARGE_INTEGER FileOffset,IN ULONG Length,IN BOOLEAN Wait,IN PVOID Buffer)
{
PVOID MappedBcb;
PVOID MappedBuffer;
gboolean errbool;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(FileOffset!=NULL,FALSE);
        g_return_val_if_fail(Wait==TRUE || Wait==FALSE,FALSE);  /* Prevent 'Wait' upgrade to 'Flags'. */
        g_return_val_if_fail(Buffer!=NULL,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,FileOffset=0x%llX,Length=0x%lX,Wait=%d",G_STRLOC,
                        FileObject,(guint64)FileOffset->QuadPart,(gulong)Length,(gint)Wait);

        if (Length) {
                errbool=CcPinRead(
                                FileObject,     /* FileObject */
                                FileOffset,     /* FileOffset */
                                Length, /* Length */
                                PIN_NO_READ             /* Flags */
                                                | (Wait ? PIN_WAIT : 0),
                                &MappedBcb,     /* Bcb */
                                &MappedBuffer); /* Buffer */
                g_return_val_if_fail(errbool==TRUE,FALSE);

                memcpy(MappedBuffer,Buffer,Length);

                CcSetDirtyPinnedData(
                                MappedBcb,      /* Bcb */
                                NULL);  /* Lsn */
                CcUnpinData(MappedBcb); /* no error code */
                }

        return TRUE;
}


/**
 * CcCanIWrite:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @BytesToWrite: Amount of data to be asked whether it will be accepted.
 * Value %0 is permitted.
 * @Wait: Whether disk waiting would be permitted during the forthcoming write call.
 * @Retrying: Use %TRUE iff calling this function for the second and further times for one request.
 *
 * Asks cache manager if it would currently accept write request to @FileObject
 * of @BytesToWrite bytes with @Wait condition.
 * libcaptive will always accept any writes. This function is a NOP.
 *
 * Returns: libcaptive always returns %TRUE.
 */
BOOLEAN CcCanIWrite(IN PFILE_OBJECT FileObject,IN ULONG BytesToWrite,IN BOOLEAN Wait,IN BOOLEAN Retrying)
{
        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(Wait==TRUE || Wait==FALSE,FALSE);  /* Prevent 'Wait' upgrade to 'Flags'. */
        g_return_val_if_fail(Retrying==TRUE || Retrying==FALSE,FALSE);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,BytesToWrite=0x%lX,Wait=%d,Retrying=%d",G_STRLOC,
                        FileObject,(gulong)BytesToWrite,(gint)Wait,(gint)Retrying);

        return TRUE;
}


/**
 * CcSetReadAheadGranularity:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @Granularity: Suggested size of the cache element.
 * Value must be larger or requal to %PAGE_SIZE and it must be even power of two.
 *
 * libcaptive does not implement any caching and therefore this function
 * is a NOP there.
 */
VOID CcSetReadAheadGranularity(IN PFILE_OBJECT FileObject,IN ULONG Granularity)
{
        g_return_if_fail(FileObject!=NULL);
        g_return_if_fail(Granularity>=PAGE_SIZE);
        g_return_if_fail((Granularity&(Granularity-1))==0);     /* Power of two */

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,Granularity=0x%lX",G_STRLOC,
                        FileObject,(gulong)Granularity);

        /* NOP; no caching by libcaptive */
}


/**
 * CcFlushCache:
 * @SectionObjectPointer: Pointer specifying file to flush;
 * %NULL value is forbidden.
 * libcaptive interprets only #SharedCacheMap field as #PUBLIC_BCB pointer.
 * Field #SharedCacheMap value %NULL is permitted; libcaptive does a NOP in such case.
 * @FileOffset: Optional starting point of the range to flush.
 * %NULL value is permitted.
 * @Length: Length of the range to flush. Ignored if @FileOffset is %NULL.
 * @IoStatus: Optionally returns the resulting operation status.
 * #Information field will contain the number of bytes flushed.
 * %NULL value is permitted.
 *
 * Flushes out any pending dirty data in cache manager BCB mapping.
 * FIXME: libcaptive currently always flushes the full file ignoring any @FileOffset or @Length.
 *
 * VERIFIED: Ranged flushes.
 * VERIFIED: Synchronous write.
 */
VOID CcFlushCache(IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
                IN PLARGE_INTEGER FileOffset OPTIONAL,IN ULONG Length,OUT PIO_STATUS_BLOCK IoStatus OPTIONAL)
{
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_if_fail(SectionObjectPointer!=NULL);

        if (SectionObjectPointer->SharedCacheMap==NULL) {
success:
                if (IoStatus) {
                        IoStatus->Status=STATUS_SUCCESS;
                        IoStatus->Information=0;
                        }
                return;
                }

        PublicBcb=SectionObjectPointer->SharedCacheMap;
        g_return_if_fail(validate_Bcb(PublicBcb));

        private_bcb_hash_init();

        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_if_fail(privbcb!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: SectionObjectPointer=%p(Bcb=%p,privbcb=%p,privbcb->FileObject=%p),"
                        "FileOffset=0x%llX,Length=0x%lX,IoStatus=%p",G_STRLOC,
                        SectionObjectPointer,PublicBcb,privbcb,privbcb->FileObject,
                        (guint64)(!FileOffset ? -1 : FileOffset->QuadPart),(gulong)Length,IoStatus);

        if (FileOffset) {
                if (FileOffset->QuadPart       >=privbcb->MappedFileOffset.QuadPart+privbcb->MappedLength)
                        goto success;
                if (FileOffset->QuadPart+Length<=privbcb->MappedFileOffset.QuadPart)
                        goto success;
                }

        /* We may find some 'privbcb' being already sheduled to be destroyed.
         * We need to reference it to not to loose it in the middle of our flush operation.
         */
        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT,+1);

        /* FIXME: Flush just FileOffset..FileOfset+Length part */
        captive_privbcb_flush_ordered(privbcb);

        privbcb_set(privbcb,PRIVBCB_ITEM_REF_COUNT,-1);

        if (IoStatus) {
                IoStatus->Status=STATUS_SUCCESS;
                IoStatus->Information=(FileOffset && Length ? MIN(privbcb->MappedLength,Length) : privbcb->MappedLength);
                }
}


BOOLEAN CcZeroData(IN PFILE_OBJECT FileObject,IN PLARGE_INTEGER StartOffset,IN PLARGE_INTEGER EndOffset,IN BOOLEAN Wait)
{
PVOID Bcb;
PVOID Buffer;
BOOLEAN errboolean;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(StartOffset!=NULL,FALSE);
        g_return_val_if_fail(EndOffset!=NULL,FALSE);
        g_return_val_if_fail(StartOffset->QuadPart<=EndOffset->QuadPart,FALSE);
        g_return_val_if_fail((EndOffset->QuadPart-StartOffset->QuadPart)
                    ==(ULONG)(EndOffset->QuadPart-StartOffset->QuadPart),FALSE);
        g_return_val_if_fail(Wait==TRUE || Wait==FALSE,FALSE);  /* Prevent 'Wait' upgrade to 'Flags'. */

        errboolean=CcPreparePinWrite(
                        FileObject,     /* FileObject */
                        StartOffset,    /* FileOffset */
                        EndOffset->QuadPart-StartOffset->QuadPart,      /* Length */
                        TRUE,   /* Zero */
                        PIN_WAIT|PIN_NO_READ,   /* Flags */
                        &Bcb,   /* Bcb */
                        &Buffer);       /* Buffer */
        g_assert(errboolean==TRUE);

        CcUnpinData(Bcb);

        return TRUE;
}


/* map (PVOID LogHandle) -> (GList (of FILE_OBJECT *) *FileObject_list) */
static GHashTable *log_handle_hash;

static void log_handle_hash_init(void)
{
        if (log_handle_hash)
                return;
        log_handle_hash=g_hash_table_new(
                        g_direct_hash,  /* hash_func */
                        g_direct_equal);        /* key_equal_func */
}

/* map (FILE_OBJECT *FileObject) -> (struct FileObject_logging *) */
struct FileObject_logging {
        PVOID LogHandle;
        PFLUSH_TO_LSN FlushToLsnRoutine;
        };

static GHashTable *FileObject_logging_hash;

static void FileObject_logging_hash_init(void)
{
        if (FileObject_logging_hash)
                return;
        FileObject_logging_hash=g_hash_table_new(
                        g_direct_hash,  /* hash_func */
                        g_direct_equal);        /* key_equal_func */
}

static void logging_notify_privbcb_flush(struct private_bcb *privbcb)
{
struct FileObject_logging *FileObject_logging;

        g_return_if_fail(privbcb!=NULL);

        if (!privbcb->lsn_valid)        /* nothing to report anyway */
                return;

        FileObject_logging_hash_init();
        
        if (!(FileObject_logging=g_hash_table_lookup(FileObject_logging_hash,privbcb->FileObject)))
                return;

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb=%p,privbcb->FileObject=%p,privbcb->lsn=0x%llX: call",G_STRLOC,
                        privbcb,privbcb->FileObject,(guint64)privbcb->lsn.QuadPart);

        (*FileObject_logging->FlushToLsnRoutine)(FileObject_logging->LogHandle,privbcb->lsn);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: privbcb=%p,privbcb->FileObject=%p,privbcb->lsn=0x%llX: finish",G_STRLOC,
                        privbcb,privbcb->FileObject,(guint64)privbcb->lsn.QuadPart);
}

/**
 * CcSetLogHandleForFile:
 *
 * VERIFIED: LogHandle may be NULL, FlushToLsnRoutine is never called with LogHandle==NULL.
 * VERIFIED: Only one !=NULL LogHandle and one FlushToLsnRoutine used in one session.
 */
VOID CcSetLogHandleForFile(IN PFILE_OBJECT FileObject,IN PVOID LogHandle,IN PFLUSH_TO_LSN FlushToLsnRoutine)
{
GList *LogHandle_list;
struct FileObject_logging *FileObject_logging;

        g_return_if_fail(FileObject!=NULL);
        /* 'LogHandle' may be NULL */
        g_return_if_fail(FlushToLsnRoutine!=NULL);

        log_handle_hash_init();
        FileObject_logging_hash_init();

        if (!(FileObject_logging=g_hash_table_lookup(
                        FileObject_logging_hash,FileObject))) {
                captive_new(FileObject_logging);
                g_hash_table_insert(FileObject_logging_hash,
                                FileObject,FileObject_logging);
                }
        else {
                LogHandle_list=g_hash_table_lookup(log_handle_hash,FileObject_logging->LogHandle);
                g_assert(NULL!=g_list_find(LogHandle_list,FileObject));
                LogHandle_list=g_list_remove(LogHandle_list,FileObject);
                g_assert(NULL==g_list_find(LogHandle_list,FileObject));
                g_hash_table_insert(log_handle_hash,FileObject_logging->LogHandle,LogHandle_list);
                }

        FileObject_logging->LogHandle=LogHandle;
        FileObject_logging->FlushToLsnRoutine=FlushToLsnRoutine;

        LogHandle_list=g_hash_table_lookup(log_handle_hash,LogHandle);
        LogHandle_list=g_list_prepend(LogHandle_list,FileObject);
        g_hash_table_insert(log_handle_hash,LogHandle,LogHandle_list);
}


struct CcGetDirtyPages_param {
        PDIRTY_PAGE_ROUTINE DirtyPageRoutine;   /* arg of CcGetDirtyPages() */
        IN PVOID Context1;      /* arg of CcGetDirtyPages() */
        IN PVOID Context2;      /* arg of CcGetDirtyPages() */
        FILE_OBJECT *FileObject;        /* search through 'page_position_hash' for 'FileObject' */
        LARGE_INTEGER OldestLsn; gboolean OldestLsn_found;      /* intermediate return value of CcGetDirtyPages() */
        GTree *FileObject_pages_Tree;
        struct CcGetDirtyPages_param_FileObject_pages_Tree_page *FileObject_pages_Tree_page_last;
        };

struct CcGetDirtyPages_param_FileObject_pages_Tree_page {
        gint64 file_offset;
        gint64 file_offset_end;
        LARGE_INTEGER OldestLsn,NewestLsn;
        };

static gint CcGetDirtyPages_FileObject_pages_Tree_key_compare_func
                (const struct CcGetDirtyPages_param_FileObject_pages_Tree_page *a,
                const struct CcGetDirtyPages_param_FileObject_pages_Tree_page *b,
                gpointer user_data /* unused */)
{
        g_return_val_if_fail(a!=NULL,0);
        g_return_val_if_fail(b!=NULL,0);

        return (a->file_offset>b->file_offset)-(a->file_offset<b->file_offset);
}

static void CcGetDirtyPages_FileObject_pages_Tree_key_destroy_func
                (struct CcGetDirtyPages_param_FileObject_pages_Tree_page *tree_page)
{
        g_return_if_fail(tree_page!=NULL);

        g_free(tree_page);
}

static void CcGetDirtyPages_page_position_hash_foreach(
                struct page_position *pagepos,  /* key */
                struct page_position *pagepos2, /* value */
                struct CcGetDirtyPages_param *CcGetDirtyPages_param)    /* user_data */
{
LARGE_INTEGER OldestLsn,NewestLsn;
gboolean lsn_found,dirty_found;
GList *privbcb_list;
struct CcGetDirtyPages_param_FileObject_pages_Tree_page *tree_page;

        g_return_if_fail(pagepos!=NULL);
        g_return_if_fail(pagepos==pagepos2);
        g_return_if_fail(CcGetDirtyPages_param!=NULL);
        g_return_if_fail(CcGetDirtyPages_param->FileObject_pages_Tree!=NULL);

        if (pagepos->FileObject!=CcGetDirtyPages_param->FileObject)
                return;

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: scan pagepos offset=0x%llX",G_STRLOC,
                        (unsigned long long)pagepos->FileOffset.QuadPart);

        dirty_found=FALSE;
        lsn_found=FALSE;
        for (
                        privbcb_list=pagepos->privbcb_list;
                        privbcb_list;
                        privbcb_list=privbcb_list->next) {
struct private_bcb *privbcb=privbcb_list->data;

                if (!privbcb->dirty)
                        continue;
                dirty_found=TRUE;

                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: scan page mapping privbcb=%p,MappedFileOffset=0x%llX,MappedLength=%lX"
                                                ",lsn=%" G_GINT64_FORMAT,G_STRLOC,
                                privbcb,(unsigned long long)privbcb->MappedFileOffset.QuadPart,(unsigned long)privbcb->MappedLength,
                                (gint64)(!privbcb->lsn_valid ? -1 : privbcb->lsn.QuadPart));

                if (privbcb->lsn_valid) {
                        if (!lsn_found) {
                                OldestLsn=NewestLsn=privbcb->lsn;
                                lsn_found=TRUE;
                                }
                        else {
                                OldestLsn.QuadPart=MIN(OldestLsn.QuadPart,privbcb->lsn.QuadPart);
                                NewestLsn.QuadPart=MAX(NewestLsn.QuadPart,privbcb->lsn.QuadPart);
                                }
                        }
                }
        if (!dirty_found) {
                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: no dirty pages found",G_STRLOC);
                return;
                }

        if (lsn_found) {
                if (!CcGetDirtyPages_param->OldestLsn_found) {
                        CcGetDirtyPages_param->OldestLsn=OldestLsn;
                        CcGetDirtyPages_param->OldestLsn_found=TRUE;
                        }
                else
                        CcGetDirtyPages_param->OldestLsn.QuadPart=MIN(CcGetDirtyPages_param->OldestLsn.QuadPart,OldestLsn.QuadPart);
                }
        else {
                OldestLsn.QuadPart=0;
                NewestLsn.QuadPart=0;
                }

        captive_new(tree_page);
        tree_page->file_offset=pagepos->FileOffset.QuadPart;
        tree_page->file_offset_end=tree_page->file_offset+PAGE_SIZE;
        tree_page->OldestLsn=OldestLsn;
        tree_page->NewestLsn=NewestLsn;
        g_tree_insert(CcGetDirtyPages_param->FileObject_pages_Tree,
                        tree_page,      /* key */
                        tree_page);     /* value */

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: new tree_page file_offset=0x%llX"
                                        ",OldestLsn=%" G_GINT64_FORMAT ",NewestLsn=%" G_GINT64_FORMAT,G_STRLOC,
                        (unsigned long long)tree_page->file_offset,
                                        (gint64)tree_page->OldestLsn.QuadPart,(gint64)tree_page->NewestLsn.QuadPart);
}

static gboolean CcGetDirtyPages_FileObject_pages_Tree_traverse_func
                (struct CcGetDirtyPages_param_FileObject_pages_Tree_page *tree_page /* key */,
                struct CcGetDirtyPages_param_FileObject_pages_Tree_page *value,
                struct CcGetDirtyPages_param *CcGetDirtyPages_param)    /* user_data */
{
struct CcGetDirtyPages_param_FileObject_pages_Tree_page *page_last;

        /* 'tree_page' may be NULL for the last invocation after complete traversal. */
        g_return_val_if_fail(tree_page==value,TRUE);    /* 'TRUE' meaning: stop the traversal. */
        g_return_val_if_fail(CcGetDirtyPages_param!=NULL,TRUE); /* 'TRUE' meaning: stop the traversal. */

        page_last=CcGetDirtyPages_param->FileObject_pages_Tree_page_last;

        /* Concatenate two pages? */
        if (page_last && tree_page
                        && page_last->file_offset_end   ==tree_page->file_offset
                        && page_last->OldestLsn.QuadPart==tree_page->OldestLsn.QuadPart
                        && page_last->NewestLsn.QuadPart==tree_page->NewestLsn.QuadPart) {
                page_last->file_offset_end=tree_page->file_offset_end;
                /* Forget about the current 'tree_page' as it has been appended. */
                return FALSE;   /* 'FALSE' meaning: continue the traversal. */
                }

        /* Flush 'page_last'. */
        if (page_last) {
LARGE_INTEGER FileOffset_local;
LARGE_INTEGER OldestLsn_check,NewestLsn_check;

                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: DirtyPageRoutine(): FileOffset=0x%llX,Length=0x%llX"
                                                ",OldestLsn=%" G_GINT64_FORMAT ",NewestLsn=%" G_GINT64_FORMAT,G_STRLOC,
                                (unsigned long long)page_last->file_offset,(unsigned long long)(page_last->file_offset_end-page_last->file_offset),
                                                (gint64)page_last->OldestLsn.QuadPart,(gint64)page_last->NewestLsn.QuadPart);

                OldestLsn_check=page_last->OldestLsn;
                NewestLsn_check=page_last->NewestLsn;

                FileOffset_local.QuadPart=page_last->file_offset;

                (*CcGetDirtyPages_param->DirtyPageRoutine)(
                                CcGetDirtyPages_param->FileObject,      /* FileObject */
                                &FileOffset_local,      /* FileOffset */
                                page_last->file_offset_end-page_last->file_offset,      /* Length */
                                &page_last->OldestLsn,  /* OldestLsn */
                                &page_last->NewestLsn,  /* NewestLsn */
                                CcGetDirtyPages_param->Context1,        /* Context1 */
                                CcGetDirtyPages_param->Context2);       /* Context2 */

                /* just unconfirmed sanity: */
                g_assert(FileOffset_local.QuadPart==page_last->file_offset);    /* check for possible corruption */
                g_assert(OldestLsn_check.QuadPart==page_last->OldestLsn.QuadPart);
                g_assert(NewestLsn_check.QuadPart==page_last->NewestLsn.QuadPart);

                CcGetDirtyPages_param->FileObject_pages_Tree_page_last=NULL;
                }

        /* May be NULL during the last flush: */
        CcGetDirtyPages_param->FileObject_pages_Tree_page_last=tree_page;

        return FALSE;   /* 'FALSE' meaning: continue the traversal. */
}

/**
 * CcGetDirtyPages:
 * @LogHandle: Arbitrary pointer to match with value passed to CcSetLogHandleForFile().
 * %NULL value is permitted (considered as regular matching value by libcaptive).
 * @DirtyPageRoutine: #PDIRTY_PAGE_ROUTINE type to call on each dirty page(s).
 * %NULL value is forbidden.
 * @Context1: User data to pass to @DirtyPageRoutine.
 * %NULL value is permitted.
 * @Context2: User data to pass to @DirtyPageRoutine.
 *
 * Searches through the list of dirty #PUBLIC_BCB s of files assigned to @LogHandle
 * by CcSetLogHandleForFile(). Any clean #PUBLIC_BCB s are ignored
 * by this function. Function will scan through all #PUBLIC_BCB mapping of each such page
 * and it will detect its oldest and newest LSN (Logical Sequence Number). Unset
 * LSN is considered as value 0. Value 0 is returned only if no other LSN is valid
 * for such case, otherwise such void value 0 is ignored (and oldest and newest LSN
 * returned are being equal in the case only single LSN was found).
 *
 * Found pages are coalesced as much as possible during calls of @DirtyPageRoutine.
 * Coalescable ranges must have the same detected both oldest and newest LSNs.
 *
 * Returns: Oldest LSN across all the #FileObject s found for the given @LogHandle.
 * Function returns value %0 if no appropriate LSN was found.
 * libcaptive must return #gint64 instead of the official #LARGE_INTEGER
 * as W32 expects it as value in EAX:EDX but GCC returns the structure address in EAX.
 *
 * VERIFIED: func called in runs for each FileObject, FileOffset sorted desc.
 */
gint64 /* instead of LARGE_INTEGER */ CcGetDirtyPages(IN PVOID LogHandle,
                IN PDIRTY_PAGE_ROUTINE DirtyPageRoutine,IN PVOID Context1,IN PVOID Context2)
{
GList *LogHandle_list;
struct CcGetDirtyPages_param CcGetDirtyPages_param;

        /* 'LogHandle' may be NULL */
        g_return_val_if_fail(DirtyPageRoutine!=NULL,0);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: LogHandle=%p,DirtyPageRoutine=%p,Context1=%p,Context2=%p",G_STRLOC,
                        LogHandle,DirtyPageRoutine,Context1,Context2);

        log_handle_hash_init();
        page_position_hash_init();

        CcGetDirtyPages_param.DirtyPageRoutine=DirtyPageRoutine;
        CcGetDirtyPages_param.Context1=Context1;
        CcGetDirtyPages_param.Context2=Context2;
        CcGetDirtyPages_param.OldestLsn_found=FALSE;

        for (
                        LogHandle_list=g_hash_table_lookup(log_handle_hash,LogHandle);
                        LogHandle_list;
                        LogHandle_list=LogHandle_list->next) {
                CcGetDirtyPages_param.FileObject=LogHandle_list->data;
                g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: processing FileObject %p",G_STRLOC,CcGetDirtyPages_param.FileObject);

                CcGetDirtyPages_param.FileObject_pages_Tree=g_tree_new_full(
                                (GCompareDataFunc)CcGetDirtyPages_FileObject_pages_Tree_key_compare_func,       /* key_compare_func */
                                NULL,   /* key_compare_data */
                                (GDestroyNotify)CcGetDirtyPages_FileObject_pages_Tree_key_destroy_func, /* key_destroy_func */
                                NULL);  /* value_destroy_func */
                g_hash_table_foreach(
                                page_position_hash,     /* hash_table */
                                (GHFunc)CcGetDirtyPages_page_position_hash_foreach,     /* func */
                                &CcGetDirtyPages_param);        /* user_data */
                CcGetDirtyPages_param.FileObject_pages_Tree_page_last=NULL;
                g_tree_foreach(CcGetDirtyPages_param.FileObject_pages_Tree,     /* tree */
                                (GTraverseFunc)CcGetDirtyPages_FileObject_pages_Tree_traverse_func,     /* traverse_func */
                                &CcGetDirtyPages_param);        /* user_data */
                CcGetDirtyPages_FileObject_pages_Tree_traverse_func(
                                NULL,   /* tree_page */
                                NULL,   /* value */
                                &CcGetDirtyPages_param);        /* user_data */
                g_tree_destroy(CcGetDirtyPages_param.FileObject_pages_Tree);
                }

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: return %" G_GINT64_FORMAT,G_STRLOC,
                        (gint64)(!CcGetDirtyPages_param.OldestLsn_found ? 0 : CcGetDirtyPages_param.OldestLsn.QuadPart));

        if (!CcGetDirtyPages_param.OldestLsn_found)
                return 0;
        return CcGetDirtyPages_param.OldestLsn.QuadPart;
}


/**
 * CcSetAdditionalCacheAttributes:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @DisableReadAhead: Read-ahead should not be done by Cache Manager.
 * @DisableWriteBehind: Write-behind should not be done by Cache Manager.
 *
 * libcaptive does not implement any caching and therefore this function
 * is a NOP there.
 */
VOID CcSetAdditionalCacheAttributes(IN PFILE_OBJECT FileObject,IN BOOLEAN DisableReadAhead,IN BOOLEAN DisableWriteBehind)
{
        g_return_if_fail(FileObject!=NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,"%s: FileObject=%p,DisableReadAhead=%s,DisableWriteBehind=%s",G_STRLOC,
                        FileObject,(DisableReadAhead ? "TRUE" : "FALSE"),(DisableWriteBehind ? "TRUE" : "FALSE"));

        /* NOP; no caching by libcaptive */
}


/**
 * CcSetBcbOwnerPointer:
 * @Bcb: Initialized #PUBLIC_BCB structure.
 * %NULL value is forbidden.
 * @Owner: Thread-specific pointer (FIXME: Is it KeGetCurrentThread()?).
 * %NULL value is forbidden (FIXME: Is it W32 compliant?).
 *
 * Set thread-specific pointer for a pinned @Bcb. Use CcUnpinDataForThread()
 * when @Bcb is no longer needed. CcUnpinDataForThread() is NOT a reverse
 * operation for this single call CcSetBcbOwnerPointer(), see CcUnpinDataForThread().
 *
 * libcaptive implements this function as no-operation as it does not yet
 * support any threading.
 */
VOID CcSetBcbOwnerPointer(IN PVOID Bcb,IN PVOID Owner)
{
        g_return_if_fail(validate_Bcb(Bcb));
        g_return_if_fail(Owner!=NULL);

        /* FIXME:thread; NOP if no threads present */
}


/**
 * CcUnpinDataForThread:
 * @Bcb: Initialized #PUBLIC_BCB structure.
 * %NULL value is forbidden.
 * @ResourceThreadId: Thread-specific pointer (FIXME: Is it KeGetCurrentThread()?).
 * This pointer had to be passed to CcSetBcbOwnerPointer() #Owner parameter previously.
 * %NULL value is forbidden (FIXME: is it W32 compliant?).
 *
 * CcUnpinData() for a thread specified by @ResourceThreadId.
 * Reverse operation for a pair of CcMapData() and CcSetBcbOwnerPointer().
 *
 * libcaptive implements this function as a simple pass to CcUnpinData() as it does not yet
 * support any threading.
 */
VOID CcUnpinDataForThread(IN PVOID Bcb,IN ERESOURCE_THREAD ResourceThreadId)
{
        g_return_if_fail(validate_Bcb(Bcb));
        g_return_if_fail(ResourceThreadId!=0);

        /* FIXME:thread */

        CcUnpinData(Bcb);
}


/**
 * CcRemapBcb:
 * @Bcb: Initialized #PUBLIC_BCB structure.
 * %NULL value is forbidden.
 *
 * Create a copy of @Bcb for the exactly same file contents as is @Bcb.
 * The returned copy has the same attributes as the result of CcMapData()
 * notwithstanding the current state of input @Bcb, therefore it is only
 * for read/only access etc.
 *
 * libcaptive calls CcMapData() internally with @Bcb parameters.
 *
 * This function is called only by ntfs.sys of NT-5.1sp1 and it will perform
 * these operations with the resulting #PUBLIC_BCB:
 * CcRemapBcb(), CcSetDirtyPinnedData(), CcUnpinData()
 *
 * Untested: This call does not set the buffer as dirty - such buffer will not be flushed automatically.
 *
 * Returns: Copy of @Bcb. This _pointer_ never equals to @Bcb.
 * It should be some different
 * #PUBLIC_BCB structure according to W32 doc.
 */
PVOID CcRemapBcb(IN PVOID Bcb)
{
PVOID r;
PVOID Buffer_unused;
BOOLEAN errbool;
PUBLIC_BCB *PublicBcb;
struct private_bcb *privbcb;

        g_return_val_if_fail(validate_Bcb(Bcb),NULL);

        private_bcb_hash_init();

        PublicBcb=(PUBLIC_BCB *)Bcb;
        privbcb=g_hash_table_lookup(private_bcb_hash,PublicBcb);
        g_return_val_if_fail(privbcb!=NULL,NULL);

        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_DEBUG,
                        "%s: privbcb->FileObject=%p,privbcb->MappedFileOffset=0x%llX,privbcb->MappedLength=0x%lX,privbcb->ref_count=%d",G_STRLOC,
                        privbcb->FileObject,(guint64)privbcb->MappedFileOffset.QuadPart,(gulong)privbcb->MappedLength,(int)privbcb->ref_count);

        errbool=CcMapData(
                        privbcb->FileObject,    /* FileObject */
                        &privbcb->MappedFileOffset,     /* FileOffset */
                        privbcb->MappedLength,  /* Length */
                        MAP_WAIT,       /* Flags; FIXME: Is it OK to?: && !MAP_NO_READ */
                        &r,     /* Bcb */
                        &Buffer_unused); /* Buffer */
        g_return_val_if_fail(errbool==TRUE,NULL);
        g_return_val_if_fail(r!=NULL,NULL);
        g_return_val_if_fail(Buffer_unused!=NULL,NULL);

        g_assert(r!=Bcb);
        return r;
}


/**
 * CcPreparePinWrite:
 * @FileObject: Initialized open #FileObject to map.
 * %NULL value is forbidden.
 * @FileOffset: The @FileObject file offset from where to map the region from.
 * Negative value is forbidden.
 * @Length: Requested length of the region to map from @FileObject.
 * FIXME: Value %0 is currently forbidden by libcaptive; it should be allowed.
 * @Zero: %TRUE if the area of @FileOffset...@FileOffset+@Length should be cleared.
 * @Flags: %PIN_WAIT means whether disk waiting is permitted for this function.
 * Value without %PIN_WAIT is currently permtted by libcaptive as the data must have been mapped by CcMapData() already anyway.
 * %PIN_NO_READ is the same as %MAP_NO_READ - see CcMapData().
 * FIXME: %PIN_EXCLUSIVE for exclusive @Bcb access is now ignored by libcaptive.
 * %PIN_IF_BCB if @Bcb should never be created; function is successful only if @Bcb already exists.
 * @Bcb: Returns initialized #PUBLIC_BCB to refer to the mapped region.
 * The memory region can be larger than requested as it is %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 * @Buffer: Returns the mapped memory region start address.
 * This address may not be %PAGE_SIZE aligned.
 * %NULL pointer is forbidden.
 *
 * Wrapper for a pair of CcPinRead() and CcSetDirtyPinnedData().
 * The mapped range can be also optionally cleared if @Zero is specified.
 * See CcPinRead() for a more detailed documentation.
 *
 * This call will set the buffer as dirty - such buffer will be flushed automatically.
 *
 * Returns: %TRUE if the mapping was successful.
 */
BOOLEAN CcPreparePinWrite(IN PFILE_OBJECT FileObject,
                IN PLARGE_INTEGER FileOffset,IN ULONG Length,IN BOOLEAN Zero,IN ULONG Flags,OUT PVOID *Bcb,OUT PVOID *Buffer)
{
BOOLEAN errbool;

        g_return_val_if_fail(FileObject!=NULL,FALSE);
        g_return_val_if_fail(FileOffset!=NULL,FALSE);
        g_return_val_if_fail(FileOffset->QuadPart>=0,FALSE);
        g_return_val_if_fail(Length>0,FALSE);   /* FIXME: not handled below; 0 should be allowed */
        /* 'Flags' passed to CcPinRead() */
        g_return_val_if_fail(Bcb!=NULL,FALSE);
        g_return_val_if_fail(Buffer!=NULL,FALSE);

        errbool=CcPinRead(FileObject,FileOffset,Length,Flags|(Zero ? PIN_NO_READ : 0),Bcb,Buffer);
        g_return_val_if_fail(errbool==TRUE,FALSE);

        CcSetDirtyPinnedData(
                        *Bcb,   /* Bcb */
                        NULL);  /* Lsn; OPTIONAL */

        if (Zero) {
                memset(*Buffer,0,Length);
                }

        return TRUE;
}


VOID FsRtlIncrementCcFastReadNoWait(VOID)
{
        /* FIXME: {{%fs:[0]}+0x4E0}:LONG++ */
}


NTSTATUS CcWaitForCurrentLazyWriterActivity(VOID)
{
        return STATUS_SUCCESS;
}

static void CcIsThereDirtyData_private_bcb_hash_foreach(
                PUBLIC_BCB *PublicBcb,  /* key */
                struct private_bcb *privbcb,  /* value */
                gboolean *dirty_foundp) /* user_data */
{
        g_return_if_fail(validate_Bcb(PublicBcb));
        g_return_if_fail(privbcb!=NULL);
        g_return_if_fail(PublicBcb==privbcb->PublicBcb);

        if (!privbcb->dirty)
                return;

        *dirty_foundp=TRUE;     /* FIXME: stop the traversal. */
}

BOOLEAN CcIsThereDirtyData(IN PVPB Vpb)
{
gboolean dirty_found;

        g_return_val_if_fail(Vpb!=NULL,FALSE);  /* We have just one volume mounted anyway. */

        private_bcb_hash_init();

        dirty_found=FALSE;
        g_hash_table_foreach(
                        private_bcb_hash,       /* hash_table */
                        (GHFunc)CcIsThereDirtyData_private_bcb_hash_foreach,    /* func */
                        &dirty_found);  /* user_data */

        return dirty_found;
}