?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- added instructions how to update the online documentation
[bochs-mirror.git] / iodev / hdimage.cc
blobb16d9421b48d88bd5b8130b1c0076d72f1a7cac2
1 /////////////////////////////////////////////////////////////////////////
2 // $Id: hdimage.cc,v 1.16 2008/02/15 22:05:42 sshwarts Exp $
3 /////////////////////////////////////////////////////////////////////////
4 //
5 // Copyright (C) 2002 MandrakeSoft S.A.
6 //
7 // MandrakeSoft S.A.
8 // 43, rue d'Aboukir
9 // 75002 Paris - France
10 // http://www.linux-mandrake.com/
11 // http://www.mandrakesoft.com/
12 //
13 // This library is free software; you can redistribute it and/or
14 // modify it under the terms of the GNU Lesser General Public
15 // License as published by the Free Software Foundation; either
16 // version 2 of the License, or (at your option) any later version.
17 //
18 // This library is distributed in the hope that it will be useful,
19 // but WITHOUT ANY WARRANTY; without even the implied warranty of
20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 // Lesser General Public License for more details.
22 //
23 // You should have received a copy of the GNU Lesser General Public
24 // License along with this library; if not, write to the Free Software
25 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 /////////////////////////////////////////////////////////////////////////
27
28 // Define BX_PLUGGABLE in files that can be compiled into plugins. For
29 // platforms that require a special tag on exported symbols, BX_PLUGGABLE
30 // is used to know when we are exporting symbols and when we are importing.
31 #define BX_PLUGGABLE
32
33 #define NO_DEVICE_INCLUDES
34 #include "iodev.h"
35 #include "hdimage.h"
36
37 #if BX_HAVE_SYS_MMAN_H
38 #include <sys/mman.h>
39 #endif
40
41 #define LOG_THIS bx_devices.pluginHardDrive->
42
43 /*** base class device_image_t ***/
44
45 device_image_t::device_image_t()
46 {
47 hd_size = 0;
48 }
49
50 /*** default_image_t function definitions ***/
51
52 int default_image_t::open(const char* pathname)
53 {
54 return open(pathname, O_RDWR);
55 }
56
57 int default_image_t::open(const char* pathname, int flags)
58 {
59 #ifdef WIN32
60 HANDLE hFile = CreateFile(pathname, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, NULL);
61 if (hFile != INVALID_HANDLE_VALUE) {
62 ULARGE_INTEGER FileSize;
63 FileSize.LowPart = GetFileSize(hFile, &FileSize.HighPart);
64 CloseHandle(hFile);
65 if ((FileSize.LowPart != INVALID_FILE_SIZE) || (GetLastError() == NO_ERROR)) {
66 hd_size = FileSize.QuadPart;
67 } else {
68 return -1;
69 }
70 } else {
71 return -1;
72 }
73 #endif
74
75 fd = ::open(pathname, flags
76 #ifdef O_BINARY
77 | O_BINARY
78 #endif
79 );
80
81 if (fd < 0) {
82 return fd;
83 }
84
85 #ifndef WIN32
86 /* look at size of image file to calculate disk geometry */
87 struct stat stat_buf;
88 int ret = fstat(fd, &stat_buf);
89 if (ret) {
90 BX_PANIC(("fstat() returns error!"));
91 }
92 hd_size = (Bit64u)stat_buf.st_size;
93 #endif
94 if ((hd_size % 512) != 0) {
95 BX_PANIC(("size of disk image must be multiple of 512 bytes"));
96 }
97
98 return fd;
99 }
100
101 void default_image_t::close()
102 {
103 if (fd > -1) {
104 ::close(fd);
105 }
106 }
107
108 Bit64s default_image_t::lseek(Bit64s offset, int whence)
109 {
110 return (Bit64s)::lseek(fd, (off_t)offset, whence);
111 }
112
113 ssize_t default_image_t::read(void* buf, size_t count)
114 {
115 return ::read(fd, (char*) buf, count);
116 }
117
118 ssize_t default_image_t::write(const void* buf, size_t count)
119 {
120 return ::write(fd, (char*) buf, count);
121 }
122
123 char increment_string(char *str, int diff)
124 {
125 // find the last character of the string, and increment it.
126 char *p = str;
127 while (*p != 0) p++;
128 BX_ASSERT(p>str); // choke on zero length strings
129 p--; // point to last character of the string
130 (*p) += diff; // increment to next/previous ascii code.
131 BX_DEBUG(("increment string returning '%s'", str));
132 return (*p);
133 }
134
135 /*** concat_image_t function definitions ***/
136
137 concat_image_t::concat_image_t()
138 {
139 fd = -1;
140 }
141
142 void concat_image_t::increment_string(char *str)
143 {
144 ::increment_string(str, +1);
145 }
146
147 int concat_image_t::open(const char* pathname0)
148 {
149 char *pathname = strdup(pathname0);
150 BX_DEBUG(("concat_image_t.open"));
151 Bit64s start_offset = 0;
152 for (int i=0; i<BX_CONCAT_MAX_IMAGES; i++) {
153 fd_table[i] = ::open(pathname, O_RDWR
154 #ifdef O_BINARY
155 | O_BINARY
156 #endif
157 );
158 if (fd_table[i] < 0) {
159 // open failed.
160 // if no FD was opened successfully, return -1 (fail).
161 if (i==0) return -1;
162 // otherwise, it only means that all images in the series have
163 // been opened. Record the number of fds opened successfully.
164 maxfd = i;
165 break;
166 }
167 BX_DEBUG(("concat_image: open image %s, fd[%d] = %d", pathname, i, fd_table[i]));
168 /* look at size of image file to calculate disk geometry */
169 struct stat stat_buf;
170 int ret = fstat(fd_table[i], &stat_buf);
171 if (ret) {
172 BX_PANIC(("fstat() returns error!"));
173 }
174 #ifdef S_ISBLK
175 if (S_ISBLK(stat_buf.st_mode)) {
176 BX_PANIC(("block devices should REALLY NOT be used as concat images"));
177 }
178 #endif
179 if ((stat_buf.st_size % 512) != 0) {
180 BX_PANIC(("size of disk image must be multiple of 512 bytes"));
181 }
182 length_table[i] = stat_buf.st_size;
183 start_offset_table[i] = start_offset;
184 start_offset += stat_buf.st_size;
185 increment_string(pathname);
186 }
187 // start up with first image selected
188 index = 0;
189 fd = fd_table[0];
190 thismin = 0;
191 thismax = length_table[0]-1;
192 seek_was_last_op = 0;
193 hd_size = start_offset;
194 return 0; // success.
195 }
196
197 void concat_image_t::close()
198 {
199 BX_DEBUG(("concat_image_t.close"));
200 if (fd > -1) {
201 ::close(fd);
202 }
203 }
204
205 Bit64s concat_image_t::lseek(Bit64s offset, int whence)
206 {
207 if ((offset % 512) != 0)
208 BX_PANIC(("lseek HD with offset not multiple of 512"));
209 BX_DEBUG(("concat_image_t.lseek(%d)", whence));
210 // is this offset in this disk image?
211 if (offset < thismin) {
212 // no, look at previous images
213 for (int i=index-1; i>=0; i--) {
214 if (offset >= start_offset_table[i]) {
215 index = i;
216 fd = fd_table[i];
217 thismin = start_offset_table[i];
218 thismax = thismin + length_table[i] - 1;
219 BX_DEBUG(("concat_image_t.lseek to earlier image, index=%d", index));
220 break;
221 }
222 }
223 } else if (offset > thismax) {
224 // no, look at later images
225 for (int i=index+1; i<maxfd; i++) {
226 if (offset < start_offset_table[i] + length_table[i]) {
227 index = i;
228 fd = fd_table[i];
229 thismin = start_offset_table[i];
230 thismax = thismin + length_table[i] - 1;
231 BX_DEBUG(("concat_image_t.lseek to earlier image, index=%d", index));
232 break;
233 }
234 }
235 }
236 // now offset should be within the current image.
237 offset -= start_offset_table[index];
238 if (offset < 0 || offset >= length_table[index]) {
239 BX_PANIC(("concat_image_t.lseek to byte %ld failed", (long)offset));
240 return -1;
241 }
242
243 seek_was_last_op = 1;
244 return (Bit64s)::lseek(fd, (off_t)offset, whence);
245 }
246
247 ssize_t concat_image_t::read(void* buf, size_t count)
248 {
249 if (bx_dbg.disk)
250 BX_DEBUG(("concat_image_t.read %ld bytes", (long)count));
251 // notice if anyone does sequential read or write without seek in between.
252 // This can be supported pretty easily, but needs additional checks for
253 // end of a partial image.
254 if (!seek_was_last_op)
255 BX_PANIC(("no seek before read"));
256 return ::read(fd, (char*) buf, count);
257 }
258
259 ssize_t concat_image_t::write(const void* buf, size_t count)
260 {
261 BX_DEBUG(("concat_image_t.write %ld bytes", (long)count));
262 // notice if anyone does sequential read or write without seek in between.
263 // This can be supported pretty easily, but needs additional checks for
264 // end of a partial image.
265 if (!seek_was_last_op)
266 BX_PANIC(("no seek before write"));
267 return ::write(fd, (char*) buf, count);
268 }
269
270 /*** sparse_image_t function definitions ***/
271
272 sparse_image_t::sparse_image_t ()
273 {
274 fd = -1;
275 pathname = NULL;
276 #ifdef _POSIX_MAPPED_FILES
277 mmap_header = NULL;
278 #endif
279 pagetable = NULL;
280 }
281
282 /*
283 void showpagetable(Bit32u * pagetable, size_t numpages)
284 {
285 printf("Non null pages: ");
286 for (int i = 0; i < numpages; i++)
287 {
288 if (pagetable[i] != 0xffffffff)
289 {
290 printf("%d ", i);
291 }
292 }
293 printf("\n");
294 }
295 */
296
297 void sparse_image_t::read_header()
298 {
299 BX_ASSERT(sizeof(header) == SPARSE_HEADER_SIZE);
300
301 int ret = ::read(fd, &header, sizeof(header));
302
303 if (-1 == ret)
304 {
305 panic(strerror(errno));
306 }
307
308 if (sizeof(header) != ret)
309 {
310 panic("could not read entire header");
311 }
312
313 if (dtoh32(header.magic) != SPARSE_HEADER_MAGIC)
314 {
315 panic("failed header magic check");
316 }
317
318 if ((dtoh32(header.version) != SPARSE_HEADER_VERSION) &&
319 (dtoh32(header.version) != SPARSE_HEADER_V1))
320 {
321 panic("unknown version in header");
322 }
323
324 pagesize = dtoh32(header.pagesize);
325 Bit32u numpages = dtoh32(header.numpages);
326
327 total_size = pagesize;
328 total_size *= numpages;
329
330 pagesize_shift = 0;
331 while ((pagesize >> pagesize_shift) > 1) pagesize_shift++;
332
333 if ((Bit32u)(1 << pagesize_shift) != pagesize)
334 {
335 panic("failed block size header check");
336 }
337
338 pagesize_mask = pagesize - 1;
339
340 size_t preamble_size = (sizeof(Bit32u) * numpages) + sizeof(header);
341 data_start = 0;
342 while ((size_t)data_start < preamble_size) data_start += pagesize;
343
344 bx_bool did_mmap = 0;
345
346 #ifdef _POSIX_MAPPED_FILES
347 // Try to memory map from the beginning of the file (0 is trivially a page multiple)
348 void * mmap_header = mmap(NULL, preamble_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
349 if (mmap_header == MAP_FAILED)
350 {
351 BX_INFO(("failed to mmap sparse disk file - using conventional file access"));
352 mmap_header = NULL;
353 }
354 else
355 {
356 mmap_length = preamble_size;
357 did_mmap = 1;
358 pagetable = ((Bit32u *) (((Bit8u *) mmap_header) + sizeof(header)));
359 system_pagesize_mask = getpagesize() - 1;
360 }
361 #endif
362
363 if (!did_mmap)
364 {
365 pagetable = new Bit32u[numpages];
366
367 if (pagetable == NULL)
368 {
369 panic("could not allocate memory for sparse disk block table");
370 }
371
372 ret = ::read(fd, pagetable, sizeof(Bit32u) * numpages);
373
374 if (-1 == ret)
375 {
376 panic(strerror(errno));
377 }
378
379 if ((int)(sizeof(Bit32u) * numpages) != ret)
380 {
381 panic("could not read entire block table");
382 }
383 }
384 }
385
386 int sparse_image_t::open (const char* pathname0)
387 {
388 pathname = strdup(pathname0);
389 BX_DEBUG(("sparse_image_t.open"));
390
391 fd = ::open(pathname, O_RDWR
392 #ifdef O_BINARY
393 | O_BINARY
394 #endif
395 );
396
397 if (fd < 0)
398 {
399 return -1; // open failed
400 }
401 BX_DEBUG(("sparse_image: open image %s", pathname));
402
403 read_header();
404
405 struct stat stat_buf;
406 if (fstat(fd, &stat_buf) != 0) panic(("fstat() returns error!"));
407
408 underlying_filesize = stat_buf.st_size;
409
410 if ((underlying_filesize % pagesize) != 0)
411 panic("size of sparse disk image is not multiple of page size");
412
413 underlying_current_filepos = 0;
414 if (-1 == ::lseek(fd, 0, SEEK_SET))
415 panic("error while seeking to start of file");
416
417 lseek(0, SEEK_SET);
418
419 //showpagetable(pagetable, header.numpages);
420
421 char * parentpathname = strdup(pathname);
422 char lastchar = ::increment_string(parentpathname, -1);
423
424 if ((lastchar >= '0') && (lastchar <= '9'))
425 {
426 struct stat stat_buf;
427 if (0 == stat(parentpathname, &stat_buf))
428 {
429 parent_image = new sparse_image_t();
430 int ret = parent_image->open(parentpathname);
431 if (ret != 0) return ret;
432 if ( (parent_image->pagesize != pagesize)
433 || (parent_image->total_size != total_size))
434 {
435 panic("child drive image does not have same page count/page size configuration");
436 }
437 }
438 }
439
440 if (parentpathname != NULL) free(parentpathname);
441
442 if (dtoh32(header.version) == SPARSE_HEADER_VERSION) {
443 hd_size = dtoh64(header.disk);
444 }
445
446 return 0; // success
447 }
448
449 void sparse_image_t::close()
450 {
451 BX_DEBUG(("concat_image_t.close"));
452 if (pathname != NULL)
453 {
454 free(pathname);
455 }
456 #ifdef _POSIX_MAPPED_FILES
457 if (mmap_header != NULL)
458 {
459 int ret = munmap(mmap_header, mmap_length);
460 if (ret != 0)
461 BX_INFO(("failed to un-memory map sparse disk file"));
462 }
463 pagetable = NULL; // We didn't malloc it
464 #endif
465 if (fd > -1) {
466 ::close(fd);
467 }
468 if (pagetable != NULL)
469 {
470 delete [] pagetable;
471 }
472 if (parent_image != NULL)
473 {
474 delete parent_image;
475 }
476 }
477
478 Bit64s sparse_image_t::lseek(Bit64s offset, int whence)
479 {
480 //showpagetable(pagetable, header.numpages);
481
482 if ((offset % 512) != 0)
483 BX_PANIC(("lseek HD with offset not multiple of 512"));
484 if (whence != SEEK_SET)
485 BX_PANIC(("lseek HD with whence not SEEK_SET"));
486
487 BX_DEBUG(("sparse_image_t.lseek(%d)", whence));
488
489 if (offset > total_size)
490 {
491 BX_PANIC(("sparse_image_t.lseek to byte %ld failed", (long)offset));
492 return -1;
493 }
494
495 //printf("Seeking to position %ld\n", (long) offset);
496
497 set_virtual_page((Bit32u)(offset >> pagesize_shift));
498 position_page_offset = (Bit32u)(offset & pagesize_mask);
499
500 return 0;
501 }
502
503 inline Bit64s sparse_image_t::get_physical_offset()
504 {
505 Bit64s physical_offset = data_start;
506 physical_offset += ((Bit64s)position_physical_page << pagesize_shift);
507 physical_offset += position_page_offset;
508 return physical_offset;
509 }
510
511 void sparse_image_t::set_virtual_page(Bit32u new_virtual_page)
512 {
513 position_virtual_page = new_virtual_page;
514 position_physical_page = dtoh32(pagetable[position_virtual_page]);
515 }
516
517 ssize_t sparse_image_t::read_page_fragment(Bit32u read_virtual_page, Bit32u read_page_offset, size_t read_size, void * buf)
518 {
519 if (read_virtual_page != position_virtual_page)
520 {
521 set_virtual_page(read_virtual_page);
522 }
523
524 position_page_offset = read_page_offset;
525
526 if (position_physical_page == SPARSE_PAGE_NOT_ALLOCATED)
527 {
528 if (parent_image != NULL)
529 {
530 return parent_image->read_page_fragment(read_virtual_page, read_page_offset, read_size, buf);
531 }
532 else
533 {
534 memset(buf, 0, read_size);
535 }
536 }
537 else
538 {
539 Bit64s physical_offset = get_physical_offset();
540
541 if (physical_offset != underlying_current_filepos)
542 {
543 off_t ret = ::lseek(fd, (off_t)physical_offset, SEEK_SET);
544 // underlying_current_filepos update deferred
545 if (ret == -1)
546 panic(strerror(errno));
547 }
548
549 //printf("Reading %s at position %ld size %d\n", pathname, (long) physical_offset, (long) read_size);
550 ssize_t readret = ::read(fd, buf, read_size);
551
552 if (readret == -1)
553 {
554 panic(strerror(errno));
555 }
556
557 if ((size_t)readret != read_size)
558 {
559 panic("could not read block contents from file");
560 }
561
562 underlying_current_filepos = physical_offset + read_size;
563 }
564
565 return read_size;
566 }
567
568 ssize_t sparse_image_t::read(void* buf, size_t count)
569 {
570 //showpagetable(pagetable, header.numpages);
571 ssize_t total_read = 0;
572
573 if (bx_dbg.disk)
574 BX_DEBUG(("sparse_image_t.read %ld bytes", (long)count));
575
576 while (count != 0)
577 {
578 size_t can_read = pagesize - position_page_offset;
579 if (count < can_read) can_read = count;
580
581 BX_ASSERT (can_read != 0);
582
583 size_t was_read = read_page_fragment(position_virtual_page, position_page_offset, can_read, buf);
584
585 BX_ASSERT(was_read == can_read);
586
587 total_read += can_read;
588
589 position_page_offset += can_read;
590 if (position_page_offset == pagesize)
591 {
592 position_page_offset = 0;
593 set_virtual_page(position_virtual_page + 1);
594 }
595
596 BX_ASSERT(position_page_offset < pagesize);
597
598 buf = (((Bit8u *) buf) + can_read);
599 count -= can_read;
600 }
601
602 return total_read;
603 }
604
605 void sparse_image_t::panic(const char * message)
606 {
607 char buffer[1024];
608 if (message == NULL)
609 {
610 snprintf(buffer, sizeof(buffer), "error with sparse disk image %s", pathname);
611 }
612 else
613 {
614 snprintf(buffer, sizeof(buffer), "error with sparse disk image %s - %s", pathname, message);
615 }
616 BX_PANIC((buffer));
617 }
618
619 ssize_t sparse_image_t::write (const void* buf, size_t count)
620 {
621 //showpagetable(pagetable, header.numpages);
622
623 ssize_t total_written = 0;
624
625 Bit32u update_pagetable_start = position_virtual_page;
626 Bit32u update_pagetable_count = 0;
627
628 if (bx_dbg.disk)
629 BX_DEBUG(("sparse_image_t.write %ld bytes", (long)count));
630
631 while (count != 0)
632 {
633 size_t can_write = pagesize - position_page_offset;
634 if (count < can_write) can_write = count;
635
636 BX_ASSERT (can_write != 0);
637
638 if (position_physical_page == SPARSE_PAGE_NOT_ALLOCATED)
639 {
640 // We just add on another page at the end of the file
641 // Reclamation, compaction etc should currently be done off-line
642
643 Bit64s data_size = underlying_filesize - data_start;
644 BX_ASSERT((data_size % pagesize) == 0);
645
646 Bit32u data_size_pages = (Bit32u)(data_size / pagesize);
647 Bit32u next_data_page = data_size_pages;
648
649 pagetable[position_virtual_page] = htod32(next_data_page);
650 position_physical_page = next_data_page;
651
652 Bit64s page_file_start = data_start + ((Bit64s)position_physical_page << pagesize_shift);
653
654 if (parent_image != NULL)
655 {
656 // If we have a parent, we must merge our portion with the parent
657 void *writebuffer = NULL;
658
659 if (can_write == pagesize)
660 {
661 writebuffer = (void *) buf;
662 }
663 else
664 {
665 writebuffer = malloc(pagesize);
666 if (writebuffer == NULL)
667 panic("Cannot allocate sufficient memory for page-merge in write");
668
669 // Read entire page - could optimize, but simple for now
670 parent_image->read_page_fragment(position_virtual_page, 0, pagesize, writebuffer);
671
672 void *dest_start = ((Bit8u *) writebuffer) + position_page_offset;
673 memcpy(dest_start, buf, can_write);
674 }
675
676 int ret = (int)::lseek(fd, page_file_start, SEEK_SET);
677 // underlying_current_filepos update deferred
678 if (ret == -1) panic(strerror(errno));
679
680 ret = ::write(fd, writebuffer, pagesize);
681 if (ret == -1) panic(strerror(errno));
682
683 if (pagesize != (Bit32u)ret) panic("failed to write entire merged page to disk");
684
685 if (can_write != pagesize)
686 {
687 free(writebuffer);
688 }
689 }
690 else
691 {
692 // We need to write a zero page because read has been returning zeroes
693 // We seek as close to the page end as possible, and then write a little
694 // This produces a sparse file which has blanks
695 // Also very quick, even when pagesize is massive
696 int ret = (int)::lseek(fd, page_file_start + pagesize - 4, SEEK_SET);
697 // underlying_current_filepos update deferred
698 if (ret == -1) panic(strerror(errno));
699
700 Bit32u zero = 0;
701 ret = ::write(fd, &zero, 4);
702 if (ret == -1) panic(strerror(errno));
703
704 if (ret != 4) panic("failed to write entire blank page to disk");
705 }
706
707 update_pagetable_count = (position_virtual_page - update_pagetable_start) + 1;
708 underlying_filesize = underlying_current_filepos = page_file_start + pagesize;
709 }
710
711 BX_ASSERT(position_physical_page != SPARSE_PAGE_NOT_ALLOCATED);
712
713 Bit64s physical_offset = get_physical_offset();
714
715 if (physical_offset != underlying_current_filepos)
716 {
717 off_t ret = ::lseek(fd, (off_t)physical_offset, SEEK_SET);
718 // underlying_current_filepos update deferred
719 if (ret == -1)
720 panic(strerror(errno));
721 }
722
723 //printf("Writing at position %ld size %d\n", (long) physical_offset, can_write);
724 ssize_t writeret = ::write(fd, buf, can_write);
725
726 if (writeret == -1)
727 {
728 panic(strerror(errno));
729 }
730
731 if ((size_t)writeret != can_write)
732 {
733 panic("could not write block contents to file");
734 }
735
736 underlying_current_filepos = physical_offset + can_write;
737
738 total_written += can_write;
739
740 position_page_offset += can_write;
741 if (position_page_offset == pagesize)
742 {
743 position_page_offset = 0;
744 set_virtual_page(position_virtual_page + 1);
745 }
746
747 BX_ASSERT(position_page_offset < pagesize);
748
749 buf = (((Bit8u *) buf) + can_write);
750 count -= can_write;
751 }
752
753 if (update_pagetable_count != 0)
754 {
755 bx_bool done = 0;
756 off_t pagetable_write_from = sizeof(header) + (sizeof(Bit32u) * update_pagetable_start);
757 size_t write_bytecount = update_pagetable_count * sizeof(Bit32u);
758
759 #ifdef _POSIX_MAPPED_FILES
760 if (mmap_header != NULL)
761 {
762 // Sync from the beginning of the page
763 size_t system_page_offset = pagetable_write_from & system_pagesize_mask;
764 void *start = ((Bit8u *) mmap_header + pagetable_write_from - system_page_offset);
765
766 int ret = msync(start, system_page_offset + write_bytecount, MS_ASYNC);
767
768 if (ret != 0)
769 panic(strerror(errno));
770
771 done = 1;
772 }
773 #endif
774
775 if (!done)
776 {
777 int ret = (int)::lseek(fd, pagetable_write_from, SEEK_SET);
778 // underlying_current_filepos update deferred
779 if (ret == -1) panic(strerror(errno));
780
781 //printf("Writing header at position %ld size %ld\n", (long) pagetable_write_from, (long) write_bytecount);
782 ret = ::write(fd, &pagetable[update_pagetable_start], write_bytecount);
783 if (ret == -1) panic(strerror(errno));
784 if ((size_t)ret != write_bytecount) panic("could not write entire updated block header");
785
786 underlying_current_filepos = pagetable_write_from + write_bytecount;
787 }
788 }
789
790 return total_written;
791 }
792
793 #if DLL_HD_SUPPORT
794
795 /*** dll_image_t function definitions ***/
796
797 /*
798 function vdisk_open(path:PChar;numclusters,clustersize:integer):integer;
799 procedure vdisk_read(vunit:integer;blk:integer;var buf:TBlock);
800 procedure vdisk_write(vunit:integer;blk:integer;var buf:TBlock);
801 procedure vdisk_close(vunit:integer);
802 */
803
804 HINSTANCE hlib_vdisk = 0;
805
806 int (*vdisk_open) (const char *path,int numclusters,int clustersize);
807 void (*vdisk_read) (int vunit,int blk,void *buf);
808 void (*vdisk_write) (int vunit,int blk,const void *buf);
809 void (*vdisk_close) (int vunit);
810
811 int dll_image_t::open (const char* pathname)
812 {
813 if (hlib_vdisk == 0) {
814 hlib_vdisk = LoadLibrary("vdisk.dll");
815 if (hlib_vdisk != 0) {
816 vdisk_read = (void (*)(int,int,void*)) GetProcAddress(hlib_vdisk,"vdisk_read");
817 vdisk_write = (void (*)(int,int,const void*)) GetProcAddress(hlib_vdisk,"vdisk_write");
818 vdisk_open = (int (*)(const char *,int,int)) GetProcAddress(hlib_vdisk,"vdisk_open");
819 vdisk_close = (void (*)(int)) GetProcAddress(hlib_vdisk,"vdisk_close");
820 }
821 }
822 if (hlib_vdisk != 0) {
823 vunit = vdisk_open(pathname,0x10000,64);
824 vblk = 0;
825 } else {
826 vunit = -2;
827 }
828 return vunit;
829 }
830
831 void dll_image_t::close ()
832 {
833 if (vunit >= 0 && hlib_vdisk != 0) {
834 vdisk_close(vunit);
835 }
836 }
837
838 Bit64s dll_image_t::lseek(Bit64s offset, int whence)
839 {
840 vblk = (int)(offset >> 9);
841 return 0;
842 }
843
844 ssize_t dll_image_t::read (void* buf, size_t count)
845 {
846 if (vunit >= 0 && hlib_vdisk != 0) {
847 vdisk_read(vunit,vblk,buf);
848 return count;
849 } else {
850 return -1;
851 }
852 }
853
854 ssize_t dll_image_t::write (const void* buf, size_t count)
855 {
856 if (vunit >= 0 && hlib_vdisk != 0) {
857 vdisk_write(vunit,vblk,buf);
858 return count;
859 } else {
860 return -1;
861 }
862 }
863 #endif // DLL_HD_SUPPORT
864
865 // redolog implementation
866 redolog_t::redolog_t()
867 {
868 fd = -1;
869 catalog = NULL;
870 bitmap = NULL;
871 extent_index = (Bit32u)0;
872 extent_offset = (Bit32u)0;
873 extent_next = (Bit32u)0;
874 }
875
876 void redolog_t::print_header()
877 {
878 BX_INFO(("redolog : Standard Header : magic='%s', type='%s', subtype='%s', version = %d.%d",
879 header.standard.magic, header.standard.type, header.standard.subtype,
880 dtoh32(header.standard.version)/0x10000,
881 dtoh32(header.standard.version)%0x10000));
882 if (dtoh32(header.standard.version) == STANDARD_HEADER_VERSION) {
883 BX_INFO(("redolog : Specific Header : #entries=%d, bitmap size=%d, exent size = %d disk size = " FMT_LL "d",
884 dtoh32(header.specific.catalog),
885 dtoh32(header.specific.bitmap),
886 dtoh32(header.specific.extent),
887 dtoh64(header.specific.disk)));
888 } else if (dtoh32(header.standard.version) == STANDARD_HEADER_V1) {
889 redolog_header_v1_t header_v1;
890 memcpy(&header_v1, &header, STANDARD_HEADER_SIZE);
891 BX_INFO(("redolog : Specific Header : #entries=%d, bitmap size=%d, exent size = %d disk size = " FMT_LL "d",
892 dtoh32(header_v1.specific.catalog),
893 dtoh32(header_v1.specific.bitmap),
894 dtoh32(header_v1.specific.extent),
895 dtoh64(header_v1.specific.disk)));
896 }
897 }
898
899 int redolog_t::make_header(const char* type, Bit64u size)
900 {
901 Bit32u entries, extent_size, bitmap_size;
902 Bit64u maxsize;
903 Bit32u flip=0;
904
905 // Set standard header values
906 strcpy((char*)header.standard.magic, STANDARD_HEADER_MAGIC);
907 strcpy((char*)header.standard.type, REDOLOG_TYPE);
908 strcpy((char*)header.standard.subtype, type);
909 header.standard.version = htod32(STANDARD_HEADER_VERSION);
910 header.standard.header = htod32(STANDARD_HEADER_SIZE);
911
912 entries = 512;
913 bitmap_size = 1;
914
915 // Compute #entries and extent size values
916 do {
917 extent_size = 8 * bitmap_size * 512;
918
919 header.specific.catalog = htod32(entries);
920 header.specific.bitmap = htod32(bitmap_size);
921 header.specific.extent = htod32(extent_size);
922
923 maxsize = (Bit64u)entries * (Bit64u)extent_size;
924
925 flip++;
926
927 if(flip&0x01) bitmap_size *= 2;
928 else entries *= 2;
929 } while (maxsize < size);
930
931 header.specific.disk = htod64(size);
932
933 print_header();
934
935 catalog = (Bit32u*)malloc(dtoh32(header.specific.catalog) * sizeof(Bit32u));
936 bitmap = (Bit8u*)malloc(dtoh32(header.specific.bitmap));
937
938 if ((catalog == NULL) || (bitmap==NULL))
939 BX_PANIC(("redolog : could not malloc catalog or bitmap"));
940
941 for (Bit32u i=0; i<dtoh32(header.specific.catalog); i++)
942 catalog[i] = htod32(REDOLOG_PAGE_NOT_ALLOCATED);
943
944 bitmap_blocs = 1 + (dtoh32(header.specific.bitmap) - 1) / 512;
945 extent_blocs = 1 + (dtoh32(header.specific.extent) - 1) / 512;
946
947 BX_DEBUG(("redolog : each bitmap is %d blocs", bitmap_blocs));
948 BX_DEBUG(("redolog : each extent is %d blocs", extent_blocs));
949
950 return 0;
951 }
952
953 int redolog_t::create(const char* filename, const char* type, Bit64u size)
954 {
955 BX_INFO(("redolog : creating redolog %s", filename));
956
957 int filedes = ::open(filename, O_RDWR | O_CREAT | O_TRUNC
958 #ifdef O_BINARY
959 | O_BINARY
960 #endif
961 , S_IWUSR | S_IRUSR | S_IRGRP | S_IWGRP);
962
963 return create(filedes, type, size);
964 }
965
966 int redolog_t::create(int filedes, const char* type, Bit64u size)
967 {
968 fd = filedes;
969
970 if (fd < 0)
971 {
972 return -1; // open failed
973 }
974
975 if (make_header(type, size) < 0)
976 {
977 return -1;
978 }
979
980 // Write header
981 ::write(fd, &header, dtoh32(header.standard.header));
982
983 // Write catalog
984 // FIXME could mmap
985 ::write(fd, catalog, dtoh32(header.specific.catalog) * sizeof (Bit32u));
986
987 return 0;
988 }
989
990 int redolog_t::open(const char* filename, const char *type)
991 {
992 fd = ::open(filename, O_RDWR
993 #ifdef O_BINARY
994 | O_BINARY
995 #endif
996 );
997 if (fd < 0)
998 {
999 BX_INFO(("redolog : could not open image %s", filename));
1000 // open failed.
1001 return -1;
1002 }
1003 BX_INFO(("redolog : open image %s", filename));
1004
1005 int res = ::read(fd, &header, sizeof(header));
1006 if (res != STANDARD_HEADER_SIZE)
1007 {
1008 BX_PANIC(("redolog : could not read header"));
1009 return -1;
1010 }
1011
1012 print_header();
1013
1014 if (strcmp((char*)header.standard.magic, STANDARD_HEADER_MAGIC) != 0)
1015 {
1016 BX_PANIC(("redolog : Bad header magic"));
1017 return -1;
1018 }
1019
1020 if (strcmp((char*)header.standard.type, REDOLOG_TYPE) != 0)
1021 {
1022 BX_PANIC(("redolog : Bad header type"));
1023 return -1;
1024 }
1025 if (strcmp((char*)header.standard.subtype, type) != 0)
1026 {
1027 BX_PANIC(("redolog : Bad header subtype"));
1028 return -1;
1029 }
1030
1031 if ((dtoh32(header.standard.version) != STANDARD_HEADER_VERSION) &&
1032 (dtoh32(header.standard.version) != STANDARD_HEADER_V1))
1033 {
1034 BX_PANIC(("redolog : Bad header version"));
1035 return -1;
1036 }
1037
1038 if (dtoh32(header.standard.version) == STANDARD_HEADER_V1) {
1039 redolog_header_v1_t header_v1;
1040
1041 memcpy(&header_v1, &header, STANDARD_HEADER_SIZE);
1042 header.specific.disk = header_v1.specific.disk;
1043 }
1044
1045 catalog = (Bit32u*)malloc(dtoh32(header.specific.catalog) * sizeof(Bit32u));
1046
1047 // FIXME could mmap
1048 ::lseek(fd,dtoh32(header.standard.header),SEEK_SET);
1049 res = ::read(fd, catalog, dtoh32(header.specific.catalog) * sizeof(Bit32u));
1050
1051 if (res != (ssize_t)(dtoh32(header.specific.catalog) * sizeof(Bit32u)))
1052 {
1053 BX_PANIC(("redolog : could not read catalog %d=%d",res, dtoh32(header.specific.catalog)));
1054 return -1;
1055 }
1056
1057 // check last used extent
1058 extent_next = 0;
1059 for (Bit32u i=0; i < dtoh32(header.specific.catalog); i++)
1060 {
1061 if (dtoh32(catalog[i]) != REDOLOG_PAGE_NOT_ALLOCATED)
1062 {
1063 if (dtoh32(catalog[i]) >= extent_next)
1064 extent_next = dtoh32(catalog[i]) + 1;
1065 }
1066 }
1067 BX_INFO(("redolog : next extent will be at index %d",extent_next));
1068
1069 // memory used for storing bitmaps
1070 bitmap = (Bit8u *)malloc(dtoh32(header.specific.bitmap));
1071
1072 bitmap_blocs = 1 + (dtoh32(header.specific.bitmap) - 1) / 512;
1073 extent_blocs = 1 + (dtoh32(header.specific.extent) - 1) / 512;
1074
1075 BX_DEBUG(("redolog : each bitmap is %d blocs", bitmap_blocs));
1076 BX_DEBUG(("redolog : each extent is %d blocs", extent_blocs));
1077
1078 return 0;
1079 }
1080
1081 void redolog_t::close()
1082 {
1083 if (fd >= 0)
1084 ::close(fd);
1085
1086 if (catalog != NULL)
1087 free(catalog);
1088
1089 if (bitmap != NULL)
1090 free(bitmap);
1091 }
1092
1093 Bit64u redolog_t::get_size()
1094 {
1095 return dtoh64(header.specific.disk);
1096 }
1097
1098 Bit64s redolog_t::lseek(Bit64s offset, int whence)
1099 {
1100 if ((offset % 512) != 0) {
1101 BX_PANIC(("redolog : lseek HD with offset not multiple of 512"));
1102 return -1;
1103 }
1104 if (whence != SEEK_SET) {
1105 BX_PANIC(("redolog : lseek HD with whence not SEEK_SET"));
1106 return -1;
1107 }
1108 if (offset > (Bit64s)dtoh64(header.specific.disk))
1109 {
1110 BX_PANIC(("redolog : lseek to byte %ld failed", (long)offset));
1111 return -1;
1112 }
1113
1114 extent_index = (Bit32u)(offset / dtoh32(header.specific.extent));
1115 extent_offset = (Bit32u)((offset % dtoh32(header.specific.extent)) / 512);
1116
1117 BX_DEBUG(("redolog : lseeking extent index %d, offset %d",extent_index, extent_offset));
1118
1119 return offset;
1120 }
1121
1122 ssize_t redolog_t::read(void* buf, size_t count)
1123 {
1124 Bit64s bloc_offset, bitmap_offset;
1125
1126 if (count != 512)
1127 BX_PANIC(("redolog : read HD with count not 512"));
1128
1129 BX_DEBUG(("redolog : reading index %d, mapping to %d", extent_index, dtoh32(catalog[extent_index])));
1130
1131 if (dtoh32(catalog[extent_index]) == REDOLOG_PAGE_NOT_ALLOCATED)
1132 {
1133 // page not allocated
1134 return 0;
1135 }
1136
1137 bitmap_offset = (Bit64s)STANDARD_HEADER_SIZE + (dtoh32(header.specific.catalog) * sizeof(Bit32u));
1138 bitmap_offset += (Bit64s)512 * dtoh32(catalog[extent_index]) * (extent_blocs + bitmap_blocs);
1139 bloc_offset = bitmap_offset + ((Bit64s)512 * (bitmap_blocs + extent_offset));
1140
1141 BX_DEBUG(("redolog : bitmap offset is %x", (Bit32u)bitmap_offset));
1142 BX_DEBUG(("redolog : bloc offset is %x", (Bit32u)bloc_offset));
1143
1144 // FIXME if same extent_index as before we can skip bitmap read
1145
1146 ::lseek(fd, (off_t)bitmap_offset, SEEK_SET);
1147
1148 if (::read(fd, bitmap, dtoh32(header.specific.bitmap)) != (ssize_t)dtoh32(header.specific.bitmap))
1149 {
1150 BX_PANIC(("redolog : failed to read bitmap for extent %d", extent_index));
1151 return 0;
1152 }
1153
1154 if (((bitmap[extent_offset/8] >> (extent_offset%8)) & 0x01) == 0x00)
1155 {
1156 BX_DEBUG(("read not in redolog"));
1157
1158 // bitmap says bloc not in reloglog
1159 return 0;
1160 }
1161
1162 ::lseek(fd, (off_t)bloc_offset, SEEK_SET);
1163
1164 return (::read(fd, buf, count));
1165 }
1166
1167 ssize_t redolog_t::write(const void* buf, size_t count)
1168 {
1169 Bit32u i;
1170 Bit64s bloc_offset, bitmap_offset, catalog_offset;
1171 ssize_t written;
1172 bx_bool update_catalog = 0;
1173
1174 if (count != 512)
1175 BX_PANIC(("redolog : write HD with count not 512"));
1176
1177 BX_DEBUG(("redolog : writing index %d, mapping to %d", extent_index, dtoh32(catalog[extent_index])));
1178 if (dtoh32(catalog[extent_index]) == REDOLOG_PAGE_NOT_ALLOCATED)
1179 {
1180 if (extent_next >= dtoh32(header.specific.catalog))
1181 {
1182 BX_PANIC(("redolog : can't allocate new extent... catalog is full"));
1183 return 0;
1184 }
1185
1186 BX_DEBUG(("redolog : allocating new extent at %d", extent_next));
1187
1188 // Extent not allocated, allocate new
1189 catalog[extent_index] = htod32(extent_next);
1190
1191 extent_next += 1;
1192
1193 char *zerobuffer = (char*)malloc(512);
1194 memset(zerobuffer, 0, 512);
1195
1196 // Write bitmap
1197 bitmap_offset = (Bit64s)STANDARD_HEADER_SIZE + (dtoh32(header.specific.catalog) * sizeof(Bit32u));
1198 bitmap_offset += (Bit64s)512 * dtoh32(catalog[extent_index]) * (extent_blocs + bitmap_blocs);
1199 ::lseek(fd, (off_t)bitmap_offset, SEEK_SET);
1200 for (i=0; i<bitmap_blocs; i++)
1201 {
1202 ::write(fd, zerobuffer, 512);
1203 }
1204 // Write extent
1205 for (i=0; i<extent_blocs; i++)
1206 {
1207 ::write(fd, zerobuffer, 512);
1208 }
1209
1210 free(zerobuffer);
1211
1212 update_catalog = 1;
1213 }
1214
1215 bitmap_offset = (Bit64s)STANDARD_HEADER_SIZE + (dtoh32(header.specific.catalog) * sizeof(Bit32u));
1216 bitmap_offset += (Bit64s)512 * dtoh32(catalog[extent_index]) * (extent_blocs + bitmap_blocs);
1217 bloc_offset = bitmap_offset + ((Bit64s)512 * (bitmap_blocs + extent_offset));
1218
1219 BX_DEBUG(("redolog : bitmap offset is %x", (Bit32u)bitmap_offset));
1220 BX_DEBUG(("redolog : bloc offset is %x", (Bit32u)bloc_offset));
1221
1222 // Write bloc
1223 ::lseek(fd, (off_t)bloc_offset, SEEK_SET);
1224 written = ::write(fd, buf, count);
1225
1226 // Write bitmap
1227 // FIXME if same extent_index as before we can skip bitmap read
1228 ::lseek(fd, (off_t)bitmap_offset, SEEK_SET);
1229 if (::read(fd, bitmap, dtoh32(header.specific.bitmap)) != (ssize_t)dtoh32(header.specific.bitmap))
1230 {
1231 BX_PANIC(("redolog : failed to read bitmap for extent %d", extent_index));
1232 return 0;
1233 }
1234
1235 // If bloc does not belong to extent yet
1236 if (((bitmap[extent_offset/8] >> (extent_offset%8)) & 0x01) == 0x00)
1237 {
1238 bitmap[extent_offset/8] |= 1 << (extent_offset%8);
1239 ::lseek(fd, (off_t)bitmap_offset, SEEK_SET);
1240 ::write(fd, bitmap, dtoh32(header.specific.bitmap));
1241 }
1242
1243 // Write catalog
1244 if (update_catalog)
1245 {
1246 // FIXME if mmap
1247 catalog_offset = (Bit64s)STANDARD_HEADER_SIZE + (extent_index * sizeof(Bit32u));
1248
1249 BX_DEBUG(("redolog : writing catalog at offset %x", (Bit32u)catalog_offset));
1250
1251 ::lseek(fd, (off_t)catalog_offset, SEEK_SET);
1252 ::write(fd, &catalog[extent_index], sizeof(Bit32u));
1253 }
1254
1255 return written;
1256 }
1257
1258 /*** growing_image_t function definitions ***/
1259
1260 growing_image_t::growing_image_t()
1261 {
1262 redolog = new redolog_t();
1263 }
1264
1265 growing_image_t::~growing_image_t()
1266 {
1267 delete redolog;
1268 }
1269
1270 int growing_image_t::open(const char* pathname)
1271 {
1272 int filedes = redolog->open(pathname, REDOLOG_SUBTYPE_GROWING);
1273 hd_size = redolog->get_size();
1274 BX_INFO(("'growing' disk opened, growing file is '%s'", pathname));
1275 return filedes;
1276 }
1277
1278 void growing_image_t::close()
1279 {
1280 redolog->close();
1281 }
1282
1283 Bit64s growing_image_t::lseek(Bit64s offset, int whence)
1284 {
1285 return redolog->lseek(offset, whence);
1286 }
1287
1288 ssize_t growing_image_t::read(void* buf, size_t count)
1289 {
1290 memset(buf, 0, count);
1291 redolog->read((char*) buf, count);
1292 return count;
1293 }
1294
1295 ssize_t growing_image_t::write(const void* buf, size_t count)
1296 {
1297 return redolog->write((char*) buf, count);
1298 }
1299
1300 /*** undoable_image_t function definitions ***/
1301
1302 undoable_image_t::undoable_image_t(const char* _redolog_name)
1303 {
1304 redolog = new redolog_t();
1305 ro_disk = new default_image_t();
1306 redolog_name = NULL;
1307 if (_redolog_name != NULL) {
1308 if (strcmp(_redolog_name,"") != 0) {
1309 redolog_name = strdup(_redolog_name);
1310 }
1311 }
1312 }
1313
1314 undoable_image_t::~undoable_image_t()
1315 {
1316 delete redolog;
1317 delete ro_disk;
1318 }
1319
1320 int undoable_image_t::open(const char* pathname)
1321 {
1322 char *logname=NULL;
1323
1324 if (ro_disk->open(pathname, O_RDONLY)<0)
1325 return -1;
1326
1327 hd_size = ro_disk->hd_size;
1328 // if redolog name was set
1329 if (redolog_name != NULL) {
1330 if (strcmp(redolog_name, "") != 0) {
1331 logname = (char*)malloc(strlen(redolog_name) + 1);
1332 strcpy(logname, redolog_name);
1333 }
1334 }
1335
1336 // Otherwise we make up the redolog filename from the pathname
1337 if (logname == NULL) {
1338 logname = (char*)malloc(strlen(pathname) + UNDOABLE_REDOLOG_EXTENSION_LENGTH + 1);
1339 sprintf(logname, "%s%s", pathname, UNDOABLE_REDOLOG_EXTENSION);
1340 }
1341
1342 if (redolog->open(logname,REDOLOG_SUBTYPE_UNDOABLE) < 0)
1343 {
1344 if (redolog->create(logname, REDOLOG_SUBTYPE_UNDOABLE, hd_size) < 0)
1345 {
1346 BX_PANIC(("Can't open or create redolog '%s'",logname));
1347 return -1;
1348 }
1349 if (hd_size != redolog->get_size())
1350 {
1351 BX_PANIC(("size reported by redolog doesn't match r/o disk size"));
1352 free(logname);
1353 return -1;
1354 }
1355 }
1356
1357 BX_INFO(("'undoable' disk opened: ro-file is '%s', redolog is '%s'", pathname, logname));
1358 free(logname);
1359
1360 return 0;
1361 }
1362
1363 void undoable_image_t::close ()
1364 {
1365 redolog->close();
1366 ro_disk->close();
1367
1368 if (redolog_name!=NULL)
1369 free(redolog_name);
1370 }
1371
1372 Bit64s undoable_image_t::lseek(Bit64s offset, int whence)
1373 {
1374 redolog->lseek(offset, whence);
1375 return ro_disk->lseek(offset, whence);
1376 }
1377
1378 ssize_t undoable_image_t::read(void* buf, size_t count)
1379 {
1380 // This should be fixed if count != 512
1381 if ((size_t)redolog->read((char*) buf, count) != count)
1382 return ro_disk->read((char*) buf, count);
1383 else
1384 return count;
1385 }
1386
1387 ssize_t undoable_image_t::write(const void* buf, size_t count)
1388 {
1389 return redolog->write((char*) buf, count);
1390 }
1391
1392 /*** volatile_image_t function definitions ***/
1393
1394 volatile_image_t::volatile_image_t(const char* _redolog_name)
1395 {
1396 redolog = new redolog_t();
1397 ro_disk = new default_image_t();
1398 redolog_temp = NULL;
1399 redolog_name = NULL;
1400 if (_redolog_name != NULL) {
1401 if (strcmp(_redolog_name,"") != 0) {
1402 redolog_name = strdup(_redolog_name);
1403 }
1404 }
1405 }
1406
1407 volatile_image_t::~volatile_image_t()
1408 {
1409 delete redolog;
1410 delete ro_disk;
1411 }
1412
1413 int volatile_image_t::open(const char* pathname)
1414 {
1415 int filedes;
1416 const char *logname=NULL;
1417
1418 if (ro_disk->open(pathname, O_RDONLY)<0)
1419 return -1;
1420
1421 hd_size = ro_disk->hd_size;
1422 // if redolog name was set
1423 if (redolog_name != NULL) {
1424 if (strcmp(redolog_name, "") != 0) {
1425 logname = redolog_name;
1426 }
1427 }
1428
1429 // otherwise use pathname as template
1430 if (logname == NULL) {
1431 logname = pathname;
1432 }
1433
1434 redolog_temp = (char*)malloc(strlen(logname) + VOLATILE_REDOLOG_EXTENSION_LENGTH + 1);
1435 sprintf (redolog_temp, "%s%s", logname, VOLATILE_REDOLOG_EXTENSION);
1436
1437 filedes = mkstemp (redolog_temp);
1438
1439 if (filedes < 0)
1440 {
1441 BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
1442 return -1;
1443 }
1444 if (redolog->create(filedes, REDOLOG_SUBTYPE_VOLATILE, hd_size) < 0)
1445 {
1446 BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
1447 return -1;
1448 }
1449
1450 #if (!defined(WIN32)) && !BX_WITH_MACOS
1451 // on unix it is legal to delete an open file
1452 unlink(redolog_temp);
1453 #endif
1454
1455 BX_INFO(("'volatile' disk opened: ro-file is '%s', redolog is '%s'", pathname, redolog_temp));
1456
1457 return 0;
1458 }
1459
1460 void volatile_image_t::close()
1461 {
1462 redolog->close();
1463 ro_disk->close();
1464
1465 #if defined(WIN32) || BX_WITH_MACOS
1466 // on non-unix we have to wait till the file is closed to delete it
1467 unlink(redolog_temp);
1468 #endif
1469 if (redolog_temp!=NULL)
1470 free(redolog_temp);
1471
1472 if (redolog_name!=NULL)
1473 free(redolog_name);
1474 }
1475
1476 Bit64s volatile_image_t::lseek(Bit64s offset, int whence)
1477 {
1478 redolog->lseek(offset, whence);
1479 return ro_disk->lseek(offset, whence);
1480 }
1481
1482 ssize_t volatile_image_t::read(void* buf, size_t count)
1483 {
1484 // This should be fixed if count != 512
1485 if ((size_t)redolog->read((char*) buf, count) != count)
1486 return ro_disk->read((char*) buf, count);
1487 else
1488 return count;
1489 }
1490
1491 ssize_t volatile_image_t::write(const void* buf, size_t count)
1492 {
1493 return redolog->write((char*) buf, count);
1494 }
1495
1496 #if BX_COMPRESSED_HD_SUPPORT
1497
1498 /*** z_ro_image_t function definitions ***/
1499
1500 z_ro_image_t::z_ro_image_t()
1501 {
1502 offset = (Bit64s)0;
1503 }
1504
1505 int z_ro_image_t::open(const char* pathname)
1506 {
1507 fd = ::open(pathname, O_RDONLY
1508 #ifdef O_BINARY
1509 | O_BINARY
1510 #endif
1511 );
1512
1513 if (fd < 0)
1514 {
1515 BX_PANIC(("Could not open '%s' file", pathname));
1516 return fd;
1517 }
1518
1519 gzfile = gzdopen(fd, "rb");
1520 return 0;
1521 }
1522
1523 void z_ro_image_t::close()
1524 {
1525 if (fd > -1) {
1526 gzclose(gzfile);
1527 // ::close(fd);
1528 }
1529 }
1530
1531 Bit64s z_ro_image_t::lseek(Bit64s _offset, int whence)
1532 {
1533 // Only SEEK_SET supported
1534 if (whence != SEEK_SET)
1535 {
1536 BX_PANIC(("lseek on compressed images : only SEEK_SET supported"));
1537 }
1538
1539 // Seeking is expensive on compressed files, so we do it
1540 // only when necessary, at the latest moment
1541 offset = _offset;
1542
1543 return offset;
1544 }
1545
1546 ssize_t z_ro_image_t::read(void* buf, size_t count)
1547 {
1548 gzseek(gzfile, offset, SEEK_SET);
1549 return gzread(gzfile, buf, count);
1550 }
1551
1552 ssize_t z_ro_image_t::write(const void* buf, size_t count)
1553 {
1554 BX_PANIC(("z_ro_image: write not supported"));
1555 return 0;
1556 }
1557
1558
1559 /*** z_undoable_image_t function definitions ***/
1560
1561 z_undoable_image_t::z_undoable_image_t(Bit64u _size, const char* _redolog_name)
1562 {
1563 redolog = new redolog_t();
1564 ro_disk = new z_ro_image_t();
1565 size = _size;
1566
1567 redolog_name = NULL;
1568 if (_redolog_name != NULL) {
1569 if (strcmp(_redolog_name,"") != 0) {
1570 redolog_name = strdup(_redolog_name);
1571 }
1572 }
1573 }
1574
1575 z_undoable_image_t::~z_undoable_image_t()
1576 {
1577 delete redolog;
1578 delete ro_disk;
1579 }
1580
1581 int z_undoable_image_t::open(const char* pathname)
1582 {
1583 char *logname=NULL;
1584
1585 if (ro_disk->open(pathname)<0)
1586 return -1;
1587
1588 // If redolog name was set
1589 if (redolog_name != NULL) {
1590 if (strcmp(redolog_name, "") != 0) {
1591 logname = (char*)malloc(strlen(redolog_name) + 1);
1592 strcpy (logname, redolog_name);
1593 }
1594 }
1595
1596 // Otherwise we make up the redolog filename from the pathname
1597 if (logname == NULL) {
1598 logname = (char*)malloc(strlen(pathname) + UNDOABLE_REDOLOG_EXTENSION_LENGTH + 1);
1599 sprintf (logname, "%s%s", pathname, UNDOABLE_REDOLOG_EXTENSION);
1600 }
1601
1602 if (redolog->open(logname, REDOLOG_SUBTYPE_UNDOABLE) < 0)
1603 {
1604 if (redolog->create(logname, REDOLOG_SUBTYPE_UNDOABLE, size) < 0)
1605 {
1606 BX_PANIC(("Can't open or create redolog '%s'",logname));
1607 return -1;
1608 }
1609 }
1610
1611 BX_INFO(("'z-undoable' disk opened, z-ro-file is '%s', redolog is '%s'", pathname, logname));
1612 free(logname);
1613
1614 return 0;
1615 }
1616
1617 void z_undoable_image_t::close()
1618 {
1619 redolog->close();
1620 ro_disk->close();
1621
1622 if (redolog_name!=NULL)
1623 free(redolog_name);
1624 }
1625
1626 Bit64s z_undoable_image_t::lseek(Bit64s offset, int whence)
1627 {
1628 redolog->lseek(offset, whence);
1629 return ro_disk->lseek(offset, whence);
1630 }
1631
1632 ssize_t z_undoable_image_t::read(void* buf, size_t count)
1633 {
1634 // This should be fixed if count != 512
1635 if (redolog->read((char*) buf, count) != count)
1636 return ro_disk->read((char*) buf, count);
1637 else
1638 return count;
1639 }
1640
1641 ssize_t z_undoable_image_t::write(const void* buf, size_t count)
1642 {
1643 return redolog->write((char*) buf, count);
1644 }
1645
1646
1647 /*** z_volatile_image_t function definitions ***/
1648
1649 z_volatile_image_t::z_volatile_image_t(Bit64u _size, const char* _redolog_name)
1650 {
1651 redolog = new redolog_t();
1652 ro_disk = new z_ro_image_t();
1653 size = _size;
1654
1655 redolog_temp = NULL;
1656 redolog_name = NULL;
1657 if (_redolog_name != NULL) {
1658 if (strcmp(_redolog_name,"") != 0) {
1659 redolog_name = strdup(_redolog_name);
1660 }
1661 }
1662 }
1663
1664 z_volatile_image_t::~z_volatile_image_t()
1665 {
1666 delete redolog;
1667 delete ro_disk;
1668 }
1669
1670 int z_volatile_image_t::open(const char* pathname)
1671 {
1672 int filedes;
1673 const char *logname=NULL;
1674
1675 if (ro_disk->open(pathname)<0)
1676 return -1;
1677
1678 // if redolog name was set
1679 if (redolog_name != NULL) {
1680 if (strcmp(redolog_name, "") != 0) {
1681 logname = redolog_name;
1682 }
1683 }
1684
1685 // otherwise use pathname as template
1686 if (logname == NULL) {
1687 logname = pathname;
1688 }
1689
1690 redolog_temp = (char*)malloc(strlen(logname) + VOLATILE_REDOLOG_EXTENSION_LENGTH + 1);
1691 sprintf (redolog_temp, "%s%s", logname, VOLATILE_REDOLOG_EXTENSION);
1692
1693 filedes = mkstemp (redolog_temp);
1694
1695 if (filedes < 0)
1696 {
1697 BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
1698 return -1;
1699 }
1700 if (redolog->create(filedes, REDOLOG_SUBTYPE_VOLATILE, size) < 0)
1701 {
1702 BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
1703 return -1;
1704 }
1705
1706 #if (!defined(WIN32)) && !BX_WITH_MACOS
1707 // on unix it is legal to delete an open file
1708 unlink(redolog_temp);
1709 #endif
1710
1711 BX_INFO(("'z-volatile' disk opened: z-ro-file is '%s', redolog is '%s'", pathname, redolog_temp));
1712
1713 return 0;
1714 }
1715
1716 void z_volatile_image_t::close ()
1717 {
1718 redolog->close();
1719 ro_disk->close();
1720
1721 #if defined(WIN32) || BX_WITH_MACOS
1722 // on non-unix we have to wait till the file is closed to delete it
1723 unlink(redolog_temp);
1724 #endif
1725
1726 if (redolog_temp!=NULL)
1727 free(redolog_temp);
1728
1729 if (redolog_name!=NULL)
1730 free(redolog_name);
1731 }
1732
1733 Bit64s z_volatile_image_t::lseek(Bit64s offset, int whence)
1734 {
1735 redolog->lseek(offset, whence);
1736 return ro_disk->lseek(offset, whence);
1737 }
1738
1739 ssize_t z_volatile_image_t::read (void* buf, size_t count)
1740 {
1741 // This should be fixed if count != 512
1742 if (redolog->read((char*) buf, count) != count)
1743 return ro_disk->read((char*) buf, count);
1744 else
1745 return count;
1746 }
1747
1748 ssize_t z_volatile_image_t::write (const void* buf, size_t count)
1749 {
1750 return redolog->write((char*) buf, count);
1751 }
1752
1753 #endif
Mirror of Bochs CVS