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

Remove references to libc_scudo.

Browse source 
As scudo is now the default native allocator, there is no need to
keep this library around.

Test: Builds and walleye boots.
Change-Id: Id2918544651348854956d1348d2a634f6425b952
Merged-In: Id2918544651348854956d1348d2a634f6425b952
(cherry picked from commit 941ad56299)
This commit is contained in:
Christopher Ferris 2020-06-08 16:32:31 -07:00
parent c17236ee78
commit ef707f9056
6 changed files with 0 additions and 399 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

69
libc/Android.bp
View file

@ -2478,75 +2478,6 @@ cc_library {
},
}
// 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_defaults {
name: "libc_scudo_wrapper_defaults",
srcs: [
"bionic/gwp_asan_wrappers.cpp",
"bionic/heap_tagging.cpp",
"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",
"-fno-emulated-tls", // Required for GWP-ASan.
],
shared_libs: ["libscudo_wrapper"],
header_libs: [
"libc_headers",
"gwp_asan_headers",
],
static_libs: [
"libasync_safe",
"gwp_asan",
],
arch: {
arm: {
srcs: [":syscalls-arm.S"],
},
arm64: {
srcs: [":syscalls-arm64.S"],
},
x86: {
srcs: [
"arch-x86/bionic/__libc_init_sysinfo.cpp",
":syscalls-x86.S",
],
},
x86_64: {
srcs: [":syscalls-x86_64.S"],
},
},
// Mark this library as global so it overrides all the allocation
// definitions properly.
ldflags: ["-Wl,-z,global"],
}
cc_library_shared {
name: "libc_scudo",
vendor_available: true,
stl: "none",
system_shared_libs: [],
allow_undefined_symbols: true,
// Like libc, disable native coverage for libc_scudo.
native_coverage: false,
apex_available: [
"//apex_available:platform",
"com.android.media.swcodec",
],
min_sdk_version: "apex_inherit",
}
subdirs = [
"bionic/scudo",
]

63
libc/bionic/scudo/Android.bp
View file

@ -1,63 +0,0 @@
//
// 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",
},
},
// Like libc, disable native coverage for libscudo_wrapper.
native_coverage: false,
}

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

@ -1,16 +0,0 @@
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
View file

@ -1,14 +0,0 @@
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
View file

@ -1,165 +0,0 @@
/*
* 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 "platform/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.

72
libc/bionic/scudo_wrapper.cpp
View file

@ -1,72 +0,0 @@
/*
* 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;
// Call the libc malloc initialisers.
__attribute__((constructor(1))) static void __scudo_preinit() {
__libc_globals.mutate(__libc_init_malloc);
}
extern "C" libc_shared_globals* __loader_shared_globals();
__LIBC_HIDDEN__ libc_shared_globals* __libc_shared_globals() {
return __loader_shared_globals();
}
#if defined(__i386__)
__LIBC_HIDDEN__ void* __libc_sysinfo = reinterpret_cast<void*>(__libc_int0x80);
#endif
extern "C" void scudo_malloc_disable_memory_tagging() {}
int scudo_mallopt(int /*param*/, int /*value*/) {
return 0;
}
int scudo_malloc_info(int /*options*/, FILE* /*fp*/) {
errno = ENOTSUP;
return -1;
}
int scudo_malloc_iterate(uintptr_t, size_t, void (*)(uintptr_t, size_t, void*), void*) {
return 0;
}
void scudo_malloc_disable() {
}
void scudo_malloc_enable() {
}