lock-contention.c

  1// SPDX-License-Identifier: GPL-2.0
  2#include "debug.h"
  3#include "env.h"
  4#include "lock-contention.h"
  5#include "machine.h"
  6#include "symbol.h"
  7
  8#include <limits.h>
  9#include <string.h>
 10
 11#include <linux/hash.h>
 12#include <linux/zalloc.h>
 13
 14#define __lockhashfn(key)	hash_long((unsigned long)key, LOCKHASH_BITS)
 15#define lockhashentry(key)	(lockhash_table + __lockhashfn((key)))
 16
 17struct callstack_filter {
 18	struct list_head list;
 19	char name[];
 20};
 21
 22static LIST_HEAD(callstack_filters);
 23struct hlist_head *lockhash_table;
 24
 25int parse_call_stack(const struct option *opt __maybe_unused, const char *str,
 26		     int unset __maybe_unused)
 27{
 28	char *s, *tmp, *tok;
 29	int ret = 0;
 30
 31	s = strdup(str);
 32	if (s == NULL)
 33		return -1;
 34
 35	for (tok = strtok_r(s, ", ", &tmp); tok; tok = strtok_r(NULL, ", ", &tmp)) {
 36		struct callstack_filter *entry;
 37
 38		entry = malloc(sizeof(*entry) + strlen(tok) + 1);
 39		if (entry == NULL) {
 40			pr_err("Memory allocation failure\n");
 41			free(s);
 42			return -1;
 43		}
 44
 45		strcpy(entry->name, tok);
 46		list_add_tail(&entry->list, &callstack_filters);
 47	}
 48
 49	free(s);
 50	return ret;
 51}
 52
 53bool needs_callstack(void)
 54{
 55	return !list_empty(&callstack_filters);
 56}
 57
 58struct lock_stat *lock_stat_find(u64 addr)
 59{
 60	struct hlist_head *entry = lockhashentry(addr);
 61	struct lock_stat *ret;
 62
 63	hlist_for_each_entry(ret, entry, hash_entry) {
 64		if (ret->addr == addr)
 65			return ret;
 66	}
 67	return NULL;
 68}
 69
 70struct lock_stat *lock_stat_findnew(u64 addr, const char *name, int flags)
 71{
 72	struct hlist_head *entry = lockhashentry(addr);
 73	struct lock_stat *ret, *new;
 74
 75	hlist_for_each_entry(ret, entry, hash_entry) {
 76		if (ret->addr == addr)
 77			return ret;
 78	}
 79
 80	new = zalloc(sizeof(struct lock_stat));
 81	if (!new)
 82		goto alloc_failed;
 83
 84	new->addr = addr;
 85	new->name = strdup(name);
 86	if (!new->name) {
 87		free(new);
 88		goto alloc_failed;
 89	}
 90
 91	new->flags = flags;
 92	new->wait_time_min = ULLONG_MAX;
 93
 94	hlist_add_head(&new->hash_entry, entry);
 95	return new;
 96
 97alloc_failed:
 98	pr_err("memory allocation failed\n");
 99	return NULL;
100}
101
102bool match_callstack_filter(struct machine *machine, u64 *callstack, int max_stack_depth)
103{
104	struct map *kmap;
105	struct symbol *sym;
106	u64 ip;
107	const char *arch = perf_env__arch(machine->env);
108
109	if (list_empty(&callstack_filters))
110		return true;
111
112	for (int i = 0; i < max_stack_depth; i++) {
113		struct callstack_filter *filter;
114
115		/*
116		 * In powerpc, the callchain saved by kernel always includes
117		 * first three entries as the NIP (next instruction pointer),
118		 * LR (link register), and the contents of LR save area in the
119		 * second stack frame. In certain scenarios its possible to have
120		 * invalid kernel instruction addresses in either LR or the second
121		 * stack frame's LR. In that case, kernel will store that address as
122		 * zero.
123		 *
124		 * The below check will continue to look into callstack,
125		 * incase first or second callstack index entry has 0
126		 * address for powerpc.
127		 */
128		if (!callstack || (!callstack[i] && (strcmp(arch, "powerpc") ||
129						(i != 1 && i != 2))))
130			break;
131
132		ip = callstack[i];
133		sym = machine__find_kernel_symbol(machine, ip, &kmap);
134		if (sym == NULL)
135			continue;
136
137		list_for_each_entry(filter, &callstack_filters, list) {
138			if (strstr(sym->name, filter->name))
139				return true;
140		}
141	}
142	return false;
143}