ole/stg_bigblockfile.c

   1 /******************************************************************************
   2  *
   3  * BigBlockFile
   4  *
   5  * This is the implementation of a file that consists of blocks of
   6  * a predetermined size.
   7  * This class is used in the Compound File implementation of the
   8  * IStorage and IStream interfaces. It provides the functionality
   9  * to read and write any blocks in the file as well as setting and
  10  * obtaining the size of the file.
  11  * The blocks are indexed sequentially from the start of the file
  12  * starting with -1.
  13  *
  14  * TODO:
  15  * - Support for a transacted mode
  16  *
  17  * Copyright 1999 Thuy Nguyen
  18  *
  19  */
  20
  21 #include <assert.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "wine/obj_storage.h"
  29
  30 #include "storage32.h"
  31
  32 /***********************************************************
  33  * Data structures used internally by the BigBlockFile
  34  * class.
  35  */
  36
  37 /***
  38  * Itdentifies a single big block and the related
  39  * information
  40  */
  41 struct BigBlock
  42 {
  43   BigBlock * next;
  44   DWORD index;
  45   DWORD access_mode;
  46   LPVOID lpBlock;
  47 };
  48
  49 /***
  50  * This structure identifies the paged that are mapped
  51  * from the file and their position in memory. It is
  52  * also used to hold a reference count to those pages.
  53  */
  54 struct MappedPage
  55 {
  56   MappedPage * next;
  57   DWORD number;
  58   int ref;
  59   LPVOID lpBytes;
  60 };
  61
  62 #define PAGE_SIZE       131072
  63 #define BLOCKS_PER_PAGE 256
  64
  65 #define NUMBER_OF_MAPPED_PAGES 100
  66
  67 /***********************************************************
  68  * Prototypes for private methods
  69  */
  70 static void*     BIGBLOCKFILE_GetMappedView(LPBIGBLOCKFILE This,
  71                                             DWORD          pagenum,
  72                                             DWORD          desired_access);
  73 static void      BIGBLOCKFILE_ReleaseMappedPage(LPBIGBLOCKFILE This,
  74                                                 DWORD          pagenum,
  75                                                 DWORD          access);
  76 static void      BIGBLOCKFILE_FreeAllMappedPages(LPBIGBLOCKFILE This);
  77 static void*     BIGBLOCKFILE_GetBigBlockPointer(LPBIGBLOCKFILE This,
  78                                                  ULONG          index,
  79                                                  DWORD          desired_access);
  80 static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(LPBIGBLOCKFILE This,
  81                                                      void*          pBlock);
  82 static void      BIGBLOCKFILE_RemoveBlock(LPBIGBLOCKFILE This,
  83                                           ULONG          index);
  84 static BigBlock* BIGBLOCKFILE_AddBigBlock(LPBIGBLOCKFILE This,
  85                                           ULONG          index);
  86 static BigBlock* BIGBLOCKFILE_CreateBlock(ULONG index);
  87 static DWORD     BIGBLOCKFILE_GetProtectMode(DWORD openFlags);
  88
  89 /******************************************************************************
  90  *      BIGBLOCKFILE_Construct
  91  *
  92  * Construct a big block file. Create the file mapping object.
  93  * Create the read only mapped pages list, the writeable mapped page list
  94  * and the blocks in use list.
  95  */
  96 BigBlockFile * BIGBLOCKFILE_Construct(
  97   HANDLE hFile,
  98   DWORD    openFlags,
  99   ULONG    blocksize)
 100 {
 101   LPBIGBLOCKFILE This;
 102
 103   This = (LPBIGBLOCKFILE)HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlockFile));
 104
 105   if (This == NULL)
 106     return NULL;
 107
 108   This->hfile = hFile;
 109
 110   if (This->hfile == INVALID_HANDLE_VALUE)
 111   {
 112     HeapFree(GetProcessHeap(), 0, This);
 113     return NULL;
 114   }
 115
 116   This->flProtect = BIGBLOCKFILE_GetProtectMode(openFlags);
 117
 118   /* create the file mapping object
 119    */
 120   This->hfilemap = CreateFileMappingA(This->hfile,
 121                                         NULL,
 122                                         This->flProtect,
 123                                         0, 0,
 124                                         NULL);
 125
 126   if (This->hfilemap == NULL)
 127   {
 128     CloseHandle(This->hfile);
 129     HeapFree(GetProcessHeap(), 0, This);
 130     return NULL;
 131   }
 132
 133   /* initialize this
 134    */
 135   This->filesize.LowPart = GetFileSize(This->hfile, NULL);
 136   This->blocksize = blocksize;
 137
 138   /* create the mapped pages list
 139    */
 140   This->maplisthead = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 141
 142   if (This->maplisthead == NULL)
 143   {
 144     CloseHandle(This->hfilemap);
 145     CloseHandle(This->hfile);
 146     HeapFree(GetProcessHeap(), 0, This);
 147     return NULL;
 148   }
 149
 150   This->maplisthead->next = NULL;
 151
 152   /* initialize the block list
 153    */
 154   This->headblock = NULL;
 155
 156   return This;
 157 }
 158
 159 /******************************************************************************
 160  *      BIGBLOCKFILE_Destructor
 161  *
 162  * Destructor. Clean up, free memory.
 163  */
 164 void BIGBLOCKFILE_Destructor(
 165   LPBIGBLOCKFILE This)
 166 {
 167   /* unmap all views and destroy the mapped page list
 168    */
 169   BIGBLOCKFILE_FreeAllMappedPages(This);
 170   HeapFree(GetProcessHeap(), 0, This->maplisthead);
 171
 172   /* close all open handles
 173    */
 174   CloseHandle(This->hfilemap);
 175   CloseHandle(This->hfile);
 176
 177   /* destroy this
 178    */
 179   HeapFree(GetProcessHeap(), 0, This);
 180 }
 181
 182 /******************************************************************************
 183  *      BIGBLOCKFILE_GetROBigBlock
 184  *
 185  * Returns the specified block in read only mode.
 186  * Will return NULL if the block doesn't exists.
 187  */
 188 void* BIGBLOCKFILE_GetROBigBlock(
 189   LPBIGBLOCKFILE This,
 190   ULONG          index)
 191 {
 192   /*
 193    * block index starts at -1
 194    * translate to zero based index
 195    */
 196   if (index == 0xffffffff)
 197     index = 0;
 198   else
 199     index++;
 200
 201   /*
 202    * validate the block index
 203    *
 204    */
 205   if ((This->blocksize * (index + 1)) >
 206       (This->filesize.LowPart +
 207        (This->blocksize - (This->filesize.LowPart % This->blocksize))))
 208     return 0;
 209
 210   return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_READ);
 211 }
 212
 213 /******************************************************************************
 214  *      BIGBLOCKFILE_GetBigBlock
 215  *
 216  * Returns the specified block.
 217  * Will grow the file if necessary.
 218  */
 219 void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index)
 220 {
 221   /*
 222    * block index starts at -1
 223    * translate to zero based index
 224    */
 225   if (index == 0xffffffff)
 226     index = 0;
 227   else
 228     index++;
 229
 230   /*
 231    * make sure that the block physically exists
 232    */
 233   if ((This->blocksize * (index + 1)) > This->filesize.LowPart)
 234   {
 235     ULARGE_INTEGER newSize;
 236
 237     newSize.HighPart = 0;
 238     newSize.LowPart = This->blocksize * (index + 1);
 239
 240     BIGBLOCKFILE_SetSize(This, newSize);
 241   }
 242
 243   return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_WRITE);
 244 }
 245
 246 /******************************************************************************
 247  *      BIGBLOCKFILE_ReleaseBigBlock
 248  *
 249  * Releases the specified block.
 250  */
 251 void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock)
 252 {
 253   DWORD page_num;
 254   BigBlock* theBigBlock;
 255
 256   if (pBlock == NULL)
 257     return;
 258
 259   /*
 260    * get the block from the block list
 261    */
 262   theBigBlock = BIGBLOCKFILE_GetBigBlockFromPointer(This, pBlock);
 263
 264   if (theBigBlock == NULL)
 265     return;
 266
 267   /*
 268    * find out which page this block is in
 269    */
 270   page_num = theBigBlock->index / BLOCKS_PER_PAGE;
 271
 272   /*
 273    * release this page
 274    */
 275   BIGBLOCKFILE_ReleaseMappedPage(This, page_num, theBigBlock->access_mode);
 276
 277   /*
 278    * remove block from list
 279    */
 280   BIGBLOCKFILE_RemoveBlock(This, theBigBlock->index);
 281 }
 282
 283 /******************************************************************************
 284  *      BIGBLOCKFILE_SetSize
 285  *
 286  * Sets the size of the file.
 287  *
 288  */
 289 void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
 290 {
 291   if (This->filesize.LowPart == newSize.LowPart)
 292     return;
 293
 294   /*
 295    * unmap all views, must be done before call to SetEndFile
 296    */
 297   BIGBLOCKFILE_FreeAllMappedPages(This);
 298
 299   /*
 300    * close file-mapping object, must be done before call to SetEndFile
 301    */
 302   CloseHandle(This->hfilemap);
 303   This->hfilemap = NULL;
 304
 305   /*
 306    * set the new end of file
 307    */
 308   SetFilePointer(This->hfile, newSize.LowPart, NULL, FILE_BEGIN);
 309   SetEndOfFile(This->hfile);
 310
 311   /*
 312    * re-create the file mapping object
 313    */
 314   This->hfilemap = CreateFileMappingA(This->hfile,
 315                                         NULL,
 316                                         This->flProtect,
 317                                         0, 0,
 318                                         NULL);
 319
 320   This->filesize.LowPart = newSize.LowPart;
 321   This->filesize.HighPart = newSize.HighPart;
 322 }
 323
 324 /******************************************************************************
 325  *      BIGBLOCKFILE_GetSize
 326  *
 327  * Returns the size of the file.
 328  *
 329  */
 330 ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This)
 331 {
 332   return This->filesize;
 333 }
 334
 335 /******************************************************************************
 336  *      BIGBLOCKFILE_GetBigBlockPointer     [PRIVATE]
 337  *
 338  * Returns a pointer to the specified block.
 339  */
 340 static void* BIGBLOCKFILE_GetBigBlockPointer(
 341   LPBIGBLOCKFILE This,
 342   ULONG          index,
 343   DWORD          desired_access)
 344 {
 345   DWORD page_num, block_num;
 346   void * pBytes;
 347   BigBlock *aBigBlock;
 348
 349   /* get the big block from the list or add it to the list
 350    */
 351   aBigBlock = BIGBLOCKFILE_AddBigBlock(This, index);
 352
 353   if (aBigBlock == NULL)
 354     return NULL;
 355
 356   /* we already have an address for this block
 357    */
 358   if (aBigBlock->lpBlock != NULL)
 359   {
 360     /* make sure the desired access matches what we already have
 361      */
 362     if (aBigBlock->access_mode == desired_access)
 363       return aBigBlock->lpBlock;
 364     else
 365       return NULL;
 366   }
 367
 368   /*
 369    * else aBigBlock->lpBigBlock == NULL, it's a new block
 370    */
 371
 372   /* find out which page this block is in
 373    */
 374   page_num = index / BLOCKS_PER_PAGE;
 375
 376   /* offset of the block in the page
 377    */
 378   block_num = index % BLOCKS_PER_PAGE;
 379
 380   /* get a pointer to the first byte in the page
 381    */
 382   pBytes = BIGBLOCKFILE_GetMappedView(This, page_num, desired_access);
 383
 384   if (pBytes == NULL)
 385     return NULL;
 386
 387   /* initialize block
 388    */
 389   aBigBlock->lpBlock = ((BYTE*)pBytes + (block_num*This->blocksize));
 390   aBigBlock->access_mode = desired_access;
 391
 392   return aBigBlock->lpBlock;
 393 }
 394
 395 /******************************************************************************
 396  *      BIGBLOCKFILE_CreateBlock      [PRIVATE]
 397  *
 398  * Creates a node of the blocks list.
 399  */
 400 static BigBlock* BIGBLOCKFILE_CreateBlock(
 401   ULONG index)
 402 {
 403   BigBlock *newBigBlock;
 404
 405   /* create new list node
 406    */
 407   newBigBlock = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlock));
 408
 409   if (newBigBlock == NULL)
 410     return NULL;
 411
 412   /* initialize node
 413    */
 414   newBigBlock->index = index;
 415   newBigBlock->lpBlock = NULL;
 416
 417   return newBigBlock;
 418 }
 419
 420 /******************************************************************************
 421  *      BIGBLOCKFILE_AddBigBlock      [PRIVATE]
 422  *
 423  * Returns the specified block from the blocks list.
 424  * If the block is not found in the list, we will create it and add it to the
 425  * list.
 426  */
 427 static BigBlock* BIGBLOCKFILE_AddBigBlock(
 428   LPBIGBLOCKFILE This,
 429   ULONG          index)
 430 {
 431   BigBlock *current = This->headblock;
 432   BigBlock *newBigBlock;
 433
 434   if (current == NULL) /* empty list */
 435   {
 436     newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 437
 438     if (newBigBlock != NULL)
 439     {
 440       newBigBlock->next = NULL;
 441       This->headblock = newBigBlock;
 442     }
 443
 444     return newBigBlock;
 445   }
 446   else
 447   {
 448     /*
 449      * special handling for head of the list
 450      */
 451
 452     if (current->index == index) /* it's already here */
 453       return current;
 454     else if (current->index > index) /* insertion at head of the list */
 455     {
 456       newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 457
 458       if (newBigBlock != NULL)
 459       {
 460         newBigBlock->next = current;
 461         This->headblock = newBigBlock;
 462       }
 463
 464       return newBigBlock;
 465     }
 466   }
 467
 468   /* iterate through rest the list
 469    */
 470   while (current->next != NULL)
 471   {
 472     if (current->next->index == index) /* found it */
 473     {
 474       return current->next;
 475     }
 476     else if (current->next->index > index) /* it's not in the list */
 477     {
 478       newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 479
 480       if (newBigBlock != NULL)
 481       {
 482         newBigBlock->next = current->next;
 483         current->next = newBigBlock;
 484       }
 485
 486       return newBigBlock;
 487     }
 488     else
 489       current = current->next;
 490   }
 491
 492   /*
 493    * insertion at end of the list
 494    */
 495   if (current->next == NULL)
 496   {
 497     newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 498
 499     if (newBigBlock != NULL)
 500     {
 501       newBigBlock->next = NULL;
 502       current->next = newBigBlock;
 503     }
 504
 505     return newBigBlock;
 506   }
 507
 508   return NULL;
 509 }
 510
 511 /******************************************************************************
 512  *      BIGBLOCKFILE_RemoveBlock      [PRIVATE]
 513  *
 514  * Removes the specified block from the blocks list.
 515  */
 516 static void BIGBLOCKFILE_RemoveBlock(
 517   LPBIGBLOCKFILE This,
 518   ULONG          index)
 519 {
 520   BigBlock *current = This->headblock;
 521
 522   /*
 523    * empty list
 524    */
 525   if (current == NULL)
 526     return;
 527
 528   /*
 529    *special case: removing head of list
 530    */
 531   if (current->index == index)
 532   {
 533     /*
 534      * set new head free the old one
 535      */
 536     This->headblock = current->next;
 537     HeapFree(GetProcessHeap(), 0, current);
 538
 539     return;
 540   }
 541
 542   /*
 543    * iterate through rest of the list
 544    */
 545   while (current->next != NULL)
 546   {
 547     if (current->next->index == index) /* found it */
 548     {
 549       /*
 550        * unlink the block and free the block
 551        */
 552       current->next = current->next->next;
 553       HeapFree(GetProcessHeap(), 0, current->next);
 554
 555       return;
 556     }
 557     else
 558     {
 559       /* next node
 560        */
 561       current = current->next;
 562     }
 563   }
 564 }
 565
 566 /******************************************************************************
 567  *      BIGBLOCKFILE_GetBigBlockFromPointer     [PRIVATE]
 568  *
 569  * Given a block pointer, this will return the corresponding block
 570  * from the blocks list.
 571  */
 572 static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(
 573   LPBIGBLOCKFILE This,
 574   void*          pBlock)
 575 {
 576   BigBlock *current = This->headblock;
 577
 578   while (current != NULL)
 579   {
 580     if (current->lpBlock == pBlock)
 581     {
 582       break;
 583     }
 584     else
 585       current = current->next;
 586   }
 587
 588   return current;
 589 }
 590
 591 /******************************************************************************
 592  *      BIGBLOCKFILE_GetMappedView      [PRIVATE]
 593  *
 594  * Gets the page requested if it is already mapped.
 595  * If it's not already mapped, this method will map it
 596  */
 597 static void * BIGBLOCKFILE_GetMappedView(
 598   LPBIGBLOCKFILE This,
 599   DWORD          pagenum,
 600   DWORD          desired_access)
 601 {
 602   MappedPage* current = This->maplisthead;
 603   ULONG       count   = 1;
 604   BOOL        found   = FALSE;
 605
 606   assert(This->maplisthead != NULL);
 607
 608   /*
 609    * Search for the page in the list.
 610    */
 611   while ((found == FALSE) && (current->next != NULL))
 612   {
 613     if (current->next->number == pagenum)
 614     {
 615       found = TRUE;
 616
 617       /*
 618        * If it's not already at the head of the list
 619        * move it there.
 620        */
 621       if (current != This->maplisthead)
 622       {
 623         MappedPage* temp = current->next;
 624
 625         current->next = current->next->next;
 626
 627         temp->next = This->maplisthead->next;
 628         This->maplisthead->next = temp;
 629       }
 630     }
 631
 632     /*
 633      * The list is full and we haven't found it.
 634      * Free the last element of the list because we'll add a new
 635      * one at the head.
 636      */
 637     if ((found == FALSE) &&
 638         (count >= NUMBER_OF_MAPPED_PAGES) &&
 639         (current->next != NULL))
 640     {
 641       UnmapViewOfFile(current->next->lpBytes);
 642
 643       HeapFree(GetProcessHeap(), 0, current->next);
 644       current->next = NULL;
 645     }
 646
 647     if (current->next != NULL)
 648       current = current->next;
 649
 650     count++;
 651   }
 652
 653   /*
 654    * Add the page at the head of the list.
 655    */
 656   if (found == FALSE)
 657   {
 658     MappedPage* newMappedPage;
 659     DWORD       numBytesToMap;
 660     DWORD       hioffset  = 0;
 661     DWORD       lowoffset = PAGE_SIZE * pagenum;
 662
 663     newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 664
 665     if (newMappedPage == NULL)
 666       return NULL;
 667
 668     newMappedPage->number = pagenum;
 669     newMappedPage->ref = 0;
 670
 671     newMappedPage->next = This->maplisthead->next;
 672     This->maplisthead->next = newMappedPage;
 673
 674     if (((pagenum + 1) * PAGE_SIZE) > This->filesize.LowPart)
 675       numBytesToMap = This->filesize.LowPart - (pagenum * PAGE_SIZE);
 676     else
 677       numBytesToMap = PAGE_SIZE;
 678
 679     if (This->flProtect == PAGE_READONLY)
 680       desired_access = FILE_MAP_READ;
 681     else
 682       desired_access = FILE_MAP_WRITE;
 683
 684     newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
 685                                            desired_access,
 686                                            hioffset,
 687                                            lowoffset,
 688                                            numBytesToMap);
 689   }
 690
 691   /*
 692    * The page we want should now be at the head of the list.
 693    */
 694   assert(This->maplisthead->next != NULL);
 695
 696   current = This->maplisthead->next;
 697   current->ref++;
 698
 699   return current->lpBytes;
 700 }
 701
 702 /******************************************************************************
 703  *      BIGBLOCKFILE_ReleaseMappedPage      [PRIVATE]
 704  *
 705  * Decrements the reference count of the mapped page.
 706  */
 707 static void BIGBLOCKFILE_ReleaseMappedPage(
 708   LPBIGBLOCKFILE This,
 709   DWORD          pagenum,
 710   DWORD          access)
 711 {
 712   MappedPage* previous = This->maplisthead;
 713   MappedPage* current;
 714
 715   assert(This->maplisthead->next != NULL);
 716
 717   current = previous->next;
 718
 719   /* search for the page in the list
 720    */
 721   while (current != NULL)
 722   {
 723     if (current->number == pagenum)
 724     {
 725       /* decrement the reference count
 726        */
 727       current->ref--;
 728       return;
 729     }
 730     else
 731     {
 732       previous = current;
 733       current = current->next;
 734     }
 735   }
 736 }
 737
 738 /******************************************************************************
 739  *      BIGBLOCKFILE_FreeAllMappedPages     [PRIVATE]
 740  *
 741  * Unmap all currently mapped pages.
 742  * Empty mapped pages list.
 743  */
 744 static void BIGBLOCKFILE_FreeAllMappedPages(
 745   LPBIGBLOCKFILE This)
 746 {
 747   MappedPage * current = This->maplisthead->next;
 748
 749   while (current != NULL)
 750   {
 751     /* Unmap views.
 752      */
 753     UnmapViewOfFile(current->lpBytes);
 754
 755     /* Free the nodes.
 756      */
 757     This->maplisthead->next = current->next;
 758     HeapFree(GetProcessHeap(), 0, current);
 759
 760     current = This->maplisthead->next;
 761   }
 762 }
 763
 764 /****************************************************************************
 765  *      BIGBLOCKFILE_GetProtectMode
 766  *
 767  * This function will return a protection mode flag for a file-mapping object
 768  * from the open flags of a file.
 769  */
 770 static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags)
 771 {
 772   DWORD flProtect        = PAGE_READONLY;
 773   BOOL bSTGM_WRITE     = ((openFlags & STGM_WRITE) == STGM_WRITE);
 774   BOOL bSTGM_READWRITE = ((openFlags & STGM_READWRITE) == STGM_READWRITE);
 775   BOOL bSTGM_READ      = ! (bSTGM_WRITE || bSTGM_READWRITE);
 776
 777   if (bSTGM_READ)
 778     flProtect = PAGE_READONLY;
 779
 780   if ((bSTGM_WRITE) || (bSTGM_READWRITE))
 781     flProtect = PAGE_READWRITE;
 782
 783   return flProtect;
 784 }
 785
 786