iodev/hdimage.cc

   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