Commit 905c4c51 authored by David Hildenbrand's avatar David Hildenbrand Committed by Michael S. Tsirkin
Browse files

virtio-mem: nb_sb_per_mb and subblock_size are specific to Sub Block Mode (SBM) 



Let's rename to "sbs_per_mb" and "sb_size" and move accordingly.

Reviewed-by: default avatarWei Yang <richard.weiyang@linux.alibaba.com>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: Jason Wang <jasowang@redhat.com>
Cc: Pankaj Gupta <pankaj.gupta.linux@gmail.com>
Signed-off-by: default avatarDavid Hildenbrand <david@redhat.com>
Link: https://lore.kernel.org/r/20201112133815.13332-21-david@redhat.com


Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent 54c6a6ba

drivers/virtio/virtio_mem.c

+48 −48
Original line number Diff line number Diff line
@@ -96,11 +96,6 @@ struct virtio_mem { 
	/* Maximum region size in bytes. */

	uint64_t region_size;



	/* The subblock size. */

	uint64_t subblock_size;

	/* The number of subblocks per memory block. */

	uint32_t nb_sb_per_mb;



	/* Id of the first memory block of this device. */

	unsigned long first_mb_id;

	/* Id of the last usable memory block of this device. */
@@ -126,6 +121,11 @@ struct virtio_mem { 
	uint64_t offline_threshold;



	struct {

		/* The subblock size. */

		uint64_t sb_size;

		/* The number of subblocks per Linux memory block. */

		uint32_t sbs_per_mb;



		/* Summary of all memory block states. */

		unsigned long mb_count[VIRTIO_MEM_SBM_MB_COUNT];
@@ -256,7 +256,7 @@ static unsigned long virtio_mem_phys_to_sb_id(struct virtio_mem *vm, 
	const unsigned long mb_id = virtio_mem_phys_to_mb_id(addr);

	const unsigned long mb_addr = virtio_mem_mb_id_to_phys(mb_id);



	return (addr - mb_addr) / vm->subblock_size;

	return (addr - mb_addr) / vm->sbm.sb_size;

}



/*
@@ -332,7 +332,7 @@ static int virtio_mem_sbm_mb_states_prepare_next_mb(struct virtio_mem *vm) 
static int virtio_mem_sbm_sb_state_bit_nr(struct virtio_mem *vm,

					  unsigned long mb_id, int sb_id)

{

	return (mb_id - vm->first_mb_id) * vm->nb_sb_per_mb + sb_id;

	return (mb_id - vm->first_mb_id) * vm->sbm.sbs_per_mb + sb_id;

}



/*
@@ -395,7 +395,7 @@ static bool virtio_mem_sbm_test_sb_unplugged(struct virtio_mem *vm, 
}



/*

 * Find the first unplugged subblock. Returns vm->nb_sb_per_mb in case there is

 * Find the first unplugged subblock. Returns vm->sbm.sbs_per_mb in case there is

 * none.

 */

static int virtio_mem_sbm_first_unplugged_sb(struct virtio_mem *vm,
@@ -404,7 +404,7 @@ static int virtio_mem_sbm_first_unplugged_sb(struct virtio_mem *vm, 
	const int bit = virtio_mem_sbm_sb_state_bit_nr(vm, mb_id, 0);



	return find_next_zero_bit(vm->sbm.sb_states,

				  bit + vm->nb_sb_per_mb, bit) - bit;

				  bit + vm->sbm.sbs_per_mb, bit) - bit;

}



/*
@@ -413,8 +413,8 @@ static int virtio_mem_sbm_first_unplugged_sb(struct virtio_mem *vm, 
static int virtio_mem_sbm_sb_states_prepare_next_mb(struct virtio_mem *vm)

{

	const unsigned long old_nb_mb = vm->next_mb_id - vm->first_mb_id;

	const unsigned long old_nb_bits = old_nb_mb * vm->nb_sb_per_mb;

	const unsigned long new_nb_bits = (old_nb_mb + 1) * vm->nb_sb_per_mb;

	const unsigned long old_nb_bits = old_nb_mb * vm->sbm.sbs_per_mb;

	const unsigned long new_nb_bits = (old_nb_mb + 1) * vm->sbm.sbs_per_mb;

	int old_pages = PFN_UP(BITS_TO_LONGS(old_nb_bits) * sizeof(long));

	int new_pages = PFN_UP(BITS_TO_LONGS(new_nb_bits) * sizeof(long));

	unsigned long *new_bitmap, *old_bitmap;
@@ -640,15 +640,15 @@ static void virtio_mem_notify_online(struct virtio_mem *vm, unsigned long mb_id) 
static void virtio_mem_notify_going_offline(struct virtio_mem *vm,

					    unsigned long mb_id)

{

	const unsigned long nr_pages = PFN_DOWN(vm->subblock_size);

	const unsigned long nr_pages = PFN_DOWN(vm->sbm.sb_size);

	unsigned long pfn;

	int sb_id;



	for (sb_id = 0; sb_id < vm->nb_sb_per_mb; sb_id++) {

	for (sb_id = 0; sb_id < vm->sbm.sbs_per_mb; sb_id++) {

		if (virtio_mem_sbm_test_sb_plugged(vm, mb_id, sb_id, 1))

			continue;

		pfn = PFN_DOWN(virtio_mem_mb_id_to_phys(mb_id) +

			       sb_id * vm->subblock_size);

			       sb_id * vm->sbm.sb_size);

		virtio_mem_fake_offline_going_offline(pfn, nr_pages);

	}

}
@@ -656,15 +656,15 @@ static void virtio_mem_notify_going_offline(struct virtio_mem *vm, 
static void virtio_mem_notify_cancel_offline(struct virtio_mem *vm,

					     unsigned long mb_id)

{

	const unsigned long nr_pages = PFN_DOWN(vm->subblock_size);

	const unsigned long nr_pages = PFN_DOWN(vm->sbm.sb_size);

	unsigned long pfn;

	int sb_id;



	for (sb_id = 0; sb_id < vm->nb_sb_per_mb; sb_id++) {

	for (sb_id = 0; sb_id < vm->sbm.sbs_per_mb; sb_id++) {

		if (virtio_mem_sbm_test_sb_plugged(vm, mb_id, sb_id, 1))

			continue;

		pfn = PFN_DOWN(virtio_mem_mb_id_to_phys(mb_id) +

			       sb_id * vm->subblock_size);

			       sb_id * vm->sbm.sb_size);

		virtio_mem_fake_offline_cancel_offline(pfn, nr_pages);

	}

}
@@ -1103,8 +1103,8 @@ static int virtio_mem_mb_plug_sb(struct virtio_mem *vm, unsigned long mb_id, 
				 int sb_id, int count)

{

	const uint64_t addr = virtio_mem_mb_id_to_phys(mb_id) +

			      sb_id * vm->subblock_size;

	const uint64_t size = count * vm->subblock_size;

			      sb_id * vm->sbm.sb_size;

	const uint64_t size = count * vm->sbm.sb_size;

	int rc;



	rc = virtio_mem_send_plug_request(vm, addr, size);
@@ -1121,8 +1121,8 @@ static int virtio_mem_mb_unplug_sb(struct virtio_mem *vm, unsigned long mb_id, 
				   int sb_id, int count)

{

	const uint64_t addr = virtio_mem_mb_id_to_phys(mb_id) +

			      sb_id * vm->subblock_size;

	const uint64_t size = count * vm->subblock_size;

			      sb_id * vm->sbm.sb_size;

	const uint64_t size = count * vm->sbm.sb_size;

	int rc;



	rc = virtio_mem_send_unplug_request(vm, addr, size);
@@ -1146,7 +1146,7 @@ static int virtio_mem_mb_unplug_any_sb(struct virtio_mem *vm, 
	int sb_id, count;

	int rc;



	sb_id = vm->nb_sb_per_mb - 1;

	sb_id = vm->sbm.sbs_per_mb - 1;

	while (*nb_sb) {

		/* Find the next candidate subblock */

		while (sb_id >= 0 &&
@@ -1181,7 +1181,7 @@ static int virtio_mem_mb_unplug_any_sb(struct virtio_mem *vm, 
 */

static int virtio_mem_mb_unplug(struct virtio_mem *vm, unsigned long mb_id)

{

	uint64_t nb_sb = vm->nb_sb_per_mb;

	uint64_t nb_sb = vm->sbm.sbs_per_mb;



	return virtio_mem_mb_unplug_any_sb(vm, mb_id, &nb_sb);

}
@@ -1222,7 +1222,7 @@ static int virtio_mem_mb_plug_and_add(struct virtio_mem *vm, 
				      unsigned long mb_id,

				      uint64_t *nb_sb)

{

	const int count = min_t(int, *nb_sb, vm->nb_sb_per_mb);

	const int count = min_t(int, *nb_sb, vm->sbm.sbs_per_mb);

	int rc;



	if (WARN_ON_ONCE(!count))
@@ -1240,7 +1240,7 @@ static int virtio_mem_mb_plug_and_add(struct virtio_mem *vm, 
	 * Mark the block properly offline before adding it to Linux,

	 * so the memory notifiers will find the block in the right state.

	 */

	if (count == vm->nb_sb_per_mb)

	if (count == vm->sbm.sbs_per_mb)

		virtio_mem_sbm_set_mb_state(vm, mb_id,

					    VIRTIO_MEM_SBM_MB_OFFLINE);

	else
@@ -1289,11 +1289,11 @@ static int virtio_mem_mb_plug_any_sb(struct virtio_mem *vm, unsigned long mb_id, 


	while (*nb_sb) {

		sb_id = virtio_mem_sbm_first_unplugged_sb(vm, mb_id);

		if (sb_id >= vm->nb_sb_per_mb)

		if (sb_id >= vm->sbm.sbs_per_mb)

			break;

		count = 1;

		while (count < *nb_sb &&

		       sb_id + count < vm->nb_sb_per_mb &&

		       sb_id + count < vm->sbm.sbs_per_mb &&

		       !virtio_mem_sbm_test_sb_plugged(vm, mb_id, sb_id + count, 1))

			count++;
@@ -1306,12 +1306,12 @@ static int virtio_mem_mb_plug_any_sb(struct virtio_mem *vm, unsigned long mb_id, 


		/* fake-online the pages if the memory block is online */

		pfn = PFN_DOWN(virtio_mem_mb_id_to_phys(mb_id) +

			       sb_id * vm->subblock_size);

		nr_pages = PFN_DOWN(count * vm->subblock_size);

			       sb_id * vm->sbm.sb_size);

		nr_pages = PFN_DOWN(count * vm->sbm.sb_size);

		virtio_mem_fake_online(pfn, nr_pages);

	}



	if (virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->nb_sb_per_mb)) {

	if (virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->sbm.sbs_per_mb)) {

		if (online)

			virtio_mem_sbm_set_mb_state(vm, mb_id,

						    VIRTIO_MEM_SBM_MB_ONLINE);
@@ -1328,7 +1328,7 @@ static int virtio_mem_mb_plug_any_sb(struct virtio_mem *vm, unsigned long mb_id, 
 */

static int virtio_mem_plug_request(struct virtio_mem *vm, uint64_t diff)

{

	uint64_t nb_sb = diff / vm->subblock_size;

	uint64_t nb_sb = diff / vm->sbm.sb_size;

	unsigned long mb_id;

	int rc;
@@ -1411,13 +1411,13 @@ static int virtio_mem_mb_unplug_any_sb_offline(struct virtio_mem *vm, 
	rc = virtio_mem_mb_unplug_any_sb(vm, mb_id, nb_sb);



	/* some subblocks might have been unplugged even on failure */

	if (!virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->nb_sb_per_mb))

	if (!virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->sbm.sbs_per_mb))

		virtio_mem_sbm_set_mb_state(vm, mb_id,

					    VIRTIO_MEM_SBM_MB_OFFLINE_PARTIAL);

	if (rc)

		return rc;



	if (virtio_mem_sbm_test_sb_unplugged(vm, mb_id, 0, vm->nb_sb_per_mb)) {

	if (virtio_mem_sbm_test_sb_unplugged(vm, mb_id, 0, vm->sbm.sbs_per_mb)) {

		/*

		 * Remove the block from Linux - this should never fail.

		 * Hinder the block from getting onlined by marking it
@@ -1444,12 +1444,12 @@ static int virtio_mem_mb_unplug_sb_online(struct virtio_mem *vm, 
					  unsigned long mb_id, int sb_id,

					  int count)

{

	const unsigned long nr_pages = PFN_DOWN(vm->subblock_size) * count;

	const unsigned long nr_pages = PFN_DOWN(vm->sbm.sb_size) * count;

	unsigned long start_pfn;

	int rc;



	start_pfn = PFN_DOWN(virtio_mem_mb_id_to_phys(mb_id) +

			     sb_id * vm->subblock_size);

			     sb_id * vm->sbm.sb_size);



	rc = virtio_mem_fake_offline(start_pfn, nr_pages);

	if (rc)
@@ -1485,19 +1485,19 @@ static int virtio_mem_mb_unplug_any_sb_online(struct virtio_mem *vm, 
	int rc, sb_id;



	/* If possible, try to unplug the complete block in one shot. */

	if (*nb_sb >= vm->nb_sb_per_mb &&

	    virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->nb_sb_per_mb)) {

	if (*nb_sb >= vm->sbm.sbs_per_mb &&

	    virtio_mem_sbm_test_sb_plugged(vm, mb_id, 0, vm->sbm.sbs_per_mb)) {

		rc = virtio_mem_mb_unplug_sb_online(vm, mb_id, 0,

						    vm->nb_sb_per_mb);

						    vm->sbm.sbs_per_mb);

		if (!rc) {

			*nb_sb -= vm->nb_sb_per_mb;

			*nb_sb -= vm->sbm.sbs_per_mb;

			goto unplugged;

		} else if (rc != -EBUSY)

			return rc;

	}



	/* Fallback to single subblocks. */

	for (sb_id = vm->nb_sb_per_mb - 1; sb_id >= 0 && *nb_sb; sb_id--) {

	for (sb_id = vm->sbm.sbs_per_mb - 1; sb_id >= 0 && *nb_sb; sb_id--) {

		/* Find the next candidate subblock */

		while (sb_id >= 0 &&

		       !virtio_mem_sbm_test_sb_plugged(vm, mb_id, sb_id, 1))
@@ -1519,7 +1519,7 @@ static int virtio_mem_mb_unplug_any_sb_online(struct virtio_mem *vm, 
	 * remove it. This will usually not fail, as no memory is in use

	 * anymore - however some other notifiers might NACK the request.

	 */

	if (virtio_mem_sbm_test_sb_unplugged(vm, mb_id, 0, vm->nb_sb_per_mb)) {

	if (virtio_mem_sbm_test_sb_unplugged(vm, mb_id, 0, vm->sbm.sbs_per_mb)) {

		mutex_unlock(&vm->hotplug_mutex);

		rc = virtio_mem_mb_offline_and_remove(vm, mb_id);

		mutex_lock(&vm->hotplug_mutex);
@@ -1536,7 +1536,7 @@ static int virtio_mem_mb_unplug_any_sb_online(struct virtio_mem *vm, 
 */

static int virtio_mem_unplug_request(struct virtio_mem *vm, uint64_t diff)

{

	uint64_t nb_sb = diff / vm->subblock_size;

	uint64_t nb_sb = diff / vm->sbm.sb_size;

	unsigned long mb_id;

	int rc;
@@ -1827,11 +1827,11 @@ static int virtio_mem_init(struct virtio_mem *vm) 
	 * - Is required for now for alloc_contig_range() to work reliably -

	 *   it doesn't properly handle smaller granularity on ZONE_NORMAL.

	 */

	vm->subblock_size = max_t(uint64_t, MAX_ORDER_NR_PAGES,

	vm->sbm.sb_size = max_t(uint64_t, MAX_ORDER_NR_PAGES,

				pageblock_nr_pages) * PAGE_SIZE;

	vm->subblock_size = max_t(uint64_t, vm->device_block_size,

				  vm->subblock_size);

	vm->nb_sb_per_mb = memory_block_size_bytes() / vm->subblock_size;

	vm->sbm.sb_size = max_t(uint64_t, vm->device_block_size,

				vm->sbm.sb_size);

	vm->sbm.sbs_per_mb = memory_block_size_bytes() / vm->sbm.sb_size;



	/* Round up to the next full memory block */

	vm->first_mb_id = virtio_mem_phys_to_mb_id(vm->addr - 1 +
@@ -1849,7 +1849,7 @@ static int virtio_mem_init(struct virtio_mem *vm) 
	dev_info(&vm->vdev->dev, "memory block size: 0x%lx",

		 memory_block_size_bytes());

	dev_info(&vm->vdev->dev, "subblock size: 0x%llx",

		 (unsigned long long)vm->subblock_size);

		 (unsigned long long)vm->sbm.sb_size);

	if (vm->nid != NUMA_NO_NODE && IS_ENABLED(CONFIG_NUMA))

		dev_info(&vm->vdev->dev, "nid: %d", vm->nid);