Commit c6460dae authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'for-linus-5.15b-rc2-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip 

Pull xen fixes from Juergen Gross:

 - The first hunk of a Xen swiotlb fixup series fixing multiple minor
   issues and doing some small cleanups

 - Some further Xen related fixes avoiding WARN() splats when running as
   Xen guests or dom0

 - A Kconfig fix allowing the pvcalls frontend to be built as a module

* tag 'for-linus-5.15b-rc2-tag' of git://git.kernel.org/pub/scm/linux/kernel/git/xen/tip:
  swiotlb-xen: drop DEFAULT_NSLABS
  swiotlb-xen: arrange to have buffer info logged
  swiotlb-xen: drop leftover __ref
  swiotlb-xen: limit init retries
  swiotlb-xen: suppress certain init retries
  swiotlb-xen: maintain slab count properly
  swiotlb-xen: fix late init retry
  swiotlb-xen: avoid double free
  xen/pvcalls: backend can be a module
  xen: fix usage of pmd_populate in mremap for pv guests
  xen: reset legacy rtc flag for PV domU
  PM: base: power: don't try to use non-existing RTC for storing data
  xen/balloon: use a kernel thread instead a workqueue
parents bdb575f8 d859ed25

arch/x86/xen/enlighten_pv.c

+7 −0
Original line number Diff line number Diff line
@@ -1214,6 +1214,11 @@ static void __init xen_dom0_set_legacy_features(void) 
	x86_platform.legacy.rtc = 1;

}



static void __init xen_domu_set_legacy_features(void)

{

	x86_platform.legacy.rtc = 0;

}



/* First C function to be called on Xen boot */

asmlinkage __visible void __init xen_start_kernel(void)

{
@@ -1359,6 +1364,8 @@ asmlinkage __visible void __init xen_start_kernel(void) 
		add_preferred_console("xenboot", 0, NULL);

		if (pci_xen)

			x86_init.pci.arch_init = pci_xen_init;

		x86_platform.set_legacy_features =

				xen_domu_set_legacy_features;

	} else {

		const struct dom0_vga_console_info *info =

			(void *)((char *)xen_start_info +

arch/x86/xen/mmu_pv.c

+5 −2
Original line number Diff line number Diff line
@@ -1518,14 +1518,17 @@ static inline void xen_alloc_ptpage(struct mm_struct *mm, unsigned long pfn, 
	if (pinned) {

		struct page *page = pfn_to_page(pfn);



		if (static_branch_likely(&xen_struct_pages_ready))

		pinned = false;

		if (static_branch_likely(&xen_struct_pages_ready)) {

			pinned = PagePinned(page);

			SetPagePinned(page);

		}



		xen_mc_batch();



		__set_pfn_prot(pfn, PAGE_KERNEL_RO);



		if (level == PT_PTE && USE_SPLIT_PTE_PTLOCKS)

		if (level == PT_PTE && USE_SPLIT_PTE_PTLOCKS && !pinned)

			__pin_pagetable_pfn(MMUEXT_PIN_L1_TABLE, pfn);



		xen_mc_issue(PARAVIRT_LAZY_MMU);

drivers/base/power/trace.c

+10 −0
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/export.h>

#include <linux/rtc.h>

#include <linux/suspend.h>

#include <linux/init.h>



#include <linux/mc146818rtc.h>
@@ -165,6 +166,9 @@ void generate_pm_trace(const void *tracedata, unsigned int user) 
	const char *file = *(const char **)(tracedata + 2);

	unsigned int user_hash_value, file_hash_value;



	if (!x86_platform.legacy.rtc)

		return;



	user_hash_value = user % USERHASH;

	file_hash_value = hash_string(lineno, file, FILEHASH);

	set_magic_time(user_hash_value, file_hash_value, dev_hash_value);
@@ -267,6 +271,9 @@ static struct notifier_block pm_trace_nb = { 


static int __init early_resume_init(void)

{

	if (!x86_platform.legacy.rtc)

		return 0;



	hash_value_early_read = read_magic_time();

	register_pm_notifier(&pm_trace_nb);

	return 0;
@@ -277,6 +284,9 @@ static int __init late_resume_init(void) 
	unsigned int val = hash_value_early_read;

	unsigned int user, file, dev;



	if (!x86_platform.legacy.rtc)

		return 0;



	user = val % USERHASH;

	val = val / USERHASH;

	file = val % FILEHASH;

drivers/xen/Kconfig

+1 −1
Original line number Diff line number Diff line
@@ -214,7 +214,7 @@ config XEN_PVCALLS_FRONTEND 
	  implements them.



config XEN_PVCALLS_BACKEND

	bool "XEN PV Calls backend driver"

	tristate "XEN PV Calls backend driver"

	depends on INET && XEN && XEN_BACKEND

	help

	  Experimental backend for the Xen PV Calls protocol

drivers/xen/balloon.c

+45 −17
Original line number Diff line number Diff line
@@ -43,6 +43,8 @@ 
#include <linux/sched.h>

#include <linux/cred.h>

#include <linux/errno.h>

#include <linux/freezer.h>

#include <linux/kthread.h>

#include <linux/mm.h>

#include <linux/memblock.h>

#include <linux/pagemap.h>
@@ -115,7 +117,7 @@ static struct ctl_table xen_root[] = { 
#define EXTENT_ORDER (fls(XEN_PFN_PER_PAGE) - 1)



/*

 * balloon_process() state:

 * balloon_thread() state:

 *

 * BP_DONE: done or nothing to do,

 * BP_WAIT: wait to be rescheduled,
@@ -130,6 +132,8 @@ enum bp_state { 
	BP_ECANCELED

};



/* Main waiting point for xen-balloon thread. */

static DECLARE_WAIT_QUEUE_HEAD(balloon_thread_wq);



static DEFINE_MUTEX(balloon_mutex);
@@ -144,10 +148,6 @@ static xen_pfn_t frame_list[PAGE_SIZE / sizeof(xen_pfn_t)]; 
static LIST_HEAD(ballooned_pages);

static DECLARE_WAIT_QUEUE_HEAD(balloon_wq);



/* Main work function, always executed in process context. */

static void balloon_process(struct work_struct *work);

static DECLARE_DELAYED_WORK(balloon_worker, balloon_process);



/* When ballooning out (allocating memory to return to Xen) we don't really

   want the kernel to try too hard since that can trigger the oom killer. */

#define GFP_BALLOON \
@@ -366,7 +366,7 @@ static void xen_online_page(struct page *page, unsigned int order) 
static int xen_memory_notifier(struct notifier_block *nb, unsigned long val, void *v)

{

	if (val == MEM_ONLINE)

		schedule_delayed_work(&balloon_worker, 0);

		wake_up(&balloon_thread_wq);



	return NOTIFY_OK;

}
@@ -491,18 +491,43 @@ static enum bp_state decrease_reservation(unsigned long nr_pages, gfp_t gfp) 
}



/*

 * As this is a work item it is guaranteed to run as a single instance only.

 * Stop waiting if either state is not BP_EAGAIN and ballooning action is

 * needed, or if the credit has changed while state is BP_EAGAIN.

 */

static bool balloon_thread_cond(enum bp_state state, long credit)

{

	if (state != BP_EAGAIN)

		credit = 0;



	return current_credit() != credit || kthread_should_stop();

}



/*

 * As this is a kthread it is guaranteed to run as a single instance only.

 * We may of course race updates of the target counts (which are protected

 * by the balloon lock), or with changes to the Xen hard limit, but we will

 * recover from these in time.

 */

static void balloon_process(struct work_struct *work)

static int balloon_thread(void *unused)

{

	enum bp_state state = BP_DONE;

	long credit;

	unsigned long timeout;



	set_freezable();

	for (;;) {

		if (state == BP_EAGAIN)

			timeout = balloon_stats.schedule_delay * HZ;

		else

			timeout = 3600 * HZ;

		credit = current_credit();



		wait_event_interruptible_timeout(balloon_thread_wq,

				 balloon_thread_cond(state, credit), timeout);



		if (kthread_should_stop())

			return 0;



	do {

		mutex_lock(&balloon_mutex);



		credit = current_credit();
@@ -529,12 +554,7 @@ static void balloon_process(struct work_struct *work) 
		mutex_unlock(&balloon_mutex);



		cond_resched();



	} while (credit && state == BP_DONE);



	/* Schedule more work if there is some still to be done. */

	if (state == BP_EAGAIN)

		schedule_delayed_work(&balloon_worker, balloon_stats.schedule_delay * HZ);

	}

}



/* Resets the Xen limit, sets new target, and kicks off processing. */
@@ -542,7 +562,7 @@ void balloon_set_new_target(unsigned long target) 
{

	/* No need for lock. Not read-modify-write updates. */

	balloon_stats.target_pages = target;

	schedule_delayed_work(&balloon_worker, 0);

	wake_up(&balloon_thread_wq);

}

EXPORT_SYMBOL_GPL(balloon_set_new_target);
@@ -647,7 +667,7 @@ void free_xenballooned_pages(int nr_pages, struct page **pages) 


	/* The balloon may be too large now. Shrink it if needed. */

	if (current_credit())

		schedule_delayed_work(&balloon_worker, 0);

		wake_up(&balloon_thread_wq);



	mutex_unlock(&balloon_mutex);

}
@@ -679,6 +699,8 @@ static void __init balloon_add_region(unsigned long start_pfn, 


static int __init balloon_init(void)

{

	struct task_struct *task;



	if (!xen_domain())

		return -ENODEV;
@@ -722,6 +744,12 @@ static int __init balloon_init(void) 
	}

#endif



	task = kthread_run(balloon_thread, NULL, "xen-balloon");

	if (IS_ERR(task)) {

		pr_err("xen-balloon thread could not be started, ballooning will not work!\n");

		return PTR_ERR(task);

	}



	/* Init the xen-balloon driver. */

	xen_balloon_init();