Debian Codegraph @

testsuite/systemtap.syscall/mmap.c

raw
1 /* COVERAGE: mmap mmap2 mmap_pgoff munmap msync */
2 /* COVERAGE: mlock mlock2 mlockall munlock munlockall */
3 /* COVERAGE: mprotect mremap */
4 #include <sys/types.h>
5 #include <sys/stat.h>
6 #define __USE_GNU
7 #include <sys/mman.h>
8 #include <fcntl.h>
9 #include <unistd.h>
10 #include <sys/syscall.h>
11 #include <sys/mman.h>
12
13 #ifdef __NR_mlock2
14
15 #ifndef MLOCK_ONFAULT
16 #define MLOCK_ONFAULT 0x01
17 #endif
18
19 static inline int __mlock2(const void *start, size_t len, int flags)
20 {
21 return syscall(__NR_mlock2, start, len, flags);
22 }
23 #endif
24
25 int main()
26 {
27 mlockall(MCL_CURRENT);
28
29 int fd, ret;
30 struct stat fs;
31 void * r;
32
33 /* create a file with something in it */
34 fd = open("foobar",O_WRONLY|O_CREAT|O_TRUNC, 0600);
35 //staptest// [[[[open (!!!!openat (AT_FDCWD, ]]]]"foobar", O_WRONLY|O_CREAT[[[[.O_LARGEFILE]]]]?|O_TRUNC, 0600) = NNNN
36
37 // Why 64k? ppc64 has 64K pages. ia64 has 16k
38 // pages. x86_64/i686 has 4k pages. When we specify an offset
39 // to mmap(), it must be a multiple of the page size, so we
40 // use the biggest.
41 lseek(fd, 65536, SEEK_SET);
42 write(fd, "abcdef", 6);
43 close(fd);
44 //staptest// close (NNNN) = 0
45
46 fd = open("foobar", O_RDONLY);
47 //staptest// [[[[open (!!!!openat (AT_FDCWD, ]]]]"foobar", O_RDONLY[[[[.O_LARGEFILE]]]]?) = NNNN
48
49 /* stat for file size */
50 ret = fstat(fd, &fs);
51 //staptest// [[[[[[[[fstat (NNNN, XXXX)!!!!fstatat (3, "", XXXX, AT_EMPTY_PATH)]]]]!!!!statx (3, "", AT_NO_AUTOMOUNT|AT_EMPTY_PATH, XXXX, XXXX)]]]] = 0
52
53 r = mmap(NULL, 4096, PROT_READ, MAP_SHARED, fd, 0);
54 //staptest// mmap[2]* (0x0, 4096, PROT_READ, MAP_SHARED, NNNN, 0) = XXXX
55
56 mlock(r, 4096);
57 //staptest// mlock (XXXX, 4096) = 0
58
59 mlock((void *)-1, 4096);
60 //staptest// mlock (0x[f]+, 4096) = NNNN
61
62 mlock(0, -1);
63 #if __WORDSIZE == 64
64 //staptest// mlock (0x[0]+, 18446744073709551615) = NNNN
65 #else
66 //staptest// mlock (0x[0]+, 4294967295) = NNNN
67 #endif
68
69 #ifdef __NR_mlock2
70 {
71 void *r2 = mmap(NULL, 12288, PROT_READ|PROT_WRITE,
72 MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
73 //staptest// mmap[2]* (0x0, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX
74
75 __mlock2(r2, 4096, MLOCK_ONFAULT);
76 //staptest// mlock2 (XXXX, 4096, MLOCK_ONFAULT) = 0
77
78 __mlock2((void *)-1, 4096, 0);
79 //staptest// mlock2 (0x[f]+, 4096, 0x0) = NNNN
80
81 __mlock2(0, -1, 0);
82 #if __WORDSIZE == 64
83 //staptest// mlock2 (0x[0]+, 18446744073709551615, 0x0) = NNNN
84 #else
85 //staptest// mlock2 (0x[0]+, 4294967295, 0x0) = NNNN
86 #endif
87
88 __mlock2(0, 4096, -1);
89 //staptest// mlock2 (0x[0]+, 4096, MLOCK_ONFAULT|XXXX) = NNNN
90
91 munlock(r2, 4096);
92 //staptest// munlock (XXXX, 4096) = 0
93 }
94 #endif
95
96 msync(r, 4096, MS_SYNC);
97 //staptest// msync (XXXX, 4096, MS_SYNC) = 0
98
99 msync((void *)-1, 4096, MS_SYNC);
100 //staptest// msync (0x[f]+, 4096, MS_SYNC) = NNNN
101
102 msync(r, -1, MS_SYNC);
103 #if __WORDSIZE == 64
104 //staptest// msync (XXXX, 18446744073709551615, MS_SYNC) = NNNN
105 #else
106 //staptest// msync (XXXX, 4294967295, MS_SYNC) = NNNN
107 #endif
108
109 msync(r, 4096, -1);
110 //staptest// msync (XXXX, 4096, MS_[^ ]+|XXXX) = NNNN
111
112 munlock(r, 4096);
113 //staptest// munlock (XXXX, 4096) = 0
114
115 mlockall(MCL_CURRENT);
116 //staptest// mlockall (MCL_CURRENT) =
117
118 mlockall(-1);
119 //staptest// mlockall (MCL_[^ ]+|XXXX) = NNNN
120
121 munlockall();
122 //staptest// munlockall () = 0
123
124 munmap(r, 4096);
125 //staptest// munmap (XXXX, 4096) = 0
126
127 // Ensure the 6th argument is handled correctly..
128 r = mmap(NULL, 6, PROT_READ, MAP_PRIVATE, fd, 65536);
129 //staptest// mmap[2]* (0x0, 6, PROT_READ, MAP_PRIVATE, NNNN, 65536) = XXXX
130
131 munmap(r, 6);
132 //staptest// munmap (XXXX, 6) = 0
133
134 close(fd);
135
136 r = mmap(NULL, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
137 //staptest// mmap[2]* (0x0, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX
138
139 mprotect(r, 4096, PROT_READ|PROT_EXEC);
140 //staptest// mprotect (XXXX, 4096, PROT_READ|PROT_EXEC) = 0
141
142 mprotect(r, 4096, PROT_GROWSDOWN|PROT_GROWSUP);
143 //staptest// mprotect (XXXX, 4096, PROT_GROWSDOWN|PROT_GROWSUP) = -XXXX (EINVAL)
144
145 #ifdef PROT_SAO
146 mprotect(r, 4096, PROT_SAO);
147 //staptest// mprotect (XXXX, 4096, PROT_SAO) =
148 #endif
149
150 munmap(r, 12288);
151 //staptest// munmap (XXXX, 12288) = 0
152
153 r = mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
154 //staptest// mmap[2]* (0x0, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX
155
156 r = mremap(r, 8192, 4096, 0);
157 //staptest// mremap (XXXX, 8192, 4096, 0x0, XXXX) = XXXX
158
159 munmap(r, 4096);
160 //staptest// munmap (XXXX, 4096) = 0
161
162 // powerpc64's glibc rejects this one. On ia64, the call
163 // fails, while on most other architectures it works. So,
164 // ignore the return values.
165 #ifndef __powerpc64__
166 r = mmap((void *)-1, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
167 //staptest// mmap[2]* (0x[f]+, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) =
168
169 munmap(r, 8192);
170 //staptest// munmap (XXXX, 8192) =
171 #endif
172
173 r = mmap(NULL, -1, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
174 #if __WORDSIZE == 64
175 //staptest// mmap[2]* (0x0, 18446744073709551615, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -XXXX (ENOMEM)
176 #else
177 //staptest// mmap[2]* (0x0, 4294967295, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = -XXXX (ENOMEM)
178 #endif
179
180 // powerpc's glibc (both 32-bit and 64-bit) rejects this one.
181 #ifndef __powerpc__
182 r = mmap(NULL, 8192, -1, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
183 //staptest// mmap[2]* (0x0, 8192, PROT_[^ ]+|XXXX, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = XXXX
184
185 munmap(r, 8192);
186 //staptest// munmap (XXXX, 8192) = 0
187 #endif
188
189 r = mmap(NULL, 8192, PROT_READ|PROT_WRITE, -1, -1, 0);
190 //staptest// mmap[2]* (0x0, 8192, PROT_READ|PROT_WRITE, MAP_[^ ]+|XXXX, -1, 0) = -XXXX
191
192 // Unfortunately, glibc and/or the syscall wrappers will
193 // reject a -1 offset, especially on a 32-bit exe on a 64-bit
194 // OS. So, we can't really test this one.
195 //
196 // r = mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, -1);
197
198 munmap((void *)-1, 8192);
199 //staptest// munmap (0x[f]+, 8192) = NNNN
200
201 munmap(r, -1);
202 #if __WORDSIZE == 64
203 //staptest// munmap (XXXX, 18446744073709551615) = NNNN
204 #else
205 //staptest// munmap (XXXX, 4294967295) = NNNN
206 #endif
207
208 #ifdef MAP_STACK
209 r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_STACK, -1, 0);
210 //staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_STACK, -1, 0) = -XXXX
211 #endif
212
213 #ifdef MAP_HUGETLB
214 r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0);
215 //staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0) = -XXXX
216
217 #ifdef MAP_HUGE_SHIFT
218 r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB|(21 << MAP_HUGE_SHIFT), -1, 0);
219 //staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_HUGE_2MB|MAP_PRIVATE|MAP_ANONYMOUS|MAP_HUGETLB, -1, 0) = -XXXX
220 #endif
221 #endif
222
223 #ifdef MAP_UNINITIALIZED
224 r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_UNINITIALIZED, -1, 0);
225 //staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_UNINITIALIZED, -1, 0) = -XXXX
226 #endif
227
228 #ifdef MAP_32BIT
229 r = mmap(NULL, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_32BIT, -1, 0);
230 //staptest// mmap[2]* (0x0, 0, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_32BIT, -1, 0) = -XXXX
231 #endif
232
233 return 0;
234 }