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