From nobody Tue Nov 26 09:42:28 2024 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; spf=pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) smtp.mailfrom=qemu-devel-bounces+importer=patchew.org@nongnu.org; dmarc=fail(p=none dis=none) header.from=redhat.com Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1709555873407560.0677641569087; Mon, 4 Mar 2024 04:37:53 -0800 (PST) Received: from localhost ([::1] helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1rh7VP-0003x0-Q1; Mon, 04 Mar 2024 07:33:21 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1rh7Se-0000iS-6d for qemu-devel@nongnu.org; Mon, 04 Mar 2024 07:30:40 -0500 Received: from mail.ozlabs.org ([2404:9400:2221:ea00::3] helo=gandalf.ozlabs.org) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1rh7S8-0004oq-HK for qemu-devel@nongnu.org; Mon, 04 Mar 2024 07:30:17 -0500 Received: from gandalf.ozlabs.org (gandalf.ozlabs.org [150.107.74.76]) by gandalf.ozlabs.org (Postfix) with ESMTP id 4TpJ1D172kz4x1R; Mon, 4 Mar 2024 23:29:52 +1100 (AEDT) Received: from authenticated.ozlabs.org (localhost [127.0.0.1]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by mail.ozlabs.org (Postfix) with ESMTPSA id 4TpJ170lKmz4x0q; Mon, 4 Mar 2024 23:29:46 +1100 (AEDT) From: =?UTF-8?q?C=C3=A9dric=20Le=20Goater?= To: qemu-devel@nongnu.org Cc: Peter Xu , Fabiano Rosas , Alex Williamson , Avihai Horon , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Markus Armbruster , =?UTF-8?q?C=C3=A9dric=20Le=20Goater?= , Stefano Stabellini , Anthony Perard , Paul Durrant , "Michael S. Tsirkin" , Paolo Bonzini , David Hildenbrand , Hyman Huang Subject: [PATCH v3 15/26] memory: Add Error** argument to the global_dirty_log routines Date: Mon, 4 Mar 2024 13:28:33 +0100 Message-ID: <20240304122844.1888308-16-clg@redhat.com> X-Mailer: git-send-email 2.44.0 In-Reply-To: <20240304122844.1888308-1-clg@redhat.com> References: <20240304122844.1888308-1-clg@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Received-SPF: pass (zohomail.com: domain of gnu.org designates 209.51.188.17 as permitted sender) client-ip=209.51.188.17; envelope-from=qemu-devel-bounces+importer=patchew.org@nongnu.org; helo=lists.gnu.org; Received-SPF: pass client-ip=2404:9400:2221:ea00::3; envelope-from=SRS0=mkh8=KK=redhat.com=clg@ozlabs.org; helo=gandalf.ozlabs.org X-Spam_score_int: -39 X-Spam_score: -4.0 X-Spam_bar: ---- X-Spam_report: (-4.0 / 5.0 requ) BAYES_00=-1.9, HEADER_FROM_DIFFERENT_DOMAINS=0.249, RCVD_IN_DNSWL_MED=-2.3, SPF_HELO_PASS=-0.001, SPF_PASS=-0.001, T_SCC_BODY_TEXT_LINE=-0.01 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: qemu-devel-bounces+importer=patchew.org@nongnu.org X-ZM-MESSAGEID: 1709555876528100003 Now that the log_global*() handlers take an Error** parameter and return a bool, do the same for memory_global_dirty_log_start() and memory_global_dirty_log_stop(). The error is reported in the callers for now and it will be propagated in the call stack in the next changes. To be noted a functional change in ram_init_bitmaps(), if the dirty pages logger fails to start, there is no need to synchronize the dirty pages bitmaps. colo_incoming_start_dirty_log() could be modified in a similar way. Cc: Stefano Stabellini Cc: Anthony Perard Cc: Paul Durrant Cc: "Michael S. Tsirkin" Cc: Paolo Bonzini Cc: David Hildenbrand Cc: Hyman Huang Signed-off-by: C=C3=A9dric Le Goater Reviewed-by: Hyman Huang --- include/exec/memory.h | 10 ++++++++-- hw/i386/xen/xen-hvm.c | 4 ++-- migration/dirtyrate.c | 21 +++++++++++++++++---- migration/ram.c | 34 ++++++++++++++++++++++++++++++---- system/memory.c | 30 ++++++++++++------------------ 5 files changed, 69 insertions(+), 30 deletions(-) diff --git a/include/exec/memory.h b/include/exec/memory.h index 4bc146c5ebdd377cd14a4e462f32cc945db5a0a8..8b019465ab13ce85c03075c8086= 5a0865ea1feed 100644 --- a/include/exec/memory.h +++ b/include/exec/memory.h @@ -2576,15 +2576,21 @@ void memory_listener_unregister(MemoryListener *lis= tener); * memory_global_dirty_log_start: begin dirty logging for all regions * * @flags: purpose of starting dirty log, migration or dirty rate + * @errp: pointer to Error*, to store an error if it happens. + * + * Return: true on success, else false setting @errp with error. */ -void memory_global_dirty_log_start(unsigned int flags); +bool memory_global_dirty_log_start(unsigned int flags, Error **errp); =20 /** * memory_global_dirty_log_stop: end dirty logging for all regions * * @flags: purpose of stopping dirty log, migration or dirty rate + * @errp: pointer to Error*, to store an error if it happens. + * + * Return: true on success, else false setting @errp with error. */ -void memory_global_dirty_log_stop(unsigned int flags); +bool memory_global_dirty_log_stop(unsigned int flags, Error **errp); =20 void mtree_info(bool flatview, bool dispatch_tree, bool owner, bool disabl= ed); =20 diff --git a/hw/i386/xen/xen-hvm.c b/hw/i386/xen/xen-hvm.c index 925a207b494b4eed52d5f360b554f18ac8a9806d..286269b47572d90e57df5ff4483= 5bb5f8e16c7ad 100644 --- a/hw/i386/xen/xen-hvm.c +++ b/hw/i386/xen/xen-hvm.c @@ -655,9 +655,9 @@ void xen_hvm_modified_memory(ram_addr_t start, ram_addr= _t length) void qmp_xen_set_global_dirty_log(bool enable, Error **errp) { if (enable) { - memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION); + memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION, errp); } else { - memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION); + memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION, errp); } } =20 diff --git a/migration/dirtyrate.c b/migration/dirtyrate.c index 1d2e85746fb7b10eb7f149976970f9a92125af8a..34f6d803ff5f4e6ccf2e06aaaed= 65a336c4be469 100644 --- a/migration/dirtyrate.c +++ b/migration/dirtyrate.c @@ -90,11 +90,17 @@ static int64_t do_calculate_dirtyrate(DirtyPageRecord d= irty_pages, =20 void global_dirty_log_change(unsigned int flag, bool start) { + Error *local_err =3D NULL; + bool ret; + bql_lock(); if (start) { - memory_global_dirty_log_start(flag); + ret =3D memory_global_dirty_log_start(flag, &local_err); } else { - memory_global_dirty_log_stop(flag); + ret =3D memory_global_dirty_log_stop(flag, &local_err); + } + if (!ret) { + error_report_err(local_err); } bql_unlock(); } @@ -106,10 +112,14 @@ void global_dirty_log_change(unsigned int flag, bool = start) */ static void global_dirty_log_sync(unsigned int flag, bool one_shot) { + Error *local_err =3D NULL; + bql_lock(); memory_global_dirty_log_sync(false); if (one_shot) { - memory_global_dirty_log_stop(flag); + if (!memory_global_dirty_log_stop(flag, &local_err)) { + error_report_err(local_err); + } } bql_unlock(); } @@ -608,9 +618,12 @@ static void calculate_dirtyrate_dirty_bitmap(struct Di= rtyRateConfig config) { int64_t start_time; DirtyPageRecord dirty_pages; + Error *local_err =3D NULL; =20 bql_lock(); - memory_global_dirty_log_start(GLOBAL_DIRTY_DIRTY_RATE); + if (!memory_global_dirty_log_start(GLOBAL_DIRTY_DIRTY_RATE, &local_err= )) { + error_report_err(local_err); + } =20 /* * 1'round of log sync may return all 1 bits with diff --git a/migration/ram.c b/migration/ram.c index 20c6ad9e759b2b8ec7ae26b7ca72d5cbd20d481f..3d9c08cfae8a59031a7c1b3c707= 21c2a90daceba 100644 --- a/migration/ram.c +++ b/migration/ram.c @@ -2390,6 +2390,7 @@ static void ram_save_cleanup(void *opaque) { RAMState **rsp =3D opaque; RAMBlock *block; + Error *local_err =3D NULL; =20 /* We don't use dirty log with background snapshots */ if (!migrate_background_snapshot()) { @@ -2402,7 +2403,10 @@ static void ram_save_cleanup(void *opaque) * memory_global_dirty_log_stop will assert that * memory_global_dirty_log_start/stop used in pairs */ - memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION); + if (!memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION, + &local_err)) { + error_report_err(local_err); + } } } =20 @@ -2799,18 +2803,31 @@ static void migration_bitmap_clear_discarded_pages(= RAMState *rs) =20 static void ram_init_bitmaps(RAMState *rs) { + Error *local_err =3D NULL; + bool ret =3D true; + qemu_mutex_lock_ramlist(); =20 WITH_RCU_READ_LOCK_GUARD() { ram_list_init_bitmaps(); /* We don't use dirty log with background snapshots */ if (!migrate_background_snapshot()) { - memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION); + ret =3D memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION, + &local_err); + if (!ret) { + error_report_err(local_err); + goto out_unlock; + } migration_bitmap_sync_precopy(rs, false); } } +out_unlock: qemu_mutex_unlock_ramlist(); =20 + if (!ret) { + return; + } + /* * After an eventual first bitmap sync, fixup the initial bitmap * containing all 1s to exclude any discarded pages from migration. @@ -3459,6 +3476,8 @@ int colo_init_ram_cache(void) void colo_incoming_start_dirty_log(void) { RAMBlock *block =3D NULL; + Error *local_err =3D NULL; + /* For memory_global_dirty_log_start below. */ bql_lock(); qemu_mutex_lock_ramlist(); @@ -3470,7 +3489,10 @@ void colo_incoming_start_dirty_log(void) /* Discard this dirty bitmap record */ bitmap_zero(block->bmap, block->max_length >> TARGET_PAGE_BITS= ); } - memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION); + if (!memory_global_dirty_log_start(GLOBAL_DIRTY_MIGRATION, + &local_err)) { + error_report_err(local_err); + } } ram_state->migration_dirty_pages =3D 0; qemu_mutex_unlock_ramlist(); @@ -3481,8 +3503,12 @@ void colo_incoming_start_dirty_log(void) void colo_release_ram_cache(void) { RAMBlock *block; + Error *local_err =3D NULL; + + if (!memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION, &local_err))= { + error_report_err(local_err); + } =20 - memory_global_dirty_log_stop(GLOBAL_DIRTY_MIGRATION); RAMBLOCK_FOREACH_NOT_IGNORED(block) { g_free(block->bmap); block->bmap =3D NULL; diff --git a/system/memory.c b/system/memory.c index af06157ead5b1272548e87f79ab9fb3036055328..48aed0f8ece1c731849636c442b= 8ab8e5d7ff6a5 100644 --- a/system/memory.c +++ b/system/memory.c @@ -2949,25 +2949,24 @@ static unsigned int postponed_stop_flags; static VMChangeStateEntry *vmstate_change; static bool memory_global_dirty_log_stop_postponed_run(Error **errp); =20 -void memory_global_dirty_log_start(unsigned int flags) +bool memory_global_dirty_log_start(unsigned int flags, Error **errp) { + ERRP_GUARD(); unsigned int old_flags; - Error *local_err =3D NULL; =20 assert(flags && !(flags & (~GLOBAL_DIRTY_MASK))); =20 if (vmstate_change) { /* If there is postponed stop(), operate on it first */ postponed_stop_flags &=3D ~flags; - if (!memory_global_dirty_log_stop_postponed_run(&local_err)) { - error_report_err(local_err); - return; + if (!memory_global_dirty_log_stop_postponed_run(errp)) { + return false; } } =20 flags &=3D ~global_dirty_tracking; if (!flags) { - return; + return true; } =20 old_flags =3D global_dirty_tracking; @@ -2975,16 +2974,15 @@ void memory_global_dirty_log_start(unsigned int fla= gs) trace_global_dirty_changed(global_dirty_tracking); =20 if (!old_flags) { - MEMORY_LISTENER_CALL_LOG_GLOBAL(log_global_start, Forward, - &local_err); - if (local_err) { - error_report_err(local_err); - return; + MEMORY_LISTENER_CALL_LOG_GLOBAL(log_global_start, Forward, errp); + if (*errp) { + return false; } memory_region_transaction_begin(); memory_region_update_pending =3D true; memory_region_transaction_commit(); } + return true; } =20 static bool memory_global_dirty_log_do_stop(unsigned int flags, Error **er= rp) @@ -3040,10 +3038,8 @@ static void memory_vm_change_state_handler(void *opa= que, bool running, } } =20 -void memory_global_dirty_log_stop(unsigned int flags) +bool memory_global_dirty_log_stop(unsigned int flags, Error **errp) { - Error *local_err =3D NULL; - if (!runstate_is_running()) { /* Postpone the dirty log stop, e.g., to when VM starts again */ if (vmstate_change) { @@ -3054,12 +3050,10 @@ void memory_global_dirty_log_stop(unsigned int flag= s) vmstate_change =3D qemu_add_vm_change_state_handler( memory_vm_change_state_handler, NULL); } - return; + return true; } =20 - if (!memory_global_dirty_log_do_stop(flags, &local_err)) { - error_report_err(local_err); - } + return memory_global_dirty_log_do_stop(flags, errp); } =20 static void listener_add_address_space(MemoryListener *listener, --=20 2.44.0