src/common/smp.c

   1 /*
   2  * SPDX-License-Identifier: LGPL-2.1-only
   3  *
   4  * Copyright (C) 2011-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   5  * Copyright (C) 2019 Michael Jeanson <mjeanson@efficios.com>
   6  */
   7
   8 #define _LGPL_SOURCE
   9 #include <assert.h>
  10 #include <ctype.h>
  11 #include <dirent.h>
  12 #include <errno.h>
  13 #include <fcntl.h>
  14 #include <limits.h>
  15 #include <unistd.h>
  16 #include <pthread.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <sys/types.h>
  20
  21 #include <urcu/compiler.h>
  22
  23 #include "common/logging.h"
  24 #include "common/smp.h"
  25
  26 #define __max(a,b) ((a)>(b)?(a):(b))
  27
  28 static int possible_cpus_array_len_cache;
  29
  30 /*
  31  * Get the highest CPU id from sysfs.
  32  *
  33  * Iterate on all the folders in "/sys/devices/system/cpu" that start with
  34  * "cpu" followed by an integer, keep the highest CPU id encountered during
  35  * this iteration and add 1 to get a number of CPUs.
  36  *
  37  * Returns the highest CPU id, or -1 on error.
  38  */
  39 int get_max_cpuid_from_sysfs(void)
  40 {
  41         return _get_max_cpuid_from_sysfs("/sys/devices/system/cpu");
  42 }
  43
  44 int _get_max_cpuid_from_sysfs(const char *path)
  45 {
  46         long max_cpuid = -1;
  47
  48         DIR *cpudir;
  49         struct dirent *entry;
  50
  51         assert(path);
  52
  53         cpudir = opendir(path);
  54         if (cpudir == NULL)
  55                 goto end;
  56
  57         /*
  58          * Iterate on all directories named "cpu" followed by an integer.
  59          */
  60         while ((entry = readdir(cpudir))) {
  61                 if (entry->d_type == DT_DIR &&
  62                         strncmp(entry->d_name, "cpu", 3) == 0) {
  63
  64                         char *endptr;
  65                         long cpu_id;
  66
  67                         cpu_id = strtol(entry->d_name + 3, &endptr, 10);
  68                         if ((cpu_id < LONG_MAX) && (endptr != entry->d_name + 3)
  69                                         && (*endptr == '\0')) {
  70                                 if (cpu_id > max_cpuid)
  71                                         max_cpuid = cpu_id;
  72                         }
  73                 }
  74         }
  75
  76         if (closedir(cpudir))
  77                 PERROR("closedir");
  78
  79         /*
  80          * If the max CPU id is out of bound, set it to -1 so it results in a
  81          * CPU num of 0.
  82          */
  83         if (max_cpuid < 0 || max_cpuid > INT_MAX)
  84                 max_cpuid = -1;
  85
  86 end:
  87         return max_cpuid;
  88 }
  89
  90 /*
  91  * As a fallback to parsing the CPU mask in "/sys/devices/system/cpu/possible",
  92  * iterate on all the folders in "/sys/devices/system/cpu" that start with
  93  * "cpu" followed by an integer, keep the highest CPU id encountered during
  94  * this iteration and add 1 to get a number of CPUs.
  95  *
  96  * Then get the value from sysconf(_SC_NPROCESSORS_CONF) as a fallback and
  97  * return the highest one.
  98  *
  99  * On Linux, using the value from sysconf can be unreliable since the way it
 100  * counts CPUs varies between C libraries and even between versions of the same
 101  * library. If we used it directly, getcpu() could return a value greater than
 102  * this sysconf, in which case the arrays indexed by processor would overflow.
 103  *
 104  * As another example, the MUSL libc implementation of the _SC_NPROCESSORS_CONF
 105  * sysconf does not return the number of configured CPUs in the system but
 106  * relies on the cpu affinity mask of the current task.
 107  *
 108  * Returns 0 or less on error.
 109  */
 110 int get_num_possible_cpus_fallback(void)
 111 {
 112         /*
 113          * Get the sysconf value as a last resort. Keep the highest number.
 114          */
 115         return __max(sysconf(_SC_NPROCESSORS_CONF), get_max_cpuid_from_sysfs() + 1);
 116 }
 117
 118 /*
 119  * Get the CPU possible mask string from sysfs.
 120  *
 121  * buf: the buffer where the mask will be read.
 122  * max_bytes: the maximum number of bytes to write in the buffer.
 123  *
 124  * Returns the number of bytes read or -1 on error.
 125  */
 126 int get_possible_cpu_mask_from_sysfs(char *buf, size_t max_bytes)
 127 {
 128         return get_cpu_mask_from_sysfs(buf, max_bytes,
 129                         "/sys/devices/system/cpu/possible");
 130 }
 131
 132 /*
 133  * Get a CPU mask string from sysfs.
 134  *
 135  * buf: the buffer where the mask will be read.
 136  * max_bytes: the maximum number of bytes to write in the buffer.
 137  * path: file path to read the mask from.
 138  *
 139  * Returns the number of bytes read or -1 on error.
 140  */
 141 int get_cpu_mask_from_sysfs(char *buf, size_t max_bytes, const char *path)
 142 {
 143         ssize_t bytes_read = 0;
 144         size_t total_bytes_read = 0;
 145         int fd = -1, ret = -1;
 146
 147         assert(path);
 148
 149         if (buf == NULL)
 150                 goto end;
 151
 152         fd = open(path, O_RDONLY);
 153         if (fd < 0)
 154                 goto end;
 155
 156         do {
 157                 bytes_read = read(fd, buf + total_bytes_read,
 158                                 max_bytes - total_bytes_read);
 159
 160                 if (bytes_read < 0) {
 161                         if (errno == EINTR) {
 162                                 continue;       /* retry operation */
 163                         } else {
 164                                 goto end;
 165                         }
 166                 }
 167
 168                 total_bytes_read += bytes_read;
 169                 assert(total_bytes_read <= max_bytes);
 170         } while (max_bytes > total_bytes_read && bytes_read > 0);
 171
 172         /*
 173          * Make sure the mask read is a null terminated string.
 174          */
 175         if (total_bytes_read < max_bytes)
 176                 buf[total_bytes_read] = '\0';
 177         else
 178                 buf[max_bytes - 1] = '\0';
 179
 180         if (total_bytes_read > INT_MAX)
 181                 goto end;
 182         ret = (int) total_bytes_read;
 183 end:
 184         if (fd >= 0 && close(fd) < 0)
 185                 PERROR("close");
 186         return ret;
 187 }
 188
 189 /*
 190  * Get the highest CPU id from a CPU mask.
 191  *
 192  * pmask: the mask to parse.
 193  * len: the len of the mask excluding '\0'.
 194  *
 195  * Returns the highest CPU id from the mask or -1 on error.
 196  */
 197 int get_max_cpuid_from_mask(const char *pmask, size_t len)
 198 {
 199         ssize_t i;
 200         unsigned long cpu_index;
 201         char *endptr;
 202
 203         /* We need at least one char to read */
 204         if (len < 1)
 205                 goto error;
 206
 207         /* Start from the end to read the last CPU index. */
 208         for (i = len - 1; i > 0; i--) {
 209                 /* Break when we hit the first separator. */
 210                 if ((pmask[i] == ',') || (pmask[i] == '-')) {
 211                         i++;
 212                         break;
 213                 }
 214         }
 215
 216         cpu_index = strtoul(&pmask[i], &endptr, 10);
 217
 218         /*
 219          * If we read a CPU index, increment it by one to return a number of
 220          * CPUs.
 221          */
 222         if ((&pmask[i] != endptr) && (cpu_index < INT_MAX))
 223                 return (int) cpu_index;
 224
 225 error:
 226         return -1;
 227 }
 228
 229 static void update_possible_cpus_array_len_cache(void)
 230 {
 231         int ret;
 232         char buf[LTTNG_UST_CPUMASK_SIZE];
 233
 234         /* Get the possible cpu mask from sysfs, fallback to sysconf. */
 235         ret = get_possible_cpu_mask_from_sysfs((char *) &buf, LTTNG_UST_CPUMASK_SIZE);
 236         if (ret <= 0)
 237                 goto fallback;
 238
 239         /* Parse the possible cpu mask, on failure fallback to sysconf. */
 240         ret = get_max_cpuid_from_mask((char *) &buf, ret);
 241         if (ret >= 0) {
 242                 /* Add 1 to convert from max cpuid to an array len. */
 243                 ret++;
 244                 goto end;
 245         }
 246
 247 fallback:
 248         /* Fallback to sysconf. */
 249         ret = get_num_possible_cpus_fallback();
 250
 251 end:
 252         /* If all methods failed, don't store the value. */
 253         if (ret < 1)
 254                 return;
 255
 256         possible_cpus_array_len_cache = ret;
 257 }
 258
 259 /*
 260  * Returns the length of an array that could contain a per-CPU element for each
 261  * possible CPU id for the lifetime of the process.
 262  *
 263  * We currently assume CPU ids are contiguous up the maximum CPU id.
 264  *
 265  * If the cache is not yet initialized, get the value from
 266  * "/sys/devices/system/cpu/possible" or fallback to sysconf and cache it.
 267  *
 268  * If all methods fail, don't populate the cache and return 0.
 269  */
 270 int get_possible_cpus_array_len(void)
 271 {
 272         if (caa_unlikely(!possible_cpus_array_len_cache))
 273                 update_possible_cpus_array_len_cache();
 274
 275         return possible_cpus_array_len_cache;
 276 }