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 void release_cgroup_list(void) 228 { 229 struct cgroup_name *cn; 230 231 while (!list_empty(&cgroup_list)) { 232 cn = list_first_entry(&cgroup_list, struct cgroup_name, list); 233 list_del(&cn->list); 234 free(cn); 235 } 236 } 237 238 /* collect given cgroups only */ 239 static int list_cgroups(const char *str) 240 { 241 const char *p, *e, *eos = str + strlen(str); 242 struct cgroup_name *cn; 243 char *s; 244 245 /* use given name as is - for testing purpose */ 246 for (;;) { 247 p = strchr(str, ','); 248 e = p ? p : eos; 249 250 if (e - str) { 251 int ret; 252 253 s = strndup(str, e - str); 254 if (!s) 255 return -1; 256 /* pretend if it's added by ftw() */ 257 ret = add_cgroup_name(s, NULL, FTW_D, NULL); 258 free(s); 259 if (ret) 260 return -1; 261 } else { 262 if (add_cgroup_name("", NULL, FTW_D, NULL) < 0) 263 return -1; 264 } 265 266 if (!p) 267 break; 268 str = p+1; 269 } 270 271 /* these groups will be used */ 272 list_for_each_entry(cn, &cgroup_list, list) 273 cn->used = true; 274 275 return 0; 276 } 277 278 /* collect all cgroups first and then match with the pattern */ 279 static int match_cgroups(const char *str) 280 { 281 char mnt[PATH_MAX]; 282 const char *p, *e, *eos = str + strlen(str); 283 struct cgroup_name *cn; 284 regex_t reg; 285 int prefix_len; 286 char *s; 287 288 if (cgroupfs_find_mountpoint(mnt, sizeof(mnt), "perf_event")) 289 return -1; 290 291 /* cgroup_name will have a full path, skip the root directory */ 292 prefix_len = strlen(mnt); 293 294 /* collect all cgroups in the cgroup_list */ 295 if (nftw(mnt, add_cgroup_name, 20, 0) < 0) 296 return -1; 297 298 for (;;) { 299 p = strchr(str, ','); 300 e = p ? p : eos; 301 302 /* allow empty cgroups, i.e., skip */ 303 if (e - str) { 304 /* termination added */ 305 s = strndup(str, e - str); 306 if (!s) 307 return -1; 308 if (regcomp(®, s, REG_NOSUB)) { 309 free(s); 310 return -1; 311 } 312 313 /* check cgroup name with the pattern */ 314 list_for_each_entry(cn, &cgroup_list, list) { 315 char *name = cn->name + prefix_len; 316 317 if (name[0] == '/' && name[1]) 318 name++; 319 if (!regexec(®, name, 0, NULL, 0)) 320 cn->used = true; 321 } 322 regfree(®); 323 free(s); 324 } else { 325 /* first entry to root cgroup */ 326 cn = list_first_entry(&cgroup_list, struct cgroup_name, 327 list); 328 cn->used = true; 329 } 330 331 if (!p) 332 break; 333 str = p+1; 334 } 335 return prefix_len; 336 } 337 338 int parse_cgroups(const struct option *opt, const char *str, 339 int unset __maybe_unused) 340 { 341 struct evlist *evlist = *(struct evlist **)opt->value; 342 struct evsel *counter; 343 struct cgroup *cgrp = NULL; 344 const char *p, *e, *eos = str + strlen(str); 345 char *s; 346 int ret, i; 347 348 if (list_empty(&evlist->core.entries)) { 349 fprintf(stderr, "must define events before cgroups\n"); 350 return -1; 351 } 352 353 for (;;) { 354 p = strchr(str, ','); 355 e = p ? p : eos; 356 357 /* allow empty cgroups, i.e., skip */ 358 if (e - str) { 359 /* termination added */ 360 s = strndup(str, e - str); 361 if (!s) 362 return -1; 363 ret = add_cgroup(evlist, s); 364 free(s); 365 if (ret) 366 return -1; 367 } 368 /* nr_cgroups is increased een for empty cgroups */ 369 nr_cgroups++; 370 if (!p) 371 break; 372 str = p+1; 373 } 374 /* for the case one cgroup combine to multiple events */ 375 i = 0; 376 if (nr_cgroups == 1) { 377 evlist__for_each_entry(evlist, counter) { 378 if (i == 0) 379 cgrp = counter->cgrp; 380 else { 381 counter->cgrp = cgrp; 382 refcount_inc(&cgrp->refcnt); 383 } 384 i++; 385 } 386 } 387 return 0; 388 } 389 390 static bool has_pattern_string(const char *str) 391 { 392 return !!strpbrk(str, "{}[]()|*+?^$"); 393 } 394 395 int evlist__expand_cgroup(struct evlist *evlist, const char *str, 396 struct rblist *metric_events, bool open_cgroup) 397 { 398 struct evlist *orig_list, *tmp_list; 399 struct evsel *pos, *evsel, *leader; 400 struct rblist orig_metric_events; 401 struct cgroup *cgrp = NULL; 402 struct cgroup_name *cn; 403 int ret = -1; 404 int prefix_len; 405 406 if (evlist->core.nr_entries == 0) { 407 fprintf(stderr, "must define events before cgroups\n"); 408 return -EINVAL; 409 } 410 411 orig_list = evlist__new(); 412 tmp_list = evlist__new(); 413 if (orig_list == NULL || tmp_list == NULL) { 414 fprintf(stderr, "memory allocation failed\n"); 415 return -ENOMEM; 416 } 417 418 /* save original events and init evlist */ 419 evlist__splice_list_tail(orig_list, &evlist->core.entries); 420 evlist->core.nr_entries = 0; 421 422 if (metric_events) { 423 orig_metric_events = *metric_events; 424 rblist__init(metric_events); 425 } else { 426 rblist__init(&orig_metric_events); 427 } 428 429 if (has_pattern_string(str)) 430 prefix_len = match_cgroups(str); 431 else 432 prefix_len = list_cgroups(str); 433 434 if (prefix_len < 0) 435 goto out_err; 436 437 list_for_each_entry(cn, &cgroup_list, list) { 438 char *name; 439 440 if (!cn->used) 441 continue; 442 443 /* cgroup_name might have a full path, skip the prefix */ 444 name = cn->name + prefix_len; 445 if (name[0] == '/' && name[1]) 446 name++; 447 cgrp = cgroup__new(name, open_cgroup); 448 if (cgrp == NULL) 449 goto out_err; 450 451 leader = NULL; 452 evlist__for_each_entry(orig_list, pos) { 453 evsel = evsel__clone(pos); 454 if (evsel == NULL) 455 goto out_err; 456 457 cgroup__put(evsel->cgrp); 458 evsel->cgrp = cgroup__get(cgrp); 459 460 if (evsel__is_group_leader(pos)) 461 leader = evsel; 462 evsel__set_leader(evsel, leader); 463 464 evlist__add(tmp_list, evsel); 465 } 466 /* cgroup__new() has a refcount, release it here */ 467 cgroup__put(cgrp); 468 nr_cgroups++; 469 470 if (metric_events) { 471 perf_stat__collect_metric_expr(tmp_list); 472 if (metricgroup__copy_metric_events(tmp_list, cgrp, 473 metric_events, 474 &orig_metric_events) < 0) 475 goto out_err; 476 } 477 478 evlist__splice_list_tail(evlist, &tmp_list->core.entries); 479 tmp_list->core.nr_entries = 0; 480 } 481 482 if (list_empty(&evlist->core.entries)) { 483 fprintf(stderr, "no cgroup matched: %s\n", str); 484 goto out_err; 485 } 486 487 ret = 0; 488 cgrp_event_expanded = true; 489 490 out_err: 491 evlist__delete(orig_list); 492 evlist__delete(tmp_list); 493 rblist__exit(&orig_metric_events); 494 release_cgroup_list(); 495 496 return ret; 497 } 498 499 static struct cgroup *__cgroup__findnew(struct rb_root *root, uint64_t id, 500 bool create, const char *path) 501 { 502 struct rb_node **p = &root->rb_node; 503 struct rb_node *parent = NULL; 504 struct cgroup *cgrp; 505 506 while (*p != NULL) { 507 parent = *p; 508 cgrp = rb_entry(parent, struct cgroup, node); 509 510 if (cgrp->id == id) 511 return cgrp; 512 513 if (cgrp->id < id) 514 p = &(*p)->rb_left; 515 else 516 p = &(*p)->rb_right; 517 } 518 519 if (!create) 520 return NULL; 521 522 cgrp = malloc(sizeof(*cgrp)); 523 if (cgrp == NULL) 524 return NULL; 525 526 cgrp->name = strdup(path); 527 if (cgrp->name == NULL) { 528 free(cgrp); 529 return NULL; 530 } 531 532 cgrp->fd = -1; 533 cgrp->id = id; 534 refcount_set(&cgrp->refcnt, 1); 535 536 rb_link_node(&cgrp->node, parent, p); 537 rb_insert_color(&cgrp->node, root); 538 539 return cgrp; 540 } 541 542 struct cgroup *cgroup__findnew(struct perf_env *env, uint64_t id, 543 const char *path) 544 { 545 struct cgroup *cgrp; 546 547 down_write(&env->cgroups.lock); 548 cgrp = __cgroup__findnew(&env->cgroups.tree, id, true, path); 549 up_write(&env->cgroups.lock); 550 return cgrp; 551 } 552 553 struct cgroup *cgroup__find(struct perf_env *env, uint64_t id) 554 { 555 struct cgroup *cgrp; 556 557 down_read(&env->cgroups.lock); 558 cgrp = __cgroup__findnew(&env->cgroups.tree, id, false, NULL); 559 up_read(&env->cgroups.lock); 560 return cgrp; 561 } 562 563 void perf_env__purge_cgroups(struct perf_env *env) 564 { 565 struct rb_node *node; 566 struct cgroup *cgrp; 567 568 down_write(&env->cgroups.lock); 569 while (!RB_EMPTY_ROOT(&env->cgroups.tree)) { 570 node = rb_first(&env->cgroups.tree); 571 cgrp = rb_entry(node, struct cgroup, node); 572 573 rb_erase(node, &env->cgroups.tree); 574 cgroup__put(cgrp); 575 } 576 up_write(&env->cgroups.lock); 577 } 578