From: David Hildenbrand <david@redhat.com> To: qemu-devel@nongnu.org Cc: kvm@vger.kernel.org, qemu-s390x@nongnu.org, Richard Henderson <rth@twiddle.net>, Paolo Bonzini <pbonzini@redhat.com>, "Dr . David Alan Gilbert" <dgilbert@redhat.com>, Eduardo Habkost <ehabkost@redhat.com>, "Michael S . Tsirkin" <mst@redhat.com>, David Hildenbrand <david@redhat.com> Subject: [PATCH v4 01/21] exec: Introduce ram_block_discard_(disable|require)() Date: Wed, 10 Jun 2020 13:53:59 +0200 [thread overview] Message-ID: <20200610115419.51688-2-david@redhat.com> (raw) In-Reply-To: <20200610115419.51688-1-david@redhat.com> We want to replace qemu_balloon_inhibit() by something more generic. Especially, we want to make sure that technologies that really rely on RAM block discards to work reliably to run mutual exclusive with technologies that effectively break it. E.g., vfio will usually pin all guest memory, turning the virtio-balloon basically useless and make the VM consume more memory than reported via the balloon. While the balloon is special already (=> no guarantees, same behavior possible afer reboots and with huge pages), this will be different, especially, with virtio-mem. Let's implement a way such that we can make both types of technology run mutually exclusive. We'll convert existing balloon inhibitors in successive patches and add some new ones. Add the check to qemu_balloon_is_inhibited() for now. We might want to make virtio-balloon an acutal inhibitor in the future - however, that requires more thought to not break existing setups. Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com> Cc: "Michael S. Tsirkin" <mst@redhat.com> Cc: Richard Henderson <rth@twiddle.net> Cc: Paolo Bonzini <pbonzini@redhat.com> Signed-off-by: David Hildenbrand <david@redhat.com> --- balloon.c | 3 ++- exec.c | 52 +++++++++++++++++++++++++++++++++++++++++++ include/exec/memory.h | 41 ++++++++++++++++++++++++++++++++++ 3 files changed, 95 insertions(+), 1 deletion(-) diff --git a/balloon.c b/balloon.c index f104b42961..5fff79523a 100644 --- a/balloon.c +++ b/balloon.c @@ -40,7 +40,8 @@ static int balloon_inhibit_count; bool qemu_balloon_is_inhibited(void) { - return atomic_read(&balloon_inhibit_count) > 0; + return atomic_read(&balloon_inhibit_count) > 0 || + ram_block_discard_is_disabled(); } void qemu_balloon_inhibit(bool state) diff --git a/exec.c b/exec.c index be4be2df3a..c4c1d9df84 100644 --- a/exec.c +++ b/exec.c @@ -4051,4 +4051,56 @@ void mtree_print_dispatch(AddressSpaceDispatch *d, MemoryRegion *root) } } +/* + * If positive, discarding RAM is disabled. If negative, discarding RAM is + * required to work and cannot be disabled. + */ +static int ram_block_discard_disabled; + +int ram_block_discard_disable(bool state) +{ + int old; + + if (!state) { + atomic_dec(&ram_block_discard_disabled); + return 0; + } + + do { + old = atomic_read(&ram_block_discard_disabled); + if (old < 0) { + return -EBUSY; + } + } while (atomic_cmpxchg(&ram_block_discard_disabled, old, old + 1) != old); + return 0; +} + +int ram_block_discard_require(bool state) +{ + int old; + + if (!state) { + atomic_inc(&ram_block_discard_disabled); + return 0; + } + + do { + old = atomic_read(&ram_block_discard_disabled); + if (old > 0) { + return -EBUSY; + } + } while (atomic_cmpxchg(&ram_block_discard_disabled, old, old - 1) != old); + return 0; +} + +bool ram_block_discard_is_disabled(void) +{ + return atomic_read(&ram_block_discard_disabled) > 0; +} + +bool ram_block_discard_is_required(void) +{ + return atomic_read(&ram_block_discard_disabled) < 0; +} + #endif diff --git a/include/exec/memory.h b/include/exec/memory.h index 3e00cdbbfa..eea7d284b9 100644 --- a/include/exec/memory.h +++ b/include/exec/memory.h @@ -2474,6 +2474,47 @@ static inline MemOp devend_memop(enum device_endian end) } #endif +/* + * Inhibit technologies that require discarding of pages in RAM blocks, e.g., + * to manage the actual amount of memory consumed by the VM (then, the memory + * provided by RAM blocks might be bigger than the desired memory consumption). + * This *must* be set if: + * - Discarding parts of a RAM blocks does not result in the change being + * reflected in the VM and the pages getting freed. + * - All memory in RAM blocks is pinned or duplicated, invaldiating any previous + * discards blindly. + * - Discarding parts of a RAM blocks will result in integrity issues (e.g., + * encrypted VMs). + * Technologies that only temporarily pin the current working set of a + * driver are fine, because we don't expect such pages to be discarded + * (esp. based on guest action like balloon inflation). + * + * This is *not* to be used to protect from concurrent discards (esp., + * postcopy). + * + * Returns 0 if successful. Returns -EBUSY if a technology that relies on + * discards to work reliably is active. + */ +int ram_block_discard_disable(bool state); + +/* + * Inhibit technologies that disable discarding of pages in RAM blocks. + * + * Returns 0 if successful. Returns -EBUSY if discards are already set to + * broken. + */ +int ram_block_discard_require(bool state); + +/* + * Test if discarding of memory in ram blocks is disabled. + */ +bool ram_block_discard_is_disabled(void); + +/* + * Test if discarding of memory in ram blocks is required to work reliably. + */ +bool ram_block_discard_is_required(void); + #endif #endif -- 2.26.2
WARNING: multiple messages have this Message-ID (diff)
From: David Hildenbrand <david@redhat.com> To: qemu-devel@nongnu.org Cc: Eduardo Habkost <ehabkost@redhat.com>, kvm@vger.kernel.org, "Michael S . Tsirkin" <mst@redhat.com>, David Hildenbrand <david@redhat.com>, "Dr . David Alan Gilbert" <dgilbert@redhat.com>, qemu-s390x@nongnu.org, Paolo Bonzini <pbonzini@redhat.com>, Richard Henderson <rth@twiddle.net> Subject: [PATCH v4 01/21] exec: Introduce ram_block_discard_(disable|require)() Date: Wed, 10 Jun 2020 13:53:59 +0200 [thread overview] Message-ID: <20200610115419.51688-2-david@redhat.com> (raw) In-Reply-To: <20200610115419.51688-1-david@redhat.com> We want to replace qemu_balloon_inhibit() by something more generic. Especially, we want to make sure that technologies that really rely on RAM block discards to work reliably to run mutual exclusive with technologies that effectively break it. E.g., vfio will usually pin all guest memory, turning the virtio-balloon basically useless and make the VM consume more memory than reported via the balloon. While the balloon is special already (=> no guarantees, same behavior possible afer reboots and with huge pages), this will be different, especially, with virtio-mem. Let's implement a way such that we can make both types of technology run mutually exclusive. We'll convert existing balloon inhibitors in successive patches and add some new ones. Add the check to qemu_balloon_is_inhibited() for now. We might want to make virtio-balloon an acutal inhibitor in the future - however, that requires more thought to not break existing setups. Reviewed-by: Dr. David Alan Gilbert <dgilbert@redhat.com> Cc: "Michael S. Tsirkin" <mst@redhat.com> Cc: Richard Henderson <rth@twiddle.net> Cc: Paolo Bonzini <pbonzini@redhat.com> Signed-off-by: David Hildenbrand <david@redhat.com> --- balloon.c | 3 ++- exec.c | 52 +++++++++++++++++++++++++++++++++++++++++++ include/exec/memory.h | 41 ++++++++++++++++++++++++++++++++++ 3 files changed, 95 insertions(+), 1 deletion(-) diff --git a/balloon.c b/balloon.c index f104b42961..5fff79523a 100644 --- a/balloon.c +++ b/balloon.c @@ -40,7 +40,8 @@ static int balloon_inhibit_count; bool qemu_balloon_is_inhibited(void) { - return atomic_read(&balloon_inhibit_count) > 0; + return atomic_read(&balloon_inhibit_count) > 0 || + ram_block_discard_is_disabled(); } void qemu_balloon_inhibit(bool state) diff --git a/exec.c b/exec.c index be4be2df3a..c4c1d9df84 100644 --- a/exec.c +++ b/exec.c @@ -4051,4 +4051,56 @@ void mtree_print_dispatch(AddressSpaceDispatch *d, MemoryRegion *root) } } +/* + * If positive, discarding RAM is disabled. If negative, discarding RAM is + * required to work and cannot be disabled. + */ +static int ram_block_discard_disabled; + +int ram_block_discard_disable(bool state) +{ + int old; + + if (!state) { + atomic_dec(&ram_block_discard_disabled); + return 0; + } + + do { + old = atomic_read(&ram_block_discard_disabled); + if (old < 0) { + return -EBUSY; + } + } while (atomic_cmpxchg(&ram_block_discard_disabled, old, old + 1) != old); + return 0; +} + +int ram_block_discard_require(bool state) +{ + int old; + + if (!state) { + atomic_inc(&ram_block_discard_disabled); + return 0; + } + + do { + old = atomic_read(&ram_block_discard_disabled); + if (old > 0) { + return -EBUSY; + } + } while (atomic_cmpxchg(&ram_block_discard_disabled, old, old - 1) != old); + return 0; +} + +bool ram_block_discard_is_disabled(void) +{ + return atomic_read(&ram_block_discard_disabled) > 0; +} + +bool ram_block_discard_is_required(void) +{ + return atomic_read(&ram_block_discard_disabled) < 0; +} + #endif diff --git a/include/exec/memory.h b/include/exec/memory.h index 3e00cdbbfa..eea7d284b9 100644 --- a/include/exec/memory.h +++ b/include/exec/memory.h @@ -2474,6 +2474,47 @@ static inline MemOp devend_memop(enum device_endian end) } #endif +/* + * Inhibit technologies that require discarding of pages in RAM blocks, e.g., + * to manage the actual amount of memory consumed by the VM (then, the memory + * provided by RAM blocks might be bigger than the desired memory consumption). + * This *must* be set if: + * - Discarding parts of a RAM blocks does not result in the change being + * reflected in the VM and the pages getting freed. + * - All memory in RAM blocks is pinned or duplicated, invaldiating any previous + * discards blindly. + * - Discarding parts of a RAM blocks will result in integrity issues (e.g., + * encrypted VMs). + * Technologies that only temporarily pin the current working set of a + * driver are fine, because we don't expect such pages to be discarded + * (esp. based on guest action like balloon inflation). + * + * This is *not* to be used to protect from concurrent discards (esp., + * postcopy). + * + * Returns 0 if successful. Returns -EBUSY if a technology that relies on + * discards to work reliably is active. + */ +int ram_block_discard_disable(bool state); + +/* + * Inhibit technologies that disable discarding of pages in RAM blocks. + * + * Returns 0 if successful. Returns -EBUSY if discards are already set to + * broken. + */ +int ram_block_discard_require(bool state); + +/* + * Test if discarding of memory in ram blocks is disabled. + */ +bool ram_block_discard_is_disabled(void); + +/* + * Test if discarding of memory in ram blocks is required to work reliably. + */ +bool ram_block_discard_is_required(void); + #endif #endif -- 2.26.2
next prev parent reply other threads:[~2020-06-10 11:54 UTC|newest] Thread overview: 68+ messages / expand[flat|nested] mbox.gz Atom feed top 2020-06-10 11:53 [PATCH v4 00/21] virtio-mem: Paravirtualized memory hot(un)plug David Hildenbrand 2020-06-10 11:53 ` David Hildenbrand 2020-06-10 11:53 ` David Hildenbrand [this message] 2020-06-10 11:53 ` [PATCH v4 01/21] exec: Introduce ram_block_discard_(disable|require)() David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 02/21] vfio: Convert to ram_block_discard_disable() David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 13:04 ` Tony Krowiak 2020-06-10 13:04 ` Tony Krowiak 2020-06-10 14:13 ` David Hildenbrand 2020-06-10 14:13 ` David Hildenbrand 2020-06-16 11:15 ` Cornelia Huck 2020-06-16 11:15 ` Cornelia Huck 2020-06-10 11:54 ` [PATCH v4 03/21] accel/kvm: " David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 04/21] s390x/pv: " David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-16 11:17 ` Cornelia Huck 2020-06-16 11:17 ` Cornelia Huck 2020-06-10 11:54 ` [PATCH v4 05/21] virtio-balloon: Rip out qemu_balloon_inhibit() David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-16 10:56 ` Dr. David Alan Gilbert 2020-06-16 10:56 ` Dr. David Alan Gilbert 2020-06-24 15:32 ` Michael S. Tsirkin 2020-06-24 15:32 ` Michael S. Tsirkin 2020-06-10 11:54 ` [PATCH v4 06/21] target/i386: sev: Use ram_block_discard_disable() David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 07/21] migration/rdma: " David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 08/21] migration/colo: " David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 09/21] linux-headers: update to contain virtio-mem David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 10/21] virtio-mem: Paravirtualized memory hot(un)plug David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 11/21] virtio-pci: Proxy for virtio-mem David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 12/21] MAINTAINERS: Add myself as virtio-mem maintainer David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 13/21] hmp: Handle virtio-mem when printing memory device info David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-17 17:53 ` Dr. David Alan Gilbert 2020-06-17 17:53 ` Dr. David Alan Gilbert 2020-06-17 17:54 ` Dr. David Alan Gilbert 2020-06-17 17:54 ` Dr. David Alan Gilbert 2020-06-10 11:54 ` [PATCH v4 14/21] numa: Handle virtio-mem in NUMA stats David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 15/21] pc: Support for virtio-mem-pci David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 16/21] virtio-mem: Allow notifiers for size changes David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 17/21] virtio-pci: Send qapi events when the virtio-mem " David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 18/21] virtio-mem: Migration sanity checks David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-17 17:59 ` Dr. David Alan Gilbert 2020-06-17 17:59 ` Dr. David Alan Gilbert 2020-06-18 10:39 ` David Hildenbrand 2020-06-18 10:39 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 19/21] virtio-mem: Add trace events David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 20/21] virtio-mem: Exclude unplugged memory during migration David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-10 11:54 ` [PATCH v4 21/21] numa: Auto-enable NUMA when any memory devices are possible David Hildenbrand 2020-06-10 11:54 ` David Hildenbrand 2020-06-24 15:33 ` [PATCH v4 00/21] virtio-mem: Paravirtualized memory hot(un)plug Michael S. Tsirkin 2020-06-24 15:33 ` Michael S. Tsirkin 2020-06-24 15:40 ` David Hildenbrand 2020-06-24 15:40 ` David Hildenbrand
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=20200610115419.51688-2-david@redhat.com \ --to=david@redhat.com \ --cc=dgilbert@redhat.com \ --cc=ehabkost@redhat.com \ --cc=kvm@vger.kernel.org \ --cc=mst@redhat.com \ --cc=pbonzini@redhat.com \ --cc=qemu-devel@nongnu.org \ --cc=qemu-s390x@nongnu.org \ --cc=rth@twiddle.net \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.