1 /* Iteration over virtual memory areas.
2 Copyright (C) 2011-2021 Free Software Foundation, Inc.
3 Written by Bruno Haible <bruno@clisp.org>, 2011-2017.
4
5 This program is free software: you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 3 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program. If not, see <https://www.gnu.org/licenses/>. */
17
18 #include <config.h>
19
20 /* On Solaris in 32-bit mode, when gnulib module 'largefile' is in use,
21 prevent a compilation error
22 "Cannot use procfs in the large file compilation environment"
23 On Android, when targeting Android 4.4 or older with a GCC toolchain,
24 prevent a compilation error
25 "error: call to 'mmap' declared with attribute error: mmap is not
26 available with _FILE_OFFSET_BITS=64 when using GCC until android-21.
27 Either raise your minSdkVersion, disable _FILE_OFFSET_BITS=64, or
28 switch to Clang."
29 The files that we access in this compilation unit are less than 2 GB
30 large. */
31 #if defined __sun || defined __ANDROID__
32 # undef _FILE_OFFSET_BITS
33 #endif
34
35 /* Specification. */
36 #include "vma-iter.h"
37
38 #include <errno.h> /* errno */
39 #include <stdlib.h> /* size_t */
40 #include <fcntl.h> /* open, O_RDONLY */
41 #include <unistd.h> /* getpagesize, lseek, read, close, getpid */
42
43 #if defined __linux__ || defined __ANDROID__
44 # include <limits.h> /* PATH_MAX */
45 #endif
46
47 #if defined __linux__ || defined __ANDROID__ || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __minix /* || defined __CYGWIN__ */
48 # include <sys/types.h>
49 # include <sys/mman.h> /* mmap, munmap */
50 #endif
51 #if defined __minix
52 # include <string.h> /* memcpy */
53 #endif
54
55 #if defined __FreeBSD__ || defined __FreeBSD_kernel__ /* FreeBSD, GNU/kFreeBSD */
56 # include <sys/types.h>
57 # include <sys/mman.h> /* mmap, munmap */
58 # include <sys/user.h> /* struct kinfo_vmentry */
59 # include <sys/sysctl.h> /* sysctl */
60 #endif
61 #if defined __NetBSD__ || defined __OpenBSD__ /* NetBSD, OpenBSD */
62 # include <sys/types.h>
63 # include <sys/mman.h> /* mmap, munmap */
64 # include <sys/sysctl.h> /* sysctl, struct kinfo_vmentry */
65 #endif
66
67 #if defined __sgi || defined __osf__ /* IRIX, OSF/1 */
68 # include <string.h> /* memcpy */
69 # include <sys/types.h>
70 # include <sys/mman.h> /* mmap, munmap */
71 # include <sys/procfs.h> /* PIOC*, prmap_t */
72 #endif
73
74 #if defined __sun /* Solaris */
75 # include <string.h> /* memcpy */
76 # include <sys/types.h>
77 # include <sys/mman.h> /* mmap, munmap */
78 /* Try to use the newer ("structured") /proc filesystem API, if supported. */
79 # define _STRUCTURED_PROC 1
80 # include <sys/procfs.h> /* prmap_t, optionally PIOC* */
81 #endif
82
83 #if HAVE_PSTAT_GETPROCVM /* HP-UX */
84 # include <sys/pstat.h> /* pstat_getprocvm */
85 #endif
86
87 #if defined __APPLE__ && defined __MACH__ /* Mac OS X */
88 # include <mach/mach.h>
89 #endif
90
91 #if defined __GNU__ /* GNU/Hurd */
92 # include <mach/mach.h>
93 #endif
94
95 #if defined _WIN32 || defined __CYGWIN__ /* Windows */
96 # include <windows.h>
97 #endif
98
99 #if defined __BEOS__ || defined __HAIKU__ /* BeOS, Haiku */
100 # include <OS.h>
101 #endif
102
103 #if HAVE_MQUERY /* OpenBSD */
104 # include <sys/types.h>
105 # include <sys/mman.h> /* mquery */
106 #endif
107
108 /* Note: On AIX, there is a /proc/$pic/map file, that contains records of type
109 prmap_t, defined in <sys/procfs.h>. But it lists only the virtual memory
110 areas that are connected to a file, not the anonymous ones. */
111
112
113 /* Support for reading text files in the /proc file system. */
114
115 #if defined __linux__ || defined __ANDROID__ || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __minix /* || defined __CYGWIN__ */
116
117 /* Buffered read-only streams.
118 We cannot use <stdio.h> here, because fopen() calls malloc(), and a malloc()
119 call may call mmap() and thus pre-allocate available memory.
120 Also, we cannot use multiple read() calls, because if the buffer size is
121 smaller than the file's contents:
122 - On NetBSD, the second read() call would return 0, thus making the file
123 appear truncated.
124 - On DragonFly BSD, the first read() call would fail with errno = EFBIG.
125 - On all platforms, if some other thread is doing memory allocations or
126 deallocations between two read() calls, there is a high risk that the
127 result of these two read() calls don't fit together, and as a
128 consequence we will parse garbage and either omit some VMAs or return
129 VMAs with nonsensical addresses.
130 So use mmap(), and ignore the resulting VMA. */
131
132 # if defined __linux__ || defined __ANDROID__
133 /* On Linux, if the file does not entirely fit into the buffer, the read()
134 function stops before the line that would come out truncated. The
135 maximum size of such a line is 73 + PATH_MAX bytes. To be sure that we
136 have read everything, we must verify that at least that many bytes are
137 left when read() returned. */
138 # define MIN_LEFTOVER (73 + PATH_MAX)
139 # else
140 # define MIN_LEFTOVER 1
141 # endif
142
143 # ifdef TEST
144 /* During testing, we want to run into the hairy cases. */
145 # define STACK_ALLOCATED_BUFFER_SIZE 32
146 # else
147 # if MIN_LEFTOVER < 1024
148 # define STACK_ALLOCATED_BUFFER_SIZE 1024
149 # else
150 /* There is no point in using a stack-allocated buffer if it is too small anyway. */
151 # define STACK_ALLOCATED_BUFFER_SIZE 1
152 # endif
153 # endif
154
155 struct rofile
156 {
157 size_t position;
158 size_t filled;
159 int eof_seen;
160 /* These fields deal with allocation of the buffer. */
161 char *buffer;
162 char *auxmap;
163 size_t auxmap_length;
164 unsigned long auxmap_start;
165 unsigned long auxmap_end;
166 char stack_allocated_buffer[STACK_ALLOCATED_BUFFER_SIZE];
167 };
168
169 /* Open a read-only file stream. */
170 static int
171 rof_open (struct rofile *rof, const char *filename)
172 {
173 int fd;
174 unsigned long pagesize;
175 size_t size;
176
177 fd = open (filename, O_RDONLY | O_CLOEXEC);
178 if (fd < 0)
179 return -1;
180 rof->position = 0;
181 rof->eof_seen = 0;
182 /* Try the static buffer first. */
183 pagesize = 0;
184 rof->buffer = rof->stack_allocated_buffer;
185 size = sizeof (rof->stack_allocated_buffer);
186 rof->auxmap = NULL;
187 rof->auxmap_start = 0;
188 rof->auxmap_end = 0;
189 for (;;)
190 {
191 /* Attempt to read the contents in a single system call. */
192 if (size > MIN_LEFTOVER)
193 {
194 int n = read (fd, rof->buffer, size);
195 if (n < 0 && errno == EINTR)
196 goto retry;
197 # if defined __DragonFly__
198 if (!(n < 0 && errno == EFBIG))
199 # endif
200 {
201 if (n <= 0)
202 /* Empty file. */
203 goto fail1;
204 if (n + MIN_LEFTOVER <= size)
205 {
206 /* The buffer was sufficiently large. */
207 rof->filled = n;
208 # if defined __linux__ || defined __ANDROID__
209 /* On Linux, the read() call may stop even if the buffer was
210 large enough. We need the equivalent of full_read(). */
211 for (;;)
212 {
213 n = read (fd, rof->buffer + rof->filled, size - rof->filled);
214 if (n < 0 && errno == EINTR)
215 goto retry;
216 if (n < 0)
217 /* Some error. */
218 goto fail1;
219 if (n + MIN_LEFTOVER > size - rof->filled)
220 /* Allocate a larger buffer. */
221 break;
222 if (n == 0)
223 {
224 /* Reached the end of file. */
225 close (fd);
226 return 0;
227 }
228 rof->filled += n;
229 }
230 # else
231 close (fd);
232 return 0;
233 # endif
234 }
235 }
236 }
237 /* Allocate a larger buffer. */
238 if (pagesize == 0)
239 {
240 pagesize = getpagesize ();
241 size = pagesize;
242 while (size <= MIN_LEFTOVER)
243 size = 2 * size;
244 }
245 else
246 {
247 size = 2 * size;
248 if (size == 0)
249 /* Wraparound. */
250 goto fail1;
251 if (rof->auxmap != NULL)
252 munmap (rof->auxmap, rof->auxmap_length);
253 }
254 rof->auxmap = (void *) mmap ((void *) 0, size, PROT_READ | PROT_WRITE,
255 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
256 if (rof->auxmap == (void *) -1)
257 {
258 close (fd);
259 return -1;
260 }
261 rof->auxmap_length = size;
262 rof->auxmap_start = (unsigned long) rof->auxmap;
263 rof->auxmap_end = rof->auxmap_start + size;
264 rof->buffer = (char *) rof->auxmap;
265 retry:
266 /* Restart. */
267 if (lseek (fd, 0, SEEK_SET) < 0)
268 {
269 close (fd);
270 fd = open (filename, O_RDONLY | O_CLOEXEC);
271 if (fd < 0)
272 goto fail2;
273 }
274 }
275 fail1:
276 close (fd);
277 fail2:
278 if (rof->auxmap != NULL)
279 munmap (rof->auxmap, rof->auxmap_length);
280 return -1;
281 }
282
283 /* Return the next byte from a read-only file stream without consuming it,
284 or -1 at EOF. */
285 static int
286 rof_peekchar (struct rofile *rof)
287 {
288 if (rof->position == rof->filled)
289 {
290 rof->eof_seen = 1;
291 return -1;
292 }
293 return (unsigned char) rof->buffer[rof->position];
294 }
295
296 /* Return the next byte from a read-only file stream, or -1 at EOF. */
297 static int
298 rof_getchar (struct rofile *rof)
299 {
300 int c = rof_peekchar (rof);
301 if (c >= 0)
302 rof->position++;
303 return c;
304 }
305
306 /* Parse an unsigned hexadecimal number from a read-only file stream. */
307 static int
308 rof_scanf_lx (struct rofile *rof, unsigned long *valuep)
309 {
310 unsigned long value = 0;
311 unsigned int numdigits = 0;
312 for (;;)
313 {
314 int c = rof_peekchar (rof);
315 if (c >= '0' && c <= '9')
316 value = (value << 4) + (c - '0');
317 else if (c >= 'A' && c <= 'F')
318 value = (value << 4) + (c - 'A' + 10);
319 else if (c >= 'a' && c <= 'f')
320 value = (value << 4) + (c - 'a' + 10);
321 else
322 break;
323 rof_getchar (rof);
324 numdigits++;
325 }
326 if (numdigits == 0)
327 return -1;
328 *valuep = value;
329 return 0;
330 }
331
332 /* Close a read-only file stream. */
333 static void
334 rof_close (struct rofile *rof)
335 {
336 if (rof->auxmap != NULL)
337 munmap (rof->auxmap, rof->auxmap_length);
338 }
339
340 #endif
341
342
343 /* Support for reading the info from a text file in the /proc file system. */
344
345 #if defined __linux__ || defined __ANDROID__ || (defined __FreeBSD_kernel__ && !defined __FreeBSD__) /* || defined __CYGWIN__ */
346 /* GNU/kFreeBSD mounts /proc as linprocfs, which looks like a Linux /proc
347 file system. */
348
349 static int
350 vma_iterate_proc (vma_iterate_callback_fn callback, void *data)
351 {
352 struct rofile rof;
353
354 /* Open the current process' maps file. It describes one VMA per line. */
355 if (rof_open (&rof, "/proc/self/maps") >= 0)
356 {
357 unsigned long auxmap_start = rof.auxmap_start;
358 unsigned long auxmap_end = rof.auxmap_end;
359
360 for (;;)
361 {
362 unsigned long start, end;
363 unsigned int flags;
364 int c;
365
366 /* Parse one line. First start and end. */
367 if (!(rof_scanf_lx (&rof, &start) >= 0
368 && rof_getchar (&rof) == '-'
369 && rof_scanf_lx (&rof, &end) >= 0))
370 break;
371 /* Then the flags. */
372 do
373 c = rof_getchar (&rof);
374 while (c == ' ');
375 flags = 0;
376 if (c == 'r')
377 flags |= VMA_PROT_READ;
378 c = rof_getchar (&rof);
379 if (c == 'w')
380 flags |= VMA_PROT_WRITE;
381 c = rof_getchar (&rof);
382 if (c == 'x')
383 flags |= VMA_PROT_EXECUTE;
384 while (c = rof_getchar (&rof), c != -1 && c != '\n')
385 ;
386
387 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
388 {
389 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
390 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
391 if (start < auxmap_start)
392 if (callback (data, start, auxmap_start, flags))
393 break;
394 if (auxmap_end - 1 < end - 1)
395 if (callback (data, auxmap_end, end, flags))
396 break;
397 }
398 else
399 {
400 if (callback (data, start, end, flags))
401 break;
402 }
403 }
404 rof_close (&rof);
405 return 0;
406 }
407
408 return -1;
409 }
410
411 #elif defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__
412
413 static int
414 vma_iterate_proc (vma_iterate_callback_fn callback, void *data)
415 {
416 struct rofile rof;
417
418 /* Open the current process' maps file. It describes one VMA per line. */
419 if (rof_open (&rof, "/proc/curproc/map") >= 0)
420 {
421 unsigned long auxmap_start = rof.auxmap_start;
422 unsigned long auxmap_end = rof.auxmap_end;
423
424 for (;;)
425 {
426 unsigned long start, end;
427 unsigned int flags;
428 int c;
429
430 /* Parse one line. First start. */
431 if (!(rof_getchar (&rof) == '0'
432 && rof_getchar (&rof) == 'x'
433 && rof_scanf_lx (&rof, &start) >= 0))
434 break;
435 while (c = rof_peekchar (&rof), c == ' ' || c == '\t')
436 rof_getchar (&rof);
437 /* Then end. */
438 if (!(rof_getchar (&rof) == '0'
439 && rof_getchar (&rof) == 'x'
440 && rof_scanf_lx (&rof, &end) >= 0))
441 break;
442 # if defined __FreeBSD__ || defined __DragonFly__
443 /* Then the resident pages count. */
444 do
445 c = rof_getchar (&rof);
446 while (c == ' ');
447 do
448 c = rof_getchar (&rof);
449 while (c != -1 && c != '\n' && c != ' ');
450 /* Then the private resident pages count. */
451 do
452 c = rof_getchar (&rof);
453 while (c == ' ');
454 do
455 c = rof_getchar (&rof);
456 while (c != -1 && c != '\n' && c != ' ');
457 /* Then some kernel address. */
458 do
459 c = rof_getchar (&rof);
460 while (c == ' ');
461 do
462 c = rof_getchar (&rof);
463 while (c != -1 && c != '\n' && c != ' ');
464 # endif
465 /* Then the flags. */
466 do
467 c = rof_getchar (&rof);
468 while (c == ' ');
469 flags = 0;
470 if (c == 'r')
471 flags |= VMA_PROT_READ;
472 c = rof_getchar (&rof);
473 if (c == 'w')
474 flags |= VMA_PROT_WRITE;
475 c = rof_getchar (&rof);
476 if (c == 'x')
477 flags |= VMA_PROT_EXECUTE;
478 while (c = rof_getchar (&rof), c != -1 && c != '\n')
479 ;
480
481 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
482 {
483 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
484 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
485 if (start < auxmap_start)
486 if (callback (data, start, auxmap_start, flags))
487 break;
488 if (auxmap_end - 1 < end - 1)
489 if (callback (data, auxmap_end, end, flags))
490 break;
491 }
492 else
493 {
494 if (callback (data, start, end, flags))
495 break;
496 }
497 }
498 rof_close (&rof);
499 return 0;
500 }
501
502 return -1;
503 }
504
505 #elif defined __minix
506
507 static int
508 vma_iterate_proc (vma_iterate_callback_fn callback, void *data)
509 {
510 char fnamebuf[6+10+4+1];
511 char *fname;
512 struct rofile rof;
513
514 /* Construct fname = sprintf (fnamebuf+i, "/proc/%u/map", getpid ()). */
515 fname = fnamebuf + sizeof (fnamebuf) - (4 + 1);
516 memcpy (fname, "/map", 4 + 1);
517 {
518 unsigned int value = getpid ();
519 do
520 *--fname = (value % 10) + '0';
521 while ((value = value / 10) > 0);
522 }
523 fname -= 6;
524 memcpy (fname, "/proc/", 6);
525
526 /* Open the current process' maps file. It describes one VMA per line. */
527 if (rof_open (&rof, fname) >= 0)
528 {
529 unsigned long auxmap_start = rof.auxmap_start;
530 unsigned long auxmap_end = rof.auxmap_end;
531
532 for (;;)
533 {
534 unsigned long start, end;
535 unsigned int flags;
536 int c;
537
538 /* Parse one line. First start and end. */
539 if (!(rof_scanf_lx (&rof, &start) >= 0
540 && rof_getchar (&rof) == '-'
541 && rof_scanf_lx (&rof, &end) >= 0))
542 break;
543 /* Then the flags. */
544 do
545 c = rof_getchar (&rof);
546 while (c == ' ');
547 flags = 0;
548 if (c == 'r')
549 flags |= VMA_PROT_READ;
550 c = rof_getchar (&rof);
551 if (c == 'w')
552 flags |= VMA_PROT_WRITE;
553 c = rof_getchar (&rof);
554 if (c == 'x')
555 flags |= VMA_PROT_EXECUTE;
556 while (c = rof_getchar (&rof), c != -1 && c != '\n')
557 ;
558
559 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
560 {
561 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
562 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
563 if (start < auxmap_start)
564 if (callback (data, start, auxmap_start, flags))
565 break;
566 if (auxmap_end - 1 < end - 1)
567 if (callback (data, auxmap_end, end, flags))
568 break;
569 }
570 else
571 {
572 if (callback (data, start, end, flags))
573 break;
574 }
575 }
576 rof_close (&rof);
577 return 0;
578 }
579
580 return -1;
581 }
582
583 #else
584
585 static inline int
586 vma_iterate_proc (vma_iterate_callback_fn callback, void *data)
587 {
588 return -1;
589 }
590
591 #endif
592
593
594 /* Support for reading the info from the BSD sysctl() system call. */
595
596 #if (defined __FreeBSD__ || defined __FreeBSD_kernel__) && defined KERN_PROC_VMMAP /* FreeBSD >= 7.1 */
597
598 static int
599 vma_iterate_bsd (vma_iterate_callback_fn callback, void *data)
600 {
601 /* Documentation: https://www.freebsd.org/cgi/man.cgi?sysctl(3) */
602 int info_path[] = { CTL_KERN, KERN_PROC, KERN_PROC_VMMAP, getpid () };
603 size_t len;
604 size_t pagesize;
605 size_t memneed;
606 void *auxmap;
607 unsigned long auxmap_start;
608 unsigned long auxmap_end;
609 char *mem;
610 char *p;
611 char *p_end;
612
613 len = 0;
614 if (sysctl (info_path, 4, NULL, &len, NULL, 0) < 0)
615 return -1;
616 /* Allow for small variations over time. In a multithreaded program
617 new VMAs can be allocated at any moment. */
618 len = 2 * len + 200;
619 /* Allocate memneed bytes of memory.
620 We cannot use alloca here, because not much stack space is guaranteed.
621 We also cannot use malloc here, because a malloc() call may call mmap()
622 and thus pre-allocate available memory.
623 So use mmap(), and ignore the resulting VMA. */
624 pagesize = getpagesize ();
625 memneed = len;
626 memneed = ((memneed - 1) / pagesize + 1) * pagesize;
627 auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
628 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
629 if (auxmap == (void *) -1)
630 return -1;
631 auxmap_start = (unsigned long) auxmap;
632 auxmap_end = auxmap_start + memneed;
633 mem = (char *) auxmap;
634 if (sysctl (info_path, 4, mem, &len, NULL, 0) < 0)
635 {
636 munmap (auxmap, memneed);
637 return -1;
638 }
639 p = mem;
640 p_end = mem + len;
641 while (p < p_end)
642 {
643 struct kinfo_vmentry *kve = (struct kinfo_vmentry *) p;
644 unsigned long start = kve->kve_start;
645 unsigned long end = kve->kve_end;
646 unsigned int flags = 0;
647 if (kve->kve_protection & KVME_PROT_READ)
648 flags |= VMA_PROT_READ;
649 if (kve->kve_protection & KVME_PROT_WRITE)
650 flags |= VMA_PROT_WRITE;
651 if (kve->kve_protection & KVME_PROT_EXEC)
652 flags |= VMA_PROT_EXECUTE;
653 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
654 {
655 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
656 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
657 if (start < auxmap_start)
658 if (callback (data, start, auxmap_start, flags))
659 break;
660 if (auxmap_end - 1 < end - 1)
661 if (callback (data, auxmap_end, end, flags))
662 break;
663 }
664 else
665 {
666 if (callback (data, start, end, flags))
667 break;
668 }
669 p += kve->kve_structsize;
670 }
671 munmap (auxmap, memneed);
672 return 0;
673 }
674
675 #elif defined __NetBSD__ && defined VM_PROC_MAP /* NetBSD >= 8.0 */
676
677 static int
678 vma_iterate_bsd (vma_iterate_callback_fn callback, void *data)
679 {
680 /* Documentation: https://man.netbsd.org/man/sysctl+7 */
681 unsigned int entry_size =
682 /* If we wanted to have the path of each entry, we would need
683 sizeof (struct kinfo_vmentry). But we need only the non-string
684 parts of each entry. */
685 offsetof (struct kinfo_vmentry, kve_path);
686 int info_path[] = { CTL_VM, VM_PROC, VM_PROC_MAP, getpid (), entry_size };
687 size_t len;
688 size_t pagesize;
689 size_t memneed;
690 void *auxmap;
691 unsigned long auxmap_start;
692 unsigned long auxmap_end;
693 char *mem;
694 char *p;
695 char *p_end;
696
697 len = 0;
698 if (sysctl (info_path, 5, NULL, &len, NULL, 0) < 0)
699 return -1;
700 /* Allow for small variations over time. In a multithreaded program
701 new VMAs can be allocated at any moment. */
702 len = 2 * len + 10 * entry_size;
703 /* But the system call rejects lengths > 1 MB. */
704 if (len > 0x100000)
705 len = 0x100000;
706 /* And the system call causes a kernel panic if the length is not a multiple
707 of entry_size. */
708 len = (len / entry_size) * entry_size;
709 /* Allocate memneed bytes of memory.
710 We cannot use alloca here, because not much stack space is guaranteed.
711 We also cannot use malloc here, because a malloc() call may call mmap()
712 and thus pre-allocate available memory.
713 So use mmap(), and ignore the resulting VMA. */
714 pagesize = getpagesize ();
715 memneed = len;
716 memneed = ((memneed - 1) / pagesize + 1) * pagesize;
717 auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
718 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
719 if (auxmap == (void *) -1)
720 return -1;
721 auxmap_start = (unsigned long) auxmap;
722 auxmap_end = auxmap_start + memneed;
723 mem = (char *) auxmap;
724 if (sysctl (info_path, 5, mem, &len, NULL, 0) < 0
725 || len > 0x100000 - entry_size)
726 {
727 /* sysctl failed, or the list of VMAs is possibly truncated. */
728 munmap (auxmap, memneed);
729 return -1;
730 }
731 p = mem;
732 p_end = mem + len;
733 while (p < p_end)
734 {
735 struct kinfo_vmentry *kve = (struct kinfo_vmentry *) p;
736 unsigned long start = kve->kve_start;
737 unsigned long end = kve->kve_end;
738 unsigned int flags = 0;
739 if (kve->kve_protection & KVME_PROT_READ)
740 flags |= VMA_PROT_READ;
741 if (kve->kve_protection & KVME_PROT_WRITE)
742 flags |= VMA_PROT_WRITE;
743 if (kve->kve_protection & KVME_PROT_EXEC)
744 flags |= VMA_PROT_EXECUTE;
745 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
746 {
747 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
748 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
749 if (start < auxmap_start)
750 if (callback (data, start, auxmap_start, flags))
751 break;
752 if (auxmap_end - 1 < end - 1)
753 if (callback (data, auxmap_end, end, flags))
754 break;
755 }
756 else
757 {
758 if (callback (data, start, end, flags))
759 break;
760 }
761 p += entry_size;
762 }
763 munmap (auxmap, memneed);
764 return 0;
765 }
766
767 #elif defined __OpenBSD__ && defined KERN_PROC_VMMAP /* OpenBSD >= 5.7 */
768
769 static int
770 vma_iterate_bsd (vma_iterate_callback_fn callback, void *data)
771 {
772 /* Documentation: https://man.openbsd.org/sysctl.2 */
773 int info_path[] = { CTL_KERN, KERN_PROC_VMMAP, getpid () };
774 size_t len;
775 size_t pagesize;
776 size_t memneed;
777 void *auxmap;
778 unsigned long auxmap_start;
779 unsigned long auxmap_end;
780 char *mem;
781 char *p;
782 char *p_end;
783
784 len = 0;
785 if (sysctl (info_path, 3, NULL, &len, NULL, 0) < 0)
786 return -1;
787 /* Allow for small variations over time. In a multithreaded program
788 new VMAs can be allocated at any moment. */
789 len = 2 * len + 10 * sizeof (struct kinfo_vmentry);
790 /* But the system call rejects lengths > 64 KB. */
791 if (len > 0x10000)
792 len = 0x10000;
793 /* And the system call rejects lengths that are not a multiple of
794 sizeof (struct kinfo_vmentry). */
795 len = (len / sizeof (struct kinfo_vmentry)) * sizeof (struct kinfo_vmentry);
796 /* Allocate memneed bytes of memory.
797 We cannot use alloca here, because not much stack space is guaranteed.
798 We also cannot use malloc here, because a malloc() call may call mmap()
799 and thus pre-allocate available memory.
800 So use mmap(), and ignore the resulting VMA. */
801 pagesize = getpagesize ();
802 memneed = len;
803 memneed = ((memneed - 1) / pagesize + 1) * pagesize;
804 auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
805 MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
806 if (auxmap == (void *) -1)
807 return -1;
808 auxmap_start = (unsigned long) auxmap;
809 auxmap_end = auxmap_start + memneed;
810 mem = (char *) auxmap;
811 if (sysctl (info_path, 3, mem, &len, NULL, 0) < 0
812 || len > 0x10000 - sizeof (struct kinfo_vmentry))
813 {
814 /* sysctl failed, or the list of VMAs is possibly truncated. */
815 munmap (auxmap, memneed);
816 return -1;
817 }
818 p = mem;
819 p_end = mem + len;
820 while (p < p_end)
821 {
822 struct kinfo_vmentry *kve = (struct kinfo_vmentry *) p;
823 unsigned long start = kve->kve_start;
824 unsigned long end = kve->kve_end;
825 unsigned int flags = 0;
826 if (kve->kve_protection & KVE_PROT_READ)
827 flags |= VMA_PROT_READ;
828 if (kve->kve_protection & KVE_PROT_WRITE)
829 flags |= VMA_PROT_WRITE;
830 if (kve->kve_protection & KVE_PROT_EXEC)
831 flags |= VMA_PROT_EXECUTE;
832 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
833 {
834 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
835 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
836 if (start < auxmap_start)
837 if (callback (data, start, auxmap_start, flags))
838 break;
839 if (auxmap_end - 1 < end - 1)
840 if (callback (data, auxmap_end, end, flags))
841 break;
842 }
843 else
844 {
845 if (start != end)
846 if (callback (data, start, end, flags))
847 break;
848 }
849 p += sizeof (struct kinfo_vmentry);
850 }
851 munmap (auxmap, memneed);
852 return 0;
853 }
854
855 #else
856
857 static inline int
858 vma_iterate_bsd (vma_iterate_callback_fn callback, void *data)
859 {
860 return -1;
861 }
862
863 #endif
864
865
866 int
867 vma_iterate (vma_iterate_callback_fn callback, void *data)
868 {
869 #if defined __linux__ || defined __ANDROID__ || defined __FreeBSD_kernel__ || defined __FreeBSD__ || defined __DragonFly__ || defined __NetBSD__ || defined __minix /* || defined __CYGWIN__ */
870
871 # if defined __FreeBSD__
872 /* On FreeBSD with procfs (but not GNU/kFreeBSD, which uses linprocfs), the
873 function vma_iterate_proc does not return the virtual memory areas that
874 were created by anonymous mmap. See
875 <https://svnweb.freebsd.org/base/head/sys/fs/procfs/procfs_map.c?view=markup>
876 So use vma_iterate_proc only as a fallback. */
877 int retval = vma_iterate_bsd (callback, data);
878 if (retval == 0)
879 return 0;
880
881 return vma_iterate_proc (callback, data);
882 # else
883 /* On the other platforms, try the /proc approach first, and the sysctl()
884 as a fallback. */
885 int retval = vma_iterate_proc (callback, data);
886 if (retval == 0)
887 return 0;
888
889 return vma_iterate_bsd (callback, data);
890 # endif
891
892 #elif defined __sgi || defined __osf__ /* IRIX, OSF/1 */
893
894 size_t pagesize;
895 char fnamebuf[6+10+1];
896 char *fname;
897 int fd;
898 int nmaps;
899 size_t memneed;
900 # if HAVE_MAP_ANONYMOUS
901 # define zero_fd -1
902 # define map_flags MAP_ANONYMOUS
903 # else
904 int zero_fd;
905 # define map_flags 0
906 # endif
907 void *auxmap;
908 unsigned long auxmap_start;
909 unsigned long auxmap_end;
910 prmap_t* maps;
911 prmap_t* mp;
912
913 pagesize = getpagesize ();
914
915 /* Construct fname = sprintf (fnamebuf+i, "/proc/%u", getpid ()). */
916 fname = fnamebuf + sizeof (fnamebuf) - 1;
917 *fname = '\0';
918 {
919 unsigned int value = getpid ();
920 do
921 *--fname = (value % 10) + '0';
922 while ((value = value / 10) > 0);
923 }
924 fname -= 6;
925 memcpy (fname, "/proc/", 6);
926
927 fd = open (fname, O_RDONLY | O_CLOEXEC);
928 if (fd < 0)
929 return -1;
930
931 if (ioctl (fd, PIOCNMAP, &nmaps) < 0)
932 goto fail2;
933
934 memneed = (nmaps + 10) * sizeof (prmap_t);
935 /* Allocate memneed bytes of memory.
936 We cannot use alloca here, because not much stack space is guaranteed.
937 We also cannot use malloc here, because a malloc() call may call mmap()
938 and thus pre-allocate available memory.
939 So use mmap(), and ignore the resulting VMA. */
940 memneed = ((memneed - 1) / pagesize + 1) * pagesize;
941 # if !HAVE_MAP_ANONYMOUS
942 zero_fd = open ("/dev/zero", O_RDONLY | O_CLOEXEC, 0644);
943 if (zero_fd < 0)
944 goto fail2;
945 # endif
946 auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
947 map_flags | MAP_PRIVATE, zero_fd, 0);
948 # if !HAVE_MAP_ANONYMOUS
949 close (zero_fd);
950 # endif
951 if (auxmap == (void *) -1)
952 goto fail2;
953 auxmap_start = (unsigned long) auxmap;
954 auxmap_end = auxmap_start + memneed;
955 maps = (prmap_t *) auxmap;
956
957 if (ioctl (fd, PIOCMAP, maps) < 0)
958 goto fail1;
959
960 for (mp = maps;;)
961 {
962 unsigned long start, end;
963 unsigned int flags;
964
965 start = (unsigned long) mp->pr_vaddr;
966 end = start + mp->pr_size;
967 if (start == 0 && end == 0)
968 break;
969 flags = 0;
970 if (mp->pr_mflags & MA_READ)
971 flags |= VMA_PROT_READ;
972 if (mp->pr_mflags & MA_WRITE)
973 flags |= VMA_PROT_WRITE;
974 if (mp->pr_mflags & MA_EXEC)
975 flags |= VMA_PROT_EXECUTE;
976 mp++;
977 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
978 {
979 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
980 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
981 if (start < auxmap_start)
982 if (callback (data, start, auxmap_start, flags))
983 break;
984 if (auxmap_end - 1 < end - 1)
985 if (callback (data, auxmap_end, end, flags))
986 break;
987 }
988 else
989 {
990 if (callback (data, start, end, flags))
991 break;
992 }
993 }
994 munmap (auxmap, memneed);
995 close (fd);
996 return 0;
997
998 fail1:
999 munmap (auxmap, memneed);
1000 fail2:
1001 close (fd);
1002 return -1;
1003
1004 #elif defined __sun /* Solaris */
1005
1006 /* Note: Solaris <sys/procfs.h> defines a different type prmap_t with
1007 _STRUCTURED_PROC than without! Here's a table of sizeof(prmap_t):
1008 32-bit 64-bit
1009 _STRUCTURED_PROC = 0 32 56
1010 _STRUCTURED_PROC = 1 96 104
1011 Therefore, if the include files provide the newer API, prmap_t has
1012 the bigger size, and thus you MUST use the newer API. And if the
1013 include files provide the older API, prmap_t has the smaller size,
1014 and thus you MUST use the older API. */
1015
1016 # if defined PIOCNMAP && defined PIOCMAP
1017 /* We must use the older /proc interface. */
1018
1019 size_t pagesize;
1020 char fnamebuf[6+10+1];
1021 char *fname;
1022 int fd;
1023 int nmaps;
1024 size_t memneed;
1025 # if HAVE_MAP_ANONYMOUS
1026 # define zero_fd -1
1027 # define map_flags MAP_ANONYMOUS
1028 # else /* Solaris <= 7 */
1029 int zero_fd;
1030 # define map_flags 0
1031 # endif
1032 void *auxmap;
1033 unsigned long auxmap_start;
1034 unsigned long auxmap_end;
1035 prmap_t* maps;
1036 prmap_t* mp;
1037
1038 pagesize = getpagesize ();
1039
1040 /* Construct fname = sprintf (fnamebuf+i, "/proc/%u", getpid ()). */
1041 fname = fnamebuf + sizeof (fnamebuf) - 1;
1042 *fname = '\0';
1043 {
1044 unsigned int value = getpid ();
1045 do
1046 *--fname = (value % 10) + '0';
1047 while ((value = value / 10) > 0);
1048 }
1049 fname -= 6;
1050 memcpy (fname, "/proc/", 6);
1051
1052 fd = open (fname, O_RDONLY | O_CLOEXEC);
1053 if (fd < 0)
1054 return -1;
1055
1056 if (ioctl (fd, PIOCNMAP, &nmaps) < 0)
1057 goto fail2;
1058
1059 memneed = (nmaps + 10) * sizeof (prmap_t);
1060 /* Allocate memneed bytes of memory.
1061 We cannot use alloca here, because not much stack space is guaranteed.
1062 We also cannot use malloc here, because a malloc() call may call mmap()
1063 and thus pre-allocate available memory.
1064 So use mmap(), and ignore the resulting VMA. */
1065 memneed = ((memneed - 1) / pagesize + 1) * pagesize;
1066 # if !HAVE_MAP_ANONYMOUS
1067 zero_fd = open ("/dev/zero", O_RDONLY | O_CLOEXEC, 0644);
1068 if (zero_fd < 0)
1069 goto fail2;
1070 # endif
1071 auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
1072 map_flags | MAP_PRIVATE, zero_fd, 0);
1073 # if !HAVE_MAP_ANONYMOUS
1074 close (zero_fd);
1075 # endif
1076 if (auxmap == (void *) -1)
1077 goto fail2;
1078 auxmap_start = (unsigned long) auxmap;
1079 auxmap_end = auxmap_start + memneed;
1080 maps = (prmap_t *) auxmap;
1081
1082 if (ioctl (fd, PIOCMAP, maps) < 0)
1083 goto fail1;
1084
1085 for (mp = maps;;)
1086 {
1087 unsigned long start, end;
1088 unsigned int flags;
1089
1090 start = (unsigned long) mp->pr_vaddr;
1091 end = start + mp->pr_size;
1092 if (start == 0 && end == 0)
1093 break;
1094 flags = 0;
1095 if (mp->pr_mflags & MA_READ)
1096 flags |= VMA_PROT_READ;
1097 if (mp->pr_mflags & MA_WRITE)
1098 flags |= VMA_PROT_WRITE;
1099 if (mp->pr_mflags & MA_EXEC)
1100 flags |= VMA_PROT_EXECUTE;
1101 mp++;
1102 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
1103 {
1104 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
1105 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
1106 if (start < auxmap_start)
1107 if (callback (data, start, auxmap_start, flags))
1108 break;
1109 if (auxmap_end - 1 < end - 1)
1110 if (callback (data, auxmap_end, end, flags))
1111 break;
1112 }
1113 else
1114 {
1115 if (callback (data, start, end, flags))
1116 break;
1117 }
1118 }
1119 munmap (auxmap, memneed);
1120 close (fd);
1121 return 0;
1122
1123 fail1:
1124 munmap (auxmap, memneed);
1125 fail2:
1126 close (fd);
1127 return -1;
1128
1129 # else
1130 /* We must use the newer /proc interface.
1131 Documentation:
1132 https://docs.oracle.com/cd/E23824_01/html/821-1473/proc-4.html
1133 The contents of /proc/<pid>/map consists of records of type
1134 prmap_t. These are different in 32-bit and 64-bit processes,
1135 but here we are fortunately accessing only the current process. */
1136
1137 size_t pagesize;
1138 char fnamebuf[6+10+4+1];
1139 char *fname;
1140 int fd;
1141 int nmaps;
1142 size_t memneed;
1143 # if HAVE_MAP_ANONYMOUS
1144 # define zero_fd -1
1145 # define map_flags MAP_ANONYMOUS
1146 # else /* Solaris <= 7 */
1147 int zero_fd;
1148 # define map_flags 0
1149 # endif
1150 void *auxmap;
1151 unsigned long auxmap_start;
1152 unsigned long auxmap_end;
1153 prmap_t* maps;
1154 prmap_t* maps_end;
1155 prmap_t* mp;
1156
1157 pagesize = getpagesize ();
1158
1159 /* Construct fname = sprintf (fnamebuf+i, "/proc/%u/map", getpid ()). */
1160 fname = fnamebuf + sizeof (fnamebuf) - 1 - 4;
1161 memcpy (fname, "/map", 4 + 1);
1162 {
1163 unsigned int value = getpid ();
1164 do
1165 *--fname = (value % 10) + '0';
1166 while ((value = value / 10) > 0);
1167 }
1168 fname -= 6;
1169 memcpy (fname, "/proc/", 6);
1170
1171 fd = open (fname, O_RDONLY | O_CLOEXEC);
1172 if (fd < 0)
1173 return -1;
1174
1175 {
1176 struct stat statbuf;
1177 if (fstat (fd, &statbuf) < 0)
1178 goto fail2;
1179 nmaps = statbuf.st_size / sizeof (prmap_t);
1180 }
1181
1182 memneed = (nmaps + 10) * sizeof (prmap_t);
1183 /* Allocate memneed bytes of memory.
1184 We cannot use alloca here, because not much stack space is guaranteed.
1185 We also cannot use malloc here, because a malloc() call may call mmap()
1186 and thus pre-allocate available memory.
1187 So use mmap(), and ignore the resulting VMA. */
1188 memneed = ((memneed - 1) / pagesize + 1) * pagesize;
1189 # if !HAVE_MAP_ANONYMOUS
1190 zero_fd = open ("/dev/zero", O_RDONLY | O_CLOEXEC, 0644);
1191 if (zero_fd < 0)
1192 goto fail2;
1193 # endif
1194 auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
1195 map_flags | MAP_PRIVATE, zero_fd, 0);
1196 # if !HAVE_MAP_ANONYMOUS
1197 close (zero_fd);
1198 # endif
1199 if (auxmap == (void *) -1)
1200 goto fail2;
1201 auxmap_start = (unsigned long) auxmap;
1202 auxmap_end = auxmap_start + memneed;
1203 maps = (prmap_t *) auxmap;
1204
1205 /* Read up to memneed bytes from fd into maps. */
1206 {
1207 size_t remaining = memneed;
1208 size_t total_read = 0;
1209 char *ptr = (char *) maps;
1210
1211 do
1212 {
1213 size_t nread = read (fd, ptr, remaining);
1214 if (nread == (size_t)-1)
1215 {
1216 if (errno == EINTR)
1217 continue;
1218 goto fail1;
1219 }
1220 if (nread == 0)
1221 /* EOF */
1222 break;
1223 total_read += nread;
1224 ptr += nread;
1225 remaining -= nread;
1226 }
1227 while (remaining > 0);
1228
1229 nmaps = (memneed - remaining) / sizeof (prmap_t);
1230 maps_end = maps + nmaps;
1231 }
1232
1233 for (mp = maps; mp < maps_end; mp++)
1234 {
1235 unsigned long start, end;
1236 unsigned int flags;
1237
1238 start = (unsigned long) mp->pr_vaddr;
1239 end = start + mp->pr_size;
1240 flags = 0;
1241 if (mp->pr_mflags & MA_READ)
1242 flags |= VMA_PROT_READ;
1243 if (mp->pr_mflags & MA_WRITE)
1244 flags |= VMA_PROT_WRITE;
1245 if (mp->pr_mflags & MA_EXEC)
1246 flags |= VMA_PROT_EXECUTE;
1247 if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
1248 {
1249 /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
1250 = [start,auxmap_start-1] u [auxmap_end,end-1]. */
1251 if (start < auxmap_start)
1252 if (callback (data, start, auxmap_start, flags))
1253 break;
1254 if (auxmap_end - 1 < end - 1)
1255 if (callback (data, auxmap_end, end, flags))
1256 break;
1257 }
1258 else
1259 {
1260 if (callback (data, start, end, flags))
1261 break;
1262 }
1263 }
1264 munmap (auxmap, memneed);
1265 close (fd);
1266 return 0;
1267
1268 fail1:
1269 munmap (auxmap, memneed);
1270 fail2:
1271 close (fd);
1272 return -1;
1273
1274 # endif
1275
1276 #elif HAVE_PSTAT_GETPROCVM /* HP-UX */
1277
1278 unsigned long pagesize = getpagesize ();
1279 int i;
1280
1281 for (i = 0; ; i++)
1282 {
1283 struct pst_vm_status info;
1284 int ret = pstat_getprocvm (&info, sizeof (info), 0, i);
1285 if (ret < 0)
1286 return -1;
1287 if (ret == 0)
1288 break;
1289 {
1290 unsigned long start = info.pst_vaddr;
1291 unsigned long end = start + info.pst_length * pagesize;
1292 unsigned int flags = 0;
1293 if (info.pst_permission & PS_PROT_READ)
1294 flags |= VMA_PROT_READ;
1295 if (info.pst_permission & PS_PROT_WRITE)
1296 flags |= VMA_PROT_WRITE;
1297 if (info.pst_permission & PS_PROT_EXECUTE)
1298 flags |= VMA_PROT_EXECUTE;
1299
1300 if (callback (data, start, end, flags))
1301 break;
1302 }
1303 }
1304
1305 #elif defined __APPLE__ && defined __MACH__ /* Mac OS X */
1306
1307 task_t task = mach_task_self ();
1308 vm_address_t address;
1309 vm_size_t size;
1310
1311 for (address = VM_MIN_ADDRESS;; address += size)
1312 {
1313 int more;
1314 mach_port_t object_name;
1315 unsigned int flags;
1316 /* In Mac OS X 10.5, the types vm_address_t, vm_offset_t, vm_size_t have
1317 32 bits in 32-bit processes and 64 bits in 64-bit processes. Whereas
1318 mach_vm_address_t and mach_vm_size_t are always 64 bits large.
1319 Mac OS X 10.5 has three vm_region like methods:
1320 - vm_region. It has arguments that depend on whether the current
1321 process is 32-bit or 64-bit. When linking dynamically, this
1322 function exists only in 32-bit processes. Therefore we use it only
1323 in 32-bit processes.
1324 - vm_region_64. It has arguments that depend on whether the current
1325 process is 32-bit or 64-bit. It interprets a flavor
1326 VM_REGION_BASIC_INFO as VM_REGION_BASIC_INFO_64, which is
1327 dangerous since 'struct vm_region_basic_info_64' is larger than
1328 'struct vm_region_basic_info'; therefore let's write
1329 VM_REGION_BASIC_INFO_64 explicitly.
1330 - mach_vm_region. It has arguments that are 64-bit always. This
1331 function is useful when you want to access the VM of a process
1332 other than the current process.
1333 In 64-bit processes, we could use vm_region_64 or mach_vm_region.
1334 I choose vm_region_64 because it uses the same types as vm_region,
1335 resulting in less conditional code. */
1336 # if defined __aarch64__ || defined __ppc64__ || defined __x86_64__
1337 struct vm_region_basic_info_64 info;
1338 mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT_64;
1339
1340 more = (vm_region_64 (task, &address, &size, VM_REGION_BASIC_INFO_64,
1341 (vm_region_info_t)&info, &info_count, &object_name)
1342 == KERN_SUCCESS);
1343 # else
1344 struct vm_region_basic_info info;
1345 mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT;
1346
1347 more = (vm_region (task, &address, &size, VM_REGION_BASIC_INFO,
1348 (vm_region_info_t)&info, &info_count, &object_name)
1349 == KERN_SUCCESS);
1350 # endif
1351 if (object_name != MACH_PORT_NULL)
1352 mach_port_deallocate (mach_task_self (), object_name);
1353 if (!more)
1354 break;
1355 flags = 0;
1356 if (info.protection & VM_PROT_READ)
1357 flags |= VMA_PROT_READ;
1358 if (info.protection & VM_PROT_WRITE)
1359 flags |= VMA_PROT_WRITE;
1360 if (info.protection & VM_PROT_EXECUTE)
1361 flags |= VMA_PROT_EXECUTE;
1362 if (callback (data, address, address + size, flags))
1363 break;
1364 }
1365 return 0;
1366
1367 #elif defined __GNU__ /* GNU/Hurd */
1368
1369 /* The Hurd has a /proc/self/maps that looks like the Linux one, but it
1370 lacks the VMAs created through anonymous mmap. Therefore use the Mach
1371 API.
1372 Documentation:
1373 https://www.gnu.org/software/hurd/gnumach-doc/Memory-Attributes.html */
1374
1375 task_t task = mach_task_self ();
1376 vm_address_t address;
1377 vm_size_t size;
1378
1379 for (address = 0;; address += size)
1380 {
1381 vm_prot_t protection;
1382 vm_prot_t max_protection;
1383 vm_inherit_t inheritance;
1384 boolean_t shared;
1385 memory_object_name_t object_name;
1386 vm_offset_t offset;
1387 unsigned int flags;
1388
1389 if (!(vm_region (task, &address, &size, &protection, &max_protection,
1390 &inheritance, &shared, &object_name, &offset)
1391 == KERN_SUCCESS))
1392 break;
1393 mach_port_deallocate (task, object_name);
1394 flags = 0;
1395 if (protection & VM_PROT_READ)
1396 flags |= VMA_PROT_READ;
1397 if (protection & VM_PROT_WRITE)
1398 flags |= VMA_PROT_WRITE;
1399 if (protection & VM_PROT_EXECUTE)
1400 flags |= VMA_PROT_EXECUTE;
1401 if (callback (data, address, address + size, flags))
1402 break;
1403 }
1404 return 0;
1405
1406 #elif defined _WIN32 || defined __CYGWIN__
1407 /* Windows platform. Use the native Windows API. */
1408
1409 MEMORY_BASIC_INFORMATION info;
1410 uintptr_t address = 0;
1411
1412 while (VirtualQuery ((void*)address, &info, sizeof(info)) == sizeof(info))
1413 {
1414 if (info.State != MEM_FREE)
1415 /* Ignore areas where info.State has the value MEM_RESERVE or,
1416 equivalently, info.Protect has the undocumented value 0.
1417 This is needed, so that on Cygwin, areas used by malloc() are
1418 distinguished from areas reserved for future malloc(). */
1419 if (info.State != MEM_RESERVE)
1420 {
1421 uintptr_t start, end;
1422 unsigned int flags;
1423
1424 start = (uintptr_t)info.BaseAddress;
1425 end = start + info.RegionSize;
1426 switch (info.Protect & ~(PAGE_GUARD|PAGE_NOCACHE))
1427 {
1428 case PAGE_READONLY:
1429 flags = VMA_PROT_READ;
1430 break;
1431 case PAGE_READWRITE:
1432 case PAGE_WRITECOPY:
1433 flags = VMA_PROT_READ | VMA_PROT_WRITE;
1434 break;
1435 case PAGE_EXECUTE:
1436 flags = VMA_PROT_EXECUTE;
1437 break;
1438 case PAGE_EXECUTE_READ:
1439 flags = VMA_PROT_READ | VMA_PROT_EXECUTE;
1440 break;
1441 case PAGE_EXECUTE_READWRITE:
1442 case PAGE_EXECUTE_WRITECOPY:
1443 flags = VMA_PROT_READ | VMA_PROT_WRITE | VMA_PROT_EXECUTE;
1444 break;
1445 case PAGE_NOACCESS:
1446 default:
1447 flags = 0;
1448 break;
1449 }
1450
1451 if (callback (data, start, end, flags))
1452 break;
1453 }
1454 address = (uintptr_t)info.BaseAddress + info.RegionSize;
1455 }
1456 return 0;
1457
1458 #elif defined __BEOS__ || defined __HAIKU__
1459 /* Use the BeOS specific API. */
1460
1461 area_info info;
1462 ssize_t cookie;
1463
1464 cookie = 0;
1465 while (get_next_area_info (0, &cookie, &info) == B_OK)
1466 {
1467 unsigned long start, end;
1468 unsigned int flags;
1469
1470 start = (unsigned long) info.address;
1471 end = start + info.size;
1472 flags = 0;
1473 if (info.protection & B_READ_AREA)
1474 flags |= VMA_PROT_READ | VMA_PROT_EXECUTE;
1475 if (info.protection & B_WRITE_AREA)
1476 flags |= VMA_PROT_WRITE;
1477
1478 if (callback (data, start, end, flags))
1479 break;
1480 }
1481 return 0;
1482
1483 #elif HAVE_MQUERY /* OpenBSD */
1484
1485 # if defined __OpenBSD__
1486 /* Try sysctl() first. It is more efficient than the mquery() loop below
1487 and also provides the flags. */
1488 {
1489 int retval = vma_iterate_bsd (callback, data);
1490 if (retval == 0)
1491 return 0;
1492 }
1493 # endif
1494
1495 {
1496 uintptr_t pagesize;
1497 uintptr_t address;
1498 int /*bool*/ address_known_mapped;
1499
1500 pagesize = getpagesize ();
1501 /* Avoid calling mquery with a NULL first argument, because this argument
1502 value has a specific meaning. We know the NULL page is unmapped. */
1503 address = pagesize;
1504 address_known_mapped = 0;
1505 for (;;)
1506 {
1507 /* Test whether the page at address is mapped. */
1508 if (address_known_mapped
1509 || mquery ((void *) address, pagesize, 0, MAP_FIXED, -1, 0)
1510 == (void *) -1)
1511 {
1512 /* The page at address is mapped.
1513 This is the start of an interval. */
1514 uintptr_t start = address;
1515 uintptr_t end;
1516
1517 /* Find the end of the interval. */
1518 end = (uintptr_t) mquery ((void *) address, pagesize, 0, 0, -1, 0);
1519 if (end == (uintptr_t) (void *) -1)
1520 end = 0; /* wrap around */
1521 address = end;
1522
1523 /* It's too complicated to find out about the flags.
1524 Just pass 0. */
1525 if (callback (data, start, end, 0))
1526 break;
1527
1528 if (address < pagesize) /* wrap around? */
1529 break;
1530 }
1531 /* Here we know that the page at address is unmapped. */
1532 {
1533 uintptr_t query_size = pagesize;
1534
1535 address += pagesize;
1536
1537 /* Query larger and larger blocks, to get through the unmapped address
1538 range with few mquery() calls. */
1539 for (;;)
1540 {
1541 if (2 * query_size > query_size)
1542 query_size = 2 * query_size;
1543 if (address + query_size - 1 < query_size) /* wrap around? */
1544 {
1545 address_known_mapped = 0;
1546 break;
1547 }
1548 if (mquery ((void *) address, query_size, 0, MAP_FIXED, -1, 0)
1549 == (void *) -1)
1550 {
1551 /* Not all the interval [address .. address + query_size - 1]
1552 is unmapped. */
1553 address_known_mapped = (query_size == pagesize);
1554 break;
1555 }
1556 /* The interval [address .. address + query_size - 1] is
1557 unmapped. */
1558 address += query_size;
1559 }
1560 /* Reduce the query size again, to determine the precise size of the
1561 unmapped interval that starts at address. */
1562 while (query_size > pagesize)
1563 {
1564 query_size = query_size / 2;
1565 if (address + query_size - 1 >= query_size)
1566 {
1567 if (mquery ((void *) address, query_size, 0, MAP_FIXED, -1, 0)
1568 != (void *) -1)
1569 {
1570 /* The interval [address .. address + query_size - 1] is
1571 unmapped. */
1572 address += query_size;
1573 address_known_mapped = 0;
1574 }
1575 else
1576 address_known_mapped = (query_size == pagesize);
1577 }
1578 }
1579 /* Here again query_size = pagesize, and
1580 either address + pagesize - 1 < pagesize, or
1581 mquery ((void *) address, pagesize, 0, MAP_FIXED, -1, 0) fails.
1582 So, the unmapped area ends at address. */
1583 }
1584 if (address + pagesize - 1 < pagesize) /* wrap around? */
1585 break;
1586 }
1587 return 0;
1588 }
1589
1590 #else
1591
1592 /* Not implemented. */
1593 return -1;
1594
1595 #endif
1596 }
1597
1598
1599 #ifdef TEST
1600
1601 #include <stdio.h>
1602
1603 /* Output the VMAs of the current process in a format similar to the Linux
1604 /proc/$pid/maps file. */
1605
1606 static int
1607 vma_iterate_callback (void *data, uintptr_t start, uintptr_t end,
1608 unsigned int flags)
1609 {
1610 printf ("%08lx-%08lx %c%c%c\n",
1611 (unsigned long) start, (unsigned long) end,
1612 flags & VMA_PROT_READ ? 'r' : '-',
1613 flags & VMA_PROT_WRITE ? 'w' : '-',
1614 flags & VMA_PROT_EXECUTE ? 'x' : '-');
1615 return 0;
1616 }
1617
1618 int
1619 main ()
1620 {
1621 vma_iterate (vma_iterate_callback, NULL);
1622
1623 /* Let the user interactively look at the /proc file system. */
1624 sleep (10);
1625
1626 return 0;
1627 }
1628
1629 /*
1630 * Local Variables:
1631 * compile-command: "gcc -ggdb -DTEST -Wall -I.. vma-iter.c"
1632 * End:
1633 */
1634
1635 #endif /* TEST */