1 // SPDX-License-Identifier: GPL-2.0
2 #include <assert.h>
3 #include <ctype.h>
4 #include <errno.h>
5 #include <limits.h>
6 #include <stdbool.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <sys/vfs.h>
11 #include <sys/types.h>
12 #include <sys/stat.h>
13 #include <fcntl.h>
14 #include <pthread.h>
15 #include <unistd.h>
16 #include <sys/mount.h>
17
18 #include "fs.h"
19 #include "debug-internal.h"
20
21 #define _STR(x) #x
22 #define STR(x) _STR(x)
23
24 #ifndef SYSFS_MAGIC
25 #define SYSFS_MAGIC 0x62656572
26 #endif
27
28 #ifndef PROC_SUPER_MAGIC
29 #define PROC_SUPER_MAGIC 0x9fa0
30 #endif
31
32 #ifndef DEBUGFS_MAGIC
33 #define DEBUGFS_MAGIC 0x64626720
34 #endif
35
36 #ifndef TRACEFS_MAGIC
37 #define TRACEFS_MAGIC 0x74726163
38 #endif
39
40 #ifndef HUGETLBFS_MAGIC
41 #define HUGETLBFS_MAGIC 0x958458f6
42 #endif
43
44 #ifndef BPF_FS_MAGIC
45 #define BPF_FS_MAGIC 0xcafe4a11
46 #endif
47
48 static const char * const sysfs__known_mountpoints[] = {
49 "/sys",
50 0,
51 };
52
53 static const char * const procfs__known_mountpoints[] = {
54 "/proc",
55 0,
56 };
57
58 #ifndef DEBUGFS_DEFAULT_PATH
59 #define DEBUGFS_DEFAULT_PATH "/sys/kernel/debug"
60 #endif
61
62 static const char * const debugfs__known_mountpoints[] = {
63 DEBUGFS_DEFAULT_PATH,
64 "/debug",
65 0,
66 };
67
68
69 #ifndef TRACEFS_DEFAULT_PATH
70 #define TRACEFS_DEFAULT_PATH "/sys/kernel/tracing"
71 #endif
72
73 static const char * const tracefs__known_mountpoints[] = {
74 TRACEFS_DEFAULT_PATH,
75 "/sys/kernel/debug/tracing",
76 "/tracing",
77 "/trace",
78 0,
79 };
80
81 static const char * const hugetlbfs__known_mountpoints[] = {
82 0,
83 };
84
85 static const char * const bpf_fs__known_mountpoints[] = {
86 "/sys/fs/bpf",
87 0,
88 };
89
90 struct fs {
91 const char * const name;
92 const char * const * const mounts;
93 char *path;
94 pthread_mutex_t mount_mutex;
95 const long magic;
96 };
97
98 #ifndef TRACEFS_MAGIC
99 #define TRACEFS_MAGIC 0x74726163
100 #endif
101
102 static void fs__init_once(struct fs *fs);
103 static const char *fs__mountpoint(const struct fs *fs);
104 static const char *fs__mount(struct fs *fs);
105
106 #define FS(lower_name, fs_name, upper_name) \
107 static struct fs fs__##lower_name = { \
108 .name = #fs_name, \
109 .mounts = lower_name##__known_mountpoints, \
110 .magic = upper_name##_MAGIC, \
111 .mount_mutex = PTHREAD_MUTEX_INITIALIZER, \
112 }; \
113 \
114 static void lower_name##_init_once(void) \
115 { \
116 struct fs *fs = &fs__##lower_name; \
117 \
118 fs__init_once(fs); \
119 } \
120 \
121 const char *lower_name##__mountpoint(void) \
122 { \
123 static pthread_once_t init_once = PTHREAD_ONCE_INIT; \
124 struct fs *fs = &fs__##lower_name; \
125 \
126 pthread_once(&init_once, lower_name##_init_once); \
127 return fs__mountpoint(fs); \
128 } \
129 \
130 const char *lower_name##__mount(void) \
131 { \
132 const char *mountpoint = lower_name##__mountpoint(); \
133 struct fs *fs = &fs__##lower_name; \
134 \
135 if (mountpoint) \
136 return mountpoint; \
137 \
138 return fs__mount(fs); \
139 } \
140 \
141 bool lower_name##__configured(void) \
142 { \
143 return lower_name##__mountpoint() != NULL; \
144 }
145
146 FS(sysfs, sysfs, SYSFS);
147 FS(procfs, procfs, PROC_SUPER);
148 FS(debugfs, debugfs, DEBUGFS);
149 FS(tracefs, tracefs, TRACEFS);
150 FS(hugetlbfs, hugetlbfs, HUGETLBFS);
151 FS(bpf_fs, bpf, BPF_FS);
152
fs__read_mounts(struct fs * fs)153 static bool fs__read_mounts(struct fs *fs)
154 {
155 char type[100];
156 FILE *fp;
157 char path[PATH_MAX + 1];
158
159 fp = fopen("/proc/mounts", "r");
160 if (fp == NULL)
161 return false;
162
163 while (fscanf(fp, "%*s %" STR(PATH_MAX) "s %99s %*s %*d %*d\n",
164 path, type) == 2) {
165
166 if (strcmp(type, fs->name) == 0) {
167 fs->path = strdup(path);
168 fclose(fp);
169 return fs->path != NULL;
170 }
171 }
172 fclose(fp);
173 return false;
174 }
175
fs__valid_mount(const char * fs,long magic)176 static int fs__valid_mount(const char *fs, long magic)
177 {
178 struct statfs st_fs;
179
180 if (statfs(fs, &st_fs) < 0)
181 return -ENOENT;
182 else if ((long)st_fs.f_type != magic)
183 return -ENOENT;
184
185 return 0;
186 }
187
fs__check_mounts(struct fs * fs)188 static bool fs__check_mounts(struct fs *fs)
189 {
190 const char * const *ptr;
191
192 ptr = fs->mounts;
193 while (*ptr) {
194 if (fs__valid_mount(*ptr, fs->magic) == 0) {
195 fs->path = strdup(*ptr);
196 if (!fs->path)
197 return false;
198 return true;
199 }
200 ptr++;
201 }
202
203 return false;
204 }
205
mem_toupper(char * f,size_t len)206 static void mem_toupper(char *f, size_t len)
207 {
208 while (len) {
209 *f = toupper(*f);
210 f++;
211 len--;
212 }
213 }
214
215 /*
216 * Check for "NAME_PATH" environment variable to override fs location (for
217 * testing). This matches the recommendation in Documentation/admin-guide/sysfs-rules.rst
218 * for SYSFS_PATH.
219 */
fs__env_override(struct fs * fs)220 static bool fs__env_override(struct fs *fs)
221 {
222 char *override_path;
223 size_t name_len = strlen(fs->name);
224 /* name + "_PATH" + '\0' */
225 char upper_name[name_len + 5 + 1];
226
227 memcpy(upper_name, fs->name, name_len);
228 mem_toupper(upper_name, name_len);
229 strcpy(&upper_name[name_len], "_PATH");
230
231 override_path = getenv(upper_name);
232 if (!override_path)
233 return false;
234
235 fs->path = strdup(override_path);
236 if (!fs->path)
237 return false;
238 return true;
239 }
240
fs__init_once(struct fs * fs)241 static void fs__init_once(struct fs *fs)
242 {
243 if (!fs__env_override(fs) &&
244 !fs__check_mounts(fs) &&
245 !fs__read_mounts(fs)) {
246 assert(!fs->path);
247 } else {
248 assert(fs->path);
249 }
250 }
251
fs__mountpoint(const struct fs * fs)252 static const char *fs__mountpoint(const struct fs *fs)
253 {
254 return fs->path;
255 }
256
mount_overload(struct fs * fs)257 static const char *mount_overload(struct fs *fs)
258 {
259 size_t name_len = strlen(fs->name);
260 /* "PERF_" + name + "_ENVIRONMENT" + '\0' */
261 char upper_name[5 + name_len + 12 + 1];
262
263 snprintf(upper_name, name_len, "PERF_%s_ENVIRONMENT", fs->name);
264 mem_toupper(upper_name, name_len);
265
266 return getenv(upper_name) ?: *fs->mounts;
267 }
268
fs__mount(struct fs * fs)269 static const char *fs__mount(struct fs *fs)
270 {
271 const char *mountpoint;
272
273 pthread_mutex_lock(&fs->mount_mutex);
274
275 /* Check if path found inside the mutex to avoid races with other callers of mount. */
276 mountpoint = fs__mountpoint(fs);
277 if (mountpoint)
278 goto out;
279
280 mountpoint = mount_overload(fs);
281
282 if (mount(NULL, mountpoint, fs->name, 0, NULL) == 0 &&
283 fs__valid_mount(mountpoint, fs->magic) == 0) {
284 fs->path = strdup(mountpoint);
285 mountpoint = fs->path;
286 }
287 out:
288 pthread_mutex_unlock(&fs->mount_mutex);
289 return mountpoint;
290 }
291
filename__read_int(const char * filename,int * value)292 int filename__read_int(const char *filename, int *value)
293 {
294 char line[64];
295 int fd = open(filename, O_RDONLY), err = -1;
296
297 if (fd < 0)
298 return -1;
299
300 if (read(fd, line, sizeof(line)) > 0) {
301 *value = atoi(line);
302 err = 0;
303 }
304
305 close(fd);
306 return err;
307 }
308
filename__read_ull_base(const char * filename,unsigned long long * value,int base)309 static int filename__read_ull_base(const char *filename,
310 unsigned long long *value, int base)
311 {
312 char line[64];
313 int fd = open(filename, O_RDONLY), err = -1;
314
315 if (fd < 0)
316 return -1;
317
318 if (read(fd, line, sizeof(line)) > 0) {
319 *value = strtoull(line, NULL, base);
320 if (*value != ULLONG_MAX)
321 err = 0;
322 }
323
324 close(fd);
325 return err;
326 }
327
328 /*
329 * Parses @value out of @filename with strtoull.
330 * By using 16 for base to treat the number as hex.
331 */
filename__read_xll(const char * filename,unsigned long long * value)332 int filename__read_xll(const char *filename, unsigned long long *value)
333 {
334 return filename__read_ull_base(filename, value, 16);
335 }
336
337 /*
338 * Parses @value out of @filename with strtoull.
339 * By using 0 for base, the strtoull detects the
340 * base automatically (see man strtoull).
341 */
filename__read_ull(const char * filename,unsigned long long * value)342 int filename__read_ull(const char *filename, unsigned long long *value)
343 {
344 return filename__read_ull_base(filename, value, 0);
345 }
346
347 #define STRERR_BUFSIZE 128 /* For the buffer size of strerror_r */
348
filename__read_str(const char * filename,char ** buf,size_t * sizep)349 int filename__read_str(const char *filename, char **buf, size_t *sizep)
350 {
351 size_t size = 0, alloc_size = 0;
352 void *bf = NULL, *nbf;
353 int fd, n, err = 0;
354 char sbuf[STRERR_BUFSIZE];
355
356 fd = open(filename, O_RDONLY);
357 if (fd < 0)
358 return -errno;
359
360 do {
361 if (size == alloc_size) {
362 alloc_size += BUFSIZ;
363 nbf = realloc(bf, alloc_size);
364 if (!nbf) {
365 err = -ENOMEM;
366 break;
367 }
368
369 bf = nbf;
370 }
371
372 n = read(fd, bf + size, alloc_size - size);
373 if (n < 0) {
374 if (size) {
375 pr_warn("read failed %d: %s\n", errno,
376 strerror_r(errno, sbuf, sizeof(sbuf)));
377 err = 0;
378 } else
379 err = -errno;
380
381 break;
382 }
383
384 size += n;
385 } while (n > 0);
386
387 if (!err) {
388 *sizep = size;
389 *buf = bf;
390 } else
391 free(bf);
392
393 close(fd);
394 return err;
395 }
396
filename__write_int(const char * filename,int value)397 int filename__write_int(const char *filename, int value)
398 {
399 int fd = open(filename, O_WRONLY), err = -1;
400 char buf[64];
401
402 if (fd < 0)
403 return err;
404
405 sprintf(buf, "%d", value);
406 if (write(fd, buf, sizeof(buf)) == sizeof(buf))
407 err = 0;
408
409 close(fd);
410 return err;
411 }
412
procfs__read_str(const char * entry,char ** buf,size_t * sizep)413 int procfs__read_str(const char *entry, char **buf, size_t *sizep)
414 {
415 char path[PATH_MAX];
416 const char *procfs = procfs__mountpoint();
417
418 if (!procfs)
419 return -1;
420
421 snprintf(path, sizeof(path), "%s/%s", procfs, entry);
422
423 return filename__read_str(path, buf, sizep);
424 }
425
sysfs__read_ull_base(const char * entry,unsigned long long * value,int base)426 static int sysfs__read_ull_base(const char *entry,
427 unsigned long long *value, int base)
428 {
429 char path[PATH_MAX];
430 const char *sysfs = sysfs__mountpoint();
431
432 if (!sysfs)
433 return -1;
434
435 snprintf(path, sizeof(path), "%s/%s", sysfs, entry);
436
437 return filename__read_ull_base(path, value, base);
438 }
439
sysfs__read_xll(const char * entry,unsigned long long * value)440 int sysfs__read_xll(const char *entry, unsigned long long *value)
441 {
442 return sysfs__read_ull_base(entry, value, 16);
443 }
444
sysfs__read_ull(const char * entry,unsigned long long * value)445 int sysfs__read_ull(const char *entry, unsigned long long *value)
446 {
447 return sysfs__read_ull_base(entry, value, 0);
448 }
449
sysfs__read_int(const char * entry,int * value)450 int sysfs__read_int(const char *entry, int *value)
451 {
452 char path[PATH_MAX];
453 const char *sysfs = sysfs__mountpoint();
454
455 if (!sysfs)
456 return -1;
457
458 snprintf(path, sizeof(path), "%s/%s", sysfs, entry);
459
460 return filename__read_int(path, value);
461 }
462
sysfs__read_str(const char * entry,char ** buf,size_t * sizep)463 int sysfs__read_str(const char *entry, char **buf, size_t *sizep)
464 {
465 char path[PATH_MAX];
466 const char *sysfs = sysfs__mountpoint();
467
468 if (!sysfs)
469 return -1;
470
471 snprintf(path, sizeof(path), "%s/%s", sysfs, entry);
472
473 return filename__read_str(path, buf, sizep);
474 }
475
sysfs__read_bool(const char * entry,bool * value)476 int sysfs__read_bool(const char *entry, bool *value)
477 {
478 char *buf;
479 size_t size;
480 int ret;
481
482 ret = sysfs__read_str(entry, &buf, &size);
483 if (ret < 0)
484 return ret;
485
486 switch (buf[0]) {
487 case '1':
488 case 'y':
489 case 'Y':
490 *value = true;
491 break;
492 case '0':
493 case 'n':
494 case 'N':
495 *value = false;
496 break;
497 default:
498 ret = -1;
499 }
500
501 free(buf);
502
503 return ret;
504 }
sysctl__read_int(const char * sysctl,int * value)505 int sysctl__read_int(const char *sysctl, int *value)
506 {
507 char path[PATH_MAX];
508 const char *procfs = procfs__mountpoint();
509
510 if (!procfs)
511 return -1;
512
513 snprintf(path, sizeof(path), "%s/sys/%s", procfs, sysctl);
514
515 return filename__read_int(path, value);
516 }
517
sysfs__write_int(const char * entry,int value)518 int sysfs__write_int(const char *entry, int value)
519 {
520 char path[PATH_MAX];
521 const char *sysfs = sysfs__mountpoint();
522
523 if (!sysfs)
524 return -1;
525
526 if (snprintf(path, sizeof(path), "%s/%s", sysfs, entry) >= PATH_MAX)
527 return -1;
528
529 return filename__write_int(path, value);
530 }
531