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

- destructors added to fix memory leaks

Browse Source 
- indent mode fixes and removed unnecessary spaces
This commit is contained in:
Volker Ruppert 2007-03-10 12:53:54 +00:00
parent 8ce336cad3
commit e5dbe40511
2 changed files with 158 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

275
bochs/iodev/hdimage.cc
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: hdimage.cc,v 1.9 2006-11-18 11:51:07 vruppert Exp $ // $Id: hdimage.cc,v 1.10 2007-03-10 12:53:54 vruppert Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2002 MandrakeSoft S.A. // Copyright (C) 2002 MandrakeSoft S.A.
@ -256,9 +256,9 @@ sparse_image_t::sparse_image_t ()
fd = -1; fd = -1;
pathname = NULL; pathname = NULL;
#ifdef _POSIX_MAPPED_FILES #ifdef _POSIX_MAPPED_FILES
mmap_header = NULL; mmap_header = NULL;
#endif #endif
pagetable = NULL; pagetable = NULL;
} }
@ -1267,6 +1267,11 @@ growing_image_t::growing_image_t()
redolog = new redolog_t(); redolog = new redolog_t();
} }
growing_image_t::~growing_image_t()
{
delete redolog;
}
int growing_image_t::open(const char* pathname) int growing_image_t::open(const char* pathname)
{ {
int filedes = redolog->open(pathname, REDOLOG_SUBTYPE_GROWING); int filedes = redolog->open(pathname, REDOLOG_SUBTYPE_GROWING);
@ -1312,6 +1317,12 @@ undoable_image_t::undoable_image_t(const char* _redolog_name)
} }
} }
undoable_image_t::~undoable_image_t()
{
delete redolog;
delete ro_disk;
}
int undoable_image_t::open(const char* pathname) int undoable_image_t::open(const char* pathname)
{ {
char *logname=NULL; char *logname=NULL;
@ -1400,6 +1411,12 @@ volatile_image_t::volatile_image_t(const char* _redolog_name)
} }
} }
volatile_image_t::~volatile_image_t()
{
delete redolog;
delete ro_disk;
}
int volatile_image_t::open(const char* pathname) int volatile_image_t::open(const char* pathname)
{ {
int filedes; int filedes;
@ -1492,7 +1509,7 @@ z_ro_image_t::z_ro_image_t()
offset = (Bit64s)0; offset = (Bit64s)0;
} }
int z_ro_image_t::open (const char* pathname) int z_ro_image_t::open(const char* pathname)
{ {
fd = ::open(pathname, O_RDONLY fd = ::open(pathname, O_RDONLY
#ifdef O_BINARY #ifdef O_BINARY
@ -1510,7 +1527,7 @@ int z_ro_image_t::open (const char* pathname)
return 0; return 0;
} }
void z_ro_image_t::close () void z_ro_image_t::close()
{ {
if (fd > -1) { if (fd > -1) {
gzclose(gzfile); gzclose(gzfile);
@ -1533,13 +1550,13 @@ Bit64s z_ro_image_t::lseek(Bit64s _offset, int whence)
return offset; return offset;
} }
ssize_t z_ro_image_t::read (void* buf, size_t count) ssize_t z_ro_image_t::read(void* buf, size_t count)
{ {
gzseek(gzfile, offset, SEEK_SET); gzseek(gzfile, offset, SEEK_SET);
return gzread(gzfile, buf, count); return gzread(gzfile, buf, count);
} }
ssize_t z_ro_image_t::write (const void* buf, size_t count) ssize_t z_ro_image_t::write(const void* buf, size_t count)
{ {
BX_PANIC(("z_ro_image: write not supported")); BX_PANIC(("z_ro_image: write not supported"));
return 0; return 0;
@ -1550,81 +1567,87 @@ ssize_t z_ro_image_t::write (const void* buf, size_t count)
z_undoable_image_t::z_undoable_image_t(Bit64u _size, const char* _redolog_name) z_undoable_image_t::z_undoable_image_t(Bit64u _size, const char* _redolog_name)
{ {
redolog = new redolog_t(); redolog = new redolog_t();
ro_disk = new z_ro_image_t(); ro_disk = new z_ro_image_t();
size = _size; size = _size;
redolog_name = NULL; redolog_name = NULL;
if (_redolog_name != NULL) { if (_redolog_name != NULL) {
if (strcmp(_redolog_name,"") != 0) { if (strcmp(_redolog_name,"") != 0) {
redolog_name = strdup(_redolog_name); redolog_name = strdup(_redolog_name);
} }
} }
} }
int z_undoable_image_t::open (const char* pathname) z_undoable_image_t::~z_undoable_image_t()
{ {
char *logname=NULL; delete redolog;
delete ro_disk;
if (ro_disk->open(pathname)<0)
return -1;
// If redolog name was set
if ( redolog_name != NULL) {
if ( strcmp(redolog_name, "") != 0) {
logname = (char*)malloc(strlen(redolog_name) + 1);
strcpy (logname, redolog_name);
}
}
// Otherwise we make up the redolog filename from the pathname
if ( logname == NULL) {
logname = (char*)malloc(strlen(pathname) + UNDOABLE_REDOLOG_EXTENSION_LENGTH + 1);
sprintf (logname, "%s%s", pathname, UNDOABLE_REDOLOG_EXTENSION);
}
if (redolog->open(logname,REDOLOG_SUBTYPE_UNDOABLE,size) < 0)
{
if (redolog->create(logname, REDOLOG_SUBTYPE_UNDOABLE, size) < 0)
{
BX_PANIC(("Can't open or create redolog '%s'",logname));
return -1;
}
}
BX_INFO(("'z-undoable' disk opened, z-ro-file is '%s', redolog is '%s'", pathname, logname));
free(logname);
return 0;
} }
void z_undoable_image_t::close () int z_undoable_image_t::open(const char* pathname)
{ {
redolog->close(); char *logname=NULL;
ro_disk->close();
if (redolog_name!=NULL) if (ro_disk->open(pathname)<0)
free(redolog_name); return -1;
// If redolog name was set
if ( redolog_name != NULL) {
if ( strcmp(redolog_name, "") != 0) {
logname = (char*)malloc(strlen(redolog_name) + 1);
strcpy (logname, redolog_name);
}
}
// Otherwise we make up the redolog filename from the pathname
if ( logname == NULL) {
logname = (char*)malloc(strlen(pathname) + UNDOABLE_REDOLOG_EXTENSION_LENGTH + 1);
sprintf (logname, "%s%s", pathname, UNDOABLE_REDOLOG_EXTENSION);
}
if (redolog->open(logname,REDOLOG_SUBTYPE_UNDOABLE,size) < 0)
{
if (redolog->create(logname, REDOLOG_SUBTYPE_UNDOABLE, size) < 0)
{
BX_PANIC(("Can't open or create redolog '%s'",logname));
return -1;
}
}
BX_INFO(("'z-undoable' disk opened, z-ro-file is '%s', redolog is '%s'", pathname, logname));
free(logname);
return 0;
}
void z_undoable_image_t::close()
{
redolog->close();
ro_disk->close();
if (redolog_name!=NULL)
free(redolog_name);
} }
Bit64s z_undoable_image_t::lseek(Bit64s offset, int whence) Bit64s z_undoable_image_t::lseek(Bit64s offset, int whence)
{ {
redolog->lseek(offset, whence); redolog->lseek(offset, whence);
return ro_disk->lseek(offset, whence); return ro_disk->lseek(offset, whence);
} }
ssize_t z_undoable_image_t::read (void* buf, size_t count) ssize_t z_undoable_image_t::read(void* buf, size_t count)
{ {
// This should be fixed if count != 512 // This should be fixed if count != 512
if (redolog->read((char*) buf, count) != count) if (redolog->read((char*) buf, count) != count)
return ro_disk->read((char*) buf, count); return ro_disk->read((char*) buf, count);
else else
return count; return count;
} }
ssize_t z_undoable_image_t::write (const void* buf, size_t count) ssize_t z_undoable_image_t::write(const void* buf, size_t count)
{ {
return redolog->write((char*) buf, count); return redolog->write((char*) buf, count);
} }
@ -1632,100 +1655,106 @@ ssize_t z_undoable_image_t::write (const void* buf, size_t count)
z_volatile_image_t::z_volatile_image_t(Bit64u _size, const char* _redolog_name) z_volatile_image_t::z_volatile_image_t(Bit64u _size, const char* _redolog_name)
{ {
redolog = new redolog_t(); redolog = new redolog_t();
ro_disk = new z_ro_image_t(); ro_disk = new z_ro_image_t();
size = _size; size = _size;
redolog_temp = NULL; redolog_temp = NULL;
redolog_name = NULL; redolog_name = NULL;
if (_redolog_name != NULL) { if (_redolog_name != NULL) {
if (strcmp(_redolog_name,"") != 0) { if (strcmp(_redolog_name,"") != 0) {
redolog_name = strdup(_redolog_name); redolog_name = strdup(_redolog_name);
} }
} }
} }
int z_volatile_image_t::open (const char* pathname) z_volatile_image_t::~z_volatile_image_t()
{ {
int filedes; delete redolog;
const char *logname=NULL; delete ro_disk;
}
if (ro_disk->open(pathname)<0) int z_volatile_image_t::open(const char* pathname)
return -1; {
int filedes;
const char *logname=NULL;
// if redolog name was set if (ro_disk->open(pathname)<0)
if ( redolog_name != NULL) { return -1;
if ( strcmp(redolog_name, "") !=0 ) {
logname = redolog_name;
}
}
// otherwise use pathname as template // if redolog name was set
if (logname == NULL) { if (redolog_name != NULL) {
logname = pathname; if (strcmp(redolog_name, "") !=0 ) {
} logname = redolog_name;
}
}
redolog_temp = (char*)malloc(strlen(logname) + VOLATILE_REDOLOG_EXTENSION_LENGTH + 1); // otherwise use pathname as template
sprintf (redolog_temp, "%s%s", logname, VOLATILE_REDOLOG_EXTENSION); if (logname == NULL) {
logname = pathname;
}
filedes = mkstemp (redolog_temp); redolog_temp = (char*)malloc(strlen(logname) + VOLATILE_REDOLOG_EXTENSION_LENGTH + 1);
sprintf (redolog_temp, "%s%s", logname, VOLATILE_REDOLOG_EXTENSION);
filedes = mkstemp (redolog_temp);
if (filedes < 0)
{
BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
return -1;
}
if (redolog->create(filedes, REDOLOG_SUBTYPE_VOLATILE, size) < 0)
{
BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
return -1;
}
if (filedes < 0)
{
BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
return -1;
}
if (redolog->create(filedes, REDOLOG_SUBTYPE_VOLATILE, size) < 0)
{
BX_PANIC(("Can't create volatile redolog '%s'", redolog_temp));
return -1;
}
#if (!defined(WIN32)) && !BX_WITH_MACOS #if (!defined(WIN32)) && !BX_WITH_MACOS
// on unix it is legal to delete an open file // on unix it is legal to delete an open file
unlink(redolog_temp); unlink(redolog_temp);
#endif #endif
BX_INFO(("'z-volatile' disk opened: z-ro-file is '%s', redolog is '%s'", pathname, redolog_temp)); BX_INFO(("'z-volatile' disk opened: z-ro-file is '%s', redolog is '%s'", pathname, redolog_temp));
return 0; return 0;
} }
void z_volatile_image_t::close () void z_volatile_image_t::close ()
{ {
redolog->close(); redolog->close();
ro_disk->close(); ro_disk->close();
#if defined(WIN32) || BX_WITH_MACOS #if defined(WIN32) || BX_WITH_MACOS
// on non-unix we have to wait till the file is closed to delete it // on non-unix we have to wait till the file is closed to delete it
unlink(redolog_temp); unlink(redolog_temp);
#endif #endif
if (redolog_temp!=NULL) if (redolog_temp!=NULL)
free(redolog_temp); free(redolog_temp);
if (redolog_name!=NULL) if (redolog_name!=NULL)
free(redolog_name); free(redolog_name);
} }
Bit64s z_volatile_image_t::lseek(Bit64s offset, int whence) Bit64s z_volatile_image_t::lseek(Bit64s offset, int whence)
{ {
redolog->lseek(offset, whence); redolog->lseek(offset, whence);
return ro_disk->lseek(offset, whence); return ro_disk->lseek(offset, whence);
} }
ssize_t z_volatile_image_t::read (void* buf, size_t count) ssize_t z_volatile_image_t::read (void* buf, size_t count)
{ {
// This should be fixed if count != 512 // This should be fixed if count != 512
if (redolog->read((char*) buf, count) != count) if (redolog->read((char*) buf, count) != count)
return ro_disk->read((char*) buf, count); return ro_disk->read((char*) buf, count);
else else
return count; return count;
} }
ssize_t z_volatile_image_t::write (const void* buf, size_t count) ssize_t z_volatile_image_t::write (const void* buf, size_t count)
{ {
return redolog->write((char*) buf, count); return redolog->write((char*) buf, count);
} }
#endif #endif

7
bochs/iodev/hdimage.h
View File

@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// $Id: hdimage.h,v 1.8 2006-12-27 15:21:03 vruppert Exp $ // $Id: hdimage.h,v 1.9 2007-03-10 12:53:54 vruppert Exp $
///////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2005 MandrakeSoft S.A. // Copyright (C) 2005 MandrakeSoft S.A.
@ -376,6 +376,7 @@ class growing_image_t : public device_image_t
public: public:
// Contructor // Contructor
growing_image_t(); growing_image_t();
virtual ~growing_image_t();
// Open a image. Returns non-negative if successful. // Open a image. Returns non-negative if successful.
int open(const char* pathname); int open(const char* pathname);
@ -405,6 +406,7 @@ class undoable_image_t : public device_image_t
public: public:
// Contructor // Contructor
undoable_image_t(const char* redolog_name); undoable_image_t(const char* redolog_name);
virtual ~undoable_image_t();
// Open a image. Returns non-negative if successful. // Open a image. Returns non-negative if successful.
int open(const char* pathname); int open(const char* pathname);
@ -437,6 +439,7 @@ class volatile_image_t : public device_image_t
public: public:
// Contructor // Contructor
volatile_image_t(const char* redolog_name); volatile_image_t(const char* redolog_name);
virtual ~volatile_image_t();
// Open a image. Returns non-negative if successful. // Open a image. Returns non-negative if successful.
int open(const char* pathname); int open(const char* pathname);
@ -507,6 +510,7 @@ class z_undoable_image_t : public device_image_t
public: public:
// Contructor // Contructor
z_undoable_image_t(Bit64u size, const char* redolog_name); z_undoable_image_t(Bit64u size, const char* redolog_name);
virtual ~z_undoable_image_t();
// Open a image. Returns non-negative if successful. // Open a image. Returns non-negative if successful.
int open(const char* pathname); int open(const char* pathname);
@ -539,6 +543,7 @@ class z_volatile_image_t : public device_image_t
public: public:
// Contructor // Contructor
z_volatile_image_t(Bit64u size, const char* redolog_name); z_volatile_image_t(Bit64u size, const char* redolog_name);
virtual ~z_volatile_image_t();
// Open a image. Returns non-negative if successful. // Open a image. Returns non-negative if successful.
int open(const char* pathname); int open(const char* pathname);