iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

virtio-mem: simplify high-level unplug handling in Sub Block Mode

Browse Source 
Let's simplify by introducing a new virtio_mem_sbm_unplug_any_sb(),
similar to virtio_mem_sbm_plug_any_sb(), to simplify high-level memory
block selection when unplugging in Sub Block Mode.

Rename existing virtio_mem_sbm_unplug_any_sb() to
virtio_mem_sbm_unplug_any_sb_raw().

The only change is that we now temporarily unlock the hotplug mutex around
cond_resched() when processing offline memory blocks, which doesn't
make a real difference as we already have to temporarily unlock in
virtio_mem_sbm_unplug_any_sb_offline() when removing a memory block.

Signed-off-by: David Hildenbrand <david@redhat.com>
Link: https://lore.kernel.org/r/20210602185720.31821-5-david@redhat.com
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
David Hildenbrand 2021-06-02 20:57:17 +02:00 committed by Michael S. Tsirkin
parent f4cf803dff
commit 5304ca3dd7
1 changed files with 57 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

103
drivers/virtio/virtio_mem.c
View File

@ -1453,8 +1453,8 @@ static int virtio_mem_bbm_plug_bb(struct virtio_mem *vm, unsigned long bb_id)
* *
* Note: can fail after some subblocks were unplugged. * Note: can fail after some subblocks were unplugged.
*/ */
static int virtio_mem_sbm_unplug_any_sb(struct virtio_mem *vm, static int virtio_mem_sbm_unplug_any_sb_raw(struct virtio_mem *vm,
unsigned long mb_id, uint64_t *nb_sb) unsigned long mb_id, uint64_t *nb_sb)
{ {
int sb_id, count; int sb_id, count;
int rc; int rc;
@ -1496,7 +1496,7 @@ static int virtio_mem_sbm_unplug_mb(struct virtio_mem *vm, unsigned long mb_id)
{ {
uint64_t nb_sb = vm->sbm.sbs_per_mb; uint64_t nb_sb = vm->sbm.sbs_per_mb;
return virtio_mem_sbm_unplug_any_sb(vm, mb_id, &nb_sb); return virtio_mem_sbm_unplug_any_sb_raw(vm, mb_id, &nb_sb);
} }
/* /*
@ -1806,7 +1806,7 @@ static int virtio_mem_sbm_unplug_any_sb_offline(struct virtio_mem *vm,
{ {
int rc; int rc;
rc = virtio_mem_sbm_unplug_any_sb(vm, mb_id, nb_sb); rc = virtio_mem_sbm_unplug_any_sb_raw(vm, mb_id, nb_sb);
/* some subblocks might have been unplugged even on failure */ /* some subblocks might have been unplugged even on failure */
if (!virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->sbm.sbs_per_mb)) if (!virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->sbm.sbs_per_mb))
@ -1929,11 +1929,46 @@ unplugged:
return 0; return 0;
} }
/*
* Unplug the desired number of plugged subblocks of a memory block that is
* already added to Linux. Will skip subblock of online memory blocks that are
* busy (by the OS). Will fail if any subblock that's not busy cannot get
* unplugged.
*
* Will modify the state of the memory block. Might temporarily drop the
* hotplug_mutex.
*
* Note: Can fail after some subblocks were successfully unplugged. Can
* return 0 even if subblocks were busy and could not get unplugged.
*/
static int virtio_mem_sbm_unplug_any_sb(struct virtio_mem *vm,
unsigned long mb_id,
uint64_t *nb_sb)
{
const int old_state = virtio_mem_sbm_get_mb_state(vm, mb_id);
switch (old_state) {
case VIRTIO_MEM_SBM_MB_ONLINE_PARTIAL:
case VIRTIO_MEM_SBM_MB_ONLINE:
return virtio_mem_sbm_unplug_any_sb_online(vm, mb_id, nb_sb);
case VIRTIO_MEM_SBM_MB_OFFLINE_PARTIAL:
case VIRTIO_MEM_SBM_MB_OFFLINE:
return virtio_mem_sbm_unplug_any_sb_offline(vm, mb_id, nb_sb);
}
return -EINVAL;
}
static int virtio_mem_sbm_unplug_request(struct virtio_mem *vm, uint64_t diff) static int virtio_mem_sbm_unplug_request(struct virtio_mem *vm, uint64_t diff)
{ {
const int mb_states[] = {
VIRTIO_MEM_SBM_MB_OFFLINE_PARTIAL,
VIRTIO_MEM_SBM_MB_OFFLINE,
VIRTIO_MEM_SBM_MB_ONLINE_PARTIAL,
VIRTIO_MEM_SBM_MB_ONLINE,
};
uint64_t nb_sb = diff / vm->sbm.sb_size; uint64_t nb_sb = diff / vm->sbm.sb_size;
unsigned long mb_id; unsigned long mb_id;
int rc; int rc, i;
if (!nb_sb) if (!nb_sb)
return 0; return 0;
@ -1945,47 +1980,23 @@ static int virtio_mem_sbm_unplug_request(struct virtio_mem *vm, uint64_t diff)
*/ */
mutex_lock(&vm->hotplug_mutex); mutex_lock(&vm->hotplug_mutex);
/* Try to unplug subblocks of partially plugged offline blocks. */ /*
virtio_mem_sbm_for_each_mb_rev(vm, mb_id, * We try unplug from partially plugged blocks first, to try removing
VIRTIO_MEM_SBM_MB_OFFLINE_PARTIAL) { * whole memory blocks along with metadata.
rc = virtio_mem_sbm_unplug_any_sb_offline(vm, mb_id, &nb_sb); */
if (rc || !nb_sb) for (i = 0; i < ARRAY_SIZE(mb_states); i++) {
goto out_unlock; virtio_mem_sbm_for_each_mb_rev(vm, mb_id, mb_states[i]) {
cond_resched(); rc = virtio_mem_sbm_unplug_any_sb(vm, mb_id, &nb_sb);
} if (rc || !nb_sb)
goto out_unlock;
/* Try to unplug subblocks of plugged offline blocks. */ mutex_unlock(&vm->hotplug_mutex);
virtio_mem_sbm_for_each_mb_rev(vm, mb_id, VIRTIO_MEM_SBM_MB_OFFLINE) { cond_resched();
rc = virtio_mem_sbm_unplug_any_sb_offline(vm, mb_id, &nb_sb); mutex_lock(&vm->hotplug_mutex);
if (rc || !nb_sb) }
goto out_unlock; if (!unplug_online && i == 1) {
cond_resched(); mutex_unlock(&vm->hotplug_mutex);
} return 0;
}
if (!unplug_online) {
mutex_unlock(&vm->hotplug_mutex);
return 0;
}
/* Try to unplug subblocks of partially plugged online blocks. */
virtio_mem_sbm_for_each_mb_rev(vm, mb_id,
VIRTIO_MEM_SBM_MB_ONLINE_PARTIAL) {
rc = virtio_mem_sbm_unplug_any_sb_online(vm, mb_id, &nb_sb);
if (rc || !nb_sb)
goto out_unlock;
mutex_unlock(&vm->hotplug_mutex);
cond_resched();
mutex_lock(&vm->hotplug_mutex);
}
/* Try to unplug subblocks of plugged online blocks. */
virtio_mem_sbm_for_each_mb_rev(vm, mb_id, VIRTIO_MEM_SBM_MB_ONLINE) {
rc = virtio_mem_sbm_unplug_any_sb_online(vm, mb_id, &nb_sb);
if (rc || !nb_sb)
goto out_unlock;
mutex_unlock(&vm->hotplug_mutex);
cond_resched();
mutex_lock(&vm->hotplug_mutex);
} }
mutex_unlock(&vm->hotplug_mutex); mutex_unlock(&vm->hotplug_mutex);