diff --git a/adb/Android.mk b/adb/Android.mk index 6188184b7..0babf1d4a 100644 --- a/adb/Android.mk +++ b/adb/Android.mk @@ -319,6 +319,7 @@ LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED) LOCAL_C_INCLUDES += system/extras/ext4_utils LOCAL_SANITIZE := $(adb_target_sanitize) +LOCAL_STRIP_MODULE := keep_symbols LOCAL_STATIC_LIBRARIES := \ libadbd \ libbase \ @@ -333,6 +334,7 @@ LOCAL_STATIC_LIBRARIES := \ libbase \ libcrypto_utils_static \ libcrypto_static \ - libminijail + libminijail \ + libdebuggerd_client \ include $(BUILD_EXECUTABLE) diff --git a/adb/daemon/main.cpp b/adb/daemon/main.cpp index 916bedfe8..b0a0162b0 100644 --- a/adb/daemon/main.cpp +++ b/adb/daemon/main.cpp @@ -32,6 +32,7 @@ #include #include "cutils/properties.h" +#include "debuggerd/client.h" #include "private/android_filesystem_config.h" #include "selinux/android.h" @@ -247,6 +248,7 @@ int main(int argc, char** argv) { close_stdin(); + debuggerd_init(nullptr); adb_trace_init(argv); D("Handling main()"); diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp new file mode 100644 index 000000000..8a63f3f12 --- /dev/null +++ b/debuggerd/Android.bp @@ -0,0 +1,19 @@ +cc_library_static { + name: "libdebuggerd_client", + srcs: ["client/debuggerd_client.cpp"], + + cflags: [ + "-Wall", + "-Wextra", + "-Werror", + "-Os", + ], + + local_include_dirs: ["include"], + export_include_dirs: ["include"], + + // libdebuggerd_client gets async signal safe logging via libc_logging, + // which defines its interface in bionic private headers. + include_dirs: ["bionic/libc"], + static_libs: ["libc_logging"], +} diff --git a/debuggerd/Android.mk b/debuggerd/Android.soong.mk similarity index 73% rename from debuggerd/Android.mk rename to debuggerd/Android.soong.mk index 9ce94c5db..19c729824 100644 --- a/debuggerd/Android.mk +++ b/debuggerd/Android.soong.mk @@ -8,6 +8,10 @@ common_cppflags := \ -Wunused \ -Werror \ +ifeq ($(TARGET_IS_64_BIT),true) +common_cppflags += -DTARGET_IS_64_BIT +endif + include $(CLEAR_VARS) LOCAL_SRC_FILES:= \ @@ -26,15 +30,12 @@ LOCAL_SRC_FILES_mips64 := mips64/machine.cpp LOCAL_SRC_FILES_x86 := x86/machine.cpp LOCAL_SRC_FILES_x86_64 := x86_64/machine.cpp +LOCAL_C_INCLUDES := $(LOCAL_PATH)/include LOCAL_CPPFLAGS := $(common_cppflags) LOCAL_INIT_RC_32 := debuggerd.rc LOCAL_INIT_RC_64 := debuggerd64.rc -ifeq ($(TARGET_IS_64_BIT),true) -LOCAL_CPPFLAGS += -DTARGET_IS_64_BIT -endif - LOCAL_SHARED_LIBRARIES := \ libbacktrace \ libbase \ @@ -51,7 +52,7 @@ LOCAL_MULTILIB := both include $(BUILD_EXECUTABLE) - +crasher_cppflags := $(common_cppflags) -fstack-protector-all -Wno-free-nonheap-object -Wno-date-time include $(CLEAR_VARS) LOCAL_SRC_FILES := crasher.cpp @@ -63,8 +64,7 @@ LOCAL_SRC_FILES_x86 := x86/crashglue.S LOCAL_SRC_FILES_x86_64 := x86_64/crashglue.S LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES) LOCAL_MODULE_TAGS := optional -LOCAL_CPPFLAGS := $(common_cppflags) -fstack-protector-all -Wno-free-nonheap-object -Wno-date-time -#LOCAL_FORCE_STATIC_EXECUTABLE := true +LOCAL_CPPFLAGS := $(crasher_cppflags) LOCAL_SHARED_LIBRARIES := libcutils liblog # The arm emulator has VFP but not VFPv3-D32. @@ -79,6 +79,34 @@ LOCAL_MULTILIB := both include $(BUILD_EXECUTABLE) +include $(CLEAR_VARS) +LOCAL_SRC_FILES := crasher.cpp +LOCAL_SRC_FILES_arm := arm/crashglue.S +LOCAL_SRC_FILES_arm64 := arm64/crashglue.S +LOCAL_SRC_FILES_mips := mips/crashglue.S +LOCAL_SRC_FILES_mips64 := mips64/crashglue.S +LOCAL_SRC_FILES_x86 := x86/crashglue.S +LOCAL_SRC_FILES_x86_64 := x86_64/crashglue.S +LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES) +LOCAL_MODULE_TAGS := optional +LOCAL_CPPFLAGS := $(crasher_cppflags) -DSTATIC_CRASHER +LOCAL_FORCE_STATIC_EXECUTABLE := true +LOCAL_SHARED_LIBRARIES := libcutils liblog + +# The arm emulator has VFP but not VFPv3-D32. +ifeq ($(ARCH_ARM_HAVE_VFP_D32),true) +LOCAL_ASFLAGS_arm += -DHAS_VFP_D32 +endif + +LOCAL_MODULE := static_crasher +LOCAL_MODULE_STEM_32 := static_crasher +LOCAL_MODULE_STEM_64 := static_crasher64 +LOCAL_MULTILIB := both + +LOCAL_STATIC_LIBRARIES := libdebuggerd_client libcutils liblog + +include $(BUILD_EXECUTABLE) + debuggerd_test_src_files := \ utility.cpp \ test/dump_memory_test.cpp \ diff --git a/debuggerd/client/debuggerd_client.cpp b/debuggerd/client/debuggerd_client.cpp new file mode 100644 index 000000000..44e92fedd --- /dev/null +++ b/debuggerd/client/debuggerd_client.cpp @@ -0,0 +1,311 @@ +/* + * Copyright (C) 2008 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 "debuggerd/client.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "private/libc_logging.h" + +#if defined(TARGET_IS_64_BIT) && !defined(__LP64__) +#define SOCKET_NAME "android:debuggerd32" +#else +#define SOCKET_NAME "android:debuggerd" +#endif + +// see man(2) prctl, specifically the section about PR_GET_NAME +#define MAX_TASK_NAME_LEN (16) + +static debuggerd_callbacks_t g_callbacks; + +static int socket_abstract_client(const char* name, int type) { + sockaddr_un addr; + + // Test with length +1 for the *initial* '\0'. + size_t namelen = strlen(name); + if ((namelen + 1) > sizeof(addr.sun_path)) { + errno = EINVAL; + return -1; + } + + // This is used for abstract socket namespace, we need + // an initial '\0' at the start of the Unix socket path. + // + // Note: The path in this case is *not* supposed to be + // '\0'-terminated. ("man 7 unix" for the gory details.) + memset(&addr, 0, sizeof(addr)); + addr.sun_family = AF_LOCAL; + addr.sun_path[0] = 0; + memcpy(addr.sun_path + 1, name, namelen); + + socklen_t alen = namelen + offsetof(sockaddr_un, sun_path) + 1; + + int s = socket(AF_LOCAL, type, 0); + if (s == -1) { + return -1; + } + + int rc = TEMP_FAILURE_RETRY(connect(s, reinterpret_cast(&addr), alen)); + if (rc == -1) { + close(s); + return -1; + } + + return s; +} + +/* + * Writes a summary of the signal to the log file. We do this so that, if + * for some reason we're not able to contact debuggerd, there is still some + * indication of the failure in the log. + * + * We could be here as a result of native heap corruption, or while a + * mutex is being held, so we don't want to use any libc functions that + * could allocate memory or hold a lock. + */ +static void log_signal_summary(int signum, const siginfo_t* info) { + const char* signal_name = "???"; + bool has_address = false; + switch (signum) { + case SIGABRT: + signal_name = "SIGABRT"; + break; + case SIGBUS: + signal_name = "SIGBUS"; + has_address = true; + break; + case SIGFPE: + signal_name = "SIGFPE"; + has_address = true; + break; + case SIGILL: + signal_name = "SIGILL"; + has_address = true; + break; + case SIGSEGV: + signal_name = "SIGSEGV"; + has_address = true; + break; +#if defined(SIGSTKFLT) + case SIGSTKFLT: + signal_name = "SIGSTKFLT"; + break; +#endif + case SIGTRAP: + signal_name = "SIGTRAP"; + break; + } + + char thread_name[MAX_TASK_NAME_LEN + 1]; // one more for termination + if (prctl(PR_GET_NAME, reinterpret_cast(thread_name), 0, 0, 0) != 0) { + strcpy(thread_name, ""); + } else { + // short names are null terminated by prctl, but the man page + // implies that 16 byte names are not. + thread_name[MAX_TASK_NAME_LEN] = 0; + } + + // "info" will be null if the siginfo_t information was not available. + // Many signals don't have an address or a code. + char code_desc[32]; // ", code -6" + char addr_desc[32]; // ", fault addr 0x1234" + addr_desc[0] = code_desc[0] = 0; + if (info != nullptr) { + // For a rethrown signal, this si_code will be right and the one debuggerd shows will + // always be SI_TKILL. + __libc_format_buffer(code_desc, sizeof(code_desc), ", code %d", info->si_code); + if (has_address) { + __libc_format_buffer(addr_desc, sizeof(addr_desc), ", fault addr %p", info->si_addr); + } + } + __libc_format_log(ANDROID_LOG_FATAL, "libc", "Fatal signal %d (%s)%s%s in tid %d (%s)", signum, + signal_name, code_desc, addr_desc, gettid(), thread_name); +} + +/* + * Returns true if the handler for signal "signum" has SA_SIGINFO set. + */ +static bool have_siginfo(int signum) { + struct sigaction old_action, new_action; + + memset(&new_action, 0, sizeof(new_action)); + new_action.sa_handler = SIG_DFL; + new_action.sa_flags = SA_RESTART; + sigemptyset(&new_action.sa_mask); + + if (sigaction(signum, &new_action, &old_action) < 0) { + __libc_format_log(ANDROID_LOG_WARN, "libc", "Failed testing for SA_SIGINFO: %s", + strerror(errno)); + return false; + } + bool result = (old_action.sa_flags & SA_SIGINFO) != 0; + + if (sigaction(signum, &old_action, nullptr) == -1) { + __libc_format_log(ANDROID_LOG_WARN, "libc", "Restore failed in test for SA_SIGINFO: %s", + strerror(errno)); + } + return result; +} + +static void send_debuggerd_packet(siginfo_t* info) { + // Mutex to prevent multiple crashing threads from trying to talk + // to debuggerd at the same time. + static pthread_mutex_t crash_mutex = PTHREAD_MUTEX_INITIALIZER; + int ret = pthread_mutex_trylock(&crash_mutex); + if (ret != 0) { + if (ret == EBUSY) { + __libc_format_log(ANDROID_LOG_INFO, "libc", + "Another thread contacted debuggerd first; not contacting debuggerd."); + // This will never complete since the lock is never released. + pthread_mutex_lock(&crash_mutex); + } else { + __libc_format_log(ANDROID_LOG_INFO, "libc", "pthread_mutex_trylock failed: %s", strerror(ret)); + } + return; + } + + int s = socket_abstract_client(SOCKET_NAME, SOCK_STREAM | SOCK_CLOEXEC); + if (s == -1) { + __libc_format_log(ANDROID_LOG_FATAL, "libc", "Unable to open connection to debuggerd: %s", + strerror(errno)); + return; + } + + // debuggerd knows our pid from the credentials on the + // local socket but we need to tell it the tid of the crashing thread. + // debuggerd will be paranoid and verify that we sent a tid + // that's actually in our process. + debugger_msg_t msg; + msg.action = DEBUGGER_ACTION_CRASH; + msg.tid = gettid(); + msg.abort_msg_address = 0; + + if (g_callbacks.get_abort_message) { + msg.abort_msg_address = reinterpret_cast(g_callbacks.get_abort_message()); + } + + msg.original_si_code = (info != nullptr) ? info->si_code : 0; + ret = TEMP_FAILURE_RETRY(write(s, &msg, sizeof(msg))); + if (ret == sizeof(msg)) { + char debuggerd_ack; + ret = TEMP_FAILURE_RETRY(read(s, &debuggerd_ack, 1)); + int saved_errno = errno; + if (g_callbacks.post_dump) { + g_callbacks.post_dump(); + } + errno = saved_errno; + } else { + // read or write failed -- broken connection? + __libc_format_log(ANDROID_LOG_FATAL, "libc", "Failed while talking to debuggerd: %s", + strerror(errno)); + } + + close(s); +} + +/* + * Catches fatal signals so we can ask debuggerd to ptrace us before + * we crash. + */ +static void debuggerd_signal_handler(int signal_number, siginfo_t* info, void*) { + // It's possible somebody cleared the SA_SIGINFO flag, which would mean + // our "info" arg holds an undefined value. + if (!have_siginfo(signal_number)) { + info = nullptr; + } + + log_signal_summary(signal_number, info); + + send_debuggerd_packet(info); + + // We need to return from the signal handler so that debuggerd can dump the + // thread that crashed, but returning here does not guarantee that the signal + // will be thrown again, even for SIGSEGV and friends, since the signal could + // have been sent manually. Resend the signal with rt_tgsigqueueinfo(2) to + // preserve the SA_SIGINFO contents. + signal(signal_number, SIG_DFL); + + struct siginfo si; + if (!info) { + memset(&si, 0, sizeof(si)); + si.si_code = SI_USER; + si.si_pid = getpid(); + si.si_uid = getuid(); + info = &si; + } else if (info->si_code >= 0 || info->si_code == SI_TKILL) { + // rt_tgsigqueueinfo(2)'s documentation appears to be incorrect on kernels + // that contain commit 66dd34a (3.9+). The manpage claims to only allow + // negative si_code values that are not SI_TKILL, but 66dd34a changed the + // check to allow all si_code values in calls coming from inside the house. + } + + int rc = syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), signal_number, info); + if (rc != 0) { + __libc_format_log(ANDROID_LOG_FATAL, "libc", "failed to resend signal during crash: %s", + strerror(errno)); + _exit(0); + } +} + +void debuggerd_init(debuggerd_callbacks_t* callbacks) { + if (callbacks) { + g_callbacks = *callbacks; + } + + struct sigaction action; + memset(&action, 0, sizeof(action)); + sigemptyset(&action.sa_mask); + action.sa_sigaction = debuggerd_signal_handler; + action.sa_flags = SA_RESTART | SA_SIGINFO; + + // Use the alternate signal stack if available so we can catch stack overflows. + action.sa_flags |= SA_ONSTACK; + + sigaction(SIGABRT, &action, nullptr); + sigaction(SIGBUS, &action, nullptr); + sigaction(SIGFPE, &action, nullptr); + sigaction(SIGILL, &action, nullptr); + sigaction(SIGSEGV, &action, nullptr); +#if defined(SIGSTKFLT) + sigaction(SIGSTKFLT, &action, nullptr); +#endif + sigaction(SIGTRAP, &action, nullptr); +} diff --git a/debuggerd/crasher.cpp b/debuggerd/crasher.cpp index bdeaf0b33..a37df3350 100644 --- a/debuggerd/crasher.cpp +++ b/debuggerd/crasher.cpp @@ -16,6 +16,10 @@ #include #include +#if defined(STATIC_CRASHER) +#include "debuggerd/client.h" +#endif + #ifndef __unused #define __unused __attribute__((__unused__)) #endif @@ -43,7 +47,7 @@ __attribute__ ((noinline)) static void smash_stack_dummy_function(volatile int* // Assign local array address to global variable to force stack guards. // Use another noinline function to corrupt the stack. __attribute__ ((noinline)) static int smash_stack(volatile int* plen) { - printf("crasher: deliberately corrupting stack...\n"); + printf("%s: deliberately corrupting stack...\n", __progname); char buf[128]; smash_stack_dummy_buf = buf; @@ -135,7 +139,7 @@ static void sigsegv_non_null() { static int do_action(const char* arg) { - fprintf(stderr,"crasher: init pid=%d tid=%d\n", getpid(), gettid()); + fprintf(stderr, "%s: init pid=%d tid=%d\n", __progname, getpid(), gettid()); if (!strncmp(arg, "thread-", strlen("thread-"))) { return do_action_on_thread(arg + strlen("thread-")); @@ -209,9 +213,26 @@ static int do_action(const char* arg) int main(int argc, char **argv) { - fprintf(stderr,"crasher: built at " __TIME__ "!@\n"); + fprintf(stderr, "%s: built at " __TIME__ "!@\n", __progname); - if(argc > 1) { +#if defined(STATIC_CRASHER) + debuggerd_callbacks_t callbacks = { + .get_abort_message = []() { + static struct { + size_t size; + char msg[32]; + } msg; + + msg.size = strlen("dummy abort message"); + memcpy(msg.msg, "dummy abort message", strlen("dummy abort message")); + return reinterpret_cast(&msg); + }, + .post_dump = nullptr + }; + debuggerd_init(&callbacks); +#endif + + if (argc > 1) { return do_action(argv[1]); } else { crash1(); diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp index 4a1f4dbb9..a4e9cae11 100644 --- a/debuggerd/debuggerd.cpp +++ b/debuggerd/debuggerd.cpp @@ -563,7 +563,7 @@ static void worker_process(int fd, debugger_request_t& request) { // won't necessarily have stopped by the time ptrace() returns. (We // currently assume it does.) We write to the file descriptor to // ensure that it can run as soon as we call PTRACE_CONT below. - // See details in bionic/libc/linker/debugger.c, in function + // See details in client/debuggerd_client.cpp, in function // debugger_signal_handler(). // Attach to the target process. diff --git a/debuggerd/include/debuggerd/client.h b/debuggerd/include/debuggerd/client.h new file mode 100644 index 000000000..41b7b3a1f --- /dev/null +++ b/debuggerd/include/debuggerd/client.h @@ -0,0 +1,59 @@ +/* + * Copyright 2016 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. + */ + +#pragma once + +#include +#include +#include + +// On 32-bit devices, DEBUGGER_SOCKET_NAME is a 32-bit debuggerd. +// On 64-bit devices, DEBUGGER_SOCKET_NAME is a 64-bit debuggerd. +#define DEBUGGER_SOCKET_NAME "android:debuggerd" + +// Used only on 64-bit devices for debuggerd32. +#define DEBUGGER32_SOCKET_NAME "android:debuggerd32" + +__BEGIN_DECLS + +typedef enum { + // dump a crash + DEBUGGER_ACTION_CRASH, + // dump a tombstone file + DEBUGGER_ACTION_DUMP_TOMBSTONE, + // dump a backtrace only back to the socket + DEBUGGER_ACTION_DUMP_BACKTRACE, +} debugger_action_t; + +// Make sure that all values have a fixed size so that this structure +// is the same for 32 bit and 64 bit processes. +typedef struct __attribute__((packed)) { + int32_t action; + pid_t tid; + uint64_t abort_msg_address; + int32_t original_si_code; +} debugger_msg_t; + +// These callbacks are called in a signal handler, and thus must be async signal safe. +// If null, the callbacks will not be called. +typedef struct { + struct abort_msg_t* (*get_abort_message)(); + void (*post_dump)(); +} debuggerd_callbacks_t; + +void debuggerd_init(debuggerd_callbacks_t* callbacks); + +__END_DECLS diff --git a/include/cutils/debugger.h b/include/cutils/debugger.h index 285e1afcd..20e8796b7 100644 --- a/include/cutils/debugger.h +++ b/include/cutils/debugger.h @@ -20,32 +20,10 @@ #include #include +#include "debuggerd/client.h" + __BEGIN_DECLS -#define DEBUGGER_SOCKET_NAME "android:debuggerd" -#define DEBUGGER32_SOCKET_NAME "android:debuggerd32" -#define DEBUGGER64_SOCKET_NAME DEBUGGER_SOCKET_NAME - -typedef enum { - // dump a crash - DEBUGGER_ACTION_CRASH, - // dump a tombstone file - DEBUGGER_ACTION_DUMP_TOMBSTONE, - // dump a backtrace only back to the socket - DEBUGGER_ACTION_DUMP_BACKTRACE, -} debugger_action_t; - -// Make sure that all values have a fixed size so that this structure -// is the same for 32 bit and 64 bit processes. -// NOTE: Any changes to this structure must also be reflected in -// bionic/linker/debugger.cpp. -typedef struct __attribute__((packed)) { - int32_t action; - pid_t tid; - uint64_t abort_msg_address; - int32_t original_si_code; -} debugger_msg_t; - /* Dumps a process backtrace, registers, and stack to a tombstone file (requires root). * Stores the tombstone path in the provided buffer. * Returns 0 on success, -1 on error. diff --git a/libcutils/Android.mk b/libcutils/Android.mk index 822a7d34b..e29c9ad6e 100644 --- a/libcutils/Android.mk +++ b/libcutils/Android.mk @@ -117,7 +117,8 @@ LOCAL_SRC_FILES_x86_64 += \ arch-x86_64/android_memset32.S \ LOCAL_C_INCLUDES := $(libcutils_c_includes) -LOCAL_STATIC_LIBRARIES := liblog +LOCAL_EXPORT_STATIC_LIBRARY_HEADERS := libdebuggerd_client +LOCAL_STATIC_LIBRARIES := liblog libdebuggerd_client ifneq ($(ENABLE_CPUSETS),) LOCAL_CFLAGS += -DUSE_CPUSETS endif @@ -134,6 +135,8 @@ LOCAL_MODULE := libcutils # TODO: remove liblog as whole static library, once we don't have prebuilt that requires # liblog symbols present in libcutils. LOCAL_WHOLE_STATIC_LIBRARIES := libcutils liblog +LOCAL_EXPORT_STATIC_LIBRARY_HEADERS := libdebuggerd_client +LOCAL_STATIC_LIBRARIES := libdebuggerd_client LOCAL_SHARED_LIBRARIES := liblog ifneq ($(ENABLE_CPUSETS),) LOCAL_CFLAGS += -DUSE_CPUSETS