Skip to contentSkip to conversation

x86, perf: Only allow rdpmc if a perf_event is mapped

PATCH 张静(长谷) 2 participants 6 messages Oct 27, 2014 – Oct 28, 2014

lore
Share & tools
lore
#0 lore raw
Quoted 127 lines

We currently allow any process to use rdpmc. This significantly weakens the protection offered by PR_TSC_DISABLED, and it could be helpful to users attempting to exploit timing attacks.

Since we can't enable access to individual counters, use a very coarse heuristic to limit access to rdpmc: allow access only when a perf_event is mmapped. This protects seccomp sandboxes.

There is plenty of room to further tighen these restrictions. For example, this allows rdpmc for any x86_pmu event, but it's only useful for self-monitoring tasks.

As a side effect, cap_user_rdpmc will now be false for AMD uncore events. This isn't a real regression, since .event_idx is disabled for these events anyway for the time being. Whenever that gets re-added, the cap_user_rdpmc code can be adjusted or refactored accordingly.

---
 arch/x86/include/asm/mmu.h         |  2 ++
 arch/x86/include/asm/mmu_context.h | 16 +++++++++++
 arch/x86/kernel/cpu/perf_event.c   | 57 +++++++++++++++++++++++++-------------
 arch/x86/kernel/cpu/perf_event.h   |  2 ++
 4 files changed, 58 insertions(+), 19 deletions(-)
arch/x86/include/asm/mmu.h +2 -0
index 876e74e8eec7..09b9620a73b4 100644
@@ -19,6 +19,8 @@ typedef struct {
 
 	struct mutex lock;
 	void __user *vdso;
+
+	atomic_t perf_rdpmc_allowed;	/* nonzero if rdpmc is allowed */
 } mm_context_t;
 
 #ifdef CONFIG_SMP
arch/x86/include/asm/mmu_context.h +16 -0
index 23697f74b372..ccad8d616038 100644
@@ -19,6 +19,18 @@ static inline void paravirt_activate_mm(struct mm_struct *prev,
 }
 #endif	/* !CONFIG_PARAVIRT */
 
+#ifdef CONFIG_PERF_EVENTS
+static inline void load_mm_cr4(struct mm_struct *mm)
+{
+	if (atomic_read(&mm->context.perf_rdpmc_allowed))
+		cr4_set_bits(X86_CR4_PCE);
+	else
+		cr4_clear_bits(X86_CR4_PCE);
+}
+#else
+static inline void load_mm_cr4(struct mm_struct *mm) {}
+#endif
+
 /*
  * Used for LDT copy/destruction.
  */
@@ -53,6 +65,9 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 		/* Stop flush ipis for the previous mm */
 		cpumask_clear_cpu(cpu, mm_cpumask(prev));
 
+		/* Load per-mm CR4 state */
+		load_mm_cr4(next);
+
 		/*
 		 * Load the LDT, if the LDT is different.
 		 *
@@ -88,6 +103,7 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
 			 */
 			load_cr3(next->pgd);
 			trace_tlb_flush(TLB_FLUSH_ON_TASK_SWITCH, TLB_FLUSH_ALL);
+			load_mm_cr4(next);
 			load_LDT_nolock(&next->context);
 		}
 	}
arch/x86/kernel/cpu/perf_event.c +19 -2
index 00fbab7aa587..3e875b3b30f2 100644
@@ -31,6 +31,7 @@
 #include <asm/nmi.h>
 #include <asm/smp.h>
 #include <asm/alternative.h>
+#include <asm/mmu_context.h>
 #include <asm/tlbflush.h>
 #include <asm/timer.h>
 #include <asm/desc.h>
@@ -1336,8 +1337,6 @@ x86_pmu_notifier(struct notifier_block *self, unsigned long action, void *hcpu)
 		break;
 
 	case CPU_STARTING:
-		if (x86_pmu.attr_rdpmc)
-			cr4_set_bits(X86_CR4_PCE);
 		if (x86_pmu.cpu_starting)
 			x86_pmu.cpu_starting(cpu);
 		break;
@@ -1813,14 +1812,44 @@ static int x86_pmu_event_init(struct perf_event *event)
 			event->destroy(event);
 	}
 
+	if (ACCESS_ONCE(x86_pmu.attr_rdpmc))
+		event->hw.flags |= PERF_X86_EVENT_RDPMC_ALLOWED;
+
 	return err;
 }
 
+static void refresh_pce(void *ignored)
+{
+	if (current->mm)
+		load_mm_cr4(current->mm);
+}
+
+static void x86_pmu_event_mapped(struct perf_event *event)
+{
+	if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
+		return;
+
+	if (atomic_inc_return(&current->mm->context.perf_rdpmc_allowed) == 1)
+		on_each_cpu_mask(mm_cpumask(current->mm), refresh_pce, NULL, 1);
+}
+

arch/x86/kernel/cpu/perf_event.c static int x86_pmu_event_init(struct perf_event *event) · line 1845

Quoted 10 lines
arch/x86/kernel/cpu/perf_event.c +10 -0
+static void x86_pmu_event_unmapped(struct perf_event *event)
+{
+	if (!current->mm)
+		return;
+
+	if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
+		return;
+
+	if (atomic_dec_and_test(&current->mm->context.perf_rdpmc_allowed))
+		on_each_cpu_mask(mm_cpumask(current->mm), refresh_pce, NULL, 1);

The current task(T-a on CPU A) is asking CPUs(A, B, C, D) to refresh pce, and looks the current task(T-d on CPU D) is disturbed if T-d loaded CR4 when going on CPU D.

Hillf

Quoted 76 lines
arch/x86/kernel/cpu/perf_event.c +9 -17
+}
+
 static int x86_pmu_event_idx(struct perf_event *event)
 {
 	int idx = event->hw.idx;
 
-	if (!x86_pmu.attr_rdpmc)
+	if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
 		return 0;
 
 	if (x86_pmu.num_counters_fixed && idx >= INTEL_PMC_IDX_FIXED) {
@@ -1838,16 +1867,6 @@ static ssize_t get_attr_rdpmc(struct device *cdev,
 	return snprintf(buf, 40, "%d\n", x86_pmu.attr_rdpmc);
 }
 
-static void change_rdpmc(void *info)
-{
-	bool enable = !!(unsigned long)info;
-
-	if (enable)
-		cr4_set_bits(X86_CR4_PCE);
-	else
-		cr4_clear_bits(X86_CR4_PCE);
-}
-
 static ssize_t set_attr_rdpmc(struct device *cdev,
 			      struct device_attribute *attr,
 			      const char *buf, size_t count)
@@ -1862,11 +1881,7 @@ static ssize_t set_attr_rdpmc(struct device *cdev,
 	if (x86_pmu.attr_rdpmc_broken)
 		return -ENOTSUPP;
 
-	if (!!val != !!x86_pmu.attr_rdpmc) {
-		x86_pmu.attr_rdpmc = !!val;
-		on_each_cpu(change_rdpmc, (void *)val, 1);
-	}
-
+	x86_pmu.attr_rdpmc = !!val;
 	return count;
 }
 
@@ -1909,6 +1924,9 @@ static struct pmu pmu = {
 
 	.event_init		= x86_pmu_event_init,
 
+	.event_mapped		= x86_pmu_event_mapped,
+	.event_unmapped		= x86_pmu_event_unmapped,
+
 	.add			= x86_pmu_add,
 	.del			= x86_pmu_del,
 	.start			= x86_pmu_start,
@@ -1930,7 +1948,8 @@ void arch_perf_update_userpage(struct perf_event *event,
 
 	userpg->cap_user_time = 0;
 	userpg->cap_user_time_zero = 0;
-	userpg->cap_user_rdpmc = x86_pmu.attr_rdpmc;
+	userpg->cap_user_rdpmc =
+		!!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED);
 	userpg->pmc_width = x86_pmu.cntval_bits;
 
 	if (!sched_clock_stable())
arch/x86/kernel/cpu/perf_event.h +2 -1
index d98a34d435d7..f6868186e67b 100644
@@ -71,6 +71,8 @@ struct event_constraint {
 #define PERF_X86_EVENT_COMMITTED	0x8 /* event passed commit_txn */
 #define PERF_X86_EVENT_PEBS_LD_HSW	0x10 /* haswell style datala, load */
 #define PERF_X86_EVENT_PEBS_NA_HSW	0x20 /* haswell style datala, unknown */
+#define PERF_X86_EVENT_RDPMC_ALLOWED	0x40 /* grant rdpmc permission */
+
 
 struct amd_nb {
 	int nb_id;  /* NorthBridge id */
--

1.9.3

#1 lore raw
Quoted 133 lines · 张静(长谷)
Quoted 133 lines

We currently allow any process to use rdpmc. This significantly weakens the protection offered by PR_TSC_DISABLED, and it could be helpful to users attempting to exploit timing attacks.

Since we can't enable access to individual counters, use a very coarse heuristic to limit access to rdpmc: allow access only when a perf_event is mmapped. This protects seccomp sandboxes.

There is plenty of room to further tighen these restrictions. For example, this allows rdpmc for any x86_pmu event, but it's only useful for self-monitoring tasks.

As a side effect, cap_user_rdpmc will now be false for AMD uncore events. This isn't a real regression, since .event_idx is disabled for these events anyway for the time being. Whenever that gets re-added, the cap_user_rdpmc code can be adjusted or refactored accordingly.

---
 arch/x86/include/asm/mmu.h         |  2 ++
 arch/x86/include/asm/mmu_context.h | 16 +++++++++++
 arch/x86/kernel/cpu/perf_event.c   | 57 +++++++++++++++++++++++++-------------
 arch/x86/kernel/cpu/perf_event.h   |  2 ++
 4 files changed, 58 insertions(+), 19 deletions(-)
arch/x86/include/asm/mmu.h +2 -0
index 876e74e8eec7..09b9620a73b4 100644
@@ -19,6 +19,8 @@ typedef struct {
 
      struct mutex lock;
      void __user *vdso;
+
+     atomic_t perf_rdpmc_allowed;    /* nonzero if rdpmc is allowed */
 } mm_context_t;
 
 #ifdef CONFIG_SMP
arch/x86/include/asm/mmu_context.h +16 -0
index 23697f74b372..ccad8d616038 100644
@@ -19,6 +19,18 @@ static inline void paravirt_activate_mm(struct mm_struct *prev,
 }
 #endif       /* !CONFIG_PARAVIRT */
 
+#ifdef CONFIG_PERF_EVENTS
+static inline void load_mm_cr4(struct mm_struct *mm)
+{
+     if (atomic_read(&mm->context.perf_rdpmc_allowed))
+             cr4_set_bits(X86_CR4_PCE);
+     else
+             cr4_clear_bits(X86_CR4_PCE);
+}
+#else
+static inline void load_mm_cr4(struct mm_struct *mm) {}
+#endif
+
 /*
  * Used for LDT copy/destruction.
  */
@@ -53,6 +65,9 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
              /* Stop flush ipis for the previous mm */
              cpumask_clear_cpu(cpu, mm_cpumask(prev));
 
+             /* Load per-mm CR4 state */
+             load_mm_cr4(next);
+
              /*
               * Load the LDT, if the LDT is different.
               *
@@ -88,6 +103,7 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
                       */
                      load_cr3(next->pgd);
                      trace_tlb_flush(TLB_FLUSH_ON_TASK_SWITCH, TLB_FLUSH_ALL);
+                     load_mm_cr4(next);
                      load_LDT_nolock(&next->context);
              }
      }
arch/x86/kernel/cpu/perf_event.c +24 -2
index 00fbab7aa587..3e875b3b30f2 100644
@@ -31,6 +31,7 @@
 #include <asm/nmi.h>
 #include <asm/smp.h>
 #include <asm/alternative.h>
+#include <asm/mmu_context.h>
 #include <asm/tlbflush.h>
 #include <asm/timer.h>
 #include <asm/desc.h>
@@ -1336,8 +1337,6 @@ x86_pmu_notifier(struct notifier_block *self, unsigned long action, void *hcpu)
              break;
 
      case CPU_STARTING:
-             if (x86_pmu.attr_rdpmc)
-                     cr4_set_bits(X86_CR4_PCE);
              if (x86_pmu.cpu_starting)
                      x86_pmu.cpu_starting(cpu);
              break;
@@ -1813,14 +1812,44 @@ static int x86_pmu_event_init(struct perf_event *event)
                      event->destroy(event);
      }
 
+     if (ACCESS_ONCE(x86_pmu.attr_rdpmc))
+             event->hw.flags |= PERF_X86_EVENT_RDPMC_ALLOWED;
+
      return err;
 }
 
+static void refresh_pce(void *ignored)
+{
+     if (current->mm)
+             load_mm_cr4(current->mm);
+}
+
+static void x86_pmu_event_mapped(struct perf_event *event)
+{
+     if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
+             return;
+
+     if (atomic_inc_return(&current->mm->context.perf_rdpmc_allowed) == 1)
+             on_each_cpu_mask(mm_cpumask(current->mm), refresh_pce, NULL, 1);
+}
+
+static void x86_pmu_event_unmapped(struct perf_event *event)
+{
+     if (!current->mm)
+             return;
+
Quoted 8 lines

arch/x86/kernel/cpu/perf_event.c static int x86_pmu_event_init(struct perf_event *event) · line 1845

Quoted 5 lines
arch/x86/kernel/cpu/perf_event.c +5 -0
+     if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
+             return;
+
+     if (atomic_dec_and_test(&current->mm->context.perf_rdpmc_allowed))
+             on_each_cpu_mask(mm_cpumask(current->mm), refresh_pce, NULL, 1);

The current task(T-a on CPU A) is asking CPUs(A, B, C, D) to refresh pce, and looks the current task(T-d on CPU D) is disturbed if T-d loaded CR4 when going on CPU D.

I don't understand. This code is intended to interrupt only affected tasks, except for a race if cpus switch mm while this code is running. At worst, the race should only result in an unnecessary IPI.

Can you clarify your concern?

--Andy

Quoted 79 lines

Hillf

Quoted 76 lines
arch/x86/kernel/cpu/perf_event.c +9 -17
+}
+
 static int x86_pmu_event_idx(struct perf_event *event)
 {
      int idx = event->hw.idx;
 
-     if (!x86_pmu.attr_rdpmc)
+     if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
              return 0;
 
      if (x86_pmu.num_counters_fixed && idx >= INTEL_PMC_IDX_FIXED) {
@@ -1838,16 +1867,6 @@ static ssize_t get_attr_rdpmc(struct device *cdev,
      return snprintf(buf, 40, "%d\n", x86_pmu.attr_rdpmc);
 }
 
-static void change_rdpmc(void *info)
-{
-     bool enable = !!(unsigned long)info;
-
-     if (enable)
-             cr4_set_bits(X86_CR4_PCE);
-     else
-             cr4_clear_bits(X86_CR4_PCE);
-}
-
 static ssize_t set_attr_rdpmc(struct device *cdev,
                            struct device_attribute *attr,
                            const char *buf, size_t count)
@@ -1862,11 +1881,7 @@ static ssize_t set_attr_rdpmc(struct device *cdev,
      if (x86_pmu.attr_rdpmc_broken)
              return -ENOTSUPP;
 
-     if (!!val != !!x86_pmu.attr_rdpmc) {
-             x86_pmu.attr_rdpmc = !!val;
-             on_each_cpu(change_rdpmc, (void *)val, 1);
-     }
-
+     x86_pmu.attr_rdpmc = !!val;
      return count;
 }
 
@@ -1909,6 +1924,9 @@ static struct pmu pmu = {
 
      .event_init             = x86_pmu_event_init,
 
+     .event_mapped           = x86_pmu_event_mapped,
+     .event_unmapped         = x86_pmu_event_unmapped,
+
      .add                    = x86_pmu_add,
      .del                    = x86_pmu_del,
      .start                  = x86_pmu_start,
@@ -1930,7 +1948,8 @@ void arch_perf_update_userpage(struct perf_event *event,
 
      userpg->cap_user_time = 0;
      userpg->cap_user_time_zero = 0;
-     userpg->cap_user_rdpmc = x86_pmu.attr_rdpmc;
+     userpg->cap_user_rdpmc =
+             !!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED);
      userpg->pmc_width = x86_pmu.cntval_bits;
 
      if (!sched_clock_stable())
arch/x86/kernel/cpu/perf_event.h +2 -1
index d98a34d435d7..f6868186e67b 100644
@@ -71,6 +71,8 @@ struct event_constraint {
 #define PERF_X86_EVENT_COMMITTED     0x8 /* event passed commit_txn */
 #define PERF_X86_EVENT_PEBS_LD_HSW   0x10 /* haswell style datala, load */
 #define PERF_X86_EVENT_PEBS_NA_HSW   0x20 /* haswell style datala, unknown */
+#define PERF_X86_EVENT_RDPMC_ALLOWED 0x40 /* grant rdpmc permission */
+
 
 struct amd_nb {
      int nb_id;  /* NorthBridge id */
--

1.9.3

#2 lore raw
Quoted 150 lines

-----Original Message-----
From: Andy Lutomirski [mailto:[email protected]]
Sent: Monday, October 27, 2014 11:45 PM
To: Hillf Danton
Cc: Peter Zijlstra; Ingo Molnar; Vince Weaver; Paul Mackerras; Kees Cook; Arnaldo Carvalho de Melo; Andrea Arcangeli; linux- [email protected]; Valdis Kletnieks
Subject: Re: [PATCH v2 7/8] x86, perf: Only allow rdpmc if a perf_event is mapped

Quoted 133 lines
Quoted 133 lines

We currently allow any process to use rdpmc. This significantly weakens the protection offered by PR_TSC_DISABLED, and it could be helpful to users attempting to exploit timing attacks.

Since we can't enable access to individual counters, use a very coarse heuristic to limit access to rdpmc: allow access only when a perf_event is mmapped. This protects seccomp sandboxes.

There is plenty of room to further tighen these restrictions. For example, this allows rdpmc for any x86_pmu event, but it's only useful for self-monitoring tasks.

As a side effect, cap_user_rdpmc will now be false for AMD uncore events. This isn't a real regression, since .event_idx is disabled for these events anyway for the time being. Whenever that gets re-added, the cap_user_rdpmc code can be adjusted or refactored accordingly.

---
 arch/x86/include/asm/mmu.h         |  2 ++
 arch/x86/include/asm/mmu_context.h | 16 +++++++++++
 arch/x86/kernel/cpu/perf_event.c   | 57 +++++++++++++++++++++++++-------------
 arch/x86/kernel/cpu/perf_event.h   |  2 ++
 4 files changed, 58 insertions(+), 19 deletions(-)
arch/x86/include/asm/mmu.h +2 -0
index 876e74e8eec7..09b9620a73b4 100644
@@ -19,6 +19,8 @@ typedef struct {
 
      struct mutex lock;
      void __user *vdso;
+
+     atomic_t perf_rdpmc_allowed;    /* nonzero if rdpmc is allowed */
 } mm_context_t;
 
 #ifdef CONFIG_SMP
arch/x86/include/asm/mmu_context.h +16 -0
index 23697f74b372..ccad8d616038 100644
@@ -19,6 +19,18 @@ static inline void paravirt_activate_mm(struct mm_struct *prev,
 }
 #endif       /* !CONFIG_PARAVIRT */
 
+#ifdef CONFIG_PERF_EVENTS
+static inline void load_mm_cr4(struct mm_struct *mm)
+{
+     if (atomic_read(&mm->context.perf_rdpmc_allowed))
+             cr4_set_bits(X86_CR4_PCE);
+     else
+             cr4_clear_bits(X86_CR4_PCE);
+}
+#else
+static inline void load_mm_cr4(struct mm_struct *mm) {}
+#endif
+
 /*
  * Used for LDT copy/destruction.
  */
@@ -53,6 +65,9 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
              /* Stop flush ipis for the previous mm */
              cpumask_clear_cpu(cpu, mm_cpumask(prev));
 
+             /* Load per-mm CR4 state */
+             load_mm_cr4(next);
+
              /*
               * Load the LDT, if the LDT is different.
               *
@@ -88,6 +103,7 @@ static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
                       */
                      load_cr3(next->pgd);
                      trace_tlb_flush(TLB_FLUSH_ON_TASK_SWITCH, TLB_FLUSH_ALL);
+                     load_mm_cr4(next);
                      load_LDT_nolock(&next->context);
              }
      }
arch/x86/kernel/cpu/perf_event.c +24 -2
index 00fbab7aa587..3e875b3b30f2 100644
@@ -31,6 +31,7 @@
 #include <asm/nmi.h>
 #include <asm/smp.h>
 #include <asm/alternative.h>
+#include <asm/mmu_context.h>
 #include <asm/tlbflush.h>
 #include <asm/timer.h>
 #include <asm/desc.h>
@@ -1336,8 +1337,6 @@ x86_pmu_notifier(struct notifier_block *self, unsigned long action, void *hcpu)
              break;
 
      case CPU_STARTING:
-             if (x86_pmu.attr_rdpmc)
-                     cr4_set_bits(X86_CR4_PCE);
              if (x86_pmu.cpu_starting)
                      x86_pmu.cpu_starting(cpu);
              break;
@@ -1813,14 +1812,44 @@ static int x86_pmu_event_init(struct perf_event *event)
                      event->destroy(event);
      }
 
+     if (ACCESS_ONCE(x86_pmu.attr_rdpmc))
+             event->hw.flags |= PERF_X86_EVENT_RDPMC_ALLOWED;
+
      return err;
 }
 
+static void refresh_pce(void *ignored)
+{
+     if (current->mm)
+             load_mm_cr4(current->mm);
+}
+
+static void x86_pmu_event_mapped(struct perf_event *event)
+{
+     if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
+             return;
+
+     if (atomic_inc_return(&current->mm->context.perf_rdpmc_allowed) == 1)
+             on_each_cpu_mask(mm_cpumask(current->mm), refresh_pce, NULL, 1);
+}
+
+static void x86_pmu_event_unmapped(struct perf_event *event)
+{
+     if (!current->mm)
+             return;
+
Quoted 8 lines

arch/x86/kernel/cpu/perf_event.c static int x86_pmu_event_init(struct perf_event *event) · line 1845

Quoted 5 lines
arch/x86/kernel/cpu/perf_event.c +5 -0
+     if (!(event->hw.flags & PERF_X86_EVENT_RDPMC_ALLOWED))
+             return;
+
+     if (atomic_dec_and_test(&current->mm->context.perf_rdpmc_allowed))
+             on_each_cpu_mask(mm_cpumask(current->mm), refresh_pce, NULL, 1);

The current task(T-a on CPU A) is asking CPUs(A, B, C, D) to refresh pce, and looks the current task(T-d on CPU D) is disturbed if T-d loaded CR4 when going on CPU D.

Quoted 6 lines

I don't understand. This code is intended to interrupt only affected tasks, except for a race if cpus switch mm while this code is running. At worst, the race should only result in an unnecessary IPI.

Can you clarify your concern?

CPU D CPU A
switch_mm
load_mm_cr4
x86_pmu_event_unmapped

I wonder if the X86_CR4_PCE set on CPU D is
cleared by CPU A by broadcasting IPI.

Hillf

#3 lore raw
Quoted 8 lines · Hillf Danton
Quoted 8 lines

-----Original Message-----
From: Andy Lutomirski [mailto:[email protected]]
Sent: Monday, October 27, 2014 11:45 PM
To: Hillf Danton
Cc: Peter Zijlstra; Ingo Molnar; Vince Weaver; Paul Mackerras; Kees Cook; Arnaldo Carvalho de Melo; Andrea Arcangeli; linux- [email protected]; Valdis Kletnieks
Subject: Re: [PATCH v2 7/8] x86, perf: Only allow rdpmc if a perf_event is mapped

Quoted 8 lines

CPU D CPU A
switch_mm
load_mm_cr4
x86_pmu_event_unmapped

I wonder if the X86_CR4_PCE set on CPU D is
cleared by CPU A by broadcasting IPI.

It should be okay. The IPI does:

+ if (current->mm)
+ load_mm_cr4(current->mm);

which refers to the current task running on the targetted CPU, not to the IPI sender's task. So, if it happens after a context switch, it will harmlessly reload the new task's cr4.

refresh_pce can't happen in between switch_mm and updating current, since irqs are off for the entire duration of the context switch.

--Andy

#4 lore raw
Quoted 16 lines
Quoted 10 lines
Quoted 2 lines

Subject: Re: [PATCH v2 7/8] x86, perf: Only allow rdpmc if a perf_event is mapped

CPU D CPU A
switch_mm
load_mm_cr4
x86_pmu_event_unmapped

I wonder if the X86_CR4_PCE set on CPU D is
cleared by CPU A by broadcasting IPI.

It should be okay. The IPI does:

(quoted diff) +2 -0
+       if (current->mm)
+               load_mm_cr4(current->mm);
Quoted 4 lines

which refers to the current task running on the targetted CPU, not to the IPI sender's task. So, if it happens after a context switch, it will harmlessly reload the new task's cr4.

Right, but prev != next is checked in switch_mm.

Hillf

#5 lore raw
Quoted 13 lines · Hillf Danton
Quoted 13 lines
Quoted 10 lines
Quoted 2 lines

Subject: Re: [PATCH v2 7/8] x86, perf: Only allow rdpmc if a perf_event is mapped

CPU D CPU A
switch_mm
load_mm_cr4
x86_pmu_event_unmapped

I wonder if the X86_CR4_PCE set on CPU D is
cleared by CPU A by broadcasting IPI.

It should be okay. The IPI does:

Quoted 8 lines
Quoted 7 lines
(quoted diff) +2 -0
+       if (current->mm)
+               load_mm_cr4(current->mm);

which refers to the current task running on the targetted CPU, not to the IPI sender's task. So, if it happens after a context switch, it will harmlessly reload the new task's cr4.

Right, but prev != next is checked in switch_mm.

If that happens and !cpumask_test_cpu(cpu, mm_cpumask(next)), then cr4 will be reloaded. So, in the case you described, we should still be okay.

It's worth checking whether a more complicated race could be a problem. I think it's okay. Here's my argument.

In x86_pmu_event_mapped / x86_pmu_event_unmapped, for each cpu, either that cpu is set in mm_cpumask or it's clear. If it's set, then we'll send the IPI and that cpu is guaranteed to be updated. If it's clear, then it must become set before any user code in this mm can be executed. There are no paths through switch_mm that set the bit in mm_cpumask without reloading cr4, so we should be safe.

Is that convincing?

--Andy

Quoted 4 lines

Hillf

Signature · 2 lines
Andy Lutomirski
AMA Capital Management, LLC