Coverage Report

Created: 2024-09-23 06:29

/src/abseil-cpp/absl/debugging/internal/vdso_support.cc
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
// Allow dynamic symbol lookup in the kernel VDSO page.
16
//
17
// VDSOSupport -- a class representing kernel VDSO (if present).
18
19
#include "absl/debugging/internal/vdso_support.h"
20
21
#ifdef ABSL_HAVE_VDSO_SUPPORT     // defined in vdso_support.h
22
23
#if !defined(__has_include)
24
#define __has_include(header) 0
25
#endif
26
27
#include <errno.h>
28
#include <fcntl.h>
29
#if __has_include(<syscall.h>)
30
#include <syscall.h>
31
#elif __has_include(<sys/syscall.h>)
32
#include <sys/syscall.h>
33
#endif
34
#include <unistd.h>
35
36
#if !defined(__UCLIBC__) && defined(__GLIBC__) && \
37
    (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 16))
38
#define ABSL_HAVE_GETAUXVAL
39
#endif
40
41
#ifdef ABSL_HAVE_GETAUXVAL
42
#include <sys/auxv.h>
43
#endif
44
45
#include "absl/base/dynamic_annotations.h"
46
#include "absl/base/internal/raw_logging.h"
47
#include "absl/base/port.h"
48
49
#ifndef AT_SYSINFO_EHDR
50
#define AT_SYSINFO_EHDR 33  // for crosstoolv10
51
#endif
52
53
#if defined(__NetBSD__)
54
using Elf32_auxv_t = Aux32Info;
55
using Elf64_auxv_t = Aux64Info;
56
#endif
57
#if defined(__FreeBSD__)
58
#if defined(__ELF_WORD_SIZE) && __ELF_WORD_SIZE == 64
59
using Elf64_auxv_t = Elf64_Auxinfo;
60
#endif
61
using Elf32_auxv_t = Elf32_Auxinfo;
62
#endif
63
64
namespace absl {
65
ABSL_NAMESPACE_BEGIN
66
namespace debugging_internal {
67
68
ABSL_CONST_INIT
69
std::atomic<const void *> VDSOSupport::vdso_base_(
70
    debugging_internal::ElfMemImage::kInvalidBase);
71
72
ABSL_CONST_INIT std::atomic<VDSOSupport::GetCpuFn> VDSOSupport::getcpu_fn_(
73
    &InitAndGetCPU);
74
75
VDSOSupport::VDSOSupport()
76
    // If vdso_base_ is still set to kInvalidBase, we got here
77
    // before VDSOSupport::Init has been called. Call it now.
78
    : image_(vdso_base_.load(std::memory_order_relaxed) ==
79
                     debugging_internal::ElfMemImage::kInvalidBase
80
                 ? Init()
81
0
                 : vdso_base_.load(std::memory_order_relaxed)) {}
82
83
// NOTE: we can't use GoogleOnceInit() below, because we can be
84
// called by tcmalloc, and none of the *once* stuff may be functional yet.
85
//
86
// In addition, we hope that the VDSOSupportHelper constructor
87
// causes this code to run before there are any threads, and before
88
// InitGoogle() has executed any chroot or setuid calls.
89
//
90
// Finally, even if there is a race here, it is harmless, because
91
// the operation should be idempotent.
92
0
const void *VDSOSupport::Init() {
93
0
  const auto kInvalidBase = debugging_internal::ElfMemImage::kInvalidBase;
94
0
#ifdef ABSL_HAVE_GETAUXVAL
95
0
  if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
96
0
    errno = 0;
97
0
    const void *const sysinfo_ehdr =
98
0
        reinterpret_cast<const void *>(getauxval(AT_SYSINFO_EHDR));
99
0
    if (errno == 0) {
100
0
      vdso_base_.store(sysinfo_ehdr, std::memory_order_relaxed);
101
0
    }
102
0
  }
103
0
#endif  // ABSL_HAVE_GETAUXVAL
104
0
  if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
105
0
    int fd = open("/proc/self/auxv", O_RDONLY);
106
0
    if (fd == -1) {
107
      // Kernel too old to have a VDSO.
108
0
      vdso_base_.store(nullptr, std::memory_order_relaxed);
109
0
      getcpu_fn_.store(&GetCPUViaSyscall, std::memory_order_relaxed);
110
0
      return nullptr;
111
0
    }
112
0
    ElfW(auxv_t) aux;
113
0
    while (read(fd, &aux, sizeof(aux)) == sizeof(aux)) {
114
0
      if (aux.a_type == AT_SYSINFO_EHDR) {
115
#if defined(__NetBSD__)
116
        vdso_base_.store(reinterpret_cast<void *>(aux.a_v),
117
                         std::memory_order_relaxed);
118
#else
119
0
        vdso_base_.store(reinterpret_cast<void *>(aux.a_un.a_val),
120
0
                         std::memory_order_relaxed);
121
0
#endif
122
0
        break;
123
0
      }
124
0
    }
125
0
    close(fd);
126
0
    if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
127
      // Didn't find AT_SYSINFO_EHDR in auxv[].
128
0
      vdso_base_.store(nullptr, std::memory_order_relaxed);
129
0
    }
130
0
  }
131
0
  GetCpuFn fn = &GetCPUViaSyscall;  // default if VDSO not present.
132
0
  if (vdso_base_.load(std::memory_order_relaxed)) {
133
0
    VDSOSupport vdso;
134
0
    SymbolInfo info;
135
0
    if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
136
0
      fn = reinterpret_cast<GetCpuFn>(const_cast<void *>(info.address));
137
0
    }
138
0
  }
139
  // Subtle: this code runs outside of any locks; prevent compiler
140
  // from assigning to getcpu_fn_ more than once.
141
0
  getcpu_fn_.store(fn, std::memory_order_relaxed);
142
0
  return vdso_base_.load(std::memory_order_relaxed);
143
0
}
144
145
0
const void *VDSOSupport::SetBase(const void *base) {
146
0
  ABSL_RAW_CHECK(base != debugging_internal::ElfMemImage::kInvalidBase,
147
0
                 "internal error");
148
0
  const void *old_base = vdso_base_.load(std::memory_order_relaxed);
149
0
  vdso_base_.store(base, std::memory_order_relaxed);
150
0
  image_.Init(base);
151
  // Also reset getcpu_fn_, so GetCPU could be tested with simulated VDSO.
152
0
  getcpu_fn_.store(&InitAndGetCPU, std::memory_order_relaxed);
153
0
  return old_base;
154
0
}
155
156
bool VDSOSupport::LookupSymbol(const char *name,
157
                               const char *version,
158
                               int type,
159
0
                               SymbolInfo *info) const {
160
0
  return image_.LookupSymbol(name, version, type, info);
161
0
}
162
163
bool VDSOSupport::LookupSymbolByAddress(const void *address,
164
0
                                        SymbolInfo *info_out) const {
165
0
  return image_.LookupSymbolByAddress(address, info_out);
166
0
}
167
168
// NOLINT on 'long' because this routine mimics kernel api.
169
long VDSOSupport::GetCPUViaSyscall(unsigned *cpu,  // NOLINT(runtime/int)
170
0
                                   void *, void *) {
171
0
#ifdef SYS_getcpu
172
0
  return syscall(SYS_getcpu, cpu, nullptr, nullptr);
173
#else
174
  // x86_64 never implemented sys_getcpu(), except as a VDSO call.
175
  static_cast<void>(cpu);  // Avoid an unused argument compiler warning.
176
  errno = ENOSYS;
177
  return -1;
178
#endif
179
0
}
180
181
// Use fast __vdso_getcpu if available.
182
long VDSOSupport::InitAndGetCPU(unsigned *cpu,  // NOLINT(runtime/int)
183
0
                                void *x, void *y) {
184
0
  Init();
185
0
  GetCpuFn fn = getcpu_fn_.load(std::memory_order_relaxed);
186
0
  ABSL_RAW_CHECK(fn != &InitAndGetCPU, "Init() did not set getcpu_fn_");
187
0
  return (*fn)(cpu, x, y);
188
0
}
189
190
// This function must be very fast, and may be called from very
191
// low level (e.g. tcmalloc). Hence I avoid things like
192
// GoogleOnceInit() and ::operator new.
193
ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
194
0
int GetCPU() {
195
0
  unsigned cpu;
196
0
  long ret_code =  // NOLINT(runtime/int)
197
0
      (*VDSOSupport::getcpu_fn_)(&cpu, nullptr, nullptr);
198
0
  return ret_code == 0 ? static_cast<int>(cpu) : static_cast<int>(ret_code);
199
0
}
200
201
}  // namespace debugging_internal
202
ABSL_NAMESPACE_END
203
}  // namespace absl
204
205
#endif  // ABSL_HAVE_VDSO_SUPPORT