1 // SPDX-License-Identifier: GPL-2.0 2 #include <subcmd/parse-options.h> 3 #include "evsel.h" 4 #include "cgroup.h" 5 #include "evlist.h" 6 #include "rblist.h" 7 #include "metricgroup.h" 8 #include "stat.h" 9 #include <linux/zalloc.h> 10 #include <sys/types.h> 11 #include <sys/stat.h> 12 #include <fcntl.h> 13 #include <stdlib.h> 14 #include <string.h> 15 #include <api/fs/fs.h> 16 #include <ftw.h> 17 #include <regex.h> 18 19 int nr_cgroups; 20 21 /* used to match cgroup name with patterns */ 22 struct cgroup_name { 23 struct list_head list; 24 bool used; 25 char name[]; 26 }; 27 static LIST_HEAD(cgroup_list); 28 29 static int open_cgroup(const char *name) 30 { 31 char path[PATH_MAX + 1]; 32 char mnt[PATH_MAX + 1]; 33 int fd; 34 35 36 if (cgroupfs_find_mountpoint(mnt, PATH_MAX + 1, "perf_event")) 37 return -1; 38 39 scnprintf(path, PATH_MAX, "%s/%s", mnt, name); 40 41 fd = open(path, O_RDONLY); 42 if (fd == -1) 43 fprintf(stderr, "no access to cgroup %s\n", path); 44 45 return fd; 46 } 47 48 static struct cgroup *evlist__find_cgroup(struct evlist *evlist, const char *str) 49 { 50 struct evsel *counter; 51 /* 52 * check if cgrp is already defined, if so we reuse it 53 */ 54 evlist__for_each_entry(evlist, counter) { 55 if (!counter->cgrp) 56 continue; 57 if (!strcmp(counter->cgrp->name, str)) 58 return cgroup__get(counter->cgrp); 59 } 60 61 return NULL; 62 } 63 64 static struct cgroup *cgroup__new(const char *name, bool do_open) 65 { 66 struct cgroup *cgroup = zalloc(sizeof(*cgroup)); 67 68 if (cgroup != NULL) { 69 refcount_set(&cgroup->refcnt, 1); 70 71 cgroup->name = strdup(name); 72 if (!cgroup->name) 73 goto out_err; 74 75 if (do_open) { 76 cgroup->fd = open_cgroup(name); 77 if (cgroup->fd == -1) 78 goto out_free_name; 79 } else { 80 cgroup->fd = -1; 81 } 82 } 83 84 return cgroup; 85 86 out_free_name: 87 zfree(&cgroup->name); 88 out_err: 89 free(cgroup); 90 return NULL; 91 } 92 93 struct cgroup *evlist__findnew_cgroup(struct evlist *evlist, const char *name) 94 { 95 struct cgroup *cgroup = evlist__find_cgroup(evlist, name); 96 97 return cgroup ?: cgroup__new(name, true); 98 } 99 100 static int add_cgroup(struct evlist *evlist, const char *str) 101 { 102 struct evsel *counter; 103 struct cgroup *cgrp = evlist__findnew_cgroup(evlist, str); 104 int n; 105 106 if (!cgrp) 107 return -1; 108 /* 109 * find corresponding event 110 * if add cgroup N, then need to find event N 111 */ 112 n = 0; 113 evlist__for_each_entry(evlist, counter) { 114 if (n == nr_cgroups) 115 goto found; 116 n++; 117 } 118 119 cgroup__put(cgrp); 120 return -1; 121 found: 122 counter->cgrp = cgrp; 123 return 0; 124 } 125 126 static void cgroup__delete(struct cgroup *cgroup) 127 { 128 if (cgroup->fd >= 0) 129 close(cgroup->fd); 130 zfree(&cgroup->name); 131 free(cgroup); 132 } 133 134 void cgroup__put(struct cgroup *cgrp) 135 { 136 if (cgrp && refcount_dec_and_test(&cgrp->refcnt)) { 137 cgroup__delete(cgrp); 138 } 139 } 140 141 struct cgroup *cgroup__get(struct cgroup *cgroup) 142 { 143 if (cgroup) 144 refcount_inc(&cgroup->refcnt); 145 return cgroup; 146 } 147 148 static void evsel__set_default_cgroup(struct evsel *evsel, struct cgroup *cgroup) 149 { 150 if (evsel->cgrp == NULL) 151 evsel->cgrp = cgroup__get(cgroup); 152 } 153 154 void evlist__set_default_cgroup(struct evlist *evlist, struct cgroup *cgroup) 155 { 156 struct evsel *evsel; 157 158 evlist__for_each_entry(evlist, evsel) 159 evsel__set_default_cgroup(evsel, cgroup); 160 } 161 162 /* helper function for ftw() in match_cgroups and list_cgroups */ 163 static int add_cgroup_name(const char *fpath, const struct stat *sb __maybe_unused, 164 int typeflag, struct FTW *ftwbuf __maybe_unused) 165 { 166 struct cgroup_name *cn; 167 168 if (typeflag != FTW_D) 169 return 0; 170 171 cn = malloc(sizeof(*cn) + strlen(fpath) + 1); 172 if (cn == NULL) 173 return -1; 174 175 cn->used = false; 176 strcpy(cn->name, fpath); 177 178 list_add_tail(&cn->list, &cgroup_list); 179 return 0; 180 } 181 182 static void release_cgroup_list(void) 183 { 184 struct cgroup_name *cn; 185 186 while (!list_empty(&cgroup_list)) { 187 cn = list_first_entry(&cgroup_list, struct cgroup_name, list); 188 list_del(&cn->list); 189 free(cn); 190 } 191 } 192 193 /* collect given cgroups only */ 194 static int list_cgroups(const char *str) 195 { 196 const char *p, *e, *eos = str + strlen(str); 197 struct cgroup_name *cn; 198 char *s; 199 200 /* use given name as is - for testing purpose */ 201 for (;;) { 202 p = strchr(str, ','); 203 e = p ? p : eos; 204 205 if (e - str) { 206 int ret; 207 208 s = strndup(str, e - str); 209 if (!s) 210 return -1; 211 /* pretend if it's added by ftw() */ 212 ret = add_cgroup_name(s, NULL, FTW_D, NULL); 213 free(s); 214 if (ret) 215 return -1; 216 } else { 217 if (add_cgroup_name("", NULL, FTW_D, NULL) < 0) 218 return -1; 219 } 220 221 if (!p) 222 break; 223 str = p+1; 224 } 225 226 /* these groups will be used */ 227 list_for_each_entry(cn, &cgroup_list, list) 228 cn->used = true; 229 230 return 0; 231 } 232 233 /* collect all cgroups first and then match with the pattern */ 234 static int match_cgroups(const char *str) 235 { 236 char mnt[PATH_MAX]; 237 const char *p, *e, *eos = str + strlen(str); 238 struct cgroup_name *cn; 239 regex_t reg; 240 int prefix_len; 241 char *s; 242 243 if (cgroupfs_find_mountpoint(mnt, sizeof(mnt), "perf_event")) 244 return -1; 245 246 /* cgroup_name will have a full path, skip the root directory */ 247 prefix_len = strlen(mnt); 248 249 /* collect all cgroups in the cgroup_list */ 250 if (nftw(mnt, add_cgroup_name, 20, 0) < 0) 251 return -1; 252 253 for (;;) { 254 p = strchr(str, ','); 255 e = p ? p : eos; 256 257 /* allow empty cgroups, i.e., skip */ 258 if (e - str) { 259 /* termination added */ 260 s = strndup(str, e - str); 261 if (!s) 262 return -1; 263 if (regcomp(®, s, REG_NOSUB)) { 264 free(s); 265 return -1; 266 } 267 268 /* check cgroup name with the pattern */ 269 list_for_each_entry(cn, &cgroup_list, list) { 270 char *name = cn->name + prefix_len; 271 272 if (name[0] == '/' && name[1]) 273 name++; 274 if (!regexec(®, name, 0, NULL, 0)) 275 cn->used = true; 276 } 277 regfree(®); 278 free(s); 279 } else { 280 /* first entry to root cgroup */ 281 cn = list_first_entry(&cgroup_list, struct cgroup_name, 282 list); 283 cn->used = true; 284 } 285 286 if (!p) 287 break; 288 str = p+1; 289 } 290 return prefix_len; 291 } 292 293 int parse_cgroups(const struct option *opt, const char *str, 294 int unset __maybe_unused) 295 { 296 struct evlist *evlist = *(struct evlist **)opt->value; 297 struct evsel *counter; 298 struct cgroup *cgrp = NULL; 299 const char *p, *e, *eos = str + strlen(str); 300 char *s; 301 int ret, i; 302 303 if (list_empty(&evlist->core.entries)) { 304 fprintf(stderr, "must define events before cgroups\n"); 305 return -1; 306 } 307 308 for (;;) { 309 p = strchr(str, ','); 310 e = p ? p : eos; 311 312 /* allow empty cgroups, i.e., skip */ 313 if (e - str) { 314 /* termination added */ 315 s = strndup(str, e - str); 316 if (!s) 317 return -1; 318 ret = add_cgroup(evlist, s); 319 free(s); 320 if (ret) 321 return -1; 322 } 323 /* nr_cgroups is increased een for empty cgroups */ 324 nr_cgroups++; 325 if (!p) 326 break; 327 str = p+1; 328 } 329 /* for the case one cgroup combine to multiple events */ 330 i = 0; 331 if (nr_cgroups == 1) { 332 evlist__for_each_entry(evlist, counter) { 333 if (i == 0) 334 cgrp = counter->cgrp; 335 else { 336 counter->cgrp = cgrp; 337 refcount_inc(&cgrp->refcnt); 338 } 339 i++; 340 } 341 } 342 return 0; 343 } 344 345 static bool has_pattern_string(const char *str) 346 { 347 return !!strpbrk(str, "{}[]()|*+?^$"); 348 } 349 350 int evlist__expand_cgroup(struct evlist *evlist, const char *str, 351 struct rblist *metric_events, bool open_cgroup) 352 { 353 struct evlist *orig_list, *tmp_list; 354 struct evsel *pos, *evsel, *leader; 355 struct rblist orig_metric_events; 356 struct cgroup *cgrp = NULL; 357 struct cgroup_name *cn; 358 int ret = -1; 359 int prefix_len; 360 361 if (evlist->core.nr_entries == 0) { 362 fprintf(stderr, "must define events before cgroups\n"); 363 return -EINVAL; 364 } 365 366 orig_list = evlist__new(); 367 tmp_list = evlist__new(); 368 if (orig_list == NULL || tmp_list == NULL) { 369 fprintf(stderr, "memory allocation failed\n"); 370 return -ENOMEM; 371 } 372 373 /* save original events and init evlist */ 374 evlist__splice_list_tail(orig_list, &evlist->core.entries); 375 evlist->core.nr_entries = 0; 376 377 if (metric_events) { 378 orig_metric_events = *metric_events; 379 rblist__init(metric_events); 380 } else { 381 rblist__init(&orig_metric_events); 382 } 383 384 if (has_pattern_string(str)) 385 prefix_len = match_cgroups(str); 386 else 387 prefix_len = list_cgroups(str); 388 389 if (prefix_len < 0) 390 goto out_err; 391 392 list_for_each_entry(cn, &cgroup_list, list) { 393 char *name; 394 395 if (!cn->used) 396 continue; 397 398 /* cgroup_name might have a full path, skip the prefix */ 399 name = cn->name + prefix_len; 400 if (name[0] == '/' && name[1]) 401 name++; 402 cgrp = cgroup__new(name, open_cgroup); 403 if (cgrp == NULL) 404 goto out_err; 405 406 leader = NULL; 407 evlist__for_each_entry(orig_list, pos) { 408 evsel = evsel__clone(pos); 409 if (evsel == NULL) 410 goto out_err; 411 412 cgroup__put(evsel->cgrp); 413 evsel->cgrp = cgroup__get(cgrp); 414 415 if (evsel__is_group_leader(pos)) 416 leader = evsel; 417 evsel->leader = leader; 418 419 evlist__add(tmp_list, evsel); 420 } 421 /* cgroup__new() has a refcount, release it here */ 422 cgroup__put(cgrp); 423 nr_cgroups++; 424 425 if (metric_events) { 426 perf_stat__collect_metric_expr(tmp_list); 427 if (metricgroup__copy_metric_events(tmp_list, cgrp, 428 metric_events, 429 &orig_metric_events) < 0) 430 goto out_err; 431 } 432 433 evlist__splice_list_tail(evlist, &tmp_list->core.entries); 434 tmp_list->core.nr_entries = 0; 435 } 436 437 if (list_empty(&evlist->core.entries)) { 438 fprintf(stderr, "no cgroup matched: %s\n", str); 439 goto out_err; 440 } 441 442 ret = 0; 443 444 out_err: 445 evlist__delete(orig_list); 446 evlist__delete(tmp_list); 447 rblist__exit(&orig_metric_events); 448 release_cgroup_list(); 449 450 return ret; 451 } 452 453 static struct cgroup *__cgroup__findnew(struct rb_root *root, uint64_t id, 454 bool create, const char *path) 455 { 456 struct rb_node **p = &root->rb_node; 457 struct rb_node *parent = NULL; 458 struct cgroup *cgrp; 459 460 while (*p != NULL) { 461 parent = *p; 462 cgrp = rb_entry(parent, struct cgroup, node); 463 464 if (cgrp->id == id) 465 return cgrp; 466 467 if (cgrp->id < id) 468 p = &(*p)->rb_left; 469 else 470 p = &(*p)->rb_right; 471 } 472 473 if (!create) 474 return NULL; 475 476 cgrp = malloc(sizeof(*cgrp)); 477 if (cgrp == NULL) 478 return NULL; 479 480 cgrp->name = strdup(path); 481 if (cgrp->name == NULL) { 482 free(cgrp); 483 return NULL; 484 } 485 486 cgrp->fd = -1; 487 cgrp->id = id; 488 refcount_set(&cgrp->refcnt, 1); 489 490 rb_link_node(&cgrp->node, parent, p); 491 rb_insert_color(&cgrp->node, root); 492 493 return cgrp; 494 } 495 496 struct cgroup *cgroup__findnew(struct perf_env *env, uint64_t id, 497 const char *path) 498 { 499 struct cgroup *cgrp; 500 501 down_write(&env->cgroups.lock); 502 cgrp = __cgroup__findnew(&env->cgroups.tree, id, true, path); 503 up_write(&env->cgroups.lock); 504 return cgrp; 505 } 506 507 struct cgroup *cgroup__find(struct perf_env *env, uint64_t id) 508 { 509 struct cgroup *cgrp; 510 511 down_read(&env->cgroups.lock); 512 cgrp = __cgroup__findnew(&env->cgroups.tree, id, false, NULL); 513 up_read(&env->cgroups.lock); 514 return cgrp; 515 } 516 517 void perf_env__purge_cgroups(struct perf_env *env) 518 { 519 struct rb_node *node; 520 struct cgroup *cgrp; 521 522 down_write(&env->cgroups.lock); 523 while (!RB_EMPTY_ROOT(&env->cgroups.tree)) { 524 node = rb_first(&env->cgroups.tree); 525 cgrp = rb_entry(node, struct cgroup, node); 526 527 rb_erase(node, &env->cgroups.tree); 528 cgroup__put(cgrp); 529 } 530 up_write(&env->cgroups.lock); 531 } 532