perf lock contention: Update default map size to 16384

[platform/kernel/linux-starfive.git] / tools / perf / util / bpf_skel / lock_contention.bpf.c

diff --git a/tools/perf/util/bpf_skel/lock_contention.bpf.c b/tools/perf/util/bpf_skel/lock_contention.bpf.c
index e6007ea..f9d2d79 100644 (file)
--- a/tools/perf/util/bpf_skel/lock_contention.bpf.c
+++ b/tools/perf/util/bpf_skel/lock_contention.bpf.c
@@ -7,8 +7,8 @@
 
 #include "lock_data.h"
 
-/* default buffer size */
-#define MAX_ENTRIES  10240
+/* for collect_lock_syms().  4096 was rejected by the verifier */
+#define MAX_CPUS  1024
 
 /* lock contention flags from include/trace/events/lock.h */
 #define LCB_F_SPIN     (1U << 0)
@@ -58,6 +58,13 @@ struct {
 
 struct {
        __uint(type, BPF_MAP_TYPE_HASH);
+       __uint(key_size, sizeof(__u64));
+       __uint(value_size, sizeof(__u32));
+       __uint(max_entries, MAX_ENTRIES);
+} lock_syms SEC(".maps");
+
+struct {
+       __uint(type, BPF_MAP_TYPE_HASH);
        __uint(key_size, sizeof(__u32));
        __uint(value_size, sizeof(__u8));
        __uint(max_entries, 1);
@@ -92,6 +99,14 @@ struct rw_semaphore___new {
        atomic_long_t owner;
 } __attribute__((preserve_access_index));
 
+struct mm_struct___old {
+       struct rw_semaphore mmap_sem;
+} __attribute__((preserve_access_index));
+
+struct mm_struct___new {
+       struct rw_semaphore mmap_lock;
+} __attribute__((preserve_access_index));
+
 /* control flags */
 int enabled;
 int has_cpu;
@@ -106,7 +121,9 @@ int lock_owner;
 int aggr_mode;
 
 /* error stat */
-int lost;
+int task_fail;
+int stack_fail;
+int time_fail;
 
 static inline int can_record(u64 *ctx)
 {
@@ -182,7 +199,13 @@ static inline struct task_struct *get_lock_owner(__u64 lock, __u32 flags)
                struct mutex *mutex = (void *)lock;
                owner = BPF_CORE_READ(mutex, owner.counter);
        } else if (flags == LCB_F_READ || flags == LCB_F_WRITE) {
-#if __has_builtin(bpf_core_type_matches)
+       /*
+        * Support for the BPF_TYPE_MATCHES argument to the
+        * __builtin_preserve_type_info builtin was added at some point during
+        * development of clang 15 and it's what is needed for
+        * bpf_core_type_matches.
+        */
+#if __has_builtin(__builtin_preserve_type_info) && __clang_major__ >= 15
                if (bpf_core_type_matches(struct rw_semaphore___old)) {
                        struct rw_semaphore___old *rwsem = (void *)lock;
                        owner = (unsigned long)BPF_CORE_READ(rwsem, owner);
@@ -204,6 +227,41 @@ static inline struct task_struct *get_lock_owner(__u64 lock, __u32 flags)
        return task;
 }
 
+static inline __u32 check_lock_type(__u64 lock, __u32 flags)
+{
+       struct task_struct *curr;
+       struct mm_struct___old *mm_old;
+       struct mm_struct___new *mm_new;
+
+       switch (flags) {
+       case LCB_F_READ:  /* rwsem */
+       case LCB_F_WRITE:
+               curr = bpf_get_current_task_btf();
+               if (curr->mm == NULL)
+                       break;
+               mm_new = (void *)curr->mm;
+               if (bpf_core_field_exists(mm_new->mmap_lock)) {
+                       if (&mm_new->mmap_lock == (void *)lock)
+                               return LCD_F_MMAP_LOCK;
+                       break;
+               }
+               mm_old = (void *)curr->mm;
+               if (bpf_core_field_exists(mm_old->mmap_sem)) {
+                       if (&mm_old->mmap_sem == (void *)lock)
+                               return LCD_F_MMAP_LOCK;
+               }
+               break;
+       case LCB_F_SPIN:  /* spinlock */
+               curr = bpf_get_current_task_btf();
+               if (&curr->sighand->siglock == (void *)lock)
+                       return LCD_F_SIGHAND_LOCK;
+               break;
+       default:
+               break;
+       }
+       return 0;
+}
+
 SEC("tp_btf/contention_begin")
 int contention_begin(u64 *ctx)
 {
@@ -224,7 +282,7 @@ int contention_begin(u64 *ctx)
                bpf_map_update_elem(&tstamp, &pid, &zero, BPF_ANY);
                pelem = bpf_map_lookup_elem(&tstamp, &pid);
                if (pelem == NULL) {
-                       lost++;
+                       __sync_fetch_and_add(&task_fail, 1);
                        return 0;
                }
        }
@@ -237,7 +295,7 @@ int contention_begin(u64 *ctx)
                pelem->stack_id = bpf_get_stackid(ctx, &stacks,
                                                  BPF_F_FAST_STACK_CMP | stack_skip);
                if (pelem->stack_id < 0)
-                       lost++;
+                       __sync_fetch_and_add(&stack_fail, 1);
        } else if (aggr_mode == LOCK_AGGR_TASK) {
                struct task_struct *task;
 
@@ -281,6 +339,11 @@ int contention_end(u64 *ctx)
                return 0;
 
        duration = bpf_ktime_get_ns() - pelem->timestamp;
+       if ((__s64)duration < 0) {
+               bpf_map_delete_elem(&tstamp, &pid);
+               __sync_fetch_and_add(&time_fail, 1);
+               return 0;
+       }
 
        switch (aggr_mode) {
        case LOCK_AGGR_CALLER:
@@ -314,6 +377,9 @@ int contention_end(u64 *ctx)
                        .flags = pelem->flags,
                };
 
+               if (aggr_mode == LOCK_AGGR_ADDR)
+                       first.flags |= check_lock_type(pelem->lock, pelem->flags);
+
                bpf_map_update_elem(&lock_stat, &key, &first, BPF_NOEXIST);
                bpf_map_delete_elem(&tstamp, &pid);
                return 0;
@@ -332,4 +398,25 @@ int contention_end(u64 *ctx)
        return 0;
 }
 
+extern struct rq runqueues __ksym;
+
+SEC("raw_tp/bpf_test_finish")
+int BPF_PROG(collect_lock_syms)
+{
+       __u64 lock_addr;
+       __u32 lock_flag;
+
+       for (int i = 0; i < MAX_CPUS; i++) {
+               struct rq *rq = bpf_per_cpu_ptr(&runqueues, i);
+
+               if (rq == NULL)
+                       break;
+
+               lock_addr = (__u64)&rq->__lock;
+               lock_flag = LOCK_CLASS_RQLOCK;
+               bpf_map_update_elem(&lock_syms, &lock_addr, &lock_flag, BPF_ANY);
+       }
+       return 0;
+}
+
 char LICENSE[] SEC("license") = "Dual BSD/GPL";