Merge tag 'for-linus-4.20a-rc5-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip (292974c5) · Commits · 戴 / test

arch/x86/xen/enlighten.c

+0 −78

Original line number	Diff line number	Diff line
		@@ -10,7 +10,6 @@
		#include <xen/xen.h>
		#include <xen/features.h>
		#include <xen/page.h>
		#include <xen/interface/memory.h>

		#include <asm/xen/hypercall.h>
		#include <asm/xen/hypervisor.h>
		@@ -346,80 +345,3 @@ void xen_arch_unregister_cpu(int num)
		}
		EXPORT_SYMBOL(xen_arch_unregister_cpu);
		#endif

		#ifdef CONFIG_XEN_BALLOON_MEMORY_HOTPLUG
		void __init arch_xen_balloon_init(struct resource *hostmem_resource)
		{
		struct xen_memory_map memmap;
		int rc;
		unsigned int i, last_guest_ram;
		phys_addr_t max_addr = PFN_PHYS(max_pfn);
		struct e820_table *xen_e820_table;
		const struct e820_entry *entry;
		struct resource *res;

		if (!xen_initial_domain())
		return;

		xen_e820_table = kmalloc(sizeof(*xen_e820_table), GFP_KERNEL);
		if (!xen_e820_table)
		return;

		memmap.nr_entries = ARRAY_SIZE(xen_e820_table->entries);
		set_xen_guest_handle(memmap.buffer, xen_e820_table->entries);
		rc = HYPERVISOR_memory_op(XENMEM_machine_memory_map, &memmap);
		if (rc) {
		pr_warn("%s: Can't read host e820 (%d)\n", __func__, rc);
		goto out;
		}

		last_guest_ram = 0;
		for (i = 0; i < memmap.nr_entries; i++) {
		if (xen_e820_table->entries[i].addr >= max_addr)
		break;
		if (xen_e820_table->entries[i].type == E820_TYPE_RAM)
		last_guest_ram = i;
		}

		entry = &xen_e820_table->entries[last_guest_ram];
		if (max_addr >= entry->addr + entry->size)
		goto out; /* No unallocated host RAM. */

		hostmem_resource->start = max_addr;
		hostmem_resource->end = entry->addr + entry->size;

		/*
		* Mark non-RAM regions between the end of dom0 RAM and end of host RAM
		* as unavailable. The rest of that region can be used for hotplug-based
		* ballooning.
		*/
		for (; i < memmap.nr_entries; i++) {
		entry = &xen_e820_table->entries[i];

		if (entry->type == E820_TYPE_RAM)
		continue;

		if (entry->addr >= hostmem_resource->end)
		break;

		res = kzalloc(sizeof(*res), GFP_KERNEL);
		if (!res)
		goto out;

		res->name = "Unavailable host RAM";
		res->start = entry->addr;
		res->end = (entry->addr + entry->size < hostmem_resource->end) ?
		entry->addr + entry->size : hostmem_resource->end;
		rc = insert_resource(hostmem_resource, res);
		if (rc) {
		pr_warn("%s: Can't insert [%llx - %llx) (%d)\n",
		__func__, res->start, res->end, rc);
		kfree(res);
		goto out;
		}
		}

		out:
		kfree(xen_e820_table);
		}
		#endif /* CONFIG_XEN_BALLOON_MEMORY_HOTPLUG */

arch/x86/xen/multicalls.c

+20 −15

Original line number	Diff line number	Diff line
		@@ -69,6 +69,11 @@ void xen_mc_flush(void)

		trace_xen_mc_flush(b->mcidx, b->argidx, b->cbidx);

		#if MC_DEBUG
		memcpy(b->debug, b->entries,
		b->mcidx * sizeof(struct multicall_entry));
		#endif

		switch (b->mcidx) {
		case 0:
		/* no-op */
		@@ -87,32 +92,34 @@ void xen_mc_flush(void)
		break;

		default:
		#if MC_DEBUG
		memcpy(b->debug, b->entries,
		b->mcidx * sizeof(struct multicall_entry));
		#endif

		if (HYPERVISOR_multicall(b->entries, b->mcidx) != 0)
		BUG();
		for (i = 0; i < b->mcidx; i++)
		if (b->entries[i].result < 0)
		ret++;
		}

		#if MC_DEBUG
		if (ret) {
		printk(KERN_ERR "%d multicall(s) failed: cpu %d\n",
		ret, smp_processor_id());
		dump_stack();
		if (WARN_ON(ret)) {
		pr_err("%d of %d multicall(s) failed: cpu %d\n",
		ret, b->mcidx, smp_processor_id());
		for (i = 0; i < b->mcidx; i++) {
		printk(KERN_DEBUG " call %2d/%d: op=%lu arg=[%lx] result=%ld\t%pF\n",
		i+1, b->mcidx,
		if (b->entries[i].result < 0) {
		#if MC_DEBUG
		pr_err(" call %2d: op=%lu arg=[%lx] result=%ld\t%pF\n",
		i + 1,
		b->debug[i].op,
		b->debug[i].args[0],
		b->entries[i].result,
		b->caller[i]);
		#else
		pr_err(" call %2d: op=%lu arg=[%lx] result=%ld\n",
		i + 1,
		b->entries[i].op,
		b->entries[i].args[0],
		b->entries[i].result);
		#endif
		}
		}
		#endif
		}

		b->mcidx = 0;
		@@ -126,8 +133,6 @@ void xen_mc_flush(void)
		b->cbidx = 0;

		local_irq_restore(flags);

		WARN_ON(ret);
		}

		struct multicall_space __xen_mc_entry(size_t args)

arch/x86/xen/setup.c

+4 −2

Original line number	Diff line number	Diff line
		@@ -808,6 +808,7 @@ char * __init xen_memory_setup(void)
		addr = xen_e820_table.entries[0].addr;
		size = xen_e820_table.entries[0].size;
		while (i < xen_e820_table.nr_entries) {
		bool discard = false;

		chunk_size = size;
		type = xen_e820_table.entries[i].type;
		@@ -823,9 +824,10 @@ char * __init xen_memory_setup(void)
		xen_add_extra_mem(pfn_s, n_pfns);
		xen_max_p2m_pfn = pfn_s + n_pfns;
		} else
		type = E820_TYPE_UNUSABLE;
		discard = true;
		}

		if (!discard)
		xen_align_and_add_e820_region(addr, chunk_size, type);

		addr += chunk_size;

arch/x86/xen/spinlock.c

+1 −6

Original line number	Diff line number	Diff line
		@@ -3,22 +3,17 @@
		* Split spinlock implementation out into its own file, so it can be
		* compiled in a FTRACE-compatible way.
		*/
		#include <linux/kernel_stat.h>
		#include <linux/kernel.h>
		#include <linux/spinlock.h>
		#include <linux/debugfs.h>
		#include <linux/log2.h>
		#include <linux/gfp.h>
		#include <linux/slab.h>
		#include <linux/atomic.h>

		#include <asm/paravirt.h>
		#include <asm/qspinlock.h>

		#include <xen/interface/xen.h>
		#include <xen/events.h>

		#include "xen-ops.h"
		#include "debugfs.h"

		static DEFINE_PER_CPU(int, lock_kicker_irq) = -1;
		static DEFINE_PER_CPU(char *, irq_name);

drivers/xen/balloon.c

+9 −56

Original line number	Diff line number	Diff line
		@@ -251,25 +251,10 @@ static void release_memory_resource(struct resource *resource)
		kfree(resource);
		}

		/*
		* Host memory not allocated to dom0. We can use this range for hotplug-based
		* ballooning.
		*
		* It's a type-less resource. Setting IORESOURCE_MEM will make resource
		* management algorithms (arch_remove_reservations()) look into guest e820,
		* which we don't want.
		*/
		static struct resource hostmem_resource = {
		.name = "Host RAM",
		};

		void __attribute__((weak)) __init arch_xen_balloon_init(struct resource *res)
		{}

		static struct resource *additional_memory_resource(phys_addr_t size)
		{
		struct resource res, res_hostmem;
		int ret = -ENOMEM;
		struct resource *res;
		int ret;

		res = kzalloc(sizeof(*res), GFP_KERNEL);
		if (!res)
		@@ -278,34 +263,6 @@ static struct resource *additional_memory_resource(phys_addr_t size)
		res->name = "System RAM";
		res->flags = IORESOURCE_SYSTEM_RAM \| IORESOURCE_BUSY;

		res_hostmem = kzalloc(sizeof(*res), GFP_KERNEL);
		if (res_hostmem) {
		/* Try to grab a range from hostmem */
		res_hostmem->name = "Host memory";
		ret = allocate_resource(&hostmem_resource, res_hostmem,
		size, 0, -1,
		PAGES_PER_SECTION * PAGE_SIZE, NULL, NULL);
		}

		if (!ret) {
		/*
		* Insert this resource into iomem. Because hostmem_resource
		* tracks portion of guest e820 marked as UNUSABLE noone else
		* should try to use it.
		*/
		res->start = res_hostmem->start;
		res->end = res_hostmem->end;
		ret = insert_resource(&iomem_resource, res);
		if (ret < 0) {
		pr_err("Can't insert iomem_resource [%llx - %llx]\n",
		res->start, res->end);
		release_memory_resource(res_hostmem);
		res_hostmem = NULL;
		res->start = res->end = 0;
		}
		}

		if (ret) {
		ret = allocate_resource(&iomem_resource, res,
		size, 0, -1,
		PAGES_PER_SECTION * PAGE_SIZE, NULL, NULL);
		@@ -314,7 +271,6 @@ static struct resource *additional_memory_resource(phys_addr_t size)
		kfree(res);
		return NULL;
		}
		}

		#ifdef CONFIG_SPARSEMEM
		{
		@@ -325,7 +281,6 @@ static struct resource *additional_memory_resource(phys_addr_t size)
		pr_err("New System RAM resource outside addressable RAM (%lu > %lu)\n",
		pfn, limit);
		release_memory_resource(res);
		release_memory_resource(res_hostmem);
		return NULL;
		}
		}
		@@ -750,8 +705,6 @@ static int __init balloon_init(void)
		set_online_page_callback(&xen_online_page);
		register_memory_notifier(&xen_memory_nb);
		register_sysctl_table(xen_root);

		arch_xen_balloon_init(&hostmem_resource);
		#endif

		#ifdef CONFIG_XEN_PV

Admin message