tools/perf/util/data.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/compiler.h>
   3 #include <linux/kernel.h>
   4 #include <linux/string.h>
   5 #include <linux/zalloc.h>
   6 #include <linux/err.h>
   7 #include <sys/types.h>
   8 #include <sys/stat.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <unistd.h>
  12 #include <string.h>
  13 #include <asm/bug.h>
  14 #include <dirent.h>
  15
  16 #include "data.h"
  17 #include "util.h" // rm_rf_perf_data()
  18 #include "debug.h"
  19 #include "header.h"
  20 #include "rlimit.h"
  21 #include <internal/lib.h>
  22
  23 static void close_dir(struct perf_data_file *files, int nr)
  24 {
  25         while (--nr >= 0) {
  26                 close(files[nr].fd);
  27                 zfree(&files[nr].path);
  28         }
  29         free(files);
  30 }
  31
  32 void perf_data__close_dir(struct perf_data *data)
  33 {
  34         close_dir(data->dir.files, data->dir.nr);
  35 }
  36
  37 int perf_data__create_dir(struct perf_data *data, int nr)
  38 {
  39         enum rlimit_action set_rlimit = NO_CHANGE;
  40         struct perf_data_file *files = NULL;
  41         int i, ret;
  42
  43         if (WARN_ON(!data->is_dir))
  44                 return -EINVAL;
  45
  46         files = zalloc(nr * sizeof(*files));
  47         if (!files)
  48                 return -ENOMEM;
  49
  50         for (i = 0; i < nr; i++) {
  51                 struct perf_data_file *file = &files[i];
  52
  53                 ret = asprintf(&file->path, "%s/data.%d", data->path, i);
  54                 if (ret < 0) {
  55                         ret = -ENOMEM;
  56                         goto out_err;
  57                 }
  58
  59 retry_open:
  60                 ret = open(file->path, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
  61                 if (ret < 0) {
  62                         /*
  63                          * If using parallel threads to collect data,
  64                          * perf record needs at least 6 fds per CPU.
  65                          * When we run out of them try to increase the limits.
  66                          */
  67                         if (errno == EMFILE && rlimit__increase_nofile(&set_rlimit))
  68                                 goto retry_open;
  69
  70                         ret = -errno;
  71                         goto out_err;
  72                 }
  73                 set_rlimit = NO_CHANGE;
  74
  75                 file->fd = ret;
  76         }
  77
  78         data->dir.version = PERF_DIR_VERSION;
  79         data->dir.files   = files;
  80         data->dir.nr      = nr;
  81         return 0;
  82
  83 out_err:
  84         close_dir(files, i);
  85         return ret;
  86 }
  87
  88 int perf_data__open_dir(struct perf_data *data)
  89 {
  90         struct perf_data_file *files = NULL;
  91         struct dirent *dent;
  92         int ret = -1;
  93         DIR *dir;
  94         int nr = 0;
  95
  96         /*
  97          * Directory containing a single regular perf data file which is already
  98          * open, means there is nothing more to do here.
  99          */
 100         if (perf_data__is_single_file(data))
 101                 return 0;
 102
 103         if (WARN_ON(!data->is_dir))
 104                 return -EINVAL;
 105
 106         /* The version is provided by DIR_FORMAT feature. */
 107         if (WARN_ON(data->dir.version != PERF_DIR_VERSION))
 108                 return -1;
 109
 110         dir = opendir(data->path);
 111         if (!dir)
 112                 return -EINVAL;
 113
 114         while ((dent = readdir(dir)) != NULL) {
 115                 struct perf_data_file *file;
 116                 char path[PATH_MAX];
 117                 struct stat st;
 118
 119                 snprintf(path, sizeof(path), "%s/%s", data->path, dent->d_name);
 120                 if (stat(path, &st))
 121                         continue;
 122
 123                 if (!S_ISREG(st.st_mode) || strncmp(dent->d_name, "data.", 5))
 124                         continue;
 125
 126                 ret = -ENOMEM;
 127
 128                 file = realloc(files, (nr + 1) * sizeof(*files));
 129                 if (!file)
 130                         goto out_err;
 131
 132                 files = file;
 133                 file = &files[nr++];
 134
 135                 file->path = strdup(path);
 136                 if (!file->path)
 137                         goto out_err;
 138
 139                 ret = open(file->path, O_RDONLY);
 140                 if (ret < 0)
 141                         goto out_err;
 142
 143                 file->fd = ret;
 144                 file->size = st.st_size;
 145         }
 146
 147         closedir(dir);
 148         if (!files)
 149                 return -EINVAL;
 150
 151         data->dir.files = files;
 152         data->dir.nr    = nr;
 153         return 0;
 154
 155 out_err:
 156         closedir(dir);
 157         close_dir(files, nr);
 158         return ret;
 159 }
 160
 161 int perf_data__update_dir(struct perf_data *data)
 162 {
 163         int i;
 164
 165         if (WARN_ON(!data->is_dir))
 166                 return -EINVAL;
 167
 168         for (i = 0; i < data->dir.nr; i++) {
 169                 struct perf_data_file *file = &data->dir.files[i];
 170                 struct stat st;
 171
 172                 if (fstat(file->fd, &st))
 173                         return -1;
 174
 175                 file->size = st.st_size;
 176         }
 177
 178         return 0;
 179 }
 180
 181 static bool check_pipe(struct perf_data *data)
 182 {
 183         struct stat st;
 184         bool is_pipe = false;
 185         int fd = perf_data__is_read(data) ?
 186                  STDIN_FILENO : STDOUT_FILENO;
 187
 188         if (!data->path) {
 189                 if (!fstat(fd, &st) && S_ISFIFO(st.st_mode))
 190                         is_pipe = true;
 191         } else {
 192                 if (!strcmp(data->path, "-"))
 193                         is_pipe = true;
 194         }
 195
 196         if (is_pipe) {
 197                 if (data->use_stdio) {
 198                         const char *mode;
 199
 200                         mode = perf_data__is_read(data) ? "r" : "w";
 201                         data->file.fptr = fdopen(fd, mode);
 202
 203                         if (data->file.fptr == NULL) {
 204                                 data->file.fd = fd;
 205                                 data->use_stdio = false;
 206                         }
 207
 208                 /*
 209                  * When is_pipe and data->file.fd is given, use given fd
 210                  * instead of STDIN_FILENO or STDOUT_FILENO
 211                  */
 212                 } else if (data->file.fd <= 0) {
 213                         data->file.fd = fd;
 214                 }
 215         }
 216
 217         return data->is_pipe = is_pipe;
 218 }
 219
 220 static int check_backup(struct perf_data *data)
 221 {
 222         struct stat st;
 223
 224         if (perf_data__is_read(data))
 225                 return 0;
 226
 227         if (!stat(data->path, &st) && st.st_size) {
 228                 char oldname[PATH_MAX];
 229                 int ret;
 230
 231                 snprintf(oldname, sizeof(oldname), "%s.old",
 232                          data->path);
 233
 234                 ret = rm_rf_perf_data(oldname);
 235                 if (ret) {
 236                         pr_err("Can't remove old data: %s (%s)\n",
 237                                ret == -2 ?
 238                                "Unknown file found" : strerror(errno),
 239                                oldname);
 240                         return -1;
 241                 }
 242
 243                 if (rename(data->path, oldname)) {
 244                         pr_err("Can't move data: %s (%s to %s)\n",
 245                                strerror(errno),
 246                                data->path, oldname);
 247                         return -1;
 248                 }
 249         }
 250
 251         return 0;
 252 }
 253
 254 static bool is_dir(struct perf_data *data)
 255 {
 256         struct stat st;
 257
 258         if (stat(data->path, &st))
 259                 return false;
 260
 261         return (st.st_mode & S_IFMT) == S_IFDIR;
 262 }
 263
 264 static int open_file_read(struct perf_data *data)
 265 {
 266         int flags = data->in_place_update ? O_RDWR : O_RDONLY;
 267         struct stat st;
 268         int fd;
 269         char sbuf[STRERR_BUFSIZE];
 270
 271         fd = open(data->file.path, flags);
 272         if (fd < 0) {
 273                 int err = errno;
 274
 275                 pr_err("failed to open %s: %s", data->file.path,
 276                         str_error_r(err, sbuf, sizeof(sbuf)));
 277                 if (err == ENOENT && !strcmp(data->file.path, "perf.data"))
 278                         pr_err("  (try 'perf record' first)");
 279                 pr_err("\n");
 280                 return -err;
 281         }
 282
 283         if (fstat(fd, &st) < 0)
 284                 goto out_close;
 285
 286         if (!data->force && st.st_uid && (st.st_uid != geteuid())) {
 287                 pr_err("File %s not owned by current user or root (use -f to override)\n",
 288                        data->file.path);
 289                 goto out_close;
 290         }
 291
 292         if (!st.st_size) {
 293                 pr_info("zero-sized data (%s), nothing to do!\n",
 294                         data->file.path);
 295                 goto out_close;
 296         }
 297
 298         data->file.size = st.st_size;
 299         return fd;
 300
 301  out_close:
 302         close(fd);
 303         return -1;
 304 }
 305
 306 static int open_file_write(struct perf_data *data)
 307 {
 308         int fd;
 309         char sbuf[STRERR_BUFSIZE];
 310
 311         fd = open(data->file.path, O_CREAT|O_RDWR|O_TRUNC|O_CLOEXEC,
 312                   S_IRUSR|S_IWUSR);
 313
 314         if (fd < 0)
 315                 pr_err("failed to open %s : %s\n", data->file.path,
 316                         str_error_r(errno, sbuf, sizeof(sbuf)));
 317
 318         return fd;
 319 }
 320
 321 static int open_file(struct perf_data *data)
 322 {
 323         int fd;
 324
 325         fd = perf_data__is_read(data) ?
 326              open_file_read(data) : open_file_write(data);
 327
 328         if (fd < 0) {
 329                 zfree(&data->file.path);
 330                 return -1;
 331         }
 332
 333         data->file.fd = fd;
 334         return 0;
 335 }
 336
 337 static int open_file_dup(struct perf_data *data)
 338 {
 339         data->file.path = strdup(data->path);
 340         if (!data->file.path)
 341                 return -ENOMEM;
 342
 343         return open_file(data);
 344 }
 345
 346 static int open_dir(struct perf_data *data)
 347 {
 348         int ret;
 349
 350         /*
 351          * So far we open only the header, so we can read the data version and
 352          * layout.
 353          */
 354         if (asprintf(&data->file.path, "%s/data", data->path) < 0)
 355                 return -1;
 356
 357         if (perf_data__is_write(data) &&
 358             mkdir(data->path, S_IRWXU) < 0)
 359                 return -1;
 360
 361         ret = open_file(data);
 362
 363         /* Cleanup whatever we managed to create so far. */
 364         if (ret && perf_data__is_write(data))
 365                 rm_rf_perf_data(data->path);
 366
 367         return ret;
 368 }
 369
 370 int perf_data__open(struct perf_data *data)
 371 {
 372         if (check_pipe(data))
 373                 return 0;
 374
 375         /* currently it allows stdio for pipe only */
 376         data->use_stdio = false;
 377
 378         if (!data->path)
 379                 data->path = "perf.data";
 380
 381         if (check_backup(data))
 382                 return -1;
 383
 384         if (perf_data__is_read(data))
 385                 data->is_dir = is_dir(data);
 386
 387         return perf_data__is_dir(data) ?
 388                open_dir(data) : open_file_dup(data);
 389 }
 390
 391 void perf_data__close(struct perf_data *data)
 392 {
 393         if (perf_data__is_dir(data))
 394                 perf_data__close_dir(data);
 395
 396         zfree(&data->file.path);
 397
 398         if (data->use_stdio)
 399                 fclose(data->file.fptr);
 400         else
 401                 close(data->file.fd);
 402 }
 403
 404 ssize_t perf_data__read(struct perf_data *data, void *buf, size_t size)
 405 {
 406         if (data->use_stdio) {
 407                 if (fread(buf, size, 1, data->file.fptr) == 1)
 408                         return size;
 409                 return feof(data->file.fptr) ? 0 : -1;
 410         }
 411         return readn(data->file.fd, buf, size);
 412 }
 413
 414 ssize_t perf_data_file__write(struct perf_data_file *file,
 415                               void *buf, size_t size)
 416 {
 417         return writen(file->fd, buf, size);
 418 }
 419
 420 ssize_t perf_data__write(struct perf_data *data,
 421                          void *buf, size_t size)
 422 {
 423         if (data->use_stdio) {
 424                 if (fwrite(buf, size, 1, data->file.fptr) == 1)
 425                         return size;
 426                 return -1;
 427         }
 428         return perf_data_file__write(&data->file, buf, size);
 429 }
 430
 431 int perf_data__switch(struct perf_data *data,
 432                       const char *postfix,
 433                       size_t pos, bool at_exit,
 434                       char **new_filepath)
 435 {
 436         int ret;
 437
 438         if (perf_data__is_read(data))
 439                 return -EINVAL;
 440
 441         if (asprintf(new_filepath, "%s.%s", data->path, postfix) < 0)
 442                 return -ENOMEM;
 443
 444         /*
 445          * Only fire a warning, don't return error, continue fill
 446          * original file.
 447          */
 448         if (rename(data->path, *new_filepath))
 449                 pr_warning("Failed to rename %s to %s\n", data->path, *new_filepath);
 450
 451         if (!at_exit) {
 452                 close(data->file.fd);
 453                 ret = perf_data__open(data);
 454                 if (ret < 0)
 455                         goto out;
 456
 457                 if (lseek(data->file.fd, pos, SEEK_SET) == (off_t)-1) {
 458                         ret = -errno;
 459                         pr_debug("Failed to lseek to %zu: %s",
 460                                  pos, strerror(errno));
 461                         goto out;
 462                 }
 463         }
 464         ret = data->file.fd;
 465 out:
 466         return ret;
 467 }
 468
 469 unsigned long perf_data__size(struct perf_data *data)
 470 {
 471         u64 size = data->file.size;
 472         int i;
 473
 474         if (perf_data__is_single_file(data))
 475                 return size;
 476
 477         for (i = 0; i < data->dir.nr; i++) {
 478                 struct perf_data_file *file = &data->dir.files[i];
 479
 480                 size += file->size;
 481         }
 482
 483         return size;
 484 }
 485
 486 int perf_data__make_kcore_dir(struct perf_data *data, char *buf, size_t buf_sz)
 487 {
 488         int ret;
 489
 490         if (!data->is_dir)
 491                 return -1;
 492
 493         ret = snprintf(buf, buf_sz, "%s/kcore_dir", data->path);
 494         if (ret < 0 || (size_t)ret >= buf_sz)
 495                 return -1;
 496
 497         return mkdir(buf, S_IRWXU);
 498 }
 499
 500 bool has_kcore_dir(const char *path)
 501 {
 502         struct dirent *d = ERR_PTR(-EINVAL);
 503         const char *name = "kcore_dir";
 504         DIR *dir = opendir(path);
 505         size_t n = strlen(name);
 506         bool result = false;
 507
 508         if (dir) {
 509                 while (d && !result) {
 510                         d = readdir(dir);
 511                         result = d ? strncmp(d->d_name, name, n) : false;
 512                 }
 513                 closedir(dir);
 514         }
 515
 516         return result;
 517 }
 518
 519 char *perf_data__kallsyms_name(struct perf_data *data)
 520 {
 521         char *kallsyms_name;
 522         struct stat st;
 523
 524         if (!data->is_dir)
 525                 return NULL;
 526
 527         if (asprintf(&kallsyms_name, "%s/kcore_dir/kallsyms", data->path) < 0)
 528                 return NULL;
 529
 530         if (stat(kallsyms_name, &st)) {
 531                 free(kallsyms_name);
 532                 return NULL;
 533         }
 534
 535         return kallsyms_name;
 536 }
 537
 538 char *perf_data__guest_kallsyms_name(struct perf_data *data, pid_t machine_pid)
 539 {
 540         char *kallsyms_name;
 541         struct stat st;
 542
 543         if (!data->is_dir)
 544                 return NULL;
 545
 546         if (asprintf(&kallsyms_name, "%s/kcore_dir__%d/kallsyms", data->path, machine_pid) < 0)
 547                 return NULL;
 548
 549         if (stat(kallsyms_name, &st)) {
 550                 free(kallsyms_name);
 551                 return NULL;
 552         }
 553
 554         return kallsyms_name;
 555 }
 556
 557 bool is_perf_data(const char *path)
 558 {
 559         bool ret = false;
 560         FILE *file;
 561         u64 magic;
 562
 563         file = fopen(path, "r");
 564         if (!file)
 565                 return false;
 566
 567         if (fread(&magic, 1, 8, file) < 8)
 568                 goto out;
 569
 570         ret = is_perf_magic(magic);
 571 out:
 572         fclose(file);
 573         return ret;
 574 }