motorhead/qemu
1
0
Fork 0
mirror of https://github.com/Motorhead1991/qemu.git synced 2025-08-11 03:24:58 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions

migration: hardcode assumption that QEMUFile is backed with QIOChannel

Browse source 
The only callers of qemu_fopen_ops pass 'true' for the 'has_ioc'
parameter, so hardcode this assumption in QEMUFile, by passing in
the QIOChannel object as a non-opaque parameter.

Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Juan Quintela <quintela@redhat.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
   dgilbert: Fixed long line
This commit is contained in:
Daniel P. Berrangé 2022-06-20 12:01:56 +01:00 • committed by Dr. David Alan Gilbert
parent 365c0463db
commit 2893a2884b
3 changed files with 20 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

4
migration/qemu-file-channel.c
View file

@ -184,11 +184,11 @@ static const QEMUFileOps channel_output_ops = {
QEMUFile *qemu_fopen_channel_input(QIOChannel *ioc) QEMUFile *qemu_fopen_channel_input(QIOChannel *ioc)
{ {
object_ref(OBJECT(ioc)); object_ref(OBJECT(ioc));
return qemu_fopen_ops(ioc, &channel_input_ops, true); return qemu_fopen_ops(ioc, &channel_input_ops);
} }
QEMUFile *qemu_fopen_channel_output(QIOChannel *ioc) QEMUFile *qemu_fopen_channel_output(QIOChannel *ioc)
{ {
object_ref(OBJECT(ioc)); object_ref(OBJECT(ioc));
return qemu_fopen_ops(ioc, &channel_output_ops, true); return qemu_fopen_ops(ioc, &channel_output_ops);
} }

35
migration/qemu-file.c
View file

@ -37,7 +37,7 @@
struct QEMUFile { struct QEMUFile {
const QEMUFileOps *ops; const QEMUFileOps *ops;
const QEMUFileHooks *hooks; const QEMUFileHooks *hooks;
void *opaque; QIOChannel *ioc;
/* /*
* Maximum amount of data in bytes to transfer during one * Maximum amount of data in bytes to transfer during one
@ -65,8 +65,6 @@ struct QEMUFile {
Error *last_error_obj; Error *last_error_obj;
/* has the file has been shutdown */ /* has the file has been shutdown */
bool shutdown; bool shutdown;
/* Whether opaque points to a QIOChannel */
bool has_ioc;
}; };
/* /*
@ -81,7 +79,7 @@ int qemu_file_shutdown(QEMUFile *f)
if (!f->ops->shut_down) { if (!f->ops->shut_down) {
return -ENOSYS; return -ENOSYS;
} }
ret = f->ops->shut_down(f->opaque, true, true, NULL); ret = f->ops->shut_down(f->ioc, true, true, NULL);
if (!f->last_error) { if (!f->last_error) {
qemu_file_set_error(f, -EIO); qemu_file_set_error(f, -EIO);
@ -98,7 +96,7 @@ QEMUFile *qemu_file_get_return_path(QEMUFile *f)
if (!f->ops->get_return_path) { if (!f->ops->get_return_path) {
return NULL; return NULL;
} }
return f->ops->get_return_path(f->opaque); return f->ops->get_return_path(f->ioc);
} }
bool qemu_file_mode_is_not_valid(const char *mode) bool qemu_file_mode_is_not_valid(const char *mode)
@ -113,15 +111,15 @@ bool qemu_file_mode_is_not_valid(const char *mode)
return false; return false;
} }
QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops, bool has_ioc) QEMUFile *qemu_fopen_ops(QIOChannel *ioc, const QEMUFileOps *ops)
{ {
QEMUFile *f; QEMUFile *f;
f = g_new0(QEMUFile, 1); f = g_new0(QEMUFile, 1);
f->opaque = opaque; f->ioc = ioc;
f->ops = ops; f->ops = ops;
f->has_ioc = has_ioc;
return f; return f;
} }
@ -242,7 +240,7 @@ void qemu_fflush(QEMUFile *f)
} }
if (f->iovcnt > 0) { if (f->iovcnt > 0) {
expect = iov_size(f->iov, f->iovcnt); expect = iov_size(f->iov, f->iovcnt);
ret = f->ops->writev_buffer(f->opaque, f->iov, f->iovcnt, ret = f->ops->writev_buffer(f->ioc, f->iov, f->iovcnt,
f->total_transferred, &local_error); f->total_transferred, &local_error);
qemu_iovec_release_ram(f); qemu_iovec_release_ram(f);
@ -358,7 +356,7 @@ static ssize_t qemu_fill_buffer(QEMUFile *f)
return 0; return 0;
} }
len = f->ops->get_buffer(f->opaque, f->buf + pending, f->total_transferred, len = f->ops->get_buffer(f->ioc, f->buf + pending, f->total_transferred,
IO_BUF_SIZE - pending, &local_error); IO_BUF_SIZE - pending, &local_error);
if (len > 0) { if (len > 0) {
f->buf_size += len; f->buf_size += len;
@ -394,7 +392,7 @@ int qemu_fclose(QEMUFile *f)
ret = qemu_file_get_error(f); ret = qemu_file_get_error(f);
if (f->ops->close) { if (f->ops->close) {
int ret2 = f->ops->close(f->opaque, NULL); int ret2 = f->ops->close(f->ioc, NULL);
if (ret >= 0) { if (ret >= 0) {
ret = ret2; ret = ret2;
} }
@ -861,18 +859,19 @@ void qemu_put_counted_string(QEMUFile *f, const char *str)
void qemu_file_set_blocking(QEMUFile *f, bool block) void qemu_file_set_blocking(QEMUFile *f, bool block)
{ {
if (f->ops->set_blocking) { if (f->ops->set_blocking) {
f->ops->set_blocking(f->opaque, block, NULL); f->ops->set_blocking(f->ioc, block, NULL);
} }
} }
/* /*
* Return the ioc object if it's a migration channel. Note: it can return NULL * qemu_file_get_ioc:
* for callers passing in a non-migration qemufile. E.g. see qemu_fopen_bdrv() *
* and its usage in e.g. load_snapshot(). So we need to check against NULL * Get the ioc object for the file, without incrementing
* before using it. If without the check, migration_incoming_state_destroy() * the reference count.
* could fail for load_snapshot(). *
* Returns: the ioc object
*/ */
QIOChannel *qemu_file_get_ioc(QEMUFile *file) QIOChannel *qemu_file_get_ioc(QEMUFile *file)
{ {
return file->has_ioc ? QIO_CHANNEL(file->opaque) : NULL; return file->ioc;
} }

2
migration/qemu-file.h
View file

@ -118,7 +118,7 @@ typedef struct QEMUFileHooks {
QEMURamSaveFunc *save_page; QEMURamSaveFunc *save_page;
} QEMUFileHooks; } QEMUFileHooks;
QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops, bool has_ioc); QEMUFile *qemu_fopen_ops(QIOChannel *ioc, const QEMUFileOps *ops);
void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks); void qemu_file_set_hooks(QEMUFile *f, const QEMUFileHooks *hooks);
int qemu_get_fd(QEMUFile *f); int qemu_get_fd(QEMUFile *f);
int qemu_fclose(QEMUFile *f); int qemu_fclose(QEMUFile *f);