--- /dev/null
+ndk_headers {
+ name: "libandroid_headers",
+ from: "include/android",
+ to: "android",
+ srcs: ["include/android/**/*.h"],
+ license: "NOTICE",
+}
+
+subdirs = [
+ "cmds/*",
+ "libs/*",
+ "opengl",
+ "services/*",
+ "vulkan",
+]
--- /dev/null
+// Copyright 2012 The Android Open Source Project
+
+cc_binary {
+ name: "atrace",
+ srcs: ["atrace.cpp"],
+
+ shared_libs: [
+ "libbinder",
+ "libhwbinder",
+ "android.hidl.manager@1.0",
+ "libhidlbase",
+ "libhidltransport",
+ "liblog",
+ "libcutils",
+ "libutils",
+ "libz",
+ "libbase",
+ ],
+
+ init_rc: ["atrace.rc"],
+}
+++ /dev/null
-# Copyright 2012 The Android Open Source Project
-
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= atrace.cpp
-
-LOCAL_C_INCLUDES += external/zlib
-
-LOCAL_MODULE:= atrace
-
-LOCAL_MODULE_TAGS:= optional
-
-LOCAL_SHARED_LIBRARIES := \
- libbinder \
- libcutils \
- libutils \
- libz \
-
-LOCAL_INIT_RC := atrace.rc
-
-include $(BUILD_EXECUTABLE)
#include <unistd.h>
#include <zlib.h>
+#include <memory>
+
#include <binder/IBinder.h>
#include <binder/IServiceManager.h>
#include <binder/Parcel.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl/ServiceManagement.h>
#include <cutils/properties.h>
#include <utils/String8.h>
#include <utils/Timers.h>
#include <utils/Tokenizer.h>
#include <utils/Trace.h>
+#include <android-base/file.h>
using namespace android;
+using std::string;
#define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
#define MAX_SYS_FILES 10
return true;
}
+// Poke all the HAL processes in the system to get them to re-read
+// their system properties.
+static void pokeHalServices()
+{
+ using ::android::hidl::manager::V1_0::IServiceManager;
+ using ::android::hardware::IBinder;
+ using ::android::hardware::hidl_string;
+ using ::android::hardware::Parcel;
+
+ Parcel data;
+
+ sp<IServiceManager> sm = ::android::hardware::defaultServiceManager();
+ sm->list([&](const auto &interfaces) {
+ for (size_t i = 0; i < interfaces.size(); i++) {
+ string fqInstanceName = interfaces[i];
+ string::size_type n = fqInstanceName.find("/");
+ if (n == std::string::npos || interfaces[i].size() == n+1)
+ continue;
+ hidl_string fqInterfaceName = fqInstanceName.substr(0, n);
+ hidl_string instanceName = fqInstanceName.substr(n+1, std::string::npos);
+ sm->get(fqInterfaceName, instanceName, [&](const auto &interface) {
+ // TODO(b/32756130)
+ // Once IServiceManager returns IBase, use interface->notifySyspropsChanged() here
+ interface->transact(IBinder::SYSPROPS_TRANSACTION, data, nullptr, 0, nullptr);
+ });
+ }
+ });
+}
+
// Set the trace tags that userland tracing uses, and poke the running
// processes to pick up the new value.
static bool setTagsProperty(uint64_t tags)
// Set the system property that indicates which apps should perform
// application-level tracing.
-static bool setAppCmdlineProperty(const char* cmdline)
+static bool setAppCmdlineProperty(char* cmdline)
{
char buf[PROPERTY_KEY_MAX];
int i = 0;
- const char* start = cmdline;
+ char* start = cmdline;
while (start != NULL) {
if (i == MAX_PACKAGES) {
fprintf(stderr, "error: only 16 packages could be traced at once\n");
// kernel.
static bool verifyKernelTraceFuncs(const char* funcs)
{
- int fd = open(k_ftraceFilterPath, O_RDONLY);
- if (fd == -1) {
- fprintf(stderr, "error opening %s: %s (%d)\n", k_ftraceFilterPath,
+ std::string buf;
+ if (!android::base::ReadFileToString(k_ftraceFilterPath, &buf)) {
+ fprintf(stderr, "error opening %s: %s (%d)\n", k_ftraceFilterPath,
strerror(errno), errno);
- return false;
+ return false;
}
- char buf[4097];
- ssize_t n = read(fd, buf, 4096);
- close(fd);
- if (n == -1) {
- fprintf(stderr, "error reading %s: %s (%d)\n", k_ftraceFilterPath,
- strerror(errno), errno);
- return false;
- }
-
- buf[n] = '\0';
- String8 funcList = String8::format("\n%s", buf);
+ String8 funcList = String8::format("\n%s",buf.c_str());
// Make sure that every function listed in funcs is in the list we just
// read from the kernel, except for wildcard inputs.
func = strtok(NULL, ",");
}
free(myFuncs);
-
return ok;
}
}
packageList += value;
}
- ok &= setAppCmdlineProperty(packageList.data());
+ ok &= setAppCmdlineProperty(&packageList[0]);
ok &= pokeBinderServices();
+ pokeHalServices();
// Disable all the sysfs enables. This is done as a separate loop from
// the enables to allow the same enable to exist in multiple categories.
if (g_compress) {
z_stream zs;
- uint8_t *in, *out;
- int result, flush;
-
memset(&zs, 0, sizeof(zs));
- result = deflateInit(&zs, Z_DEFAULT_COMPRESSION);
+
+ int result = deflateInit(&zs, Z_DEFAULT_COMPRESSION);
if (result != Z_OK) {
fprintf(stderr, "error initializing zlib: %d\n", result);
close(traceFD);
return;
}
- const size_t bufSize = 64*1024;
- in = (uint8_t*)malloc(bufSize);
- out = (uint8_t*)malloc(bufSize);
- flush = Z_NO_FLUSH;
+ constexpr size_t bufSize = 64*1024;
+ std::unique_ptr<uint8_t> in(new uint8_t[bufSize]);
+ std::unique_ptr<uint8_t> out(new uint8_t[bufSize]);
+ if (!in || !out) {
+ fprintf(stderr, "couldn't allocate buffers\n");
+ close(traceFD);
+ return;
+ }
+
+ int flush = Z_NO_FLUSH;
- zs.next_out = out;
+ zs.next_out = reinterpret_cast<Bytef*>(out.get());
zs.avail_out = bufSize;
do {
if (zs.avail_in == 0) {
// More input is needed.
- result = read(traceFD, in, bufSize);
+ result = read(traceFD, in.get(), bufSize);
if (result < 0) {
fprintf(stderr, "error reading trace: %s (%d)\n",
strerror(errno), errno);
} else if (result == 0) {
flush = Z_FINISH;
} else {
- zs.next_in = in;
+ zs.next_in = reinterpret_cast<Bytef*>(in.get());
zs.avail_in = result;
}
}
if (zs.avail_out == 0) {
// Need to write the output.
- result = write(outFd, out, bufSize);
+ result = write(outFd, out.get(), bufSize);
if ((size_t)result < bufSize) {
fprintf(stderr, "error writing deflated trace: %s (%d)\n",
strerror(errno), errno);
zs.avail_out = bufSize; // skip the final write
break;
}
- zs.next_out = out;
+ zs.next_out = reinterpret_cast<Bytef*>(out.get());
zs.avail_out = bufSize;
}
if (zs.avail_out < bufSize) {
size_t bytes = bufSize - zs.avail_out;
- result = write(outFd, out, bytes);
+ result = write(outFd, out.get(), bytes);
if ((size_t)result < bytes) {
fprintf(stderr, "error writing deflated trace: %s (%d)\n",
strerror(errno), errno);
if (result != Z_OK) {
fprintf(stderr, "error cleaning up zlib: %d\n", result);
}
-
- free(in);
- free(out);
} else {
ssize_t sent = 0;
while ((sent = sendfile(outFd, traceFD, NULL, 64*1024*1024)) > 0);
" -k fname,... trace the listed kernel functions\n"
" -n ignore signals\n"
" -s N sleep for N seconds before tracing [default 0]\n"
- " -t N trace for N seconds [defualt 5]\n"
+ " -t N trace for N seconds [default 5]\n"
" -z compress the trace dump\n"
" --async_start start circular trace and return immediatly\n"
" --async_dump dump the current contents of circular trace buffer\n"
## Permissions to allow system-wide tracing to the kernel trace buffer.
##
-on fs
+on post-fs
# Allow writing to the kernel trace log.
chmod 0222 /sys/kernel/debug/tracing/trace_marker
--- /dev/null
+cc_binary {
+ name: "bugreport",
+ srcs: ["bugreport.cpp"],
+ cflags: ["-Wall"],
+ shared_libs: ["libcutils"],
+}
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= bugreport.cpp
-
-LOCAL_MODULE:= bugreport
-
-LOCAL_CFLAGS := -Wall
-
-LOCAL_SHARED_LIBRARIES := libcutils
-
-include $(BUILD_EXECUTABLE)
--- /dev/null
+cc_library_static {
+ name: "libdumpstate.default",
+ srcs: ["libdumpstate_default.cpp"],
+}
LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := libdumpstate_default.cpp
-LOCAL_MODULE := libdumpstate.default
-include $(BUILD_STATIC_LIBRARY)
include $(CLEAR_VARS)
LOCAL_SHARED_LIBRARIES := libcutils liblog libselinux libbase
# ZipArchive support, the order matters here to get all symbols.
-LOCAL_STATIC_LIBRARIES := libziparchive libz libmincrypt
+LOCAL_STATIC_LIBRARIES := libziparchive libz libcrypto_static
LOCAL_HAL_STATIC_LIBRARIES := libdumpstate
LOCAL_CFLAGS += -Wall -Werror -Wno-unused-parameter
LOCAL_INIT_RC := dumpstate.rc
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+#define LOG_TAG "dumpstate"
#include <dirent.h>
#include <errno.h>
#include <unistd.h>
#include <android-base/stringprintf.h>
+#include <android-base/unique_fd.h>
#include <android-base/file.h>
#include <cutils/properties.h>
-#include "private/android_filesystem_config.h"
-
-#define LOG_TAG "dumpstate"
-#include <cutils/log.h>
+#include <private/android_filesystem_config.h>
+#include <private/android_logger.h>
#include "dumpstate.h"
-#include "ScopedFd.h"
#include "ziparchive/zip_writer.h"
-#include "mincrypt/sha256.h"
+#include <openssl/sha.h>
using android::base::StringPrintf;
return 0;
}
-/* Copied policy from system/core/logd/LogBuffer.cpp */
-
-#define LOG_BUFFER_SIZE (256 * 1024)
-#define LOG_BUFFER_MIN_SIZE (64 * 1024UL)
-#define LOG_BUFFER_MAX_SIZE (256 * 1024 * 1024UL)
-
-static bool valid_size(unsigned long value) {
- if ((value < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < value)) {
- return false;
- }
-
- long pages = sysconf(_SC_PHYS_PAGES);
- if (pages < 1) {
- return true;
- }
-
- long pagesize = sysconf(_SC_PAGESIZE);
- if (pagesize <= 1) {
- pagesize = PAGE_SIZE;
- }
-
- // maximum memory impact a somewhat arbitrary ~3%
- pages = (pages + 31) / 32;
- unsigned long maximum = pages * pagesize;
-
- if ((maximum < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < maximum)) {
- return true;
- }
-
- return value <= maximum;
-}
-
-static unsigned long property_get_size(const char *key) {
- unsigned long value;
- char *cp, property[PROPERTY_VALUE_MAX];
-
- property_get(key, property, "");
- value = strtoul(property, &cp, 10);
-
- switch(*cp) {
- case 'm':
- case 'M':
- value *= 1024;
- /* FALLTHRU */
- case 'k':
- case 'K':
- value *= 1024;
- /* FALLTHRU */
- case '\0':
- break;
-
- default:
- value = 0;
- }
-
- if (!valid_size(value)) {
- value = 0;
- }
-
- return value;
-}
-
/* timeout in ms */
static unsigned long logcat_timeout(const char *name) {
- static const char global_tuneable[] = "persist.logd.size"; // Settings App
- static const char global_default[] = "ro.logd.size"; // BoardConfig.mk
- char key[PROP_NAME_MAX];
- unsigned long property_size, default_size;
-
- default_size = property_get_size(global_tuneable);
- if (!default_size) {
- default_size = property_get_size(global_default);
- }
-
- snprintf(key, sizeof(key), "%s.%s", global_tuneable, name);
- property_size = property_get_size(key);
-
- if (!property_size) {
- snprintf(key, sizeof(key), "%s.%s", global_default, name);
- property_size = property_get_size(key);
- }
-
- if (!property_size) {
- property_size = default_size;
- }
-
- if (!property_size) {
- property_size = LOG_BUFFER_SIZE;
- }
-
+ log_id_t id = android_name_to_log_id(name);
+ unsigned long property_size = __android_logger_get_buffer_size(id);
/* Engineering margin is ten-fold our guess */
return 10 * (property_size + worst_write_perf) / worst_write_perf;
}
-/* End copy from system/core/logd/LogBuffer.cpp */
-
/* dumps the current system state to stdout */
static void print_header(std::string version) {
char build[PROPERTY_VALUE_MAX], fingerprint[PROPERTY_VALUE_MAX];
}
bool add_zip_entry(const std::string& entry_name, const std::string& entry_path) {
- ScopedFd fd(TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC)));
- if (fd.get() == -1) {
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(entry_path.c_str(), O_RDONLY | O_NONBLOCK
+ | O_CLOEXEC)));
+ if (fd == -1) {
MYLOGE("open(%s): %s\n", entry_path.c_str(), strerror(errno));
return false;
}
dump_files("UPTIME MMC PERF", mmcblk0, skip_not_stat, dump_stat_from_fd);
dump_emmc_ecsd("/d/mmc0/mmc0:0001/ext_csd");
dump_file("MEMORY INFO", "/proc/meminfo");
- run_command("CPU INFO", 10, "top", "-n", "1", "-d", "1", "-m", "30", "-H", NULL);
+ run_command("CPU INFO", 10, "top", "-b", "-n", "1", "-H", "-s", "6",
+ "-o", "pid,tid,user,pr,ni,%cpu,s,virt,res,pcy,cmd,name", NULL);
run_command("PROCRANK", 20, SU_PATH, "root", "procrank", NULL);
dump_file("VIRTUAL MEMORY STATS", "/proc/vmstat");
dump_file("VMALLOC INFO", "/proc/vmallocinfo");
dump_file("KERNEL CPUFREQ", "/sys/devices/system/cpu/cpu0/cpufreq/stats/time_in_state");
dump_file("KERNEL SYNC", "/d/sync");
- run_command("PROCESSES AND THREADS", 10, "ps", "-Z", "-t", "-p", "-P", NULL);
+ run_command("PROCESSES AND THREADS", 10, "ps", "-A", "-T", "-Z",
+ "-O", "pri,nice,rtprio,sched,pcy", NULL);
run_command("LIBRANK", 10, SU_PATH, "root", "librank", NULL);
run_command("PRINTENV", 10, "printenv", NULL);
- run_command("NETSTAT", 10, "netstat", "-n", NULL);
+ run_command("NETSTAT", 10, "netstat", "-nW", NULL);
run_command("LSMOD", 10, "lsmod", NULL);
do_dmesg();
for_each_tid(show_wchan, "BLOCKED PROCESS WAIT-CHANNELS");
for_each_pid(show_showtime, "PROCESS TIMES (pid cmd user system iowait+percentage)");
+ /* Dump Bluetooth HCI logs */
+ add_dir("/data/misc/bluetooth/logs", true);
+
if (!screenshot_path.empty()) {
MYLOGI("taking late screenshot\n");
take_screenshot(screenshot_path);
}
static std::string SHA256_file_hash(std::string filepath) {
- ScopedFd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK | O_CLOEXEC
- | O_NOFOLLOW)));
- if (fd.get() == -1) {
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(filepath.c_str(), O_RDONLY | O_NONBLOCK
+ | O_CLOEXEC | O_NOFOLLOW)));
+ if (fd == -1) {
MYLOGE("open(%s): %s\n", filepath.c_str(), strerror(errno));
return NULL;
}
SHA256_CTX ctx;
- SHA256_init(&ctx);
+ SHA256_Init(&ctx);
std::vector<uint8_t> buffer(65536);
while (1) {
return NULL;
}
- SHA256_update(&ctx, buffer.data(), bytes_read);
+ SHA256_Update(&ctx, buffer.data(), bytes_read);
}
- uint8_t hash[SHA256_DIGEST_SIZE];
- memcpy(hash, SHA256_final(&ctx), SHA256_DIGEST_SIZE);
- char hash_buffer[SHA256_DIGEST_SIZE * 2 + 1];
- for(size_t i = 0; i < SHA256_DIGEST_SIZE; i++) {
+ uint8_t hash[SHA256_DIGEST_LENGTH];
+ SHA256_Final(hash, &ctx);
+
+ char hash_buffer[SHA256_DIGEST_LENGTH * 2 + 1];
+ for(size_t i = 0; i < SHA256_DIGEST_LENGTH; i++) {
sprintf(hash_buffer + (i * 2), "%02x", hash[i]);
}
hash_buffer[sizeof(hash_buffer) - 1] = 0;
*/
class DurationReporter {
public:
- DurationReporter(const char *title);
+ explicit DurationReporter(const char *title);
DurationReporter(const char *title, FILE* out);
~DurationReporter();
#include <sys/capability.h>
#include <sys/inotify.h>
#include <sys/stat.h>
-#include <sys/sysconf.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/klog.h>
void for_each_pid(for_each_pid_func func, const char *header) {
ON_DRY_RUN_RETURN();
- __for_each_pid(for_each_pid_helper, header, (void *)func);
+ __for_each_pid(for_each_pid_helper, header, (void *) func);
}
static void for_each_tid_helper(int pid, const char *cmdline, void *arg) {
* stuck.
*/
int dump_file_from_fd(const char *title, const char *path, int fd) {
+ ON_DRY_RUN_RETURN(0);
int flags = fcntl(fd, F_GETFL);
if (flags == -1) {
printf("*** %s: failed to get flags on fd %d: %s\n", path, fd, strerror(errno));
}
gid_t groups[] = { AID_LOG, AID_SDCARD_R, AID_SDCARD_RW,
- AID_MOUNT, AID_INET, AID_NET_BW_STATS, AID_READPROC };
+ AID_MOUNT, AID_INET, AID_NET_BW_STATS, AID_READPROC,
+ AID_BLUETOOTH };
if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) {
MYLOGE("Unable to setgroups, aborting: %s\n", strerror(errno));
return false;
--- /dev/null
+cc_binary {
+ name: "dumpsys",
+
+ srcs: ["dumpsys.cpp"],
+
+ shared_libs: [
+ "libbase",
+ "libutils",
+ "liblog",
+ "libbinder",
+ ],
+
+ cflags: ["-DXP_UNIX"],
+ //shared_libs: ["librt"],
+}
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- dumpsys.cpp
-
-LOCAL_SHARED_LIBRARIES := \
- libbase \
- libutils \
- liblog \
- libbinder
-
-
-ifeq ($(TARGET_OS),linux)
- LOCAL_CFLAGS += -DXP_UNIX
- #LOCAL_SHARED_LIBRARIES += librt
-endif
-
-LOCAL_MODULE:= dumpsys
-
-include $(BUILD_EXECUTABLE)
// call returns, to terminate our reads if the other end closes their copy of the
// file descriptor, but then hangs for some reason. There doesn't seem to be a good
// way to do this, though.
- remote_end.clear();
+ remote_end.reset();
if (err != 0) {
aerr << "Error dumping service info: (" << strerror(err) << ") " << service_name
if (!result) {
fprintf(stderr, "Shader source:\n");
printShaderSource(lines);
+ delete[] src;
return false;
}
delete[] src;
--- /dev/null
+cc_defaults {
+ name: "installd_defaults",
+
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+ srcs: [
+ "commands.cpp",
+ "globals.cpp",
+ "utils.cpp",
+ ],
+ shared_libs: [
+ "libbase",
+ "libcutils",
+ "liblog",
+ "liblogwrap",
+ "libselinux",
+ ],
+
+ clang: true,
+}
+
+//
+// Static library used in testing and executable
+//
+
+cc_library_static {
+ name: "libinstalld",
+ defaults: ["installd_defaults"],
+
+ export_include_dirs: ["."],
+}
+
+//
+// Executable
+//
+
+cc_binary {
+ name: "installd",
+ defaults: ["installd_defaults"],
+ srcs: ["installd.cpp"],
+
+ static_libs: ["libdiskusage"],
+
+ init_rc: ["installd.rc"],
+}
+
+// OTA chroot tool
+
+cc_binary {
+ name: "otapreopt_chroot",
+ cflags: [
+ "-Wall",
+ "-Werror",
+ ],
+ clang: true,
+
+ srcs: ["otapreopt_chroot.cpp"],
+ shared_libs: [
+ "libbase",
+ "liblog",
+ ],
+}
+
+subdirs = ["tests"]
LOCAL_PATH := $(call my-dir)
-common_src_files := commands.cpp globals.cpp utils.cpp
-common_cflags := -Wall -Werror
-
-#
-# Static library used in testing and executable
-#
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := libinstalld
-LOCAL_MODULE_TAGS := eng tests
-LOCAL_SRC_FILES := $(common_src_files)
-LOCAL_CFLAGS := $(common_cflags)
-LOCAL_SHARED_LIBRARIES := \
- libbase \
- liblogwrap \
- libselinux \
-
-LOCAL_ADDITIONAL_DEPENDENCIES += $(LOCAL_PATH)/Android.mk
-LOCAL_CLANG := true
-include $(BUILD_STATIC_LIBRARY)
-
-#
-# Executable
-#
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := installd
-LOCAL_MODULE_TAGS := optional
-LOCAL_CFLAGS := $(common_cflags)
-LOCAL_SRC_FILES := installd.cpp $(common_src_files)
-LOCAL_SHARED_LIBRARIES := \
- libbase \
- libcutils \
- liblog \
- liblogwrap \
- libselinux \
-
-LOCAL_STATIC_LIBRARIES := libdiskusage
-LOCAL_ADDITIONAL_DEPENDENCIES += $(LOCAL_PATH)/Android.mk
-LOCAL_INIT_RC := installd.rc
-LOCAL_CLANG := true
-include $(BUILD_EXECUTABLE)
-
#
# OTA Executable
#
include $(CLEAR_VARS)
LOCAL_MODULE := otapreopt
LOCAL_MODULE_TAGS := optional
-LOCAL_CFLAGS := $(common_cflags)
+LOCAL_CFLAGS := -Wall -Werror
# Base & ASLR boundaries for boot image creation.
ifndef LIBART_IMG_HOST_MIN_BASE_ADDRESS_DELTA
LOCAL_CFLAGS += -DART_BASE_ADDRESS_MIN_DELTA=$(LOCAL_LIBART_IMG_HOST_MIN_BASE_ADDRESS_DELTA)
LOCAL_CFLAGS += -DART_BASE_ADDRESS_MAX_DELTA=$(LOCAL_LIBART_IMG_HOST_MAX_BASE_ADDRESS_DELTA)
-LOCAL_SRC_FILES := otapreopt.cpp $(common_src_files)
+LOCAL_SRC_FILES := otapreopt.cpp commands.cpp globals.cpp utils.cpp
LOCAL_SHARED_LIBRARIES := \
libbase \
libcutils \
LOCAL_CLANG := true
include $(BUILD_EXECUTABLE)
-# OTA chroot tool
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := otapreopt_chroot
-LOCAL_MODULE_TAGS := optional
-LOCAL_CFLAGS := $(common_cflags)
-
-LOCAL_SRC_FILES := otapreopt_chroot.cpp
-LOCAL_SHARED_LIBRARIES := \
- libbase \
- liblog \
-
-LOCAL_ADDITIONAL_DEPENDENCIES += $(LOCAL_PATH)/Android.mk
-LOCAL_CLANG := true
-include $(BUILD_EXECUTABLE)
-
# OTA slot script
include $(CLEAR_VARS)
LOCAL_REQUIRED_MODULES := otapreopt otapreopt_chroot otapreopt_slot
include $(BUILD_PREBUILT)
-
-# Tests.
-
-include $(LOCAL_PATH)/tests/Android.mk
\ No newline at end of file
static constexpr int FLAG_CLEAR_CODE_CACHE_ONLY = 1 << 9;
/* dexopt needed flags matching those in dalvik.system.DexFile */
-static constexpr int DEXOPT_DEX2OAT_NEEDED = 1;
-static constexpr int DEXOPT_PATCHOAT_NEEDED = 2;
-static constexpr int DEXOPT_SELF_PATCHOAT_NEEDED = 3;
+static constexpr int DEX2OAT_FROM_SCRATCH = 1;
+static constexpr int DEX2OAT_FOR_BOOT_IMAGE = 2;
+static constexpr int DEX2OAT_FOR_FILTER = 3;
+static constexpr int DEX2OAT_FOR_RELOCATION = 4;
+static constexpr int PATCHOAT_FOR_RELOCATION = 5;
#define MIN_RESTRICTED_HOME_SDK_VERSION 24 // > M
return count;
}
-static void run_patchoat(int input_fd, int oat_fd, const char* input_file_name,
- const char* output_file_name, const char *pkgname ATTRIBUTE_UNUSED, const char *instruction_set)
+static void run_patchoat(int input_oat_fd, int input_vdex_fd, int out_oat_fd, int out_vdex_fd,
+ const char* input_oat_file_name, const char* input_vdex_file_name,
+ const char* output_oat_file_name, const char* output_vdex_file_name,
+ const char *pkgname ATTRIBUTE_UNUSED, const char *instruction_set)
{
static const int MAX_INT_LEN = 12; // '-'+10dig+'\0' -OR- 0x+8dig
static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
/* input_file_name/input_fd should be the .odex/.oat file that is precompiled. I think*/
char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
- char output_oat_fd_arg[strlen("--output-oat-fd=") + MAX_INT_LEN];
char input_oat_fd_arg[strlen("--input-oat-fd=") + MAX_INT_LEN];
+ char input_vdex_fd_arg[strlen("--input-vdex-fd=") + MAX_INT_LEN];
+ char output_oat_fd_arg[strlen("--output-oat-fd=") + MAX_INT_LEN];
+ char output_vdex_fd_arg[strlen("--output-vdex-fd=") + MAX_INT_LEN];
const char* patched_image_location_arg = "--patched-image-location=/system/framework/boot.art";
// The caller has already gotten all the locks we need.
const char* no_lock_arg = "--no-lock-output";
sprintf(instruction_set_arg, "--instruction-set=%s", instruction_set);
- sprintf(output_oat_fd_arg, "--output-oat-fd=%d", oat_fd);
- sprintf(input_oat_fd_arg, "--input-oat-fd=%d", input_fd);
- ALOGV("Running %s isa=%s in-fd=%d (%s) out-fd=%d (%s)\n",
- PATCHOAT_BIN, instruction_set, input_fd, input_file_name, oat_fd, output_file_name);
+ sprintf(output_oat_fd_arg, "--output-oat-fd=%d", out_oat_fd);
+ sprintf(input_oat_fd_arg, "--input-oat-fd=%d", input_oat_fd);
+ ALOGV("Running %s isa=%s in-oat-fd=%d (%s) in-vdex-fd=%d (%s) "
+ "out-oat-fd=%d (%s) out-vdex-fd=%d (%s)\n",
+ PATCHOAT_BIN, instruction_set,
+ input_oat_fd, input_oat_file_name,
+ input_vdex_fd, input_vdex_file_name,
+ out_oat_fd, output_oat_file_name,
+ out_vdex_fd, output_vdex_file_name);
/* patchoat, patched-image-location, no-lock, isa, input-fd, output-fd */
- char* argv[7];
+ char* argv[9];
argv[0] = (char*) PATCHOAT_BIN;
argv[1] = (char*) patched_image_location_arg;
argv[2] = (char*) no_lock_arg;
argv[3] = instruction_set_arg;
- argv[4] = output_oat_fd_arg;
- argv[5] = input_oat_fd_arg;
- argv[6] = NULL;
+ argv[4] = input_oat_fd_arg;
+ argv[5] = input_vdex_fd_arg;
+ argv[6] = output_oat_fd_arg;
+ argv[7] = output_vdex_fd_arg;
+ argv[8] = NULL;
execv(PATCHOAT_BIN, (char* const *)argv);
ALOGE("execv(%s) failed: %s\n", PATCHOAT_BIN, strerror(errno));
}
-static void run_dex2oat(int zip_fd, int oat_fd, int image_fd, const char* input_file_name,
- const char* output_file_name, int swap_fd, const char *instruction_set,
- const char* compiler_filter, bool vm_safe_mode, bool debuggable, bool post_bootcomplete,
- int profile_fd, const char* shared_libraries) {
+static void run_dex2oat(int zip_fd, int oat_fd, int input_vdex_fd, int output_vdex_fd, int image_fd,
+ const char* input_file_name, const char* output_file_name, int swap_fd,
+ const char *instruction_set, const char* compiler_filter, bool vm_safe_mode,
+ bool debuggable, bool post_bootcomplete, int profile_fd, const char* shared_libraries) {
static const unsigned int MAX_INSTRUCTION_SET_LEN = 7;
if (strlen(instruction_set) >= MAX_INSTRUCTION_SET_LEN) {
char zip_fd_arg[strlen("--zip-fd=") + MAX_INT_LEN];
char zip_location_arg[strlen("--zip-location=") + PKG_PATH_MAX];
+ char input_vdex_fd_arg[strlen("--input-vdex-fd=") + MAX_INT_LEN];
+ char output_vdex_fd_arg[strlen("--output-vdex-fd=") + MAX_INT_LEN];
char oat_fd_arg[strlen("--oat-fd=") + MAX_INT_LEN];
char oat_location_arg[strlen("--oat-location=") + PKG_PATH_MAX];
char instruction_set_arg[strlen("--instruction-set=") + MAX_INSTRUCTION_SET_LEN];
sprintf(zip_fd_arg, "--zip-fd=%d", zip_fd);
sprintf(zip_location_arg, "--zip-location=%s", input_file_name);
+ sprintf(input_vdex_fd_arg, "--input-vdex-fd=%d", input_vdex_fd);
+ sprintf(output_vdex_fd_arg, "--output-vdex-fd=%d", output_vdex_fd);
sprintf(oat_fd_arg, "--oat-fd=%d", oat_fd);
sprintf(oat_location_arg, "--oat-location=%s", output_file_name);
sprintf(instruction_set_arg, "--instruction-set=%s", instruction_set);
ALOGV("Running %s in=%s out=%s\n", DEX2OAT_BIN, input_file_name, output_file_name);
- const char* argv[7 // program name, mandatory arguments and the final NULL
+ const char* argv[9 // program name, mandatory arguments and the final NULL
+ (have_dex2oat_isa_variant ? 1 : 0)
+ (have_dex2oat_isa_features ? 1 : 0)
+ (have_dex2oat_Xms_flag ? 2 : 0)
argv[i++] = DEX2OAT_BIN;
argv[i++] = zip_fd_arg;
argv[i++] = zip_location_arg;
+ argv[i++] = input_vdex_fd_arg;
+ argv[i++] = output_vdex_fd_arg;
argv[i++] = oat_fd_arg;
argv[i++] = oat_location_arg;
argv[i++] = instruction_set_arg;
return true;
}
-// Translate the given oat path to an art (app image) path. An empty string
-// denotes an error.
-static std::string create_image_filename(const std::string& oat_path) {
- // A standard dalvik-cache entry. Replace ".dex" with ".art."
+static std::string replace_file_extension(const std::string& oat_path, const std::string& new_ext) {
+ // A standard dalvik-cache entry. Replace ".dex" with `new_ext`.
if (EndsWith(oat_path, ".dex")) {
- std::string art_path = oat_path;
- art_path.replace(art_path.length() - strlen("dex"), strlen("dex"), "art");
- CHECK(EndsWith(art_path, ".art"));
- return art_path;
+ std::string new_path = oat_path;
+ new_path.replace(new_path.length() - strlen(".dex"), strlen(".dex"), new_ext);
+ CHECK(EndsWith(new_path, new_ext.c_str()));
+ return new_path;
}
// An odex entry. Not that this may not be an extension, e.g., in the OTA
// case (where the base name will have an extension for the B artifact).
size_t odex_pos = oat_path.rfind(".odex");
if (odex_pos != std::string::npos) {
- std::string art_path = oat_path;
- art_path.replace(odex_pos, strlen(".odex"), ".art");
- CHECK_NE(art_path.find(".art"), std::string::npos);
- return art_path;
+ std::string new_path = oat_path;
+ new_path.replace(odex_pos, strlen(".odex"), new_ext);
+ CHECK_NE(new_path.find(new_ext), std::string::npos);
+ return new_path;
}
// Don't know how to handle this.
return "";
}
+// Translate the given oat path to an art (app image) path. An empty string
+// denotes an error.
+static std::string create_image_filename(const std::string& oat_path) {
+ return replace_file_extension(oat_path, ".art");
+}
+
+// Translate the given oat path to a vdex path. An empty string denotes an error.
+static std::string create_vdex_filename(const std::string& oat_path) {
+ return replace_file_extension(oat_path, ".vdex");
+}
+
static bool add_extension_to_file_name(char* file_name, const char* extension) {
if (strlen(file_name) + strlen(extension) + 1 > PKG_PATH_MAX) {
return false;
return true;
}
+static bool IsOutputDalvikCache(const char* oat_dir) {
+ // InstallerConnection.java (which invokes installd) transforms Java null arguments
+ // into '!'. Play it safe by handling it both.
+ // TODO: ensure we never get null.
+ // TODO: pass a flag instead of inferring if the output is dalvik cache.
+ return oat_dir == nullptr || oat_dir[0] == '!';
+}
+
static bool create_oat_out_path(const char* apk_path, const char* instruction_set,
- const char* oat_dir, /*out*/ char* out_path) {
+ const char* oat_dir, /*out*/ char* out_oat_path) {
// Early best-effort check whether we can fit the the path into our buffers.
// Note: the cache path will require an additional 5 bytes for ".swap", but we'll try to run
// without a swap file, if necessary. Reference profiles file also add an extra ".prof"
return false;
}
- if (oat_dir != NULL && oat_dir[0] != '!') {
+ if (!IsOutputDalvikCache(oat_dir)) {
if (validate_apk_path(oat_dir)) {
- ALOGE("invalid oat_dir '%s'\n", oat_dir);
+ ALOGE("cannot validate apk path with oat_dir '%s'\n", oat_dir);
return false;
}
- if (!calculate_oat_file_path(out_path, oat_dir, apk_path, instruction_set)) {
+ if (!calculate_oat_file_path(out_oat_path, oat_dir, apk_path, instruction_set)) {
return false;
}
} else {
- if (!create_cache_path(out_path, apk_path, instruction_set)) {
+ if (!create_cache_path(out_oat_path, apk_path, instruction_set)) {
return false;
}
}
bool boot_complete = (dexopt_flags & DEXOPT_BOOTCOMPLETE) != 0;
bool profile_guided = (dexopt_flags & DEXOPT_PROFILE_GUIDED) != 0;
- // Don't use profile for vm_safe_mode. b/30688277
- profile_guided = profile_guided && !vm_safe_mode;
-
CHECK(pkgname != nullptr);
CHECK(pkgname[0] != 0);
LOG_FATAL("dexopt flags contains unknown fields\n");
}
- char out_path[PKG_PATH_MAX];
- if (!create_oat_out_path(apk_path, instruction_set, oat_dir, out_path)) {
+ char out_oat_path[PKG_PATH_MAX];
+ if (!create_oat_out_path(apk_path, instruction_set, oat_dir, out_oat_path)) {
return false;
}
const char *input_file;
char in_odex_path[PKG_PATH_MAX];
- switch (dexopt_needed) {
- case DEXOPT_DEX2OAT_NEEDED:
+ int dexopt_action = abs(dexopt_needed);
+ bool is_odex_location = dexopt_needed < 0;
+ switch (dexopt_action) {
+ case DEX2OAT_FROM_SCRATCH:
+ case DEX2OAT_FOR_BOOT_IMAGE:
+ case DEX2OAT_FOR_FILTER:
+ case DEX2OAT_FOR_RELOCATION:
input_file = apk_path;
break;
- case DEXOPT_PATCHOAT_NEEDED:
- if (!calculate_odex_file_path(in_odex_path, apk_path, instruction_set)) {
- return -1;
+ case PATCHOAT_FOR_RELOCATION:
+ if (is_odex_location) {
+ if (!calculate_odex_file_path(in_odex_path, apk_path, instruction_set)) {
+ return -1;
+ }
+ input_file = in_odex_path;
+ } else {
+ input_file = out_oat_path;
}
- input_file = in_odex_path;
- break;
-
- case DEXOPT_SELF_PATCHOAT_NEEDED:
- input_file = out_path;
break;
default:
memset(&input_stat, 0, sizeof(input_stat));
stat(input_file, &input_stat);
+ // Open the input file. If running dex2oat, `input_file` is the APK. If running
+ // patchoat, it is the OAT file to be relocated.
base::unique_fd input_fd(open(input_file, O_RDONLY, 0));
if (input_fd.get() < 0) {
ALOGE("installd cannot open '%s' for input during dexopt\n", input_file);
return -1;
}
- const std::string out_path_str(out_path);
- Dex2oatFileWrapper<std::function<void ()>> out_fd(
- open_output_file(out_path, /*recreate*/true, /*permissions*/0644),
- [out_path_str]() { unlink(out_path_str.c_str()); });
- if (out_fd.get() < 0) {
- ALOGE("installd cannot open '%s' for output during dexopt\n", out_path);
+ // Create the output OAT file.
+ const std::string out_oat_path_str(out_oat_path);
+ Dex2oatFileWrapper<std::function<void ()>> out_oat_fd(
+ open_output_file(out_oat_path, /*recreate*/true, /*permissions*/0644),
+ [out_oat_path_str]() { unlink(out_oat_path_str.c_str()); });
+ if (out_oat_fd.get() < 0) {
+ ALOGE("installd cannot open '%s' for output during dexopt\n", out_oat_path);
return -1;
}
- if (!set_permissions_and_ownership(out_fd.get(), is_public, uid, out_path)) {
+ if (!set_permissions_and_ownership(out_oat_fd.get(), is_public, uid, out_oat_path)) {
+ return -1;
+ }
+
+ // Open the existing VDEX. We do this before creating the new output VDEX, which will
+ // unlink the old one.
+ base::unique_fd in_vdex_fd;
+ std::string in_vdex_path_str;
+ if (dexopt_action == PATCHOAT_FOR_RELOCATION) {
+ // `input_file` is the OAT file to be relocated. The VDEX has to be there as well.
+ in_vdex_path_str = create_vdex_filename(input_file);
+ if (in_vdex_path_str.empty()) {
+ ALOGE("installd cannot compute input vdex location for '%s'\n", input_file);
+ return -1;
+ }
+ in_vdex_fd.reset(open(in_vdex_path_str.c_str(), O_RDONLY, 0));
+ if (in_vdex_fd.get() < 0) {
+ ALOGE("installd cannot open '%s' for input during dexopt: %s\n",
+ in_vdex_path_str.c_str(), strerror(errno));
+ return -1;
+ }
+ } else if (dexopt_action != DEX2OAT_FROM_SCRATCH) {
+ // Open the possibly existing vdex. If none exist, we pass -1 to dex2oat for input-vdex-fd.
+ const char* path = nullptr;
+ if (is_odex_location) {
+ if (calculate_odex_file_path(in_odex_path, apk_path, instruction_set)) {
+ path = in_odex_path;
+ } else {
+ ALOGE("installd cannot compute input vdex location for '%s'\n", apk_path);
+ return -1;
+ }
+ } else {
+ path = out_oat_path;
+ }
+ in_vdex_path_str = create_vdex_filename(path);
+ if (in_vdex_path_str.empty()) {
+ ALOGE("installd cannot compute input vdex location for '%s'\n", path);
+ return -1;
+ }
+ in_vdex_fd.reset(open(in_vdex_path_str.c_str(), O_RDONLY, 0));
+ }
+
+ // Infer the name of the output VDEX and create it.
+ const std::string out_vdex_path_str = create_vdex_filename(out_oat_path_str);
+ if (out_vdex_path_str.empty()) {
+ return -1;
+ }
+ Dex2oatFileWrapper<std::function<void ()>> out_vdex_fd(
+ open_output_file(out_vdex_path_str.c_str(), /*recreate*/true, /*permissions*/0644),
+ [out_vdex_path_str]() { unlink(out_vdex_path_str.c_str()); });
+ if (out_vdex_fd.get() < 0) {
+ ALOGE("installd cannot open '%s' for output during dexopt\n", out_vdex_path_str.c_str());
+ return -1;
+ }
+ if (!set_permissions_and_ownership(out_vdex_fd.get(), is_public,
+ uid, out_vdex_path_str.c_str())) {
return -1;
}
if (ShouldUseSwapFileForDexopt()) {
// Make sure there really is enough space.
char swap_file_name[PKG_PATH_MAX];
- strcpy(swap_file_name, out_path);
+ strcpy(swap_file_name, out_oat_path);
if (add_extension_to_file_name(swap_file_name, ".swap")) {
swap_fd.reset(open_output_file(swap_file_name, /*recreate*/true, /*permissions*/0600));
}
// Avoid generating an app image for extract only since it will not contain any classes.
Dex2oatFileWrapper<std::function<void ()>> image_fd;
- const std::string image_path = create_image_filename(out_path);
- if (!image_path.empty()) {
+ const std::string image_path = create_image_filename(out_oat_path);
+ if (dexopt_action != PATCHOAT_FOR_RELOCATION && !image_path.empty()) {
char app_image_format[kPropertyValueMax];
bool have_app_image_format =
get_property("dalvik.vm.appimageformat", app_image_format, NULL) > 0;
drop_capabilities(uid);
SetDex2OatAndPatchOatScheduling(boot_complete);
- if (flock(out_fd.get(), LOCK_EX | LOCK_NB) != 0) {
- ALOGE("flock(%s) failed: %s\n", out_path, strerror(errno));
+ if (flock(out_oat_fd.get(), LOCK_EX | LOCK_NB) != 0) {
+ ALOGE("flock(%s) failed: %s\n", out_oat_path, strerror(errno));
_exit(67);
}
- if (dexopt_needed == DEXOPT_PATCHOAT_NEEDED
- || dexopt_needed == DEXOPT_SELF_PATCHOAT_NEEDED) {
+ if (dexopt_action == PATCHOAT_FOR_RELOCATION) {
run_patchoat(input_fd.get(),
- out_fd.get(),
+ in_vdex_fd.get(),
+ out_oat_fd.get(),
+ out_vdex_fd.get(),
input_file,
- out_path,
+ in_vdex_path_str.c_str(),
+ out_oat_path,
+ out_vdex_path_str.c_str(),
pkgname,
instruction_set);
- } else if (dexopt_needed == DEXOPT_DEX2OAT_NEEDED) {
+ } else {
// Pass dex2oat the relative path to the input file.
const char *input_file_name = get_location_from_path(input_file);
run_dex2oat(input_fd.get(),
- out_fd.get(),
+ out_oat_fd.get(),
+ in_vdex_fd.get(),
+ out_vdex_fd.get(),
image_fd.get(),
input_file_name,
- out_path,
+ out_oat_path,
swap_fd.get(),
instruction_set,
compiler_filter,
boot_complete,
reference_profile_fd.get(),
shared_libraries);
- } else {
- ALOGE("Invalid dexopt needed: %d\n", dexopt_needed);
- _exit(73);
}
_exit(68); /* only get here on exec failure */
} else {
struct utimbuf ut;
ut.actime = input_stat.st_atime;
ut.modtime = input_stat.st_mtime;
- utime(out_path, &ut);
+ utime(out_oat_path, &ut);
// We've been successful, don't delete output.
- out_fd.SetCleanup(false);
+ out_oat_fd.SetCleanup(false);
+ out_vdex_fd.SetCleanup(false);
image_fd.SetCleanup(false);
reference_profile_fd.SetCleanup(false);
PLOG(ERROR) << "Could not rename " << from << " to " << to;
return false;
}
-
return true;
}
if (!calculate_oat_file_path(a_path, oat_dir, apk_path, instruction_set)) {
return -1;
}
+ const std::string a_vdex_path = create_vdex_filename(a_path);
const std::string a_image_path = create_image_filename(a_path);
// B path = A path + slot suffix.
const std::string b_path = StringPrintf("%s.%s", a_path, slot_suffix.c_str());
+ const std::string b_vdex_path = StringPrintf("%s.%s", a_vdex_path.c_str(), slot_suffix.c_str());
const std::string b_image_path = StringPrintf("%s.%s",
a_image_path.c_str(),
slot_suffix.c_str());
- bool oat_success = move_ab_path(b_path, a_path);
- bool success;
-
- if (oat_success) {
- // Note: we can live without an app image. As such, ignore failure to move the image file.
- // If we decide to require the app image, or the app image being moved correctly,
- // then change accordingly.
- constexpr bool kIgnoreAppImageFailure = true;
-
- bool art_success = true;
- if (!a_image_path.empty()) {
- art_success = move_ab_path(b_image_path, a_image_path);
- if (!art_success) {
- unlink(a_image_path.c_str());
+ bool success = true;
+ if (move_ab_path(b_path, a_path)) {
+ if (move_ab_path(b_vdex_path, a_vdex_path)) {
+ // Note: we can live without an app image. As such, ignore failure to move the image file.
+ // If we decide to require the app image, or the app image being moved correctly,
+ // then change accordingly.
+ constexpr bool kIgnoreAppImageFailure = true;
+
+ if (!a_image_path.empty()) {
+ if (!move_ab_path(b_image_path, a_image_path)) {
+ unlink(a_image_path.c_str());
+ if (!kIgnoreAppImageFailure) {
+ success = false;
+ }
+ }
}
+ } else {
+ // Cleanup: delete B image, ignore errors.
+ unlink(b_image_path.c_str());
+ success = false;
}
-
- success = art_success || kIgnoreAppImageFailure;
} else {
// Cleanup: delete B image, ignore errors.
+ unlink(b_vdex_path.c_str());
unlink(b_image_path.c_str());
-
success = false;
}
const char *oat_dir,
const char *apk_path,
const char *instruction_set) {
- char *file_name_start;
- char *file_name_end;
+ const char *file_name_start;
+ const char *file_name_end;
file_name_start = strrchr(apk_path, '/');
if (file_name_start == NULL) {
return false;
}
- sprintf(path,"%s%s/%s/%s%s",
+ sprintf(path,"%s%s/%s/%s",
android_data_dir.path,
DALVIK_CACHE,
instruction_set,
- src + 1, /* skip the leading / */
- DALVIK_CACHE_POSTFIX);
+ src + 1 /* skip the leading / */);
char* tmp =
path +
}
}
+ strcat(path, DALVIK_CACHE_POSTFIX);
return true;
}
// This is used as a string literal, can't be constants. TODO: std::string...
#define DALVIK_CACHE "dalvik-cache"
-constexpr const char* DALVIK_CACHE_POSTFIX = "/classes.dex";
-constexpr const char* DALVIK_CACHE_POSTFIX2 = "@classes.dex";
+constexpr const char* DALVIK_CACHE_POSTFIX = "@classes.dex";
constexpr size_t PKG_NAME_MAX = 128u; /* largest allowed package name */
constexpr size_t PKG_PATH_MAX = 256u; /* max size of any path we use */
DALVIK_CACHE,
instruction_set,
from_src.c_str(),
- DALVIK_CACHE_POSTFIX2);
+ DALVIK_CACHE_POSTFIX);
if (assembled_path.length() + 1 > PKG_PATH_MAX) {
return false;
--- /dev/null
+// Build the unit tests for installd
+cc_test {
+ name: "installd_utils_test",
+ clang: true,
+ srcs: ["installd_utils_test.cpp"],
+ shared_libs: [
+ "libbase",
+ "libutils",
+ "liblog",
+ "libcutils",
+ ],
+ static_libs: [
+ "libinstalld",
+ "libdiskusage",
+ ],
+}
+++ /dev/null
-# Build the unit tests for installd
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-
-# Build the unit tests.
-test_src_files := \
- installd_utils_test.cpp
-
-shared_libraries := \
- libbase \
- libutils \
- libcutils \
-
-static_libraries := \
- libinstalld \
- libdiskusage \
-
-c_includes := \
- frameworks/native/cmds/installd
-
-$(foreach file,$(test_src_files), \
- $(eval include $(CLEAR_VARS)) \
- $(eval LOCAL_SHARED_LIBRARIES := $(shared_libraries)) \
- $(eval LOCAL_STATIC_LIBRARIES := $(static_libraries)) \
- $(eval LOCAL_SRC_FILES := $(file)) \
- $(eval LOCAL_C_INCLUDES := $(c_includes)) \
- $(eval LOCAL_MODULE := $(notdir $(file:%.cpp=%))) \
- $(eval LOCAL_CLANG := true) \
- $(eval include $(BUILD_NATIVE_TEST)) \
-)
--- /dev/null
+cc_binary {
+ name: "service",
+
+ srcs: ["service.cpp"],
+
+ shared_libs: [
+ "libutils",
+ "libbinder",
+ ],
+
+ cflags: ["-DXP_UNIX"],
+ //shared_libs: ["librt"],
+}
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- service.cpp
-
-LOCAL_SHARED_LIBRARIES := libutils libbinder
-
-ifeq ($(TARGET_OS),linux)
- LOCAL_CFLAGS += -DXP_UNIX
- #LOCAL_SHARED_LIBRARIES += librt
-endif
-
-LOCAL_MODULE:= service
-
-include $(BUILD_EXECUTABLE)
--- /dev/null
+cc_defaults {
+ name: "servicemanager_flags",
+
+ cflags: [
+ "-Wall",
+ "-Wextra",
+ "-Werror",
+ ],
+ product_variables: {
+ binder32bit: {
+ cflags: ["-DBINDER_IPC_32BIT=1"],
+ },
+ },
+
+ shared_libs: ["liblog"],
+}
+
+cc_binary {
+ name: "bctest",
+ defaults: ["servicemanager_flags"],
+ srcs: [
+ "bctest.c",
+ "binder.c",
+ ],
+}
+
+cc_binary {
+ name: "servicemanager",
+ defaults: ["servicemanager_flags"],
+ srcs: [
+ "service_manager.c",
+ "binder.c",
+ ],
+ shared_libs: ["libcutils", "libselinux"],
+ init_rc: ["servicemanager.rc"],
+}
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-
-svc_c_flags = \
- -Wall -Wextra -Werror \
-
-ifneq ($(TARGET_USES_64_BIT_BINDER),true)
-ifneq ($(TARGET_IS_64_BIT),true)
-svc_c_flags += -DBINDER_IPC_32BIT=1
-endif
-endif
-
-include $(CLEAR_VARS)
-LOCAL_SHARED_LIBRARIES := liblog
-LOCAL_SRC_FILES := bctest.c binder.c
-LOCAL_CFLAGS += $(svc_c_flags)
-LOCAL_MODULE := bctest
-LOCAL_MODULE_TAGS := optional
-include $(BUILD_EXECUTABLE)
-
-include $(CLEAR_VARS)
-LOCAL_SHARED_LIBRARIES := liblog libcutils libselinux
-LOCAL_SRC_FILES := service_manager.c binder.c
-LOCAL_CFLAGS += $(svc_c_flags)
-LOCAL_MODULE := servicemanager
-LOCAL_INIT_RC := servicemanager.rc
-include $(BUILD_EXECUTABLE)
#define _BINDER_H_
#include <sys/ioctl.h>
-#include <linux/binder.h>
+#include <linux/android/binder.h>
struct binder_state;
limitations under the License.
-->
-<!-- This is the standard feature indicating that the device includes WiFi NAN. -->
+<!-- This is the standard feature indicating that the device includes WiFi Aware. -->
<permissions>
- <feature name="android.hardware.wifi.nan" />
+ <feature name="android.hardware.wifi.aware" />
</permissions>
#ifndef ANDROID_ASSET_MANAGER_H
#define ANDROID_ASSET_MANAGER_H
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
#ifdef __cplusplus
extern "C" {
#endif
*/
off_t AAsset_seek(AAsset* asset, off_t offset, int whence);
+#if __ANDROID_API__ >= 13
/**
* Seek to the specified offset within the asset data. 'whence' uses the
* same constants as lseek()/fseek().
* Returns the new position on success, or (off64_t) -1 on error.
*/
off64_t AAsset_seek64(AAsset* asset, off64_t offset, int whence);
+#endif
/**
* Close the asset, freeing all associated resources.
*/
off_t AAsset_getLength(AAsset* asset);
+#if __ANDROID_API__ >= 13
/**
* Report the total size of the asset data. Reports the size using a 64-bit
* number insted of 32-bit as AAsset_getLength.
*/
off64_t AAsset_getLength64(AAsset* asset);
+#endif
/**
* Report the total amount of asset data that can be read from the current position.
*/
off_t AAsset_getRemainingLength(AAsset* asset);
+#if __ANDROID_API__ >= 13
/**
* Report the total amount of asset data that can be read from the current position.
*
* Uses a 64-bit number instead of a 32-bit number as AAsset_getRemainingLength does.
*/
off64_t AAsset_getRemainingLength64(AAsset* asset);
+#endif
/**
* Open a new file descriptor that can be used to read the asset data. If the
*/
int AAsset_openFileDescriptor(AAsset* asset, off_t* outStart, off_t* outLength);
+#if __ANDROID_API__ >= 13
/**
* Open a new file descriptor that can be used to read the asset data.
*
* compressed).
*/
int AAsset_openFileDescriptor64(AAsset* asset, off64_t* outStart, off64_t* outLength);
+#endif
/**
* Returns whether this asset's internal buffer is allocated in ordinary RAM (i.e. not
__BEGIN_DECLS
+#if __ANDROID_API__ >= 24
+
struct AChoreographer;
typedef struct AChoreographer AChoreographer;
*/
void AChoreographer_postFrameCallbackDelayed(AChoreographer* choreographer,
AChoreographer_frameCallback callback, void* data, long delayMillis);
+
+#endif /* __ANDROID_API__ >= 24 */
+
__END_DECLS
#endif // ANDROID_CHOREOGRAPHER_H
#ifndef ANDROID_CONFIGURATION_H
#define ANDROID_CONFIGURATION_H
+#include <sys/cdefs.h>
+
#include <android/asset_manager.h>
#ifdef __cplusplus
*/
void AConfiguration_setUiModeNight(AConfiguration* config, int32_t uiModeNight);
+#if __ANDROID_API__ >= 13
/**
* Return the current configuration screen width in dp units, or
* ACONFIGURATION_SCREEN_WIDTH_DP_ANY if not set.
* Set the configuration's smallest screen width in dp units.
*/
void AConfiguration_setSmallestScreenWidthDp(AConfiguration* config, int32_t value);
+#endif /* __ANDROID_API__ >= 13 */
+#if __ANDROID_API__ >= 17
/**
* Return the configuration's layout direction, or
* ACONFIGURATION_LAYOUTDIR_ANY if not set.
* Set the configuration's layout direction.
*/
void AConfiguration_setLayoutDirection(AConfiguration* config, int32_t value);
+#endif /* __ANDROID_API__ >= 17 */
/**
* Perform a diff between two configurations. Returns a bit mask of
#ifndef _ANDROID_INPUT_H
#define _ANDROID_INPUT_H
+#include <sys/cdefs.h>
+
/******************************************************************
*
* IMPORTANT NOTICE:
*/
int32_t AMotionEvent_getMetaState(const AInputEvent* motion_event);
+#if __ANDROID_API__ >= 14
/** Get the button state of all buttons that are pressed. */
int32_t AMotionEvent_getButtonState(const AInputEvent* motion_event);
+#endif
/**
* Get a bitfield indicating which edges, if any, were touched by this motion event.
*/
int32_t AMotionEvent_getPointerId(const AInputEvent* motion_event, size_t pointer_index);
+#if __ANDROID_API__ >= 14
/**
* Get the tool type of a pointer for the given pointer index.
* The tool type indicates the type of tool used to make contact such as a
* finger or stylus, if known.
*/
int32_t AMotionEvent_getToolType(const AInputEvent* motion_event, size_t pointer_index);
+#endif
/**
* Get the original raw X coordinate of this event.
*/
float AMotionEvent_getOrientation(const AInputEvent* motion_event, size_t pointer_index);
+#if __ANDROID_API__ >= 13
/** Get the value of the request axis for the given pointer index. */
float AMotionEvent_getAxisValue(const AInputEvent* motion_event,
int32_t axis, size_t pointer_index);
+#endif
/**
* Get the number of historical points in this event. These are movements that
float AMotionEvent_getHistoricalOrientation(const AInputEvent* motion_event, size_t pointer_index,
size_t history_index);
+#if __ANDROID_API__ >= 13
/**
* Get the historical value of the request axis for the given pointer index
* that occurred between this event and the previous motion event.
*/
float AMotionEvent_getHistoricalAxisValue(const AInputEvent* motion_event,
int32_t axis, size_t pointer_index, size_t history_index);
+#endif
struct AInputQueue;
* on failure with an appropriate errno value set.
*/
+#if __ANDROID_API__ >= 24
/**
* Set the network to be used by the given socket file descriptor.
const char *node, const char *service,
const struct addrinfo *hints, struct addrinfo **res);
+#endif /* __ANDROID_API__ >= 24 */
+
__END_DECLS
#endif // ANDROID_MULTINETWORK_H
#ifndef ANDROID_NATIVE_WINDOW_H
#define ANDROID_NATIVE_WINDOW_H
+#include <sys/cdefs.h>
+
#include <android/rect.h>
#ifdef __cplusplus
#ifndef ANDROID_NATIVE_WINDOW_JNI_H
#define ANDROID_NATIVE_WINDOW_JNI_H
+#include <sys/cdefs.h>
+
#include <android/native_window.h>
#include <jni.h>
*/
ANativeWindow* ANativeWindow_fromSurface(JNIEnv* env, jobject surface);
+#if __ANDROID_API__ >= 13
+/**
+ * Return the ANativeWindow associated with a Java SurfaceTexture object,
+ * for interacting with it through native code. This acquires a reference
+ * on the ANativeWindow that is returned; be sure to use ANativeWindow_release()
+ * when done with it so that it doesn't leak.
+ */
+ANativeWindow* ANativeWindow_fromSurfaceTexture(JNIEnv* env, jobject surfaceTexture);
+#endif
+
#ifdef __cplusplus
};
#endif
*/
ASensor const* ASensorManager_getDefaultSensor(ASensorManager* manager, int type);
+#if __ANDROID_API__ >= 21
/**
* Returns the default sensor with the given type and wakeUp properties or NULL if no sensor
* of this type and wakeUp properties exists.
*/
ASensor const* ASensorManager_getDefaultSensorEx(ASensorManager* manager, int type,
bool wakeUp);
+#endif
/**
* Creates a new sensor event queue and associate it with a looper.
*/
int ASensor_getMinDelay(ASensor const* sensor);
+#if __ANDROID_API__ >= 21
/**
* Returns the maximum size of batches for this sensor. Batches will often be
* smaller, as the hardware fifo might be used for other sensors.
* Returns true if this is a wake up sensor, false otherwise.
*/
bool ASensor_isWakeUpSensor(ASensor const* sensor);
+#endif /* __ANDROID_API__ >= 21 */
#ifdef __cplusplus
};
#define ANDROID_NATIVE_TRACE_H
#include <stdbool.h>
+#include <sys/cdefs.h>
#ifdef __cplusplus
extern "C" {
#endif
+#if __ANDROID_API__ >= 23
+
/**
* Returns true if tracing is enabled. Use this signal to avoid expensive computation only necessary
* when tracing is enabled.
*/
void ATrace_endSection();
+#endif /* __ANDROID_API__ >= 23 */
+
#ifdef __cplusplus
};
#endif
class IBatteryPropertiesListener : public IInterface {
public:
- DECLARE_META_INTERFACE(BatteryPropertiesListener);
+ DECLARE_META_INTERFACE(BatteryPropertiesListener)
virtual void batteryPropertiesChanged(struct BatteryProperties props) = 0;
};
class IBatteryPropertiesRegistrar : public IInterface {
public:
- DECLARE_META_INTERFACE(BatteryPropertiesRegistrar);
+ DECLARE_META_INTERFACE(BatteryPropertiesRegistrar)
virtual void registerListener(const sp<IBatteryPropertiesListener>& listener) = 0;
virtual void unregisterListener(const sp<IBatteryPropertiesListener>& listener) = 0;
class BpRefBase : public virtual RefBase
{
protected:
- BpRefBase(const sp<IBinder>& o);
+ explicit BpRefBase(const sp<IBinder>& o);
virtual ~BpRefBase();
virtual void onFirstRef();
virtual void onLastStrongRef(const void* id);
class IAppOpsCallback : public IInterface
{
public:
- DECLARE_META_INTERFACE(AppOpsCallback);
+ DECLARE_META_INTERFACE(AppOpsCallback)
virtual void opChanged(int32_t op, const String16& packageName) = 0;
class IAppOpsService : public IInterface
{
public:
- DECLARE_META_INTERFACE(AppOpsService);
+ DECLARE_META_INTERFACE(AppOpsService)
virtual int32_t checkOperation(int32_t code, int32_t uid, const String16& packageName) = 0;
virtual int32_t noteOperation(int32_t code, int32_t uid, const String16& packageName) = 0;
class IBatteryStats : public IInterface
{
public:
- DECLARE_META_INTERFACE(BatteryStats);
+ DECLARE_META_INTERFACE(BatteryStats)
virtual void noteStartSensor(int uid, int sensor) = 0;
virtual void noteStopSensor(int uid, int sensor) = 0;
Parcel* reply,
uint32_t flags = 0) = 0;
+ // DeathRecipient is pure abstract, there is no virtual method
+ // implementation to put in a translation unit in order to silence the
+ // weak vtables warning.
+ #if defined(__clang__)
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wweak-vtables"
+ #endif
+
class DeathRecipient : public virtual RefBase
{
public:
virtual void binderDied(const wp<IBinder>& who) = 0;
};
+ #if defined(__clang__)
+ #pragma clang diagnostic pop
+ #endif
+
/**
* Register the @a recipient for a notification if this binder
* goes away. If this binder object unexpectedly goes away
class BpInterface : public INTERFACE, public BpRefBase
{
public:
- BpInterface(const sp<IBinder>& remote);
+ explicit BpInterface(const sp<IBinder>& remote);
protected:
virtual IBinder* onAsBinder();
#define CHECK_INTERFACE(interface, data, reply) \
- if (!data.checkInterface(this)) { return PERMISSION_DENIED; } \
+ if (!(data).checkInterface(this)) { return PERMISSION_DENIED; } \
// ----------------------------------------------------------------------
class IMediaResourceMonitor : public IInterface {
public:
- DECLARE_META_INTERFACE(MediaResourceMonitor);
+ DECLARE_META_INTERFACE(MediaResourceMonitor)
// Values should be in sync with Intent.EXTRA_MEDIA_RESOURCE_TYPE_XXX.
enum {
class IMemoryHeap : public IInterface
{
public:
- DECLARE_META_INTERFACE(MemoryHeap);
+ DECLARE_META_INTERFACE(MemoryHeap)
// flags returned by getFlags()
enum {
class IMemory : public IInterface
{
public:
- DECLARE_META_INTERFACE(Memory);
+ DECLARE_META_INTERFACE(Memory)
virtual sp<IMemoryHeap> getMemory(ssize_t* offset=0, size_t* size=0) const = 0;
class IPermissionController : public IInterface
{
public:
- DECLARE_META_INTERFACE(PermissionController);
+ DECLARE_META_INTERFACE(PermissionController)
virtual bool checkPermission(const String16& permission, int32_t pid, int32_t uid) = 0;
class IProcessInfoService : public IInterface {
public:
- DECLARE_META_INTERFACE(ProcessInfoService);
+ DECLARE_META_INTERFACE(ProcessInfoService)
virtual status_t getProcessStatesFromPids( size_t length,
/*in*/ int32_t* pids,
class IResultReceiver : public IInterface
{
public:
- DECLARE_META_INTERFACE(ResultReceiver);
+ DECLARE_META_INTERFACE(ResultReceiver)
virtual void send(int32_t resultCode) = 0;
class IServiceManager : public IInterface
{
public:
- DECLARE_META_INTERFACE(ServiceManager);
+ DECLARE_META_INTERFACE(ServiceManager)
/**
* Retrieve an existing service, blocking for a few seconds
#include <string>
#include <vector>
+#include <android-base/unique_fd.h>
#include <cutils/native_handle.h>
-#include <nativehelper/ScopedFd.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <utils/String16.h>
#include <utils/Vector.h>
#include <utils/Flattenable.h>
-#include <linux/binder.h>
+#include <linux/android/binder.h>
#include <binder/IInterface.h>
#include <binder/Parcelable.h>
template<typename T>
status_t write(const LightFlattenable<T>& val);
+ template<typename T>
+ status_t writeVectorSize(const std::vector<T>& val);
+ template<typename T>
+ status_t writeVectorSize(const std::unique_ptr<std::vector<T>>& val);
// Place a native_handle into the parcel (the native_handle's file-
// descriptors are dup'ed, so it is safe to delete the native_handle
// semantics of the smart file descriptor. A new descriptor will be
// created, and will be closed when the parcel is destroyed.
status_t writeUniqueFileDescriptor(
- const ScopedFd& fd);
+ const base::unique_fd& fd);
// Place a vector of file desciptors into the parcel. Each descriptor is
// dup'd as in writeDupFileDescriptor
status_t writeUniqueFileDescriptorVector(
- const std::unique_ptr<std::vector<ScopedFd>>& val);
+ const std::unique_ptr<std::vector<base::unique_fd>>& val);
status_t writeUniqueFileDescriptorVector(
- const std::vector<ScopedFd>& val);
+ const std::vector<base::unique_fd>& val);
// Writes a blob to the parcel.
// If the blob is small, then it is stored in-place, otherwise it is
const char* readCString() const;
String8 readString8() const;
+ status_t readString8(String8* pArg) const;
String16 readString16() const;
status_t readString16(String16* pArg) const;
status_t readString16(std::unique_ptr<String16>* pArg) const;
const char16_t* readString16Inplace(size_t* outLen) const;
sp<IBinder> readStrongBinder() const;
status_t readStrongBinder(sp<IBinder>* val) const;
+ status_t readNullableStrongBinder(sp<IBinder>* val) const;
wp<IBinder> readWeakBinder() const;
template<typename T>
template<typename T>
status_t readStrongBinder(sp<T>* val) const;
+ template<typename T>
+ status_t readNullableStrongBinder(sp<T>* val) const;
+
status_t readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const;
status_t readStrongBinderVector(std::vector<sp<IBinder>>* val) const;
template<typename T>
status_t read(LightFlattenable<T>& val) const;
+ template<typename T>
+ status_t resizeOutVector(std::vector<T>* val) const;
+ template<typename T>
+ status_t resizeOutVector(std::unique_ptr<std::vector<T>>* val) const;
+
// Like Parcel.java's readExceptionCode(). Reads the first int32
// off of a Parcel's header, returning 0 or the negative error
// code on exceptions, but also deals with skipping over rich
// Retrieve a smart file descriptor from the parcel.
status_t readUniqueFileDescriptor(
- ScopedFd* val) const;
+ base::unique_fd* val) const;
// Retrieve a vector of smart file descriptors from the parcel.
status_t readUniqueFileDescriptorVector(
- std::unique_ptr<std::vector<ScopedFd>>* val) const;
+ std::unique_ptr<std::vector<base::unique_fd>>* val) const;
status_t readUniqueFileDescriptorVector(
- std::vector<ScopedFd>* val) const;
+ std::vector<base::unique_fd>* val) const;
// Reads a blob from the parcel.
// The caller should call release() on the blob after reading its contents.
void clear();
void release();
inline size_t size() const { return mSize; }
- inline int fd() const { return mFd; };
+ inline int fd() const { return mFd; }
inline bool isMutable() const { return mMutable; }
protected:
bool mMutable;
};
+ #if defined(__clang__)
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wweak-vtables"
+ #endif
+
class FlattenableHelperInterface {
protected:
~FlattenableHelperInterface() { }
virtual status_t unflatten(void const* buffer, size_t size, int const* fds, size_t count) = 0;
};
+ #if defined(__clang__)
+ #pragma clang diagnostic pop
+ #endif
+
template<typename T>
class FlattenableHelper : public FlattenableHelperInterface {
friend class Parcel;
const Flattenable<T>& val;
- explicit FlattenableHelper(const Flattenable<T>& val) : val(val) { }
+ explicit FlattenableHelper(const Flattenable<T>& _val) : val(_val) { }
+ protected:
+ ~FlattenableHelper() = default;
public:
virtual size_t getFlattenedSize() const {
return val.getFlattenedSize();
status_t Parcel::write(const LightFlattenable<T>& val) {
size_t size(val.getFlattenedSize());
if (!val.isFixedSize()) {
- status_t err = writeInt32(size);
+ if (size > INT32_MAX) {
+ return BAD_VALUE;
+ }
+ status_t err = writeInt32(static_cast<int32_t>(size));
if (err != NO_ERROR) {
return err;
}
if (err != NO_ERROR) {
return err;
}
- size = s;
+ size = static_cast<size_t>(s);
}
if (size) {
void const* buffer = readInplace(size);
}
template<typename T>
+status_t Parcel::writeVectorSize(const std::vector<T>& val) {
+ if (val.size() > INT32_MAX) {
+ return BAD_VALUE;
+ }
+ return writeInt32(static_cast<int32_t>(val.size()));
+}
+
+template<typename T>
+status_t Parcel::writeVectorSize(const std::unique_ptr<std::vector<T>>& val) {
+ if (!val) {
+ return writeInt32(-1);
+ }
+
+ return writeVectorSize(*val);
+}
+
+template<typename T>
+status_t Parcel::resizeOutVector(std::vector<T>* val) const {
+ int32_t size;
+ status_t err = readInt32(&size);
+ if (err != NO_ERROR) {
+ return err;
+ }
+
+ if (size < 0) {
+ return UNEXPECTED_NULL;
+ }
+ val->resize(size_t(size));
+ return OK;
+}
+
+template<typename T>
+status_t Parcel::resizeOutVector(std::unique_ptr<std::vector<T>>* val) const {
+ int32_t size;
+ status_t err = readInt32(&size);
+ if (err != NO_ERROR) {
+ return err;
+ }
+
+ val->reset();
+ if (size >= 0) {
+ val->reset(new std::vector<T>(size_t(size)));
+ }
+
+ return OK;
+}
+
+template<typename T>
status_t Parcel::readStrongBinder(sp<T>* val) const {
sp<IBinder> tmp;
status_t ret = readStrongBinder(&tmp);
return ret;
}
+template<typename T>
+status_t Parcel::readNullableStrongBinder(sp<T>* val) const {
+ sp<IBinder> tmp;
+ status_t ret = readNullableStrongBinder(&tmp);
+
+ if (ret == OK) {
+ *val = interface_cast<T>(tmp);
+
+ if (val->get() == nullptr && tmp.get() != nullptr) {
+ ret = UNKNOWN_ERROR;
+ }
+ }
+
+ return ret;
+}
+
template<typename T, typename U>
status_t Parcel::unsafeReadTypedVector(
std::vector<T>* val,
return UNEXPECTED_NULL;
}
- if (val->max_size() < size) {
+ if (val->max_size() < static_cast<size_t>(size)) {
return NO_MEMORY;
}
- val->resize(size);
+ val->resize(static_cast<size_t>(size));
- if (val->size() < size) {
+ if (val->size() < static_cast<size_t>(size)) {
return NO_MEMORY;
}
template<typename T>
status_t Parcel::readNullableTypedVector(std::unique_ptr<std::vector<T>>* val,
status_t(Parcel::*read_func)(T*) const) const {
- const int32_t start = dataPosition();
+ const size_t start = dataPosition();
int32_t size;
status_t status = readInt32(&size);
val->reset();
return BAD_VALUE;
}
- status_t status = this->writeInt32(val.size());
+ status_t status = this->writeInt32(static_cast<int32_t>(val.size()));
if (status != OK) {
return status;
template<typename T>
status_t Parcel::readParcelableVector(std::unique_ptr<std::vector<std::unique_ptr<T>>>* val) const {
- const int32_t start = dataPosition();
+ const size_t start = dataPosition();
int32_t size;
status_t status = readInt32(&size);
val->reset();
template<typename T>
status_t Parcel::readParcelable(std::unique_ptr<T>* parcelable) const {
- const int32_t start = dataPosition();
+ const size_t start = dataPosition();
int32_t present;
status_t status = readInt32(&present);
parcelable->reset();
class Parcel;
+#if defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
// Abstract interface of all parcelables.
class Parcelable {
public:
virtual status_t readFromParcel(const Parcel* parcel) = 0;
}; // class Parcelable
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
} // namespace android
#endif // ANDROID_PARCELABLE_H
#define ANDROID_PERSISTABLE_BUNDLE_H
#include <map>
+#include <set>
#include <vector>
#include <binder/Parcelable.h>
bool getStringVector(const String16& key, std::vector<String16>* out) const;
bool getPersistableBundle(const String16& key, PersistableBundle* out) const;
+ /* Getters for all keys for each value type */
+ std::set<String16> getBooleanKeys() const;
+ std::set<String16> getIntKeys() const;
+ std::set<String16> getLongKeys() const;
+ std::set<String16> getDoubleKeys() const;
+ std::set<String16> getStringKeys() const;
+ std::set<String16> getBooleanVectorKeys() const;
+ std::set<String16> getIntVectorKeys() const;
+ std::set<String16> getLongVectorKeys() const;
+ std::set<String16> getDoubleVectorKeys() const;
+ std::set<String16> getStringVectorKeys() const;
+ std::set<String16> getPersistableBundleKeys() const;
+
friend bool operator==(const PersistableBundle& lhs, const PersistableBundle& rhs) {
return (lhs.mBoolMap == rhs.mBoolMap && lhs.mIntMap == rhs.mIntMap &&
lhs.mLongMap == rhs.mLongMap && lhs.mDoubleMap == rhs.mDoubleMap &&
#define ANDROID_BINDER_STATUS_H
#include <cstdint>
+#include <sstream>
#include <binder/Parcel.h>
#include <utils/String8.h>
// A more readable alias for the default constructor.
static Status ok();
+
// Authors should explicitly pick whether their integer is:
// - an exception code (EX_* above)
// - service specific error code
static Status fromExceptionCode(int32_t exceptionCode);
static Status fromExceptionCode(int32_t exceptionCode,
const String8& message);
+ static Status fromExceptionCode(int32_t exceptionCode,
+ const char* message);
+
static Status fromServiceSpecificError(int32_t serviceSpecificErrorCode);
static Status fromServiceSpecificError(int32_t serviceSpecificErrorCode,
const String8& message);
+ static Status fromServiceSpecificError(int32_t serviceSpecificErrorCode,
+ const char* message);
+
static Status fromStatusT(status_t status);
Status() = default;
}; // class Status
// For gtest output logging
-template<typename T>
-T& operator<< (T& stream, const Status& s) {
- stream << s.toString8().string();
- return stream;
-}
+std::stringstream& operator<< (std::stringstream& stream, const Status& s);
} // namespace binder
} // namespace android
#define ANDROID_TEXTOUTPUT_H
#include <utils/Errors.h>
+#include <utils/String8.h>
#include <stdint.h>
#include <string.h>
+#include <sstream>
// ---------------------------------------------------------------------------
namespace android {
-class String8;
-class String16;
-
class TextOutput
{
public:
TextOutput& indent(TextOutput& to);
TextOutput& dedent(TextOutput& to);
-TextOutput& operator<<(TextOutput& to, const char* str);
-TextOutput& operator<<(TextOutput& to, char); // writes raw character
-TextOutput& operator<<(TextOutput& to, bool);
-TextOutput& operator<<(TextOutput& to, int);
-TextOutput& operator<<(TextOutput& to, long);
-TextOutput& operator<<(TextOutput& to, unsigned int);
-TextOutput& operator<<(TextOutput& to, unsigned long);
-TextOutput& operator<<(TextOutput& to, long long);
-TextOutput& operator<<(TextOutput& to, unsigned long long);
-TextOutput& operator<<(TextOutput& to, float);
-TextOutput& operator<<(TextOutput& to, double);
+template<typename T>
+TextOutput& operator<<(TextOutput& to, const T& val)
+{
+ std::stringstream strbuf;
+ strbuf << val;
+ std::string str = strbuf.str();
+ to.print(str.c_str(), str.size());
+ return to;
+}
+
TextOutput& operator<<(TextOutput& to, TextOutputManipFunc func);
-TextOutput& operator<<(TextOutput& to, const void*);
-TextOutput& operator<<(TextOutput& to, const String8& val);
-TextOutput& operator<<(TextOutput& to, const String16& val);
-class TypeCode
+class TypeCode
{
public:
inline TypeCode(uint32_t code);
inline ~TypeCode();
inline uint32_t typeCode() const;
-
+
private:
uint32_t mCode;
};
};
TextOutput& operator<<(TextOutput& to, const HexDump& val);
+inline TextOutput& operator<<(TextOutput& to,
+ decltype(std::endl<char,
+ std::char_traits<char>>)
+ /*val*/) {
+ endl(to);
+ return to;
+}
-// ---------------------------------------------------------------------------
-// No user servicable parts below.
+inline TextOutput& operator<<(TextOutput& to, const char &c)
+{
+ to.print(&c, 1);
+ return to;
+}
-inline TextOutput& endl(TextOutput& to)
+inline TextOutput& operator<<(TextOutput& to, const bool &val)
{
- to.print("\n", 1);
+ if (val) to.print("true", 4);
+ else to.print("false", 5);
return to;
}
-inline TextOutput& indent(TextOutput& to)
+inline TextOutput& operator<<(TextOutput& to, const String16& val)
{
- to.moveIndent(1);
+ to << String8(val).string();
return to;
}
-inline TextOutput& dedent(TextOutput& to)
+// ---------------------------------------------------------------------------
+// No user servicable parts below.
+
+inline TextOutput& endl(TextOutput& to)
{
- to.moveIndent(-1);
+ to.print("\n", 1);
return to;
}
-inline TextOutput& operator<<(TextOutput& to, const char* str)
+inline TextOutput& indent(TextOutput& to)
{
- to.print(str, strlen(str));
+ to.moveIndent(1);
return to;
}
-inline TextOutput& operator<<(TextOutput& to, char c)
+inline TextOutput& dedent(TextOutput& to)
{
- to.print(&c, 1);
+ to.moveIndent(-1);
return to;
}
enum { INVALID_BUFFER_SLOT = -1 };
BufferItem();
~BufferItem();
+ BufferItem(const BufferItem&) = default;
+ BufferItem& operator=(const BufferItem&) = default;
static const char* scalingModeName(uint32_t scalingMode);
// to set by queueBuffer each time this slot is queued. This value
// is guaranteed to be monotonically increasing for each newly
// acquired buffer.
- union {
- int64_t mTimestamp;
- struct {
- uint32_t mTimestampLo;
- uint32_t mTimestampHi;
- };
- };
+ int64_t mTimestamp;
// mIsAutoTimestamp indicates whether mTimestamp was generated
// automatically when the buffer was queued.
android_dataspace mDataSpace;
// mFrameNumber is the number of the queued frame for this slot.
- union {
- uint64_t mFrameNumber;
- struct {
- uint32_t mFrameNumberLo;
- uint32_t mFrameNumberHi;
- };
- };
+ uint64_t mFrameNumber;
// mSlot is the slot index of this buffer (default INVALID_BUFFER_SLOT).
int mSlot;
// weak references.
class ProxyConsumerListener : public BnConsumerListener {
public:
- ProxyConsumerListener(const wp<ConsumerListener>& consumerListener);
+ explicit ProxyConsumerListener(const wp<ConsumerListener>& consumerListener);
virtual ~ProxyConsumerListener();
virtual void onFrameAvailable(const BufferItem& item) override;
virtual void onFrameReplaced(const BufferItem& item) override;
virtual status_t discardFreeBuffers() override;
// dump our state in a String
- virtual void dump(String8& result, const char* prefix) const;
+ virtual void dumpState(String8& result, const char* prefix) const;
// Functions required for backwards compatibility.
// These will be modified/renamed in IGraphicBufferConsumer and will be
private:
// Dump our state in a string
- void dump(String8& result, const char* prefix) const;
+ void dumpState(String8& result, const char* prefix) const;
// getMinUndequeuedBufferCountLocked returns the minimum number of buffers
// that must remain in a state other than DEQUEUED. The async parameter
// Cached data about the shared buffer in shared buffer mode
struct SharedBufferCache {
- SharedBufferCache(Rect _crop, uint32_t _transform, int _scalingMode,
- android_dataspace _dataspace)
+ SharedBufferCache(Rect _crop, uint32_t _transform,
+ uint32_t _scalingMode, android_dataspace _dataspace)
: crop(_crop),
transform(_transform),
scalingMode(_scalingMode),
dataspace(_dataspace) {
- };
+ }
Rect crop;
uint32_t transform;
namespace android {
-class BufferSlot;
+struct BufferSlot;
class BufferQueueProducer : public BnGraphicBufferProducer,
private IBinder::DeathRecipient {
// log messages.
void setName(const String8& name);
- // dump writes the current state to a string. Child classes should add
+ // dumpState writes the current state to a string. Child classes should add
// their state to the dump by overriding the dumpLocked method, which is
// called by these methods after locking the mutex.
- void dump(String8& result) const;
- void dump(String8& result, const char* prefix) const;
+ void dumpState(String8& result) const;
+ void dumpState(String8& result, const char* prefix) const;
// setFrameAvailableListener sets the listener object that will be notified
// when a new frame becomes available.
// buffers from the given IGraphicBufferConsumer.
// The controlledByApp flag indicates that this consumer is under the application's
// control.
- ConsumerBase(const sp<IGraphicBufferConsumer>& consumer, bool controlledByApp = false);
+ explicit ConsumerBase(const sp<IGraphicBufferConsumer>& consumer, bool controlledByApp = false);
// onLastStrongRef gets called by RefBase just before the dtor of the most
// derived class. It is used to clean up the buffers so that ConsumerBase
class BitTube;
class IDisplayEventConnection;
-// ----------------------------------------------------------------------------
+static inline constexpr uint32_t fourcc(char c1, char c2, char c3, char c4) {
+ return static_cast<uint32_t>(c1) << 24 |
+ static_cast<uint32_t>(c2) << 16 |
+ static_cast<uint32_t>(c3) << 8 |
+ static_cast<uint32_t>(c4);
+}
+// ----------------------------------------------------------------------------
class DisplayEventReceiver {
public:
enum {
- DISPLAY_EVENT_VSYNC = 'vsyn',
- DISPLAY_EVENT_HOTPLUG = 'plug'
+ DISPLAY_EVENT_VSYNC = fourcc('v', 's', 'y', 'n'),
+ DISPLAY_EVENT_HOTPLUG = fourcc('p', 'l', 'u', 'g'),
};
struct Event {
class ConsumerListener : public virtual RefBase {
public:
ConsumerListener() { }
- virtual ~ConsumerListener() { }
+ virtual ~ConsumerListener();
// onFrameAvailable is called from queueBuffer each time an additional
// frame becomes available for consumption. This means that frames that
class IConsumerListener : public ConsumerListener, public IInterface
{
public:
- DECLARE_META_INTERFACE(ConsumerListener);
+ DECLARE_META_INTERFACE(ConsumerListener)
};
// ----------------------------------------------------------------------------
{
public:
- DECLARE_META_INTERFACE(DisplayEventConnection);
+ DECLARE_META_INTERFACE(DisplayEventConnection)
/*
* getDataChannel() returns a BitTube where to receive the events from
class IGraphicBufferAlloc : public IInterface
{
public:
- DECLARE_META_INTERFACE(GraphicBufferAlloc);
+ DECLARE_META_INTERFACE(GraphicBufferAlloc)
/* Create a new GraphicBuffer for the client to use.
*/
virtual status_t discardFreeBuffers() = 0;
// dump state into a string
- virtual void dump(String8& result, const char* prefix) const = 0;
+ virtual void dumpState(String8& result, const char* prefix) const = 0;
public:
- DECLARE_META_INTERFACE(GraphicBufferConsumer);
+ DECLARE_META_INTERFACE(GraphicBufferConsumer)
};
// ----------------------------------------------------------------------------
class IGraphicBufferProducer : public IInterface
{
public:
- DECLARE_META_INTERFACE(GraphicBufferProducer);
+ DECLARE_META_INTERFACE(GraphicBufferProducer)
enum {
// A flag returned by dequeueBuffer when the client needs to call
struct QueueBufferInput : public Flattenable<QueueBufferInput> {
friend class Flattenable<QueueBufferInput>;
- inline QueueBufferInput(const Parcel& parcel);
+ explicit inline QueueBufferInput(const Parcel& parcel);
// timestamp - a monotonically increasing value in nanoseconds
// isAutoTimestamp - if the timestamp was synthesized at queue time
// dataSpace - description of the contents, interpretation depends on format
// set this to Fence::NO_FENCE if the buffer is ready immediately
// sticky - the sticky transform set in Surface (only used by the LEGACY
// camera mode).
- inline QueueBufferInput(int64_t timestamp, bool isAutoTimestamp,
- android_dataspace dataSpace, const Rect& crop, int scalingMode,
- uint32_t transform, const sp<Fence>& fence, uint32_t sticky = 0)
- : timestamp(timestamp), isAutoTimestamp(isAutoTimestamp),
- dataSpace(dataSpace), crop(crop), scalingMode(scalingMode),
- transform(transform), stickyTransform(sticky), fence(fence),
+ inline QueueBufferInput(int64_t _timestamp, bool _isAutoTimestamp,
+ android_dataspace _dataSpace, const Rect& _crop,
+ int _scalingMode, uint32_t _transform, const sp<Fence>& _fence,
+ uint32_t _sticky = 0)
+ : timestamp(_timestamp), isAutoTimestamp(_isAutoTimestamp),
+ dataSpace(_dataSpace), crop(_crop), scalingMode(_scalingMode),
+ transform(_transform), stickyTransform(_sticky), fence(_fence),
surfaceDamage() { }
inline void deflate(int64_t* outTimestamp, bool* outIsAutoTimestamp,
android_dataspace* outDataSpace,
};
// QueueBufferOutput must be a POD structure
- struct __attribute__ ((__packed__)) QueueBufferOutput {
+ struct QueueBufferOutput {
inline QueueBufferOutput() { }
// outWidth - filled with default width applied to the buffer
// outHeight - filled with default height applied to the buffer
{
public:
ProducerListener() {}
- virtual ~ProducerListener() {}
+ virtual ~ProducerListener();
// onBufferReleased is called from IGraphicBufferConsumer::releaseBuffer to
// notify the producer that a new buffer is free and ready to be dequeued.
class DummyProducerListener : public BnProducerListener
{
public:
+ virtual ~DummyProducerListener();
virtual void onBufferReleased() {}
virtual bool needsReleaseNotify() { return false; }
};
class ISensorEventConnection : public IInterface
{
public:
- DECLARE_META_INTERFACE(SensorEventConnection);
+ DECLARE_META_INTERFACE(SensorEventConnection)
virtual sp<BitTube> getSensorChannel() const = 0;
virtual status_t enableDisable(int handle, bool enabled, nsecs_t samplingPeriodNs,
class ISensorServer : public IInterface
{
public:
- DECLARE_META_INTERFACE(SensorServer);
+ DECLARE_META_INTERFACE(SensorServer)
virtual Vector<Sensor> getSensorList(const String16& opPackageName) = 0;
virtual Vector<Sensor> getDynamicSensorList(const String16& opPackageName) = 0;
namespace android {
// ----------------------------------------------------------------------------
-class ComposerState;
-class DisplayState;
+struct ComposerState;
+struct DisplayState;
struct DisplayInfo;
struct DisplayStatInfo;
class HdrCapabilities;
*/
class ISurfaceComposer: public IInterface {
public:
- DECLARE_META_INTERFACE(SurfaceComposer);
+ DECLARE_META_INTERFACE(SurfaceComposer)
// flags for setTransactionState()
enum {
class ISurfaceComposerClient : public IInterface
{
public:
- DECLARE_META_INTERFACE(SurfaceComposerClient);
+ DECLARE_META_INTERFACE(SurfaceComposerClient)
// flags for createSurface()
enum { // (keep in sync with Surface.java)
occupancyAverage(0.0f),
usedThirdBuffer(false) {}
- Segment(nsecs_t totalTime, size_t numFrames, float occupancyAverage,
- bool usedThirdBuffer)
- : totalTime(totalTime),
- numFrames(numFrames),
- occupancyAverage(occupancyAverage),
- usedThirdBuffer(usedThirdBuffer) {}
+ Segment(nsecs_t _totalTime, size_t _numFrames, float _occupancyAverage,
+ bool _usedThirdBuffer)
+ : totalTime(_totalTime),
+ numFrames(_numFrames),
+ occupancyAverage(_occupancyAverage),
+ usedThirdBuffer(_usedThirdBuffer) {}
// Parcelable interface
virtual status_t writeToParcel(Parcel* parcel) const override;
uuid_t() : b{0} {}
};
+ Sensor(const Sensor&) = default;
+ Sensor& operator=(const Sensor&) = default;
+
Sensor(const char * name = "");
Sensor(struct sensor_t const* hwSensor, int halVersion = 0);
Sensor(struct sensor_t const& hwSensor, const uuid_t& uuid, int halVersion = 0);
* the controlledByApp flag indicates that this Surface (producer) is
* controlled by the application. This flag is used at connect time.
*/
- Surface(const sp<IGraphicBufferProducer>& bufferProducer, bool controlledByApp = false);
+ explicit Surface(const sp<IGraphicBufferProducer>& bufferProducer, bool controlledByApp = false);
/* getIGraphicBufferProducer() returns the IGraphicBufferProducer this
* Surface was created with. Usually it's an error to use the
// ---------------------------------------------------------------------------
-class DisplayInfo;
+struct DisplayInfo;
class Composer;
class HdrCapabilities;
class ISurfaceComposerClient;
*/
class IInputFlinger : public IInterface {
public:
- DECLARE_META_INTERFACE(InputFlinger);
+ DECLARE_META_INTERFACE(InputFlinger)
};
inline int32_t getButtonState() const { return mButtonState; }
- inline int32_t setButtonState(int32_t buttonState) { mButtonState = buttonState; }
+ inline void setButtonState(int32_t buttonState) { mButtonState = buttonState; }
inline int32_t getActionButton() const { return mActionButton; }
return NULL;
}
-static int32_t getKeyCodeByLabel(const char* label) {
+static inline int32_t getKeyCodeByLabel(const char* label) {
return int32_t(lookupValueByLabel(label, KEYCODES));
}
-static const char* getLabelByKeyCode(int32_t keyCode) {
- if (keyCode >= 0 && keyCode < size(KEYCODES)) {
+static inline const char* getLabelByKeyCode(int32_t keyCode) {
+ if (keyCode >= 0 && keyCode < static_cast<int32_t>(size(KEYCODES))) {
return KEYCODES[keyCode].literal;
}
return NULL;
}
-static uint32_t getKeyFlagByLabel(const char* label) {
+static inline uint32_t getKeyFlagByLabel(const char* label) {
return uint32_t(lookupValueByLabel(label, FLAGS));
}
-static int32_t getAxisByLabel(const char* label) {
+static inline int32_t getAxisByLabel(const char* label) {
return int32_t(lookupValueByLabel(label, AXES));
}
-static const char* getAxisLabel(int32_t axisId) {
+static inline const char* getAxisLabel(int32_t axisId) {
return lookupLabelByValue(axisId, AXES);
}
-static int32_t getLedByLabel(const char* label) {
+static inline int32_t getLedByLabel(const char* label) {
return int32_t(lookupValueByLabel(label, LEDS));
}
// output: fill out the MediaImage fields
MediaImage sMediaImage;
- DescribeColorFormatParams(const DescribeColorFormat2Params&); // for internal use only
+ explicit DescribeColorFormatParams(const DescribeColorFormat2Params&); // for internal use only
};
// A pointer to this struct is passed to OMX_GetParameter when the extension
pComponentVersion, \
pSpecVersion, \
pComponentUUID) \
- ((OMX_COMPONENTTYPE*)hComponent)->GetComponentVersion( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->GetComponentVersion(\
hComponent, \
pComponentName, \
pComponentVersion, \
Cmd, \
nParam, \
pCmdData) \
- ((OMX_COMPONENTTYPE*)hComponent)->SendCommand( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->SendCommand( \
hComponent, \
Cmd, \
nParam, \
#define OMX_GetParameter( \
hComponent, \
nParamIndex, \
- pComponentParameterStructure) \
- ((OMX_COMPONENTTYPE*)hComponent)->GetParameter( \
+ pComponentParameterStructure) \
+ ((OMX_COMPONENTTYPE*)(hComponent))->GetParameter( \
hComponent, \
nParamIndex, \
pComponentParameterStructure) /* Macro End */
#define OMX_SetParameter( \
hComponent, \
nParamIndex, \
- pComponentParameterStructure) \
- ((OMX_COMPONENTTYPE*)hComponent)->SetParameter( \
+ pComponentParameterStructure) \
+ ((OMX_COMPONENTTYPE*)(hComponent))->SetParameter( \
hComponent, \
nParamIndex, \
pComponentParameterStructure) /* Macro End */
#define OMX_GetConfig( \
hComponent, \
nConfigIndex, \
- pComponentConfigStructure) \
- ((OMX_COMPONENTTYPE*)hComponent)->GetConfig( \
+ pComponentConfigStructure) \
+ ((OMX_COMPONENTTYPE*)(hComponent))->GetConfig( \
hComponent, \
nConfigIndex, \
pComponentConfigStructure) /* Macro End */
#define OMX_SetConfig( \
hComponent, \
nConfigIndex, \
- pComponentConfigStructure) \
- ((OMX_COMPONENTTYPE*)hComponent)->SetConfig( \
+ pComponentConfigStructure) \
+ ((OMX_COMPONENTTYPE*)(hComponent))->SetConfig( \
hComponent, \
nConfigIndex, \
pComponentConfigStructure) /* Macro End */
hComponent, \
cParameterName, \
pIndexType) \
- ((OMX_COMPONENTTYPE*)hComponent)->GetExtensionIndex( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->GetExtensionIndex( \
hComponent, \
cParameterName, \
pIndexType) /* Macro End */
#define OMX_GetState( \
hComponent, \
pState) \
- ((OMX_COMPONENTTYPE*)hComponent)->GetState( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->GetState( \
hComponent, \
pState) /* Macro End */
pAppPrivate, \
nSizeBytes, \
pBuffer) \
- ((OMX_COMPONENTTYPE*)hComponent)->UseBuffer( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->UseBuffer( \
hComponent, \
ppBufferHdr, \
nPortIndex, \
nPortIndex, \
pAppPrivate, \
nSizeBytes) \
- ((OMX_COMPONENTTYPE*)hComponent)->AllocateBuffer( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->AllocateBuffer( \
hComponent, \
ppBuffer, \
nPortIndex, \
hComponent, \
nPortIndex, \
pBuffer) \
- ((OMX_COMPONENTTYPE*)hComponent)->FreeBuffer( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->FreeBuffer( \
hComponent, \
nPortIndex, \
pBuffer) /* Macro End */
#define OMX_EmptyThisBuffer( \
hComponent, \
pBuffer) \
- ((OMX_COMPONENTTYPE*)hComponent)->EmptyThisBuffer( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->EmptyThisBuffer( \
hComponent, \
pBuffer) /* Macro End */
#define OMX_FillThisBuffer( \
hComponent, \
pBuffer) \
- ((OMX_COMPONENTTYPE*)hComponent)->FillThisBuffer( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->FillThisBuffer( \
hComponent, \
pBuffer) /* Macro End */
nPortIndex, \
pAppPrivate, \
eglImage) \
- ((OMX_COMPONENTTYPE*)hComponent)->UseEGLImage( \
+ ((OMX_COMPONENTTYPE*)(hComponent))->UseEGLImage( \
hComponent, \
ppBufferHdr, \
nPortIndex, \
CRASH = IBinder::FIRST_CALL_TRANSACTION + 16,
};
- DECLARE_META_INTERFACE(PowerManager);
+ DECLARE_META_INTERFACE(PowerManager)
// The parcels created by these methods must be kept in sync with the
// corresponding methods from IPowerManager.aidl.
/* obtain structures and constants from the kernel header */
#include <sys/ioctl.h>
-#include <linux/binder.h>
+#include <linux/android/binder.h>
#ifdef __cplusplus
} // namespace android
TYPE dy;
inline region(const region& rhs)
: rects(rhs.rects), count(rhs.count), dx(rhs.dx), dy(rhs.dy) { }
- inline region(RECT const* r, size_t c)
- : rects(r), count(c), dx(), dy() { }
- inline region(RECT const* r, size_t c, TYPE dx, TYPE dy)
- : rects(r), count(c), dx(dx), dy(dy) { }
+ inline region(RECT const* _r, size_t _c)
+ : rects(_r), count(_c), dx(), dy() { }
+ inline region(RECT const* _r, size_t _c, TYPE _dx, TYPE _dy)
+ : rects(_r), count(_c), dx(_dx), dy(_dy) { }
};
class region_rasterizer {
friend class region_operator;
virtual void operator()(const RECT& rect) = 0;
public:
- virtual ~region_rasterizer() { };
+ virtual ~region_rasterizer() { }
};
- inline region_operator(int op, const region& lhs, const region& rhs)
+ inline region_operator(uint32_t op, const region& lhs, const region& rhs)
: op_mask(op), spanner(lhs, rhs)
{
}
spannerInner.prepare(inside);
do {
TYPE left, right;
- int inside = spannerInner.next(current.left, current.right);
- if ((op_mask >> inside) & 1) {
+ int inner_inside = spannerInner.next(current.left, current.right);
+ if ((op_mask >> inner_inside) & 1) {
if (current.left < current.right &&
current.top < current.bottom) {
rasterizer(current);
region rhs;
public:
- inline Spanner(const region& lhs, const region& rhs)
- : lhs(lhs), rhs(rhs)
+ inline Spanner(const region& _lhs, const region& _rhs)
+ : lhs(_lhs), rhs(_rhs)
{
if (lhs.count) {
SpannerBase::lhs_head = lhs.rects->top + lhs.dy;
region rhs;
public:
- inline SpannerInner(const region& lhs, const region& rhs)
- : lhs(lhs), rhs(rhs)
+ inline SpannerInner(const region& _lhs, const region& _rhs)
+ : lhs(_lhs), rhs(_rhs)
{
}
// Construct a new Fence object to manage a given fence file descriptor.
// When the new Fence object is destructed the file descriptor will be
// closed.
- Fence(int fenceFd);
+ explicit Fence(int fenceFd);
// Check whether the Fence has an open fence file descriptor. Most Fence
// methods treat an invalid file descriptor just like a valid fence that
class FrameStats : public LightFlattenable<FrameStats> {
public:
- FrameStats() : refreshPeriodNano(0) {};
+ FrameStats() : refreshPeriodNano(0) {}
/*
* Approximate refresh time, in nanoseconds.
uint32_t* outCount,
int32_t* /*gralloc1_capability_t*/ outCapabilities) {
getAdapter(device)->doGetCapabilities(outCount, outCapabilities);
- };
+ }
// getFunction
// Buffer descriptor lifecycle functions
- class Descriptor;
+ struct Descriptor;
gralloc1_error_t createDescriptor(
gralloc1_buffer_descriptor_t* outDescriptor);
// Buffer descriptor modification functions
struct Descriptor : public std::enable_shared_from_this<Descriptor> {
- Descriptor(Gralloc1On0Adapter* adapter,
- gralloc1_buffer_descriptor_t id)
- : adapter(adapter),
- id(id),
+ Descriptor(Gralloc1On0Adapter* _adapter,
+ gralloc1_buffer_descriptor_t _id)
+ : adapter(_adapter),
+ id(_id),
width(0),
height(0),
format(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
if (!outData) {
const auto producerCpuUsage = GRALLOC1_PRODUCER_USAGE_CPU_READ |
GRALLOC1_PRODUCER_USAGE_CPU_WRITE;
- if (producerUsage & producerCpuUsage != 0) {
+ if ((producerUsage & producerCpuUsage) != 0) {
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
}
- if (consumerUsage & GRALLOC1_CONSUMER_USAGE_CPU_READ != 0) {
+ if ((consumerUsage & GRALLOC1_CONSUMER_USAGE_CPU_READ) != 0) {
return static_cast<int32_t>(GRALLOC1_ERROR_BAD_VALUE);
}
}
// Default constructor doesn't initialize the Point
inline Point() {
}
- inline Point(int x, int y) : x(x), y(y) {
+ inline Point(int _x, int _y) : x(_x), y(_y) {
}
inline bool operator == (const Point& rhs) const {
class rasterizer;
friend class rasterizer;
- Region& operationSelf(const Rect& r, int op);
- Region& operationSelf(const Region& r, int op);
- Region& operationSelf(const Region& r, int dx, int dy, int op);
- const Region operation(const Rect& rhs, int op) const;
- const Region operation(const Region& rhs, int op) const;
- const Region operation(const Region& rhs, int dx, int dy, int op) const;
-
- static void boolean_operation(int op, Region& dst,
+ Region& operationSelf(const Rect& r, uint32_t op);
+ Region& operationSelf(const Region& r, uint32_t op);
+ Region& operationSelf(const Region& r, int dx, int dy, uint32_t op);
+ const Region operation(const Rect& rhs, uint32_t op) const;
+ const Region operation(const Region& rhs, uint32_t op) const;
+ const Region operation(const Region& rhs, int dx, int dy, uint32_t op) const;
+
+ static void boolean_operation(uint32_t op, Region& dst,
const Region& lhs, const Region& rhs, int dx, int dy);
- static void boolean_operation(int op, Region& dst,
+ static void boolean_operation(uint32_t op, Region& dst,
const Region& lhs, const Rect& rhs, int dx, int dy);
- static void boolean_operation(int op, Region& dst,
+ static void boolean_operation(uint32_t op, Region& dst,
const Region& lhs, const Region& rhs);
- static void boolean_operation(int op, Region& dst,
+ static void boolean_operation(uint32_t op, Region& dst,
const Region& lhs, const Rect& rhs);
static void translate(Region& reg, int dx, int dy);
--- /dev/null
+// Copyright (C) 2009 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 {
+ name: "libbinder",
+
+ srcs: [
+ "AppOpsManager.cpp",
+ "Binder.cpp",
+ "BpBinder.cpp",
+ "BufferedTextOutput.cpp",
+ "Debug.cpp",
+ "IAppOpsCallback.cpp",
+ "IAppOpsService.cpp",
+ "IBatteryStats.cpp",
+ "IInterface.cpp",
+ "IMediaResourceMonitor.cpp",
+ "IMemory.cpp",
+ "IPCThreadState.cpp",
+ "IPermissionController.cpp",
+ "IProcessInfoService.cpp",
+ "IResultReceiver.cpp",
+ "IServiceManager.cpp",
+ "MemoryBase.cpp",
+ "MemoryDealer.cpp",
+ "MemoryHeapBase.cpp",
+ "Parcel.cpp",
+ "PermissionCache.cpp",
+ "PersistableBundle.cpp",
+ "ProcessInfoService.cpp",
+ "ProcessState.cpp",
+ "Static.cpp",
+ "Status.cpp",
+ "TextOutput.cpp",
+ ],
+
+ cflags: [
+ "-Wall",
+ "-Wextra",
+ "-Werror",
+ ],
+ product_variables: {
+ binder32bit: {
+ cflags: ["-DBINDER_IPC_32BIT=1"],
+ },
+ },
+
+ shared_libs: [
+ "libbase",
+ "liblog",
+ "libcutils",
+ "libutils",
+ ],
+ export_shared_lib_headers: [
+ "libbase",
+ "libutils",
+ ],
+
+ clang: true,
+ sanitize: {
+ misc_undefined: ["integer"],
+ },
+}
+
+subdirs = ["tests"]
+++ /dev/null
-# Copyright (C) 2009 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.
-
-# we have the common sources, plus some device-specific stuff
-sources := \
- AppOpsManager.cpp \
- Binder.cpp \
- BpBinder.cpp \
- BufferedTextOutput.cpp \
- Debug.cpp \
- IAppOpsCallback.cpp \
- IAppOpsService.cpp \
- IBatteryStats.cpp \
- IInterface.cpp \
- IMediaResourceMonitor.cpp \
- IMemory.cpp \
- IPCThreadState.cpp \
- IPermissionController.cpp \
- IProcessInfoService.cpp \
- IResultReceiver.cpp \
- IServiceManager.cpp \
- MemoryBase.cpp \
- MemoryDealer.cpp \
- MemoryHeapBase.cpp \
- Parcel.cpp \
- PermissionCache.cpp \
- PersistableBundle.cpp \
- ProcessInfoService.cpp \
- ProcessState.cpp \
- Static.cpp \
- Status.cpp \
- TextOutput.cpp \
-
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := libbinder
-LOCAL_SHARED_LIBRARIES := liblog libcutils libutils
-
-LOCAL_CLANG := true
-LOCAL_SANITIZE := integer
-LOCAL_SRC_FILES := $(sources)
-ifneq ($(TARGET_USES_64_BIT_BINDER),true)
-ifneq ($(TARGET_IS_64_BIT),true)
-LOCAL_CFLAGS += -DBINDER_IPC_32BIT=1
-endif
-endif
-LOCAL_CFLAGS += -Werror
-include $(BUILD_SHARED_LIBRARY)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := libbinder
-LOCAL_STATIC_LIBRARIES += libutils
-LOCAL_SRC_FILES := $(sources)
-ifneq ($(TARGET_USES_64_BIT_BINDER),true)
-ifneq ($(TARGET_IS_64_BIT),true)
-LOCAL_CFLAGS += -DBINDER_IPC_32BIT=1
-endif
-endif
-LOCAL_CFLAGS += -Werror
-include $(BUILD_STATIC_LIBRARY)
* limitations under the License.
*/
+#include <mutex>
#include <binder/AppOpsManager.h>
#include <binder/Binder.h>
#include <binder/IServiceManager.h>
namespace android {
+namespace {
+
+#if defined(__BRILLO__)
+// Because Brillo has no application model, security policy is managed
+// statically (at build time) with SELinux controls.
+// As a consequence, it also never runs the AppOpsManager service.
+const int APP_OPS_MANAGER_UNAVAILABLE_MODE = AppOpsManager::MODE_ALLOWED;
+#else
+const int APP_OPS_MANAGER_UNAVAILABLE_MODE = AppOpsManager::MODE_IGNORED;
+#endif // defined(__BRILLO__)
+
+} // namespace
+
static String16 _appops("appops");
static pthread_mutex_t gTokenMutex = PTHREAD_MUTEX_INITIALIZER;
static sp<IBinder> gToken;
{
}
+#if defined(__BRILLO__)
+// There is no AppOpsService on Brillo
+sp<IAppOpsService> AppOpsManager::getService() { return NULL; }
+#else
sp<IAppOpsService> AppOpsManager::getService()
{
+
+ std::lock_guard<Mutex> scoped_lock(mLock);
int64_t startTime = 0;
- mLock.lock();
sp<IAppOpsService> service = mService;
while (service == NULL || !IInterface::asBinder(service)->isBinderAlive()) {
sp<IBinder> binder = defaultServiceManager()->checkService(_appops);
ALOGI("Waiting for app ops service");
} else if ((uptimeMillis()-startTime) > 10000) {
ALOGW("Waiting too long for app ops service, giving up");
- return NULL;
+ service = NULL;
+ break;
}
sleep(1);
} else {
mService = service;
}
}
- mLock.unlock();
return service;
}
+#endif // defined(__BRILLO__)
int32_t AppOpsManager::checkOp(int32_t op, int32_t uid, const String16& callingPackage)
{
sp<IAppOpsService> service = getService();
- return service != NULL ? service->checkOperation(op, uid, callingPackage) : MODE_IGNORED;
+ return service != NULL
+ ? service->checkOperation(op, uid, callingPackage)
+ : APP_OPS_MANAGER_UNAVAILABLE_MODE;
}
int32_t AppOpsManager::noteOp(int32_t op, int32_t uid, const String16& callingPackage) {
sp<IAppOpsService> service = getService();
- return service != NULL ? service->noteOperation(op, uid, callingPackage) : MODE_IGNORED;
+ return service != NULL
+ ? service->noteOperation(op, uid, callingPackage)
+ : APP_OPS_MANAGER_UNAVAILABLE_MODE;
}
int32_t AppOpsManager::startOp(int32_t op, int32_t uid, const String16& callingPackage) {
sp<IAppOpsService> service = getService();
- return service != NULL ? service->startOperation(getToken(service), op, uid, callingPackage)
- : MODE_IGNORED;
+ return service != NULL
+ ? service->startOperation(getToken(service), op, uid, callingPackage)
+ : APP_OPS_MANAGER_UNAVAILABLE_MODE;
}
void AppOpsManager::finishOp(int32_t op, int32_t uid, const String16& callingPackage) {
// XXX can't add virtuals until binaries are updated.
//return shellCommand(in, out, err, args, resultReceiver);
+ (void)in;
+ (void)out;
+ (void)err;
+
if (resultReceiver != NULL) {
resultReceiver->send(INVALID_OPERATION);
}
struct BufferedTextOutput::BufferState : public RefBase
{
- BufferState(int32_t _seq)
+ explicit BufferState(int32_t _seq)
: seq(_seq)
, buffer(NULL)
, bufferPos(0)
class BpAppOpsCallback : public BpInterface<IAppOpsCallback>
{
public:
- BpAppOpsCallback(const sp<IBinder>& impl)
+ explicit BpAppOpsCallback(const sp<IBinder>& impl)
: BpInterface<IAppOpsCallback>(impl)
{
}
class BpAppOpsService : public BpInterface<IAppOpsService>
{
public:
- BpAppOpsService(const sp<IBinder>& impl)
+ explicit BpAppOpsService(const sp<IBinder>& impl)
: BpInterface<IAppOpsService>(impl)
{
}
class BpBatteryStats : public BpInterface<IBatteryStats>
{
public:
- BpBatteryStats(const sp<IBinder>& impl)
+ explicit BpBatteryStats(const sp<IBinder>& impl)
: BpInterface<IBatteryStats>(impl)
{
}
#define LOG_TAG "IMemory"
+#include <atomic>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <cutils/log.h>
#include <utils/KeyedVector.h>
#include <utils/threads.h>
-#include <utils/Atomic.h>
#include <binder/Parcel.h>
#include <utils/CallStack.h>
struct heap_info_t {
sp<IMemoryHeap> heap;
int32_t count;
+ // Note that this cannot be meaningfully copied.
};
void free_heap(const wp<IBinder>& binder);
- Mutex mHeapCacheLock;
+ Mutex mHeapCacheLock; // Protects entire vector below.
KeyedVector< wp<IBinder>, heap_info_t > mHeapCache;
+ // We do not use the copy-on-write capabilities of KeyedVector.
+ // TODO: Reimplemement based on standard C++ container?
};
static sp<HeapCache> gHeapCache = new HeapCache();
class BpMemoryHeap : public BpInterface<IMemoryHeap>
{
public:
- BpMemoryHeap(const sp<IBinder>& impl);
+ explicit BpMemoryHeap(const sp<IBinder>& impl);
virtual ~BpMemoryHeap();
virtual int getHeapID() const;
void assertMapped() const;
void assertReallyMapped() const;
- mutable volatile int32_t mHeapId;
+ mutable std::atomic<int32_t> mHeapId;
mutable void* mBase;
mutable size_t mSize;
mutable uint32_t mFlags;
class BpMemory : public BpInterface<IMemory>
{
public:
- BpMemory(const sp<IBinder>& impl);
+ explicit BpMemory(const sp<IBinder>& impl);
virtual ~BpMemory();
virtual sp<IMemoryHeap> getMemory(ssize_t* offset=0, size_t* size=0) const;
}
BpMemoryHeap::~BpMemoryHeap() {
- if (mHeapId != -1) {
- close(mHeapId);
+ int32_t heapId = mHeapId.load(memory_order_relaxed);
+ if (heapId != -1) {
+ close(heapId);
if (mRealHeap) {
// by construction we're the last one
if (mBase != MAP_FAILED) {
if (VERBOSE) {
ALOGD("UNMAPPING binder=%p, heap=%p, size=%zu, fd=%d",
- binder.get(), this, mSize, mHeapId);
+ binder.get(), this, mSize, heapId);
CallStack stack(LOG_TAG);
}
void BpMemoryHeap::assertMapped() const
{
- if (mHeapId == -1) {
+ int32_t heapId = mHeapId.load(memory_order_acquire);
+ if (heapId == -1) {
sp<IBinder> binder(IInterface::asBinder(const_cast<BpMemoryHeap*>(this)));
sp<BpMemoryHeap> heap(static_cast<BpMemoryHeap*>(find_heap(binder).get()));
heap->assertReallyMapped();
if (heap->mBase != MAP_FAILED) {
Mutex::Autolock _l(mLock);
- if (mHeapId == -1) {
+ if (mHeapId.load(memory_order_relaxed) == -1) {
mBase = heap->mBase;
mSize = heap->mSize;
mOffset = heap->mOffset;
- android_atomic_write( dup( heap->mHeapId ), &mHeapId );
+ int fd = dup(heap->mHeapId.load(memory_order_relaxed));
+ ALOGE_IF(fd==-1, "cannot dup fd=%d",
+ heap->mHeapId.load(memory_order_relaxed));
+ mHeapId.store(fd, memory_order_release);
}
} else {
// something went wrong
void BpMemoryHeap::assertReallyMapped() const
{
- if (mHeapId == -1) {
+ int32_t heapId = mHeapId.load(memory_order_acquire);
+ if (heapId == -1) {
// remote call without mLock held, worse case scenario, we end up
// calling transact() from multiple threads, but that's not a problem,
parcel_fd, size, err, strerror(-err));
Mutex::Autolock _l(mLock);
- if (mHeapId == -1) {
+ if (mHeapId.load(memory_order_relaxed) == -1) {
int fd = dup( parcel_fd );
ALOGE_IF(fd==-1, "cannot dup fd=%d, size=%zd, err=%d (%s)",
parcel_fd, size, err, strerror(errno));
if (!(flags & READ_ONLY)) {
access |= PROT_WRITE;
}
-
mRealHeap = true;
mBase = mmap(0, size, access, MAP_SHARED, fd, offset);
if (mBase == MAP_FAILED) {
mSize = size;
mFlags = flags;
mOffset = offset;
- android_atomic_write(fd, &mHeapId);
+ mHeapId.store(fd, memory_order_release);
}
}
}
int BpMemoryHeap::getHeapID() const {
assertMapped();
- return mHeapId;
+ // We either stored mHeapId ourselves, or loaded it with acquire semantics.
+ return mHeapId.load(memory_order_relaxed);
}
void* BpMemoryHeap::getBase() const {
"found binder=%p, heap=%p, size=%zu, fd=%d, count=%d",
binder.get(), info.heap.get(),
static_cast<BpMemoryHeap*>(info.heap.get())->mSize,
- static_cast<BpMemoryHeap*>(info.heap.get())->mHeapId,
+ static_cast<BpMemoryHeap*>(info.heap.get())
+ ->mHeapId.load(memory_order_relaxed),
info.count);
- android_atomic_inc(&info.count);
+ ++info.count;
return info.heap;
} else {
heap_info_t info;
ssize_t i = mHeapCache.indexOfKey(binder);
if (i>=0) {
heap_info_t& info(mHeapCache.editValueAt(i));
- int32_t c = android_atomic_dec(&info.count);
- if (c == 1) {
+ if (--info.count == 0) {
ALOGD_IF(VERBOSE,
"removing binder=%p, heap=%p, size=%zu, fd=%d, count=%d",
binder.unsafe_get(), info.heap.get(),
static_cast<BpMemoryHeap*>(info.heap.get())->mSize,
- static_cast<BpMemoryHeap*>(info.heap.get())->mHeapId,
+ static_cast<BpMemoryHeap*>(info.heap.get())
+ ->mHeapId.load(memory_order_relaxed),
info.count);
rel = mHeapCache.valueAt(i).heap;
mHeapCache.removeItemsAt(i);
ALOGD("hey=%p, heap=%p, count=%d, (fd=%d, base=%p, size=%zu)",
mHeapCache.keyAt(i).unsafe_get(),
info.heap.get(), info.count,
- h->mHeapId, h->mBase, h->mSize);
+ h->mHeapId.load(memory_order_relaxed), h->mBase, h->mSize);
}
}
namespace android {
-static const char* getReturnString(size_t idx);
-static const void* printReturnCommand(TextOutput& out, const void* _cmd);
-static const void* printCommand(TextOutput& out, const void* _cmd);
-
// Static const and functions will be optimized out if not used,
// when LOG_NDEBUG and references in IF_LOG_COMMANDS() are optimized out.
static const char *kReturnStrings[] = {
"BC_DEAD_BINDER_DONE"
};
-static const char* getReturnString(size_t idx)
+static const char* getReturnString(uint32_t cmd)
{
+ size_t idx = cmd & 0xff;
if (idx < sizeof(kReturnStrings) / sizeof(kReturnStrings[0]))
return kReturnStrings[idx];
else
delete st;
pthread_setspecific(gTLS, NULL);
}
+ pthread_key_delete(gTLS);
gHaveTLS = false;
}
}
}
} while (result != -ECONNREFUSED && result != -EBADF);
- LOG_THREADPOOL("**** THREAD %p (PID %d) IS LEAVING THE THREAD POOL err=%p\n",
- (void*)pthread_self(), getpid(), (void*)result);
+ LOG_THREADPOOL("**** THREAD %p (PID %d) IS LEAVING THE THREAD POOL err=%d\n",
+ (void*)pthread_self(), getpid(), result);
mOut.writeInt32(BC_EXIT_LOOPER);
talkWithDriver(false);
waitForResponse(NULL, &result);
#if LOG_REFCOUNTS
- printf("IPCThreadState::attemptIncStrongHandle(%ld) = %s\n",
+ ALOGV("IPCThreadState::attemptIncStrongHandle(%ld) = %s\n",
handle, result == NO_ERROR ? "SUCCESS" : "FAILURE");
#endif
void IPCThreadState::expungeHandle(int32_t handle, IBinder* binder)
{
#if LOG_REFCOUNTS
- printf("IPCThreadState::expungeHandle(%ld)\n", handle);
+ ALOGV("IPCThreadState::expungeHandle(%ld)\n", handle);
#endif
self()->mProcess->expungeHandle(handle, binder);
}
break;
default:
- printf("*** BAD COMMAND %d received from Binder driver\n", cmd);
+ ALOGE("*** BAD COMMAND %d received from Binder driver\n", cmd);
result = UNKNOWN_ERROR;
break;
}
class BpPermissionController : public BpInterface<IPermissionController>
{
public:
- BpPermissionController(const sp<IBinder>& impl)
+ explicit BpPermissionController(const sp<IBinder>& impl)
: BpInterface<IPermissionController>(impl)
{
}
class BpProcessInfoService : public BpInterface<IProcessInfoService> {
public:
- BpProcessInfoService(const sp<IBinder>& impl)
+ explicit BpProcessInfoService(const sp<IBinder>& impl)
: BpInterface<IProcessInfoService>(impl) {}
virtual status_t getProcessStatesFromPids(size_t length, /*in*/ int32_t* pids,
bool checkPermission(const String16& permission, pid_t pid, uid_t uid)
{
-#ifdef __BRILLO__
- // Brillo doesn't currently run ActivityManager or support framework permissions.
- return true;
-#endif
-
sp<IPermissionController> pc;
gDefaultServiceManagerLock.lock();
pc = gPermissionController;
class BpServiceManager : public BpInterface<IServiceManager>
{
public:
- BpServiceManager(const sp<IBinder>& impl)
+ explicit BpServiceManager(const sp<IBinder>& impl)
: BpInterface<IServiceManager>(impl)
{
}
PAGE_ALIGNED = 0x00000001
};
public:
- SimpleBestFitAllocator(size_t size);
+ explicit SimpleBestFitAllocator(size_t size);
~SimpleBestFitAllocator();
size_t allocate(size_t size, uint32_t flags = 0);
BLOB_ASHMEM_MUTABLE = 2,
};
-static dev_t ashmem_rdev()
-{
- static dev_t __ashmem_rdev;
- static pthread_mutex_t __ashmem_rdev_lock = PTHREAD_MUTEX_INITIALIZER;
-
- pthread_mutex_lock(&__ashmem_rdev_lock);
-
- dev_t rdev = __ashmem_rdev;
- if (!rdev) {
- int fd = TEMP_FAILURE_RETRY(open("/dev/ashmem", O_RDONLY));
- if (fd >= 0) {
- struct stat st;
-
- int ret = TEMP_FAILURE_RETRY(fstat(fd, &st));
- close(fd);
- if ((ret >= 0) && S_ISCHR(st.st_mode)) {
- rdev = __ashmem_rdev = st.st_rdev;
- }
- }
- }
-
- pthread_mutex_unlock(&__ashmem_rdev_lock);
-
- return rdev;
-}
-
void acquire_object(const sp<ProcessState>& proc,
const flat_binder_object& obj, const void* who, size_t* outAshmemSize)
{
return;
}
case BINDER_TYPE_FD: {
- if ((obj.cookie != 0) && (outAshmemSize != NULL)) {
- struct stat st;
- int ret = fstat(obj.handle, &st);
- if (!ret && S_ISCHR(st.st_mode) && (st.st_rdev == ashmem_rdev())) {
- // If we own an ashmem fd, keep track of how much memory it refers to.
- int size = ashmem_get_size_region(obj.handle);
- if (size > 0) {
- *outAshmemSize += size;
- }
+ if ((obj.cookie != 0) && (outAshmemSize != NULL) && ashmem_valid(obj.handle)) {
+ // If we own an ashmem fd, keep track of how much memory it refers to.
+ int size = ashmem_get_size_region(obj.handle);
+ if (size > 0) {
+ *outAshmemSize += size;
}
}
return;
}
case BINDER_TYPE_FD: {
if (obj.cookie != 0) { // owned
- if (outAshmemSize != NULL) {
- struct stat st;
- int ret = fstat(obj.handle, &st);
- if (!ret && S_ISCHR(st.st_mode) && (st.st_rdev == ashmem_rdev())) {
- int size = ashmem_get_size_region(obj.handle);
- if (size > 0) {
- *outAshmemSize -= size;
- }
+ if ((outAshmemSize != NULL) && ashmem_valid(obj.handle)) {
+ int size = ashmem_get_size_region(obj.handle);
+ if (size > 0) {
+ *outAshmemSize -= size;
}
}
const uint8_t* strData = (uint8_t*)str.data();
const size_t strLen= str.length();
const ssize_t utf16Len = utf8_to_utf16_length(strData, strLen);
- if (utf16Len < 0 || utf16Len> std::numeric_limits<int32_t>::max()) {
+ if (utf16Len < 0 || utf16Len > std::numeric_limits<int32_t>::max()) {
return BAD_VALUE;
}
return NO_MEMORY;
}
- utf8_to_utf16(strData, strLen, (char16_t*)dst);
+ utf8_to_utf16(strData, strLen, (char16_t*)dst, (size_t) utf16Len + 1);
return NO_ERROR;
}
}
status_t Parcel::readStrongBinderVector(std::unique_ptr<std::vector<sp<IBinder>>>* val) const {
- return readNullableTypedVector(val, &Parcel::readStrongBinder);
+ return readNullableTypedVector(val, &Parcel::readNullableStrongBinder);
}
status_t Parcel::readStrongBinderVector(std::vector<sp<IBinder>>* val) const {
return err;
}
-status_t Parcel::writeUniqueFileDescriptor(const ScopedFd& fd) {
+status_t Parcel::writeUniqueFileDescriptor(const base::unique_fd& fd) {
return writeDupFileDescriptor(fd.get());
}
-status_t Parcel::writeUniqueFileDescriptorVector(const std::vector<ScopedFd>& val) {
+status_t Parcel::writeUniqueFileDescriptorVector(const std::vector<base::unique_fd>& val) {
return writeTypedVector(val, &Parcel::writeUniqueFileDescriptor);
}
-status_t Parcel::writeUniqueFileDescriptorVector(const std::unique_ptr<std::vector<ScopedFd>>& val) {
+status_t Parcel::writeUniqueFileDescriptorVector(const std::unique_ptr<std::vector<base::unique_fd>>& val) {
return writeNullableTypedVector(val, &Parcel::writeUniqueFileDescriptor);
}
String8 Parcel::readString8() const
{
- int32_t size = readInt32();
- // watch for potential int overflow adding 1 for trailing NUL
- if (size > 0 && size < INT32_MAX) {
- const char* str = (const char*)readInplace(size+1);
- if (str) return String8(str, size);
+ String8 retString;
+ status_t status = readString8(&retString);
+ if (status != OK) {
+ // We don't care about errors here, so just return an empty string.
+ return String8();
}
- return String8();
+ return retString;
+}
+
+status_t Parcel::readString8(String8* pArg) const
+{
+ int32_t size;
+ status_t status = readInt32(&size);
+ if (status != OK) {
+ return status;
+ }
+ // watch for potential int overflow from size+1
+ if (size < 0 || size >= INT32_MAX) {
+ return BAD_VALUE;
+ }
+ // |writeString8| writes nothing for empty string.
+ if (size == 0) {
+ *pArg = String8();
+ return OK;
+ }
+ const char* str = (const char*)readInplace(size + 1);
+ if (str == NULL) {
+ return BAD_VALUE;
+ }
+ pArg->setTo(str, size);
+ return OK;
}
String16 Parcel::readString16() const
status_t Parcel::readStrongBinder(sp<IBinder>* val) const
{
+ status_t status = readNullableStrongBinder(val);
+ if (status == OK && !val->get()) {
+ status = UNEXPECTED_NULL;
+ }
+ return status;
+}
+
+status_t Parcel::readNullableStrongBinder(sp<IBinder>* val) const
+{
return unflatten_binder(ProcessState::self(), *this, val);
}
sp<IBinder> Parcel::readStrongBinder() const
{
sp<IBinder> val;
- readStrongBinder(&val);
+ // Note that a lot of code in Android reads binders by hand with this
+ // method, and that code has historically been ok with getting nullptr
+ // back (while ignoring error codes).
+ readNullableStrongBinder(&val);
return val;
}
return BAD_TYPE;
}
-status_t Parcel::readUniqueFileDescriptor(ScopedFd* val) const
+status_t Parcel::readUniqueFileDescriptor(base::unique_fd* val) const
{
int got = readFileDescriptor();
}
-status_t Parcel::readUniqueFileDescriptorVector(std::unique_ptr<std::vector<ScopedFd>>* val) const {
+status_t Parcel::readUniqueFileDescriptorVector(std::unique_ptr<std::vector<base::unique_fd>>* val) const {
return readNullableTypedVector(val, &Parcel::readUniqueFileDescriptor);
}
-status_t Parcel::readUniqueFileDescriptorVector(std::vector<ScopedFd>* val) const {
+status_t Parcel::readUniqueFileDescriptorVector(std::vector<base::unique_fd>* val) const {
return readTypedVector(val, &Parcel::readUniqueFileDescriptor);
}
using android::sp;
using android::status_t;
using android::UNEXPECTED_NULL;
+using std::map;
+using std::set;
+using std::vector;
enum {
// Keep in sync with BUNDLE_MAGIC in frameworks/base/core/java/android/os/BaseBundle.java.
namespace {
template <typename T>
-bool getValue(const android::String16& key, T* out, const
std::map<android::String16, T>& map) {
+bool getValue(const android::String16& key, T* out, const map<android::String16, T>& map) {
const auto& it = map.find(key);
if (it == map.end()) return false;
*out = it->second;
return true;
}
+
+template <typename T>
+set<android::String16> getKeys(const map<android::String16, T>& map) {
+ if (map.empty()) return set<android::String16>();
+ set<android::String16> keys;
+ for (const auto& key_value_pair : map) {
+ keys.emplace(key_value_pair.first);
+ }
+ return keys;
+}
} // namespace
namespace android {
#define RETURN_IF_ENTRY_ERASED(map, key) \
{ \
- size_t num_erased = map.erase(key); \
+ size_t num_erased = (map).erase(key); \
if (num_erased) { \
ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \
return num_erased; \
mStringMap[key] = value;
}
-void PersistableBundle::putBooleanVector(const String16& key, const std::vector<bool>& value) {
+void PersistableBundle::putBooleanVector(const String16& key, const vector<bool>& value) {
erase(key);
mBoolVectorMap[key] = value;
}
-void PersistableBundle::putIntVector(const String16& key, const std::vector<int32_t>& value) {
+void PersistableBundle::putIntVector(const String16& key, const vector<int32_t>& value) {
erase(key);
mIntVectorMap[key] = value;
}
-void PersistableBundle::putLongVector(const String16& key, const std::vector<int64_t>& value) {
+void PersistableBundle::putLongVector(const String16& key, const vector<int64_t>& value) {
erase(key);
mLongVectorMap[key] = value;
}
-void PersistableBundle::putDoubleVector(const String16& key, const std::vector<double>& value) {
+void PersistableBundle::putDoubleVector(const String16& key, const vector<double>& value) {
erase(key);
mDoubleVectorMap[key] = value;
}
-void PersistableBundle::putStringVector(const String16& key, const std::vector<String16>& value) {
+void PersistableBundle::putStringVector(const String16& key, const vector<String16>& value) {
erase(key);
mStringVectorMap[key] = value;
}
return getValue(key, out, mStringMap);
}
-bool PersistableBundle::getBooleanVector(const String16& key, std::vector<bool>* out) const {
+bool PersistableBundle::getBooleanVector(const String16& key, vector<bool>* out) const {
return getValue(key, out, mBoolVectorMap);
}
-bool PersistableBundle::getIntVector(const String16& key, std::vector<int32_t>* out) const {
+bool PersistableBundle::getIntVector(const String16& key, vector<int32_t>* out) const {
return getValue(key, out, mIntVectorMap);
}
-bool PersistableBundle::getLongVector(const String16& key, std::vector<int64_t>* out) const {
+bool PersistableBundle::getLongVector(const String16& key, vector<int64_t>* out) const {
return getValue(key, out, mLongVectorMap);
}
-bool PersistableBundle::getDoubleVector(const String16& key, std::vector<double>* out) const {
+bool PersistableBundle::getDoubleVector(const String16& key, vector<double>* out) const {
return getValue(key, out, mDoubleVectorMap);
}
-bool PersistableBundle::getStringVector(const String16& key, std::vector<String16>* out) const {
+bool PersistableBundle::getStringVector(const String16& key, vector<String16>* out) const {
return getValue(key, out, mStringVectorMap);
}
return getValue(key, out, mPersistableBundleMap);
}
+set<String16> PersistableBundle::getBooleanKeys() const {
+ return getKeys(mBoolMap);
+}
+
+set<String16> PersistableBundle::getIntKeys() const {
+ return getKeys(mIntMap);
+}
+
+set<String16> PersistableBundle::getLongKeys() const {
+ return getKeys(mLongMap);
+}
+
+set<String16> PersistableBundle::getDoubleKeys() const {
+ return getKeys(mDoubleMap);
+}
+
+set<String16> PersistableBundle::getStringKeys() const {
+ return getKeys(mStringMap);
+}
+
+set<String16> PersistableBundle::getBooleanVectorKeys() const {
+ return getKeys(mBoolVectorMap);
+}
+
+set<String16> PersistableBundle::getIntVectorKeys() const {
+ return getKeys(mIntVectorMap);
+}
+
+set<String16> PersistableBundle::getLongVectorKeys() const {
+ return getKeys(mLongVectorMap);
+}
+
+set<String16> PersistableBundle::getDoubleVectorKeys() const {
+ return getKeys(mDoubleVectorMap);
+}
+
+set<String16> PersistableBundle::getStringVectorKeys() const {
+ return getKeys(mStringVectorMap);
+}
+
+set<String16> PersistableBundle::getPersistableBundleKeys() const {
+ return getKeys(mPersistableBundleMap);
+}
+
status_t PersistableBundle::writeToParcelInner(Parcel* parcel) const {
/*
* To keep this implementation in sync with writeArrayMapInternal() in
RETURN_IF_FAILED(parcel->readInt32(&num_entries));
for (; num_entries > 0; --num_entries) {
- size_t start_pos = parcel->dataPosition();
String16 key;
int32_t value_type;
RETURN_IF_FAILED(parcel->readString16(&key));
#define LOG_TAG "ProcessState"
-#include <cutils/process_name.h>
-
#include <binder/ProcessState.h>
#include <utils/Atomic.h>
class PoolThread : public Thread
{
public:
- PoolThread(bool isMain)
+ explicit PoolThread(bool isMain)
: mIsMain(isMain)
{
}
ProcessState::~ProcessState()
{
+ if (mDriverFD >= 0) {
+ if (mVMStart != MAP_FAILED) {
+ munmap(mVMStart, BINDER_VM_SIZE);
+ }
+ close(mDriverFD);
+ }
+ mDriverFD = -1;
}
}; // namespace android
class FdTextOutput : public BufferedTextOutput
{
public:
- FdTextOutput(int fd) : BufferedTextOutput(MULTITHREADED), mFD(fd) { }
+ explicit FdTextOutput(int fd) : BufferedTextOutput(MULTITHREADED), mFD(fd) { }
virtual ~FdTextOutput() { };
protected:
return Status(exceptionCode, OK, message);
}
+Status Status::fromExceptionCode(int32_t exceptionCode,
+ const char* message) {
+ return fromExceptionCode(exceptionCode, String8(message));
+}
+
Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode) {
return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode);
}
return Status(EX_SERVICE_SPECIFIC, serviceSpecificErrorCode, message);
}
+Status Status::fromServiceSpecificError(int32_t serviceSpecificErrorCode,
+ const char* message) {
+ return fromServiceSpecificError(serviceSpecificErrorCode, String8(message));
+}
+
Status Status::fromStatusT(status_t status) {
Status ret;
ret.setFromStatusT(status);
return ret;
}
+std::stringstream& operator<< (std::stringstream& stream, const Status& s) {
+ stream << s.toString8().string();
+ return stream;
+}
+
} // namespace binder
} // namespace android
// ---------------------------------------------------------------------------
-TextOutput::TextOutput() {
+TextOutput::TextOutput() {
}
-TextOutput::~TextOutput() {
+TextOutput::~TextOutput() {
}
// ---------------------------------------------------------------------------
-TextOutput& operator<<(TextOutput& to, bool val)
-{
- if (val) to.print("true", 4);
- else to.print("false", 5);
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, int val)
-{
- char buf[16];
- sprintf(buf, "%d", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, long val)
-{
- char buf[16];
- sprintf(buf, "%ld", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, unsigned int val)
-{
- char buf[16];
- sprintf(buf, "%u", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, unsigned long val)
-{
- char buf[16];
- sprintf(buf, "%lu", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, long long val)
-{
- char buf[32];
- sprintf(buf, "%Ld", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, unsigned long long val)
-{
- char buf[32];
- sprintf(buf, "%Lu", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-static TextOutput& print_float(TextOutput& to, double value)
-{
- char buf[64];
- sprintf(buf, "%g", value);
- if( !strchr(buf, '.') && !strchr(buf, 'e') &&
- !strchr(buf, 'E') ) {
- strncat(buf, ".0", sizeof(buf)-1);
- }
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, float val)
-{
- return print_float(to,val);
-}
-
-TextOutput& operator<<(TextOutput& to, double val)
-{
- return print_float(to,val);
-}
-
-TextOutput& operator<<(TextOutput& to, const void* val)
-{
- char buf[32];
- snprintf(buf, sizeof(buf), "%p", val);
- to.print(buf, strlen(buf));
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, const String8& val)
-{
- to << val.string();
- return to;
-}
-
-TextOutput& operator<<(TextOutput& to, const String16& val)
-{
- to << String8(val).string();
- return to;
-}
-
static void textOutputPrinter(void* cookie, const char* txt)
{
((TextOutput*)cookie)->print(txt, strlen(txt));
--- /dev/null
+//
+// Copyright (C) 2014 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_test {
+ product_variables: {
+ binder32bit: {
+ cflags: ["-DBINDER_IPC_32BIT=1"],
+ },
+ },
+
+ name: "binderDriverInterfaceTest",
+ srcs: ["binderDriverInterfaceTest.cpp"],
+}
+
+cc_test {
+ name: "binderLibTest",
+ srcs: ["binderLibTest.cpp"],
+ shared_libs: [
+ "libbinder",
+ "libutils",
+ ],
+}
+
+cc_test {
+ name: "binderThroughputTest",
+ srcs: ["binderThroughputTest.cpp"],
+ shared_libs: [
+ "libbinder",
+ "libutils",
+ ],
+ clang: true,
+ cflags: [
+ "-g",
+ "-Wall",
+ "-Werror",
+ "-Wno-missing-field-initializers",
+ "-Wno-sign-compare",
+ "-O3",
+ ],
+}
+
+cc_test {
+ name: "binderTextOutputTest",
+ srcs: ["binderTextOutputTest.cpp"],
+ shared_libs: [
+ "libbinder",
+ "libutils",
+ "libbase",
+ ],
+}
+++ /dev/null
-#
-# Copyright (C) 2014 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.
-#
-
-LOCAL_PATH:= $(call my-dir)
-
-include $(CLEAR_VARS)
-ifneq ($(TARGET_USES_64_BIT_BINDER),true)
-ifneq ($(TARGET_IS_64_BIT),true)
-LOCAL_CFLAGS += -DBINDER_IPC_32BIT=1
-endif
-endif
-
-LOCAL_MODULE := binderDriverInterfaceTest
-LOCAL_SRC_FILES := binderDriverInterfaceTest.cpp
-include $(BUILD_NATIVE_TEST)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := binderLibTest
-LOCAL_SRC_FILES := binderLibTest.cpp
-LOCAL_SHARED_LIBRARIES := libbinder libutils
-include $(BUILD_NATIVE_TEST)
-
-include $(CLEAR_VARS)
-LOCAL_MODULE := binderThroughputTest
-LOCAL_SRC_FILES := binderThroughputTest.cpp
-LOCAL_SHARED_LIBRARIES := libbinder libutils
-LOCAL_CLANG := true
-LOCAL_CFLAGS += -g -Wall -Werror -std=c++11 -Wno-missing-field-initializers -Wno-sign-compare -O3
-include $(BUILD_NATIVE_TEST)
#include <stdlib.h>
#include <gtest/gtest.h>
-#include <linux/binder.h>
+#include <linux/android/binder.h>
#include <binder/IBinder.h>
#include <sys/mman.h>
#include <poll.h>
.sender_euid = 0,
.data_size = 0,
.offsets_size = 0,
- .data = {0, 0},
+ .data = {
+ .ptr = {0, 0},
+ },
},
};
struct {
return RUN_ALL_TESTS();
}
-
static testing::Environment* binder_env;
static char *binderservername;
+static char *binderserversuffix;
static char binderserverarg[] = "--binderserver";
static String16 binderLibTestServiceName = String16("test.binderLib");
binderserverarg,
stri,
strpipefd1,
+ binderserversuffix,
NULL
};
int ret;
pthread_mutex_lock(&m_waitMutex);
if (!m_eventTriggered) {
-#if defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)
- pthread_cond_timeout_np(&m_waitCond, &m_waitMutex, timeout_s * 1000);
-#else
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += timeout_s;
pthread_cond_timedwait(&m_waitCond, &m_waitMutex, &ts);
-#endif
}
ret = m_eventTriggered ? NO_ERROR : TIMED_OUT;
pthread_mutex_unlock(&m_waitMutex);
}
if (ret > 0) {
if (m_serverStartRequested) {
-#if defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE)
- ret = pthread_cond_timeout_np(&m_serverWaitCond, &m_serverWaitMutex, 5000);
-#else
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 5;
ret = pthread_cond_timedwait(&m_serverWaitCond, &m_serverWaitMutex, &ts);
-#endif
}
if (m_serverStartRequested) {
m_serverStartRequested = false;
int run_server(int index, int readypipefd)
{
+ binderLibTestServiceName += String16(binderserversuffix);
+
status_t ret;
sp<IServiceManager> sm = defaultServiceManager();
{
int main(int argc, char **argv) {
int ret;
- if (argc == 3 && !strcmp(argv[1], "--servername")) {
+ if (argc == 4 && !strcmp(argv[1], "--servername")) {
binderservername = argv[2];
} else {
binderservername = argv[0];
}
- if (argc == 4 && !strcmp(argv[1], binderserverarg)) {
+ if (argc == 5 && !strcmp(argv[1], binderserverarg)) {
+ binderserversuffix = argv[4];
return run_server(atoi(argv[2]), atoi(argv[3]));
}
+ binderserversuffix = new char[16];
+ snprintf(binderserversuffix, 16, "%d", getpid());
+ binderLibTestServiceName += String16(binderserversuffix);
::testing::InitGoogleTest(&argc, argv);
binder_env = AddGlobalTestEnvironment(new BinderLibTestEnv());
--- /dev/null
+/*
+ * Copyright (C) 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.
+ */
+
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits>
+#include <cstddef>
+
+#include "android-base/file.h"
+#include "android-base/test_utils.h"
+#include <gtest/gtest.h>
+
+#include <binder/Parcel.h>
+#include <binder/TextOutput.h>
+#include <binder/Debug.h>
+
+static void CheckMessage(const CapturedStderr& cap,
+ const char* expected,
+ bool singleline) {
+ std::string output;
+ ASSERT_EQ(0, lseek(cap.fd(), 0, SEEK_SET));
+ android::base::ReadFdToString(cap.fd(), &output);
+ if (singleline)
+ output.erase(std::remove(output.begin(), output.end(), '\n'));
+ ASSERT_STREQ(output.c_str(), expected);
+}
+
+#define CHECK_LOG_(input, expect, singleline) \
+{ \
+ CapturedStderr cap; \
+ android::aerr << input << android::endl; \
+ CheckMessage(cap, expect, singleline); \
+} \
+
+#define CHECK_VAL_(val, singleline) \
+{ \
+ std::stringstream ss; \
+ ss << val; \
+ std::string s = ss.str(); \
+ CHECK_LOG_(val, s.c_str(), singleline); \
+} \
+
+#define CHECK_LOG(input, expect) CHECK_LOG_(input, expect, true)
+#define CHECK_VAL(val) CHECK_VAL_(val, true)
+
+TEST(TextOutput, HandlesStdEndl) {
+ CapturedStderr cap;
+ android::aerr << "foobar" << std::endl;
+ std::string output;
+ ASSERT_EQ(0, lseek(cap.fd(), 0, SEEK_SET));
+ android::base::ReadFdToString(cap.fd(), &output);
+ ASSERT_STREQ(output.c_str(), "foobar\n");
+}
+
+TEST(TextOutput, HandlesCEndl) {
+ CapturedStderr cap;
+ android::aerr << "foobar" << "\n";
+ std::string output;
+ ASSERT_EQ(0, lseek(cap.fd(), 0, SEEK_SET));
+ android::base::ReadFdToString(cap.fd(), &output);
+ ASSERT_STREQ(output.c_str(), "foobar\n");
+}
+
+TEST(TextOutput, HandlesAndroidEndl) {
+ CapturedStderr cap;
+ android::aerr << "foobar" << android::endl;
+ std::string output;
+ ASSERT_EQ(0, lseek(cap.fd(), 0, SEEK_SET));
+ android::base::ReadFdToString(cap.fd(), &output);
+ ASSERT_STREQ(output.c_str(), "foobar\n");
+}
+
+TEST(TextOutput, HandleEmptyString) {
+ CHECK_LOG("", "");
+}
+
+TEST(TextOutput, HandleString) {
+ CHECK_LOG("foobar", "foobar");
+}
+
+TEST(TextOutput, HandleNum) {
+ CHECK_LOG(12345, "12345");
+}
+
+TEST(TextOutput, HandleBool) {
+ CHECK_LOG(false, "false");
+}
+
+TEST(TextOutput, HandleChar) {
+ CHECK_LOG('T', "T");
+}
+
+TEST(TextOutput, HandleParcel) {
+ android::Parcel val;
+ CHECK_LOG(val, "Parcel(NULL)");
+}
+
+TEST(TextOutput, HandleHexDump) {
+ const char buf[16] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
+ android::HexDump val(buf, sizeof(buf));
+ CHECK_LOG(val, "03020100 07060504 0b0a0908 0f0e0d0c '................'");
+}
+
+TEST(TextOutput, HandleHexDumpCustom) {
+ const char buf[4] = {0x11,0x22,0x33,0x44};
+ android::HexDump val(buf, sizeof(buf), 4);
+ CHECK_LOG(val, "11 22 33 44 '.\"3D'");
+}
+
+TEST(TextOutput, HandleTypeCode) {
+ android::TypeCode val(1234);
+ CHECK_LOG(val, "'\\x04\\xd2'");
+}
+
+TEST(TextOutput, HandleCookie) {
+ int32_t val = 321; //0x141
+ CHECK_LOG((void*)(long)val, "0x141");
+}
+
+TEST(TextOutput, HandleString8) {
+ android::String8 val("foobar");
+ CHECK_LOG(val, "foobar");
+}
+
+TEST(TextOutput, HandleString16) {
+ android::String16 val("foobar");
+ CHECK_LOG(val, "foobar");
+}
+
+template <typename T>
+class TextTest : public testing::Test {};
+
+typedef testing::Types<short, unsigned short,
+ int, unsigned int,
+ long, unsigned long,
+ long long, unsigned long long,
+ float, double, long double> TestTypes;
+TYPED_TEST_CASE(TextTest, TestTypes);
+
+TYPED_TEST(TextTest, TextMax)
+{
+ TypeParam max = std::numeric_limits<TypeParam>::max();
+ CHECK_VAL(max);
+}
+
+TYPED_TEST(TextTest, TestMin)
+{
+ TypeParam min = std::numeric_limits<TypeParam>::min();
+ CHECK_VAL(min);
+}
+
+TYPED_TEST(TextTest, TestDenom)
+{
+ TypeParam min = std::numeric_limits<TypeParam>::denorm_min();
+ CHECK_VAL(min);
+}
+
+TYPED_TEST(TextTest, TestEpsilon)
+{
+ TypeParam eps = std::numeric_limits<TypeParam>::epsilon();
+ CHECK_VAL(eps);
+}
--- /dev/null
+// Copyright (C) 2010 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_static {
+ name: "libdiskusage",
+ srcs: ["dirsize.c"],
+}
--- /dev/null
+// Copyright 2010 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: "libgui",
+
+ clang: true,
+ cppflags: [
+ "-Weverything",
+ "-Werror",
+
+ // The static constructors and destructors in this library have not been noted to
+ // introduce significant overheads
+ "-Wno-exit-time-destructors",
+ "-Wno-global-constructors",
+
+ // We only care about compiling as C++14
+ "-Wno-c++98-compat-pedantic",
+
+ // We don't need to enumerate every case in a switch as long as a default case
+ // is present
+ "-Wno-switch-enum",
+
+ // Allow calling variadic macros without a __VA_ARGS__ list
+ "-Wno-gnu-zero-variadic-macro-arguments",
+
+ // Don't warn about struct padding
+ "-Wno-padded",
+
+ // android/sensors.h uses nested anonymous unions and anonymous structs
+ "-Wno-nested-anon-types",
+ "-Wno-gnu-anonymous-struct",
+
+ "-DDEBUG_ONLY_CODE=0",
+ ],
+
+ product_variables: {
+ brillo: {
+ cflags: ["-DHAVE_NO_SURFACE_FLINGER"],
+ },
+ debuggable: {
+ cppflags: [
+ "-UDEBUG_ONLY_CODE",
+ "-DDEBUG_ONLY_CODE=1",
+ ],
+ },
+ },
+
+ srcs: [
+ "IGraphicBufferConsumer.cpp",
+ "IConsumerListener.cpp",
+ "BitTube.cpp",
+ "BufferItem.cpp",
+ "BufferItemConsumer.cpp",
+ "BufferQueue.cpp",
+ "BufferQueueConsumer.cpp",
+ "BufferQueueCore.cpp",
+ "BufferQueueProducer.cpp",
+ "BufferSlot.cpp",
+ "ConsumerBase.cpp",
+ "CpuConsumer.cpp",
+ "DisplayEventReceiver.cpp",
+ "GLConsumer.cpp",
+ "GraphicBufferAlloc.cpp",
+ "GuiConfig.cpp",
+ "IDisplayEventConnection.cpp",
+ "IGraphicBufferAlloc.cpp",
+ "IGraphicBufferProducer.cpp",
+ "IProducerListener.cpp",
+ "ISensorEventConnection.cpp",
+ "ISensorServer.cpp",
+ "ISurfaceComposer.cpp",
+ "ISurfaceComposerClient.cpp",
+ "LayerState.cpp",
+ "OccupancyTracker.cpp",
+ "Sensor.cpp",
+ "SensorEventQueue.cpp",
+ "SensorManager.cpp",
+ "StreamSplitter.cpp",
+ "Surface.cpp",
+ "SurfaceControl.cpp",
+ "SurfaceComposerClient.cpp",
+ "SyncFeatures.cpp",
+ ],
+
+ shared_libs: [
+ "libbinder",
+ "libcutils",
+ "libEGL",
+ "libGLESv2",
+ "libsync",
+ "libui",
+ "libutils",
+ "liblog",
+ ],
+
+ export_shared_lib_headers: ["libbinder"],
+}
+
+subdirs = ["tests"]
+++ /dev/null
-# Copyright 2010 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.
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_CLANG := true
-LOCAL_CPPFLAGS := -std=c++1y -Weverything -Werror
-
-# The static constructors and destructors in this library have not been noted to
-# introduce significant overheads
-LOCAL_CPPFLAGS += -Wno-exit-time-destructors
-LOCAL_CPPFLAGS += -Wno-global-constructors
-
-# We only care about compiling as C++14
-LOCAL_CPPFLAGS += -Wno-c++98-compat-pedantic
-
-# We don't need to enumerate every case in a switch as long as a default case
-# is present
-LOCAL_CPPFLAGS += -Wno-switch-enum
-
-# Allow calling variadic macros without a __VA_ARGS__ list
-LOCAL_CPPFLAGS += -Wno-gnu-zero-variadic-macro-arguments
-
-# Don't warn about struct padding
-LOCAL_CPPFLAGS += -Wno-padded
-
-LOCAL_CPPFLAGS += -DDEBUG_ONLY_CODE=$(if $(filter userdebug eng,$(TARGET_BUILD_VARIANT)),1,0)
-
-LOCAL_SRC_FILES := \
- IGraphicBufferConsumer.cpp \
- IConsumerListener.cpp \
- BitTube.cpp \
- BufferItem.cpp \
- BufferItemConsumer.cpp \
- BufferQueue.cpp \
- BufferQueueConsumer.cpp \
- BufferQueueCore.cpp \
- BufferQueueProducer.cpp \
- BufferSlot.cpp \
- ConsumerBase.cpp \
- CpuConsumer.cpp \
- DisplayEventReceiver.cpp \
- GLConsumer.cpp \
- GraphicBufferAlloc.cpp \
- GuiConfig.cpp \
- IDisplayEventConnection.cpp \
- IGraphicBufferAlloc.cpp \
- IGraphicBufferProducer.cpp \
- IProducerListener.cpp \
- ISensorEventConnection.cpp \
- ISensorServer.cpp \
- ISurfaceComposer.cpp \
- ISurfaceComposerClient.cpp \
- LayerState.cpp \
- OccupancyTracker.cpp \
- Sensor.cpp \
- SensorEventQueue.cpp \
- SensorManager.cpp \
- StreamSplitter.cpp \
- Surface.cpp \
- SurfaceControl.cpp \
- SurfaceComposerClient.cpp \
- SyncFeatures.cpp \
-
-LOCAL_SHARED_LIBRARIES := \
- libbinder \
- libcutils \
- libEGL \
- libGLESv2 \
- libsync \
- libui \
- libutils \
- liblog
-
-
-LOCAL_MODULE := libgui
-
-ifeq ($(TARGET_BOARD_PLATFORM), tegra)
- LOCAL_CFLAGS += -DDONT_USE_FENCE_SYNC
-endif
-ifeq ($(TARGET_BOARD_PLATFORM), tegra3)
- LOCAL_CFLAGS += -DDONT_USE_FENCE_SYNC
-endif
-
-include $(BUILD_SHARED_LIBRARY)
-
-ifeq (,$(ONE_SHOT_MAKEFILE))
-include $(call first-makefiles-under,$(LOCAL_PATH))
-endif
namespace android {
+template<typename T>
+static inline constexpr uint32_t low32(const T n) {
+ return static_cast<uint32_t>(static_cast<uint64_t>(n));
+}
+
+template<typename T>
+static inline constexpr uint32_t high32(const T n) {
+ return static_cast<uint32_t>(static_cast<uint64_t>(n)>>32);
+}
+
+template<typename T>
+static inline constexpr T to64(const uint32_t lo, const uint32_t hi) {
+ return static_cast<T>(static_cast<uint64_t>(hi)<<32 | lo);
+}
+
BufferItem::BufferItem() :
mGraphicBuffer(NULL),
mFence(NULL),
addAligned(size, mCrop);
addAligned(size, mTransform);
addAligned(size, mScalingMode);
- addAligned(size, mTimestampLo);
- addAligned(size, mTimestampHi);
+ addAligned(size, low32(mTimestamp));
+ addAligned(size, high32(mTimestamp));
addAligned(size, mIsAutoTimestamp);
addAligned(size, mDataSpace);
- addAligned(size, mFrameNumberLo);
- addAligned(size, mFrameNumberHi);
+ addAligned(size, low32(mFrameNumber));
+ addAligned(size, high32(mFrameNumber));
addAligned(size, mSlot);
addAligned(size, mIsDroppable);
addAligned(size, mAcquireCalled);
writeAligned(buffer, size, mCrop);
writeAligned(buffer, size, mTransform);
writeAligned(buffer, size, mScalingMode);
- writeAligned(buffer, size, mTimestampLo);
- writeAligned(buffer, size, mTimestampHi);
+ writeAligned(buffer, size, low32(mTimestamp));
+ writeAligned(buffer, size, high32(mTimestamp));
writeAligned(buffer, size, mIsAutoTimestamp);
writeAligned(buffer, size, mDataSpace);
- writeAligned(buffer, size, mFrameNumberLo);
- writeAligned(buffer, size, mFrameNumberHi);
+ writeAligned(buffer, size, low32(mFrameNumber));
+ writeAligned(buffer, size, high32(mFrameNumber));
writeAligned(buffer, size, mSlot);
writeAligned(buffer, size, mIsDroppable);
writeAligned(buffer, size, mAcquireCalled);
return NO_MEMORY;
}
+ uint32_t timestampLo = 0, timestampHi = 0;
+ uint32_t frameNumberLo = 0, frameNumberHi = 0;
+
readAligned(buffer, size, mCrop);
readAligned(buffer, size, mTransform);
readAligned(buffer, size, mScalingMode);
- readAligned(buffer, size, mTimestampLo);
- readAligned(buffer, size, mTimestampHi);
+ readAligned(buffer, size, timestampLo);
+ readAligned(buffer, size, timestampHi);
+ mTimestamp = to64<int64_t>(timestampLo, timestampHi);
readAligned(buffer, size, mIsAutoTimestamp);
readAligned(buffer, size, mDataSpace);
- readAligned(buffer, size, mFrameNumberLo);
- readAligned(buffer, size, mFrameNumberHi);
+ readAligned(buffer, size, frameNumberLo);
+ readAligned(buffer, size, frameNumberHi);
+ mFrameNumber = to64<uint64_t>(frameNumberLo, frameNumberHi);
readAligned(buffer, size, mSlot);
readAligned(buffer, size, mIsDroppable);
readAligned(buffer, size, mAcquireCalled);
// decrease.
mCore->mDequeueCondition.broadcast();
- ATRACE_INT(mCore->mConsumerName.string(), mCore->mQueue.size());
+ ATRACE_INT(mCore->mConsumerName.string(),
+ static_cast<int32_t>(mCore->mQueue.size()));
mCore->mOccupancyTracker.registerOccupancyChange(mCore->mQueue.size());
VALIDATE_CONSISTENCY();
return NO_ERROR;
}
-void BufferQueueConsumer::dump(String8& result, const char* prefix) const {
+void BufferQueueConsumer::dumpState(String8& result, const char* prefix) const {
const IPCThreadState* ipc = IPCThreadState::self();
const pid_t pid = ipc->getCallingPid();
const uid_t uid = ipc->getCallingUid();
"android.permission.DUMP"), pid, uid)) {
result.appendFormat("Permission Denial: can't dump BufferQueueConsumer "
"from pid=%d, uid=%d\n", pid, uid);
- android_errorWriteWithInfoLog(0x534e4554, "27046057", uid, NULL, 0);
+ android_errorWriteWithInfoLog(0x534e4554, "27046057",
+ static_cast<int32_t>(uid), NULL, 0);
} else {
- mCore->dump(result, prefix);
+ mCore->dumpState(result, prefix);
}
}
#include <inttypes.h>
+#include <cutils/properties.h>
+
#include <gui/BufferItem.h>
#include <gui/BufferQueueCore.h>
+#include <gui/GraphicBufferAlloc.h>
#include <gui/IConsumerListener.h>
#include <gui/IGraphicBufferAlloc.h>
#include <gui/IProducerListener.h>
mUniqueId(getUniqueId())
{
if (allocator == NULL) {
- sp<ISurfaceComposer> composer(ComposerService::getComposerService());
- mAllocator = composer->createGraphicBufferAlloc();
+
+#ifdef HAVE_NO_SURFACE_FLINGER
+ // Without a SurfaceFlinger, allocate in-process. This only makes
+ // sense in systems with static SELinux configurations and no
+ // applications (since applications need dynamic SELinux policy).
+ mAllocator = new GraphicBufferAlloc();
+#else
+ // Run time check for headless, where we also allocate in-process.
+ char value[PROPERTY_VALUE_MAX];
+ property_get("config.headless", value, "0");
+ if (atoi(value) == 1) {
+ mAllocator = new GraphicBufferAlloc();
+ } else {
+ sp<ISurfaceComposer> composer(ComposerService::getComposerService());
+ mAllocator = composer->createGraphicBufferAlloc();
+ }
+#endif // HAVE_NO_SURFACE_FLINGER
+
if (mAllocator == NULL) {
BQ_LOGE("createGraphicBufferAlloc failed");
}
BufferQueueCore::~BufferQueueCore() {}
-void BufferQueueCore::dump(String8& result, const char* prefix) const {
+void BufferQueueCore::dumpState(String8& result, const char* prefix) const {
Mutex::Autolock lock(mMutex);
String8 fifo;
static_cast<uint32_t>(mCore->mQueue.size()),
mCore->mFrameCounter + 1);
- ATRACE_INT(mCore->mConsumerName.string(), mCore->mQueue.size());
+ ATRACE_INT(mCore->mConsumerName.string(),
+ static_cast<int32_t>(mCore->mQueue.size()));
mCore->mOccupancyTracker.registerOccupancyChange(mCore->mQueue.size());
// Take a ticket for the callback functions
return mConsumer->discardFreeBuffers();
}
-void ConsumerBase::dump(String8& result) const {
- dump(result, "");
+void ConsumerBase::dumpState(String8& result) const {
+ dumpState(result, "");
}
-void ConsumerBase::dump(String8& result, const char* prefix) const {
+void ConsumerBase::dumpState(String8& result, const char* prefix) const {
Mutex::Autolock _l(mMutex);
dumpLocked(result, prefix);
}
result.appendFormat("%smAbandoned=%d\n", prefix, int(mAbandoned));
if (!mAbandoned) {
- mConsumer->dump(result, prefix);
+ mConsumer->dumpState(result, prefix);
}
}
EGL_NONE,
};
if (!crop.isValid()) {
- // No crop rect to set, so terminate the attrib array before the crop.
- attrs[2] = EGL_NONE;
+ // No crop rect to set, so leave the crop out of the attrib array. Make
+ // sure to propagate the protected content attrs if they are set.
+ attrs[2] = attrs[10];
+ attrs[3] = attrs[11];
+ attrs[4] = EGL_NONE;
} else if (!isEglImageCroppable(crop)) {
// The crop rect is not at the origin, so we can't set the crop on the
// EGLImage because that's not allowed by the EGL_ANDROID_image_crop
// extension. In the future we can add a layered extension that
// removes this restriction if there is hardware that can support it.
- attrs[2] = EGL_NONE;
+ attrs[2] = attrs[10];
+ attrs[3] = attrs[11];
+ attrs[4] = EGL_NONE;
}
eglInitialize(dpy, 0, 0);
EGLImageKHR image = eglCreateImageKHR(dpy, EGL_NO_CONTEXT,
class BpConsumerListener : public BpInterface<IConsumerListener>
{
public:
- BpConsumerListener(const sp<IBinder>& impl)
+ explicit BpConsumerListener(const sp<IBinder>& impl)
: BpInterface<IConsumerListener>(impl) {
}
return BBinder::onTransact(code, data, reply, flags);
}
+ConsumerListener::~ConsumerListener() = default;
// ---------------------------------------------------------------------------
}; // namespace android
class BpDisplayEventConnection : public BpInterface<IDisplayEventConnection>
{
public:
- BpDisplayEventConnection(const sp<IBinder>& impl)
+ explicit BpDisplayEventConnection(const sp<IBinder>& impl)
: BpInterface<IDisplayEventConnection>(impl)
{
}
class BpGraphicBufferAlloc : public BpInterface<IGraphicBufferAlloc>
{
public:
- BpGraphicBufferAlloc(const sp<IBinder>& impl)
+ explicit BpGraphicBufferAlloc(const sp<IBinder>& impl)
: BpInterface<IGraphicBufferAlloc>(impl)
{
}
class BufferReference : public BBinder {
sp<GraphicBuffer> mBuffer;
public:
- BufferReference(const sp<GraphicBuffer>& buffer) : mBuffer(buffer) {}
+ explicit BufferReference(const sp<GraphicBuffer>& buffer) : mBuffer(buffer) {}
};
class BpGraphicBufferConsumer : public BpInterface<IGraphicBufferConsumer>
{
public:
- BpGraphicBufferConsumer(const sp<IBinder>& impl)
+ explicit BpGraphicBufferConsumer(const sp<IBinder>& impl)
: BpInterface<IGraphicBufferConsumer>(impl)
{
}
return result;
}
- virtual void dump(String8& result, const char* prefix) const {
+ virtual void dumpState(String8& result, const char* prefix) const {
Parcel data, reply;
data.writeInterfaceToken(IGraphicBufferConsumer::getInterfaceDescriptor());
data.writeString8(result);
CHECK_INTERFACE(IGraphicBufferConsumer, data, reply);
String8 result = data.readString8();
String8 prefix = data.readString8();
- static_cast<IGraphicBufferConsumer*>(this)->dump(result, prefix);
+ static_cast<IGraphicBufferConsumer*>(this)->dumpState(result, prefix);
reply->writeString8(result);
return NO_ERROR;
}
class BpGraphicBufferProducer : public BpInterface<IGraphicBufferProducer>
{
public:
- BpGraphicBufferProducer(const sp<IBinder>& impl)
+ explicit BpGraphicBufferProducer(const sp<IBinder>& impl)
: BpInterface<IGraphicBufferProducer>(impl)
{
}
class BpProducerListener : public BpInterface<IProducerListener>
{
public:
- BpProducerListener(const sp<IBinder>& impl)
+ explicit BpProducerListener(const sp<IBinder>& impl)
: BpInterface<IProducerListener>(impl) {}
virtual ~BpProducerListener();
return BBinder::onTransact(code, data, reply, flags);
}
+ProducerListener::~ProducerListener() = default;
+
+DummyProducerListener::~DummyProducerListener() = default;
+
bool BnProducerListener::needsReleaseNotify() {
return true;
}
class BpSensorEventConnection : public BpInterface<ISensorEventConnection>
{
public:
- BpSensorEventConnection(const sp<IBinder>& impl)
+ explicit BpSensorEventConnection(const sp<IBinder>& impl)
: BpInterface<ISensorEventConnection>(impl)
{
}
class BpSensorServer : public BpInterface<ISensorServer>
{
public:
- BpSensorServer(const sp<IBinder>& impl)
+ explicit BpSensorServer(const sp<IBinder>& impl)
: BpInterface<ISensorServer>(impl)
{
}
class BpSurfaceComposer : public BpInterface<ISurfaceComposer>
{
public:
- BpSurfaceComposer(const sp<IBinder>& impl)
+ explicit BpSurfaceComposer(const sp<IBinder>& impl)
: BpInterface<ISurfaceComposer>(impl)
{
}
class BpSurfaceComposerClient : public BpInterface<ISurfaceComposerClient>
{
public:
- BpSurfaceComposerClient(const sp<IBinder>& impl)
+ explicit BpSurfaceComposerClient(const sp<IBinder>& impl)
: BpInterface<ISurfaceComposerClient>(impl) {
}
mSensorManager.sensorManagerDied();
}
public:
- DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { }
+ explicit DeathObserver(SensorManager& mgr) : mSensorManager(mgr) { }
};
LOG_ALWAYS_FATAL_IF(mSensorServer.get() == NULL, "getService(SensorService) NULL");
timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
isAutoTimestamp = true;
ALOGV("Surface::queueBuffer making up timestamp: %.2f ms",
- timestamp / 1000000.f);
+ timestamp / 1000000.0);
} else {
timestamp = mTimestamp;
}
mComposerService.composerServiceDied();
}
public:
- DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }
+ explicit DeathObserver(ComposerService& mgr) : mComposerService(mgr) { }
};
mDeathObserver = new DeathObserver(*const_cast<ComposerService*>(this));
--- /dev/null
+// Build the unit tests,
+
+// Build the binary to $(TARGET_OUT_DATA_NATIVE_TESTS)/$(LOCAL_MODULE)
+// to integrate with auto-test framework.
+cc_test {
+ name: "libgui_test",
+
+ clang: true,
+
+ srcs: [
+ "BufferQueue_test.cpp",
+ "CpuConsumer_test.cpp",
+ "FillBuffer.cpp",
+ "GLTest.cpp",
+ "IGraphicBufferProducer_test.cpp",
+ "MultiTextureConsumer_test.cpp",
+ "Sensor_test.cpp",
+ "SRGB_test.cpp",
+ "StreamSplitter_test.cpp",
+ "SurfaceTextureClient_test.cpp",
+ "SurfaceTextureFBO_test.cpp",
+ "SurfaceTextureGLThreadToGL_test.cpp",
+ "SurfaceTextureGLToGL_test.cpp",
+ "SurfaceTextureGL_test.cpp",
+ "SurfaceTextureMultiContextGL_test.cpp",
+ "Surface_test.cpp",
+ "TextureRenderer.cpp",
+ ],
+
+ shared_libs: [
+ "liblog",
+ "libEGL",
+ "libGLESv1_CM",
+ "libGLESv2",
+ "libbinder",
+ "libcutils",
+ "libgui",
+ "libsync",
+ "libui",
+ "libutils",
+ ],
+}
+++ /dev/null
-# Build the unit tests,
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-
-LOCAL_CLANG := true
-
-LOCAL_MODULE := libgui_test
-
-LOCAL_MODULE_TAGS := tests
-
-LOCAL_SRC_FILES := \
- BufferQueue_test.cpp \
- CpuConsumer_test.cpp \
- FillBuffer.cpp \
- GLTest.cpp \
- IGraphicBufferProducer_test.cpp \
- MultiTextureConsumer_test.cpp \
- SRGB_test.cpp \
- StreamSplitter_test.cpp \
- SurfaceTextureClient_test.cpp \
- SurfaceTextureFBO_test.cpp \
- SurfaceTextureGLThreadToGL_test.cpp \
- SurfaceTextureGLToGL_test.cpp \
- SurfaceTextureGL_test.cpp \
- SurfaceTextureMultiContextGL_test.cpp \
- Surface_test.cpp \
- TextureRenderer.cpp \
-
-LOCAL_SHARED_LIBRARIES := \
- libEGL \
- libGLESv1_CM \
- libGLESv2 \
- libbinder \
- libcutils \
- libgui \
- libsync \
- libui \
- libutils \
-
-# Build the binary to $(TARGET_OUT_DATA_NATIVE_TESTS)/$(LOCAL_MODULE)
-# to integrate with auto-test framework.
-include $(BUILD_NATIVE_TEST)
-
-# Include subdirectory makefiles
-# ============================================================
-
-# If we're building with ONE_SHOT_MAKEFILE (mm, mmm), then what the framework
-# team really wants is to build the stuff defined by this makefile.
-ifeq (,$(ONE_SHOT_MAKEFILE))
-include $(call first-makefiles-under,$(LOCAL_PATH))
-endif
// Check no free buffers in dump
String8 dumpString;
- mConsumer->dump(dumpString, nullptr);
+ mConsumer->dumpState(dumpString, nullptr);
// Parse the dump to ensure that all buffer slots that are FREE also
// have a null GraphicBuffer
};
#define ASSERT_NO_ERROR(err, msg) \
- ASSERT_EQ(NO_ERROR, err) << msg << strerror(-err)
+ ASSERT_EQ(NO_ERROR, err) << (msg) << strerror(-(err))
void checkPixel(const CpuConsumer::LockedBuffer &buf,
uint32_t x, uint32_t y, uint32_t r, uint32_t g=0, uint32_t b=0) {
--- /dev/null
+/*
+ * Copyright (C) 2012 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.
+ */
+
+#define LOG_TAG "Sensor_test"
+
+#include <gui/Sensor.h>
+#include <hardware/sensors.h>
+#include <utils/Errors.h>
+
+#include <gtest/gtest.h>
+
+namespace android {
+
+// Returns true if the two sensors have the same attributes. Does not compare
+// UUID since that should not be transmitted via flatten/unflatten.
+static bool sensorsMatch(const Sensor& a, const Sensor& b) {
+ return a.getName() == b.getName () &&
+ a.getVendor() == b.getVendor () &&
+ a.getHandle() == b.getHandle () &&
+ a.getType() == b.getType () &&
+ a.getMinValue() == b.getMinValue () &&
+ a.getMaxValue() == b.getMaxValue () &&
+ a.getResolution() == b.getResolution () &&
+ a.getPowerUsage() == b.getPowerUsage () &&
+ a.getMinDelay() == b.getMinDelay () &&
+ a.getMinDelayNs() == b.getMinDelayNs () &&
+ a.getVersion() == b.getVersion () &&
+ a.getFifoReservedEventCount() == b.getFifoReservedEventCount () &&
+ a.getFifoMaxEventCount() == b.getFifoMaxEventCount () &&
+ a.getStringType() == b.getStringType () &&
+ a.getRequiredPermission() == b.getRequiredPermission () &&
+ a.isRequiredPermissionRuntime() == b.isRequiredPermissionRuntime () &&
+ a.getRequiredAppOp() == b.getRequiredAppOp () &&
+ a.getMaxDelay() == b.getMaxDelay () &&
+ a.getFlags() == b.getFlags () &&
+ a.isWakeUpSensor() == b.isWakeUpSensor () &&
+ a.isDynamicSensor() == b.isDynamicSensor () &&
+ a.hasAdditionalInfo() == b.hasAdditionalInfo () &&
+ a.getReportingMode() == b.getReportingMode();
+}
+
+// Creates and returns a sensor_t struct with some default values filled in.
+static sensor_t getTestSensorT() {
+ sensor_t hwSensor = {};
+ hwSensor.name = "Test Sensor";
+ hwSensor.vendor = "Test Vendor";
+ hwSensor.version = 1;
+ hwSensor.handle = 2;
+ hwSensor.type = SENSOR_TYPE_ACCELEROMETER;
+ hwSensor.maxRange = 10.f;
+ hwSensor.resolution = 1.f;
+ hwSensor.power = 5.f;
+ hwSensor.minDelay = 1000;
+ hwSensor.fifoReservedEventCount = 50;
+ hwSensor.fifoMaxEventCount = 100;
+ hwSensor.stringType = SENSOR_STRING_TYPE_ACCELEROMETER;
+ hwSensor.requiredPermission = "";
+ hwSensor.maxDelay = 5000;
+ hwSensor.flags = SENSOR_FLAG_CONTINUOUS_MODE;
+ return hwSensor;
+}
+
+TEST(SensorTest, FlattenAndUnflatten) {
+ sensor_t hwSensor = getTestSensorT();
+ Sensor sensor1(&hwSensor, SENSORS_DEVICE_API_VERSION_1_4);
+ Sensor sensor2;
+
+ std::vector<uint8_t> buffer(sensor1.getFlattenedSize());
+ ASSERT_EQ(OK, sensor1.flatten(buffer.data(), buffer.size()));
+ ASSERT_EQ(OK, sensor2.unflatten(buffer.data(), buffer.size()));
+
+ EXPECT_TRUE(sensorsMatch(sensor1, sensor2));
+}
+
+} // namespace android
return false;
}
public:
- MyThread(const sp<GLConsumer>& mST)
+ explicit MyThread(const sp<GLConsumer>& mST)
: mST(mST), mBufferRetired(false) {
ctx = eglGetCurrentContext();
sur = eglGetCurrentSurface(EGL_DRAW);
class ProducerThread : public Thread {
public:
- ProducerThread(const sp<ANativeWindow>& anw):
+
explicit ProducerThread(const sp<ANativeWindow>& anw):
mANW(anw) {
}
TEST_F(SurfaceTextureGLTest, AbandonUnblocksDequeueBuffer) {
class ProducerThread : public Thread {
public:
- ProducerThread(const sp<ANativeWindow>& anw):
+
explicit ProducerThread(const sp<ANativeWindow>& anw):
mANW(anw),
mDequeueError(NO_ERROR) {
}
--- /dev/null
+// Copyright (C) 2013 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.
+
+// libinput is partially built for the host (used by build time keymap validation tool)
+
+cc_library {
+ name: "libinput",
+ host_supported: true,
+
+ srcs: [
+ "Input.cpp",
+ "InputDevice.cpp",
+ "Keyboard.cpp",
+ "KeyCharacterMap.cpp",
+ "KeyLayoutMap.cpp",
+ "VirtualKeyMap.cpp",
+ ],
+
+ clang: true,
+ sanitize: {
+ misc_undefined: ["integer"],
+ },
+
+ shared_libs: [
+ "liblog",
+ "libcutils",
+ ],
+
+ target: {
+ android: {
+ srcs: [
+ "IInputFlinger.cpp",
+ "InputTransport.cpp",
+ "VelocityControl.cpp",
+ "VelocityTracker.cpp",
+ ],
+
+ shared_libs: [
+ "libutils",
+ "libbinder",
+ ],
+ },
+ host: {
+ shared: {
+ enabled: false,
+ },
+ },
+ },
+}
+
+subdirs = ["tests"]
+++ /dev/null
-# Copyright (C) 2013 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.
-
-LOCAL_PATH:= $(call my-dir)
-
-# libinput is partially built for the host (used by build time keymap validation tool)
-# These files are common to host and target builds.
-
-commonSources := \
- Input.cpp \
- InputDevice.cpp \
- Keyboard.cpp \
- KeyCharacterMap.cpp \
- KeyLayoutMap.cpp \
- VirtualKeyMap.cpp
-
-deviceSources := \
- $(commonSources) \
- IInputFlinger.cpp \
- InputTransport.cpp \
- VelocityControl.cpp \
- VelocityTracker.cpp
-
-hostSources := \
- $(commonSources)
-
-# For the host
-# =====================================================
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= $(hostSources)
-
-LOCAL_MODULE:= libinput
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_HOST_STATIC_LIBRARY)
-
-
-# For the device
-# =====================================================
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= $(deviceSources)
-
-LOCAL_CLANG := true
-LOCAL_SANITIZE := integer
-
-LOCAL_SHARED_LIBRARIES := \
- liblog \
- libcutils \
- libutils \
- libbinder
-
-LOCAL_MODULE:= libinput
-
-LOCAL_MODULE_TAGS := optional
-
-include $(BUILD_SHARED_LIBRARY)
-
-
-# Include subdirectory makefiles
-# ============================================================
-
-# If we're building with ONE_SHOT_MAKEFILE (mm, mmm), then what the framework
-# team really wants is to build the stuff defined by this makefile.
-ifeq (,$(ONE_SHOT_MAKEFILE))
-include $(call first-makefiles-under,$(LOCAL_PATH))
-endif
class BpInputFlinger : public BpInterface<IInputFlinger> {
public:
- BpInputFlinger(const sp<IBinder>& impl) :
+ explicit BpInputFlinger(const sp<IBinder>& impl) :
BpInterface<IInputFlinger>(impl) { }
virtual status_t doSomething() {
--- /dev/null
+// Build the unit tests.
+cc_test {
+ name: "libinput_tests",
+ test_per_src: true,
+ srcs: [
+ "InputChannel_test.cpp",
+ "InputEvent_test.cpp",
+ "InputPublisherAndConsumer_test.cpp",
+ ],
+ shared_libs: [
+ "libinput",
+ "libcutils",
+ "libutils",
+ "libbinder",
+ "libui",
+ ]
+}
+
+// NOTE: This is a compile time test, and does not need to be
+// run. All assertions are static_asserts and will fail during
+// buildtime if something's wrong.
+cc_library_static {
+ name: "StructLayout_test",
+ srcs: ["StructLayout_test.cpp"],
+ cflags: [
+ "-O0",
+ ],
+}
+++ /dev/null
-# Build the unit tests.
-LOCAL_PATH:= $(call my-dir)
-
-# Build the unit tests.
-test_src_files := \
- InputChannel_test.cpp \
- InputEvent_test.cpp \
- InputPublisherAndConsumer_test.cpp
-
-shared_libraries := \
- libinput \
- libcutils \
- libutils \
- libbinder \
- libui \
-
-$(foreach file,$(test_src_files), \
- $(eval include $(CLEAR_VARS)) \
- $(eval LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk) \
- $(eval LOCAL_SHARED_LIBRARIES := $(shared_libraries)) \
- $(eval LOCAL_STATIC_LIBRARIES := $(static_libraries)) \
- $(eval LOCAL_SRC_FILES := $(file)) \
- $(eval LOCAL_MODULE := $(notdir $(file:%.cpp=%))) \
- $(eval include $(BUILD_NATIVE_TEST)) \
-)
-
-# NOTE: This is a compile time test, and does not need to be
-# run. All assertions are static_asserts and will fail during
-# buildtime if something's wrong.
-include $(CLEAR_VARS)
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-LOCAL_SRC_FILES := StructLayout_test.cpp
-LOCAL_MODULE := StructLayout_test
-LOCAL_CFLAGS := -std=c++11 -O0
-LOCAL_MULTILIB := both
-include $(BUILD_STATIC_LIBRARY)
-
-
-# Build the manual test programs.
-include $(call all-makefiles-under, $(LOCAL_PATH))
namespace android {
#define CHECK_OFFSET(type, member, expected_offset) \
- static_assert((offsetof(type, member) == expected_offset), "")
+ static_assert((offsetof(type, member) == (expected_offset)), "")
struct Foo {
uint32_t dummy;
--- /dev/null
+// Copyright (C) 2010 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: "libui",
+
+ clang: true,
+ cppflags: [
+ "-Weverything",
+ "-Werror",
+
+ // The static constructors and destructors in this library have not been noted to
+ // introduce significant overheads
+ "-Wno-exit-time-destructors",
+ "-Wno-global-constructors",
+
+ // We only care about compiling as C++14
+ "-Wno-c++98-compat-pedantic",
+
+ // We use four-character constants for the GraphicBuffer header, and don't care
+ // that they're non-portable as long as they're consistent within one execution
+ "-Wno-four-char-constants",
+
+ // Don't warn about struct padding
+ "-Wno-padded",
+ ],
+
+ sanitize: {
+ //misc_undefined: ["integer"],
+ },
+
+ srcs: [
+ "Fence.cpp",
+ "FrameStats.cpp",
+ "Gralloc1.cpp",
+ "Gralloc1On0Adapter.cpp",
+ "GraphicBuffer.cpp",
+ "GraphicBufferAllocator.cpp",
+ "GraphicBufferMapper.cpp",
+ "HdrCapabilities.cpp",
+ "PixelFormat.cpp",
+ "Rect.cpp",
+ "Region.cpp",
+ "UiConfig.cpp",
+ ],
+
+ shared_libs: [
+ "libbinder",
+ "libcutils",
+ "libhardware",
+ "libsync",
+ "libutils",
+ "liblog",
+ ],
+}
+
+subdirs = ["tests"]
+++ /dev/null
-# Copyright (C) 2010 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.
-
-LOCAL_PATH := $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_CLANG := true
-LOCAL_CPPFLAGS := -std=c++1y -Weverything -Werror
-# LOCAL_SANITIZE := integer
-
-# The static constructors and destructors in this library have not been noted to
-# introduce significant overheads
-LOCAL_CPPFLAGS += -Wno-exit-time-destructors
-LOCAL_CPPFLAGS += -Wno-global-constructors
-
-# We only care about compiling as C++14
-LOCAL_CPPFLAGS += -Wno-c++98-compat-pedantic
-
-# We use four-character constants for the GraphicBuffer header, and don't care
-# that they're non-portable as long as they're consistent within one execution
-LOCAL_CPPFLAGS += -Wno-four-char-constants
-
-# Don't warn about struct padding
-LOCAL_CPPFLAGS += -Wno-padded
-
-LOCAL_SRC_FILES := \
- Fence.cpp \
- FrameStats.cpp \
- Gralloc1.cpp \
- Gralloc1On0Adapter.cpp \
- GraphicBuffer.cpp \
- GraphicBufferAllocator.cpp \
- GraphicBufferMapper.cpp \
- HdrCapabilities.cpp \
- PixelFormat.cpp \
- Rect.cpp \
- Region.cpp \
- UiConfig.cpp
-
-LOCAL_SHARED_LIBRARIES := \
- libbinder \
- libcutils \
- libhardware \
- libsync \
- libutils \
- liblog
-
-ifneq ($(BOARD_FRAMEBUFFER_FORCE_FORMAT),)
-LOCAL_CFLAGS += -DFRAMEBUFFER_FORCE_FORMAT=$(BOARD_FRAMEBUFFER_FORCE_FORMAT)
-endif
-
-LOCAL_MODULE := libui
-
-include $(BUILD_SHARED_LIBRARY)
-
-
-# Include subdirectory makefiles
-# ============================================================
-
-# If we're building with ONE_SHOT_MAKEFILE (mm, mmm), then what the framework
-# team really wants is to build the stuff defined by this makefile.
-ifeq (,$(ONE_SHOT_MAKEFILE))
-include $(call first-makefiles-under,$(LOCAL_PATH))
-endif
Region& Region::subtractSelf(const Rect& r) {
return operationSelf(r, op_nand);
}
-Region& Region::operationSelf(const Rect& r, int op) {
+Region& Region::operationSelf(const Rect& r, uint32_t op) {
Region lhs(*this);
boolean_operation(op, *this, lhs, r);
return *this;
Region& Region::subtractSelf(const Region& rhs) {
return operationSelf(rhs, op_nand);
}
-Region& Region::operationSelf(const Region& rhs, int op) {
+Region& Region::operationSelf(const Region& rhs, uint32_t op) {
Region lhs(*this);
boolean_operation(op, *this, lhs, rhs);
return *this;
const Region Region::subtract(const Rect& rhs) const {
return operation(rhs, op_nand);
}
-const Region Region::operation(const Rect& rhs, int op) const {
+const Region Region::operation(const Rect& rhs, uint32_t op) const {
Region result;
boolean_operation(op, result, *this, rhs);
return result;
const Region Region::subtract(const Region& rhs) const {
return operation(rhs, op_nand);
}
-const Region Region::operation(const Region& rhs, int op) const {
+const Region Region::operation(const Region& rhs, uint32_t op) const {
Region result;
boolean_operation(op, result, *this, rhs);
return result;
Region& Region::subtractSelf(const Region& rhs, int dx, int dy) {
return operationSelf(rhs, dx, dy, op_nand);
}
-Region& Region::operationSelf(const Region& rhs, int dx, int dy, int op) {
+Region& Region::operationSelf(const Region& rhs, int dx, int dy, uint32_t op) {
Region lhs(*this);
boolean_operation(op, *this, lhs, rhs, dx, dy);
return *this;
const Region Region::subtract(const Region& rhs, int dx, int dy) const {
return operation(rhs, dx, dy, op_nand);
}
-const Region Region::operation(const Region& rhs, int dx, int dy, int op) const {
+const Region Region::operation(const Region& rhs, int dx, int dy, uint32_t op) const {
Region result;
boolean_operation(op, result, *this, rhs, dx, dy);
return result;
Vector<Rect> span;
Rect* cur;
public:
- rasterizer(Region& reg)
+ explicit rasterizer(Region& reg)
: bounds(INT_MAX, 0, INT_MIN, 0), storage(reg.mStorage), head(), tail(), cur() {
storage.clear();
}
merge = false;
break;
}
- p++, q++;
+ p++;
+ q++;
}
}
}
return result;
}
-void Region::boolean_operation(int op, Region& dst,
+void Region::boolean_operation(uint32_t op, Region& dst,
const Region& lhs,
const Region& rhs, int dx, int dy)
{
#endif
}
-void Region::boolean_operation(int op, Region& dst,
+void Region::boolean_operation(uint32_t op, Region& dst,
const Region& lhs,
const Rect& rhs, int dx, int dy)
{
#endif
}
-void Region::boolean_operation(int op, Region& dst,
+void Region::boolean_operation(uint32_t op, Region& dst,
const Region& lhs, const Region& rhs)
{
boolean_operation(op, dst, lhs, rhs, 0, 0);
}
-void Region::boolean_operation(int op, Region& dst,
+void Region::boolean_operation(uint32_t op, Region& dst,
const Region& lhs, const Rect& rhs)
{
boolean_operation(op, dst, lhs, rhs, 0, 0);
namespace android {
-#ifdef FRAMEBUFFER_FORCE_FORMAT
-// We need the two-level macro to stringify the contents of a macro argument
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-#endif
-
void appendUiConfigString(String8& configStr)
{
static const char* config =
- " [libui"
-#ifdef FRAMEBUFFER_FORCE_FORMAT
- " FRAMEBUFFER_FORCE_FORMAT=" TOSTRING(FRAMEBUFFER_FORCE_FORMAT)
-#endif
- "]";
+ " [libui]";
configStr.append(config);
}
--- /dev/null
+//
+// Copyright (C) 2014 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_test {
+ name: "Region_test",
+ shared_libs: ["libui"],
+ srcs: ["Region_test.cpp"],
+}
+
+cc_test {
+ name: "vec_test",
+ srcs: ["vec_test.cpp"],
+}
+
+cc_test {
+ name: "mat_test",
+ srcs: ["mat_test.cpp"],
+}
+++ /dev/null
-#
-# Copyright (C) 2014 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.
-#
-
-LOCAL_PATH := $(call my-dir)
-
-include $(CLEAR_VARS)
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-LOCAL_SHARED_LIBRARIES := libui
-LOCAL_SRC_FILES := Region_test.cpp
-LOCAL_MODULE := Region_test
-include $(BUILD_NATIVE_TEST)
-
-include $(CLEAR_VARS)
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-LOCAL_SRC_FILES := vec_test.cpp
-LOCAL_MODULE := vec_test
-include $(BUILD_NATIVE_TEST)
-
-include $(CLEAR_VARS)
-LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
-LOCAL_SRC_FILES := mat_test.cpp
-LOCAL_MODULE := mat_test
-include $(BUILD_NATIVE_TEST)
--- /dev/null
+// Copyright (C) 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.
+
+ndk_headers {
+ name: "libEGL_headers",
+ from: "include",
+ to: "",
+ srcs: ["include/EGL/**/*.h"],
+ license: "include/EGL/NOTICE",
+}
+
+ndk_headers {
+ name: "libGLESv1_CM_headers",
+ from: "include",
+ to: "",
+ srcs: ["include/GLES/**/*.h"],
+ license: "include/GLES/NOTICE",
+}
+
+ndk_headers {
+ name: "libGLESv2_headers",
+ from: "include",
+ to: "",
+ srcs: ["include/GLES2/**/*.h"],
+ license: "include/GLES2/NOTICE",
+}
+
+ndk_headers {
+ name: "libGLESv3_headers",
+ from: "include",
+ to: "",
+ srcs: ["include/GLES3/**/*.h"],
+ license: "include/GLES3/NOTICE",
+}
+
+ndk_headers {
+ name: "khr_headers",
+ from: "include",
+ to: "",
+ srcs: ["include/KHR/**/*.h"],
+ license: "include/KHR/NOTICE",
+}
+
+subdirs = [
+ "*",
+]
--- /dev/null
+Copyright (c) 2007-2009 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
#define EGL_TRUE 1
/* Out-of-band handle values */
-#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
-#define EGL_NO_CONTEXT ((EGLContext)0)
-#define EGL_NO_DISPLAY ((EGLDisplay)0)
-#define EGL_NO_SURFACE ((EGLSurface)0)
+#define EGL_DEFAULT_DISPLAY EGL_CAST(EGLNativeDisplayType, 0)
+#define EGL_NO_CONTEXT EGL_CAST(EGLContext, 0)
+#define EGL_NO_DISPLAY EGL_CAST(EGLDisplay, 0)
+#define EGL_NO_SURFACE EGL_CAST(EGLSurface, 0)
/* Out-of-band attribute value */
-#define EGL_DONT_CARE ((EGLint)-1)
+#define EGL_DONT_CARE EGL_CAST(EGLint, -1)
/* Errors / GetError return values */
#define EGL_SUCCESS 0x3000
#define EGL_DISPLAY_SCALING 10000
/* Unknown display resolution/aspect ratio */
-#define EGL_UNKNOWN ((EGLint)-1)
+#define EGL_UNKNOWN EGL_CAST(EGLint, -1)
/* Back buffer swap behaviors */
#define EGL_BUFFER_PRESERVED 0x3094 /* EGL_SWAP_BEHAVIOR value */
#define EGL_KHR_image 1
#define EGL_NATIVE_PIXMAP_KHR 0x30B0 /* eglCreateImageKHR target */
typedef void *EGLImageKHR;
-#define EGL_NO_IMAGE_KHR ((EGLImageKHR)0)
+#define EGL_NO_IMAGE_KHR EGL_CAST(EGLImageKHR, 0)
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);
#define EGL_GL_TEXTURE_ZOFFSET_KHR 0x30BD /* eglCreateImageKHR attribute */
#endif
+#ifndef EGL_KHR_gl_colorspace
+#define EGL_KHR_gl_colorspace 1
+#define EGL_GL_COLORSPACE_KHR 0x309D
+#define EGL_GL_COLORSPACE_SRGB_KHR 0x3089
+#define EGL_GL_COLORSPACE_LINEAR_KHR 0x308A
+#endif
+
#ifndef EGL_KHR_gl_renderbuffer_image
#define EGL_KHR_gl_renderbuffer_image 1
#define EGL_GL_RENDERBUFFER_KHR 0x30B9 /* eglCreateImageKHR target */
#define EGL_SYNC_REUSABLE_KHR 0x30FA
#define EGL_SYNC_FLUSH_COMMANDS_BIT_KHR 0x0001 /* eglClientWaitSyncKHR <flags> bitfield */
#define EGL_FOREVER_KHR 0xFFFFFFFFFFFFFFFFull
-#define EGL_NO_SYNC_KHR ((EGLSyncKHR)0)
+#define EGL_NO_SYNC_KHR EGL_CAST(EGLSyncKHR, 0)
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLSyncKHR EGLAPIENTRY eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync);
#define EGL_SYNC_TYPE_NV 0x30ED
#define EGL_SYNC_CONDITION_NV 0x30EE
#define EGL_SYNC_FENCE_NV 0x30EF
-#define EGL_NO_SYNC_NV ((EGLSyncNV)0)
+#define EGL_NO_SYNC_NV EGL_CAST(EGLSyncNV, 0)
typedef void* EGLSyncNV;
typedef khronos_utime_nanoseconds_t EGLTimeNV;
#ifdef EGL_EGLEXT_PROTOTYPES
#define EGL_KHR_stream 1
typedef void* EGLStreamKHR;
typedef khronos_uint64_t EGLuint64KHR;
-#define EGL_NO_STREAM_KHR ((EGLStreamKHR)0)
+#define EGL_NO_STREAM_KHR EGL_CAST(EGLStreamKHR, 0)
#define EGL_CONSUMER_LATENCY_USEC_KHR 0x3210
#define EGL_PRODUCER_FRAME_KHR 0x3212
#define EGL_CONSUMER_FRAME_KHR 0x3213
#ifndef EGL_KHR_stream_cross_process_fd
#define EGL_KHR_stream_cross_process_fd 1
typedef int EGLNativeFileDescriptorKHR;
-#define EGL_NO_FILE_DESCRIPTOR_KHR ((EGLNativeFileDescriptorKHR)(-1))
+#define EGL_NO_FILE_DESCRIPTOR_KHR EGL_CAST(EGLNativeFileDescriptorKHR, -1)
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLNativeFileDescriptorKHR EGLAPIENTRY eglGetStreamFileDescriptorKHR(EGLDisplay dpy, EGLStreamKHR stream);
EGLAPI EGLStreamKHR EGLAPIENTRY eglCreateStreamFromFileDescriptorKHR(EGLDisplay dpy, EGLNativeFileDescriptorKHR file_descriptor);
#define EGL_SYNC_NATIVE_FENCE_ANDROID 0x3144
#define EGL_SYNC_NATIVE_FENCE_FD_ANDROID 0x3145
#define EGL_SYNC_NATIVE_FENCE_SIGNALED_ANDROID 0x3146
-#define EGL_NO_NATIVE_FENCE_FD_ANDROID -1
+#define EGL_NO_NATIVE_FENCE_FD_ANDROID (-1)
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLint EGLAPIENTRY eglDupNativeFenceFDANDROID( EGLDisplay dpy, EGLSyncKHR);
#endif /* EGL_EGLEXT_PROTOTYPES */
#ifdef EGL_EGLEXT_PROTOTYPES
EGLAPI EGLClientBuffer eglCreateNativeClientBufferANDROID (const EGLint *attrib_list);
#else
-typedef EGLAPI EGLClientBuffer (EGLAPIENTRYP PFNEGLCREATENATIVECLIENTBUFFERANDROID) (const EGLint *attrib_list);
+typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLCREATENATIVECLIENTBUFFERANDROID) (const EGLint *attrib_list);
#endif
#endif
*/
typedef khronos_int32_t EGLint;
+#if defined(__cplusplus)
+#define EGL_CAST(type, value) (static_cast<type>(value))
+#else
+#define EGL_CAST(type, value) ((type) (value))
+#endif
+
#endif /* __eglplatform_h */
--- /dev/null
+This document is licensed under the SGI Free Software B License Version 2.0.
+For details, see http://oss.sgi.com/projects/FreeB/ .
--- /dev/null
+Copyright (c) 2013-2015 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
--- /dev/null
+Copyright (c) 2013-2015 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
--- /dev/null
+Copyright (c) 2008-2009 The Khronos Group Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and/or associated documentation files (the
+"Materials"), to deal in the Materials without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Materials, and to
+permit persons to whom the Materials are furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Materials.
+
+THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
.text
- .align
+ .align 4
/*
* this version rounds-to-nearest and saturates numbers
--- /dev/null
+// Build the ETC1 library
+cc_library {
+ name: "libETC1",
+ srcs: ["ETC1/etc1.cpp"],
+ host_supported: true,
+
+ target: {
+ android: {
+ static: {
+ enabled: false,
+ },
+ },
+ host: {
+ shared: {
+ enabled: false,
+ },
+ },
+ windows: {
+ enabled: true,
+ },
+ },
+}
+
+// The headers modules are in frameworks/native/opengl/Android.bp.
+ndk_library {
+ name: "libEGL.ndk",
+ symbol_file: "libEGL.map.txt",
+ first_version: "9",
+}
+
+ndk_library {
+ name: "libGLESv1_CM.ndk",
+ symbol_file: "libGLESv1_CM.map.txt",
+ first_version: "9",
+}
+
+ndk_library {
+ name: "libGLESv2.ndk",
+ symbol_file: "libGLESv2.map.txt",
+ first_version: "9",
+}
+
+ndk_library {
+ name: "libGLESv3.ndk",
+ symbol_file: "libGLESv3.map.txt",
+ first_version: "18",
+}
+
+cc_defaults {
+ name: "gl_libs_defaults",
+ cflags: [
+ "-DGL_GLEXT_PROTOTYPES",
+ "-DEGL_EGLEXT_PROTOTYPES",
+ "-fvisibility=hidden",
+ ],
+ shared_libs: [
+ "libcutils",
+ "liblog",
+ "libdl",
+ ],
+
+ // we need to access the private Bionic header <bionic_tls.h>
+ include_dirs: ["bionic/libc/private"],
+}
+
+//##############################################################################
+// Build META EGL library
+//
+cc_defaults {
+ name: "egl_libs_defaults",
+ defaults: ["gl_libs_defaults"],
+ cflags: [
+ "-DLOG_TAG=\"libEGL\"",
+ ],
+ shared_libs: [
+ "libbinder",
+ "libutils",
+ "libui",
+ ],
+}
+
+cc_library_static {
+ name: "libEGL_getProcAddress",
+ defaults: ["egl_libs_defaults"],
+ srcs: ["EGL/getProcAddress.cpp"],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+ },
+ },
+}
+
+cc_library_shared {
+ name: "libEGL",
+ defaults: ["egl_libs_defaults"],
+ srcs: [
+ "EGL/egl_tls.cpp",
+ "EGL/egl_cache.cpp",
+ "EGL/egl_display.cpp",
+ "EGL/egl_object.cpp",
+ "EGL/egl.cpp",
+ "EGL/eglApi.cpp",
+ "EGL/Loader.cpp",
+ ],
+ static_libs: ["libEGL_getProcAddress"],
+ ldflags: ["-Wl,--exclude-libs=ALL"],
+
+ required: ["egl.cfg"],
+}
+
+cc_defaults {
+ name: "gles_libs_defaults",
+ defaults: ["gl_libs_defaults"],
+ arch: {
+ arm: {
+ instruction_set: "arm",
+
+ // TODO: This is to work around b/20093774. Remove after root cause is fixed
+ ldflags: ["-Wl,--hash-style,both"],
+ },
+ },
+ shared_libs: ["libEGL"],
+}
+
+//##############################################################################
+// Build the wrapper OpenGL ES 1.x library
+//
+cc_library_shared {
+ name: "libGLESv1_CM",
+ defaults: ["gles_libs_defaults"],
+ srcs: ["GLES_CM/gl.cpp"],
+
+ cflags: ["-DLOG_TAG=\"libGLESv1\""],
+}
+
+//##############################################################################
+// Build the wrapper OpenGL ES 2.x library
+//
+cc_library_shared {
+ name: "libGLESv2",
+ defaults: ["gles_libs_defaults"],
+ srcs: ["GLES2/gl2.cpp"],
+
+ shared_libs: ["libutils"],
+
+ cflags: ["-DLOG_TAG=\"libGLESv2\""],
+}
+
+//##############################################################################
+// Build the wrapper OpenGL ES 3.x library (this is just different name for v2)
+//
+cc_library_shared {
+ name: "libGLESv3",
+ defaults: ["gles_libs_defaults"],
+ srcs: ["GLES2/gl2.cpp"],
+
+ shared_libs: ["libutils"],
+
+ cflags: ["-DLOG_TAG=\"libGLESv3\""],
+}
LOCAL_PATH:= $(call my-dir)
-###############################################################################
-# Build META EGL library
-#
-
-egl.cfg_config_module :=
# OpenGL drivers config file
ifneq ($(BOARD_EGL_CFG),)
-
include $(CLEAR_VARS)
LOCAL_MODULE := egl.cfg
LOCAL_MODULE_TAGS := optional
LOCAL_MODULE_PATH := $(TARGET_OUT)/lib/egl
LOCAL_SRC_FILES := ../../../../$(BOARD_EGL_CFG)
include $(BUILD_PREBUILT)
-egl.cfg_config_module := $(LOCAL_MODULE)
endif
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- EGL/egl_tls.cpp \
- EGL/egl_cache.cpp \
- EGL/egl_display.cpp \
- EGL/egl_object.cpp \
- EGL/egl.cpp \
- EGL/eglApi.cpp \
- EGL/getProcAddress.cpp.arm \
- EGL/Loader.cpp \
-#
-
-LOCAL_SHARED_LIBRARIES += libbinder libcutils libutils liblog libui
-LOCAL_MODULE:= libEGL
-LOCAL_LDFLAGS += -Wl,--exclude-libs=ALL
-LOCAL_SHARED_LIBRARIES += libdl
-# we need to access the private Bionic header <bionic_tls.h>
-LOCAL_C_INCLUDES += bionic/libc/private
-
-LOCAL_CFLAGS += -DLOG_TAG=\"libEGL\"
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
-LOCAL_CFLAGS += -fvisibility=hidden
-
-ifeq ($(BOARD_ALLOW_EGL_HIBERNATION),true)
- LOCAL_CFLAGS += -DBOARD_ALLOW_EGL_HIBERNATION
-endif
-ifneq ($(MAX_EGL_CACHE_ENTRY_SIZE),)
- LOCAL_CFLAGS += -DMAX_EGL_CACHE_ENTRY_SIZE=$(MAX_EGL_CACHE_ENTRY_SIZE)
-endif
-
-ifneq ($(MAX_EGL_CACHE_KEY_SIZE),)
- LOCAL_CFLAGS += -DMAX_EGL_CACHE_KEY_SIZE=$(MAX_EGL_CACHE_KEY_SIZE)
-endif
-
-ifneq ($(MAX_EGL_CACHE_SIZE),)
- LOCAL_CFLAGS += -DMAX_EGL_CACHE_SIZE=$(MAX_EGL_CACHE_SIZE)
-endif
-
-ifneq ($(filter address,$(SANITIZE_TARGET)),)
- LOCAL_CFLAGS_32 += -DEGL_WRAPPER_DIR=\"/$(TARGET_COPY_OUT_DATA)/lib\"
- LOCAL_CFLAGS_64 += -DEGL_WRAPPER_DIR=\"/$(TARGET_COPY_OUT_DATA)/lib64\"
-endif
-
-LOCAL_REQUIRED_MODULES := $(egl.cfg_config_module)
-egl.cfg_config_module :=
-
-include $(BUILD_SHARED_LIBRARY)
-
-###############################################################################
-# Build the wrapper OpenGL ES 1.x library
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- GLES_CM/gl.cpp.arm \
-#
-
-LOCAL_CLANG := false
-LOCAL_SHARED_LIBRARIES += libcutils liblog libEGL
-LOCAL_MODULE:= libGLESv1_CM
-
-LOCAL_SHARED_LIBRARIES += libdl
-# we need to access the private Bionic header <bionic_tls.h>
-LOCAL_C_INCLUDES += bionic/libc/private
-
-LOCAL_CFLAGS += -DLOG_TAG=\"libGLESv1\"
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
-LOCAL_CFLAGS += -fvisibility=hidden
-
-# TODO: This is to work around b/20093774. Remove after root cause is fixed
-LOCAL_LDFLAGS_arm += -Wl,--hash-style,both
-
-include $(BUILD_SHARED_LIBRARY)
-
-
-###############################################################################
-# Build the wrapper OpenGL ES 2.x library
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- GLES2/gl2.cpp \
-#
-
-LOCAL_CLANG := false
-LOCAL_ARM_MODE := arm
-LOCAL_SHARED_LIBRARIES += libcutils libutils liblog libEGL
-LOCAL_MODULE:= libGLESv2
-
-LOCAL_SHARED_LIBRARIES += libdl
-# we need to access the private Bionic header <bionic_tls.h>
-LOCAL_C_INCLUDES += bionic/libc/private
-
-LOCAL_CFLAGS += -DLOG_TAG=\"libGLESv2\"
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
-LOCAL_CFLAGS += -fvisibility=hidden
-
-# TODO: This is to work around b/20093774. Remove after root cause is fixed
-LOCAL_LDFLAGS_arm += -Wl,--hash-style,both
-
-include $(BUILD_SHARED_LIBRARY)
-
-###############################################################################
-# Build the wrapper OpenGL ES 3.x library (this is just different name for v2)
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- GLES2/gl2.cpp \
-#
-
-LOCAL_CLANG := false
-LOCAL_ARM_MODE := arm
-LOCAL_SHARED_LIBRARIES += libcutils libutils liblog libEGL
-LOCAL_MODULE:= libGLESv3
-LOCAL_SHARED_LIBRARIES += libdl
-# we need to access the private Bionic header <bionic_tls.h>
-LOCAL_C_INCLUDES += bionic/libc/private
-
-LOCAL_CFLAGS += -DLOG_TAG=\"libGLESv3\"
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
-LOCAL_CFLAGS += -fvisibility=hidden
-
-# TODO: This is to work around b/20093774. Remove after root cause is fixed
-LOCAL_LDFLAGS_arm += -Wl,--hash-style,both
-
-include $(BUILD_SHARED_LIBRARY)
-
-###############################################################################
-# Build the ETC1 host static library
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- ETC1/etc1.cpp \
-#
-
-LOCAL_MODULE:= libETC1
-LOCAL_MODULE_HOST_OS := darwin linux windows
-
-include $(BUILD_HOST_STATIC_LIBRARY)
-
-###############################################################################
-# Build the ETC1 device library
-#
-
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- ETC1/etc1.cpp \
-#
-
-LOCAL_MODULE:= libETC1
-
-include $(BUILD_SHARED_LIBRARY)
-
-include $(call all-makefiles-under,$(LOCAL_PATH))
GLESv2 = 0x04
};
struct driver_t {
- driver_t(void* gles);
+ explicit driver_t(void* gles);
~driver_t();
status_t set(void* hnd, int32_t api);
void* dso[3];
using namespace android;
-// This extension has not been ratified yet, so can't be shipped.
-// Implementation is incomplete and untested.
-#define ENABLE_EGL_KHR_GL_COLORSPACE 0
-
#define ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS 0
// ----------------------------------------------------------------------------
"EGL_KHR_image_base " // mandatory
"EGL_KHR_image_pixmap "
"EGL_KHR_lock_surface "
-#if (ENABLE_EGL_KHR_GL_COLORSPACE != 0)
"EGL_KHR_gl_colorspace "
-#endif
"EGL_KHR_gl_texture_2D_image "
"EGL_KHR_gl_texture_3D_image "
"EGL_KHR_gl_texture_cubemap_image "
// surfaces
// ----------------------------------------------------------------------------
-// The EGL_KHR_gl_colorspace spec hasn't been ratified yet, so these haven't
-// been added to the Khronos egl.h.
-#define EGL_GL_COLORSPACE_KHR EGL_VG_COLORSPACE
-#define EGL_GL_COLORSPACE_SRGB_KHR EGL_VG_COLORSPACE_sRGB
-#define EGL_GL_COLORSPACE_LINEAR_KHR EGL_VG_COLORSPACE_LINEAR
-
// Turn linear formats into corresponding sRGB formats when colorspace is
// EGL_GL_COLORSPACE_SRGB_KHR, or turn sRGB formats into corresponding linear
// formats when colorspace is EGL_GL_COLORSPACE_LINEAR_KHR. In any cases where
if (attrib_list && dp->haveExtension("EGL_KHR_gl_colorspace")) {
for (const EGLint* attr = attrib_list; *attr != EGL_NONE; attr += 2) {
if (*attr == EGL_GL_COLORSPACE_KHR) {
- if (ENABLE_EGL_KHR_GL_COLORSPACE) {
- dataSpace = modifyBufferDataspace(dataSpace, *(attr+1));
- } else {
- // Normally we'd pass through unhandled attributes to
- // the driver. But in case the driver implements this
- // extension but we're disabling it, we want to prevent
- // it getting through -- support will be broken without
- // our help.
- ALOGE("sRGB window surfaces not supported");
- return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE);
- }
+ dataSpace = modifyBufferDataspace(dataSpace, *(attr+1));
}
}
}
{
clearError();
- // If there is context bound to the thread, release it
- egl_display_t::loseCurrent(get_context(getContext()));
-
egl_connection_t* const cnx = &gEGLImpl;
if (cnx->dso && cnx->egl.eglReleaseThread) {
cnx->egl.eglReleaseThread();
}
+
+ // If there is context bound to the thread, release it
+ egl_display_t::loseCurrent(get_context(getContext()));
+
egl_tls_t::clearTLS();
return EGL_TRUE;
}
#include <sys/types.h>
#include <unistd.h>
-#ifndef MAX_EGL_CACHE_ENTRY_SIZE
-#define MAX_EGL_CACHE_ENTRY_SIZE (16 * 1024);
-#endif
-
-#ifndef MAX_EGL_CACHE_KEY_SIZE
-#define MAX_EGL_CACHE_KEY_SIZE (1024);
-#endif
-
-#ifndef MAX_EGL_CACHE_SIZE
-#define MAX_EGL_CACHE_SIZE (64 * 1024);
-#endif
-
// Cache size limits.
-static const size_t maxKeySize = MAX_EGL_CACHE_KEY_SIZE;
-static const size_t maxValueSize = MAX_EGL_CACHE_ENTRY_SIZE;
-static const size_t maxTotalSize = MAX_EGL_CACHE_SIZE;
+static const size_t maxKeySize = 12 * 1024;
+static const size_t maxValueSize = 64 * 1024;
+static const size_t maxTotalSize = 2 * 1024 * 1024;
// Cache file header
static const char* cacheFileMagic = "EGL$";
*major = VERSION_MAJOR;
if (minor != NULL)
*minor = VERSION_MINOR;
-
- mHibernation.setDisplayValid(true);
}
{
res = EGL_TRUE;
}
- mHibernation.setDisplayValid(false);
-
// Reset the extension string since it will be regenerated if we get
// reinitialized.
mExtensionString.setTo("");
disp.dpy, impl_draw, impl_read, impl_ctx);
if (result == EGL_TRUE) {
c->onMakeCurrent(draw, read);
- if (!cur_c) {
- mHibernation.incWakeCount(HibernationMachine::STRONG);
- }
}
} else {
result = cur_c->cnx->egl.eglMakeCurrent(
disp.dpy, impl_draw, impl_read, impl_ctx);
if (result == EGL_TRUE) {
cur_c->onLooseCurrent();
- mHibernation.decWakeCount(HibernationMachine::STRONG);
}
}
}
}
// ----------------------------------------------------------------------------
-
-bool egl_display_t::HibernationMachine::incWakeCount(WakeRefStrength strength) {
- Mutex::Autolock _l(mLock);
- ALOGE_IF(mWakeCount < 0 || mWakeCount == INT32_MAX,
- "Invalid WakeCount (%d) on enter\n", mWakeCount);
-
- mWakeCount++;
- if (strength == STRONG)
- mAttemptHibernation = false;
-
- if (CC_UNLIKELY(mHibernating)) {
- ALOGV("Awakening\n");
- egl_connection_t* const cnx = &gEGLImpl;
-
- // These conditions should be guaranteed before entering hibernation;
- // we don't want to get into a state where we can't wake up.
- ALOGD_IF(!mDpyValid || !cnx->egl.eglAwakenProcessIMG,
- "Invalid hibernation state, unable to awaken\n");
-
- if (!cnx->egl.eglAwakenProcessIMG()) {
- ALOGE("Failed to awaken EGL implementation\n");
- return false;
- }
- mHibernating = false;
- }
- return true;
-}
-
-void egl_display_t::HibernationMachine::decWakeCount(WakeRefStrength strength) {
- Mutex::Autolock _l(mLock);
- ALOGE_IF(mWakeCount <= 0, "Invalid WakeCount (%d) on leave\n", mWakeCount);
-
- mWakeCount--;
- if (strength == STRONG)
- mAttemptHibernation = true;
-
- if (mWakeCount == 0 && CC_UNLIKELY(mAttemptHibernation)) {
- egl_connection_t* const cnx = &gEGLImpl;
- mAttemptHibernation = false;
- if (mAllowHibernation && mDpyValid &&
- cnx->egl.eglHibernateProcessIMG &&
- cnx->egl.eglAwakenProcessIMG) {
- ALOGV("Hibernating\n");
- if (!cnx->egl.eglHibernateProcessIMG()) {
- ALOGE("Failed to hibernate EGL implementation\n");
- return;
- }
- mHibernating = true;
- }
- }
-}
-
-void egl_display_t::HibernationMachine::setDisplayValid(bool valid) {
- Mutex::Autolock _l(mLock);
- mDpyValid = valid;
-}
-
-// ----------------------------------------------------------------------------
}; // namespace android
// ----------------------------------------------------------------------------
// add reference to this object. returns true if this is a valid object.
bool getObject(egl_object_t* object) const;
- // These notifications allow the display to keep track of how many window
- // surfaces exist, which it uses to decide whether to hibernate the
- // underlying EGL implementation. They can be called by any thread without
- // holding a lock, but must be called via egl_display_ptr to ensure
- // proper hibernate/wakeup sequencing. If a surface destruction triggers
- // hibernation, hibernation will be delayed at least until the calling
- // thread's egl_display_ptr is destroyed.
- void onWindowSurfaceCreated() {
- mHibernation.incWakeCount(HibernationMachine::STRONG);
- }
- void onWindowSurfaceDestroyed() {
- mHibernation.decWakeCount(HibernationMachine::STRONG);
- }
-
static egl_display_t* get(EGLDisplay dpy);
static EGLDisplay getFromNativeDisplay(EGLNativeDisplayType disp);
private:
friend class egl_display_ptr;
- bool enter() { return mHibernation.incWakeCount(HibernationMachine::WEAK); }
- void leave() { return mHibernation.decWakeCount(HibernationMachine::WEAK); }
uint32_t refs;
bool eglIsInitialized;
String8 mVersionString;
String8 mClientApiString;
String8 mExtensionString;
-
- // HibernationMachine uses its own internal mutex to protect its own data.
- // The owning egl_display_t's lock may be but is not required to be held
- // when calling HibernationMachine methods. As a result, nothing in this
- // class may call back up to egl_display_t directly or indirectly.
- class HibernationMachine {
- public:
- // STRONG refs cancel (inc) or initiate (dec) a hibernation attempt
- // the next time the wakecount reaches zero. WEAK refs don't affect
- // whether a hibernation attempt will be made. Use STRONG refs only
- // for infrequent/heavy changes that are likely to indicate the
- // EGLDisplay is entering or leaving a long-term idle state.
- enum WakeRefStrength {
- WEAK = 0,
- STRONG = 1,
- };
-
- HibernationMachine(): mWakeCount(0), mHibernating(false),
- mAttemptHibernation(false), mDpyValid(false),
-#if BOARD_ALLOW_EGL_HIBERNATION
- mAllowHibernation(true)
-#else
- mAllowHibernation(false)
-#endif
- {}
- ~HibernationMachine() {}
-
- bool incWakeCount(WakeRefStrength strenth);
- void decWakeCount(WakeRefStrength strenth);
-
- void setDisplayValid(bool valid);
-
- private:
- Mutex mLock;
- int32_t mWakeCount;
- bool mHibernating;
- bool mAttemptHibernation;
- bool mDpyValid;
- const bool mAllowHibernation;
- };
- HibernationMachine mHibernation;
};
// ----------------------------------------------------------------------------
// as the egl_display_ptr exists.
class egl_display_ptr {
public:
- explicit egl_display_ptr(egl_display_t* dpy): mDpy(dpy) {
- if (mDpy) {
- if (CC_UNLIKELY(!mDpy->enter())) {
- mDpy = NULL;
- }
- }
- }
+ explicit egl_display_ptr(egl_display_t* dpy): mDpy(dpy) {}
// We only really need a C++11 move constructor, not a copy constructor.
// A move constructor would save an enter()/leave() pair on every EGL API
// other.mDpy = NULL;
// }
//
- egl_display_ptr(const egl_display_ptr& other): mDpy(other.mDpy) {
- if (mDpy) {
- mDpy->enter();
- }
- }
-
- ~egl_display_ptr() {
- if (mDpy) {
- mDpy->leave();
- }
- }
+ egl_display_ptr(const egl_display_ptr& other): mDpy(other.mDpy) {}
+
+ ~egl_display_ptr() {}
const egl_display_t* operator->() const { return mDpy; }
egl_display_t* operator->() { return mDpy; }
egl_connection_t const* cnx) :
egl_object_t(dpy), surface(surface), config(config), win(win), cnx(cnx),
enableTimestamps(false), connected(true)
-{
- if (win) {
- getDisplay()->onWindowSurfaceCreated();
- }
-}
+{}
egl_surface_t::~egl_surface_t() {
ANativeWindow* const window = win.get();
if (window != NULL) {
disconnect();
- getDisplay()->onWindowSurfaceDestroyed();
}
}
virtual void terminate();
public:
- egl_object_t(egl_display_t* display);
+ explicit egl_object_t(egl_display_t* display);
void destroy();
inline void incRef() { count.fetch_add(1, std::memory_order_relaxed); }
class LocalRef {
egl_object_t* ref;
LocalRef();
- LocalRef(const LocalRef* rhs);
+ explicit LocalRef(const LocalRef* rhs);
public:
~LocalRef();
explicit LocalRef(egl_object_t* rhs);
#undef API_ENTRY
#undef CALL_GL_API
+#undef CALL_GL_API_INTERNAL_CALL
+#undef CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+#undef CALL_GL_API_INTERNAL_DO_RETURN
#undef CALL_GL_API_RETURN
#if USE_SLOW_BINDING
#define API_ENTRY(_api) _api
- #define CALL_GL_API(_api, ...) \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; \
if (_c) return _c->_api(__VA_ARGS__);
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE return 0;
+
+ // This stays blank, since void functions will implicitly return, and
+ // all of the other functions will return 0 based on the previous macro.
+ #define CALL_GL_API_INTERNAL_DO_RETURN
+
#elif defined(__arm__)
#define GET_TLS(reg) "mrc p15, 0, " #reg ", c13, c0, 3 \n"
- #define API_ENTRY(_api) __attribute__((noinline)) _api
-
- #define CALL_GL_API(_api, ...) \
- asm volatile( \
- GET_TLS(r12) \
- "ldr r12, [r12, %[tls]] \n" \
- "cmp r12, #0 \n" \
- "ldrne pc, [r12, %[api]] \n" \
- : \
- : [tls] "J"(TLS_SLOT_OPENGL_API*4), \
- [api] "J"(__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "r12" \
- );
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
+
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
+ asm volatile( \
+ GET_TLS(r12) \
+ "ldr r12, [r12, %[tls]] \n" \
+ "cmp r12, #0 \n" \
+ "ldrne pc, [r12, %[api]] \n" \
+ : \
+ : [tls] "J"(TLS_SLOT_OPENGL_API*4), \
+ [api] "J"(__builtin_offsetof(gl_hooks_t, gl._api)) \
+ : "r0", "r1", "r2", "r3", "r12" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ asm volatile( \
+ "mov r0, #0 \n" \
+ : \
+ : \
+ : "r0" \
+ );
+
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ asm volatile( \
+ "bx lr \n" \
+ : \
+ : \
+ : "r0" \
+ );
#elif defined(__aarch64__)
- #define API_ENTRY(_api) __attribute__((noinline)) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
asm volatile( \
"mrs x16, tpidr_el0\n" \
"ldr x16, [x16, %[tls]]\n" \
: \
: [tls] "i" (TLS_SLOT_OPENGL_API * sizeof(void*)), \
[api] "i" (__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "x16" \
+ : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x16" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ asm volatile( \
+ "mov w0, wzr \n" \
+ : \
+ : \
+ : "w0" \
+ );
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ asm volatile( \
+ "ret \n" \
+ : \
+ : \
+ : \
);
#elif defined(__i386__)
- #define API_ENTRY(_api) __attribute__((noinline,optimize("omit-frame-pointer"))) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- register void** fn; \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
__asm__ volatile( \
- "mov %%gs:0, %[fn]\n" \
- "mov %P[tls](%[fn]), %[fn]\n" \
- "test %[fn], %[fn]\n" \
+ "mov %%gs:0, %%eax\n" \
+ "mov %P[tls](%%eax), %%eax\n" \
+ "test %%eax, %%eax\n" \
"je 1f\n" \
- "jmp *%P[api](%[fn])\n" \
+ "jmp *%P[api](%%eax)\n" \
"1:\n" \
- : [fn] "=r" (fn) \
+ : \
: [tls] "i" (TLS_SLOT_OPENGL_API*sizeof(void*)), \
[api] "i" (__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "cc" \
+ : "cc", "%eax" \
);
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ __asm__ volatile( \
+ "xor %%eax, %%eax\n" \
+ : \
+ : \
+ : "%eax" \
+ );
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ __asm__ volatile( \
+ "ret\n" \
+ : \
+ : \
+ : \
+ );
+
#elif defined(__x86_64__)
- #define API_ENTRY(_api) __attribute__((noinline,optimize("omit-frame-pointer"))) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- register void** fn; \
- __asm__ volatile( \
- "mov %%fs:0, %[fn]\n" \
- "mov %P[tls](%[fn]), %[fn]\n" \
- "test %[fn], %[fn]\n" \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
+ __asm__ volatile( \
+ "mov %%fs:0, %%rax\n" \
+ "mov %P[tls](%%rax), %%rax\n" \
+ "test %%rax, %%rax\n" \
"je 1f\n" \
- "jmp *%P[api](%[fn])\n" \
+ "jmp *%P[api](%%rax)\n" \
"1:\n" \
- : [fn] "=r" (fn) \
+ : \
: [tls] "i" (TLS_SLOT_OPENGL_API*sizeof(void*)), \
[api] "i" (__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "cc" \
- );
+ : "cc", "%rdi", "%rsi", "%rdx", "%rcx", "%r8", "%r9", \
+ "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", \
+ "%xmm6", "%xmm7" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ __asm__ volatile( \
+ "xor %%eax, %%eax\n" \
+ : \
+ : \
+ : "%eax" \
+ );
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ __asm__ volatile( \
+ "retq\n" \
+ : \
+ : \
+ : \
+ );
#elif defined(__mips64)
- #define API_ENTRY(_api) __attribute__((noinline)) _api
-
- #define CALL_GL_API(_api, ...) \
- register unsigned long _t0 asm("$12"); \
- register unsigned long _fn asm("$25"); \
- register unsigned long _tls asm("$3"); \
- register unsigned long _v0 asm("$2"); \
- asm volatile( \
- ".set push\n\t" \
- ".set noreorder\n\t" \
- "rdhwr %[tls], $29\n\t" \
- "ld %[t0], %[OPENGL_API](%[tls])\n\t" \
- "beqz %[t0], 1f\n\t" \
- " move %[fn], $ra\n\t" \
- "ld %[t0], %[API](%[t0])\n\t" \
- "beqz %[t0], 1f\n\t" \
- " nop\n\t" \
- "move %[fn], %[t0]\n\t" \
- "1:\n\t" \
- "jalr $0, %[fn]\n\t" \
- " move %[v0], $0\n\t" \
- ".set pop\n\t" \
- : [fn] "=c"(_fn), \
- [tls] "=&r"(_tls), \
- [t0] "=&r"(_t0), \
- [v0] "=&r"(_v0) \
- : [OPENGL_API] "I"(TLS_SLOT_OPENGL_API*sizeof(void*)),\
- [API] "I"(__builtin_offsetof(gl_hooks_t, gl._api)) \
- : \
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
+
+ // t0: $12
+ // fn: $25
+ // tls: $3
+ // v0: $2
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
+ asm volatile( \
+ ".set push\n\t" \
+ ".set noreorder\n\t" \
+ "rdhwr $3, $29\n\t" \
+ "ld $12, %[OPENGL_API]($3)\n\t" \
+ "beqz $12, 1f\n\t" \
+ " move $25, $ra\n\t" \
+ "ld $12, %[API]($12)\n\t" \
+ "beqz $12, 1f\n\t" \
+ " nop\n\t" \
+ "move $25, $12\n\t" \
+ "1:\n\t" \
+ "jalr $0, $25\n\t" \
+ " move $2, $0\n\t" \
+ ".set pop\n\t" \
+ : \
+ : [OPENGL_API] "I"(TLS_SLOT_OPENGL_API*sizeof(void*)),\
+ [API] "I"(__builtin_offsetof(gl_hooks_t, gl._api)) \
+ : "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", \
+ "$10", "$11", "$12", "$25" \
);
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+ #define CALL_GL_API_INTERNAL_DO_RETURN
+
#elif defined(__mips__)
- #define API_ENTRY(_api) __attribute__((noinline)) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- register unsigned int _t0 asm("$8"); \
- register unsigned int _fn asm("$25"); \
- register unsigned int _tls asm("$3"); \
- register unsigned int _v0 asm("$2"); \
+ // t0: $8
+ // fn: $25
+ // tls: $3
+ // v0: $2
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
asm volatile( \
".set push\n\t" \
".set noreorder\n\t" \
".set mips32r2\n\t" \
- "rdhwr %[tls], $29\n\t" \
- "lw %[t0], %[OPENGL_API](%[tls])\n\t" \
- "beqz %[t0], 1f\n\t" \
- " move %[fn],$ra\n\t" \
- "lw %[t0], %[API](%[t0])\n\t" \
- "beqz %[t0], 1f\n\t" \
+ "rdhwr $3, $29\n\t" \
+ "lw $3, %[OPENGL_API]($3)\n\t" \
+ "beqz $3, 1f\n\t" \
+ " move $25,$ra\n\t" \
+ "lw $3, %[API]($3)\n\t" \
+ "beqz $3, 1f\n\t" \
" nop\n\t" \
- "move %[fn], %[t0]\n\t" \
+ "move $25, $3\n\t" \
"1:\n\t" \
- "jalr $0, %[fn]\n\t" \
- " move %[v0], $0\n\t" \
+ "jalr $0, $25\n\t" \
+ " move $2, $0\n\t" \
".set pop\n\t" \
- : [fn] "=c"(_fn), \
- [tls] "=&r"(_tls), \
- [t0] "=&r"(_t0), \
- [v0] "=&r"(_v0) \
+ : \
: [OPENGL_API] "I"(TLS_SLOT_OPENGL_API*4), \
[API] "I"(__builtin_offsetof(gl_hooks_t, gl._api)) \
- : \
- );
+ : "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$25" \
+ );
-#endif
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+ #define CALL_GL_API_INTERNAL_DO_RETURN
-#define CALL_GL_API_RETURN(_api, ...) \
- CALL_GL_API(_api, __VA_ARGS__) \
- return 0;
+#endif
+#define CALL_GL_API(_api, ...) \
+ CALL_GL_API_INTERNAL_CALL(_api, __VA_ARGS__) \
+ CALL_GL_API_INTERNAL_DO_RETURN
+#define CALL_GL_API_RETURN(_api, ...) \
+ CALL_GL_API_INTERNAL_CALL(_api, __VA_ARGS__) \
+ CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ CALL_GL_API_INTERNAL_DO_RETURN
extern "C" {
#pragma GCC diagnostic ignored "-Wunused-parameter"
#undef API_ENTRY
#undef CALL_GL_API
+#undef CALL_GL_API_INTERNAL_CALL
+#undef CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+#undef CALL_GL_API_INTERNAL_DO_RETURN
#undef CALL_GL_API_RETURN
/*
#undef API_ENTRY
#undef CALL_GL_API
+#undef CALL_GL_API_INTERNAL_CALL
+#undef CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+#undef CALL_GL_API_INTERNAL_DO_RETURN
#undef CALL_GL_API_RETURN
#if USE_SLOW_BINDING
#define API_ENTRY(_api) _api
- #define CALL_GL_API(_api, ...) \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
gl_hooks_t::gl_t const * const _c = &getGlThreadSpecific()->gl; \
if (_c) return _c->_api(__VA_ARGS__);
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE return 0;
+
+ // This stays blank, since void functions will implicitly return, and
+ // all of the other functions will return 0 based on the previous macro.
+ #define CALL_GL_API_INTERNAL_DO_RETURN
+
#elif defined(__arm__)
#define GET_TLS(reg) "mrc p15, 0, " #reg ", c13, c0, 3 \n"
- #define API_ENTRY(_api) __attribute__((noinline)) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- asm volatile( \
- GET_TLS(r12) \
- "ldr r12, [r12, %[tls]] \n" \
- "cmp r12, #0 \n" \
- "ldrne pc, [r12, %[api]] \n" \
- : \
- : [tls] "J"(TLS_SLOT_OPENGL_API*4), \
- [api] "J"(__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "r12" \
- );
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
+ asm volatile( \
+ GET_TLS(r12) \
+ "ldr r12, [r12, %[tls]] \n" \
+ "cmp r12, #0 \n" \
+ "ldrne pc, [r12, %[api]] \n" \
+ : \
+ : [tls] "J"(TLS_SLOT_OPENGL_API*4), \
+ [api] "J"(__builtin_offsetof(gl_hooks_t, gl._api)) \
+ : "r0", "r1", "r2", "r3", "r12" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ asm volatile( \
+ "mov r0, #0 \n" \
+ : \
+ : \
+ : "r0" \
+ );
+
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ asm volatile( \
+ "bx lr \n" \
+ : \
+ : \
+ : "r0" \
+ );
#elif defined(__aarch64__)
- #define API_ENTRY(_api) __attribute__((noinline)) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
asm volatile( \
"mrs x16, tpidr_el0\n" \
"ldr x16, [x16, %[tls]]\n" \
: \
: [tls] "i" (TLS_SLOT_OPENGL_API * sizeof(void*)), \
[api] "i" (__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "x16" \
+ : "x0", "x1", "x2", "x3", "x4", "x5", "x6", "x7", "x16" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ asm volatile( \
+ "mov w0, wzr \n" \
+ : \
+ : \
+ : "w0" \
+ );
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ asm volatile( \
+ "ret \n" \
+ : \
+ : \
+ : \
);
#elif defined(__i386__)
- #define API_ENTRY(_api) __attribute__((noinline,optimize("omit-frame-pointer"))) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- register void* fn; \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
__asm__ volatile( \
- "mov %%gs:0, %[fn]\n" \
- "mov %P[tls](%[fn]), %[fn]\n" \
- "test %[fn], %[fn]\n" \
+ "mov %%gs:0, %%eax\n" \
+ "mov %P[tls](%%eax), %%eax\n" \
+ "test %%eax, %%eax\n" \
"je 1f\n" \
- "jmp *%P[api](%[fn])\n" \
+ "jmp *%P[api](%%eax)\n" \
"1:\n" \
- : [fn] "=r" (fn) \
+ : \
: [tls] "i" (TLS_SLOT_OPENGL_API*sizeof(void*)), \
[api] "i" (__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "cc" \
- );
+ : "cc", "%eax" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ __asm__ volatile( \
+ "xor %%eax, %%eax\n" \
+ : \
+ : \
+ : "%eax" \
+ );
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ __asm__ volatile( \
+ "ret\n" \
+ : \
+ : \
+ : \
+ );
#elif defined(__x86_64__)
- #define API_ENTRY(_api) __attribute__((noinline,optimize("omit-frame-pointer"))) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- register void** fn; \
- __asm__ volatile( \
- "mov %%fs:0, %[fn]\n" \
- "mov %P[tls](%[fn]), %[fn]\n" \
- "test %[fn], %[fn]\n" \
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
+ __asm__ volatile( \
+ "mov %%fs:0, %%rax\n" \
+ "mov %P[tls](%%rax), %%rax\n" \
+ "test %%rax, %%rax\n" \
"je 1f\n" \
- "jmp *%P[api](%[fn])\n" \
+ "jmp *%P[api](%%rax)\n" \
"1:\n" \
- : [fn] "=r" (fn) \
+ : \
: [tls] "i" (TLS_SLOT_OPENGL_API*sizeof(void*)), \
[api] "i" (__builtin_offsetof(gl_hooks_t, gl._api)) \
- : "cc" \
- );
+ : "cc", "%rdi", "%rsi", "%rdx", "%rcx", "%r8", "%r9", \
+ "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", \
+ "%xmm6", "%xmm7" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ __asm__ volatile( \
+ "xor %%eax, %%eax\n" \
+ : \
+ : \
+ : "%eax" \
+ );
+
+ #define CALL_GL_API_INTERNAL_DO_RETURN \
+ __asm__ volatile( \
+ "retq\n" \
+ : \
+ : \
+ : \
+ );
#elif defined(__mips64)
- #define API_ENTRY(_api) __attribute__((noinline)) _api
-
- #define CALL_GL_API(_api, ...) \
- register unsigned long _t0 asm("$12"); \
- register unsigned long _fn asm("$25"); \
- register unsigned long _tls asm("$3"); \
- register unsigned long _v0 asm("$2"); \
- asm volatile( \
- ".set push\n\t" \
- ".set noreorder\n\t" \
- "rdhwr %[tls], $29\n\t" \
- "ld %[t0], %[OPENGL_API](%[tls])\n\t" \
- "beqz %[t0], 1f\n\t" \
- " move %[fn], $ra\n\t" \
- "ld %[t0], %[API](%[t0])\n\t" \
- "beqz %[t0], 1f\n\t" \
- " nop\n\t" \
- "move %[fn], %[t0]\n\t" \
- "1:\n\t" \
- "jalr $0, %[fn]\n\t" \
- " move %[v0], $0\n\t" \
- ".set pop\n\t" \
- : [fn] "=c"(_fn), \
- [tls] "=&r"(_tls), \
- [t0] "=&r"(_t0), \
- [v0] "=&r"(_v0) \
- : [OPENGL_API] "I"(TLS_SLOT_OPENGL_API*sizeof(void*)),\
- [API] "I"(__builtin_offsetof(gl_hooks_t, gl._api)) \
- : \
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
+
+ // t0: $12
+ // fn: $25
+ // tls: $3
+ // v0: $2
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
+ asm volatile( \
+ ".set push\n\t" \
+ ".set noreorder\n\t" \
+ "rdhwr $3, $29\n\t" \
+ "ld $12, %[OPENGL_API]($3)\n\t" \
+ "beqz $12, 1f\n\t" \
+ " move $25, $ra\n\t" \
+ "ld $12, %[API]($12)\n\t" \
+ "beqz $12, 1f\n\t" \
+ " nop\n\t" \
+ "move $25, $12\n\t" \
+ "1:\n\t" \
+ "jalr $0, $25\n\t" \
+ " move $2, $0\n\t" \
+ ".set pop\n\t" \
+ : \
+ : [OPENGL_API] "I"(TLS_SLOT_OPENGL_API*sizeof(void*)),\
+ [API] "I"(__builtin_offsetof(gl_hooks_t, gl._api)) \
+ : "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", \
+ "$10", "$11", "$12", "$25" \
);
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+ #define CALL_GL_API_INTERNAL_DO_RETURN
+
#elif defined(__mips__)
- #define API_ENTRY(_api) __attribute__((noinline)) _api
+ #define API_ENTRY(_api) __attribute__((naked,noinline)) _api
- #define CALL_GL_API(_api, ...) \
- register unsigned int _t0 asm("$8"); \
- register unsigned int _fn asm("$25"); \
- register unsigned int _tls asm("$3"); \
- register unsigned int _v0 asm("$2"); \
+ // t0: $8
+ // fn: $25
+ // tls: $3
+ // v0: $2
+ #define CALL_GL_API_INTERNAL_CALL(_api, ...) \
asm volatile( \
".set push\n\t" \
".set noreorder\n\t" \
".set mips32r2\n\t" \
- "rdhwr %[tls], $29\n\t" \
- "lw %[t0], %[OPENGL_API](%[tls])\n\t" \
- "beqz %[t0], 1f\n\t" \
- " move %[fn], $ra\n\t" \
- "lw %[t0], %[API](%[t0])\n\t" \
- "beqz %[t0], 1f\n\t" \
+ "rdhwr $3, $29\n\t" \
+ "lw $3, %[OPENGL_API]($3)\n\t" \
+ "beqz $3, 1f\n\t" \
+ " move $25,$ra\n\t" \
+ "lw $3, %[API]($3)\n\t" \
+ "beqz $3, 1f\n\t" \
" nop\n\t" \
- "move %[fn], %[t0]\n\t" \
+ "move $25, $3\n\t" \
"1:\n\t" \
- "jalr $0, %[fn]\n\t" \
- " move %[v0], $0\n\t" \
+ "jalr $0, $25\n\t" \
+ " move $2, $0\n\t" \
".set pop\n\t" \
- : [fn] "=c"(_fn), \
- [tls] "=&r"(_tls), \
- [t0] "=&r"(_t0), \
- [v0] "=&r"(_v0) \
+ : \
: [OPENGL_API] "I"(TLS_SLOT_OPENGL_API*4), \
[API] "I"(__builtin_offsetof(gl_hooks_t, gl._api)) \
- : \
- );
+ : "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$25" \
+ );
+
+ #define CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+ #define CALL_GL_API_INTERNAL_DO_RETURN
#endif
-#define CALL_GL_API_RETURN(_api, ...) \
- CALL_GL_API(_api, __VA_ARGS__) \
- return 0;
+#define CALL_GL_API(_api, ...) \
+ CALL_GL_API_INTERNAL_CALL(_api, __VA_ARGS__) \
+ CALL_GL_API_INTERNAL_DO_RETURN
+#define CALL_GL_API_RETURN(_api, ...) \
+ CALL_GL_API_INTERNAL_CALL(_api, __VA_ARGS__) \
+ CALL_GL_API_INTERNAL_SET_RETURN_VALUE \
+ CALL_GL_API_INTERNAL_DO_RETURN
extern "C" {
#pragma GCC diagnostic ignored "-Wunused-parameter"
#undef API_ENTRY
#undef CALL_GL_API
+#undef CALL_GL_API_INTERNAL_CALL
+#undef CALL_GL_API_INTERNAL_SET_RETURN_VALUE
+#undef CALL_GL_API_INTERNAL_DO_RETURN
#undef CALL_GL_API_RETURN
/*
#undef GL_ENTRY
#undef EGL_ENTRY
-#define GL_ENTRY(_r, _api, ...) _r (*_api)(__VA_ARGS__);
-#define EGL_ENTRY(_r, _api, ...) _r (*_api)(__VA_ARGS__);
+#define GL_ENTRY(_r, _api, ...) _r (*(_api))(__VA_ARGS__);
+#define EGL_ENTRY(_r, _api, ...) _r (*(_api))(__VA_ARGS__);
struct egl_t {
#include "EGL/egl_entries.in"
--- /dev/null
+LIBEGL {
+ global:
+ eglBindAPI;
+ eglBindTexImage;
+ eglChooseConfig;
+ eglClientWaitSyncKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ eglCopyBuffers;
+ eglCreateContext;
+ eglCreateImageKHR;
+ eglCreateNativeClientBufferANDROID; # introduced=24
+ eglCreatePbufferFromClientBuffer;
+ eglCreatePbufferSurface;
+ eglCreatePixmapSurface;
+ eglCreateStreamFromFileDescriptorKHR; # introduced=23
+ eglCreateStreamKHR; # introduced=23
+ eglCreateStreamProducerSurfaceKHR; # introduced=23
+ eglCreateSyncKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ eglCreateWindowSurface;
+ eglDestroyContext;
+ eglDestroyImageKHR;
+ eglDestroyStreamKHR; # introduced=23
+ eglDestroySurface;
+ eglDestroySyncKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ eglGetConfigAttrib;
+ eglGetConfigs;
+ eglGetCurrentContext;
+ eglGetCurrentDisplay;
+ eglGetCurrentSurface;
+ eglGetDisplay;
+ eglGetError;
+ eglGetProcAddress;
+ eglGetStreamFileDescriptorKHR; # introduced=23
+ eglGetSyncAttribKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ eglGetSystemTimeFrequencyNV; # introduced-arm=14 introduced-arm64=21 introduced-mips=14 introduced-mips64=21 introduced-x86=14 introduced-x86_64=21
+ eglGetSystemTimeNV; # introduced-arm=14 introduced-arm64=21 introduced-mips=14 introduced-mips64=21 introduced-x86=14 introduced-x86_64=21
+ eglInitialize;
+ eglLockSurfaceKHR;
+ eglMakeCurrent;
+ eglPresentationTimeANDROID; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ eglQueryAPI;
+ eglQueryContext;
+ eglQueryStreamKHR; # introduced=23
+ eglQueryStreamTimeKHR; # introduced=23
+ eglQueryStreamu64KHR; # introduced=23
+ eglQueryString;
+ eglQuerySurface;
+ eglReleaseTexImage;
+ eglReleaseThread;
+ eglSetDamageRegionKHR; # introduced=23
+ eglSignalSyncKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ eglStreamAttribKHR; # introduced=23
+ eglStreamConsumerAcquireKHR; # introduced=23
+ eglStreamConsumerGLTextureExternalKHR; # introduced=23
+ eglStreamConsumerReleaseKHR; # introduced=23
+ eglSurfaceAttrib;
+ eglSwapBuffers;
+ eglSwapBuffersWithDamageKHR; # introduced=23
+ eglSwapInterval;
+ eglTerminate;
+ eglUnlockSurfaceKHR;
+ eglWaitClient;
+ eglWaitGL;
+ eglWaitNative;
+ eglWaitSyncKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
+ local:
+ *;
+};
--- /dev/null
+LIBGLESV1_CM {
+ global:
+ glActiveTexture;
+ glAlphaFunc;
+ glAlphaFuncx;
+ glAlphaFuncxOES;
+ glBindBuffer;
+ glBindFramebufferOES;
+ glBindRenderbufferOES;
+ glBindTexture;
+ glBindVertexArrayOES; # introduced-mips=9 introduced-x86=9
+ glBlendEquationOES;
+ glBlendEquationSeparateOES;
+ glBlendFunc;
+ glBlendFuncSeparateOES;
+ glBufferData;
+ glBufferSubData;
+ glCheckFramebufferStatusOES;
+ glClear;
+ glClearColor;
+ glClearColorx;
+ glClearColorxOES;
+ glClearDepthf;
+ glClearDepthfOES;
+ glClearDepthx;
+ glClearDepthxOES;
+ glClearStencil;
+ glClientActiveTexture;
+ glClipPlanef;
+ glClipPlanefIMG; # introduced-mips=9 introduced-x86=9
+ glClipPlanefOES;
+ glClipPlanex;
+ glClipPlanexIMG; # introduced-mips=9 introduced-x86=9
+ glClipPlanexOES;
+ glColor4f;
+ glColor4ub;
+ glColor4x;
+ glColor4xOES;
+ glColorMask;
+ glColorPointer;
+ glColorPointerBounds;
+ glCompressedTexImage2D;
+ glCompressedTexSubImage2D;
+ glCopyTexImage2D;
+ glCopyTexSubImage2D;
+ glCullFace;
+ glCurrentPaletteMatrixOES;
+ glDeleteBuffers;
+ glDeleteFencesNV; # introduced-mips=9 introduced-x86=9
+ glDeleteFramebuffersOES;
+ glDeleteRenderbuffersOES;
+ glDeleteTextures;
+ glDeleteVertexArraysOES; # introduced-mips=9 introduced-x86=9
+ glDepthFunc;
+ glDepthMask;
+ glDepthRangef;
+ glDepthRangefOES;
+ glDepthRangex;
+ glDepthRangexOES;
+ glDisable;
+ glDisableClientState;
+ glDisableDriverControlQCOM; # introduced-mips=9 introduced-x86=9
+ glDiscardFramebufferEXT; # introduced-mips=9 introduced-x86=9
+ glDrawArrays;
+ glDrawElements;
+ glDrawTexfOES;
+ glDrawTexfvOES;
+ glDrawTexiOES;
+ glDrawTexivOES;
+ glDrawTexsOES;
+ glDrawTexsvOES;
+ glDrawTexxOES;
+ glDrawTexxvOES;
+ glEGLImageTargetRenderbufferStorageOES;
+ glEGLImageTargetTexture2DOES;
+ glEnable;
+ glEnableClientState;
+ glEnableDriverControlQCOM; # introduced-mips=9 introduced-x86=9
+ glEndTilingQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetBufferPointervQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetBuffersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetFramebuffersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetProgramBinarySourceQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetProgramsQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetRenderbuffersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetShadersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetTexLevelParameterivQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetTexSubImageQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetTexturesQCOM; # introduced-mips=9 introduced-x86=9
+ glExtIsProgramBinaryQCOM; # introduced-mips=9 introduced-x86=9
+ glExtTexObjectStateOverrideiQCOM; # introduced-mips=9 introduced-x86=9
+ glFinish;
+ glFinishFenceNV; # introduced-mips=9 introduced-x86=9
+ glFlush;
+ glFogf;
+ glFogfv;
+ glFogx;
+ glFogxOES;
+ glFogxv;
+ glFogxvOES;
+ glFramebufferRenderbufferOES;
+ glFramebufferTexture2DMultisampleIMG; # introduced-mips=9 introduced-x86=9
+ glFramebufferTexture2DOES;
+ glFrontFace;
+ glFrustumf;
+ glFrustumfOES;
+ glFrustumx;
+ glFrustumxOES;
+ glGenBuffers;
+ glGenFencesNV; # introduced-mips=9 introduced-x86=9
+ glGenFramebuffersOES;
+ glGenRenderbuffersOES;
+ glGenTextures;
+ glGenVertexArraysOES; # introduced-mips=9 introduced-x86=9
+ glGenerateMipmapOES;
+ glGetBooleanv;
+ glGetBufferParameteriv;
+ glGetBufferPointervOES;
+ glGetClipPlanef;
+ glGetClipPlanefOES;
+ glGetClipPlanex;
+ glGetClipPlanexOES;
+ glGetDriverControlStringQCOM; # introduced-mips=9 introduced-x86=9
+ glGetDriverControlsQCOM; # introduced-mips=9 introduced-x86=9
+ glGetError;
+ glGetFenceivNV; # introduced-mips=9 introduced-x86=9
+ glGetFixedv;
+ glGetFixedvOES;
+ glGetFloatv;
+ glGetFramebufferAttachmentParameterivOES;
+ glGetIntegerv;
+ glGetLightfv;
+ glGetLightxv;
+ glGetLightxvOES;
+ glGetMaterialfv;
+ glGetMaterialxv;
+ glGetMaterialxvOES;
+ glGetPointerv;
+ glGetRenderbufferParameterivOES;
+ glGetString;
+ glGetTexEnvfv;
+ glGetTexEnviv;
+ glGetTexEnvxv;
+ glGetTexEnvxvOES;
+ glGetTexGenfvOES;
+ glGetTexGenivOES;
+ glGetTexGenxvOES;
+ glGetTexParameterfv;
+ glGetTexParameteriv;
+ glGetTexParameterxv;
+ glGetTexParameterxvOES;
+ glHint;
+ glIsBuffer;
+ glIsEnabled;
+ glIsFenceNV; # introduced-mips=9 introduced-x86=9
+ glIsFramebufferOES;
+ glIsRenderbufferOES;
+ glIsTexture;
+ glIsVertexArrayOES; # introduced-mips=9 introduced-x86=9
+ glLightModelf;
+ glLightModelfv;
+ glLightModelx;
+ glLightModelxOES;
+ glLightModelxv;
+ glLightModelxvOES;
+ glLightf;
+ glLightfv;
+ glLightx;
+ glLightxOES;
+ glLightxv;
+ glLightxvOES;
+ glLineWidth;
+ glLineWidthx;
+ glLineWidthxOES;
+ glLoadIdentity;
+ glLoadMatrixf;
+ glLoadMatrixx;
+ glLoadMatrixxOES;
+ glLoadPaletteFromModelViewMatrixOES;
+ glLogicOp;
+ glMapBufferOES;
+ glMaterialf;
+ glMaterialfv;
+ glMaterialx;
+ glMaterialxOES;
+ glMaterialxv;
+ glMaterialxvOES;
+ glMatrixIndexPointerOES;
+ glMatrixIndexPointerOESBounds; # introduced-mips=9 introduced-x86=9
+ glMatrixMode;
+ glMultMatrixf;
+ glMultMatrixx;
+ glMultMatrixxOES;
+ glMultiDrawArraysEXT; # introduced-mips=9 introduced-x86=9
+ glMultiDrawElementsEXT; # introduced-mips=9 introduced-x86=9
+ glMultiTexCoord4f;
+ glMultiTexCoord4x;
+ glMultiTexCoord4xOES;
+ glNormal3f;
+ glNormal3x;
+ glNormal3xOES;
+ glNormalPointer;
+ glNormalPointerBounds;
+ glOrthof;
+ glOrthofOES;
+ glOrthox;
+ glOrthoxOES;
+ glPixelStorei;
+ glPointParameterf;
+ glPointParameterfv;
+ glPointParameterx;
+ glPointParameterxOES;
+ glPointParameterxv;
+ glPointParameterxvOES;
+ glPointSize;
+ glPointSizePointerOES;
+ glPointSizePointerOESBounds; # introduced-mips=9 introduced-x86=9
+ glPointSizex;
+ glPointSizexOES;
+ glPolygonOffset;
+ glPolygonOffsetx;
+ glPolygonOffsetxOES;
+ glPopMatrix;
+ glPushMatrix;
+ glQueryMatrixxOES;
+ glReadPixels;
+ glRenderbufferStorageMultisampleIMG; # introduced-mips=9 introduced-x86=9
+ glRenderbufferStorageOES;
+ glRotatef;
+ glRotatex;
+ glRotatexOES;
+ glSampleCoverage;
+ glSampleCoveragex;
+ glSampleCoveragexOES;
+ glScalef;
+ glScalex;
+ glScalexOES;
+ glScissor;
+ glSetFenceNV; # introduced-mips=9 introduced-x86=9
+ glShadeModel;
+ glStartTilingQCOM; # introduced-mips=9 introduced-x86=9
+ glStencilFunc;
+ glStencilMask;
+ glStencilOp;
+ glTestFenceNV; # introduced-mips=9 introduced-x86=9
+ glTexCoordPointer;
+ glTexCoordPointerBounds;
+ glTexEnvf;
+ glTexEnvfv;
+ glTexEnvi;
+ glTexEnviv;
+ glTexEnvx;
+ glTexEnvxOES;
+ glTexEnvxv;
+ glTexEnvxvOES;
+ glTexGenfOES;
+ glTexGenfvOES;
+ glTexGeniOES;
+ glTexGenivOES;
+ glTexGenxOES;
+ glTexGenxvOES;
+ glTexImage2D;
+ glTexParameterf;
+ glTexParameterfv;
+ glTexParameteri;
+ glTexParameteriv;
+ glTexParameterx;
+ glTexParameterxOES;
+ glTexParameterxv;
+ glTexParameterxvOES;
+ glTexSubImage2D;
+ glTranslatef;
+ glTranslatex;
+ glTranslatexOES;
+ glUnmapBufferOES;
+ glVertexPointer;
+ glVertexPointerBounds;
+ glViewport;
+ glWeightPointerOES;
+ glWeightPointerOESBounds; # introduced-mips=9 introduced-x86=9
+ local:
+ *;
+};
--- /dev/null
+LIBGLESV2 {
+ global:
+ glActiveTexture;
+ glAttachShader;
+ glBeginPerfMonitorAMD;
+ glBindAttribLocation;
+ glBindBuffer;
+ glBindFramebuffer;
+ glBindRenderbuffer;
+ glBindTexture;
+ glBindVertexArrayOES; # introduced-mips=9 introduced-x86=9
+ glBlendColor;
+ glBlendEquation;
+ glBlendEquationSeparate;
+ glBlendFunc;
+ glBlendFuncSeparate;
+ glBufferData;
+ glBufferSubData;
+ glCheckFramebufferStatus;
+ glClear;
+ glClearColor;
+ glClearDepthf;
+ glClearStencil;
+ glColorMask;
+ glCompileShader;
+ glCompressedTexImage2D;
+ glCompressedTexImage3DOES;
+ glCompressedTexSubImage2D;
+ glCompressedTexSubImage3DOES;
+ glCopyTexImage2D;
+ glCopyTexSubImage2D;
+ glCopyTexSubImage3DOES;
+ glCoverageMaskNV; # introduced-mips=9 introduced-x86=9
+ glCoverageOperationNV; # introduced-mips=9 introduced-x86=9
+ glCreateProgram;
+ glCreateShader;
+ glCullFace;
+ glDeleteBuffers;
+ glDeleteFencesNV;
+ glDeleteFramebuffers;
+ glDeletePerfMonitorsAMD;
+ glDeleteProgram;
+ glDeleteRenderbuffers;
+ glDeleteShader;
+ glDeleteTextures;
+ glDeleteVertexArraysOES; # introduced-mips=9 introduced-x86=9
+ glDepthFunc;
+ glDepthMask;
+ glDepthRangef;
+ glDetachShader;
+ glDisable;
+ glDisableDriverControlQCOM;
+ glDisableVertexAttribArray;
+ glDiscardFramebufferEXT; # introduced-mips=9 introduced-x86=9
+ glDrawArrays;
+ glDrawElements;
+ glEGLImageTargetRenderbufferStorageOES;
+ glEGLImageTargetTexture2DOES;
+ glEnable;
+ glEnableDriverControlQCOM;
+ glEnableVertexAttribArray;
+ glEndPerfMonitorAMD;
+ glEndTilingQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetBufferPointervQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetBuffersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetFramebuffersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetProgramBinarySourceQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetProgramsQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetRenderbuffersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetShadersQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetTexLevelParameterivQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetTexSubImageQCOM; # introduced-mips=9 introduced-x86=9
+ glExtGetTexturesQCOM; # introduced-mips=9 introduced-x86=9
+ glExtIsProgramBinaryQCOM; # introduced-mips=9 introduced-x86=9
+ glExtTexObjectStateOverrideiQCOM; # introduced-mips=9 introduced-x86=9
+ glFinish;
+ glFinishFenceNV;
+ glFlush;
+ glFramebufferRenderbuffer;
+ glFramebufferTexture2D;
+ glFramebufferTexture2DMultisampleIMG; # introduced-mips=9 introduced-x86=9
+ glFramebufferTexture3DOES;
+ glFrontFace;
+ glGenBuffers;
+ glGenFencesNV;
+ glGenFramebuffers;
+ glGenPerfMonitorsAMD;
+ glGenRenderbuffers;
+ glGenTextures;
+ glGenVertexArraysOES; # introduced-mips=9 introduced-x86=9
+ glGenerateMipmap;
+ glGetActiveAttrib;
+ glGetActiveUniform;
+ glGetAttachedShaders;
+ glGetAttribLocation;
+ glGetBooleanv;
+ glGetBufferParameteriv;
+ glGetBufferPointervOES;
+ glGetDriverControlStringQCOM;
+ glGetDriverControlsQCOM;
+ glGetError;
+ glGetFenceivNV;
+ glGetFloatv;
+ glGetFramebufferAttachmentParameteriv;
+ glGetIntegerv;
+ glGetPerfMonitorCounterDataAMD;
+ glGetPerfMonitorCounterInfoAMD;
+ glGetPerfMonitorCounterStringAMD;
+ glGetPerfMonitorCountersAMD;
+ glGetPerfMonitorGroupStringAMD;
+ glGetPerfMonitorGroupsAMD;
+ glGetProgramBinaryOES;
+ glGetProgramInfoLog;
+ glGetProgramiv;
+ glGetRenderbufferParameteriv;
+ glGetShaderInfoLog;
+ glGetShaderPrecisionFormat;
+ glGetShaderSource;
+ glGetShaderiv;
+ glGetString;
+ glGetTexParameterfv;
+ glGetTexParameteriv;
+ glGetUniformLocation;
+ glGetUniformfv;
+ glGetUniformiv;
+ glGetVertexAttribPointerv;
+ glGetVertexAttribfv;
+ glGetVertexAttribiv;
+ glHint;
+ glIsBuffer;
+ glIsEnabled;
+ glIsFenceNV;
+ glIsFramebuffer;
+ glIsProgram;
+ glIsRenderbuffer;
+ glIsShader;
+ glIsTexture;
+ glIsVertexArrayOES; # introduced-mips=9 introduced-x86=9
+ glLineWidth;
+ glLinkProgram;
+ glMapBufferOES;
+ glMultiDrawArraysEXT; # introduced-mips=9 introduced-x86=9
+ glMultiDrawElementsEXT; # introduced-mips=9 introduced-x86=9
+ glPixelStorei;
+ glPolygonOffset;
+ glProgramBinaryOES;
+ glReadPixels;
+ glReleaseShaderCompiler;
+ glRenderbufferStorage;
+ glRenderbufferStorageMultisampleIMG; # introduced-mips=9 introduced-x86=9
+ glSampleCoverage;
+ glScissor;
+ glSelectPerfMonitorCountersAMD;
+ glSetFenceNV;
+ glShaderBinary;
+ glShaderSource;
+ glStartTilingQCOM; # introduced-mips=9 introduced-x86=9
+ glStencilFunc;
+ glStencilFuncSeparate;
+ glStencilMask;
+ glStencilMaskSeparate;
+ glStencilOp;
+ glStencilOpSeparate;
+ glTestFenceNV;
+ glTexImage2D;
+ glTexImage3DOES;
+ glTexParameterf;
+ glTexParameterfv;
+ glTexParameteri;
+ glTexParameteriv;
+ glTexSubImage2D;
+ glTexSubImage3DOES;
+ glUniform1f;
+ glUniform1fv;
+ glUniform1i;
+ glUniform1iv;
+ glUniform2f;
+ glUniform2fv;
+ glUniform2i;
+ glUniform2iv;
+ glUniform3f;
+ glUniform3fv;
+ glUniform3i;
+ glUniform3iv;
+ glUniform4f;
+ glUniform4fv;
+ glUniform4i;
+ glUniform4iv;
+ glUniformMatrix2fv;
+ glUniformMatrix3fv;
+ glUniformMatrix4fv;
+ glUnmapBufferOES;
+ glUseProgram;
+ glValidateProgram;
+ glVertexAttrib1f;
+ glVertexAttrib1fv;
+ glVertexAttrib2f;
+ glVertexAttrib2fv;
+ glVertexAttrib3f;
+ glVertexAttrib3fv;
+ glVertexAttrib4f;
+ glVertexAttrib4fv;
+ glVertexAttribPointer;
+ glViewport;
+ local:
+ *;
+};
--- /dev/null
+LIBGLESV3 {
+ global:
+ glActiveShaderProgram; # introduced=21
+ glActiveTexture;
+ glAttachShader;
+ glBeginQuery;
+ glBeginTransformFeedback;
+ glBindAttribLocation;
+ glBindBuffer;
+ glBindBufferBase;
+ glBindBufferRange;
+ glBindFramebuffer;
+ glBindImageTexture; # introduced=21
+ glBindProgramPipeline; # introduced=21
+ glBindRenderbuffer;
+ glBindSampler;
+ glBindTexture;
+ glBindTransformFeedback;
+ glBindVertexArray;
+ glBindVertexArrayOES;
+ glBindVertexBuffer; # introduced=21
+ glBlendBarrier; # introduced=24
+ glBlendBarrierKHR; # introduced=21
+ glBlendColor;
+ glBlendEquation;
+ glBlendEquationSeparate;
+ glBlendEquationSeparatei; # introduced=24
+ glBlendEquationSeparateiEXT; # introduced=21
+ glBlendEquationi; # introduced=24
+ glBlendEquationiEXT; # introduced=21
+ glBlendFunc;
+ glBlendFuncSeparate;
+ glBlendFuncSeparatei; # introduced=24
+ glBlendFuncSeparateiEXT; # introduced=21
+ glBlendFunci; # introduced=24
+ glBlendFunciEXT; # introduced=21
+ glBlitFramebuffer;
+ glBufferData;
+ glBufferSubData;
+ glCheckFramebufferStatus;
+ glClear;
+ glClearBufferfi;
+ glClearBufferfv;
+ glClearBufferiv;
+ glClearBufferuiv;
+ glClearColor;
+ glClearDepthf;
+ glClearStencil;
+ glClientWaitSync;
+ glColorMask;
+ glColorMaski; # introduced=24
+ glColorMaskiEXT; # introduced=21
+ glCompileShader;
+ glCompressedTexImage2D;
+ glCompressedTexImage3D;
+ glCompressedTexImage3DOES;
+ glCompressedTexSubImage2D;
+ glCompressedTexSubImage3D;
+ glCompressedTexSubImage3DOES;
+ glCopyBufferSubData;
+ glCopyImageSubData; # introduced=24
+ glCopyImageSubDataEXT; # introduced=21
+ glCopyTexImage2D;
+ glCopyTexSubImage2D;
+ glCopyTexSubImage3D;
+ glCopyTexSubImage3DOES;
+ glCreateProgram;
+ glCreateShader;
+ glCreateShaderProgramv; # introduced=21
+ glCullFace;
+ glDebugMessageCallback; # introduced=24
+ glDebugMessageCallbackKHR; # introduced=21
+ glDebugMessageControl; # introduced=24
+ glDebugMessageControlKHR; # introduced=21
+ glDebugMessageInsert; # introduced=24
+ glDebugMessageInsertKHR; # introduced=21
+ glDeleteBuffers;
+ glDeleteFramebuffers;
+ glDeleteProgram;
+ glDeleteProgramPipelines; # introduced=21
+ glDeleteQueries;
+ glDeleteRenderbuffers;
+ glDeleteSamplers;
+ glDeleteShader;
+ glDeleteSync;
+ glDeleteTextures;
+ glDeleteTransformFeedbacks;
+ glDeleteVertexArrays;
+ glDeleteVertexArraysOES;
+ glDepthFunc;
+ glDepthMask;
+ glDepthRangef;
+ glDetachShader;
+ glDisable;
+ glDisableVertexAttribArray;
+ glDisablei; # introduced=24
+ glDisableiEXT; # introduced=21
+ glDispatchCompute; # introduced=21
+ glDispatchComputeIndirect; # introduced=21
+ glDrawArrays;
+ glDrawArraysIndirect; # introduced=21
+ glDrawArraysInstanced;
+ glDrawBuffers;
+ glDrawElements;
+ glDrawElementsBaseVertex; # introduced=24
+ glDrawElementsIndirect; # introduced=21
+ glDrawElementsInstanced;
+ glDrawElementsInstancedBaseVertex; # introduced=24
+ glDrawRangeElements;
+ glDrawRangeElementsBaseVertex; # introduced=24
+ glEGLImageTargetRenderbufferStorageOES;
+ glEGLImageTargetTexture2DOES;
+ glEnable;
+ glEnableVertexAttribArray;
+ glEnablei; # introduced=24
+ glEnableiEXT; # introduced=21
+ glEndQuery;
+ glEndTransformFeedback;
+ glFenceSync;
+ glFinish;
+ glFlush;
+ glFlushMappedBufferRange;
+ glFramebufferParameteri; # introduced=21
+ glFramebufferRenderbuffer;
+ glFramebufferTexture; # introduced=24
+ glFramebufferTexture2D;
+ glFramebufferTexture3DOES;
+ glFramebufferTextureEXT; # introduced=21
+ glFramebufferTextureLayer;
+ glFrontFace;
+ glGenBuffers;
+ glGenFramebuffers;
+ glGenProgramPipelines; # introduced=21
+ glGenQueries;
+ glGenRenderbuffers;
+ glGenSamplers;
+ glGenTextures;
+ glGenTransformFeedbacks;
+ glGenVertexArrays;
+ glGenVertexArraysOES;
+ glGenerateMipmap;
+ glGetActiveAttrib;
+ glGetActiveUniform;
+ glGetActiveUniformBlockName;
+ glGetActiveUniformBlockiv;
+ glGetActiveUniformsiv;
+ glGetAttachedShaders;
+ glGetAttribLocation;
+ glGetBooleani_v; # introduced=21
+ glGetBooleanv;
+ glGetBufferParameteri64v;
+ glGetBufferParameteriv;
+ glGetBufferPointerv;
+ glGetBufferPointervOES;
+ glGetDebugMessageLog; # introduced=24
+ glGetDebugMessageLogKHR; # introduced=21
+ glGetError;
+ glGetFloatv;
+ glGetFragDataLocation;
+ glGetFramebufferAttachmentParameteriv;
+ glGetFramebufferParameteriv; # introduced=21
+ glGetGraphicsResetStatus; # introduced=24
+ glGetInteger64i_v;
+ glGetInteger64v;
+ glGetIntegeri_v;
+ glGetIntegerv;
+ glGetInternalformativ;
+ glGetMultisamplefv; # introduced=21
+ glGetObjectLabel; # introduced=24
+ glGetObjectLabelKHR; # introduced=21
+ glGetObjectPtrLabel; # introduced=24
+ glGetObjectPtrLabelKHR; # introduced=21
+ glGetPointerv; # introduced=24
+ glGetPointervKHR; # introduced=21
+ glGetProgramBinary;
+ glGetProgramBinaryOES;
+ glGetProgramInfoLog;
+ glGetProgramInterfaceiv; # introduced=21
+ glGetProgramPipelineInfoLog; # introduced=21
+ glGetProgramPipelineiv; # introduced=21
+ glGetProgramResourceIndex; # introduced=21
+ glGetProgramResourceLocation; # introduced=21
+ glGetProgramResourceName; # introduced=21
+ glGetProgramResourceiv; # introduced=21
+ glGetProgramiv;
+ glGetQueryObjectuiv;
+ glGetQueryiv;
+ glGetRenderbufferParameteriv;
+ glGetSamplerParameterIiv; # introduced=24
+ glGetSamplerParameterIivEXT; # introduced=21
+ glGetSamplerParameterIuiv; # introduced=24
+ glGetSamplerParameterIuivEXT; # introduced=21
+ glGetSamplerParameterfv;
+ glGetSamplerParameteriv;
+ glGetShaderInfoLog;
+ glGetShaderPrecisionFormat;
+ glGetShaderSource;
+ glGetShaderiv;
+ glGetString;
+ glGetStringi;
+ glGetSynciv;
+ glGetTexLevelParameterfv; # introduced=21
+ glGetTexLevelParameteriv; # introduced=21
+ glGetTexParameterIiv; # introduced=24
+ glGetTexParameterIivEXT; # introduced=21
+ glGetTexParameterIuiv; # introduced=24
+ glGetTexParameterIuivEXT; # introduced=21
+ glGetTexParameterfv;
+ glGetTexParameteriv;
+ glGetTransformFeedbackVarying;
+ glGetUniformBlockIndex;
+ glGetUniformIndices;
+ glGetUniformLocation;
+ glGetUniformfv;
+ glGetUniformiv;
+ glGetUniformuiv;
+ glGetVertexAttribIiv;
+ glGetVertexAttribIuiv;
+ glGetVertexAttribPointerv;
+ glGetVertexAttribfv;
+ glGetVertexAttribiv;
+ glGetnUniformfv; # introduced=24
+ glGetnUniformiv; # introduced=24
+ glGetnUniformuiv; # introduced=24
+ glHint;
+ glInvalidateFramebuffer;
+ glInvalidateSubFramebuffer;
+ glIsBuffer;
+ glIsEnabled;
+ glIsEnabledi; # introduced=24
+ glIsEnablediEXT; # introduced=21
+ glIsFramebuffer;
+ glIsProgram;
+ glIsProgramPipeline; # introduced=21
+ glIsQuery;
+ glIsRenderbuffer;
+ glIsSampler;
+ glIsShader;
+ glIsSync;
+ glIsTexture;
+ glIsTransformFeedback;
+ glIsVertexArray;
+ glIsVertexArrayOES;
+ glLineWidth;
+ glLinkProgram;
+ glMapBufferOES;
+ glMapBufferRange;
+ glMemoryBarrier; # introduced=21
+ glMemoryBarrierByRegion; # introduced=21
+ glMinSampleShading; # introduced=24
+ glMinSampleShadingOES; # introduced=21
+ glObjectLabel; # introduced=24
+ glObjectLabelKHR; # introduced=21
+ glObjectPtrLabel; # introduced=24
+ glObjectPtrLabelKHR; # introduced=21
+ glPatchParameteri; # introduced=24
+ glPatchParameteriEXT; # introduced=21
+ glPauseTransformFeedback;
+ glPixelStorei;
+ glPolygonOffset;
+ glPopDebugGroup; # introduced=24
+ glPopDebugGroupKHR; # introduced=21
+ glPrimitiveBoundingBox; # introduced=24
+ glPrimitiveBoundingBoxEXT; # introduced=21
+ glProgramBinary;
+ glProgramBinaryOES;
+ glProgramParameteri;
+ glProgramUniform1f; # introduced=21
+ glProgramUniform1fv; # introduced=21
+ glProgramUniform1i; # introduced=21
+ glProgramUniform1iv; # introduced=21
+ glProgramUniform1ui; # introduced=21
+ glProgramUniform1uiv; # introduced=21
+ glProgramUniform2f; # introduced=21
+ glProgramUniform2fv; # introduced=21
+ glProgramUniform2i; # introduced=21
+ glProgramUniform2iv; # introduced=21
+ glProgramUniform2ui; # introduced=21
+ glProgramUniform2uiv; # introduced=21
+ glProgramUniform3f; # introduced=21
+ glProgramUniform3fv; # introduced=21
+ glProgramUniform3i; # introduced=21
+ glProgramUniform3iv; # introduced=21
+ glProgramUniform3ui; # introduced=21
+ glProgramUniform3uiv; # introduced=21
+ glProgramUniform4f; # introduced=21
+ glProgramUniform4fv; # introduced=21
+ glProgramUniform4i; # introduced=21
+ glProgramUniform4iv; # introduced=21
+ glProgramUniform4ui; # introduced=21
+ glProgramUniform4uiv; # introduced=21
+ glProgramUniformMatrix2fv; # introduced=21
+ glProgramUniformMatrix2x3fv; # introduced=21
+ glProgramUniformMatrix2x4fv; # introduced=21
+ glProgramUniformMatrix3fv; # introduced=21
+ glProgramUniformMatrix3x2fv; # introduced=21
+ glProgramUniformMatrix3x4fv; # introduced=21
+ glProgramUniformMatrix4fv; # introduced=21
+ glProgramUniformMatrix4x2fv; # introduced=21
+ glProgramUniformMatrix4x3fv; # introduced=21
+ glPushDebugGroup; # introduced=24
+ glPushDebugGroupKHR; # introduced=21
+ glReadBuffer;
+ glReadPixels;
+ glReadnPixels; # introduced=24
+ glReleaseShaderCompiler;
+ glRenderbufferStorage;
+ glRenderbufferStorageMultisample;
+ glResumeTransformFeedback;
+ glSampleCoverage;
+ glSampleMaski; # introduced=21
+ glSamplerParameterIiv; # introduced=24
+ glSamplerParameterIivEXT; # introduced=21
+ glSamplerParameterIuiv; # introduced=24
+ glSamplerParameterIuivEXT; # introduced=21
+ glSamplerParameterf;
+ glSamplerParameterfv;
+ glSamplerParameteri;
+ glSamplerParameteriv;
+ glScissor;
+ glShaderBinary;
+ glShaderSource;
+ glStencilFunc;
+ glStencilFuncSeparate;
+ glStencilMask;
+ glStencilMaskSeparate;
+ glStencilOp;
+ glStencilOpSeparate;
+ glTexBuffer; # introduced=24
+ glTexBufferEXT; # introduced=21
+ glTexBufferRange; # introduced=24
+ glTexBufferRangeEXT; # introduced=21
+ glTexImage2D;
+ glTexImage3D;
+ glTexImage3DOES;
+ glTexParameterIiv; # introduced=24
+ glTexParameterIivEXT; # introduced=21
+ glTexParameterIuiv; # introduced=24
+ glTexParameterIuivEXT; # introduced=21
+ glTexParameterf;
+ glTexParameterfv;
+ glTexParameteri;
+ glTexParameteriv;
+ glTexStorage2D;
+ glTexStorage2DMultisample; # introduced=21
+ glTexStorage3D;
+ glTexStorage3DMultisample; # introduced=24
+ glTexStorage3DMultisampleOES; # introduced=21
+ glTexSubImage2D;
+ glTexSubImage3D;
+ glTexSubImage3DOES;
+ glTransformFeedbackVaryings;
+ glUniform1f;
+ glUniform1fv;
+ glUniform1i;
+ glUniform1iv;
+ glUniform1ui;
+ glUniform1uiv;
+ glUniform2f;
+ glUniform2fv;
+ glUniform2i;
+ glUniform2iv;
+ glUniform2ui;
+ glUniform2uiv;
+ glUniform3f;
+ glUniform3fv;
+ glUniform3i;
+ glUniform3iv;
+ glUniform3ui;
+ glUniform3uiv;
+ glUniform4f;
+ glUniform4fv;
+ glUniform4i;
+ glUniform4iv;
+ glUniform4ui;
+ glUniform4uiv;
+ glUniformBlockBinding;
+ glUniformMatrix2fv;
+ glUniformMatrix2x3fv;
+ glUniformMatrix2x4fv;
+ glUniformMatrix3fv;
+ glUniformMatrix3x2fv;
+ glUniformMatrix3x4fv;
+ glUniformMatrix4fv;
+ glUniformMatrix4x2fv;
+ glUniformMatrix4x3fv;
+ glUnmapBuffer;
+ glUnmapBufferOES;
+ glUseProgram;
+ glUseProgramStages; # introduced=21
+ glValidateProgram;
+ glValidateProgramPipeline; # introduced=21
+ glVertexAttrib1f;
+ glVertexAttrib1fv;
+ glVertexAttrib2f;
+ glVertexAttrib2fv;
+ glVertexAttrib3f;
+ glVertexAttrib3fv;
+ glVertexAttrib4f;
+ glVertexAttrib4fv;
+ glVertexAttribBinding; # introduced=21
+ glVertexAttribDivisor;
+ glVertexAttribFormat; # introduced=21
+ glVertexAttribI4i;
+ glVertexAttribI4iv;
+ glVertexAttribI4ui;
+ glVertexAttribI4uiv;
+ glVertexAttribIFormat; # introduced=21
+ glVertexAttribIPointer;
+ glVertexAttribPointer;
+ glVertexBindingDivisor; # introduced=21
+ glViewport;
+ glWaitSync;
+ local:
+ *;
+};
y[2] /= mag;
}
-#define M(row,col) m[col*4+row]
+#define M(row,col) m[(col)*4+(row)]
M(0, 0) = x[0];
M(0, 1) = x[1];
M(0, 2) = x[2];
#define CMD_START_FRAMEWORK "start 2>&1"
// Macros
-#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array
+#define NUMA(a) (sizeof(a) / sizeof((a)[0])) // Num elements in an array
#define MEMCLR(addr, size) do { \
memset((addr), 0, (size)); \
} while (0)
#define CMD_START_FRAMEWORK "start 2>&1"
// Macros
-#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array
+#define NUMA(a) (sizeof(a) / sizeof((a)[0])) // Num elements in an array
// Local types
class Rectangle {
public:
- Rectangle(uint32_t graphicFormat = defaultFormat,
+ explicit Rectangle(uint32_t graphicFormat = defaultFormat,
HwcTestDim dfDim = HwcTestDim(1, 1),
HwcTestDim sDim = HwcTestDim(1, 1));
void setSourceDim(HwcTestDim dim);
#define CMD_START_FRAMEWORK "start 2>&1"
// Macros
-#define NUMA(a) (sizeof(a) / sizeof(a [0])) // Num elements in an array
+#define NUMA(a) (sizeof(a) / sizeof((a)[0])) // Num elements in an array
// Local types
class Rectangle {
#define CMD_STOP_FRAMEWORK "stop 2>&1"
#define CMD_START_FRAMEWORK "start 2>&1"
-#define NUMA(a) (sizeof(a) / sizeof(a [0]))
+#define NUMA(a) (sizeof(a) / sizeof((a)[0]))
#define MEMCLR(addr, size) do { \
memset((addr), 0, (size)); \
} while (0)
class ColorRGB {
public:
ColorRGB(): _r(0.0), _g(0.0), _b(0.0) {};
- ColorRGB(float f): _r(f), _g(f), _b(f) {}; // Gray
+ ColorRGB(float f): _r(f), _g(f), _b(f) {}; // Gray, NOLINT(implicit)
ColorRGB(float r, float g, float b): _r(r), _g(g), _b(b) {};
float r(void) const { return _r; }
float g(void) const { return _g; }
--- /dev/null
+cc_library_static {
+ name: "libbatteryservice",
+
+ srcs: [
+ "BatteryProperties.cpp",
+ "BatteryProperty.cpp",
+ "IBatteryPropertiesListener.cpp",
+ "IBatteryPropertiesRegistrar.cpp",
+ ],
+
+ static_libs: [
+ "libutils",
+ "libbinder",
+ ],
+
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wunused",
+ "-Wunreachable-code",
+ ],
+}
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- BatteryProperties.cpp \
- BatteryProperty.cpp \
- IBatteryPropertiesListener.cpp \
- IBatteryPropertiesRegistrar.cpp
-
-LOCAL_STATIC_LIBRARIES := \
- libutils \
- libbinder
-
-LOCAL_MODULE:= libbatteryservice
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code
-
-include $(BUILD_STATIC_LIBRARY)
class BpBatteryPropertiesListener : public BpInterface<IBatteryPropertiesListener>
{
public:
- BpBatteryPropertiesListener(const sp<IBinder>& impl)
+ explicit BpBatteryPropertiesListener(const sp<IBinder>& impl)
: BpInterface<IBatteryPropertiesListener>(impl)
{
}
class BpBatteryPropertiesRegistrar : public BpInterface<IBatteryPropertiesRegistrar> {
public:
- BpBatteryPropertiesRegistrar(const sp<IBinder>& impl)
+ explicit BpBatteryPropertiesRegistrar(const sp<IBinder>& impl)
: BpInterface<IBatteryPropertiesRegistrar>(impl) {}
void registerListener(const sp<IBatteryPropertiesListener>& listener) {
* operation with a byte that only has the relevant bit set.
* eg. to check for the 12th bit, we do (array[1] & 1<<4)
*/
-#define test_bit(bit, array) (array[bit/8] & (1<<(bit%8)))
+#define test_bit(bit, array) ((array)[(bit)/8] & (1<<((bit)%8)))
/* this macro computes the number of bytes needed to represent a bit array of the specified size */
-#define sizeof_bit_array(bits) ((bits + 7) / 8)
+#define sizeof_bit_array(bits) (((bits) + 7) / 8)
#define INDENT " "
#define INDENT2 " "
};
struct ConfigurationChangedEntry : EventEntry {
- ConfigurationChangedEntry(nsecs_t eventTime);
+ explicit ConfigurationChangedEntry(nsecs_t eventTime);
virtual void appendDescription(String8& msg) const;
protected:
class Connection;
struct CommandEntry : Link<CommandEntry> {
- CommandEntry(Command command);
+ explicit CommandEntry(Command command);
~CommandEntry();
Command command;
inline NotifyConfigurationChangedArgs() { }
- NotifyConfigurationChangedArgs(nsecs_t eventTime);
+ explicit NotifyConfigurationChangedArgs(nsecs_t eventTime);
NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other);
virtual ~QueuedInputListener();
public:
- QueuedInputListener(const sp<InputListenerInterface>& innerListener);
+ explicit QueuedInputListener(const sp<InputListenerInterface>& innerListener);
virtual void notifyConfigurationChanged(const NotifyConfigurationChangedArgs* args);
virtual void notifyKey(const NotifyKeyArgs* args);
size_t inCount = mMultiTouchMotionAccumulator.getSlotCount();
size_t outCount = 0;
BitSet32 newPointerIdBits;
+ mHavePointerIds = true;
for (size_t inIndex = 0; inIndex < inCount; inIndex++) {
const MultiTouchMotionAccumulator::Slot* inSlot =
outPointer.isHovering = isHovering;
// Assign pointer id using tracking id if available.
- mHavePointerIds = true;
- int32_t trackingId = inSlot->getTrackingId();
- int32_t id = -1;
- if (trackingId >= 0) {
- for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) {
- uint32_t n = idBits.clearFirstMarkedBit();
- if (mPointerTrackingIdMap[n] == trackingId) {
- id = n;
+ if (mHavePointerIds) {
+ int32_t trackingId = inSlot->getTrackingId();
+ int32_t id = -1;
+ if (trackingId >= 0) {
+ for (BitSet32 idBits(mPointerIdBits); !idBits.isEmpty(); ) {
+ uint32_t n = idBits.clearFirstMarkedBit();
+ if (mPointerTrackingIdMap[n] == trackingId) {
+ id = n;
+ }
}
- }
- if (id < 0 && !mPointerIdBits.isFull()) {
- id = mPointerIdBits.markFirstUnmarkedBit();
- mPointerTrackingIdMap[id] = trackingId;
+ if (id < 0 && !mPointerIdBits.isFull()) {
+ id = mPointerIdBits.markFirstUnmarkedBit();
+ mPointerTrackingIdMap[id] = trackingId;
+ }
+ }
+ if (id < 0) {
+ mHavePointerIds = false;
+ outState->rawPointerData.clearIdBits();
+ newPointerIdBits.clear();
+ } else {
+ outPointer.id = id;
+ outState->rawPointerData.idToIndex[id] = outCount;
+ outState->rawPointerData.markIdBit(id, isHovering);
+ newPointerIdBits.markBit(id);
}
}
- if (id < 0) {
- mHavePointerIds = false;
- outState->rawPointerData.clearIdBits();
- newPointerIdBits.clear();
- } else {
- outPointer.id = id;
- outState->rawPointerData.idToIndex[id] = outCount;
- outState->rawPointerData.markIdBit(id, isHovering);
- newPointerIdBits.markBit(id);
- }
-
outCount += 1;
}
InputReader* mReader;
public:
- ContextImpl(InputReader* reader);
+ explicit ContextImpl(InputReader* reader);
virtual void updateGlobalMetaState();
virtual int32_t getGlobalMetaState();
/* Reads raw events from the event hub and processes them, endlessly. */
class InputReaderThread : public Thread {
public:
- InputReaderThread(const sp<InputReaderInterface>& reader);
+ explicit InputReaderThread(const sp<InputReaderInterface>& reader);
virtual ~InputReaderThread();
private:
*/
class InputMapper {
public:
- InputMapper(InputDevice* device);
+ explicit InputMapper(InputDevice* device);
virtual ~InputMapper();
inline InputDevice* getDevice() { return mDevice; }
class SwitchInputMapper : public InputMapper {
public:
- SwitchInputMapper(InputDevice* device);
+ explicit SwitchInputMapper(InputDevice* device);
virtual ~SwitchInputMapper();
virtual uint32_t getSources();
class VibratorInputMapper : public InputMapper {
public:
- VibratorInputMapper(InputDevice* device);
+ explicit VibratorInputMapper(InputDevice* device);
virtual ~VibratorInputMapper();
virtual uint32_t getSources();
class CursorInputMapper : public InputMapper {
public:
- CursorInputMapper(InputDevice* device);
+ explicit CursorInputMapper(InputDevice* device);
virtual ~CursorInputMapper();
virtual uint32_t getSources();
class RotaryEncoderInputMapper : public InputMapper {
public:
- RotaryEncoderInputMapper(InputDevice* device);
+ explicit RotaryEncoderInputMapper(InputDevice* device);
virtual ~RotaryEncoderInputMapper();
virtual uint32_t getSources();
class TouchInputMapper : public InputMapper {
public:
- TouchInputMapper(InputDevice* device);
+ explicit TouchInputMapper(InputDevice* device);
virtual ~TouchInputMapper();
virtual uint32_t getSources();
class SingleTouchInputMapper : public TouchInputMapper {
public:
- SingleTouchInputMapper(InputDevice* device);
+ explicit SingleTouchInputMapper(InputDevice* device);
virtual ~SingleTouchInputMapper();
virtual void reset(nsecs_t when);
class MultiTouchInputMapper : public TouchInputMapper {
public:
- MultiTouchInputMapper(InputDevice* device);
+ explicit MultiTouchInputMapper(InputDevice* device);
virtual ~MultiTouchInputMapper();
virtual void reset(nsecs_t when);
class ExternalStylusInputMapper : public InputMapper {
public:
- ExternalStylusInputMapper(InputDevice* device);
+ explicit ExternalStylusInputMapper(InputDevice* device);
virtual ~ExternalStylusInputMapper() = default;
virtual uint32_t getSources();
class JoystickInputMapper : public InputMapper {
public:
- JoystickInputMapper(InputDevice* device);
+ explicit JoystickInputMapper(InputDevice* device);
virtual ~JoystickInputMapper();
virtual uint32_t getSources();
void releaseInfo();
protected:
- InputWindowHandle(const sp<InputApplicationHandle>& inputApplicationHandle);
+ explicit InputWindowHandle(const sp<InputApplicationHandle>& inputApplicationHandle);
virtual ~InputWindowHandle();
InputWindowInfo* mInfo;
class InputDriver : public InputDriverInterface {
public:
- InputDriver(const char* name);
+ explicit InputDriver(const char* name);
virtual ~InputDriver() = default;
virtual void init() override;
KeyedVector<int32_t, bool> leds;
Vector<VirtualKeyDefinition> virtualKeys;
- Device(uint32_t classes) :
+ explicit Device(uint32_t classes) :
classes(classes) {
}
};
--- /dev/null
+BasedOnStyle: Google
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: true
+BinPackArguments: true
+BinPackParameters: true
+ColumnLimit: 80
+CommentPragmas: NOLINT:.*
+ContinuationIndentWidth: 8
+DerivePointerAlignment: false
+IndentWidth: 4
+PointerAlignment: Left
+TabWidth: 4
-# Copyright (C) 2010 The Android Open Source Project
+# 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.
# 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.
+#
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_MODULE := libdiskusage
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_SRC_FILES := dirsize.c
+LOCAL_PATH := $(call my-dir)
-include $(BUILD_STATIC_LIBRARY)
\ No newline at end of file
+include $(CLEAR_VARS)
+LOCAL_MODULE := nativeperms
+LOCAL_SRC_FILES := \
+ nativeperms.cpp \
+ android/os/IPermissionController.aidl
+LOCAL_CFLAGS := -Wall -Werror
+LOCAL_SHARED_LIBRARIES := \
+ libbinder \
+ libbrillo \
+ libbrillo-binder \
+ libchrome \
+ libutils
+LOCAL_INIT_RC := nativeperms.rc
+include $(BUILD_EXECUTABLE)
--- /dev/null
+/* //device/java/android/android/os/IPowerManager.aidl
+**
+** Copyright 2007, 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.
+*/
+
+package android.os;
+
+/** @hide */
+interface IPermissionController {
+ boolean checkPermission(String permission, int pid, int uid);
+ String[] getPackagesForUid(int uid);
+ boolean isRuntimePermission(String permission);
+}
--- /dev/null
+IPermissionController.aidl in this directory is a verbatim copy of
+https://android.googlesource.com/platform/frameworks/base/+/master/core/java/android/os/IPermissionController.aidl,
+because some Brillo manifests do not currently include the frameworks/base repo.
+TODO(jorgelo): Figure out a way to use the .aidl file in frameworks/base.
--- /dev/null
+/*
+ * 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.
+ */
+
+#include <base/at_exit.h>
+#include <base/logging.h>
+#include <base/message_loop/message_loop.h>
+#include <binder/IServiceManager.h>
+#include <binder/Status.h>
+#include <brillo/binder_watcher.h>
+#include <brillo/message_loops/base_message_loop.h>
+#include <brillo/syslog_logging.h>
+#include <utils/String16.h>
+
+#include "android/os/BnPermissionController.h"
+
+namespace {
+static android::String16 serviceName("permission");
+}
+
+namespace android {
+
+class PermissionService : public android::os::BnPermissionController {
+ public:
+ ::android::binder::Status checkPermission(
+ const ::android::String16& permission, int32_t pid, int32_t uid,
+ bool* _aidl_return) {
+ (void)permission;
+ (void)pid;
+ (void)uid;
+ *_aidl_return = true;
+ return binder::Status::ok();
+ }
+
+ ::android::binder::Status getPackagesForUid(
+ int32_t uid, ::std::vector<::android::String16>* _aidl_return) {
+ (void)uid;
+ // Brillo doesn't currently have installable packages.
+ if (_aidl_return) {
+ _aidl_return->clear();
+ }
+ return binder::Status::ok();
+ }
+
+ ::android::binder::Status isRuntimePermission(
+ const ::android::String16& permission, bool* _aidl_return) {
+ (void)permission;
+ // Brillo doesn't currently have runtime permissions.
+ *_aidl_return = false;
+ return binder::Status::ok();
+ }
+};
+
+} // namespace android
+
+int main() {
+ base::AtExitManager atExitManager;
+ brillo::InitLog(brillo::kLogToSyslog);
+ // Register the service with servicemanager.
+ android::status_t status = android::defaultServiceManager()->addService(
+ serviceName, new android::PermissionService());
+ CHECK(status == android::OK) << "Failed to get IPermissionController "
+ "binder from servicemanager.";
+
+ // Create a message loop.
+ base::MessageLoopForIO messageLoopForIo;
+ brillo::BaseMessageLoop messageLoop{&messageLoopForIo};
+
+ // Initialize a binder watcher.
+ brillo::BinderWatcher watcher(&messageLoop);
+ watcher.Init();
+
+ // Run the message loop.
+ messageLoop.Run();
+}
--- /dev/null
+service nativeperms /system/bin/nativeperms
+ class main
+ user system
+ group system
--- /dev/null
+cc_library_shared {
+ name: "libpowermanager",
+
+ srcs: ["IPowerManager.cpp"],
+
+ shared_libs: [
+ "libutils",
+ "libbinder",
+ ],
+
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wunused",
+ "-Wunreachable-code",
+ ],
+}
+++ /dev/null
-LOCAL_PATH:= $(call my-dir)
-include $(CLEAR_VARS)
-
-LOCAL_SRC_FILES:= \
- IPowerManager.cpp
-
-LOCAL_SHARED_LIBRARIES := \
- libutils \
- libbinder
-
-LOCAL_MODULE:= libpowermanager
-
-LOCAL_MODULE_TAGS := optional
-
-LOCAL_CFLAGS += -Wall -Werror -Wunused -Wunreachable-code
-
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/../../include
-
-include $(BUILD_SHARED_LIBRARY)
class BpPowerManager : public BpInterface<IPowerManager>
{
public:
- BpPowerManager(const sp<IBinder>& impl)
+ explicit BpPowerManager(const sp<IBinder>& impl)
: BpInterface<IPowerManager>(impl)
{
}
// behavior.
class RecentEventLogger : public Dumpable {
public:
- RecentEventLogger(int sensorType);
+ explicit RecentEventLogger(int sensorType);
void addEvent(const sensors_event_t& event);
bool populateLastEvent(sensors_event_t *event) const;
bool isEmpty() const;
protected:
struct SensorEventLog {
- SensorEventLog(const sensors_event_t& e);
+ explicit SensorEventLog(const sensors_event_t& e);
timespec mWallTime;
sensors_event_t mEvent;
};
/**
* Construct a RingBuffer that can grow up to the given length.
*/
- RingBuffer(size_t length);
+ explicit RingBuffer(size_t length);
/**
* Forward iterator to this class. Implements an std:forward_iterator.
class RotationVectorSensor : public VirtualSensor {
public:
- RotationVectorSensor(int mode = FUSION_9AXIS);
+ explicit RotationVectorSensor(int mode = FUSION_9AXIS);
virtual bool process(sensors_event_t* outEvent, const sensors_event_t& event) override;
virtual status_t activate(void* ident, bool enabled) override;
virtual status_t setDelay(void* ident, int handle, int64_t ns) override;
sp<SensorService> const mService;
public:
virtual bool threadLoop();
- SensorEventAckReceiver(const sp<SensorService>& service)
+ explicit SensorEventAckReceiver(const sp<SensorService>& service)
: mService(service) {
}
};
class BaseSensor : public SensorInterface {
public:
- BaseSensor(const sensor_t& sensor);
+ explicit BaseSensor(const sensor_t& sensor);
BaseSensor(const sensor_t& sensor, const uint8_t (&uuid)[16]);
// Not all sensors need to support batching.
class HardwareSensor : public BaseSensor {
public:
- HardwareSensor(const sensor_t& sensor);
+ explicit HardwareSensor(const sensor_t& sensor);
HardwareSensor(const sensor_t& sensor, const uint8_t (&uuid)[16]);
virtual ~HardwareSensor();
status_t SensorService::resetToNormalModeLocked() {
SensorDevice& dev(SensorDevice::getInstance());
- dev.enableAllSensors();
status_t err = dev.setMode(NORMAL);
- mCurrentOperatingMode = NORMAL;
+ if (err == NO_ERROR) {
+ mCurrentOperatingMode = NORMAL;
+ dev.enableAllSensors();
+ }
return err;
}
#define IGNORE_HARDWARE_FUSION false
#define DEBUG_CONNECTIONS false
// Max size is 100 KB which is enough to accept a batch of about 1000 events.
-#define MAX_SOCKET_BUFFER_SIZE_BATCHED 100 * 1024
+#define MAX_SOCKET_BUFFER_SIZE_BATCHED (100 * 1024)
// For older HALs which don't support batching, use a smaller socket buffer size.
-#define SOCKET_BUFFER_SIZE_NON_BATCHED 4 * 1024
+#define SOCKET_BUFFER_SIZE_NON_BATCHED (4 * 1024)
#define SENSOR_REGISTRATIONS_BUF_SIZE 200
mat() { }
mat(const mat& rhs) : base(rhs) { }
- mat(const base& rhs) : base(rhs) { }
+ mat(const base& rhs) : base(rhs) { } // NOLINT(implicit)
// -----------------------------------------------------------------------
// conversion constructors
// sets the diagonal to the value, off-diagonal to zero
- mat(pTYPE rhs) {
+ mat(pTYPE rhs) { // NOLINT(implicit)
helpers::doAssign(*this, rhs);
}
template<size_t PREV_COLUMN>
struct column_builder {
mat& matrix;
- column_builder(mat& matrix) : matrix(matrix) { }
+ explicit column_builder(mat& matrix) : matrix(matrix) { }
};
// operator << is not a method of column_builder<> so we can
enum { ROWS = R, COLS = 1 };
mat() { }
- mat(const base& rhs) : base(rhs) { }
+ explicit mat(const base& rhs) : base(rhs) { }
mat(const mat& rhs) : base(rhs) { }
- mat(const TYPE& rhs) { helpers::doAssign(*this, rhs); }
+ explicit mat(const TYPE& rhs) { helpers::doAssign(*this, rhs); }
mat& operator=(const mat& rhs) { base::operator=(rhs); return *this; }
mat& operator=(const base& rhs) { base::operator=(rhs); return *this; }
mat& operator=(const TYPE& rhs) { return helpers::doAssign(*this, rhs); }
vec() { }
vec(const vec& rhs) : base(rhs) { }
- vec(const base& rhs) : base(rhs) { }
+ vec(const base& rhs) : base(rhs) { } // NOLINT(implicit)
// -----------------------------------------------------------------------
// conversion constructors
- vec(pTYPE rhs) {
+ vec(pTYPE rhs) { // NOLINT(implicit)
for (size_t i=0 ; i<SIZE ; i++)
base::operator[](i) = rhs;
}
endif
LOCAL_CFLAGS += -fvisibility=hidden -Werror=format
-LOCAL_CFLAGS += -std=c++14
LOCAL_STATIC_LIBRARIES := libvkjson
LOCAL_SHARED_LIBRARIES := \
LOCAL_CLANG := true
-LOCAL_LDFLAGS := -Wl,--version-script,art/sigchainlib/version-script.txt -Wl,--export-dynamic
+LOCAL_LDFLAGS_32 := -Wl,--version-script,art/sigchainlib/version-script32.txt -Wl,--export-dynamic
+LOCAL_LDFLAGS_64 := -Wl,--version-script,art/sigchainlib/version-script64.txt -Wl,--export-dynamic
LOCAL_CFLAGS := -DLOG_TAG=\"SurfaceFlinger\"
-LOCAL_CPPFLAGS := -std=c++14
LOCAL_INIT_RC := surfaceflinger.rc
LOCAL_CLANG := true
LOCAL_CFLAGS := -DLOG_TAG=\"SurfaceFlinger\"
-LOCAL_CPPFLAGS := -std=c++14
LOCAL_SRC_FILES := \
DdmConnection.cpp
class Client : public BnSurfaceComposerClient
{
public:
- Client(const sp<SurfaceFlinger>& flinger);
+ explicit Client(const sp<SurfaceFlinger>& flinger);
~Client();
status_t initCheck() const;
WHITE = 37
};
- Colorizer(bool enabled)
+ explicit Colorizer(bool enabled)
: mEnabled(enabled) {
}
virtual void onDispSyncEvent(nsecs_t when) = 0;
};
- DispSync(const char* name);
+ explicit DispSync(const char* name);
~DispSync();
// reset clears the resync samples and error value.
inline FloatRect()
: left(0), top(0), right(0), bottom(0) { }
- inline FloatRect(const Rect& other)
+ inline FloatRect(const Rect& other) // NOLINT(implicit)
: left(other.left), top(other.top), right(other.right), bottom(other.bottom) { }
inline float getWidth() const { return right - left; }
#endif
void FramebufferSurface::dumpAsString(String8& result) const {
- ConsumerBase::dump(result);
+ ConsumerBase::dumpState(result);
}
void FramebufferSurface::dumpLocked(String8& result, const char* prefix) const
class Device
{
public:
- Device(hwc2_device_t* device);
+ explicit Device(hwc2_device_t* device);
~Device();
friend class HWC2::Display;
class HWC2On1Adapter : public hwc2_device_t
{
public:
- HWC2On1Adapter(struct hwc_composer_device_1* hwc1Device);
+ explicit HWC2On1Adapter(struct hwc_composer_device_1* hwc1Device);
~HWC2On1Adapter();
struct hwc_composer_device_1* getHwc1Device() const { return mHwc1Device; }
class Layer {
public:
- Layer(Display& display);
+ explicit Layer(Display& display);
bool operator==(const Layer& other) { return mId == other.mId; }
bool operator!=(const Layer& other) { return !(*this == other); }
class EventControlThread: public Thread {
public:
- EventControlThread(const sp<SurfaceFlinger>& flinger);
+ explicit EventControlThread(const sp<SurfaceFlinger>& flinger);
virtual ~EventControlThread() {}
void setVsyncEnabled(bool enabled);
bool mOverflow;
char mStorage[STORAGE_MAX_SIZE];
public:
- TagBuffer(int32_t tag);
+ explicit TagBuffer(int32_t tag);
// starts list of items
void startList(int8_t count);
class EventThread : public Thread, private VSyncSource::Callback {
class Connection : public BnDisplayEventConnection {
public:
- Connection(const sp<EventThread>& eventThread);
+ explicit Connection(const sp<EventThread>& eventThread);
status_t postEvent(const DisplayEventReceiver::Event& event);
// count >= 1 : continuous event. count is the vsync rate
mSurfaceFlingerConsumer->setContentsChangedListener(this);
mSurfaceFlingerConsumer->setName(mName);
-#ifdef TARGET_DISABLE_TRIPLE_BUFFERING
-#warning "disabling triple buffering"
-#else
+#ifndef TARGET_DISABLE_TRIPLE_BUFFERING
mProducer->setMaxDequeuedBufferCount(2);
#endif
mQueuedFrames, mRefreshPending);
if (mSurfaceFlingerConsumer != 0) {
- mSurfaceFlingerConsumer->dump(result, " ");
+ mSurfaceFlingerConsumer->dumpState(result, " ");
}
}
class SyncPoint
{
public:
- SyncPoint(uint64_t frameNumber) : mFrameNumber(frameNumber),
+ explicit SyncPoint(uint64_t frameNumber) : mFrameNumber(frameNumber),
mFrameIsAvailable(false), mTransactionIsApplied(false) {}
uint64_t getFrameNumber() const {
MessageQueue& mQueue;
int32_t mEventMask;
public:
- Handler(MessageQueue& queue) : mQueue(queue), mEventMask(0) { }
+ explicit Handler(MessageQueue& queue) : mQueue(queue), mEventMask(0) { }
virtual void handleMessage(const Message& message);
void dispatchRefresh();
void dispatchInvalidate();
}
int SurfaceFlinger::getActiveConfig(const sp<IBinder>& display) {
+ if (display == NULL) {
+ ALOGE("%s : display is NULL", __func__);
+ return BAD_VALUE;
+ }
sp<DisplayDevice> device(getDisplayDevice(display));
if (device != NULL) {
return device->getActiveConfig();
return err;
}
+ if (autoRefresh) {
+ *autoRefresh = item.mAutoRefresh;
+ }
+
+ if (queuedBuffer) {
+ *queuedBuffer = item.mQueuedBuffer;
+ }
+
// We call the rejecter here, in case the caller has a reason to
// not accept this buffer. This is used by SurfaceFlinger to
// reject buffers which have the wrong size
return BUFFER_REJECTED;
}
- if (autoRefresh) {
- *autoRefresh = item.mAutoRefresh;
- }
-
- if (queuedBuffer) {
- *queuedBuffer = item.mQueuedBuffer;
- }
-
// Release the previous buffer.
#ifdef USE_HWC2
err = updateAndReleaseLocked(item, &mPendingRelease);
--- /dev/null
+// Copyright (C) 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.
+
+ndk_headers {
+ name: "libvulkan_headers",
+ from: "include",
+ to: "",
+ srcs: ["include/vulkan/**/*.h"],
+ license: "include/vulkan/NOTICE",
+}
+
+subdirs = [
+ "libvulkan",
+]
--- /dev/null
+Copyright (c) 2015-2016 The Khronos Group Inc.
+
+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.
--- /dev/null
+// Copyright (C) 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.
+
+// Headers module is in frameworks/native/vulkan/Android.bp.
+ndk_library {
+ name: "libvulkan.ndk",
+ symbol_file: "libvulkan.map.txt",
+ first_version: "24",
+}
-Wno-padded \
-Wno-switch-enum \
-Wno-undef
+
#LOCAL_CFLAGS += -DLOG_NDEBUG=0
LOCAL_CPPFLAGS := -std=c++14 \
-Wno-c99-extensions \
class DebugReportLogger {
public:
- DebugReportLogger(const VkInstanceCreateInfo& info)
+ explicit DebugReportLogger(const VkInstanceCreateInfo& info)
: instance_pnext_(info.pNext), callbacks_(nullptr) {}
- DebugReportLogger(const DebugReportCallbackList& callbacks)
+ explicit DebugReportLogger(const DebugReportCallbackList& callbacks)
: instance_pnext_(nullptr), callbacks_(&callbacks) {}
void Message(VkDebugReportFlagsEXT flags,
VK_DEFINE_HANDLE(DeviceDispatchable)
struct InstanceData {
- InstanceData(const VkAllocationCallbacks& alloc)
+ explicit InstanceData(const VkAllocationCallbacks& alloc)
: opaque_api_data(),
allocator(alloc),
driver(),
class LayerRef {
public:
- LayerRef(const Layer* layer);
+ explicit LayerRef(const Layer* layer);
LayerRef(LayerRef&& other);
~LayerRef();
LayerRef(const LayerRef&) = delete;
--- /dev/null
+LIBVULKAN {
+ global:
+ vkAcquireNextImageKHR;
+ vkAllocateCommandBuffers;
+ vkAllocateDescriptorSets;
+ vkAllocateMemory;
+ vkBeginCommandBuffer;
+ vkBindBufferMemory;
+ vkBindImageMemory;
+ vkCmdBeginQuery;
+ vkCmdBeginRenderPass;
+ vkCmdBindDescriptorSets;
+ vkCmdBindIndexBuffer;
+ vkCmdBindPipeline;
+ vkCmdBindVertexBuffers;
+ vkCmdBlitImage;
+ vkCmdClearAttachments;
+ vkCmdClearColorImage;
+ vkCmdClearDepthStencilImage;
+ vkCmdCopyBuffer;
+ vkCmdCopyBufferToImage;
+ vkCmdCopyImage;
+ vkCmdCopyImageToBuffer;
+ vkCmdCopyQueryPoolResults;
+ vkCmdDispatch;
+ vkCmdDispatchIndirect;
+ vkCmdDraw;
+ vkCmdDrawIndexed;
+ vkCmdDrawIndexedIndirect;
+ vkCmdDrawIndirect;
+ vkCmdEndQuery;
+ vkCmdEndRenderPass;
+ vkCmdExecuteCommands;
+ vkCmdFillBuffer;
+ vkCmdNextSubpass;
+ vkCmdPipelineBarrier;
+ vkCmdPushConstants;
+ vkCmdResetEvent;
+ vkCmdResetQueryPool;
+ vkCmdResolveImage;
+ vkCmdSetBlendConstants;
+ vkCmdSetDepthBias;
+ vkCmdSetDepthBounds;
+ vkCmdSetEvent;
+ vkCmdSetLineWidth;
+ vkCmdSetScissor;
+ vkCmdSetStencilCompareMask;
+ vkCmdSetStencilReference;
+ vkCmdSetStencilWriteMask;
+ vkCmdSetViewport;
+ vkCmdUpdateBuffer;
+ vkCmdWaitEvents;
+ vkCmdWriteTimestamp;
+ vkCreateAndroidSurfaceKHR;
+ vkCreateBuffer;
+ vkCreateBufferView;
+ vkCreateCommandPool;
+ vkCreateComputePipelines;
+ vkCreateDescriptorPool;
+ vkCreateDescriptorSetLayout;
+ vkCreateDevice;
+ vkCreateEvent;
+ vkCreateFence;
+ vkCreateFramebuffer;
+ vkCreateGraphicsPipelines;
+ vkCreateImage;
+ vkCreateImageView;
+ vkCreateInstance;
+ vkCreatePipelineCache;
+ vkCreatePipelineLayout;
+ vkCreateQueryPool;
+ vkCreateRenderPass;
+ vkCreateSampler;
+ vkCreateSemaphore;
+ vkCreateShaderModule;
+ vkCreateSwapchainKHR;
+ vkDestroyBuffer;
+ vkDestroyBufferView;
+ vkDestroyCommandPool;
+ vkDestroyDescriptorPool;
+ vkDestroyDescriptorSetLayout;
+ vkDestroyDevice;
+ vkDestroyEvent;
+ vkDestroyFence;
+ vkDestroyFramebuffer;
+ vkDestroyImage;
+ vkDestroyImageView;
+ vkDestroyInstance;
+ vkDestroyPipeline;
+ vkDestroyPipelineCache;
+ vkDestroyPipelineLayout;
+ vkDestroyQueryPool;
+ vkDestroyRenderPass;
+ vkDestroySampler;
+ vkDestroySemaphore;
+ vkDestroyShaderModule;
+ vkDestroySurfaceKHR;
+ vkDestroySwapchainKHR;
+ vkDeviceWaitIdle;
+ vkEndCommandBuffer;
+ vkEnumerateDeviceExtensionProperties;
+ vkEnumerateDeviceLayerProperties;
+ vkEnumerateInstanceExtensionProperties;
+ vkEnumerateInstanceLayerProperties;
+ vkEnumeratePhysicalDevices;
+ vkFlushMappedMemoryRanges;
+ vkFreeCommandBuffers;
+ vkFreeDescriptorSets;
+ vkFreeMemory;
+ vkGetBufferMemoryRequirements;
+ vkGetDeviceMemoryCommitment;
+ vkGetDeviceProcAddr;
+ vkGetDeviceQueue;
+ vkGetEventStatus;
+ vkGetFenceStatus;
+ vkGetImageMemoryRequirements;
+ vkGetImageSparseMemoryRequirements;
+ vkGetImageSubresourceLayout;
+ vkGetInstanceProcAddr;
+ vkGetPhysicalDeviceFeatures;
+ vkGetPhysicalDeviceFormatProperties;
+ vkGetPhysicalDeviceImageFormatProperties;
+ vkGetPhysicalDeviceMemoryProperties;
+ vkGetPhysicalDeviceProperties;
+ vkGetPhysicalDeviceQueueFamilyProperties;
+ vkGetPhysicalDeviceSparseImageFormatProperties;
+ vkGetPhysicalDeviceSurfaceCapabilitiesKHR;
+ vkGetPhysicalDeviceSurfaceFormatsKHR;
+ vkGetPhysicalDeviceSurfacePresentModesKHR;
+ vkGetPhysicalDeviceSurfaceSupportKHR;
+ vkGetPipelineCacheData;
+ vkGetQueryPoolResults;
+ vkGetRenderAreaGranularity;
+ vkGetSwapchainImagesKHR;
+ vkInvalidateMappedMemoryRanges;
+ vkMapMemory;
+ vkMergePipelineCaches;
+ vkQueueBindSparse;
+ vkQueuePresentKHR;
+ vkQueueSubmit;
+ vkQueueWaitIdle;
+ vkResetCommandBuffer;
+ vkResetCommandPool;
+ vkResetDescriptorPool;
+ vkResetEvent;
+ vkResetFences;
+ vkSetEvent;
+ vkUnmapMemory;
+ vkUpdateDescriptorSets;
+ vkWaitForFences;
+ local:
+ *;
+};
static std::bitset<kMaxInstances> g_instance_used(false);
static std::array<hwvulkan_dispatch_t, kMaxInstances> g_instances;
-[[noreturn]] void NoOp() {
+[[noreturn]] VKAPI_ATTR void NoOp() {
LOG_ALWAYS_FATAL("invalid stub function called");
}
if (formats) {
if (*count < kNumFormats)
result = VK_INCOMPLETE;
- std::copy(kFormats, kFormats + std::min(*count, kNumFormats), formats);
+ *count = std::min(*count, kNumFormats);
+ std::copy(kFormats, kFormats + *count, formats);
+ } else {
+ *count = kNumFormats;
}
- *count = kNumFormats;
return result;
}
if (modes) {
if (*count < kNumModes)
result = VK_INCOMPLETE;
- std::copy(kModes, kModes + std::min(*count, kNumModes), modes);
+ *count = std::min(*count, kNumModes);
+ std::copy(kModes, kModes + *count, modes);
+ } else {
+ *count = kNumModes;
}
- *count = kNumModes;
return result;
}
}
for (uint32_t i = 0; i < n; i++)
images[i] = swapchain.images[i].image;
+ *count = n;
+ } else {
+ *count = swapchain.num_images;
}
- *count = swapchain.num_images;
return result;
}
OSDN Git Service
