SSL utils.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright 2013-2015, Michael Ellerman, IBM Corp.
 */

#define _GNU_SOURCE /* For CPU_ZERO etc. */

#include <elf.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <link.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/sysinfo.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <unistd.h>
#include <asm/unistd.h>
#include <linux/limits.h>

#include "utils.h"

static char auxv[4096];

int read_file(const char *path, char *buf, size_t count, size_t *len)
{
 ssize_t rc;
 int fd;
 int err;
 char eof;

 fd = open(path, O_RDONLY);
 if (fd < 0)
  return -errno;

 rc = read(fd, buf, count);
 if (rc < 0) {
  err = -errno;
  goto out;
 }

 if (len)
  *len = rc;

 /* Overflow if there are still more bytes after filling the buffer */
 if (rc == count) {
  rc = read(fd, &eof, 1);
  if (rc != 0) {
   err = -EOVERFLOW;
   goto out;
  }
 }

 err = 0;

out:
 close(fd);
 errno = -err;
 return err;
}

int read_file_alloc(const char *path, char **buf, size_t *len)
{
 size_t read_offset = 0;
 size_t buffer_len = 0;
 char *buffer = NULL;
 int err;
 int fd;

 fd = open(path, O_RDONLY);
 if (fd < 0)
  return -errno;

 /*
 * We don't use stat & preallocate st_size because some non-files
 * report 0 file size. Instead just dynamically grow the buffer
 * as needed.
 */
 while (1) {
  ssize_t rc;

  if (read_offset >= buffer_len / 2) {
   char *next_buffer;

   buffer_len = buffer_len ? buffer_len * 2 : 4096;
   next_buffer = realloc(buffer, buffer_len);
   if (!next_buffer) {
    err = -errno;
    goto out;
   }
   buffer = next_buffer;
  }

  rc = read(fd, buffer + read_offset, buffer_len - read_offset);
  if (rc < 0) {
   err = -errno;
   goto out;
  }

  if (rc == 0)
   break;

  read_offset += rc;
 }

 *buf = buffer;
 if (len)
  *len = read_offset;

 err = 0;

out:
 close(fd);
 if (err)
  free(buffer);
 errno = -err;
 return err;
}

int write_file(const char *path, const char *buf, size_t count)
{
 int fd;
 int err;
 ssize_t rc;

 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
 if (fd < 0)
  return -errno;

 rc = write(fd, buf, count);
 if (rc < 0) {
  err = -errno;
  goto out;
 }

 if (rc != count) {
  err = -EOVERFLOW;
  goto out;
 }

 err = 0;

out:
 close(fd);
 errno = -err;
 return err;
}

int read_auxv(char *buf, ssize_t buf_size)
{
 int err;

 err = read_file("/proc/self/auxv", buf, buf_size, NULL);
 if (err) {
  perror("Error reading /proc/self/auxv");
  return err;
 }

 return 0;
}

int read_debugfs_file(const char *subpath, char *buf, size_t count)
{
 char path[PATH_MAX] = "/sys/kernel/debug/";

 strncat(path, subpath, sizeof(path) - strlen(path) - 1);

 return read_file(path, buf, count, NULL);
}

int write_debugfs_file(const char *subpath, const char *buf, size_t count)
{
 char path[PATH_MAX] = "/sys/kernel/debug/";

 strncat(path, subpath, sizeof(path) - strlen(path) - 1);

 return write_file(path, buf, count);
}

static int validate_int_parse(const char *buffer, size_t count, char *end)
{
 int err = 0;

 /* Require at least one digit */
 if (end == buffer) {
  err = -EINVAL;
  goto out;
 }

 /* Require all remaining characters be whitespace-ish */
 for (; end < buffer + count; end++) {
  if (*end == '\0')
   break;

  if (*end != ' ' && *end != '\n') {
   err = -EINVAL;
   goto out;
  }
 }

out:
 errno = -err;
 return err;
}

static int parse_bounded_int(const char *buffer, size_t count, intmax_t *result,
        int base, intmax_t min, intmax_t max)
{
 int err;
 char *end;

 errno = 0;
 *result = strtoimax(buffer, &end, base);

 if (errno)
  return -errno;

 err = validate_int_parse(buffer, count, end);
 if (err)
  goto out;

 if (*result < min || *result > max)
  err = -EOVERFLOW;

out:
 errno = -err;
 return err;
}

static int parse_bounded_uint(const char *buffer, size_t count, uintmax_t *result,
         int base, uintmax_t max)
{
 int err = 0;
 char *end;

 errno = 0;
 *result = strtoumax(buffer, &end, base);

 if (errno)
  return -errno;

 err = validate_int_parse(buffer, count, end);
 if (err)
  goto out;

 if (*result > max)
  err = -EOVERFLOW;

out:
 errno = -err;
 return err;
}

int parse_intmax(const char *buffer, size_t count, intmax_t *result, int base)
{
 return parse_bounded_int(buffer, count, result, base, INTMAX_MIN, INTMAX_MAX);
}

int parse_uintmax(const char *buffer, size_t count, uintmax_t *result, int base)
{
 return parse_bounded_uint(buffer, count, result, base, UINTMAX_MAX);
}

int parse_int(const char *buffer, size_t count, int *result, int base)
{
 intmax_t parsed;
 int err = parse_bounded_int(buffer, count, &parsed, base, INT_MIN, INT_MAX);

 *result = parsed;
 return err;
}

int parse_uint(const char *buffer, size_t count, unsigned int *result, int base)
{
 uintmax_t parsed;
 int err = parse_bounded_uint(buffer, count, &parsed, base, UINT_MAX);

 *result = parsed;
 return err;
}

int parse_long(const char *buffer, size_t count, long *result, int base)
{
 intmax_t parsed;
 int err = parse_bounded_int(buffer, count, &parsed, base, LONG_MIN, LONG_MAX);

 *result = parsed;
 return err;
}

int parse_ulong(const char *buffer, size_t count, unsigned long *result, int base)
{
 uintmax_t parsed;
 int err = parse_bounded_uint(buffer, count, &parsed, base, ULONG_MAX);

 *result = parsed;
 return err;
}

int read_long(const char *path, long *result, int base)
{
 int err;
 char buffer[32] = {0};

 err = read_file(path, buffer, sizeof(buffer) - 1, NULL);
 if (err)
  return err;

 return parse_long(buffer, sizeof(buffer), result, base);
}

int read_ulong(const char *path, unsigned long *result, int base)
{
 int err;
 char buffer[32] = {0};

 err = read_file(path, buffer, sizeof(buffer) - 1, NULL);
 if (err)
  return err;

 return parse_ulong(buffer, sizeof(buffer), result, base);
}

int write_long(const char *path, long result, int base)
{
 int err;
 int len;
 char buffer[32];

 /* Decimal only for now: no format specifier for signed hex values */
 if (base != 10) {
  err = -EINVAL;
  goto out;
 }

 len = snprintf(buffer, sizeof(buffer), "%ld", result);
 if (len < 0 || len >= sizeof(buffer)) {
  err = -EOVERFLOW;
  goto out;
 }

 err = write_file(path, buffer, len);

out:
 errno = -err;
 return err;
}

int write_ulong(const char *path, unsigned long result, int base)
{
 int err;
 int len;
 char buffer[32];
 char *fmt;

 switch (base) {
 case 10:
  fmt = "%lu";
  break;
 case 16:
  fmt = "%lx";
  break;
 default:
  err = -EINVAL;
  goto out;
 }

 len = snprintf(buffer, sizeof(buffer), fmt, result);
 if (len < 0 || len >= sizeof(buffer)) {
  err = -errno;
  goto out;
 }

 err = write_file(path, buffer, len);

out:
 errno = -err;
 return err;
}

void *find_auxv_entry(int type, char *auxv)
{
 ElfW(auxv_t) *p;

 p = (ElfW(auxv_t) *)auxv;

 while (p->a_type != AT_NULL) {
  if (p->a_type == type)
   return p;

  p++;
 }

 return NULL;
}

void *get_auxv_entry(int type)
{
 ElfW(auxv_t) *p;

 if (read_auxv(auxv, sizeof(auxv)))
  return NULL;

 p = find_auxv_entry(type, auxv);
 if (p)
  return (void *)p->a_un.a_val;

 return NULL;
}

int pick_online_cpu(void)
{
 int ncpus, cpu = -1;
 cpu_set_t *mask;
 size_t size;

 ncpus = get_nprocs_conf();
 size = CPU_ALLOC_SIZE(ncpus);
 mask = CPU_ALLOC(ncpus);
 if (!mask) {
  perror("malloc");
  return -1;
 }

 CPU_ZERO_S(size, mask);

 if (sched_getaffinity(0, size, mask)) {
  perror("sched_getaffinity");
  goto done;
 }

 /* We prefer a primary thread, but skip 0 */
 for (cpu = 8; cpu < ncpus; cpu += 8)
  if (CPU_ISSET_S(cpu, size, mask))
   goto done;

 /* Search for anything, but in reverse */
 for (cpu = ncpus - 1; cpu >= 0; cpu--)
  if (CPU_ISSET_S(cpu, size, mask))
   goto done;

 printf("No cpus in affinity mask?!\n");

done:
 CPU_FREE(mask);
 return cpu;
}

int bind_to_cpu(int cpu)
{
 cpu_set_t mask;
 int err;

 if (cpu == BIND_CPU_ANY) {
  cpu = pick_online_cpu();
  if (cpu < 0)
   return cpu;
 }

 printf("Binding to cpu %d\n", cpu);

 CPU_ZERO(&mask);
 CPU_SET(cpu, &mask);

 err = sched_setaffinity(0, sizeof(mask), &mask);
 if (err)
  return err;

 return cpu;
}

bool is_ppc64le(void)
{
 struct utsname uts;
 int rc;

 errno = 0;
 rc = uname(&uts);
 if (rc) {
  perror("uname");
  return false;
 }

 return strcmp(uts.machine, "ppc64le") == 0;
}

int read_sysfs_file(char *fpath, char *result, size_t result_size)
{
 char path[PATH_MAX] = "/sys/";

 strncat(path, fpath, PATH_MAX - strlen(path) - 1);

 return read_file(path, result, result_size, NULL);
}

int read_debugfs_int(const char *debugfs_file, int *result)
{
 int err;
 char value[16] = {0};

 err = read_debugfs_file(debugfs_file, value, sizeof(value) - 1);
 if (err)
  return err;

 return parse_int(value, sizeof(value), result, 10);
}

int write_debugfs_int(const char *debugfs_file, int result)
{
 char value[16];

 snprintf(value, 16, "%d", result);

 return write_debugfs_file(debugfs_file, value, strlen(value));
}

static long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
  int cpu, int group_fd, unsigned long flags)
{
 return syscall(__NR_perf_event_open, hw_event, pid, cpu,
        group_fd, flags);
}

static void perf_event_attr_init(struct perf_event_attr *event_attr,
     unsigned int type,
     unsigned long config)
{
 memset(event_attr, 0, sizeof(*event_attr));

 event_attr->type = type;
 event_attr->size = sizeof(struct perf_event_attr);
 event_attr->config = config;
 event_attr->read_format = PERF_FORMAT_GROUP;
 event_attr->disabled = 1;
 event_attr->exclude_kernel = 1;
 event_attr->exclude_hv = 1;
 event_attr->exclude_guest = 1;
}

int perf_event_open_counter(unsigned int type,
       unsigned long config, int group_fd)
{
 int fd;
 struct perf_event_attr event_attr;

 perf_event_attr_init(&event_attr, type, config);

 fd = perf_event_open(&event_attr, 0, -1, group_fd, 0);

 if (fd < 0)
  perror("perf_event_open() failed");

 return fd;
}

int perf_event_enable(int fd)
{
 if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
  perror("error while enabling perf events");
  return -1;
 }

 return 0;
}

int perf_event_disable(int fd)
{
 if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
  perror("error disabling perf events");
  return -1;
 }

 return 0;
}

int perf_event_reset(int fd)
{
 if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
  perror("error resetting perf events");
  return -1;
 }

 return 0;
}

int using_hash_mmu(bool *using_hash)
{
 char line[128];
 FILE *f;
 int rc;

 f = fopen("/proc/cpuinfo", "r");
 FAIL_IF(!f);

 rc = 0;
 while (fgets(line, sizeof(line), f) != NULL) {
  if (!strcmp(line, "MMU : Hash\n") ||
      !strcmp(line, "platform : Cell\n") ||
      !strcmp(line, "platform : PowerMac\n")) {
   *using_hash = true;
   goto out;
  }

  if (strcmp(line, "MMU : Radix\n") == 0) {
   *using_hash = false;
   goto out;
  }
 }

 rc = -1;
out:
 fclose(f);
 return rc;
}

struct sigaction push_signal_handler(int sig, void (*fn)(int, siginfo_t *, void *))
{
 struct sigaction sa;
 struct sigaction old_handler;

 sa.sa_sigaction = fn;
 sigemptyset(&sa.sa_mask);
 sa.sa_flags = SA_SIGINFO;
 FAIL_IF_EXIT_MSG(sigaction(sig, &sa, &old_handler),
    "failed to push signal handler");

 return old_handler;
}

struct sigaction pop_signal_handler(int sig, struct sigaction old_handler)
{
 struct sigaction popped;

 FAIL_IF_EXIT_MSG(sigaction(sig, &old_handler, &popped),
    "failed to pop signal handler");

 return popped;
}