tools/perf/util/thread_map.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <dirent.h>
   3 #include <errno.h>
   4 #include <limits.h>
   5 #include <stdbool.h>
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <sys/types.h>
   9 #include <sys/stat.h>
  10 #include <unistd.h>
  11 #include "string2.h"
  12 #include "strlist.h"
  13 #include <string.h>
  14 #include <api/fs/fs.h>
  15 #include "asm/bug.h"
  16 #include "thread_map.h"
  17 #include "util.h"
  18 #include "debug.h"
  19 #include "event.h"
  20
  21 /* Skip "." and ".." directories */
  22 static int filter(const struct dirent *dir)
  23 {
  24         if (dir->d_name[0] == '.')
  25                 return 0;
  26         else
  27                 return 1;
  28 }
  29
  30 static void thread_map__reset(struct thread_map *map, int start, int nr)
  31 {
  32         size_t size = (nr - start) * sizeof(map->map[0]);
  33
  34         memset(&map->map[start], 0, size);
  35 }
  36
  37 static struct thread_map *thread_map__realloc(struct thread_map *map, int nr)
  38 {
  39         size_t size = sizeof(*map) + sizeof(map->map[0]) * nr;
  40         int start = map ? map->nr : 0;
  41
  42         map = realloc(map, size);
  43         /*
  44          * We only realloc to add more items, let's reset new items.
  45          */
  46         if (map)
  47                 thread_map__reset(map, start, nr);
  48
  49         return map;
  50 }
  51
  52 #define thread_map__alloc(__nr) thread_map__realloc(NULL, __nr)
  53
  54 struct thread_map *thread_map__new_by_pid(pid_t pid)
  55 {
  56         struct thread_map *threads;
  57         char name[256];
  58         int items;
  59         struct dirent **namelist = NULL;
  60         int i;
  61
  62         sprintf(name, "/proc/%d/task", pid);
  63         items = scandir(name, &namelist, filter, NULL);
  64         if (items <= 0)
  65                 return NULL;
  66
  67         threads = thread_map__alloc(items);
  68         if (threads != NULL) {
  69                 for (i = 0; i < items; i++)
  70                         thread_map__set_pid(threads, i, atoi(namelist[i]->d_name));
  71                 threads->nr = items;
  72                 refcount_set(&threads->refcnt, 1);
  73         }
  74
  75         for (i=0; i<items; i++)
  76                 zfree(&namelist[i]);
  77         free(namelist);
  78
  79         return threads;
  80 }
  81
  82 struct thread_map *thread_map__new_by_tid(pid_t tid)
  83 {
  84         struct thread_map *threads = thread_map__alloc(1);
  85
  86         if (threads != NULL) {
  87                 thread_map__set_pid(threads, 0, tid);
  88                 threads->nr = 1;
  89                 refcount_set(&threads->refcnt, 1);
  90         }
  91
  92         return threads;
  93 }
  94
  95 struct thread_map *thread_map__new_by_uid(uid_t uid)
  96 {
  97         DIR *proc;
  98         int max_threads = 32, items, i;
  99         char path[NAME_MAX + 1 + 6];
 100         struct dirent *dirent, **namelist = NULL;
 101         struct thread_map *threads = thread_map__alloc(max_threads);
 102
 103         if (threads == NULL)
 104                 goto out;
 105
 106         proc = opendir("/proc");
 107         if (proc == NULL)
 108                 goto out_free_threads;
 109
 110         threads->nr = 0;
 111         refcount_set(&threads->refcnt, 1);
 112
 113         while ((dirent = readdir(proc)) != NULL) {
 114                 char *end;
 115                 bool grow = false;
 116                 struct stat st;
 117                 pid_t pid = strtol(dirent->d_name, &end, 10);
 118
 119                 if (*end) /* only interested in proper numerical dirents */
 120                         continue;
 121
 122                 snprintf(path, sizeof(path), "/proc/%s", dirent->d_name);
 123
 124                 if (stat(path, &st) != 0)
 125                         continue;
 126
 127                 if (st.st_uid != uid)
 128                         continue;
 129
 130                 snprintf(path, sizeof(path), "/proc/%d/task", pid);
 131                 items = scandir(path, &namelist, filter, NULL);
 132                 if (items <= 0)
 133                         goto out_free_closedir;
 134
 135                 while (threads->nr + items >= max_threads) {
 136                         max_threads *= 2;
 137                         grow = true;
 138                 }
 139
 140                 if (grow) {
 141                         struct thread_map *tmp;
 142
 143                         tmp = thread_map__realloc(threads, max_threads);
 144                         if (tmp == NULL)
 145                                 goto out_free_namelist;
 146
 147                         threads = tmp;
 148                 }
 149
 150                 for (i = 0; i < items; i++) {
 151                         thread_map__set_pid(threads, threads->nr + i,
 152                                             atoi(namelist[i]->d_name));
 153                 }
 154
 155                 for (i = 0; i < items; i++)
 156                         zfree(&namelist[i]);
 157                 free(namelist);
 158
 159                 threads->nr += items;
 160         }
 161
 162 out_closedir:
 163         closedir(proc);
 164 out:
 165         return threads;
 166
 167 out_free_threads:
 168         free(threads);
 169         return NULL;
 170
 171 out_free_namelist:
 172         for (i = 0; i < items; i++)
 173                 zfree(&namelist[i]);
 174         free(namelist);
 175
 176 out_free_closedir:
 177         zfree(&threads);
 178         goto out_closedir;
 179 }
 180
 181 struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid)
 182 {
 183         if (pid != -1)
 184                 return thread_map__new_by_pid(pid);
 185
 186         if (tid == -1 && uid != UINT_MAX)
 187                 return thread_map__new_by_uid(uid);
 188
 189         return thread_map__new_by_tid(tid);
 190 }
 191
 192 static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
 193 {
 194         struct thread_map *threads = NULL, *nt;
 195         char name[256];
 196         int items, total_tasks = 0;
 197         struct dirent **namelist = NULL;
 198         int i, j = 0;
 199         pid_t pid, prev_pid = INT_MAX;
 200         char *end_ptr;
 201         struct str_node *pos;
 202         struct strlist_config slist_config = { .dont_dupstr = true, };
 203         struct strlist *slist = strlist__new(pid_str, &slist_config);
 204
 205         if (!slist)
 206                 return NULL;
 207
 208         strlist__for_each_entry(pos, slist) {
 209                 pid = strtol(pos->s, &end_ptr, 10);
 210
 211                 if (pid == INT_MIN || pid == INT_MAX ||
 212                     (*end_ptr != '\0' && *end_ptr != ','))
 213                         goto out_free_threads;
 214
 215                 if (pid == prev_pid)
 216                         continue;
 217
 218                 sprintf(name, "/proc/%d/task", pid);
 219                 items = scandir(name, &namelist, filter, NULL);
 220                 if (items <= 0)
 221                         goto out_free_threads;
 222
 223                 total_tasks += items;
 224                 nt = thread_map__realloc(threads, total_tasks);
 225                 if (nt == NULL)
 226                         goto out_free_namelist;
 227
 228                 threads = nt;
 229
 230                 for (i = 0; i < items; i++) {
 231                         thread_map__set_pid(threads, j++, atoi(namelist[i]->d_name));
 232                         zfree(&namelist[i]);
 233                 }
 234                 threads->nr = total_tasks;
 235                 free(namelist);
 236         }
 237
 238 out:
 239         strlist__delete(slist);
 240         if (threads)
 241                 refcount_set(&threads->refcnt, 1);
 242         return threads;
 243
 244 out_free_namelist:
 245         for (i = 0; i < items; i++)
 246                 zfree(&namelist[i]);
 247         free(namelist);
 248
 249 out_free_threads:
 250         zfree(&threads);
 251         goto out;
 252 }
 253
 254 struct thread_map *thread_map__new_dummy(void)
 255 {
 256         struct thread_map *threads = thread_map__alloc(1);
 257
 258         if (threads != NULL) {
 259                 thread_map__set_pid(threads, 0, -1);
 260                 threads->nr = 1;
 261                 refcount_set(&threads->refcnt, 1);
 262         }
 263         return threads;
 264 }
 265
 266 struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
 267 {
 268         struct thread_map *threads = NULL, *nt;
 269         int ntasks = 0;
 270         pid_t tid, prev_tid = INT_MAX;
 271         char *end_ptr;
 272         struct str_node *pos;
 273         struct strlist_config slist_config = { .dont_dupstr = true, };
 274         struct strlist *slist;
 275
 276         /* perf-stat expects threads to be generated even if tid not given */
 277         if (!tid_str)
 278                 return thread_map__new_dummy();
 279
 280         slist = strlist__new(tid_str, &slist_config);
 281         if (!slist)
 282                 return NULL;
 283
 284         strlist__for_each_entry(pos, slist) {
 285                 tid = strtol(pos->s, &end_ptr, 10);
 286
 287                 if (tid == INT_MIN || tid == INT_MAX ||
 288                     (*end_ptr != '\0' && *end_ptr != ','))
 289                         goto out_free_threads;
 290
 291                 if (tid == prev_tid)
 292                         continue;
 293
 294                 ntasks++;
 295                 nt = thread_map__realloc(threads, ntasks);
 296
 297                 if (nt == NULL)
 298                         goto out_free_threads;
 299
 300                 threads = nt;
 301                 thread_map__set_pid(threads, ntasks - 1, tid);
 302                 threads->nr = ntasks;
 303         }
 304 out:
 305         if (threads)
 306                 refcount_set(&threads->refcnt, 1);
 307         return threads;
 308
 309 out_free_threads:
 310         zfree(&threads);
 311         strlist__delete(slist);
 312         goto out;
 313 }
 314
 315 struct thread_map *thread_map__new_str(const char *pid, const char *tid,
 316                                        uid_t uid)
 317 {
 318         if (pid)
 319                 return thread_map__new_by_pid_str(pid);
 320
 321         if (!tid && uid != UINT_MAX)
 322                 return thread_map__new_by_uid(uid);
 323
 324         return thread_map__new_by_tid_str(tid);
 325 }
 326
 327 static void thread_map__delete(struct thread_map *threads)
 328 {
 329         if (threads) {
 330                 int i;
 331
 332                 WARN_ONCE(refcount_read(&threads->refcnt) != 0,
 333                           "thread map refcnt unbalanced\n");
 334                 for (i = 0; i < threads->nr; i++)
 335                         free(thread_map__comm(threads, i));
 336                 free(threads);
 337         }
 338 }
 339
 340 struct thread_map *thread_map__get(struct thread_map *map)
 341 {
 342         if (map)
 343                 refcount_inc(&map->refcnt);
 344         return map;
 345 }
 346
 347 void thread_map__put(struct thread_map *map)
 348 {
 349         if (map && refcount_dec_and_test(&map->refcnt))
 350                 thread_map__delete(map);
 351 }
 352
 353 size_t thread_map__fprintf(struct thread_map *threads, FILE *fp)
 354 {
 355         int i;
 356         size_t printed = fprintf(fp, "%d thread%s: ",
 357                                  threads->nr, threads->nr > 1 ? "s" : "");
 358         for (i = 0; i < threads->nr; ++i)
 359                 printed += fprintf(fp, "%s%d", i ? ", " : "", thread_map__pid(threads, i));
 360
 361         return printed + fprintf(fp, "\n");
 362 }
 363
 364 static int get_comm(char **comm, pid_t pid)
 365 {
 366         char *path;
 367         size_t size;
 368         int err;
 369
 370         if (asprintf(&path, "%s/%d/comm", procfs__mountpoint(), pid) == -1)
 371                 return -ENOMEM;
 372
 373         err = filename__read_str(path, comm, &size);
 374         if (!err) {
 375                 /*
 376                  * We're reading 16 bytes, while filename__read_str
 377                  * allocates data per BUFSIZ bytes, so we can safely
 378                  * mark the end of the string.
 379                  */
 380                 (*comm)[size] = 0;
 381                 rtrim(*comm);
 382         }
 383
 384         free(path);
 385         return err;
 386 }
 387
 388 static void comm_init(struct thread_map *map, int i)
 389 {
 390         pid_t pid = thread_map__pid(map, i);
 391         char *comm = NULL;
 392
 393         /* dummy pid comm initialization */
 394         if (pid == -1) {
 395                 map->map[i].comm = strdup("dummy");
 396                 return;
 397         }
 398
 399         /*
 400          * The comm name is like extra bonus ;-),
 401          * so just warn if we fail for any reason.
 402          */
 403         if (get_comm(&comm, pid))
 404                 pr_warning("Couldn't resolve comm name for pid %d\n", pid);
 405
 406         map->map[i].comm = comm;
 407 }
 408
 409 void thread_map__read_comms(struct thread_map *threads)
 410 {
 411         int i;
 412
 413         for (i = 0; i < threads->nr; ++i)
 414                 comm_init(threads, i);
 415 }
 416
 417 static void thread_map__copy_event(struct thread_map *threads,
 418                                    struct thread_map_event *event)
 419 {
 420         unsigned i;
 421
 422         threads->nr = (int) event->nr;
 423
 424         for (i = 0; i < event->nr; i++) {
 425                 thread_map__set_pid(threads, i, (pid_t) event->entries[i].pid);
 426                 threads->map[i].comm = strndup(event->entries[i].comm, 16);
 427         }
 428
 429         refcount_set(&threads->refcnt, 1);
 430 }
 431
 432 struct thread_map *thread_map__new_event(struct thread_map_event *event)
 433 {
 434         struct thread_map *threads;
 435
 436         threads = thread_map__alloc(event->nr);
 437         if (threads)
 438                 thread_map__copy_event(threads, event);
 439
 440         return threads;
 441 }
 442
 443 bool thread_map__has(struct thread_map *threads, pid_t pid)
 444 {
 445         int i;
 446
 447         for (i = 0; i < threads->nr; ++i) {
 448                 if (threads->map[i].pid == pid)
 449                         return true;
 450         }
 451
 452         return false;
 453 }
 454
 455 int thread_map__remove(struct thread_map *threads, int idx)
 456 {
 457         int i;
 458
 459         if (threads->nr < 1)
 460                 return -EINVAL;
 461
 462         if (idx >= threads->nr)
 463                 return -EINVAL;
 464
 465         /*
 466          * Free the 'idx' item and shift the rest up.
 467          */
 468         free(threads->map[idx].comm);
 469
 470         for (i = idx; i < threads->nr - 1; i++)
 471                 threads->map[i] = threads->map[i + 1];
 472
 473         threads->nr--;
 474         return 0;
 475 }