x86/bus_lock: Set rate limit for bus lock

A bus lock can be thousands of cycles slower than atomic operation within
one cache line. It also disrupts performance on other cores. Malicious
users can generate multiple bus locks to degrade the whole system
performance.

The current mitigation is to kill the offending process, but for certain
scenarios it's desired to identify and throttle the offending application.

Add a system wide rate limit for bus locks. When the system detects bus
locks at a rate higher than N/sec (where N can be set by the kernel boot
argument in the range [1..1000]) any task triggering a bus lock will be
forced to sleep for at least 20ms until the overall system rate of bus
locks drops below the threshold.

Signed-off-by: Fenghua Yu <fenghua.yu@intel.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Tony Luck <tony.luck@intel.com>
Link: https://lore.kernel.org/r/20210419214958.4035512-3-fenghua.yu@intel.com

diff --git a/arch/x86/kernel/cpu/intel.c b/arch/x86/kernel/cpu/intel.c
index 8adffc1..7c23f03 100644 (file)
--- a/arch/x86/kernel/cpu/intel.c
+++ b/arch/x86/kernel/cpu/intel.c
@@ -10,6 +10,7 @@
 #include <linux/thread_info.h>
 #include <linux/init.h>
 #include <linux/uaccess.h>
+#include <linux/delay.h>
 
 #include <asm/cpufeature.h>
 #include <asm/msr.h>
@@ -41,6 +42,7 @@ enum split_lock_detect_state {
        sld_off = 0,
        sld_warn,
        sld_fatal,
+       sld_ratelimit,
 };
 
 /*
@@ -997,13 +999,30 @@ static const struct {
        { "off",        sld_off   },
        { "warn",       sld_warn  },
        { "fatal",      sld_fatal },
+       { "ratelimit:", sld_ratelimit },
 };
 
+static struct ratelimit_state bld_ratelimit;
+
 static inline bool match_option(const char *arg, int arglen, const char *opt)
 {
-       int len = strlen(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 && !strncmp(arg, opt, len);
+       return len == arglen;
 }
 
 static bool split_lock_verify_msr(bool on)
@@ -1082,6 +1101,15 @@ static void sld_update_msr(bool on)
 
 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);
 }
@@ -1154,6 +1182,12 @@ 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);
@@ -1259,6 +1293,10 @@ static void sld_state_show(void)
                                " 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;
        }
 }