summaryrefslogtreecommitdiff
path: root/absl
diff options
context:
space:
mode:
Diffstat (limited to 'absl')
-rw-r--r--absl/base/BUILD.bazel1
-rw-r--r--absl/base/CMakeLists.txt1
-rw-r--r--absl/base/internal/direct_mmap.h145
-rw-r--r--absl/base/internal/malloc_hook_mmap_linux.inc96
-rw-r--r--absl/synchronization/mutex.h31
5 files changed, 186 insertions, 88 deletions
diff --git a/absl/base/BUILD.bazel b/absl/base/BUILD.bazel
index ac6ffc41..707f4882 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 4b7b53a7..ced81b6b 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 00000000..87576df6
--- /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 059ded57..b87621a6 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 9301222e..c4e026f9 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
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-20 16:03:03 +0000