tools/testing/selftests/powerpc/utils.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright 2013-2015, Michael Ellerman, IBM Corp.
   4  */
   5
   6 #define _GNU_SOURCE     /* For CPU_ZERO etc. */
   7
   8 #include <elf.h>
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <inttypes.h>
  12 #include <limits.h>
  13 #include <link.h>
  14 #include <sched.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <sys/ioctl.h>
  19 #include <sys/stat.h>
  20 #include <sys/sysinfo.h>
  21 #include <sys/types.h>
  22 #include <sys/utsname.h>
  23 #include <unistd.h>
  24 #include <asm/unistd.h>
  25 #include <linux/limits.h>
  26
  27 #include "utils.h"
  28
  29 static char auxv[4096];
  30
  31 int read_file(const char *path, char *buf, size_t count, size_t *len)
  32 {
  33         ssize_t rc;
  34         int fd;
  35         int err;
  36         char eof;
  37
  38         fd = open(path, O_RDONLY);
  39         if (fd < 0)
  40                 return -errno;
  41
  42         rc = read(fd, buf, count);
  43         if (rc < 0) {
  44                 err = -errno;
  45                 goto out;
  46         }
  47
  48         if (len)
  49                 *len = rc;
  50
  51         /* Overflow if there are still more bytes after filling the buffer */
  52         if (rc == count) {
  53                 rc = read(fd, &eof, 1);
  54                 if (rc != 0) {
  55                         err = -EOVERFLOW;
  56                         goto out;
  57                 }
  58         }
  59
  60         err = 0;
  61
  62 out:
  63         close(fd);
  64         errno = -err;
  65         return err;
  66 }
  67
  68 int read_file_alloc(const char *path, char **buf, size_t *len)
  69 {
  70         size_t read_offset = 0;
  71         size_t buffer_len = 0;
  72         char *buffer = NULL;
  73         int err;
  74         int fd;
  75
  76         fd = open(path, O_RDONLY);
  77         if (fd < 0)
  78                 return -errno;
  79
  80         /*
  81          * We don't use stat & preallocate st_size because some non-files
  82          * report 0 file size. Instead just dynamically grow the buffer
  83          * as needed.
  84          */
  85         while (1) {
  86                 ssize_t rc;
  87
  88                 if (read_offset >= buffer_len / 2) {
  89                         char *next_buffer;
  90
  91                         buffer_len = buffer_len ? buffer_len * 2 : 4096;
  92                         next_buffer = realloc(buffer, buffer_len);
  93                         if (!next_buffer) {
  94                                 err = -errno;
  95                                 goto out;
  96                         }
  97                         buffer = next_buffer;
  98                 }
  99
 100                 rc = read(fd, buffer + read_offset, buffer_len - read_offset);
 101                 if (rc < 0) {
 102                         err = -errno;
 103                         goto out;
 104                 }
 105
 106                 if (rc == 0)
 107                         break;
 108
 109                 read_offset += rc;
 110         }
 111
 112         *buf = buffer;
 113         if (len)
 114                 *len = read_offset;
 115
 116         err = 0;
 117
 118 out:
 119         close(fd);
 120         if (err)
 121                 free(buffer);
 122         errno = -err;
 123         return err;
 124 }
 125
 126 int write_file(const char *path, const char *buf, size_t count)
 127 {
 128         int fd;
 129         int err;
 130         ssize_t rc;
 131
 132         fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
 133         if (fd < 0)
 134                 return -errno;
 135
 136         rc = write(fd, buf, count);
 137         if (rc < 0) {
 138                 err = -errno;
 139                 goto out;
 140         }
 141
 142         if (rc != count) {
 143                 err = -EOVERFLOW;
 144                 goto out;
 145         }
 146
 147         err = 0;
 148
 149 out:
 150         close(fd);
 151         errno = -err;
 152         return err;
 153 }
 154
 155 int read_auxv(char *buf, ssize_t buf_size)
 156 {
 157         int err;
 158
 159         err = read_file("/proc/self/auxv", buf, buf_size, NULL);
 160         if (err) {
 161                 perror("Error reading /proc/self/auxv");
 162                 return err;
 163         }
 164
 165         return 0;
 166 }
 167
 168 int read_debugfs_file(const char *subpath, char *buf, size_t count)
 169 {
 170         char path[PATH_MAX] = "/sys/kernel/debug/";
 171
 172         strncat(path, subpath, sizeof(path) - strlen(path) - 1);
 173
 174         return read_file(path, buf, count, NULL);
 175 }
 176
 177 int write_debugfs_file(const char *subpath, const char *buf, size_t count)
 178 {
 179         char path[PATH_MAX] = "/sys/kernel/debug/";
 180
 181         strncat(path, subpath, sizeof(path) - strlen(path) - 1);
 182
 183         return write_file(path, buf, count);
 184 }
 185
 186 static int validate_int_parse(const char *buffer, size_t count, char *end)
 187 {
 188         int err = 0;
 189
 190         /* Require at least one digit */
 191         if (end == buffer) {
 192                 err = -EINVAL;
 193                 goto out;
 194         }
 195
 196         /* Require all remaining characters be whitespace-ish */
 197         for (; end < buffer + count; end++) {
 198                 if (*end == '\0')
 199                         break;
 200
 201                 if (*end != ' ' && *end != '\n') {
 202                         err = -EINVAL;
 203                         goto out;
 204                 }
 205         }
 206
 207 out:
 208         errno = -err;
 209         return err;
 210 }
 211
 212 static int parse_bounded_int(const char *buffer, size_t count, intmax_t *result,
 213                              int base, intmax_t min, intmax_t max)
 214 {
 215         int err;
 216         char *end;
 217
 218         errno = 0;
 219         *result = strtoimax(buffer, &end, base);
 220
 221         if (errno)
 222                 return -errno;
 223
 224         err = validate_int_parse(buffer, count, end);
 225         if (err)
 226                 goto out;
 227
 228         if (*result < min || *result > max)
 229                 err = -EOVERFLOW;
 230
 231 out:
 232         errno = -err;
 233         return err;
 234 }
 235
 236 static int parse_bounded_uint(const char *buffer, size_t count, uintmax_t *result,
 237                               int base, uintmax_t max)
 238 {
 239         int err = 0;
 240         char *end;
 241
 242         errno = 0;
 243         *result = strtoumax(buffer, &end, base);
 244
 245         if (errno)
 246                 return -errno;
 247
 248         err = validate_int_parse(buffer, count, end);
 249         if (err)
 250                 goto out;
 251
 252         if (*result > max)
 253                 err = -EOVERFLOW;
 254
 255 out:
 256         errno = -err;
 257         return err;
 258 }
 259
 260 int parse_intmax(const char *buffer, size_t count, intmax_t *result, int base)
 261 {
 262         return parse_bounded_int(buffer, count, result, base, INTMAX_MIN, INTMAX_MAX);
 263 }
 264
 265 int parse_uintmax(const char *buffer, size_t count, uintmax_t *result, int base)
 266 {
 267         return parse_bounded_uint(buffer, count, result, base, UINTMAX_MAX);
 268 }
 269
 270 int parse_int(const char *buffer, size_t count, int *result, int base)
 271 {
 272         intmax_t parsed;
 273         int err = parse_bounded_int(buffer, count, &parsed, base, INT_MIN, INT_MAX);
 274
 275         *result = parsed;
 276         return err;
 277 }
 278
 279 int parse_uint(const char *buffer, size_t count, unsigned int *result, int base)
 280 {
 281         uintmax_t parsed;
 282         int err = parse_bounded_uint(buffer, count, &parsed, base, UINT_MAX);
 283
 284         *result = parsed;
 285         return err;
 286 }
 287
 288 int parse_long(const char *buffer, size_t count, long *result, int base)
 289 {
 290         intmax_t parsed;
 291         int err = parse_bounded_int(buffer, count, &parsed, base, LONG_MIN, LONG_MAX);
 292
 293         *result = parsed;
 294         return err;
 295 }
 296
 297 int parse_ulong(const char *buffer, size_t count, unsigned long *result, int base)
 298 {
 299         uintmax_t parsed;
 300         int err = parse_bounded_uint(buffer, count, &parsed, base, ULONG_MAX);
 301
 302         *result = parsed;
 303         return err;
 304 }
 305
 306 int read_long(const char *path, long *result, int base)
 307 {
 308         int err;
 309         char buffer[32] = {0};
 310
 311         err = read_file(path, buffer, sizeof(buffer) - 1, NULL);
 312         if (err)
 313                 return err;
 314
 315         return parse_long(buffer, sizeof(buffer), result, base);
 316 }
 317
 318 int read_ulong(const char *path, unsigned long *result, int base)
 319 {
 320         int err;
 321         char buffer[32] = {0};
 322
 323         err = read_file(path, buffer, sizeof(buffer) - 1, NULL);
 324         if (err)
 325                 return err;
 326
 327         return parse_ulong(buffer, sizeof(buffer), result, base);
 328 }
 329
 330 int write_long(const char *path, long result, int base)
 331 {
 332         int err;
 333         int len;
 334         char buffer[32];
 335
 336         /* Decimal only for now: no format specifier for signed hex values */
 337         if (base != 10) {
 338                 err = -EINVAL;
 339                 goto out;
 340         }
 341
 342         len = snprintf(buffer, sizeof(buffer), "%ld", result);
 343         if (len < 0 || len >= sizeof(buffer)) {
 344                 err = -EOVERFLOW;
 345                 goto out;
 346         }
 347
 348         err = write_file(path, buffer, len);
 349
 350 out:
 351         errno = -err;
 352         return err;
 353 }
 354
 355 int write_ulong(const char *path, unsigned long result, int base)
 356 {
 357         int err;
 358         int len;
 359         char buffer[32];
 360         char *fmt;
 361
 362         switch (base) {
 363         case 10:
 364                 fmt = "%lu";
 365                 break;
 366         case 16:
 367                 fmt = "%lx";
 368                 break;
 369         default:
 370                 err = -EINVAL;
 371                 goto out;
 372         }
 373
 374         len = snprintf(buffer, sizeof(buffer), fmt, result);
 375         if (len < 0 || len >= sizeof(buffer)) {
 376                 err = -errno;
 377                 goto out;
 378         }
 379
 380         err = write_file(path, buffer, len);
 381
 382 out:
 383         errno = -err;
 384         return err;
 385 }
 386
 387 void *find_auxv_entry(int type, char *auxv)
 388 {
 389         ElfW(auxv_t) *p;
 390
 391         p = (ElfW(auxv_t) *)auxv;
 392
 393         while (p->a_type != AT_NULL) {
 394                 if (p->a_type == type)
 395                         return p;
 396
 397                 p++;
 398         }
 399
 400         return NULL;
 401 }
 402
 403 void *get_auxv_entry(int type)
 404 {
 405         ElfW(auxv_t) *p;
 406
 407         if (read_auxv(auxv, sizeof(auxv)))
 408                 return NULL;
 409
 410         p = find_auxv_entry(type, auxv);
 411         if (p)
 412                 return (void *)p->a_un.a_val;
 413
 414         return NULL;
 415 }
 416
 417 int pick_online_cpu(void)
 418 {
 419         int ncpus, cpu = -1;
 420         cpu_set_t *mask;
 421         size_t size;
 422
 423         ncpus = get_nprocs_conf();
 424         size = CPU_ALLOC_SIZE(ncpus);
 425         mask = CPU_ALLOC(ncpus);
 426         if (!mask) {
 427                 perror("malloc");
 428                 return -1;
 429         }
 430
 431         CPU_ZERO_S(size, mask);
 432
 433         if (sched_getaffinity(0, size, mask)) {
 434                 perror("sched_getaffinity");
 435                 goto done;
 436         }
 437
 438         /* We prefer a primary thread, but skip 0 */
 439         for (cpu = 8; cpu < ncpus; cpu += 8)
 440                 if (CPU_ISSET_S(cpu, size, mask))
 441                         goto done;
 442
 443         /* Search for anything, but in reverse */
 444         for (cpu = ncpus - 1; cpu >= 0; cpu--)
 445                 if (CPU_ISSET_S(cpu, size, mask))
 446                         goto done;
 447
 448         printf("No cpus in affinity mask?!\n");
 449
 450 done:
 451         CPU_FREE(mask);
 452         return cpu;
 453 }
 454
 455 int bind_to_cpu(int cpu)
 456 {
 457         cpu_set_t mask;
 458         int err;
 459
 460         if (cpu == BIND_CPU_ANY) {
 461                 cpu = pick_online_cpu();
 462                 if (cpu < 0)
 463                         return cpu;
 464         }
 465
 466         printf("Binding to cpu %d\n", cpu);
 467
 468         CPU_ZERO(&mask);
 469         CPU_SET(cpu, &mask);
 470
 471         err = sched_setaffinity(0, sizeof(mask), &mask);
 472         if (err)
 473                 return err;
 474
 475         return cpu;
 476 }
 477
 478 bool is_ppc64le(void)
 479 {
 480         struct utsname uts;
 481         int rc;
 482
 483         errno = 0;
 484         rc = uname(&uts);
 485         if (rc) {
 486                 perror("uname");
 487                 return false;
 488         }
 489
 490         return strcmp(uts.machine, "ppc64le") == 0;
 491 }
 492
 493 int read_sysfs_file(char *fpath, char *result, size_t result_size)
 494 {
 495         char path[PATH_MAX] = "/sys/";
 496
 497         strncat(path, fpath, PATH_MAX - strlen(path) - 1);
 498
 499         return read_file(path, result, result_size, NULL);
 500 }
 501
 502 int read_debugfs_int(const char *debugfs_file, int *result)
 503 {
 504         int err;
 505         char value[16] = {0};
 506
 507         err = read_debugfs_file(debugfs_file, value, sizeof(value) - 1);
 508         if (err)
 509                 return err;
 510
 511         return parse_int(value, sizeof(value), result, 10);
 512 }
 513
 514 int write_debugfs_int(const char *debugfs_file, int result)
 515 {
 516         char value[16];
 517
 518         snprintf(value, 16, "%d", result);
 519
 520         return write_debugfs_file(debugfs_file, value, strlen(value));
 521 }
 522
 523 static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
 524                 int cpu, int group_fd, unsigned long flags)
 525 {
 526         return syscall(__NR_perf_event_open, hw_event, pid, cpu,
 527                       group_fd, flags);
 528 }
 529
 530 static void perf_event_attr_init(struct perf_event_attr *event_attr,
 531                                         unsigned int type,
 532                                         unsigned long config)
 533 {
 534         memset(event_attr, 0, sizeof(*event_attr));
 535
 536         event_attr->type = type;
 537         event_attr->size = sizeof(struct perf_event_attr);
 538         event_attr->config = config;
 539         event_attr->read_format = PERF_FORMAT_GROUP;
 540         event_attr->disabled = 1;
 541         event_attr->exclude_kernel = 1;
 542         event_attr->exclude_hv = 1;
 543         event_attr->exclude_guest = 1;
 544 }
 545
 546 int perf_event_open_counter(unsigned int type,
 547                             unsigned long config, int group_fd)
 548 {
 549         int fd;
 550         struct perf_event_attr event_attr;
 551
 552         perf_event_attr_init(&event_attr, type, config);
 553
 554         fd = perf_event_open(&event_attr, 0, -1, group_fd, 0);
 555
 556         if (fd < 0)
 557                 perror("perf_event_open() failed");
 558
 559         return fd;
 560 }
 561
 562 int perf_event_enable(int fd)
 563 {
 564         if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
 565                 perror("error while enabling perf events");
 566                 return -1;
 567         }
 568
 569         return 0;
 570 }
 571
 572 int perf_event_disable(int fd)
 573 {
 574         if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
 575                 perror("error disabling perf events");
 576                 return -1;
 577         }
 578
 579         return 0;
 580 }
 581
 582 int perf_event_reset(int fd)
 583 {
 584         if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
 585                 perror("error resetting perf events");
 586                 return -1;
 587         }
 588
 589         return 0;
 590 }
 591
 592 int using_hash_mmu(bool *using_hash)
 593 {
 594         char line[128];
 595         FILE *f;
 596         int rc;
 597
 598         f = fopen("/proc/cpuinfo", "r");
 599         FAIL_IF(!f);
 600
 601         rc = 0;
 602         while (fgets(line, sizeof(line), f) != NULL) {
 603                 if (!strcmp(line, "MMU          : Hash\n") ||
 604                     !strcmp(line, "platform     : Cell\n") ||
 605                     !strcmp(line, "platform     : PowerMac\n")) {
 606                         *using_hash = true;
 607                         goto out;
 608                 }
 609
 610                 if (strcmp(line, "MMU           : Radix\n") == 0) {
 611                         *using_hash = false;
 612                         goto out;
 613                 }
 614         }
 615
 616         rc = -1;
 617 out:
 618         fclose(f);
 619         return rc;
 620 }
 621
 622 struct sigaction push_signal_handler(int sig, void (*fn)(int, siginfo_t *, void *))
 623 {
 624         struct sigaction sa;
 625         struct sigaction old_handler;
 626
 627         sa.sa_sigaction = fn;
 628         sigemptyset(&sa.sa_mask);
 629         sa.sa_flags = SA_SIGINFO;
 630         FAIL_IF_EXIT_MSG(sigaction(sig, &sa, &old_handler),
 631                          "failed to push signal handler");
 632
 633         return old_handler;
 634 }
 635
 636 struct sigaction pop_signal_handler(int sig, struct sigaction old_handler)
 637 {
 638         struct sigaction popped;
 639
 640         FAIL_IF_EXIT_MSG(sigaction(sig, &old_handler, &popped),
 641                          "failed to pop signal handler");
 642
 643         return popped;
 644 }