diff options
Diffstat (limited to 'absl')
| -rw-r--r-- | absl/base/BUILD.bazel | 1 | ||||
| -rw-r--r-- | absl/base/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | absl/base/internal/direct_mmap.h | 145 | ||||
| -rw-r--r-- | absl/base/internal/malloc_hook_mmap_linux.inc | 96 | ||||
| -rw-r--r-- | absl/synchronization/mutex.h | 31 |
5 files changed, 186 insertions, 88 deletions
diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel index ac6ffc4117ff..707f48828a88 100644 --- a/absl/base/BUILD.bazel +++ b/absl/base/BUILD.bazel @@ -104,6 +104,7 @@ cc_library( "internal/malloc_hook_mmap_linux.inc", ], hdrs = [ + "internal/direct_mmap.h", "internal/low_level_alloc.h", "internal/malloc_hook.h", "internal/malloc_hook_c.h", diff --git a/absl/base/CMakeLists.txt b/absl/base/CMakeLists.txt index 4b7b53a7b91b..ced81b6b7976 100644 --- a/absl/base/CMakeLists.txt +++ b/absl/base/CMakeLists.txt @@ -32,6 +32,7 @@ list(APPEND BASE_PUBLIC_HEADERS list(APPEND BASE_INTERNAL_HEADERS "internal/atomic_hook.h" "internal/cycleclock.h" + "internal/direct_mmap.h" "internal/endian.h" "internal/exception_testing.h" "internal/exception_safety_testing.h" diff --git a/absl/base/internal/direct_mmap.h b/absl/base/internal/direct_mmap.h new file mode 100644 index 000000000000..87576df6ee5b --- /dev/null +++ b/absl/base/internal/direct_mmap.h @@ -0,0 +1,145 @@ +// Copyright 2017 The Abseil Authors. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Functions for directly invoking mmap() via syscall, avoiding the case where +// mmap() has been locally overridden. + +#ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_ +#define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_ + +#include "absl/base/config.h" + +#if ABSL_HAVE_MMAP + +#include <sys/mman.h> + +#ifdef __linux__ + +#include <sys/types.h> +#ifdef __BIONIC__ +#include <sys/syscall.h> +#else +#include <syscall.h> +#endif + +#include <linux/unistd.h> +#include <unistd.h> +#include <cerrno> +#include <cstdarg> +#include <cstdint> + +#ifdef __mips__ +// Include definitions of the ABI currently in use. +#ifdef __BIONIC__ +// Android doesn't have sgidefs.h, but does have asm/sgidefs.h, which has the +// definitions we need. +#include <asm/sgidefs.h> +#else +#include <sgidefs.h> +#endif // __BIONIC__ +#endif // __mips__ + +// SYS_mmap and SYS_munmap are not defined in Android. +#ifdef __BIONIC__ +extern "C" void* __mmap2(void*, size_t, int, int, int, long); +#if defined(__NR_mmap) && !defined(SYS_mmap) +#define SYS_mmap __NR_mmap +#endif +#ifndef SYS_munmap +#define SYS_munmap __NR_munmap +#endif +#endif // __BIONIC__ + +namespace absl { +namespace base_internal { + +// Platform specific logic extracted from +// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h +inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd, + off64_t offset) __THROW { +#if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \ + (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || \ + (defined(__PPC__) && !defined(__PPC64__)) || \ + (defined(__s390__) && !defined(__s390x__)) + // On these architectures, implement mmap with mmap2. + static int pagesize = 0; + if (pagesize == 0) { + pagesize = getpagesize(); + } + if (offset < 0 || offset % pagesize != 0) { + errno = EINVAL; + return MAP_FAILED; + } +#ifdef __BIONIC__ + // SYS_mmap2 has problems on Android API level <= 16. + // Workaround by invoking __mmap2() instead. + return __mmap2(start, length, prot, flags, fd, offset / pagesize); +#else + return reinterpret_cast<void*>( + syscall(SYS_mmap2, start, length, prot, flags, fd, + static_cast<off_t>(offset / pagesize))); +#endif +#elif defined(__s390x__) + // On s390x, mmap() arguments are passed in memory. + uint32_t buf[6] = { + reinterpret_cast<uint32_t>(start), static_cast<uint32_t>(length), + static_cast<uint32_t>(prot), static_cast<uint32_t>(flags), + static_cast<uint32_t>(fd), static_cast<uint32_t>(offset)}; + return reintrepret_cast<void*>(syscall(SYS_mmap, buf)); +#elif defined(__x86_64__) +// The x32 ABI has 32 bit longs, but the syscall interface is 64 bit. +// We need to explicitly cast to an unsigned 64 bit type to avoid implicit +// sign extension. We can't cast pointers directly because those are +// 32 bits, and gcc will dump ugly warnings about casting from a pointer +// to an integer of a different size. We also need to make sure __off64_t +// isn't truncated to 32-bits under x32. +#define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x)) + return reinterpret_cast<void*>( + syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length), + MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags), + MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset))); +#undef MMAP_SYSCALL_ARG +#else // Remaining 64-bit aritectures. + static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit"); + return reinterpret_cast<void*>( + syscall(SYS_mmap, start, length, prot, flags, fd, offset)); +#endif +} + +inline int DirectMunmap(void* start, size_t length) { + return static_cast<int>(syscall(SYS_munmap, start, length)); +} + +} // namespace base_internal +} // namespace absl + +#else // !__linux__ + +// For non-linux platforms where we have mmap, just dispatch directly to the +// actual mmap()/munmap() methods. + +inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd, + off_t offset) { + return mmap(start, length, prot, flags, fd, offset); +} + +inline int DirectMunmap(void* start, size_t length) { + return munmap(start, length); +} + +#endif // __linux__ + +#endif // ABSL_HAVE_MMAP + +#endif // ABSL_BASE_INTERNAL_DIRECT_MMAP_H_ diff --git a/absl/base/internal/malloc_hook_mmap_linux.inc b/absl/base/internal/malloc_hook_mmap_linux.inc index 059ded57626d..b87621a68a47 100644 --- a/absl/base/internal/malloc_hook_mmap_linux.inc +++ b/absl/base/internal/malloc_hook_mmap_linux.inc @@ -35,89 +35,18 @@ #include <cstdarg> #include <cstdint> -#ifdef __mips__ -// Include definitions of the ABI currently in use. -#ifdef __BIONIC__ -// Android doesn't have sgidefs.h, but does have asm/sgidefs.h, which has the -// definitions we need. -#include <asm/sgidefs.h> -#else -#include <sgidefs.h> -#endif // __BIONIC__ -#endif // __mips__ +#include "absl/base/internal/direct_mmap.h" -// SYS_mmap, SYS_munmap, and SYS_mremap are not defined in Android. +// SYS_mremap is not defined in Android. #ifdef __BIONIC__ -extern "C" void *__mmap2(void *, size_t, int, int, int, long); -#if defined(__NR_mmap) && !defined(SYS_mmap) -#define SYS_mmap __NR_mmap -#endif -#ifndef SYS_munmap -#define SYS_munmap __NR_munmap -#endif #ifndef SYS_mremap #define SYS_mremap __NR_mremap #endif #endif // __BIONIC__ -// Platform specific logic extracted from -// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h -static inline void* do_mmap64(void* start, size_t length, int prot, - int flags, int fd, off64_t offset) __THROW { -#if defined(__i386__) || \ - defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \ - (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || \ - (defined(__PPC__) && !defined(__PPC64__)) || \ - (defined(__s390__) && !defined(__s390x__)) - // On these architectures, implement mmap with mmap2. - static int pagesize = 0; - if (pagesize == 0) { - pagesize = getpagesize(); - } - if (offset < 0 || offset % pagesize != 0) { - errno = EINVAL; - return MAP_FAILED; - } -#ifdef __BIONIC__ - // SYS_mmap2 has problems on Android API level <= 16. - // Workaround by invoking __mmap2() instead. - return __mmap2(start, length, prot, flags, fd, offset / pagesize); -#else - return reinterpret_cast<void*>( - syscall(SYS_mmap2, start, length, prot, flags, fd, - static_cast<off_t>(offset / pagesize))); -#endif -#elif defined(__s390x__) - // On s390x, mmap() arguments are passed in memory. - uint32_t buf[6] = { - reinterpret_cast<uint32_t>(start), static_cast<uint32_t>(length), - static_cast<uint32_t>(prot), static_cast<uint32_t>(flags), - static_cast<uint32_t>(fd), static_cast<uint32_t>(offset)}; - return reintrepret_cast<void*>(syscall(SYS_mmap, buf)); -#elif defined(__x86_64__) - // The x32 ABI has 32 bit longs, but the syscall interface is 64 bit. - // We need to explicitly cast to an unsigned 64 bit type to avoid implicit - // sign extension. We can't cast pointers directly because those are - // 32 bits, and gcc will dump ugly warnings about casting from a pointer - // to an integer of a different size. We also need to make sure __off64_t - // isn't truncated to 32-bits under x32. - #define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x)) - return reinterpret_cast<void*>( - syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length), - MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags), - MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset))); - #undef MMAP_SYSCALL_ARG -#else // Remaining 64-bit aritectures. - static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit"); - return reinterpret_cast<void*>( - syscall(SYS_mmap, start, length, prot, flags, fd, offset)); -#endif -} - -// We use do_mmap64 abstraction to put MallocHook::InvokeMmapHook -// calls right into mmap and mmap64, so that the stack frames in the caller's -// stack are at the same offsets for all the calls of memory allocating -// functions. +// We put MallocHook::InvokeMmapHook calls right into mmap and mmap64, so that +// the stack frames in the caller's stack are at the same offsets for all the +// calls of memory allocating functions. // Put all callers of MallocHook::Invoke* in this module into // malloc_hook section, @@ -148,7 +77,8 @@ extern "C" void* mmap64(void *start, size_t length, int prot, int flags, void *result; if (!absl::base_internal::MallocHook::InvokeMmapReplacement( start, length, prot, flags, fd, offset, &result)) { - result = do_mmap64(start, length, prot, flags, fd, offset); + result = absl::base_internal::DirectMmap(start, length, prot, flags, fd, + offset); } absl::base_internal::MallocHook::InvokeMmapHook(result, start, length, prot, flags, fd, offset); @@ -164,8 +94,9 @@ extern "C" void* mmap(void *start, size_t length, int prot, int flags, void *result; if (!absl::base_internal::MallocHook::InvokeMmapReplacement( start, length, prot, flags, fd, offset, &result)) { - result = do_mmap64(start, length, prot, flags, fd, - static_cast<size_t>(offset)); // avoid sign extension + result = absl::base_internal::DirectMmap( + start, length, prot, flags, fd, + static_cast<size_t>(offset)); // avoid sign extension } absl::base_internal::MallocHook::InvokeMmapHook(result, start, length, prot, flags, fd, offset); @@ -179,7 +110,7 @@ extern "C" int munmap(void* start, size_t length) __THROW { int result; if (!absl::base_internal::MallocHook::InvokeMunmapReplacement(start, length, &result)) { - result = syscall(SYS_munmap, start, length); + result = absl::base_internal::DirectMunmap(start, length); } return result; } @@ -219,7 +150,8 @@ namespace base_internal { void* result; if (!MallocHook::InvokeMmapReplacement( start, length, prot, flags, fd, offset, &result)) { - result = do_mmap64(start, length, prot, flags, fd, offset); + result = absl::base_internal::DirectMmap(start, length, prot, flags, fd, + offset); } return result; } @@ -227,7 +159,7 @@ namespace base_internal { /*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) { int result; if (!MallocHook::InvokeMunmapReplacement(start, length, &result)) { - result = syscall(SYS_munmap, start, length); + result = absl::base_internal::DirectMunmap(start, length); } return result; } diff --git a/absl/synchronization/mutex.h b/absl/synchronization/mutex.h index 9301222e0218..c4e026f9b936 100644 --- a/absl/synchronization/mutex.h +++ b/absl/synchronization/mutex.h @@ -519,11 +519,16 @@ class SCOPED_LOCKABLE MutexLock { explicit MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) { this->mu_->Lock(); } + + MutexLock(const MutexLock &) = delete; // NOLINT(runtime/mutex) + MutexLock(MutexLock&&) = delete; // NOLINT(runtime/mutex) + MutexLock& operator=(const MutexLock&) = delete; + MutexLock& operator=(MutexLock&&) = delete; + ~MutexLock() UNLOCK_FUNCTION() { this->mu_->Unlock(); } + private: Mutex *const mu_; - MutexLock(const MutexLock &) = delete; // NOLINT(runtime/mutex) - MutexLock& operator=(const MutexLock&) = delete; }; // ReaderMutexLock @@ -536,13 +541,18 @@ class SCOPED_LOCKABLE ReaderMutexLock { : mu_(mu) { mu->ReaderLock(); } + + ReaderMutexLock(const ReaderMutexLock&) = delete; + ReaderMutexLock(ReaderMutexLock&&) = delete; + ReaderMutexLock& operator=(const ReaderMutexLock&) = delete; + ReaderMutexLock& operator=(ReaderMutexLock&&) = delete; + ~ReaderMutexLock() UNLOCK_FUNCTION() { this->mu_->ReaderUnlock(); } + private: Mutex *const mu_; - ReaderMutexLock(const ReaderMutexLock&) = delete; - ReaderMutexLock& operator=(const ReaderMutexLock&) = delete; }; // WriterMutexLock @@ -555,13 +565,18 @@ class SCOPED_LOCKABLE WriterMutexLock { : mu_(mu) { mu->WriterLock(); } + + WriterMutexLock(const WriterMutexLock&) = delete; + WriterMutexLock(WriterMutexLock&&) = delete; + WriterMutexLock& operator=(const WriterMutexLock&) = delete; + WriterMutexLock& operator=(WriterMutexLock&&) = delete; + ~WriterMutexLock() UNLOCK_FUNCTION() { this->mu_->WriterUnlock(); } + private: Mutex *const mu_; - WriterMutexLock(const WriterMutexLock&) = delete; - WriterMutexLock& operator=(const WriterMutexLock&) = delete; }; // ----------------------------------------------------------------------------- @@ -834,7 +849,9 @@ class SCOPED_LOCKABLE MutexLockMaybe { private: Mutex *const mu_; MutexLockMaybe(const MutexLockMaybe&) = delete; + MutexLockMaybe(MutexLockMaybe&&) = delete; MutexLockMaybe& operator=(const MutexLockMaybe&) = delete; + MutexLockMaybe& operator=(MutexLockMaybe&&) = delete; }; // ReleaseableMutexLock @@ -856,7 +873,9 @@ class SCOPED_LOCKABLE ReleasableMutexLock { private: Mutex *mu_; ReleasableMutexLock(const ReleasableMutexLock&) = delete; + ReleasableMutexLock(ReleasableMutexLock&&) = delete; ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete; + ReleasableMutexLock& operator=(ReleasableMutexLock&&) = delete; }; #ifdef ABSL_INTERNAL_USE_NONPROD_MUTEX |