Debian Codegraph @

libsanitizer/sanitizer_common/sanitizer_common_interceptors_netbsd_compat.inc

raw
1 //===-- sanitizer_common_interceptors_netbsd_compat.inc ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Common function interceptors for tools like AddressSanitizer,
10 // ThreadSanitizer, MemorySanitizer, etc.
11 //
12 // Interceptors for NetBSD old function calls that have been versioned.
13 //
14 // NetBSD minimal version supported 9.0.
15 // NetBSD current version supported 9.99.26.
16 //
17 //===----------------------------------------------------------------------===//
18
19 #if SANITIZER_NETBSD
20
21 // First undef all mangled symbols.
22 // Next, define compat interceptors.
23 // Finally, undef INIT_ and redefine it.
24 // This allows to avoid preprocessor issues.
25
26 #undef fstatvfs
27 #undef fstatvfs1
28 #undef getmntinfo
29 #undef getvfsstat
30 #undef statvfs
31 #undef statvfs1
32
33 INTERCEPTOR(int, statvfs, char *path, void *buf) {
34 void *ctx;
35 COMMON_INTERCEPTOR_ENTER(ctx, statvfs, path, buf);
36 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, internal_strlen(path) + 1);
37 // FIXME: under ASan the call below may write to freed memory and corrupt
38 // its metadata. See
39 // https://github.com/google/sanitizers/issues/321.
40 int res = REAL(statvfs)(path, buf);
41 if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs90_sz);
42 return res;
43 }
44
45 INTERCEPTOR(int, fstatvfs, int fd, void *buf) {
46 void *ctx;
47 COMMON_INTERCEPTOR_ENTER(ctx, fstatvfs, fd, buf);
48 COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
49 // FIXME: under ASan the call below may write to freed memory and corrupt
50 // its metadata. See
51 // https://github.com/google/sanitizers/issues/321.
52 int res = REAL(fstatvfs)(fd, buf);
53 if (!res) {
54 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs90_sz);
55 if (fd >= 0)
56 COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
57 }
58 return res;
59 }
60
61 #undef INIT_STATVFS
62 #define INIT_STATVFS \
63 COMMON_INTERCEPT_FUNCTION(statvfs); \
64 COMMON_INTERCEPT_FUNCTION(fstatvfs); \
65 COMMON_INTERCEPT_FUNCTION(__statvfs90); \
66 COMMON_INTERCEPT_FUNCTION(__fstatvfs90)
67
68 INTERCEPTOR(int, __getmntinfo13, void **mntbufp, int flags) {
69 void *ctx;
70 COMMON_INTERCEPTOR_ENTER(ctx, __getmntinfo13, mntbufp, flags);
71 int cnt = REAL(__getmntinfo13)(mntbufp, flags);
72 if (cnt > 0 && mntbufp) {
73 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, mntbufp, sizeof(void *));
74 if (*mntbufp)
75 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, *mntbufp, cnt * struct_statvfs90_sz);
76 }
77 return cnt;
78 }
79
80 #undef INIT_GETMNTINFO
81 #define INIT_GETMNTINFO \
82 COMMON_INTERCEPT_FUNCTION(__getmntinfo13); \
83 COMMON_INTERCEPT_FUNCTION(__getmntinfo90)
84
85 INTERCEPTOR(int, getvfsstat, void *buf, SIZE_T bufsize, int flags) {
86 void *ctx;
87 COMMON_INTERCEPTOR_ENTER(ctx, getvfsstat, buf, bufsize, flags);
88 int ret = REAL(getvfsstat)(buf, bufsize, flags);
89 if (buf && ret > 0)
90 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, ret * struct_statvfs90_sz);
91 return ret;
92 }
93
94 #undef INIT_GETVFSSTAT
95 #define INIT_GETVFSSTAT \
96 COMMON_INTERCEPT_FUNCTION(getvfsstat); \
97 COMMON_INTERCEPT_FUNCTION(__getvfsstat90)
98
99 INTERCEPTOR(int, statvfs1, const char *path, void *buf, int flags) {
100 void *ctx;
101 COMMON_INTERCEPTOR_ENTER(ctx, statvfs1, path, buf, flags);
102 if (path) COMMON_INTERCEPTOR_READ_RANGE(ctx, path, internal_strlen(path) + 1);
103 int res = REAL(statvfs1)(path, buf, flags);
104 if (!res) COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs90_sz);
105 return res;
106 }
107
108 INTERCEPTOR(int, fstatvfs1, int fd, void *buf, int flags) {
109 void *ctx;
110 COMMON_INTERCEPTOR_ENTER(ctx, fstatvfs1, fd, buf, flags);
111 COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
112 int res = REAL(fstatvfs1)(fd, buf, flags);
113 if (!res) {
114 COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, struct_statvfs90_sz);
115 if (fd >= 0)
116 COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd);
117 }
118 return res;
119 }
120
121 #undef INIT_STATVFS1
122 #define INIT_STATVFS1 \
123 COMMON_INTERCEPT_FUNCTION(statvfs1); \
124 COMMON_INTERCEPT_FUNCTION(fstatvfs1); \
125 COMMON_INTERCEPT_FUNCTION(__statvfs190); \
126 COMMON_INTERCEPT_FUNCTION(__fstatvfs190)
127
128 #endif