mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- splitted image headers from hard drive header (TODO: split emulation and image

Browse Source 
code for non-IDE interfaces)
- fixed bximage error messages
This commit is contained in:
Volker Ruppert 2005-11-06 11:07:01 +00:00
parent 93355486d2
commit 3c4b32f9a4
6 changed files with 576 additions and 543 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
bochs/iodev/harddrv.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: harddrv.cc,v 1.151 2005-11-06 08:21:38 vruppert Exp $
// $Id: harddrv.cc,v 1.152 2005-11-06 11:07:01 vruppert Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -36,6 +36,7 @@
#define BX_PLUGGABLE
#include "iodev.h"
#include "hdimage.h"
#include "vmware3.h"
#include "cdrom.h"
@ -149,7 +150,7 @@ bx_hard_drive_c::init(void)
char string[5];
char sbtext[8];
BX_DEBUG(("Init $Id: harddrv.cc,v 1.151 2005-11-06 08:21:38 vruppert Exp $"));
BX_DEBUG(("Init $Id: harddrv.cc,v 1.152 2005-11-06 11:07:01 vruppert Exp $"));
for (channel=0; channel<BX_MAX_ATA_CHANNEL; channel++) {
if (bx_options.ata[channel].Opresent->get() == 1) {

532
bochs/iodev/harddrv.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: harddrv.h,v 1.36 2005-11-06 08:21:38 vruppert Exp $
// $Id: harddrv.h,v 1.37 2005-11-06 11:07:01 vruppert Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -24,84 +24,6 @@
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// SPARSE IMAGES HEADER
#define SPARSE_HEADER_MAGIC (0x02468ace)
#define SPARSE_HEADER_VERSION 1
#define SPARSE_HEADER_SIZE (256) // Plenty of room for later
#define SPARSE_PAGE_NOT_ALLOCATED (0xffffffff)
typedef struct
{
Bit32u magic;
Bit32u version;
Bit32u pagesize;
Bit32u numpages;
Bit32u padding[60];
} sparse_header_t;
#define STANDARD_HEADER_MAGIC "Bochs Virtual HD Image"
#define STANDARD_HEADER_VERSION (0x00010000)
#define STANDARD_HEADER_SIZE (512)
// WARNING : headers are kept in x86 (little) endianness
typedef struct
{
Bit8u magic[32];
Bit8u type[16];
Bit8u subtype[16];
Bit32u version;
Bit32u header;
} standard_header_t;
#define REDOLOG_TYPE "Redolog"
#define REDOLOG_SUBTYPE_UNDOABLE "Undoable"
#define REDOLOG_SUBTYPE_VOLATILE "Volatile"
#define REDOLOG_SUBTYPE_GROWING "Growing"
// #define REDOLOG_SUBTYPE_Z_UNDOABLE "z-Undoable"
// #define REDOLOG_SUBTYPE_Z_VOLATILE "z-Volatile"
#define REDOLOG_PAGE_NOT_ALLOCATED (0xffffffff)
#define UNDOABLE_REDOLOG_EXTENSION ".redolog"
#define UNDOABLE_REDOLOG_EXTENSION_LENGTH (strlen(UNDOABLE_REDOLOG_EXTENSION))
#define VOLATILE_REDOLOG_EXTENSION ".XXXXXX"
#define VOLATILE_REDOLOG_EXTENSION_LENGTH (strlen(VOLATILE_REDOLOG_EXTENSION))
typedef struct
{
// the fields in the header are kept in little endian
Bit32u catalog; // #entries in the catalog
Bit32u bitmap; // bitmap size in bytes
Bit32u extent; // extent size in bytes
Bit64u disk; // disk size in bytes
} redolog_specific_header_t;
typedef struct
{
standard_header_t standard;
redolog_specific_header_t specific;
Bit8u padding[STANDARD_HEADER_SIZE - (sizeof (standard_header_t) + sizeof (redolog_specific_header_t))];
} redolog_header_t;
// htod : convert host to disk (little) endianness
// dtoh : convert disk (little) to host endianness
#if defined (BX_LITTLE_ENDIAN)
#define htod32(val) (val)
#define dtoh32(val) (val)
#define htod64(val) (val)
#define dtoh64(val) (val)
#else
#define htod32(val) ( (((val)&0xff000000)>>24) | (((val)&0xff0000)>>8) | (((val)&0xff00)<<8) | (((val)&0xff)<<24) )
#define dtoh32(val) htod32(val)
#define htod64(val) ( (((val)&0xff00000000000000LL)>>56) | (((val)&0xff000000000000LL)>>40) | (((val)&0xff0000000000LL)>>24) | (((val)&0xff00000000LL)>>8) | (((val)&0xff000000LL)<<8) | (((val)&0xff0000LL)<<24) | (((val)&0xff00LL)<<40) | (((val)&0xffLL)<<56) )
#define dtoh64(val) htod64(val)
#endif
#ifndef INCLUDE_ONLY_HD_HEADERS
typedef enum _sense {
SENSE_NONE = 0, SENSE_NOT_READY = 2, SENSE_ILLEGAL_REQUEST = 5,
SENSE_UNIT_ATTENTION = 6
@ -115,457 +37,9 @@ typedef enum _asc {
ASC_MEDIUM_NOT_PRESENT = 0x3a
} asc_t;
class device_image_t;
class LOWLEVEL_CDROM;
class device_image_t
{
public:
// Open a image. Returns non-negative if successful.
virtual int open (const char* pathname) = 0;
// Close the image.
virtual void close () = 0;
// Position ourselves. Return the resulting offset from the
// beginning of the file.
virtual off_t lseek (off_t offset, int whence) = 0;
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
virtual ssize_t read (void* buf, size_t count) = 0;
// Write count bytes from buf. Return the number of bytes
// written (count).
virtual ssize_t write (const void* buf, size_t count) = 0;
unsigned cylinders;
unsigned heads;
unsigned sectors;
off_t hd_size;
};
// FLAT MODE
class default_image_t : public device_image_t
{
public:
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Open an image with specific flags. Returns non-negative if successful.
int open (const char* pathname, int flags);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
int fd;
};
// CONCAT MODE
class concat_image_t : public device_image_t
{
public:
// Default constructor
concat_image_t();
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
#define BX_CONCAT_MAX_IMAGES 8
int fd_table[BX_CONCAT_MAX_IMAGES];
off_t start_offset_table[BX_CONCAT_MAX_IMAGES];
off_t length_table[BX_CONCAT_MAX_IMAGES];
void increment_string (char *str);
int maxfd; // number of entries in tables that are valid
// notice if anyone does sequential read or write without seek in between.
// This can be supported pretty easily, but needs additional checks.
// 0=something other than seek was last operation
// 1=seek was last operation
int seek_was_last_op;
// the following variables tell which partial image file to use for
// the next read and write.
int index; // index into table
int fd; // fd to use for reads and writes
off_t thismin, thismax; // byte offset boundary of this image
};
// SPARSE MODE
class sparse_image_t : public device_image_t
{
// Format of a sparse file:
// 256 byte header, containing details such as page size and number of pages
// Page indirection table, mapping virtual pages to physical pages within file
// Physical pages till end of file
public:
// Default constructor
sparse_image_t();
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
int fd;
#ifdef _POSIX_MAPPED_FILES
void * mmap_header;
size_t mmap_length;
size_t system_pagesize_mask;
#endif
Bit32u * pagetable;
// Header is written to disk in little-endian (x86) format
// Thus needs to be converted on big-endian systems before read
// The pagetable is also kept little endian
sparse_header_t header;
Bit32u pagesize;
int pagesize_shift;
Bit32u pagesize_mask;
off_t data_start;
off_t underlying_filesize;
char * pathname;
off_t position;
Bit32u position_virtual_page;
Bit32u position_physical_page;
Bit32u position_page_offset;
off_t underlying_current_filepos;
off_t total_size;
void panic(const char * message);
off_t
#ifndef PARANOID
sparse_image_t::
#endif
get_physical_offset();
void
#ifndef PARANOID
sparse_image_t::
#endif
set_virtual_page(Bit32u new_virtual_page);
void read_header();
ssize_t read_page_fragment(Bit32u read_virtual_page, Bit32u read_page_offset, size_t read_size, void * buf);
sparse_image_t * parent_image;
};
#if EXTERNAL_DISK_SIMULATOR
#include "external-disk-simulator.h"
#endif
#if DLL_HD_SUPPORT
class dll_image_t : public device_image_t
{
public:
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
int vunit,vblk;
};
#endif
// REDOLOG class
class redolog_t
{
public:
redolog_t();
int make_header (const char* type, Bit64u size);
int create (const char* filename, const char* type, Bit64u size);
int create (int filedes, const char* type, Bit64u size);
int open (const char* filename, const char* type, Bit64u size);
void close ();
off_t lseek (off_t offset, int whence);
ssize_t read (void* buf, size_t count);
ssize_t write (const void* buf, size_t count);
private:
void print_header();
int fd;
redolog_header_t header; // Header is kept in x86 (little) endianness
Bit32u *catalog;
Bit8u *bitmap;
Bit32u extent_index;
Bit32u extent_offset;
Bit32u extent_next;
Bit32u bitmap_blocs;
Bit32u extent_blocs;
};
// GROWING MODE
class growing_image_t : public device_image_t
{
public:
// Contructor
growing_image_t(Bit64u size);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog;
Bit64u size;
};
// UNDOABLE MODE
class undoable_image_t : public device_image_t
{
public:
// Contructor
undoable_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
default_image_t *ro_disk; // Read-only flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
};
// VOLATILE MODE
class volatile_image_t : public device_image_t
{
public:
// Contructor
volatile_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
default_image_t *ro_disk; // Read-only flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
char *redolog_temp; // Redolog temporary file name
};
#if BX_COMPRESSED_HD_SUPPORT
#include <zlib.h>
// Default compressed READ-ONLY image class
class z_ro_image_t : public device_image_t
{
public:
// Contructor
z_ro_image_t();
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
off_t offset;
int fd;
gzFile gzfile;
};
// Z-UNDOABLE MODE
class z_undoable_image_t : public device_image_t
{
public:
// Contructor
z_undoable_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
z_ro_image_t *ro_disk; // Read-only compressed flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
};
// Z-VOLATILE MODE
class z_volatile_image_t : public device_image_t
{
public:
// Contructor
z_volatile_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
z_ro_image_t *ro_disk; // Read-only compressed flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
char *redolog_temp; // Redolog temporary file name
};
#endif
typedef struct {
struct {
bx_bool busy;
@ -764,5 +238,3 @@ private:
int iolight_timer_index;
};
#endif // INCLUDE_ONLY_SPARSE_HEADER

553
bochs/iodev/hdimage.h Normal file
View File

@ -0,0 +1,553 @@
/////////////////////////////////////////////////////////////////////////
// $Id: hdimage.h,v 1.1 2005-11-06 11:07:01 vruppert Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2005 MandrakeSoft S.A.
//
// MandrakeSoft S.A.
// 43, rue d'Aboukir
// 75002 Paris - France
// http://www.linux-mandrake.com/
// http://www.mandrakesoft.com/
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
// SPARSE IMAGES HEADER
#define SPARSE_HEADER_MAGIC (0x02468ace)
#define SPARSE_HEADER_VERSION 1
#define SPARSE_HEADER_SIZE (256) // Plenty of room for later
#define SPARSE_PAGE_NOT_ALLOCATED (0xffffffff)
typedef struct
{
Bit32u magic;
Bit32u version;
Bit32u pagesize;
Bit32u numpages;
Bit32u padding[60];
} sparse_header_t;
#define STANDARD_HEADER_MAGIC "Bochs Virtual HD Image"
#define STANDARD_HEADER_VERSION (0x00010000)
#define STANDARD_HEADER_SIZE (512)
// WARNING : headers are kept in x86 (little) endianness
typedef struct
{
Bit8u magic[32];
Bit8u type[16];
Bit8u subtype[16];
Bit32u version;
Bit32u header;
} standard_header_t;
#define REDOLOG_TYPE "Redolog"
#define REDOLOG_SUBTYPE_UNDOABLE "Undoable"
#define REDOLOG_SUBTYPE_VOLATILE "Volatile"
#define REDOLOG_SUBTYPE_GROWING "Growing"
// #define REDOLOG_SUBTYPE_Z_UNDOABLE "z-Undoable"
// #define REDOLOG_SUBTYPE_Z_VOLATILE "z-Volatile"
#define REDOLOG_PAGE_NOT_ALLOCATED (0xffffffff)
#define UNDOABLE_REDOLOG_EXTENSION ".redolog"
#define UNDOABLE_REDOLOG_EXTENSION_LENGTH (strlen(UNDOABLE_REDOLOG_EXTENSION))
#define VOLATILE_REDOLOG_EXTENSION ".XXXXXX"
#define VOLATILE_REDOLOG_EXTENSION_LENGTH (strlen(VOLATILE_REDOLOG_EXTENSION))
typedef struct
{
// the fields in the header are kept in little endian
Bit32u catalog; // #entries in the catalog
Bit32u bitmap; // bitmap size in bytes
Bit32u extent; // extent size in bytes
Bit64u disk; // disk size in bytes
} redolog_specific_header_t;
typedef struct
{
standard_header_t standard;
redolog_specific_header_t specific;
Bit8u padding[STANDARD_HEADER_SIZE - (sizeof (standard_header_t) + sizeof (redolog_specific_header_t))];
} redolog_header_t;
// htod : convert host to disk (little) endianness
// dtoh : convert disk (little) to host endianness
#if defined (BX_LITTLE_ENDIAN)
#define htod32(val) (val)
#define dtoh32(val) (val)
#define htod64(val) (val)
#define dtoh64(val) (val)
#else
#define htod32(val) ( (((val)&0xff000000)>>24) | (((val)&0xff0000)>>8) | (((val)&0xff00)<<8) | (((val)&0xff)<<24) )
#define dtoh32(val) htod32(val)
#define htod64(val) ( (((val)&0xff00000000000000LL)>>56) | (((val)&0xff000000000000LL)>>40) | (((val)&0xff0000000000LL)>>24) | (((val)&0xff00000000LL)>>8) | (((val)&0xff000000LL)<<8) | (((val)&0xff0000LL)<<24) | (((val)&0xff00LL)<<40) | (((val)&0xffLL)<<56) )
#define dtoh64(val) htod64(val)
#endif
#ifndef HDIMAGE_HEADERS_ONLY
class device_image_t
{
public:
// Open a image. Returns non-negative if successful.
virtual int open (const char* pathname) = 0;
// Close the image.
virtual void close () = 0;
// Position ourselves. Return the resulting offset from the
// beginning of the file.
virtual off_t lseek (off_t offset, int whence) = 0;
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
virtual ssize_t read (void* buf, size_t count) = 0;
// Write count bytes from buf. Return the number of bytes
// written (count).
virtual ssize_t write (const void* buf, size_t count) = 0;
unsigned cylinders;
unsigned heads;
unsigned sectors;
off_t hd_size;
};
// FLAT MODE
class default_image_t : public device_image_t
{
public:
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Open an image with specific flags. Returns non-negative if successful.
int open (const char* pathname, int flags);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
int fd;
};
// CONCAT MODE
class concat_image_t : public device_image_t
{
public:
// Default constructor
concat_image_t();
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
#define BX_CONCAT_MAX_IMAGES 8
int fd_table[BX_CONCAT_MAX_IMAGES];
off_t start_offset_table[BX_CONCAT_MAX_IMAGES];
off_t length_table[BX_CONCAT_MAX_IMAGES];
void increment_string (char *str);
int maxfd; // number of entries in tables that are valid
// notice if anyone does sequential read or write without seek in between.
// This can be supported pretty easily, but needs additional checks.
// 0=something other than seek was last operation
// 1=seek was last operation
int seek_was_last_op;
// the following variables tell which partial image file to use for
// the next read and write.
int index; // index into table
int fd; // fd to use for reads and writes
off_t thismin, thismax; // byte offset boundary of this image
};
// SPARSE MODE
class sparse_image_t : public device_image_t
{
// Format of a sparse file:
// 256 byte header, containing details such as page size and number of pages
// Page indirection table, mapping virtual pages to physical pages within file
// Physical pages till end of file
public:
// Default constructor
sparse_image_t();
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
int fd;
#ifdef _POSIX_MAPPED_FILES
void * mmap_header;
size_t mmap_length;
size_t system_pagesize_mask;
#endif
Bit32u * pagetable;
// Header is written to disk in little-endian (x86) format
// Thus needs to be converted on big-endian systems before read
// The pagetable is also kept little endian
sparse_header_t header;
Bit32u pagesize;
int pagesize_shift;
Bit32u pagesize_mask;
off_t data_start;
off_t underlying_filesize;
char * pathname;
off_t position;
Bit32u position_virtual_page;
Bit32u position_physical_page;
Bit32u position_page_offset;
off_t underlying_current_filepos;
off_t total_size;
void panic(const char * message);
off_t
#ifndef PARANOID
sparse_image_t::
#endif
get_physical_offset();
void
#ifndef PARANOID
sparse_image_t::
#endif
set_virtual_page(Bit32u new_virtual_page);
void read_header();
ssize_t read_page_fragment(Bit32u read_virtual_page, Bit32u read_page_offset, size_t read_size, void * buf);
sparse_image_t * parent_image;
};
#if EXTERNAL_DISK_SIMULATOR
#include "external-disk-simulator.h"
#endif
#if DLL_HD_SUPPORT
class dll_image_t : public device_image_t
{
public:
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
int vunit,vblk;
};
#endif
// REDOLOG class
class redolog_t
{
public:
redolog_t();
int make_header (const char* type, Bit64u size);
int create (const char* filename, const char* type, Bit64u size);
int create (int filedes, const char* type, Bit64u size);
int open (const char* filename, const char* type, Bit64u size);
void close ();
off_t lseek (off_t offset, int whence);
ssize_t read (void* buf, size_t count);
ssize_t write (const void* buf, size_t count);
private:
void print_header();
int fd;
redolog_header_t header; // Header is kept in x86 (little) endianness
Bit32u *catalog;
Bit8u *bitmap;
Bit32u extent_index;
Bit32u extent_offset;
Bit32u extent_next;
Bit32u bitmap_blocs;
Bit32u extent_blocs;
};
// GROWING MODE
class growing_image_t : public device_image_t
{
public:
// Contructor
growing_image_t(Bit64u size);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog;
Bit64u size;
};
// UNDOABLE MODE
class undoable_image_t : public device_image_t
{
public:
// Contructor
undoable_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
default_image_t *ro_disk; // Read-only flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
};
// VOLATILE MODE
class volatile_image_t : public device_image_t
{
public:
// Contructor
volatile_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
default_image_t *ro_disk; // Read-only flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
char *redolog_temp; // Redolog temporary file name
};
#if BX_COMPRESSED_HD_SUPPORT
#include <zlib.h>
// Default compressed READ-ONLY image class
class z_ro_image_t : public device_image_t
{
public:
// Contructor
z_ro_image_t();
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
off_t offset;
int fd;
gzFile gzfile;
};
// Z-UNDOABLE MODE
class z_undoable_image_t : public device_image_t
{
public:
// Contructor
z_undoable_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
z_ro_image_t *ro_disk; // Read-only compressed flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
};
// Z-VOLATILE MODE
class z_volatile_image_t : public device_image_t
{
public:
// Contructor
z_volatile_image_t(Bit64u size, const char* redolog_name);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);
// Close the image.
void close ();
// Position ourselves. Return the resulting offset from the
// beginning of the file.
off_t lseek (off_t offset, int whence);
// Read count bytes to the buffer buf. Return the number of
// bytes read (count).
ssize_t read (void* buf, size_t count);
// Write count bytes from buf. Return the number of bytes
// written (count).
ssize_t write (const void* buf, size_t count);
private:
redolog_t *redolog; // Redolog instance
z_ro_image_t *ro_disk; // Read-only compressed flat disk instance
Bit64u size;
char *redolog_name; // Redolog name
char *redolog_temp; // Redolog temporary file name
};
#endif
#endif // HDIMAGE_HEADERS_ONLY

1
bochs/iodev/vmware3.cc
View File

@ -28,6 +28,7 @@
#define BX_PLUGGABLE
#include "iodev.h"
#include "hdimage.h"
#include "vmware3.h"
const off_t vmware3_image_t::INVALID_OFFSET=(off_t)-1;

8
bochs/misc/bxcommit.c
View File

@ -1,6 +1,6 @@
/*
* misc/bximage.c
* $Id: bxcommit.c,v 1.10 2005-06-26 10:54:49 vruppert Exp $
* $Id: bxcommit.c,v 1.11 2005-11-06 11:07:01 vruppert Exp $
*
* Commits a redolog file in a flat file for bochs images.
*
@ -45,11 +45,11 @@ int snprintf (char *s, size_t maxlen, const char *format, ...)
#include "../osdep.h"
#define INCLUDE_ONLY_HD_HEADERS 1
#include "../iodev/harddrv.h"
#define HDIMAGE_HEADERS_ONLY 1
#include "../iodev/hdimage.h"
char *EOF_ERR = "ERROR: End of input";
char *rcsid = "$Id: bxcommit.c,v 1.10 2005-06-26 10:54:49 vruppert Exp $";
char *rcsid = "$Id: bxcommit.c,v 1.11 2005-11-06 11:07:01 vruppert Exp $";
char *divider = "========================================================================";
void myexit (int code)

20
bochs/misc/bximage.c
View File

@ -1,6 +1,6 @@
/*
* misc/bximage.c
* $Id: bximage.c,v 1.28 2005-06-26 10:54:49 vruppert Exp $
* $Id: bximage.c,v 1.29 2005-11-06 11:07:01 vruppert Exp $
*
* Create empty hard disk or floppy disk images for bochs.
*
@ -25,8 +25,8 @@
#include "../osdep.h"
#define INCLUDE_ONLY_HD_HEADERS 1
#include "../iodev/harddrv.h"
#define HDIMAGE_HEADERS_ONLY 1
#include "../iodev/hdimage.h"
int bx_hdimage;
int bx_fdsize_idx;
@ -41,7 +41,7 @@ typedef int (*WRITE_IMAGE_WIN32)(HANDLE, Bit64u);
#endif
char *EOF_ERR = "ERROR: End of input";
char *rcsid = "$Id: bximage.c,v 1.28 2005-06-26 10:54:49 vruppert Exp $";
char *rcsid = "$Id: bximage.c,v 1.29 2005-11-06 11:07:01 vruppert Exp $";
char *divider = "========================================================================";
/* menu data for choosing floppy/hard disk */
@ -304,7 +304,7 @@ void make_redolog_header(redolog_header_t *header, const char* type, Bit64u size
int make_flat_image_win32(HANDLE hFile, Bit64u sec)
{
LARGE_INTEGER pos;
DWORD dwCount;
DWORD dwCount, errCode;
USHORT mode;
char buffer[1024];
@ -321,8 +321,14 @@ int make_flat_image_win32(HANDLE hFile, Bit64u sec)
memset(buffer, 0, 512);
if ((pos.u.LowPart == 0xffffffff && GetLastError() != NO_ERROR) || !WriteFile(hFile, buffer, 512, &dwCount, NULL) || dwCount != 512)
{
errCode = GetLastError();
CloseHandle(hFile);
fatal ("ERROR: The disk image is not complete!");
if (errCode == ERROR_DISK_FULL) {
fatal ("\nERROR: Not enough space on disk for image!");
} else {
sprintf(buffer, "\nERROR: Disk image creation failed with error code %i!", errCode);
fatal (buffer);
}
}
return 0;
}
@ -349,7 +355,7 @@ int make_flat_image(FILE *fp, Bit64u sec)
if (fputc('\0', fp) == EOF)
{
fclose (fp);
fatal ("ERROR: The disk image is not complete!");
fatal ("\nERROR: The disk image is not complete! (image larger then free space?)");
}
return 0;
}