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

migration: consolidate QEMUFile methods in a single QEMUFileOps struct

Browse Source 
Reviewed-by: Orit Wasserman <owasserm@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2012-08-08 10:15:15 +02:00
parent 5f0ebf1b4d
commit 9229bf3c2d
3 changed files with 79 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
buffered_file.c
View File

@ -234,6 +234,14 @@ static void buffered_rate_tick(void *opaque)
buffered_put_buffer(s, NULL, 0, 0); buffered_put_buffer(s, NULL, 0, 0);
} }
static const QEMUFileOps buffered_file_ops = {
.put_buffer = buffered_put_buffer,
.close = buffered_close,
.rate_limit = buffered_rate_limit,
.get_rate_limit = buffered_get_rate_limit,
.set_rate_limit = buffered_set_rate_limit,
};
QEMUFile *qemu_fopen_ops_buffered(MigrationState *migration_state) QEMUFile *qemu_fopen_ops_buffered(MigrationState *migration_state)
{ {
QEMUFileBuffered *s; QEMUFileBuffered *s;
@ -243,10 +251,7 @@ QEMUFile *qemu_fopen_ops_buffered(MigrationState *migration_state)
s->migration_state = migration_state; s->migration_state = migration_state;
s->xfer_limit = migration_state->bandwidth_limit / 10; s->xfer_limit = migration_state->bandwidth_limit / 10;
s->file = qemu_fopen_ops(s, buffered_put_buffer, NULL, s->file = qemu_fopen_ops(s, &buffered_file_ops);
buffered_close, buffered_rate_limit,
buffered_set_rate_limit,
buffered_get_rate_limit);
s->timer = qemu_new_timer_ms(rt_clock, buffered_rate_tick, s); s->timer = qemu_new_timer_ms(rt_clock, buffered_rate_tick, s);

16
qemu-file.h
View File

@ -59,12 +59,16 @@ typedef int (QEMUFileRateLimit)(void *opaque);
typedef int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate); typedef int64_t (QEMUFileSetRateLimit)(void *opaque, int64_t new_rate);
typedef int64_t (QEMUFileGetRateLimit)(void *opaque); typedef int64_t (QEMUFileGetRateLimit)(void *opaque);
QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer, typedef struct QEMUFileOps {
QEMUFileGetBufferFunc *get_buffer, QEMUFilePutBufferFunc *put_buffer;
QEMUFileCloseFunc *close, QEMUFileGetBufferFunc *get_buffer;
QEMUFileRateLimit *rate_limit, QEMUFileCloseFunc *close;
QEMUFileSetRateLimit *set_rate_limit, QEMUFileRateLimit *rate_limit;
QEMUFileGetRateLimit *get_rate_limit); QEMUFileSetRateLimit *set_rate_limit;
QEMUFileGetRateLimit *get_rate_limit;
} QEMUFileOps;
QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops);
QEMUFile *qemu_fopen(const char *filename, const char *mode); QEMUFile *qemu_fopen(const char *filename, const char *mode);
QEMUFile *qemu_fdopen(int fd, const char *mode); QEMUFile *qemu_fdopen(int fd, const char *mode);
QEMUFile *qemu_fopen_socket(int fd); QEMUFile *qemu_fopen_socket(int fd);

108
savevm.c
View File

@ -163,12 +163,7 @@ void qemu_announce_self(void)
#define IO_BUF_SIZE 32768 #define IO_BUF_SIZE 32768
struct QEMUFile { struct QEMUFile {
QEMUFilePutBufferFunc *put_buffer; const QEMUFileOps *ops;
QEMUFileGetBufferFunc *get_buffer;
QEMUFileCloseFunc *close;
QEMUFileRateLimit *rate_limit;
QEMUFileSetRateLimit *set_rate_limit;
QEMUFileGetRateLimit *get_rate_limit;
void *opaque; void *opaque;
int is_write; int is_write;
@ -257,6 +252,16 @@ static int stdio_fclose(void *opaque)
return ret; return ret;
} }
static const QEMUFileOps stdio_pipe_read_ops = {
.get_buffer = stdio_get_buffer,
.close = stdio_pclose
};
static const QEMUFileOps stdio_pipe_write_ops = {
.put_buffer = stdio_put_buffer,
.close = stdio_pclose
};
QEMUFile *qemu_popen(FILE *stdio_file, const char *mode) QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
{ {
QEMUFileStdio *s; QEMUFileStdio *s;
@ -271,11 +276,9 @@ QEMUFile *qemu_popen(FILE *stdio_file, const char *mode)
s->stdio_file = stdio_file; s->stdio_file = stdio_file;
if(mode[0] == 'r') { if(mode[0] == 'r') {
s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_pclose, s->file = qemu_fopen_ops(s, &stdio_pipe_read_ops);
NULL, NULL, NULL);
} else { } else {
s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_pclose, s->file = qemu_fopen_ops(s, &stdio_pipe_write_ops);
NULL, NULL, NULL);
} }
return s->file; return s->file;
} }
@ -303,6 +306,16 @@ int qemu_stdio_fd(QEMUFile *f)
return fd; return fd;
} }
static const QEMUFileOps stdio_file_read_ops = {
.get_buffer = stdio_get_buffer,
.close = stdio_fclose
};
static const QEMUFileOps stdio_file_write_ops = {
.put_buffer = stdio_put_buffer,
.close = stdio_fclose
};
QEMUFile *qemu_fdopen(int fd, const char *mode) QEMUFile *qemu_fdopen(int fd, const char *mode)
{ {
QEMUFileStdio *s; QEMUFileStdio *s;
@ -320,11 +333,9 @@ QEMUFile *qemu_fdopen(int fd, const char *mode)
goto fail; goto fail;
if(mode[0] == 'r') { if(mode[0] == 'r') {
s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose, s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
NULL, NULL, NULL);
} else { } else {
s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose, s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
NULL, NULL, NULL);
} }
return s->file; return s->file;
@ -333,13 +344,17 @@ fail:
return NULL; return NULL;
} }
static const QEMUFileOps socket_read_ops = {
.get_buffer = socket_get_buffer,
.close = socket_close
};
QEMUFile *qemu_fopen_socket(int fd) QEMUFile *qemu_fopen_socket(int fd)
{ {
QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket)); QEMUFileSocket *s = g_malloc0(sizeof(QEMUFileSocket));
s->fd = fd; s->fd = fd;
s->file = qemu_fopen_ops(s, NULL, socket_get_buffer, socket_close, s->file = qemu_fopen_ops(s, &socket_read_ops);
NULL, NULL, NULL);
return s->file; return s->file;
} }
@ -361,11 +376,9 @@ QEMUFile *qemu_fopen(const char *filename, const char *mode)
goto fail; goto fail;
if(mode[0] == 'w') { if(mode[0] == 'w') {
s->file = qemu_fopen_ops(s, stdio_put_buffer, NULL, stdio_fclose, s->file = qemu_fopen_ops(s, &stdio_file_write_ops);
NULL, NULL, NULL);
} else { } else {
s->file = qemu_fopen_ops(s, NULL, stdio_get_buffer, stdio_fclose, s->file = qemu_fopen_ops(s, &stdio_file_read_ops);
NULL, NULL, NULL);
} }
return s->file; return s->file;
fail: fail:
@ -390,32 +403,31 @@ static int bdrv_fclose(void *opaque)
return bdrv_flush(opaque); return bdrv_flush(opaque);
} }
static const QEMUFileOps bdrv_read_ops = {
.get_buffer = block_get_buffer,
.close = bdrv_fclose
};
static const QEMUFileOps bdrv_write_ops = {
.put_buffer = block_put_buffer,
.close = bdrv_fclose
};
static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable) static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int is_writable)
{ {
if (is_writable) if (is_writable)
return qemu_fopen_ops(bs, block_put_buffer, NULL, bdrv_fclose, return qemu_fopen_ops(bs, &bdrv_write_ops);
NULL, NULL, NULL); return qemu_fopen_ops(bs, &bdrv_read_ops);
return qemu_fopen_ops(bs, NULL, block_get_buffer, bdrv_fclose, NULL, NULL, NULL);
} }
QEMUFile *qemu_fopen_ops(void *opaque, QEMUFilePutBufferFunc *put_buffer, QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
QEMUFileGetBufferFunc *get_buffer,
QEMUFileCloseFunc *close,
QEMUFileRateLimit *rate_limit,
QEMUFileSetRateLimit *set_rate_limit,
QEMUFileGetRateLimit *get_rate_limit)
{ {
QEMUFile *f; QEMUFile *f;
f = g_malloc0(sizeof(QEMUFile)); f = g_malloc0(sizeof(QEMUFile));
f->opaque = opaque; f->opaque = opaque;
f->put_buffer = put_buffer; f->ops = ops;
f->get_buffer = get_buffer;
f->close = close;
f->rate_limit = rate_limit;
f->set_rate_limit = set_rate_limit;
f->get_rate_limit = get_rate_limit;
f->is_write = 0; f->is_write = 0;
return f; return f;
@ -438,11 +450,11 @@ static int qemu_fflush(QEMUFile *f)
{ {
int ret = 0; int ret = 0;
if (!f->put_buffer) if (!f->ops->put_buffer)
return 0; return 0;
if (f->is_write && f->buf_index > 0) { if (f->is_write && f->buf_index > 0) {
ret = f->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index); ret = f->ops->put_buffer(f->opaque, f->buf, f->buf_offset, f->buf_index);
if (ret >= 0) { if (ret >= 0) {
f->buf_offset += f->buf_index; f->buf_offset += f->buf_index;
} }
@ -456,7 +468,7 @@ static void qemu_fill_buffer(QEMUFile *f)
int len; int len;
int pending; int pending;
if (!f->get_buffer) if (!f->ops->get_buffer)
return; return;
if (f->is_write) if (f->is_write)
@ -469,7 +481,7 @@ static void qemu_fill_buffer(QEMUFile *f)
f->buf_index = 0; f->buf_index = 0;
f->buf_size = pending; f->buf_size = pending;
len = f->get_buffer(f->opaque, f->buf + pending, f->buf_offset, len = f->ops->get_buffer(f->opaque, f->buf + pending, f->buf_offset,
IO_BUF_SIZE - pending); IO_BUF_SIZE - pending);
if (len > 0) { if (len > 0) {
f->buf_size += len; f->buf_size += len;
@ -493,8 +505,8 @@ int qemu_fclose(QEMUFile *f)
int ret; int ret;
ret = qemu_fflush(f); ret = qemu_fflush(f);
if (f->close) { if (f->ops->close) {
int ret2 = f->close(f->opaque); int ret2 = f->ops->close(f->opaque);
if (ret >= 0) { if (ret >= 0) {
ret = ret2; ret = ret2;
} }
@ -511,7 +523,7 @@ int qemu_fclose(QEMUFile *f)
int qemu_file_put_notify(QEMUFile *f) int qemu_file_put_notify(QEMUFile *f)
{ {
return f->put_buffer(f->opaque, NULL, 0, 0); return f->ops->put_buffer(f->opaque, NULL, 0, 0);
} }
void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size) void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
@ -658,16 +670,16 @@ static int64_t qemu_ftell(QEMUFile *f)
int qemu_file_rate_limit(QEMUFile *f) int qemu_file_rate_limit(QEMUFile *f)
{ {
if (f->rate_limit) if (f->ops->rate_limit)
return f->rate_limit(f->opaque); return f->ops->rate_limit(f->opaque);
return 0; return 0;
} }
int64_t qemu_file_get_rate_limit(QEMUFile *f) int64_t qemu_file_get_rate_limit(QEMUFile *f)
{ {
if (f->get_rate_limit) if (f->ops->get_rate_limit)
return f->get_rate_limit(f->opaque); return f->ops->get_rate_limit(f->opaque);
return 0; return 0;
} }
@ -676,8 +688,8 @@ int64_t qemu_file_set_rate_limit(QEMUFile *f, int64_t new_rate)
{ {
/* any failed or completed migration keeps its state to allow probing of /* any failed or completed migration keeps its state to allow probing of
* migration data, but has no associated file anymore */ * migration data, but has no associated file anymore */
if (f && f->set_rate_limit) if (f && f->ops->set_rate_limit)
return f->set_rate_limit(f->opaque, new_rate); return f->ops->set_rate_limit(f->opaque, new_rate);
return 0; return 0;
} }