/* System support for get_rusage_as_via_iterator(). */
-#if defined __sgi || defined __osf__ /* IRIX, OSF/1 */
-# include <string.h> /* memcpy */
-# include <sys/types.h>
-# include <sys/procfs.h> /* PIOC*, prmap_t */
-#endif
-
-#if defined __APPLE__ && defined __MACH__ /* MacOS X */
-# include <mach/mach.h>
-#endif
-
-#if (defined _WIN32 || defined __WIN32__) || defined __CYGWIN__ /* Windows */
-# include <windows.h>
-#endif
-
-#if defined __BEOS__ /* BeOS */
-# include <OS.h>
-#endif
+#include "vma-iter.h"
#if HAVE_SETRLIMIT && defined RLIMIT_AS && HAVE_SYS_MMAN_H && HAVE_MPROTECT
#endif
-/* Support for reading text files in the /proc file system. */
-
-#if defined __linux__ || defined __FreeBSD__ || defined __NetBSD__ /* || defined __CYGWIN__ */
-
-/* Buffered read-only streams.
- We cannot use <stdio.h> here, because fopen() calls malloc(), and a malloc()
- call may call mmap() and thus pre-allocate available memory. */
-
-struct rofile
- {
- int fd;
- size_t position;
- size_t filled;
- int eof_seen;
- char buffer[1024];
- };
-
-/* Open a read-only file stream. */
-static int
-rof_open (struct rofile *rof, const char *filename)
-{
- int fd = open (filename, O_RDONLY);
- if (fd < 0)
- return -1;
- rof->fd = fd;
- rof->position = 0;
- rof->filled = 0;
- rof->eof_seen = 0;
- return 0;
-}
+#if VMA_ITERATE_SUPPORTED
-/* Return the next byte from a read-only file stream without consuming it,
- or -1 at EOF. */
static int
-rof_peekchar (struct rofile *rof)
+vma_iterate_callback (void *data, uintptr_t start, uintptr_t end,
+ unsigned int flags)
{
- if (rof->position == rof->filled)
- {
- if (rof->eof_seen)
- return -1;
- else
- for (;;)
- {
- int n = read (rof->fd, rof->buffer, sizeof (rof->buffer));
-# ifdef EINTR
- if (n < 0 && errno == EINTR)
- continue;
-# endif
- if (n <= 0)
- {
- rof->eof_seen = 1;
- return -1;
- }
- rof->filled = n;
- rof->position = 0;
- break;
- }
- }
- return (unsigned char) rof->buffer[rof->position];
-}
+ uintptr_t *totalp = (uintptr_t *) data;
-/* Return the next byte from a read-only file stream, or -1 at EOF. */
-static int
-rof_getchar (struct rofile *rof)
-{
- int c = rof_peekchar (rof);
- if (c >= 0)
- rof->position++;
- return c;
-}
-
-/* Parse an unsigned hexadecimal number from a read-only file stream. */
-static int
-rof_scanf_lx (struct rofile *rof, unsigned long *valuep)
-{
- unsigned long value = 0;
- unsigned int numdigits = 0;
- for (;;)
- {
- int c = rof_peekchar (rof);
- if (c >= '0' && c <= '9')
- value = (value << 4) + (c - '0');
- else if (c >= 'A' && c <= 'F')
- value = (value << 4) + (c - 'A' + 10);
- else if (c >= 'a' && c <= 'f')
- value = (value << 4) + (c - 'a' + 10);
- else
- break;
- rof_getchar (rof);
- numdigits++;
- }
- if (numdigits == 0)
- return -1;
- *valuep = value;
+ *totalp += end - start;
return 0;
}
-/* Close a read-only file stream. */
-static void
-rof_close (struct rofile *rof)
-{
- close (rof->fd);
-}
-
-#endif
-
-
static inline uintptr_t
get_rusage_as_via_iterator (void)
{
-#if defined __linux__ /* || defined __CYGWIN__ */
-
- struct rofile rof;
- int c;
- unsigned long total;
-
- /* Open the current process' maps file. It describes one VMA per line. */
- if (rof_open (&rof, "/proc/self/maps") < 0)
- return 0;
-
- total = 0;
- for (;;)
- {
- unsigned long start, end;
-
- if (!(rof_scanf_lx (&rof, &start) >= 0
- && rof_getchar (&rof) == '-'
- && rof_scanf_lx (&rof, &end) >= 0))
- break;
- while (c = rof_getchar (&rof), c != -1 && c != '\n')
- ;
- total += end - start;
- }
- rof_close (&rof);
- return total;
-
-#elif defined __FreeBSD__ || defined __NetBSD__
-
- struct rofile rof;
- int c;
- unsigned long total;
-
- /* Open the current process' maps file. It describes one VMA per line. */
- if (rof_open (&rof, "/proc/curproc/map") < 0)
- return 0;
-
- total = 0;
- for (;;)
- {
- unsigned long start, end;
-
- if (!(rof_getchar (&rof) == '0'
- && rof_getchar (&rof) == 'x'
- && rof_scanf_lx (&rof, &start) >= 0))
- break;
- while (c = rof_peekchar (&rof), c == ' ' || c == '\t')
- rof_getchar (&rof);
- if (!(rof_getchar (&rof) == '0'
- && rof_getchar (&rof) == 'x'
- && rof_scanf_lx (&rof, &end) >= 0))
- break;
- while (c = rof_getchar (&rof), c != -1 && c != '\n')
- continue;
- total += end - start;
- }
- rof_close (&rof);
- return total;
-
-#elif defined __sgi || defined __osf__ /* IRIX, OSF/1 */
-
- size_t pagesize;
- char fnamebuf[6+10+1];
- char *fname;
- int fd;
- int nmaps;
- size_t memneed;
-# if HAVE_MAP_ANONYMOUS
-# define zero_fd -1
-# define map_flags MAP_ANONYMOUS
-# else
- int zero_fd;
-# define map_flags 0
-# endif
- void *auxmap;
- unsigned long auxmap_start;
- unsigned long auxmap_end;
- prmap_t* maps;
- prmap_t* mp;
- unsigned long total;
-
- pagesize = getpagesize ();
-
- /* Construct fname = sprintf (fnamebuf+i, "/proc/%u", getpid ()). */
- fname = fnamebuf + sizeof (fnamebuf) - 1;
- *fname = '\0';
- {
- unsigned int value = getpid ();
- do
- *--fname = (value % 10) + '0';
- while ((value = value / 10) > 0);
- }
- fname -= 6;
- memcpy (fname, "/proc/", 6);
-
- fd = open (fname, O_RDONLY);
- if (fd < 0)
- return 0;
-
- if (ioctl (fd, PIOCNMAP, &nmaps) < 0)
- goto fail2;
+ uintptr_t total = 0;
- memneed = (nmaps + 10) * sizeof (prmap_t);
- /* Allocate memneed bytes of memory.
- We cannot use alloca here, because not much stack space is guaranteed.
- We also cannot use malloc here, because a malloc() call may call mmap()
- and thus pre-allocate available memory.
- So use mmap(), and ignore the resulting VMA. */
- memneed = ((memneed - 1) / pagesize + 1) * pagesize;
-# if !HAVE_MAP_ANONYMOUS
- zero_fd = open ("/dev/zero", O_RDONLY, 0644);
- if (zero_fd < 0)
- goto fail2;
-# endif
- auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
- map_flags | MAP_PRIVATE, zero_fd, 0);
-# if !HAVE_MAP_ANONYMOUS
- close (zero_fd);
-# endif
- if (auxmap == (void *) -1)
- goto fail2;
- auxmap_start = (unsigned long) auxmap;
- auxmap_end = auxmap_start + memneed;
- maps = (prmap_t *) auxmap;
+ vma_iterate (vma_iterate_callback, &total);
- if (ioctl (fd, PIOCMAP, maps) < 0)
- goto fail1;
-
- total = 0;
- for (mp = maps;;)
- {
- unsigned long start, end;
-
- start = (unsigned long) mp->pr_vaddr;
- end = start + mp->pr_size;
- if (start == 0 && end == 0)
- break;
- mp++;
- if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
- /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
- = [start,auxmap_start-1] u [auxmap_end,end-1]. */
- total += (end - start) - memneed;
- else
- total += end - start;
- }
- munmap (auxmap, memneed);
- close (fd);
- return total;
-
- fail1:
- munmap (auxmap, memneed);
- fail2:
- close (fd);
- return 0;
-
-#elif defined __APPLE__ && defined __MACH__ /* MacOS X */
-
- task_t task = mach_task_self ();
- vm_address_t address;
- vm_size_t size;
- vm_address_t total = 0;
-
- for (address = VM_MIN_ADDRESS;; address += size)
- {
- int more;
- mach_port_t object_name;
- /* In MacOS X 10.5, the types vm_address_t, vm_offset_t, vm_size_t have
- 32 bits in 32-bit processes and 64 bits in 64-bit processes. Whereas
- mach_vm_address_t and mach_vm_size_t are always 64 bits large.
- MacOS X 10.5 has three vm_region like methods:
- - vm_region. It has arguments that depend on whether the current
- process is 32-bit or 64-bit. When linking dynamically, this
- function exists only in 32-bit processes. Therefore we use it only
- in 32-bit processes.
- - vm_region_64. It has arguments that depend on whether the current
- process is 32-bit or 64-bit. It interprets a flavor
- VM_REGION_BASIC_INFO as VM_REGION_BASIC_INFO_64, which is
- dangerous since 'struct vm_region_basic_info_64' is larger than
- 'struct vm_region_basic_info'; therefore let's write
- VM_REGION_BASIC_INFO_64 explicitly.
- - mach_vm_region. It has arguments that are 64-bit always. This
- function is useful when you want to access the VM of a process
- other than the current process.
- In 64-bit processes, we could use vm_region_64 or mach_vm_region.
- I choose vm_region_64 because it uses the same types as vm_region,
- resulting in less conditional code. */
-# if defined __ppc64__ || defined __x86_64__
- struct vm_region_basic_info_64 info;
- mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT_64;
-
- more = (vm_region_64 (task, &address, &size, VM_REGION_BASIC_INFO_64,
- (vm_region_info_t)&info, &info_count, &object_name)
- == KERN_SUCCESS);
-# else
- struct vm_region_basic_info info;
- mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT;
-
- more = (vm_region (task, &address, &size, VM_REGION_BASIC_INFO,
- (vm_region_info_t)&info, &info_count, &object_name)
- == KERN_SUCCESS);
-# endif
- if (object_name != MACH_PORT_NULL)
- mach_port_deallocate (mach_task_self (), object_name);
- if (!more)
- break;
- total += size;
- }
- return total;
-
-#elif (defined _WIN32 || defined __WIN32__) || defined __CYGWIN__
- /* Windows platform. Use the native Windows API. */
-
- MEMORY_BASIC_INFORMATION info;
- unsigned long address = 0;
- unsigned long total = 0;
-
- while (VirtualQuery ((void*)address, &info, sizeof(info)) == sizeof(info))
- {
- if (info.State != MEM_FREE)
- /* Ignore areas where info.Protect has the undocumented value 0.
- This is needed, so that on Cygwin, areas used by malloc() are
- distinguished from areas reserved for future malloc(). */
- if (info.Protect != 0)
- total += info.RegionSize;
- address = (unsigned long)info.BaseAddress + info.RegionSize;
- }
- return total;
-
-#elif defined __BEOS__
- /* Use the BeOS specific API. */
-
- area_info info;
- int32 cookie;
- unsigned long total = 0;
-
- cookie = 0;
- while (get_next_area_info (0, &cookie, &info) == B_OK)
- {
- unsigned long start, end;
-
- start = (unsigned long) info.address;
- end = start + info.size;
-
- total += end - start;
- }
return total;
+}
#else
+static inline uintptr_t
+get_rusage_as_via_iterator (void)
+{
return 0;
+}
#endif
-}
uintptr_t
--- /dev/null
+/* Iteration over virtual memory areas.
+ Copyright (C) 2011 Free Software Foundation, Inc.
+ Written by Bruno Haible <bruno@clisp.org>, 2011.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+#include <config.h>
+
+/* Specification. */
+#include "vma-iter.h"
+
+#include <errno.h> /* errno */
+#include <stdlib.h> /* size_t */
+#include <fcntl.h> /* open, O_RDONLY */
+#include <unistd.h> /* getpagesize, read, close */
+
+#if defined __sgi || defined __osf__ /* IRIX, OSF/1 */
+# include <string.h> /* memcpy */
+# include <sys/types.h>
+# include <sys/mman.h> /* mmap, munmap */
+# include <sys/procfs.h> /* PIOC*, prmap_t */
+#endif
+
+#if defined __APPLE__ && defined __MACH__ /* MacOS X */
+# include <mach/mach.h>
+#endif
+
+#if (defined _WIN32 || defined __WIN32__) || defined __CYGWIN__ /* Windows */
+# include <windows.h>
+#endif
+
+#if defined __BEOS__ /* BeOS */
+# include <OS.h>
+#endif
+
+
+/* Support for reading text files in the /proc file system. */
+
+#if defined __linux__ || defined __FreeBSD__ || defined __NetBSD__ /* || defined __CYGWIN__ */
+
+/* Buffered read-only streams.
+ We cannot use <stdio.h> here, because fopen() calls malloc(), and a malloc()
+ call may call mmap() and thus pre-allocate available memory. */
+
+struct rofile
+ {
+ int fd;
+ size_t position;
+ size_t filled;
+ int eof_seen;
+ char buffer[1024];
+ };
+
+/* Open a read-only file stream. */
+static int
+rof_open (struct rofile *rof, const char *filename)
+{
+ int fd = open (filename, O_RDONLY);
+ if (fd < 0)
+ return -1;
+ rof->fd = fd;
+ rof->position = 0;
+ rof->filled = 0;
+ rof->eof_seen = 0;
+ return 0;
+}
+
+/* Return the next byte from a read-only file stream without consuming it,
+ or -1 at EOF. */
+static int
+rof_peekchar (struct rofile *rof)
+{
+ if (rof->position == rof->filled)
+ {
+ if (rof->eof_seen)
+ return -1;
+ else
+ for (;;)
+ {
+ int n = read (rof->fd, rof->buffer, sizeof (rof->buffer));
+# ifdef EINTR
+ if (n < 0 && errno == EINTR)
+ continue;
+# endif
+ if (n <= 0)
+ {
+ rof->eof_seen = 1;
+ return -1;
+ }
+ rof->filled = n;
+ rof->position = 0;
+ break;
+ }
+ }
+ return (unsigned char) rof->buffer[rof->position];
+}
+
+/* Return the next byte from a read-only file stream, or -1 at EOF. */
+static int
+rof_getchar (struct rofile *rof)
+{
+ int c = rof_peekchar (rof);
+ if (c >= 0)
+ rof->position++;
+ return c;
+}
+
+/* Parse an unsigned hexadecimal number from a read-only file stream. */
+static int
+rof_scanf_lx (struct rofile *rof, unsigned long *valuep)
+{
+ unsigned long value = 0;
+ unsigned int numdigits = 0;
+ for (;;)
+ {
+ int c = rof_peekchar (rof);
+ if (c >= '0' && c <= '9')
+ value = (value << 4) + (c - '0');
+ else if (c >= 'A' && c <= 'F')
+ value = (value << 4) + (c - 'A' + 10);
+ else if (c >= 'a' && c <= 'f')
+ value = (value << 4) + (c - 'a' + 10);
+ else
+ break;
+ rof_getchar (rof);
+ numdigits++;
+ }
+ if (numdigits == 0)
+ return -1;
+ *valuep = value;
+ return 0;
+}
+
+/* Close a read-only file stream. */
+static void
+rof_close (struct rofile *rof)
+{
+ close (rof->fd);
+}
+
+#endif
+
+
+void
+vma_iterate (vma_iterate_callback_fn callback, void *data)
+{
+#if defined __linux__ /* || defined __CYGWIN__ */
+
+ struct rofile rof;
+ int c;
+
+ /* Open the current process' maps file. It describes one VMA per line. */
+ if (rof_open (&rof, "/proc/self/maps") < 0)
+ return;
+
+ for (;;)
+ {
+ unsigned long start, end;
+ unsigned int flags;
+
+ /* Parse one line. First start and end. */
+ if (!(rof_scanf_lx (&rof, &start) >= 0
+ && rof_getchar (&rof) == '-'
+ && rof_scanf_lx (&rof, &end) >= 0))
+ break;
+ /* Then the flags. */
+ do
+ c = rof_getchar (&rof);
+ while (c == ' ');
+ flags = 0;
+ if (c == 'r')
+ flags |= VMA_PROT_READ;
+ c = rof_getchar (&rof);
+ if (c == 'w')
+ flags |= VMA_PROT_WRITE;
+ c = rof_getchar (&rof);
+ if (c == 'x')
+ flags |= VMA_PROT_EXECUTE;
+ while (c = rof_getchar (&rof), c != -1 && c != '\n')
+ ;
+
+ if (callback (data, start, end, flags))
+ break;
+ }
+ rof_close (&rof);
+
+#elif defined __FreeBSD__ || defined __NetBSD__
+
+ struct rofile rof;
+ int c;
+
+ /* Open the current process' maps file. It describes one VMA per line. */
+ if (rof_open (&rof, "/proc/curproc/map") < 0)
+ return;
+
+ for (;;)
+ {
+ unsigned long start, end;
+ unsigned int flags;
+
+ /* Parse one line. First start. */
+ if (!(rof_getchar (&rof) == '0'
+ && rof_getchar (&rof) == 'x'
+ && rof_scanf_lx (&rof, &start) >= 0))
+ break;
+ while (c = rof_peekchar (&rof), c == ' ' || c == '\t')
+ rof_getchar (&rof);
+ /* Then end. */
+ if (!(rof_getchar (&rof) == '0'
+ && rof_getchar (&rof) == 'x'
+ && rof_scanf_lx (&rof, &end) >= 0))
+ break;
+ /* Then the flags. */
+ do
+ c = rof_getchar (&rof);
+ while (c == ' ');
+ flags = 0;
+ if (c == 'r')
+ flags |= VMA_PROT_READ;
+ c = rof_getchar (&rof);
+ if (c == 'w')
+ flags |= VMA_PROT_WRITE;
+ c = rof_getchar (&rof);
+ if (c == 'x')
+ flags |= VMA_PROT_EXECUTE;
+ while (c = rof_getchar (&rof), c != -1 && c != '\n')
+ ;
+
+ if (callback (data, start, end, flags))
+ break;
+ }
+ rof_close (&rof);
+
+#elif defined __sgi || defined __osf__ /* IRIX, OSF/1 */
+
+ size_t pagesize;
+ char fnamebuf[6+10+1];
+ char *fname;
+ int fd;
+ int nmaps;
+ size_t memneed;
+# if HAVE_MAP_ANONYMOUS
+# define zero_fd -1
+# define map_flags MAP_ANONYMOUS
+# else
+ int zero_fd;
+# define map_flags 0
+# endif
+ void *auxmap;
+ unsigned long auxmap_start;
+ unsigned long auxmap_end;
+ prmap_t* maps;
+ prmap_t* mp;
+
+ pagesize = getpagesize ();
+
+ /* Construct fname = sprintf (fnamebuf+i, "/proc/%u", getpid ()). */
+ fname = fnamebuf + sizeof (fnamebuf) - 1;
+ *fname = '\0';
+ {
+ unsigned int value = getpid ();
+ do
+ *--fname = (value % 10) + '0';
+ while ((value = value / 10) > 0);
+ }
+ fname -= 6;
+ memcpy (fname, "/proc/", 6);
+
+ fd = open (fname, O_RDONLY);
+ if (fd < 0)
+ return;
+
+ if (ioctl (fd, PIOCNMAP, &nmaps) < 0)
+ goto fail2;
+
+ memneed = (nmaps + 10) * sizeof (prmap_t);
+ /* Allocate memneed bytes of memory.
+ We cannot use alloca here, because not much stack space is guaranteed.
+ We also cannot use malloc here, because a malloc() call may call mmap()
+ and thus pre-allocate available memory.
+ So use mmap(), and ignore the resulting VMA. */
+ memneed = ((memneed - 1) / pagesize + 1) * pagesize;
+# if !HAVE_MAP_ANONYMOUS
+ zero_fd = open ("/dev/zero", O_RDONLY, 0644);
+ if (zero_fd < 0)
+ goto fail2;
+# endif
+ auxmap = (void *) mmap ((void *) 0, memneed, PROT_READ | PROT_WRITE,
+ map_flags | MAP_PRIVATE, zero_fd, 0);
+# if !HAVE_MAP_ANONYMOUS
+ close (zero_fd);
+# endif
+ if (auxmap == (void *) -1)
+ goto fail2;
+ auxmap_start = (unsigned long) auxmap;
+ auxmap_end = auxmap_start + memneed;
+ maps = (prmap_t *) auxmap;
+
+ if (ioctl (fd, PIOCMAP, maps) < 0)
+ goto fail1;
+
+ for (mp = maps;;)
+ {
+ unsigned long start, end;
+ unsigned int flags;
+
+ start = (unsigned long) mp->pr_vaddr;
+ end = start + mp->pr_size;
+ if (start == 0 && end == 0)
+ break;
+ flags = 0;
+ if (mp->pr_mflags & MA_READ)
+ flags |= VMA_PROT_READ;
+ if (mp->pr_mflags & MA_WRITE)
+ flags |= VMA_PROT_WRITE;
+ if (mp->pr_mflags & MA_EXEC)
+ flags |= VMA_PROT_EXECUTE;
+ mp++;
+ if (start <= auxmap_start && auxmap_end - 1 <= end - 1)
+ {
+ /* Consider [start,end-1] \ [auxmap_start,auxmap_end-1]
+ = [start,auxmap_start-1] u [auxmap_end,end-1]. */
+ if (callback (data, start, auxmap_start, flags))
+ break;
+ if (callback (data, auxmap_end, end, flags))
+ break;
+ }
+ else
+ {
+ if (callback (data, start, end, flags))
+ break;
+ }
+ }
+ munmap (auxmap, memneed);
+ close (fd);
+ return;
+
+ fail1:
+ munmap (auxmap, memneed);
+ fail2:
+ close (fd);
+ return;
+
+#elif defined __APPLE__ && defined __MACH__ /* MacOS X */
+
+ task_t task = mach_task_self ();
+ vm_address_t address;
+ vm_size_t size;
+
+ for (address = VM_MIN_ADDRESS;; address += size)
+ {
+ int more;
+ mach_port_t object_name;
+ unsigned int flags;
+ /* In MacOS X 10.5, the types vm_address_t, vm_offset_t, vm_size_t have
+ 32 bits in 32-bit processes and 64 bits in 64-bit processes. Whereas
+ mach_vm_address_t and mach_vm_size_t are always 64 bits large.
+ MacOS X 10.5 has three vm_region like methods:
+ - vm_region. It has arguments that depend on whether the current
+ process is 32-bit or 64-bit. When linking dynamically, this
+ function exists only in 32-bit processes. Therefore we use it only
+ in 32-bit processes.
+ - vm_region_64. It has arguments that depend on whether the current
+ process is 32-bit or 64-bit. It interprets a flavor
+ VM_REGION_BASIC_INFO as VM_REGION_BASIC_INFO_64, which is
+ dangerous since 'struct vm_region_basic_info_64' is larger than
+ 'struct vm_region_basic_info'; therefore let's write
+ VM_REGION_BASIC_INFO_64 explicitly.
+ - mach_vm_region. It has arguments that are 64-bit always. This
+ function is useful when you want to access the VM of a process
+ other than the current process.
+ In 64-bit processes, we could use vm_region_64 or mach_vm_region.
+ I choose vm_region_64 because it uses the same types as vm_region,
+ resulting in less conditional code. */
+# if defined __ppc64__ || defined __x86_64__
+ struct vm_region_basic_info_64 info;
+ mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT_64;
+
+ more = (vm_region_64 (task, &address, &size, VM_REGION_BASIC_INFO_64,
+ (vm_region_info_t)&info, &info_count, &object_name)
+ == KERN_SUCCESS);
+# else
+ struct vm_region_basic_info info;
+ mach_msg_type_number_t info_count = VM_REGION_BASIC_INFO_COUNT;
+
+ more = (vm_region (task, &address, &size, VM_REGION_BASIC_INFO,
+ (vm_region_info_t)&info, &info_count, &object_name)
+ == KERN_SUCCESS);
+# endif
+ if (object_name != MACH_PORT_NULL)
+ mach_port_deallocate (mach_task_self (), object_name);
+ if (!more)
+ break;
+ flags = 0;
+ if (info.protection & VM_PROT_READ)
+ flags |= VMA_PROT_READ;
+ if (info.protection & VM_PROT_WRITE)
+ flags |= VMA_PROT_WRITE;
+ if (info.protection & VM_PROT_EXECUTE)
+ flags |= VMA_PROT_EXECUTE;
+ if (callback (data, address, address + size, flags))
+ break;
+ }
+
+#elif (defined _WIN32 || defined __WIN32__) || defined __CYGWIN__
+ /* Windows platform. Use the native Windows API. */
+
+ MEMORY_BASIC_INFORMATION info;
+ unsigned long address = 0;
+
+ while (VirtualQuery ((void*)address, &info, sizeof(info)) == sizeof(info))
+ {
+ if (info.State != MEM_FREE)
+ /* Ignore areas where info.State has the value MEM_RESERVE or,
+ equivalently, info.Protect has the undocumented value 0.
+ This is needed, so that on Cygwin, areas used by malloc() are
+ distinguished from areas reserved for future malloc(). */
+ if (info.State != MEM_RESERVE)
+ {
+ unsigned long start, end;
+ unsigned int flags;
+
+ start = (unsigned long)info.BaseAddress;
+ end = start + info.RegionSize;
+ switch (info.Protect & ~(PAGE_GUARD|PAGE_NOCACHE))
+ {
+ case PAGE_READONLY:
+ flags = VMA_PROT_READ;
+ break;
+ case PAGE_READWRITE:
+ case PAGE_WRITECOPY:
+ flags = VMA_PROT_READ | VMA_PROT_WRITE;
+ break;
+ case PAGE_EXECUTE:
+ flags = VMA_PROT_EXECUTE;
+ break;
+ case PAGE_EXECUTE_READ:
+ flags = VMA_PROT_READ | VMA_PROT_EXECUTE;
+ break;
+ case PAGE_EXECUTE_READWRITE:
+ case PAGE_EXECUTE_WRITECOPY:
+ flags = VMA_PROT_READ | VMA_PROT_WRITE | VMA_PROT_EXECUTE;
+ break;
+ case PAGE_NOACCESS:
+ default:
+ flags = 0;
+ break;
+ }
+
+ if (callback (data, start, end, flags))
+ break;
+ }
+ address = (unsigned long)info.BaseAddress + info.RegionSize;
+ }
+
+#elif defined __BEOS__
+ /* Use the BeOS specific API. */
+
+ area_info info;
+ int32 cookie;
+
+ cookie = 0;
+ while (get_next_area_info (0, &cookie, &info) == B_OK)
+ {
+ unsigned long start, end;
+ unsigned int flags;
+
+ start = (unsigned long) info.address;
+ end = start + info.size;
+ flags = 0;
+ if (info.protection & B_READ_AREA)
+ flags |= VMA_PROT_READ | VMA_PROT_EXECUTE;
+ if (info.protection & B_WRITE_AREA)
+ flags |= VMA_PROT_WRITE;
+
+ if (callback (data, start, end, flags))
+ break;
+ }
+
+#endif
+}
+
+
+#ifdef TEST
+
+#include <stdio.h>
+
+/* Output the VMAs of the current process in a format similar to the Linux
+ /proc/$pid/maps file. */
+
+static int
+vma_iterate_callback (void *data, uintptr_t start, uintptr_t end,
+ unsigned int flags)
+{
+ printf ("%08lx-%08lx %c%c%c\n",
+ (unsigned long) start, (unsigned long) end,
+ flags & VMA_PROT_READ ? 'r' : '-',
+ flags & VMA_PROT_WRITE ? 'w' : '-',
+ flags & VMA_PROT_EXECUTE ? 'x' : '-');
+ return 0;
+}
+
+int
+main ()
+{
+ vma_iterate (vma_iterate_callback, NULL);
+
+ /* Let the user interactively look at the /proc file system. */
+ sleep (10);
+
+ return 0;
+}
+
+#endif /* TEST */
projects / pspp / commitdiff