From patchwork Thu Aug 8 06:29:34 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ravi Bangoria X-Patchwork-Id: 13756989 Received: from NAM12-MW2-obe.outbound.protection.outlook.com (mail-mw2nam12on2060.outbound.protection.outlook.com [40.107.244.60]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5005413210D; Thu, 8 Aug 2024 06:31:07 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.107.244.60 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098669; cv=fail; b=ig3I/b3R0zjEU+dmtoChhaGxfImGOz4l19+xS4BQSnA2p1NxbanhHhWumKsuNwWYSz0cZBYCbEbaC5acJO1FW5n9vZ/9WGE1F/BHFQJ3HTu5kml8oBvCGPLnbJJ7rYnJMiCe45A3+v8TYfeD/x8s3udaTmlf810QO49BGbk0ZQU= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098669; c=relaxed/simple; bh=x1HiO08wUJnb9GD/GvSbBUdiMG0ex7Y4R3OAzERsB2c=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=lTBN6P2kjuTfvjxqeq6P2a19KNZSFjdVl0HcPOqQF2NBdYFZjEuwJxNieNHYszYDN1lOtLA8YkT65pZNNv9kcOS+nWK0msTI7KsCONUKj2WbNcpzvEb4BQ+NP0ZXrxzwLzntI3fZAOwc2MiQI0GT2EThe00mGUqsD4BCzpGne+E= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com; spf=fail smtp.mailfrom=amd.com; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b=hZHCfArs; arc=fail smtp.client-ip=40.107.244.60 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=amd.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b="hZHCfArs" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=qh3oMSI0cFvJOevppV0WD842EBER54p0UKfMfBmbe0tMXSCYWzltyJ9biCQd4guz9UDSXtppVuHtArNzV3LRSuD/uDxMne9Olan30P1IHvv5dJI3QXtYMybGmhj6KEXtODAs5n2CZr+DnY8Qu/dGYeBOtttQAbHUOGAkFGWshlSgWm1nB3Tu+0lP+amzlei/OqOXADndhhDAW1SZOhd/FFfDjhGDGyjtrjZFX3q46TTapdjQWe8WtA6voDdLg991Uz7Ge8TXDrRJOwyC+n9AbPDtPb9XrMf1FSZy6dIxnd4ZRtYDdW9FvjCxAUmlWKeKmaLEWVJqNXapYxhNVRSPHg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=yY9HCOikVtuD0ovx51yHFNpS/Tt4XgmRp4q5xAi6BIA=; b=i4RArC1CTbKgSsyaEtKUVyS7sdvTpovRkLJ/D7LtYAaSDXgALvPrAJCrwnmCfAVPp10mGyHIluoXqNm4LvoCtT7pZyV+tjeLybgvDuaBdmZJaEsNsedWZW4E92nT2tPzsy3/PYJz5lNKpQ38cIQbm6JFxa4guuMJa+CjPNp35sX8tF1vG1bV3YA62lHYV08ADLhFEZROslvOQ8upqIEqbgOZiH4YDpsCTvMlztiGB8vC2j7cJULqbB7EM5ttm8bW6guOUNCht1Yd2S18aXPo5Y9R5qFbOMZm83epwftzoAf0t8GS/MYPC6l/0Uy9l/JlVYPiH5mZ4HhsDcnC6O58JA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=linutronix.de smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=yY9HCOikVtuD0ovx51yHFNpS/Tt4XgmRp4q5xAi6BIA=; b=hZHCfArsj/E08bwHbWhPhe2G7R1LKKKIr/PUz7KQazPJdQrhaoXGonMncMfpQNhhezULR+NmtqzSxc/tS5ZBur+LDH3rQJp8Wvyl4WXnuJN4hYNN1xrsZLKN/WT+HVD8YiQFZw4j9fe2TfpRBLf0/z2UB/kcmlwQ5nK3V3MlCWQ= Received: from BN9PR03CA0496.namprd03.prod.outlook.com (2603:10b6:408:130::21) by SJ1PR12MB6316.namprd12.prod.outlook.com (2603:10b6:a03:455::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.26; Thu, 8 Aug 2024 06:31:03 +0000 Received: from BN2PEPF0000449D.namprd02.prod.outlook.com (2603:10b6:408:130:cafe::5d) by BN9PR03CA0496.outlook.office365.com (2603:10b6:408:130::21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.29 via Frontend Transport; Thu, 8 Aug 2024 06:31:03 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN2PEPF0000449D.mail.protection.outlook.com (10.167.243.148) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.7849.8 via Frontend Transport; Thu, 8 Aug 2024 06:31:03 +0000 Received: from BLR-L-RBANGORI.amd.com (10.180.168.240) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Thu, 8 Aug 2024 01:30:52 -0500 From: Ravi Bangoria To: , , , , , , , CC: , , , , , , , , , , , , , , , , , , , Subject: [PATCH v4 1/4] x86/split_lock: Move Split and Bus lock code to a dedicated file Date: Thu, 8 Aug 2024 06:29:34 +0000 Message-ID: <20240808062937.1149-2-ravi.bangoria@amd.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240808062937.1149-1-ravi.bangoria@amd.com> References: <20240808062937.1149-1-ravi.bangoria@amd.com> Precedence: bulk X-Mailing-List: kvm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-ClientProxiedBy: SATLEXMB04.amd.com (10.181.40.145) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN2PEPF0000449D:EE_|SJ1PR12MB6316:EE_ X-MS-Office365-Filtering-Correlation-Id: 18f39ca8-b3a2-4b30-86d9-08dcb773acfe X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|7416014|1800799024|376014|36860700013|82310400026; X-Microsoft-Antispam-Message-Info: 6sxYhBtzN0GPKdEIbOjdWnf8yxQu9Y22M+BM8xTW2Wm806guTSGZ0avH8f928IufNbbnM4t1o+kBnYRoRQlJSaeiUW6ZQ4unOafOW5XnquLMFiD/WYla3j/JZkenBmWdlbdU7X1lstyHNewW2peQdkmgRQkli8mMCUmIV7Lsp8qknm41i9J1ZCWKN7esEiSt1IfJ3P1P873HznuOMTM2XyPC8MJVJV8TDgk+kvQkhWs9UU0Fw3YQWvUnK84svoe68GY+Nlhv5LG82a5qpFJF+h1ITxkoWeBGDlAKc+tfCfe93S4KqJlgkh/p2iQqgn38q/eH0xJ9f0zcqC/CaYoPEUpCwOvABFkbPknhivKDzf2oLDkmYcoRKiBG5xHPa+V8WG6zqQGjyk/mDEthRwnqT5RCcp/qQmPWzIJG7SGQaSQgctxKXd3T0BLChfTdA7OQxzy17wHb9MlwT42wpHyrvo5x9BAg3/oWVSCIgeH8QwNtrcvR0dBkR6C/GK9CUA7Vf9igo+wuaTDoIgUFWxBoW/W/IzV7z8b8Cwb8F6jSUWV8/j5shRWbEL8Z4THzz2P0ilEZvGq26+SRuu2tLXzZgQa9BkM1wPJ1GtH5dR77+STMBH/67ad0HbDY1LL/5MXblS6gdLjgeh3Gs6a2HRtyVVxQEHcj3O/JHAU8V2ZtMs8nXTcEWx0NaTbHwjB8YoAytYlJMTTV6Q9lSOx8MJo5r4bKmSncXjzSrMVvX6kPCXnN5Kfo1MdFtGLzd0nYdPVH4MeoM+fvEILI/cBO1pYZKztVFFZf1w7wNFbJbq+T1K/yZkO3ZSXClfe+bR+bYfDUT9Qp4ELQl+5TTGnPNu2sQk8qwX7zOdi3Lbv7gAAu+nmOZmL9vCnOnj2vulusBLQInjy3has+l4RtZp1P5zHytsmDWae1tz7/ZIH485P7K6NeJ3X2tdeC4zc/T7kGu3Dh/D6H1QyvhOmvIihAa3Q8ItVwQ1aeRdCKNvvw+EsgucVyhZkFv+EYDVwc3wBZ6WryiR9b/ofdwMC8jbIRpTYdJN2RlwkJv0c5MaeUz/GNzJ7hY6lNGOiXjyrkf6kK0yfwTmNd8Cr8wrz68t8uWDH8SaSNR6xfECJ0uAoTg1h1buM4jrtsZ4E2vK2okKe29NKUdTMLqGMh1mY+kqMzWIln80XmbyA6QE1fHHK3VLOrOi9XxCKgCJbX46BqGGq1JPyBr38GarKY70jcDRX6ERg6UH1RPIiETK5DbNNQGMXM927VaGBQL4xUGlMh2od0WpSO0n1j9snIfQc+nfXw61aIPOnT9So6hhePECRBNJpLZNlCnBcy6RWuSGXTOA8iYf6T24oP5Z1+Dl1sTTjAgaUQR279L9I3eRMgi1tXK5AipLYxJQRuzYT1+fFlB84n5rr716KB5P+SFHRFtsiA5HJJJ1r0wdGZ+irgeky0KhC9NNS+RAKIAHh93kESIriwoFYh X-Forefront-Antispam-Report: CIP:165.204.84.17;CTRY:US;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:SATLEXMB04.amd.com;PTR:InfoDomainNonexistent;CAT:NONE;SFS:(13230040)(7416014)(1800799024)(376014)(36860700013)(82310400026);DIR:OUT;SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Aug 2024 06:31:03.0470 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 18f39ca8-b3a2-4b30-86d9-08dcb773acfe X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.17];Helo=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN2PEPF0000449D.namprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: SJ1PR12MB6316 Bus Lock Detect functionality on AMD platforms works identical to Intel. Move split_lock and bus_lock specific code from intel.c to a dedicated file so that it can be compiled and supported on non-Intel platforms. Also, introduce CONFIG_X86_BUS_LOCK_DETECT, make it dependent on CONFIG_CPU_SUP_INTEL and add compilation dependency of new bus_lock.c file on CONFIG_X86_BUS_LOCK_DETECT. Signed-off-by: Ravi Bangoria Reviewed-by: Tom Lendacky --- arch/x86/Kconfig | 8 + arch/x86/include/asm/cpu.h | 11 +- arch/x86/kernel/cpu/Makefile | 2 + arch/x86/kernel/cpu/bus_lock.c | 406 +++++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/intel.c | 406 --------------------------------- include/linux/sched.h | 2 +- kernel/fork.c | 2 +- 7 files changed, 427 insertions(+), 410 deletions(-) create mode 100644 arch/x86/kernel/cpu/bus_lock.c diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 02775a61b557..db2aad850a8f 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -2427,6 +2427,14 @@ config CFI_AUTO_DEFAULT source "kernel/livepatch/Kconfig" +config X86_BUS_LOCK_DETECT + bool "Split Lock Detect and Bus Lock Detect support" + depends on CPU_SUP_INTEL + default y + help + Enable Split Lock Detect and Bus Lock Detect functionalities. + See for more information. + endmenu config CC_HAS_NAMED_AS diff --git a/arch/x86/include/asm/cpu.h b/arch/x86/include/asm/cpu.h index aa30fd8cad7f..86cf7952ee86 100644 --- a/arch/x86/include/asm/cpu.h +++ b/arch/x86/include/asm/cpu.h @@ -26,12 +26,13 @@ int mwait_usable(const struct cpuinfo_x86 *); unsigned int x86_family(unsigned int sig); unsigned int x86_model(unsigned int sig); unsigned int x86_stepping(unsigned int sig); -#ifdef CONFIG_CPU_SUP_INTEL +#ifdef CONFIG_X86_BUS_LOCK_DETECT extern void __init sld_setup(struct cpuinfo_x86 *c); extern bool handle_user_split_lock(struct pt_regs *regs, long error_code); extern bool handle_guest_split_lock(unsigned long ip); extern void handle_bus_lock(struct pt_regs *regs); -u8 get_this_hybrid_cpu_type(void); +void split_lock_init(void); +void bus_lock_init(void); #else static inline void __init sld_setup(struct cpuinfo_x86 *c) {} static inline bool handle_user_split_lock(struct pt_regs *regs, long error_code) @@ -45,7 +46,13 @@ static inline bool handle_guest_split_lock(unsigned long ip) } static inline void handle_bus_lock(struct pt_regs *regs) {} +static inline void split_lock_init(void) {} +static inline void bus_lock_init(void) {} +#endif +#ifdef CONFIG_CPU_SUP_INTEL +u8 get_this_hybrid_cpu_type(void); +#else static inline u8 get_this_hybrid_cpu_type(void) { return 0; diff --git a/arch/x86/kernel/cpu/Makefile b/arch/x86/kernel/cpu/Makefile index 5857a0f5d514..4efdf5c2efc8 100644 --- a/arch/x86/kernel/cpu/Makefile +++ b/arch/x86/kernel/cpu/Makefile @@ -59,6 +59,8 @@ obj-$(CONFIG_ACRN_GUEST) += acrn.o obj-$(CONFIG_DEBUG_FS) += debugfs.o +obj-$(CONFIG_X86_BUS_LOCK_DETECT) += bus_lock.o + quiet_cmd_mkcapflags = MKCAP $@ cmd_mkcapflags = $(CONFIG_SHELL) $(src)/mkcapflags.sh $@ $^ diff --git a/arch/x86/kernel/cpu/bus_lock.c b/arch/x86/kernel/cpu/bus_lock.c new file mode 100644 index 000000000000..704e9241b964 --- /dev/null +++ b/arch/x86/kernel/cpu/bus_lock.c @@ -0,0 +1,406 @@ +// SPDX-License-Identifier: GPL-2.0 + +#define pr_fmt(fmt) "x86/split lock detection: " fmt + +#include +#include +#include +#include +#include +#include +#include +#include + +enum split_lock_detect_state { + sld_off = 0, + sld_warn, + sld_fatal, + sld_ratelimit, +}; + +/* + * Default to sld_off because most systems do not support split lock detection. + * sld_state_setup() will switch this to sld_warn on systems that support + * split lock/bus lock detect, unless there is a command line override. + */ +static enum split_lock_detect_state sld_state __ro_after_init = sld_off; +static u64 msr_test_ctrl_cache __ro_after_init; + +/* + * With a name like MSR_TEST_CTL it should go without saying, but don't touch + * MSR_TEST_CTL unless the CPU is one of the whitelisted models. Writing it + * on CPUs that do not support SLD can cause fireworks, even when writing '0'. + */ +static bool cpu_model_supports_sld __ro_after_init; + +static const struct { + const char *option; + enum split_lock_detect_state state; +} sld_options[] __initconst = { + { "off", sld_off }, + { "warn", sld_warn }, + { "fatal", sld_fatal }, + { "ratelimit:", sld_ratelimit }, +}; + +static struct ratelimit_state bld_ratelimit; + +static unsigned int sysctl_sld_mitigate = 1; +static DEFINE_SEMAPHORE(buslock_sem, 1); + +#ifdef CONFIG_PROC_SYSCTL +static struct ctl_table sld_sysctls[] = { + { + .procname = "split_lock_mitigate", + .data = &sysctl_sld_mitigate, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = proc_douintvec_minmax, + .extra1 = SYSCTL_ZERO, + .extra2 = SYSCTL_ONE, + }, +}; + +static int __init sld_mitigate_sysctl_init(void) +{ + register_sysctl_init("kernel", sld_sysctls); + return 0; +} + +late_initcall(sld_mitigate_sysctl_init); +#endif + +static inline bool match_option(const char *arg, int arglen, const char *opt) +{ + int len = strlen(opt), ratelimit; + + if (strncmp(arg, opt, len)) + return false; + + /* + * Min ratelimit is 1 bus lock/sec. + * Max ratelimit is 1000 bus locks/sec. + */ + if (sscanf(arg, "ratelimit:%d", &ratelimit) == 1 && + ratelimit > 0 && ratelimit <= 1000) { + ratelimit_state_init(&bld_ratelimit, HZ, ratelimit); + ratelimit_set_flags(&bld_ratelimit, RATELIMIT_MSG_ON_RELEASE); + return true; + } + + return len == arglen; +} + +static bool split_lock_verify_msr(bool on) +{ + u64 ctrl, tmp; + + if (rdmsrl_safe(MSR_TEST_CTRL, &ctrl)) + return false; + if (on) + ctrl |= MSR_TEST_CTRL_SPLIT_LOCK_DETECT; + else + ctrl &= ~MSR_TEST_CTRL_SPLIT_LOCK_DETECT; + if (wrmsrl_safe(MSR_TEST_CTRL, ctrl)) + return false; + rdmsrl(MSR_TEST_CTRL, tmp); + return ctrl == tmp; +} + +static void __init sld_state_setup(void) +{ + enum split_lock_detect_state state = sld_warn; + char arg[20]; + int i, ret; + + if (!boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT) && + !boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) + return; + + ret = cmdline_find_option(boot_command_line, "split_lock_detect", + arg, sizeof(arg)); + if (ret >= 0) { + for (i = 0; i < ARRAY_SIZE(sld_options); i++) { + if (match_option(arg, ret, sld_options[i].option)) { + state = sld_options[i].state; + break; + } + } + } + sld_state = state; +} + +static void __init __split_lock_setup(void) +{ + if (!split_lock_verify_msr(false)) { + pr_info("MSR access failed: Disabled\n"); + return; + } + + rdmsrl(MSR_TEST_CTRL, msr_test_ctrl_cache); + + if (!split_lock_verify_msr(true)) { + pr_info("MSR access failed: Disabled\n"); + return; + } + + /* Restore the MSR to its cached value. */ + wrmsrl(MSR_TEST_CTRL, msr_test_ctrl_cache); + + setup_force_cpu_cap(X86_FEATURE_SPLIT_LOCK_DETECT); +} + +/* + * MSR_TEST_CTRL is per core, but we treat it like a per CPU MSR. Locking + * is not implemented as one thread could undo the setting of the other + * thread immediately after dropping the lock anyway. + */ +static void sld_update_msr(bool on) +{ + u64 test_ctrl_val = msr_test_ctrl_cache; + + if (on) + test_ctrl_val |= MSR_TEST_CTRL_SPLIT_LOCK_DETECT; + + wrmsrl(MSR_TEST_CTRL, test_ctrl_val); +} + +void split_lock_init(void) +{ + /* + * #DB for bus lock handles ratelimit and #AC for split lock is + * disabled. + */ + if (sld_state == sld_ratelimit) { + split_lock_verify_msr(false); + return; + } + + if (cpu_model_supports_sld) + split_lock_verify_msr(sld_state != sld_off); +} + +static void __split_lock_reenable_unlock(struct work_struct *work) +{ + sld_update_msr(true); + up(&buslock_sem); +} + +static DECLARE_DELAYED_WORK(sl_reenable_unlock, __split_lock_reenable_unlock); + +static void __split_lock_reenable(struct work_struct *work) +{ + sld_update_msr(true); +} +static DECLARE_DELAYED_WORK(sl_reenable, __split_lock_reenable); + +/* + * If a CPU goes offline with pending delayed work to re-enable split lock + * detection then the delayed work will be executed on some other CPU. That + * handles releasing the buslock_sem, but because it executes on a + * different CPU probably won't re-enable split lock detection. This is a + * problem on HT systems since the sibling CPU on the same core may then be + * left running with split lock detection disabled. + * + * Unconditionally re-enable detection here. + */ +static int splitlock_cpu_offline(unsigned int cpu) +{ + sld_update_msr(true); + + return 0; +} + +static void split_lock_warn(unsigned long ip) +{ + struct delayed_work *work; + int cpu; + + if (!current->reported_split_lock) + pr_warn_ratelimited("#AC: %s/%d took a split_lock trap at address: 0x%lx\n", + current->comm, current->pid, ip); + current->reported_split_lock = 1; + + if (sysctl_sld_mitigate) { + /* + * misery factor #1: + * sleep 10ms before trying to execute split lock. + */ + if (msleep_interruptible(10) > 0) + return; + /* + * Misery factor #2: + * only allow one buslocked disabled core at a time. + */ + if (down_interruptible(&buslock_sem) == -EINTR) + return; + work = &sl_reenable_unlock; + } else { + work = &sl_reenable; + } + + cpu = get_cpu(); + schedule_delayed_work_on(cpu, work, 2); + + /* Disable split lock detection on this CPU to make progress */ + sld_update_msr(false); + put_cpu(); +} + +bool handle_guest_split_lock(unsigned long ip) +{ + if (sld_state == sld_warn) { + split_lock_warn(ip); + return true; + } + + pr_warn_once("#AC: %s/%d %s split_lock trap at address: 0x%lx\n", + current->comm, current->pid, + sld_state == sld_fatal ? "fatal" : "bogus", ip); + + current->thread.error_code = 0; + current->thread.trap_nr = X86_TRAP_AC; + force_sig_fault(SIGBUS, BUS_ADRALN, NULL); + return false; +} +EXPORT_SYMBOL_GPL(handle_guest_split_lock); + +void bus_lock_init(void) +{ + u64 val; + + if (!boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) + return; + + rdmsrl(MSR_IA32_DEBUGCTLMSR, val); + + if ((boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT) && + (sld_state == sld_warn || sld_state == sld_fatal)) || + sld_state == sld_off) { + /* + * Warn and fatal are handled by #AC for split lock if #AC for + * split lock is supported. + */ + val &= ~DEBUGCTLMSR_BUS_LOCK_DETECT; + } else { + val |= DEBUGCTLMSR_BUS_LOCK_DETECT; + } + + wrmsrl(MSR_IA32_DEBUGCTLMSR, val); +} + +bool handle_user_split_lock(struct pt_regs *regs, long error_code) +{ + if ((regs->flags & X86_EFLAGS_AC) || sld_state == sld_fatal) + return false; + split_lock_warn(regs->ip); + return true; +} + +void handle_bus_lock(struct pt_regs *regs) +{ + switch (sld_state) { + case sld_off: + break; + case sld_ratelimit: + /* Enforce no more than bld_ratelimit bus locks/sec. */ + while (!__ratelimit(&bld_ratelimit)) + msleep(20); + /* Warn on the bus lock. */ + fallthrough; + case sld_warn: + pr_warn_ratelimited("#DB: %s/%d took a bus_lock trap at address: 0x%lx\n", + current->comm, current->pid, regs->ip); + break; + case sld_fatal: + force_sig_fault(SIGBUS, BUS_ADRALN, NULL); + break; + } +} + +/* + * CPU models that are known to have the per-core split-lock detection + * feature even though they do not enumerate IA32_CORE_CAPABILITIES. + */ +static const struct x86_cpu_id split_lock_cpu_ids[] __initconst = { + X86_MATCH_VFM(INTEL_ICELAKE_X, 0), + X86_MATCH_VFM(INTEL_ICELAKE_L, 0), + X86_MATCH_VFM(INTEL_ICELAKE_D, 0), + {} +}; + +static void __init split_lock_setup(struct cpuinfo_x86 *c) +{ + const struct x86_cpu_id *m; + u64 ia32_core_caps; + + if (boot_cpu_has(X86_FEATURE_HYPERVISOR)) + return; + + /* Check for CPUs that have support but do not enumerate it: */ + m = x86_match_cpu(split_lock_cpu_ids); + if (m) + goto supported; + + if (!cpu_has(c, X86_FEATURE_CORE_CAPABILITIES)) + return; + + /* + * Not all bits in MSR_IA32_CORE_CAPS are architectural, but + * MSR_IA32_CORE_CAPS_SPLIT_LOCK_DETECT is. All CPUs that set + * it have split lock detection. + */ + rdmsrl(MSR_IA32_CORE_CAPS, ia32_core_caps); + if (ia32_core_caps & MSR_IA32_CORE_CAPS_SPLIT_LOCK_DETECT) + goto supported; + + /* CPU is not in the model list and does not have the MSR bit: */ + return; + +supported: + cpu_model_supports_sld = true; + __split_lock_setup(); +} + +static void sld_state_show(void) +{ + if (!boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT) && + !boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT)) + return; + + switch (sld_state) { + case sld_off: + pr_info("disabled\n"); + break; + case sld_warn: + if (boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT)) { + pr_info("#AC: crashing the kernel on kernel split_locks and warning on user-space split_locks\n"); + if (cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, + "x86/splitlock", NULL, splitlock_cpu_offline) < 0) + pr_warn("No splitlock CPU offline handler\n"); + } else if (boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) { + pr_info("#DB: warning on user-space bus_locks\n"); + } + break; + case sld_fatal: + if (boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT)) { + pr_info("#AC: crashing the kernel on kernel split_locks and sending SIGBUS on user-space split_locks\n"); + } else if (boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) { + pr_info("#DB: sending SIGBUS on user-space bus_locks%s\n", + boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT) ? + " from non-WB" : ""); + } + break; + case sld_ratelimit: + if (boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) + pr_info("#DB: setting system wide bus lock rate limit to %u/sec\n", bld_ratelimit.burst); + break; + } +} + +void __init sld_setup(struct cpuinfo_x86 *c) +{ + split_lock_setup(c); + sld_state_setup(); + sld_state_show(); +} diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c index 08b95a35b5cb..8a483f4ad026 100644 --- a/arch/x86/kernel/cpu/intel.c +++ b/arch/x86/kernel/cpu/intel.c @@ -7,13 +7,9 @@ #include #include #include -#include #include #include #include -#include -#include -#include #include #include @@ -24,8 +20,6 @@ #include #include #include -#include -#include #include #include #include @@ -41,28 +35,6 @@ #include #endif -enum split_lock_detect_state { - sld_off = 0, - sld_warn, - sld_fatal, - sld_ratelimit, -}; - -/* - * Default to sld_off because most systems do not support split lock detection. - * sld_state_setup() will switch this to sld_warn on systems that support - * split lock/bus lock detect, unless there is a command line override. - */ -static enum split_lock_detect_state sld_state __ro_after_init = sld_off; -static u64 msr_test_ctrl_cache __ro_after_init; - -/* - * With a name like MSR_TEST_CTL it should go without saying, but don't touch - * MSR_TEST_CTL unless the CPU is one of the whitelisted models. Writing it - * on CPUs that do not support SLD can cause fireworks, even when writing '0'. - */ -static bool cpu_model_supports_sld __ro_after_init; - /* * Processors which have self-snooping capability can handle conflicting * memory type across CPUs by snooping its own cache. However, there exists @@ -547,9 +519,6 @@ static void init_intel_misc_features(struct cpuinfo_x86 *c) wrmsrl(MSR_MISC_FEATURES_ENABLES, msr); } -static void split_lock_init(void); -static void bus_lock_init(void); - static void init_intel(struct cpuinfo_x86 *c) { early_init_intel(c); @@ -907,381 +876,6 @@ static const struct cpu_dev intel_cpu_dev = { cpu_dev_register(intel_cpu_dev); -#undef pr_fmt -#define pr_fmt(fmt) "x86/split lock detection: " fmt - -static const struct { - const char *option; - enum split_lock_detect_state state; -} sld_options[] __initconst = { - { "off", sld_off }, - { "warn", sld_warn }, - { "fatal", sld_fatal }, - { "ratelimit:", sld_ratelimit }, -}; - -static struct ratelimit_state bld_ratelimit; - -static unsigned int sysctl_sld_mitigate = 1; -static DEFINE_SEMAPHORE(buslock_sem, 1); - -#ifdef CONFIG_PROC_SYSCTL -static struct ctl_table sld_sysctls[] = { - { - .procname = "split_lock_mitigate", - .data = &sysctl_sld_mitigate, - .maxlen = sizeof(unsigned int), - .mode = 0644, - .proc_handler = proc_douintvec_minmax, - .extra1 = SYSCTL_ZERO, - .extra2 = SYSCTL_ONE, - }, -}; - -static int __init sld_mitigate_sysctl_init(void) -{ - register_sysctl_init("kernel", sld_sysctls); - return 0; -} - -late_initcall(sld_mitigate_sysctl_init); -#endif - -static inline bool match_option(const char *arg, int arglen, const char *opt) -{ - int len = strlen(opt), ratelimit; - - if (strncmp(arg, opt, len)) - return false; - - /* - * Min ratelimit is 1 bus lock/sec. - * Max ratelimit is 1000 bus locks/sec. - */ - if (sscanf(arg, "ratelimit:%d", &ratelimit) == 1 && - ratelimit > 0 && ratelimit <= 1000) { - ratelimit_state_init(&bld_ratelimit, HZ, ratelimit); - ratelimit_set_flags(&bld_ratelimit, RATELIMIT_MSG_ON_RELEASE); - return true; - } - - return len == arglen; -} - -static bool split_lock_verify_msr(bool on) -{ - u64 ctrl, tmp; - - if (rdmsrl_safe(MSR_TEST_CTRL, &ctrl)) - return false; - if (on) - ctrl |= MSR_TEST_CTRL_SPLIT_LOCK_DETECT; - else - ctrl &= ~MSR_TEST_CTRL_SPLIT_LOCK_DETECT; - if (wrmsrl_safe(MSR_TEST_CTRL, ctrl)) - return false; - rdmsrl(MSR_TEST_CTRL, tmp); - return ctrl == tmp; -} - -static void __init sld_state_setup(void) -{ - enum split_lock_detect_state state = sld_warn; - char arg[20]; - int i, ret; - - if (!boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT) && - !boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) - return; - - ret = cmdline_find_option(boot_command_line, "split_lock_detect", - arg, sizeof(arg)); - if (ret >= 0) { - for (i = 0; i < ARRAY_SIZE(sld_options); i++) { - if (match_option(arg, ret, sld_options[i].option)) { - state = sld_options[i].state; - break; - } - } - } - sld_state = state; -} - -static void __init __split_lock_setup(void) -{ - if (!split_lock_verify_msr(false)) { - pr_info("MSR access failed: Disabled\n"); - return; - } - - rdmsrl(MSR_TEST_CTRL, msr_test_ctrl_cache); - - if (!split_lock_verify_msr(true)) { - pr_info("MSR access failed: Disabled\n"); - return; - } - - /* Restore the MSR to its cached value. */ - wrmsrl(MSR_TEST_CTRL, msr_test_ctrl_cache); - - setup_force_cpu_cap(X86_FEATURE_SPLIT_LOCK_DETECT); -} - -/* - * MSR_TEST_CTRL is per core, but we treat it like a per CPU MSR. Locking - * is not implemented as one thread could undo the setting of the other - * thread immediately after dropping the lock anyway. - */ -static void sld_update_msr(bool on) -{ - u64 test_ctrl_val = msr_test_ctrl_cache; - - if (on) - test_ctrl_val |= MSR_TEST_CTRL_SPLIT_LOCK_DETECT; - - wrmsrl(MSR_TEST_CTRL, test_ctrl_val); -} - -static void split_lock_init(void) -{ - /* - * #DB for bus lock handles ratelimit and #AC for split lock is - * disabled. - */ - if (sld_state == sld_ratelimit) { - split_lock_verify_msr(false); - return; - } - - if (cpu_model_supports_sld) - split_lock_verify_msr(sld_state != sld_off); -} - -static void __split_lock_reenable_unlock(struct work_struct *work) -{ - sld_update_msr(true); - up(&buslock_sem); -} - -static DECLARE_DELAYED_WORK(sl_reenable_unlock, __split_lock_reenable_unlock); - -static void __split_lock_reenable(struct work_struct *work) -{ - sld_update_msr(true); -} -static DECLARE_DELAYED_WORK(sl_reenable, __split_lock_reenable); - -/* - * If a CPU goes offline with pending delayed work to re-enable split lock - * detection then the delayed work will be executed on some other CPU. That - * handles releasing the buslock_sem, but because it executes on a - * different CPU probably won't re-enable split lock detection. This is a - * problem on HT systems since the sibling CPU on the same core may then be - * left running with split lock detection disabled. - * - * Unconditionally re-enable detection here. - */ -static int splitlock_cpu_offline(unsigned int cpu) -{ - sld_update_msr(true); - - return 0; -} - -static void split_lock_warn(unsigned long ip) -{ - struct delayed_work *work; - int cpu; - - if (!current->reported_split_lock) - pr_warn_ratelimited("#AC: %s/%d took a split_lock trap at address: 0x%lx\n", - current->comm, current->pid, ip); - current->reported_split_lock = 1; - - if (sysctl_sld_mitigate) { - /* - * misery factor #1: - * sleep 10ms before trying to execute split lock. - */ - if (msleep_interruptible(10) > 0) - return; - /* - * Misery factor #2: - * only allow one buslocked disabled core at a time. - */ - if (down_interruptible(&buslock_sem) == -EINTR) - return; - work = &sl_reenable_unlock; - } else { - work = &sl_reenable; - } - - cpu = get_cpu(); - schedule_delayed_work_on(cpu, work, 2); - - /* Disable split lock detection on this CPU to make progress */ - sld_update_msr(false); - put_cpu(); -} - -bool handle_guest_split_lock(unsigned long ip) -{ - if (sld_state == sld_warn) { - split_lock_warn(ip); - return true; - } - - pr_warn_once("#AC: %s/%d %s split_lock trap at address: 0x%lx\n", - current->comm, current->pid, - sld_state == sld_fatal ? "fatal" : "bogus", ip); - - current->thread.error_code = 0; - current->thread.trap_nr = X86_TRAP_AC; - force_sig_fault(SIGBUS, BUS_ADRALN, NULL); - return false; -} -EXPORT_SYMBOL_GPL(handle_guest_split_lock); - -static void bus_lock_init(void) -{ - u64 val; - - if (!boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) - return; - - rdmsrl(MSR_IA32_DEBUGCTLMSR, val); - - if ((boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT) && - (sld_state == sld_warn || sld_state == sld_fatal)) || - sld_state == sld_off) { - /* - * Warn and fatal are handled by #AC for split lock if #AC for - * split lock is supported. - */ - val &= ~DEBUGCTLMSR_BUS_LOCK_DETECT; - } else { - val |= DEBUGCTLMSR_BUS_LOCK_DETECT; - } - - wrmsrl(MSR_IA32_DEBUGCTLMSR, val); -} - -bool handle_user_split_lock(struct pt_regs *regs, long error_code) -{ - if ((regs->flags & X86_EFLAGS_AC) || sld_state == sld_fatal) - return false; - split_lock_warn(regs->ip); - return true; -} - -void handle_bus_lock(struct pt_regs *regs) -{ - switch (sld_state) { - case sld_off: - break; - case sld_ratelimit: - /* Enforce no more than bld_ratelimit bus locks/sec. */ - while (!__ratelimit(&bld_ratelimit)) - msleep(20); - /* Warn on the bus lock. */ - fallthrough; - case sld_warn: - pr_warn_ratelimited("#DB: %s/%d took a bus_lock trap at address: 0x%lx\n", - current->comm, current->pid, regs->ip); - break; - case sld_fatal: - force_sig_fault(SIGBUS, BUS_ADRALN, NULL); - break; - } -} - -/* - * CPU models that are known to have the per-core split-lock detection - * feature even though they do not enumerate IA32_CORE_CAPABILITIES. - */ -static const struct x86_cpu_id split_lock_cpu_ids[] __initconst = { - X86_MATCH_VFM(INTEL_ICELAKE_X, 0), - X86_MATCH_VFM(INTEL_ICELAKE_L, 0), - X86_MATCH_VFM(INTEL_ICELAKE_D, 0), - {} -}; - -static void __init split_lock_setup(struct cpuinfo_x86 *c) -{ - const struct x86_cpu_id *m; - u64 ia32_core_caps; - - if (boot_cpu_has(X86_FEATURE_HYPERVISOR)) - return; - - /* Check for CPUs that have support but do not enumerate it: */ - m = x86_match_cpu(split_lock_cpu_ids); - if (m) - goto supported; - - if (!cpu_has(c, X86_FEATURE_CORE_CAPABILITIES)) - return; - - /* - * Not all bits in MSR_IA32_CORE_CAPS are architectural, but - * MSR_IA32_CORE_CAPS_SPLIT_LOCK_DETECT is. All CPUs that set - * it have split lock detection. - */ - rdmsrl(MSR_IA32_CORE_CAPS, ia32_core_caps); - if (ia32_core_caps & MSR_IA32_CORE_CAPS_SPLIT_LOCK_DETECT) - goto supported; - - /* CPU is not in the model list and does not have the MSR bit: */ - return; - -supported: - cpu_model_supports_sld = true; - __split_lock_setup(); -} - -static void sld_state_show(void) -{ - if (!boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT) && - !boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT)) - return; - - switch (sld_state) { - case sld_off: - pr_info("disabled\n"); - break; - case sld_warn: - if (boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT)) { - pr_info("#AC: crashing the kernel on kernel split_locks and warning on user-space split_locks\n"); - if (cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, - "x86/splitlock", NULL, splitlock_cpu_offline) < 0) - pr_warn("No splitlock CPU offline handler\n"); - } else if (boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) { - pr_info("#DB: warning on user-space bus_locks\n"); - } - break; - case sld_fatal: - if (boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT)) { - pr_info("#AC: crashing the kernel on kernel split_locks and sending SIGBUS on user-space split_locks\n"); - } else if (boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) { - pr_info("#DB: sending SIGBUS on user-space bus_locks%s\n", - boot_cpu_has(X86_FEATURE_SPLIT_LOCK_DETECT) ? - " from non-WB" : ""); - } - break; - case sld_ratelimit: - if (boot_cpu_has(X86_FEATURE_BUS_LOCK_DETECT)) - pr_info("#DB: setting system wide bus lock rate limit to %u/sec\n", bld_ratelimit.burst); - break; - } -} - -void __init sld_setup(struct cpuinfo_x86 *c) -{ - split_lock_setup(c); - sld_state_setup(); - sld_state_show(); -} - #define X86_HYBRID_CPU_TYPE_ID_SHIFT 24 /** diff --git a/include/linux/sched.h b/include/linux/sched.h index d4cc144f72a3..2b16e5cfeb36 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -991,7 +991,7 @@ struct task_struct { #ifdef CONFIG_ARCH_HAS_CPU_PASID unsigned pasid_activated:1; #endif -#ifdef CONFIG_CPU_SUP_INTEL +#ifdef CONFIG_X86_BUS_LOCK_DETECT unsigned reported_split_lock:1; #endif #ifdef CONFIG_TASK_DELAY_ACCT diff --git a/kernel/fork.c b/kernel/fork.c index c1b343cba560..0b71fc9fa750 100644 --- a/kernel/fork.c +++ b/kernel/fork.c @@ -1182,7 +1182,7 @@ static struct task_struct *dup_task_struct(struct task_struct *orig, int node) tsk->active_memcg = NULL; #endif -#ifdef CONFIG_CPU_SUP_INTEL +#ifdef CONFIG_X86_BUS_LOCK_DETECT tsk->reported_split_lock = 0; #endif From patchwork Thu Aug 8 06:29:35 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ravi Bangoria X-Patchwork-Id: 13756990 Received: from NAM02-SN1-obe.outbound.protection.outlook.com (mail-sn1nam02on2050.outbound.protection.outlook.com [40.107.96.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B2B0C187856; Thu, 8 Aug 2024 06:31:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.107.96.50 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098678; cv=fail; b=Cly7YrFw1I2WnYaYm5Aqr3rCA2fuHDbXM10B7LVfQLAq/hq3Sp7GcBSiRxmUN+kkg+TIxfrPRWdVrQ2FnoUpMp0/U0WFkajn/scqFgnMTz7TQQNG22XOpt9mgcJoXVTmDTFxvOfPwUpIGpkOrMDQVCJpXW4Abvy2FFU+SZcukwY= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098678; c=relaxed/simple; bh=1h86h35Xg5dGdtM2vlbPZl8m7VT2yE7gO8kYOeB0LKM=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=nVEB2gJag+iEr7M7OvIjhRRheC921iP7TEArhNeTRb1WttR1WqAt5ghZn6MLleSTAcRUqldl/tHn4WW4Llm4WzBYCLKQvCqEhibtzHjoXB1OQsTOwrn9+Fhd1ItEPDBl1JDsFoGzCJQQzObKKA0YxpBGti9XHk+WFOEq7/5ozQc= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com; spf=fail smtp.mailfrom=amd.com; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b=PA8lhuc2; arc=fail smtp.client-ip=40.107.96.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=amd.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b="PA8lhuc2" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=GSvaB7PjSiHOtHoVJPbUMIKC7NmgGw+0fpUX2NqsYBO+SQYFazfkr7VBjEnn2Pp8szkQx0aoPbaOgginwzGkG0ES+aixRxXj0wXiBgT+tj0Z66hIGrkYQoDCIvfCQCHUFhGv7vreZAoHz9w/X3E7TfrzjBsPMmxHa204bvO2kTTvtZP5ag5jrrJISRnVPPoMKhkRMCt1GgXSjCEnR2jS/pmaIBDGByZyAsBBZY5oNzb0G9vq2nGWSN0aFEf7X49ft1xXsuS3BOulcrLg3dxj27/YHlSKoDGwmf/b8taOvEZjvK9y/7EyLzzBX7XStTihmO62FC2LTTBxMOYMwZi4HQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=vrN/hIW+1SUQESJawbX8KfRDUh7JL+yazdWLFHSH/QI=; b=TfgZZkEIErsIQAIA0pVsKVUc4Or9MjvFpqd1dvR9EtHvg6DDqh7WYSCHQlwSNcKptTuxsFFXk741R5es0Q9T2YSZmhEirRFlnO3HEisnoEUwoq+9tOKxOO8EozB9l7uSHLXNvh88Rtx6fTe7Mfi+y61CRUrMUJJeSKs1ILdgF1Tz0mshD1raWGZs/41jvXij6+OuxJazSGcwSqf4DaI1vwDGpc/1ygMvmkvGMys/l6UK/y/KsGt1zdNjAUgZzRXMnwq4tf7au8AzZn/nbdQJIksvSTtZhhejV4GThgjKhxUxEgdHpZ0rcGtTDg0pLML1fjcrQd7pdwMvfvScRbePgg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=linutronix.de smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=vrN/hIW+1SUQESJawbX8KfRDUh7JL+yazdWLFHSH/QI=; b=PA8lhuc2eJK5rkyZdXKHihNniAQD0vfkItmqyjO+FLBMyR3uRs7diJyToHxpqm3wt5v0Q05f6f6E3YhZb2DsMWx8tHVL26D15OmDWAkgsSrjCV3HsEDTF4ik59MokR1pRXoCbtsEXVBv7wwZoK/Bd5Rdeyz3nS6rkpNHBYbZ2Wo= Received: from BN8PR16CA0022.namprd16.prod.outlook.com (2603:10b6:408:4c::35) by CH2PR12MB4135.namprd12.prod.outlook.com (2603:10b6:610:7c::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7849.15; Thu, 8 Aug 2024 06:31:11 +0000 Received: from BN2PEPF000044A4.namprd02.prod.outlook.com (2603:10b6:408:4c:cafe::d0) by BN8PR16CA0022.outlook.office365.com (2603:10b6:408:4c::35) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7849.12 via Frontend Transport; Thu, 8 Aug 2024 06:31:11 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN2PEPF000044A4.mail.protection.outlook.com (10.167.243.155) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.7849.8 via Frontend Transport; Thu, 8 Aug 2024 06:31:11 +0000 Received: from BLR-L-RBANGORI.amd.com (10.180.168.240) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Thu, 8 Aug 2024 01:31:02 -0500 From: Ravi Bangoria To: , , , , , , , CC: , , , , , , , , , , , , , , , , , , , Subject: [PATCH v4 2/4] x86/bus_lock: Add support for AMD Date: Thu, 8 Aug 2024 06:29:35 +0000 Message-ID: <20240808062937.1149-3-ravi.bangoria@amd.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240808062937.1149-1-ravi.bangoria@amd.com> References: <20240808062937.1149-1-ravi.bangoria@amd.com> Precedence: bulk X-Mailing-List: kvm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-ClientProxiedBy: SATLEXMB04.amd.com (10.181.40.145) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN2PEPF000044A4:EE_|CH2PR12MB4135:EE_ X-MS-Office365-Filtering-Correlation-Id: 44432e38-2ab6-45cd-8a9d-08dcb773b1c1 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|82310400026|376014|7416014|36860700013|1800799024; X-Microsoft-Antispam-Message-Info: 7y2fyf93cdJ+YjmXsfuoz9ALgDOJ/TgaRKoavqU1B7Xd3vD0miCEmJ76v3SLbPQ03ESReqWOcigRTv1DK6pQ6KImmXaOTrdcXDj3vwt1wsqssXNfL9KY4Ly8eY4OZdbidX0dOi++9OGAOQBla+WF7kR7VUA/wjn2RDpi8G4jHSJmPltl/MaxFvO8aOiMeimmeGiEc7Jd6ZlXDew/AMqzHETJ8RDNPDKpsNOtGsTgF8WcpXi3HzE+xJAvxAfIvQpMpsarMU7sjCDgG+O9R5wExEt7KvdppZuDYwDPUk2tCLOE6RfvlIVaGgUnDQIZNWVx4eJt19aQAkwftXGYLOkpKKK+ioEPICX9vArhAIeoN9c96nEjafueGYx/SN5oq/LgF7tN9rh5X+P7Q+hCxUoy3vixZD89T2YFFdCVKfhUNqGfnUB7gmMIf2xCykvTkj6UEbKpa3pzByVPSvgUD4FjNcppo8Pjdb2Nmvla/2qMA45iC42qzKYAzNlrUdFZ1kxUXu9+XKOvm45vSw8+6PwLIecMECykGqYGkr7BeRueSFRcrAHPZrVtTM7UORNqaeKEndW+dBNrGFxaW5xNEcFqLkNt5nhhrQE8I4Y4/SrgCoWHjQZ/vvus2/Insnm8MalT/F19AgeujsPqq4N2zMzIZAAwCWI+RT3IQpMrSe+2/fwESNqMJIW93Trjy2lagZfPrJRqutEQjXoaNuT/WEa3IfKuHSB8bQcuaFcJYbMDXvVPxMr8dend4ltHzmAN+dYoDpw0xu2i1M5sGBa5mhS9hKSoqsBvP6Ky0SpllxrfIk5TFnNtwFEhxnLhWtvtqbaAfo9aUVLMNmRQzPBDZN+FJBTAmtw4+btnj+GTim8kQ5SmGtxS8t95CWpGLgCAoMv+2eTmnbtqJN9I8B0r/BO5L+Nv5mTwWdJHayVgOD9kp8Qrs2H+n13pRXI+cxlg8v74mjS6Vt3Zv+sR0DL3UOPU8XepHoabuFl/DzAMZDkbSz2pufacEeM3A8zC68EE629fevQ0fMIb1rhIEJq8e4VdTJ2IYs5yIrOY7SZM6R+HPtWsPLwydmpJx+cR4eyDCNbLNy3jYqhFUvDaGBc8c3PATMJuVk2GQUaiBDy1q0+wp/OESqW+ZMqYYSzGyb/1J1xDhKVvE7dUCs4WKAkyjvBPJv/itJx/Qy+4SveKPWMMS+Suq+OhaxZ+Zh/RnnlJuekwFHh1qhcS4vNsPLSalQGg5AEruVTdC4/IOcb78mV/rY78hPJkbYpRA02j3Qyc7/JIVhhcFvZoJfCZhr1cOa0WNJzxrpwg/lIrSYYynv/dVBCAK5TmZ1/pPsA3TiBqlEC6WjXj0nhWfYUn05T+HkUAaYb1/C0QgMuZWg1/zsRJH64QWogOeM+RkqcdICz3dsGg3X6vgJlcJfTHmoDflQRvYg== X-Forefront-Antispam-Report: CIP:165.204.84.17;CTRY:US;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:SATLEXMB04.amd.com;PTR:InfoDomainNonexistent;CAT:NONE;SFS:(13230040)(82310400026)(376014)(7416014)(36860700013)(1800799024);DIR:OUT;SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Aug 2024 06:31:11.0047 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 44432e38-2ab6-45cd-8a9d-08dcb773b1c1 X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.17];Helo=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN2PEPF000044A4.namprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: CH2PR12MB4135 Add Bus Lock Detect (called Bus Lock Trap in AMD docs) support for AMD platforms. Bus Lock Detect is enumerated with CPUID Fn0000_0007_ECX_x0 bit [24 / BUSLOCKTRAP]. It can be enabled through MSR_IA32_DEBUGCTLMSR. When enabled, hardware clears DR6[11] and raises a #DB exception on occurrence of Bus Lock if CPL > 0. More detail about the feature can be found in AMD APM[1]. [1]: AMD64 Architecture Programmer's Manual Pub. 40332, Rev. 4.07 - June 2023, Vol 2, 13.1.3.6 Bus Lock Trap https://bugzilla.kernel.org/attachment.cgi?id=304653 Signed-off-by: Ravi Bangoria Reviewed-by: Tom Lendacky --- Documentation/arch/x86/buslock.rst | 3 ++- arch/x86/Kconfig | 2 +- arch/x86/kernel/cpu/common.c | 2 ++ arch/x86/kernel/cpu/intel.c | 1 - 4 files changed, 5 insertions(+), 3 deletions(-) diff --git a/Documentation/arch/x86/buslock.rst b/Documentation/arch/x86/buslock.rst index 4c5a4822eeb7..31f1bfdff16f 100644 --- a/Documentation/arch/x86/buslock.rst +++ b/Documentation/arch/x86/buslock.rst @@ -26,7 +26,8 @@ Detection ========= Intel processors may support either or both of the following hardware -mechanisms to detect split locks and bus locks. +mechanisms to detect split locks and bus locks. Some AMD processors also +support bus lock detect. #AC exception for split lock detection -------------------------------------- diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index db2aad850a8f..d422247b2882 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -2429,7 +2429,7 @@ source "kernel/livepatch/Kconfig" config X86_BUS_LOCK_DETECT bool "Split Lock Detect and Bus Lock Detect support" - depends on CPU_SUP_INTEL + depends on CPU_SUP_INTEL || CPU_SUP_AMD default y help Enable Split Lock Detect and Bus Lock Detect functionalities. diff --git a/arch/x86/kernel/cpu/common.c b/arch/x86/kernel/cpu/common.c index d4e539d4e158..a37670e1ab4d 100644 --- a/arch/x86/kernel/cpu/common.c +++ b/arch/x86/kernel/cpu/common.c @@ -1832,6 +1832,8 @@ static void identify_cpu(struct cpuinfo_x86 *c) if (this_cpu->c_init) this_cpu->c_init(c); + bus_lock_init(); + /* Disable the PN if appropriate */ squash_the_stupid_serial_number(c); diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c index 8a483f4ad026..799f18545c6e 100644 --- a/arch/x86/kernel/cpu/intel.c +++ b/arch/x86/kernel/cpu/intel.c @@ -610,7 +610,6 @@ static void init_intel(struct cpuinfo_x86 *c) init_intel_misc_features(c); split_lock_init(); - bus_lock_init(); intel_init_thermal(c); } From patchwork Thu Aug 8 06:29:36 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ravi Bangoria X-Patchwork-Id: 13756991 Received: from NAM11-DM6-obe.outbound.protection.outlook.com (mail-dm6nam11on2066.outbound.protection.outlook.com [40.107.223.66]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3E936187856; Thu, 8 Aug 2024 06:31:22 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.107.223.66 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098684; cv=fail; b=U6smyo/VBh92It65QfRGpC0NpO3BiwLeE707Tts4qTuJwN3amlRLbQWVXKCTORnJX84W/vwybEr6ByoiioeQqVn3uwyyUg7fIkHb/ucr6kiw1Xh73c4wb99xNBCiVrZJLtY6Kh66adKe/Cjh+GbU7CkdtPuUQ9uFQng4/AwLuI8= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098684; c=relaxed/simple; bh=Ogmxi5g5anKwOGIqIDotel9U9SR7utOELpTVBxZgcDw=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=PbanOssZw22G0WCmjlDTZWhj4oF748BdNlMe/WwjFs4aF9QJlTRE3aWiQNTa2lZ2kkkXMVgD4Kc/KU1kWUiy1VXuvWhG7rmByLDMHM8e9UohNH2T4i9RKNjd1PK08pu0YsLu2bO7PkYHAV6EX0gMGfqzzffyB3QcVYu6Yz6FkYA= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com; spf=fail smtp.mailfrom=amd.com; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b=MzMYBlvJ; arc=fail smtp.client-ip=40.107.223.66 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=amd.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b="MzMYBlvJ" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=I2lOC1slQO/qOnU9D7skX7QcqrUifrWwCPK0+yATi9zplWKuHpVc7I2h47aN3atKGyzk08E4gqYDn5ovT7IwENsoRCqids025XiPSagvIEmih3nK/3W1hGBuZPnT/HbEEG17PnnCBc/h3GIgR5XmAovndIfxJQ+fPEXV2jOYeDI8qET8Ao1F9IbOl1b3lbHgO2uTyp/W2VXSXnGJcuOv4S1TUnxfXNc713Ck7afiP4H5O8j4BKutYKLGKG8yeu/RyILckgpMswLEtv8abJpv83Y56I03baSIeh2aFGojHM6o7t52uafM0urMj0a8CCUtBprFaB3nk0Tl5gaYjs6nUA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=TDJMMEI+mWun6BZ2XcxL8y5gYRmVwcdbVagt2DLFMro=; b=fF5IQLI2hoqPqLhAQyH5mOcc0unSQ+2wUFAYRJHHCHJoDJPP0NHCvUoAN6J9OO9r1qSN5m1ZxHk/UKyLa/pyp0y4ONeKTeZbkvJn6J8FUBC/Rr+nPbuhkY1iZp/hMjztWv38XL2Sx1DRWrGc0zyasZeoIZKlvDE7WZtM0mc4Fq4sQD8ybKewj9LDA1Gqd6j9N3//+c4XWxGUkxNE9gBFTk1w7v4pITg80LacDt2UDLTBKhbibpRna73H/XL8Cdn2rmG6AeavNNSiVfUelCI6Sw5EU5bxYxNAEAy/idl3Ne0+tD/fo1xYc7a9BZJox63MMDP7pua/Cw98HBYJkFvEjw== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=linutronix.de smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=TDJMMEI+mWun6BZ2XcxL8y5gYRmVwcdbVagt2DLFMro=; b=MzMYBlvJCg4xZQ6JfftgXRNv6eWwx41y/o/S2HYZqB9hxzwJJDW+AcimmDReK4JxaS8wsewxEhYDWpkr7584kdT+y9CodbwJTQDvFoFaV0jnt0d9eGGBQW4TZXOUe4SyzepwmBvcf6hL/uxVkgKBPAmtHlbgs0Jqn7n0XENMPTM= Received: from BN9PR03CA0327.namprd03.prod.outlook.com (2603:10b6:408:112::32) by PH8PR12MB6964.namprd12.prod.outlook.com (2603:10b6:510:1bf::13) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.23; Thu, 8 Aug 2024 06:31:19 +0000 Received: from BN2PEPF000044A3.namprd02.prod.outlook.com (2603:10b6:408:112:cafe::6c) by BN9PR03CA0327.outlook.office365.com (2603:10b6:408:112::32) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7828.30 via Frontend Transport; Thu, 8 Aug 2024 06:31:19 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN2PEPF000044A3.mail.protection.outlook.com (10.167.243.154) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.7849.8 via Frontend Transport; Thu, 8 Aug 2024 06:31:19 +0000 Received: from BLR-L-RBANGORI.amd.com (10.180.168.240) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Thu, 8 Aug 2024 01:31:10 -0500 From: Ravi Bangoria To: , , , , , , , CC: , , , , , , , , , , , , , , , , , , , Subject: [PATCH v4 3/4] KVM: SVM: Don't advertise Bus Lock Detect to guest if SVM support is missing Date: Thu, 8 Aug 2024 06:29:36 +0000 Message-ID: <20240808062937.1149-4-ravi.bangoria@amd.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240808062937.1149-1-ravi.bangoria@amd.com> References: <20240808062937.1149-1-ravi.bangoria@amd.com> Precedence: bulk X-Mailing-List: kvm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-ClientProxiedBy: SATLEXMB04.amd.com (10.181.40.145) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN2PEPF000044A3:EE_|PH8PR12MB6964:EE_ X-MS-Office365-Filtering-Correlation-Id: 6792c51b-a24a-4513-aa7d-08dcb773b685 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|82310400026|7416014|36860700013|376014|1800799024; X-Microsoft-Antispam-Message-Info: LrbkqD/7op45nd9iN3wqmkmKiLjv5iVCj4hT7jg8DqTndsWpAvAY3IsTS/doFVRe8cQ+WFMaATeA3Dnm8aKJRs+rMWo2dYxjY8SSyWtglwQrcrv61o+j4ZSXCo6cOeLxRvd36rhhRJOZtpgoNtOFhpeIgqVkQu73VuGYiCWunzraqwSHfwNion8BVagh8Ik8pmq7ls95YthSkqPu1xyvkEukFmw9jJ192F+ru4gO/H+C+WjBRq2aszgzBWC4KBiSdsuvODmfm5DCjDpR8ycN+PlFeKBA8tpuqAIMmDrrfARg7IexIWupFUF4PK4AACiuBsl1B/HYvCstBIXJ30YBqHQ9CCZ6C+yqPo4etAmCKUtG4pr/g8H0g6m2fOEtzjLFhO4j+Fkn0zBKhvEzZ/d5sXK4vw5xTbXtkqFRdgHCHBLemasEUIyTf2kNY0MRKaz7g3JyhTnwL2pC57f2Wc6xZVbCRf96CrSzSFW4nJWCL6nBC7cWHcFzU+NYR1J8ZTybh3cp07tctpmP//BTdS4omi2prJhwuI6WSZx/HlOxMXcgiEmeGnuzy2VdrvDdJ9AfiF+3R7lPHPV+3pirPQWwXovqptgYKQFJjMQhhLx2ruqwhxOPYVa7pz6OJc5nQoHbD25e8tT8ctHY4AnZ5XFlMiZS46Kif8prQN8Wgb++T+S3n27A8fl5quOsRFL1zJ2h3L9wqWW/YXI9dEoRXsXloTfs9KGbc+qfEXlIeAy64JdDmh3yPk8jL273f2YULxmeOipOvIyExjEnaIUN/wnf9lFtwNpxG9Q+UOGyq05osYVvOARGwkH3qbqyhEtQYyKZIYUMj6xSb77xV9l8vKMD1Xm/MCIB2jULHhanmE77ZU6Xo4G//hanEhH3jJL+/6/zHWdmgZri69jLe8QFqE36xnBrngs0CZ2OTq6nMHRDKlEIPaU94U+amJapD7tKDe591iZuJIZBFJjtlyEVHnUA+GLd3ZC56hMQ7QSXV/XGU5ATTF/65FbTFVU0FSTUN5eURs2xD0TSzubvVZh4T8g2Av6SiiD9u3qeUGFUQdswvVE8dsxkohI8JmMLAMJnzniaIiXBhj/mp9kIBVkwmbveWwmjK1U8WDQhSSYtBQ8F8wFR0osuAtWG0PlnSq2z15ZK5NUKSiAZFlRt6BDE6BfVqHqHsOUBm+4iJQhWwo+1tDASNvyxTAJ6aqRBG9lcLvxl+8CedkNaPrXTRjReNS3ByeOMBavL4mgIcIHhgZVtf3pc8vWT+wAbAQW1V/kAK1KPdgtNq62D99S3BEx30HfwnqFmoVPJj5W16/gIMYPK1MHoMTgH2eUrN/0q69I0sF92A3974cM32zY2iVRcfIzk9aZadT5jZ8k5fKADeR8tU8DOZmwBFkmXqlL56D8IdD9vazrdbcDtv5u3+Aqhoowa9g== X-Forefront-Antispam-Report: CIP:165.204.84.17;CTRY:US;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:SATLEXMB04.amd.com;PTR:InfoDomainNonexistent;CAT:NONE;SFS:(13230040)(82310400026)(7416014)(36860700013)(376014)(1800799024);DIR:OUT;SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Aug 2024 06:31:19.0320 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 6792c51b-a24a-4513-aa7d-08dcb773b685 X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.17];Helo=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN2PEPF000044A3.namprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PH8PR12MB6964 If host supports Bus Lock Detect, KVM advertises it to guests even if SVM support is absent. Additionally, guest wouldn't be able to use it despite guest CPUID bit being set. Fix it by unconditionally clearing the feature bit in KVM cpu capability. Reported-by: Jim Mattson Closes: https://lore.kernel.org/r/CALMp9eRet6+v8Y1Q-i6mqPm4hUow_kJNhmVHfOV8tMfuSS=tVg@mail.gmail.com Fixes: 76ea438b4afc ("KVM: X86: Expose bus lock debug exception to guest") Cc: stable@vger.kernel.org Signed-off-by: Ravi Bangoria Reviewed-by: Jim Mattson Reviewed-by: Tom Lendacky --- arch/x86/kvm/svm/svm.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c index d6f252555ab3..e1b6a16e97c0 100644 --- a/arch/x86/kvm/svm/svm.c +++ b/arch/x86/kvm/svm/svm.c @@ -5224,6 +5224,9 @@ static __init void svm_set_cpu_caps(void) /* CPUID 0x8000001F (SME/SEV features) */ sev_set_cpu_caps(); + + /* Don't advertise Bus Lock Detect to guest if SVM support is absent */ + kvm_cpu_cap_clear(X86_FEATURE_BUS_LOCK_DETECT); } static __init int svm_hardware_setup(void) From patchwork Thu Aug 8 06:29:37 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ravi Bangoria X-Patchwork-Id: 13756992 Received: from NAM02-BN1-obe.outbound.protection.outlook.com (mail-bn1nam02on2050.outbound.protection.outlook.com [40.107.212.50]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 13D1318784B; Thu, 8 Aug 2024 06:31:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=fail smtp.client-ip=40.107.212.50 ARC-Seal: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098693; cv=fail; b=rJbr8awQFQ4Ed0ATBdKFoY89mdSXnKdG60DInfMzF5b7sCjIQvp9leItCsbSZu+ogEDantCr+nPYunxDekeHzEecu/3iYLn487nEQQv4soYCq2vrWMEQNEBBGzZ0pMbpvshQGVDwVC0VWblBNgTxWUN/7opVaK66rUx62eXGIpc= ARC-Message-Signature: i=2; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1723098693; c=relaxed/simple; bh=+xH53VYWSTPEXzDHcNyUPM+Zty8HhqwcoNvVDGckMZ0=; h=From:To:CC:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=c0fCD70ET99Kw13OC6GPA3rC8CI8muX+krZsI+MQdgrD9RcjpVUWmh8HnP45LuROD19RvnnyPs12sKW12tsYrZ+AELVmt4nSpk2FWZuQq9h7eawABS54K02x891S7d9+9MMC8WLL6hx5kmgrajnWGaHZBvACv2pm3c/xiEegAMI= ARC-Authentication-Results: i=2; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com; spf=fail smtp.mailfrom=amd.com; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b=avg5Depd; arc=fail smtp.client-ip=40.107.212.50 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=amd.com Authentication-Results: smtp.subspace.kernel.org; spf=fail smtp.mailfrom=amd.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=amd.com header.i=@amd.com header.b="avg5Depd" ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=KR2QEdJ7YP67/lUAoOmX+YFWAr/YxwddbAW+edUFpw4egTXD4nj52YFwyvqezsXB4dMI/sBmCBWHb9CPCM6H2YHj4dFyeSmAcDLNNKjlIXeZ4+lLZ57foT5GhYYgh89m1Pi5E4s7PsLPB72AFJkBZ5lbNM/8FivpG3CLRZuXMVi58Fk8L6HBQhKRznXMeCnwRrPFZgkAlHhPqX+io8JO+X3ucCGYFCKyiMtuAR8uahssPkBVOp6au7TEjDO/KTfFZwcChCPcl4NB/HbErrth/mK6x+kzp/u56OzrYHvuLHkgb2AGsc/LhZk6ZreRVbR9TdX4GSUsZJkOwU6mdUS9iw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=87cYDsUIkdLNCr9WdH65u17/VXmxFXlopUnfWjWIaqY=; b=POcjcmjnManaxh8RzBEl7GNoT2BQxQtDMpMyVhMTM+KMA+3rLN1QI8/sgWAJ8O12nMQPtcu5M/UMF6YrgobxZ99+glbH5YlSk5HI4faUDLCvdNbeIxXPrfAv55evMRgTQdIc/Ap/nJokbNWKIxj8h0tyWbGilGqn12ARvpSfx4yYVhnJ6ey8TmdAxGt67+5960fWQYaVeJz5rTUx3r5y1c40ReSDuFl66okP3dxOt8v8UKxvb9s5OjRy7Kou3r3V0ebTV2B9wiII5JMsAf3QuK8Aq7/fz8pN2uGni8lKs9Djtq06On4Hk08n57vRQKt8wo3kilkxcGFrBsZoq1lb9A== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass (sender ip is 165.204.84.17) smtp.rcpttodomain=linutronix.de smtp.mailfrom=amd.com; dmarc=pass (p=quarantine sp=quarantine pct=100) action=none header.from=amd.com; dkim=none (message not signed); arc=none (0) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amd.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=87cYDsUIkdLNCr9WdH65u17/VXmxFXlopUnfWjWIaqY=; b=avg5Depd58l0Tjkbc7emwaMO+2syWs6l+O5zS9JEzZLiFiNR85SoalRThWhcDZU/f8RZ06ws3zOIvd7g82kblFkv0eCKXnwKvlImjX/GiT4ML1qRl0pKkfr6+BrnnXz8cVIb8K8GLwyQej9cONbFvytSzeziGOd2jNgAjLCukhM= Received: from BN1PR10CA0009.namprd10.prod.outlook.com (2603:10b6:408:e0::14) by PH8PR12MB7208.namprd12.prod.outlook.com (2603:10b6:510:224::7) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7807.27; Thu, 8 Aug 2024 06:31:28 +0000 Received: from BN2PEPF0000449F.namprd02.prod.outlook.com (2603:10b6:408:e0:cafe::5c) by BN1PR10CA0009.outlook.office365.com (2603:10b6:408:e0::14) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.7849.13 via Frontend Transport; Thu, 8 Aug 2024 06:31:27 +0000 X-MS-Exchange-Authentication-Results: spf=pass (sender IP is 165.204.84.17) smtp.mailfrom=amd.com; dkim=none (message not signed) header.d=none;dmarc=pass action=none header.from=amd.com; Received-SPF: Pass (protection.outlook.com: domain of amd.com designates 165.204.84.17 as permitted sender) receiver=protection.outlook.com; client-ip=165.204.84.17; helo=SATLEXMB04.amd.com; pr=C Received: from SATLEXMB04.amd.com (165.204.84.17) by BN2PEPF0000449F.mail.protection.outlook.com (10.167.243.150) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.20.7849.8 via Frontend Transport; Thu, 8 Aug 2024 06:31:27 +0000 Received: from BLR-L-RBANGORI.amd.com (10.180.168.240) by SATLEXMB04.amd.com (10.181.40.145) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2507.39; Thu, 8 Aug 2024 01:31:18 -0500 From: Ravi Bangoria To: , , , , , , , CC: , , , , , , , , , , , , , , , , , , , Subject: [PATCH v4 4/4] KVM: SVM: Add Bus Lock Detect support Date: Thu, 8 Aug 2024 06:29:37 +0000 Message-ID: <20240808062937.1149-5-ravi.bangoria@amd.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240808062937.1149-1-ravi.bangoria@amd.com> References: <20240808062937.1149-1-ravi.bangoria@amd.com> Precedence: bulk X-Mailing-List: kvm@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-ClientProxiedBy: SATLEXMB04.amd.com (10.181.40.145) To SATLEXMB04.amd.com (10.181.40.145) X-EOPAttributedMessage: 0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BN2PEPF0000449F:EE_|PH8PR12MB7208:EE_ X-MS-Office365-Filtering-Correlation-Id: 8a538387-5f1b-4842-39f1-08dcb773bbae X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|82310400026|7416014|376014|1800799024|36860700013; X-Microsoft-Antispam-Message-Info: 5bD0jC/3hOoiGRwwEahKANyYXKIsFGKukl3SHFipYojyyZBcq6SUAX5yAbniHQ8mTCHsgojpLVek5sLfmpiW2xPXB3xXJTU4d2utzG3G+AXE2XGgLrs0e+acC2ndc2oIMsnfH1yYrGmfJsoxjcLK6WY3bFTVFmtt8RK4BQwGAiNq0UqmnQdDCF2HA/w0eSRdhhKsp0Rc40i8vqjDlixqNBisf0pB6wOz3vero6nmdxBpxQLvtdszIozv03TlKn65Nbk2tzPgLoSoTRp7rTEKq4/7SVLgPrTiG2u5El8Df6To+icn615dDajmjb1t1dnXceJiLDhziHmWy3Cn3+HUEnoMIXl4BH7TBjK8vKbsTBJyDW5BzMHgx9QJHr+1J/BizIPX73OWQQ2jeSURMPJ4paUzXuIzSvab8TQLZLJ8OQuVF+fHq69sJq+XxOF6/8+D4+B5I4eG6dyoYXm1SH6ljvIiVmYBYdqKtKpuyDwV/+8I9cho+hKFv8hIIeUjE0qSd2Jhwxbp664//5r8iCY/JNO7+V+SlBNPmZeFWlAXSIkywaTNiTwCoTht/oPutnH5Nu0SL+d1ulDgyziuEnn9I5tOrGcbx0FTDVYs0Jwk2ud0VY2UxOk1PhFfmaQvGp4PNZqBt5PnOmLHbr8zSLGBNK+WQTZ5AStWOPDDiROA8px02j27nWh6nmBONFpc2dA2oZnXu7MuW4cZQ+pfl4nKKsnz7Ik+/3mhDRtCs9YQWASrwVd5+ZgUuycWJAGev/TbZMfKpnsVFhGXCr+dunihT2c7pkvbQBvFPOhshvbYBzyVG+i7agC5vvQZcJ8vy1pJ58LBgFI4V3PGdmY8l4B5DAQT85v6vym7rS9RABKP1prx3/Z10Hn6TNSApGW+yu5dQxjtLupC65CwxIJlQBBNKVtvMJ5RWuSQlXyqpeaeQF4M6IEIQE0hO7w+gm9WTcogbcmwKSsRt3gFWgQMQZvDParqCCnTjLsPrwKY12sWLOWhYE/KTuu3UYhCP1+w8LFFQjY017t9QLZD1SxQ0HaslrPajcNE3RSzLddZwholXEr37G0IdtrVuQtNIhl9ymSSxAxhC1tQb1+h9YnKBuRAidyN9nfJnKAf1zNJqiq9YoAsq7Td0iz/IIJY93xRnsbmiel9TVI6uqgkW5vJ5mdqVKcEudNlL6jSNUz5mynAGNXOk/hywK4xF08pG3KkBNuwCTTxBJl1pGDK92R+zeJzIZWrAPh/C89bGi0o9jtYPOsF5kVlDs0ImexKuY7koHryGvXaI04jpkRBmZu4kiyRlSD2Vl/ekXzyXaLac6k34l3lLVEXirWOD05osYrZlKCCrMsopjPJfA3bcH9zExUETiEH4gTqReEG94YIo/8ut0So8OUEw/EbEvNrWFJVgtGiLgRvH9cczBhLOnxsGpmMUaDaGXlwGGdqz2XTNrHBesi3mKqKIFbBn9fz6R11FeoJ X-Forefront-Antispam-Report: CIP:165.204.84.17;CTRY:US;LANG:en;SCL:1;SRV:;IPV:CAL;SFV:NSPM;H:SATLEXMB04.amd.com;PTR:InfoDomainNonexistent;CAT:NONE;SFS:(13230040)(82310400026)(7416014)(376014)(1800799024)(36860700013);DIR:OUT;SFP:1101; X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 08 Aug 2024 06:31:27.7022 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 8a538387-5f1b-4842-39f1-08dcb773bbae X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-OriginalAttributedTenantConnectingIp: TenantId=3dd8961f-e488-4e60-8e11-a82d994e183d;Ip=[165.204.84.17];Helo=[SATLEXMB04.amd.com] X-MS-Exchange-CrossTenant-AuthSource: BN2PEPF0000449F.namprd02.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Anonymous X-MS-Exchange-CrossTenant-FromEntityHeader: HybridOnPrem X-MS-Exchange-Transport-CrossTenantHeadersStamped: PH8PR12MB7208 Add Bus Lock Detect support in AMD SVM. Bus Lock Detect is enabled through MSR_IA32_DEBUGCTLMSR and MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is enabled. Add this dependency in the SVM. Signed-off-by: Ravi Bangoria Reviewed-by: Tom Lendacky --- arch/x86/kvm/svm/nested.c | 3 ++- arch/x86/kvm/svm/svm.c | 17 ++++++++++++++--- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/arch/x86/kvm/svm/nested.c b/arch/x86/kvm/svm/nested.c index 6f704c1037e5..1df9158c72c1 100644 --- a/arch/x86/kvm/svm/nested.c +++ b/arch/x86/kvm/svm/nested.c @@ -586,7 +586,8 @@ static void nested_vmcb02_prepare_save(struct vcpu_svm *svm, struct vmcb *vmcb12 /* These bits will be set properly on the first execution when new_vmc12 is true */ if (unlikely(new_vmcb12 || vmcb_is_dirty(vmcb12, VMCB_DR))) { vmcb02->save.dr7 = svm->nested.save.dr7 | DR7_FIXED_1; - svm->vcpu.arch.dr6 = svm->nested.save.dr6 | DR6_ACTIVE_LOW; + /* DR6_RTM is a reserved bit on AMD and as such must be set to 1 */ + svm->vcpu.arch.dr6 = svm->nested.save.dr6 | DR6_FIXED_1 | DR6_RTM; vmcb_mark_dirty(vmcb02, VMCB_DR); } diff --git a/arch/x86/kvm/svm/svm.c b/arch/x86/kvm/svm/svm.c index e1b6a16e97c0..9f3d31a5d231 100644 --- a/arch/x86/kvm/svm/svm.c +++ b/arch/x86/kvm/svm/svm.c @@ -1047,7 +1047,8 @@ void svm_update_lbrv(struct kvm_vcpu *vcpu) { struct vcpu_svm *svm = to_svm(vcpu); bool current_enable_lbrv = svm->vmcb->control.virt_ext & LBR_CTL_ENABLE_MASK; - bool enable_lbrv = (svm_get_lbr_vmcb(svm)->save.dbgctl & DEBUGCTLMSR_LBR) || + u64 dbgctl_buslock_lbr = DEBUGCTLMSR_BUS_LOCK_DETECT | DEBUGCTLMSR_LBR; + bool enable_lbrv = (svm_get_lbr_vmcb(svm)->save.dbgctl & dbgctl_buslock_lbr) || (is_guest_mode(vcpu) && guest_can_use(vcpu, X86_FEATURE_LBRV) && (svm->nested.ctl.virt_ext & LBR_CTL_ENABLE_MASK)); @@ -3158,6 +3159,10 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) if (data & DEBUGCTL_RESERVED_BITS) return 1; + if ((data & DEBUGCTLMSR_BUS_LOCK_DETECT) && + !guest_cpuid_has(vcpu, X86_FEATURE_BUS_LOCK_DETECT)) + return 1; + svm_get_lbr_vmcb(svm)->save.dbgctl = data; svm_update_lbrv(vcpu); break; @@ -5225,8 +5230,14 @@ static __init void svm_set_cpu_caps(void) /* CPUID 0x8000001F (SME/SEV features) */ sev_set_cpu_caps(); - /* Don't advertise Bus Lock Detect to guest if SVM support is absent */ - kvm_cpu_cap_clear(X86_FEATURE_BUS_LOCK_DETECT); + /* + * LBR Virtualization must be enabled to support BusLockTrap inside the + * guest, since BusLockTrap is enabled through MSR_IA32_DEBUGCTLMSR and + * MSR_IA32_DEBUGCTLMSR is virtualized only if LBR Virtualization is + * enabled. + */ + if (!lbrv) + kvm_cpu_cap_clear(X86_FEATURE_BUS_LOCK_DETECT); } static __init int svm_hardware_setup(void)