2015-03-29 17:27:32 +03:00
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
// $Id$
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This file provides support for the following VBox virtual
|
|
|
|
* disk image formats: VDI.
|
|
|
|
*
|
|
|
|
* Author: Benjamin D Lunt
|
|
|
|
* Contact: fys [at] fysnet [dot] net
|
|
|
|
*
|
2016-12-30 13:04:06 +03:00
|
|
|
* Copyright (C) 2015 Benjamin D Lunt.
|
|
|
|
* Copyright (C) 2006-2016 The Bochs Project
|
2015-03-29 17:27:32 +03:00
|
|
|
*
|
|
|
|
* 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.1 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*
|
|
|
|
* Information found at:
|
|
|
|
* https://forums.virtualbox.org/viewtopic.php?t=8046
|
|
|
|
*
|
|
|
|
* Many Image Files can be found at:
|
|
|
|
* http://sourceforge.net/projects/virtualboximage/files/
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Define BX_PLUGGABLE in files that can be compiled into plugins. For
|
|
|
|
// platforms that require a special tag on exported symbols, BX_PLUGGABLE
|
|
|
|
// is used to know when we are exporting symbols and when we are importing.
|
|
|
|
#define BX_PLUGGABLE
|
|
|
|
|
|
|
|
#ifdef BXIMAGE
|
|
|
|
#include "config.h"
|
|
|
|
#include "misc/bxcompat.h"
|
|
|
|
#include "misc/bswap.h"
|
|
|
|
#include "osdep.h"
|
|
|
|
#else
|
|
|
|
#include "iodev.h"
|
|
|
|
#endif
|
|
|
|
#include "hdimage.h"
|
|
|
|
#include "vbox.h"
|
|
|
|
|
|
|
|
#define LOG_THIS bx_devices.pluginHDImageCtl->
|
|
|
|
|
|
|
|
const off_t vbox_image_t::INVALID_OFFSET = (off_t)-1;
|
|
|
|
const int vbox_image_t::SECTOR_SIZE = 512;
|
|
|
|
|
|
|
|
vbox_image_t::vbox_image_t()
|
|
|
|
: file_descriptor(-1),
|
|
|
|
mtlb(0),
|
|
|
|
block_data(0),
|
|
|
|
current_offset(INVALID_OFFSET),
|
|
|
|
mtlb_sector(0),
|
|
|
|
is_dirty(0),
|
|
|
|
mtlb_dirty(0),
|
|
|
|
header_dirty(0)
|
|
|
|
{
|
|
|
|
if (sizeof(_VBOX_VDI_Header) != 512) {
|
2016-12-30 13:04:06 +03:00
|
|
|
BX_FATAL(("system error: invalid header structure size"));
|
2015-03-29 17:27:32 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vbox_image_t::~vbox_image_t()
|
|
|
|
{
|
|
|
|
close();
|
|
|
|
}
|
|
|
|
|
|
|
|
int vbox_image_t::open(const char* _pathname, int flags)
|
|
|
|
{
|
|
|
|
Bit64u imgsize = 0;
|
|
|
|
|
|
|
|
pathname = _pathname;
|
|
|
|
close();
|
|
|
|
|
|
|
|
file_descriptor = hdimage_open_file(pathname, flags, &imgsize, &mtime);
|
|
|
|
|
|
|
|
if (!is_open())
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (!read_header()) {
|
|
|
|
BX_PANIC(("unable to read vbox virtual disk header from file '%s'", pathname));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// allocate one block of memory
|
|
|
|
block_data = new Bit8u[(unsigned) header.block_size];
|
|
|
|
if (block_data == 0) {
|
|
|
|
BX_PANIC(("unable to allocate %d bytes for vbox block size", header.block_size));
|
|
|
|
}
|
|
|
|
is_dirty = 0;
|
|
|
|
mtlb_dirty = 0;
|
|
|
|
header_dirty = 0;
|
|
|
|
|
|
|
|
// we allocate and read the image block map.
|
|
|
|
// it is not a very large size, since each entry is only 32-bits and
|
|
|
|
// a 10-gig image will only use 40k of memory in this block.
|
|
|
|
// (10gig = 10240 1-meg blocks with each entry using 4 bytes) = 40k
|
|
|
|
mtlb = new Bit32s[(unsigned) header.blocks_in_hdd];
|
|
|
|
if (mtlb == 0) {
|
|
|
|
BX_PANIC(("unable to allocate %lu bytes for vbox image's map table", header.blocks_in_hdd * sizeof(Bit32u)));
|
|
|
|
}
|
|
|
|
|
|
|
|
// read in the map table
|
|
|
|
if (bx_read_image(file_descriptor, header.offset_blocks, mtlb, (unsigned) header.blocks_in_hdd * sizeof(Bit32u))
|
|
|
|
!= (ssize_t)(header.blocks_in_hdd * sizeof(Bit32u))) {
|
|
|
|
BX_PANIC(("did not read in map table"));
|
|
|
|
}
|
|
|
|
|
|
|
|
// read in the first index so that we have something in memory
|
|
|
|
read_block(0);
|
|
|
|
|
|
|
|
mtlb_sector = 0;
|
|
|
|
current_offset = 0;
|
|
|
|
|
|
|
|
hd_size = header.disk_size;
|
|
|
|
if ((unsigned) header.cylinders > 0) {
|
|
|
|
cylinders = (unsigned) header.cylinders;
|
|
|
|
heads = (unsigned) header.heads;
|
|
|
|
spt = (unsigned) header.sectors;
|
|
|
|
} else {
|
|
|
|
cylinders = (unsigned) ((header.disk_size / 512) / 16) / 63;
|
|
|
|
heads = 16;
|
|
|
|
spt = 63;
|
|
|
|
}
|
|
|
|
|
|
|
|
BX_DEBUG(("VBox VDI disk geometry:"));
|
|
|
|
BX_DEBUG((" .size = " FMT_LL "d", hd_size));
|
|
|
|
BX_DEBUG((" .cylinders = %d", cylinders));
|
|
|
|
BX_DEBUG((" .heads = %d", heads));
|
|
|
|
BX_DEBUG((" .sectors = %d", spt));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vbox_image_t::close()
|
|
|
|
{
|
|
|
|
if (file_descriptor == -1)
|
|
|
|
return;
|
|
|
|
|
|
|
|
flush();
|
|
|
|
|
|
|
|
// write the map back to the disk
|
|
|
|
if (mtlb_dirty) {
|
|
|
|
if (bx_write_image(file_descriptor, header.offset_blocks, mtlb, (unsigned) header.blocks_in_hdd * sizeof(Bit32u))
|
|
|
|
!= (ssize_t)(header.blocks_in_hdd * sizeof(Bit32u))) {
|
|
|
|
BX_PANIC(("did not write map table"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// write header back to image
|
|
|
|
if (header_dirty) {
|
|
|
|
if (bx_write_image(file_descriptor, 0, &header, sizeof(VBOX_VDI_Header)) != sizeof(VBOX_VDI_Header)) {
|
|
|
|
BX_PANIC(("did not write header"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
delete [] mtlb; mtlb = 0;
|
|
|
|
delete [] block_data; block_data = 0;
|
|
|
|
|
|
|
|
::close(file_descriptor);
|
|
|
|
file_descriptor = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bit64s vbox_image_t::lseek(Bit64s offset, int whence)
|
|
|
|
{
|
|
|
|
switch (whence) {
|
|
|
|
case SEEK_SET:
|
|
|
|
current_offset = (off_t) offset;
|
|
|
|
return current_offset;
|
|
|
|
case SEEK_CUR:
|
|
|
|
current_offset += (off_t) offset;
|
|
|
|
return current_offset;
|
|
|
|
case SEEK_END:
|
|
|
|
current_offset = header.disk_size + (off_t)offset;
|
|
|
|
return current_offset;
|
|
|
|
default:
|
|
|
|
BX_INFO(("unknown 'whence' value (%d) when trying to seek vbox image", whence));
|
|
|
|
return INVALID_OFFSET;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t vbox_image_t::read(void *buf, size_t count)
|
|
|
|
{
|
2015-10-15 20:21:34 +03:00
|
|
|
char *cbuf = (char*)buf;
|
2015-03-29 17:27:32 +03:00
|
|
|
ssize_t total = 0;
|
|
|
|
while (count > 0) {
|
|
|
|
off_t readable = perform_seek();
|
|
|
|
if (readable == INVALID_OFFSET) {
|
|
|
|
BX_ERROR(("vbox disk image read failed on %u bytes at " FMT_LL "d", (unsigned)count, current_offset));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
off_t copysize = ((off_t)count > readable) ? readable : count;
|
|
|
|
off_t offset = current_offset & (header.block_size - 1);
|
2015-10-15 20:21:34 +03:00
|
|
|
memcpy(cbuf, block_data + (size_t) offset, (size_t) copysize);
|
2015-03-29 17:27:32 +03:00
|
|
|
|
|
|
|
current_offset += copysize;
|
|
|
|
total += (long) copysize;
|
2015-10-15 20:21:34 +03:00
|
|
|
cbuf += copysize;
|
2015-03-29 17:27:32 +03:00
|
|
|
count -= (size_t) copysize;
|
|
|
|
}
|
|
|
|
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
|
|
|
|
ssize_t vbox_image_t::write(const void *buf, size_t count)
|
|
|
|
{
|
2015-10-15 20:21:34 +03:00
|
|
|
char *cbuf = (char*)buf;
|
2015-03-29 17:27:32 +03:00
|
|
|
ssize_t total = 0;
|
|
|
|
while (count > 0) {
|
|
|
|
off_t writable = perform_seek();
|
|
|
|
if (writable == INVALID_OFFSET) {
|
|
|
|
BX_ERROR(("vbox disk image write failed on %u bytes at " FMT_LL "d", (unsigned)count, current_offset));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
off_t writesize = ((off_t)count > writable) ? writable : count;
|
|
|
|
off_t offset = current_offset & (header.block_size - 1);
|
2015-10-15 20:21:34 +03:00
|
|
|
memcpy(block_data + offset, cbuf, (size_t) writesize);
|
2015-03-29 17:27:32 +03:00
|
|
|
|
|
|
|
current_offset += writesize;
|
|
|
|
total += (long) writesize;
|
2015-10-15 20:21:34 +03:00
|
|
|
cbuf += writesize;
|
2015-03-29 17:27:32 +03:00
|
|
|
count -= (size_t) writesize;
|
|
|
|
is_dirty = 1;
|
|
|
|
}
|
|
|
|
return total;
|
|
|
|
}
|
|
|
|
|
|
|
|
int vbox_image_t::check_format(int fd, Bit64u imgsize)
|
|
|
|
{
|
|
|
|
VBOX_VDI_Header temp_header;
|
|
|
|
|
|
|
|
if (bx_read_image(fd, 0, &temp_header, sizeof(VBOX_VDI_Header)) != sizeof(VBOX_VDI_Header))
|
|
|
|
return HDIMAGE_READ_ERROR;
|
|
|
|
|
|
|
|
// type can be 1 (Dynamic) or 2 (Static/Fixed)
|
|
|
|
// block size must be 1Meg (FIXME: I think it can be anything as long as it is a power of 2)
|
|
|
|
// sector size must be 512
|
|
|
|
if (((temp_header.image_type < 1) || (temp_header.image_type > 2))
|
|
|
|
|| (temp_header.block_size != 0x00100000)
|
|
|
|
|| (temp_header.sector_size != 0x00000200))
|
|
|
|
return HDIMAGE_NO_SIGNATURE;
|
|
|
|
|
|
|
|
// version must be 01.01
|
|
|
|
if (temp_header.version != 0x00010001)
|
|
|
|
return HDIMAGE_VERSION_ERROR;
|
|
|
|
|
|
|
|
return HDIMAGE_FORMAT_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
bx_bool vbox_image_t::is_open() const
|
|
|
|
{
|
|
|
|
return (file_descriptor != -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
bx_bool vbox_image_t::read_header()
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!is_open())
|
|
|
|
BX_PANIC(("attempt to read vbox header from a closed file"));
|
|
|
|
|
|
|
|
if ((ret = check_format(file_descriptor, 0)) != HDIMAGE_FORMAT_OK) {
|
|
|
|
switch (ret) {
|
|
|
|
case HDIMAGE_READ_ERROR:
|
|
|
|
BX_ERROR(("vbox image read error"));
|
|
|
|
break;
|
|
|
|
case HDIMAGE_NO_SIGNATURE:
|
|
|
|
BX_ERROR(("not a vbox image"));
|
|
|
|
break;
|
|
|
|
case HDIMAGE_VERSION_ERROR:
|
|
|
|
BX_ERROR(("unsupported vbox image version"));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bx_read_image(file_descriptor, 0, &header, sizeof(VBOX_VDI_Header)) != sizeof(VBOX_VDI_Header)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
BX_DEBUG(("VBOX_VDI_Header (size=%u)", (unsigned)sizeof(VBOX_VDI_Header)));
|
|
|
|
BX_DEBUG((" .version = %08X", header.version));
|
|
|
|
BX_DEBUG((" .flags = %08X", header.flags));
|
|
|
|
BX_DEBUG((" .disk_size = " FMT_LL "d", header.disk_size));
|
|
|
|
BX_DEBUG((" .type = %d (%s)", header.image_type, (header.image_type == 1) ? "Dynamic" : "Static"));
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// Returns the number of bytes that can be read from the current offset before needing
|
|
|
|
// to perform another seek.
|
|
|
|
//
|
|
|
|
off_t vbox_image_t::perform_seek()
|
|
|
|
{
|
|
|
|
if (current_offset == INVALID_OFFSET) {
|
|
|
|
BX_ERROR(("invalid offset specified in vbox seek"));
|
|
|
|
return INVALID_OFFSET;
|
|
|
|
}
|
|
|
|
|
|
|
|
Bit32u index = (Bit32u) (current_offset / header.block_size);
|
|
|
|
|
|
|
|
if (mtlb_sector == index) {
|
|
|
|
return header.block_size - (current_offset & (header.block_size - 1));
|
|
|
|
} else {
|
|
|
|
flush();
|
|
|
|
|
|
|
|
read_block(index);
|
|
|
|
mtlb_sector = index;
|
|
|
|
|
|
|
|
return header.block_size;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void vbox_image_t::flush()
|
|
|
|
{
|
|
|
|
if (!is_dirty)
|
|
|
|
return;
|
|
|
|
|
|
|
|
//
|
|
|
|
// Write dirty sectors to disk.
|
|
|
|
//
|
|
|
|
write_block(mtlb_sector);
|
|
|
|
is_dirty = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vbox_image_t::read_block(const Bit32u index)
|
|
|
|
{
|
|
|
|
off_t offset;
|
|
|
|
|
|
|
|
// if the mtlb[index] returns -1, then we haven't written this sector
|
|
|
|
// to disk yet, so return an "empty" buffer
|
|
|
|
if (dtoh32(mtlb[index]) == -1) {
|
|
|
|
if (header.image_type == 2) {
|
|
|
|
BX_PANIC(("Found non-existing block in Static type image"));
|
|
|
|
}
|
|
|
|
memset(block_data, 0, header.block_size);
|
|
|
|
|
|
|
|
BX_DEBUG(("reading empty block index %d", index));
|
|
|
|
} else {
|
|
|
|
if (dtoh32(mtlb[index]) >= (int) header.blocks_in_hdd) {
|
|
|
|
BX_PANIC(("Trying to read past end of image (index out of range)"));
|
|
|
|
}
|
|
|
|
offset = dtoh32(mtlb[index]) * header.block_size;
|
|
|
|
bx_read_image(file_descriptor, header.offset_data + offset, block_data, header.block_size);
|
|
|
|
|
|
|
|
BX_DEBUG(("reading block index %d (%d) " FMT_LL "d", index, dtoh32(mtlb[index]), offset));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void vbox_image_t::write_block(const Bit32u index)
|
|
|
|
{
|
|
|
|
off_t offset;
|
|
|
|
|
|
|
|
// if the mtlb[index] returns -1, then we haven't written this sector
|
|
|
|
// to disk yet, so allocate another and write it to file
|
|
|
|
if (dtoh32(mtlb[index]) == -1) {
|
|
|
|
if (header.image_type == 2) {
|
|
|
|
BX_PANIC(("Found non-existing block in Static type image"));
|
|
|
|
}
|
|
|
|
mtlb[index] = htod32(header.blocks_allocated++);
|
|
|
|
BX_DEBUG(("allocating new block at block: %d", dtoh32(mtlb[index])));
|
|
|
|
mtlb_dirty = 1;
|
|
|
|
header_dirty = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dtoh32(mtlb[index]) >= (int) header.blocks_in_hdd) {
|
|
|
|
BX_PANIC(("Trying to write past end of image (index out of range)"));
|
|
|
|
}
|
|
|
|
|
|
|
|
offset = dtoh32(mtlb[index]) * header.block_size;
|
|
|
|
|
|
|
|
BX_DEBUG(("writing block index %d (%d) " FMT_LL "d", index, dtoh32(mtlb[index]), offset));
|
|
|
|
|
|
|
|
bx_write_image(file_descriptor, header.offset_data + offset, block_data, header.block_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
Bit32u vbox_image_t::get_capabilities(void)
|
|
|
|
{
|
|
|
|
return HDIMAGE_HAS_GEOMETRY;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifndef BXIMAGE
|
|
|
|
bx_bool vbox_image_t::save_state(const char *backup_fname)
|
|
|
|
{
|
|
|
|
return hdimage_backup_file(file_descriptor, backup_fname);
|
|
|
|
}
|
|
|
|
|
|
|
|
void vbox_image_t::restore_state(const char *backup_fname)
|
|
|
|
{
|
|
|
|
int temp_fd;
|
|
|
|
Bit64u imgsize;
|
|
|
|
|
|
|
|
if ((temp_fd = hdimage_open_file(backup_fname, O_RDONLY, &imgsize, NULL)) < 0) {
|
|
|
|
BX_PANIC(("Cannot open vbox image backup '%s'", backup_fname));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (check_format(temp_fd, imgsize) < HDIMAGE_FORMAT_OK) {
|
|
|
|
::close(temp_fd);
|
|
|
|
BX_PANIC(("Cannot detect vbox image header"));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
::close(temp_fd);
|
|
|
|
close();
|
|
|
|
if (!hdimage_copy_file(backup_fname, pathname)) {
|
|
|
|
BX_PANIC(("Failed to restore vbox image '%s'", pathname));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
device_image_t::open(pathname);
|
|
|
|
}
|
|
|
|
#endif
|