Merge branch 'x86-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip (72825454) · Commits · 戴 / test

arch/x86/events/core.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -2402,13 +2402,13 @@ perf_callchain_kernel(struct perf_callchain_entry_ctx entry, struct pt_regs re
		return;
		}

		if (perf_hw_regs(regs)) {
		if (perf_callchain_store(entry, regs->ip))
		return;

		if (perf_hw_regs(regs))
		unwind_start(&state, current, regs, NULL);
		} else {
		else
		unwind_start(&state, current, NULL, (void *)regs->sp);
		}

		for (; !unwind_done(&state); unwind_next_frame(&state)) {
		addr = unwind_get_return_address(&state);

arch/x86/kernel/apic/apic.c

+2 −1

Original line number	Diff line number	Diff line
		@@ -1464,7 +1464,8 @@ static void apic_pending_intr_clear(void)
		if (queued) {
		if (boot_cpu_has(X86_FEATURE_TSC) && cpu_khz) {
		ntsc = rdtsc();
		max_loops = (cpu_khz << 10) - (ntsc - tsc);
		max_loops = (long long)cpu_khz << 10;
		max_loops -= ntsc - tsc;
		} else {
		max_loops--;
		}

arch/x86/kernel/cpu/bugs.c

+10 −1

Original line number	Diff line number	Diff line
		@@ -835,6 +835,16 @@ static enum ssb_mitigation __init __ssb_select_mitigation(void)
		break;
		}

		/*
		* If SSBD is controlled by the SPEC_CTRL MSR, then set the proper
		* bit in the mask to allow guests to use the mitigation even in the
		* case where the host does not enable it.
		*/
		if (static_cpu_has(X86_FEATURE_SPEC_CTRL_SSBD) \|\|
		static_cpu_has(X86_FEATURE_AMD_SSBD)) {
		x86_spec_ctrl_mask \|= SPEC_CTRL_SSBD;
		}

		/*
		* We have three CPU feature flags that are in play here:
		* - X86_BUG_SPEC_STORE_BYPASS - CPU is susceptible.
		@@ -852,7 +862,6 @@ static enum ssb_mitigation __init __ssb_select_mitigation(void)
		x86_amd_ssb_disable();
		} else {
		x86_spec_ctrl_base \|= SPEC_CTRL_SSBD;
		x86_spec_ctrl_mask \|= SPEC_CTRL_SSBD;
		wrmsrl(MSR_IA32_SPEC_CTRL, x86_spec_ctrl_base);
		}
		}

arch/x86/kernel/cpu/microcode/core.c

+10 −5

Original line number	Diff line number	Diff line
		@@ -789,13 +789,16 @@ static struct syscore_ops mc_syscore_ops = {
		.resume = mc_bp_resume,
		};

		static int mc_cpu_online(unsigned int cpu)
		static int mc_cpu_starting(unsigned int cpu)
		{
		struct device *dev;

		dev = get_cpu_device(cpu);
		microcode_update_cpu(cpu);
		pr_debug("CPU%d added\n", cpu);
		return 0;
		}

		static int mc_cpu_online(unsigned int cpu)
		{
		struct device *dev = get_cpu_device(cpu);

		if (sysfs_create_group(&dev->kobj, &mc_attr_group))
		pr_err("Failed to create group for CPU%d\n", cpu);
		@@ -872,7 +875,9 @@ int __init microcode_init(void)
		goto out_ucode_group;

		register_syscore_ops(&mc_syscore_ops);
		cpuhp_setup_state_nocalls(CPUHP_AP_MICROCODE_LOADER, "x86/microcode:online",
		cpuhp_setup_state_nocalls(CPUHP_AP_MICROCODE_LOADER, "x86/microcode:starting",
		mc_cpu_starting, NULL);
		cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, "x86/microcode:online",
		mc_cpu_online, mc_cpu_down_prep);

		pr_info("Microcode Update Driver: v%s.", DRIVER_VERSION);

arch/x86/kernel/cpu/resctrl/rdtgroup.c

+16 −19

Original line number	Diff line number	Diff line
		@@ -796,8 +796,12 @@ static int rdt_bit_usage_show(struct kernfs_open_file *of,
		struct seq_file seq, void v)
		{
		struct rdt_resource *r = of->kn->parent->priv;
		u32 sw_shareable = 0, hw_shareable = 0;
		u32 exclusive = 0, pseudo_locked = 0;
		/*
		* Use unsigned long even though only 32 bits are used to ensure
		* test_bit() is used safely.
		*/
		unsigned long sw_shareable = 0, hw_shareable = 0;
		unsigned long exclusive = 0, pseudo_locked = 0;
		struct rdt_domain *dom;
		int i, hwb, swb, excl, psl;
		enum rdtgrp_mode mode;
		@@ -842,10 +846,10 @@ static int rdt_bit_usage_show(struct kernfs_open_file *of,
		}
		for (i = r->cache.cbm_len - 1; i >= 0; i--) {
		pseudo_locked = dom->plr ? dom->plr->cbm : 0;
		hwb = test_bit(i, (unsigned long *)&hw_shareable);
		swb = test_bit(i, (unsigned long *)&sw_shareable);
		excl = test_bit(i, (unsigned long *)&exclusive);
		psl = test_bit(i, (unsigned long *)&pseudo_locked);
		hwb = test_bit(i, &hw_shareable);
		swb = test_bit(i, &sw_shareable);
		excl = test_bit(i, &exclusive);
		psl = test_bit(i, &pseudo_locked);
		if (hwb && swb)
		seq_putc(seq, 'X');
		else if (hwb && !swb)
		@@ -2486,26 +2490,19 @@ out_destroy:
		*/
		static void cbm_ensure_valid(u32 _val, struct rdt_resource r)
		{
		/*
		* Convert the u32 _val to an unsigned long required by all the bit
		* operations within this function. No more than 32 bits of this
		* converted value can be accessed because all bit operations are
		* additionally provided with cbm_len that is initialized during
		* hardware enumeration using five bits from the EAX register and
		* thus never can exceed 32 bits.
		*/
		unsigned long val = (unsigned long )_val;
		unsigned long val = *_val;
		unsigned int cbm_len = r->cache.cbm_len;
		unsigned long first_bit, zero_bit;

		if (*val == 0)
		if (val == 0)
		return;

		first_bit = find_first_bit(val, cbm_len);
		zero_bit = find_next_zero_bit(val, cbm_len, first_bit);
		first_bit = find_first_bit(&val, cbm_len);
		zero_bit = find_next_zero_bit(&val, cbm_len, first_bit);

		/* Clear any remaining bits to ensure contiguous region */
		bitmap_clear(val, zero_bit, cbm_len - zero_bit);
		bitmap_clear(&val, zero_bit, cbm_len - zero_bit);
		*_val = (u32)val;
		}

		/*

Admin message