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