Skip to content

W
wine-cw
Commit 1529f584 authored by Andrew Lewycky's avatar Andrew Lewycky Committed by Alexandre Julliard
Browse files
Options

Rewrite the BIGBLOCKFILE implementation for better performance.

parent 92d76bd7
Hide whitespace changes
Inline Side-by-side
Showing with 383 additions and 466 deletions
dlls/ole32/stg_bigblockfile.c
View file @ 1529f584
......@@ -22,6 +22,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include "winbase.h"
#include "winerror.h"
......@@ -39,66 +40,107 @@ DEFAULT_DEBUG_CHANNEL(storage)
* class.
*/
/***
* Itdentifies a single big block and the related
* information
*/
struct BigBlock
/* We map in PAGE_SIZE-sized chunks. Must be a multiple of 4096. */
#define PAGE_SIZE 131072
#define BLOCKS_PER_PAGE (PAGE_SIZE / BIG_BLOCK_SIZE)
/* We keep a list of recently-discarded pages. This controls the
* size of that list. */
#define MAX_VICTIM_PAGES 16
/* This structure provides one bit for each block in a page.
* Use BIGBLOCKFILE_{Test,Set,Clear}Bit to manipulate it. */
typedef struct
{
BigBlock * next;
DWORD index;
DWORD access_mode;
LPVOID lpBlock;
};
unsigned int bits[BLOCKS_PER_PAGE / (CHAR_BIT * sizeof(unsigned int))];
} BlockBits;
/***
* This structure identifies the paged that are mapped
* from the file and their position in memory. It is
* also used to hold a reference count to those pages.
*
* page_index identifies which PAGE_SIZE chunk from the
* file this mapping represents. (The mappings are always
* PAGE_SIZE-aligned.)
*/
struct MappedPage
{
MappedPage * next;
DWORD number;
int ref;
LPVOID lpBytes;
};
MappedPage *next;
MappedPage *prev;
#define PAGE_SIZE 131072
#define BLOCKS_PER_PAGE 256
DWORD page_index;
LPVOID lpBytes;
LONG refcnt;
#define NUMBER_OF_MAPPED_PAGES 100
BlockBits readable_blocks;
BlockBits writable_blocks;
};
/***********************************************************
* Prototypes for private methods
*/
static void* BIGBLOCKFILE_GetMappedView(LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD desired_access);
DWORD page_index);
static void BIGBLOCKFILE_ReleaseMappedPage(LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD access);
MappedPage *page);
static void BIGBLOCKFILE_FreeAllMappedPages(LPBIGBLOCKFILE This);
static void BIGBLOCKFILE_UnmapAllMappedPages(LPBIGBLOCKFILE This);
static void BIGBLOCKFILE_RemapAllMappedPages(LPBIGBLOCKFILE This);
static void* BIGBLOCKFILE_GetBigBlockPointer(LPBIGBLOCKFILE This,
ULONG index,
DWORD desired_access);
static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(LPBIGBLOCKFILE This,
void* pBlock);
static void BIGBLOCKFILE_RemoveBlock(LPBIGBLOCKFILE This,
ULONG index);
static BigBlock* BIGBLOCKFILE_AddBigBlock(LPBIGBLOCKFILE This,
ULONG index);
static BigBlock* BIGBLOCKFILE_CreateBlock(ULONG index);
static MappedPage* BIGBLOCKFILE_GetPageFromPointer(LPBIGBLOCKFILE This,
void* pBlock);
static MappedPage* BIGBLOCKFILE_CreatePage(LPBIGBLOCKFILE This,
ULONG page_index);
static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags);
static BOOL BIGBLOCKFILE_FileInit(LPBIGBLOCKFILE This, HANDLE hFile);
static BOOL BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt);
static void BIGBLOCKFILE_RemoveAllBlocks(LPBIGBLOCKFILE This);
/* Note that this evaluates a and b multiple times, so don't
* pass expressions with side effects. */
#define ROUND_UP(a, b) ((((a) + (b) - 1)/(b))*(b))
/***********************************************************
* Blockbits functions.
*/
static inline BOOL BIGBLOCKFILE_TestBit(const BlockBits *bb,
unsigned int index)
{
unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
return bb->bits[array_index] & (1 << bit_index);
}
static inline void BIGBLOCKFILE_SetBit(BlockBits *bb, unsigned int index)
{
unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
bb->bits[array_index] |= (1 << bit_index);
}
static inline void BIGBLOCKFILE_ClearBit(BlockBits *bb, unsigned int index)
{
unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
bb->bits[array_index] &= ~(1 << bit_index);
}
static inline void BIGBLOCKFILE_Zero(BlockBits *bb)
{
memset(bb->bits, 0, sizeof(bb->bits));
}
/******************************************************************************
* BIGBLOCKFILE_Construct
*
* Construct a big block file. Create the file mapping object.
* Create the read only mapped pages list, the writeable mapped page list
* Create the read only mapped pages list, the writable mapped page list
* and the blocks in use list.
*/
BigBlockFile * BIGBLOCKFILE_Construct(
......@@ -121,9 +163,10 @@ BigBlockFile * BIGBLOCKFILE_Construct(
This->blocksize = blocksize;
/* initialize the block list
*/
This->headblock = NULL;
This->maplist = NULL;
This->victimhead = NULL;
This->victimtail = NULL;
This->num_victim_pages = 0;
if (This->fileBased)
{
......@@ -175,20 +218,12 @@ static BOOL BIGBLOCKFILE_FileInit(LPBIGBLOCKFILE This, HANDLE hFile)
return FALSE;
}
This->filesize.s.LowPart = GetFileSize(This->hfile, NULL);
This->filesize.s.LowPart = GetFileSize(This->hfile,
&This->filesize.s.HighPart);
/* create the mapped pages list
*/
This->maplisthead = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
This->maplist = NULL;
if (This->maplisthead == NULL)
{
CloseHandle(This->hfilemap);
CloseHandle(This->hfile);
return FALSE;
}
This->maplisthead->next = NULL;
TRACE("file len %lu\n", This->filesize.s.LowPart);
return TRUE;
}
......@@ -202,7 +237,6 @@ static BOOL BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt)
{
This->hfile = 0;
This->hfilemap = NULL;
This->maplisthead = NULL;
/*
* Retrieve the handle to the byte array from the LockByte object.
......@@ -226,6 +260,8 @@ static BOOL BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt)
This->pbytearray = GlobalLock(This->hbytearray);
TRACE("mem on %p len %lu\n", This->pbytearray, This->filesize.s.LowPart);
return TRUE;
}
......@@ -237,15 +273,10 @@ static BOOL BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt)
void BIGBLOCKFILE_Destructor(
LPBIGBLOCKFILE This)
{
BIGBLOCKFILE_FreeAllMappedPages(This);
if (This->fileBased)
{
/* unmap all views and destroy the mapped page list
*/
BIGBLOCKFILE_FreeAllMappedPages(This);
HeapFree(GetProcessHeap(), 0, This->maplisthead);
/* close all open handles
*/
CloseHandle(This->hfilemap);
CloseHandle(This->hfile);
}
......@@ -255,11 +286,6 @@ void BIGBLOCKFILE_Destructor(
ILockBytes_Release(This->pLkbyt);
}
/*
* Destroy the blocks list.
*/
BIGBLOCKFILE_RemoveAllBlocks(This);
/* destroy this
*/
HeapFree(GetProcessHeap(), 0, This);
......@@ -288,10 +314,13 @@ void* BIGBLOCKFILE_GetROBigBlock(
* validate the block index
*
*/
if ((This->blocksize * (index + 1)) >
(This->filesize.s.LowPart +
(This->blocksize - (This->filesize.s.LowPart % This->blocksize))))
return 0;
if (This->blocksize * (index + 1)
> ROUND_UP(This->filesize.s.LowPart, This->blocksize))
{
TRACE("out of range %lu vs %lu\n", This->blocksize * (index + 1),
This->filesize.s.LowPart);
return NULL;
}
return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_READ);
}
......@@ -336,37 +365,17 @@ void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index)
*/
void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock)
{
DWORD page_num;
BigBlock* theBigBlock;
MappedPage *page;
if (pBlock == NULL)
return;
/*
* get the block from the block list
*/
theBigBlock = BIGBLOCKFILE_GetBigBlockFromPointer(This, pBlock);
if (pBlock == NULL)
return;
if (theBigBlock == NULL)
return;
page = BIGBLOCKFILE_GetPageFromPointer(This, pBlock);
if (This->fileBased)
{
/*
* find out which page this block is in
*/
page_num = theBigBlock->index / BLOCKS_PER_PAGE;
/*
* release this page
*/
BIGBLOCKFILE_ReleaseMappedPage(This, page_num, theBigBlock->access_mode);
}
if (page == NULL)
return;
/*
* remove block from list
*/
BIGBLOCKFILE_RemoveBlock(This, theBigBlock->index);
BIGBLOCKFILE_ReleaseMappedPage(This, page);
}
/******************************************************************************
......@@ -380,19 +389,41 @@ void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
if (This->filesize.s.LowPart == newSize.s.LowPart)
return;
TRACE("from %lu to %lu\n", This->filesize.s.LowPart, newSize.s.LowPart);
/*
* unmap all views, must be done before call to SetEndFile
*/
BIGBLOCKFILE_UnmapAllMappedPages(This);
if (This->fileBased)
{
/*
* unmap all views, must be done before call to SetEndFile
*/
BIGBLOCKFILE_FreeAllMappedPages(This);
char buf[10];
/*
* close file-mapping object, must be done before call to SetEndFile
*/
CloseHandle(This->hfilemap);
This->hfilemap = NULL;
/*
* BEGIN HACK
* This fixes a bug when saving through smbfs.
* smbmount a Windows shared directory, save a structured storage file
* to that dir: crash.
*
* The problem is that the SetFilePointer-SetEndOfFile combo below
* doesn't always succeed. The file is not grown. It seems like the
* operation is cached. By doing the WriteFile, the file is actually
* grown on disk.
* This hack is only needed when saving to smbfs.
*/
memset(buf, '0', 10);
SetFilePointer(This->hfile, newSize.s.LowPart, NULL, FILE_BEGIN);
WriteFile(This->hfile, buf, 10, NULL, NULL);
/*
* END HACK
*/
/*
* set the new end of file
*/
......@@ -424,13 +455,10 @@ void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
This->pbytearray = GlobalLock(This->hbytearray);
}
/*
* empty the blocks list.
*/
BIGBLOCKFILE_RemoveAllBlocks(This);
This->filesize.s.LowPart = newSize.s.LowPart;
This->filesize.s.HighPart = newSize.s.HighPart;
BIGBLOCKFILE_RemapAllMappedPages(This);
}
/******************************************************************************
......@@ -445,287 +473,116 @@ ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This)
}
/******************************************************************************
* BIGBLOCKFILE_GetBigBlockPointer [PRIVATE]
* BIGBLOCKFILE_AccessCheck [PRIVATE]
*
* Returns a pointer to the specified block.
* block_index is the index within the page.
*/
static void* BIGBLOCKFILE_GetBigBlockPointer(
LPBIGBLOCKFILE This,
ULONG index,
DWORD desired_access)
static BOOL BIGBLOCKFILE_AccessCheck(MappedPage *page, ULONG block_index,
DWORD desired_access)
{
DWORD block_num;
void * pBytes;
BigBlock *aBigBlock;
/* get the big block from the list or add it to the list
*/
aBigBlock = BIGBLOCKFILE_AddBigBlock(This, index);
assert(block_index < BLOCKS_PER_PAGE);
if (aBigBlock == NULL)
return NULL;
if (desired_access == FILE_MAP_READ)
{
if (BIGBLOCKFILE_TestBit(&page->writable_blocks, block_index))
return FALSE;
/* we already have an address for this block
*/
if (aBigBlock->lpBlock != NULL)
{
/* make sure the desired access matches what we already have
*/
if (aBigBlock->access_mode == desired_access)
return aBigBlock->lpBlock;
BIGBLOCKFILE_SetBit(&page->readable_blocks, block_index);
}
else
return NULL;
}
/*
* else aBigBlock->lpBigBlock == NULL, it's a new block
*/
if (This->fileBased)
{
DWORD page_num;
/* find out which page this block is in
*/
page_num = index / BLOCKS_PER_PAGE;
/* offset of the block in the page
*/
block_num = index % BLOCKS_PER_PAGE;
/* get a pointer to the first byte in the page
*/
pBytes = BIGBLOCKFILE_GetMappedView(This, page_num, desired_access);
}
else
{
pBytes = This->pbytearray;
block_num = index;
}
{
assert(desired_access == FILE_MAP_WRITE);
if (pBytes == NULL)
return NULL;
if (BIGBLOCKFILE_TestBit(&page->readable_blocks, block_index))
return FALSE;
/* initialize block
*/
aBigBlock->lpBlock = ((BYTE*)pBytes + (block_num*This->blocksize));
aBigBlock->access_mode = desired_access;
BIGBLOCKFILE_SetBit(&page->writable_blocks, block_index);
}
return aBigBlock->lpBlock;
return TRUE;
}
/******************************************************************************
* BIGBLOCKFILE_CreateBlock [PRIVATE]
* BIGBLOCKFILE_GetBigBlockPointer [PRIVATE]
*
* Creates a node of the blocks list.
* Returns a pointer to the specified block.
*/
static BigBlock* BIGBLOCKFILE_CreateBlock(
ULONG index)
static void* BIGBLOCKFILE_GetBigBlockPointer(
LPBIGBLOCKFILE This,
ULONG block_index,
DWORD desired_access)
{
BigBlock *newBigBlock;
DWORD page_index = block_index / BLOCKS_PER_PAGE;
DWORD block_on_page = block_index % BLOCKS_PER_PAGE;
/* create new list node
*/
newBigBlock = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlock));
if (newBigBlock == NULL)
return NULL;
MappedPage *page = BIGBLOCKFILE_GetMappedView(This, page_index);
if (!page || !page->lpBytes) return NULL;
/* initialize node
*/
newBigBlock->index = index;
newBigBlock->lpBlock = NULL;
if (!BIGBLOCKFILE_AccessCheck(page, block_on_page, desired_access))
{
BIGBLOCKFILE_ReleaseMappedPage(This, page);
return NULL;
}
return newBigBlock;
return (LPBYTE)page->lpBytes + (block_on_page * This->blocksize);
}
/******************************************************************************
* BIGBLOCKFILE_AddBigBlock [PRIVATE]
* BIGBLOCKFILE_GetMappedPageFromPointer [PRIVATE]
*
* pBlock is a pointer to a block on a page.
* The page has to be on the in-use list. (As oppsed to the victim list.)
*
* Returns the specified block from the blocks list.
* If the block is not found in the list, we will create it and add it to the
* list.
* Does not increment the usage count.
*/
static BigBlock* BIGBLOCKFILE_AddBigBlock(
LPBIGBLOCKFILE This,
ULONG index)
static MappedPage *BIGBLOCKFILE_GetPageFromPointer(LPBIGBLOCKFILE This,
void *pBlock)
{
BigBlock *current = This->headblock;
BigBlock *newBigBlock;
if (current == NULL) /* empty list */
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = NULL;
This->headblock = newBigBlock;
}
return newBigBlock;
}
else
{
/*
* special handling for head of the list
*/
if (current->index == index) /* it's already here */
return current;
else if (current->index > index) /* insertion at head of the list */
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = current;
This->headblock = newBigBlock;
}
return newBigBlock;
}
}
MappedPage *page;
/* iterate through rest the list
*/
while (current->next != NULL)
{
if (current->next->index == index) /* found it */
for (page = This->maplist; page != NULL; page = page->next)
{
return current->next;
}
else if (current->next->index > index) /* it's not in the list */
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = current->next;
current->next = newBigBlock;
}
if ((LPBYTE)pBlock >= (LPBYTE)page->lpBytes
&& (LPBYTE)pBlock <= (LPBYTE)page->lpBytes + PAGE_SIZE)
break;
return newBigBlock;
}
else
current = current->next;
}
/*
* insertion at end of the list
*/
if (current->next == NULL)
{
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
if (newBigBlock != NULL)
{
newBigBlock->next = NULL;
current->next = newBigBlock;
}
return newBigBlock;
}
return NULL;
return page;
}
/******************************************************************************
* BIGBLOCKFILE_RemoveAllBlocks [PRIVATE]
* BIGBLOCKFILE_FindPageInList [PRIVATE]
*
* Removes all blocks from the blocks list.
*/
static void BIGBLOCKFILE_RemoveAllBlocks(
LPBIGBLOCKFILE This)
static MappedPage *BIGBLOCKFILE_FindPageInList(MappedPage *head,
ULONG page_index)
{
BigBlock *current;
for (; head != NULL; head = head->next)
{
if (head->page_index == page_index)
{
InterlockedIncrement(&head->refcnt);
break;
}
}
return head;
while (This->headblock != NULL)
{
current = This->headblock;
This->headblock = current->next;
HeapFree(GetProcessHeap(), 0, current);
}
}
/******************************************************************************
* BIGBLOCKFILE_RemoveBlock [PRIVATE]
*
* Removes the specified block from the blocks list.
*/
static void BIGBLOCKFILE_RemoveBlock(
LPBIGBLOCKFILE This,
ULONG index)
static void BIGBLOCKFILE_UnlinkPage(MappedPage *page)
{
BigBlock *current = This->headblock;
/*
* empty list
*/
if (current == NULL)
return;
/*
*special case: removing head of list
*/
if (current->index == index)
{
/*
* set new head free the old one
*/
This->headblock = current->next;
HeapFree(GetProcessHeap(), 0, current);
return;
}
/*
* iterate through rest of the list
*/
while (current->next != NULL)
{
if (current->next->index == index) /* found it */
{
/*
* unlink the block and free the block
*/
current->next = current->next->next;
HeapFree(GetProcessHeap(), 0, current->next);
return;
}
else
{
/* next node
*/
current = current->next;
}
}
if (page->next) page->next->prev = page->prev;
if (page->prev) page->prev->next = page->next;
}
/******************************************************************************
* BIGBLOCKFILE_GetBigBlockFromPointer [PRIVATE]
*
* Given a block pointer, this will return the corresponding block
* from the blocks list.
*/
static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(
LPBIGBLOCKFILE This,
void* pBlock)
static void BIGBLOCKFILE_LinkHeadPage(MappedPage **head, MappedPage *page)
{
BigBlock *current = This->headblock;
while (current != NULL)
{
if (current->lpBlock == pBlock)
{
break;
}
else
current = current->next;
}
return current;
if (*head) (*head)->prev = page;
page->next = *head;
page->prev = NULL;
*head = page;
}
/******************************************************************************
......@@ -736,107 +593,120 @@ static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(
*/
static void * BIGBLOCKFILE_GetMappedView(
LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD desired_access)
DWORD page_index)
{
MappedPage* current = This->maplisthead;
ULONG count = 1;
BOOL found = FALSE;
MappedPage *page;
assert(This->maplisthead != NULL);
page = BIGBLOCKFILE_FindPageInList(This->maplist, page_index);
if (!page)
{
page = BIGBLOCKFILE_FindPageInList(This->victimhead, page_index);
if (page)
{
This->num_victim_pages--;
BIGBLOCKFILE_Zero(&page->readable_blocks);
BIGBLOCKFILE_Zero(&page->writable_blocks);
}
}
/*
* Search for the page in the list.
*/
while ((found == FALSE) && (current->next != NULL))
{
if (current->next->number == pagenum)
if (page)
{
found = TRUE;
/* If the page is not already at the head of the list, move
* it there. (Also moves pages from victim to main list.) */
if (This->maplist != page)
{
if (This->victimhead == page) This->victimhead = page->next;
if (This->victimtail == page) This->victimtail = page->prev;
/*
* If it's not already at the head of the list
* move it there.
*/
if (current != This->maplisthead)
{
MappedPage* temp = current->next;
BIGBLOCKFILE_UnlinkPage(page);
current->next = current->next->next;
BIGBLOCKFILE_LinkHeadPage(&This->maplist, page);
}
temp->next = This->maplisthead->next;
This->maplisthead->next = temp;
}
return page;
}
/*
* The list is full and we haven't found it.
* Free the last element of the list because we'll add a new
* one at the head.
*/
if ((found == FALSE) &&
(count >= NUMBER_OF_MAPPED_PAGES) &&
(current->next != NULL))
page = BIGBLOCKFILE_CreatePage(This, page_index);
if (!page) return NULL;
BIGBLOCKFILE_LinkHeadPage(&This->maplist, page);
return page;
}
static BOOL BIGBLOCKFILE_MapPage(LPBIGBLOCKFILE This, MappedPage *page)
{
DWORD lowoffset = PAGE_SIZE * page->page_index;
if (This->fileBased)
{
UnmapViewOfFile(current->next->lpBytes);
DWORD numBytesToMap;
DWORD desired_access;
HeapFree(GetProcessHeap(), 0, current->next);
current->next = NULL;
}
if (lowoffset + PAGE_SIZE > This->filesize.s.LowPart)
numBytesToMap = This->filesize.s.LowPart - lowoffset;
else
numBytesToMap = PAGE_SIZE;
if (current->next != NULL)
current = current->next;
if (This->flProtect == PAGE_READONLY)
desired_access = FILE_MAP_READ;
else
desired_access = FILE_MAP_WRITE;
count++;
}
page->lpBytes = MapViewOfFile(This->hfilemap, desired_access, 0,
lowoffset, numBytesToMap);
}
else
{
page->lpBytes = (LPBYTE)This->pbytearray + lowoffset;
}
/*
* Add the page at the head of the list.
*/
if (found == FALSE)
{
MappedPage* newMappedPage;
DWORD numBytesToMap;
DWORD hioffset = 0;
DWORD lowoffset = PAGE_SIZE * pagenum;
TRACE("mapped page %lu to %p\n", page->page_index, page->lpBytes);
newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
return page->lpBytes != NULL;
}
if (newMappedPage == NULL)
static MappedPage *BIGBLOCKFILE_CreatePage(LPBIGBLOCKFILE This,
ULONG page_index)
{
MappedPage *page;
page = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
if (page == NULL)
return NULL;
newMappedPage->number = pagenum;
newMappedPage->ref = 0;
page->page_index = page_index;
page->refcnt = 1;
newMappedPage->next = This->maplisthead->next;
This->maplisthead->next = newMappedPage;
page->next = NULL;
page->prev = NULL;
if (((pagenum + 1) * PAGE_SIZE) > This->filesize.s.LowPart)
numBytesToMap = This->filesize.s.LowPart - (pagenum * PAGE_SIZE);
else
numBytesToMap = PAGE_SIZE;
BIGBLOCKFILE_MapPage(This, page);
if (This->flProtect == PAGE_READONLY)
desired_access = FILE_MAP_READ;
else
desired_access = FILE_MAP_WRITE;
BIGBLOCKFILE_Zero(&page->readable_blocks);
BIGBLOCKFILE_Zero(&page->writable_blocks);
newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
desired_access,
hioffset,
lowoffset,
numBytesToMap);
}
return page;
}
/*
* The page we want should now be at the head of the list.
*/
assert(This->maplisthead->next != NULL);
static void BIGBLOCKFILE_UnmapPage(LPBIGBLOCKFILE This, MappedPage *page)
{
TRACE("%ld at %p\n", page->page_index, page->lpBytes);
if (page->refcnt > 0)
ERR("unmapping inuse page %p\n", page->lpBytes);
current = This->maplisthead->next;
current->ref++;
if (This->fileBased && page->lpBytes)
UnmapViewOfFile(page->lpBytes);
page->lpBytes = NULL;
}
static void BIGBLOCKFILE_DeletePage(LPBIGBLOCKFILE This, MappedPage *page)
{
BIGBLOCKFILE_UnmapPage(This, page);
return current->lpBytes;
HeapFree(GetProcessHeap(), 0, page);
}
/******************************************************************************
......@@ -846,33 +716,54 @@ static void * BIGBLOCKFILE_GetMappedView(
*/
static void BIGBLOCKFILE_ReleaseMappedPage(
LPBIGBLOCKFILE This,
DWORD pagenum,
DWORD access)
MappedPage *page)
{
MappedPage* previous = This->maplisthead;
MappedPage* current;
assert(This != NULL);
assert(page != NULL);
assert(This->maplisthead->next != NULL);
current = previous->next;
/* search for the page in the list
*/
while (current != NULL)
{
if (current->number == pagenum)
/* If the page is no longer refenced, move it to the victim list.
* If the victim list is too long, kick somebody off. */
if (!InterlockedDecrement(&page->refcnt))
{
/* decrement the reference count
*/
current->ref--;
return;
if (This->maplist == page) This->maplist = page->next;
BIGBLOCKFILE_UnlinkPage(page);
if (MAX_VICTIM_PAGES > 0)
{
if (This->num_victim_pages >= MAX_VICTIM_PAGES)
{
MappedPage *victim = This->victimtail;
if (victim)
{
This->victimtail = victim->prev;
if (This->victimhead == victim)
This->victimhead = victim->next;
BIGBLOCKFILE_UnlinkPage(victim);
BIGBLOCKFILE_DeletePage(This, victim);
}
}
else This->num_victim_pages++;
BIGBLOCKFILE_LinkHeadPage(&This->victimhead, page);
if (This->victimtail == NULL) This->victimtail = page;
}
else
BIGBLOCKFILE_DeletePage(This, page);
}
else
}
static void BIGBLOCKFILE_DeleteList(LPBIGBLOCKFILE This, MappedPage *list)
{
while (list != NULL)
{
previous = current;
current = current->next;
MappedPage *next = list->next;
BIGBLOCKFILE_DeletePage(This, list);
list = next;
}
}
}
/******************************************************************************
......@@ -884,21 +775,57 @@ static void BIGBLOCKFILE_ReleaseMappedPage(
static void BIGBLOCKFILE_FreeAllMappedPages(
LPBIGBLOCKFILE This)
{
MappedPage * current = This->maplisthead->next;
BIGBLOCKFILE_DeleteList(This, This->maplist);
BIGBLOCKFILE_DeleteList(This, This->victimhead);
while (current != NULL)
{
/* Unmap views.
*/
UnmapViewOfFile(current->lpBytes);
This->maplist = NULL;
This->victimhead = NULL;
This->victimtail = NULL;
This->num_victim_pages = 0;
}
/* Free the nodes.
*/
This->maplisthead->next = current->next;
HeapFree(GetProcessHeap(), 0, current);
static void BIGBLOCKFILE_UnmapList(LPBIGBLOCKFILE This, MappedPage *list)
{
for (; list != NULL; list = list->next)
{
BIGBLOCKFILE_UnmapPage(This, list);
}
}
current = This->maplisthead->next;
}
static void BIGBLOCKFILE_UnmapAllMappedPages(LPBIGBLOCKFILE This)
{
BIGBLOCKFILE_UnmapList(This, This->maplist);
BIGBLOCKFILE_UnmapList(This, This->victimhead);
}
static void BIGBLOCKFILE_RemapList(LPBIGBLOCKFILE This, MappedPage *list)
{
while (list != NULL)
{
MappedPage *next = list->next;
if (list->page_index * PAGE_SIZE > This->filesize.s.LowPart)
{
TRACE("discarding %lu\n", list->page_index);
/* page is entirely outside of the file, delete it */
BIGBLOCKFILE_UnlinkPage(list);
BIGBLOCKFILE_DeletePage(This, list);
}
else
{
/* otherwise, remap it */
BIGBLOCKFILE_MapPage(This, list);
}
list = next;
}
}
static void BIGBLOCKFILE_RemapAllMappedPages(LPBIGBLOCKFILE This)
{
BIGBLOCKFILE_RemapList(This, This->maplist);
BIGBLOCKFILE_RemapList(This, This->victimhead);
}
/****************************************************************************
......@@ -909,18 +836,8 @@ static void BIGBLOCKFILE_FreeAllMappedPages(
*/
static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags)
{
DWORD flProtect = PAGE_READONLY;
BOOL bSTGM_WRITE = ((openFlags & STGM_WRITE) == STGM_WRITE);
BOOL bSTGM_READWRITE = ((openFlags & STGM_READWRITE) == STGM_READWRITE);
BOOL bSTGM_READ = ! (bSTGM_WRITE || bSTGM_READWRITE);
if (bSTGM_READ)
flProtect = PAGE_READONLY;
if ((bSTGM_WRITE) || (bSTGM_READWRITE))
flProtect = PAGE_READWRITE;
return flProtect;
if (openFlags & (STGM_WRITE | STGM_READWRITE))
return PAGE_READWRITE;
else
return PAGE_READONLY;
}
dlls/ole32/storage32.h
View file @ 1529f584
......@@ -135,7 +135,6 @@ struct StgProperty
*/
typedef struct BigBlockFile BigBlockFile,*LPBIGBLOCKFILE;
typedef struct MappedPage MappedPage,*LPMAPPEDPAGE;
typedef struct BigBlock BigBlock,*LPBIGBLOCK;
struct BigBlockFile
{
......@@ -145,11 +144,12 @@ struct BigBlockFile
HANDLE hfile;
HANDLE hfilemap;
DWORD flProtect;
MappedPage *maplisthead;
MappedPage *maplist;
MappedPage *victimhead, *victimtail;
ULONG num_victim_pages;
ILockBytes *pLkbyt;
HGLOBAL hbytearray;
LPVOID pbytearray;
BigBlock *headblock;
};
/*
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment