From: David Hildenbrand <david@redhat.com>
To: linux-kernel@vger.kernel.org
Cc: linux-mm@kvack.org, virtio-dev@lists.oasis-open.org,
virtualization@lists.linux-foundation.org, kvm@vger.kernel.org,
Michal Hocko <mhocko@kernel.org>,
Andrew Morton <akpm@linux-foundation.org>,
"Michael S . Tsirkin" <mst@redhat.com>,
David Hildenbrand <david@redhat.com>,
Jason Wang <jasowang@redhat.com>,
Oscar Salvador <osalvador@suse.de>,
Igor Mammedov <imammedo@redhat.com>,
Dave Young <dyoung@redhat.com>,
Dan Williams <dan.j.williams@intel.com>,
Pavel Tatashin <pasha.tatashin@soleen.com>,
Stefan Hajnoczi <stefanha@redhat.com>,
Vlastimil Babka <vbabka@suse.cz>
Subject: [PATCH RFC v4 03/13] virtio-mem: Paravirtualized memory hotunplug part 1
Date: Thu, 12 Dec 2019 18:11:27 +0100 [thread overview]
Message-ID: <20191212171137.13872-4-david@redhat.com> (raw)
In-Reply-To: <20191212171137.13872-1-david@redhat.com>
Unplugging subblocks of memory blocks that are offline is easy. All we
have to do is watch out for concurrent onlining acticity.
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: Jason Wang <jasowang@redhat.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Igor Mammedov <imammedo@redhat.com>
Cc: Dave Young <dyoung@redhat.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Pavel Tatashin <pasha.tatashin@soleen.com>
Cc: Stefan Hajnoczi <stefanha@redhat.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: David Hildenbrand <david@redhat.com>
---
drivers/virtio/virtio_mem.c | 109 +++++++++++++++++++++++++++++++++++-
1 file changed, 107 insertions(+), 2 deletions(-)
diff --git a/drivers/virtio/virtio_mem.c b/drivers/virtio/virtio_mem.c
index 8f4ceeab3d7c..f1af05def5df 100644
--- a/drivers/virtio/virtio_mem.c
+++ b/drivers/virtio/virtio_mem.c
@@ -119,7 +119,7 @@ struct virtio_mem {
*
* When this lock is held the pointers can't change, ONLINE and
* OFFLINE blocks can't change the state and no subblocks will get
- * plugged.
+ * plugged/unplugged.
*/
struct mutex hotplug_mutex;
bool hotplug_active;
@@ -321,6 +321,19 @@ static bool virtio_mem_mb_test_sb_plugged(struct virtio_mem *vm,
bit + count;
}
+/*
+ * Test if all selected subblocks are unplugged.
+ */
+static bool virtio_mem_mb_test_sb_unplugged(struct virtio_mem *vm,
+ unsigned long mb_id, int sb_id,
+ int count)
+{
+ const int bit = (mb_id - vm->first_mb_id) * vm->nb_sb_per_mb + sb_id;
+
+ /* TODO: Helper similar to bitmap_set() */
+ return find_next_bit(vm->sb_bitmap, bit + count, bit) >= bit + count;
+}
+
/*
* Find the first plugged subblock. Returns vm->nb_sb_per_mb in case there is
* none.
@@ -511,6 +524,9 @@ static void virtio_mem_notify_offline(struct virtio_mem *vm,
BUG();
break;
}
+
+ /* trigger the workqueue, maybe we can now unplug memory. */
+ virtio_mem_retry(vm);
}
static void virtio_mem_notify_online(struct virtio_mem *vm, unsigned long mb_id,
@@ -1123,6 +1139,93 @@ static int virtio_mem_plug_request(struct virtio_mem *vm, uint64_t diff)
return rc;
}
+/*
+ * Unplug the desired number of plugged subblocks of an offline memory block.
+ * Will fail if any subblock cannot get unplugged (instead of skipping it).
+ *
+ * Will modify the state of the memory block. Might temporarily drop the
+ * hotplug_mutex.
+ *
+ * Note: Can fail after some subblocks were successfully unplugged.
+ */
+static int virtio_mem_mb_unplug_any_sb_offline(struct virtio_mem *vm,
+ unsigned long mb_id,
+ uint64_t *nb_sb)
+{
+ int rc;
+
+ rc = virtio_mem_mb_unplug_any_sb(vm, mb_id, nb_sb);
+
+ /* some subblocks might have been unplugged even on failure */
+ if (!virtio_mem_mb_test_sb_plugged(vm, mb_id, 0, vm->nb_sb_per_mb))
+ virtio_mem_mb_set_state(vm, mb_id,
+ VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL);
+ if (rc)
+ return rc;
+
+ if (virtio_mem_mb_test_sb_unplugged(vm, mb_id, 0, vm->nb_sb_per_mb)) {
+ /*
+ * Remove the block from Linux - this should never fail.
+ * Hinder the block from getting onlined by marking it
+ * unplugged. Temporarily drop the mutex, so
+ * any pending GOING_ONLINE requests can be serviced/rejected.
+ */
+ virtio_mem_mb_set_state(vm, mb_id,
+ VIRTIO_MEM_MB_STATE_UNUSED);
+
+ mutex_unlock(&vm->hotplug_mutex);
+ rc = virtio_mem_mb_remove(vm, mb_id);
+ BUG_ON(rc);
+ mutex_lock(&vm->hotplug_mutex);
+ }
+ return 0;
+}
+
+/*
+ * Try to unplug the requested amount of memory.
+ */
+static int virtio_mem_unplug_request(struct virtio_mem *vm, uint64_t diff)
+{
+ uint64_t nb_sb = diff / vm->subblock_size;
+ unsigned long mb_id;
+ int rc;
+
+ if (!nb_sb)
+ return 0;
+
+ /*
+ * We'll drop the mutex a couple of times when it is safe to do so.
+ * This might result in some blocks switching the state (online/offline)
+ * and we could miss them in this run - we will retry again later.
+ */
+ mutex_lock(&vm->hotplug_mutex);
+
+ /* Try to unplug subblocks of partially plugged offline blocks. */
+ virtio_mem_for_each_mb_state(vm, mb_id,
+ VIRTIO_MEM_MB_STATE_OFFLINE_PARTIAL) {
+ rc = virtio_mem_mb_unplug_any_sb_offline(vm, mb_id,
+ &nb_sb);
+ if (rc || !nb_sb)
+ goto out_unlock;
+ cond_resched();
+ }
+
+ /* Try to unplug subblocks of plugged offline blocks. */
+ virtio_mem_for_each_mb_state(vm, mb_id, VIRTIO_MEM_MB_STATE_OFFLINE) {
+ rc = virtio_mem_mb_unplug_any_sb_offline(vm, mb_id,
+ &nb_sb);
+ if (rc || !nb_sb)
+ goto out_unlock;
+ cond_resched();
+ }
+
+ mutex_unlock(&vm->hotplug_mutex);
+ return 0;
+out_unlock:
+ mutex_unlock(&vm->hotplug_mutex);
+ return rc;
+}
+
/*
* Try to unplug all blocks that couldn't be unplugged before, for example,
* because the hypervisor was busy.
@@ -1203,8 +1306,10 @@ static void virtio_mem_run_wq(struct work_struct *work)
if (vm->requested_size > vm->plugged_size) {
diff = vm->requested_size - vm->plugged_size;
rc = virtio_mem_plug_request(vm, diff);
+ } else {
+ diff = vm->plugged_size - vm->requested_size;
+ rc = virtio_mem_unplug_request(vm, diff);
}
- /* TODO: try to unplug memory */
}
switch (rc) {
--
2.23.0
next prev parent reply other threads:[~2019-12-12 17:12 UTC|newest]
Thread overview: 47+ messages / expand[flat|nested] mbox.gz Atom feed top
2019-12-12 17:11 [PATCH RFC v4 00/13] virtio-mem: paravirtualized memory David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 01/13] ACPI: NUMA: export pxm_to_node David Hildenbrand
2019-12-12 21:43 ` Rafael J. Wysocki
2019-12-13 9:41 ` David Hildenbrand
2019-12-13 9:47 ` Rafael J. Wysocki
2019-12-12 17:11 ` [PATCH RFC v4 02/13] virtio-mem: Paravirtualized memory hotplug David Hildenbrand
2019-12-12 17:11 ` David Hildenbrand [this message]
2019-12-12 17:11 ` [PATCH RFC v4 04/13] mm: Export alloc_contig_range() / free_contig_range() David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 05/13] virtio-mem: Paravirtualized memory hotunplug part 2 David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 06/13] mm: Allow to offline unmovable PageOffline() pages via MEM_GOING_OFFLINE David Hildenbrand
2020-02-25 18:26 ` Alexander Duyck
2020-02-25 18:49 ` David Hildenbrand
2020-02-25 21:46 ` Alexander Duyck
2020-02-25 22:19 ` David Hildenbrand
2020-02-26 16:27 ` Alexander Duyck
2019-12-12 17:11 ` [PATCH RFC v4 07/13] virtio-mem: Allow to offline partially unplugged memory blocks David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 08/13] mm/memory_hotplug: Introduce offline_and_remove_memory() David Hildenbrand
2020-02-25 14:11 ` Michal Hocko
2020-02-25 14:27 ` David Hildenbrand
2020-03-02 12:48 ` Michal Hocko
2020-03-02 12:53 ` David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 09/13] virtio-mem: Offline and remove completely unplugged memory blocks David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 10/13] virtio-mem: Better retry handling David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 11/13] mm/vmscan: Move count_vm_event(DROP_SLAB) into drop_slab() David Hildenbrand
2020-02-25 14:13 ` Michal Hocko
2019-12-12 17:11 ` [PATCH RFC v4 12/13] mm/vmscan: Export drop_slab() and drop_slab_node() David Hildenbrand
2020-02-25 14:58 ` Michal Hocko
2020-02-25 15:09 ` David Hildenbrand
2020-02-25 17:06 ` Michal Hocko
2020-02-25 17:23 ` David Hildenbrand
2019-12-12 17:11 ` [PATCH RFC v4 13/13] virtio-mem: Drop slab objects when unplug continues to fail David Hildenbrand
2019-12-13 20:15 ` [PATCH RFC v4 00/13] virtio-mem: paravirtualized memory Konrad Rzeszutek Wilk
2019-12-16 11:03 ` David Hildenbrand
2019-12-24 6:58 ` teawater
2019-12-24 9:28 ` David Hildenbrand
2020-01-09 13:48 ` David Hildenbrand
2020-01-29 9:41 ` David Hildenbrand
2020-02-25 9:58 ` David Hildenbrand
2020-06-05 8:55 ` Alex Shi
2020-06-05 9:08 ` David Hildenbrand
2020-06-05 9:36 ` David Hildenbrand
2020-06-05 10:05 ` David Hildenbrand
2020-06-05 10:46 ` Alex Shi
2020-06-05 12:18 ` David Hildenbrand
2020-06-09 3:05 ` Alex Shi
2020-06-05 10:08 ` Alex Shi
2020-06-05 10:06 ` Alex Shi
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=20191212171137.13872-4-david@redhat.com \
--to=david@redhat.com \
--cc=akpm@linux-foundation.org \
--cc=dan.j.williams@intel.com \
--cc=dyoung@redhat.com \
--cc=imammedo@redhat.com \
--cc=jasowang@redhat.com \
--cc=kvm@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=mhocko@kernel.org \
--cc=mst@redhat.com \
--cc=osalvador@suse.de \
--cc=pasha.tatashin@soleen.com \
--cc=stefanha@redhat.com \
--cc=vbabka@suse.cz \
--cc=virtio-dev@lists.oasis-open.org \
--cc=virtualization@lists.linux-foundation.org \
/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: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).