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(*ptr, 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(upper_name, 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(upper_name, 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(mountpoint, 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, 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, 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, bf, sizeof(bf)); 358 *buf = NULL; 359 err = io__getdelim(&io, buf, 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(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, 16); 415 } 416 417 int sysfs__read_ull(const char *entry, unsigned long long *value) 418 { 419 return sysfs__read_ull_base(entry, value, 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(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, bf, sizeof(bf)); 465 switch (io__get_char(&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(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(path, value); 508 } 509