cgroup.c 4.38 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3
#include "util.h"
#include "../perf.h"
4
#include <subcmd/parse-options.h>
5 6 7
#include "evsel.h"
#include "cgroup.h"
#include "evlist.h"
8
#include <linux/stringify.h>
9 10 11
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
12 13 14 15 16 17 18

int nr_cgroups;

static int
cgroupfs_find_mountpoint(char *buf, size_t maxlen)
{
	FILE *fp;
19
	char mountpoint[PATH_MAX + 1], tokens[PATH_MAX + 1], type[PATH_MAX + 1];
20
	char path_v1[PATH_MAX + 1], path_v2[PATH_MAX + 2], *path;
21
	char *token, *saved_ptr = NULL;
22 23 24 25 26 27 28 29 30 31

	fp = fopen("/proc/mounts", "r");
	if (!fp)
		return -1;

	/*
	 * in order to handle split hierarchy, we need to scan /proc/mounts
	 * and inspect every cgroupfs mount point to find one that has
	 * perf_event subsystem
	 */
32 33 34
	path_v1[0] = '\0';
	path_v2[0] = '\0';

35 36
	while (fscanf(fp, "%*s %"__stringify(PATH_MAX)"s %"__stringify(PATH_MAX)"s %"
				__stringify(PATH_MAX)"s %*d %*d\n",
37 38
				mountpoint, type, tokens) == 3) {

39
		if (!path_v1[0] && !strcmp(type, "cgroup")) {
40 41 42 43 44

			token = strtok_r(tokens, ",", &saved_ptr);

			while (token != NULL) {
				if (!strcmp(token, "perf_event")) {
45
					strcpy(path_v1, mountpoint);
46 47 48 49 50
					break;
				}
				token = strtok_r(NULL, ",", &saved_ptr);
			}
		}
51 52 53 54 55

		if (!path_v2[0] && !strcmp(type, "cgroup2"))
			strcpy(path_v2, mountpoint);

		if (path_v1[0] && path_v2[0])
56 57 58
			break;
	}
	fclose(fp);
59 60 61 62 63 64

	if (path_v1[0])
		path = path_v1;
	else if (path_v2[0])
		path = path_v2;
	else
65 66
		return -1;

67 68
	if (strlen(path) < maxlen) {
		strcpy(buf, path);
69 70 71 72 73 74 75
		return 0;
	}
	return -1;
}

static int open_cgroup(char *name)
{
76 77
	char path[PATH_MAX + 1];
	char mnt[PATH_MAX + 1];
78 79 80
	int fd;


81
	if (cgroupfs_find_mountpoint(mnt, PATH_MAX + 1))
82 83
		return -1;

84
	snprintf(path, PATH_MAX, "%s/%s", mnt, name);
85 86 87 88 89 90 91 92

	fd = open(path, O_RDONLY);
	if (fd == -1)
		fprintf(stderr, "no access to cgroup %s\n", path);

	return fd;
}

93
static struct cgroup *evlist__find_cgroup(struct perf_evlist *evlist, char *str)
94 95
{
	struct perf_evsel *counter;
96
	struct cgroup *cgrp = NULL;
97 98 99
	/*
	 * check if cgrp is already defined, if so we reuse it
	 */
100
	evlist__for_each_entry(evlist, counter) {
101
		if (!counter->cgrp)
102
			continue;
103 104
		if (!strcmp(counter->cgrp->name, str)) {
			cgrp = cgroup__get(counter->cgrp);
105
			break;
106
		}
107 108
	}

109 110 111
	return cgrp;
}

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
static struct cgroup *cgroup__new(char *name)
{
	struct cgroup *cgroup = zalloc(sizeof(*cgroup));

	if (cgroup != NULL) {
		cgroup->name = name;
		refcount_set(&cgroup->refcnt, 1);

		cgroup->fd = open_cgroup(name);
		if (cgroup->fd == -1)
			goto out_err;
	}

	return cgroup;
out_err:
	free(cgroup);
	return NULL;
}

131 132 133 134 135 136
static int add_cgroup(struct perf_evlist *evlist, char *str)
{
	struct perf_evsel *counter;
	struct cgroup *cgrp = evlist__find_cgroup(evlist, str);
	int n;

137
	if (!cgrp) {
138
		cgrp = cgroup__new(str);
139 140 141 142 143 144 145 146 147
		if (!cgrp)
			return -1;
	}

	/*
	 * find corresponding event
	 * if add cgroup N, then need to find event N
	 */
	n = 0;
148
	evlist__for_each_entry(evlist, counter) {
149 150 151 152 153
		if (n == nr_cgroups)
			goto found;
		n++;
	}

154
	cgroup__put(cgrp);
155 156 157 158 159 160
	return -1;
found:
	counter->cgrp = cgrp;
	return 0;
}

161 162 163 164 165 166 167
static void cgroup__delete(struct cgroup *cgroup)
{
	close(cgroup->fd);
	zfree(&cgroup->name);
	free(cgroup);
}

168
void cgroup__put(struct cgroup *cgrp)
169
{
170
	if (cgrp && refcount_dec_and_test(&cgrp->refcnt)) {
171
		cgroup__delete(cgrp);
172 173 174
	}
}

175 176 177 178 179 180 181
struct cgroup *cgroup__get(struct cgroup *cgroup)
{
       if (cgroup)
		refcount_inc(&cgroup->refcnt);
       return cgroup;
}

182
int parse_cgroups(const struct option *opt, const char *str,
183
		  int unset __maybe_unused)
184 185
{
	struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
186
	struct perf_evsel *counter;
187
	struct cgroup *cgrp = NULL;
188 189
	const char *p, *e, *eos = str + strlen(str);
	char *s;
190
	int ret, i;
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218

	if (list_empty(&evlist->entries)) {
		fprintf(stderr, "must define events before cgroups\n");
		return -1;
	}

	for (;;) {
		p = strchr(str, ',');
		e = p ? p : eos;

		/* allow empty cgroups, i.e., skip */
		if (e - str) {
			/* termination added */
			s = strndup(str, e - str);
			if (!s)
				return -1;
			ret = add_cgroup(evlist, s);
			if (ret) {
				free(s);
				return -1;
			}
		}
		/* nr_cgroups is increased een for empty cgroups */
		nr_cgroups++;
		if (!p)
			break;
		str = p+1;
	}
219 220 221 222 223 224 225 226 227 228 229 230 231
	/* for the case one cgroup combine to multiple events */
	i = 0;
	if (nr_cgroups == 1) {
		evlist__for_each_entry(evlist, counter) {
			if (i == 0)
				cgrp = counter->cgrp;
			else {
				counter->cgrp = cgrp;
				refcount_inc(&cgrp->refcnt);
			}
			i++;
		}
	}
232 233
	return 0;
}