tequilaOS/platform_bionic
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Create a lib that uses scudo instead of jemalloc." am: d486e024c6

Browse source 
am: b525ee4a11

Change-Id: I5013c5efe11cd587d51f1766855eaa62d53b116e
This commit is contained in:
Christopher Ferris 2019-04-01 19:04:26 -07:00 committed by android-build-merger
commit f3edfb5773
9 changed files with 459 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
libc/Android.bp
View file

@ -2425,3 +2425,54 @@ cc_library {
static_libs: ["libbase"],
},
}
// This is a temporary library that will use scudo as the native memory
// allocator. To use it, add it as the first shared library.
cc_library_shared {
name: "libc_scudo",
vendor_available: true,
srcs: [
"bionic/malloc_common.cpp",
"bionic/malloc_common_dynamic.cpp",
"bionic/malloc_heapprofd.cpp",
"bionic/malloc_limit.cpp",
"bionic/scudo_wrapper.cpp",
"bionic/__set_errno.cpp",
],
cflags: ["-DUSE_SCUDO"],
stl: "none",
system_shared_libs: [],
header_libs: ["libc_headers"],
static_libs: ["libasync_safe"],
allow_undefined_symbols: true,
shared_libs: ["libscudo_wrapper"],
arch: {
arm: {
srcs: ["arch-arm/syscalls/__rt_sigprocmask.S"],
},
arm64: {
srcs: ["arch-arm64/syscalls/__rt_sigprocmask.S"],
},
x86: {
srcs: [
"arch-x86/bionic/__libc_init_sysinfo.cpp",
"arch-x86/syscalls/__rt_sigprocmask.S",
],
},
x86_64: {
srcs: ["arch-x86_64/syscalls/__rt_sigprocmask.S"],
},
},
// Mark this library as global so it overrides all the allocation
// definitions properly.
ldflags: ["-Wl,-z,global"],
}
subdirs = [
"bionic/scudo",
]

9
libc/bionic/malloc_common.h
View file

@ -55,11 +55,20 @@ __END_DECLS
#else // __has_feature(hwaddress_sanitizer)
#if defined(USE_SCUDO)
#include "scudo.h"
#define Malloc(function) scudo_ ## function
#else
#include "jemalloc.h"
#define Malloc(function) je_ ## function
#endif
#endif
extern int gMallocLeakZygoteChild;
static inline const MallocDispatch* GetDispatchTable() {

59
libc/bionic/scudo.h Normal file
View file

@ -0,0 +1,59 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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 copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#pragma once
#include <stdint.h>
#include <stdio.h>
#include <malloc.h>
#include <private/bionic_config.h>
__BEGIN_DECLS
void* scudo_aligned_alloc(size_t, size_t);
void* scudo_calloc(size_t, size_t);
void scudo_free(void*);
struct mallinfo scudo_mallinfo();
void* scudo_malloc(size_t);
int scudo_malloc_info(int, FILE*);
size_t scudo_malloc_usable_size(const void*);
int scudo_mallopt(int, int);
void* scudo_memalign(size_t, size_t);
void* scudo_realloc(void*, size_t);
int scudo_posix_memalign(void**, size_t, size_t);
#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
void* scudo_pvalloc(size_t);
void* scudo_valloc(size_t);
#endif
int scudo_iterate(uintptr_t, size_t, void (*)(uintptr_t, size_t, void*), void*);
void scudo_malloc_disable();
void scudo_malloc_enable();
__END_DECLS

60
libc/bionic/scudo/Android.bp Normal file
View file

@ -0,0 +1,60 @@
//
// Copyright (C) 2019 The Android Open Source Project
//
// 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.
//
cc_library_shared {
name: "libscudo_wrapper",
vendor_available: true,
srcs: ["scudo.cpp"],
stl: "none",
system_shared_libs: [],
host_supported: false,
header_libs: ["libc_headers"],
include_dirs: [
"bionic/libc",
"bionic/libc/bionic",
],
whole_static_libs: ["libasync_safe"],
arch: {
arm: {
whole_static_libs: ["libclang_rt.scudo_minimal-arm-android.static"],
},
arm64: {
whole_static_libs: ["libclang_rt.scudo_minimal-aarch64-android.static"],
},
x86: {
whole_static_libs: ["libclang_rt.scudo_minimal-i686-android.static"],
},
x86_64: {
whole_static_libs: ["libclang_rt.scudo_minimal-x86_64-android.static"],
},
},
// Will be referencing other libc code that won't be defined here.
allow_undefined_symbols: true,
multilib: {
lib32: {
version_script: "exported32.map",
},
lib64: {
version_script: "exported64.map",
},
},
}

16
libc/bionic/scudo/exported32.map Normal file
View file

@ -0,0 +1,16 @@
LIBC_SCUDO {
global:
scudo_aligned_alloc;
scudo_calloc;
scudo_free;
scudo_mallinfo;
scudo_malloc;
scudo_malloc_usable_size;
scudo_memalign;
scudo_posix_memalign;
scudo_pvalloc;
scudo_realloc;
scudo_valloc;
local:
*;
};

14
libc/bionic/scudo/exported64.map Normal file
View file

@ -0,0 +1,14 @@
LIBC_SCUDO {
global:
scudo_aligned_alloc;
scudo_calloc;
scudo_free;
scudo_mallinfo;
scudo_malloc;
scudo_malloc_usable_size;
scudo_memalign;
scudo_posix_memalign;
scudo_realloc;
local:
*;
};

165
libc/bionic/scudo/scudo.cpp Normal file
View file

@ -0,0 +1,165 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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 copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <errno.h>
#include <malloc.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <sys/prctl.h>
#include "private/bionic_macros.h"
#include "scudo.h"
// Disable Scudo's mismatch allocation check, as it is being triggered
// by some third party code.
extern "C" const char *__scudo_default_options() {
return "DeallocationTypeMismatch=false";
}
static inline bool AllocTooBig(size_t bytes) {
#if defined(__LP64__)
if (__predict_false(bytes > 0x10000000000ULL)) {
#else
if (__predict_false(bytes > 0x80000000ULL)) {
#endif
return true;
}
return false;
}
void* scudo_aligned_alloc(size_t alignment, size_t size) {
if (alignment == 0 || !powerof2(alignment) || (size % alignment) != 0) {
errno = EINVAL;
return nullptr;
}
if (AllocTooBig(size)) {
errno = ENOMEM;
return nullptr;
}
return aligned_alloc(alignment, size);
}
void* scudo_calloc(size_t item_count, size_t item_size) {
size_t total;
if (__builtin_mul_overflow(item_count, item_size, &total) || AllocTooBig(total)) {
errno = ENOMEM;
return nullptr;
}
return calloc(item_count, item_size);
}
void scudo_free(void* ptr) {
free(ptr);
}
extern "C" size_t __sanitizer_get_current_allocated_bytes();
extern "C" size_t __sanitizer_get_heap_size();
struct mallinfo scudo_mallinfo() {
struct mallinfo info {};
info.uordblks = __sanitizer_get_current_allocated_bytes();
info.hblkhd = __sanitizer_get_heap_size();
info.usmblks = info.hblkhd;
return info;
}
void* scudo_malloc(size_t byte_count) {
if (AllocTooBig(byte_count)) {
errno = ENOMEM;
return nullptr;
}
return malloc(byte_count);
}
size_t scudo_malloc_usable_size(const void* ptr) {
return malloc_usable_size(ptr);
}
void* scudo_memalign(size_t alignment, size_t byte_count) {
if (AllocTooBig(byte_count)) {
errno = ENOMEM;
return nullptr;
}
if (alignment != 0) {
if (!powerof2(alignment)) {
alignment = BIONIC_ROUND_UP_POWER_OF_2(alignment);
}
} else {
alignment = 1;
}
return memalign(alignment, byte_count);
}
void* scudo_realloc(void* ptr, size_t byte_count) {
if (AllocTooBig(byte_count)) {
errno = ENOMEM;
return nullptr;
}
return realloc(ptr, byte_count);
}
int scudo_posix_memalign(void** memptr, size_t alignment, size_t size) {
if (alignment < sizeof(void*) || !powerof2(alignment)) {
return EINVAL;
}
if (AllocTooBig(size)) {
return ENOMEM;
}
return posix_memalign(memptr, alignment, size);
}
#if defined(HAVE_DEPRECATED_MALLOC_FUNCS)
extern "C" void* pvalloc(size_t);
void* scudo_pvalloc(size_t size) {
if (AllocTooBig(size)) {
errno = ENOMEM;
return nullptr;
}
return pvalloc(size);
}
extern "C" void* valloc(size_t);
void* scudo_valloc(size_t size) {
if (AllocTooBig(size)) {
errno = ENOMEM;
return nullptr;
}
return valloc(size);
}
#endif
// Do not try and name the scudo maps by overriding __sanitizer::internal_mmap.
// There is already a function called MmapNamed that names the maps.
// Unfortunately, there is no easy way to override MmapNamed because
// too much of the code is not compiled into functions available in the
// library, and the code is complicated.

59
libc/bionic/scudo_wrapper.cpp Normal file
View file

@ -0,0 +1,59 @@
/*
* Copyright (C) 2019 The Android Open Source Project
* 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 copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <errno.h>
#include <stdio.h>
#include "scudo.h"
#include "private/bionic_globals.h"
#include "private/WriteProtected.h"
__LIBC_HIDDEN__ WriteProtected<libc_globals> __libc_globals;
#if defined(__i386__)
__LIBC_HIDDEN__ void* __libc_sysinfo = reinterpret_cast<void*>(__libc_int0x80);
#endif
int scudo_mallopt(int /*param*/, int /*value*/) {
return 0;
}
int scudo_malloc_info(int /*options*/, FILE* /*fp*/) {
errno = ENOTSUP;
return -1;
}
int scudo_iterate(uintptr_t, size_t, void (*)(uintptr_t, size_t, void*), void*) {
return 0;
}
void scudo_malloc_disable() {
}
void scudo_malloc_enable() {
}

49
tests/Android.bp
View file

@ -426,6 +426,11 @@ cc_test_library {
cc_defaults {
name: "bionic_unit_tests_defaults",
host_supported: false,
gtest: false,
defaults: [
"bionic_tests_defaults",
],
whole_static_libs: [
"libBionicTests",
@ -437,12 +442,14 @@ cc_defaults {
"libtinyxml2",
"liblog",
"libbase",
"libgtest_isolated",
],
srcs: [
// TODO: Include __cxa_thread_atexit_test.cpp to glibc tests once it is upgraded (glibc 2.18+)
"__cxa_thread_atexit_test.cpp",
"gtest_globals.cpp",
"gtest_main.cpp",
"thread_local_test.cpp",
],
@ -461,6 +468,7 @@ cc_defaults {
android: {
shared_libs: [
"ld-android",
"libandroidicu",
"libdl",
"libdl_preempt_test_1",
"libdl_preempt_test_2",
@ -488,29 +496,6 @@ cc_defaults {
],
},
},
}
cc_test {
name: "bionic-unit-tests",
gtest: false,
defaults: [
"bionic_unit_tests_defaults",
"bionic_tests_defaults",
],
srcs: [
"gtest_main.cpp",
],
static_libs: [
"libgtest_isolated",
],
target: {
android: {
shared_libs: ["libandroidicu"],
},
},
required: [
"cfi_test_helper",
@ -655,6 +640,24 @@ cc_test {
],
}
cc_test {
name: "bionic-unit-tests",
defaults: [
"bionic_unit_tests_defaults",
],
}
cc_test {
name: "bionic-unit-tests-scudo",
defaults: [
"bionic_unit_tests_defaults",
],
shared_libs: [
"libc_scudo",
],
}
// -----------------------------------------------------------------------------
// Tests for the device linked against bionic's static library. Run with:
// adb shell /data/nativetest/bionic-unit-tests-static/bionic-unit-tests-static