src/libcaptive/cc/sharedcachemap.c

   1 /* $Id$
   2  * reactos Cache Manager (Cc*) SharedCacheMap structure of libcaptive
   3  * Copyright (C) 2003 Jan Kratochvil <project-captive@jankratochvil.net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; exactly version 2 of June 1991 is required
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19
  20 #include "config.h"
  21
  22 #include "sharedcachemap.h"     /* self */
  23 #include "sharedcachemap-priv.h"        /* self */
  24 #include "io.h"
  25 #include "marshallers.h"
  26 #include <glib-object.h>
  27 #include "privatebcbpin.h"
  28 #include "captive/macros.h"
  29 #include <sys/mman.h>
  30 #include "reactos/ddk/obfuncs.h"
  31
  32
  33 static GHashTable *CaptiveSharedCacheMapObject_hash;
  34
  35 static void CaptiveSharedCacheMapObject_hash_init(void)
  36 {
  37         if (CaptiveSharedCacheMapObject_hash)
  38                 return;
  39         CaptiveSharedCacheMapObject_hash=g_hash_table_new(
  40                         g_direct_hash,  /* hash_func */
  41                         g_direct_equal);        /* key_equal_func */
  42 }
  43
  44
  45 static gpointer captive_shared_cache_map_object_parent_class=NULL;
  46
  47
  48 static void captive_shared_cache_map_object_finalize(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
  49 {
  50 static const CC_FILE_SIZES FileSizes_zero;
  51 gboolean errbool;
  52 guint64 offset;
  53 CaptiveSharedCacheMapObject_page *page;
  54
  55         g_return_if_fail(captive_shared_cache_map_object!=NULL);
  56
  57         for (offset=0;offset<CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE);offset+=PAGE_SIZE) {
  58                 page=captive_shared_cache_map_object->pages+offset/PAGE_SIZE;
  59                 if (!page->data_valid)
  60                         continue;
  61                 g_assert(!page->dirty); /* FIXME: Is it allowed by W32? */
  62                 }
  63
  64         CaptiveSharedCacheMapObject_hash_init();
  65         errbool=g_hash_table_remove(CaptiveSharedCacheMapObject_hash,captive_shared_cache_map_object);
  66         g_assert(errbool==TRUE);
  67
  68         captive_shared_cache_map_FileSizes_set(captive_shared_cache_map_object,&FileSizes_zero);
  69         g_assert(captive_shared_cache_map_object->buffer==NULL);
  70         g_assert(captive_shared_cache_map_object->pages==NULL);
  71
  72         if (captive_shared_cache_map_object->pin_hash) {
  73                 captive_private_bcb_pin_object_hash_destroy(captive_shared_cache_map_object->pin_hash);
  74                 captive_shared_cache_map_object->pin_hash=NULL;
  75                 }
  76         g_assert(captive_shared_cache_map_object->map==NULL);
  77         if (captive_shared_cache_map_object->SectionObjectPointer) {
  78                 g_assert(captive_shared_cache_map_object==captive_shared_cache_map_object->SectionObjectPointer->SharedCacheMap);
  79                 captive_shared_cache_map_object->SectionObjectPointer->SharedCacheMap=NULL;
  80                 }
  81
  82         if (captive_shared_cache_map_object->FileObject) {
  83                 /* W32 dereferences twice. */
  84                 ObDereferenceObject(captive_shared_cache_map_object->FileObject);
  85                 captive_shared_cache_map_object->FileObject=NULL;
  86                 }
  87
  88         G_OBJECT_CLASS(captive_shared_cache_map_object_parent_class)->finalize((GObject *)captive_shared_cache_map_object);
  89 }
  90
  91 static guint FileSizes_changed_signal;
  92 static guint purge_signal;
  93
  94 static void captive_shared_cache_map_object_FileSizes_changed(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
  95                 guint64 AllocationSize,guint64 FileSize,guint64 ValidDataLength);
  96 static void captive_shared_cache_map_object_purge(CaptiveSharedCacheMapObject *captive_shared_cache_map_object);
  97
  98 static void captive_shared_cache_map_object_class_init(CaptiveSharedCacheMapObjectClass *class)
  99 {
 100 GObjectClass *gobject_class=G_OBJECT_CLASS(class);
 101
 102         captive_shared_cache_map_object_parent_class=g_type_class_ref(g_type_parent(G_TYPE_FROM_CLASS(class)));
 103         gobject_class->finalize=(void (*)(GObject *object))captive_shared_cache_map_object_finalize;
 104
 105         class->FileSizes_changed=captive_shared_cache_map_object_FileSizes_changed;
 106         class->purge=captive_shared_cache_map_object_purge;
 107
 108         FileSizes_changed_signal=g_signal_new("FileSizes_changed",
 109                         G_TYPE_FROM_CLASS(gobject_class),
 110                         G_SIGNAL_RUN_LAST,
 111                         G_STRUCT_OFFSET(CaptiveSharedCacheMapObjectClass,FileSizes_changed),
 112                         NULL,NULL,
 113                         captive_cc_VOID__UINT64_UINT64_UINT64,
 114                         G_TYPE_NONE,3,G_TYPE_UINT64,G_TYPE_UINT64,G_TYPE_UINT64);
 115         purge_signal=g_signal_new("purge",
 116                         G_TYPE_FROM_CLASS(gobject_class),
 117                         G_SIGNAL_RUN_LAST,
 118                         G_STRUCT_OFFSET(CaptiveSharedCacheMapObjectClass,purge),
 119                         NULL,NULL,
 120                         captive_cc_VOID__VOID,
 121                         G_TYPE_NONE,0);
 122 }
 123
 124
 125 static void captive_shared_cache_map_object_init(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
 126 {
 127         captive_shared_cache_map_object->pin_hash=captive_private_bcb_pin_object_hash_new();
 128
 129         captive_shared_cache_map_w32_ref(captive_shared_cache_map_object);
 130         g_object_unref(captive_shared_cache_map_object);        /* ==sink */
 131
 132         CaptiveSharedCacheMapObject_hash_init();
 133         g_hash_table_insert(CaptiveSharedCacheMapObject_hash,
 134                         captive_shared_cache_map_object,captive_shared_cache_map_object);
 135 }
 136
 137
 138 GType captive_shared_cache_map_object_get_type(void)
 139 {
 140 static GType captive_shared_cache_map_object_type=0;
 141
 142         if (!captive_shared_cache_map_object_type) {
 143 static const GTypeInfo captive_shared_cache_map_object_info={
 144                                 sizeof(CaptiveSharedCacheMapObjectClass),
 145                                 NULL,   /* base_init */
 146                                 NULL,   /* base_finalize */
 147                                 (GClassInitFunc)captive_shared_cache_map_object_class_init,
 148                                 NULL,   /* class_finalize */
 149                                 NULL,   /* class_data */
 150                                 sizeof(CaptiveSharedCacheMapObject),
 151                                 5,      /* n_preallocs */
 152                                 (GInstanceInitFunc)captive_shared_cache_map_object_init,
 153                                 };
 154
 155                 captive_shared_cache_map_object_type=g_type_register_static(G_TYPE_OBJECT,
 156                                 "CaptiveSharedCacheMapObject",&captive_shared_cache_map_object_info,0);
 157                 }
 158
 159         return captive_shared_cache_map_object_type;
 160 }
 161
 162 static void captive_shared_cache_map_object_FileSizes_changed(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 163                 guint64 AllocationSize,guint64 FileSize,guint64 ValidDataLength)
 164 {
 165 size_t size_old,size_new;
 166 guint64 size64_old,size64_new;
 167
 168         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 169
 170         g_assert((!captive_shared_cache_map_object->buffer)==(!captive_shared_cache_map_object->AllocationSize));
 171         g_assert((!captive_shared_cache_map_object->pages)==(!captive_shared_cache_map_object->AllocationSize));
 172
 173         size64_old=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE);
 174         size_old=size64_old;
 175         g_assert(size_old==size64_old);
 176         size64_new=CAPTIVE_ROUND_UP64(AllocationSize,PAGE_SIZE);
 177         size_new=size64_new;
 178         if (size_new!=size64_new) {
 179 size_new_big:
 180                 g_error("Mapped size %" G_GUINT64_FORMAT " is too big; FIXME: non-mmap(2)-able areas not yet supported",size64_new);
 181                 g_assert_not_reached();
 182                 }
 183
 184         if (size_old!=size_new) {
 185 gpointer buffer_new;
 186
 187                 /* These two assertions should be already catched by pin/map signal handlers. */
 188                 g_assert(!captive_shared_cache_map_object->map);
 189                 g_assert(!g_hash_table_size(captive_shared_cache_map_object->pin_hash));
 190
 191                 if (AllocationSize) {
 192 gpointer base;
 193 int errint;
 194
 195                         base=mmap(
 196                                         NULL,   /* start */
 197                                         PAGE_SIZE+size_new+PAGE_SIZE,   /* length; leading and trailing boundary check pages */
 198                                         PROT_READ|PROT_WRITE,   /* prot; read/write must be possible although write is not guaranteed to be flushed yet */
 199                                         MAP_PRIVATE|MAP_ANONYMOUS       /* flags */
 200                                                         |MAP_NORESERVE, /* At least ext2fsd maps the whole disk. */
 201                                         -1,     /* fd; ignored due to MAP_ANONYMOUS */
 202                                         0);     /* offset; ignored due to MAP_ANONYMOUS */
 203                         if (base==MAP_FAILED)
 204                                 goto size_new_big;
 205                         g_assert(base!=NULL);
 206
 207                         base+=PAGE_SIZE;
 208                         errint=munmap(base-PAGE_SIZE,PAGE_SIZE);        /* unmap leading boundary check page */
 209                         g_assert(errint==0);
 210                         errint=munmap(base+size_new,PAGE_SIZE); /* unmap trailing boundary check page */
 211                         g_assert(errint==0);
 212
 213                         buffer_new=base;
 214                         }
 215                 else
 216                         buffer_new=NULL;
 217
 218                 memcpy(buffer_new,captive_shared_cache_map_object->buffer,
 219                                 MIN(AllocationSize,captive_shared_cache_map_object->AllocationSize));
 220
 221                 if (captive_shared_cache_map_object->AllocationSize) {
 222 int errint;
 223
 224                         errint=munmap(captive_shared_cache_map_object->buffer,size_old);
 225                         g_assert(errint==0);
 226                         }
 227
 228                 captive_shared_cache_map_object->buffer=buffer_new;
 229
 230 #if 0   /* It appears it is valid to squeeze out 'dirty' blocks. FIXME: Flush them? */
 231                 if (size_old>size_new) {
 232 guint64 now;
 233
 234                         for (now=size_new;now<size_old;now+=PAGE_SIZE) {
 235                                 if (!captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid)
 236                                         continue;
 237                                 g_assert(!captive_shared_cache_map_object->pages[now/PAGE_SIZE].dirty);
 238                                 }
 239                         }
 240 #endif
 241                 captive_shared_cache_map_object->pages=g_realloc(captive_shared_cache_map_object->pages,
 242                                 size_new/PAGE_SIZE*sizeof(*captive_shared_cache_map_object->pages));
 243                 if (size_new>size_old)  /* prevent 'size_new-size_old' as it is unsigned! */
 244                         memset(captive_shared_cache_map_object->pages+(size_old/PAGE_SIZE),0,
 245                                         (size_new-size_old)/PAGE_SIZE*sizeof(*captive_shared_cache_map_object->pages));
 246                 }
 247
 248         captive_shared_cache_map_object->AllocationSize=AllocationSize;
 249         captive_shared_cache_map_object->FileSize=FileSize;
 250         captive_shared_cache_map_object->ValidDataLength=ValidDataLength;
 251
 252         g_assert((!captive_shared_cache_map_object->buffer)==(!captive_shared_cache_map_object->AllocationSize));
 253         g_assert((!captive_shared_cache_map_object->pages)==(!captive_shared_cache_map_object->AllocationSize));
 254 }
 255
 256 static void captive_shared_cache_map_object_purge(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
 257 {
 258         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 259
 260         /* NOP; just to provide slot for checking by Bcbs */
 261 }
 262
 263 CaptiveSharedCacheMapObject *captive_shared_cache_map_get_ref(FILE_OBJECT *FileObject,
 264                 const CC_FILE_SIZES *FileSizes,BOOLEAN PinAccess,const CACHE_MANAGER_CALLBACKS *CallBacks,VOID *LazyWriterContext)
 265 {
 266 CaptiveSharedCacheMapObject *captive_shared_cache_map_object;
 267
 268         g_return_val_if_fail(FileObject!=NULL,NULL);
 269         g_return_val_if_fail(FileObject->SectionObjectPointer!=NULL,NULL);
 270         g_return_val_if_fail(FileSizes!=NULL,NULL);
 271         g_return_val_if_fail(CallBacks!=NULL,NULL);
 272
 273         if ((captive_shared_cache_map_object=FileObject->SectionObjectPointer->SharedCacheMap)) {
 274                 captive_shared_cache_map_w32_ref(captive_shared_cache_map_object);
 275                 }
 276         else {
 277                 captive_shared_cache_map_object=g_object_new(
 278                                 CAPTIVE_SHARED_CACHE_MAP_TYPE_OBJECT,   /* object_type */
 279                                 NULL);  /* first_property_name; FIXME: support properties */
 280
 281                 /* FIXME: When to drop SharedCacheMap?
 282                  * Currently we never close it.
 283                  * Fix also CcZeroData() workaround.
 284                  */
 285                 g_object_ref(captive_shared_cache_map_object);
 286
 287                 /* W32 references twice. */
 288                 ObReferenceObject(FileObject);
 289                 captive_shared_cache_map_object->FileObject=FileObject;
 290                 captive_shared_cache_map_object->SectionObjectPointer=FileObject->SectionObjectPointer;
 291                 captive_shared_cache_map_object->AllocationSize=0;
 292                 captive_shared_cache_map_object->FileSize=0;
 293                 captive_shared_cache_map_object->ValidDataLength=0;
 294                 captive_shared_cache_map_object->PinAccess=PinAccess;
 295                 captive_shared_cache_map_object->CallBacks=*CallBacks;
 296                 captive_shared_cache_map_object->LazyWriterContext=LazyWriterContext;
 297
 298                 FileObject->SectionObjectPointer->SharedCacheMap=captive_shared_cache_map_object;
 299                 }
 300
 301         g_assert(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 302         /* FileObject may differ - we can have a different reference to the same FCB. */
 303         g_assert(FileObject->SectionObjectPointer==captive_shared_cache_map_object->SectionObjectPointer);
 304         g_assert(PinAccess==captive_shared_cache_map_object->PinAccess);
 305         g_assert(CallBacks->AcquireForLazyWrite==captive_shared_cache_map_object->CallBacks.AcquireForLazyWrite);
 306         g_assert(CallBacks->ReleaseFromLazyWrite==captive_shared_cache_map_object->CallBacks.ReleaseFromLazyWrite);
 307         g_assert(CallBacks->AcquireForReadAhead==captive_shared_cache_map_object->CallBacks.AcquireForReadAhead);
 308         g_assert(CallBacks->ReleaseFromReadAhead==captive_shared_cache_map_object->CallBacks.ReleaseFromReadAhead);
 309         g_assert(LazyWriterContext==captive_shared_cache_map_object->LazyWriterContext);
 310
 311         captive_shared_cache_map_FileSizes_set(captive_shared_cache_map_object,FileSizes);
 312
 313         return captive_shared_cache_map_object;
 314 }
 315
 316 void captive_shared_cache_map_FileSizes_set(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 317                 const CC_FILE_SIZES *FileSizes)
 318 {
 319 guint64 AllocationSize,FileSize,ValidDataLength;
 320
 321         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 322         g_return_if_fail(FileSizes!=NULL);
 323
 324         AllocationSize=FileSizes->AllocationSize.QuadPart;
 325         FileSize=FileSizes->FileSize.QuadPart;
 326         ValidDataLength=FileSizes->ValidDataLength.QuadPart;
 327
 328         if (ValidDataLength==G_MAXINT64)
 329                 ValidDataLength=FileSize;
 330
 331         g_assert(AllocationSize>=0);
 332         g_assert(FileSize>=0);
 333         g_assert(ValidDataLength>=0);
 334
 335         g_assert(ValidDataLength<=FileSize);
 336         /* Do not: g_assert(0==(AllocationSize%0x200));
 337          * as it is true for ntfs.sys of NT-5.1sp1 but it fails for fastfat.sys of NT-5.1sp1.
 338          */
 339         /* AllocationSize can be much higher: */
 340         g_assert(FileSize<=AllocationSize);
 341
 342         /* Prevent signalling if not needed. */
 343         if (0
 344                         || captive_shared_cache_map_object->AllocationSize!=AllocationSize
 345                         || captive_shared_cache_map_object->FileSize!=FileSize
 346                         || captive_shared_cache_map_object->ValidDataLength!=ValidDataLength) {
 347                 /* Signalling is forbidden in captive_shared_cache_map_object_finalize(). */
 348                 if (G_OBJECT(captive_shared_cache_map_object)->ref_count==0) {
 349                         (*CAPTIVE_SHARED_CACHE_MAP_OBJECT_GET_CLASS(captive_shared_cache_map_object)->FileSizes_changed)
 350                                         (captive_shared_cache_map_object,AllocationSize,FileSize,ValidDataLength);
 351                         }
 352                 else {
 353                                 g_signal_emit(captive_shared_cache_map_object,FileSizes_changed_signal,0,
 354                                                 AllocationSize,FileSize,ValidDataLength);
 355                         }
 356                 }
 357
 358         g_assert(captive_shared_cache_map_object->AllocationSize==AllocationSize);
 359         g_assert(captive_shared_cache_map_object->FileSize==FileSize);
 360         g_assert(captive_shared_cache_map_object->ValidDataLength==ValidDataLength);
 361 }
 362
 363 CaptiveSharedCacheMapObject *captive_SectionObjectPointers_to_SharedCacheMap(SECTION_OBJECT_POINTERS *SectionObjectPointers)
 364 {
 365         g_return_val_if_fail(SectionObjectPointers!=NULL,NULL);
 366         g_return_val_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(SectionObjectPointers->SharedCacheMap),NULL);
 367
 368         return SectionObjectPointers->SharedCacheMap;
 369 }
 370
 371 CaptiveSharedCacheMapObject *captive_FileObject_to_SharedCacheMap(FILE_OBJECT *FileObject)
 372 {
 373         g_return_val_if_fail(FileObject!=NULL,NULL);
 374
 375         return captive_SectionObjectPointers_to_SharedCacheMap(FileObject->SectionObjectPointer);
 376 }
 377
 378 void captive_shared_cache_map_w32_ref(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
 379 {
 380         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 381
 382         g_object_ref(captive_shared_cache_map_object);
 383         captive_shared_cache_map_object->w32_ref_count++;
 384 }
 385
 386 void captive_shared_cache_map_w32_unref(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
 387 {
 388         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 389         g_return_if_fail(G_OBJECT(captive_shared_cache_map_object)->ref_count>0);
 390
 391         captive_shared_cache_map_object->w32_ref_count--;
 392         g_object_unref(captive_shared_cache_map_object);
 393 }
 394
 395 void captive_shared_cache_map_data_validate_read(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 396                 FILE_OBJECT *FileObject,guint64 start,guint64 end)
 397 {
 398 guint64 now;
 399 gboolean after_eof=FALSE;       /* Did we reached the end of file already? */
 400
 401         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 402         g_return_if_fail(captive_shared_cache_map_object==captive_FileObject_to_SharedCacheMap(FileObject));
 403         g_return_if_fail(start<=end);
 404         g_return_if_fail(end<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 405
 406         start=CAPTIVE_ROUND_DOWN64(start,PAGE_SIZE);
 407         end=CAPTIVE_ROUND_UP64(end,PAGE_SIZE);
 408
 409         for (now=start;now<end;now+=PAGE_SIZE) {
 410 LARGE_INTEGER now_LargeInteger;
 411 ULONG got;
 412
 413                 if (captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid)
 414                         continue;
 415                 now_LargeInteger.QuadPart=now;
 416                 got=captive_Cc_IoPageRead(FileObject,captive_shared_cache_map_object->buffer+now,PAGE_SIZE,&now_LargeInteger);
 417                 if (after_eof)
 418                         g_assert(got==0);
 419                 else
 420                         g_assert(got<=PAGE_SIZE);
 421                 after_eof=(got<PAGE_SIZE);
 422                 captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid=TRUE;
 423                 captive_shared_cache_map_object->pages[now/PAGE_SIZE].dirty=FALSE;
 424                 }
 425 }
 426
 427 void captive_shared_cache_map_data_validate_noread(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 428                 guint64 start,guint64 end)
 429 {
 430 guint64 now;
 431
 432         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 433         g_return_if_fail(start<=end);
 434         g_return_if_fail(end<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 435
 436         start=CAPTIVE_ROUND_DOWN64(start,PAGE_SIZE);
 437         end=CAPTIVE_ROUND_UP64(end,PAGE_SIZE);
 438
 439         for (now=start;now<end;now+=PAGE_SIZE) {
 440                 g_assert(captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid);
 441                 }
 442 }
 443
 444 void captive_shared_cache_map_set_data_valid(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 445                 guint64 start,guint64 end)
 446 {
 447 guint64 now;
 448
 449         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 450         g_return_if_fail(start<=end);
 451         g_return_if_fail(end<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 452
 453         start=CAPTIVE_ROUND_UP64(start,PAGE_SIZE);
 454         if (end<captive_shared_cache_map_object->FileSize)
 455                 end=CAPTIVE_ROUND_DOWN64(end,PAGE_SIZE);
 456         else {
 457                 /* We can validate the last page of the file
 458                  * even if it does not end on PAGE_SIZE boundary.
 459                  */
 460                 end=CAPTIVE_ROUND_UP64(end,PAGE_SIZE);
 461                 }
 462         /* We may get end<start here - it is valid to not to validate anything. */
 463
 464         for (now=start;now<end;now+=PAGE_SIZE) {
 465                 captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid=TRUE;
 466                 /* .dirty is undefined */
 467                 }
 468 }
 469
 470 void captive_shared_cache_map_set_data_invalid(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 471                 guint64 start,guint64 end)
 472 {
 473 guint64 now;
 474
 475         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 476         g_return_if_fail(start<=end);
 477         g_return_if_fail(end<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 478
 479         start=CAPTIVE_ROUND_DOWN64(start,PAGE_SIZE);
 480         end=CAPTIVE_ROUND_UP64(end,PAGE_SIZE);
 481
 482         for (now=start;now<end;now+=PAGE_SIZE) {
 483                 captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid=FALSE;
 484                 }
 485 }
 486
 487 void captive_shared_cache_map_set_dirty(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 488                 guint64 start,guint64 end)
 489 {
 490 guint64 now;
 491 CaptiveSharedCacheMapObject_page *page;
 492
 493         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 494         g_return_if_fail(end<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 495
 496         start=CAPTIVE_ROUND_DOWN64(start,PAGE_SIZE);
 497         end=CAPTIVE_ROUND_UP64(end,PAGE_SIZE);
 498
 499         for (now=start;now<end;now+=PAGE_SIZE) {
 500                 page=captive_shared_cache_map_object->pages+now/PAGE_SIZE;
 501                 g_assert(page->data_valid);
 502                 if (!page->dirty) {
 503                         page->dirty=TRUE;
 504                         page->lsn_oldest=0;
 505                         page->lsn_newest=0;
 506                         }
 507                 }
 508 }
 509
 510 gboolean captive_shared_cache_map_is_page_dirty(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 511                 guint64 offset)
 512 {
 513 CaptiveSharedCacheMapObject_page *page;
 514
 515         g_return_val_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object),FALSE);
 516         g_return_val_if_fail(offset<CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE),FALSE);
 517         g_return_val_if_fail(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(offset,PAGE_SIZE),FALSE);
 518         page=captive_shared_cache_map_object->pages+offset/PAGE_SIZE;
 519         g_return_val_if_fail(page->data_valid,FALSE);
 520
 521         return page->dirty;
 522 }
 523
 524 void captive_shared_cache_map_page_set_lsn(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 525                 guint64 offset,gint64 lsn)
 526 {
 527 CaptiveSharedCacheMapObject_page *page;
 528
 529         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 530         g_return_if_fail(offset<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 531         g_return_if_fail(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(offset,PAGE_SIZE));
 532         page=captive_shared_cache_map_object->pages+offset/PAGE_SIZE;
 533         g_return_if_fail(page->data_valid);
 534         g_return_if_fail(page->dirty);
 535         g_return_if_fail(page->lsn_oldest<=page->lsn_newest);
 536         g_return_if_fail(!page->lsn_newest || lsn>=page->lsn_newest);
 537         g_return_if_fail(captive_shared_cache_map_object->LogHandle_set);
 538         g_return_if_fail(captive_shared_cache_map_object->FlushToLsnRoutine_set);
 539
 540         if (!page->lsn_oldest)
 541                 page->lsn_oldest=lsn;
 542         page->lsn_newest=lsn;
 543 }
 544
 545 void captive_shared_cache_map_purge(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
 546 {
 547 guint64 offset;
 548 CaptiveSharedCacheMapObject_page *page;
 549
 550         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 551
 552         g_signal_emit(captive_shared_cache_map_object,purge_signal,0);
 553
 554         /* Needed by fastfat.sys of NT-5.1sp1 during FAT32 unmount
 555          * otherwise it fails on: g_assert(!page->dirty);
 556          * It corrupts the disk if the buffer is dropped instead.
 557          */
 558         captive_shared_cache_map_flush(captive_shared_cache_map_object,
 559                         0,CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 560
 561         for (offset=0;offset<CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE);offset+=PAGE_SIZE) {
 562                 page=captive_shared_cache_map_object->pages+offset/PAGE_SIZE;
 563                 if (!page->data_valid)
 564                         continue;
 565                 g_assert(!page->dirty);
 566                 page->data_valid=FALSE;
 567                 }
 568 }
 569
 570 static VOID *captive_LogHandle;
 571 static PFLUSH_TO_LSN captive_FlushToLsnRoutine;
 572
 573 void captive_shared_cache_map_set_LogHandle(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,VOID *LogHandle)
 574 {
 575         g_return_if_fail(!captive_shared_cache_map_object || CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 576         /* FIXME: 'captive_shared_cache_map_object->LogHandle_set' may be set.
 577          * Does it mean 'LogHandle_set' is 'FileObject'-based instead of 'SharedCacheMap'-based?
 578          */
 579
 580         if (!LogHandle)
 581                 return;
 582         g_assert(!captive_LogHandle || captive_LogHandle==LogHandle);
 583         captive_LogHandle=LogHandle;
 584         if (LogHandle && captive_shared_cache_map_object)
 585                 captive_shared_cache_map_object->LogHandle_set=TRUE;
 586 }
 587
 588 void captive_shared_cache_map_set_FlushToLsnRoutine
 589                 (CaptiveSharedCacheMapObject *captive_shared_cache_map_object,PFLUSH_TO_LSN FlushToLsnRoutine)
 590 {
 591         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 592         /* FIXME: 'captive_shared_cache_map_object->FlushToLsnRoutine_set' may be set.
 593          * Does it mean 'FlushToLsnRoutine_set' is 'FileObject'-based instead of 'SharedCacheMap'-based?
 594          */
 595
 596         if (!FlushToLsnRoutine)
 597                 return;
 598         g_assert(!captive_FlushToLsnRoutine || captive_FlushToLsnRoutine==FlushToLsnRoutine);
 599         captive_FlushToLsnRoutine=FlushToLsnRoutine;
 600         if (FlushToLsnRoutine)
 601                 captive_shared_cache_map_object->FlushToLsnRoutine_set=TRUE;
 602 }
 603
 604 static void captive_shared_cache_map_page_write(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 605                 guint64 offset)
 606 {
 607 LARGE_INTEGER offset_LargeInteger;
 608 static gint64 lsn_last;
 609 CaptiveSharedCacheMapObject_page *page;
 610
 611         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 612         g_return_if_fail(captive_shared_cache_map_object->FileObject!=NULL);
 613         g_return_if_fail(offset<=CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 614         g_return_if_fail(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(offset,PAGE_SIZE));
 615         page=captive_shared_cache_map_object->pages+offset/PAGE_SIZE;
 616         g_return_if_fail(page->data_valid);
 617         g_return_if_fail(page->dirty);
 618
 619         if (page->lsn_newest) {
 620                 /* sanity check */
 621                 g_assert(!lsn_last || lsn_last<=page->lsn_newest);
 622                 lsn_last=page->lsn_newest;
 623
 624                 captive_stdcall_call_12((CaptiveStdCallFunc12)captive_FlushToLsnRoutine,
 625                                 captive_LogHandle,
 626                                 (gpointer)(guint32)(page->lsn_newest>> 0U),     /* 'LARGE_INTEGER' argument */
 627                                 (gpointer)(guint32)(page->lsn_newest>>32U));
 628                 }
 629
 630         offset_LargeInteger.QuadPart=offset;
 631         captive_Cc_IoPageWrite(captive_shared_cache_map_object->FileObject,
 632                         captive_shared_cache_map_object->buffer+offset,PAGE_SIZE,&offset_LargeInteger);
 633
 634         page->dirty=FALSE;
 635         page->lsn_oldest=0;
 636         page->lsn_newest=0;
 637 }
 638
 639 typedef struct _captive_shared_cache_map_page_write_lsn_foreach_param captive_shared_cache_map_page_write_lsn_foreach_param;
 640 struct _captive_shared_cache_map_page_write_lsn_foreach_param {
 641         gint64 lsn_target;
 642         gint64 lsn_best;
 643         CaptiveSharedCacheMapObject *captive_shared_cache_map_object_best;
 644         guint64 offset_best;
 645         };
 646
 647 static void captive_shared_cache_map_page_write_lsn_foreach(
 648                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object,  /* key */
 649                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object_value,  /* value */
 650                 captive_shared_cache_map_page_write_lsn_foreach_param *param)   /* user_data */
 651 {
 652 guint64 now;
 653 CaptiveSharedCacheMapObject_page *page;
 654
 655         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 656         g_return_if_fail(captive_shared_cache_map_object==captive_shared_cache_map_object_value);
 657         g_return_if_fail(param!=NULL);
 658
 659         for (now=0;now<captive_shared_cache_map_object->AllocationSize;now+=PAGE_SIZE) {
 660                 page=captive_shared_cache_map_object->pages+now/PAGE_SIZE;
 661                 if (!page->data_valid)
 662                         continue;
 663                 if (!page->dirty)
 664                         continue;
 665                 if (!page->lsn_newest)
 666                         continue;
 667                 if (page->lsn_newest>=param->lsn_target)
 668                         continue;
 669                 if (param->lsn_best && page->lsn_newest>param->lsn_best)
 670                         continue;
 671                 param->lsn_best=page->lsn_newest;
 672                 param->captive_shared_cache_map_object_best=captive_shared_cache_map_object;
 673                 param->offset_best=now;
 674                 }
 675 }
 676
 677 static void captive_shared_cache_map_page_write_lsn(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 678                 guint64 offset)
 679 {
 680 CaptiveSharedCacheMapObject_page *page;
 681
 682         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 683         g_return_if_fail(captive_shared_cache_map_object->FileObject!=NULL);
 684         g_return_if_fail(offset<CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 685         g_return_if_fail(0==CAPTIVE_ROUND_DOWN_EXCEEDING64(offset,PAGE_SIZE));
 686         page=captive_shared_cache_map_object->pages+offset/PAGE_SIZE;
 687         g_return_if_fail(page->data_valid);
 688         g_return_if_fail(page->dirty);
 689
 690         if (page->lsn_newest) {
 691                 CaptiveSharedCacheMapObject_hash_init();
 692                 for (;;) {
 693 captive_shared_cache_map_page_write_lsn_foreach_param param;
 694
 695                         param.lsn_target=page->lsn_newest;
 696                         param.lsn_best=0;
 697                         g_hash_table_foreach(
 698                                         CaptiveSharedCacheMapObject_hash,       /* hash_table */
 699                                         (GHFunc)captive_shared_cache_map_page_write_lsn_foreach,        /* func */
 700                                         &param);        /* user_data */
 701                         if (!param.lsn_best)
 702                                 break;
 703                         captive_shared_cache_map_page_write(param.captive_shared_cache_map_object_best,param.offset_best);
 704                         }
 705                 }
 706
 707         captive_shared_cache_map_page_write(captive_shared_cache_map_object,offset);
 708 }
 709
 710 guint64 captive_shared_cache_map_flush(CaptiveSharedCacheMapObject *captive_shared_cache_map_object,
 711                 guint64 start,guint64 end)
 712 {
 713 guint64 flushed;
 714 guint64 now;
 715
 716         g_return_val_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object),0);
 717         g_return_val_if_fail(start<=end,0);
 718
 719         end=MIN(end,CAPTIVE_ROUND_UP64(captive_shared_cache_map_object->AllocationSize,PAGE_SIZE));
 720
 721         start=CAPTIVE_ROUND_DOWN64(start,PAGE_SIZE);
 722         end=CAPTIVE_ROUND_UP64(end,PAGE_SIZE);
 723
 724         flushed=0;
 725         for (now=start;now<end;now+=PAGE_SIZE) {
 726                 if (!captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid)
 727                         continue;
 728                 if (!captive_shared_cache_map_object->pages[now/PAGE_SIZE].dirty)
 729                         continue;
 730                 captive_shared_cache_map_page_write_lsn(captive_shared_cache_map_object,now);
 731                 flushed+=PAGE_SIZE;
 732                 }
 733
 734         /* We were calling W32 code - recheck our task completion. */
 735         for (now=start;now<end;now+=PAGE_SIZE) {
 736                 if (!captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid)
 737                         continue;
 738                 g_assert(!captive_shared_cache_map_object->pages[now/PAGE_SIZE].dirty);
 739                 }
 740
 741         return flushed;
 742 }
 743
 744 static void captive_shared_cache_map_is_any_dirty_foreach(
 745                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object,  /* key */
 746                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object_value,  /* value */
 747                 gboolean *dirty_foundp) /* user_data */
 748 {
 749 guint64 now;
 750
 751         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 752         g_return_if_fail(captive_shared_cache_map_object==captive_shared_cache_map_object_value);
 753         g_return_if_fail(dirty_foundp!=NULL);
 754
 755         for (now=0;now<captive_shared_cache_map_object->AllocationSize;now+=PAGE_SIZE) {
 756                 if (!captive_shared_cache_map_object->pages[now/PAGE_SIZE].data_valid)
 757                         continue;
 758                 if (!captive_shared_cache_map_object->pages[now/PAGE_SIZE].dirty)
 759                         continue;
 760                 *dirty_foundp=TRUE;     /* FIXME: stop the traversal. */
 761                 break;
 762                 }
 763 }
 764
 765
 766 gboolean captive_shared_cache_map_is_any_dirty(void)
 767 {
 768 gboolean dirty_found;
 769
 770         CaptiveSharedCacheMapObject_hash_init();
 771         dirty_found=FALSE;
 772         g_hash_table_foreach(
 773                         CaptiveSharedCacheMapObject_hash,       /* hash_table */
 774                         (GHFunc)captive_shared_cache_map_is_any_dirty_foreach,  /* func */
 775                         &dirty_found);  /* user_data */
 776
 777         return dirty_found;
 778 }
 779
 780
 781 typedef struct _captive_shared_cache_map_CcGetDirtyPages_foreach_param captive_shared_cache_map_CcGetDirtyPages_foreach_param;
 782 struct _captive_shared_cache_map_CcGetDirtyPages_foreach_param {
 783         PDIRTY_PAGE_ROUTINE DirtyPageRoutine;
 784         VOID *Context1;
 785         VOID *Context2;
 786         gint64 result;
 787         };
 788
 789 static void captive_shared_cache_map_CcGetDirtyPages_foreach(
 790                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object,  /* key */
 791                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object_value,  /* value */
 792                 captive_shared_cache_map_CcGetDirtyPages_foreach_param *param)  /* user_data */
 793 {
 794 gint64 now;
 795 CaptiveSharedCacheMapObject_page *page;
 796
 797         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 798         g_return_if_fail(captive_shared_cache_map_object->FileObject!=NULL);
 799         g_return_if_fail(captive_shared_cache_map_object==captive_shared_cache_map_object_value);
 800         g_return_if_fail(param!=NULL);
 801
 802         for (now=CAPTIVE_ROUND_DOWN64(captive_shared_cache_map_object->AllocationSize-1,PAGE_SIZE);now>=0;now-=PAGE_SIZE) {
 803 LARGE_INTEGER now_LargeInteger,lsn_oldest_LargeInteger,lsn_newest_LargeInteger;
 804
 805                 page=captive_shared_cache_map_object->pages+now/PAGE_SIZE;
 806                 if (!page->data_valid)
 807                         continue;
 808                 if (!page->dirty)
 809                         continue;
 810                 if (page->lsn_oldest && (!param->result || param->result>page->lsn_oldest))
 811                         param->result=page->lsn_oldest;
 812
 813                 now_LargeInteger.QuadPart=now;
 814                 lsn_oldest_LargeInteger.QuadPart=page->lsn_oldest;
 815                 lsn_newest_LargeInteger.QuadPart=page->lsn_newest;
 816                 (*param->DirtyPageRoutine)(
 817                                 captive_shared_cache_map_object->FileObject,    /* FileObject */
 818                                 &now_LargeInteger,      /* FileOffset */
 819                                 PAGE_SIZE,      /* Length */
 820                                 &lsn_oldest_LargeInteger,       /* OldestLsn */
 821                                 &lsn_newest_LargeInteger,       /* NewestLsn */
 822                                 param->Context1,        /* Context1 */
 823                                 param->Context2);       /* Context2 */
 824                 }
 825 }
 826
 827 gint64 captive_shared_cache_map_CcGetDirtyPages(PDIRTY_PAGE_ROUTINE DirtyPageRoutine,VOID *Context1,VOID *Context2)
 828 {
 829 captive_shared_cache_map_CcGetDirtyPages_foreach_param param;
 830
 831         g_return_val_if_fail(DirtyPageRoutine!=NULL,0);
 832
 833         param.DirtyPageRoutine=DirtyPageRoutine;
 834         param.Context1=Context1;
 835         param.Context2=Context2;
 836         param.result=0;
 837
 838         CaptiveSharedCacheMapObject_hash_init();
 839         g_hash_table_foreach(
 840                         CaptiveSharedCacheMapObject_hash,       /* hash_table */
 841                         (GHFunc)captive_shared_cache_map_CcGetDirtyPages_foreach,       /* func */
 842                         &param);        /* user_data */
 843
 844         return param.result;
 845 }
 846
 847 gpointer captive_shared_cache_map_get_buffer(CaptiveSharedCacheMapObject *captive_shared_cache_map_object)
 848 {
 849         g_return_val_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object),NULL);
 850         g_return_val_if_fail(captive_shared_cache_map_object->buffer!=NULL,NULL);
 851
 852         return captive_shared_cache_map_object->buffer;
 853 }
 854
 855 static void captive_cc_FileObject_delete_foreach(
 856                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object,  /* key */
 857                 CaptiveSharedCacheMapObject *captive_shared_cache_map_object_value,  /* value */
 858                 FILE_OBJECT *FileObject)        /* user_data */
 859 {
 860         g_return_if_fail(CAPTIVE_SHARED_CACHE_MAP_IS_OBJECT(captive_shared_cache_map_object));
 861         g_return_if_fail(captive_shared_cache_map_object==captive_shared_cache_map_object_value);
 862         g_return_if_fail(FileObject!=NULL);
 863
 864         g_assert(FileObject!=captive_shared_cache_map_object->FileObject);
 865 }
 866
 867 BOOLEAN captive_cc_FileObject_delete(FILE_OBJECT *FileObject)
 868 {
 869         g_return_val_if_fail(FileObject!=NULL,FALSE);
 870
 871         CaptiveSharedCacheMapObject_hash_init();
 872         g_hash_table_foreach(
 873                         CaptiveSharedCacheMapObject_hash,       /* hash_table */
 874                         (GHFunc)captive_cc_FileObject_delete_foreach,   /* func */
 875                         FileObject);    /* user_data */
 876
 877         return FALSE;   /* FIXME: remove useless return code. */
 878 }