Support Android in MallocHook for mmap, munmap and mremap.

third_party/tcmalloc/chromium/src/malloc_hook_mmap_linux.h

 // Copyright (c) 2005, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 22 matching lines @@
 // We define mmap() and mmap64(), which somewhat reimplements libc's mmap
 // syscall stubs.  Unfortunately libc only exports the stubs via weak symbols
 // (which we're overriding with our mmap64() and mmap() wrappers) so we can't
 // just call through to them.
 
 #ifndef __linux
 # error Should only be including malloc_hook_mmap_linux.h on linux systems.
 #endif
 
 #include <unistd.h>
+#if defined(__ANDROID__) || defined(ANDROID)
+#include <sys/syscall.h>
+#include <sys/linux-syscalls.h>
+#else
 #include <syscall.h>
+#endif
 #include <sys/mman.h>
 #include <errno.h>
 #include "base/linux_syscall_support.h"
 
+// SYS_mmap2, SYS_munmap, SYS_mremap and __off64_t are not defined in Android.
+#if defined(__ANDROID__) || defined(ANDROID)
+#ifndef SYS_mmap2
+#define SYS_mmap2 __NR_mmap2
+#endif
+#ifndef SYS_munmap
+#define SYS_munmap __NR_munmap
+#endif
+#ifndef SYS_mremap
+#define SYS_mremap __NR_mremap
+#endif
+typedef off64_t __off64_t;
+#endif  // defined(__ANDROID__) || defined(ANDROID)
+
 // The x86-32 case and the x86-64 case differ:
 // 32b has a mmap2() syscall, 64b does not.
 // 64b and 32b have different calling conventions for mmap().
 
 // I test for 64-bit first so I don't have to do things like
 // '#if (defined(__mips__) && !defined(__MIPS64__))' as a mips32 check.
 #if defined(__x86_64__) || defined(__PPC64__) || (defined(_MIPS_SIM) && _MIPS_SIM == _ABI64)
 
 static inline void* do_mmap64(void *start, size_t length,
                               int prot, int flags,
@@ skipping 84 matching lines @@
                int fd, __off64_t offset  ) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
   void* mmap(void *start, size_t length,int prot, int flags,
              int fd, off_t offset) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
   int munmap(void* start, size_t length) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
   void* mremap(void* old_addr, size_t old_size, size_t new_size,
                int flags, ...) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
+#if !defined(__ANDROID__) && !defined(ANDROID)
   void* sbrk(ptrdiff_t increment) __THROW
     ATTRIBUTE_SECTION(malloc_hook);
+#endif
 }
 
 extern "C" void* mmap64(void *start, size_t length, int prot, int flags,
                         int fd, __off64_t offset) __THROW {
   MallocHook::InvokePreMmapHook(start, length, prot, flags, fd, offset);
   void *result;
   if (!MallocHook::InvokeMmapReplacement(
           start, length, prot, flags, fd, offset, &result)) {
     result = do_mmap64(start, length, prot, flags, fd, offset);
   }
@@ skipping 37 matching lines @@
   va_end(ap);
   // The original gperftools uses sys_mremap() here.  But, it is not allowed by
   // Chromium's sandbox.
   void* result = (void *)syscall(
       SYS_mremap, old_addr, old_size, new_size, flags, new_address);
   MallocHook::InvokeMremapHook(result, old_addr, old_size, new_size, flags,
                                new_address);
   return result;
 }
 
+// Don't hook sbrk in Androis since Android doesn't have __sbrk.

[digit1, 2013/05/13 16:14:42]

Small typo here. Also probably better avoid the repetition, i.e.:

  // Don't hook sbrk() in Android, since it doesn't expose __sbrk.

[Dai Mikurube (NOT FULLTIME), 2013/05/13 21:25:52]

Thanks.  Replaced the comment.

+#if !defined(__ANDROID__) && !defined(ANDROID)
 // libc's version:
 extern "C" void* __sbrk(ptrdiff_t increment);
 
 extern "C" void* sbrk(ptrdiff_t increment) __THROW {
   MallocHook::InvokePreSbrkHook(increment);
   void *result = __sbrk(increment);
   MallocHook::InvokeSbrkHook(result, increment);
   return result;
 }
+#endif  // !defined(__ANDROID__) && !defined(ANDROID)
 
 /*static*/void* MallocHook::UnhookedMMap(void *start, size_t length, int prot,
                                          int flags, int fd, off_t offset) {
   void* result;
   if (!MallocHook::InvokeMmapReplacement(
           start, length, prot, flags, fd, offset, &result)) {
     result = do_mmap64(start, length, prot, flags, fd, offset);
   }
   return result;
 }
 
 /*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
   int result;
   if (!MallocHook::InvokeMunmapReplacement(start, length, &result)) {
     result = syscall(SYS_munmap, start, length);
   }
   return result;
 }
 
 #undef MALLOC_HOOK_HAVE_DO_MMAP64
 
 #endif  // #ifdef MALLOC_HOOK_HAVE_DO_MMAP64