tools/perf/util/bpf_lock_contention.c

Source file repositories/reference/linux-study-clean/tools/perf/util/bpf_lock_contention.c

File Facts

System
Linux kernel
Corpus path
tools/perf/util/bpf_lock_contention.c
Extension
.c
Size
21032 bytes
Lines
856
Domain
Support Tooling And Documentation
Bucket
tools
Inferred role
Support Tooling And Documentation: implementation source
Status
source implementation candidate

Why This File Exists

Repository support layer: documentation, build tooling, samples, user-space helper tools, generated initramfs support, licenses, and validation utilities.

Dependency Surface

Detected Declarations

Annotated Snippet

if (con->owner) {
			bpf_map__set_value_size(skel->maps.stack_buf, con->max_stack * sizeof(u64));
			bpf_map__set_key_size(skel->maps.owner_stacks,
						con->max_stack * sizeof(u64));
			bpf_map__set_max_entries(skel->maps.owner_stacks, con->map_nr_entries);
			bpf_map__set_max_entries(skel->maps.owner_data, con->map_nr_entries);
			bpf_map__set_max_entries(skel->maps.owner_stat, con->map_nr_entries);
			skel->rodata->max_stack = con->max_stack;
		}
	} else {
		bpf_map__set_max_entries(skel->maps.stacks, 1);
	}

	if (target__has_cpu(target)) {
		skel->rodata->has_cpu = 1;
		ncpus = perf_cpu_map__nr(evlist->core.user_requested_cpus);
	}
	if (target__has_task(target)) {
		skel->rodata->has_task = 1;
		ntasks = perf_thread_map__nr(evlist->core.threads);
	}
	if (con->filters->nr_types) {
		skel->rodata->has_type = 1;
		ntypes = con->filters->nr_types;
	}
	if (con->filters->nr_cgrps) {
		skel->rodata->has_cgroup = 1;
		ncgrps = con->filters->nr_cgrps;
	}

	/* resolve lock name filters to addr */
	if (con->filters->nr_syms) {
		struct symbol *sym;
		struct map *kmap;
		unsigned long *addrs;

		for (i = 0; i < con->filters->nr_syms; i++) {
			sym = machine__find_kernel_symbol_by_name(con->machine,
								  con->filters->syms[i],
								  &kmap);
			if (sym == NULL) {
				pr_warning("ignore unknown symbol: %s\n",
					   con->filters->syms[i]);
				continue;
			}

			addrs = realloc(con->filters->addrs,
					(con->filters->nr_addrs + 1) * sizeof(*addrs));
			if (addrs == NULL) {
				pr_warning("memory allocation failure\n");
				continue;
			}

			addrs[con->filters->nr_addrs++] = map__unmap_ip(kmap, sym->start);
			con->filters->addrs = addrs;
		}
		naddrs = con->filters->nr_addrs;
		skel->rodata->has_addr = 1;
	}

	/* resolve lock name in delays */
	if (con->nr_delays) {
		struct symbol *sym;
		struct map *kmap;

		for (i = 0; i < con->nr_delays; i++) {
			sym = machine__find_kernel_symbol_by_name(con->machine,
								  con->delays[i].sym,
								  &kmap);
			if (sym == NULL) {
				pr_warning("ignore unknown symbol: %s\n",
					   con->delays[i].sym);
				continue;
			}

			con->delays[i].addr = map__unmap_ip(kmap, sym->start);
		}
		skel->rodata->lock_delay = 1;
		bpf_map__set_max_entries(skel->maps.lock_delays, con->nr_delays);
	}

	bpf_map__set_max_entries(skel->maps.cpu_filter, ncpus);
	bpf_map__set_max_entries(skel->maps.task_filter, ntasks);
	bpf_map__set_max_entries(skel->maps.type_filter, ntypes);
	bpf_map__set_max_entries(skel->maps.addr_filter, naddrs);
	bpf_map__set_max_entries(skel->maps.cgroup_filter, ncgrps);

	skel->rodata->stack_skip = con->stack_skip;
	skel->rodata->aggr_mode = con->aggr_mode;
	skel->rodata->needs_callstack = con->save_callstack;

Annotation

Implementation Notes