Coverage Report

Created: 2024-09-23 06:29

/src/abseil-cpp/absl/base/internal/direct_mmap.h
Line
Count
Source (jump to first uncovered line)
1
// Copyright 2017 The Abseil Authors.
2
//
3
// Licensed under the Apache License, Version 2.0 (the "License");
4
// you may not use this file except in compliance with the License.
5
// You may obtain a copy of the License at
6
//
7
//      https://www.apache.org/licenses/LICENSE-2.0
8
//
9
// Unless required by applicable law or agreed to in writing, software
10
// distributed under the License is distributed on an "AS IS" BASIS,
11
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12
// See the License for the specific language governing permissions and
13
// limitations under the License.
14
//
15
// Functions for directly invoking mmap() via syscall, avoiding the case where
16
// mmap() has been locally overridden.
17
18
#ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
19
#define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
20
21
#include "absl/base/config.h"
22
23
#ifdef ABSL_HAVE_MMAP
24
25
#include <sys/mman.h>
26
27
#ifdef __linux__
28
29
#include <sys/types.h>
30
#ifdef __BIONIC__
31
#include <sys/syscall.h>
32
#else
33
#include <syscall.h>
34
#endif
35
36
#include <linux/unistd.h>
37
#include <unistd.h>
38
#include <cerrno>
39
#include <cstdarg>
40
#include <cstdint>
41
42
#ifdef __mips__
43
// Include definitions of the ABI currently in use.
44
#if defined(__BIONIC__) || !defined(__GLIBC__)
45
// Android doesn't have sgidefs.h, but does have asm/sgidefs.h, which has the
46
// definitions we need.
47
#include <asm/sgidefs.h>
48
#else
49
#include <sgidefs.h>
50
#endif  // __BIONIC__ || !__GLIBC__
51
#endif  // __mips__
52
53
// SYS_mmap and SYS_munmap are not defined in Android.
54
#ifdef __BIONIC__
55
extern "C" void* __mmap2(void*, size_t, int, int, int, size_t);
56
#if defined(__NR_mmap) && !defined(SYS_mmap)
57
#define SYS_mmap __NR_mmap
58
#endif
59
#ifndef SYS_munmap
60
#define SYS_munmap __NR_munmap
61
#endif
62
#endif  // __BIONIC__
63
64
#if defined(__NR_mmap2) && !defined(SYS_mmap2)
65
#define SYS_mmap2 __NR_mmap2
66
#endif
67
68
namespace absl {
69
ABSL_NAMESPACE_BEGIN
70
namespace base_internal {
71
72
// Platform specific logic extracted from
73
// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h
74
inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
75
0
                        off_t offset) noexcept {
76
#if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
77
    defined(__m68k__) || defined(__sh__) ||                                  \
78
    (defined(__hppa__) && !defined(__LP64__)) ||                             \
79
    (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) ||                   \
80
    (defined(__PPC__) && !defined(__PPC64__)) ||                             \
81
    (defined(__riscv) && __riscv_xlen == 32) ||                              \
82
    (defined(__s390__) && !defined(__s390x__)) ||                            \
83
    (defined(__sparc__) && !defined(__arch64__))
84
  // On these architectures, implement mmap with mmap2.
85
  static int pagesize = 0;
86
  if (pagesize == 0) {
87
#if defined(__wasm__) || defined(__asmjs__)
88
    pagesize = getpagesize();
89
#else
90
    pagesize = sysconf(_SC_PAGESIZE);
91
#endif
92
  }
93
  if (offset < 0 || offset % pagesize != 0) {
94
    errno = EINVAL;
95
    return MAP_FAILED;
96
  }
97
#ifdef __BIONIC__
98
  // SYS_mmap2 has problems on Android API level <= 16.
99
  // Workaround by invoking __mmap2() instead.
100
  return __mmap2(start, length, prot, flags, fd,
101
                 static_cast<size_t>(offset / pagesize));
102
#else
103
  return reinterpret_cast<void*>(
104
      syscall(SYS_mmap2, start, length, prot, flags, fd,
105
              static_cast<unsigned long>(offset / pagesize)));  // NOLINT
106
#endif
107
#elif defined(__s390x__)
108
  // On s390x, mmap() arguments are passed in memory.
109
  unsigned long buf[6] = {reinterpret_cast<unsigned long>(start),  // NOLINT
110
                          static_cast<unsigned long>(length),      // NOLINT
111
                          static_cast<unsigned long>(prot),        // NOLINT
112
                          static_cast<unsigned long>(flags),       // NOLINT
113
                          static_cast<unsigned long>(fd),          // NOLINT
114
                          static_cast<unsigned long>(offset)};     // NOLINT
115
  return reinterpret_cast<void*>(syscall(SYS_mmap, buf));
116
#elif defined(__x86_64__)
117
// The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
118
// We need to explicitly cast to an unsigned 64 bit type to avoid implicit
119
// sign extension.  We can't cast pointers directly because those are
120
// 32 bits, and gcc will dump ugly warnings about casting from a pointer
121
// to an integer of a different size. We also need to make sure __off64_t
122
// isn't truncated to 32-bits under x32.
123
0
#define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x))
124
0
  return reinterpret_cast<void*>(
125
0
      syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length),
126
0
              MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags),
127
0
              MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset)));
128
0
#undef MMAP_SYSCALL_ARG
129
#else  // Remaining 64-bit aritectures.
130
  static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit");
131
  return reinterpret_cast<void*>(
132
      syscall(SYS_mmap, start, length, prot, flags, fd, offset));
133
#endif
134
0
}
135
136
0
inline int DirectMunmap(void* start, size_t length) {
137
0
  return static_cast<int>(syscall(SYS_munmap, start, length));
138
0
}
139
140
}  // namespace base_internal
141
ABSL_NAMESPACE_END
142
}  // namespace absl
143
144
#else  // !__linux__
145
146
// For non-linux platforms where we have mmap, just dispatch directly to the
147
// actual mmap()/munmap() methods.
148
149
namespace absl {
150
ABSL_NAMESPACE_BEGIN
151
namespace base_internal {
152
153
inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
154
                        off_t offset) {
155
  return mmap(start, length, prot, flags, fd, offset);
156
}
157
158
inline int DirectMunmap(void* start, size_t length) {
159
  return munmap(start, length);
160
}
161
162
}  // namespace base_internal
163
ABSL_NAMESPACE_END
164
}  // namespace absl
165
166
#endif  // __linux__
167
168
#endif  // ABSL_HAVE_MMAP
169
170
#endif  // ABSL_BASE_INTERNAL_DIRECT_MMAP_H_