Merge tag 'perf-tools-for-v6.5-1-2023-06-28' of... (b30d7a77) · Commits · EulixOS / Software / Kernel

tools/lib/api/fs/cgroup.c

+11 −6

Original line number	Diff line number	Diff line
		@@ -14,7 +14,7 @@ struct cgroupfs_cache_entry {
		};

		/* just cache last used one */
		static struct cgroupfs_cache_entry cached;
		static struct cgroupfs_cache_entry *cached;

		int cgroupfs_find_mountpoint(char buf, size_t maxlen, const char subsys)
		{
		@@ -24,9 +24,9 @@ int cgroupfs_find_mountpoint(char buf, size_t maxlen, const char subsys)
		char p, path;
		char mountpoint[PATH_MAX];

		if (!strcmp(cached.subsys, subsys)) {
		if (strlen(cached.mountpoint) < maxlen) {
		strcpy(buf, cached.mountpoint);
		if (cached && !strcmp(cached->subsys, subsys)) {
		if (strlen(cached->mountpoint) < maxlen) {
		strcpy(buf, cached->mountpoint);
		return 0;
		}
		return -1;
		@@ -91,8 +91,13 @@ int cgroupfs_find_mountpoint(char buf, size_t maxlen, const char subsys)
		free(line);
		fclose(fp);

		strncpy(cached.subsys, subsys, sizeof(cached.subsys) - 1);
		strcpy(cached.mountpoint, mountpoint);
		if (!cached)
		cached = calloc(1, sizeof(*cached));

		if (cached) {
		strncpy(cached->subsys, subsys, sizeof(cached->subsys) - 1);
		strcpy(cached->mountpoint, mountpoint);
		}

		if (mountpoint[0] && strlen(mountpoint) < maxlen) {
		strcpy(buf, mountpoint);

tools/lib/api/fs/fs.c

+99 −127

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		#include <assert.h>
		#include <ctype.h>
		#include <errno.h>
		#include <limits.h>
		@@ -10,6 +11,7 @@
		#include <sys/types.h>
		#include <sys/stat.h>
		#include <fcntl.h>
		#include <pthread.h>
		#include <unistd.h>
		#include <sys/mount.h>

		@@ -43,7 +45,7 @@
		#define BPF_FS_MAGIC 0xcafe4a11
		#endif

		static const char * const sysfs__fs_known_mountpoints[] = {
		static const char * const sysfs__known_mountpoints[] = {
		"/sys",
		0,
		};
		@@ -86,87 +88,89 @@ static const char * const bpf_fs__known_mountpoints[] = {
		};

		struct fs {
		const char *name;
		const char * const *mounts;
		char path[PATH_MAX];
		bool found;
		bool checked;
		long magic;
		};

		enum {
		FS__SYSFS = 0,
		FS__PROCFS = 1,
		FS__DEBUGFS = 2,
		FS__TRACEFS = 3,
		FS__HUGETLBFS = 4,
		FS__BPF_FS = 5,
		const char * const name;
		const char * const * const mounts;
		char *path;
		pthread_mutex_t mount_mutex;
		const long magic;
		};

		#ifndef TRACEFS_MAGIC
		#define TRACEFS_MAGIC 0x74726163
		#endif

		static struct fs fs__entries[] = {
		[FS__SYSFS] = {
		.name = "sysfs",
		.mounts = sysfs__fs_known_mountpoints,
		.magic = SYSFS_MAGIC,
		.checked = false,
		},
		[FS__PROCFS] = {
		.name = "proc",
		.mounts = procfs__known_mountpoints,
		.magic = PROC_SUPER_MAGIC,
		.checked = false,
		},
		[FS__DEBUGFS] = {
		.name = "debugfs",
		.mounts = debugfs__known_mountpoints,
		.magic = DEBUGFS_MAGIC,
		.checked = false,
		},
		[FS__TRACEFS] = {
		.name = "tracefs",
		.mounts = tracefs__known_mountpoints,
		.magic = TRACEFS_MAGIC,
		.checked = false,
		},
		[FS__HUGETLBFS] = {
		.name = "hugetlbfs",
		.mounts = hugetlbfs__known_mountpoints,
		.magic = HUGETLBFS_MAGIC,
		.checked = false,
		},
		[FS__BPF_FS] = {
		.name = "bpf",
		.mounts = bpf_fs__known_mountpoints,
		.magic = BPF_FS_MAGIC,
		.checked = false,
		},
		};
		static void fs__init_once(struct fs *fs);
		static const char fs__mountpoint(const struct fs fs);
		static const char fs__mount(struct fs fs);

		#define FS(lower_name, fs_name, upper_name) \
		static struct fs fs__##lower_name = { \
		.name = #fs_name, \
		.mounts = lower_name##__known_mountpoints, \
		.magic = upper_name##_MAGIC, \
		.mount_mutex = PTHREAD_MUTEX_INITIALIZER, \
		}; \
		\
		static void lower_name##_init_once(void) \
		{ \
		struct fs *fs = &fs__##lower_name; \
		\
		fs__init_once(fs); \
		} \
		\
		const char *lower_name##__mountpoint(void) \
		{ \
		static pthread_once_t init_once = PTHREAD_ONCE_INIT; \
		struct fs *fs = &fs__##lower_name; \
		\
		pthread_once(&init_once, lower_name##_init_once); \
		return fs__mountpoint(fs); \
		} \
		\
		const char *lower_name##__mount(void) \
		{ \
		const char *mountpoint = lower_name##__mountpoint(); \
		struct fs *fs = &fs__##lower_name; \
		\
		if (mountpoint) \
		return mountpoint; \
		\
		return fs__mount(fs); \
		} \
		\
		bool lower_name##__configured(void) \
		{ \
		return lower_name##__mountpoint() != NULL; \
		}

		FS(sysfs, sysfs, SYSFS);
		FS(procfs, procfs, PROC_SUPER);
		FS(debugfs, debugfs, DEBUGFS);
		FS(tracefs, tracefs, TRACEFS);
		FS(hugetlbfs, hugetlbfs, HUGETLBFS);
		FS(bpf_fs, bpf, BPF_FS);

		static bool fs__read_mounts(struct fs *fs)
		{
		bool found = false;
		char type[100];
		FILE *fp;
		char path[PATH_MAX + 1];

		fp = fopen("/proc/mounts", "r");
		if (fp == NULL)
		return NULL;
		return false;

		while (!found &&
		fscanf(fp, "%s %" STR(PATH_MAX) "s %99s %s %d %d\n",
		fs->path, type) == 2) {
		while (fscanf(fp, "%s %" STR(PATH_MAX) "s %99s %s %d %d\n",
		path, type) == 2) {

		if (strcmp(type, fs->name) == 0)
		found = true;
		if (strcmp(type, fs->name) == 0) {
		fs->path = strdup(path);
		fclose(fp);
		return fs->path != NULL;
		}
		}

		fclose(fp);
		fs->checked = true;
		return fs->found = found;
		return false;
		}

		static int fs__valid_mount(const char *fs, long magic)
		@@ -188,8 +192,9 @@ static bool fs__check_mounts(struct fs *fs)
		ptr = fs->mounts;
		while (*ptr) {
		if (fs__valid_mount(*ptr, fs->magic) == 0) {
		fs->found = true;
		strcpy(fs->path, *ptr);
		fs->path = strdup(*ptr);
		if (!fs->path)
		return false;
		return true;
		}
		ptr++;
		@@ -227,43 +232,26 @@ static bool fs__env_override(struct fs *fs)
		if (!override_path)
		return false;

		fs->found = true;
		fs->checked = true;
		strncpy(fs->path, override_path, sizeof(fs->path) - 1);
		fs->path[sizeof(fs->path) - 1] = '\0';
		fs->path = strdup(override_path);
		if (!fs->path)
		return false;
		return true;
		}

		static const char fs__get_mountpoint(struct fs fs)
		static void fs__init_once(struct fs *fs)
		{
		if (fs__env_override(fs))
		return fs->path;

		if (fs__check_mounts(fs))
		return fs->path;

		if (fs__read_mounts(fs))
		return fs->path;

		return NULL;
		if (!fs__env_override(fs) &&
		!fs__check_mounts(fs) &&
		!fs__read_mounts(fs)) {
		assert(!fs->path);
		} else {
		assert(fs->path);
		}
		}

		static const char *fs__mountpoint(int idx)
		static const char fs__mountpoint(const struct fs fs)
		{
		struct fs *fs = &fs__entries[idx];

		if (fs->found)
		return (const char *)fs->path;

		/* the mount point was already checked for the mount point
		* but and did not exist, so return NULL to avoid scanning again.
		* This makes the found and not found paths cost equivalent
		* in case of multiple calls.
		*/
		if (fs->checked)
		return NULL;

		return fs__get_mountpoint(fs);
		return fs->path;
		}

		static const char mount_overload(struct fs fs)
		@@ -278,45 +266,29 @@ static const char mount_overload(struct fs fs)
		return getenv(upper_name) ?: *fs->mounts;
		}

		static const char *fs__mount(int idx)
		static const char fs__mount(struct fs fs)
		{
		struct fs *fs = &fs__entries[idx];
		const char *mountpoint;

		if (fs__mountpoint(idx))
		return (const char *)fs->path;
		pthread_mutex_lock(&fs->mount_mutex);

		mountpoint = mount_overload(fs);
		/* Check if path found inside the mutex to avoid races with other callers of mount. */
		mountpoint = fs__mountpoint(fs);
		if (mountpoint)
		goto out;

		if (mount(NULL, mountpoint, fs->name, 0, NULL) < 0)
		return NULL;
		mountpoint = mount_overload(fs);

		return fs__check_mounts(fs) ? fs->path : NULL;
		if (mount(NULL, mountpoint, fs->name, 0, NULL) == 0 &&
		fs__valid_mount(mountpoint, fs->magic) == 0) {
		fs->path = strdup(mountpoint);
		mountpoint = fs->path;
		}

		#define FS(name, idx) \
		const char *name##__mountpoint(void) \
		{ \
		return fs__mountpoint(idx); \
		} \
		\
		const char *name##__mount(void) \
		{ \
		return fs__mount(idx); \
		} \
		\
		bool name##__configured(void) \
		{ \
		return name##__mountpoint() != NULL; \
		out:
		pthread_mutex_unlock(&fs->mount_mutex);
		return mountpoint;
		}

		FS(sysfs, FS__SYSFS);
		FS(procfs, FS__PROCFS);
		FS(debugfs, FS__DEBUGFS);
		FS(tracefs, FS__TRACEFS);
		FS(hugetlbfs, FS__HUGETLBFS);
		FS(bpf_fs, FS__BPF_FS);

		int filename__read_int(const char filename, int value)
		{
		char line[64];

tools/lib/api/fs/tracing_path.c

+6 −11

Original line number	Diff line number	Diff line
		@@ -13,17 +13,12 @@

		#include "tracing_path.h"

		static char tracing_mnt[PATH_MAX] = "/sys/kernel/debug";
		static char tracing_path[PATH_MAX] = "/sys/kernel/tracing";
		static char tracing_events_path[PATH_MAX] = "/sys/kernel/tracing/events";

		static void __tracing_path_set(const char tracing, const char mountpoint)
		{
		snprintf(tracing_mnt, sizeof(tracing_mnt), "%s", mountpoint);
		snprintf(tracing_path, sizeof(tracing_path), "%s/%s",
		mountpoint, tracing);
		snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s%s",
		mountpoint, tracing, "events");
		}

		static const char *tracing_path_tracefs_mount(void)
		@@ -149,15 +144,15 @@ int tracing_path__strerror_open_tp(int err, char *buf, size_t size,
		/* sdt markers */
		if (!strncmp(filename, "sdt_", 4)) {
		snprintf(buf, size,
		"Error:\tFile %s/%s not found.\n"
		"Error:\tFile %s/events/%s not found.\n"
		"Hint:\tSDT event cannot be directly recorded on.\n"
		"\tPlease first use 'perf probe %s:%s' before recording it.\n",
		tracing_events_path, filename, sys, name);
		tracing_path, filename, sys, name);
		} else {
		snprintf(buf, size,
		"Error:\tFile %s/%s not found.\n"
		"Error:\tFile %s/events/%s not found.\n"
		"Hint:\tPerhaps this kernel misses some CONFIG_ setting to enable this feature?.\n",
		tracing_events_path, filename);
		tracing_path, filename);
		}
		break;
		}
		@@ -169,9 +164,9 @@ int tracing_path__strerror_open_tp(int err, char *buf, size_t size,
		break;
		case EACCES: {
		snprintf(buf, size,
		"Error:\tNo permissions to read %s/%s\n"
		"Error:\tNo permissions to read %s/events/%s\n"
		"Hint:\tTry 'sudo mount -o remount,mode=755 %s'\n",
		tracing_events_path, filename, tracing_path_mount());
		tracing_path, filename, tracing_path_mount());
		}
		break;
		default:

tools/lib/api/io.h

+27 −1

Original line number	Diff line number	Diff line
		@@ -8,6 +8,7 @@
		#define __API_IO__

		#include <errno.h>
		#include <poll.h>
		#include <stdlib.h>
		#include <string.h>
		#include <unistd.h>
		@@ -23,6 +24,8 @@ struct io {
		char *end;
		/* Currently accessed data pointer. */
		char *data;
		/* Read timeout, 0 implies no timeout. */
		int timeout_ms;
		/* Set true on when the end of file on read error. */
		bool eof;
		};
		@@ -35,6 +38,7 @@ static inline void io__init(struct io *io, int fd,
		io->buf = buf;
		io->end = buf;
		io->data = buf;
		io->timeout_ms = 0;
		io->eof = false;
		}

		@@ -47,7 +51,29 @@ static inline int io__get_char(struct io *io)
		return -1;

		if (ptr == io->end) {
		ssize_t n = read(io->fd, io->buf, io->buf_len);
		ssize_t n;

		if (io->timeout_ms != 0) {
		struct pollfd pfds[] = {
		{
		.fd = io->fd,
		.events = POLLIN,
		},
		};

		n = poll(pfds, 1, io->timeout_ms);
		if (n == 0)
		errno = ETIMEDOUT;
		if (n > 0 && !(pfds[0].revents & POLLIN)) {
		errno = EIO;
		n = -1;
		}
		if (n <= 0) {
		io->eof = true;
		return -1;
		}
		}
		n = read(io->fd, io->buf, io->buf_len);

		if (n <= 0) {
		io->eof = true;

tools/lib/perf/cpumap.c

+101 −24

Original line number	Diff line number	Diff line
		@@ -99,6 +99,11 @@ static int cmp_cpu(const void a, const void b)
		return cpu_a->cpu - cpu_b->cpu;
		}

		static struct perf_cpu __perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx)
		{
		return RC_CHK_ACCESS(cpus)->map[idx];
		}

		static struct perf_cpu_map cpu_map__trim_new(int nr_cpus, const struct perf_cpu tmp_cpus)
		{
		size_t payload_size = nr_cpus * sizeof(struct perf_cpu);
		@@ -111,8 +116,12 @@ static struct perf_cpu_map *cpu_map__trim_new(int nr_cpus, const struct perf_cpu
		/* Remove dups */
		j = 0;
		for (i = 0; i < nr_cpus; i++) {
		if (i == 0 \|\| RC_CHK_ACCESS(cpus)->map[i].cpu != RC_CHK_ACCESS(cpus)->map[i - 1].cpu)
		RC_CHK_ACCESS(cpus)->map[j++].cpu = RC_CHK_ACCESS(cpus)->map[i].cpu;
		if (i == 0 \|\|
		__perf_cpu_map__cpu(cpus, i).cpu !=
		__perf_cpu_map__cpu(cpus, i - 1).cpu) {
		RC_CHK_ACCESS(cpus)->map[j++].cpu =
		__perf_cpu_map__cpu(cpus, i).cpu;
		}
		}
		perf_cpu_map__set_nr(cpus, j);
		assert(j <= nr_cpus);
		@@ -269,26 +278,31 @@ struct perf_cpu_map perf_cpu_map__new(const char cpu_list)
		return cpus;
		}

		static int __perf_cpu_map__nr(const struct perf_cpu_map *cpus)
		{
		return RC_CHK_ACCESS(cpus)->nr;
		}

		struct perf_cpu perf_cpu_map__cpu(const struct perf_cpu_map *cpus, int idx)
		{
		struct perf_cpu result = {
		.cpu = -1
		};

		if (cpus && idx < RC_CHK_ACCESS(cpus)->nr)
		return RC_CHK_ACCESS(cpus)->map[idx];
		if (cpus && idx < __perf_cpu_map__nr(cpus))
		return __perf_cpu_map__cpu(cpus, idx);

		return result;
		}

		int perf_cpu_map__nr(const struct perf_cpu_map *cpus)
		{
		return cpus ? RC_CHK_ACCESS(cpus)->nr : 1;
		return cpus ? __perf_cpu_map__nr(cpus) : 1;
		}

		bool perf_cpu_map__empty(const struct perf_cpu_map *map)
		{
		return map ? RC_CHK_ACCESS(map)->map[0].cpu == -1 : true;
		return map ? __perf_cpu_map__cpu(map, 0).cpu == -1 : true;
		}

		int perf_cpu_map__idx(const struct perf_cpu_map *cpus, struct perf_cpu cpu)
		@@ -299,10 +313,10 @@ int perf_cpu_map__idx(const struct perf_cpu_map *cpus, struct perf_cpu cpu)
		return -1;

		low = 0;
		high = RC_CHK_ACCESS(cpus)->nr;
		high = __perf_cpu_map__nr(cpus);
		while (low < high) {
		int idx = (low + high) / 2;
		struct perf_cpu cpu_at_idx = RC_CHK_ACCESS(cpus)->map[idx];
		struct perf_cpu cpu_at_idx = __perf_cpu_map__cpu(cpus, idx);

		if (cpu_at_idx.cpu == cpu.cpu)
		return idx;
		@@ -321,6 +335,32 @@ bool perf_cpu_map__has(const struct perf_cpu_map *cpus, struct perf_cpu cpu)
		return perf_cpu_map__idx(cpus, cpu) != -1;
		}

		bool perf_cpu_map__equal(const struct perf_cpu_map lhs, const struct perf_cpu_map rhs)
		{
		int nr;

		if (lhs == rhs)
		return true;

		if (!lhs \|\| !rhs)
		return false;

		nr = __perf_cpu_map__nr(lhs);
		if (nr != __perf_cpu_map__nr(rhs))
		return false;

		for (int idx = 0; idx < nr; idx++) {
		if (__perf_cpu_map__cpu(lhs, idx).cpu != __perf_cpu_map__cpu(rhs, idx).cpu)
		return false;
		}
		return true;
		}

		bool perf_cpu_map__has_any_cpu(const struct perf_cpu_map *map)
		{
		return map && __perf_cpu_map__cpu(map, 0).cpu == -1;
		}

		struct perf_cpu perf_cpu_map__max(const struct perf_cpu_map *map)
		{
		struct perf_cpu result = {
		@@ -328,7 +368,9 @@ struct perf_cpu perf_cpu_map__max(const struct perf_cpu_map *map)
		};

		// cpu_map__trim_new() qsort()s it, cpu_map__default_new() sorts it as well.
		return RC_CHK_ACCESS(map)->nr > 0 ? RC_CHK_ACCESS(map)->map[RC_CHK_ACCESS(map)->nr - 1] : result;
		return __perf_cpu_map__nr(map) > 0
		? __perf_cpu_map__cpu(map, __perf_cpu_map__nr(map) - 1)
		: result;
		}

		/** Is 'b' a subset of 'a'. */
		@@ -336,15 +378,15 @@ bool perf_cpu_map__is_subset(const struct perf_cpu_map *a, const struct perf_cpu
		{
		if (a == b \|\| !b)
		return true;
		if (!a \|\| RC_CHK_ACCESS(b)->nr > RC_CHK_ACCESS(a)->nr)
		if (!a \|\| __perf_cpu_map__nr(b) > __perf_cpu_map__nr(a))
		return false;

		for (int i = 0, j = 0; i < RC_CHK_ACCESS(a)->nr; i++) {
		if (RC_CHK_ACCESS(a)->map[i].cpu > RC_CHK_ACCESS(b)->map[j].cpu)
		for (int i = 0, j = 0; i < __perf_cpu_map__nr(a); i++) {
		if (__perf_cpu_map__cpu(a, i).cpu > __perf_cpu_map__cpu(b, j).cpu)
		return false;
		if (RC_CHK_ACCESS(a)->map[i].cpu == RC_CHK_ACCESS(b)->map[j].cpu) {
		if (__perf_cpu_map__cpu(a, i).cpu == __perf_cpu_map__cpu(b, j).cpu) {
		j++;
		if (j == RC_CHK_ACCESS(b)->nr)
		if (j == __perf_cpu_map__nr(b))
		return true;
		}
		}
		@@ -374,27 +416,27 @@ struct perf_cpu_map perf_cpu_map__merge(struct perf_cpu_map orig,
		return perf_cpu_map__get(other);
		}

		tmp_len = RC_CHK_ACCESS(orig)->nr + RC_CHK_ACCESS(other)->nr;
		tmp_len = __perf_cpu_map__nr(orig) + __perf_cpu_map__nr(other);
		tmp_cpus = malloc(tmp_len * sizeof(struct perf_cpu));
		if (!tmp_cpus)
		return NULL;

		/* Standard merge algorithm from wikipedia */
		i = j = k = 0;
		while (i < RC_CHK_ACCESS(orig)->nr && j < RC_CHK_ACCESS(other)->nr) {
		if (RC_CHK_ACCESS(orig)->map[i].cpu <= RC_CHK_ACCESS(other)->map[j].cpu) {
		if (RC_CHK_ACCESS(orig)->map[i].cpu == RC_CHK_ACCESS(other)->map[j].cpu)
		while (i < __perf_cpu_map__nr(orig) && j < __perf_cpu_map__nr(other)) {
		if (__perf_cpu_map__cpu(orig, i).cpu <= __perf_cpu_map__cpu(other, j).cpu) {
		if (__perf_cpu_map__cpu(orig, i).cpu == __perf_cpu_map__cpu(other, j).cpu)
		j++;
		tmp_cpus[k++] = RC_CHK_ACCESS(orig)->map[i++];
		tmp_cpus[k++] = __perf_cpu_map__cpu(orig, i++);
		} else
		tmp_cpus[k++] = RC_CHK_ACCESS(other)->map[j++];
		tmp_cpus[k++] = __perf_cpu_map__cpu(other, j++);
		}

		while (i < RC_CHK_ACCESS(orig)->nr)
		tmp_cpus[k++] = RC_CHK_ACCESS(orig)->map[i++];
		while (i < __perf_cpu_map__nr(orig))
		tmp_cpus[k++] = __perf_cpu_map__cpu(orig, i++);

		while (j < RC_CHK_ACCESS(other)->nr)
		tmp_cpus[k++] = RC_CHK_ACCESS(other)->map[j++];
		while (j < __perf_cpu_map__nr(other))
		tmp_cpus[k++] = __perf_cpu_map__cpu(other, j++);
		assert(k <= tmp_len);

		merged = cpu_map__trim_new(k, tmp_cpus);
		@@ -402,3 +444,38 @@ struct perf_cpu_map perf_cpu_map__merge(struct perf_cpu_map orig,
		perf_cpu_map__put(orig);
		return merged;
		}

		struct perf_cpu_map perf_cpu_map__intersect(struct perf_cpu_map orig,
		struct perf_cpu_map *other)
		{
		struct perf_cpu *tmp_cpus;
		int tmp_len;
		int i, j, k;
		struct perf_cpu_map *merged = NULL;

		if (perf_cpu_map__is_subset(other, orig))
		return perf_cpu_map__get(orig);
		if (perf_cpu_map__is_subset(orig, other))
		return perf_cpu_map__get(other);

		tmp_len = max(__perf_cpu_map__nr(orig), __perf_cpu_map__nr(other));
		tmp_cpus = malloc(tmp_len * sizeof(struct perf_cpu));
		if (!tmp_cpus)
		return NULL;

		i = j = k = 0;
		while (i < __perf_cpu_map__nr(orig) && j < __perf_cpu_map__nr(other)) {
		if (__perf_cpu_map__cpu(orig, i).cpu < __perf_cpu_map__cpu(other, j).cpu)
		i++;
		else if (__perf_cpu_map__cpu(orig, i).cpu > __perf_cpu_map__cpu(other, j).cpu)
		j++;
		else {
		j++;
		tmp_cpus[k++] = __perf_cpu_map__cpu(orig, i++);
		}
		}
		if (k)
		merged = cpu_map__trim_new(k, tmp_cpus);
		free(tmp_cpus);
		return merged;
		}