From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610026660; cv=none; d=zohomail.com; s=zohoarc; b=PmFP6BpIkBM6Yub3sdrIXwr/00495KAXO99ntwozbIs4419GE6GdJ6isRJ35k6M+MYt/KYDXDXtl9mhQeAUc3XCKTdlSRUT0sAOOt9zo5lMfG+ewPsL58aKJ4SkrGV3mO0y33hphJTXpf24xKFuJwpf/STZAyYqNyw1LRfnGutw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610026660; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=Dy1ZZY0ZHnLHtYewSSoq4Ihnmm7sy7AHSwV/WxbUlVY=; b=GTi02QyOLeFc1cFah6Zhli109wdeyopTuTHdNljTQ/JLyUlG5Zw7fCW6gGyiQ+klBZaTV1BRNe1W88YFr/ofh1zxihAvzIiAhxt/g0LzU/xfAXEQZKOsyWuWCz/hNr8DdSryVQ+B6lskCwHEDInq9wrJhD+JnBtP0I5FvI+5/Rk= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610026660609422.6816260399502; Thu, 7 Jan 2021 05:37:40 -0800 (PST) Received: from localhost ([::1]:45764 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVTu-0005q2-3v for importer@patchew.org; Thu, 07 Jan 2021 08:37:38 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:35540) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVRR-0004RX-9k for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:05 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:22797) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVRO-0003s8-Uz for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:05 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-436-ZVpCKl-JP4m7qp18hdaV9Q-1; Thu, 07 Jan 2021 08:35:00 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id C24521005504; Thu, 7 Jan 2021 13:34:58 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 0BD9B18811; Thu, 7 Jan 2021 13:34:45 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026502; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=Dy1ZZY0ZHnLHtYewSSoq4Ihnmm7sy7AHSwV/WxbUlVY=; b=Pc0Ck6aoH84jffSm3aa34PfyYJrghGinKbS8Z4J1d5tqCWIEzG6+m9z/dOOnwfPpbmQVUI fp3mPu5WjjWpMe7dKb49XO3+nVCs4xN9QQUvpKGH1TR6abJI4ZxbjYQwR1AVYLx52nGFxB gbAZhQHrw6cLFXMLkrkiA3OguInOFo4= X-MC-Unique: ZVpCKl-JP4m7qp18hdaV9Q-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 01/11] memory: Introduce RamDiscardMgr for RAM memory regions Date: Thu, 7 Jan 2021 14:34:13 +0100 Message-Id: <20210107133423.44964-2-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Marek Kedzierski , Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , Alex Williamson , Peter Xu , "Dr . David Alan Gilbert" , Auger Eric , Pankaj Gupta , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" We have some special RAM memory regions (managed by virtio-mem), whereby the guest agreed to only use selected memory ranges. "unused" parts are discarded so they won't consume memory - to logically unplug these memory ranges. Before the VM is allowed to use such logically unplugged memory again, coordination with the hypervisor is required. This results in "sparse" mmaps/RAMBlocks/memory regions, whereby only coordinated parts are valid to be used/accessed by the VM. In most cases, we don't care about that - e.g., in KVM, we simply have a single KVM memory slot. However, in case of vfio, registering the whole region with the kernel results in all pages getting pinned, and therefore an unexpected high memory consumption - discarding of RAM in that context is broken. Let's introduce a way to coordinate discarding/populating memory within a RAM memory region with such special consumers of RAM memory regions: they can register as listeners and get updates on memory getting discarded and populated. Using this machinery, vfio will be able to map only the currently populated parts, resulting in discarded parts not getting pinned and not consuming memory. A RamDiscardMgr has to be set for a memory region before it is getting mapped, and cannot change while the memory region is mapped. Note: At some point, we might want to let RAMBlock users (esp. vfio used for nvme://) consume this interface as well. We'll need RAMBlock notifier calls when a RAMBlock is getting mapped/unmapped (via the corresponding memory region), so we can properly register a listener there as well. Reviewed-by: Pankaj Gupta Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- include/exec/memory.h | 231 ++++++++++++++++++++++++++++++++++++++++++ softmmu/memory.c | 22 ++++ 2 files changed, 253 insertions(+) diff --git a/include/exec/memory.h b/include/exec/memory.h index 521d9901d7..67d9f1f3a7 100644 --- a/include/exec/memory.h +++ b/include/exec/memory.h @@ -42,6 +42,12 @@ typedef struct IOMMUMemoryRegionClass IOMMUMemoryRegionC= lass; DECLARE_OBJ_CHECKERS(IOMMUMemoryRegion, IOMMUMemoryRegionClass, IOMMU_MEMORY_REGION, TYPE_IOMMU_MEMORY_REGION) =20 +#define TYPE_RAM_DISCARD_MGR "qemu:ram-discard-mgr" +typedef struct RamDiscardMgrClass RamDiscardMgrClass; +typedef struct RamDiscardMgr RamDiscardMgr; +DECLARE_OBJ_CHECKERS(RamDiscardMgr, RamDiscardMgrClass, RAM_DISCARD_MGR, + TYPE_RAM_DISCARD_MGR); + #ifdef CONFIG_FUZZ void fuzz_dma_read_cb(size_t addr, size_t len, @@ -126,6 +132,66 @@ typedef struct IOMMUTLBEvent { IOMMUTLBEntry entry; } IOMMUTLBEvent; =20 +struct RamDiscardListener; +typedef int (*NotifyRamPopulate)(struct RamDiscardListener *rdl, + const MemoryRegion *mr, ram_addr_t offset, + ram_addr_t size); +typedef void (*NotifyRamDiscard)(struct RamDiscardListener *rdl, + const MemoryRegion *mr, ram_addr_t offset, + ram_addr_t size); +typedef void (*NotifyRamDiscardAll)(struct RamDiscardListener *rdl, + const MemoryRegion *mr); + +typedef struct RamDiscardListener { + /* + * @notify_populate: + * + * Notification that previously discarded memory is about to get popul= ated. + * Listeners are able to object. If any listener objects, already + * successfully notified listeners are notified about a discard again. + * + * @rdl: the #RamDiscardListener getting notified + * @mr: the relevant #MemoryRegion + * @offset: offset into the #MemoryRegion, aligned to minimum granular= ity of + * the #RamDiscardMgr + * @size: the size, aligned to minimum granularity of the #RamDiscardM= gr + * + * Returns 0 on success. If the notification is rejected by the listen= er, + * an error is returned. + */ + NotifyRamPopulate notify_populate; + + /* + * @notify_discard: + * + * Notification that previously populated memory was discarded success= fully + * and listeners should drop all references to such memory and prevent + * new population (e.g., unmap). + * + * @rdl: the #RamDiscardListener getting notified + * @mr: the relevant #MemoryRegion + * @offset: offset into the #MemoryRegion, aligned to minimum granular= ity of + * the #RamDiscardMgr + * @size: the size, aligned to minimum granularity of the #RamDiscardM= gr + */ + NotifyRamDiscard notify_discard; + + /* + * @notify_discard_all: + * + * Notification that all previously populated memory was discarded + * successfully. + * + * Note: this callback is optional. If not set, individual notify_popu= late() + * notifications are triggered. + * + * @rdl: the #RamDiscardListener getting notified + * @mr: the relevant #MemoryRegion + */ + NotifyRamDiscardAll notify_discard_all; + QLIST_ENTRY(RamDiscardListener) next; +} RamDiscardListener; + /* RAM is pre-allocated and passed into qemu_ram_alloc_from_ptr */ #define RAM_PREALLOC (1 << 0) =20 @@ -161,6 +227,16 @@ static inline void iommu_notifier_init(IOMMUNotifier *= n, IOMMUNotify fn, n->iommu_idx =3D iommu_idx; } =20 +static inline void ram_discard_listener_init(RamDiscardListener *rdl, + NotifyRamPopulate populate_fn, + NotifyRamDiscard discard_fn, + NotifyRamDiscardAll discard_a= ll_fn) +{ + rdl->notify_populate =3D populate_fn; + rdl->notify_discard =3D discard_fn; + rdl->notify_discard_all =3D discard_all_fn; +} + /* * Memory region callbacks */ @@ -435,6 +511,126 @@ struct IOMMUMemoryRegionClass { Error **errp); }; =20 +/* + * RamDiscardMgrClass: + * + * A #RamDiscardMgr coordinates which parts of specific RAM #MemoryRegion + * regions are currently populated to be used/accessed by the VM, notifying + * after parts were discarded (freeing up memory) and before parts will be + * populated (consuming memory), to be used/acessed by the VM. + * + * A #RamDiscardMgr can only be set for a RAM #MemoryRegion while the + * #MemoryRegion isn't mapped yet; it cannot change while the #MemoryRegio= n is + * mapped. + * + * The #RamDiscardMgr is intended to be used by technologies that are + * incompatible with discarding of RAM (e.g., VFIO, which may pin all + * memory inside a #MemoryRegion), and require proper coordination to only + * map the currently populated parts, to hinder parts that are expected to + * remain discarded from silently getting populated and consuming memory. + * Technologies that support discarding of RAM don't have to bother and can + * simply map the whole #MemoryRegion. + * + * An example #RamDiscardMgr is virtio-mem, which logically (un)plugs + * memory within an assigned RAM #MemoryRegion, coordinated with the VM. + * Logically unplugging memory consists of discarding RAM. The VM agreed t= o not + * access unplugged (discarded) memory - especially via DMA. virtio-mem wi= ll + * properly coordinate with listeners before memory is plugged (populated), + * and after memory is unplugged (discarded). + * + * Listeners are called in multiples of the minimum granularity and change= s are + * aligned to the minimum granularity within the #MemoryRegion. Listeners = have + * to prepare for memory becomming discarded in a different granularity th= an it + * was populated and the other way around. + */ +struct RamDiscardMgrClass { + /* private */ + InterfaceClass parent_class; + + /* public */ + + /** + * @get_min_granularity: + * + * Get the minimum granularity in which listeners will get notified + * about changes within the #MemoryRegion via the #RamDiscardMgr. + * + * @rdm: the #RamDiscardMgr + * @mr: the #MemoryRegion + * + * Returns the minimum granularity. + */ + uint64_t (*get_min_granularity)(const RamDiscardMgr *rdm, + const MemoryRegion *mr); + + /** + * @is_populated: + * + * Check whether the given range within the #MemoryRegion is completely + * populated (i.e., no parts are currently discarded). There are no + * alignment requirements for the range. + * + * @rdm: the #RamDiscardMgr + * @mr: the #MemoryRegion + * @offset: offset into the #MemoryRegion + * @size: size in the #MemoryRegion + * + * Returns whether the given range is completely populated. + */ + bool (*is_populated)(const RamDiscardMgr *rdm, const MemoryRegion *mr, + ram_addr_t start, ram_addr_t offset); + + /** + * @register_listener: + * + * Register a #RamDiscardListener for a #MemoryRegion via the + * #RamDiscardMgr and immediately notify the #RamDiscardListener about= all + * populated parts within the #MemoryRegion via the #RamDiscardMgr. + * + * In case any notification fails, no further notifications are trigge= red + * and an error is logged. + * + * @rdm: the #RamDiscardMgr + * @mr: the #MemoryRegion + * @rdl: the #RamDiscardListener + */ + void (*register_listener)(RamDiscardMgr *rdm, const MemoryRegion *mr, + RamDiscardListener *rdl); + + /** + * @unregister_listener: + * + * Unregister a previously registered #RamDiscardListener for a + * #MemoryRegion via the #RamDiscardMgr after notifying the + * #RamDiscardListener about all populated parts becoming unpopulated + * within the #MemoryRegion via the #RamDiscardMgr. + * + * @rdm: the #RamDiscardMgr + * @mr: the #MemoryRegion + * @rdl: the #RamDiscardListener + */ + void (*unregister_listener)(RamDiscardMgr *rdm, const MemoryRegion *mr, + RamDiscardListener *rdl); + + /** + * @replay_populated: + * + * Notify the #RamDiscardListener about all populated parts within the + * #MemoryRegion via the #RamDiscardMgr. + * + * In case any notification fails, no further notifications are trigge= red. + * The listener is not required to be registered. + * + * @rdm: the #RamDiscardMgr + * @mr: the #MemoryRegion + * @rdl: the #RamDiscardListener + * + * Returns 0 on success, or a negative error if any notification faile= d. + */ + int (*replay_populated)(const RamDiscardMgr *rdm, const MemoryRegion *= mr, + RamDiscardListener *rdl); +}; + typedef struct CoalescedMemoryRange CoalescedMemoryRange; typedef struct MemoryRegionIoeventfd MemoryRegionIoeventfd; =20 @@ -481,6 +677,7 @@ struct MemoryRegion { const char *name; unsigned ioeventfd_nb; MemoryRegionIoeventfd *ioeventfds; + RamDiscardMgr *rdm; /* Only for RAM */ }; =20 struct IOMMUMemoryRegion { @@ -1969,6 +2166,40 @@ bool memory_region_present(MemoryRegion *container, = hwaddr addr); */ bool memory_region_is_mapped(MemoryRegion *mr); =20 +/** + * memory_region_get_ram_discard_mgr: get the #RamDiscardMgr for a + * #MemoryRegion + * + * The #RamDiscardMgr cannot change while a memory region is mapped. + * + * @mr: the #MemoryRegion + */ +RamDiscardMgr *memory_region_get_ram_discard_mgr(MemoryRegion *mr); + +/** + * memory_region_has_ram_discard_mgr: check whether a #MemoryRegion has a + * #RamDiscardMgr assigned + * + * @mr: the #MemoryRegion + */ +static inline bool memory_region_has_ram_discard_mgr(MemoryRegion *mr) +{ + return !!memory_region_get_ram_discard_mgr(mr); +} + +/** + * memory_region_set_ram_discard_mgr: set the #RamDiscardMgr for a + * #MemoryRegion + * + * This function must not be called for a mapped #MemoryRegion, a #MemoryR= egion + * that does not cover RAM, or a #MemoryRegion that already has a + * #RamDiscardMgr assigned. + * + * @mr: the #MemoryRegion + * @urn: #RamDiscardMgr to set + */ +void memory_region_set_ram_discard_mgr(MemoryRegion *mr, RamDiscardMgr *rd= m); + /** * memory_region_find: translate an address/size relative to a * MemoryRegion into a #MemoryRegionSection. diff --git a/softmmu/memory.c b/softmmu/memory.c index 333e1ed7b0..61fa6290e4 100644 --- a/softmmu/memory.c +++ b/softmmu/memory.c @@ -2025,6 +2025,21 @@ int memory_region_iommu_num_indexes(IOMMUMemoryRegio= n *iommu_mr) return imrc->num_indexes(iommu_mr); } =20 +RamDiscardMgr *memory_region_get_ram_discard_mgr(MemoryRegion *mr) +{ + if (!memory_region_is_mapped(mr) || !memory_region_is_ram(mr)) { + return NULL; + } + return mr->rdm; +} + +void memory_region_set_ram_discard_mgr(MemoryRegion *mr, RamDiscardMgr *rd= m) +{ + g_assert(memory_region_is_ram(mr) && !memory_region_is_mapped(mr)); + g_assert(!rdm || !mr->rdm); + mr->rdm =3D rdm; +} + void memory_region_set_log(MemoryRegion *mr, bool log, unsigned client) { uint8_t mask =3D 1 << client; @@ -3306,10 +3321,17 @@ static const TypeInfo iommu_memory_region_info =3D { .abstract =3D true, }; =20 +static const TypeInfo ram_discard_mgr_info =3D { + .parent =3D TYPE_INTERFACE, + .name =3D TYPE_RAM_DISCARD_MGR, + .class_size =3D sizeof(RamDiscardMgrClass), +}; + static void memory_register_types(void) { type_register_static(&memory_region_info); type_register_static(&iommu_memory_region_info); + type_register_static(&ram_discard_mgr_info); } =20 type_init(memory_register_types) --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610026678; cv=none; d=zohomail.com; s=zohoarc; b=Ghly6mULF5UCd7Vu8ubr6u2QJIi/9kAT4EXwebJxzNf3jAYvBmeLf3I4XYBKofpg5sAfA5EqgF3ZWaBFiuC8bXFmO9Ht+CgzaG0N6hnVcyX6siZHbrxs+iC6AGTV+H9eRvKH7T6v12MTHTMhDJeWJugI4R09r69wS8QxspWPiPk= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610026678; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=EHFdQA7aTBQT13RD0wAY2nXbum2oXJWh4vl0UvSD72U=; b=ful8g5N6yetnPHletLsEIATfQuFvFLNsgJr0ZWyja6DhFAzDhuevgd7RaeG3Q+csHTbFDyAYB6Ufsqg42nn3E5ldhv1jk9hik7OTnsNKamIZOsxHT0M4mBfI1bCAiJ3I7g0wxMeN2oUXkFsb6jS/L9LB3RiVxDZ52M2CY0II1W0= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 161002667810520.9167067881192; Thu, 7 Jan 2021 05:37:58 -0800 (PST) Received: from localhost ([::1]:46624 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVUB-0006CE-Ha for importer@patchew.org; Thu, 07 Jan 2021 08:37:55 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:35616) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVRj-0004eX-JK for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:23 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:53692) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVRh-0004A8-Jb for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:23 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-302-g4jHZgZcMpycAj2HkqLQ2w-1; Thu, 07 Jan 2021 08:35:18 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id ADD59B8100; Thu, 7 Jan 2021 13:35:16 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1A4EF71C82; Thu, 7 Jan 2021 13:34:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026519; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=EHFdQA7aTBQT13RD0wAY2nXbum2oXJWh4vl0UvSD72U=; b=TfNKGt2BbJ/tXVcdiWvNMMX5xjy4P3HY71U0qjHWJlFsiYxtFwZk2bRDS6Ntbkyol8yFh2 bdc792B6EE/gCFmKwls3EXUhTNddV0pA8YuWhfPNjGcWpoDL45nnReZtKBcapFQmgWOrxk 4T5W+1wyNizdYGoINuzgndUpfpg6U+Y= X-MC-Unique: g4jHZgZcMpycAj2HkqLQ2w-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 02/11] virtio-mem: Factor out traversing unplugged ranges Date: Thu, 7 Jan 2021 14:34:14 +0100 Message-Id: <20210107133423.44964-3-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Marek Kedzierski , Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , Alex Williamson , Peter Xu , "Dr . David Alan Gilbert" , Auger Eric , Pankaj Gupta , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Let's factor out the core logic, to be reused soon. Reviewed-by: Pankaj Gupta Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- hw/virtio/virtio-mem.c | 86 ++++++++++++++++++++++++------------------ 1 file changed, 49 insertions(+), 37 deletions(-) diff --git a/hw/virtio/virtio-mem.c b/hw/virtio/virtio-mem.c index 655824ff81..471e464171 100644 --- a/hw/virtio/virtio-mem.c +++ b/hw/virtio/virtio-mem.c @@ -145,6 +145,33 @@ static bool virtio_mem_is_busy(void) return migration_in_incoming_postcopy() || !migration_is_idle(); } =20 +typedef int (*virtio_mem_range_cb)(const VirtIOMEM *vmem, void *arg, + uint64_t offset, uint64_t size); + +static int virtio_mem_for_each_unplugged_range(const VirtIOMEM *vmem, void= *arg, + virtio_mem_range_cb cb) +{ + unsigned long first_zero_bit, last_zero_bit; + uint64_t offset, size; + int ret =3D 0; + + first_zero_bit =3D find_first_zero_bit(vmem->bitmap, vmem->bitmap_size= ); + while (first_zero_bit < vmem->bitmap_size) { + offset =3D first_zero_bit * vmem->block_size; + last_zero_bit =3D find_next_bit(vmem->bitmap, vmem->bitmap_size, + first_zero_bit + 1) - 1; + size =3D (last_zero_bit - first_zero_bit + 1) * vmem->block_size; + + ret =3D cb(vmem, arg, offset, size); + if (ret) { + break; + } + first_zero_bit =3D find_next_zero_bit(vmem->bitmap, vmem->bitmap_s= ize, + last_zero_bit + 2); + } + return ret; +} + static bool virtio_mem_test_bitmap(VirtIOMEM *vmem, uint64_t start_gpa, uint64_t size, bool plugged) { @@ -594,33 +621,27 @@ static void virtio_mem_device_unrealize(DeviceState *= dev) ram_block_discard_require(false); } =20 -static int virtio_mem_restore_unplugged(VirtIOMEM *vmem) +static int virtio_mem_discard_range_cb(const VirtIOMEM *vmem, void *arg, + uint64_t offset, uint64_t size) { RAMBlock *rb =3D vmem->memdev->mr.ram_block; - unsigned long first_zero_bit, last_zero_bit; - uint64_t offset, length; int ret; =20 - /* Find consecutive unplugged blocks and discard the consecutive range= . */ - first_zero_bit =3D find_first_zero_bit(vmem->bitmap, vmem->bitmap_size= ); - while (first_zero_bit < vmem->bitmap_size) { - offset =3D first_zero_bit * vmem->block_size; - last_zero_bit =3D find_next_bit(vmem->bitmap, vmem->bitmap_size, - first_zero_bit + 1) - 1; - length =3D (last_zero_bit - first_zero_bit + 1) * vmem->block_size; - - ret =3D ram_block_discard_range(rb, offset, length); - if (ret) { - error_report("Unexpected error discarding RAM: %s", - strerror(-ret)); - return -EINVAL; - } - first_zero_bit =3D find_next_zero_bit(vmem->bitmap, vmem->bitmap_s= ize, - last_zero_bit + 2); + ret =3D ram_block_discard_range(rb, offset, size); + if (ret) { + error_report("Unexpected error discarding RAM: %s", strerror(-ret)= ); + return -EINVAL; } return 0; } =20 +static int virtio_mem_restore_unplugged(VirtIOMEM *vmem) +{ + /* Make sure all memory is really discarded after migration. */ + return virtio_mem_for_each_unplugged_range(vmem, NULL, + virtio_mem_discard_range_cb= ); +} + static int virtio_mem_post_load(void *opaque, int version_id) { if (migration_in_incoming_postcopy()) { @@ -872,28 +893,19 @@ static void virtio_mem_set_block_size(Object *obj, Vi= sitor *v, const char *name, vmem->block_size =3D value; } =20 -static void virtio_mem_precopy_exclude_unplugged(VirtIOMEM *vmem) +static int virtio_mem_precopy_exclude_range_cb(const VirtIOMEM *vmem, void= *arg, + uint64_t offset, uint64_t s= ize) { void * const host =3D qemu_ram_get_host_addr(vmem->memdev->mr.ram_bloc= k); - unsigned long first_zero_bit, last_zero_bit; - uint64_t offset, length; =20 - /* - * Find consecutive unplugged blocks and exclude them from migration. - * - * Note: Blocks cannot get (un)plugged during precopy, no locking need= ed. - */ - first_zero_bit =3D find_first_zero_bit(vmem->bitmap, vmem->bitmap_size= ); - while (first_zero_bit < vmem->bitmap_size) { - offset =3D first_zero_bit * vmem->block_size; - last_zero_bit =3D find_next_bit(vmem->bitmap, vmem->bitmap_size, - first_zero_bit + 1) - 1; - length =3D (last_zero_bit - first_zero_bit + 1) * vmem->block_size; + qemu_guest_free_page_hint(host + offset, size); + return 0; +} =20 - qemu_guest_free_page_hint(host + offset, length); - first_zero_bit =3D find_next_zero_bit(vmem->bitmap, vmem->bitmap_s= ize, - last_zero_bit + 2); - } +static void virtio_mem_precopy_exclude_unplugged(VirtIOMEM *vmem) +{ + virtio_mem_for_each_unplugged_range(vmem, NULL, + virtio_mem_precopy_exclude_range_c= b); } =20 static int virtio_mem_precopy_notify(NotifierWithReturn *n, void *data) --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610027097; cv=none; d=zohomail.com; s=zohoarc; b=KSf1pYLH6dLg++w/4DFAQK92Jha3nriJFjxVd/DU/S9mCxR7rlM60vWEuxPWE4KswdfNOrZvef4Vjk/+Cx73mJ53BqV+2xI6VGJBkjoSZ+bM4GZsp3+NnU60fIRhixTI6bUwoya2DlNPo4c1tUbqHpkwI2kBzUE9YImTjahenrE= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610027097; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=sAcvYCzOsfSzsISlhG1Pg4+ha0mhGX0n8M02y24P1s4=; b=UF7k3L7tZCoY5aSpD9sKobfWJFZdUyp4d9aVm+EFEEvIGy1cwN33H71FNk1Hi4ODvTTkm+U8XGdT3cmUnCEdVhZY8GqkDE5qgEtgkchAn1/lhdyXE1nuqVhnQCl8b2ahQgIfis9VQvRphJJZNX8UBFRoMHdue2TCtB6y4Vvdunc= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610027097768348.42530687154647; Thu, 7 Jan 2021 05:44:57 -0800 (PST) Received: from localhost ([::1]:37768 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVay-0005oC-KH for importer@patchew.org; Thu, 07 Jan 2021 08:44:56 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:35758) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVS5-0004wJ-IF for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:45 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:24693) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVS2-0004SR-TM for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:45 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-29-youk8R1YMbSoRfYg-py3iA-1; Thu, 07 Jan 2021 08:35:38 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 1C86F1800D42; Thu, 7 Jan 2021 13:35:37 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 0D3A35C67A; Thu, 7 Jan 2021 13:35:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026542; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=sAcvYCzOsfSzsISlhG1Pg4+ha0mhGX0n8M02y24P1s4=; b=UeaKYS93HhOE83lRaGjX1O8c5IY49aAjhXlkVV/uqkk0NIpSZPN9W7GicNj7uCkww3vMXw hTvqiPA3tf5opFLOlo/gEaHN6DOh9cEzANlk95LqEo+JpArDSRVLQSjkwAgYNVeQ9HiLHu EohpYhhEwax3fjSagg55hyWx4P0CWG0= X-MC-Unique: youk8R1YMbSoRfYg-py3iA-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 03/11] virtio-mem: Implement RamDiscardMgr interface Date: Thu, 7 Jan 2021 14:34:15 +0100 Message-Id: <20210107133423.44964-4-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=216.205.24.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , "Dr . David Alan Gilbert" , Peter Xu , Marek Kedzierski , Auger Eric , Alex Williamson , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Let's properly notify when (un)plugging blocks, after discarding memory and before allowing the guest to consume memory. Handle errors from notifiers gracefully (e.g., no remaining VFIO mappings) when plugging, rolling back the change and telling the guest that the VM is busy. One special case to take care of is replaying all notifications after restoring the vmstate. The device starts out with all memory discarded, so after loading the vmstate, we have to notify about all plugged blocks. Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- hw/virtio/virtio-mem.c | 258 ++++++++++++++++++++++++++++++++- include/hw/virtio/virtio-mem.h | 3 + 2 files changed, 258 insertions(+), 3 deletions(-) diff --git a/hw/virtio/virtio-mem.c b/hw/virtio/virtio-mem.c index 471e464171..6200813bb8 100644 --- a/hw/virtio/virtio-mem.c +++ b/hw/virtio/virtio-mem.c @@ -172,7 +172,110 @@ static int virtio_mem_for_each_unplugged_range(const = VirtIOMEM *vmem, void *arg, return ret; } =20 -static bool virtio_mem_test_bitmap(VirtIOMEM *vmem, uint64_t start_gpa, +static int virtio_mem_for_each_plugged_range(const VirtIOMEM *vmem, void *= arg, + virtio_mem_range_cb cb) +{ + unsigned long first_bit, last_bit; + uint64_t offset, size; + int ret =3D 0; + + first_bit =3D find_first_bit(vmem->bitmap, vmem->bitmap_size); + while (first_bit < vmem->bitmap_size) { + offset =3D first_bit * vmem->block_size; + last_bit =3D find_next_zero_bit(vmem->bitmap, vmem->bitmap_size, + first_bit + 1) - 1; + size =3D (last_bit - first_bit + 1) * vmem->block_size; + + ret =3D cb(vmem, arg, offset, size); + if (ret) { + break; + } + first_bit =3D find_next_bit(vmem->bitmap, vmem->bitmap_size, + last_bit + 2); + } + return ret; +} + +static void virtio_mem_notify_unplug(VirtIOMEM *vmem, uint64_t offset, + uint64_t size) +{ + RamDiscardListener *rdl; + + QLIST_FOREACH(rdl, &vmem->rdl_list, next) { + rdl->notify_discard(rdl, &vmem->memdev->mr, offset, size); + } +} + +static int virtio_mem_notify_plug(VirtIOMEM *vmem, uint64_t offset, + uint64_t size) +{ + RamDiscardListener *rdl, *rdl2; + int ret =3D 0, ret2; + + QLIST_FOREACH(rdl, &vmem->rdl_list, next) { + ret =3D rdl->notify_populate(rdl, &vmem->memdev->mr, offset, size); + if (ret) { + break; + } + } + + if (ret) { + /* Could be a mapping attempt resulted in memory getting populated= . */ + ret2 =3D ram_block_discard_range(vmem->memdev->mr.ram_block, offse= t, + size); + if (ret2) { + error_report("Unexpected error discarding RAM: %s", + strerror(-ret2)); + } + + /* Notify all already-notified listeners. */ + QLIST_FOREACH(rdl2, &vmem->rdl_list, next) { + if (rdl2 =3D=3D rdl) { + break; + } + rdl2->notify_discard(rdl2, &vmem->memdev->mr, offset, size); + } + } + return ret; +} + +static int virtio_mem_notify_discard_range_cb(const VirtIOMEM *vmem, void = *arg, + uint64_t offset, uint64_t si= ze) +{ + RamDiscardListener *rdl; + + QLIST_FOREACH(rdl, &vmem->rdl_list, next) { + if (!rdl->notify_discard_all) { + rdl->notify_discard(rdl, &vmem->memdev->mr, offset, size); + } + } + return 0; +} + +static void virtio_mem_notify_unplug_all(VirtIOMEM *vmem) +{ + bool individual_calls =3D false; + RamDiscardListener *rdl; + + if (!vmem->size) { + return; + } + + QLIST_FOREACH(rdl, &vmem->rdl_list, next) { + if (rdl->notify_discard_all) { + rdl->notify_discard_all(rdl, &vmem->memdev->mr); + } else { + individual_calls =3D true; + } + } + + if (individual_calls) { + virtio_mem_for_each_unplugged_range(vmem, NULL, + virtio_mem_notify_discard_rang= e_cb); + } +} + +static bool virtio_mem_test_bitmap(const VirtIOMEM *vmem, uint64_t start_g= pa, uint64_t size, bool plugged) { const unsigned long first_bit =3D (start_gpa - vmem->addr) / vmem->blo= ck_size; @@ -225,7 +328,8 @@ static void virtio_mem_send_response_simple(VirtIOMEM *= vmem, virtio_mem_send_response(vmem, elem, &resp); } =20 -static bool virtio_mem_valid_range(VirtIOMEM *vmem, uint64_t gpa, uint64_t= size) +static bool virtio_mem_valid_range(const VirtIOMEM *vmem, uint64_t gpa, + uint64_t size) { if (!QEMU_IS_ALIGNED(gpa, vmem->block_size)) { return false; @@ -259,6 +363,9 @@ static int virtio_mem_set_block_state(VirtIOMEM *vmem, = uint64_t start_gpa, strerror(-ret)); return -EBUSY; } + virtio_mem_notify_unplug(vmem, offset, size); + } else if (virtio_mem_notify_plug(vmem, offset, size)) { + return -EBUSY; } virtio_mem_set_bitmap(vmem, start_gpa, size, plug); return 0; @@ -356,6 +463,8 @@ static int virtio_mem_unplug_all(VirtIOMEM *vmem) error_report("Unexpected error discarding RAM: %s", strerror(-ret)= ); return -EBUSY; } + virtio_mem_notify_unplug_all(vmem); + bitmap_clear(vmem->bitmap, 0, vmem->bitmap_size); if (vmem->size) { vmem->size =3D 0; @@ -604,6 +713,12 @@ static void virtio_mem_device_realize(DeviceState *dev= , Error **errp) vmstate_register_ram(&vmem->memdev->mr, DEVICE(vmem)); qemu_register_reset(virtio_mem_system_reset, vmem); precopy_add_notifier(&vmem->precopy_notifier); + + /* + * Set ourselves as RamDiscardMgr before the plug handler maps the mem= ory + * region and exposes it via an address space. + */ + memory_region_set_ram_discard_mgr(&vmem->memdev->mr, RAM_DISCARD_MGR(v= mem)); } =20 static void virtio_mem_device_unrealize(DeviceState *dev) @@ -611,6 +726,11 @@ static void virtio_mem_device_unrealize(DeviceState *d= ev) VirtIODevice *vdev =3D VIRTIO_DEVICE(dev); VirtIOMEM *vmem =3D VIRTIO_MEM(dev); =20 + /* + * The unplug handler unmapped the memory region, it cannot be + * found via an address space anymore. Unset ourselves. + */ + memory_region_set_ram_discard_mgr(&vmem->memdev->mr, NULL); precopy_remove_notifier(&vmem->precopy_notifier); qemu_unregister_reset(virtio_mem_system_reset, vmem); vmstate_unregister_ram(&vmem->memdev->mr, DEVICE(vmem)); @@ -642,13 +762,41 @@ static int virtio_mem_restore_unplugged(VirtIOMEM *vm= em) virtio_mem_discard_range_cb= ); } =20 +static int virtio_mem_post_load_replay_cb(const VirtIOMEM *vmem, void *arg, + uint64_t offset, uint64_t size) +{ + RamDiscardListener *rdl; + int ret =3D 0; + + QLIST_FOREACH(rdl, &vmem->rdl_list, next) { + ret =3D rdl->notify_populate(rdl, &vmem->memdev->mr, offset, size); + if (ret) { + break; + } + } + return ret; +} + static int virtio_mem_post_load(void *opaque, int version_id) { + VirtIOMEM *vmem =3D VIRTIO_MEM(opaque); + int ret; + + /* + * We started out with all memory discarded and our memory region is m= apped + * into an address space. Replay, now that we updated the bitmap. + */ + ret =3D virtio_mem_for_each_plugged_range(vmem, NULL, + virtio_mem_post_load_replay_cb= ); + if (ret) { + return ret; + } + if (migration_in_incoming_postcopy()) { return 0; } =20 - return virtio_mem_restore_unplugged(VIRTIO_MEM(opaque)); + return virtio_mem_restore_unplugged(vmem); } =20 typedef struct VirtIOMEMMigSanityChecks { @@ -933,6 +1081,7 @@ static void virtio_mem_instance_init(Object *obj) =20 notifier_list_init(&vmem->size_change_notifiers); vmem->precopy_notifier.notify =3D virtio_mem_precopy_notify; + QLIST_INIT(&vmem->rdl_list); =20 object_property_add(obj, VIRTIO_MEM_SIZE_PROP, "size", virtio_mem_get_= size, NULL, NULL, NULL); @@ -952,11 +1101,104 @@ static Property virtio_mem_properties[] =3D { DEFINE_PROP_END_OF_LIST(), }; =20 +static uint64_t virtio_mem_rdm_get_min_granularity(const RamDiscardMgr *rd= m, + const MemoryRegion *mr) +{ + const VirtIOMEM *vmem =3D VIRTIO_MEM(rdm); + + g_assert(mr =3D=3D &vmem->memdev->mr); + return vmem->block_size; +} + +static bool virtio_mem_rdm_is_populated(const RamDiscardMgr *rdm, + const MemoryRegion *mr, + ram_addr_t offset, ram_addr_t size) +{ + const VirtIOMEM *vmem =3D VIRTIO_MEM(rdm); + uint64_t start_gpa =3D QEMU_ALIGN_DOWN(vmem->addr + offset, vmem->bloc= k_size); + uint64_t end_gpa =3D QEMU_ALIGN_UP(vmem->addr + offset + size, + vmem->block_size); + + g_assert(mr =3D=3D &vmem->memdev->mr); + if (!virtio_mem_valid_range(vmem, start_gpa, end_gpa - start_gpa)) { + return false; + } + + return virtio_mem_test_bitmap(vmem, start_gpa, end_gpa - start_gpa, tr= ue); +} + +static int virtio_mem_notify_populate_range_single_cb(const VirtIOMEM *vme= m, + void *arg, + uint64_t offset, + uint64_t size) +{ + RamDiscardListener *rdl =3D arg; + + return rdl->notify_populate(rdl, &vmem->memdev->mr, offset, size); +} + +static int virtio_mem_notify_discard_range_single_cb(const VirtIOMEM *vmem, + void *arg, + uint64_t offset, + uint64_t size) +{ + RamDiscardListener *rdl =3D arg; + + rdl->notify_discard(rdl, &vmem->memdev->mr, offset, size); + return 0; +} + +static void virtio_mem_rdm_register_listener(RamDiscardMgr *rdm, + const MemoryRegion *mr, + RamDiscardListener *rdl) +{ + VirtIOMEM *vmem =3D VIRTIO_MEM(rdm); + int ret; + + g_assert(mr =3D=3D &vmem->memdev->mr); + QLIST_INSERT_HEAD(&vmem->rdl_list, rdl, next); + ret =3D virtio_mem_for_each_plugged_range(vmem, rdl, + virtio_mem_notify_populate_range_singl= e_cb); + if (ret) { + error_report("%s: Replaying plugged ranges failed: %s", __func__, + strerror(-ret)); + } +} + +static void virtio_mem_rdm_unregister_listener(RamDiscardMgr *rdm, + const MemoryRegion *mr, + RamDiscardListener *rdl) +{ + VirtIOMEM *vmem =3D VIRTIO_MEM(rdm); + + g_assert(mr =3D=3D &vmem->memdev->mr); + if (rdl->notify_discard_all) { + rdl->notify_discard_all(rdl, &vmem->memdev->mr); + } else { + virtio_mem_for_each_plugged_range(vmem, rdl, + virtio_mem_notify_discard_range_singl= e_cb); + + } + QLIST_REMOVE(rdl, next); +} + +static int virtio_mem_rdm_replay_populated(const RamDiscardMgr *rdm, + const MemoryRegion *mr, + RamDiscardListener *rdl) +{ + const VirtIOMEM *vmem =3D VIRTIO_MEM(rdm); + + g_assert(mr =3D=3D &vmem->memdev->mr); + return virtio_mem_for_each_plugged_range(vmem, rdl, + virtio_mem_notify_populate_range_singl= e_cb); +} + static void virtio_mem_class_init(ObjectClass *klass, void *data) { DeviceClass *dc =3D DEVICE_CLASS(klass); VirtioDeviceClass *vdc =3D VIRTIO_DEVICE_CLASS(klass); VirtIOMEMClass *vmc =3D VIRTIO_MEM_CLASS(klass); + RamDiscardMgrClass *rdmc =3D RAM_DISCARD_MGR_CLASS(klass); =20 device_class_set_props(dc, virtio_mem_properties); dc->vmsd =3D &vmstate_virtio_mem; @@ -972,6 +1214,12 @@ static void virtio_mem_class_init(ObjectClass *klass,= void *data) vmc->get_memory_region =3D virtio_mem_get_memory_region; vmc->add_size_change_notifier =3D virtio_mem_add_size_change_notifier; vmc->remove_size_change_notifier =3D virtio_mem_remove_size_change_not= ifier; + + rdmc->get_min_granularity =3D virtio_mem_rdm_get_min_granularity; + rdmc->is_populated =3D virtio_mem_rdm_is_populated; + rdmc->register_listener =3D virtio_mem_rdm_register_listener; + rdmc->unregister_listener =3D virtio_mem_rdm_unregister_listener; + rdmc->replay_populated =3D virtio_mem_rdm_replay_populated; } =20 static const TypeInfo virtio_mem_info =3D { @@ -981,6 +1229,10 @@ static const TypeInfo virtio_mem_info =3D { .instance_init =3D virtio_mem_instance_init, .class_init =3D virtio_mem_class_init, .class_size =3D sizeof(VirtIOMEMClass), + .interfaces =3D (InterfaceInfo[]) { + { TYPE_RAM_DISCARD_MGR }, + { } + }, }; =20 static void virtio_register_types(void) diff --git a/include/hw/virtio/virtio-mem.h b/include/hw/virtio/virtio-mem.h index 4eeb82d5dd..9a6e348fa2 100644 --- a/include/hw/virtio/virtio-mem.h +++ b/include/hw/virtio/virtio-mem.h @@ -67,6 +67,9 @@ struct VirtIOMEM { =20 /* don't migrate unplugged memory */ NotifierWithReturn precopy_notifier; + + /* listeners to notify on plug/unplug activity. */ + QLIST_HEAD(, RamDiscardListener) rdl_list; }; =20 struct VirtIOMEMClass { --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610027223; cv=none; d=zohomail.com; s=zohoarc; b=Nftod4RYbbcxVxBbXyyYQ692a7on47b+9plfgR6qQcCsJrcevT6OEKz3q1IfoaQRXH3vwfC6WJm+tnt4iKRgDB+FPrTIZArqWBSAbkLoT9fZRuPlbC8uNqJFiiQwziuxgQD0l4pDjqf7tEmWNz9WpLnqpS01NhHjVyeFQlB6Q8A= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610027223; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=LyR0aNBgbL4dQPsdBYT1DMHtllTjOTQfiLyEGMT0EKs=; b=Etwyk0LykDXhP8doEYiDPWU7eczSe7R/ylBlrllZimgP30fe4ZgiQR7w1zPHgJd96PuXHa1G1nhJcQsURpPBXjjyRHUS8rcQcIho9pR4ZM/+w/l8ligKtTAKYuq9yTZJEnV/x+jj2I8w7lw0QD/6vzcVlWPtqpxX4aETz140TgY= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610027223891845.6850398926044; Thu, 7 Jan 2021 05:47:03 -0800 (PST) Received: from localhost ([::1]:42352 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVd0-0007no-Ou for importer@patchew.org; Thu, 07 Jan 2021 08:47:02 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:35774) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVSC-00053j-VA for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:54 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:29200) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVS8-0004Xa-Mx for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:35:52 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-265-Q8M6wjt5NOO3I9G86Xfz7g-1; Thu, 07 Jan 2021 08:35:44 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 07DEF1005E40; Thu, 7 Jan 2021 13:35:43 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 6B82D71C82; Thu, 7 Jan 2021 13:35:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026547; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=LyR0aNBgbL4dQPsdBYT1DMHtllTjOTQfiLyEGMT0EKs=; b=UR5WJ2TqxyTwRVinHGMv49R7gMBkPm6zHgI0TKlfXDfmUgDs/AbMHmBbL1GWLwQURI67oq 9+AW+E02Qm7zyQAT7jjK15hNAUUqapjurdLy3fS3TaDDJvMtu+D9zvP2RmZU1oEnRg6a/z U2CT7gluhOoNRxRAM9/NuWVlb7Fmzio= X-MC-Unique: Q8M6wjt5NOO3I9G86Xfz7g-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 04/11] vfio: Support for RamDiscardMgr in the !vIOMMU case Date: Thu, 7 Jan 2021 14:34:16 +0100 Message-Id: <20210107133423.44964-5-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=216.205.24.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , "Dr . David Alan Gilbert" , Peter Xu , Marek Kedzierski , Auger Eric , Alex Williamson , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Implement support for RamDiscardMgr, to prepare for virtio-mem support. Instead of mapping the whole memory section, we only map "populated" parts and update the mapping when notified about discarding/population of memory via the RamDiscardListener. Similarly, when syncing the dirty bitmaps, sync only the actually mapped (populated) parts by replaying via the notifier. Using virtio-mem with vfio is still blocked via ram_block_discard_disable()/ram_block_discard_require() after this patch. Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand Acked-by: Alex Williamson Reviewed-by: Alex Williamson --- hw/vfio/common.c | 200 ++++++++++++++++++++++++++++++++++ include/hw/vfio/vfio-common.h | 12 ++ 2 files changed, 212 insertions(+) diff --git a/hw/vfio/common.c b/hw/vfio/common.c index 6ff1daa763..2bd219cf1d 100644 --- a/hw/vfio/common.c +++ b/hw/vfio/common.c @@ -654,6 +654,136 @@ out: rcu_read_unlock(); } =20 +static void vfio_ram_discard_notify_discard(RamDiscardListener *rdl, + const MemoryRegion *mr, + ram_addr_t offset, ram_addr_t = size) +{ + VFIORamDiscardListener *vrdl =3D container_of(rdl, VFIORamDiscardListe= ner, + listener); + const hwaddr mr_start =3D MAX(offset, vrdl->offset_within_region); + const hwaddr mr_end =3D MIN(offset + size, + vrdl->offset_within_region + vrdl->size); + const hwaddr iova =3D mr_start - vrdl->offset_within_region + + vrdl->offset_within_address_space; + int ret; + + if (mr_start >=3D mr_end) { + return; + } + + /* Unmap with a single call. */ + ret =3D vfio_dma_unmap(vrdl->container, iova, mr_end - mr_start, NULL); + if (ret) { + error_report("%s: vfio_dma_unmap() failed: %s", __func__, + strerror(-ret)); + } +} + +static int vfio_ram_discard_notify_populate(RamDiscardListener *rdl, + const MemoryRegion *mr, + ram_addr_t offset, ram_addr_t = size) +{ + VFIORamDiscardListener *vrdl =3D container_of(rdl, VFIORamDiscardListe= ner, + listener); + const hwaddr mr_end =3D MIN(offset + size, + vrdl->offset_within_region + vrdl->size); + hwaddr mr_start =3D MAX(offset, vrdl->offset_within_region); + hwaddr mr_next, iova; + void *vaddr; + int ret; + + /* + * Map in (aligned within memory region) minimum granularity, so we can + * unmap in minimum granularity later. + */ + for (; mr_start < mr_end; mr_start =3D mr_next) { + mr_next =3D ROUND_UP(mr_start + 1, vrdl->granularity); + mr_next =3D MIN(mr_next, mr_end); + + iova =3D mr_start - vrdl->offset_within_region + + vrdl->offset_within_address_space; + vaddr =3D memory_region_get_ram_ptr(vrdl->mr) + mr_start; + + ret =3D vfio_dma_map(vrdl->container, iova, mr_next - mr_start, + vaddr, mr->readonly); + if (ret) { + /* Rollback */ + vfio_ram_discard_notify_discard(rdl, mr, offset, size); + return ret; + } + } + return 0; +} + +static void vfio_ram_discard_notify_discard_all(RamDiscardListener *rdl, + const MemoryRegion *mr) +{ + VFIORamDiscardListener *vrdl =3D container_of(rdl, VFIORamDiscardListe= ner, + listener); + int ret; + + /* Unmap with a single call. */ + ret =3D vfio_dma_unmap(vrdl->container, vrdl->offset_within_address_sp= ace, + vrdl->size, NULL); + if (ret) { + error_report("%s: vfio_dma_unmap() failed: %s", __func__, + strerror(-ret)); + } +} + +static void vfio_register_ram_discard_notifier(VFIOContainer *container, + MemoryRegionSection *sectio= n) +{ + RamDiscardMgr *rdm =3D memory_region_get_ram_discard_mgr(section->mr); + RamDiscardMgrClass *rdmc =3D RAM_DISCARD_MGR_GET_CLASS(rdm); + VFIORamDiscardListener *vrdl; + + vrdl =3D g_new0(VFIORamDiscardListener, 1); + vrdl->container =3D container; + vrdl->mr =3D section->mr; + vrdl->offset_within_region =3D section->offset_within_region; + vrdl->offset_within_address_space =3D section->offset_within_address_s= pace; + vrdl->size =3D int128_get64(section->size); + vrdl->granularity =3D rdmc->get_min_granularity(rdm, section->mr); + + /* Ignore some corner cases not relevant in practice. */ + g_assert(QEMU_IS_ALIGNED(vrdl->offset_within_region, TARGET_PAGE_SIZE)= ); + g_assert(QEMU_IS_ALIGNED(vrdl->offset_within_address_space, + TARGET_PAGE_SIZE)); + g_assert(QEMU_IS_ALIGNED(vrdl->size, TARGET_PAGE_SIZE)); + + ram_discard_listener_init(&vrdl->listener, + vfio_ram_discard_notify_populate, + vfio_ram_discard_notify_discard, + vfio_ram_discard_notify_discard_all); + rdmc->register_listener(rdm, section->mr, &vrdl->listener); + QLIST_INSERT_HEAD(&container->vrdl_list, vrdl, next); +} + +static void vfio_unregister_ram_discard_listener(VFIOContainer *container, + MemoryRegionSection *sect= ion) +{ + RamDiscardMgr *rdm =3D memory_region_get_ram_discard_mgr(section->mr); + RamDiscardMgrClass *rdmc =3D RAM_DISCARD_MGR_GET_CLASS(rdm); + VFIORamDiscardListener *vrdl =3D NULL; + + QLIST_FOREACH(vrdl, &container->vrdl_list, next) { + if (vrdl->mr =3D=3D section->mr && + vrdl->offset_within_region =3D=3D section->offset_within_regio= n) { + break; + } + } + + if (!vrdl) { + hw_error("vfio: Trying to unregister missing RAM discard listener"= ); + } + + rdmc->unregister_listener(rdm, section->mr, &vrdl->listener); + QLIST_REMOVE(vrdl, next); + + g_free(vrdl); +} + static void vfio_listener_region_add(MemoryListener *listener, MemoryRegionSection *section) { @@ -814,6 +944,16 @@ static void vfio_listener_region_add(MemoryListener *l= istener, =20 /* Here we assume that memory_region_is_ram(section->mr)=3D=3Dtrue */ =20 + /* + * For RAM memory regions with a RamDiscardMgr, we only want to map the + * actually populated parts - and update the mapping whenever we're no= tified + * about changes. + */ + if (memory_region_has_ram_discard_mgr(section->mr)) { + vfio_register_ram_discard_notifier(container, section); + return; + } + vaddr =3D memory_region_get_ram_ptr(section->mr) + section->offset_within_region + (iova - section->offset_within_address_space); @@ -950,6 +1090,10 @@ static void vfio_listener_region_del(MemoryListener *= listener, =20 pgmask =3D (1ULL << ctz64(hostwin->iova_pgsizes)) - 1; try_unmap =3D !((iova & pgmask) || (int128_get64(llsize) & pgmask)= ); + } else if (memory_region_has_ram_discard_mgr(section->mr)) { + vfio_unregister_ram_discard_listener(container, section); + /* Unregistering will trigger an unmap. */ + try_unmap =3D false; } =20 if (try_unmap) { @@ -1077,6 +1221,59 @@ static void vfio_iommu_map_dirty_notify(IOMMUNotifie= r *n, IOMMUTLBEntry *iotlb) rcu_read_unlock(); } =20 +static int vfio_ram_discard_notify_dirty_bitmap(RamDiscardListener *rdl, + const MemoryRegion *mr, + ram_addr_t offset, + ram_addr_t size) +{ + VFIORamDiscardListener *vrdl =3D container_of(rdl, VFIORamDiscardListe= ner, + listener); + const hwaddr mr_start =3D MAX(offset, vrdl->offset_within_region); + const hwaddr mr_end =3D MIN(offset + size, + vrdl->offset_within_region + vrdl->size); + const hwaddr iova =3D mr_start - vrdl->offset_within_region + + vrdl->offset_within_address_space; + ram_addr_t ram_addr; + int ret; + + if (mr_start >=3D mr_end) { + return 0; + } + + /* + * Sync the whole mapped region (spanning multiple individual mappings) + * in one go. + */ + ram_addr =3D memory_region_get_ram_addr(vrdl->mr) + mr_start; + ret =3D vfio_get_dirty_bitmap(vrdl->container, iova, mr_end - mr_start, + ram_addr); + return ret; +} + +static int vfio_sync_ram_discard_listener_dirty_bitmap(VFIOContainer *cont= ainer, + MemoryRegionSection *se= ction) +{ + RamDiscardMgr *rdm =3D memory_region_get_ram_discard_mgr(section->mr); + RamDiscardMgrClass *rdmc =3D RAM_DISCARD_MGR_GET_CLASS(rdm); + VFIORamDiscardListener tmp_vrdl, *vrdl =3D NULL; + + QLIST_FOREACH(vrdl, &container->vrdl_list, next) { + if (vrdl->mr =3D=3D section->mr && + vrdl->offset_within_region =3D=3D section->offset_within_regio= n) { + break; + } + } + + if (!vrdl) { + hw_error("vfio: Trying to sync missing RAM discard listener"); + } + + tmp_vrdl =3D *vrdl; + ram_discard_listener_init(&tmp_vrdl.listener, + vfio_ram_discard_notify_dirty_bitmap, NULL, = NULL); + return rdmc->replay_populated(rdm, section->mr, &tmp_vrdl.listener); +} + static int vfio_sync_dirty_bitmap(VFIOContainer *container, MemoryRegionSection *section) { @@ -1108,6 +1305,8 @@ static int vfio_sync_dirty_bitmap(VFIOContainer *cont= ainer, } } return 0; + } else if (memory_region_has_ram_discard_mgr(section->mr)) { + return vfio_sync_ram_discard_listener_dirty_bitmap(container, sect= ion); } =20 ram_addr =3D memory_region_get_ram_addr(section->mr) + @@ -1737,6 +1936,7 @@ static int vfio_connect_container(VFIOGroup *group, A= ddressSpace *as, container->dirty_pages_supported =3D false; QLIST_INIT(&container->giommu_list); QLIST_INIT(&container->hostwin_list); + QLIST_INIT(&container->vrdl_list); =20 ret =3D vfio_init_container(container, group->fd, errp); if (ret) { diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h index 6141162d7a..af6f8d1b22 100644 --- a/include/hw/vfio/vfio-common.h +++ b/include/hw/vfio/vfio-common.h @@ -91,6 +91,7 @@ typedef struct VFIOContainer { QLIST_HEAD(, VFIOGuestIOMMU) giommu_list; QLIST_HEAD(, VFIOHostDMAWindow) hostwin_list; QLIST_HEAD(, VFIOGroup) group_list; + QLIST_HEAD(, VFIORamDiscardListener) vrdl_list; QLIST_ENTRY(VFIOContainer) next; } VFIOContainer; =20 @@ -102,6 +103,17 @@ typedef struct VFIOGuestIOMMU { QLIST_ENTRY(VFIOGuestIOMMU) giommu_next; } VFIOGuestIOMMU; =20 +typedef struct VFIORamDiscardListener { + VFIOContainer *container; + MemoryRegion *mr; + hwaddr offset_within_region; + hwaddr offset_within_address_space; + hwaddr size; + uint64_t granularity; + RamDiscardListener listener; + QLIST_ENTRY(VFIORamDiscardListener) next; +} VFIORamDiscardListener; + typedef struct VFIOHostDMAWindow { hwaddr min_iova; hwaddr max_iova; --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610026873; cv=none; d=zohomail.com; s=zohoarc; b=d0Kl+Qe/F15JBQ2o0/CI83qDd/YC7dKWWQUPi6A31URA+SregqQD+LCkAEVE6QAdRV3qvz4f9t906cHgbzoBVQQKK5Esd+HcE1jRETA6BzUGU8QFM+mVuc02ktpy+GFqLkm1hKXw1mbOQqjFk0UWTGU6p1WMLXR2A4BtzM/XMa4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610026873; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=MpgISYbNWh/byxuNWvmdaxhWpij9YwvJUEpchzl5WrY=; b=Y3X3045FVLytaJNFFUxEsk/Dm+LaoxPC0iTjS+4yZ2FotWUR9tZ13AI1Bp2pf8CEoGvtHdDW3dD6owznAkUjfN5Pqb3wNzCWRRvCeyTRLa5KtYk2mcALAfEr3rXaDKxm6zlIJBwmjeXT+RuPNBgWjryM2Y4lPKU1dfabie16Nt8= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 161002687389983.45040637197087; Thu, 7 Jan 2021 05:41:13 -0800 (PST) Received: from localhost ([::1]:54756 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVXM-00018d-NR for importer@patchew.org; Thu, 07 Jan 2021 08:41:12 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:35896) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVSz-0005cG-Hb for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:41 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:31369) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVSO-0004ZK-Ch for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:41 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-236-QVdzXTXeNlu-3z_w_AyZ1A-1; Thu, 07 Jan 2021 08:36:02 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id BDC7B1005513; Thu, 7 Jan 2021 13:36:00 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 5851471C82; Thu, 7 Jan 2021 13:35:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026563; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=MpgISYbNWh/byxuNWvmdaxhWpij9YwvJUEpchzl5WrY=; b=HPjX9YeMgSVIenI5NUl528ReB+xlZYZrzgQicGBCXq69/o0SgNmfQCh6N/DgGjpxmL7HTq rR07kw/BoPH23Z8v4jP8i9yWtRTMgzUkJaRHf6IpLFfs9vGDIq9/ujGeWmdtfG4vAsQ08o 23A8Mjal4kzu+xnYhHhK/RlA4kJRlSI= X-MC-Unique: QVdzXTXeNlu-3z_w_AyZ1A-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 05/11] vfio: Query and store the maximum number of possible DMA mappings Date: Thu, 7 Jan 2021 14:34:17 +0100 Message-Id: <20210107133423.44964-6-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=unavailable autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , "Dr . David Alan Gilbert" , Peter Xu , Marek Kedzierski , Auger Eric , Alex Williamson , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Let's query the maximum number of possible DMA mappings by querying the available mappings when creating the container (before any mappings are created). We'll use this informaton soon to perform some sanity checks and warn the user. Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand Acked-by: Alex Williamson Reviewed-by: Alex Williamson --- hw/vfio/common.c | 4 ++++ include/hw/vfio/vfio-common.h | 1 + 2 files changed, 5 insertions(+) diff --git a/hw/vfio/common.c b/hw/vfio/common.c index 2bd219cf1d..1babb6bb99 100644 --- a/hw/vfio/common.c +++ b/hw/vfio/common.c @@ -1934,6 +1934,7 @@ static int vfio_connect_container(VFIOGroup *group, A= ddressSpace *as, container->fd =3D fd; container->error =3D NULL; container->dirty_pages_supported =3D false; + container->dma_max_mappings =3D 0; QLIST_INIT(&container->giommu_list); QLIST_INIT(&container->hostwin_list); QLIST_INIT(&container->vrdl_list); @@ -1965,7 +1966,10 @@ static int vfio_connect_container(VFIOGroup *group, = AddressSpace *as, vfio_host_win_add(container, 0, (hwaddr)-1, info->iova_pgsizes); container->pgsizes =3D info->iova_pgsizes; =20 + /* The default in the kernel ("dma_entry_limit") is 65535. */ + container->dma_max_mappings =3D 65535; if (!ret) { + vfio_get_info_dma_avail(info, &container->dma_max_mappings); vfio_get_iommu_info_migration(container, info); } g_free(info); diff --git a/include/hw/vfio/vfio-common.h b/include/hw/vfio/vfio-common.h index af6f8d1b22..4b28c6e8ac 100644 --- a/include/hw/vfio/vfio-common.h +++ b/include/hw/vfio/vfio-common.h @@ -88,6 +88,7 @@ typedef struct VFIOContainer { uint64_t dirty_pgsizes; uint64_t max_dirty_bitmap_size; unsigned long pgsizes; + unsigned int dma_max_mappings; QLIST_HEAD(, VFIOGuestIOMMU) giommu_list; QLIST_HEAD(, VFIOHostDMAWindow) hostwin_list; QLIST_HEAD(, VFIOGroup) group_list; --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610026761; cv=none; d=zohomail.com; s=zohoarc; b=W7ICZU5dALZzXXqyEi/1KVb7iHoDMtIzxHkKyawi6ftarUT+YTROjsbzw6UqOIuQ4DO6W5bpeoHbbSbTlAAQAAblUZyjGhD69aQPyyeWf4sa48F5Apg/4fwTQpcQBJ8C1ZeWyzm+pS1mvrj1o+S48jRKO0ISE33JWqeDSY7lIfw= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610026761; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=phpUApLFWJcRZKTgToVV/F1hUfJLo3qn5Y2gqdT+Elw=; b=H1kjmJiXjJBql9yOuJzl4gEB373jCvK8AvBMHrwNsnrTFoazdDT1zTL66W4v8LGhgdES/1EYX1sPDcJe72HlWIB7yl3ehyBSE/WgO7jFQyaiceg6h6W7obGOeKPD216Ame42bleX8rTm54O0hlLbSq1zBFYx+mPBNBXMz5Mf7o4= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610026761095111.25228310340913; Thu, 7 Jan 2021 05:39:21 -0800 (PST) Received: from localhost ([::1]:49424 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVVX-0007NW-Ts for importer@patchew.org; Thu, 07 Jan 2021 08:39:19 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:35948) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVT2-0005gq-3J for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:44 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:54179) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVSU-0004Zr-5E for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:43 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-539-Jy9EJ1jVOdSwzOX9Nyz_iQ-1; Thu, 07 Jan 2021 08:36:05 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id C58D4B8100; Thu, 7 Jan 2021 13:36:03 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 18E8218017; Thu, 7 Jan 2021 13:36:00 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026568; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=phpUApLFWJcRZKTgToVV/F1hUfJLo3qn5Y2gqdT+Elw=; b=Ct3HTrBKFpZE4Zlead+wTuEfSAjvkoqJTKKR+9biXx+4CJuKX2ZkmtOTA4uoOUYLzr6EFO GZRaMR2JNNIOldre9k7fyDMRcaXVsqnFvGS0uWYfYWdqaMkCi9T4pfVNjdkevdgHxpQ+qe w4yn0SbfACZoHe46ZZeK8fUO6PU5kDI= X-MC-Unique: Jy9EJ1jVOdSwzOX9Nyz_iQ-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 06/11] vfio: Sanity check maximum number of DMA mappings with RamDiscardMgr Date: Thu, 7 Jan 2021 14:34:18 +0100 Message-Id: <20210107133423.44964-7-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=216.205.24.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , "Dr . David Alan Gilbert" , Peter Xu , Marek Kedzierski , Auger Eric , Alex Williamson , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" Although RamDiscardMgr can handle running into the maximum number of DMA mappings by propagating errors when creating a DMA mapping, we want to sanity check and warn the user early that there is a theoretical setup issue and that virtio-mem might not be able to provide as much memory towards a VM as desired. As suggested by Alex, let's use the number of KVM memory slots to guess how many other mappings we might see over time. Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- hw/vfio/common.c | 43 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/hw/vfio/common.c b/hw/vfio/common.c index 1babb6bb99..bc20f738ce 100644 --- a/hw/vfio/common.c +++ b/hw/vfio/common.c @@ -758,6 +758,49 @@ static void vfio_register_ram_discard_notifier(VFIOCon= tainer *container, vfio_ram_discard_notify_discard_all); rdmc->register_listener(rdm, section->mr, &vrdl->listener); QLIST_INSERT_HEAD(&container->vrdl_list, vrdl, next); + + /* + * Sanity-check if we have a theoretically problematic setup where we = could + * exceed the maximum number of possible DMA mappings over time. We as= sume + * that each mapped section in the same address space as a RamDiscardM= gr + * section consumes exactly one DMA mapping, with the exception of + * RamDiscardMgr sections; i.e., we don't expect to have gIOMMU sectio= ns in + * the same address space as RamDiscardMgr sections. + * + * We assume that each section in the address space consumes one memsl= ot. + * We take the number of KVM memory slots as a best guess for the maxi= mum + * number of sections in the address space we could have over time, + * also consuming DMA mappings. + */ + if (container->dma_max_mappings) { + unsigned int vrdl_count =3D 0, vrdl_mappings =3D 0, max_memslots = =3D 512; + +#ifdef CONFIG_KVM + if (kvm_enabled()) { + max_memslots =3D kvm_get_max_memslots(); + } +#endif + + QLIST_FOREACH(vrdl, &container->vrdl_list, next) { + hwaddr start, end; + + start =3D QEMU_ALIGN_DOWN(vrdl->offset_within_address_space, + vrdl->granularity); + end =3D ROUND_UP(vrdl->offset_within_address_space + vrdl->siz= e, + vrdl->granularity); + vrdl_mappings =3D (end - start) / vrdl->granularity; + vrdl_count++; + } + + if (vrdl_mappings + max_memslots - vrdl_count > + container->dma_max_mappings) { + warn_report("%s: possibly running out of DMA mappings. E.g., t= ry" + " increasing the 'block-size' of virtio-mem devies= ." + " Maximum possible DMA mappings: %d, Maximum possi= ble" + " memslots: %d", __func__, container->dma_max_mapp= ings, + max_memslots); + } + } } =20 static void vfio_unregister_ram_discard_listener(VFIOContainer *container, --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610026896; cv=none; d=zohomail.com; s=zohoarc; b=Hhg9UUq0eQv6DCDGm8DR0oJ0aLLh+G7iT3u4mwaHC3x0z4nQfvZ2F9TWG4wfR2XxbjjKyfCCNmNrbhdDHwY8+9G1nNNYQAoOJ1zW0zIsqALLHvBipm/rtAoBaFbQdL41YM6eD54y8XlxExtekxHph+EFn5gBFHIdLIZEwuISja4= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610026896; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=/8PKGC0beMkcQTTfQzgN0oTseHZB9CI8DIQMmrEErgI=; b=iLkz0Zw0IHgVG/S4+PdAJ2MDjNKUyBGiYv98aNoAvLqIa1dJywKY0Ho/t5JkLvPsj94LtiDgUaXdSf6+oHiyydSoS1e0vDWK2N2aceAhnVnwCmnc0h2lc4EshGuYsR0HE8CN1tnIyjTxDsuHHRj8B8dZpMtPK9dsAepEndxf7sw= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 161002689656211.126814502902562; Thu, 7 Jan 2021 05:41:36 -0800 (PST) Received: from localhost ([::1]:56654 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVXj-00020g-GQ for importer@patchew.org; Thu, 07 Jan 2021 08:41:35 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:36026) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVT4-0005mD-9K for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:46 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:23850) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVSl-0004cE-Jm for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:46 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-454-CkpOLo_YMOyyMbFJhUUxBA-1; Thu, 07 Jan 2021 08:36:22 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 9F30818C89D9; Thu, 7 Jan 2021 13:36:21 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 21F0A71C82; Thu, 7 Jan 2021 13:36:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026586; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=/8PKGC0beMkcQTTfQzgN0oTseHZB9CI8DIQMmrEErgI=; b=I+zmYzCGoBHF/vH2YSaQxOeYFg8Hq1riTrKhDSab7afiyDfEgwuLulXpVF+WFhUCqyyBhe CS3qgreelZSSfEs1MMfNqzu1y2+sr4RMdW2CFsRB6QfBSpvaeZgsthfxuUUjNtbWhmIbmm xyKV0Zn1zYzUVCcTUCP0gPd2LyriI4I= X-MC-Unique: CkpOLo_YMOyyMbFJhUUxBA-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 07/11] vfio: Support for RamDiscardMgr in the vIOMMU case Date: Thu, 7 Jan 2021 14:34:19 +0100 Message-Id: <20210107133423.44964-8-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , "Dr . David Alan Gilbert" , Peter Xu , Marek Kedzierski , Auger Eric , Alex Williamson , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" vIOMMU support works already with RamDiscardMgr as long as guests only map populated memory. Both, populated and discarded memory is mapped into &address_space_memory, where vfio_get_xlat_addr() will find that memory, to create the vfio mapping. Sane guests will never map discarded memory (e.g., unplugged memory blocks in virtio-mem) into an IOMMU - or keep it mapped into an IOMMU while memory is getting discarded. However, there are two cases where a malicious guests could trigger pinning of more memory than intended. One case is easy to handle: the guest trying to map discarded memory into an IOMMU. The other case is harder to handle: the guest keeping memory mapped in the IOMMU while it is getting discarded. We would have to walk over all mappings when discarding memory and identify if any mapping would be a violation. Let's keep it simple for now and print a warning, indicating that setting RLIMIT_MEMLOCK can mitigate such attacks. We have to take care of incoming migration: at the point the IOMMUs get restored and start creating mappings in vfio, RamDiscardMgr implementations might not be back up and running yet. Let's rely on the runstate. An alternative would be using vmstate priorities - but current handling is cleaner and more obvious. Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- hw/vfio/common.c | 35 +++++++++++++++++++++++++++++++++++ hw/virtio/virtio-mem.c | 1 + include/migration/vmstate.h | 1 + 3 files changed, 37 insertions(+) diff --git a/hw/vfio/common.c b/hw/vfio/common.c index bc20f738ce..2b9ba3f8c9 100644 --- a/hw/vfio/common.c +++ b/hw/vfio/common.c @@ -36,6 +36,7 @@ #include "qemu/range.h" #include "sysemu/kvm.h" #include "sysemu/reset.h" +#include "sysemu/runstate.h" #include "trace.h" #include "qapi/error.h" #include "migration/migration.h" @@ -574,6 +575,40 @@ static bool vfio_get_xlat_addr(IOMMUTLBEntry *iotlb, v= oid **vaddr, error_report("iommu map to non memory area %"HWADDR_PRIx"", xlat); return false; + } else if (memory_region_has_ram_discard_mgr(mr)) { + RamDiscardMgr *rdm =3D memory_region_get_ram_discard_mgr(mr); + RamDiscardMgrClass *rdmc =3D RAM_DISCARD_MGR_GET_CLASS(rdm); + + /* + * Malicious VMs can map memory into the IOMMU, which is expected + * to remain discarded. vfio will pin all pages, populating memory. + * Disallow that. vmstate priorities make sure any RamDiscardMgr w= ere + * already restored before IOMMUs are restored. + */ + if (!rdmc->is_populated(rdm, mr, xlat, len)) { + error_report("iommu map to discarded memory (e.g., unplugged v= ia" + " virtio-mem): %"HWADDR_PRIx"", + iotlb->translated_addr); + return false; + } + + /* + * Malicious VMs might trigger discarding of IOMMU-mapped memory. = The + * pages will remain pinned inside vfio until unmapped, resulting = in a + * higher memory consumption than expected. If memory would get + * populated again later, there would be an inconsistency between = pages + * pinned by vfio and pages seen by QEMU. This is the case until + * unmapped from the IOMMU (e.g., during device reset). + * + * With malicious guests, we really only care about pinning more m= emory + * than expected. RLIMIT_MEMLOCK set for the user/process can neve= r be + * exceeded and can be used to mitigate this problem. + */ + warn_report_once("Using vfio with vIOMMUs and coordinated discardi= ng of" + " RAM (e.g., virtio-mem) works, however, maliciou= s" + " guests can trigger pinning of more memory than" + " intended via an IOMMU. It's possible to mitigat= e " + " by setting/adjusting RLIMIT_MEMLOCK."); } =20 /* diff --git a/hw/virtio/virtio-mem.c b/hw/virtio/virtio-mem.c index 6200813bb8..f419a758f3 100644 --- a/hw/virtio/virtio-mem.c +++ b/hw/virtio/virtio-mem.c @@ -871,6 +871,7 @@ static const VMStateDescription vmstate_virtio_mem_devi= ce =3D { .name =3D "virtio-mem-device", .minimum_version_id =3D 1, .version_id =3D 1, + .priority =3D MIG_PRI_VIRTIO_MEM, .post_load =3D virtio_mem_post_load, .fields =3D (VMStateField[]) { VMSTATE_WITH_TMP(VirtIOMEM, VirtIOMEMMigSanityChecks, diff --git a/include/migration/vmstate.h b/include/migration/vmstate.h index 075ee80096..3bf58ff043 100644 --- a/include/migration/vmstate.h +++ b/include/migration/vmstate.h @@ -153,6 +153,7 @@ typedef enum { MIG_PRI_DEFAULT =3D 0, MIG_PRI_IOMMU, /* Must happen before PCI devices */ MIG_PRI_PCI_BUS, /* Must happen before IOMMU */ + MIG_PRI_VIRTIO_MEM, /* Must happen before IOMMU */ MIG_PRI_GICV3_ITS, /* Must happen before PCI devices */ MIG_PRI_GICV3, /* Must happen before the ITS */ MIG_PRI_MAX, --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610027036; cv=none; d=zohomail.com; s=zohoarc; b=bTm2yMm7eWgW34za637TUBvgGjZDruV23FupCoGy9aCQtiPauFNQfDHlJgZMtEkid4/2CckKXjAmdXCTSD/pjUAXBBKoXdhyAnsSpyhy5CwOZfjb8DajoZsYKdIpv5sY9lgG9xDXBaaFqREBb7kMxF38DSqxplTaLRYWwCIE/KM= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610027036; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=efnjmySnLXG7z9W2Ni1BIKDyce5zh4iRiS+oo5bnSf4=; b=b/pztUcxG5758pl4iZj3WVp7j/X7p5TU5Pvf7IOAe/xVkzqQLMx7vG3Wie59KnOd6O74xaTQTKUdqjj0qz4/NEulP7iVG6E3MDSyl+FznZOAngBtDX4qgUACVVNBy6kgZeNSrbo3cAkudXgMtnUJWPeA1gB43jYRvHOlYbBYieI= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 16100270368561.4273284295196618; Thu, 7 Jan 2021 05:43:56 -0800 (PST) Received: from localhost ([::1]:34890 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVZy-0004dX-OG for importer@patchew.org; Thu, 07 Jan 2021 08:43:54 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:36034) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVT4-0005nS-PQ for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:46 -0500 Received: from us-smtp-delivery-124.mimecast.com ([216.205.24.124]:54442) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVSn-0004cK-4i for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:46 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-227-ivr0RCNkMaCGPgCw2Y5l2A-1; Thu, 07 Jan 2021 08:36:27 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id CBDF2801817; Thu, 7 Jan 2021 13:36:24 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id F0C741724C; Thu, 7 Jan 2021 13:36:21 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026588; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=efnjmySnLXG7z9W2Ni1BIKDyce5zh4iRiS+oo5bnSf4=; b=UV/UvzHBILOtQSZ847U9/b6cAtOrGluBya6GKrZrbLXxU+vboR0hH9gcXnkrwB6xAxqqg7 s76gENfybwgyUEF0IOAECYTuBkDpSp+qflLACWrpIvfCIgyzbIHMv1zZ2/ZEq9ZEZXWrWz xOWPvey+2TxY39391/rGdu7HMGGMZfE= X-MC-Unique: ivr0RCNkMaCGPgCw2Y5l2A-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 08/11] softmmu/physmem: Don't use atomic operations in ram_block_discard_(disable|require) Date: Thu, 7 Jan 2021 14:34:20 +0100 Message-Id: <20210107133423.44964-9-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=216.205.24.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H3=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Marek Kedzierski , Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , Alex Williamson , Peter Xu , "Dr . David Alan Gilbert" , Auger Eric , Pankaj Gupta , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" We have users in migration context that don't hold the BQL (when finishing migration). To prepare for further changes, use a dedicated mutex instead of atomic operations. Keep using qatomic_read ("READ_ONCE") for the functions that only extract the current state (e.g., used by virtio-balloon), locking isn't necessary. While at it, split up the counter into two variables to make it easier to understand. Suggested-by: Peter Xu Reviewed-by: Peter Xu Reviewed-by: Pankaj Gupta Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- softmmu/physmem.c | 70 ++++++++++++++++++++++++++--------------------- 1 file changed, 39 insertions(+), 31 deletions(-) diff --git a/softmmu/physmem.c b/softmmu/physmem.c index 8b9ffc41c2..dc61335b60 100644 --- a/softmmu/physmem.c +++ b/softmmu/physmem.c @@ -3660,56 +3660,64 @@ void mtree_print_dispatch(AddressSpaceDispatch *d, = MemoryRegion *root) } } =20 -/* - * If positive, discarding RAM is disabled. If negative, discarding RAM is - * required to work and cannot be disabled. - */ -static int ram_block_discard_disabled; +static unsigned int ram_block_discard_requirers; +static unsigned int ram_block_discard_disablers; +static QemuMutex ram_block_discard_disable_mutex; + +static void ram_block_discard_disable_mutex_lock(void) +{ + static gsize initialized; + + if (g_once_init_enter(&initialized)) { + qemu_mutex_init(&ram_block_discard_disable_mutex); + g_once_init_leave(&initialized, 1); + } + qemu_mutex_lock(&ram_block_discard_disable_mutex); +} + +static void ram_block_discard_disable_mutex_unlock(void) +{ + qemu_mutex_unlock(&ram_block_discard_disable_mutex); +} =20 int ram_block_discard_disable(bool state) { - int old; + int ret =3D 0; =20 + ram_block_discard_disable_mutex_lock(); if (!state) { - qatomic_dec(&ram_block_discard_disabled); - return 0; + ram_block_discard_disablers--; + } else if (!ram_block_discard_requirers) { + ram_block_discard_disablers++; + } else { + ret =3D -EBUSY; } - - do { - old =3D qatomic_read(&ram_block_discard_disabled); - if (old < 0) { - return -EBUSY; - } - } while (qatomic_cmpxchg(&ram_block_discard_disabled, - old, old + 1) !=3D old); - return 0; + ram_block_discard_disable_mutex_unlock(); + return ret; } =20 int ram_block_discard_require(bool state) { - int old; + int ret =3D 0; =20 + ram_block_discard_disable_mutex_lock(); if (!state) { - qatomic_inc(&ram_block_discard_disabled); - return 0; + ram_block_discard_requirers--; + } else if (!ram_block_discard_disablers) { + ram_block_discard_requirers++; + } else { + ret =3D -EBUSY; } - - do { - old =3D qatomic_read(&ram_block_discard_disabled); - if (old > 0) { - return -EBUSY; - } - } while (qatomic_cmpxchg(&ram_block_discard_disabled, - old, old - 1) !=3D old); - return 0; + ram_block_discard_disable_mutex_unlock(); + return ret; } =20 bool ram_block_discard_is_disabled(void) { - return qatomic_read(&ram_block_discard_disabled) > 0; + return qatomic_read(&ram_block_discard_disablers); } =20 bool ram_block_discard_is_required(void) { - return qatomic_read(&ram_block_discard_disabled) < 0; + return qatomic_read(&ram_block_discard_requirers); } --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610027171; cv=none; d=zohomail.com; s=zohoarc; b=SH+iJqjEBaMBSUz0DOHa0NVBqYCYrEV+yL7IhNv3ujeJwKODat2d/qy6bkhQq/BIl2bdqGiwGTxsVQFYCAHTlnxW2QfIgFtw6m8QMTzIexNeQmWMsbPdSr3z9ohsTr3kDmtiqTTcEyyLoeKdTV96wlzN0q9TtTbK4MDXOKYyR3Y= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610027171; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=NDJl84KEdjlgLLvcRzDOsHL+HtcoP4SkwFsxAmiKiRE=; b=FHXTEHOO7k05cNHjRPwhCX9oZoBPmtPWBvljUANuC2lP1SjJW/MP4mya0rZpT1TVu0qq0/bV+bHfBSnkye8vxGuv7Z/P9vExxiBrhQosMZP67DQw8my5MR3/Ew91PuYCXUTvaQSvD9Xu0NAqUMMo3b4xGJzW1GKIezrz7JoGVQU= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610027171669334.52881394727615; Thu, 7 Jan 2021 05:46:11 -0800 (PST) Received: from localhost ([::1]:40396 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVcA-0006yu-9J for importer@patchew.org; Thu, 07 Jan 2021 08:46:10 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:36122) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVTB-00063f-D1 for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:57 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:32798) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVT5-0004fg-8x for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:36:53 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-476-85M06svQPa6vO3QCzX-uUA-1; Thu, 07 Jan 2021 08:36:44 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id 316AA801AA7; Thu, 7 Jan 2021 13:36:43 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 28A2E71C82; Thu, 7 Jan 2021 13:36:25 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026606; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=NDJl84KEdjlgLLvcRzDOsHL+HtcoP4SkwFsxAmiKiRE=; b=H+GPGPfQc4LtiChm1d/bKJyfCasJi+JqCkkAzTp7bEbCtPbR6AnAfDLAx/tnUDw6Y+RNLK yCIRPtUbjKSxBGl+mwHK46MCQGiHU4RsssGtmv9O3UcWj2ybhD6kHs9gDTX5tb0il4P4u2 hM9jF7cnrQmzipcIpgEHh1l8Cyo4UZ8= X-MC-Unique: 85M06svQPa6vO3QCzX-uUA-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 09/11] softmmu/physmem: Extend ram_block_discard_(require|disable) by two discard types Date: Thu, 7 Jan 2021 14:34:21 +0100 Message-Id: <20210107133423.44964-10-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Marek Kedzierski , Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , Alex Williamson , Peter Xu , "Dr . David Alan Gilbert" , Auger Eric , Pankaj Gupta , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" We want to separate the two cases whereby we discard ram - uncoordinated: e.g., virito-balloon - coordinated: e.g., virtio-mem coordinated via the RamDiscardMgr Reviewed-by: Pankaj Gupta Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- include/exec/memory.h | 18 +++++++++++++-- softmmu/physmem.c | 54 ++++++++++++++++++++++++++++++++++++++----- 2 files changed, 64 insertions(+), 8 deletions(-) diff --git a/include/exec/memory.h b/include/exec/memory.h index 67d9f1f3a7..11832cce3c 100644 --- a/include/exec/memory.h +++ b/include/exec/memory.h @@ -2808,6 +2808,12 @@ static inline MemOp devend_memop(enum device_endian = end) */ int ram_block_discard_disable(bool state); =20 +/* + * See ram_block_discard_disable(): only disable uncoordinated discards, + * keeping coordinated discards (via the RamDiscardMgr) enabled. + */ +int ram_block_uncoordinated_discard_disable(bool state); + /* * Inhibit technologies that disable discarding of pages in RAM blocks. * @@ -2817,12 +2823,20 @@ int ram_block_discard_disable(bool state); int ram_block_discard_require(bool state); =20 /* - * Test if discarding of memory in ram blocks is disabled. + * See ram_block_discard_require(): only inhibit technologies that disable + * uncoordinated discarding of pages in RAM blocks, allowing co-existance = with + * technologies that only inhibit uncoordinated discards (via the + * RamDiscardMgr). + */ +int ram_block_coordinated_discard_require(bool state); + +/* + * Test if any discarding of memory in ram blocks is disabled. */ bool ram_block_discard_is_disabled(void); =20 /* - * Test if discarding of memory in ram blocks is required to work reliably. + * Test if any discarding of memory in ram blocks is required to work reli= ably. */ bool ram_block_discard_is_required(void); =20 diff --git a/softmmu/physmem.c b/softmmu/physmem.c index dc61335b60..2e8512aa26 100644 --- a/softmmu/physmem.c +++ b/softmmu/physmem.c @@ -3660,8 +3660,14 @@ void mtree_print_dispatch(AddressSpaceDispatch *d, M= emoryRegion *root) } } =20 +/* Require any discards to work. */ static unsigned int ram_block_discard_requirers; +/* Require only coordinated discards to work. */ +static unsigned int ram_block_coordinated_discard_requirers; +/* Disable any discards. */ static unsigned int ram_block_discard_disablers; +/* Disable only uncoordinated discards. */ +static unsigned int ram_block_uncoordinated_discard_disablers; static QemuMutex ram_block_discard_disable_mutex; =20 static void ram_block_discard_disable_mutex_lock(void) @@ -3687,10 +3693,27 @@ int ram_block_discard_disable(bool state) ram_block_discard_disable_mutex_lock(); if (!state) { ram_block_discard_disablers--; - } else if (!ram_block_discard_requirers) { - ram_block_discard_disablers++; + } else if (ram_block_discard_requirers || + ram_block_coordinated_discard_requirers) { + ret =3D -EBUSY; } else { + ram_block_discard_disablers++; + } + ram_block_discard_disable_mutex_unlock(); + return ret; +} + +int ram_block_uncoordinated_discard_disable(bool state) +{ + int ret =3D 0; + + ram_block_discard_disable_mutex_lock(); + if (!state) { + ram_block_uncoordinated_discard_disablers--; + } else if (ram_block_discard_requirers) { ret =3D -EBUSY; + } else { + ram_block_uncoordinated_discard_disablers++; } ram_block_discard_disable_mutex_unlock(); return ret; @@ -3703,10 +3726,27 @@ int ram_block_discard_require(bool state) ram_block_discard_disable_mutex_lock(); if (!state) { ram_block_discard_requirers--; - } else if (!ram_block_discard_disablers) { - ram_block_discard_requirers++; + } else if (ram_block_discard_disablers || + ram_block_uncoordinated_discard_disablers) { + ret =3D -EBUSY; } else { + ram_block_discard_requirers++; + } + ram_block_discard_disable_mutex_unlock(); + return ret; +} + +int ram_block_coordinated_discard_require(bool state) +{ + int ret =3D 0; + + ram_block_discard_disable_mutex_lock(); + if (!state) { + ram_block_coordinated_discard_requirers--; + } else if (ram_block_discard_disablers) { ret =3D -EBUSY; + } else { + ram_block_coordinated_discard_requirers++; } ram_block_discard_disable_mutex_unlock(); return ret; @@ -3714,10 +3754,12 @@ int ram_block_discard_require(bool state) =20 bool ram_block_discard_is_disabled(void) { - return qatomic_read(&ram_block_discard_disablers); + return qatomic_read(&ram_block_discard_disablers) || + qatomic_read(&ram_block_uncoordinated_discard_disablers); } =20 bool ram_block_discard_is_required(void) { - return qatomic_read(&ram_block_discard_requirers); + return qatomic_read(&ram_block_discard_requirers) || + qatomic_read(&ram_block_coordinated_discard_requirers); } --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610026983; cv=none; d=zohomail.com; s=zohoarc; b=CY0FMA1QXfLc9EZwFC1078UwX5ak70ygeptWbP7N0oUniDu/cDFh9YQU7lU4CvnLNFeQ54HAbniOM0Nm9lGV6kk5ljayBeOvBzZwZ9TiGfaAdFyhpSN/qom6BvGwMNm1Nibc8wZlW1nFl2IEG75MiYlLBk7cV8VybLrlX2jqAt8= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610026983; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=dVlzzsAxRMvurHvFrOg8YkHRbLfUgjuHNTWvKkQZmQc=; b=AmnNgVkCPAsMLc/T7AnoB16wvCXAvx5vsY5paKQWvtELicIIxCsQvjcw3BXEoXsQ69IkaSb8LyhhL7or3gJA+rDU+y7kz+PnyvRrmeUslKQa8B4mApPSVD7twXIWE0xdXoIOA9x7eogL3aBDb9+x9eJzjJfFw1C3K9E1EqJ18ew= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610026983585962.2237004787817; Thu, 7 Jan 2021 05:43:03 -0800 (PST) Received: from localhost ([::1]:33010 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVZ8-0003qA-E0 for importer@patchew.org; Thu, 07 Jan 2021 08:43:02 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:36226) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVTZ-0006JH-IE for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:37:17 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:22845) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVTV-0004rF-Vf for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:37:17 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-358-0bjmQYbsMMmOIsStbWPJYw-1; Thu, 07 Jan 2021 08:37:10 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id B4CD91005E42; Thu, 7 Jan 2021 13:37:05 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 81C2371C82; Thu, 7 Jan 2021 13:36:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026633; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=dVlzzsAxRMvurHvFrOg8YkHRbLfUgjuHNTWvKkQZmQc=; b=V83a4a8Kk0AYDinbwHRo0+2YzOi9WrpwpPO635GwD181nsOjUVNHo+coVScjU8aJyrfFKr pbEPiU9/k6shjEPAr2HshwcNYRiNTsfb6T/NsQdGgcNKAsn85ZWpwW+f6W6isCJsQvqAoy hzYXm0Iy5VMmnsZRVTiBr/TKnCyMmlQ= X-MC-Unique: 0bjmQYbsMMmOIsStbWPJYw-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 10/11] virtio-mem: Require only coordinated discards Date: Thu, 7 Jan 2021 14:34:22 +0100 Message-Id: <20210107133423.44964-11-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Pankaj Gupta , Alex Williamson , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , "Dr . David Alan Gilbert" , Peter Xu , Marek Kedzierski , Auger Eric , Pankaj Gupta , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" We implement the RamDiscardMgr interface and only require coordinated discarding of RAM to work. Reviewed-by: Dr. David Alan Gilbert Reviewed-by: Pankaj Gupta Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- hw/virtio/virtio-mem.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/hw/virtio/virtio-mem.c b/hw/virtio/virtio-mem.c index f419a758f3..99d0712195 100644 --- a/hw/virtio/virtio-mem.c +++ b/hw/virtio/virtio-mem.c @@ -687,7 +687,7 @@ static void virtio_mem_device_realize(DeviceState *dev,= Error **errp) return; } =20 - if (ram_block_discard_require(true)) { + if (ram_block_coordinated_discard_require(true)) { error_setg(errp, "Discarding RAM is disabled"); return; } @@ -695,7 +695,7 @@ static void virtio_mem_device_realize(DeviceState *dev,= Error **errp) ret =3D ram_block_discard_range(rb, 0, qemu_ram_get_used_length(rb)); if (ret) { error_setg_errno(errp, -ret, "Unexpected error discarding RAM"); - ram_block_discard_require(false); + ram_block_coordinated_discard_require(false); return; } =20 @@ -738,7 +738,7 @@ static void virtio_mem_device_unrealize(DeviceState *de= v) virtio_del_queue(vdev, 0); virtio_cleanup(vdev); g_free(vmem->bitmap); - ram_block_discard_require(false); + ram_block_coordinated_discard_require(false); } =20 static int virtio_mem_discard_range_cb(const VirtIOMEM *vmem, void *arg, --=20 2.29.2 From nobody Tue Nov 18 09:16:25 2025 Delivered-To: importer@patchew.org Authentication-Results: mx.zohomail.com; dkim=fail; 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 ARC-Seal: i=1; a=rsa-sha256; t=1610027381; cv=none; d=zohomail.com; s=zohoarc; b=PgOp4ojbr1CMEYV8Mx9Het1RflMq42XzTD9lM9XbGTc6tzFPIb8SbAzvB1BlDmDZ5IhG3q3wukF/mzp+Pkt1gArAJt6+cHZFn1tEA5lZawmpgXKL9JSPMckRf2Zp9bCy95smtkKO2i8K5SqY8ho08yu3GQdydYo6GZ8wVTLwajk= ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=zohomail.com; s=zohoarc; t=1610027381; h=Content-Type:Content-Transfer-Encoding:Cc:Date:From:In-Reply-To:List-Subscribe:List-Post:List-Id:List-Archive:List-Help:List-Unsubscribe:MIME-Version:Message-ID:References:Sender:Subject:To; bh=0arJOqUiWWphhe5KuPGhKKhtNhEaKPCoVTvAuwp7jN0=; b=fMBk3UrT+l3T1uCklNPe9HnXMl/AMjtkAjfMq7XoFB3GhhKPoeTkbnRNk63nx1ogNBFbp8txqyLwC+/PD98BhD0wbOLK0hYoj+YI0Tk5Ok8oUwRDx1fxIoHUrc7fsKwdrMA8d8JOEXqIdHyDXD4Yzslj3a3brUN7JDKxCB7lu34= ARC-Authentication-Results: i=1; mx.zohomail.com; dkim=fail; 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 header.from= (p=none dis=none) header.from= Return-Path: Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) by mx.zohomail.com with SMTPS id 1610027381886392.52885114899243; Thu, 7 Jan 2021 05:49:41 -0800 (PST) Received: from localhost ([::1]:47480 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1kxVfY-0001Vv-PG for importer@patchew.org; Thu, 07 Jan 2021 08:49:40 -0500 Received: from eggs.gnu.org ([2001:470:142:3::10]:36284) by lists.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_GCM_SHA384:256) (Exim 4.90_1) (envelope-from ) id 1kxVTi-0006Nu-W9 for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:37:29 -0500 Received: from us-smtp-delivery-124.mimecast.com ([63.128.21.124]:47930) by eggs.gnu.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA1:256) (Exim 4.90_1) (envelope-from ) id 1kxVTZ-0004sB-8u for qemu-devel@nongnu.org; Thu, 07 Jan 2021 08:37:24 -0500 Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-350-DU-JQrSkMSyAP1ZHQK8YpQ-1; Thu, 07 Jan 2021 08:37:14 -0500 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id E5ED818C89DD; Thu, 7 Jan 2021 13:37:11 +0000 (UTC) Received: from t480s.redhat.com (ovpn-114-161.ams2.redhat.com [10.36.114.161]) by smtp.corp.redhat.com (Postfix) with ESMTP id 1151F71C82; Thu, 7 Jan 2021 13:37:05 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1610026635; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=0arJOqUiWWphhe5KuPGhKKhtNhEaKPCoVTvAuwp7jN0=; b=YB1RfRe4PaG1fEnHooHtP6NaGCE6LdYZdM5fxujqpSpOnvq62upBq0HZ5ebhJgAKV6z9Cj RhUY37IgoAcGFhtp80rpsgnsj4prmm72a5qo5U3zRgP1wi0o7IUUm4gDKXgJpQdJptHyyg ta/7p0b7REpLcy66BXvDGMqh66oMfnk= X-MC-Unique: DU-JQrSkMSyAP1ZHQK8YpQ-1 From: David Hildenbrand To: qemu-devel@nongnu.org Subject: [PATCH v4 11/11] vfio: Disable only uncoordinated discards Date: Thu, 7 Jan 2021 14:34:23 +0100 Message-Id: <20210107133423.44964-12-david@redhat.com> In-Reply-To: <20210107133423.44964-1-david@redhat.com> References: <20210107133423.44964-1-david@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Authentication-Results: relay.mimecast.com; auth=pass smtp.auth=CUSA124A263 smtp.mailfrom=david@redhat.com X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com 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=63.128.21.124; envelope-from=david@redhat.com; helo=us-smtp-delivery-124.mimecast.com X-Spam_score_int: -29 X-Spam_score: -3.0 X-Spam_bar: --- X-Spam_report: (-3.0 / 5.0 requ) BAYES_00=-1.9, DKIMWL_WL_HIGH=-0.246, DKIM_SIGNED=0.1, DKIM_VALID=-0.1, DKIM_VALID_AU=-0.1, DKIM_VALID_EF=-0.1, RCVD_IN_DNSWL_LOW=-0.7, RCVD_IN_MSPIKE_H4=0.001, RCVD_IN_MSPIKE_WL=0.001, SPF_HELO_NONE=0.001, SPF_PASS=-0.001 autolearn=ham autolearn_force=no X-Spam_action: no action X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Marek Kedzierski , Pankaj Gupta , Wei Yang , David Hildenbrand , "Michael S. Tsirkin" , Alex Williamson , Peter Xu , "Dr . David Alan Gilbert" , Auger Eric , Pankaj Gupta , teawater , Jonathan Cameron , Paolo Bonzini , Igor Mammedov Errors-To: qemu-devel-bounces+importer=patchew.org@nongnu.org Sender: "Qemu-devel" X-ZohoMail-DKIM: fail (Header signature does not verify) Content-Type: text/plain; charset="utf-8" We support coordinated discarding of RAM using the RamDiscardMgr. Let's unlock support for coordinated discards, keeping uncoordinated discards (e.g., via virtio-balloon) disabled. This unlocks virtio-mem + vfio. Note that vfio used via "nvme://" by the block layer has to be implemented/unlocked separately. For now, virtio-mem only supports x86-64 - spapr IOMMUs are not tested/affected. Note: The block size of a virtio-mem device has to be set to sane sizes, depending on the maximum hotplug size - to not run out of vfio mappings. The default virtio-mem block size is usually in the range of a couple of MBs. The maximum number of mapping is 64k, shared with other users. Assume you want to hotplug 256GB using virtio-mem - the block size would have to be set to at least 8 MiB (resulting in 32768 separate mappings). Reviewed-by: Pankaj Gupta Cc: Paolo Bonzini Cc: "Michael S. Tsirkin" Cc: Alex Williamson Cc: Dr. David Alan Gilbert Cc: Igor Mammedov Cc: Pankaj Gupta Cc: Peter Xu Cc: Auger Eric Cc: Wei Yang Cc: teawater Cc: Marek Kedzierski Signed-off-by: David Hildenbrand --- hw/vfio/common.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/hw/vfio/common.c b/hw/vfio/common.c index 2b9ba3f8c9..ee7a82524a 100644 --- a/hw/vfio/common.c +++ b/hw/vfio/common.c @@ -1976,8 +1976,10 @@ static int vfio_connect_container(VFIOGroup *group, = AddressSpace *as, * new memory, it will not yet set ram_block_discard_set_required() and * therefore, neither stops us here or deals with the sudden memory * consumption of inflated memory. + * + * We do support discarding of memory coordinated via the RamDiscardMg= r. */ - ret =3D ram_block_discard_disable(true); + ret =3D ram_block_uncoordinated_discard_disable(true); if (ret) { error_setg_errno(errp, -ret, "Cannot set discarding of RAM broken"= ); return ret; @@ -2157,7 +2159,7 @@ close_fd_exit: close(fd); =20 put_space_exit: - ram_block_discard_disable(false); + ram_block_uncoordinated_discard_disable(false); vfio_put_address_space(space); =20 return ret; @@ -2279,7 +2281,7 @@ void vfio_put_group(VFIOGroup *group) } =20 if (!group->ram_block_discard_allowed) { - ram_block_discard_disable(false); + ram_block_uncoordinated_discard_disable(false); } vfio_kvm_device_del_group(group); vfio_disconnect_container(group); @@ -2333,7 +2335,7 @@ int vfio_get_device(VFIOGroup *group, const char *nam= e, =20 if (!group->ram_block_discard_allowed) { group->ram_block_discard_allowed =3D true; - ram_block_discard_disable(false); + ram_block_uncoordinated_discard_disable(false); } } =20 --=20 2.29.2