starred/qemu-qemu
1
0
Fork 0
mirror of https://github.com/qemu/qemu.git synced 2026-07-08 17:46:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

migration: Refactor migration_completion_precopy() to return bool

Browse Source 
migration_completion_precopy() reports its error through the Error
**errp argument, so its int return value carries no information beyond
success/failure. Convert it to return a bool, matching the common
convention.

Convert its underlying helper qemu_savevm_state_complete_precopy()
likewise, and in turn qemu_savevm_state_non_iterable(), which it calls.
Adjust all callers accordingly.

Refactor and clean migration_completion() code too, which no longer
needs to track int return values.

Signed-off-by: Avihai Horon <avihaih@nvidia.com>
Reviewed-by: Cédric Le Goater <clg@redhat.com>
Link: https://lore.kernel.org/qemu-devel/20260706085211.13905-16-avihaih@nvidia.com
Signed-off-by: Cédric Le Goater <clg@redhat.com>
This commit is contained in:
Avihai Horon
2026-07-06 11:52:10 +03:00
committed by Cédric Le Goater
parent 13a9616805
commit 511b786d13
3 changed files with 31 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
migration/migration.c
View File

@@ -2659,8 +2659,7 @@ static int postcopy_start(MigrationState *ms, Error **errp)
*/
qemu_savevm_send_postcopy_listen(fb);
ret = qemu_savevm_state_non_iterable(fb, errp);
if (ret) {
if (!qemu_savevm_state_non_iterable(fb, errp)) {
error_prepend(errp, "Postcopy save non-iterable states failed: ");
goto fail_closefb;
}
@@ -2858,22 +2857,22 @@ static bool migration_switchover_start(MigrationState *s, Error **errp)
return true;
}
static int migration_completion_precopy(MigrationState *s, Error **errp)
static bool migration_completion_precopy(MigrationState *s, Error **errp)
{
int ret;
bool ret = false;
bql_lock();
if (!migrate_mode_is_cpr()) {
ret = migration_stop_vm(s, RUN_STATE_FINISH_MIGRATE);
if (ret < 0) {
error_setg_errno(errp, -ret, "Failed to stop the VM");
int r = migration_stop_vm(s, RUN_STATE_FINISH_MIGRATE);
if (r < 0) {
error_setg_errno(errp, -r, "Failed to stop the VM");
goto out_unlock;
}
}
if (!migration_switchover_start(s, errp)) {
ret = -EFAULT;
goto out_unlock;
}
@@ -2910,18 +2909,17 @@ static void migration_completion_postcopy(MigrationState *s)
*/
static void migration_completion(MigrationState *s)
{
int ret = 0;
Error *local_err = NULL;
if (s->state == MIGRATION_STATUS_ACTIVE) {
ret = migration_completion_precopy(s, &local_err);
if (!migration_completion_precopy(s, &local_err)) {
goto fail;
}
} else if (s->state == MIGRATION_STATUS_POSTCOPY_ACTIVE) {
migration_completion_postcopy(s);
} else {
ret = -1;
}
if (ret < 0) {
error_setg(&local_err, "Unexpected migration completion status %s",
MigrationStatus_str(s->state));
goto fail;
}
@@ -2945,12 +2943,7 @@ static void migration_completion(MigrationState *s)
return;
fail:
if (local_err) {
migrate_error_propagate(s, local_err);
} else if (qemu_file_get_error_obj(s->to_dst_file, &local_err)) {
migrate_error_propagate(s, local_err);
} else if (ret) {
error_setg_errno(&local_err, -ret, "Error in migration completion");
if (local_err || qemu_file_get_error_obj(s->to_dst_file, &local_err)) {
migrate_error_propagate(s, local_err);
}
@@ -3863,7 +3856,7 @@ static void *bg_migration_thread(void *opaque)
goto fail_with_bql;
}
if (qemu_savevm_state_non_iterable(fb, &local_err)) {
if (!qemu_savevm_state_non_iterable(fb, &local_err)) {
error_prepend(&local_err, "Failed to save non-iterable devices ");
goto fail_with_bql;
}

32
migration/savevm.c
View File

@@ -1737,13 +1737,12 @@ void qemu_savevm_state_end_precopy(MigrationState *s, QEMUFile *f)
qemu_savevm_state_vm_desc(s, f);
}
int qemu_savevm_state_non_iterable(QEMUFile *f, Error **errp)
bool qemu_savevm_state_non_iterable(QEMUFile *f, Error **errp)
{
MigrationState *ms = migrate_get_current();
int64_t start_ts_each, end_ts_each;
JSONWriter *vmdesc = ms->vmdesc;
SaveStateEntry *se;
int ret;
/* Making sure cpu states are synchronized before saving non-iterable */
cpu_synchronize_all_states();
@@ -1756,9 +1755,8 @@ int qemu_savevm_state_non_iterable(QEMUFile *f, Error **errp)
start_ts_each = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
ret = vmstate_save(f, se, vmdesc, errp);
if (ret) {
return ret;
if (vmstate_save(f, se, vmdesc, errp) < 0) {
return false;
}
end_ts_each = qemu_clock_get_us(QEMU_CLOCK_REALTIME);
@@ -1768,10 +1766,10 @@ int qemu_savevm_state_non_iterable(QEMUFile *f, Error **errp)
trace_vmstate_downtime_checkpoint("src-non-iterable-saved");
return 0;
return true;
}
int qemu_savevm_state_complete_precopy(MigrationState *s, Error **errp)
bool qemu_savevm_state_complete_precopy(MigrationState *s, Error **errp)
{
ERRP_GUARD();
QEMUFile *f = s->to_dst_file;
@@ -1781,12 +1779,11 @@ int qemu_savevm_state_complete_precopy(MigrationState *s, Error **errp)
if (ret) {
qemu_file_get_error_obj(f, errp);
error_prepend(errp, "Failed to save iterable device state: ");
return ret;
return false;
}
ret = qemu_savevm_state_non_iterable(f, errp);
if (ret) {
return ret;
if (!qemu_savevm_state_non_iterable(f, errp)) {
return false;
}
qemu_savevm_state_end_precopy(s, f);
@@ -1795,10 +1792,10 @@ int qemu_savevm_state_complete_precopy(MigrationState *s, Error **errp)
if (ret) {
qemu_file_get_error_obj(f, errp);
error_prepend(errp, "Failed to flush QEMUFile: ");
return ret;
return false;
}
return 0;
return true;
}
static void qemu_savevm_query_pending(MigrationState *s,
@@ -1928,7 +1925,9 @@ static int qemu_savevm_state(QEMUFile *f, Error **errp)
goto cleanup;
}
ret = qemu_savevm_state_complete_precopy(ms, errp);
if (!qemu_savevm_state_complete_precopy(ms, errp)) {
ret = -1;
}
cleanup:
qemu_savevm_state_cleanup();
@@ -1962,9 +1961,8 @@ int qemu_save_device_state(QEMUFile *f, Error **errp)
return ret;
}
ret = qemu_savevm_state_non_iterable(f, errp);
if (ret) {
return ret;
if (!qemu_savevm_state_non_iterable(f, errp)) {
return -1;
}
qemu_savevm_state_end(f);

4
migration/savevm.h
View File

@@ -44,7 +44,7 @@ void qemu_savevm_state_header(QEMUFile *f);
int qemu_savevm_state_iterate(QEMUFile *f, bool postcopy);
void qemu_savevm_state_cleanup(void);
void qemu_savevm_state_complete_postcopy(QEMUFile *f);
int qemu_savevm_state_complete_precopy(MigrationState *s, Error **errp);
bool qemu_savevm_state_complete_precopy(MigrationState *s, Error **errp);
void qemu_savevm_query_pending_iter(MigrationState *s, MigPendingData *pending,
bool exact);
bool qemu_savevm_query_pending_final(MigrationState *s,
@@ -74,7 +74,7 @@ int qemu_loadvm_state_main(QEMUFile *f, MigrationIncomingState *mis,
Error **errp);
int qemu_load_device_state(QEMUFile *f, Error **errp);
int qemu_loadvm_approve_switchover(const char *approver);
int qemu_savevm_state_non_iterable(QEMUFile *f, Error **errp);
bool qemu_savevm_state_non_iterable(QEMUFile *f, Error **errp);
int qemu_savevm_state_non_iterable_early(QEMUFile *f,
JSONWriter *vmdesc,
Error **errp);