@@ 12,10 12,10 @@ Signed-off-by: Jose Carlos Venegas Munoz <jos.c.venegas.munoz@intel.com>
  1 file changed, 5 insertions(+), 5 deletions(-)
 
 diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
-index 0b9f1d0a8f8b..fc5f6ac8d264 100644
+index 3fc0a89cc785..a7c103f9dfd3 100644
 --- a/drivers/input/serio/i8042.c
 +++ b/drivers/input/serio/i8042.c
-@@ -617,7 +617,7 @@ static int i8042_enable_kbd_port(void)
+@@ -621,7 +621,7 @@ static int i8042_enable_kbd_port(void)
  	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
  		i8042_ctr &= ~I8042_CTR_KBDINT;
  		i8042_ctr |= I8042_CTR_KBDDIS;


@@ 24,7 24,7 @@ index 0b9f1d0a8f8b..fc5f6ac8d264 100644
  		return -EIO;
  	}
  
-@@ -636,7 +636,7 @@ static int i8042_enable_aux_port(void)
+@@ -640,7 +640,7 @@ static int i8042_enable_aux_port(void)
  	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {
  		i8042_ctr &= ~I8042_CTR_AUXINT;
  		i8042_ctr |= I8042_CTR_AUXDIS;


@@ 33,7 33,7 @@ index 0b9f1d0a8f8b..fc5f6ac8d264 100644
  		return -EIO;
  	}
  
-@@ -728,7 +728,7 @@ static int __init i8042_check_mux(void)
+@@ -732,7 +732,7 @@ static int i8042_check_mux(void)
  	i8042_ctr &= ~I8042_CTR_AUXINT;
  
  	if (i8042_command(&i8042_ctr, I8042_CMD_CTL_WCTR)) {


@@ 42,7 42,7 @@ index 0b9f1d0a8f8b..fc5f6ac8d264 100644
  		return -EIO;
  	}
  
-@@ -951,7 +951,7 @@ static int i8042_controller_selftest(void)
+@@ -955,7 +955,7 @@ static int i8042_controller_selftest(void)
  	do {
  
  		if (i8042_command(&param, I8042_CMD_CTL_TEST)) {


@@ 51,7 51,7 @@ index 0b9f1d0a8f8b..fc5f6ac8d264 100644
  			return -ENODEV;
  		}
  
-@@ -973,7 +973,7 @@ static int i8042_controller_selftest(void)
+@@ -977,7 +977,7 @@ static int i8042_controller_selftest(void)
  	pr_info("giving up on controller selftest, continuing anyway...\n");
  	return 0;
  #else


@@ 18,7 18,7 @@ Signed-off-by: Jose Carlos Venegas Munoz <jose.carlos.venegas.munoz@intel.com>
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
-index fd933c45281a..e70409a77cfa 100644
+index 9c3ada74ffb1..c4aef0bb2661 100644
 --- a/include/linux/jbd2.h
 +++ b/include/linux/jbd2.h
 @@ -45,7 +45,7 @@


@@ 8,10 8,10 @@ Subject: [PATCH] silence rapl
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/drivers/powercap/intel_rapl_common.c b/drivers/powercap/intel_rapl_common.c
-index 7c0099e7a6d7..f0d65382806a 100644
+index 07611a00b78f..4031d810def5 100644
 --- a/drivers/powercap/intel_rapl_common.c
 +++ b/drivers/powercap/intel_rapl_common.c
-@@ -1455,7 +1455,7 @@ static int __init rapl_init(void)
+@@ -1512,7 +1512,7 @@ static int __init rapl_init(void)
  
  	id = x86_match_cpu(rapl_ids);
  	if (!id) {


@@ 10,7 10,7 @@ boards (sadly, too many of them) in laptops.
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
-index a101faf3e88a..4d7422b42c93 100644
+index d25122fbe98a..dbfb6aaa4a07 100644
 --- a/drivers/pci/pci.c
 +++ b/drivers/pci/pci.c
 @@ -60,7 +60,7 @@ struct pci_pme_device {


@@ 13,7 13,7 @@ Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
  2 files changed, 9 insertions(+), 4 deletions(-)
 
 diff --git a/kernel/watchdog.c b/kernel/watchdog.c
-index ad912511a0c0..8ccb40284a24 100644
+index 99afb88d2e85..e24483521e17 100644
 --- a/kernel/watchdog.c
 +++ b/kernel/watchdog.c
 @@ -41,7 +41,7 @@ unsigned long __read_mostly watchdog_enabled;


@@ 26,10 26,10 @@ index ad912511a0c0..8ccb40284a24 100644
  
  struct cpumask watchdog_cpumask __read_mostly;
 diff --git a/mm/ksm.c b/mm/ksm.c
-index a5716fdec1aa..7d5ec01385c7 100644
+index c20bd4d9a0d9..702a2a111fef 100644
 --- a/mm/ksm.c
 +++ b/mm/ksm.c
-@@ -2415,9 +2415,14 @@ static int ksm_scan_thread(void *nothing)
+@@ -2421,9 +2421,14 @@ static int ksm_scan_thread(void *nothing)
  
  		if (ksmd_should_run()) {
  			sleep_ms = READ_ONCE(ksm_thread_sleep_millisecs);


@@ 14,10 14,10 @@ performance while keeping power efficiency
  1 file changed, 22 insertions(+), 22 deletions(-)
 
 diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
-index e6c543b5ee1d..b73df64b2925 100644
+index 0b66e25c0e2d..406b41b387d5 100644
 --- a/drivers/idle/intel_idle.c
 +++ b/drivers/idle/intel_idle.c
-@@ -502,7 +502,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -511,7 +511,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x01",
  		.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
  		.exit_latency = 10,


@@ 26,7 26,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -510,7 +510,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -519,7 +519,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x10",
  		.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 33,


@@ 35,7 35,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -518,7 +518,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -527,7 +527,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x20",
  		.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 133,


@@ 44,7 44,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -526,7 +526,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -535,7 +535,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x32",
  		.flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 166,


@@ 53,7 53,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -534,7 +534,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -543,7 +543,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x40",
  		.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 300,


@@ 62,7 62,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -542,7 +542,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -551,7 +551,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x50",
  		.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 600,


@@ 71,7 71,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -550,7 +550,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
+@@ -559,7 +559,7 @@ static struct cpuidle_state hsw_cstates[] __initdata = {
  		.desc = "MWAIT 0x60",
  		.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 2600,


@@ 80,7 80,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -570,7 +570,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -579,7 +579,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x01",
  		.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
  		.exit_latency = 10,


@@ 89,7 89,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -578,7 +578,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -587,7 +587,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x10",
  		.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 40,


@@ 98,7 98,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -586,7 +586,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -595,7 +595,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x20",
  		.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 133,


@@ 107,7 107,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -594,7 +594,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -603,7 +603,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x32",
  		.flags = MWAIT2flg(0x32) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 166,


@@ 116,7 116,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -602,7 +602,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -611,7 +611,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x40",
  		.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 300,


@@ 125,7 125,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -610,7 +610,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -619,7 +619,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x50",
  		.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 600,


@@ 134,7 134,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -618,7 +618,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
+@@ -627,7 +627,7 @@ static struct cpuidle_state bdw_cstates[] __initdata = {
  		.desc = "MWAIT 0x60",
  		.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 2600,


@@ 143,7 143,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -639,7 +639,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -648,7 +648,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x01",
  		.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
  		.exit_latency = 10,


@@ 152,7 152,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -647,7 +647,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -656,7 +656,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x10",
  		.flags = MWAIT2flg(0x10) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 70,


@@ 161,7 161,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -655,7 +655,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -664,7 +664,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x20",
  		.flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 85,


@@ 170,7 170,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -663,7 +663,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -672,7 +672,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x33",
  		.flags = MWAIT2flg(0x33) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 124,


@@ 179,7 179,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -671,7 +671,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -680,7 +680,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x40",
  		.flags = MWAIT2flg(0x40) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 200,


@@ 188,7 188,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -679,7 +679,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -688,7 +688,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x50",
  		.flags = MWAIT2flg(0x50) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 480,


@@ 197,7 197,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -687,7 +687,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
+@@ -696,7 +696,7 @@ static struct cpuidle_state skl_cstates[] __initdata = {
  		.desc = "MWAIT 0x60",
  		.flags = MWAIT2flg(0x60) | CPUIDLE_FLAG_TLB_FLUSHED,
  		.exit_latency = 890,


@@ 206,7 206,7 @@ index e6c543b5ee1d..b73df64b2925 100644
  		.enter = &intel_idle,
  		.enter_s2idle = intel_idle_s2idle, },
  	{
-@@ -708,7 +708,7 @@ static struct cpuidle_state skx_cstates[] __initdata = {
+@@ -717,7 +717,7 @@ static struct cpuidle_state skx_cstates[] __initdata = {
  		.desc = "MWAIT 0x01",
  		.flags = MWAIT2flg(0x01) | CPUIDLE_FLAG_ALWAYS_ENABLE,
  		.exit_latency = 10,


@@ 10,10 10,10 @@ saves 200ms+ of boot time.
  1 file changed, 3 insertions(+)
 
 diff --git a/arch/x86/kernel/tsc.c b/arch/x86/kernel/tsc.c
-index 2e076a459a0c..94bc1166476e 100644
+index a698196377be..5f3ee7c31c8a 100644
 --- a/arch/x86/kernel/tsc.c
 +++ b/arch/x86/kernel/tsc.c
-@@ -1549,6 +1549,9 @@ unsigned long calibrate_delay_is_known(void)
+@@ -1569,6 +1569,9 @@ unsigned long calibrate_delay_is_known(void)
  	if (!constant_tsc || !mask)
  		return 0;
  


@@ 11,10 11,10 @@ in parallel
  1 file changed, 8 insertions(+), 7 deletions(-)
 
 diff --git a/drivers/Makefile b/drivers/Makefile
-index be5d40ae1488..5cf1c4a93708 100644
+index a110338c860c..f91099276a78 100644
 --- a/drivers/Makefile
 +++ b/drivers/Makefile
-@@ -60,15 +60,8 @@ obj-y				+= char/
+@@ -59,15 +59,8 @@ obj-y				+= char/
  # iommu/ comes before gpu as gpu are using iommu controllers
  obj-y				+= iommu/
  


@@ 30,7 30,7 @@ index be5d40ae1488..5cf1c4a93708 100644
  obj-$(CONFIG_PARPORT)		+= parport/
  obj-y				+= base/ block/ misc/ mfd/ nfc/
  obj-$(CONFIG_LIBNVDIMM)		+= nvdimm/
-@@ -80,6 +73,14 @@ obj-y				+= macintosh/
+@@ -79,6 +72,14 @@ obj-y				+= macintosh/
  obj-y				+= scsi/
  obj-y				+= nvme/
  obj-$(CONFIG_ATA)		+= ata/


@@ 0,0 1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Fri, 29 Jul 2016 19:10:52 +0000
+Subject: [PATCH] give rdrand some credit
+
+try to credit rdrand/rdseed with some entropy
+
+In VMs but even modern hardware, we're super starved for entropy, and while we can
+and do wear a tin foil hat, it's very hard to argue that
+rdrand and rdtsc add zero entropy.
+---
+ drivers/char/random.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/drivers/char/random.c b/drivers/char/random.c
+index 3404a91edf29..479994faedba 100644
+--- a/drivers/char/random.c
++++ b/drivers/char/random.c
+@@ -1678,6 +1678,8 @@ static void __init init_std_data(void)
+ 		if (!arch_get_random_seed_long(&rv) &&
+ 		    !arch_get_random_long(&rv))
+ 			rv = random_get_entropy();
++		else
++			credit_entropy_bits(1);
+ 		mix_pool_bytes(&rv, sizeof(rv));
+ 	}
+ 	mix_pool_bytes(utsname(), sizeof(*(utsname())));
+-- 
+https://clearlinux.org
+


@@ 9,10 9,10 @@ Subject: [PATCH] ipv4/tcp: allow the memory tuning for tcp to go a little
  1 file changed, 2 insertions(+), 2 deletions(-)
 
 diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
-index 8affba5909bd..aba132bfa984 100644
+index 28ff2a820f7c..c4f240da8d70 100644
 --- a/net/ipv4/tcp.c
 +++ b/net/ipv4/tcp.c
-@@ -4585,8 +4585,8 @@ void __init tcp_init(void)
+@@ -4604,8 +4604,8 @@ void __init tcp_init(void)
  	tcp_init_mem();
  	/* Set per-socket limits to no more than 1/128 the pressure threshold */
  	limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7);


@@ 11,10 11,10 @@ firmware and distribution firmware.
  1 file changed, 2 insertions(+)
 
 diff --git a/drivers/base/firmware_loader/main.c b/drivers/base/firmware_loader/main.c
-index bdbedc6660a8..53b254e5240b 100644
+index 406a907a4cae..89890e085171 100644
 --- a/drivers/base/firmware_loader/main.c
 +++ b/drivers/base/firmware_loader/main.c
-@@ -466,6 +466,8 @@ static int fw_decompress_xz(struct device *dev, struct fw_priv *fw_priv,
+@@ -407,6 +407,8 @@ static int fw_decompress_xz(struct device *dev, struct fw_priv *fw_priv,
  static char fw_path_para[256];
  static const char * const fw_path[] = {
  	fw_path_para,


@@ 23,7 23,7 @@ Signed-off-by: Alan Cox <alan@linux.intel.com>
  1 file changed, 8 insertions(+), 7 deletions(-)
 
 diff --git a/fs/xattr.c b/fs/xattr.c
-index 5c8c5175b385..0f98df2ea2e2 100644
+index 998045165916..62b6fb4dedee 100644
 --- a/fs/xattr.c
 +++ b/fs/xattr.c
 @@ -120,16 +120,17 @@ xattr_permission(struct user_namespace *mnt_userns, struct inode *inode,


@@ 10,7 10,7 @@ Small scheduler tweak to make the scheduler more turbo3 aware
  2 files changed, 33 insertions(+)
 
 diff --git a/arch/x86/kernel/itmt.c b/arch/x86/kernel/itmt.c
-index 1afbdd1dd777..d828ecf6bce7 100644
+index 9ff480e94511..57027bfed25f 100644
 --- a/arch/x86/kernel/itmt.c
 +++ b/arch/x86/kernel/itmt.c
 @@ -172,6 +172,11 @@ int arch_asym_cpu_priority(int cpu)


@@ 26,7 26,7 @@ index 1afbdd1dd777..d828ecf6bce7 100644
   * sched_set_itmt_core_prio() - Set CPU priority based on ITMT
   * @prio:	Priority of cpu core
 @@ -201,5 +206,14 @@ void sched_set_itmt_core_prio(int prio, int core_cpu)
- 		smt_prio = prio * smp_num_siblings / i;
+ 		smt_prio = prio * smp_num_siblings / (i * i);
  		per_cpu(sched_core_priority, cpu) = smt_prio;
  		i++;
 +


@@ 41,12 41,12 @@ index 1afbdd1dd777..d828ecf6bce7 100644
  	}
  }
 diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
-index 3889fee98d11..6d925f337add 100644
+index 2f461f059278..632fcb22f4e2 100644
 --- a/kernel/sched/fair.c
 +++ b/kernel/sched/fair.c
-@@ -6836,6 +6836,10 @@ static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu)
+@@ -6854,6 +6854,10 @@ static int find_energy_efficient_cpu(struct task_struct *p, int prev_cpu)
   *
-  * preempt must be disabled.
+  * Returns the target CPU number.
   */
 +
 +int best_core = -1;


@@ 55,7 55,7 @@ index 3889fee98d11..6d925f337add 100644
  static int
  select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags)
  {
-@@ -6860,6 +6864,21 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags)
+@@ -6882,6 +6886,21 @@ select_task_rq_fair(struct task_struct *p, int prev_cpu, int wake_flags)
  		want_affine = !wake_wide(p) && cpumask_test_cpu(cpu, p->cpus_ptr);
  	}
  


@@ 10,7 10,7 @@ Subject: [PATCH] do accept() in LIFO order for cache efficiency
  3 files changed, 27 insertions(+), 1 deletion(-)
 
 diff --git a/include/linux/wait.h b/include/linux/wait.h
-index 6598ae35e1b5..100dbbcd0df9 100644
+index 851e07da2583..85653fc33274 100644
 --- a/include/linux/wait.h
 +++ b/include/linux/wait.h
 @@ -165,6 +165,7 @@ static inline bool wq_has_sleeper(struct wait_queue_head *wq_head)


@@ 21,7 21,7 @@ index 6598ae35e1b5..100dbbcd0df9 100644
  extern void add_wait_queue_priority(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
  extern void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
  
-@@ -1137,6 +1138,7 @@ do {										\
+@@ -1163,6 +1164,7 @@ do {										\
   */
  void prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);
  bool prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);


@@ 30,7 30,7 @@ index 6598ae35e1b5..100dbbcd0df9 100644
  void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
  long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout);
 diff --git a/kernel/sched/wait.c b/kernel/sched/wait.c
-index 76577d1642a5..c33f48ed2bbb 100644
+index eca38107b32f..0306fa23b4f8 100644
 --- a/kernel/sched/wait.c
 +++ b/kernel/sched/wait.c
 @@ -48,6 +48,17 @@ void add_wait_queue_priority(struct wait_queue_head *wq_head, struct wait_queue_


@@ 51,7 51,7 @@ index 76577d1642a5..c33f48ed2bbb 100644
  void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
  {
  	unsigned long flags;
-@@ -283,6 +294,19 @@ prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_ent
+@@ -290,6 +301,19 @@ prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_ent
  }
  EXPORT_SYMBOL(prepare_to_wait_exclusive);
  


@@ 72,10 72,10 @@ index 76577d1642a5..c33f48ed2bbb 100644
  {
  	wq_entry->flags = flags;
 diff --git a/net/ipv4/inet_connection_sock.c b/net/ipv4/inet_connection_sock.c
-index fd472eae4f5c..d85f68c9f4a6 100644
+index fc2a985f6064..02dc861de3d5 100644
 --- a/net/ipv4/inet_connection_sock.c
 +++ b/net/ipv4/inet_connection_sock.c
-@@ -433,7 +433,7 @@ static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
+@@ -441,7 +441,7 @@ static int inet_csk_wait_for_connect(struct sock *sk, long timeo)
  	 * having to remove and re-insert us on the wait queue.
  	 */
  	for (;;) {


@@ 9,18 9,18 @@ tweak rwsem owner spinning a bit
  1 file changed, 3 insertions(+), 1 deletion(-)
 
 diff --git a/kernel/locking/rwsem.c b/kernel/locking/rwsem.c
-index 809b0016d344..2cc79a87c1ca 100644
+index 69aba4abe104..b4818ccad5de 100644
 --- a/kernel/locking/rwsem.c
 +++ b/kernel/locking/rwsem.c
-@@ -668,6 +668,7 @@ rwsem_spin_on_owner(struct rw_semaphore *sem)
+@@ -707,6 +707,7 @@ rwsem_spin_on_owner(struct rw_semaphore *sem)
  	struct task_struct *new, *owner;
  	unsigned long flags, new_flags;
  	enum owner_state state;
 +	int i = 0;
  
- 	owner = rwsem_owner_flags(sem, &flags);
- 	state = rwsem_owner_state(owner, flags);
-@@ -701,7 +702,8 @@ rwsem_spin_on_owner(struct rw_semaphore *sem)
+ 	lockdep_assert_preemption_disabled();
+ 
+@@ -743,7 +744,8 @@ rwsem_spin_on_owner(struct rw_semaphore *sem)
  			break;
  		}
  


@@ 28,8 28,8 @@ index 809b0016d344..2cc79a87c1ca 100644
 +		if (i++ > 1000)
 +			cpu_relax();
  	}
- 	rcu_read_unlock();
  
+ 	return state;
 -- 
 https://clearlinux.org
 


@@ 17,7 17,7 @@ Signed-off-by: Joe Konno <joe.konno@intel.com>
  1 file changed, 2 insertions(+), 2 deletions(-)
 
 diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
-index fec2e9754aed..e339cb80f29b 100644
+index 0ed484e04fd6..bbcb54da7a31 100644
 --- a/drivers/ata/libahci.c
 +++ b/drivers/ata/libahci.c
 @@ -33,14 +33,14 @@


@@ 9,10 9,10 @@ print cpu number when we print a crash
  1 file changed, 2 insertions(+), 2 deletions(-)
 
 diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
-index 6bda7f67d737..cc37727abe98 100644
+index d0074c6ed31a..aeeae77fe5dd 100644
 --- a/arch/x86/mm/fault.c
 +++ b/arch/x86/mm/fault.c
-@@ -771,9 +771,9 @@ show_signal_msg(struct pt_regs *regs, unsigned long error_code,
+@@ -776,9 +776,9 @@ show_signal_msg(struct pt_regs *regs, unsigned long error_code,
  	if (!printk_ratelimit())
  		return;
  


@@ 0,0 1,173 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Ashok Raj <ashok.raj@intel.com>
+Date: Thu, 19 Aug 2021 14:49:47 -0700
+Subject: [PATCH] x86/microcode: Add an option to reload microcode even if
+ revision is the same
+
+This is POC to support rollback. This is a simple version, admin uses
+echo 2 instead of echo 1 to reload. We don't do the version checks.
+
+#echo 1 > /sys/devices/system/cpu/microcode/reload
+
+The following usage, writing 2 to reload file is helpful to reload
+the microcode again even if the revision is less than what is loaded.
+
+#echo 2 > /sys/devices/system/cpu/microcode/reload
+
+Signed-off-by: Ashok Raj <ashok.raj@intel.com>
+---
+ arch/x86/kernel/cpu/microcode/core.c  | 40 ++++++++++++++++++++++++++-
+ arch/x86/kernel/cpu/microcode/intel.c | 14 ++++++----
+ 2 files changed, 47 insertions(+), 7 deletions(-)
+
+diff --git a/arch/x86/kernel/cpu/microcode/core.c b/arch/x86/kernel/cpu/microcode/core.c
+index 239ff5fcec6a..b096a43b2b9d 100644
+--- a/arch/x86/kernel/cpu/microcode/core.c
++++ b/arch/x86/kernel/cpu/microcode/core.c
+@@ -44,6 +44,8 @@
+ 
+ static struct microcode_ops	*microcode_ops;
+ static bool dis_ucode_ldr = true;
++bool ucode_rollback = false;
++int enable_rollback = 0;
+ 
+ bool initrd_gone;
+ 
+@@ -80,6 +82,26 @@ static u32 final_levels[] = {
+ 	0, /* T-101 terminator */
+ };
+ 
++static int __init ucode_setup(char *str)
++{
++	if (!str)
++		return -EINVAL;
++
++	while (*str) {
++		if (!strncmp(str, "rollback", 8)) {
++			enable_rollback = 1;
++			pr_info("Microcode Rollback Enabled\n");
++		}
++		str += strcspn(str, ",");
++		while (*str == ',')
++			str++;
++	}
++	return 0;
++}
++
++__setup("ucode=", ucode_setup);
++
++
+ /*
+  * Check the current patch level on this CPU.
+  *
+@@ -600,6 +622,7 @@ static ssize_t reload_store(struct device *dev,
+ 			    struct device_attribute *attr,
+ 			    const char *buf, size_t size)
+ {
++	struct cpuinfo_x86 *c = &boot_cpu_data;
+ 	enum ucode_state tmp_ret = UCODE_OK;
+ 	int bsp = boot_cpu_data.cpu_index;
+ 	unsigned long val;
+@@ -609,7 +632,7 @@ static ssize_t reload_store(struct device *dev,
+ 	if (ret)
+ 		return ret;
+ 
+-	if (val != 1)
++	if (!val || val > 2)
+ 		return size;
+ 
+ 	cpus_read_lock();
+@@ -617,6 +640,20 @@ static ssize_t reload_store(struct device *dev,
+ 	ret = check_online_cpus();
+ 	if (ret)
+ 		goto put;
++	/*
++	 * Check if the vendor is Intel to permit reloading
++	 * microcode even if the revision is unchanged.
++	 * This is typically used during development of microcode
++	 * and changing rev is a pain.
++	 */
++	if ((val == 2) && ((c->x86_vendor != X86_VENDOR_INTEL) ||
++	     !enable_rollback))
++		return size;
++	else if (val == 2) {
++		mutex_lock(&microcode_mutex);
++		ucode_rollback = true;
++		mutex_unlock(&microcode_mutex);
++	}
+ 
+ 	tmp_ret = microcode_ops->request_microcode_fw(bsp, &microcode_pdev->dev, true);
+ 	if (tmp_ret != UCODE_NEW)
+@@ -627,6 +664,7 @@ static ssize_t reload_store(struct device *dev,
+ 	mutex_unlock(&microcode_mutex);
+ 
+ put:
++	ucode_rollback = false;
+ 	cpus_read_unlock();
+ 
+ 	if (ret == 0)
+diff --git a/arch/x86/kernel/cpu/microcode/intel.c b/arch/x86/kernel/cpu/microcode/intel.c
+index d28a9f8f3fec..02b506f52a13 100644
+--- a/arch/x86/kernel/cpu/microcode/intel.c
++++ b/arch/x86/kernel/cpu/microcode/intel.c
+@@ -44,6 +44,7 @@ static struct microcode_intel *intel_ucode_patch;
+ 
+ /* last level cache size per core */
+ static int llc_size_per_core;
++extern bool ucode_rollback;
+ 
+ static inline bool cpu_signatures_match(unsigned int s1, unsigned int p1,
+ 					unsigned int s2, unsigned int p2)
+@@ -94,7 +95,7 @@ static int has_newer_microcode(void *mc, unsigned int csig, int cpf, int new_rev
+ {
+ 	struct microcode_header_intel *mc_hdr = mc;
+ 
+-	if (mc_hdr->rev <= new_rev)
++	if (!ucode_rollback && mc_hdr->rev <= new_rev)
+ 		return 0;
+ 
+ 	return find_matching_signature(mc, csig, cpf);
+@@ -134,7 +135,7 @@ static void save_microcode_patch(struct ucode_cpu_info *uci, void *data, unsigne
+ 		if (find_matching_signature(data, sig, pf)) {
+ 			prev_found = true;
+ 
+-			if (mc_hdr->rev <= mc_saved_hdr->rev)
++			if (!ucode_rollback && mc_hdr->rev <= mc_saved_hdr->rev)
+ 				continue;
+ 
+ 			p = memdup_patch(data, size);
+@@ -694,7 +695,7 @@ static struct microcode_intel *find_patch(struct ucode_cpu_info *uci)
+ 
+ 		phdr = (struct microcode_header_intel *)iter->data;
+ 
+-		if (phdr->rev <= uci->cpu_sig.rev)
++		if (!ucode_rollback && phdr->rev <= uci->cpu_sig.rev)
+ 			continue;
+ 
+ 		if (!find_matching_signature(phdr,
+@@ -779,10 +780,11 @@ static enum ucode_state apply_microcode_intel(int cpu)
+ 	 * already.
+ 	 */
+ 	rev = intel_get_microcode_revision();
+-	if (rev >= mc->hdr.rev) {
++	if (!ucode_rollback && rev >= mc->hdr.rev) {
+ 		ret = UCODE_OK;
+ 		goto out;
+-	}
++	} else if (ucode_rollback)
++		ret = UCODE_OK;
+ 
+ 	/*
+ 	 * Writeback and invalidate caches before updating microcode to avoid
+@@ -801,7 +803,7 @@ static enum ucode_state apply_microcode_intel(int cpu)
+ 		return UCODE_ERROR;
+ 	}
+ 
+-	if (bsp && rev != prev_rev) {
++	if (bsp && ((rev != prev_rev) || ucode_rollback)) {
+ 		pr_info("updated to revision 0x%x, date = %04x-%02x-%02x\n",
+ 			rev,
+ 			mc->hdr.date & 0xffff,
+-- 
+https://clearlinux.org
+


@@ 0,0 1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Mon, 11 Nov 2019 23:12:11 +0000
+Subject: [PATCH] nvme workaround
+
+---
+ drivers/nvme/host/core.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
+index 0abd772c57f0..9129a2179f25 100644
+--- a/drivers/nvme/host/core.c
++++ b/drivers/nvme/host/core.c
+@@ -48,7 +48,7 @@ static u8 nvme_max_retries = 5;
+ module_param_named(max_retries, nvme_max_retries, byte, 0644);
+ MODULE_PARM_DESC(max_retries, "max number of retries a command may have");
+ 
+-static unsigned long default_ps_max_latency_us = 100000;
++static unsigned long default_ps_max_latency_us = 200;
+ module_param(default_ps_max_latency_us, ulong, 0644);
+ MODULE_PARM_DESC(default_ps_max_latency_us,
+ 		 "max power saving latency for new devices; use PM QOS to change per device");
+-- 
+https://clearlinux.org
+


@@ 0,0 1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Alexander Koskovich <zvnexus@outlook.com>
+Date: Wed, 12 Feb 2020 22:47:12 +0000
+Subject: [PATCH] don't report an error if PowerClamp run on other CPU
+
+---
+ drivers/thermal/intel/intel_powerclamp.c | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+diff --git a/drivers/thermal/intel/intel_powerclamp.c b/drivers/thermal/intel/intel_powerclamp.c
+index 14256421d98c..8df2e604ceef 100644
+--- a/drivers/thermal/intel/intel_powerclamp.c
++++ b/drivers/thermal/intel/intel_powerclamp.c
+@@ -647,6 +647,11 @@ static const struct thermal_cooling_device_ops powerclamp_cooling_ops = {
+ 	.set_cur_state = powerclamp_set_cur_state,
+ };
+ 
++static const struct x86_cpu_id amd_cpu[] = {
++	{ X86_VENDOR_AMD },
++	{},
++};
++
+ static const struct x86_cpu_id __initconst intel_powerclamp_ids[] = {
+ 	X86_MATCH_VENDOR_FEATURE(INTEL, X86_FEATURE_MWAIT, NULL),
+ 	{}
+@@ -656,6 +661,11 @@ MODULE_DEVICE_TABLE(x86cpu, intel_powerclamp_ids);
+ static int __init powerclamp_probe(void)
+ {
+ 
++	if (x86_match_cpu(amd_cpu)){
++		pr_info("Intel PowerClamp does not support AMD CPUs\n");
++		return -ENODEV;
++	}
++
+ 	if (!x86_match_cpu(intel_powerclamp_ids)) {
+ 		pr_err("CPU does not support MWAIT\n");
+ 		return -ENODEV;
+-- 
+https://clearlinux.org
+


@@ 0,0 1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan.van.de.ven@intel.com>
+Date: Mon, 27 Sep 2021 17:43:01 +0000
+Subject: [PATCH] lib/raid6: add patch
+
+---
+ lib/raid6/algos.c | 4 +++-
+ 1 file changed, 3 insertions(+), 1 deletion(-)
+
+diff --git a/lib/raid6/algos.c b/lib/raid6/algos.c
+index 39b74221f4a7..ec3eab8cd6b1 100644
+--- a/lib/raid6/algos.c
++++ b/lib/raid6/algos.c
+@@ -128,8 +128,10 @@ static inline const struct raid6_recov_calls *raid6_choose_recov(void)
+ 
+ 	for (best = NULL, algo = raid6_recov_algos; *algo; algo++)
+ 		if (!best || (*algo)->priority > best->priority)
+-			if (!(*algo)->valid || (*algo)->valid())
++			if (!(*algo)->valid || (*algo)->valid()) {
+ 				best = *algo;
++				break;
++			}
+ 
+ 	if (best) {
+ 		raid6_2data_recov = best->data2;
+-- 
+https://clearlinux.org
+


@@ 0,0 1,92 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan.van.de.ven@intel.com>
+Date: Tue, 16 Nov 2021 17:39:25 +0000
+Subject: [PATCH] itmt_epb: use epb to scale itmt
+
+---
+ arch/x86/include/asm/topology.h |  1 +
+ arch/x86/kernel/cpu/intel_epb.c |  4 ++++
+ arch/x86/kernel/itmt.c          | 29 ++++++++++++++++++++++++++++-
+ 3 files changed, 33 insertions(+), 1 deletion(-)
+
+diff --git a/arch/x86/include/asm/topology.h b/arch/x86/include/asm/topology.h
+index 2f0b6be8eaab..c31f81e2ea05 100644
+--- a/arch/x86/include/asm/topology.h
++++ b/arch/x86/include/asm/topology.h
+@@ -174,6 +174,7 @@ extern unsigned int __read_mostly sysctl_sched_itmt_enabled;
+ 
+ /* Interface to set priority of a cpu */
+ void sched_set_itmt_core_prio(int prio, int core_cpu);
++void sched_set_itmt_power_ratio(int power_ratio, int core_cpu);
+ 
+ /* Interface to notify scheduler that system supports ITMT */
+ int sched_set_itmt_support(void);
+diff --git a/arch/x86/kernel/cpu/intel_epb.c b/arch/x86/kernel/cpu/intel_epb.c
+index fbaf12e43f41..c8c2d6f1a8ac 100644
+--- a/arch/x86/kernel/cpu/intel_epb.c
++++ b/arch/x86/kernel/cpu/intel_epb.c
+@@ -166,6 +166,10 @@ static ssize_t energy_perf_bias_store(struct device *dev,
+ 	if (ret < 0)
+ 		return ret;
+ 
++	/* update the ITMT scheduler logic to use the power policy data */
++	/* scale the val up by 2 so the range is 224 - 256 */
++	sched_set_itmt_power_ratio(256 - val * 2, cpu);
++
+ 	return count;
+ }
+ 
+diff --git a/arch/x86/kernel/itmt.c b/arch/x86/kernel/itmt.c
+index 57027bfed25f..596fd7fb7847 100644
+--- a/arch/x86/kernel/itmt.c
++++ b/arch/x86/kernel/itmt.c
+@@ -25,6 +25,7 @@
+ 
+ static DEFINE_MUTEX(itmt_update_mutex);
+ DEFINE_PER_CPU_READ_MOSTLY(int, sched_core_priority);
++DEFINE_PER_CPU_READ_MOSTLY(int, sched_power_ratio);
+ 
+ /* Boolean to track if system has ITMT capabilities */
+ static bool __read_mostly sched_itmt_capable;
+@@ -169,7 +170,12 @@ void sched_clear_itmt_support(void)
+ 
+ int arch_asym_cpu_priority(int cpu)
+ {
+-	return per_cpu(sched_core_priority, cpu);
++	int power_ratio = per_cpu(sched_power_ratio, cpu);
++
++	/* a power ratio of 0 (uninitialized) is assumed to be maximum */
++	if (power_ratio == 0)
++		power_ratio = 256 - 2 * 6;
++	return per_cpu(sched_core_priority, cpu) * power_ratio / 256;
+ }
+ 
+ extern int best_core;
+@@ -217,3 +223,24 @@ void sched_set_itmt_core_prio(int prio, int core_cpu)
+ 		}
+ 	}
+ }
++
++/**
++ * sched_set_itmt_power_ratio() - Set CPU priority based on ITMT
++ * @power_ratio:	The power scaling ratio [1..256] for the core
++ * @core_cpu:		The cpu number associated with the core
++ *
++ * Set a scaling to the cpu performance based on long term power
++ * settings (like EPB).
++ *
++ * Note this is for the policy not for the actual dynamic frequency;
++ * the frequency will increase itself as workloads run on a core.
++ */
++
++void sched_set_itmt_power_ratio(int power_ratio, int core_cpu)
++{
++	int cpu;
++
++	for_each_cpu(cpu, topology_sibling_cpumask(core_cpu)) {
++		per_cpu(sched_power_ratio, cpu) = power_ratio;
++	}
++}
+-- 
+https://clearlinux.org
+


@@ 0,0 1,43 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
+Date: Thu, 18 Nov 2021 16:09:47 +0000
+Subject: [PATCH] itmt2 ADL fixes
+
+On systems with overclocking enabled, CPPC Highest Performance can be
+hard coded to 0xff. In this case even if we have cores with different
+highest performance, ITMT can't be enabled as the current implementation
+depends on CPPC Highest Performance.
+
+On such systems we can use MSR_HWP_CAPABILITIES maximum performance field
+when CPPC.Highest Performance is 0xff.
+
+Due to legacy reasons, we can't solely depend on MSR_HWP_CAPABILITIES as
+in some older systems CPPC Highest Performance is the only way to identify
+different performing cores.
+
+Signed-off-by: Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>
+---
+ drivers/cpufreq/intel_pstate.c | 7 +++++++
+ 1 file changed, 7 insertions(+)
+
+diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
+index bc7f7e6759bd..ee33ad7f6f28 100644
+--- a/drivers/cpufreq/intel_pstate.c
++++ b/drivers/cpufreq/intel_pstate.c
+@@ -364,6 +364,13 @@ static void intel_pstate_set_itmt_prio(int cpu)
+ 	 * update them at any time after it has been called.
+ 	 */
+ 	sched_set_itmt_core_prio(cppc_perf.highest_perf, cpu);
++	/*
++	 * On some systems with overclocking enabled, CPPC.highest_perf is hardcoded to 0xff.
++	 * In this case we can't use CPPC.highest_perf to enable ITMT.
++	 * In this case we can look at MSR_HWP_CAPABILITIES bits [8:0] to decide.
++	 */
++	if (cppc_perf.highest_perf == 0xff)
++		cppc_perf.highest_perf = HWP_HIGHEST_PERF(READ_ONCE(all_cpu_data[cpu]->hwp_cap_cached));
+ 
+ 	if (max_highest_perf <= min_highest_perf) {
+ 		if (cppc_perf.highest_perf > max_highest_perf)
+-- 
+https://clearlinux.org
+


@@ 0,0 1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan.van.de.ven@intel.com>
+Date: Tue, 23 Nov 2021 17:38:50 +0000
+Subject: [PATCH] add a per cpu minimum high watermark an tune batch size
+
+make sure there's at least 1024 per cpu pages... a reasonably small
+amount for todays system
+---
+ mm/page_alloc.c | 5 +++--
+ 1 file changed, 3 insertions(+), 2 deletions(-)
+
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index e6f211dcf82e..0ea48434ac7d 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -6836,11 +6836,11 @@ static int zone_batchsize(struct zone *zone)
+ 
+ 	/*
+ 	 * The number of pages to batch allocate is either ~0.1%
+-	 * of the zone or 1MB, whichever is smaller. The batch
++	 * of the zone or 4MB, whichever is smaller. The batch
+ 	 * size is striking a balance between allocation latency
+ 	 * and zone lock contention.
+ 	 */
+-	batch = min(zone_managed_pages(zone) >> 10, (1024 * 1024) / PAGE_SIZE);
++	batch = min(zone_managed_pages(zone) >> 10, 4 * (1024 * 1024) / PAGE_SIZE);
+ 	batch /= 4;		/* We effectively *= 4 below */
+ 	if (batch < 1)
+ 		batch = 1;
+@@ -6918,6 +6918,7 @@ static int zone_highsize(struct zone *zone, int batch, int cpu_online)
+ 	 * historical relationship between high and batch.
+ 	 */
+ 	high = max(high, batch << 2);
++	high = max(high, 1024);
+ 
+ 	return high;
+ #else
+-- 
+https://clearlinux.org
+


@@ 0,0 1,817 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Dave Hansen <dave.hansen@intel.com>
+Date: Mon, 7 Mar 2022 11:59:20 -0800
+Subject: [PATCH] prezero 20220308
+
+---
+ include/linux/compaction.h |   2 +
+ include/linux/gfp.h        |   2 +-
+ kernel/sysctl.c            |   9 +
+ mm/compaction.c            |  52 +++++
+ mm/huge_memory.c           |   9 +-
+ mm/internal.h              |  23 +-
+ mm/page_alloc.c            | 416 +++++++++++++++++++++++++++++++++----
+ 7 files changed, 468 insertions(+), 45 deletions(-)
+
+diff --git a/include/linux/compaction.h b/include/linux/compaction.h
+index 34bce35c808d..45407237e6c9 100644
+--- a/include/linux/compaction.h
++++ b/include/linux/compaction.h
+@@ -82,6 +82,8 @@ static inline unsigned long compact_gap(unsigned int order)
+ 
+ #ifdef CONFIG_COMPACTION
+ extern unsigned int sysctl_compaction_proactiveness;
++extern int sysctl_zero_handler(struct ctl_table *table, int write,
++			void *buffer, size_t *length, loff_t *ppos);
+ extern int sysctl_compaction_handler(struct ctl_table *table, int write,
+ 			void *buffer, size_t *length, loff_t *ppos);
+ extern int compaction_proactiveness_sysctl_handler(struct ctl_table *table,
+diff --git a/include/linux/gfp.h b/include/linux/gfp.h
+index 80f63c862be5..f49971123e2f 100644
+--- a/include/linux/gfp.h
++++ b/include/linux/gfp.h
+@@ -334,7 +334,7 @@ struct vm_area_struct;
+ #define GFP_HIGHUSER	(GFP_USER | __GFP_HIGHMEM)
+ #define GFP_HIGHUSER_MOVABLE	(GFP_HIGHUSER | __GFP_MOVABLE | \
+ 			 __GFP_SKIP_KASAN_POISON)
+-#define GFP_TRANSHUGE_LIGHT	((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
++#define GFP_TRANSHUGE_LIGHT	((GFP_HIGHUSER_MOVABLE | __GFP_COMP | __GFP_ZERO |\
+ 			 __GFP_NOMEMALLOC | __GFP_NOWARN) & ~__GFP_RECLAIM)
+ #define GFP_TRANSHUGE	(GFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM)
+ 
+diff --git a/kernel/sysctl.c b/kernel/sysctl.c
+index 730ab56d9e92..95f4d4771470 100644
+--- a/kernel/sysctl.c
++++ b/kernel/sysctl.c
+@@ -94,6 +94,8 @@
+ 
+ #if defined(CONFIG_SYSCTL)
+ 
++extern int sysctl_zero_pages;
++
+ /* Constants used for minimum and  maximum */
+ 
+ #ifdef CONFIG_PERF_EVENTS
+@@ -2531,6 +2533,13 @@ static struct ctl_table vm_table[] = {
+ 		.extra1		= SYSCTL_ONE,
+ 		.extra2		= SYSCTL_FOUR,
+ 	},
++	{
++		.procname	= "zero_pages",
++		.data		= &sysctl_zero_pages,
++		.maxlen		= sizeof(sysctl_zero_pages),
++		.mode		= 0644,
++		.proc_handler	= sysctl_zero_handler,
++	},
+ #ifdef CONFIG_COMPACTION
+ 	{
+ 		.procname	= "compact_memory",
+diff --git a/mm/compaction.c b/mm/compaction.c
+index e9a36942c1fa..de6268560058 100644
+--- a/mm/compaction.c
++++ b/mm/compaction.c
+@@ -96,6 +96,16 @@ static void split_map_pages(struct list_head *list)
+ 		order = page_private(page);
+ 		nr_pages = 1 << order;
+ 
++		WARN_ON(PageBuddy(page));
++		// These pages recent came out of the buddy but
++		// they should have come via __isolate_free_page()
++		// which does del_page_from_free_list().  That
++		// should have left PageBuddy() clear.
++		// page_order() metadata was left presumably so
++		// that we could do this split and map here.  It
++		// is likely no longer needed.  Zap it to keep
++		// post_alloc_hook() from complaining.
++		page->private = 0;
+ 		post_alloc_hook(page, order, __GFP_MOVABLE);
+ 		if (order)
+ 			split_page(page, order);
+@@ -2658,6 +2668,48 @@ static void proactive_compact_node(pg_data_t *pgdat)
+ 	}
+ }
+ 
++void zero_some_pages(struct zone *z, int pages);
++
++static void zero_nodes(int pages)
++{
++	int nid;
++
++	for_each_online_node(nid) {
++		pg_data_t *pgdat = NODE_DATA(nid);
++		int zoneid;
++
++		for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
++			struct zone *zone = &pgdat->node_zones[zoneid];
++                	if (!populated_zone(zone))
++                        	continue;
++
++			zero_some_pages(zone, pages);
++		}
++	}
++}
++
++int sysctl_zero_pages;
++
++int sysctl_zero_handler(struct ctl_table *table, int write,
++			void *buffer, size_t *length, loff_t *ppos)
++{
++	int rc;
++	int old = sysctl_zero_pages;
++
++	rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
++	if (rc)
++		return rc;
++
++
++
++	if (write)
++		zero_nodes(sysctl_zero_pages);
++
++	return 0;
++}
++
++
++
+ /* Compact all zones within a node */
+ static void compact_node(int nid)
+ {
+diff --git a/mm/huge_memory.c b/mm/huge_memory.c
+index fb9163691705..ba8c298784c1 100644
+--- a/mm/huge_memory.c
++++ b/mm/huge_memory.c
+@@ -617,7 +617,12 @@ static vm_fault_t __do_huge_pmd_anonymous_page(struct vm_fault *vmf,
+ 		goto release;
+ 	}
+ 
+-	clear_huge_page(page, vmf->address, HPAGE_PMD_NR);
++	// move the zeroing to use __GFP_ZERO in
++	// the allocator.  Clearing here has the advantage of not
++	// wasting the clear operation if the cgroup charge or
++	// page table allocation fails.
++	//
++	//clear_huge_page(page, vmf->address, HPAGE_PMD_NR);
+ 	/*
+ 	 * The memory barrier inside __SetPageUptodate makes sure that
+ 	 * clear_huge_page writes become visible before the set_pmd_at()
+@@ -774,7 +779,7 @@ vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf)
+ 		return ret;
+ 	}
+ 	gfp = vma_thp_gfp_mask(vma);
+-	page = alloc_hugepage_vma(gfp, vma, haddr, HPAGE_PMD_ORDER);
++ 	page = alloc_hugepage_vma(gfp, vma, haddr, HPAGE_PMD_ORDER);
+ 	if (unlikely(!page)) {
+ 		count_vm_event(THP_FAULT_FALLBACK);
+ 		return VM_FAULT_FALLBACK;
+diff --git a/mm/internal.h b/mm/internal.h
+index d80300392a19..d6c7c26fe598 100644
+--- a/mm/internal.h
++++ b/mm/internal.h
+@@ -328,6 +328,22 @@ isolate_migratepages_range(struct compact_control *cc,
+ int find_suitable_fallback(struct free_area *area, unsigned int order,
+ 			int migratetype, bool only_stealable, bool *can_steal);
+ 
++/*
++ * Use the bit above the highest-possible buddy page
++ * order (MAX_ORDER-1).
++ */
++#define BUDDY_ZEROED	(1UL << (ilog2(MAX_ORDER-1)+1))
++static inline unsigned int __buddy_order(struct page *page, bool unsafe)
++{
++	unsigned int ret;
++	if (unsafe)
++		ret = READ_ONCE(page_private(page));
++	else
++		ret = page_private(page);
++
++	return ret & ~BUDDY_ZEROED;
++}
++
+ /*
+  * This function returns the order of a free page in the buddy system. In
+  * general, page_zone(page)->lock must be held by the caller to prevent the
+@@ -339,7 +355,7 @@ int find_suitable_fallback(struct free_area *area, unsigned int order,
+ static inline unsigned int buddy_order(struct page *page)
+ {
+ 	/* PageBuddy() must be checked by the caller */
+-	return page_private(page);
++	return __buddy_order(page, false);
+ }
+ 
+ /*
+@@ -353,7 +369,10 @@ static inline unsigned int buddy_order(struct page *page)
+  * times, potentially observing different values in the tests and the actual
+  * use of the result.
+  */
+-#define buddy_order_unsafe(page)	READ_ONCE(page_private(page))
++static inline unsigned int buddy_order_unsafe(struct page *page)
++{
++	return __buddy_order(page, true);
++}
+ 
+ /*
+  * These three helpers classifies VMAs for virtual memory accounting.
+diff --git a/mm/page_alloc.c b/mm/page_alloc.c
+index 0ea48434ac7d..bddadb46bf78 100644
+--- a/mm/page_alloc.c
++++ b/mm/page_alloc.c
+@@ -15,6 +15,7 @@
+  *          (lots of bits borrowed from Ingo Molnar & Andrew Morton)
+  */
+ 
++#include <linux/debugfs.h>
+ #include <linux/stddef.h>
+ #include <linux/mm.h>
+ #include <linux/highmem.h>
+@@ -758,6 +759,26 @@ void prep_compound_page(struct page *page, unsigned int order)
+ 	prep_compound_head(page, order);
+ }
+ 
++enum zero_state {
++	NOT_ZEROED,
++	PRE_ZEROED
++};
++
++static enum zero_state pre_zeroed(struct page *page)
++{
++	if (page_private(page) & BUDDY_ZEROED)
++		return PRE_ZEROED;
++	return NOT_ZEROED;
++}
++
++static void set_buddy_private(struct page *page, unsigned long value)
++{
++	WARN_ON(!PageBuddy(page));
++
++
++	set_page_private(page, value);
++}
++
+ #ifdef CONFIG_DEBUG_PAGEALLOC
+ unsigned int _debug_guardpage_minorder;
+ 
+@@ -800,7 +821,7 @@ static inline bool set_page_guard(struct zone *zone, struct page *page,
+ 
+ 	__SetPageGuard(page);
+ 	INIT_LIST_HEAD(&page->lru);
+-	set_page_private(page, order);
++	set_buddy_private(page, order);
+ 	/* Guard pages are not available for any usage */
+ 	__mod_zone_freepage_state(zone, -(1 << order), migratetype);
+ 
+@@ -815,7 +836,7 @@ static inline void clear_page_guard(struct zone *zone, struct page *page,
+ 
+ 	__ClearPageGuard(page);
+ 
+-	set_page_private(page, 0);
++	set_buddy_private(page, 0);
+ 	if (!is_migrate_isolate(migratetype))
+ 		__mod_zone_freepage_state(zone, (1 << order), migratetype);
+ }
+@@ -880,12 +901,80 @@ void init_mem_debugging_and_hardening(void)
+ #endif
+ }
+ 
+-static inline void set_buddy_order(struct page *page, unsigned int order)
++u64 prezero_really_skip = 1;
++u64 prezero_counter = 0;
++u64 prezero_could_have_skipped = 0;
++u64 prezero_check_zero_highpage = 0;
++u64 prezero_buddy_sane_checks = 0;
++u64 prezero_buddy_order = 9;
++static int prezero_debugfs(void)
+ {
+-	set_page_private(page, order);
++	debugfs_create_u64("prezero_really_skip", 0644, NULL, &prezero_really_skip);
++	debugfs_create_u64("prezero_counter", 0644, NULL, &prezero_counter);
++	debugfs_create_u64("prezero_check_zero_highpage", 0644, NULL, &prezero_check_zero_highpage);
++	debugfs_create_u64("prezero_could_have_skipped", 0644, NULL, &prezero_could_have_skipped);
++	debugfs_create_u64("prezero_buddy_sane_checks", 0644, NULL, &prezero_buddy_sane_checks);
++	debugfs_create_u64("prezero_buddy_order", 0644, NULL, &prezero_buddy_order);
++
++	return 0;
++}
++late_initcall(prezero_debugfs);
++
++void check_zero_highpage(struct page *page, int order, int numpages, int line, struct page *op)
++{
++       int nr;
++
++	if (!prezero_check_zero_highpage)
++		return;
++
++
++
++       if (!memchr_inv(page_address(page), 0, PAGE_SIZE<<order))
++               return;
++       BUILD_BUG_ON(IS_ENABLED(CONFIG_HIGHMEM));
++
++       printk("check_zero_highpage() BAD pfn=0x%lx/%d numpages: %d from line %d\n", page_to_pfn(page), order, numpages, line);
++//       trace_printk("check_zero_highpage() BAD pfn=0x%lx order=%d numpages: %d from line %d\n", page_to_pfn(page), order, numpages, line);
++//       trace_printk("check_zero_highpage() real pfn=0x%lx\n", page_to_pfn(op));
++//       tracing_off();
++       WARN_ON(1);
++       for (nr = 0; nr < 1<<order; nr++) {
++               struct page *tmp = &page[nr];
++               if (PageBuddy(tmp))
++                       printk("page[0x%x] had PageBuddy pfn=0x%lx\n", nr, page_to_pfn(tmp));
++               clear_highpage(&page[nr]);
++       }
++}
++
++/*
++ * Only use this for pages which are new to the buddy allocator.
++ * They should not yet have PageBuddy() set.
++ */
++static inline void mark_new_buddy(struct page *page, unsigned int order,
++				  enum zero_state zero)
++{
++	unsigned long private = order;
++
++	WARN_ON(PageBuddy(page));
++
++	if (zero == PRE_ZEROED) {
++		private |= BUDDY_ZEROED;
++		check_zero_highpage(page, order, 1<<order, __LINE__, page);
++	}
++
+ 	__SetPageBuddy(page);
++	set_buddy_private(page, private);
+ }
+ 
++/*
++static inline void change_buddy_order(struct page *page, unsigned int order)
++{
++	WARN_ON(!PageBuddy(page));
++	__SetPageBuddy(page);
++	set_page_private(page, order);
++}
++*/
++
+ /*
+  * This function checks whether a page is free && is the buddy
+  * we can coalesce a page and its buddy if
+@@ -970,12 +1059,16 @@ compaction_capture(struct capture_control *capc, struct page *page,
+ }
+ #endif /* CONFIG_COMPACTION */
+ 
++#define list_check_buddy_is_sane(p, o) __list_check_buddy_is_sane(p, o, __LINE__)
++void __list_check_buddy_is_sane(struct page *page, int order, int line);
++
+ /* Used for pages not on another list */
+ static inline void add_to_free_list(struct page *page, struct zone *zone,
+ 				    unsigned int order, int migratetype)
+ {
+ 	struct free_area *area = &zone->free_area[order];
+ 
++	list_check_buddy_is_sane(page, order);
+ 	list_add(&page->lru, &area->free_list[migratetype]);
+ 	area->nr_free++;
+ }
+@@ -986,6 +1079,7 @@ static inline void add_to_free_list_tail(struct page *page, struct zone *zone,
+ {
+ 	struct free_area *area = &zone->free_area[order];
+ 
++	list_check_buddy_is_sane(page, order);
+ 	list_add_tail(&page->lru, &area->free_list[migratetype]);
+ 	area->nr_free++;
+ }
+@@ -1000,6 +1094,7 @@ static inline void move_to_free_list(struct page *page, struct zone *zone,
+ {
+ 	struct free_area *area = &zone->free_area[order];
+ 
++	list_check_buddy_is_sane(page, order);
+ 	list_move_tail(&page->lru, &area->free_list[migratetype]);
+ }
+ 
+@@ -1011,11 +1106,117 @@ static inline void del_page_from_free_list(struct page *page, struct zone *zone,
+ 		__ClearPageReported(page);
+ 
+ 	list_del(&page->lru);
++	set_buddy_private(page, 0);
+ 	__ClearPageBuddy(page);
+-	set_page_private(page, 0);
+ 	zone->free_area[order].nr_free--;
+ }
+ 
++bool __zero_one_page(struct zone *zone, int order)
++{
++	struct page *page;
++	int numpages = 1<<order;
++	int i;
++	int migratetype = MIGRATE_RECLAIMABLE;
++	struct free_area *area;
++	bool did_zero = false;
++	int got_mt;
++	int order_orig;
++
++	spin_lock(&zone->lock);
++	/* mostly ripped from __rmqueue_smallest() */
++	area = &(zone->free_area[order]);
++
++	/* Look for a page to zero in all migratetypes: */
++	while (migratetype >= 0) {
++		struct list_head *lh = &area->free_list[migratetype];
++		page = get_page_from_free_area(area, migratetype);
++		got_mt = migratetype;
++
++
++
++
++
++
++		/* Was a page located that needs to be zeroed? */
++		if (page && (pre_zeroed(page) == NOT_ZEROED))
++			break;
++
++		/* No page was found to zero.  Try another migratetype. */
++		page = NULL;
++		migratetype--;
++	}
++	if (!page) {
++		spin_unlock(&zone->lock);
++		return did_zero;
++	}
++
++	order_orig = buddy_order(page);
++
++	del_page_from_free_list(page, zone, order);
++	spin_unlock(&zone->lock);
++
++	did_zero = true;
++	for (i = 0; i < numpages; i++) {
++		clear_highpage(page + i);
++	}
++
++	spin_lock(&zone->lock);
++	{
++		int pz_before = pre_zeroed(page);
++		int order_before = buddy_order(page);
++		int pz_after;
++		int order_after;
++
++		mark_new_buddy(page, order, PRE_ZEROED);
++		pz_after = pre_zeroed(page);
++		order_after = buddy_order(page);
++
++
++
++	}
++	add_to_free_list_tail(page, zone, order, migratetype);
++	//did_some_prezeroing = 1;
++	check_zero_highpage(page , order, 1<<order, __LINE__, page);
++	spin_unlock(&zone->lock);
++	return did_zero;
++}
++
++
++int zero_pages(struct zone *zone, int order, int do_count)
++{
++	int count = 0;
++
++	while (__zero_one_page(zone, order)) {
++		cond_resched();
++		count++;
++		// arbitrary limit to keep this from
++		// taking insane amounts of time:
++		if (count >= do_count)
++			break;
++	}
++
++
++
++
++
++
++	return count;
++}
++
++void zero_some_pages(struct zone *zone, int pages)
++{
++	int order;
++	long zero_count = 0;
++
++	for (order = MAX_ORDER-1; order >= prezero_buddy_order; order--) {
++		long did = zero_pages(zone, order, pages);
++		zero_count += did << order;
++		if (zero_count > pages)
++			break;
++	}
++
++}
++
+ /*
+  * If this is not the largest possible page, check if the buddy
+  * of the next-highest order is free. If it is, it's possible
+@@ -1141,7 +1342,8 @@ static inline void __free_one_page(struct page *page,
+ 	}
+ 
+ done_merging:
+-	set_buddy_order(page, order);
++	list_check_buddy_is_sane(page, order);
++	mark_new_buddy(page, order, NOT_ZEROED);
+ 
+ 	if (fpi_flags & FPI_TO_TAIL)
+ 		to_tail = true;
+@@ -1285,8 +1487,20 @@ static void kernel_init_free_pages(struct page *page, int numpages, bool zero_ta
+ 	kasan_disable_current();
+ 	for (i = 0; i < numpages; i++) {
+ 		u8 tag = page_kasan_tag(page + i);
++		bool need_to_zero = true;
++
+ 		page_kasan_tag_reset(page + i);
+-		clear_highpage(page + i);
++		if (pre_zeroed(page) == PRE_ZEROED) {
++			check_zero_highpage(page, ilog2(numpages), numpages, __LINE__, page);
++
++			if (prezero_really_skip)
++				need_to_zero = false;
++			prezero_could_have_skipped++;
++		}
++		if (need_to_zero)
++			clear_highpage(page + i);
++		else
++			prezero_counter++;
+ 		page_kasan_tag_set(page + i, tag);
+ 	}
+ 	kasan_enable_current();
+@@ -1329,6 +1543,11 @@ static __always_inline bool free_pages_prepare(struct page *page,
+ 			ClearPageHasHWPoisoned(page);
+ 		}
+ 		for (i = 1; i < (1 << order); i++) {
++			/*
++			 * This will leave BUDDY_ZEROED in place
++			 * in tail pages.  It should get cleared
++			 * up before anyone notices in expand().
++			 */
+ 			if (compound)
+ 				bad += free_tail_pages_check(page, page + i);
+ 			if (unlikely(check_free_page(page + i))) {
+@@ -1393,44 +1612,58 @@ static __always_inline bool free_pages_prepare(struct page *page,
+ 	return true;
+ }
+ 
+-#ifdef CONFIG_DEBUG_VM
+ /*
+- * With DEBUG_VM enabled, order-0 pages are checked immediately when being freed
+- * to pcp lists. With debug_pagealloc also enabled, they are also rechecked when
+- * moved from pcp lists to free lists.
++ * Is extra page-free-time debugging needed?  Returning true here will wreck
++ * performance, but add extra sanity checks to pages at free time.  Only
++ * turn on when debugging.
+  */
+-static bool free_pcp_prepare(struct page *page, unsigned int order)
++static inline bool extra_debug_free(void)
+ {
+-	return free_pages_prepare(page, order, true, FPI_NONE);
++	return IS_ENABLED(CONFIG_DEBUG_VM) || debug_pagealloc_enabled_static();
+ }
+ 
+-static bool bulkfree_pcp_prepare(struct page *page)
+-{
+-	if (debug_pagealloc_enabled_static())
+-		return check_free_page(page);
+-	else
+-		return false;
+-}
+-#else
+ /*
+- * With DEBUG_VM disabled, order-0 pages being freed are checked only when
+- * moving from pcp lists to free list in order to reduce overhead. With
+- * debug_pagealloc enabled, they are checked also immediately when being freed
+- * to the pcp lists.
++ * Called when pages are freed into the allocaor but before being added to the
++ * pcp lists.  Only do free page checking when some form of debugging is on to
++ * reduce overhead.
+  */
+ static bool free_pcp_prepare(struct page *page, unsigned int order)
+ {
+-	if (debug_pagealloc_enabled_static())
+-		return free_pages_prepare(page, order, true, FPI_NONE);
+-	else
+-		return free_pages_prepare(page, order, false, FPI_NONE);
++
++	page->private = 0;
++
++
++	return free_pages_prepare(page, order, extra_debug_free(), FPI_NONE);
+ }
+ 
+-static bool bulkfree_pcp_prepare(struct page *page)
++/*
++ * Called when pages are moved from the pcp lists to the main buddy free lists.
++ *
++ * These pages should have been checked when they were initially freed into the
++ * allocator via free_pcp_prepare().  Check them again if one the extra free
++ * debugging checks are on.
++ */
++static bool bulkfree_pcp_prepare(struct page *page, int order)
+ {
+-	return check_free_page(page);
++	unsigned long private = page->private;
++
++
++	/*
++	 * Only BUDDY_ZEROED should be set in page->private at
++	 * this point.  If any other bit is set, we have uno
++	 * problemo.
++	 */
++	if ((private & ~BUDDY_ZEROED) && printk_ratelimit()) {
++		printk("%s()::%d %lx\n", __func__, __LINE__, page->private);
++		page->private = 0;
++
++	}
++
++	if (extra_debug_free())
++		return check_free_page(page);
++	else
++		return false;
+ }
+-#endif /* CONFIG_DEBUG_VM */
+ 
+ static inline void prefetch_buddy(struct page *page)
+ {
+@@ -1493,7 +1726,7 @@ static void free_pcppages_bulk(struct zone *zone, int count,
+ 			nr_freed += 1 << order;
+ 			count -= 1 << order;
+ 
+-			if (bulkfree_pcp_prepare(page))
++			if (bulkfree_pcp_prepare(page, order))
+ 				continue;
+ 
+ 			/* Encode order with the migratetype */
+@@ -2294,7 +2527,7 @@ void __init init_cma_reserved_pageblock(struct page *page)
+  * -- nyc
+  */
+ static inline void expand(struct zone *zone, struct page *page,
+-	int low, int high, int migratetype)
++	int low, int high, int migratetype, enum zero_state page_prezeroed)
+ {
+ 	unsigned long size = 1 << high;
+ 
+@@ -2312,8 +2545,8 @@ static inline void expand(struct zone *zone, struct page *page,
+ 		if (set_page_guard(zone, &page[size], high, migratetype))
+ 			continue;
+ 
++		mark_new_buddy(&page[size], high, page_prezeroed);
+ 		add_to_free_list(&page[size], zone, high, migratetype);
+-		set_buddy_order(&page[size], high);
+ 	}
+ }
+ 
+@@ -2392,10 +2625,19 @@ static bool check_new_pages(struct page *page, unsigned int order)
+ 	return false;
+ }
+ 
+-inline void post_alloc_hook(struct page *page, unsigned int order,
++noinline void post_alloc_hook(struct page *page, unsigned int order,
+ 				gfp_t gfp_flags)
+ {
+-	set_page_private(page, 0);
++	if ((page->private & ~BUDDY_ZEROED) && printk_ratelimit()) {
++		printk("%s()::%d BAD page private: priv=%lx\n", __func__, __LINE__, page->private);
++		page->private = 0;
++		/*
++		 * PageBuddy() is clear.  This trips the
++		 * PageBuddy check in set_buddy_private().
++		 */
++		//set_buddy_private(page, 0);
++		dump_stack();
++	}
+ 	set_page_refcounted(page);
+ 
+ 	arch_alloc_page(page, order);
+@@ -2428,7 +2670,7 @@ inline void post_alloc_hook(struct page *page, unsigned int order,
+ 	page_table_check_alloc(page, order);
+ }
+ 
+-static void prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags,
++static noinline void prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags,
+ 							unsigned int alloc_flags)
+ {
+ 	post_alloc_hook(page, order, gfp_flags);
+@@ -2462,13 +2704,30 @@ struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
+ 
+ 	/* Find a page of the appropriate size in the preferred list */
+ 	for (current_order = order; current_order < MAX_ORDER; ++current_order) {
++		enum zero_state page_pz;
+ 		area = &(zone->free_area[current_order]);
+ 		page = get_page_from_free_area(area, migratetype);
+ 		if (!page)
+ 			continue;
++		/* stash this away before del_page_from_free_list() zaps it: */
++		page_pz = pre_zeroed(page);
++
+ 		del_page_from_free_list(page, zone, current_order);
+-		expand(zone, page, order, current_order, migratetype);
++		expand(zone, page, order, current_order, migratetype, page_pz);
+ 		set_pcppage_migratetype(page, migratetype);
++		/*
++		 * This is a bit of a kludge.  The state was zapped above
++		 * and is restored here.  We should probably
++		 * think about if del_page_from_free_list()
++		 * leaves BUDDY_ZEROED in place and what the
++		 * implications are.
++		 *
++		 * Without this, pages leaving the buddy always
++		 * have page->private=0.
++		 */
++		if (page_pz == PRE_ZEROED) {
++			page->private = BUDDY_ZEROED;
++		}
+ 		return page;
+ 	}
+ 
+@@ -9490,7 +9749,9 @@ static void break_down_buddy_pages(struct zone *zone, struct page *page,
+ 
+ 		if (current_buddy != target) {
+ 			add_to_free_list(current_buddy, zone, high, migratetype);
+-			set_buddy_order(current_buddy, high);
++			// This is very rare.  Do not bother
++			// trying to preserve zero state:
++			mark_new_buddy(current_buddy, high, NOT_ZEROED);
+ 			page = next_page;
+ 		}
+ 	}
+@@ -9573,3 +9834,78 @@ bool has_managed_dma(void)
+ 	return false;
+ }
+ #endif /* CONFIG_ZONE_DMA */
++
++void __list_check_buddy_low_orders(struct page *page, int order, int line)
++{
++	int nr_pages = 1 << order;
++	int i;
++
++	for (i = 1; i < nr_pages; i++) {
++		struct page *child = &page[i];
++		unsigned long child_pfn = page_to_pfn(child);
++		unsigned long pfn = page_to_pfn(page);
++		if (!PageBuddy(child))
++			continue;
++
++		printk("bad low order: %d pfns: 0x%lx 0x%lx buddy: %d/%d line=%d bo=%d\n",
++				order, pfn, child_pfn,
++				PageBuddy(page),
++				PageBuddy(child),
++				line, buddy_order(child));
++	}
++}
++
++void __list_check_buddy_high_orders(struct page *page, int order, int line)
++{
++	unsigned long pfn = page_to_pfn(page);
++
++	// Highest-order buddy pages (MAX_ORDER-1) are not
++	// merged together and can be on lists together
++	if (order >= MAX_ORDER-1)
++		return;
++
++	while (order < MAX_ORDER-1) {
++		unsigned long buddy_pfn = __find_buddy_pfn(pfn, order);
++		struct page *buddy = pfn_to_page(buddy_pfn);
++		bool bad;
++
++		// not in the buddy, don't care
++		if (!PageBuddy(buddy))
++			goto next;
++
++		// starts after me, can't possible overlap, don't care
++		if (buddy_pfn >= pfn + (1<<order))
++			goto next;
++
++		// Starts before me.  Does it cover me?
++		if (buddy_pfn + (1<<buddy_order(buddy)) <= pfn)
++			goto next;
++
++		bad = 1;
++		if (bad) {
++			printk("bad high order: %d pfns: 0x%lx 0x%lx buddy: %d/%d pib=%d line=%d bo=%d bad=%d\n",
++					order, pfn, buddy_pfn, PageBuddy(page),
++					PageBuddy(buddy),
++					page_is_buddy(page, buddy, order),
++					line,
++					buddy_order(buddy),
++					bad);
++			//WARN_ON(1);
++		}
++
++		// combine the PFNs to "move up" one order:
++		pfn = buddy_pfn & pfn;
++		page = pfn_to_page(pfn);
++	next:
++		order++;
++	}
++}
++
++
++void __list_check_buddy_is_sane(struct page *page, int order, int line)
++{
++	if (!prezero_buddy_sane_checks)
++		return;
++	__list_check_buddy_high_orders(page, order, line);
++	__list_check_buddy_low_orders(page, order, line);
++}
+-- 
+https://clearlinux.org
+


@@ 0,0 1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan.van.de.ven@intel.com>
+Date: Fri, 15 Apr 2022 00:07:38 +0000
+Subject: [PATCH] novector
+
+gcc12/build workarounds
+
+---
+ arch/x86/Makefile | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/arch/x86/Makefile b/arch/x86/Makefile
+index e84cdd409b64..59ef9ef60ab7 100644
+--- a/arch/x86/Makefile
++++ b/arch/x86/Makefile
+@@ -60,7 +60,7 @@ export BITS
+ #
+ #    https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53383
+ #
+-KBUILD_CFLAGS += -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx
++KBUILD_CFLAGS += -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx -mno-avx2 -O0 -O2 -fno-tree-vectorize -march=westmere -mpopcnt 
+ 
+ # Intel CET isn't enabled in the kernel
+ KBUILD_CFLAGS += $(call cc-option,-fcf-protection=none)
+-- 
+https://clearlinux.org
+