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

- change disk image mode name "growable" to the more accurate "growing"

Browse Source
This commit is contained in:
Christophe Bothamy 2003-08-01 01:20:00 +00:00
parent 1f48fc3178
commit 974d3538a1
8 changed files with 39 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bochs/.bochsrc
View File

@ -173,7 +173,7 @@ ata3: enabled=0, ioaddr1=0x168, ioaddr2=0x368, irq=9
# This defines the type and characteristics of all attached ata devices:
# type= type of attached device [disk|cdrom]
# mode= only valid for disks [flat|concat|external|dll|sparse|vmware3]
# mode= only valid for disks [undoable|growable|volatile|z-undoable|z-volatile]
# mode= only valid for disks [undoable|growing|volatile|z-undoable|z-volatile]
# path= path of the image
# cylinders= only valid for disks
# heads= only valid for disks

4
bochs/doc/man/bochsrc.5
View File

@ -187,7 +187,7 @@ Examples:
This defines the type and characteristics of all attached ata devices:
type= type of attached device [disk|cdrom]
path= path of the image
mode= image mode [flat|concat|external|dll|sparse|vmware3|undoable|growable|volatile|z-undoable|z-volatile], only valid for disks
mode= image mode [flat|concat|external|dll|sparse|vmware3|undoable|growing|volatile|z-undoable|z-volatile], only valid for disks
cylinders= only valid for disks
heads= only valid for disks
spt= only valid for disks
@ -216,7 +216,7 @@ The mode option defines how the disk image is handled. Disks can be defined as:
- sparse : stackable, commitable, rollbackable
- vmware3 : vmware3 disk support
- undoable : flat file with commitable redolog
- growable : growing file
- growing : growing file
- volatile : flat file with volatile redolog
- z-undoable : gziped flat file with commitable redolog
- z-volatile : gziped flat file with volatile redolog

4
bochs/gui/siminterface.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: siminterface.cc,v 1.96 2003-06-07 19:16:53 vruppert Exp $
// $Id: siminterface.cc,v 1.97 2003-08-01 01:20:00 cbothamy Exp $
/////////////////////////////////////////////////////////////////////////
//
// See siminterface.h for description of the siminterface concept.
@ -451,7 +451,7 @@ int n_keyboard_type_names = 3;
char *atadevice_type_names[] = { "disk", "cdrom", NULL };
int n_atadevice_type_names = 2;
char *atadevice_mode_names[] = { "flat", "concat", "external", "dll", "sparse", "vmware3", "split", "undoable", "growable", "volatile", "z-undoable", "z-volatile", NULL };
char *atadevice_mode_names[] = { "flat", "concat", "external", "dll", "sparse", "vmware3", "split", "undoable", "growing", "volatile", "z-undoable", "z-volatile", NULL };
int n_atadevice_mode_names = 12;
char *atadevice_status_names[] = { "ejected", "inserted", NULL };
int n_atadevice_status_names = 2;

4
bochs/gui/siminterface.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: siminterface.h,v 1.101 2003-05-27 18:19:13 vruppert Exp $
// $Id: siminterface.h,v 1.102 2003-08-01 01:20:00 cbothamy Exp $
/////////////////////////////////////////////////////////////////////////
//
// Before I can describe what this file is for, I have to make the
@ -1133,7 +1133,7 @@ enum {
#define BX_ATA_MODE_VMWARE3 5
#define BX_ATA_MODE_SPLIT 6
#define BX_ATA_MODE_UNDOABLE 7
#define BX_ATA_MODE_GROWABLE 8
#define BX_ATA_MODE_GROWING 8
#define BX_ATA_MODE_VOLATILE 9
#define BX_ATA_MODE_Z_UNDOABLE 10
#define BX_ATA_MODE_Z_VOLATILE 11

29
bochs/iodev/harddrv.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: harddrv.cc,v 1.105 2003-07-31 19:51:42 vruppert Exp $
// $Id: harddrv.cc,v 1.106 2003-08-01 01:20:00 cbothamy Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -159,7 +159,7 @@ bx_hard_drive_c::init(void)
Bit8u channel;
char string[5];
BX_DEBUG(("Init $Id: harddrv.cc,v 1.105 2003-07-31 19:51:42 vruppert Exp $"));
BX_DEBUG(("Init $Id: harddrv.cc,v 1.106 2003-08-01 01:20:00 cbothamy Exp $"));
for (channel=0; channel<BX_MAX_ATA_CHANNEL; channel++) {
if (bx_options.ata[channel].Opresent->get() == 1) {
@ -300,10 +300,10 @@ bx_hard_drive_c::init(void)
channels[channel].drives[device].hard_drive = new undoable_image_t(disk_size);
break;
case BX_ATA_MODE_GROWABLE:
BX_INFO(("HD on ata%d-%d: '%s' 'growable' mode ", channel, device,
case BX_ATA_MODE_GROWING:
BX_INFO(("HD on ata%d-%d: '%s' 'growing' mode ", channel, device,
bx_options.atadevice[channel][device].Opath->getptr ()));
channels[channel].drives[device].hard_drive = new growable_image_t(disk_size);
channels[channel].drives[device].hard_drive = new growing_image_t(disk_size);
break;
case BX_ATA_MODE_VOLATILE:
@ -4049,6 +4049,7 @@ redolog_t::make_header (const char* type, Bit64u size)
{
Bit32u entries, extent_size, bitmap_size;
Bit64u maxsize;
Bit32u flip=0;
// Set standard header values
strcpy((char*)header.standard.magic, STANDARD_HEADER_MAGIC);
@ -4062,8 +4063,6 @@ redolog_t::make_header (const char* type, Bit64u size)
// Compute #entries and extent size values
do {
static Bit32u flip=0;
extent_size = 8 * bitmap_size * 512;
header.specific.catalog = htod32(entries);
@ -4406,37 +4405,37 @@ redolog_t::write (const void* buf, size_t count)
}
/*** growable_image_t function definitions ***/
/*** growing_image_t function definitions ***/
growable_image_t::growable_image_t(Bit64u _size)
growing_image_t::growing_image_t(Bit64u _size)
{
redolog = new redolog_t();
size = _size;
}
int growable_image_t::open (const char* pathname)
int growing_image_t::open (const char* pathname)
{
return redolog->open(pathname,REDOLOG_SUBTYPE_GROWABLE,size);
return redolog->open(pathname,REDOLOG_SUBTYPE_GROWING,size);
}
void growable_image_t::close ()
void growing_image_t::close ()
{
redolog->close();
}
off_t growable_image_t::lseek (off_t offset, int whence)
off_t growing_image_t::lseek (off_t offset, int whence)
{
return redolog->lseek(offset, whence);
}
ssize_t growable_image_t::read (void* buf, size_t count)
ssize_t growing_image_t::read (void* buf, size_t count)
{
memset(buf, 0, count);
redolog->read((char*) buf, count);
return count;
}
ssize_t growable_image_t::write (const void* buf, size_t count)
ssize_t growing_image_t::write (const void* buf, size_t count)
{
return redolog->write((char*) buf, count);
}

10
bochs/iodev/harddrv.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: harddrv.h,v 1.20 2003-05-03 16:37:17 cbothamy Exp $
// $Id: harddrv.h,v 1.21 2003-08-01 01:20:00 cbothamy Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -58,7 +58,7 @@
#define REDOLOG_TYPE "Redolog"
#define REDOLOG_SUBTYPE_UNDOABLE "Undoable"
#define REDOLOG_SUBTYPE_VOLATILE "Volatile"
#define REDOLOG_SUBTYPE_GROWABLE "Growable"
#define REDOLOG_SUBTYPE_GROWING "Growing"
// #define REDOLOG_SUBTYPE_Z_UNDOABLE "z-Undoable"
// #define REDOLOG_SUBTYPE_Z_VOLATILE "z-Volatile"
@ -351,12 +351,12 @@ class redolog_t
Bit32u extent_blocs;
};
// GROWABLE MODE
class growable_image_t : public device_image_t
// GROWING MODE
class growing_image_t : public device_image_t
{
public:
// Contructor
growable_image_t(Bit64u size);
growing_image_t(Bit64u size);
// Open a image. Returns non-negative if successful.
int open (const char* pathname);

10
bochs/main.cc
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: main.cc,v 1.230 2003-07-15 21:02:05 vruppert Exp $
// $Id: main.cc,v 1.231 2003-08-01 01:20:00 cbothamy Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -2842,8 +2842,8 @@ parse_line_formatted(char *context, int num_params, char *params[])
else if (!strcmp(params[i], "mode=undoable")) {
bx_options.atadevice[channel][slave].Omode->set (BX_ATA_MODE_UNDOABLE);
}
else if (!strcmp(params[i], "mode=growable")) {
bx_options.atadevice[channel][slave].Omode->set (BX_ATA_MODE_GROWABLE);
else if (!strcmp(params[i], "mode=growing")) {
bx_options.atadevice[channel][slave].Omode->set (BX_ATA_MODE_GROWING);
}
else if (!strcmp(params[i], "mode=volatile")) {
bx_options.atadevice[channel][slave].Omode->set (BX_ATA_MODE_VOLATILE);
@ -3786,8 +3786,8 @@ bx_write_atadevice_options (FILE *fp, Bit8u channel, Bit8u drive, bx_atadevice_o
case BX_ATA_MODE_UNDOABLE:
fprintf (fp, ", mode=undoable");
break;
case BX_ATA_MODE_GROWABLE:
fprintf (fp, ", mode=growable");
case BX_ATA_MODE_GROWING:
fprintf (fp, ", mode=growing");
break;
case BX_ATA_MODE_VOLATILE:
fprintf (fp, ", mode=volatile");

16
bochs/misc/bximage.c
View File

@ -1,6 +1,6 @@
/*
* misc/bximage.c
* $Id: bximage.c,v 1.18 2003-05-03 16:37:18 cbothamy Exp $
* $Id: bximage.c,v 1.19 2003-08-01 01:20:00 cbothamy Exp $
*
* Create empty hard disk or floppy disk images for bochs.
*
@ -26,7 +26,7 @@
#include "../iodev/harddrv.h"
char *EOF_ERR = "ERROR: End of input";
char *rcsid = "$Id: bximage.c,v 1.18 2003-05-03 16:37:18 cbothamy Exp $";
char *rcsid = "$Id: bximage.c,v 1.19 2003-08-01 01:20:00 cbothamy Exp $";
char *divider = "========================================================================";
/* menu data for choosing floppy/hard disk */
@ -40,8 +40,8 @@ char *fdsize_choices[] = { "0.36","0.72","1.2","1.44","2.88" };
int fdsize_n_choices = 5;
/* menu data for choosing disk mode */
char *hdmode_menu = "\nWhat kind of image should I create?\nPlease type flat, sparse or growable. ";
char *hdmode_choices[] = {"flat", "sparse", "growable" };
char *hdmode_menu = "\nWhat kind of image should I create?\nPlease type flat, sparse or growing. ";
char *hdmode_choices[] = {"flat", "sparse", "growing" };
int hdmode_n_choices = 3;
void myexit (int code)
@ -338,14 +338,14 @@ int make_sparse_image(FILE *fp, Bit64u sec)
return 0;
}
/* produce a growable image file */
int make_growable_image(FILE *fp, Bit64u sec)
/* produce a growing image file */
int make_growing_image(FILE *fp, Bit64u sec)
{
redolog_header_t header;
Bit32u i, not_allocated = htod32(REDOLOG_PAGE_NOT_ALLOCATED);
memset(&header, 0, sizeof(header));
make_redolog_header(&header, REDOLOG_SUBTYPE_GROWABLE, sec * 512);
make_redolog_header(&header, REDOLOG_SUBTYPE_GROWING, sec * 512);
if (fwrite(&header, sizeof(header), 1, fp) != 1)
{
@ -445,7 +445,7 @@ int main()
write_function=make_sparse_image;
break;
case 2:
write_function=make_growable_image;
write_function=make_growing_image;
break;
default:
write_function=make_flat_image;