src/basic/procfs-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <unistd.h>
   5
   6 #include "alloc-util.h"
   7 #include "constants.h"
   8 #include "fd-util.h"
   9 #include "fileio.h"
  10 #include "parse-util.h"
  11 #include "process-util.h"
  12 #include "procfs-util.h"
  13 #include "stdio-util.h"
  14 #include "string-util.h"
  15
  16 int procfs_get_pid_max(uint64_t *ret) {
  17         _cleanup_free_ char *value = NULL;
  18         int r;
  19
  20         assert(ret);
  21
  22         r = read_one_line_file("/proc/sys/kernel/pid_max", &value);
  23         if (r < 0)
  24                 return r;
  25
  26         return safe_atou64(value, ret);
  27 }
  28
  29 int procfs_get_threads_max(uint64_t *ret) {
  30         _cleanup_free_ char *value = NULL;
  31         int r;
  32
  33         assert(ret);
  34
  35         r = read_one_line_file("/proc/sys/kernel/threads-max", &value);
  36         if (r < 0)
  37                 return r;
  38
  39         return safe_atou64(value, ret);
  40 }
  41
  42 int procfs_tasks_set_limit(uint64_t limit) {
  43         char buffer[DECIMAL_STR_MAX(uint64_t)+1];
  44         uint64_t pid_max;
  45         int r;
  46
  47         if (limit == 0) /* This makes no sense, we are userspace and hence count as tasks too, and we want to live,
  48                          * hence the limit conceptually has to be above 0. Also, most likely if anyone asks for a zero
  49                          * limit they probably mean "no limit", hence let's better refuse this to avoid
  50                          * confusion. */
  51                 return -EINVAL;
  52
  53         /* The Linux kernel doesn't allow this value to go below 20, hence don't allow this either, higher values than
  54          * TASKS_MAX are not accepted by the pid_max sysctl. We'll treat anything this high as "unbounded" and hence
  55          * set it to the maximum. */
  56         limit = CLAMP(limit, 20U, TASKS_MAX);
  57
  58         r = procfs_get_pid_max(&pid_max);
  59         if (r < 0)
  60                 return r;
  61
  62         /* As pid_max is about the numeric pid_t range we'll bump it if necessary, but only ever increase it, never
  63          * decrease it, as threads-max is the much more relevant sysctl. */
  64         if (limit > pid_max-1) {
  65                 sprintf(buffer, "%" PRIu64, limit+1); /* Add one, since PID 0 is not a valid PID */
  66                 r = write_string_file("/proc/sys/kernel/pid_max", buffer, WRITE_STRING_FILE_DISABLE_BUFFER);
  67                 if (r < 0)
  68                         return r;
  69         }
  70
  71         sprintf(buffer, "%" PRIu64, limit);
  72         r = write_string_file("/proc/sys/kernel/threads-max", buffer, WRITE_STRING_FILE_DISABLE_BUFFER);
  73         if (r < 0) {
  74                 uint64_t threads_max;
  75
  76                 /* Hmm, we couldn't write this? If so, maybe it was already set properly? In that case let's not
  77                  * generate an error */
  78
  79                 if (procfs_get_threads_max(&threads_max) < 0)
  80                         return r; /* return original error */
  81
  82                 if (MIN(pid_max - 1, threads_max) != limit)
  83                         return r; /* return original error */
  84
  85                 /* Yay! Value set already matches what we were trying to set, hence consider this a success. */
  86         }
  87
  88         return 0;
  89 }
  90
  91 int procfs_tasks_get_current(uint64_t *ret) {
  92         _cleanup_free_ char *value = NULL;
  93         const char *p, *nr;
  94         size_t n;
  95         int r;
  96
  97         assert(ret);
  98
  99         r = read_one_line_file("/proc/loadavg", &value);
 100         if (r < 0)
 101                 return r;
 102
 103         /* Look for the second part of the fourth field, which is separated by a slash from the first part. None of the
 104          * earlier fields use a slash, hence let's use this to find the right spot. */
 105         p = strchr(value, '/');
 106         if (!p)
 107                 return -EINVAL;
 108
 109         p++;
 110         n = strspn(p, DIGITS);
 111         nr = strndupa_safe(p, n);
 112
 113         return safe_atou64(nr, ret);
 114 }
 115
 116 static uint64_t calc_gcd64(uint64_t a, uint64_t b) {
 117
 118         while (b > 0) {
 119                 uint64_t t;
 120
 121                 t = a % b;
 122
 123                 a = b;
 124                 b = t;
 125         }
 126
 127         return a;
 128 }
 129
 130 int procfs_cpu_get_usage(nsec_t *ret) {
 131         _cleanup_free_ char *first_line = NULL;
 132         unsigned long user_ticks, nice_ticks, system_ticks, irq_ticks, softirq_ticks,
 133                 guest_ticks = 0, guest_nice_ticks = 0;
 134         long ticks_per_second;
 135         uint64_t sum, gcd, a, b;
 136         const char *p;
 137         int r;
 138
 139         assert(ret);
 140
 141         r = read_one_line_file("/proc/stat", &first_line);
 142         if (r < 0)
 143                 return r;
 144
 145         p = first_word(first_line, "cpu");
 146         if (!p)
 147                 return -EINVAL;
 148
 149         if (sscanf(p, "%lu %lu %lu %*u %*u %lu %lu %*u %lu %lu",
 150                    &user_ticks,
 151                    &nice_ticks,
 152                    &system_ticks,
 153                    &irq_ticks,
 154                    &softirq_ticks,
 155                    &guest_ticks,
 156                    &guest_nice_ticks) < 5) /* we only insist on the first five fields */
 157                 return -EINVAL;
 158
 159         ticks_per_second = sysconf(_SC_CLK_TCK);
 160         if (ticks_per_second  < 0)
 161                 return -errno;
 162         assert(ticks_per_second > 0);
 163
 164         sum = (uint64_t) user_ticks + (uint64_t) nice_ticks + (uint64_t) system_ticks +
 165                 (uint64_t) irq_ticks + (uint64_t) softirq_ticks +
 166                 (uint64_t) guest_ticks + (uint64_t) guest_nice_ticks;
 167
 168         /* Let's reduce this fraction before we apply it to avoid overflows when converting this to μsec */
 169         gcd = calc_gcd64(NSEC_PER_SEC, ticks_per_second);
 170
 171         a = (uint64_t) NSEC_PER_SEC / gcd;
 172         b = (uint64_t) ticks_per_second / gcd;
 173
 174         *ret = DIV_ROUND_UP((nsec_t) sum * (nsec_t) a, (nsec_t) b);
 175         return 0;
 176 }
 177
 178 int convert_meminfo_value_to_uint64_bytes(const char *word, uint64_t *ret) {
 179         _cleanup_free_ char *w = NULL;
 180         char *digits, *e;
 181         uint64_t v;
 182         size_t n;
 183         int r;
 184
 185         assert(word);
 186         assert(ret);
 187
 188         w = strdup(word);
 189         if (!w)
 190                 return -ENOMEM;
 191
 192         /* Determine length of numeric value */
 193         n = strspn(w, WHITESPACE);
 194         digits = w + n;
 195         n = strspn(digits, DIGITS);
 196         if (n == 0)
 197                 return -EINVAL;
 198         e = digits + n;
 199
 200         /* Ensure the line ends in " kB" */
 201         n = strspn(e, WHITESPACE);
 202         if (n == 0)
 203                 return -EINVAL;
 204         if (!streq(e + n, "kB"))
 205                 return -EINVAL;
 206
 207         *e = 0;
 208         r = safe_atou64(digits, &v);
 209         if (r < 0)
 210                 return r;
 211         if (v == UINT64_MAX)
 212                 return -EINVAL;
 213
 214         if (v > UINT64_MAX/1024)
 215                 return -EOVERFLOW;
 216
 217         *ret = v * 1024U;
 218         return 0;
 219 }
 220
 221 int procfs_memory_get(uint64_t *ret_total, uint64_t *ret_used) {
 222         uint64_t mem_total = UINT64_MAX, mem_available = UINT64_MAX;
 223         _cleanup_fclose_ FILE *f = NULL;
 224         int r;
 225
 226         f = fopen("/proc/meminfo", "re");
 227         if (!f)
 228                 return -errno;
 229
 230         for (;;) {
 231                 _cleanup_free_ char *line = NULL;
 232                 uint64_t *v;
 233                 char *p;
 234
 235                 r = read_line(f, LONG_LINE_MAX, &line);
 236                 if (r < 0)
 237                         return r;
 238                 if (r == 0)
 239                         return -EINVAL; /* EOF: Couldn't find one or both fields? */
 240
 241                 p = first_word(line, "MemTotal:");
 242                 if (p)
 243                         v = &mem_total;
 244                 else {
 245                         p = first_word(line, "MemAvailable:");
 246                         if (p)
 247                                 v = &mem_available;
 248                         else
 249                                 continue;
 250                 }
 251
 252                 r = convert_meminfo_value_to_uint64_bytes(p, v);
 253                 if (r < 0)
 254                         return r;
 255
 256                 if (mem_total != UINT64_MAX && mem_available != UINT64_MAX)
 257                         break;
 258         }
 259
 260         if (mem_available > mem_total)
 261                 return -EINVAL;
 262
 263         if (ret_total)
 264                 *ret_total = mem_total;
 265         if (ret_used)
 266                 *ret_used = mem_total - mem_available;
 267         return 0;
 268 }