Merge branch 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull perf fixes from Ingo Molnar:
 "Mostly tooling fixes, but also a couple of updates for new Intel
  models (which are technically hw-enablement, but to users it's a fix
  to perf behavior on those new CPUs - hope this is fine), an AUX
  inheritance fix, event time-sharing fix, and a fix for lost non-perf
  NMI events on AMD systems"

* 'perf-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (36 commits)
  perf/x86/cstate: Add Tiger Lake CPU support
  perf/x86/msr: Add Tiger Lake CPU support
  perf/x86/intel: Add Tiger Lake CPU support
  perf/x86/cstate: Update C-state counters for Ice Lake
  perf/x86/msr: Add new CPU model numbers for Ice Lake
  perf/x86/cstate: Add Comet Lake CPU support
  perf/x86/msr: Add Comet Lake CPU support
  perf/x86/intel: Add Comet Lake CPU support
  perf/x86/amd: Change/fix NMI latency mitigation to use a timestamp
  perf/core: Fix corner case in perf_rotate_context()
  perf/core: Rework memory accounting in perf_mmap()
  perf/core: Fix inheritance of aux_output groups
  perf annotate: Don't return -1 for error when doing BPF disassembly
  perf annotate: Return appropriate error code for allocation failures
  perf annotate: Fix arch specific ->init() failure errors
  perf annotate: Propagate the symbol__annotate() error return
  perf annotate: Fix the signedness of failure returns
  perf annotate: Propagate perf_env__arch() error
  perf evsel: Fall back to global 'perf_env' in perf_evsel__env()
  perf tools: Propagate get_cpuid() error
  ...

1 files changed, 36 insertions, 7 deletions

diff --git a/kernel/events/core.c b/kernel/events/core.c
index 3f0cb82e4fbc..9ec0b0bfddbd 100644
--- a/kernel/events/core.c
+++ b/kernel/events/core.c
@@ -3779,11 +3779,23 @@ static void rotate_ctx(struct perf_event_context *ctx, struct perf_event *event)
         perf_event_groups_insert(&ctx->flexible_groups, event);
 }
 
+/* pick an event from the flexible_groups to rotate */
 static inline struct perf_event *
-ctx_first_active(struct perf_event_context *ctx)
+ctx_event_to_rotate(struct perf_event_context *ctx)
 {
-        return list_first_entry_or_null(&ctx->flexible_active,
-                                        struct perf_event, active_list);
+        struct perf_event *event;
+
+        /* pick the first active flexible event */
+        event = list_first_entry_or_null(&ctx->flexible_active,
+                                         struct perf_event, active_list);
+
+        /* if no active flexible event, pick the first event */
+        if (!event) {
+                event = rb_entry_safe(rb_first(&ctx->flexible_groups.tree),
+                                      typeof(*event), group_node);
+        }
+
+        return event;
 }
 
 static bool perf_rotate_context(struct perf_cpu_context *cpuctx)
@@ -3808,9 +3820,9 @@ static bool perf_rotate_context(struct perf_cpu_context *cpuctx)
         perf_pmu_disable(cpuctx->ctx.pmu);
 
         if (task_rotate)
-                task_event = ctx_first_active(task_ctx);
+                task_event = ctx_event_to_rotate(task_ctx);
         if (cpu_rotate)
-                cpu_event = ctx_first_active(&cpuctx->ctx);
+                cpu_event = ctx_event_to_rotate(&cpuctx->ctx);
 
         /*
          * As per the order given at ctx_resched() first 'pop' task flexible
@@ -5668,7 +5680,8 @@ again:
          * undo the VM accounting.
          */
 
-        atomic_long_sub((size >> PAGE_SHIFT) + 1, &mmap_user->locked_vm);
+        atomic_long_sub((size >> PAGE_SHIFT) + 1 - mmap_locked,
+                        &mmap_user->locked_vm);
         atomic64_sub(mmap_locked, &vma->vm_mm->pinned_vm);
         free_uid(mmap_user);
 
@@ -5812,8 +5825,20 @@ accounting:
 
         user_locked = atomic_long_read(&user->locked_vm) + user_extra;
 
-        if (user_locked > user_lock_limit)
+        if (user_locked <= user_lock_limit) {
+                /* charge all to locked_vm */
+        } else if (atomic_long_read(&user->locked_vm) >= user_lock_limit) {
+                /* charge all to pinned_vm */
+                extra = user_extra;
+                user_extra = 0;
+        } else {
+                /*
+                 * charge locked_vm until it hits user_lock_limit;
+                 * charge the rest from pinned_vm
+                 */
                 extra = user_locked - user_lock_limit;
+                user_extra -= extra;
+        }
 
         lock_limit = rlimit(RLIMIT_MEMLOCK);
         lock_limit >>= PAGE_SHIFT;
@@ -11862,6 +11887,10 @@ static int inherit_group(struct perf_event *parent_event,
                                             child, leader, child_ctx);
                 if (IS_ERR(child_ctr))
                         return PTR_ERR(child_ctr);
+
+                if (sub->aux_event == parent_event &&
+                    !perf_get_aux_event(child_ctr, leader))
+                        return -EINVAL;
         }
         return 0;
 }