19151b96382e44f9cdbea2278532c245f19af594
[reactos.git] / reactos / dll / win32 / ole32 / 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 * This library is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU Lesser General Public
21 * License as published by the Free Software Foundation; either
22 * version 2.1 of the License, or (at your option) any later version.
23 *
24 * This library is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * Lesser General Public License for more details.
28 *
29 * You should have received a copy of the GNU Lesser General Public
30 * License along with this library; if not, write to the Free Software
31 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
32 */
33
34 #include <assert.h>
35 #include <stdlib.h>
36 #include <stdarg.h>
37 #include <stdio.h>
38 #include <string.h>
39 #include <limits.h>
40
41 #define COBJMACROS
42 #define NONAMELESSUNION
43 #define NONAMELESSSTRUCT
44
45 #include "windef.h"
46 #include "winbase.h"
47 #include "winuser.h"
48 #include "winerror.h"
49 #include "objbase.h"
50 #include "ole2.h"
51
52 #include "storage32.h"
53
54 #include "wine/debug.h"
55
56 WINE_DEFAULT_DEBUG_CHANNEL(storage);
57
58 /***********************************************************
59 * Data structures used internally by the BigBlockFile
60 * class.
61 */
62
63 /* We map in PAGE_SIZE-sized chunks. Must be a multiple of 4096. */
64 #define PAGE_SIZE 131072
65
66 #define BLOCKS_PER_PAGE (PAGE_SIZE / BIG_BLOCK_SIZE)
67
68 /* We keep a list of recently-discarded pages. This controls the
69 * size of that list. */
70 #define MAX_VICTIM_PAGES 16
71
72 /* This structure provides one bit for each block in a page.
73 * Use BIGBLOCKFILE_{Test,Set,Clear}Bit to manipulate it. */
74 typedef struct
75 {
76 unsigned int bits[BLOCKS_PER_PAGE / (CHAR_BIT * sizeof(unsigned int))];
77 } BlockBits;
78
79 /***
80 * This structure identifies the paged that are mapped
81 * from the file and their position in memory. It is
82 * also used to hold a reference count to those pages.
83 *
84 * page_index identifies which PAGE_SIZE chunk from the
85 * file this mapping represents. (The mappings are always
86 * PAGE_SIZE-aligned.)
87 */
88
89 typedef struct MappedPage MappedPage;
90 struct MappedPage
91 {
92 MappedPage *next;
93 MappedPage *prev;
94
95 DWORD page_index;
96 DWORD mapped_bytes;
97 LPVOID lpBytes;
98 LONG refcnt;
99
100 BlockBits readable_blocks;
101 BlockBits writable_blocks;
102 };
103
104 struct BigBlockFile
105 {
106 BOOL fileBased;
107 ULARGE_INTEGER filesize;
108 ULONG blocksize;
109 HANDLE hfile;
110 HANDLE hfilemap;
111 DWORD flProtect;
112 MappedPage *maplist;
113 MappedPage *victimhead, *victimtail;
114 ULONG num_victim_pages;
115 ILockBytes *pLkbyt;
116 };
117
118 /***********************************************************
119 * Prototypes for private methods
120 */
121
122 /* Note that this evaluates a and b multiple times, so don't
123 * pass expressions with side effects. */
124 #define ROUND_UP(a, b) ((((a) + (b) - 1)/(b))*(b))
125
126 /***********************************************************
127 * Blockbits functions.
128 */
129 static inline BOOL BIGBLOCKFILE_TestBit(const BlockBits *bb,
130 unsigned int index)
131 {
132 unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
133 unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
134
135 return bb->bits[array_index] & (1 << bit_index);
136 }
137
138 static inline void BIGBLOCKFILE_SetBit(BlockBits *bb, unsigned int index)
139 {
140 unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
141 unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
142
143 bb->bits[array_index] |= (1 << bit_index);
144 }
145
146 static inline void BIGBLOCKFILE_ClearBit(BlockBits *bb, unsigned int index)
147 {
148 unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
149 unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
150
151 bb->bits[array_index] &= ~(1 << bit_index);
152 }
153
154 static inline void BIGBLOCKFILE_Zero(BlockBits *bb)
155 {
156 memset(bb->bits, 0, sizeof(bb->bits));
157 }
158
159 /******************************************************************************
160 * BIGBLOCKFILE_FileInit
161 *
162 * Initialize a big block object supported by a file.
163 */
164 static BOOL BIGBLOCKFILE_FileInit(LPBIGBLOCKFILE This, HANDLE hFile)
165 {
166 This->pLkbyt = NULL;
167 This->hfile = hFile;
168
169 if (This->hfile == INVALID_HANDLE_VALUE)
170 return FALSE;
171
172 This->filesize.u.LowPart = GetFileSize(This->hfile,
173 &This->filesize.u.HighPart);
174
175 if( This->filesize.u.LowPart || This->filesize.u.HighPart )
176 {
177 /* create the file mapping object
178 */
179 This->hfilemap = CreateFileMappingA(This->hfile,
180 NULL,
181 This->flProtect,
182 0, 0,
183 NULL);
184
185 if (!This->hfilemap)
186 {
187 CloseHandle(This->hfile);
188 return FALSE;
189 }
190 }
191 else
192 This->hfilemap = NULL;
193
194 This->maplist = NULL;
195
196 TRACE("file len %u\n", This->filesize.u.LowPart);
197
198 return TRUE;
199 }
200
201 /******************************************************************************
202 * BIGBLOCKFILE_LockBytesInit
203 *
204 * Initialize a big block object supported by an ILockBytes.
205 */
206 static BOOL BIGBLOCKFILE_LockBytesInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt)
207 {
208 This->hfile = 0;
209 This->hfilemap = 0;
210 This->pLkbyt = plkbyt;
211 ILockBytes_AddRef(This->pLkbyt);
212
213 /* We'll get the size directly with ILockBytes_Stat */
214 This->filesize.QuadPart = 0;
215
216 TRACE("ILockBytes %p\n", This->pLkbyt);
217 return TRUE;
218 }
219
220 /******************************************************************************
221 * BIGBLOCKFILE_FindPageInList [PRIVATE]
222 *
223 */
224 static MappedPage *BIGBLOCKFILE_FindPageInList(MappedPage *head,
225 ULONG page_index)
226 {
227 for (; head != NULL; head = head->next)
228 {
229 if (head->page_index == page_index)
230 {
231 InterlockedIncrement(&head->refcnt);
232 break;
233 }
234 }
235
236 return head;
237
238 }
239
240 static void BIGBLOCKFILE_UnlinkPage(MappedPage *page)
241 {
242 if (page->next) page->next->prev = page->prev;
243 if (page->prev) page->prev->next = page->next;
244 }
245
246 static void BIGBLOCKFILE_LinkHeadPage(MappedPage **head, MappedPage *page)
247 {
248 if (*head) (*head)->prev = page;
249 page->next = *head;
250 page->prev = NULL;
251 *head = page;
252 }
253
254 static BOOL BIGBLOCKFILE_MapPage(BigBlockFile *This, MappedPage *page)
255 {
256 DWORD lowoffset = PAGE_SIZE * page->page_index;
257 DWORD numBytesToMap;
258 DWORD desired_access;
259
260 assert(This->fileBased);
261
262 if( !This->hfilemap )
263 return FALSE;
264
265 if (lowoffset + PAGE_SIZE > This->filesize.u.LowPart)
266 numBytesToMap = This->filesize.u.LowPart - lowoffset;
267 else
268 numBytesToMap = PAGE_SIZE;
269
270 if (This->flProtect == PAGE_READONLY)
271 desired_access = FILE_MAP_READ;
272 else
273 desired_access = FILE_MAP_WRITE;
274
275 page->lpBytes = MapViewOfFile(This->hfilemap, desired_access, 0,
276 lowoffset, numBytesToMap);
277 page->mapped_bytes = numBytesToMap;
278
279 TRACE("mapped page %u to %p\n", page->page_index, page->lpBytes);
280
281 return page->lpBytes != NULL;
282 }
283
284
285 static MappedPage *BIGBLOCKFILE_CreatePage(BigBlockFile *This, ULONG page_index)
286 {
287 MappedPage *page;
288
289 page = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
290 if (page == NULL)
291 return NULL;
292
293 page->page_index = page_index;
294 page->refcnt = 1;
295
296 page->next = NULL;
297 page->prev = NULL;
298
299 if (!BIGBLOCKFILE_MapPage(This, page))
300 {
301 HeapFree(GetProcessHeap(),0,page);
302 return NULL;
303 }
304
305 BIGBLOCKFILE_Zero(&page->readable_blocks);
306 BIGBLOCKFILE_Zero(&page->writable_blocks);
307
308 return page;
309 }
310
311
312 /******************************************************************************
313 * BIGBLOCKFILE_GetMappedView [PRIVATE]
314 *
315 * Gets the page requested if it is already mapped.
316 * If it's not already mapped, this method will map it
317 */
318 static void * BIGBLOCKFILE_GetMappedView(
319 LPBIGBLOCKFILE This,
320 DWORD page_index)
321 {
322 MappedPage *page;
323
324 page = BIGBLOCKFILE_FindPageInList(This->maplist, page_index);
325 if (!page)
326 {
327 page = BIGBLOCKFILE_FindPageInList(This->victimhead, page_index);
328 if (page)
329 {
330 This->num_victim_pages--;
331
332 BIGBLOCKFILE_Zero(&page->readable_blocks);
333 BIGBLOCKFILE_Zero(&page->writable_blocks);
334 }
335 }
336
337 if (page)
338 {
339 /* If the page is not already at the head of the list, move
340 * it there. (Also moves pages from victim to main list.) */
341 if (This->maplist != page)
342 {
343 if (This->victimhead == page) This->victimhead = page->next;
344 if (This->victimtail == page) This->victimtail = page->prev;
345
346 BIGBLOCKFILE_UnlinkPage(page);
347
348 BIGBLOCKFILE_LinkHeadPage(&This->maplist, page);
349 }
350
351 return page;
352 }
353
354 page = BIGBLOCKFILE_CreatePage(This, page_index);
355 if (!page) return NULL;
356
357 BIGBLOCKFILE_LinkHeadPage(&This->maplist, page);
358
359 return page;
360 }
361
362 static void BIGBLOCKFILE_UnmapPage(LPBIGBLOCKFILE This, MappedPage *page)
363 {
364 TRACE("%d at %p\n", page->page_index, page->lpBytes);
365
366 assert(This->fileBased);
367
368 if (page->refcnt > 0)
369 ERR("unmapping inuse page %p\n", page->lpBytes);
370
371 if (page->lpBytes)
372 UnmapViewOfFile(page->lpBytes);
373
374 page->lpBytes = NULL;
375 }
376
377 static void BIGBLOCKFILE_DeletePage(LPBIGBLOCKFILE This, MappedPage *page)
378 {
379 BIGBLOCKFILE_UnmapPage(This, page);
380
381 HeapFree(GetProcessHeap(), 0, page);
382 }
383
384 /******************************************************************************
385 * BIGBLOCKFILE_ReleaseMappedPage [PRIVATE]
386 *
387 * Decrements the reference count of the mapped page.
388 */
389 static void BIGBLOCKFILE_ReleaseMappedPage(
390 LPBIGBLOCKFILE This,
391 MappedPage *page)
392 {
393 assert(This != NULL);
394 assert(page != NULL);
395
396 /* If the page is no longer refenced, move it to the victim list.
397 * If the victim list is too long, kick somebody off. */
398 if (!InterlockedDecrement(&page->refcnt))
399 {
400 if (This->maplist == page) This->maplist = page->next;
401
402 BIGBLOCKFILE_UnlinkPage(page);
403
404 if (MAX_VICTIM_PAGES > 0)
405 {
406 if (This->num_victim_pages >= MAX_VICTIM_PAGES)
407 {
408 MappedPage *victim = This->victimtail;
409 if (victim)
410 {
411 This->victimtail = victim->prev;
412 if (This->victimhead == victim)
413 This->victimhead = victim->next;
414
415 BIGBLOCKFILE_UnlinkPage(victim);
416 BIGBLOCKFILE_DeletePage(This, victim);
417 }
418 }
419 else This->num_victim_pages++;
420
421 BIGBLOCKFILE_LinkHeadPage(&This->victimhead, page);
422 if (This->victimtail == NULL) This->victimtail = page;
423 }
424 else
425 BIGBLOCKFILE_DeletePage(This, page);
426 }
427 }
428
429 static void BIGBLOCKFILE_DeleteList(LPBIGBLOCKFILE This, MappedPage *list)
430 {
431 while (list != NULL)
432 {
433 MappedPage *next = list->next;
434
435 BIGBLOCKFILE_DeletePage(This, list);
436
437 list = next;
438 }
439 }
440
441 /******************************************************************************
442 * BIGBLOCKFILE_FreeAllMappedPages [PRIVATE]
443 *
444 * Unmap all currently mapped pages.
445 * Empty mapped pages list.
446 */
447 static void BIGBLOCKFILE_FreeAllMappedPages(
448 LPBIGBLOCKFILE This)
449 {
450 BIGBLOCKFILE_DeleteList(This, This->maplist);
451 BIGBLOCKFILE_DeleteList(This, This->victimhead);
452
453 This->maplist = NULL;
454 This->victimhead = NULL;
455 This->victimtail = NULL;
456 This->num_victim_pages = 0;
457 }
458
459 static void BIGBLOCKFILE_UnmapList(LPBIGBLOCKFILE This, MappedPage *list)
460 {
461 for (; list != NULL; list = list->next)
462 {
463 BIGBLOCKFILE_UnmapPage(This, list);
464 }
465 }
466
467 static void BIGBLOCKFILE_UnmapAllMappedPages(LPBIGBLOCKFILE This)
468 {
469 BIGBLOCKFILE_UnmapList(This, This->maplist);
470 BIGBLOCKFILE_UnmapList(This, This->victimhead);
471 }
472
473 static void BIGBLOCKFILE_RemapList(LPBIGBLOCKFILE This, MappedPage *list)
474 {
475 while (list != NULL)
476 {
477 MappedPage *next = list->next;
478
479 if (list->page_index * PAGE_SIZE > This->filesize.u.LowPart)
480 {
481 TRACE("discarding %u\n", list->page_index);
482
483 /* page is entirely outside of the file, delete it */
484 BIGBLOCKFILE_UnlinkPage(list);
485 BIGBLOCKFILE_DeletePage(This, list);
486 }
487 else
488 {
489 /* otherwise, remap it */
490 BIGBLOCKFILE_MapPage(This, list);
491 }
492
493 list = next;
494 }
495 }
496
497 static void BIGBLOCKFILE_RemapAllMappedPages(LPBIGBLOCKFILE This)
498 {
499 BIGBLOCKFILE_RemapList(This, This->maplist);
500 BIGBLOCKFILE_RemapList(This, This->victimhead);
501 }
502
503 /****************************************************************************
504 * BIGBLOCKFILE_GetProtectMode
505 *
506 * This function will return a protection mode flag for a file-mapping object
507 * from the open flags of a file.
508 */
509 static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags)
510 {
511 switch(STGM_ACCESS_MODE(openFlags))
512 {
513 case STGM_WRITE:
514 case STGM_READWRITE:
515 return PAGE_READWRITE;
516 }
517 return PAGE_READONLY;
518 }
519
520
521 /* ILockByte Interfaces */
522
523 /******************************************************************************
524 * This method is part of the ILockBytes interface.
525 *
526 * It reads a block of information from the byte array at the specified
527 * offset.
528 *
529 * See the documentation of ILockBytes for more info.
530 */
531 static HRESULT ImplBIGBLOCKFILE_ReadAt(
532 BigBlockFile* const This,
533 ULARGE_INTEGER ulOffset, /* [in] */
534 void* pv, /* [length_is][size_is][out] */
535 ULONG cb, /* [in] */
536 ULONG* pcbRead) /* [out] */
537 {
538 ULONG first_page = ulOffset.u.LowPart / PAGE_SIZE;
539 ULONG offset_in_page = ulOffset.u.LowPart % PAGE_SIZE;
540 ULONG bytes_left = cb;
541 ULONG page_index = first_page;
542 ULONG bytes_from_page;
543 LPVOID writePtr = pv;
544
545 HRESULT rc = S_OK;
546
547 TRACE("(%p)-> %i %p %i %p\n",This, ulOffset.u.LowPart, pv, cb, pcbRead);
548
549 /* verify a sane environment */
550 if (!This) return E_FAIL;
551
552 if (offset_in_page + bytes_left > PAGE_SIZE)
553 bytes_from_page = PAGE_SIZE - offset_in_page;
554 else
555 bytes_from_page = bytes_left;
556
557 if (pcbRead)
558 *pcbRead = 0;
559
560 while (bytes_left)
561 {
562 LPBYTE readPtr;
563 BOOL eof = FALSE;
564 MappedPage *page = BIGBLOCKFILE_GetMappedView(This, page_index);
565
566 if (!page || !page->lpBytes)
567 {
568 rc = STG_E_READFAULT;
569 break;
570 }
571
572 TRACE("page %i, offset %u, bytes_from_page %u, bytes_left %u\n",
573 page->page_index, offset_in_page, bytes_from_page, bytes_left);
574
575 if (page->mapped_bytes < bytes_from_page)
576 {
577 eof = TRUE;
578 bytes_from_page = page->mapped_bytes;
579 }
580
581 readPtr = (BYTE*)page->lpBytes + offset_in_page;
582 memcpy(writePtr,readPtr,bytes_from_page);
583 BIGBLOCKFILE_ReleaseMappedPage(This, page);
584
585 if (pcbRead)
586 *pcbRead += bytes_from_page;
587 bytes_left -= bytes_from_page;
588
589 if (bytes_left && !eof)
590 {
591 writePtr = (LPBYTE)writePtr + bytes_from_page;
592 page_index ++;
593 offset_in_page = 0;
594 if (bytes_left > PAGE_SIZE)
595 bytes_from_page = PAGE_SIZE;
596 else
597 bytes_from_page = bytes_left;
598 }
599 if (eof)
600 {
601 rc = STG_E_READFAULT;
602 break;
603 }
604 }
605
606 TRACE("finished\n");
607 return rc;
608 }
609
610 /******************************************************************************
611 * This method is part of the ILockBytes interface.
612 *
613 * It writes the specified bytes at the specified offset.
614 * position. If the file is too small, it will be resized.
615 *
616 * See the documentation of ILockBytes for more info.
617 */
618 static HRESULT ImplBIGBLOCKFILE_WriteAt(
619 BigBlockFile* const This,
620 ULARGE_INTEGER ulOffset, /* [in] */
621 const void* pv, /* [size_is][in] */
622 ULONG cb, /* [in] */
623 ULONG* pcbWritten) /* [out] */
624 {
625 ULONG size_needed = ulOffset.u.LowPart + cb;
626 ULONG first_page = ulOffset.u.LowPart / PAGE_SIZE;
627 ULONG offset_in_page = ulOffset.u.LowPart % PAGE_SIZE;
628 ULONG bytes_left = cb;
629 ULONG page_index = first_page;
630 ULONG bytes_to_page;
631 LPCVOID readPtr = pv;
632
633 HRESULT rc = S_OK;
634
635 TRACE("(%p)-> %i %p %i %p\n",This, ulOffset.u.LowPart, pv, cb, pcbWritten);
636
637 /* verify a sane environment */
638 if (!This) return E_FAIL;
639
640 if (This->flProtect != PAGE_READWRITE)
641 return STG_E_ACCESSDENIED;
642
643 if (size_needed > This->filesize.u.LowPart)
644 {
645 ULARGE_INTEGER newSize;
646 newSize.u.HighPart = 0;
647 newSize.u.LowPart = size_needed;
648 BIGBLOCKFILE_SetSize(This, newSize);
649 }
650
651 if (offset_in_page + bytes_left > PAGE_SIZE)
652 bytes_to_page = PAGE_SIZE - offset_in_page;
653 else
654 bytes_to_page = bytes_left;
655
656 if (pcbWritten)
657 *pcbWritten = 0;
658
659 while (bytes_left)
660 {
661 LPBYTE writePtr;
662 MappedPage *page = BIGBLOCKFILE_GetMappedView(This, page_index);
663
664 TRACE("page %i, offset %u, bytes_to_page %u, bytes_left %u\n",
665 page ? page->page_index : 0, offset_in_page, bytes_to_page, bytes_left);
666
667 if (!page)
668 {
669 ERR("Unable to get a page to write. This should never happen\n");
670 rc = E_FAIL;
671 break;
672 }
673
674 if (page->mapped_bytes < bytes_to_page)
675 {
676 ERR("Not enough bytes mapped to the page. This should never happen\n");
677 rc = E_FAIL;
678 break;
679 }
680
681 writePtr = (BYTE*)page->lpBytes + offset_in_page;
682 memcpy(writePtr,readPtr,bytes_to_page);
683 BIGBLOCKFILE_ReleaseMappedPage(This, page);
684
685 if (pcbWritten)
686 *pcbWritten += bytes_to_page;
687 bytes_left -= bytes_to_page;
688
689 if (bytes_left)
690 {
691 readPtr = (const BYTE *)readPtr + bytes_to_page;
692 page_index ++;
693 offset_in_page = 0;
694 if (bytes_left > PAGE_SIZE)
695 bytes_to_page = PAGE_SIZE;
696 else
697 bytes_to_page = bytes_left;
698 }
699 }
700
701 return rc;
702 }
703
704 /******************************************************************************
705 * BIGBLOCKFILE_Construct
706 *
707 * Construct a big block file. Create the file mapping object.
708 * Create the read only mapped pages list, the writable mapped page list
709 * and the blocks in use list.
710 */
711 BigBlockFile *BIGBLOCKFILE_Construct(HANDLE hFile, ILockBytes* pLkByt, DWORD openFlags,
712 ULONG blocksize, BOOL fileBased)
713 {
714 BigBlockFile *This;
715
716 This = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlockFile));
717
718 if (This == NULL)
719 return NULL;
720
721 This->fileBased = fileBased;
722 This->flProtect = BIGBLOCKFILE_GetProtectMode(openFlags);
723 This->blocksize = blocksize;
724
725 This->maplist = NULL;
726 This->victimhead = NULL;
727 This->victimtail = NULL;
728 This->num_victim_pages = 0;
729
730 if (This->fileBased)
731 {
732 if (!BIGBLOCKFILE_FileInit(This, hFile))
733 {
734 HeapFree(GetProcessHeap(), 0, This);
735 return NULL;
736 }
737 }
738 else
739 {
740 if (!BIGBLOCKFILE_LockBytesInit(This, pLkByt))
741 {
742 HeapFree(GetProcessHeap(), 0, This);
743 return NULL;
744 }
745 }
746
747 return This;
748 }
749
750 /******************************************************************************
751 * BIGBLOCKFILE_Destructor
752 *
753 * Destructor. Clean up, free memory.
754 */
755 void BIGBLOCKFILE_Destructor(BigBlockFile *This)
756 {
757 BIGBLOCKFILE_FreeAllMappedPages(This);
758
759 if (This->fileBased)
760 {
761 CloseHandle(This->hfilemap);
762 CloseHandle(This->hfile);
763 }
764 else
765 {
766 ILockBytes_Release(This->pLkbyt);
767 }
768
769 HeapFree(GetProcessHeap(), 0, This);
770 }
771
772 /******************************************************************************
773 * BIGBLOCKFILE_ReadAt
774 */
775 HRESULT BIGBLOCKFILE_ReadAt(BigBlockFile *This, ULARGE_INTEGER offset,
776 void* buffer, ULONG size, ULONG* bytesRead)
777 {
778 if (This->fileBased)
779 return ImplBIGBLOCKFILE_ReadAt(This,offset,buffer,size,bytesRead);
780 else
781 return ILockBytes_ReadAt(This->pLkbyt,offset,buffer,size,bytesRead);
782 }
783
784 /******************************************************************************
785 * BIGBLOCKFILE_WriteAt
786 */
787 HRESULT BIGBLOCKFILE_WriteAt(BigBlockFile *This, ULARGE_INTEGER offset,
788 const void* buffer, ULONG size, ULONG* bytesRead)
789 {
790 if (This->fileBased)
791 return ImplBIGBLOCKFILE_WriteAt(This,offset,buffer,size,bytesRead);
792 else
793 return ILockBytes_WriteAt(This->pLkbyt,offset,buffer,size,bytesRead);
794 }
795
796 /******************************************************************************
797 * BIGBLOCKFILE_SetSize
798 *
799 * Sets the size of the file.
800 *
801 */
802 HRESULT BIGBLOCKFILE_SetSize(BigBlockFile *This, ULARGE_INTEGER newSize)
803 {
804 HRESULT hr = S_OK;
805 LARGE_INTEGER newpos;
806
807 if (!This->fileBased)
808 return ILockBytes_SetSize(This->pLkbyt, newSize);
809
810 if (This->filesize.u.LowPart == newSize.u.LowPart)
811 return hr;
812
813 TRACE("from %u to %u\n", This->filesize.u.LowPart, newSize.u.LowPart);
814
815 /*
816 * Unmap all views, must be done before call to SetEndFile.
817 *
818 * Just ditch the victim list because there is no guarantee we will need them
819 * and it is not worth the performance hit to unmap and remap them all.
820 */
821 BIGBLOCKFILE_DeleteList(This, This->victimhead);
822 This->victimhead = NULL;
823 This->victimtail = NULL;
824 This->num_victim_pages = 0;
825
826 BIGBLOCKFILE_UnmapAllMappedPages(This);
827
828 newpos.QuadPart = newSize.QuadPart;
829 if (SetFilePointerEx(This->hfile, newpos, NULL, FILE_BEGIN))
830 {
831 if( This->hfilemap ) CloseHandle(This->hfilemap);
832
833 SetEndOfFile(This->hfile);
834
835 /* re-create the file mapping object */
836 This->hfilemap = CreateFileMappingA(This->hfile, NULL, This->flProtect,
837 0, 0, NULL);
838 }
839
840 This->filesize = newSize;
841 BIGBLOCKFILE_RemapAllMappedPages(This);
842 return hr;
843 }
844
845 /******************************************************************************
846 * BIGBLOCKFILE_GetSize
847 *
848 * Gets the size of the file.
849 *
850 */
851 static HRESULT BIGBLOCKFILE_GetSize(BigBlockFile *This, ULARGE_INTEGER *size)
852 {
853 HRESULT hr = S_OK;
854 if(This->fileBased)
855 *size = This->filesize;
856 else
857 {
858 STATSTG stat;
859 hr = ILockBytes_Stat(This->pLkbyt, &stat, STATFLAG_NONAME);
860 if(SUCCEEDED(hr)) *size = stat.cbSize;
861 }
862 return hr;
863 }
864
865 /******************************************************************************
866 * BIGBLOCKFILE_EnsureExists
867 *
868 * Grows the file if necessary to make sure the block is valid.
869 */
870 HRESULT BIGBLOCKFILE_EnsureExists(BigBlockFile *This, ULONG index)
871 {
872 ULARGE_INTEGER size;
873 HRESULT hr;
874
875 /* Block index starts at -1 translate to zero based index */
876 if (index == 0xffffffff)
877 index = 0;
878 else
879 index++;
880
881 hr = BIGBLOCKFILE_GetSize(This, &size);
882 if(FAILED(hr)) return hr;
883
884 /* make sure that the block physically exists */
885 if ((This->blocksize * (index + 1)) > size.QuadPart)
886 {
887 ULARGE_INTEGER newSize;
888
889 newSize.QuadPart = This->blocksize * (index + 1);
890 hr = BIGBLOCKFILE_SetSize(This, newSize);
891 }
892 return hr;
893 }