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