Merge "Log errors from loading public libraries"
diff --git a/adb/client/usb_dispatch.cpp b/adb/client/usb_dispatch.cpp
index 597e66e..f02dccf 100644
--- a/adb/client/usb_dispatch.cpp
+++ b/adb/client/usb_dispatch.cpp
@@ -24,10 +24,10 @@
void usb_init() {
if (should_use_libusb()) {
- LOG(INFO) << "using libusb backend";
+ LOG(DEBUG) << "using libusb backend";
libusb::usb_init();
} else {
- LOG(INFO) << "using native backend";
+ LOG(DEBUG) << "using native backend";
native::usb_init();
}
}
diff --git a/adf/libadf/Android.bp b/adf/libadf/Android.bp
index 2b5461e..1a81a49 100644
--- a/adf/libadf/Android.bp
+++ b/adf/libadf/Android.bp
@@ -19,3 +19,5 @@
local_include_dirs: ["include"],
export_include_dirs: ["include"],
}
+
+subdirs = ["tests"]
diff --git a/adf/libadf/include/video/adf.h b/adf/libadf/include/video/adf.h
new file mode 100644
index 0000000..77203a5
--- /dev/null
+++ b/adf/libadf/include/video/adf.h
@@ -0,0 +1,180 @@
+/****************************************************************************
+ ****************************************************************************
+ ***
+ *** This header was automatically generated from a Linux kernel header
+ *** of the same name, to make information necessary for userspace to
+ *** call into the kernel available to libc. It contains only constants,
+ *** structures, and macros generated from the original header, and thus,
+ *** contains no copyrightable information.
+ ***
+ *** To edit the content of this header, modify the corresponding
+ *** source file (e.g. under external/kernel-headers/original/) then
+ *** run bionic/libc/kernel/tools/update_all.py
+ ***
+ *** Any manual change here will be lost the next time this script will
+ *** be run. You've been warned!
+ ***
+ ****************************************************************************
+ ****************************************************************************/
+#ifndef _UAPI_VIDEO_ADF_H_
+#define _UAPI_VIDEO_ADF_H_
+#include <linux/ioctl.h>
+#include <linux/types.h>
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+#include <drm/drm_fourcc.h>
+#include <drm/drm_mode.h>
+#define ADF_NAME_LEN 32
+#define ADF_MAX_CUSTOM_DATA_SIZE 4096
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+enum adf_interface_type {
+ ADF_INTF_DSI = 0,
+ ADF_INTF_eDP = 1,
+ ADF_INTF_DPI = 2,
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ ADF_INTF_VGA = 3,
+ ADF_INTF_DVI = 4,
+ ADF_INTF_HDMI = 5,
+ ADF_INTF_MEMORY = 6,
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ ADF_INTF_TYPE_DEVICE_CUSTOM = 128,
+ ADF_INTF_TYPE_MAX = (~(__u32) 0),
+};
+#define ADF_INTF_FLAG_PRIMARY (1 << 0)
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+#define ADF_INTF_FLAG_EXTERNAL (1 << 1)
+enum adf_event_type {
+ ADF_EVENT_VSYNC = 0,
+ ADF_EVENT_HOTPLUG = 1,
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ ADF_EVENT_DEVICE_CUSTOM = 128,
+ ADF_EVENT_TYPE_MAX = 255,
+};
+struct adf_set_event {
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u8 type;
+ __u8 enabled;
+};
+struct adf_event {
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u8 type;
+ __u32 length;
+};
+struct adf_vsync_event {
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ struct adf_event base;
+ __aligned_u64 timestamp;
+};
+struct adf_hotplug_event {
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ struct adf_event base;
+ __u8 connected;
+};
+#define ADF_MAX_PLANES 4
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+struct adf_buffer_config {
+ __u32 overlay_engine;
+ __u32 w;
+ __u32 h;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u32 format;
+ __s32 fd[ADF_MAX_PLANES];
+ __u32 offset[ADF_MAX_PLANES];
+ __u32 pitch[ADF_MAX_PLANES];
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u8 n_planes;
+ __s32 acquire_fence;
+};
+#define ADF_MAX_BUFFERS (4096 / sizeof(struct adf_buffer_config))
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+struct adf_post_config {
+ size_t n_interfaces;
+ __u32 __user * interfaces;
+ size_t n_bufs;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ struct adf_buffer_config __user * bufs;
+ size_t custom_data_size;
+ void __user * custom_data;
+ __s32 complete_fence;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+};
+#define ADF_MAX_INTERFACES (4096 / sizeof(__u32))
+struct adf_simple_buffer_alloc {
+ __u16 w;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u16 h;
+ __u32 format;
+ __s32 fd;
+ __u32 offset;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u32 pitch;
+};
+struct adf_simple_post_config {
+ struct adf_buffer_config buf;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __s32 complete_fence;
+};
+struct adf_attachment_config {
+ __u32 overlay_engine;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u32 interface;
+};
+struct adf_device_data {
+ char name[ADF_NAME_LEN];
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ size_t n_attachments;
+ struct adf_attachment_config __user * attachments;
+ size_t n_allowed_attachments;
+ struct adf_attachment_config __user * allowed_attachments;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ size_t custom_data_size;
+ void __user * custom_data;
+};
+#define ADF_MAX_ATTACHMENTS (4096 / sizeof(struct adf_attachment_config))
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+struct adf_interface_data {
+ char name[ADF_NAME_LEN];
+ __u32 type;
+ __u32 id;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u32 flags;
+ __u8 dpms_state;
+ __u8 hotplug_detect;
+ __u16 width_mm;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ __u16 height_mm;
+ struct drm_mode_modeinfo current_mode;
+ size_t n_available_modes;
+ struct drm_mode_modeinfo __user * available_modes;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ size_t custom_data_size;
+ void __user * custom_data;
+};
+#define ADF_MAX_MODES (4096 / sizeof(struct drm_mode_modeinfo))
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+struct adf_overlay_engine_data {
+ char name[ADF_NAME_LEN];
+ size_t n_supported_formats;
+ __u32 __user * supported_formats;
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+ size_t custom_data_size;
+ void __user * custom_data;
+};
+#define ADF_MAX_SUPPORTED_FORMATS (4096 / sizeof(__u32))
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+#define ADF_IOCTL_TYPE 'D'
+#define ADF_IOCTL_NR_CUSTOM 128
+#define ADF_SET_EVENT _IOW(ADF_IOCTL_TYPE, 0, struct adf_set_event)
+#define ADF_BLANK _IOW(ADF_IOCTL_TYPE, 1, __u8)
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+#define ADF_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 2, struct adf_post_config)
+#define ADF_SET_MODE _IOW(ADF_IOCTL_TYPE, 3, struct drm_mode_modeinfo)
+#define ADF_GET_DEVICE_DATA _IOR(ADF_IOCTL_TYPE, 4, struct adf_device_data)
+#define ADF_GET_INTERFACE_DATA _IOR(ADF_IOCTL_TYPE, 5, struct adf_interface_data)
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+#define ADF_GET_OVERLAY_ENGINE_DATA _IOR(ADF_IOCTL_TYPE, 6, struct adf_overlay_engine_data)
+#define ADF_SIMPLE_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 7, struct adf_simple_post_config)
+#define ADF_SIMPLE_BUFFER_ALLOC _IOW(ADF_IOCTL_TYPE, 8, struct adf_simple_buffer_alloc)
+#define ADF_ATTACH _IOW(ADF_IOCTL_TYPE, 9, struct adf_attachment_config)
+/* WARNING: DO NOT EDIT, AUTO-GENERATED CODE - SEE TOP FOR INSTRUCTIONS */
+#define ADF_DETACH _IOW(ADF_IOCTL_TYPE, 10, struct adf_attachment_config)
+#endif
diff --git a/adf/libadf/original-kernel-headers/video/adf.h b/adf/libadf/original-kernel-headers/video/adf.h
new file mode 100644
index 0000000..c5d2e62
--- /dev/null
+++ b/adf/libadf/original-kernel-headers/video/adf.h
@@ -0,0 +1,321 @@
+/*
+ * Copyright (C) 2013 Google, Inc.
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _UAPI_VIDEO_ADF_H_
+#define _UAPI_VIDEO_ADF_H_
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+
+#include <drm/drm_fourcc.h>
+#include <drm/drm_mode.h>
+
+#define ADF_NAME_LEN 32
+#define ADF_MAX_CUSTOM_DATA_SIZE 4096
+
+enum adf_interface_type {
+ ADF_INTF_DSI = 0,
+ ADF_INTF_eDP = 1,
+ ADF_INTF_DPI = 2,
+ ADF_INTF_VGA = 3,
+ ADF_INTF_DVI = 4,
+ ADF_INTF_HDMI = 5,
+ ADF_INTF_MEMORY = 6,
+ ADF_INTF_TYPE_DEVICE_CUSTOM = 128,
+ ADF_INTF_TYPE_MAX = (~(__u32)0),
+};
+
+#define ADF_INTF_FLAG_PRIMARY (1 << 0)
+#define ADF_INTF_FLAG_EXTERNAL (1 << 1)
+
+enum adf_event_type {
+ ADF_EVENT_VSYNC = 0,
+ ADF_EVENT_HOTPLUG = 1,
+ ADF_EVENT_DEVICE_CUSTOM = 128,
+ ADF_EVENT_TYPE_MAX = 255,
+};
+
+/**
+ * struct adf_set_event - start or stop subscribing to ADF events
+ *
+ * @type: the type of event to (un)subscribe
+ * @enabled: subscribe or unsubscribe
+ *
+ * After subscribing to an event, userspace may poll() the ADF object's fd
+ * to wait for events or read() to consume the event's data.
+ *
+ * ADF reserves event types 0 to %ADF_EVENT_DEVICE_CUSTOM-1 for its own events.
+ * Devices may use event types %ADF_EVENT_DEVICE_CUSTOM to %ADF_EVENT_TYPE_MAX-1
+ * for driver-private events.
+ */
+struct adf_set_event {
+ __u8 type;
+ __u8 enabled;
+};
+
+/**
+ * struct adf_event - common header for ADF event data
+ *
+ * @type: event type
+ * @length: total size of event data, header inclusive
+ */
+struct adf_event {
+ __u8 type;
+ __u32 length;
+};
+
+/**
+ * struct adf_vsync_event - ADF vsync event
+ *
+ * @base: event header (see &struct adf_event)
+ * @timestamp: time of vsync event, in nanoseconds
+ */
+struct adf_vsync_event {
+ struct adf_event base;
+ __aligned_u64 timestamp;
+};
+
+/**
+ * struct adf_vsync_event - ADF display hotplug event
+ *
+ * @base: event header (see &struct adf_event)
+ * @connected: whether a display is now connected to the interface
+ */
+struct adf_hotplug_event {
+ struct adf_event base;
+ __u8 connected;
+};
+
+#define ADF_MAX_PLANES 4
+/**
+ * struct adf_buffer_config - description of buffer displayed by adf_post_config
+ *
+ * @overlay_engine: id of the target overlay engine
+ * @w: width of display region in pixels
+ * @h: height of display region in pixels
+ * @format: DRM-style fourcc, see drm_fourcc.h for standard formats
+ * @fd: dma_buf fd for each plane
+ * @offset: location of first pixel to scan out, in bytes
+ * @pitch: stride (i.e. length of a scanline including padding) in bytes
+ * @n_planes: number of planes in buffer
+ * @acquire_fence: sync_fence fd which will clear when the buffer is
+ * ready for display, or <0 if the buffer is already ready
+ */
+struct adf_buffer_config {
+ __u32 overlay_engine;
+
+ __u32 w;
+ __u32 h;
+ __u32 format;
+
+ __s32 fd[ADF_MAX_PLANES];
+ __u32 offset[ADF_MAX_PLANES];
+ __u32 pitch[ADF_MAX_PLANES];
+ __u8 n_planes;
+
+ __s32 acquire_fence;
+};
+#define ADF_MAX_BUFFERS (4096 / sizeof(struct adf_buffer_config))
+
+/**
+ * struct adf_post_config - request to flip to a new set of buffers
+ *
+ * @n_interfaces: number of interfaces targeted by the flip (input)
+ * @interfaces: ids of interfaces targeted by the flip (input)
+ * @n_bufs: number of buffers displayed (input)
+ * @bufs: description of buffers displayed (input)
+ * @custom_data_size: size of driver-private data (input)
+ * @custom_data: driver-private data (input)
+ * @complete_fence: sync_fence fd which will clear when this
+ * configuration has left the screen (output)
+ */
+struct adf_post_config {
+ size_t n_interfaces;
+ __u32 __user *interfaces;
+
+ size_t n_bufs;
+ struct adf_buffer_config __user *bufs;
+
+ size_t custom_data_size;
+ void __user *custom_data;
+
+ __s32 complete_fence;
+};
+#define ADF_MAX_INTERFACES (4096 / sizeof(__u32))
+
+/**
+ * struct adf_simple_buffer_allocate - request to allocate a "simple" buffer
+ *
+ * @w: width of buffer in pixels (input)
+ * @h: height of buffer in pixels (input)
+ * @format: DRM-style fourcc (input)
+ *
+ * @fd: dma_buf fd (output)
+ * @offset: location of first pixel, in bytes (output)
+ * @pitch: length of a scanline including padding, in bytes (output)
+ *
+ * Simple buffers are analogous to DRM's "dumb" buffers. They have a single
+ * plane of linear RGB data which can be allocated and scanned out without
+ * any driver-private ioctls or data.
+ *
+ * @format must be a standard RGB format defined in drm_fourcc.h.
+ *
+ * ADF clients must NOT assume that an interface can scan out a simple buffer
+ * allocated by a different ADF interface, even if the two interfaces belong to
+ * the same ADF device.
+ */
+struct adf_simple_buffer_alloc {
+ __u16 w;
+ __u16 h;
+ __u32 format;
+
+ __s32 fd;
+ __u32 offset;
+ __u32 pitch;
+};
+
+/**
+ * struct adf_simple_post_config - request to flip to a single buffer without
+ * driver-private data
+ *
+ * @buf: description of buffer displayed (input)
+ * @complete_fence: sync_fence fd which will clear when this buffer has left the
+ * screen (output)
+ */
+struct adf_simple_post_config {
+ struct adf_buffer_config buf;
+ __s32 complete_fence;
+};
+
+/**
+ * struct adf_attachment_config - description of attachment between an overlay
+ * engine and an interface
+ *
+ * @overlay_engine: id of the overlay engine
+ * @interface: id of the interface
+ */
+struct adf_attachment_config {
+ __u32 overlay_engine;
+ __u32 interface;
+};
+
+/**
+ * struct adf_device_data - describes a display device
+ *
+ * @name: display device's name
+ * @n_attachments: the number of current attachments
+ * @attachments: list of current attachments
+ * @n_allowed_attachments: the number of allowed attachments
+ * @allowed_attachments: list of allowed attachments
+ * @custom_data_size: size of driver-private data
+ * @custom_data: driver-private data
+ */
+struct adf_device_data {
+ char name[ADF_NAME_LEN];
+
+ size_t n_attachments;
+ struct adf_attachment_config __user *attachments;
+
+ size_t n_allowed_attachments;
+ struct adf_attachment_config __user *allowed_attachments;
+
+ size_t custom_data_size;
+ void __user *custom_data;
+};
+#define ADF_MAX_ATTACHMENTS (4096 / sizeof(struct adf_attachment_config))
+
+/**
+ * struct adf_device_data - describes a display interface
+ *
+ * @name: display interface's name
+ * @type: interface type (see enum @adf_interface_type)
+ * @id: which interface of type @type;
+ * e.g. interface DSI.1 -> @type=@ADF_INTF_TYPE_DSI, @id=1
+ * @flags: informational flags (bitmask of %ADF_INTF_FLAG_* values)
+ * @dpms_state: DPMS state (one of @DRM_MODE_DPMS_* defined in drm_mode.h)
+ * @hotplug_detect: whether a display is plugged in
+ * @width_mm: screen width in millimeters, or 0 if unknown
+ * @height_mm: screen height in millimeters, or 0 if unknown
+ * @current_mode: current display mode
+ * @n_available_modes: the number of hardware display modes
+ * @available_modes: list of hardware display modes
+ * @custom_data_size: size of driver-private data
+ * @custom_data: driver-private data
+ */
+struct adf_interface_data {
+ char name[ADF_NAME_LEN];
+
+ __u32 type;
+ __u32 id;
+ /* e.g. type=ADF_INTF_TYPE_DSI, id=1 => DSI.1 */
+ __u32 flags;
+
+ __u8 dpms_state;
+ __u8 hotplug_detect;
+ __u16 width_mm;
+ __u16 height_mm;
+
+ struct drm_mode_modeinfo current_mode;
+ size_t n_available_modes;
+ struct drm_mode_modeinfo __user *available_modes;
+
+ size_t custom_data_size;
+ void __user *custom_data;
+};
+#define ADF_MAX_MODES (4096 / sizeof(struct drm_mode_modeinfo))
+
+/**
+ * struct adf_overlay_engine_data - describes an overlay engine
+ *
+ * @name: overlay engine's name
+ * @n_supported_formats: number of supported formats
+ * @supported_formats: list of supported formats
+ * @custom_data_size: size of driver-private data
+ * @custom_data: driver-private data
+ */
+struct adf_overlay_engine_data {
+ char name[ADF_NAME_LEN];
+
+ size_t n_supported_formats;
+ __u32 __user *supported_formats;
+
+ size_t custom_data_size;
+ void __user *custom_data;
+};
+#define ADF_MAX_SUPPORTED_FORMATS (4096 / sizeof(__u32))
+
+#define ADF_IOCTL_TYPE 'D'
+#define ADF_IOCTL_NR_CUSTOM 128
+
+#define ADF_SET_EVENT _IOW(ADF_IOCTL_TYPE, 0, struct adf_set_event)
+#define ADF_BLANK _IOW(ADF_IOCTL_TYPE, 1, __u8)
+#define ADF_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 2, struct adf_post_config)
+#define ADF_SET_MODE _IOW(ADF_IOCTL_TYPE, 3, \
+ struct drm_mode_modeinfo)
+#define ADF_GET_DEVICE_DATA _IOR(ADF_IOCTL_TYPE, 4, struct adf_device_data)
+#define ADF_GET_INTERFACE_DATA _IOR(ADF_IOCTL_TYPE, 5, \
+ struct adf_interface_data)
+#define ADF_GET_OVERLAY_ENGINE_DATA \
+ _IOR(ADF_IOCTL_TYPE, 6, \
+ struct adf_overlay_engine_data)
+#define ADF_SIMPLE_POST_CONFIG _IOW(ADF_IOCTL_TYPE, 7, \
+ struct adf_simple_post_config)
+#define ADF_SIMPLE_BUFFER_ALLOC _IOW(ADF_IOCTL_TYPE, 8, \
+ struct adf_simple_buffer_alloc)
+#define ADF_ATTACH _IOW(ADF_IOCTL_TYPE, 9, \
+ struct adf_attachment_config)
+#define ADF_DETACH _IOW(ADF_IOCTL_TYPE, 10, \
+ struct adf_attachment_config)
+
+#endif /* _UAPI_VIDEO_ADF_H_ */
diff --git a/adf/libadf/tests/adf_test.cpp b/adf/libadf/tests/adf_test.cpp
index 01b2785..eaa9342 100644
--- a/adf/libadf/tests/adf_test.cpp
+++ b/adf/libadf/tests/adf_test.cpp
@@ -149,11 +149,13 @@
int eng;
private:
- const static adf_id_t dev_id = 0;
+ const static adf_id_t dev_id;
const static __u32 fmt8888[];
const static size_t n_fmt8888;
};
+const adf_id_t AdfTest::dev_id = 0;
+
const __u32 AdfTest::fmt8888[] = {
DRM_FORMAT_XRGB8888,
DRM_FORMAT_XBGR8888,
diff --git a/bootstat/bootstat.cpp b/bootstat/bootstat.cpp
index a626704..c85667e 100644
--- a/bootstat/bootstat.cpp
+++ b/bootstat/bootstat.cpp
@@ -28,10 +28,12 @@
#include <map>
#include <memory>
#include <string>
+#include <vector>
#include <android/log.h>
#include <android-base/logging.h>
#include <android-base/parseint.h>
+#include <android-base/strings.h>
#include <cutils/properties.h>
#include "boot_event_record_store.h"
@@ -218,6 +220,27 @@
}
}
+// Parses and records the set of bootloader stages and associated boot times
+// from the ro.boot.boottime system property.
+void RecordBootloaderTimings(BootEventRecordStore* boot_event_store) {
+ // |ro.boot.boottime| is of the form 'stage1:time1,...,stageN:timeN'.
+ std::string value = GetProperty("ro.boot.boottime");
+
+ auto stages = android::base::Split(value, ",");
+ for (auto const &stageTiming : stages) {
+ // |stageTiming| is of the form 'stage:time'.
+ auto stageTimingValues = android::base::Split(stageTiming, ":");
+ DCHECK_EQ(2, stageTimingValues.size());
+
+ std::string stageName = stageTimingValues[0];
+ int32_t time_ms;
+ if (android::base::ParseInt(stageTimingValues[1], &time_ms)) {
+ boot_event_store->AddBootEventWithValue(
+ "boottime.bootloader." + stageName, time_ms);
+ }
+ }
+}
+
// Records several metrics related to the time it takes to boot the device,
// including disambiguating boot time on encrypted or non-encrypted devices.
void RecordBootComplete() {
@@ -271,6 +294,8 @@
RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init");
RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init.selinux");
RecordInitBootTimeProp(&boot_event_store, "ro.boottime.init.cold_boot_wait");
+
+ RecordBootloaderTimings(&boot_event_store);
}
// Records the boot_reason metric by querying the ro.boot.bootreason system
diff --git a/bootstat/bootstat.rc b/bootstat/bootstat.rc
index ca8bea2..b072412 100644
--- a/bootstat/bootstat.rc
+++ b/bootstat/bootstat.rc
@@ -12,19 +12,19 @@
exec - root root -- /system/bin/bootstat -r post_decrypt_time_elapsed
# sys.logbootcomplete is a signal to enable the bootstat logging mechanism.
-# This signaling is necessary to prevent logging boot metrics after a soft
-# reboot (e.g., adb shell stop && adb shell start). /proc/uptime is not reset
-# during a soft reboot, which leads to false boot time metrics being reported.
+# This signaling is necessary to prevent logging boot metrics after a runtime
+# restart (e.g., adb shell stop && adb shell start). /proc/uptime is not reset
+# during a runtime restart, which leads to false boot time metrics being reported.
#
# The 'on boot' event occurs once per hard boot (device power on), which
-# switches the flag on. If the device performs a soft reboot, the flag is
+# switches the flag on. If the device performs a runtime restart, the flag is
# switched off and cannot be switched on until the device hard boots again.
# Enable bootstat logging on boot.
on boot
setprop sys.logbootcomplete 1
-# Disable further bootstat logging on a soft reboot. A soft reboot is
+# Disable further bootstat logging on a runtime restart. A runtime restart is
# signaled by the zygote stopping.
on property:init.svc.zygote=stopping
setprop sys.logbootcomplete 0
diff --git a/debuggerd/Android.bp b/debuggerd/Android.bp
index 6dc6675..ca881aa 100644
--- a/debuggerd/Android.bp
+++ b/debuggerd/Android.bp
@@ -195,3 +195,7 @@
init_rc: ["tombstoned/tombstoned.rc"]
}
+
+subdirs = [
+ "crasher",
+]
diff --git a/debuggerd/crash_dump.cpp b/debuggerd/crash_dump.cpp
index c145933..ed6d3b7 100644
--- a/debuggerd/crash_dump.cpp
+++ b/debuggerd/crash_dump.cpp
@@ -18,10 +18,12 @@
#include <dirent.h>
#include <fcntl.h>
#include <stdlib.h>
-#include <syscall.h>
+#include <sys/capability.h>
+#include <sys/prctl.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/un.h>
+#include <syscall.h>
#include <unistd.h>
#include <limits>
@@ -51,24 +53,25 @@
using android::base::unique_fd;
using android::base::StringPrintf;
-static bool pid_contains_tid(pid_t pid, pid_t tid) {
- std::string task_path = StringPrintf("/proc/%d/task/%d", pid, tid);
- return access(task_path.c_str(), F_OK) == 0;
+static bool pid_contains_tid(int pid_proc_fd, pid_t tid) {
+ struct stat st;
+ std::string task_path = StringPrintf("task/%d", tid);
+ return fstatat(pid_proc_fd, task_path.c_str(), &st, 0) == 0;
}
// Attach to a thread, and verify that it's still a member of the given process
-static bool ptrace_seize_thread(pid_t pid, pid_t tid, std::string* error) {
+static bool ptrace_seize_thread(int pid_proc_fd, pid_t tid, std::string* error) {
if (ptrace(PTRACE_SEIZE, tid, 0, 0) != 0) {
*error = StringPrintf("failed to attach to thread %d: %s", tid, strerror(errno));
return false;
}
// Make sure that the task we attached to is actually part of the pid we're dumping.
- if (!pid_contains_tid(pid, tid)) {
+ if (!pid_contains_tid(pid_proc_fd, tid)) {
if (ptrace(PTRACE_DETACH, tid, 0, 0) != 0) {
PLOG(FATAL) << "failed to detach from thread " << tid;
}
- *error = StringPrintf("thread %d is not in process %d", tid, pid);
+ *error = StringPrintf("thread %d is not in process", tid);
return false;
}
@@ -190,6 +193,24 @@
_exit(1);
}
+static void drop_capabilities() {
+ __user_cap_header_struct capheader;
+ memset(&capheader, 0, sizeof(capheader));
+ capheader.version = _LINUX_CAPABILITY_VERSION_3;
+ capheader.pid = 0;
+
+ __user_cap_data_struct capdata[2];
+ memset(&capdata, 0, sizeof(capdata));
+
+ if (capset(&capheader, &capdata[0]) == -1) {
+ PLOG(FATAL) << "failed to drop capabilities";
+ }
+
+ if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) != 0) {
+ PLOG(FATAL) << "failed to set PR_SET_NO_NEW_PRIVS";
+ }
+}
+
static void check_process(int proc_fd, pid_t expected_pid) {
android::procinfo::ProcessInfo proc_info;
if (!android::procinfo::GetProcessInfoFromProcPidFd(proc_fd, &proc_info)) {
@@ -263,7 +284,7 @@
check_process(target_proc_fd, target);
std::string attach_error;
- if (!ptrace_seize_thread(target, main_tid, &attach_error)) {
+ if (!ptrace_seize_thread(target_proc_fd, main_tid, &attach_error)) {
LOG(FATAL) << attach_error;
}
@@ -304,6 +325,7 @@
}
int signo = siginfo.si_signo;
+ bool fatal_signal = signo != DEBUGGER_SIGNAL;
bool backtrace = false;
uintptr_t abort_address = 0;
@@ -319,17 +341,16 @@
// Now that we have the signal that kicked things off, attach all of the
// sibling threads, and then proceed.
- bool fatal_signal = signo != DEBUGGER_SIGNAL;
- std::set<pid_t> siblings;
std::set<pid_t> attached_siblings;
- if (fatal_signal) {
+ {
+ std::set<pid_t> siblings;
if (!android::procinfo::GetProcessTids(target, &siblings)) {
PLOG(FATAL) << "failed to get process siblings";
}
siblings.erase(main_tid);
for (pid_t sibling_tid : siblings) {
- if (!ptrace_seize_thread(target, sibling_tid, &attach_error)) {
+ if (!ptrace_seize_thread(target_proc_fd, sibling_tid, &attach_error)) {
LOG(WARNING) << attach_error;
} else {
attached_siblings.insert(sibling_tid);
@@ -337,6 +358,9 @@
}
}
+ // Drop our capabilities now that we've attached to the threads we care about.
+ drop_capabilities();
+
check_process(target_proc_fd, target);
// TODO: Use seccomp to lock ourselves down.
diff --git a/debuggerd/crasher/Android.bp b/debuggerd/crasher/Android.bp
new file mode 100644
index 0000000..4727894
--- /dev/null
+++ b/debuggerd/crasher/Android.bp
@@ -0,0 +1,81 @@
+cc_defaults {
+ name: "crasher-defaults",
+
+ cppflags: [
+ "-std=gnu++14",
+ "-W",
+ "-Wall",
+ "-Wextra",
+ "-Wunused",
+ "-Werror",
+ "-O0",
+ "-fstack-protector-all",
+ "-Wno-free-nonheap-object",
+ "-Wno-date-time",
+ ],
+ srcs: ["crasher.cpp"],
+ arch: {
+ arm: {
+ srcs: ["arm/crashglue.S"],
+
+ armv7_a_neon: {
+ asflags: ["-DHAS_VFP_D32"],
+ },
+ },
+ arm64: {
+ srcs: ["arm64/crashglue.S"],
+ },
+ mips: {
+ srcs: ["mips/crashglue.S"],
+ },
+ mips64: {
+ srcs: ["mips64/crashglue.S"],
+ },
+ x86: {
+ srcs: ["x86/crashglue.S"],
+ },
+ x86_64: {
+ srcs: ["x86_64/crashglue.S"],
+ },
+ },
+ compile_multilib: "both",
+}
+
+cc_binary {
+ name: "crasher",
+
+ defaults: ["crasher-defaults"],
+ shared_libs: [
+ "libbase",
+ "liblog",
+ ],
+ multilib: {
+ lib32: {
+ stem: "crasher",
+ },
+ lib64: {
+ stem: "crasher64",
+ },
+ },
+}
+
+cc_binary {
+ name: "static_crasher",
+
+ defaults: ["crasher-defaults"],
+ cppflags: ["-DSTATIC_CRASHER"],
+ static_executable: true,
+ static_libs: [
+ "libdebuggerd_handler",
+ "libbase",
+ "liblog",
+ ],
+ multilib: {
+ lib32: {
+ stem: "static_crasher",
+ },
+ lib64: {
+ stem: "static_crasher64",
+ },
+ },
+}
diff --git a/debuggerd/crasher/Android.mk b/debuggerd/crasher/Android.mk
deleted file mode 100644
index b8b786b..0000000
--- a/debuggerd/crasher/Android.mk
+++ /dev/null
@@ -1,66 +0,0 @@
-LOCAL_PATH := $(call my-dir)
-
-crasher_cppflags := \
- -std=gnu++14 \
- -W \
- -Wall \
- -Wextra \
- -Wunused \
- -Werror \
- -O0 \
- -fstack-protector-all \
- -Wno-free-nonheap-object \
- -Wno-date-time
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := crasher.cpp
-LOCAL_SRC_FILES_arm := arm/crashglue.S
-LOCAL_SRC_FILES_arm64 := arm64/crashglue.S
-LOCAL_SRC_FILES_mips := mips/crashglue.S
-LOCAL_SRC_FILES_mips64 := mips64/crashglue.S
-LOCAL_SRC_FILES_x86 := x86/crashglue.S
-LOCAL_SRC_FILES_x86_64 := x86_64/crashglue.S
-LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
-LOCAL_MODULE_TAGS := optional
-LOCAL_CPPFLAGS := $(crasher_cppflags)
-LOCAL_SHARED_LIBRARIES := libbase liblog
-
-# The arm emulator has VFP but not VFPv3-D32.
-ifeq ($(ARCH_ARM_HAVE_VFP_D32),true)
-LOCAL_ASFLAGS_arm += -DHAS_VFP_D32
-endif
-
-LOCAL_MODULE := crasher
-LOCAL_MODULE_STEM_32 := crasher
-LOCAL_MODULE_STEM_64 := crasher64
-LOCAL_MULTILIB := both
-
-include $(BUILD_EXECUTABLE)
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := crasher.cpp
-LOCAL_SRC_FILES_arm := arm/crashglue.S
-LOCAL_SRC_FILES_arm64 := arm64/crashglue.S
-LOCAL_SRC_FILES_mips := mips/crashglue.S
-LOCAL_SRC_FILES_mips64 := mips64/crashglue.S
-LOCAL_SRC_FILES_x86 := x86/crashglue.S
-LOCAL_SRC_FILES_x86_64 := x86_64/crashglue.S
-LOCAL_MODULE_PATH := $(TARGET_OUT_OPTIONAL_EXECUTABLES)
-LOCAL_MODULE_TAGS := optional
-LOCAL_CPPFLAGS := $(crasher_cppflags) -DSTATIC_CRASHER
-LOCAL_FORCE_STATIC_EXECUTABLE := true
-LOCAL_SHARED_LIBRARIES := libbase liblog
-
-# The arm emulator has VFP but not VFPv3-D32.
-ifeq ($(ARCH_ARM_HAVE_VFP_D32),true)
-LOCAL_ASFLAGS_arm += -DHAS_VFP_D32
-endif
-
-LOCAL_MODULE := static_crasher
-LOCAL_MODULE_STEM_32 := static_crasher
-LOCAL_MODULE_STEM_64 := static_crasher64
-LOCAL_MULTILIB := both
-
-LOCAL_STATIC_LIBRARIES := libdebuggerd_handler libbase liblog
-
-include $(BUILD_EXECUTABLE)
diff --git a/debuggerd/crasher/crasher.cpp b/debuggerd/crasher/crasher.cpp
index 288f116..64a38dd 100644
--- a/debuggerd/crasher/crasher.cpp
+++ b/debuggerd/crasher/crasher.cpp
@@ -36,6 +36,19 @@
#include "debuggerd/handler.h"
#endif
+#if defined(__arm__)
+// See https://www.kernel.org/doc/Documentation/arm/kernel_user_helpers.txt for details.
+#define __kuser_helper_version (*(int32_t*) 0xffff0ffc)
+typedef void * (__kuser_get_tls_t)(void);
+#define __kuser_get_tls (*(__kuser_get_tls_t*) 0xffff0fe0)
+typedef int (__kuser_cmpxchg_t)(int oldval, int newval, volatile int *ptr);
+#define __kuser_cmpxchg (*(__kuser_cmpxchg_t*) 0xffff0fc0)
+typedef void (__kuser_dmb_t)(void);
+#define __kuser_dmb (*(__kuser_dmb_t*) 0xffff0fa0)
+typedef int (__kuser_cmpxchg64_t)(const int64_t*, const int64_t*, volatile int64_t*);
+#define __kuser_cmpxchg64 (*(__kuser_cmpxchg64_t*) 0xffff0f60)
+#endif
+
#define noinline __attribute__((__noinline__))
// Avoid name mangling so that stacks are more readable.
@@ -142,22 +155,36 @@
fprintf(stderr, "where KIND is:\n");
fprintf(stderr, " smash-stack overwrite a -fstack-protector guard\n");
fprintf(stderr, " stack-overflow recurse until the stack overflows\n");
+ fprintf(stderr, " nostack crash with a NULL stack pointer\n");
+ fprintf(stderr, "\n");
fprintf(stderr, " heap-corruption cause a libc abort by corrupting the heap\n");
fprintf(stderr, " heap-usage cause a libc abort by abusing a heap function\n");
- fprintf(stderr, " nostack crash with a NULL stack pointer\n");
+ fprintf(stderr, "\n");
fprintf(stderr, " abort call abort()\n");
fprintf(stderr, " assert call assert() without a function\n");
fprintf(stderr, " assert2 call assert() with a function\n");
fprintf(stderr, " exit call exit(1)\n");
+ fprintf(stderr, "\n");
fprintf(stderr, " fortify fail a _FORTIFY_SOURCE check\n");
+ fprintf(stderr, " seccomp fail a seccomp check\n");
+#if defined(__arm__)
+ fprintf(stderr, " kuser_helper_version call kuser_helper_version\n");
+ fprintf(stderr, " kuser_get_tls call kuser_get_tls\n");
+ fprintf(stderr, " kuser_cmpxchg call kuser_cmpxchg\n");
+ fprintf(stderr, " kuser_memory_barrier call kuser_memory_barrier\n");
+ fprintf(stderr, " kuser_cmpxchg64 call kuser_cmpxchg64\n");
+#endif
+ fprintf(stderr, "\n");
fprintf(stderr, " LOG_ALWAYS_FATAL call liblog LOG_ALWAYS_FATAL\n");
fprintf(stderr, " LOG_ALWAYS_FATAL_IF call liblog LOG_ALWAYS_FATAL_IF\n");
fprintf(stderr, " LOG-FATAL call libbase LOG(FATAL)\n");
+ fprintf(stderr, "\n");
fprintf(stderr, " SIGFPE cause a SIGFPE\n");
fprintf(stderr, " SIGSEGV cause a SIGSEGV at address 0x0 (synonym: crash)\n");
fprintf(stderr, " SIGSEGV-non-null cause a SIGSEGV at a non-zero address\n");
fprintf(stderr, " SIGSEGV-unmapped mmap/munmap a region of memory and then attempt to access it\n");
fprintf(stderr, " SIGTRAP cause a SIGTRAP\n");
+ fprintf(stderr, "\n");
fprintf(stderr, " fprintf-NULL pass a null pointer to fprintf\n");
fprintf(stderr, " readdir-NULL pass a null pointer to readdir\n");
fprintf(stderr, " strlen-NULL pass a null pointer to strlen\n");
@@ -235,6 +262,20 @@
MAP_SHARED | MAP_ANONYMOUS, -1, 0));
munmap(map, sizeof(int));
map[0] = '8';
+ } else if (!strcasecmp(arg, "seccomp")) {
+ syscall(99999);
+#if defined(__arm__)
+ } else if (!strcasecmp(arg, "kuser_helper_version")) {
+ return __kuser_helper_version;
+ } else if (!strcasecmp(arg, "kuser_get_tls")) {
+ return !__kuser_get_tls();
+ } else if (!strcasecmp(arg, "kuser_cmpxchg")) {
+ return __kuser_cmpxchg(0, 0, 0);
+ } else if (!strcasecmp(arg, "kuser_memory_barrier")) {
+ __kuser_dmb();
+ } else if (!strcasecmp(arg, "kuser_cmpxchg64")) {
+ return __kuser_cmpxchg64(0, 0, 0);
+#endif
} else {
return usage();
}
diff --git a/debuggerd/debuggerd.cpp b/debuggerd/debuggerd.cpp
index 3208230..0c5d3cf 100644
--- a/debuggerd/debuggerd.cpp
+++ b/debuggerd/debuggerd.cpp
@@ -71,7 +71,7 @@
std::thread redirect_thread = spawn_redirect_thread(std::move(piperead));
bool backtrace = argc == 3;
if (!debuggerd_trigger_dump(pid, std::move(pipewrite),
- backtrace ? kDebuggerdBacktrace : kDebuggerdBacktrace, 0)) {
+ backtrace ? kDebuggerdBacktrace : kDebuggerdTombstone, 0)) {
redirect_thread.join();
errx(1, "failed to dump process %d", pid);
}
diff --git a/debuggerd/handler/debuggerd_handler.cpp b/debuggerd/handler/debuggerd_handler.cpp
index 501d089..156534e 100644
--- a/debuggerd/handler/debuggerd_handler.cpp
+++ b/debuggerd/handler/debuggerd_handler.cpp
@@ -39,6 +39,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <sys/capability.h>
#include <sys/mman.h>
#include <sys/prctl.h>
#include <sys/socket.h>
@@ -67,11 +68,22 @@
static pthread_mutex_t crash_mutex = PTHREAD_MUTEX_INITIALIZER;
// Don't use __libc_fatal because it exits via abort, which might put us back into a signal handler.
-#define fatal(...) \
- do { \
- __libc_format_log(ANDROID_LOG_FATAL, "libc", __VA_ARGS__); \
- _exit(1); \
- } while (0)
+static void __noreturn __printflike(1, 2) fatal(const char* fmt, ...) {
+ va_list args;
+ va_start(args, fmt);
+ __libc_format_log_va_list(ANDROID_LOG_FATAL, "libc", fmt, args);
+ _exit(1);
+}
+
+static void __noreturn __printflike(1, 2) fatal_errno(const char* fmt, ...) {
+ int err = errno;
+ va_list args;
+ va_start(args, fmt);
+
+ char buf[4096];
+ vsnprintf(buf, sizeof(buf), fmt, args);
+ fatal("%s: %s", buf, strerror(err));
+}
/*
* Writes a summary of the signal to the log file. We do this so that, if
@@ -83,6 +95,21 @@
* could allocate memory or hold a lock.
*/
static void log_signal_summary(int signum, const siginfo_t* info) {
+ char thread_name[MAX_TASK_NAME_LEN + 1]; // one more for termination
+ if (prctl(PR_GET_NAME, reinterpret_cast<unsigned long>(thread_name), 0, 0, 0) != 0) {
+ strcpy(thread_name, "<name unknown>");
+ } else {
+ // short names are null terminated by prctl, but the man page
+ // implies that 16 byte names are not.
+ thread_name[MAX_TASK_NAME_LEN] = 0;
+ }
+
+ if (signum == DEBUGGER_SIGNAL) {
+ __libc_format_log(ANDROID_LOG_FATAL, "libc", "Requested dump for tid %d (%s)", gettid(),
+ thread_name);
+ return;
+ }
+
const char* signal_name = "???";
bool has_address = false;
switch (signum) {
@@ -118,15 +145,6 @@
break;
}
- char thread_name[MAX_TASK_NAME_LEN + 1]; // one more for termination
- if (prctl(PR_GET_NAME, reinterpret_cast<unsigned long>(thread_name), 0, 0, 0) != 0) {
- strcpy(thread_name, "<name unknown>");
- } else {
- // short names are null terminated by prctl, but the man page
- // implies that 16 byte names are not.
- thread_name[MAX_TASK_NAME_LEN] = 0;
- }
-
// "info" will be null if the siginfo_t information was not available.
// Many signals don't have an address or a code.
char code_desc[32]; // ", code -6"
@@ -138,6 +156,7 @@
__libc_format_buffer(addr_desc, sizeof(addr_desc), ", fault addr %p", info->si_addr);
}
}
+
__libc_format_log(ANDROID_LOG_FATAL, "libc", "Fatal signal %d (%s)%s%s in tid %d (%s)", signum,
signal_name, code_desc, addr_desc, gettid(), thread_name);
}
@@ -185,11 +204,11 @@
int pipefds[2];
if (pipe(pipefds) != 0) {
- fatal("failed to create pipe");
+ fatal_errno("failed to create pipe");
}
// Don't use fork(2) to avoid calling pthread_atfork handlers.
- int forkpid = clone(nullptr, nullptr, SIGCHLD, nullptr);
+ int forkpid = clone(nullptr, nullptr, 0, nullptr);
if (forkpid == -1) {
__libc_format_log(ANDROID_LOG_FATAL, "libc", "failed to fork in debuggerd signal handler: %s",
strerror(errno));
@@ -198,11 +217,16 @@
close(pipefds[0]);
close(pipefds[1]);
+ // Set all of the ambient capability bits we can, so that crash_dump can ptrace us.
+ for (unsigned long i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0); ++i) {
+ prctl(PR_CAP_AMBIENT, PR_CAP_AMBIENT_RAISE, i, 0, 0);
+ }
+
char buf[10];
snprintf(buf, sizeof(buf), "%d", thread_info->crashing_tid);
execl(CRASH_DUMP_PATH, CRASH_DUMP_NAME, buf, nullptr);
- fatal("exec failed: %s", strerror(errno));
+ fatal_errno("exec failed");
} else {
close(pipefds[1]);
char buf[4];
@@ -224,10 +248,12 @@
close(pipefds[0]);
// Don't leave a zombie child.
- siginfo_t child_siginfo;
- if (TEMP_FAILURE_RETRY(waitid(P_PID, forkpid, &child_siginfo, WEXITED)) != 0) {
+ int status;
+ if (TEMP_FAILURE_RETRY(waitpid(forkpid, &status, __WCLONE)) == -1 && errno != ECHILD) {
__libc_format_log(ANDROID_LOG_FATAL, "libc", "failed to wait for crash_dump helper: %s",
strerror(errno));
+ } else if (WIFSTOPPED(status) || WIFSIGNALED(status)) {
+ __libc_format_log(ANDROID_LOG_FATAL, "libc", "crash_dump helper crashed or stopped");
thread_info->crash_dump_started = false;
}
}
@@ -257,7 +283,7 @@
if (crash_dump_started || info->si_signo != DEBUGGER_SIGNAL) {
int rc = syscall(SYS_rt_tgsigqueueinfo, getpid(), gettid(), info->si_signo, info);
if (rc != 0) {
- fatal("failed to resend signal during crash: %s", strerror(errno));
+ fatal_errno("failed to resend signal during crash");
}
}
@@ -329,7 +355,7 @@
CLONE_THREAD | CLONE_SIGHAND | CLONE_VM | CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID,
&thread_info, nullptr, nullptr, &thread_info.pseudothread_tid);
if (child_pid == -1) {
- fatal("failed to spawn debuggerd dispatch thread: %s", strerror(errno));
+ fatal_errno("failed to spawn debuggerd dispatch thread");
}
// Wait for the child to start...
@@ -359,12 +385,12 @@
void* thread_stack_allocation =
mmap(nullptr, PAGE_SIZE * 3, PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
if (thread_stack_allocation == MAP_FAILED) {
- fatal("failed to allocate debuggerd thread stack");
+ fatal_errno("failed to allocate debuggerd thread stack");
}
char* stack = static_cast<char*>(thread_stack_allocation) + PAGE_SIZE;
if (mprotect(stack, PAGE_SIZE, PROT_READ | PROT_WRITE) != 0) {
- fatal("failed to mprotect debuggerd thread stack");
+ fatal_errno("failed to mprotect debuggerd thread stack");
}
// Stack grows negatively, set it to the last byte in the page...
diff --git a/debuggerd/libdebuggerd/tombstone.cpp b/debuggerd/libdebuggerd/tombstone.cpp
index 01e9cf6..ac2c0b6 100644
--- a/debuggerd/libdebuggerd/tombstone.cpp
+++ b/debuggerd/libdebuggerd/tombstone.cpp
@@ -49,6 +49,8 @@
#include "open_files_list.h"
#include "tombstone.h"
+using android::base::StringPrintf;
+
#define STACK_WORDS 16
#define MAX_TOMBSTONES 10
@@ -74,7 +76,7 @@
}
static const char* get_signame(int sig) {
- switch(sig) {
+ switch (sig) {
case SIGABRT: return "SIGABRT";
case SIGBUS: return "SIGBUS";
case SIGFPE: return "SIGFPE";
@@ -195,6 +197,29 @@
_LOG(log, logtype::HEADER, "ABI: '%s'\n", ABI_STRING);
}
+static void dump_probable_cause(log_t* log, const siginfo_t& si) {
+ std::string cause;
+ if (si.si_signo == SIGSEGV && si.si_code == SEGV_MAPERR) {
+ if (si.si_addr < reinterpret_cast<void*>(4096)) {
+ cause = StringPrintf("null pointer dereference");
+ } else if (si.si_addr == reinterpret_cast<void*>(0xffff0ffc)) {
+ cause = "call to kuser_helper_version";
+ } else if (si.si_addr == reinterpret_cast<void*>(0xffff0fe0)) {
+ cause = "call to kuser_get_tls";
+ } else if (si.si_addr == reinterpret_cast<void*>(0xffff0fc0)) {
+ cause = "call to kuser_cmpxchg";
+ } else if (si.si_addr == reinterpret_cast<void*>(0xffff0fa0)) {
+ cause = "call to kuser_memory_barrier";
+ } else if (si.si_addr == reinterpret_cast<void*>(0xffff0f60)) {
+ cause = "call to kuser_cmpxchg64";
+ }
+ } else if (si.si_signo == SIGSYS && si.si_code == SYS_SECCOMP) {
+ cause = StringPrintf("seccomp prevented call to disallowed system call %d", si.si_syscall);
+ }
+
+ if (!cause.empty()) _LOG(log, logtype::HEADER, "Cause: %s\n", cause.c_str());
+}
+
static void dump_signal_info(log_t* log, pid_t tid) {
siginfo_t si;
memset(&si, 0, sizeof(si));
@@ -212,6 +237,8 @@
_LOG(log, logtype::HEADER, "signal %d (%s), code %d (%s), fault addr %s\n", si.si_signo,
get_signame(si.si_signo), si.si_code, get_sigcode(si.si_signo, si.si_code), addr_desc);
+
+ dump_probable_cause(log, si);
}
static void dump_thread_info(log_t* log, pid_t pid, pid_t tid) {
@@ -262,11 +289,11 @@
line = " ";
if (i == 0 && label >= 0) {
// Print the label once.
- line += android::base::StringPrintf("#%02d ", label);
+ line += StringPrintf("#%02d ", label);
} else {
line += " ";
}
- line += android::base::StringPrintf("%" PRIPTR " %" PRIPTR, *sp, stack_data[i]);
+ line += StringPrintf("%" PRIPTR " %" PRIPTR, *sp, stack_data[i]);
backtrace_map_t map;
backtrace->FillInMap(stack_data[i], &map);
@@ -277,7 +304,7 @@
if (!func_name.empty()) {
line += " (" + func_name;
if (offset) {
- line += android::base::StringPrintf("+%" PRIuPTR, offset);
+ line += StringPrintf("+%" PRIuPTR, offset);
}
line += ')';
}
@@ -336,11 +363,11 @@
static std::string get_addr_string(uintptr_t addr) {
std::string addr_str;
#if defined(__LP64__)
- addr_str = android::base::StringPrintf("%08x'%08x",
- static_cast<uint32_t>(addr >> 32),
- static_cast<uint32_t>(addr & 0xffffffff));
+ addr_str = StringPrintf("%08x'%08x",
+ static_cast<uint32_t>(addr >> 32),
+ static_cast<uint32_t>(addr & 0xffffffff));
#else
- addr_str = android::base::StringPrintf("%08x", addr);
+ addr_str = StringPrintf("%08x", addr);
#endif
return addr_str;
}
@@ -426,8 +453,7 @@
} else {
line += '-';
}
- line += android::base::StringPrintf(" %8" PRIxPTR " %8" PRIxPTR,
- it->offset, it->end - it->start);
+ line += StringPrintf(" %8" PRIxPTR " %8" PRIxPTR, it->offset, it->end - it->start);
bool space_needed = true;
if (it->name.length() > 0) {
space_needed = false;
@@ -441,7 +467,7 @@
if (space_needed) {
line += ' ';
}
- line += android::base::StringPrintf(" (load base 0x%" PRIxPTR ")", it->load_base);
+ line += StringPrintf(" (load base 0x%" PRIxPTR ")", it->load_base);
}
_LOG(log, logtype::MAPS, "%s\n", line.c_str());
}
diff --git a/fastboot/usb_osx.cpp b/fastboot/usb_osx.cpp
index 032ae31..9069baa 100644
--- a/fastboot/usb_osx.cpp
+++ b/fastboot/usb_osx.cpp
@@ -302,13 +302,6 @@
// So, we have a device, finally. Grab its vitals.
-
- kr = (*dev)->USBDeviceOpen(dev);
- if (kr != 0) {
- WARN("USBDeviceOpen");
- goto out;
- }
-
kr = (*dev)->GetDeviceVendor(dev, &handle->info.dev_vendor);
if (kr != 0) {
ERR("GetDeviceVendor");
@@ -381,16 +374,12 @@
goto error;
}
- out:
-
- (*dev)->USBDeviceClose(dev);
(*dev)->Release(dev);
return 0;
error:
if (dev != NULL) {
- (*dev)->USBDeviceClose(dev);
(*dev)->Release(dev);
}
diff --git a/include/android b/include/android
deleted file mode 120000
index 4872393..0000000
--- a/include/android
+++ /dev/null
@@ -1 +0,0 @@
-../liblog/include/android
\ No newline at end of file
diff --git a/include/android/log.h b/include/android/log.h
new file mode 120000
index 0000000..736c448
--- /dev/null
+++ b/include/android/log.h
@@ -0,0 +1 @@
+../../liblog/include/android/log.h
\ No newline at end of file
diff --git a/init/Android.mk b/init/Android.mk
index 759be52..9e61fb2 100644
--- a/init/Android.mk
+++ b/init/Android.mk
@@ -70,7 +70,6 @@
init.cpp \
keychords.cpp \
property_service.cpp \
- seccomp.cpp \
signal_handler.cpp \
ueventd.cpp \
ueventd_parser.cpp \
@@ -97,7 +96,6 @@
libbase \
libc \
libselinux \
- libseccomp_policy \
liblog \
libcrypto_utils \
libcrypto \
diff --git a/init/README.md b/init/README.md
index cef0dbc..c76a33b 100644
--- a/init/README.md
+++ b/init/README.md
@@ -298,7 +298,8 @@
> Fork and execute command with the given arguments. The command starts
after "--" so that an optional security context, user, and supplementary
groups can be provided. No other commands will be run until this one
- finishes. _seclabel_ can be a - to denote default.
+ finishes. _seclabel_ can be a - to denote default. Properties are expanded
+ within _argument_.
`export <name> <value>`
> Set the environment variable _name_ equal to _value_ in the
@@ -412,6 +413,11 @@
or the timeout has been reached. If timeout is not specified it
currently defaults to five seconds.
+`wait_for_prop <name> <value>`
+> Wait for system property _name_ to be _value_. Properties are expanded
+ within _value_. If property _name_ is already set to _value_, continue
+ immediately.
+
`write <path> <content>`
> Open the file at _path_ and write a string to it with write(2).
If the file does not exist, it will be created. If it does exist,
diff --git a/init/builtins.cpp b/init/builtins.cpp
index 1186e9d..2388edc 100644
--- a/init/builtins.cpp
+++ b/init/builtins.cpp
@@ -265,10 +265,14 @@
if (!svc) {
return -1;
}
- if (!svc->Start()) {
+ if (!start_waiting_for_exec()) {
return -1;
}
- waiting_for_exec = true;
+ if (!svc->Start()) {
+ stop_waiting_for_exec();
+ ServiceManager::GetInstance().RemoveService(*svc);
+ return -1;
+ }
return 0;
}
@@ -1003,6 +1007,29 @@
return -1;
}
+static int do_wait_for_prop(const std::vector<std::string>& args) {
+ const char* name = args[1].c_str();
+ const char* value = args[2].c_str();
+ size_t value_len = strlen(value);
+
+ if (!is_legal_property_name(name)) {
+ LOG(ERROR) << "do_wait_for_prop(\"" << name << "\", \"" << value
+ << "\") failed: bad name";
+ return -1;
+ }
+ if (value_len >= PROP_VALUE_MAX) {
+ LOG(ERROR) << "do_wait_for_prop(\"" << name << "\", \"" << value
+ << "\") failed: value too long";
+ return -1;
+ }
+ if (!start_waiting_for_property(name, value)) {
+ LOG(ERROR) << "do_wait_for_prop(\"" << name << "\", \"" << value
+ << "\") failed: init already in waiting";
+ return -1;
+ }
+ return 0;
+}
+
/*
* Callback to make a directory from the ext4 code
*/
@@ -1074,6 +1101,7 @@
{"verity_load_state", {0, 0, do_verity_load_state}},
{"verity_update_state", {0, 0, do_verity_update_state}},
{"wait", {1, 2, do_wait}},
+ {"wait_for_prop", {2, 2, do_wait_for_prop}},
{"write", {2, 2, do_write}},
};
return builtin_functions;
diff --git a/init/init.cpp b/init/init.cpp
index e7772e7..43f601f 100644
--- a/init/init.cpp
+++ b/init/init.cpp
@@ -62,7 +62,6 @@
#include "keychords.h"
#include "log.h"
#include "property_service.h"
-#include "seccomp.h"
#include "service.h"
#include "signal_handler.h"
#include "ueventd.h"
@@ -83,10 +82,14 @@
const char *ENV[32];
-bool waiting_for_exec = false;
+static std::unique_ptr<Timer> waiting_for_exec(nullptr);
static int epoll_fd = -1;
+static std::unique_ptr<Timer> waiting_for_prop(nullptr);
+static std::string wait_prop_name;
+static std::string wait_prop_value;
+
void register_epoll_handler(int fd, void (*fn)()) {
epoll_event ev;
ev.events = EPOLLIN;
@@ -128,10 +131,52 @@
return -1;
}
+bool start_waiting_for_exec()
+{
+ if (waiting_for_exec) {
+ return false;
+ }
+ waiting_for_exec.reset(new Timer());
+ return true;
+}
+
+void stop_waiting_for_exec()
+{
+ if (waiting_for_exec) {
+ LOG(INFO) << "Wait for exec took " << *waiting_for_exec;
+ waiting_for_exec.reset();
+ }
+}
+
+bool start_waiting_for_property(const char *name, const char *value)
+{
+ if (waiting_for_prop) {
+ return false;
+ }
+ if (property_get(name) != value) {
+ // Current property value is not equal to expected value
+ wait_prop_name = name;
+ wait_prop_value = value;
+ waiting_for_prop.reset(new Timer());
+ } else {
+ LOG(INFO) << "start_waiting_for_property(\""
+ << name << "\", \"" << value << "\"): already set";
+ }
+ return true;
+}
+
void property_changed(const char *name, const char *value)
{
if (property_triggers_enabled)
ActionManager::GetInstance().QueuePropertyTrigger(name, value);
+ if (waiting_for_prop) {
+ if (wait_prop_name == name && wait_prop_value == value) {
+ wait_prop_name.clear();
+ wait_prop_value.clear();
+ LOG(INFO) << "Wait for property took " << *waiting_for_prop;
+ waiting_for_prop.reset();
+ }
+ }
}
static void restart_processes()
@@ -793,12 +838,6 @@
// Now set up SELinux for second stage.
selinux_initialize(false);
-
- // Install system-wide seccomp filter
- if (!set_seccomp_filter()) {
- LOG(ERROR) << "Failed to set seccomp policy";
- security_failure();
- }
}
// These directories were necessarily created before initial policy load
@@ -811,7 +850,8 @@
restorecon("/dev/random");
restorecon("/dev/urandom");
restorecon("/dev/__properties__");
- restorecon("/property_contexts");
+ restorecon("/plat_property_contexts");
+ restorecon("/nonplat_property_contexts");
restorecon("/sys", SELINUX_ANDROID_RESTORECON_RECURSE);
restorecon("/dev/block", SELINUX_ANDROID_RESTORECON_RECURSE);
restorecon("/dev/device-mapper");
@@ -875,7 +915,7 @@
am.QueueBuiltinAction(queue_property_triggers_action, "queue_property_triggers");
while (true) {
- if (!waiting_for_exec) {
+ if (!(waiting_for_exec || waiting_for_prop)) {
am.ExecuteOneCommand();
restart_processes();
}
diff --git a/init/init.h b/init/init.h
index cfb3139..3768c02 100644
--- a/init/init.h
+++ b/init/init.h
@@ -23,7 +23,6 @@
class Service;
extern const char *ENV[32];
-extern bool waiting_for_exec;
extern std::string default_console;
extern struct selabel_handle *sehandle;
extern struct selabel_handle *sehandle_prop;
@@ -36,4 +35,10 @@
int add_environment(const char* key, const char* val);
+bool start_waiting_for_exec();
+
+void stop_waiting_for_exec();
+
+bool start_waiting_for_property(const char *name, const char *value);
+
#endif /* _INIT_INIT_H */
diff --git a/init/seccomp.cpp b/init/seccomp.cpp
deleted file mode 100644
index 6c85217..0000000
--- a/init/seccomp.cpp
+++ /dev/null
@@ -1,235 +0,0 @@
-/*
- * 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 "seccomp.h"
-
-#include <vector>
-
-#include <sys/prctl.h>
-
-#include <linux/unistd.h>
-#include <linux/audit.h>
-#include <linux/filter.h>
-#include <linux/seccomp.h>
-
-#include "log.h"
-#include "seccomp_policy.h"
-
-#define syscall_nr (offsetof(struct seccomp_data, nr))
-#define arch_nr (offsetof(struct seccomp_data, arch))
-
-#if defined __arm__
-#define AUDIT_ARCH_NR AUDIT_ARCH_ARM
-#elif defined __aarch64__
-#define AUDIT_ARCH_NR AUDIT_ARCH_AARCH64
-#define AUDIT_ARCH_NR32 AUDIT_ARCH_ARM
-#elif defined __i386__
-#define AUDIT_ARCH_NR AUDIT_ARCH_I386
-#elif defined __x86_64__
-#define AUDIT_ARCH_NR AUDIT_ARCH_X86_64
-#define AUDIT_ARCH_NR32 AUDIT_ARCH_I386
-#elif defined __mips64__
-#define AUDIT_ARCH_NR AUDIT_ARCH_MIPS64
-#define AUDIT_ARCH_NR32 AUDIT_ARCH_MIPS
-#elif defined __mips__ && !defined __mips64__
-#define AUDIT_ARCH_NR AUDIT_ARCH_MIPS
-#else
-#error "Could not determine AUDIT_ARCH_NR for this architecture"
-#endif
-
-typedef std::vector<sock_filter> filter;
-
-// We want to keep the below inline functions for debugging and future
-// development even though they are not used currently.
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunused-function"
-
-static inline void Kill(filter& f) {
- f.push_back(BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_KILL));
-}
-
-static inline void Trap(filter& f) {
- f.push_back(BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_TRAP));
-}
-
-static inline void Error(filter& f, __u16 retcode) {
- f.push_back(BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ERRNO + retcode));
-}
-
-inline static void Trace(filter& f) {
- f.push_back(BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_TRACE));
-}
-
-inline static void Allow(filter& f) {
- f.push_back(BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW));
-}
-
-inline static void AllowSyscall(filter& f, __u32 num) {
- f.push_back(BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, num, 0, 1));
- f.push_back(BPF_STMT(BPF_RET|BPF_K, SECCOMP_RET_ALLOW));
-}
-
-inline static void ExamineSyscall(filter& f) {
- f.push_back(BPF_STMT(BPF_LD|BPF_W|BPF_ABS, syscall_nr));
-}
-
-#ifdef AUDIT_ARCH_NR32
-inline static int SetValidateArchitectureJumpTarget(size_t offset, filter& f) {
- auto jump_length = f.size() - offset - 1;
- auto u8_jump_length = (__u8) jump_length;
- if (u8_jump_length != jump_length) {
- LOG(ERROR) << "Can't set jump greater than 255 - actual jump is " << jump_length;
- return -1;
- }
- f[offset] = BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, AUDIT_ARCH_NR32, u8_jump_length, 0);
- return 0;
-}
-#endif
-
-inline static size_t ValidateArchitectureAndJumpIfNeeded(filter& f) {
- f.push_back(BPF_STMT(BPF_LD|BPF_W|BPF_ABS, arch_nr));
-
-#ifdef AUDIT_ARCH_NR32
- f.push_back(BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, AUDIT_ARCH_NR, 2, 0));
- f.push_back(BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, AUDIT_ARCH_NR32, 1, 0));
- Kill(f);
- return f.size() - 2;
-#else
- f.push_back(BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, AUDIT_ARCH_NR, 1, 0));
- Kill(f);
- return 0;
-#endif
-}
-
-#pragma clang diagnostic pop
-
-static bool install_filter(filter const& f) {
- struct sock_fprog prog = {
- (unsigned short) f.size(),
- (struct sock_filter*) &f[0],
- };
-
- if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) < 0) {
- PLOG(ERROR) << "SECCOMP: Could not set seccomp filter";
- return false;
- }
-
- LOG(INFO) << "SECCOMP: Global filter installed";
- return true;
-}
-
-bool set_seccomp_filter() {
- filter f;
-
- // Note that for mixed 64/32 bit architectures, ValidateArchitecture inserts a
- // jump that must be changed to point to the start of the 32-bit policy
- // 32 bit syscalls will not hit the policy between here and the call to SetJump
-#ifdef AUDIT_ARCH_NR32
- auto offset_to_32bit_filter =
-#endif
- ValidateArchitectureAndJumpIfNeeded(f);
-
- // Native filter
- ExamineSyscall(f);
-
-#ifdef __aarch64__
- // Syscalls needed to boot Android
- AllowSyscall(f, __NR_pivot_root);
- AllowSyscall(f, __NR_ioprio_get);
- AllowSyscall(f, __NR_ioprio_set);
- AllowSyscall(f, __NR_gettid);
- AllowSyscall(f, __NR_futex);
- AllowSyscall(f, __NR_clone);
- AllowSyscall(f, __NR_rt_sigreturn);
- AllowSyscall(f, __NR_rt_tgsigqueueinfo);
- AllowSyscall(f, __NR_add_key);
- AllowSyscall(f, __NR_request_key);
- AllowSyscall(f, __NR_keyctl);
- AllowSyscall(f, __NR_restart_syscall);
- AllowSyscall(f, __NR_getrandom);
-
- // Needed for performance tools
- AllowSyscall(f, __NR_perf_event_open);
-
- // Needed for treble
- AllowSyscall(f, __NR_finit_module);
-
- // Needed for trusty
- AllowSyscall(f, __NR_syncfs);
-
- // Needed for strace
- AllowSyscall(f, __NR_tkill); // __NR_tkill
-
- // Needed for kernel to restart syscalls
- AllowSyscall(f, __NR_restart_syscall);
-
- // arm64-only filter - autogenerated from bionic syscall usage
- for (size_t i = 0; i < arm64_filter_size; ++i)
- f.push_back(arm64_filter[i]);
-#else
- // Generic policy
- Allow(f);
-#endif
-
-#ifdef AUDIT_ARCH_NR32
- if (SetValidateArchitectureJumpTarget(offset_to_32bit_filter, f) != 0)
- return -1;
-
- // 32-bit filter for 64-bit platforms
- ExamineSyscall(f);
-
-#ifdef __aarch64__
- // Syscalls needed to boot android
- AllowSyscall(f, 120); // __NR_clone
- AllowSyscall(f, 240); // __NR_futex
- AllowSyscall(f, 119); // __NR_sigreturn
- AllowSyscall(f, 173); // __NR_rt_sigreturn
- AllowSyscall(f, 363); // __NR_rt_tgsigqueueinfo
- AllowSyscall(f, 224); // __NR_gettid
-
- // Syscalls needed to run Chrome
- AllowSyscall(f, 383); // __NR_seccomp - needed to start Chrome
- AllowSyscall(f, 384); // __NR_getrandom - needed to start Chrome
-
- // Syscalls needed to run GFXBenchmark
- AllowSyscall(f, 190); // __NR_vfork
-
- // Needed for strace
- AllowSyscall(f, 238); // __NR_tkill
-
- // Needed for kernel to restart syscalls
- AllowSyscall(f, 0); // __NR_restart_syscall
-
- // Needed for debugging 32-bit Chrome
- AllowSyscall(f, 42); // __NR_pipe
-
- // b/34732712
- AllowSyscall(f, 364); // __NR_perf_event_open
-
- // b/34651972
- AllowSyscall(f, 33); // __NR_access
- AllowSyscall(f, 195); // __NR_stat64
-
- // arm32-on-arm64 only filter - autogenerated from bionic syscall usage
- for (size_t i = 0; i < arm_filter_size; ++i)
- f.push_back(arm_filter[i]);
-#else
- // Generic policy
- Allow(f);
-#endif
-#endif
- return install_filter(f);
-}
diff --git a/init/service.cpp b/init/service.cpp
index 0f7f62f..e186f27 100644
--- a/init/service.cpp
+++ b/init/service.cpp
@@ -997,7 +997,7 @@
}
if (svc->Reap()) {
- waiting_for_exec = false;
+ stop_waiting_for_exec();
RemoveService(*svc);
}
diff --git a/libcutils/Android.bp b/libcutils/Android.bp
index cf266dc..8ba7452 100644
--- a/libcutils/Android.bp
+++ b/libcutils/Android.bp
@@ -103,6 +103,9 @@
"trace-dev.c",
"uevent.c",
],
+ sanitize: {
+ misc_undefined: ["integer"],
+ },
},
android_arm: {
@@ -153,9 +156,6 @@
],
clang: true,
- sanitize: {
- misc_undefined: ["integer"],
- },
}
subdirs = ["tests"]
diff --git a/libcutils/fs_config.c b/libcutils/fs_config.c
index 013999a..b701bba 100644
--- a/libcutils/fs_config.c
+++ b/libcutils/fs_config.c
@@ -177,11 +177,8 @@
CAP_MASK_LONG(CAP_SETPCAP),
"system/bin/webview_zygote64" },
- { 00755, AID_ROOT, AID_SHELL, CAP_MASK_LONG(CAP_SYS_PTRACE),
- "system/bin/crash_dump32" },
- { 00755, AID_ROOT, AID_SHELL, CAP_MASK_LONG(CAP_SYS_PTRACE),
- "system/bin/crash_dump64" },
-
+ { 00755, AID_ROOT, AID_SHELL, 0, "system/bin/crash_dump32" },
+ { 00755, AID_ROOT, AID_SHELL, 0, "system/bin/crash_dump64" },
{ 00755, AID_ROOT, AID_SHELL, 0, "system/bin/debuggerd" },
{ 00750, AID_ROOT, AID_ROOT, 0, "system/bin/uncrypt" },
{ 00750, AID_ROOT, AID_ROOT, 0, "system/bin/install-recovery.sh" },
diff --git a/liblog/Android.bp b/liblog/Android.bp
index dce316d..747fcc8 100644
--- a/liblog/Android.bp
+++ b/liblog/Android.bp
@@ -97,19 +97,11 @@
compile_multilib: "both",
}
-// system/core/android/log.h needs some work before it can be included in the
-// NDK. It defines a *lot* of macros that previously were usable names in NDK
-// sources that used android/log.h. As an example, the following file defines
-// LOG_TAG as a variable, but the variable name gets macro replaced if we use
-// the current android/log.h.
-// https://android.googlesource.com/platform/external/deqp/+/4adc1515f867b26c19c2f7498e9de93a230a234d/framework/platform/android/tcuTestLogParserJNI.cpp#41
-//
-// For now, we keep a copy of the old NDK android/log.h in legacy-ndk-includes.
ndk_headers {
name: "liblog_headers",
- from: "legacy-ndk-includes",
+ from: "include/android",
to: "android",
- srcs: ["legacy-ndk-includes/log.h"],
+ srcs: ["include/android/log.h"],
license: "NOTICE",
}
diff --git a/liblog/event_tag_map.cpp b/liblog/event_tag_map.cpp
index c53ea2c..1f08eb4 100644
--- a/liblog/event_tag_map.cpp
+++ b/liblog/event_tag_map.cpp
@@ -19,6 +19,7 @@
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
+#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -26,15 +27,63 @@
#include <experimental/string_view>
#include <functional>
+#include <string>
#include <unordered_map>
#include <log/event_tag_map.h>
+#include <utils/FastStrcmp.h>
+#include <utils/RWLock.h>
+#include <private/android_logger.h>
#include "log_portability.h"
+#include "logd_reader.h"
#define OUT_TAG "EventTagMap"
-typedef std::experimental::string_view MapString;
+class MapString {
+private:
+ const std::string* alloc; // HAS-AN
+ const std::experimental::string_view str; // HAS-A
+
+public:
+ operator const std::experimental::string_view() const { return str; }
+
+ const char* data() const { return str.data(); }
+ size_t length() const { return str.length(); }
+
+ bool operator== (const MapString& rval) const {
+ if (length() != rval.length()) return false;
+ if (length() == 0) return true;
+ return fastcmp<strncmp>(data(), rval.data(), length()) == 0;
+ }
+ bool operator!= (const MapString& rval) const {
+ return !(*this == rval);
+ }
+
+ MapString(const char* str, size_t len) : alloc(NULL), str(str, len) { }
+ explicit MapString(const std::string& str) :
+ alloc(new std::string(str)),
+ str(alloc->data(), alloc->length()) { }
+ MapString(MapString &&rval) :
+ alloc(rval.alloc),
+ str(rval.data(), rval.length()) {
+ rval.alloc = NULL;
+ }
+ explicit MapString(const MapString &rval) :
+ alloc(rval.alloc ? new std::string(*rval.alloc) : NULL),
+ str(alloc ? alloc->data() : rval.data(), rval.length()) { }
+
+ ~MapString() { if (alloc) delete alloc; }
+};
+
+// Hash for MapString
+template <> struct std::hash<MapString>
+ : public std::unary_function<const MapString&, size_t> {
+ size_t operator()(const MapString& __t) const noexcept {
+ if (!__t.length()) return 0;
+ return std::hash<std::experimental::string_view>()(std::experimental::string_view(__t));
+ }
+};
typedef std::pair<MapString, MapString> TagFmt;
@@ -53,57 +102,125 @@
// Map
struct EventTagMap {
+# define NUM_MAPS 2
// memory-mapped source file; we get strings from here
- void* mapAddr;
- size_t mapLen;
+ void* mapAddr[NUM_MAPS];
+ size_t mapLen[NUM_MAPS];
private:
std::unordered_map<uint32_t, TagFmt> Idx2TagFmt;
+ std::unordered_map<TagFmt, uint32_t> TagFmt2Idx;
+ std::unordered_map<MapString, uint32_t> Tag2Idx;
+ // protect unordered sets
+ android::RWLock rwlock;
public:
- EventTagMap() : mapAddr(NULL), mapLen(0) { }
+ EventTagMap() {
+ memset(mapAddr, 0, sizeof(mapAddr));
+ memset(mapLen, 0, sizeof(mapLen));
+ }
~EventTagMap() {
Idx2TagFmt.clear();
- if (mapAddr) {
- munmap(mapAddr, mapLen);
- mapAddr = 0;
+ TagFmt2Idx.clear();
+ Tag2Idx.clear();
+ for (size_t which = 0; which < NUM_MAPS; ++which) {
+ if (mapAddr[which]) {
+ munmap(mapAddr[which], mapLen[which]);
+ mapAddr[which] = 0;
+ }
}
}
bool emplaceUnique(uint32_t tag, const TagFmt& tagfmt, bool verbose = false);
const TagFmt* find(uint32_t tag) const;
+ int find(TagFmt&& tagfmt) const;
+ int find(MapString&& tag) const;
};
bool EventTagMap::emplaceUnique(uint32_t tag, const TagFmt& tagfmt, bool verbose) {
- std::unordered_map<uint32_t, TagFmt>::const_iterator it;
- it = Idx2TagFmt.find(tag);
- if (it != Idx2TagFmt.end()) {
- if (verbose) {
- fprintf(stderr,
- OUT_TAG ": duplicate tag entries %" PRIu32
- ":%.*s:%.*s and %" PRIu32 ":%.*s:%.*s)\n",
- it->first,
- (int)it->second.first.length(), it->second.first.data(),
- (int)it->second.second.length(), it->second.second.data(),
- tag,
- (int)tagfmt.first.length(), tagfmt.first.data(),
- (int)tagfmt.second.length(), tagfmt.second.data());
+ bool ret = true;
+ static const char errorFormat[] = OUT_TAG ": duplicate tag entries %" PRIu32
+ ":%.*s:%.*s and %" PRIu32
+ ":%.*s:%.*s)\n";
+ android::RWLock::AutoWLock writeLock(rwlock);
+ {
+ std::unordered_map<uint32_t, TagFmt>::const_iterator it;
+ it = Idx2TagFmt.find(tag);
+ if (it != Idx2TagFmt.end()) {
+ if (verbose) {
+ fprintf(stderr, errorFormat,
+ it->first,
+ (int)it->second.first.length(), it->second.first.data(),
+ (int)it->second.second.length(), it->second.second.data(),
+ tag,
+ (int)tagfmt.first.length(), tagfmt.first.data(),
+ (int)tagfmt.second.length(), tagfmt.second.data());
+ }
+ ret = false;
+ } else {
+ Idx2TagFmt.emplace(std::make_pair(tag, tagfmt));
}
- return false;
}
- Idx2TagFmt.emplace(std::make_pair(tag, tagfmt));
- return true;
+ {
+ std::unordered_map<TagFmt, uint32_t>::const_iterator it;
+ it = TagFmt2Idx.find(tagfmt);
+ if (it != TagFmt2Idx.end()) {
+ if (verbose) {
+ fprintf(stderr, errorFormat,
+ it->second,
+ (int)it->first.first.length(), it->first.first.data(),
+ (int)it->first.second.length(), it->first.second.data(),
+ tag,
+ (int)tagfmt.first.length(), tagfmt.first.data(),
+ (int)tagfmt.second.length(), tagfmt.second.data());
+ }
+ ret = false;
+ } else {
+ TagFmt2Idx.emplace(std::make_pair(tagfmt, tag));
+ }
+ }
+
+ {
+ std::unordered_map<MapString, uint32_t>::const_iterator it;
+ it = Tag2Idx.find(tagfmt.first);
+ if (!tagfmt.second.length() && (it != Tag2Idx.end())) {
+ Tag2Idx.erase(it);
+ it = Tag2Idx.end();
+ }
+ if (it == Tag2Idx.end()) {
+ Tag2Idx.emplace(std::make_pair(tagfmt.first, tag));
+ }
+ }
+
+ return ret;
}
const TagFmt* EventTagMap::find(uint32_t tag) const {
std::unordered_map<uint32_t, TagFmt>::const_iterator it;
+ android::RWLock::AutoRLock readLock(const_cast<android::RWLock&>(rwlock));
it = Idx2TagFmt.find(tag);
if (it == Idx2TagFmt.end()) return NULL;
return &(it->second);
}
+int EventTagMap::find(TagFmt&& tagfmt) const {
+ std::unordered_map<TagFmt, uint32_t>::const_iterator it;
+ android::RWLock::AutoRLock readLock(const_cast<android::RWLock&>(rwlock));
+ it = TagFmt2Idx.find(std::move(tagfmt));
+ if (it == TagFmt2Idx.end()) return -1;
+ return it->second;
+}
+
+int EventTagMap::find(MapString&& tag) const {
+ std::unordered_map<MapString, uint32_t>::const_iterator it;
+ android::RWLock::AutoRLock readLock(const_cast<android::RWLock&>(rwlock));
+ it = Tag2Idx.find(std::move(tag));
+ if (it == Tag2Idx.end()) return -1;
+ return it->second;
+}
+
// Scan one tag line.
//
// "*pData" should be pointing to the first digit in the tag number. On
@@ -157,6 +274,19 @@
fmtLen = cp - fmt;
}
+ // KISS Only report identicals if they are global
+ // Ideally we want to check if there are identicals
+ // recorded for the same uid, but recording that
+ // unused detail in our database is too burdensome.
+ bool verbose = true;
+ while ((*cp != '#') && (*cp != '\n')) ++cp;
+ if (*cp == '#') {
+ do {
+ ++cp;
+ } while (isspace(*cp) && (*cp != '\n'));
+ verbose = !!fastcmp<strncmp>(cp, "uid=", strlen("uid="));
+ }
+
while (*cp != '\n') ++cp;
#ifdef DEBUG
fprintf(stderr, "%d: %p: %.*s\n", lineNum, tag, (int)(cp - *pData), *pData);
@@ -164,24 +294,33 @@
*pData = cp;
if (map->emplaceUnique(tagIndex, TagFmt(std::make_pair(
- MapString(tag, tagLen), MapString(fmt, fmtLen))), true)) {
+ MapString(tag, tagLen), MapString(fmt, fmtLen))), verbose)) {
return 0;
}
errno = EMLINK;
return -1;
}
+static const char* eventTagFiles[NUM_MAPS] = {
+ EVENT_TAG_MAP_FILE,
+ "/dev/event-log-tags",
+};
+
// Parse the tags out of the file.
-static int parseMapLines(EventTagMap* map) {
- char* cp = static_cast<char*>(map->mapAddr);
- size_t len = map->mapLen;
+static int parseMapLines(EventTagMap* map, size_t which) {
+ char* cp = static_cast<char*>(map->mapAddr[which]);
+ size_t len = map->mapLen[which];
char* endp = cp + len;
// insist on EOL at EOF; simplifies parsing and null-termination
if (!len || (*(endp - 1) != '\n')) {
#ifdef DEBUG
- fprintf(stderr, OUT_TAG ": map file missing EOL on last line\n");
+ fprintf(stderr, OUT_TAG ": map file %zu[%zu] missing EOL on last line\n",
+ which, len);
#endif
+ if (which) { // do not propagate errors for other files
+ return 0;
+ }
errno = EINVAL;
return -1;
}
@@ -199,7 +338,9 @@
} else if (isdigit(*cp)) {
// looks like a tag; scan it out
if (scanTagLine(map, &cp, lineNum) != 0) {
- return -1;
+ if (!which || (errno != EMLINK)) {
+ return -1;
+ }
}
lineNum++; // we eat the '\n'
// leave lineStart==true
@@ -226,57 +367,87 @@
// We create a private mapping because we want to terminate the log tag
// strings with '\0'.
LIBLOG_ABI_PUBLIC EventTagMap* android_openEventTagMap(const char* fileName) {
- int save_errno;
+ EventTagMap* newTagMap;
+ off_t end[NUM_MAPS];
+ int save_errno, fd[NUM_MAPS];
+ size_t which;
- const char* tagfile = fileName ? fileName : EVENT_TAG_MAP_FILE;
- int fd = open(tagfile, O_RDONLY | O_CLOEXEC);
- if (fd < 0) {
+ memset(fd, -1, sizeof(fd));
+ memset(end, 0, sizeof(end));
+
+ for (which = 0; which < NUM_MAPS; ++which) {
+ const char* tagfile = fileName ? fileName : eventTagFiles[which];
+
+ fd[which] = open(tagfile, O_RDONLY | O_CLOEXEC);
+ if (fd[which] < 0) {
+ if (!which) {
+ save_errno = errno;
+ fprintf(stderr, OUT_TAG ": unable to open map '%s': %s\n",
+ tagfile, strerror(save_errno));
+ goto fail_errno;
+ }
+ continue;
+ }
+ end[which] = lseek(fd[which], 0L, SEEK_END);
save_errno = errno;
- fprintf(stderr, OUT_TAG ": unable to open map '%s': %s\n",
- tagfile, strerror(save_errno));
- errno = save_errno;
- return NULL;
- }
- off_t end = lseek(fd, 0L, SEEK_END);
- save_errno = errno;
- (void)lseek(fd, 0L, SEEK_SET);
- if (end < 0) {
- fprintf(stderr, OUT_TAG ": unable to seek map '%s' %s\n",
- tagfile, strerror(save_errno));
- close(fd);
- errno = save_errno;
- return NULL;
+ (void)lseek(fd[which], 0L, SEEK_SET);
+ if (!which && (end[0] < 0)) {
+ fprintf(stderr, OUT_TAG ": unable to seek map '%s' %s\n",
+ tagfile, strerror(save_errno));
+ goto fail_close;
+ }
+ if (fileName) break; // Only allow one as specified
}
- EventTagMap* newTagMap = new EventTagMap;
+ newTagMap = new EventTagMap;
if (newTagMap == NULL) {
save_errno = errno;
- close(fd);
- errno = save_errno;
- return NULL;
+ goto fail_close;
}
- newTagMap->mapAddr = mmap(NULL, end, PROT_READ | PROT_WRITE,
- MAP_PRIVATE, fd, 0);
- save_errno = errno;
- close(fd);
- fd = -1;
- if ((newTagMap->mapAddr == MAP_FAILED) || (newTagMap->mapAddr == NULL)) {
- fprintf(stderr, OUT_TAG ": mmap(%s) failed: %s\n",
- tagfile, strerror(save_errno));
- delete newTagMap;
- errno = save_errno;
- return NULL;
+ for (which = 0; which < NUM_MAPS; ++which) {
+ if (fd[which] >= 0) {
+ newTagMap->mapAddr[which] = mmap(NULL, end[which],
+ which ?
+ PROT_READ :
+ PROT_READ | PROT_WRITE,
+ which ?
+ MAP_SHARED :
+ MAP_PRIVATE,
+ fd[which], 0);
+ save_errno = errno;
+ close(fd[which]);
+ fd[which] = -1;
+ if ((newTagMap->mapAddr[which] != MAP_FAILED) &&
+ (newTagMap->mapAddr[which] != NULL)) {
+ newTagMap->mapLen[which] = end[which];
+ } else if (!which) {
+ const char* tagfile = fileName ? fileName : eventTagFiles[which];
+
+ fprintf(stderr, OUT_TAG ": mmap(%s) failed: %s\n",
+ tagfile, strerror(save_errno));
+ goto fail_unmap;
+ }
+ }
}
- newTagMap->mapLen = end;
-
- if (parseMapLines(newTagMap) != 0) {
- delete newTagMap;
- return NULL;
+ for (which = 0; which < NUM_MAPS; ++which) {
+ if (parseMapLines(newTagMap, which) != 0) {
+ delete newTagMap;
+ return NULL;
+ }
}
return newTagMap;
+
+fail_unmap:
+ save_errno = EINVAL;
+ delete newTagMap;
+fail_close:
+ for (which = 0; which < NUM_MAPS; ++which) close(fd[which]);
+fail_errno:
+ errno = save_errno;
+ return NULL;
}
// Close the map.
@@ -320,3 +491,75 @@
if (*cp) *cp = '\0'; // Trigger copy on write :-( and why deprecated.
return tagStr;
}
+
+// Look up tagname, generate one if necessary, and return a tag
+LIBLOG_ABI_PUBLIC int android_lookupEventTagNum(EventTagMap* map,
+ const char* tagname,
+ const char* format,
+ int prio) {
+ size_t len = strlen(tagname);
+ if (!len) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if ((prio != ANDROID_LOG_UNKNOWN) && (prio < ANDROID_LOG_SILENT) &&
+ !__android_log_is_loggable_len(prio, tagname, len,
+ __android_log_is_debuggable() ?
+ ANDROID_LOG_VERBOSE :
+ ANDROID_LOG_DEBUG)) {
+ errno = EPERM;
+ return -1;
+ }
+
+ if (!format) format="";
+ ssize_t fmtLen = strlen(format);
+ int ret = map->find(TagFmt(std::make_pair(MapString(tagname, len),
+ MapString(format, fmtLen))));
+ if (ret != -1) return ret;
+
+ // call event tag service to arrange for a new tag
+ char *buf = NULL;
+ // Can not use android::base::StringPrintf, asprintf + free instead.
+ static const char command_template[] = "getEventTag name=%s format=\"%s\"";
+ ret = asprintf(&buf, command_template, tagname, format);
+ if (ret > 0) {
+ // Add some buffer margin for an estimate of the full return content.
+ char *cp;
+ size_t size = ret - strlen(command_template) +
+ strlen("65535\n4294967295\t?\t\t\t?\t# uid=32767\n\n\f?success?");
+ if (size > (size_t)ret) {
+ cp = static_cast<char*>(realloc(buf, size));
+ if (cp) {
+ buf = cp;
+ } else {
+ size = ret;
+ }
+ } else {
+ size = ret;
+ }
+ // Ask event log tag service for an allocation
+ if (__send_log_msg(buf, size) >= 0) {
+ buf[size - 1] = '\0';
+ unsigned long val = strtoul(buf, &cp, 10); // return size
+ if ((buf != cp) && (val > 0) && (*cp == '\n')) { // truncation OK
+ val = strtoul(cp + 1, &cp, 10); // allocated tag number
+ if ((val > 0) && (val < UINT32_MAX) && (*cp == '\t')) {
+ free(buf);
+ ret = val;
+ // cache
+ map->emplaceUnique(ret, TagFmt(std::make_pair(
+ MapString(std::string(tagname, len)),
+ MapString(std::string(format, fmtLen)))));
+ return ret;
+ }
+ }
+ }
+ free(buf);
+ }
+
+ // Hail Mary
+ ret = map->find(MapString(tagname, len));
+ if (ret == -1) errno = ESRCH;
+ return ret;
+}
diff --git a/liblog/fake_log_device.c b/liblog/fake_log_device.c
index 4939221..957129e 100644
--- a/liblog/fake_log_device.c
+++ b/liblog/fake_log_device.c
@@ -715,6 +715,12 @@
return redirectWritev(fd, vector, count);
}
+LIBLOG_HIDDEN ssize_t __send_log_msg(char *buf __unused,
+ size_t buf_size __unused)
+{
+ return -ENODEV;
+}
+
LIBLOG_ABI_PUBLIC int __android_log_is_loggable(int prio,
const char *tag __unused,
int def)
diff --git a/liblog/include/log/event_tag_map.h b/liblog/include/log/event_tag_map.h
index 22e62ec..e57e47b 100644
--- a/liblog/include/log/event_tag_map.h
+++ b/liblog/include/log/event_tag_map.h
@@ -58,6 +58,12 @@
const char* android_lookupEventFormat_len(const EventTagMap* map,
size_t* len, unsigned int tag);
+/*
+ * Look up tagname, generate one if necessary, and return a tag
+ */
+int android_lookupEventTagNum(EventTagMap* map, const char* tagname,
+ const char* format, int prio);
+
#ifdef __cplusplus
}
#endif
diff --git a/liblog/include/log/logprint.h b/liblog/include/log/logprint.h
index 3509e7f..5b99c3c 100644
--- a/liblog/include/log/logprint.h
+++ b/liblog/include/log/logprint.h
@@ -42,11 +42,13 @@
FORMAT_MODIFIER_TIME_USEC, /* switches from msec to usec time precision */
FORMAT_MODIFIER_PRINTABLE, /* converts non-printable to printable escapes */
FORMAT_MODIFIER_YEAR, /* Adds year to date */
- FORMAT_MODIFIER_ZONE, /* Adds zone to date */
+ FORMAT_MODIFIER_ZONE, /* Adds zone to date, + UTC */
FORMAT_MODIFIER_EPOCH, /* Print time as seconds since Jan 1 1970 */
FORMAT_MODIFIER_MONOTONIC, /* Print cpu time as seconds since start */
FORMAT_MODIFIER_UID, /* Adds uid */
FORMAT_MODIFIER_DESCRIPT, /* Adds descriptive */
+ /* private, undocumented */
+ FORMAT_MODIFIER_TIME_NSEC, /* switches from msec to nsec time precision */
} AndroidLogPrintFormat;
typedef struct AndroidLogFormat_t AndroidLogFormat;
diff --git a/liblog/legacy-ndk-includes/log.h b/liblog/legacy-ndk-includes/log.h
deleted file mode 100644
index d40d6fa..0000000
--- a/liblog/legacy-ndk-includes/log.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef _ANDROID_LOG_H
-#define _ANDROID_LOG_H
-
-/******************************************************************
- *
- * IMPORTANT NOTICE:
- *
- * This file is part of Android's set of stable system headers
- * exposed by the Android NDK (Native Development Kit) since
- * platform release 1.5
- *
- * Third-party source AND binary code relies on the definitions
- * here to be FROZEN ON ALL UPCOMING PLATFORM RELEASES.
- *
- * - DO NOT MODIFY ENUMS (EXCEPT IF YOU ADD NEW 32-BIT VALUES)
- * - DO NOT MODIFY CONSTANTS OR FUNCTIONAL MACROS
- * - DO NOT CHANGE THE SIGNATURE OF FUNCTIONS IN ANY WAY
- * - DO NOT CHANGE THE LAYOUT OR SIZE OF STRUCTURES
- */
-
-/*
- * Support routines to send messages to the Android in-kernel log buffer,
- * which can later be accessed through the 'logcat' utility.
- *
- * Each log message must have
- * - a priority
- * - a log tag
- * - some text
- *
- * The tag normally corresponds to the component that emits the log message,
- * and should be reasonably small.
- *
- * Log message text may be truncated to less than an implementation-specific
- * limit (e.g. 1023 characters max).
- *
- * Note that a newline character ("\n") will be appended automatically to your
- * log message, if not already there. It is not possible to send several messages
- * and have them appear on a single line in logcat.
- *
- * PLEASE USE LOGS WITH MODERATION:
- *
- * - Sending log messages eats CPU and slow down your application and the
- * system.
- *
- * - The circular log buffer is pretty small (<64KB), sending many messages
- * might push off other important log messages from the rest of the system.
- *
- * - In release builds, only send log messages to account for exceptional
- * conditions.
- *
- * NOTE: These functions MUST be implemented by /system/lib/liblog.so
- */
-
-#include <stdarg.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*
- * Android log priority values, in ascending priority order.
- */
-typedef enum android_LogPriority {
- ANDROID_LOG_UNKNOWN = 0,
- ANDROID_LOG_DEFAULT, /* only for SetMinPriority() */
- ANDROID_LOG_VERBOSE,
- ANDROID_LOG_DEBUG,
- ANDROID_LOG_INFO,
- ANDROID_LOG_WARN,
- ANDROID_LOG_ERROR,
- ANDROID_LOG_FATAL,
- ANDROID_LOG_SILENT, /* only for SetMinPriority(); must be last */
-} android_LogPriority;
-
-/*
- * Send a simple string to the log.
- */
-int __android_log_write(int prio, const char *tag, const char *text);
-
-/*
- * Send a formatted string to the log, used like printf(fmt,...)
- */
-int __android_log_print(int prio, const char *tag, const char *fmt, ...)
-#if defined(__GNUC__)
- __attribute__((__format__(printf, 3, 4)))
-#endif
- ;
-
-/*
- * A variant of __android_log_print() that takes a va_list to list
- * additional parameters.
- */
-int __android_log_vprint(int prio, const char *tag,
- const char *fmt, va_list ap);
-
-/*
- * Log an assertion failure and SIGTRAP the process to have a chance
- * to inspect it, if a debugger is attached. This uses the FATAL priority.
- */
-void __android_log_assert(const char *cond, const char *tag,
- const char *fmt, ...)
-#if defined(__GNUC__)
- __attribute__((__noreturn__))
- __attribute__((__format__(printf, 3, 4)))
-#endif
- ;
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _ANDROID_LOG_H */
diff --git a/liblog/logd_reader.c b/liblog/logd_reader.c
index 99d7fea..ccc7da8 100644
--- a/liblog/logd_reader.c
+++ b/liblog/logd_reader.c
@@ -37,6 +37,7 @@
#include "config_read.h"
#include "log_portability.h"
+#include "logd_reader.h"
#include "logger.h"
/* branchless on many architectures. */
@@ -324,6 +325,11 @@
return ret;
}
+LIBLOG_HIDDEN ssize_t __send_log_msg(char *buf, size_t buf_size)
+{
+ return send_log_msg(NULL, NULL, buf, buf_size);
+}
+
static int check_log_success(char *buf, ssize_t ret)
{
if (ret < 0) {
diff --git a/init/seccomp.h b/liblog/logd_reader.h
similarity index 71%
copy from init/seccomp.h
copy to liblog/logd_reader.h
index cda7a89..04c2cf2 100644
--- a/init/seccomp.h
+++ b/liblog/logd_reader.h
@@ -14,9 +14,17 @@
* limitations under the License.
*/
-#ifndef SECCOMP_H
-#define SECCOMP_H
+#ifndef _LIBLOG_LOGD_READER_H__
+#define _LIBLOG_LOGD_READER_H__
-bool set_seccomp_filter();
+#include <unistd.h>
-#endif
+#include "log_portability.h"
+
+__BEGIN_DECLS
+
+LIBLOG_HIDDEN ssize_t __send_log_msg(char *buf, size_t buf_size);
+
+__END_DECLS
+
+#endif /* _LIBLOG_LOGD_READER_H__ */
diff --git a/liblog/logprint.c b/liblog/logprint.c
index da80e36..18af9de 100644
--- a/liblog/logprint.c
+++ b/liblog/logprint.c
@@ -52,6 +52,7 @@
AndroidLogPrintFormat format;
bool colored_output;
bool usec_time_output;
+ bool nsec_time_output;
bool printable_output;
bool year_output;
bool zone_output;
@@ -210,6 +211,7 @@
p_ret->format = FORMAT_BRIEF;
p_ret->colored_output = false;
p_ret->usec_time_output = false;
+ p_ret->nsec_time_output = false;
p_ret->printable_output = false;
p_ret->year_output = false;
p_ret->zone_output = false;
@@ -258,6 +260,9 @@
case FORMAT_MODIFIER_TIME_USEC:
p_format->usec_time_output = true;
return 0;
+ case FORMAT_MODIFIER_TIME_NSEC:
+ p_format->nsec_time_output = true;
+ return 0;
case FORMAT_MODIFIER_PRINTABLE:
p_format->printable_output = true;
return 0;
@@ -309,6 +314,7 @@
else if (strcmp(formatString, "color") == 0) format = FORMAT_MODIFIER_COLOR;
else if (strcmp(formatString, "colour") == 0) format = FORMAT_MODIFIER_COLOR;
else if (strcmp(formatString, "usec") == 0) format = FORMAT_MODIFIER_TIME_USEC;
+ else if (strcmp(formatString, "nsec") == 0) format = FORMAT_MODIFIER_TIME_NSEC;
else if (strcmp(formatString, "printable") == 0) format = FORMAT_MODIFIER_PRINTABLE;
else if (strcmp(formatString, "year") == 0) format = FORMAT_MODIFIER_YEAR;
else if (strcmp(formatString, "zone") == 0) format = FORMAT_MODIFIER_ZONE;
@@ -1496,7 +1502,8 @@
struct tm tmBuf;
#endif
struct tm* ptm;
- char timeBuf[64]; /* good margin, 23+nul for msec, 26+nul for usec */
+ /* good margin, 23+nul for msec, 26+nul for usec, 29+nul to nsec */
+ char timeBuf[64];
char prefixBuf[128], suffixBuf[128];
char priChar;
int prefixSuffixIsHeaderFooter = 0;
@@ -1550,7 +1557,10 @@
ptm);
}
len = strlen(timeBuf);
- if (p_format->usec_time_output) {
+ if (p_format->nsec_time_output) {
+ len += snprintf(timeBuf + len, sizeof(timeBuf) - len,
+ ".%09ld", nsec);
+ } else if (p_format->usec_time_output) {
len += snprintf(timeBuf + len, sizeof(timeBuf) - len,
".%06ld", nsec / US_PER_NSEC);
} else {
diff --git a/liblog/tests/liblog_benchmark.cpp b/liblog/tests/liblog_benchmark.cpp
index 5420f68..dc411c3 100644
--- a/liblog/tests/liblog_benchmark.cpp
+++ b/liblog/tests/liblog_benchmark.cpp
@@ -15,6 +15,8 @@
*/
#include <fcntl.h>
+#include <inttypes.h>
+#include <poll.h>
#include <sys/endian.h>
#include <sys/socket.h>
#include <sys/types.h>
@@ -22,6 +24,7 @@
#include <unordered_set>
+#include <android-base/file.h>
#include <cutils/sockets.h>
#include <log/event_tag_map.h>
#include <private/android_logger.h>
@@ -695,7 +698,7 @@
// Keep maps around for multiple iterations
static std::unordered_set<uint32_t> set;
-static const EventTagMap* map;
+static EventTagMap* map;
static bool prechargeEventMap() {
if (map) return true;
@@ -785,3 +788,142 @@
StopBenchmarkTiming();
}
BENCHMARK(BM_lookupEventFormat);
+
+/*
+ * Measure the time it takes for android_lookupEventTagNum plus above
+ */
+static void BM_lookupEventTagNum(int iters) {
+
+ prechargeEventMap();
+
+ std::unordered_set<uint32_t>::const_iterator it = set.begin();
+
+ for (int i = 0; i < iters; ++i) {
+ size_t len;
+ const char* name = android_lookupEventTag_len(map, &len, (*it));
+ std::string Name(name, len);
+ const char* format = android_lookupEventFormat_len(map, &len, (*it));
+ std::string Format(format, len);
+ StartBenchmarkTiming();
+ android_lookupEventTagNum(map, Name.c_str(), Format.c_str(),
+ ANDROID_LOG_UNKNOWN);
+ StopBenchmarkTiming();
+ ++it;
+ if (it == set.end()) it = set.begin();
+ }
+
+}
+BENCHMARK(BM_lookupEventTagNum);
+
+// Must be functionally identical to liblog internal __send_log_msg.
+static void send_to_control(char *buf, size_t len)
+{
+ int sock = socket_local_client("logd",
+ ANDROID_SOCKET_NAMESPACE_RESERVED,
+ SOCK_STREAM);
+ if (sock < 0) return;
+ size_t writeLen = strlen(buf) + 1;
+
+ ssize_t ret = TEMP_FAILURE_RETRY(write(sock, buf, writeLen));
+ if (ret <= 0) {
+ close(sock);
+ return;
+ }
+ while ((ret = read(sock, buf, len)) > 0) {
+ if (((size_t)ret == len) || (len < PAGE_SIZE)) {
+ break;
+ }
+ len -= ret;
+ buf += ret;
+
+ struct pollfd p = {
+ .fd = sock,
+ .events = POLLIN,
+ .revents = 0
+ };
+
+ ret = poll(&p, 1, 20);
+ if ((ret <= 0) || !(p.revents & POLLIN)) {
+ break;
+ }
+ }
+ close(sock);
+}
+
+static void BM_lookupEventTagNum_logd_new(int iters) {
+ fprintf(stderr, "WARNING: "
+ "This test can cause logd to grow in size and hit DOS limiter\n");
+ // Make copies
+ static const char empty_event_log_tags[] = "# content owned by logd\n";
+ static const char dev_event_log_tags_path[] = "/dev/event-log-tags";
+ std::string dev_event_log_tags;
+ if (android::base::ReadFileToString(dev_event_log_tags_path,
+ &dev_event_log_tags) &&
+ (dev_event_log_tags.length() == 0)) {
+ dev_event_log_tags = empty_event_log_tags;
+ }
+ static const char data_event_log_tags_path[] = "/data/misc/logd/event-log-tags";
+ std::string data_event_log_tags;
+ if (android::base::ReadFileToString(data_event_log_tags_path,
+ &data_event_log_tags) &&
+ (data_event_log_tags.length() == 0)) {
+ data_event_log_tags = empty_event_log_tags;
+ }
+
+ for (int i = 0; i < iters; ++i) {
+ char buffer[256];
+ memset(buffer, 0, sizeof(buffer));
+ log_time now(CLOCK_MONOTONIC);
+ char name[64];
+ snprintf(name, sizeof(name), "a%" PRIu64, now.nsec());
+ snprintf(buffer, sizeof(buffer),
+ "getEventTag name=%s format=\"(new|1)\"", name);
+ StartBenchmarkTiming();
+ send_to_control(buffer, sizeof(buffer));
+ StopBenchmarkTiming();
+ }
+
+ // Restore copies (logd still know about them, until crash or reboot)
+ if (dev_event_log_tags.length() &&
+ !android::base::WriteStringToFile(dev_event_log_tags,
+ dev_event_log_tags_path)) {
+ fprintf(stderr, "WARNING: "
+ "failed to restore %s\n", dev_event_log_tags_path);
+ }
+ if (data_event_log_tags.length() &&
+ !android::base::WriteStringToFile(data_event_log_tags,
+ data_event_log_tags_path)) {
+ fprintf(stderr, "WARNING: "
+ "failed to restore %s\n", data_event_log_tags_path);
+ }
+ fprintf(stderr, "WARNING: "
+ "Restarting logd to make it forget what we just did\n");
+ system("stop logd ; start logd");
+}
+BENCHMARK(BM_lookupEventTagNum_logd_new);
+
+static void BM_lookupEventTagNum_logd_existing(int iters) {
+ prechargeEventMap();
+
+ std::unordered_set<uint32_t>::const_iterator it = set.begin();
+
+ for (int i = 0; i < iters; ++i) {
+ size_t len;
+ const char* name = android_lookupEventTag_len(map, &len, (*it));
+ std::string Name(name, len);
+ const char* format = android_lookupEventFormat_len(map, &len, (*it));
+ std::string Format(format, len);
+
+ char buffer[256];
+ snprintf(buffer, sizeof(buffer),
+ "getEventTag name=%s format=\"%s\"",
+ Name.c_str(), Format.c_str());
+
+ StartBenchmarkTiming();
+ send_to_control(buffer, sizeof(buffer));
+ StopBenchmarkTiming();
+ ++it;
+ if (it == set.end()) it = set.begin();
+ }
+}
+BENCHMARK(BM_lookupEventTagNum_logd_existing);
diff --git a/liblog/tests/liblog_test.cpp b/liblog/tests/liblog_test.cpp
index 8b9f0f0..5faf8e1 100644
--- a/liblog/tests/liblog_test.cpp
+++ b/liblog/tests/liblog_test.cpp
@@ -2929,3 +2929,19 @@
}
// Do not test default seconds, to allow liblog to tune freely
}
+
+TEST(liblog, android_lookupEventTagNum) {
+#ifdef __ANDROID__
+ EventTagMap* map = android_openEventTagMap(NULL);
+ EXPECT_TRUE(NULL != map);
+ std::string Name = android::base::StringPrintf("a%d", getpid());
+ int tag = android_lookupEventTagNum(map, Name.c_str(), "(new|1)", ANDROID_LOG_UNKNOWN);
+ android_closeEventTagMap(map);
+ if (tag == -1) system("tail -3 /dev/event-log-tags >&2");
+ EXPECT_NE(-1, tag);
+ EXPECT_NE(0, tag);
+ EXPECT_GT(UINT32_MAX, (unsigned)tag);
+#else
+ GTEST_LOG_(INFO) << "This test does nothing.\n";
+#endif
+}
diff --git a/libnativeloader/dlext_namespaces.h b/libnativeloader/include/nativeloader/dlext_namespaces.h
similarity index 87%
rename from libnativeloader/dlext_namespaces.h
rename to libnativeloader/include/nativeloader/dlext_namespaces.h
index 13a44e2..02e7075 100644
--- a/libnativeloader/dlext_namespaces.h
+++ b/libnativeloader/include/nativeloader/dlext_namespaces.h
@@ -86,6 +86,19 @@
const char* permitted_when_isolated_path,
android_namespace_t* parent);
+/*
+ * Get the default library search path.
+ * The path will be copied into buffer, which must have space for at least
+ * buffer_size chars. Elements are separated with ':', and the path will always
+ * be null-terminated.
+ *
+ * If buffer_size is too small to hold the entire default search path and the
+ * null terminator, this function will abort. There is currently no way to find
+ * out what the required buffer size is. At the time of this writing, PATH_MAX
+ * is sufficient and used by all callers of this function.
+ */
+extern void android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size);
+
__END_DECLS
#endif /* __ANDROID_DLEXT_NAMESPACES_H__ */
diff --git a/libnativeloader/native_loader.cpp b/libnativeloader/native_loader.cpp
index 8c2a5f7..2f23c2c 100644
--- a/libnativeloader/native_loader.cpp
+++ b/libnativeloader/native_loader.cpp
@@ -20,7 +20,7 @@
#include <dlfcn.h>
#ifdef __ANDROID__
#define LOG_TAG "libnativeloader"
-#include "dlext_namespaces.h"
+#include "nativeloader/dlext_namespaces.h"
#include "cutils/properties.h"
#include "log/log.h"
#endif
diff --git a/libsync/tests/sync_test.cpp b/libsync/tests/sync_test.cpp
index ff8a300..401aaee 100644
--- a/libsync/tests/sync_test.cpp
+++ b/libsync/tests/sync_test.cpp
@@ -536,7 +536,7 @@
ASSERT_TRUE(fence.isValid());
unordered_map<int, int> fenceMap;
- fenceMap.insert(make_tuple(0, 0));
+ fenceMap.insert(make_pair(0, 0));
// Randomly create syncpoints out of a fixed set of timelines, and merge them together.
for (int i = 0; i < mergeCount; i++) {
@@ -549,12 +549,12 @@
// Keep track of the latest syncpoint in each timeline.
auto itr = fenceMap.find(timelineOffset);
if (itr == end(fenceMap)) {
- fenceMap.insert(tie(timelineOffset, syncPoint));
+ fenceMap.insert(make_pair(timelineOffset, syncPoint));
}
else {
int oldSyncPoint = itr->second;
fenceMap.erase(itr);
- fenceMap.insert(tie(timelineOffset, max(syncPoint, oldSyncPoint)));
+ fenceMap.insert(make_pair(timelineOffset, max(syncPoint, oldSyncPoint)));
}
// Merge.
diff --git a/libunwindstack/Android.bp b/libunwindstack/Android.bp
new file mode 100644
index 0000000..9bb1304
--- /dev/null
+++ b/libunwindstack/Android.bp
@@ -0,0 +1,132 @@
+//
+// Copyright (C) 2017 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_defaults {
+ name: "libunwindstack_flags",
+
+ host_supported: true,
+
+ cflags: [
+ "-Wall",
+ "-Werror",
+ "-Wextra",
+ ],
+
+ target: {
+ darwin: {
+ enabled: false,
+ },
+ },
+}
+
+cc_defaults {
+ name: "libunwindstack_common",
+ defaults: ["libunwindstack_flags"],
+
+ srcs: [
+ "ArmExidx.cpp",
+ "Memory.cpp",
+ "Log.cpp",
+ ],
+
+ shared_libs: [
+ "libbase",
+ "liblog",
+ ],
+}
+
+cc_library {
+ name: "libunwindstack",
+ defaults: ["libunwindstack_common"],
+}
+
+cc_library {
+ name: "libunwindstack_debug",
+ defaults: ["libunwindstack_common"],
+
+ cflags: [
+ "-UNDEBUG",
+ "-O0",
+ "-g",
+ ],
+}
+
+//-------------------------------------------------------------------------
+// Unit Tests
+//-------------------------------------------------------------------------
+cc_defaults {
+ name: "libunwindstack_test_common",
+ defaults: ["libunwindstack_flags"],
+
+ srcs: [
+ "tests/ArmExidxDecodeTest.cpp",
+ "tests/ArmExidxExtractTest.cpp",
+ "tests/LogFake.cpp",
+ "tests/MemoryFake.cpp",
+ "tests/MemoryFileTest.cpp",
+ "tests/MemoryLocalTest.cpp",
+ "tests/MemoryRangeTest.cpp",
+ "tests/MemoryRemoteTest.cpp",
+ "tests/RegsTest.cpp",
+ ],
+
+ cflags: [
+ "-O0",
+ "-g",
+ ],
+
+ shared_libs: [
+ "libbase",
+ "liblog",
+ ],
+
+ multilib: {
+ lib32: {
+ suffix: "32",
+ },
+ lib64: {
+ suffix: "64",
+ },
+ },
+
+ target: {
+ linux: {
+ host_ldlibs: [
+ "-lrt",
+ ],
+ },
+ },
+}
+
+// These unit tests run against the shared library.
+cc_test {
+ name: "libunwindstack_test",
+ defaults: ["libunwindstack_test_common"],
+
+ shared_libs: [
+ "libunwindstack",
+ ],
+}
+
+// These unit tests run against the static debug library.
+cc_test {
+ name: "libunwindstack_test_debug",
+ defaults: ["libunwindstack_test_common"],
+
+ static_libs: [
+ "libunwindstack_debug",
+ ],
+}
diff --git a/libunwindstack/ArmExidx.cpp b/libunwindstack/ArmExidx.cpp
new file mode 100644
index 0000000..3b78918
--- /dev/null
+++ b/libunwindstack/ArmExidx.cpp
@@ -0,0 +1,680 @@
+/*
+ * 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 <assert.h>
+#include <stdint.h>
+
+#include <deque>
+#include <string>
+
+#include <android-base/stringprintf.h>
+
+#include "ArmExidx.h"
+#include "Log.h"
+#include "Machine.h"
+
+void ArmExidx::LogRawData() {
+ std::string log_str("Raw Data:");
+ for (const uint8_t data : data_) {
+ log_str += android::base::StringPrintf(" 0x%02x", data);
+ }
+ log(log_indent_, log_str.c_str());
+}
+
+bool ArmExidx::ExtractEntryData(uint32_t entry_offset) {
+ data_.clear();
+ status_ = ARM_STATUS_NONE;
+
+ if (entry_offset & 1) {
+ // The offset needs to be at least two byte aligned.
+ status_ = ARM_STATUS_INVALID_ALIGNMENT;
+ return false;
+ }
+
+ // Each entry is a 32 bit prel31 offset followed by 32 bits
+ // of unwind information. If bit 31 of the unwind data is zero,
+ // then this is a prel31 offset to the start of the unwind data.
+ // If the unwind data is 1, then this is a cant unwind entry.
+ // Otherwise, this data is the compact form of the unwind information.
+ uint32_t data;
+ if (!elf_memory_->Read32(entry_offset + 4, &data)) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ if (data == 1) {
+ // This is a CANT UNWIND entry.
+ status_ = ARM_STATUS_NO_UNWIND;
+ if (log_) {
+ log(log_indent_, "Raw Data: 0x00 0x00 0x00 0x01");
+ log(log_indent_, "[cantunwind]");
+ }
+ return false;
+ }
+
+ if (data & (1UL << 31)) {
+ // This is a compact table entry.
+ if ((data >> 24) & 0xf) {
+ // This is a non-zero index, this code doesn't support
+ // other formats.
+ status_ = ARM_STATUS_INVALID_PERSONALITY;
+ return false;
+ }
+ data_.push_back((data >> 16) & 0xff);
+ data_.push_back((data >> 8) & 0xff);
+ uint8_t last_op = data & 0xff;
+ data_.push_back(last_op);
+ if (last_op != ARM_OP_FINISH) {
+ // If this didn't end with a finish op, add one.
+ data_.push_back(ARM_OP_FINISH);
+ }
+ if (log_) {
+ LogRawData();
+ }
+ return true;
+ }
+
+ // Get the address of the ops.
+ // Sign extend the data value if necessary.
+ int32_t signed_data = static_cast<int32_t>(data << 1) >> 1;
+ uint32_t addr = (entry_offset + 4) + signed_data;
+ if (!elf_memory_->Read32(addr, &data)) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+
+ size_t num_table_words;
+ if (data & (1UL << 31)) {
+ // Compact model.
+ switch ((data >> 24) & 0xf) {
+ case 0:
+ num_table_words = 0;
+ data_.push_back((data >> 16) & 0xff);
+ break;
+ case 1:
+ case 2:
+ num_table_words = (data >> 16) & 0xff;
+ addr += 4;
+ break;
+ default:
+ // Only a personality of 0, 1, 2 is valid.
+ status_ = ARM_STATUS_INVALID_PERSONALITY;
+ return false;
+ }
+ data_.push_back((data >> 8) & 0xff);
+ data_.push_back(data & 0xff);
+ } else {
+ // Generic model.
+
+ // Skip the personality routine data, it doesn't contain any data
+ // needed to decode the unwind information.
+ addr += 4;
+ if (!elf_memory_->Read32(addr, &data)) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ num_table_words = (data >> 24) & 0xff;
+ data_.push_back((data >> 16) & 0xff);
+ data_.push_back((data >> 8) & 0xff);
+ data_.push_back(data & 0xff);
+ addr += 4;
+ }
+
+ if (num_table_words > 5) {
+ status_ = ARM_STATUS_MALFORMED;
+ return false;
+ }
+
+ for (size_t i = 0; i < num_table_words; i++) {
+ if (!elf_memory_->Read32(addr, &data)) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ data_.push_back((data >> 24) & 0xff);
+ data_.push_back((data >> 16) & 0xff);
+ data_.push_back((data >> 8) & 0xff);
+ data_.push_back(data & 0xff);
+ addr += 4;
+ }
+
+ if (data_.back() != ARM_OP_FINISH) {
+ // If this didn't end with a finish op, add one.
+ data_.push_back(ARM_OP_FINISH);
+ }
+
+ if (log_) {
+ LogRawData();
+ }
+ return true;
+}
+
+inline bool ArmExidx::GetByte(uint8_t* byte) {
+ if (data_.empty()) {
+ status_ = ARM_STATUS_TRUNCATED;
+ return false;
+ }
+ *byte = data_.front();
+ data_.pop_front();
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_00(uint8_t byte) {
+ assert((byte >> 4) == 0x8);
+
+ uint16_t registers = (byte & 0xf) << 8;
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ registers |= byte;
+ if (registers == 0) {
+ // 10000000 00000000: Refuse to unwind
+ if (log_) {
+ log(log_indent_, "Refuse to unwind");
+ }
+ status_ = ARM_STATUS_NO_UNWIND;
+ return false;
+ }
+ // 1000iiii iiiiiiii: Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}
+ if (log_) {
+ bool add_comma = false;
+ std::string msg = "pop {";
+ for (size_t i = 0; i < 12; i++) {
+ if (registers & (1 << i)) {
+ if (add_comma) {
+ msg += ", ";
+ }
+ msg += android::base::StringPrintf("r%zu", i + 4);
+ add_comma = true;
+ }
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+
+ registers <<= 4;
+ for (size_t reg = 4; reg < 16; reg++) {
+ if (registers & (1 << reg)) {
+ if (!process_memory_->Read32(cfa_, &(*regs_)[reg])) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ cfa_ += 4;
+ }
+ }
+ // If the sp register is modified, change the cfa value.
+ if (registers & (1 << ARM_REG_SP)) {
+ cfa_ = (*regs_)[ARM_REG_SP];
+ }
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_01(uint8_t byte) {
+ assert((byte >> 4) == 0x9);
+
+ uint8_t bits = byte & 0xf;
+ if (bits == 13 || bits == 15) {
+ // 10011101: Reserved as prefix for ARM register to register moves
+ // 10011111: Reserved as prefix for Intel Wireless MMX register to register moves
+ if (log_) {
+ log(log_indent_, "[Reserved]");
+ }
+ status_ = ARM_STATUS_RESERVED;
+ return false;
+ }
+ // 1001nnnn: Set vsp = r[nnnn] (nnnn != 13, 15)
+ if (log_) {
+ log(log_indent_, "vsp = r%d", bits);
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ // It is impossible for bits to be larger than the total number of
+ // arm registers, so don't bother checking if bits is a valid register.
+ cfa_ = (*regs_)[bits];
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_10(uint8_t byte) {
+ assert((byte >> 4) == 0xa);
+
+ // 10100nnn: Pop r4-r[4+nnn]
+ // 10101nnn: Pop r4-r[4+nnn], r14
+ if (log_) {
+ std::string msg = "pop {r4";
+ uint8_t end_reg = byte & 0x7;
+ if (end_reg) {
+ msg += android::base::StringPrintf("-r%d", 4 + end_reg);
+ }
+ if (byte & 0x8) {
+ log(log_indent_, "%s, r14}", msg.c_str());
+ } else {
+ log(log_indent_, "%s}", msg.c_str());
+ }
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+
+ for (size_t i = 4; i <= 4 + (byte & 0x7); i++) {
+ if (!process_memory_->Read32(cfa_, &(*regs_)[i])) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ cfa_ += 4;
+ }
+ if (byte & 0x8) {
+ if (!process_memory_->Read32(cfa_, &(*regs_)[ARM_REG_R14])) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ cfa_ += 4;
+ }
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_11_0000() {
+ // 10110000: Finish
+ if (log_) {
+ log(log_indent_, "finish");
+ if (log_skip_execution_) {
+ status_ = ARM_STATUS_FINISH;
+ return false;
+ }
+ }
+ if (!(*regs_)[ARM_REG_PC]) {
+ (*regs_)[ARM_REG_PC] = (*regs_)[ARM_REG_LR];
+ }
+ status_ = ARM_STATUS_FINISH;
+ return false;
+}
+
+inline bool ArmExidx::DecodePrefix_10_11_0001() {
+ uint8_t byte;
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ if (byte == 0) {
+ // 10110001 00000000: Spare
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+ }
+ if (byte >> 4) {
+ // 10110001 xxxxyyyy: Spare (xxxx != 0000)
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+ }
+
+ // 10110001 0000iiii: Pop integer registers under mask {r3, r2, r1, r0}
+ if (log_) {
+ bool add_comma = false;
+ std::string msg = "pop {";
+ for (size_t i = 0; i < 4; i++) {
+ if (byte & (1 << i)) {
+ if (add_comma) {
+ msg += ", ";
+ }
+ msg += android::base::StringPrintf("r%zu", i);
+ add_comma = true;
+ }
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+
+ for (size_t reg = 0; reg < 4; reg++) {
+ if (byte & (1 << reg)) {
+ if (!process_memory_->Read32(cfa_, &(*regs_)[reg])) {
+ status_ = ARM_STATUS_READ_FAILED;
+ return false;
+ }
+ cfa_ += 4;
+ }
+ }
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_11_0010() {
+ // 10110010 uleb128: vsp = vsp + 0x204 + (uleb128 << 2)
+ uint32_t result = 0;
+ uint32_t shift = 0;
+ uint8_t byte;
+ do {
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ result |= (byte & 0x7f) << shift;
+ shift += 7;
+ } while (byte & 0x80);
+ result <<= 2;
+ if (log_) {
+ log(log_indent_, "vsp = vsp + %d", 0x204 + result);
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ cfa_ += 0x204 + result;
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_11_0011() {
+ // 10110011 sssscccc: Pop VFP double precision registers D[ssss]-D[ssss+cccc] by FSTMFDX
+ uint8_t byte;
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ if (log_) {
+ uint8_t start_reg = byte >> 4;
+ std::string msg = android::base::StringPrintf("pop {d%d", start_reg);
+ uint8_t end_reg = start_reg + (byte & 0xf);
+ if (end_reg) {
+ msg += android::base::StringPrintf("-d%d", end_reg);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ cfa_ += (byte & 0xf) * 8 + 12;
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10_11_01nn() {
+ // 101101nn: Spare
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+}
+
+inline bool ArmExidx::DecodePrefix_10_11_1nnn(uint8_t byte) {
+ assert((byte & ~0x07) == 0xb8);
+
+ // 10111nnn: Pop VFP double-precision registers D[8]-D[8+nnn] by FSTMFDX
+ if (log_) {
+ std::string msg = "pop {d8";
+ uint8_t last_reg = (byte & 0x7);
+ if (last_reg) {
+ msg += android::base::StringPrintf("-d%d", last_reg + 8);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ // Only update the cfa.
+ cfa_ += (byte & 0x7) * 8 + 12;
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_10(uint8_t byte) {
+ assert((byte >> 6) == 0x2);
+
+ switch ((byte >> 4) & 0x3) {
+ case 0:
+ return DecodePrefix_10_00(byte);
+ case 1:
+ return DecodePrefix_10_01(byte);
+ case 2:
+ return DecodePrefix_10_10(byte);
+ default:
+ switch (byte & 0xf) {
+ case 0:
+ return DecodePrefix_10_11_0000();
+ case 1:
+ return DecodePrefix_10_11_0001();
+ case 2:
+ return DecodePrefix_10_11_0010();
+ case 3:
+ return DecodePrefix_10_11_0011();
+ default:
+ if (byte & 0x8) {
+ return DecodePrefix_10_11_1nnn(byte);
+ } else {
+ return DecodePrefix_10_11_01nn();
+ }
+ }
+ }
+}
+
+inline bool ArmExidx::DecodePrefix_11_000(uint8_t byte) {
+ assert((byte & ~0x07) == 0xc0);
+
+ uint8_t bits = byte & 0x7;
+ if (bits == 6) {
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ // 11000110 sssscccc: Intel Wireless MMX pop wR[ssss]-wR[ssss+cccc]
+ if (log_) {
+ uint8_t start_reg = byte >> 4;
+ std::string msg = android::base::StringPrintf("pop {wR%d", start_reg);
+ uint8_t end_reg = byte & 0xf;
+ if (end_reg) {
+ msg += android::base::StringPrintf("-wR%d", start_reg + end_reg);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ // Only update the cfa.
+ cfa_ += (byte & 0xf) * 8 + 8;
+ } else if (bits == 7) {
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ if (byte == 0) {
+ // 11000111 00000000: Spare
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+ } else if ((byte >> 4) == 0) {
+ // 11000111 0000iiii: Intel Wireless MMX pop wCGR registers {wCGR0,1,2,3}
+ if (log_) {
+ bool add_comma = false;
+ std::string msg = "pop {";
+ for (size_t i = 0; i < 4; i++) {
+ if (byte & (1 << i)) {
+ if (add_comma) {
+ msg += ", ";
+ }
+ msg += android::base::StringPrintf("wCGR%zu", i);
+ add_comma = true;
+ }
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ }
+ // Only update the cfa.
+ cfa_ += __builtin_popcount(byte) * 4;
+ } else {
+ // 11000111 xxxxyyyy: Spare (xxxx != 0000)
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+ }
+ } else {
+ // 11000nnn: Intel Wireless MMX pop wR[10]-wR[10+nnn] (nnn != 6, 7)
+ if (log_) {
+ std::string msg = "pop {wR10";
+ uint8_t nnn = byte & 0x7;
+ if (nnn) {
+ msg += android::base::StringPrintf("-wR%d", 10 + nnn);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ // Only update the cfa.
+ cfa_ += (byte & 0x7) * 8 + 8;
+ }
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_11_001(uint8_t byte) {
+ assert((byte & ~0x07) == 0xc8);
+
+ uint8_t bits = byte & 0x7;
+ if (bits == 0) {
+ // 11001000 sssscccc: Pop VFP double precision registers D[16+ssss]-D[16+ssss+cccc] by VPUSH
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ if (log_) {
+ uint8_t start_reg = byte >> 4;
+ std::string msg = android::base::StringPrintf("pop {d%d", 16 + start_reg);
+ uint8_t end_reg = byte & 0xf;
+ if (end_reg) {
+ msg += android::base::StringPrintf("-d%d", 16 + start_reg + end_reg);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ // Only update the cfa.
+ cfa_ += (byte & 0xf) * 8 + 8;
+ } else if (bits == 1) {
+ // 11001001 sssscccc: Pop VFP double precision registers D[ssss]-D[ssss+cccc] by VPUSH
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ if (log_) {
+ uint8_t start_reg = byte >> 4;
+ std::string msg = android::base::StringPrintf("pop {d%d", start_reg);
+ uint8_t end_reg = byte & 0xf;
+ if (end_reg) {
+ msg += android::base::StringPrintf("-d%d", start_reg + end_reg);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ // Only update the cfa.
+ cfa_ += (byte & 0xf) * 8 + 8;
+ } else {
+ // 11001yyy: Spare (yyy != 000, 001)
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+ }
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_11_010(uint8_t byte) {
+ assert((byte & ~0x07) == 0xd0);
+
+ // 11010nnn: Pop VFP double precision registers D[8]-D[8+nnn] by VPUSH
+ if (log_) {
+ std::string msg = "pop {d8";
+ uint8_t end_reg = byte & 0x7;
+ if (end_reg) {
+ msg += android::base::StringPrintf("-d%d", 8 + end_reg);
+ }
+ log(log_indent_, "%s}", msg.c_str());
+ if (log_skip_execution_) {
+ return true;
+ }
+ }
+ cfa_ += (byte & 0x7) * 8 + 8;
+ return true;
+}
+
+inline bool ArmExidx::DecodePrefix_11(uint8_t byte) {
+ assert((byte >> 6) == 0x3);
+
+ switch ((byte >> 3) & 0x7) {
+ case 0:
+ return DecodePrefix_11_000(byte);
+ case 1:
+ return DecodePrefix_11_001(byte);
+ case 2:
+ return DecodePrefix_11_010(byte);
+ default:
+ // 11xxxyyy: Spare (xxx != 000, 001, 010)
+ if (log_) {
+ log(log_indent_, "Spare");
+ }
+ status_ = ARM_STATUS_SPARE;
+ return false;
+ }
+}
+
+bool ArmExidx::Decode() {
+ status_ = ARM_STATUS_NONE;
+ uint8_t byte;
+ if (!GetByte(&byte)) {
+ return false;
+ }
+
+ switch (byte >> 6) {
+ case 0:
+ // 00xxxxxx: vsp = vsp + (xxxxxxx << 2) + 4
+ if (log_) {
+ log(log_indent_, "vsp = vsp + %d", ((byte & 0x3f) << 2) + 4);
+ if (log_skip_execution_) {
+ break;
+ }
+ }
+ cfa_ += ((byte & 0x3f) << 2) + 4;
+ break;
+ case 1:
+ // 01xxxxxx: vsp = vsp - (xxxxxxx << 2) + 4
+ if (log_) {
+ log(log_indent_, "vsp = vsp - %d", ((byte & 0x3f) << 2) + 4);
+ if (log_skip_execution_) {
+ break;
+ }
+ }
+ cfa_ -= ((byte & 0x3f) << 2) + 4;
+ break;
+ case 2:
+ return DecodePrefix_10(byte);
+ default:
+ return DecodePrefix_11(byte);
+ }
+ return true;
+}
+
+bool ArmExidx::Eval() {
+ while (Decode());
+ return status_ == ARM_STATUS_FINISH;
+}
diff --git a/libunwindstack/ArmExidx.h b/libunwindstack/ArmExidx.h
new file mode 100644
index 0000000..a92caef
--- /dev/null
+++ b/libunwindstack/ArmExidx.h
@@ -0,0 +1,103 @@
+/*
+ * 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.
+ */
+
+#ifndef _LIBUNWINDSTACK_ARM_EXIDX_H
+#define _LIBUNWINDSTACK_ARM_EXIDX_H
+
+#include <stdint.h>
+
+#include <deque>
+
+#include "Memory.h"
+#include "Regs.h"
+
+enum ArmStatus : size_t {
+ ARM_STATUS_NONE = 0,
+ ARM_STATUS_NO_UNWIND,
+ ARM_STATUS_FINISH,
+ ARM_STATUS_RESERVED,
+ ARM_STATUS_SPARE,
+ ARM_STATUS_TRUNCATED,
+ ARM_STATUS_READ_FAILED,
+ ARM_STATUS_MALFORMED,
+ ARM_STATUS_INVALID_ALIGNMENT,
+ ARM_STATUS_INVALID_PERSONALITY,
+};
+
+enum ArmOp : uint8_t {
+ ARM_OP_FINISH = 0xb0,
+};
+
+class ArmExidx {
+ public:
+ ArmExidx(Regs32* regs, Memory* elf_memory, Memory* process_memory)
+ : regs_(regs), elf_memory_(elf_memory), process_memory_(process_memory) {}
+ virtual ~ArmExidx() {}
+
+ void LogRawData();
+
+ bool ExtractEntryData(uint32_t entry_offset);
+
+ bool Eval();
+
+ bool Decode();
+
+ std::deque<uint8_t>* data() { return &data_; }
+
+ ArmStatus status() { return status_; }
+
+ Regs32* regs() { return regs_; }
+
+ uint32_t cfa() { return cfa_; }
+ void set_cfa(uint32_t cfa) { cfa_ = cfa; }
+
+ void set_log(bool log) { log_ = log; }
+ void set_log_skip_execution(bool skip_execution) { log_skip_execution_ = skip_execution; }
+ void set_log_indent(uint8_t indent) { log_indent_ = indent; }
+
+ private:
+ bool GetByte(uint8_t* byte);
+
+ bool DecodePrefix_10_00(uint8_t byte);
+ bool DecodePrefix_10_01(uint8_t byte);
+ bool DecodePrefix_10_10(uint8_t byte);
+ bool DecodePrefix_10_11_0000();
+ bool DecodePrefix_10_11_0001();
+ bool DecodePrefix_10_11_0010();
+ bool DecodePrefix_10_11_0011();
+ bool DecodePrefix_10_11_01nn();
+ bool DecodePrefix_10_11_1nnn(uint8_t byte);
+ bool DecodePrefix_10(uint8_t byte);
+
+ bool DecodePrefix_11_000(uint8_t byte);
+ bool DecodePrefix_11_001(uint8_t byte);
+ bool DecodePrefix_11_010(uint8_t byte);
+ bool DecodePrefix_11(uint8_t byte);
+
+ Regs32* regs_ = nullptr;
+ uint32_t cfa_ = 0;
+ std::deque<uint8_t> data_;
+ ArmStatus status_ = ARM_STATUS_NONE;
+
+ Memory* elf_memory_;
+ Memory* process_memory_;
+
+ bool log_ = false;
+ uint8_t log_indent_ = 0;
+ bool log_skip_execution_ = false;
+};
+
+#endif // _LIBUNWINDSTACK_ARM_EXIDX_H
diff --git a/libunwindstack/Log.cpp b/libunwindstack/Log.cpp
new file mode 100644
index 0000000..faeb66c
--- /dev/null
+++ b/libunwindstack/Log.cpp
@@ -0,0 +1,53 @@
+/*
+ * 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 <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+
+#include <string>
+
+#define LOG_TAG "unwind"
+#include <log/log.h>
+
+#include <android-base/stringprintf.h>
+
+#include "Log.h"
+
+static bool g_print_to_stdout = false;
+
+void log_to_stdout(bool enable) {
+ g_print_to_stdout = enable;
+}
+
+// Send the data to the log.
+void log(uint8_t indent, const char* format, ...) {
+ std::string real_format;
+ if (indent > 0) {
+ real_format = android::base::StringPrintf("%*s%s", 2 * indent, " ", format);
+ } else {
+ real_format = format;
+ }
+ va_list args;
+ va_start(args, format);
+ if (g_print_to_stdout) {
+ real_format += '\n';
+ vprintf(real_format.c_str(), args);
+ } else {
+ LOG_PRI_VA(ANDROID_LOG_INFO, LOG_TAG, real_format.c_str(), args);
+ }
+ va_end(args);
+}
diff --git a/init/seccomp.h b/libunwindstack/Log.h
similarity index 75%
rename from init/seccomp.h
rename to libunwindstack/Log.h
index cda7a89..2d01aa8 100644
--- a/init/seccomp.h
+++ b/libunwindstack/Log.h
@@ -14,9 +14,12 @@
* limitations under the License.
*/
-#ifndef SECCOMP_H
-#define SECCOMP_H
+#ifndef _LIBUNWINDSTACK_LOG_H
+#define _LIBUNWINDSTACK_LOG_H
-bool set_seccomp_filter();
+#include <stdint.h>
-#endif
+void log_to_stdout(bool enable);
+void log(uint8_t indent, const char* format, ...);
+
+#endif // _LIBUNWINDSTACK_LOG_H
diff --git a/libunwindstack/Machine.h b/libunwindstack/Machine.h
new file mode 100644
index 0000000..db84271
--- /dev/null
+++ b/libunwindstack/Machine.h
@@ -0,0 +1,135 @@
+/*
+ * 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.
+ */
+
+#ifndef _LIBUNWINDSTACK_MACHINE_H
+#define _LIBUNWINDSTACK_MACHINE_H
+
+#include <stdint.h>
+
+class Regs;
+
+enum ArmReg : uint16_t {
+ ARM_REG_R0 = 0,
+ ARM_REG_R1,
+ ARM_REG_R2,
+ ARM_REG_R3,
+ ARM_REG_R4,
+ ARM_REG_R5,
+ ARM_REG_R6,
+ ARM_REG_R7,
+ ARM_REG_R8,
+ ARM_REG_R9,
+ ARM_REG_R10,
+ ARM_REG_R11,
+ ARM_REG_R12,
+ ARM_REG_R13,
+ ARM_REG_R14,
+ ARM_REG_R15,
+ ARM_REG_LAST,
+
+ ARM_REG_SP = ARM_REG_R13,
+ ARM_REG_LR = ARM_REG_R14,
+ ARM_REG_PC = ARM_REG_R15,
+};
+
+enum Arm64Reg : uint16_t {
+ ARM64_REG_R0 = 0,
+ ARM64_REG_R1,
+ ARM64_REG_R2,
+ ARM64_REG_R3,
+ ARM64_REG_R4,
+ ARM64_REG_R5,
+ ARM64_REG_R6,
+ ARM64_REG_R7,
+ ARM64_REG_R8,
+ ARM64_REG_R9,
+ ARM64_REG_R10,
+ ARM64_REG_R11,
+ ARM64_REG_R12,
+ ARM64_REG_R13,
+ ARM64_REG_R14,
+ ARM64_REG_R15,
+ ARM64_REG_R16,
+ ARM64_REG_R17,
+ ARM64_REG_R18,
+ ARM64_REG_R19,
+ ARM64_REG_R20,
+ ARM64_REG_R21,
+ ARM64_REG_R22,
+ ARM64_REG_R23,
+ ARM64_REG_R24,
+ ARM64_REG_R25,
+ ARM64_REG_R26,
+ ARM64_REG_R27,
+ ARM64_REG_R28,
+ ARM64_REG_R29,
+ ARM64_REG_R30,
+ ARM64_REG_R31,
+ ARM64_REG_PC,
+ ARM64_REG_LAST,
+
+ ARM64_REG_SP = ARM64_REG_R31,
+ ARM64_REG_LR = ARM64_REG_R30,
+};
+
+enum X86Reg : uint16_t {
+ X86_REG_EAX = 0,
+ X86_REG_ECX,
+ X86_REG_EDX,
+ X86_REG_EBX,
+ X86_REG_ESP,
+ X86_REG_EBP,
+ X86_REG_ESI,
+ X86_REG_EDI,
+ X86_REG_EIP,
+ X86_REG_EFL,
+ X86_REG_CS,
+ X86_REG_SS,
+ X86_REG_DS,
+ X86_REG_ES,
+ X86_REG_FS,
+ X86_REG_GS,
+ X86_REG_LAST,
+
+ X86_REG_SP = X86_REG_ESP,
+ X86_REG_PC = X86_REG_EIP,
+};
+
+enum X86_64Reg : uint16_t {
+ X86_64_REG_RAX = 0,
+ X86_64_REG_RDX,
+ X86_64_REG_RCX,
+ X86_64_REG_RBX,
+ X86_64_REG_RSI,
+ X86_64_REG_RDI,
+ X86_64_REG_RBP,
+ X86_64_REG_RSP,
+ X86_64_REG_R8,
+ X86_64_REG_R9,
+ X86_64_REG_R10,
+ X86_64_REG_R11,
+ X86_64_REG_R12,
+ X86_64_REG_R13,
+ X86_64_REG_R14,
+ X86_64_REG_R15,
+ X86_64_REG_RIP,
+ X86_64_REG_LAST,
+
+ X86_64_REG_SP = X86_64_REG_RSP,
+ X86_64_REG_PC = X86_64_REG_RIP,
+};
+
+#endif // _LIBUNWINDSTACK_MACHINE_H
diff --git a/libunwindstack/Memory.cpp b/libunwindstack/Memory.cpp
new file mode 100644
index 0000000..336e4fe
--- /dev/null
+++ b/libunwindstack/Memory.cpp
@@ -0,0 +1,180 @@
+/*
+ * 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 <errno.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <sys/ptrace.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <memory>
+
+#include <android-base/unique_fd.h>
+
+#include "Memory.h"
+
+bool Memory::ReadString(uint64_t addr, std::string* string, uint64_t max_read) {
+ string->clear();
+ uint64_t bytes_read = 0;
+ while (bytes_read < max_read) {
+ uint8_t value;
+ if (!Read(addr, &value, sizeof(value))) {
+ return false;
+ }
+ if (value == '\0') {
+ return true;
+ }
+ string->push_back(value);
+ addr++;
+ bytes_read++;
+ }
+ return false;
+}
+
+MemoryFileAtOffset::~MemoryFileAtOffset() {
+ if (data_) {
+ munmap(&data_[-offset_], size_ + offset_);
+ data_ = nullptr;
+ }
+}
+
+bool MemoryFileAtOffset::Init(const std::string& file, uint64_t offset) {
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(file.c_str(), O_RDONLY | O_CLOEXEC)));
+ if (fd == -1) {
+ return false;
+ }
+ struct stat buf;
+ if (fstat(fd, &buf) == -1) {
+ return false;
+ }
+ if (offset >= static_cast<uint64_t>(buf.st_size)) {
+ return false;
+ }
+
+ offset_ = offset & (getpagesize() - 1);
+ uint64_t aligned_offset = offset & ~(getpagesize() - 1);
+ size_ = buf.st_size - aligned_offset;
+ void* map = mmap(nullptr, size_, PROT_READ, MAP_PRIVATE, fd, aligned_offset);
+ if (map == MAP_FAILED) {
+ return false;
+ }
+
+ data_ = &reinterpret_cast<uint8_t*>(map)[offset_];
+ size_ -= offset_;
+
+ return true;
+}
+
+bool MemoryFileAtOffset::Read(uint64_t addr, void* dst, size_t size) {
+ if (addr + size > size_) {
+ return false;
+ }
+ memcpy(dst, &data_[addr], size);
+ return true;
+}
+
+static bool PtraceRead(pid_t pid, uint64_t addr, long* value) {
+ // ptrace() returns -1 and sets errno when the operation fails.
+ // To disambiguate -1 from a valid result, we clear errno beforehand.
+ errno = 0;
+ *value = ptrace(PTRACE_PEEKTEXT, pid, reinterpret_cast<void*>(addr), nullptr);
+ if (*value == -1 && errno) {
+ return false;
+ }
+ return true;
+}
+
+bool MemoryRemote::Read(uint64_t addr, void* dst, size_t bytes) {
+ size_t bytes_read = 0;
+ long data;
+ size_t align_bytes = addr & (sizeof(long) - 1);
+ if (align_bytes != 0) {
+ if (!PtraceRead(pid_, addr & ~(sizeof(long) - 1), &data)) {
+ return false;
+ }
+ size_t copy_bytes = std::min(sizeof(long) - align_bytes, bytes);
+ memcpy(dst, reinterpret_cast<uint8_t*>(&data) + align_bytes, copy_bytes);
+ addr += copy_bytes;
+ dst = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(dst) + copy_bytes);
+ bytes -= copy_bytes;
+ bytes_read += copy_bytes;
+ }
+
+ for (size_t i = 0; i < bytes / sizeof(long); i++) {
+ if (!PtraceRead(pid_, addr, &data)) {
+ return false;
+ }
+ memcpy(dst, &data, sizeof(long));
+ dst = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(dst) + sizeof(long));
+ addr += sizeof(long);
+ bytes_read += sizeof(long);
+ }
+
+ size_t left_over = bytes & (sizeof(long) - 1);
+ if (left_over) {
+ if (!PtraceRead(pid_, addr, &data)) {
+ return false;
+ }
+ memcpy(dst, &data, left_over);
+ bytes_read += left_over;
+ }
+ return true;
+}
+
+bool MemoryLocal::Read(uint64_t addr, void* dst, size_t size) {
+ // The process_vm_readv call does will not always work on remote
+ // processes, so only use it for reads from the current pid.
+ // Use this method to avoid crashes if an address is invalid since
+ // unwind data could try to access any part of the address space.
+ struct iovec local_io;
+ local_io.iov_base = dst;
+ local_io.iov_len = size;
+
+ struct iovec remote_io;
+ remote_io.iov_base = reinterpret_cast<void*>(static_cast<uintptr_t>(addr));
+ remote_io.iov_len = size;
+
+ ssize_t bytes_read = process_vm_readv(getpid(), &local_io, 1, &remote_io, 1, 0);
+ if (bytes_read == -1) {
+ return false;
+ }
+ return static_cast<size_t>(bytes_read) == size;
+}
+
+bool MemoryOffline::Init(const std::string& file, uint64_t offset) {
+ if (!MemoryFileAtOffset::Init(file, offset)) {
+ return false;
+ }
+ // The first uint64_t value is the start of memory.
+ if (!MemoryFileAtOffset::Read(0, &start_, sizeof(start_))) {
+ return false;
+ }
+ // Subtract the first 64 bit value from the total size.
+ size_ -= sizeof(start_);
+ return true;
+}
+
+bool MemoryOffline::Read(uint64_t addr, void* dst, size_t size) {
+ if (addr < start_ || addr + size > start_ + offset_ + size_) {
+ return false;
+ }
+ memcpy(dst, &data_[addr + offset_ - start_ + sizeof(start_)], size);
+ return true;
+}
diff --git a/libunwindstack/Memory.h b/libunwindstack/Memory.h
new file mode 100644
index 0000000..5ab031d
--- /dev/null
+++ b/libunwindstack/Memory.h
@@ -0,0 +1,121 @@
+/*
+ * 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.
+ */
+
+#ifndef _LIBUNWINDSTACK_MEMORY_H
+#define _LIBUNWINDSTACK_MEMORY_H
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+
+#include <android-base/unique_fd.h>
+
+constexpr bool kMemoryStatsEnabled = true;
+
+class Memory {
+ public:
+ Memory() = default;
+ virtual ~Memory() = default;
+
+ virtual bool ReadString(uint64_t addr, std::string* string, uint64_t max_read = UINT64_MAX);
+
+ virtual bool Read(uint64_t addr, void* dst, size_t size) = 0;
+
+ inline bool Read(uint64_t addr, void* start, void* field, size_t size) {
+ return Read(addr + reinterpret_cast<uintptr_t>(field) - reinterpret_cast<uintptr_t>(start),
+ field, size);
+ }
+
+ inline bool Read32(uint64_t addr, uint32_t* dst) {
+ return Read(addr, dst, sizeof(uint32_t));
+ }
+
+ inline bool Read64(uint64_t addr, uint64_t* dst) {
+ return Read(addr, dst, sizeof(uint64_t));
+ }
+};
+
+class MemoryFileAtOffset : public Memory {
+ public:
+ MemoryFileAtOffset() = default;
+ virtual ~MemoryFileAtOffset();
+
+ bool Init(const std::string& file, uint64_t offset);
+
+ bool Read(uint64_t addr, void* dst, size_t size) override;
+
+ protected:
+ size_t size_ = 0;
+ size_t offset_ = 0;
+ uint8_t* data_ = nullptr;
+};
+
+class MemoryOffline : public MemoryFileAtOffset {
+ public:
+ MemoryOffline() = default;
+ virtual ~MemoryOffline() = default;
+
+ bool Init(const std::string& file, uint64_t offset);
+
+ bool Read(uint64_t addr, void* dst, size_t size) override;
+
+ private:
+ uint64_t start_;
+};
+
+class MemoryRemote : public Memory {
+ public:
+ MemoryRemote(pid_t pid) : pid_(pid) {}
+ virtual ~MemoryRemote() = default;
+
+ bool Read(uint64_t addr, void* dst, size_t size) override;
+
+ pid_t pid() { return pid_; }
+
+ private:
+ pid_t pid_;
+};
+
+class MemoryLocal : public Memory {
+ public:
+ MemoryLocal() = default;
+ virtual ~MemoryLocal() = default;
+
+ bool Read(uint64_t addr, void* dst, size_t size) override;
+};
+
+class MemoryRange : public Memory {
+ public:
+ MemoryRange(Memory* memory, uint64_t begin, uint64_t end)
+ : memory_(memory), begin_(begin), length_(end - begin_) {}
+ virtual ~MemoryRange() { delete memory_; }
+
+ inline bool Read(uint64_t addr, void* dst, size_t size) override {
+ if (addr + size <= length_) {
+ return memory_->Read(addr + begin_, dst, size);
+ }
+ return false;
+ }
+
+ private:
+ Memory* memory_;
+ uint64_t begin_;
+ uint64_t length_;
+};
+
+#endif // _LIBUNWINDSTACK_MEMORY_H
diff --git a/libunwindstack/Regs.h b/libunwindstack/Regs.h
new file mode 100644
index 0000000..2766c6f
--- /dev/null
+++ b/libunwindstack/Regs.h
@@ -0,0 +1,77 @@
+/*
+ * 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.
+ */
+
+#ifndef _LIBUNWINDSTACK_REGS_H
+#define _LIBUNWINDSTACK_REGS_H
+
+#include <stdint.h>
+
+#include <vector>
+
+class Regs {
+ public:
+ Regs(uint16_t pc_reg, uint16_t sp_reg, uint16_t total_regs)
+ : pc_reg_(pc_reg), sp_reg_(sp_reg), total_regs_(total_regs) {
+ }
+ virtual ~Regs() = default;
+
+ uint16_t pc_reg() { return pc_reg_; }
+ uint16_t sp_reg() { return sp_reg_; }
+ uint16_t total_regs() { return total_regs_; }
+
+ virtual void* raw_data() = 0;
+ virtual uint64_t pc() = 0;
+ virtual uint64_t sp() = 0;
+
+ protected:
+ uint16_t pc_reg_;
+ uint16_t sp_reg_;
+ uint16_t total_regs_;
+};
+
+template <typename AddressType>
+class RegsTmpl : public Regs {
+ public:
+ RegsTmpl(uint16_t pc_reg, uint16_t sp_reg, uint16_t total_regs)
+ : Regs(pc_reg, sp_reg, total_regs), regs_(total_regs) {}
+ virtual ~RegsTmpl() = default;
+
+ uint64_t pc() override { return regs_[pc_reg_]; }
+ uint64_t sp() override { return regs_[sp_reg_]; }
+
+ inline AddressType& operator[](size_t reg) { return regs_[reg]; }
+
+ void* raw_data() override { return regs_.data(); }
+
+ private:
+ std::vector<AddressType> regs_;
+};
+
+class Regs32 : public RegsTmpl<uint32_t> {
+ public:
+ Regs32(uint16_t pc_reg, uint16_t sp_reg, uint16_t total_regs)
+ : RegsTmpl(pc_reg, sp_reg, total_regs) {}
+ virtual ~Regs32() = default;
+};
+
+class Regs64 : public RegsTmpl<uint64_t> {
+ public:
+ Regs64(uint16_t pc_reg, uint16_t sp_reg, uint16_t total_regs)
+ : RegsTmpl(pc_reg, sp_reg, total_regs) {}
+ virtual ~Regs64() = default;
+};
+
+#endif // _LIBUNWINDSTACK_REGS_H
diff --git a/libunwindstack/tests/ArmExidxDecodeTest.cpp b/libunwindstack/tests/ArmExidxDecodeTest.cpp
new file mode 100644
index 0000000..9ea917a
--- /dev/null
+++ b/libunwindstack/tests/ArmExidxDecodeTest.cpp
@@ -0,0 +1,992 @@
+/*
+ * 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 <stdint.h>
+
+#include <deque>
+#include <ios>
+#include <memory>
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include "ArmExidx.h"
+#include "Log.h"
+
+#include "LogFake.h"
+#include "MemoryFake.h"
+
+class ArmExidxDecodeTest : public ::testing::TestWithParam<std::string> {
+ protected:
+ void Init(Memory* process_memory = nullptr) {
+ TearDown();
+
+ if (process_memory == nullptr) {
+ process_memory = &process_memory_;
+ }
+
+ regs32_.reset(new Regs32(0, 1, 32));
+ for (size_t i = 0; i < 32; i++) {
+ (*regs32_)[i] = 0;
+ }
+
+ exidx_.reset(new ArmExidx(regs32_.get(), &elf_memory_, process_memory));
+ if (log_) {
+ exidx_->set_log(true);
+ exidx_->set_log_indent(0);
+ exidx_->set_log_skip_execution(false);
+ }
+ data_ = exidx_->data();
+ exidx_->set_cfa(0x10000);
+ }
+
+ void SetUp() override {
+ if (GetParam() != "no_logging") {
+ log_ = false;
+ } else {
+ log_ = true;
+ }
+ ResetLogs();
+ elf_memory_.Clear();
+ process_memory_.Clear();
+ Init();
+ }
+
+ std::unique_ptr<ArmExidx> exidx_;
+ std::unique_ptr<Regs32> regs32_;
+ std::deque<uint8_t>* data_;
+
+ MemoryFake elf_memory_;
+ MemoryFake process_memory_;
+ bool log_;
+};
+
+TEST_P(ArmExidxDecodeTest, vsp_incr) {
+ // 00xxxxxx: vsp = vsp + (xxxxxx << 2) + 4
+ data_->push_back(0x00);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp + 4\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10004U, exidx_->cfa());
+
+ ResetLogs();
+ data_->clear();
+ data_->push_back(0x01);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp + 8\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1000cU, exidx_->cfa());
+
+ ResetLogs();
+ data_->clear();
+ data_->push_back(0x3f);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp + 256\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1010cU, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, vsp_decr) {
+ // 01xxxxxx: vsp = vsp - (xxxxxx << 2) + 4
+ data_->push_back(0x40);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp - 4\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0xfffcU, exidx_->cfa());
+
+ ResetLogs();
+ data_->clear();
+ data_->push_back(0x41);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp - 8\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0xfff4U, exidx_->cfa());
+
+ ResetLogs();
+ data_->clear();
+ data_->push_back(0x7f);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp - 256\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0xfef4U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, refuse_unwind) {
+ // 10000000 00000000: Refuse to unwind
+ data_->push_back(0x80);
+ data_->push_back(0x00);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind Refuse to unwind\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(ARM_STATUS_NO_UNWIND, exidx_->status());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_up_to_12) {
+ // 1000iiii iiiiiiii: Pop up to 12 integer registers
+ data_->push_back(0x80);
+ data_->push_back(0x01);
+ process_memory_.SetData(0x10000, 0x10);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10004U, exidx_->cfa());
+ ASSERT_EQ(0x10U, (*exidx_->regs())[4]);
+
+ ResetLogs();
+ data_->push_back(0x8f);
+ data_->push_back(0xff);
+ for (size_t i = 0; i < 12; i++) {
+ process_memory_.SetData(0x10004 + i * 4, i + 0x20);
+ }
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4, r5, r6, r7, r8, r9, r10, r11, r12, r13, r14, r15}\n",
+ GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ // Popping r13 results in a modified cfa.
+ ASSERT_EQ(0x29U, exidx_->cfa());
+
+ ASSERT_EQ(0x20U, (*exidx_->regs())[4]);
+ ASSERT_EQ(0x21U, (*exidx_->regs())[5]);
+ ASSERT_EQ(0x22U, (*exidx_->regs())[6]);
+ ASSERT_EQ(0x23U, (*exidx_->regs())[7]);
+ ASSERT_EQ(0x24U, (*exidx_->regs())[8]);
+ ASSERT_EQ(0x25U, (*exidx_->regs())[9]);
+ ASSERT_EQ(0x26U, (*exidx_->regs())[10]);
+ ASSERT_EQ(0x27U, (*exidx_->regs())[11]);
+ ASSERT_EQ(0x28U, (*exidx_->regs())[12]);
+ ASSERT_EQ(0x29U, (*exidx_->regs())[13]);
+ ASSERT_EQ(0x2aU, (*exidx_->regs())[14]);
+ ASSERT_EQ(0x2bU, (*exidx_->regs())[15]);
+
+ ResetLogs();
+ exidx_->set_cfa(0x10034);
+ data_->push_back(0x81);
+ data_->push_back(0x28);
+ process_memory_.SetData(0x10034, 0x11);
+ process_memory_.SetData(0x10038, 0x22);
+ process_memory_.SetData(0x1003c, 0x33);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r7, r9, r12}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10040U, exidx_->cfa());
+ ASSERT_EQ(0x11U, (*exidx_->regs())[7]);
+ ASSERT_EQ(0x22U, (*exidx_->regs())[9]);
+ ASSERT_EQ(0x33U, (*exidx_->regs())[12]);
+}
+
+TEST_P(ArmExidxDecodeTest, set_vsp_from_register) {
+ // 1001nnnn: Set vsp = r[nnnn] (nnnn != 13, 15)
+ exidx_->set_cfa(0x100);
+ for (size_t i = 0; i < 15; i++) {
+ (*regs32_)[i] = i + 1;
+ }
+
+ data_->push_back(0x90);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = r0\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(1U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0x93);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = r3\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(4U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0x9e);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = r14\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(15U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, reserved_prefix) {
+ // 10011101: Reserved as prefix for ARM register to register moves
+ data_->push_back(0x9d);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind [Reserved]\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(ARM_STATUS_RESERVED, exidx_->status());
+
+ // 10011111: Reserved as prefix for Intel Wireless MMX register to register moves
+ ResetLogs();
+ data_->push_back(0x9f);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind [Reserved]\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(ARM_STATUS_RESERVED, exidx_->status());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_registers) {
+ // 10100nnn: Pop r4-r[4+nnn]
+ data_->push_back(0xa0);
+ process_memory_.SetData(0x10000, 0x14);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10004U, exidx_->cfa());
+ ASSERT_EQ(0x14U, (*exidx_->regs())[4]);
+
+ ResetLogs();
+ data_->push_back(0xa3);
+ process_memory_.SetData(0x10004, 0x20);
+ process_memory_.SetData(0x10008, 0x30);
+ process_memory_.SetData(0x1000c, 0x40);
+ process_memory_.SetData(0x10010, 0x50);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4-r7}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10014U, exidx_->cfa());
+ ASSERT_EQ(0x20U, (*exidx_->regs())[4]);
+ ASSERT_EQ(0x30U, (*exidx_->regs())[5]);
+ ASSERT_EQ(0x40U, (*exidx_->regs())[6]);
+ ASSERT_EQ(0x50U, (*exidx_->regs())[7]);
+
+ ResetLogs();
+ data_->push_back(0xa7);
+ process_memory_.SetData(0x10014, 0x41);
+ process_memory_.SetData(0x10018, 0x51);
+ process_memory_.SetData(0x1001c, 0x61);
+ process_memory_.SetData(0x10020, 0x71);
+ process_memory_.SetData(0x10024, 0x81);
+ process_memory_.SetData(0x10028, 0x91);
+ process_memory_.SetData(0x1002c, 0xa1);
+ process_memory_.SetData(0x10030, 0xb1);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4-r11}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10034U, exidx_->cfa());
+ ASSERT_EQ(0x41U, (*exidx_->regs())[4]);
+ ASSERT_EQ(0x51U, (*exidx_->regs())[5]);
+ ASSERT_EQ(0x61U, (*exidx_->regs())[6]);
+ ASSERT_EQ(0x71U, (*exidx_->regs())[7]);
+ ASSERT_EQ(0x81U, (*exidx_->regs())[8]);
+ ASSERT_EQ(0x91U, (*exidx_->regs())[9]);
+ ASSERT_EQ(0xa1U, (*exidx_->regs())[10]);
+ ASSERT_EQ(0xb1U, (*exidx_->regs())[11]);
+}
+
+TEST_P(ArmExidxDecodeTest, pop_registers_with_r14) {
+ // 10101nnn: Pop r4-r[4+nnn], r14
+ data_->push_back(0xa8);
+ process_memory_.SetData(0x10000, 0x12);
+ process_memory_.SetData(0x10004, 0x22);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4, r14}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10008U, exidx_->cfa());
+ ASSERT_EQ(0x12U, (*exidx_->regs())[4]);
+ ASSERT_EQ(0x22U, (*exidx_->regs())[14]);
+
+ ResetLogs();
+ data_->push_back(0xab);
+ process_memory_.SetData(0x10008, 0x1);
+ process_memory_.SetData(0x1000c, 0x2);
+ process_memory_.SetData(0x10010, 0x3);
+ process_memory_.SetData(0x10014, 0x4);
+ process_memory_.SetData(0x10018, 0x5);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4-r7, r14}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1001cU, exidx_->cfa());
+ ASSERT_EQ(0x1U, (*exidx_->regs())[4]);
+ ASSERT_EQ(0x2U, (*exidx_->regs())[5]);
+ ASSERT_EQ(0x3U, (*exidx_->regs())[6]);
+ ASSERT_EQ(0x4U, (*exidx_->regs())[7]);
+ ASSERT_EQ(0x5U, (*exidx_->regs())[14]);
+
+ ResetLogs();
+ data_->push_back(0xaf);
+ process_memory_.SetData(0x1001c, 0x1a);
+ process_memory_.SetData(0x10020, 0x2a);
+ process_memory_.SetData(0x10024, 0x3a);
+ process_memory_.SetData(0x10028, 0x4a);
+ process_memory_.SetData(0x1002c, 0x5a);
+ process_memory_.SetData(0x10030, 0x6a);
+ process_memory_.SetData(0x10034, 0x7a);
+ process_memory_.SetData(0x10038, 0x8a);
+ process_memory_.SetData(0x1003c, 0x9a);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r4-r11, r14}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10040U, exidx_->cfa());
+ ASSERT_EQ(0x1aU, (*exidx_->regs())[4]);
+ ASSERT_EQ(0x2aU, (*exidx_->regs())[5]);
+ ASSERT_EQ(0x3aU, (*exidx_->regs())[6]);
+ ASSERT_EQ(0x4aU, (*exidx_->regs())[7]);
+ ASSERT_EQ(0x5aU, (*exidx_->regs())[8]);
+ ASSERT_EQ(0x6aU, (*exidx_->regs())[9]);
+ ASSERT_EQ(0x7aU, (*exidx_->regs())[10]);
+ ASSERT_EQ(0x8aU, (*exidx_->regs())[11]);
+ ASSERT_EQ(0x9aU, (*exidx_->regs())[14]);
+}
+
+TEST_P(ArmExidxDecodeTest, finish) {
+ // 10110000: Finish
+ data_->push_back(0xb0);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind finish\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa());
+ ASSERT_EQ(ARM_STATUS_FINISH, exidx_->status());
+}
+
+TEST_P(ArmExidxDecodeTest, spare) {
+ // 10110001 00000000: Spare
+ data_->push_back(0xb1);
+ data_->push_back(0x00);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa());
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+
+ // 10110001 xxxxyyyy: Spare (xxxx != 0000)
+ for (size_t x = 1; x < 16; x++) {
+ for (size_t y = 0; y < 16; y++) {
+ ResetLogs();
+ data_->push_back(0xb1);
+ data_->push_back((x << 4) | y);
+ ASSERT_FALSE(exidx_->Decode()) << "x, y = " << x << ", " << y;
+ ASSERT_EQ("", GetFakeLogBuf()) << "x, y = " << x << ", " << y;
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint()) << "x, y = " << x << ", " << y;
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa()) << "x, y = " << x << ", " << y;
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+ }
+ }
+
+ // 101101nn: Spare
+ for (size_t n = 0; n < 4; n++) {
+ ResetLogs();
+ data_->push_back(0xb4 | n);
+ ASSERT_FALSE(exidx_->Decode()) << "n = " << n;
+ ASSERT_EQ("", GetFakeLogBuf()) << "n = " << n;
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint()) << "n = " << n;
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa()) << "n = " << n;
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+ }
+
+ // 11000111 00000000: Spare
+ ResetLogs();
+ data_->push_back(0xc7);
+ data_->push_back(0x00);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa());
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+
+ // 11000111 xxxxyyyy: Spare (xxxx != 0000)
+ for (size_t x = 1; x < 16; x++) {
+ for (size_t y = 0; y < 16; y++) {
+ ResetLogs();
+ data_->push_back(0xc7);
+ data_->push_back(0x10);
+ ASSERT_FALSE(exidx_->Decode()) << "x, y = " << x << ", " << y;
+ ASSERT_EQ("", GetFakeLogBuf()) << "x, y = " << x << ", " << y;
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint()) << "x, y = " << x << ", " << y;
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa()) << "x, y = " << x << ", " << y;
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+ }
+ }
+
+ // 11001yyy: Spare (yyy != 000, 001)
+ for (size_t y = 2; y < 8; y++) {
+ ResetLogs();
+ data_->push_back(0xc8 | y);
+ ASSERT_FALSE(exidx_->Decode()) << "y = " << y;
+ ASSERT_EQ("", GetFakeLogBuf()) << "y = " << y;
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint()) << "y = " << y;
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa()) << "y = " << y;
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+ }
+
+ // 11xxxyyy: Spare (xxx != 000, 001, 010)
+ for (size_t x = 3; x < 8; x++) {
+ for (size_t y = 0; y < 8; y++) {
+ ResetLogs();
+ data_->push_back(0xc0 | (x << 3) | y);
+ ASSERT_FALSE(exidx_->Decode()) << "x, y = " << x << ", " << y;
+ ASSERT_EQ("", GetFakeLogBuf()) << "x, y = " << x << ", " << y;
+ if (log_) {
+ ASSERT_EQ("4 unwind Spare\n", GetFakeLogPrint()) << "x, y = " << x << ", " << y;
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10000U, exidx_->cfa()) << "x, y = " << x << ", " << y;
+ ASSERT_EQ(ARM_STATUS_SPARE, exidx_->status());
+ }
+ }
+}
+
+TEST_P(ArmExidxDecodeTest, pop_registers_under_mask) {
+ // 10110001 0000iiii: Pop integer registers {r0, r1, r2, r3}
+ data_->push_back(0xb1);
+ data_->push_back(0x01);
+ process_memory_.SetData(0x10000, 0x45);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r0}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10004U, exidx_->cfa());
+ ASSERT_EQ(0x45U, (*exidx_->regs())[0]);
+
+ ResetLogs();
+ data_->push_back(0xb1);
+ data_->push_back(0x0a);
+ process_memory_.SetData(0x10004, 0x23);
+ process_memory_.SetData(0x10008, 0x24);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r1, r3}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1000cU, exidx_->cfa());
+ ASSERT_EQ(0x23U, (*exidx_->regs())[1]);
+ ASSERT_EQ(0x24U, (*exidx_->regs())[3]);
+
+ ResetLogs();
+ data_->push_back(0xb1);
+ data_->push_back(0x0f);
+ process_memory_.SetData(0x1000c, 0x65);
+ process_memory_.SetData(0x10010, 0x54);
+ process_memory_.SetData(0x10014, 0x43);
+ process_memory_.SetData(0x10018, 0x32);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {r0, r1, r2, r3}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1001cU, exidx_->cfa());
+ ASSERT_EQ(0x65U, (*exidx_->regs())[0]);
+ ASSERT_EQ(0x54U, (*exidx_->regs())[1]);
+ ASSERT_EQ(0x43U, (*exidx_->regs())[2]);
+ ASSERT_EQ(0x32U, (*exidx_->regs())[3]);
+}
+
+TEST_P(ArmExidxDecodeTest, vsp_large_incr) {
+ // 10110010 uleb128: vsp = vsp + 0x204 + (uleb128 << 2)
+ data_->push_back(0xb2);
+ data_->push_back(0x7f);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp + 1024\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10400U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xb2);
+ data_->push_back(0xff);
+ data_->push_back(0x02);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp + 2048\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10c00U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xb2);
+ data_->push_back(0xff);
+ data_->push_back(0x82);
+ data_->push_back(0x30);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind vsp = vsp + 3147776\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x311400U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_vfp_fstmfdx) {
+ // 10110011 sssscccc: Pop VFP double precision registers D[ssss]-D[ssss+cccc] by FSTMFDX
+ data_->push_back(0xb3);
+ data_->push_back(0x00);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d0}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1000cU, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xb3);
+ data_->push_back(0x48);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d4-d12}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10058U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_vfp8_fstmfdx) {
+ // 10111nnn: Pop VFP double precision registers D[8]-D[8+nnn] by FSTMFDX
+ data_->push_back(0xb8);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d8}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1000cU, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xbb);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d8-d11}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10030U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xbf);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d8-d15}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10074U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_mmx_wr10) {
+ // 11000nnn: Intel Wireless MMX pop wR[10]-wR[10+nnn] (nnn != 6, 7)
+ data_->push_back(0xc0);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wR10}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10008U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc2);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wR10-wR12}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10020U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc5);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wR10-wR15}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10050U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_mmx_wr) {
+ // 11000110 sssscccc: Intel Wireless MMX pop wR[ssss]-wR[ssss+cccc]
+ data_->push_back(0xc6);
+ data_->push_back(0x00);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wR0}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10008U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc6);
+ data_->push_back(0x25);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wR2-wR7}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10038U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc6);
+ data_->push_back(0xff);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wR15-wR30}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x100b8U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_mmx_wcgr) {
+ // 11000111 0000iiii: Intel Wireless MMX pop wCGR registes {wCGR0,1,2,3}
+ data_->push_back(0xc7);
+ data_->push_back(0x01);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wCGR0}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10004U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc7);
+ data_->push_back(0x0a);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wCGR1, wCGR3}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1000cU, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc7);
+ data_->push_back(0x0f);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {wCGR0, wCGR1, wCGR2, wCGR3}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x1001cU, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_vfp16_vpush) {
+ // 11001000 sssscccc: Pop VFP double precision registers d[16+ssss]-D[16+ssss+cccc] by VPUSH
+ data_->push_back(0xc8);
+ data_->push_back(0x00);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d16}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10008U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc8);
+ data_->push_back(0x14);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d17-d21}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10030U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc8);
+ data_->push_back(0xff);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d31-d46}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x100b0U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_vfp_vpush) {
+ // 11001001 sssscccc: Pop VFP double precision registers d[ssss]-D[ssss+cccc] by VPUSH
+ data_->push_back(0xc9);
+ data_->push_back(0x00);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d0}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10008U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc9);
+ data_->push_back(0x23);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d2-d5}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10028U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xc9);
+ data_->push_back(0xff);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d15-d30}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x100a8U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, pop_vfp8_vpush) {
+ // 11010nnn: Pop VFP double precision registers D[8]-D[8+nnn] by VPUSH
+ data_->push_back(0xd0);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d8}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10008U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xd2);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d8-d10}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10020U, exidx_->cfa());
+
+ ResetLogs();
+ data_->push_back(0xd7);
+ ASSERT_TRUE(exidx_->Decode());
+ ASSERT_EQ("", GetFakeLogBuf());
+ if (log_) {
+ ASSERT_EQ("4 unwind pop {d8-d15}\n", GetFakeLogPrint());
+ } else {
+ ASSERT_EQ("", GetFakeLogPrint());
+ }
+ ASSERT_EQ(0x10060U, exidx_->cfa());
+}
+
+TEST_P(ArmExidxDecodeTest, expect_truncated) {
+ // This test verifies that any op that requires extra ops will
+ // fail if the data is not present.
+ data_->push_back(0x80);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xb1);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xb2);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xb3);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xc6);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xc7);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xc8);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+
+ data_->clear();
+ data_->push_back(0xc9);
+ ASSERT_FALSE(exidx_->Decode());
+ ASSERT_EQ(ARM_STATUS_TRUNCATED, exidx_->status());
+}
+
+TEST_P(ArmExidxDecodeTest, verify_no_truncated) {
+ // This test verifies that no pattern results in a crash or truncation.
+ MemoryFakeAlwaysReadZero memory_zero;
+ Init(&memory_zero);
+
+ for (size_t x = 0; x < 256; x++) {
+ if (x == 0xb2) {
+ // This opcode is followed by an uleb128, so just skip this one.
+ continue;
+ }
+ for (size_t y = 0; y < 256; y++) {
+ data_->clear();
+ data_->push_back(x);
+ data_->push_back(y);
+ if (!exidx_->Decode()) {
+ ASSERT_NE(ARM_STATUS_TRUNCATED, exidx_->status())
+ << "x y = 0x" << std::hex << x << " 0x" << y;
+ ASSERT_NE(ARM_STATUS_READ_FAILED, exidx_->status())
+ << "x y = 0x" << std::hex << x << " 0x" << y;
+ }
+ }
+ }
+}
+
+INSTANTIATE_TEST_CASE_P(, ArmExidxDecodeTest, ::testing::Values("logging", "no_logging"));
diff --git a/libunwindstack/tests/ArmExidxExtractTest.cpp b/libunwindstack/tests/ArmExidxExtractTest.cpp
new file mode 100644
index 0000000..021765a
--- /dev/null
+++ b/libunwindstack/tests/ArmExidxExtractTest.cpp
@@ -0,0 +1,331 @@
+/*
+ * 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 <stdint.h>
+
+#include <deque>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "ArmExidx.h"
+#include "Log.h"
+
+#include "LogFake.h"
+#include "MemoryFake.h"
+
+class ArmExidxExtractTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ ResetLogs();
+ elf_memory_.Clear();
+ exidx_ = new ArmExidx(nullptr, &elf_memory_, nullptr);
+ data_ = exidx_->data();
+ data_->clear();
+ }
+
+ void TearDown() override {
+ delete exidx_;
+ }
+
+ ArmExidx* exidx_ = nullptr;
+ std::deque<uint8_t>* data_;
+ MemoryFake elf_memory_;
+};
+
+TEST_F(ArmExidxExtractTest, bad_alignment) {
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x1001));
+ ASSERT_EQ(ARM_STATUS_INVALID_ALIGNMENT, exidx_->status());
+ ASSERT_TRUE(data_->empty());
+}
+
+TEST_F(ArmExidxExtractTest, cant_unwind) {
+ elf_memory_.SetData(0x1000, 0x7fff2340);
+ elf_memory_.SetData(0x1004, 1);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x1000));
+ ASSERT_EQ(ARM_STATUS_NO_UNWIND, exidx_->status());
+ ASSERT_TRUE(data_->empty());
+}
+
+TEST_F(ArmExidxExtractTest, compact) {
+ elf_memory_.SetData(0x4000, 0x7ffa3000);
+ elf_memory_.SetData(0x4004, 0x80a8b0b0);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x4000));
+ ASSERT_EQ(3U, data_->size());
+ ASSERT_EQ(0xa8, data_->at(0));
+ ASSERT_EQ(0xb0, data_->at(1));
+ ASSERT_EQ(0xb0, data_->at(2));
+
+ // Missing finish gets added.
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x534, 0x7ffa3000);
+ elf_memory_.SetData(0x538, 0x80a1a2a3);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x534));
+ ASSERT_EQ(4U, data_->size());
+ ASSERT_EQ(0xa1, data_->at(0));
+ ASSERT_EQ(0xa2, data_->at(1));
+ ASSERT_EQ(0xa3, data_->at(2));
+ ASSERT_EQ(0xb0, data_->at(3));
+}
+
+TEST_F(ArmExidxExtractTest, compact_non_zero_personality) {
+ elf_memory_.SetData(0x4000, 0x7ffa3000);
+
+ uint32_t compact_value = 0x80a8b0b0;
+ for (size_t i = 1; i < 16; i++) {
+ elf_memory_.SetData(0x4004, compact_value | (i << 24));
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x4000));
+ ASSERT_EQ(ARM_STATUS_INVALID_PERSONALITY, exidx_->status());
+ }
+}
+
+TEST_F(ArmExidxExtractTest, second_read_compact_personality_1_2) {
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x8100f3b0);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(2U, data_->size());
+ ASSERT_EQ(0xf3, data_->at(0));
+ ASSERT_EQ(0xb0, data_->at(1));
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x8200f3f4);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(3U, data_->size());
+ ASSERT_EQ(0xf3, data_->at(0));
+ ASSERT_EQ(0xf4, data_->at(1));
+ ASSERT_EQ(0xb0, data_->at(2));
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x8201f3f4);
+ elf_memory_.SetData(0x6238, 0x102030b0);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(6U, data_->size());
+ ASSERT_EQ(0xf3, data_->at(0));
+ ASSERT_EQ(0xf4, data_->at(1));
+ ASSERT_EQ(0x10, data_->at(2));
+ ASSERT_EQ(0x20, data_->at(3));
+ ASSERT_EQ(0x30, data_->at(4));
+ ASSERT_EQ(0xb0, data_->at(5));
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x8103f3f4);
+ elf_memory_.SetData(0x6238, 0x10203040);
+ elf_memory_.SetData(0x623c, 0x50607080);
+ elf_memory_.SetData(0x6240, 0x90a0c0d0);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(15U, data_->size());
+ ASSERT_EQ(0xf3, data_->at(0));
+ ASSERT_EQ(0xf4, data_->at(1));
+ ASSERT_EQ(0x10, data_->at(2));
+ ASSERT_EQ(0x20, data_->at(3));
+ ASSERT_EQ(0x30, data_->at(4));
+ ASSERT_EQ(0x40, data_->at(5));
+ ASSERT_EQ(0x50, data_->at(6));
+ ASSERT_EQ(0x60, data_->at(7));
+ ASSERT_EQ(0x70, data_->at(8));
+ ASSERT_EQ(0x80, data_->at(9));
+ ASSERT_EQ(0x90, data_->at(10));
+ ASSERT_EQ(0xa0, data_->at(11));
+ ASSERT_EQ(0xc0, data_->at(12));
+ ASSERT_EQ(0xd0, data_->at(13));
+ ASSERT_EQ(0xb0, data_->at(14));
+}
+
+TEST_F(ArmExidxExtractTest, second_read_compact_personality_illegal) {
+ elf_memory_.SetData(0x5000, 0x7ffa1e48);
+ elf_memory_.SetData(0x5004, 0x1230);
+ elf_memory_.SetData(0x6234, 0x832132b0);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_INVALID_PERSONALITY, exidx_->status());
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x7ffa1e48);
+ elf_memory_.SetData(0x5004, 0x1230);
+ elf_memory_.SetData(0x6234, 0x842132b0);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_INVALID_PERSONALITY, exidx_->status());
+}
+
+TEST_F(ArmExidxExtractTest, second_read_offset_is_negative) {
+ elf_memory_.SetData(0x5000, 0x7ffa1e48);
+ elf_memory_.SetData(0x5004, 0x7fffb1e0);
+ elf_memory_.SetData(0x1e4, 0x842132b0);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_INVALID_PERSONALITY, exidx_->status());
+}
+
+TEST_F(ArmExidxExtractTest, second_read_not_compact) {
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x1);
+ elf_memory_.SetData(0x6238, 0x001122b0);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(3U, data_->size());
+ ASSERT_EQ(0x11, data_->at(0));
+ ASSERT_EQ(0x22, data_->at(1));
+ ASSERT_EQ(0xb0, data_->at(2));
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x2);
+ elf_memory_.SetData(0x6238, 0x00112233);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(4U, data_->size());
+ ASSERT_EQ(0x11, data_->at(0));
+ ASSERT_EQ(0x22, data_->at(1));
+ ASSERT_EQ(0x33, data_->at(2));
+ ASSERT_EQ(0xb0, data_->at(3));
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x3);
+ elf_memory_.SetData(0x6238, 0x01112233);
+ elf_memory_.SetData(0x623c, 0x445566b0);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(7U, data_->size());
+ ASSERT_EQ(0x11, data_->at(0));
+ ASSERT_EQ(0x22, data_->at(1));
+ ASSERT_EQ(0x33, data_->at(2));
+ ASSERT_EQ(0x44, data_->at(3));
+ ASSERT_EQ(0x55, data_->at(4));
+ ASSERT_EQ(0x66, data_->at(5));
+ ASSERT_EQ(0xb0, data_->at(6));
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x3);
+ elf_memory_.SetData(0x6238, 0x05112233);
+ elf_memory_.SetData(0x623c, 0x01020304);
+ elf_memory_.SetData(0x6240, 0x05060708);
+ elf_memory_.SetData(0x6244, 0x090a0b0c);
+ elf_memory_.SetData(0x6248, 0x0d0e0f10);
+ elf_memory_.SetData(0x624c, 0x11121314);
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(24U, data_->size());
+ ASSERT_EQ(0x11, data_->at(0));
+ ASSERT_EQ(0x22, data_->at(1));
+ ASSERT_EQ(0x33, data_->at(2));
+ ASSERT_EQ(0x01, data_->at(3));
+ ASSERT_EQ(0x02, data_->at(4));
+ ASSERT_EQ(0x03, data_->at(5));
+ ASSERT_EQ(0x04, data_->at(6));
+ ASSERT_EQ(0x05, data_->at(7));
+ ASSERT_EQ(0x06, data_->at(8));
+ ASSERT_EQ(0x07, data_->at(9));
+ ASSERT_EQ(0x08, data_->at(10));
+ ASSERT_EQ(0x09, data_->at(11));
+ ASSERT_EQ(0x0a, data_->at(12));
+ ASSERT_EQ(0x0b, data_->at(13));
+ ASSERT_EQ(0x0c, data_->at(14));
+ ASSERT_EQ(0x0d, data_->at(15));
+ ASSERT_EQ(0x0e, data_->at(16));
+ ASSERT_EQ(0x0f, data_->at(17));
+ ASSERT_EQ(0x10, data_->at(18));
+ ASSERT_EQ(0x11, data_->at(19));
+ ASSERT_EQ(0x12, data_->at(20));
+ ASSERT_EQ(0x13, data_->at(21));
+ ASSERT_EQ(0x14, data_->at(22));
+ ASSERT_EQ(0xb0, data_->at(23));
+}
+
+TEST_F(ArmExidxExtractTest, read_failures) {
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_READ_FAILED, exidx_->status());
+
+ elf_memory_.SetData(0x5000, 0x100);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_READ_FAILED, exidx_->status());
+
+ elf_memory_.SetData(0x5004, 0x100);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_READ_FAILED, exidx_->status());
+
+ elf_memory_.SetData(0x5104, 0x1);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_READ_FAILED, exidx_->status());
+
+ elf_memory_.SetData(0x5108, 0x01010203);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_READ_FAILED, exidx_->status());
+}
+
+TEST_F(ArmExidxExtractTest, malformed) {
+ elf_memory_.SetData(0x5000, 0x100);
+ elf_memory_.SetData(0x5004, 0x100);
+ elf_memory_.SetData(0x5104, 0x1);
+ elf_memory_.SetData(0x5108, 0x06010203);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_MALFORMED, exidx_->status());
+
+ elf_memory_.Clear();
+ elf_memory_.SetData(0x5000, 0x100);
+ elf_memory_.SetData(0x5004, 0x100);
+ elf_memory_.SetData(0x5104, 0x1);
+ elf_memory_.SetData(0x5108, 0x81060203);
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ(ARM_STATUS_MALFORMED, exidx_->status());
+}
+
+TEST_F(ArmExidxExtractTest, cant_unwind_log) {
+ elf_memory_.SetData(0x1000, 0x7fff2340);
+ elf_memory_.SetData(0x1004, 1);
+
+ exidx_->set_log(true);
+ exidx_->set_log_indent(0);
+ exidx_->set_log_skip_execution(false);
+
+ ASSERT_FALSE(exidx_->ExtractEntryData(0x1000));
+ ASSERT_EQ(ARM_STATUS_NO_UNWIND, exidx_->status());
+
+ ASSERT_EQ("4 unwind Raw Data: 0x00 0x00 0x00 0x01\n"
+ "4 unwind [cantunwind]\n", GetFakeLogPrint());
+}
+
+TEST_F(ArmExidxExtractTest, raw_data_compact) {
+ elf_memory_.SetData(0x4000, 0x7ffa3000);
+ elf_memory_.SetData(0x4004, 0x80a8b0b0);
+
+ exidx_->set_log(true);
+ exidx_->set_log_indent(0);
+ exidx_->set_log_skip_execution(false);
+
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x4000));
+ ASSERT_EQ("4 unwind Raw Data: 0xa8 0xb0 0xb0\n", GetFakeLogPrint());
+}
+
+TEST_F(ArmExidxExtractTest, raw_data_non_compact) {
+ elf_memory_.SetData(0x5000, 0x1234);
+ elf_memory_.SetData(0x5004, 0x00001230);
+ elf_memory_.SetData(0x6234, 0x2);
+ elf_memory_.SetData(0x6238, 0x00112233);
+
+ exidx_->set_log(true);
+ exidx_->set_log_indent(0);
+ exidx_->set_log_skip_execution(false);
+
+ ASSERT_TRUE(exidx_->ExtractEntryData(0x5000));
+ ASSERT_EQ("4 unwind Raw Data: 0x11 0x22 0x33 0xb0\n", GetFakeLogPrint());
+}
diff --git a/libunwindstack/tests/LogFake.cpp b/libunwindstack/tests/LogFake.cpp
new file mode 100644
index 0000000..411594a
--- /dev/null
+++ b/libunwindstack/tests/LogFake.cpp
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2015 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 <errno.h>
+#include <stdarg.h>
+
+#include <string>
+
+#include <android-base/stringprintf.h>
+#include <log/log.h>
+
+#include "LogFake.h"
+
+// Forward declarations.
+class Backtrace;
+struct EventTagMap;
+struct AndroidLogEntry;
+
+std::string g_fake_log_buf;
+
+std::string g_fake_log_print;
+
+void ResetLogs() {
+ g_fake_log_buf = "";
+ g_fake_log_print = "";
+}
+
+std::string GetFakeLogBuf() {
+ return g_fake_log_buf;
+}
+
+std::string GetFakeLogPrint() {
+ return g_fake_log_print;
+}
+
+extern "C" int __android_log_buf_write(int bufId, int prio, const char* tag, const char* msg) {
+ g_fake_log_buf += std::to_string(bufId) + ' ' + std::to_string(prio) + ' ';
+ g_fake_log_buf += tag;
+ g_fake_log_buf += ' ';
+ g_fake_log_buf += msg;
+ return 1;
+}
+
+extern "C" int __android_log_print(int prio, const char* tag, const char* fmt, ...) {
+ va_list ap;
+ va_start(ap, fmt);
+ int val = __android_log_vprint(prio, tag, fmt, ap);
+ va_end(ap);
+
+ return val;
+}
+
+extern "C" int __android_log_vprint(int prio, const char* tag, const char* fmt, va_list ap) {
+ g_fake_log_print += std::to_string(prio) + ' ';
+ g_fake_log_print += tag;
+ g_fake_log_print += ' ';
+
+ android::base::StringAppendV(&g_fake_log_print, fmt, ap);
+
+ g_fake_log_print += '\n';
+
+ return 1;
+}
+
+extern "C" log_id_t android_name_to_log_id(const char*) {
+ return LOG_ID_SYSTEM;
+}
+
+extern "C" struct logger_list* android_logger_list_open(log_id_t, int, unsigned int, pid_t) {
+ errno = EACCES;
+ return nullptr;
+}
+
+extern "C" int android_logger_list_read(struct logger_list*, struct log_msg*) {
+ return 0;
+}
+
+extern "C" EventTagMap* android_openEventTagMap(const char*) {
+ return nullptr;
+}
+
+extern "C" int android_log_processBinaryLogBuffer(
+ struct logger_entry*,
+ AndroidLogEntry*, const EventTagMap*, char*, int) {
+ return 0;
+}
+
+extern "C" void android_logger_list_free(struct logger_list*) {
+}
diff --git a/init/seccomp.h b/libunwindstack/tests/LogFake.h
similarity index 66%
copy from init/seccomp.h
copy to libunwindstack/tests/LogFake.h
index cda7a89..006d393 100644
--- a/init/seccomp.h
+++ b/libunwindstack/tests/LogFake.h
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2016 The Android Open Source Project
+ * Copyright (C) 2015 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.
@@ -14,9 +14,13 @@
* limitations under the License.
*/
-#ifndef SECCOMP_H
-#define SECCOMP_H
+#ifndef _LIBUNWINDSTACK_TESTS_LOG_FAKE_H
+#define _LIBUNWINDSTACK_TESTS_LOG_FAKE_H
-bool set_seccomp_filter();
+#include <string>
-#endif
+void ResetLogs();
+std::string GetFakeLogBuf();
+std::string GetFakeLogPrint();
+
+#endif // _LIBUNWINDSTACK_TESTS_LOG_FAKE_H
diff --git a/libunwindstack/tests/MapsTest.cpp b/libunwindstack/tests/MapsTest.cpp
new file mode 100644
index 0000000..216873f
--- /dev/null
+++ b/libunwindstack/tests/MapsTest.cpp
@@ -0,0 +1,219 @@
+/*
+ * 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 <sys/mman.h>
+
+#include <android-base/file.h>
+#include <android-base/test_utils.h>
+#include <gtest/gtest.h>
+
+#include "Maps.h"
+
+#include "LogFake.h"
+
+class MapsTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ ResetLogs();
+ }
+};
+
+TEST_F(MapsTest, parse_permissions) {
+ MapsBuffer maps("1000-2000 ---- 00000000 00:00 0\n"
+ "2000-3000 r--- 00000000 00:00 0\n"
+ "3000-4000 -w-- 00000000 00:00 0\n"
+ "4000-5000 --x- 00000000 00:00 0\n"
+ "5000-6000 rwx- 00000000 00:00 0\n");
+
+ ASSERT_TRUE(maps.Parse());
+ ASSERT_EQ(5U, maps.Total());
+ auto it = maps.begin();
+ ASSERT_EQ(PROT_NONE, it->flags);
+ ASSERT_EQ(0x1000U, it->start);
+ ASSERT_EQ(0x2000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ("", it->name);
+ ++it;
+ ASSERT_EQ(PROT_READ, it->flags);
+ ASSERT_EQ(0x2000U, it->start);
+ ASSERT_EQ(0x3000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ("", it->name);
+ ++it;
+ ASSERT_EQ(PROT_WRITE, it->flags);
+ ASSERT_EQ(0x3000U, it->start);
+ ASSERT_EQ(0x4000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ("", it->name);
+ ++it;
+ ASSERT_EQ(PROT_EXEC, it->flags);
+ ASSERT_EQ(0x4000U, it->start);
+ ASSERT_EQ(0x5000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ("", it->name);
+ ++it;
+ ASSERT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, it->flags);
+ ASSERT_EQ(0x5000U, it->start);
+ ASSERT_EQ(0x6000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ("", it->name);
+ ++it;
+ ASSERT_EQ(it, maps.end());
+}
+
+TEST_F(MapsTest, parse_name) {
+ MapsBuffer maps("720b29b000-720b29e000 rw-p 00000000 00:00 0\n"
+ "720b29e000-720b29f000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
+ "720b29f000-720b2a0000 rw-p 00000000 00:00 0");
+
+ ASSERT_TRUE(maps.Parse());
+ ASSERT_EQ(3U, maps.Total());
+ auto it = maps.begin();
+ ASSERT_EQ("", it->name);
+ ASSERT_EQ(0x720b29b000U, it->start);
+ ASSERT_EQ(0x720b29e000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
+ ++it;
+ ASSERT_EQ("/system/lib/fake.so", it->name);
+ ASSERT_EQ(0x720b29e000U, it->start);
+ ASSERT_EQ(0x720b29f000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
+ ++it;
+ ASSERT_EQ("", it->name);
+ ASSERT_EQ(0x720b29f000U, it->start);
+ ASSERT_EQ(0x720b2a0000U, it->end);
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
+ ++it;
+ ASSERT_EQ(it, maps.end());
+}
+
+TEST_F(MapsTest, parse_offset) {
+ MapsBuffer maps("a000-e000 rw-p 00000000 00:00 0 /system/lib/fake.so\n"
+ "e000-f000 rw-p 00a12345 00:00 0 /system/lib/fake.so\n");
+
+ ASSERT_TRUE(maps.Parse());
+ ASSERT_EQ(2U, maps.Total());
+ auto it = maps.begin();
+ ASSERT_EQ(0U, it->offset);
+ ASSERT_EQ(0xa000U, it->start);
+ ASSERT_EQ(0xe000U, it->end);
+ ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
+ ASSERT_EQ("/system/lib/fake.so", it->name);
+ ++it;
+ ASSERT_EQ(0xa12345U, it->offset);
+ ASSERT_EQ(0xe000U, it->start);
+ ASSERT_EQ(0xf000U, it->end);
+ ASSERT_EQ(PROT_READ | PROT_WRITE, it->flags);
+ ASSERT_EQ("/system/lib/fake.so", it->name);
+ ++it;
+ ASSERT_EQ(maps.end(), it);
+}
+
+TEST_F(MapsTest, file_smoke) {
+ TemporaryFile tf;
+ ASSERT_TRUE(tf.fd != -1);
+
+ ASSERT_TRUE(android::base::WriteStringToFile(
+ "720b29b000-720b29e000 r-xp a0000000 00:00 0 /fake.so\n"
+ "720b2b0000-720b2e0000 r-xp b0000000 00:00 0 /fake2.so\n"
+ "720b2e0000-720b2f0000 r-xp c0000000 00:00 0 /fake3.so\n",
+ tf.path, 0660, getuid(), getgid()));
+
+ MapsFile maps(tf.path);
+
+ ASSERT_TRUE(maps.Parse());
+ ASSERT_EQ(3U, maps.Total());
+ auto it = maps.begin();
+ ASSERT_EQ(0x720b29b000U, it->start);
+ ASSERT_EQ(0x720b29e000U, it->end);
+ ASSERT_EQ(0xa0000000U, it->offset);
+ ASSERT_EQ(PROT_READ | PROT_EXEC, it->flags);
+ ASSERT_EQ("/fake.so", it->name);
+ ++it;
+ ASSERT_EQ(0x720b2b0000U, it->start);
+ ASSERT_EQ(0x720b2e0000U, it->end);
+ ASSERT_EQ(0xb0000000U, it->offset);
+ ASSERT_EQ(PROT_READ | PROT_EXEC, it->flags);
+ ASSERT_EQ("/fake2.so", it->name);
+ ++it;
+ ASSERT_EQ(0x720b2e0000U, it->start);
+ ASSERT_EQ(0x720b2f0000U, it->end);
+ ASSERT_EQ(0xc0000000U, it->offset);
+ ASSERT_EQ(PROT_READ | PROT_EXEC, it->flags);
+ ASSERT_EQ("/fake3.so", it->name);
+ ++it;
+ ASSERT_EQ(it, maps.end());
+}
+
+TEST_F(MapsTest, find) {
+ MapsBuffer maps("1000-2000 r--p 00000010 00:00 0 /system/lib/fake1.so\n"
+ "3000-4000 -w-p 00000020 00:00 0 /system/lib/fake2.so\n"
+ "6000-8000 --xp 00000030 00:00 0 /system/lib/fake3.so\n"
+ "a000-b000 rw-p 00000040 00:00 0 /system/lib/fake4.so\n"
+ "e000-f000 rwxp 00000050 00:00 0 /system/lib/fake5.so\n");
+ ASSERT_TRUE(maps.Parse());
+ ASSERT_EQ(5U, maps.Total());
+
+ ASSERT_TRUE(maps.Find(0x500) == nullptr);
+ ASSERT_TRUE(maps.Find(0x2000) == nullptr);
+ ASSERT_TRUE(maps.Find(0x5010) == nullptr);
+ ASSERT_TRUE(maps.Find(0x9a00) == nullptr);
+ ASSERT_TRUE(maps.Find(0xf000) == nullptr);
+ ASSERT_TRUE(maps.Find(0xf010) == nullptr);
+
+ MapInfo* info = maps.Find(0x1000);
+ ASSERT_TRUE(info != nullptr);
+ ASSERT_EQ(0x1000U, info->start);
+ ASSERT_EQ(0x2000U, info->end);
+ ASSERT_EQ(0x10U, info->offset);
+ ASSERT_EQ(PROT_READ, info->flags);
+ ASSERT_EQ("/system/lib/fake1.so", info->name);
+
+ info = maps.Find(0x3020);
+ ASSERT_TRUE(info != nullptr);
+ ASSERT_EQ(0x3000U, info->start);
+ ASSERT_EQ(0x4000U, info->end);
+ ASSERT_EQ(0x20U, info->offset);
+ ASSERT_EQ(PROT_WRITE, info->flags);
+ ASSERT_EQ("/system/lib/fake2.so", info->name);
+
+ info = maps.Find(0x6020);
+ ASSERT_TRUE(info != nullptr);
+ ASSERT_EQ(0x6000U, info->start);
+ ASSERT_EQ(0x8000U, info->end);
+ ASSERT_EQ(0x30U, info->offset);
+ ASSERT_EQ(PROT_EXEC, info->flags);
+ ASSERT_EQ("/system/lib/fake3.so", info->name);
+
+ info = maps.Find(0xafff);
+ ASSERT_TRUE(info != nullptr);
+ ASSERT_EQ(0xa000U, info->start);
+ ASSERT_EQ(0xb000U, info->end);
+ ASSERT_EQ(0x40U, info->offset);
+ ASSERT_EQ(PROT_READ | PROT_WRITE, info->flags);
+ ASSERT_EQ("/system/lib/fake4.so", info->name);
+
+ info = maps.Find(0xe500);
+ ASSERT_TRUE(info != nullptr);
+ ASSERT_EQ(0xe000U, info->start);
+ ASSERT_EQ(0xf000U, info->end);
+ ASSERT_EQ(0x50U, info->offset);
+ ASSERT_EQ(PROT_READ | PROT_WRITE | PROT_EXEC, info->flags);
+ ASSERT_EQ("/system/lib/fake5.so", info->name);
+}
diff --git a/libunwindstack/tests/MemoryFake.cpp b/libunwindstack/tests/MemoryFake.cpp
new file mode 100644
index 0000000..afb1029
--- /dev/null
+++ b/libunwindstack/tests/MemoryFake.cpp
@@ -0,0 +1,46 @@
+/*
+ * 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 <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "MemoryFake.h"
+
+void MemoryFake::SetMemory(uint64_t addr, const void* memory, size_t length) {
+ const uint8_t* src = reinterpret_cast<const uint8_t*>(memory);
+ for (size_t i = 0; i < length; i++, addr++) {
+ auto value = data_.find(addr);
+ if (value != data_.end()) {
+ value->second = src[i];
+ } else {
+ data_.insert({ addr, src[i] });
+ }
+ }
+}
+
+bool MemoryFake::Read(uint64_t addr, void* memory, size_t size) {
+ uint8_t* dst = reinterpret_cast<uint8_t*>(memory);
+ for (size_t i = 0; i < size; i++, addr++) {
+ auto value = data_.find(addr);
+ if (value == data_.end()) {
+ return false;
+ }
+ dst[i] = value->second;
+ }
+ return true;
+}
diff --git a/libunwindstack/tests/MemoryFake.h b/libunwindstack/tests/MemoryFake.h
new file mode 100644
index 0000000..4f898fa
--- /dev/null
+++ b/libunwindstack/tests/MemoryFake.h
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+#ifndef _LIBUNWINDSTACK_TESTS_MEMORY_FAKE_H
+#define _LIBUNWINDSTACK_TESTS_MEMORY_FAKE_H
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+#include "Memory.h"
+
+class MemoryFake : public Memory {
+ public:
+ MemoryFake() = default;
+ virtual ~MemoryFake() = default;
+
+ bool Read(uint64_t addr, void* buffer, size_t size) override;
+
+ void SetMemory(uint64_t addr, const void* memory, size_t length);
+
+ void SetData(uint64_t addr, uint32_t value) {
+ SetMemory(addr, &value, sizeof(value));
+ }
+
+ void SetMemory(uint64_t addr, std::vector<uint8_t> values) {
+ SetMemory(addr, values.data(), values.size());
+ }
+
+ void SetMemory(uint64_t addr, std::string string) {
+ SetMemory(addr, string.c_str(), string.size() + 1);
+ }
+
+ void Clear() { data_.clear(); }
+
+ private:
+ std::unordered_map<uint64_t, uint8_t> data_;
+};
+
+class MemoryFakeAlwaysReadZero : public Memory {
+ public:
+ MemoryFakeAlwaysReadZero() = default;
+ virtual ~MemoryFakeAlwaysReadZero() = default;
+
+ bool Read(uint64_t, void* buffer, size_t size) override {
+ memset(buffer, 0, size);
+ return true;
+ }
+};
+
+#endif // _LIBUNWINDSTACK_TESTS_MEMORY_FAKE_H
diff --git a/libunwindstack/tests/MemoryFileTest.cpp b/libunwindstack/tests/MemoryFileTest.cpp
new file mode 100644
index 0000000..ebc6118
--- /dev/null
+++ b/libunwindstack/tests/MemoryFileTest.cpp
@@ -0,0 +1,167 @@
+/*
+ * 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 <android-base/test_utils.h>
+#include <android-base/file.h>
+#include <gtest/gtest.h>
+
+#include "Memory.h"
+
+#include "LogFake.h"
+
+class MemoryFileTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ ResetLogs();
+ tf_ = new TemporaryFile;
+ }
+
+ void TearDown() override {
+ delete tf_;
+ }
+
+ void WriteTestData() {
+ ASSERT_TRUE(android::base::WriteStringToFd("0123456789abcdefghijklmnopqrstuvxyz", tf_->fd));
+ }
+
+ MemoryFileAtOffset memory_;
+
+ TemporaryFile* tf_ = nullptr;
+};
+
+TEST_F(MemoryFileTest, offset_0) {
+ WriteTestData();
+
+ ASSERT_TRUE(memory_.Init(tf_->path, 0));
+ std::vector<char> buffer(11);
+ ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
+ buffer[10] = '\0';
+ ASSERT_STREQ("0123456789", buffer.data());
+}
+
+TEST_F(MemoryFileTest, offset_non_zero) {
+ WriteTestData();
+
+ ASSERT_TRUE(memory_.Init(tf_->path, 10));
+ std::vector<char> buffer(11);
+ ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
+ buffer[10] = '\0';
+ ASSERT_STREQ("abcdefghij", buffer.data());
+}
+
+TEST_F(MemoryFileTest, offset_non_zero_larger_than_pagesize) {
+ size_t pagesize = getpagesize();
+ std::string large_string;
+ for (size_t i = 0; i < pagesize; i++) {
+ large_string += '1';
+ }
+ large_string += "012345678901234abcdefgh";
+ ASSERT_TRUE(android::base::WriteStringToFd(large_string, tf_->fd));
+
+ ASSERT_TRUE(memory_.Init(tf_->path, pagesize + 15));
+ std::vector<char> buffer(9);
+ ASSERT_TRUE(memory_.Read(0, buffer.data(), 8));
+ buffer[8] = '\0';
+ ASSERT_STREQ("abcdefgh", buffer.data());
+}
+
+TEST_F(MemoryFileTest, offset_pagesize_aligned) {
+ size_t pagesize = getpagesize();
+ std::string data;
+ for (size_t i = 0; i < 2 * pagesize; i++) {
+ data += static_cast<char>((i / pagesize) + '0');
+ data += static_cast<char>((i % 10) + '0');
+ }
+ ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
+ ASSERT_TRUE(memory_.Init(tf_->path, 2 * pagesize));
+ std::vector<char> buffer(11);
+ ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
+ buffer[10] = '\0';
+ std::string expected_str;
+ for (size_t i = 0; i < 5; i++) {
+ expected_str += '1';
+ expected_str += static_cast<char>(((i + pagesize) % 10) + '0');
+ }
+ ASSERT_STREQ(expected_str.c_str(), buffer.data());
+}
+
+TEST_F(MemoryFileTest, offset_pagesize_aligned_plus_extra) {
+ size_t pagesize = getpagesize();
+ std::string data;
+ for (size_t i = 0; i < 2 * pagesize; i++) {
+ data += static_cast<char>((i / pagesize) + '0');
+ data += static_cast<char>((i % 10) + '0');
+ }
+ ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
+ ASSERT_TRUE(memory_.Init(tf_->path, 2 * pagesize + 10));
+ std::vector<char> buffer(11);
+ ASSERT_TRUE(memory_.Read(0, buffer.data(), 10));
+ buffer[10] = '\0';
+ std::string expected_str;
+ for (size_t i = 0; i < 5; i++) {
+ expected_str += '1';
+ expected_str += static_cast<char>(((i + pagesize + 5) % 10) + '0');
+ }
+ ASSERT_STREQ(expected_str.c_str(), buffer.data());
+}
+
+TEST_F(MemoryFileTest, read_error) {
+ std::string data;
+ for (size_t i = 0; i < 5000; i++) {
+ data += static_cast<char>((i % 10) + '0');
+ }
+ ASSERT_TRUE(android::base::WriteStringToFd(data, tf_->fd));
+
+ std::vector<char> buffer(100);
+
+ // Read before init.
+ ASSERT_FALSE(memory_.Read(0, buffer.data(), 10));
+
+ ASSERT_TRUE(memory_.Init(tf_->path, 0));
+
+ ASSERT_FALSE(memory_.Read(10000, buffer.data(), 10));
+ ASSERT_FALSE(memory_.Read(5000, buffer.data(), 10));
+ ASSERT_FALSE(memory_.Read(4990, buffer.data(), 11));
+ ASSERT_TRUE(memory_.Read(4990, buffer.data(), 10));
+ ASSERT_FALSE(memory_.Read(4999, buffer.data(), 2));
+ ASSERT_TRUE(memory_.Read(4999, buffer.data(), 1));
+}
+
+TEST_F(MemoryFileTest, read_string) {
+ std::string value("name_in_file");
+ ASSERT_TRUE(android::base::WriteFully(tf_->fd, value.c_str(), value.size() + 1));
+
+ std::string name;
+ ASSERT_TRUE(memory_.Init(tf_->path, 0));
+ ASSERT_TRUE(memory_.ReadString(0, &name));
+ ASSERT_EQ("name_in_file", name);
+ ASSERT_TRUE(memory_.ReadString(5, &name));
+ ASSERT_EQ("in_file", name);
+}
+
+TEST_F(MemoryFileTest, read_string_error) {
+ std::vector<uint8_t> buffer = { 0x23, 0x32, 0x45 };
+ ASSERT_TRUE(android::base::WriteFully(tf_->fd, buffer.data(), buffer.size()));
+
+ std::string name;
+ ASSERT_TRUE(memory_.Init(tf_->path, 0));
+
+ // Read from a non-existant address.
+ ASSERT_FALSE(memory_.ReadString(100, &name));
+
+ // This should fail because there is no terminating \0
+ ASSERT_FALSE(memory_.ReadString(0, &name));
+}
diff --git a/libunwindstack/tests/MemoryLocalTest.cpp b/libunwindstack/tests/MemoryLocalTest.cpp
new file mode 100644
index 0000000..49ece9d
--- /dev/null
+++ b/libunwindstack/tests/MemoryLocalTest.cpp
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2017 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 <stdint.h>
+#include <string.h>
+
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "Memory.h"
+
+#include "LogFake.h"
+
+class MemoryLocalTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ ResetLogs();
+ }
+};
+
+TEST_F(MemoryLocalTest, read) {
+ std::vector<uint8_t> src(1024);
+ memset(src.data(), 0x4c, 1024);
+
+ MemoryLocal local;
+
+ std::vector<uint8_t> dst(1024);
+ ASSERT_TRUE(local.Read(reinterpret_cast<uint64_t>(src.data()), dst.data(), 1024));
+ ASSERT_EQ(0, memcmp(src.data(), dst.data(), 1024));
+ for (size_t i = 0; i < 1024; i++) {
+ ASSERT_EQ(0x4cU, dst[i]);
+ }
+
+ memset(src.data(), 0x23, 512);
+ ASSERT_TRUE(local.Read(reinterpret_cast<uint64_t>(src.data()), dst.data(), 1024));
+ ASSERT_EQ(0, memcmp(src.data(), dst.data(), 1024));
+ for (size_t i = 0; i < 512; i++) {
+ ASSERT_EQ(0x23U, dst[i]);
+ }
+ for (size_t i = 512; i < 1024; i++) {
+ ASSERT_EQ(0x4cU, dst[i]);
+ }
+}
+
+TEST_F(MemoryLocalTest, read_string) {
+ std::string name("string_in_memory");
+
+ MemoryLocal local;
+
+ std::vector<uint8_t> dst(1024);
+ std::string dst_name;
+ ASSERT_TRUE(local.ReadString(reinterpret_cast<uint64_t>(name.c_str()), &dst_name));
+ ASSERT_EQ("string_in_memory", dst_name);
+
+ ASSERT_TRUE(local.ReadString(reinterpret_cast<uint64_t>(&name[7]), &dst_name));
+ ASSERT_EQ("in_memory", dst_name);
+
+ ASSERT_TRUE(local.ReadString(reinterpret_cast<uint64_t>(&name[7]), &dst_name, 10));
+ ASSERT_EQ("in_memory", dst_name);
+
+ ASSERT_FALSE(local.ReadString(reinterpret_cast<uint64_t>(&name[7]), &dst_name, 9));
+}
+
+TEST_F(MemoryLocalTest, read_illegal) {
+ MemoryLocal local;
+
+ std::vector<uint8_t> dst(100);
+ ASSERT_FALSE(local.Read(0, dst.data(), 1));
+ ASSERT_FALSE(local.Read(0, dst.data(), 100));
+}
diff --git a/libunwindstack/tests/MemoryRangeTest.cpp b/libunwindstack/tests/MemoryRangeTest.cpp
new file mode 100644
index 0000000..fcae3a4
--- /dev/null
+++ b/libunwindstack/tests/MemoryRangeTest.cpp
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2017 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 <stdint.h>
+#include <string.h>
+
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "Memory.h"
+
+#include "LogFake.h"
+#include "MemoryFake.h"
+
+class MemoryRangeTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ ResetLogs();
+ memory_ = new MemoryFake;
+ }
+
+ MemoryFake* memory_;
+};
+
+TEST_F(MemoryRangeTest, read) {
+ std::vector<uint8_t> src(1024);
+ memset(src.data(), 0x4c, 1024);
+ memory_->SetMemory(9001, src);
+
+ MemoryRange range(memory_, 9001, 9001 + src.size());
+
+ std::vector<uint8_t> dst(1024);
+ ASSERT_TRUE(range.Read(0, dst.data(), src.size()));
+ for (size_t i = 0; i < 1024; i++) {
+ ASSERT_EQ(0x4cU, dst[i]) << "Failed at byte " << i;
+ }
+}
+
+TEST_F(MemoryRangeTest, read_near_limit) {
+ std::vector<uint8_t> src(4096);
+ memset(src.data(), 0x4c, 4096);
+ memory_->SetMemory(1000, src);
+
+ MemoryRange range(memory_, 1000, 2024);
+
+ std::vector<uint8_t> dst(1024);
+ ASSERT_TRUE(range.Read(1020, dst.data(), 4));
+ for (size_t i = 0; i < 4; i++) {
+ ASSERT_EQ(0x4cU, dst[i]) << "Failed at byte " << i;
+ }
+
+ // Verify that reads outside of the range will fail.
+ ASSERT_FALSE(range.Read(1020, dst.data(), 5));
+ ASSERT_FALSE(range.Read(1024, dst.data(), 1));
+ ASSERT_FALSE(range.Read(1024, dst.data(), 1024));
+}
+
+TEST_F(MemoryRangeTest, read_string_past_end) {
+ std::string name("0123456789");
+ memory_->SetMemory(0, name);
+
+ // Verify a read past the range fails.
+ MemoryRange range(memory_, 0, 5);
+ std::string dst_name;
+ ASSERT_FALSE(range.ReadString(0, &dst_name));
+}
+
+TEST_F(MemoryRangeTest, read_string_to_end) {
+ std::string name("0123456789");
+ memory_->SetMemory(30, name);
+
+ // Verify the range going to the end of the string works.
+ MemoryRange range(memory_, 30, 30 + name.size() + 1);
+ std::string dst_name;
+ ASSERT_TRUE(range.ReadString(0, &dst_name));
+ ASSERT_EQ("0123456789", dst_name);
+}
+
+TEST_F(MemoryRangeTest, read_string_fencepost) {
+ std::string name("0123456789");
+ memory_->SetMemory(10, name);
+
+ // Verify the range set to one byte less than the end of the string fails.
+ MemoryRange range(memory_, 10, 10 + name.size());
+ std::string dst_name;
+ ASSERT_FALSE(range.ReadString(0, &dst_name));
+}
diff --git a/libunwindstack/tests/MemoryRemoteTest.cpp b/libunwindstack/tests/MemoryRemoteTest.cpp
new file mode 100644
index 0000000..49244a5
--- /dev/null
+++ b/libunwindstack/tests/MemoryRemoteTest.cpp
@@ -0,0 +1,156 @@
+/*
+ * 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 <errno.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/ptrace.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+#include <vector>
+
+#include <android-base/test_utils.h>
+#include <android-base/file.h>
+#include <gtest/gtest.h>
+
+#include "Memory.h"
+
+#include "LogFake.h"
+
+class MemoryRemoteTest : public ::testing::Test {
+ protected:
+ void SetUp() override {
+ ResetLogs();
+ }
+
+ static uint64_t NanoTime() {
+ struct timespec t = { 0, 0 };
+ clock_gettime(CLOCK_MONOTONIC, &t);
+ return static_cast<uint64_t>(t.tv_sec * NS_PER_SEC + t.tv_nsec);
+ }
+
+ static bool Attach(pid_t pid) {
+ if (ptrace(PTRACE_ATTACH, pid, 0, 0) == -1) {
+ return false;
+ }
+
+ uint64_t start = NanoTime();
+ siginfo_t si;
+ while (TEMP_FAILURE_RETRY(ptrace(PTRACE_GETSIGINFO, pid, 0, &si)) < 0 && errno == ESRCH) {
+ if ((NanoTime() - start) > 10 * NS_PER_SEC) {
+ printf("%d: Failed to stop after 10 seconds.\n", pid);
+ return false;
+ }
+ usleep(30);
+ }
+ return true;
+ }
+
+ static bool Detach(pid_t pid) {
+ return ptrace(PTRACE_DETACH, pid, 0, 0) == 0;
+ }
+
+ static constexpr size_t NS_PER_SEC = 1000000000ULL;
+};
+
+TEST_F(MemoryRemoteTest, read) {
+ std::vector<uint8_t> src(1024);
+ memset(src.data(), 0x4c, 1024);
+
+ pid_t pid;
+ if ((pid = fork()) == 0) {
+ while (true);
+ exit(1);
+ }
+ ASSERT_LT(0, pid);
+
+ ASSERT_TRUE(Attach(pid));
+
+ MemoryRemote remote(pid);
+
+ std::vector<uint8_t> dst(1024);
+ ASSERT_TRUE(remote.Read(reinterpret_cast<uint64_t>(src.data()), dst.data(), 1024));
+ for (size_t i = 0; i < 1024; i++) {
+ ASSERT_EQ(0x4cU, dst[i]) << "Failed at byte " << i;
+ }
+
+ ASSERT_TRUE(Detach(pid));
+
+ kill(pid, SIGKILL);
+}
+
+TEST_F(MemoryRemoteTest, read_fail) {
+ int pagesize = getpagesize();
+ void* src = mmap(nullptr, pagesize * 2, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,-1, 0);
+ memset(src, 0x4c, pagesize * 2);
+ ASSERT_NE(MAP_FAILED, src);
+ // Put a hole right after the first page.
+ ASSERT_EQ(0, munmap(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(src) + pagesize),
+ pagesize));
+
+ pid_t pid;
+ if ((pid = fork()) == 0) {
+ while (true);
+ exit(1);
+ }
+ ASSERT_LT(0, pid);
+
+ ASSERT_TRUE(Attach(pid));
+
+ MemoryRemote remote(pid);
+
+ std::vector<uint8_t> dst(pagesize);
+ ASSERT_TRUE(remote.Read(reinterpret_cast<uint64_t>(src), dst.data(), pagesize));
+ for (size_t i = 0; i < 1024; i++) {
+ ASSERT_EQ(0x4cU, dst[i]) << "Failed at byte " << i;
+ }
+
+ ASSERT_FALSE(remote.Read(reinterpret_cast<uint64_t>(src) + pagesize, dst.data(), 1));
+ ASSERT_TRUE(remote.Read(reinterpret_cast<uint64_t>(src) + pagesize - 1, dst.data(), 1));
+ ASSERT_FALSE(remote.Read(reinterpret_cast<uint64_t>(src) + pagesize - 4, dst.data(), 8));
+
+ ASSERT_EQ(0, munmap(src, pagesize));
+
+ ASSERT_TRUE(Detach(pid));
+
+ kill(pid, SIGKILL);
+}
+
+TEST_F(MemoryRemoteTest, read_illegal) {
+ pid_t pid;
+ if ((pid = fork()) == 0) {
+ while (true);
+ exit(1);
+ }
+ ASSERT_LT(0, pid);
+
+ ASSERT_TRUE(Attach(pid));
+
+ MemoryRemote remote(pid);
+
+ std::vector<uint8_t> dst(100);
+ ASSERT_FALSE(remote.Read(0, dst.data(), 1));
+ ASSERT_FALSE(remote.Read(0, dst.data(), 100));
+
+ ASSERT_TRUE(Detach(pid));
+
+ kill(pid, SIGKILL);
+}
diff --git a/libunwindstack/tests/RegsTest.cpp b/libunwindstack/tests/RegsTest.cpp
new file mode 100644
index 0000000..f9e8b0e
--- /dev/null
+++ b/libunwindstack/tests/RegsTest.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2017 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 <stdint.h>
+
+#include <gtest/gtest.h>
+
+#include "Regs.h"
+
+class RegsTest : public ::testing::Test {};
+
+TEST_F(RegsTest, regs32) {
+ Regs32 regs32(10, 20, 30);
+
+ ASSERT_EQ(10U, regs32.pc_reg());
+ ASSERT_EQ(20U, regs32.sp_reg());
+ ASSERT_EQ(30U, regs32.total_regs());
+
+ uint32_t* raw = reinterpret_cast<uint32_t*>(regs32.raw_data());
+ for (size_t i = 0; i < 30; i++) {
+ raw[i] = 0xf0000000 + i;
+ }
+
+ ASSERT_EQ(0xf000000aU, regs32.pc());
+ ASSERT_EQ(0xf0000014U, regs32.sp());
+
+ ASSERT_EQ(0xf0000001U, regs32[1]);
+ regs32[1] = 10;
+ ASSERT_EQ(10U, regs32[1]);
+
+ ASSERT_EQ(0xf000001dU, regs32[29]);
+}
+
+TEST_F(RegsTest, regs64) {
+ Regs64 regs64(10, 20, 30);
+
+ ASSERT_EQ(10U, regs64.pc_reg());
+ ASSERT_EQ(20U, regs64.sp_reg());
+ ASSERT_EQ(30U, regs64.total_regs());
+
+ uint64_t* raw = reinterpret_cast<uint64_t*>(regs64.raw_data());
+ for (size_t i = 0; i < 30; i++) {
+ raw[i] = 0xf123456780000000UL + i;
+ }
+
+ ASSERT_EQ(0xf12345678000000aUL, regs64.pc());
+ ASSERT_EQ(0xf123456780000014UL, regs64.sp());
+
+ ASSERT_EQ(0xf123456780000008U, regs64[8]);
+ regs64[8] = 10;
+ ASSERT_EQ(10U, regs64[8]);
+
+ ASSERT_EQ(0xf12345678000001dU, regs64[29]);
+}
diff --git a/logcat/logcat.cpp b/logcat/logcat.cpp
index d9935c3..4a171fd 100644
--- a/logcat/logcat.cpp
+++ b/logcat/logcat.cpp
@@ -298,6 +298,8 @@
" and individually flagged modifying adverbs can be added:\n"
" color descriptive epoch monotonic printable uid\n"
" usec UTC year zone\n"
+ // private and undocumented nsec, no signal, too much noise
+ // useful for -T or -t <timestamp> accurate testing though.
" -D, --dividers Print dividers between each log buffer\n"
" -c, --clear Clear (flush) the entire log and exit\n"
" if Log to File specified, clear fileset instead\n"
diff --git a/logcat/tests/logcat_test.cpp b/logcat/tests/logcat_test.cpp
index 10d9e39..081bf92 100644
--- a/logcat/tests/logcat_test.cpp
+++ b/logcat/tests/logcat_test.cpp
@@ -107,6 +107,32 @@
EXPECT_LT(4, count);
}
+// If there is not enough background noise in the logs, then spam the logs to
+// permit tail checking so that the tests can progress.
+static size_t inject(ssize_t count) {
+ if (count <= 0) return 0;
+
+ static const size_t retry = 4;
+ size_t errors = retry;
+ size_t num = 0;
+ for(;;) {
+ log_time ts(CLOCK_MONOTONIC);
+ if (__android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)) >= 0) {
+ if (++num >= (size_t)count) {
+ // let data settle end-to-end
+ sleep(3);
+ return num;
+ }
+ errors = retry;
+ usleep(100); // ~32 per timer tick, we are a spammer regardless
+ } else if (--errors <= 0) {
+ return num;
+ }
+ }
+ // NOTREACH
+ return num;
+}
+
TEST(logcat, year) {
if (android_log_clockid() == CLOCK_MONOTONIC) {
@@ -114,35 +140,40 @@
return;
}
- FILE *fp;
+ int count;
+ int tries = 3; // in case run too soon after system start or buffer clear
- char needle[32];
- time_t now;
- time(&now);
- struct tm *ptm;
+ do {
+ FILE *fp;
+
+ char needle[32];
+ time_t now;
+ time(&now);
+ struct tm *ptm;
#if !defined(_WIN32)
- struct tm tmBuf;
- ptm = localtime_r(&now, &tmBuf);
+ struct tm tmBuf;
+ ptm = localtime_r(&now, &tmBuf);
#else
- ptm = localtime(&&now);
+ ptm = localtime(&&now);
#endif
- strftime(needle, sizeof(needle), "[ %Y-", ptm);
+ strftime(needle, sizeof(needle), "[ %Y-", ptm);
- ASSERT_TRUE(NULL != (fp = popen(
- "logcat -v long -v year -b all -t 3 2>/dev/null",
- "r")));
+ ASSERT_TRUE(NULL != (fp = popen(
+ "logcat -v long -v year -b all -t 3 2>/dev/null",
+ "r")));
- char buffer[BIG_BUFFER];
+ char buffer[BIG_BUFFER];
- int count = 0;
+ count = 0;
- while (fgets(buffer, sizeof(buffer), fp)) {
- if (!strncmp(buffer, needle, strlen(needle))) {
- ++count;
+ while (fgets(buffer, sizeof(buffer), fp)) {
+ if (!strncmp(buffer, needle, strlen(needle))) {
+ ++count;
+ }
}
- }
+ pclose(fp);
- pclose(fp);
+ } while ((count < 3) && --tries && inject(3 - count));
ASSERT_EQ(3, count);
}
@@ -179,32 +210,6 @@
return NULL;
}
-// If there is not enough background noise in the logs, then spam the logs to
-// permit tail checking so that the tests can progress.
-static size_t inject(ssize_t count) {
- if (count <= 0) return 0;
-
- static const size_t retry = 4;
- size_t errors = retry;
- size_t num = 0;
- for(;;) {
- log_time ts(CLOCK_MONOTONIC);
- if (__android_log_btwrite(0, EVENT_TYPE_LONG, &ts, sizeof(ts)) >= 0) {
- if (++num >= (size_t)count) {
- // let data settle end-to-end
- sleep(3);
- return num;
- }
- errors = retry;
- usleep(50);
- } else if (--errors <= 0) {
- return num;
- }
- }
- // NOTREACH
- return num;
-}
-
TEST(logcat, tz) {
if (android_log_clockid() == CLOCK_MONOTONIC) {
@@ -267,6 +272,8 @@
int tries = 4; // in case run too soon after system start or buffer clear
int count;
+ if (num > 10) ++tries;
+ if (num > 100) ++tries;
do {
char buffer[BIG_BUFFER];
@@ -310,25 +317,32 @@
int count;
char buffer[BIG_BUFFER];
char *last_timestamp = NULL;
+ // Hard to predict 100% if first (overlap) or second line will match.
+ // -v nsec will in a substantial majority be the second line.
char *first_timestamp = NULL;
- char *cp;
+ char *second_timestamp = NULL;
+ char *input;
int tries = 4; // in case run too soon after system start or buffer clear
- // Do not be tempted to use -v usec because that increases the
- // chances of an occasional test failure by 1000 (see below).
do {
- ASSERT_TRUE(NULL != (fp = popen("logcat -v long -b all -t 10 2>&1", "r")));
-
+ ASSERT_TRUE(NULL != (fp = popen("logcat"
+ " -v long"
+ " -v nsec"
+ " -b all"
+ " -t 10"
+ " 2>&1", "r")));
count = 0;
- while ((cp = fgetLongTime(buffer, sizeof(buffer), fp))) {
+ while ((input = fgetLongTime(buffer, sizeof(buffer), fp))) {
++count;
if (!first_timestamp) {
- first_timestamp = strdup(cp);
+ first_timestamp = strdup(input);
+ } else if (!second_timestamp) {
+ second_timestamp = strdup(input);
}
free(last_timestamp);
- last_timestamp = strdup(cp);
+ last_timestamp = strdup(input);
}
pclose(fp);
@@ -337,34 +351,80 @@
EXPECT_EQ(10, count); // We want _some_ history, too small, falses below
EXPECT_TRUE(last_timestamp != NULL);
EXPECT_TRUE(first_timestamp != NULL);
+ EXPECT_TRUE(second_timestamp != NULL);
- snprintf(buffer, sizeof(buffer), "logcat -v long -b all -t '%s' 2>&1",
- first_timestamp);
+ snprintf(buffer, sizeof(buffer), "logcat"
+ " -v long"
+ " -v nsec"
+ " -b all"
+ " -t '%s'"
+ " 2>&1",
+ first_timestamp);
ASSERT_TRUE(NULL != (fp = popen(buffer, "r")));
int second_count = 0;
int last_timestamp_count = -1;
- while ((cp = fgetLongTime(buffer, sizeof(buffer), fp))) {
+ --count; // One less unless we match the first_timestamp
+ bool found = false;
+ while ((input = fgetLongTime(buffer, sizeof(buffer), fp))) {
++second_count;
+ // We want to highlight if we skip to the next entry.
+ // WAI, if the time in logd is *exactly*
+ // XX-XX XX:XX:XX.XXXXXX000 (usec) or XX-XX XX:XX:XX.XXX000000
+ // this can happen, but it should not happen with nsec.
+ // We can make this WAI behavior happen 1000 times less
+ // frequently if the caller does not use the -v usec flag,
+ // but always the second (always skip) if they use the
+ // (undocumented) -v nsec flag.
if (first_timestamp) {
- // we can get a transitory *extremely* rare failure if hidden
- // underneath the time is *exactly* XX-XX XX:XX:XX.XXX000000
- EXPECT_STREQ(cp, first_timestamp);
+ found = !strcmp(input, first_timestamp);
+ if (found) {
+ ++count;
+ GTEST_LOG_(INFO) << "input = first("
+ << first_timestamp
+ << ")\n";
+ }
free(first_timestamp);
first_timestamp = NULL;
}
- if (!strcmp(cp, last_timestamp)) {
+ if (second_timestamp) {
+ found = found || !strcmp(input, second_timestamp);
+ if (!found) {
+ GTEST_LOG_(INFO) << "input("
+ << input
+ << ") != second("
+ << second_timestamp
+ << ")\n";
+ }
+ free(second_timestamp);
+ second_timestamp = NULL;
+ }
+ if (!strcmp(input, last_timestamp)) {
last_timestamp_count = second_count;
}
}
pclose(fp);
+ EXPECT_TRUE(found);
+ if (!found) {
+ if (first_timestamp) {
+ GTEST_LOG_(INFO) << "first = " << first_timestamp << "\n";
+ }
+ if (second_timestamp) {
+ GTEST_LOG_(INFO) << "second = " << second_timestamp << "\n";
+ }
+ if (last_timestamp) {
+ GTEST_LOG_(INFO) << "last = " << last_timestamp << "\n";
+ }
+ }
free(last_timestamp);
last_timestamp = NULL;
free(first_timestamp);
+ free(second_timestamp);
EXPECT_TRUE(first_timestamp == NULL);
+ EXPECT_TRUE(second_timestamp == NULL);
EXPECT_LE(count, second_count);
EXPECT_LE(count, last_timestamp_count);
}
@@ -747,7 +807,7 @@
ASSERT_TRUE(NULL != mkdtemp(strcpy(tmp_out_dir, tmp_out_dir_form)));
static const char log_filename[] = "log.txt";
- static const char logcat_cmd[] = "logcat -b all -d -f %s/%s -n 256 -r 1024";
+ static const char logcat_cmd[] = "logcat -b all -v nsec -d -f %s/%s -n 256 -r 1024";
static const char cleanup_cmd[] = "rm -rf %s";
char command[sizeof(tmp_out_dir) + sizeof(logcat_cmd) + sizeof(log_filename)];
snprintf(command, sizeof(command), logcat_cmd, tmp_out_dir, log_filename);
@@ -769,9 +829,15 @@
}
char *line = NULL;
char *last_line = NULL; // this line is allowed to stutter, one-line overlap
- char *second_last_line = NULL;
+ char *second_last_line = NULL; // should never stutter
+ char *first_line = NULL; // help diagnose failure?
size_t len = 0;
while (getline(&line, &len, fp) != -1) {
+ if (!first_line) {
+ first_line = line;
+ line = NULL;
+ continue;
+ }
free(second_last_line);
second_last_line = last_line;
last_line = line;
@@ -789,6 +855,7 @@
if (!second_last_line) {
snprintf(command, sizeof(command), cleanup_cmd, tmp_out_dir);
EXPECT_FALSE(IsFalse(system(command), command));
+ free(first_line);
return;
}
// re-run the command, it should only add a few lines more content if it
@@ -798,6 +865,8 @@
if (ret) {
snprintf(command, sizeof(command), cleanup_cmd, tmp_out_dir);
EXPECT_FALSE(IsFalse(system(command), command));
+ free(second_last_line);
+ free(first_line);
return;
}
std::unique_ptr<DIR, decltype(&closedir)> dir(opendir(tmp_out_dir), closedir);
@@ -805,6 +874,8 @@
if (!dir) {
snprintf(command, sizeof(command), cleanup_cmd, tmp_out_dir);
EXPECT_FALSE(IsFalse(system(command), command));
+ free(second_last_line);
+ free(first_line);
return;
}
struct dirent *entry;
@@ -834,13 +905,18 @@
}
if (count > 1) {
char *brk = strpbrk(second_last_line, "\r\n");
- if (!brk) {
- brk = second_last_line + strlen(second_last_line);
- }
- fprintf(stderr, "\"%.*s\" occured %u times\n",
+ if (!brk) brk = second_last_line + strlen(second_last_line);
+ fprintf(stderr, "\"%.*s\" occurred %u times\n",
(int)(brk - second_last_line), second_last_line, count);
+ if (first_line) {
+ brk = strpbrk(first_line, "\r\n");
+ if (!brk) brk = first_line + strlen(first_line);
+ fprintf(stderr, "\"%.*s\" was first line, fault?\n",
+ (int)(brk - first_line), first_line);
+ }
}
free(second_last_line);
+ free(first_line);
snprintf(command, sizeof(command), cleanup_cmd, tmp_out_dir);
EXPECT_FALSE(IsFalse(system(command), command));
diff --git a/logd/Android.mk b/logd/Android.mk
index 2da9782..9211037 100644
--- a/logd/Android.mk
+++ b/logd/Android.mk
@@ -21,6 +21,7 @@
libaudit.c \
LogAudit.cpp \
LogKlog.cpp \
+ LogTags.cpp \
event.logtags
LOCAL_SHARED_LIBRARIES := \
@@ -38,12 +39,23 @@
# $(LOCAL_PATH)/$2/event.logtags)
# event_flag := $(call event_logtags,auditd)
# event_flag += $(call event_logtags,logd)
+# event_flag += $(call event_logtags,tag_def)
# so make sure we do not regret hard-coding it as follows:
-event_flag := -DAUDITD_LOG_TAG=1003 -DCHATTY_LOG_TAG=1004
+event_flag := -DAUDITD_LOG_TAG=1003 -DCHATTY_LOG_TAG=1004 -DTAG_DEF_LOG_TAG=1005
event_flag += -DLIBLOG_LOG_TAG=1006
LOCAL_CFLAGS := -Werror $(event_flag)
include $(BUILD_EXECUTABLE)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := logtagd.rc
+LOCAL_SRC_FILES := $(LOCAL_MODULE)
+LOCAL_MODULE_CLASS := ETC
+LOCAL_MODULE_TAGS := debug
+LOCAL_MODULE_PATH := $(TARGET_OUT_ETC)/init
+
+include $(BUILD_PREBUILT)
+
include $(call first-makefiles-under,$(LOCAL_PATH))
diff --git a/logd/CommandListener.cpp b/logd/CommandListener.cpp
index 52c6742..74e0ea5 100644
--- a/logd/CommandListener.cpp
+++ b/logd/CommandListener.cpp
@@ -15,6 +15,7 @@
*/
#include <arpa/inet.h>
+#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
@@ -47,6 +48,7 @@
registerCmd(new GetStatisticsCmd(buf));
registerCmd(new SetPruneListCmd(buf));
registerCmd(new GetPruneListCmd(buf));
+ registerCmd(new GetEventTagCmd(buf));
registerCmd(new ReinitCmd());
registerCmd(new ExitCmd(this));
}
@@ -284,6 +286,41 @@
return 0;
}
+CommandListener::GetEventTagCmd::GetEventTagCmd(LogBuffer *buf) :
+ LogCommand("getEventTag"),
+ mBuf(*buf) {
+}
+
+int CommandListener::GetEventTagCmd::runCommand(SocketClient *cli,
+ int argc, char ** argv) {
+ setname();
+ uid_t uid = cli->getUid();
+ if (clientHasLogCredentials(cli)) {
+ uid = AID_ROOT;
+ }
+
+ const char *name = NULL;
+ const char *format = NULL;
+ for (int i = 1; i < argc; ++i) {
+ static const char _name[] = "name=";
+ if (!strncmp(argv[i], _name, strlen(_name))) {
+ name = argv[i] + strlen(_name);
+ continue;
+ }
+
+ static const char _format[] = "format=";
+ if (!strncmp(argv[i], _format, strlen(_format))) {
+ format = argv[i] + strlen(_format);
+ continue;
+ }
+ }
+
+ cli->sendMsg(package_string(mBuf.formatGetEventTag(uid,
+ name, format)).c_str());
+
+ return 0;
+}
+
CommandListener::ReinitCmd::ReinitCmd() : LogCommand("reinit") {
}
diff --git a/logd/CommandListener.h b/logd/CommandListener.h
index 5d50177..39de03b 100644
--- a/logd/CommandListener.h
+++ b/logd/CommandListener.h
@@ -61,6 +61,7 @@
LogBufferCmd(GetStatistics);
LogBufferCmd(GetPruneList);
LogBufferCmd(SetPruneList);
+ LogBufferCmd(GetEventTag);
#define LogCmd(name) \
class name##Cmd : public LogCommand { \
diff --git a/logd/LogBuffer.cpp b/logd/LogBuffer.cpp
index 820ff64..7613c1e 100644
--- a/logd/LogBuffer.cpp
+++ b/logd/LogBuffer.cpp
@@ -199,15 +199,13 @@
if (log_id != LOG_ID_SECURITY) {
int prio = ANDROID_LOG_INFO;
const char *tag = NULL;
- size_t len = 0;
if (log_id == LOG_ID_EVENTS) {
- tag = android::tagToName(&len, elem->getTag());
+ tag = tagToName(elem->getTag());
} else {
prio = *msg;
tag = msg + 1;
- len = strlen(tag);
}
- if (!__android_log_is_loggable_len(prio, tag, len, ANDROID_LOG_VERBOSE)) {
+ if (!__android_log_is_loggable(prio, tag, ANDROID_LOG_VERBOSE)) {
// Log traffic received to total
pthread_mutex_lock(&mLogElementsLock);
stats.add(elem);
diff --git a/logd/LogBuffer.h b/logd/LogBuffer.h
index 932d55f..da63e12 100644
--- a/logd/LogBuffer.h
+++ b/logd/LogBuffer.h
@@ -27,6 +27,7 @@
#include <sysutils/SocketClient.h>
#include "LogBufferElement.h"
+#include "LogTags.h"
#include "LogTimes.h"
#include "LogStatistics.h"
#include "LogWhiteBlackList.h"
@@ -99,6 +100,8 @@
bool monotonic;
+ LogTags tags;
+
LogBufferElement* lastLoggedElements[LOG_ID_MAX];
LogBufferElement* droppedElements[LOG_ID_MAX];
void log(LogBufferElement* elem);
@@ -133,6 +136,12 @@
int initPrune(const char *cp) { return mPrune.init(cp); }
std::string formatPrune() { return mPrune.format(); }
+ std::string formatGetEventTag(uid_t uid,
+ const char *name, const char *format) {
+ return tags.formatGetEventTag(uid, name, format);
+ }
+ const char *tagToName(uint32_t tag) { return tags.tagToName(tag); }
+
// helper must be protected directly or implicitly by lock()/unlock()
const char *pidToName(pid_t pid) { return stats.pidToName(pid); }
uid_t pidToUid(pid_t pid) { return stats.pidToUid(pid); }
diff --git a/logd/LogStatistics.cpp b/logd/LogStatistics.cpp
index 273150e..7e0a6b7 100644
--- a/logd/LogStatistics.cpp
+++ b/logd/LogStatistics.cpp
@@ -452,12 +452,11 @@
name = android::base::StringPrintf("%7u/%u",
getKey(), uid);
}
- size_t len = 0;
- const char *nameTmp = getName(len);
+ const char *nameTmp = getName();
if (nameTmp) {
name += android::base::StringPrintf(
- "%*s%.*s", (int)std::max(14 - name.length(), (size_t)1),
- "", (int)len, nameTmp);
+ "%*s%s", (int)std::max(14 - name.length(), (size_t)1),
+ "", nameTmp);
}
std::string size = android::base::StringPrintf("%zu",
diff --git a/logd/LogStatistics.h b/logd/LogStatistics.h
index 7acef6d..777dc33 100644
--- a/logd/LogStatistics.h
+++ b/logd/LogStatistics.h
@@ -413,7 +413,7 @@
const uint32_t&getKey() const { return tag; }
const pid_t&getPid() const { return pid; }
const uid_t&getUid() const { return uid; }
- const char*getName(size_t &len) const { return android::tagToName(&len, tag); }
+ const char*getName() const { return android::tagToName(tag); }
inline void add(LogBufferElement *element) {
if (uid != element->getUid()) {
diff --git a/logd/LogTags.cpp b/logd/LogTags.cpp
new file mode 100644
index 0000000..a109592
--- /dev/null
+++ b/logd/LogTags.cpp
@@ -0,0 +1,884 @@
+/*
+ * Copyright (C) 2017 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 <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+
+#include <android-base/file.h>
+#include <android-base/macros.h>
+#include <android-base/stringprintf.h>
+#include <log/log_event_list.h>
+#include <private/android_filesystem_config.h>
+#include <private/android_logger.h>
+
+#include "LogTags.h"
+#include "LogUtils.h"
+
+static LogTags* logtags;
+
+const char LogTags::system_event_log_tags[] = "/system/etc/event-log-tags";
+const char LogTags::dynamic_event_log_tags[] = "/dev/event-log-tags";
+// Only for debug
+const char LogTags::debug_event_log_tags[] = "/data/misc/logd/event-log-tags";
+
+// Sniff for first uid=%d in utf8z comment string
+static uid_t sniffUid(const char* comment, const char* endp) {
+ if (!comment) return AID_ROOT;
+
+ if (*comment == '#') ++comment;
+ while ((comment < endp) && (*comment != '\n') && isspace(*comment)) ++comment;
+ static const char uid_str[] = "uid=";
+ if (((comment + strlen(uid_str)) >= endp) ||
+ fastcmp<strncmp>(comment, uid_str, strlen(uid_str)) ||
+ !isdigit(comment[strlen(uid_str)])) return AID_ROOT;
+ char* cp;
+ unsigned long Uid = strtoul(comment + 4, &cp, 10);
+ if ((cp > endp) || (Uid >= INT_MAX)) return AID_ROOT;
+
+ return Uid;
+}
+
+// Checks for file corruption, and report false if there was no need
+// to rebuild the referenced file. Failure to rebuild is only logged,
+// does not cause a return value of false.
+bool LogTags::RebuildFileEventLogTags(const char* filename, bool warn) {
+ int fd;
+
+ {
+ android::RWLock::AutoRLock readLock(rwlock);
+
+ if (tag2total.begin() == tag2total.end()) {
+ return false;
+ }
+
+ file2watermark_const_iterator iwater = file2watermark.find(filename);
+ if (iwater == file2watermark.end()) {
+ return false;
+ }
+
+ struct stat sb;
+ if (!stat(filename, &sb) && ((size_t)sb.st_size >= iwater->second)) {
+ return false;
+ }
+
+ // dump what we already know back into the file?
+ fd = TEMP_FAILURE_RETRY(open(filename,
+ O_WRONLY | O_TRUNC | O_CLOEXEC |
+ O_NOFOLLOW | O_BINARY));
+ if (fd >= 0) {
+ time_t now = time(NULL);
+ struct tm tm;
+ localtime_r(&now, &tm);
+ char timebuf[20];
+ size_t len = strftime(timebuf, sizeof(timebuf),
+ "%Y-%m-%d %H:%M:%S", &tm);
+ android::base::WriteStringToFd(
+ android::base::StringPrintf(
+ "# Rebuilt %.20s, content owned by logd\n", timebuf),
+ fd);
+ for (const auto& it : tag2total) {
+ android::base::WriteStringToFd(formatEntry_locked(it.first,
+ AID_ROOT),
+ fd);
+ }
+ TEMP_FAILURE_RETRY(close(fd));
+ }
+ }
+
+ if (warn) {
+ android::prdebug(((fd < 0) ?
+ "%s failed to rebuild" :
+ "%s missing, damaged or truncated; rebuilt"),
+ filename);
+ }
+
+ if (fd >= 0) {
+ android::RWLock::AutoWLock writeLock(rwlock);
+
+ struct stat sb;
+ if (!stat(filename, &sb)) file2watermark[filename] = sb.st_size;
+ }
+
+ return true;
+}
+
+void LogTags::AddEventLogTags(uint32_t tag, uid_t uid,
+ const std::string& Name,
+ const std::string& Format,
+ const char* source, bool warn) {
+ std::string Key = Name;
+ if (Format.length()) Key += "+" + Format;
+
+ bool update = !source || !!strcmp(source, system_event_log_tags);
+ bool newOne;
+
+ {
+ android::RWLock::AutoWLock writeLock(rwlock);
+
+ tag2total_const_iterator itot = tag2total.find(tag);
+
+ // unlikely except for dupes, or updates to uid list (more later)
+ if (itot != tag2total.end()) update = false;
+
+ newOne = tag2name.find(tag) == tag2name.end();
+ key2tag[Key] = tag;
+
+ if (Format.length()) {
+ if (key2tag.find(Name) == key2tag.end()) {
+ key2tag[Name] = tag;
+ }
+ tag2format[tag] = Format;
+ }
+ tag2name[tag] = Name;
+
+ tag2uid_const_iterator ut = tag2uid.find(tag);
+ if (ut != tag2uid.end()) {
+ if (uid == AID_ROOT) {
+ tag2uid.erase(ut);
+ update = true;
+ } else if (ut->second.find(uid) == ut->second.end()) {
+ const_cast<uid_list&>(ut->second).emplace(uid);
+ update = true;
+ }
+ } else if (newOne && (uid != AID_ROOT)) {
+ tag2uid[tag].emplace(uid);
+ update = true;
+ }
+
+ // updatePersist -> trigger output on modified
+ // content, reset tag2total if available
+ if (update && (itot != tag2total.end())) tag2total[tag] = 0;
+ }
+
+ if (update) {
+ WritePersistEventLogTags(tag, uid, source);
+ } else if (warn && !newOne && source) {
+ // For the files, we want to report dupes.
+ android::prdebug("Multiple tag %" PRIu32 " %s %s %s", tag,
+ Name.c_str(), Format.c_str(), source);
+ }
+}
+
+// Read the event log tags file, and build up our internal database
+void LogTags::ReadFileEventLogTags(const char* filename, bool warn) {
+ bool etc = !strcmp(filename, system_event_log_tags);
+ bool debug = !etc && !strcmp(filename, debug_event_log_tags);
+
+ if (!etc) {
+ RebuildFileEventLogTags(filename, warn);
+ }
+ std::string content;
+ if (android::base::ReadFileToString(filename, &content)) {
+ char* cp = (char*) content.c_str();
+ char* endp = cp + content.length();
+
+ {
+ android::RWLock::AutoRLock writeLock(rwlock);
+
+ file2watermark[filename] = content.length();
+ }
+
+ char* lineStart = cp;
+ while (cp < endp) {
+ if (*cp == '\n') {
+ lineStart = cp;
+ } else if (lineStart) {
+ if (*cp == '#') {
+ /* comment; just scan to end */
+ lineStart = NULL;
+ } else if (isdigit(*cp)) {
+ unsigned long Tag = strtoul(cp, &cp, 10);
+ if (warn && (Tag > emptyTag)) {
+ android::prdebug("tag too large %lu", Tag);
+ }
+ while ((cp < endp) && (*cp != '\n') && isspace(*cp)) ++cp;
+ if (cp >= endp) break;
+ if (*cp == '\n') continue;
+ const char* name = cp;
+ /* Determine whether it is a valid tag name [a-zA-Z0-9_] */
+ bool hasAlpha = false;
+ while ((cp < endp) && (isalnum(*cp) || (*cp == '_'))) {
+ if (!isdigit(*cp)) hasAlpha = true;
+ ++cp;
+ }
+ std::string Name(name, cp - name);
+#ifdef ALLOW_NOISY_LOGGING_OF_PROBLEM_WITH_LOTS_OF_TECHNICAL_DEBT
+ static const size_t maximum_official_tag_name_size = 24;
+ if (warn && (Name.length() > maximum_official_tag_name_size)) {
+ android::prdebug("tag name too long %s", Name.c_str());
+ }
+#endif
+ if (hasAlpha && ((cp >= endp) || (*cp == '#') || isspace(*cp))) {
+ if (Tag > emptyTag) {
+ if (*cp != '\n') lineStart = NULL;
+ continue;
+ }
+ while ((cp < endp) && (*cp != '\n') && isspace(*cp)) ++cp;
+ const char* format = cp;
+ uid_t uid = AID_ROOT;
+ while ((cp < endp) && (*cp != '\n')) {
+ if (*cp == '#') {
+ uid = sniffUid(cp, endp);
+ lineStart = NULL;
+ break;
+ }
+ ++cp;
+ }
+ while ((cp > format) && isspace(cp[-1])) {
+ --cp;
+ lineStart = NULL;
+ }
+ std::string Format(format, cp - format);
+
+ AddEventLogTags((uint32_t)Tag, uid, Name, Format,
+ filename, warn);
+ } else {
+ if (warn) {
+ android::prdebug("tag name invalid %.*s",
+ (int)(cp - name + 1), name);
+ }
+ lineStart = NULL;
+ }
+ } else if (!isspace(*cp)) break;
+ }
+ cp++;
+ }
+ } else if (warn) {
+ android::prdebug("Cannot read %s", filename);
+ }
+}
+
+// Extract a 4-byte value from a byte stream.
+static inline uint32_t get4LE(const char* msg)
+{
+ const uint8_t* src = reinterpret_cast<const uint8_t*>(msg);
+ return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
+}
+
+// Additional persistent sources for invented log tags. Read the
+// special pmsg event for log tags, and build up our internal
+// database with any found.
+void LogTags::ReadPersistEventLogTags() {
+ struct logger_list* logger_list = android_logger_list_alloc(
+ ANDROID_LOG_RDONLY | ANDROID_LOG_PSTORE | ANDROID_LOG_NONBLOCK,
+ 0, (pid_t)0);
+ if (!logger_list) return;
+
+ struct logger* e = android_logger_open(logger_list, LOG_ID_EVENTS);
+ struct logger* s = android_logger_open(logger_list, LOG_ID_SECURITY);
+ if (!e && !s) {
+ android_logger_list_free(logger_list);
+ return;
+ }
+
+ for (;;) {
+ struct log_msg log_msg;
+ int ret = android_logger_list_read(logger_list, &log_msg);
+ if (ret <= 0) break;
+
+ const char* msg = log_msg.msg();
+ if (!msg) continue;
+ if (log_msg.entry.len <= sizeof(uint32_t)) continue;
+ uint32_t Tag = get4LE(msg);
+ if (Tag != TAG_DEF_LOG_TAG) continue;
+ uid_t uid = (log_msg.entry.hdr_size >= sizeof(logger_entry_v4)) ?
+ log_msg.entry.uid : AID_ROOT;
+
+ std::string Name;
+ std::string Format;
+ android_log_list_element elem;
+ {
+ android_log_event_list ctx(log_msg);
+ elem = ctx.read();
+ if (elem.type != EVENT_TYPE_LIST) {
+ continue;
+ }
+ elem = ctx.read();
+ if (elem.type != EVENT_TYPE_INT) {
+ continue;
+ }
+ Tag = elem.data.int32;
+ elem = ctx.read();
+ if (elem.type != EVENT_TYPE_STRING) {
+ continue;
+ }
+ Name = std::string(elem.data.string, elem.len);
+ elem = ctx.read();
+ if (elem.type != EVENT_TYPE_STRING) {
+ continue;
+ }
+ Format = std::string(elem.data.string, elem.len);
+ elem = ctx.read();
+ }
+ if ((elem.type != EVENT_TYPE_LIST_STOP) || !elem.complete) continue;
+
+ AddEventLogTags(Tag, uid, Name, Format);
+ }
+ android_logger_list_free(logger_list);
+}
+
+LogTags::LogTags() {
+ ReadFileEventLogTags(system_event_log_tags);
+ // Following will likely fail on boot, but is required if logd restarts
+ ReadFileEventLogTags(dynamic_event_log_tags, false);
+ if (__android_log_is_debuggable()) {
+ ReadFileEventLogTags(debug_event_log_tags, false);
+ }
+ ReadPersistEventLogTags();
+
+ logtags = this;
+}
+
+// Converts an event tag into a name
+const char* LogTags::tagToName(uint32_t tag) const {
+ tag2name_const_iterator it;
+
+ android::RWLock::AutoRLock readLock(const_cast<android::RWLock&>(rwlock));
+
+ it = tag2name.find(tag);
+ if ((it == tag2name.end()) || (it->second.length() == 0)) return NULL;
+
+ return it->second.c_str();
+}
+
+// Prototype in LogUtils.h allowing external access to our database.
+//
+// This must be a pure reader to our database, as everything else is
+// guaranteed single-threaded except this access point which is
+// asynchonous and can be multithreaded and thus rentrant. The
+// object's rwlock is only used to guarantee atomic access to the
+// unordered_map to prevent corruption, with a requirement to be a
+// low chance of contention for this call. If we end up changing
+// this algorithm resulting in write, then we should use a different
+// lock than the object's rwlock to protect groups of associated
+// actions.
+const char* android::tagToName(uint32_t tag) {
+ LogTags* me = logtags;
+
+ if (!me) return NULL;
+ me->WritePmsgEventLogTags(tag);
+ return me->tagToName(tag);
+}
+
+// Prototype in LogUtils.h allowing external access to our database.
+//
+// This only works on userdebug and eng devices to re-read the
+// /data/misc/logd/event-log-tags file right after /data is mounted.
+// The operation is near to boot and should only happen once. There
+// are races associated with its use since it can trigger a Rebuild
+// of the file, but that is a can-not-happen since the file was not
+// read yet. More dangerous if called later, but if all is well it
+// should just skip over everything and not write any new entries.
+void android::ReReadEventLogTags() {
+ LogTags* me = logtags;
+
+ if (me && __android_log_is_debuggable()) {
+ me->ReadFileEventLogTags(me->debug_event_log_tags);
+ }
+}
+
+// converts an event tag into a format
+const char* LogTags::tagToFormat(uint32_t tag) const {
+ tag2format_const_iterator iform;
+
+ android::RWLock::AutoRLock readLock(const_cast<android::RWLock&>(rwlock));
+
+ iform = tag2format.find(tag);
+ if (iform == tag2format.end()) return NULL;
+
+ return iform->second.c_str();
+}
+
+// converts a name into an event tag
+uint32_t LogTags::nameToTag(const char* name) const {
+ uint32_t ret = emptyTag;
+
+ // Bug: Only works for a single entry, we can have multiple entries,
+ // one for each format, so we find first entry recorded, or entry with
+ // no format associated with it.
+
+ android::RWLock::AutoRLock readLock(const_cast<android::RWLock&>(rwlock));
+
+ key2tag_const_iterator ik = key2tag.find(std::string(name));
+ if (ik != key2tag.end()) ret = ik->second;
+
+ return ret;
+}
+
+// Caller must perform locks, can be under reader (for pre-check) or
+// writer lock. We use this call to invent a new deterministically
+// random tag, unique is cleared if no conflicts. If format is NULL,
+// we are in readonly mode.
+uint32_t LogTags::nameToTag_locked(const std::string& name,
+ const char* format,
+ bool& unique) {
+ key2tag_const_iterator ik;
+
+ bool write = format != NULL;
+ unique = write;
+
+ if (!write) {
+ // Bug: Only works for a single entry, we can have multiple entries,
+ // one for each format, so we find first entry recorded, or entry with
+ // no format associated with it.
+ ik = key2tag.find(name);
+ if (ik == key2tag.end()) return emptyTag;
+ return ik->second;
+ }
+
+ std::string Key(name);
+ if (*format) Key += std::string("+") + format;
+
+ ik = key2tag.find(Key);
+ if (ik != key2tag.end()) {
+ unique = false;
+ return ik->second;
+ }
+
+ size_t Hash = key2tag.hash_function()(Key);
+ uint32_t Tag = Hash;
+ // This sets an upper limit on the conflics we are allowed to deal with.
+ for (unsigned i = 0; i < 256; ) {
+ tag2name_const_iterator it = tag2name.find(Tag);
+ if (it == tag2name.end()) return Tag;
+ std::string localKey(it->second);
+ tag2format_const_iterator iform = tag2format.find(Tag);
+ if ((iform == tag2format.end()) && iform->second.length()) {
+ localKey += "+" + iform->second;
+ }
+ unique = !!it->second.compare(localKey);
+ if (!unique) return Tag; // unlikely except in a race
+
+ ++i;
+ // Algorithm to convert hash to next tag
+ if (i < 32) {
+ Tag = (Hash >> i);
+ // size_t is 32 bits, or upper word zero, rotate
+ if ((sizeof(Hash) <= 4) ||
+ ((Hash & (uint64_t(-1LL) << 32)) == 0)) {
+ Tag |= Hash << (32 - i);
+ }
+ } else {
+ Tag = Hash + i - 31;
+ }
+ }
+ return emptyTag;
+}
+
+static int openFile(const char* name, int mode, bool warning) {
+ int fd = TEMP_FAILURE_RETRY(open(name, mode));
+ if ((fd < 0) && warning) {
+ android::prdebug("Failed open %s (%d)", name, errno);
+ }
+ return fd;
+}
+
+void LogTags::WritePmsgEventLogTags(uint32_t tag, uid_t uid) {
+ android::RWLock::AutoRLock readLock(rwlock);
+
+ tag2total_const_iterator itot = tag2total.find(tag);
+ if (itot == tag2total.end()) return; // source is a static entry
+
+ size_t lastTotal = itot->second;
+
+ // Every 16K (half the smallest configurable pmsg buffer size) record
+ static const size_t rate_to_pmsg = 16 * 1024;
+ if (lastTotal && ((android::sizesTotal() - lastTotal) < rate_to_pmsg)) {
+ return;
+ }
+
+ static int pmsg_fd = -1;
+ if (pmsg_fd < 0) {
+ pmsg_fd = TEMP_FAILURE_RETRY(open("/dev/pmsg0", O_WRONLY | O_CLOEXEC));
+ // unlikely, but deal with partners with borken pmsg
+ if (pmsg_fd < 0) return;
+ }
+
+ std::string Name = tag2name[tag];
+ tag2format_const_iterator iform = tag2format.find(tag);
+ std::string Format = (iform != tag2format.end()) ? iform->second : "";
+
+ __android_log_event_list ctx(TAG_DEF_LOG_TAG);
+ ctx << tag << Name << Format;
+ std::string buffer(ctx);
+ if (buffer.length() <= 0) return; // unlikely
+
+ /*
+ * struct {
+ * // what we provide to pstore
+ * android_pmsg_log_header_t pmsgHeader;
+ * // what we provide to file
+ * android_log_header_t header;
+ * // caller provides
+ * union {
+ * struct {
+ * char prio;
+ * char payload[];
+ * } string;
+ * struct {
+ * uint32_t tag
+ * char payload[];
+ * } binary;
+ * };
+ * };
+ */
+
+ struct timespec ts;
+ clock_gettime(android_log_clockid(), &ts);
+
+ android_log_header_t header = {
+ .id = LOG_ID_EVENTS,
+ .tid = (uint16_t)gettid(),
+ .realtime.tv_sec = (uint32_t)ts.tv_sec,
+ .realtime.tv_nsec = (uint32_t)ts.tv_nsec,
+ };
+
+ uint32_t outTag = TAG_DEF_LOG_TAG;
+ outTag = get4LE((const char*)&outTag);
+
+ android_pmsg_log_header_t pmsgHeader = {
+ .magic = LOGGER_MAGIC,
+ .len = (uint16_t)(sizeof(pmsgHeader) + sizeof(header) +
+ sizeof(outTag) + buffer.length()),
+ .uid = (uint16_t)AID_ROOT,
+ .pid = (uint16_t)getpid(),
+ };
+
+ struct iovec Vec[] = {
+ { (unsigned char*)&pmsgHeader, sizeof(pmsgHeader) },
+ { (unsigned char*)&header, sizeof(header) },
+ { (unsigned char*)&outTag, sizeof(outTag) },
+ { (unsigned char*)const_cast<char*>(buffer.data()), buffer.length() }
+ };
+
+ tag2uid_const_iterator ut = tag2uid.find(tag);
+ if (ut == tag2uid.end()) {
+ TEMP_FAILURE_RETRY(writev(pmsg_fd, Vec, arraysize(Vec)));
+ } else if (uid != AID_ROOT) {
+ pmsgHeader.uid = (uint16_t)uid;
+ TEMP_FAILURE_RETRY(writev(pmsg_fd, Vec, arraysize(Vec)));
+ } else {
+ for (auto &it : ut->second) {
+ pmsgHeader.uid = (uint16_t)it;
+ TEMP_FAILURE_RETRY(writev(pmsg_fd, Vec, arraysize(Vec)));
+ }
+ }
+}
+
+void LogTags::WriteDynamicEventLogTags(uint32_t tag, uid_t uid) {
+ static const int mode = O_WRONLY | O_APPEND |
+ O_CLOEXEC | O_NOFOLLOW | O_BINARY;
+
+ int fd = openFile(dynamic_event_log_tags, mode, true);
+ if (fd < 0) return;
+
+ android::RWLock::AutoWLock writeLock(rwlock);
+
+ std::string ret = formatEntry_locked(tag, uid, false);
+ android::base::WriteStringToFd(ret, fd);
+ TEMP_FAILURE_RETRY(close(fd));
+
+ size_t size = 0;
+ file2watermark_const_iterator iwater;
+
+ iwater = file2watermark.find(dynamic_event_log_tags);
+ if (iwater != file2watermark.end()) size = iwater->second;
+
+ file2watermark[dynamic_event_log_tags] = size + ret.length();
+}
+
+void LogTags::WriteDebugEventLogTags(uint32_t tag, uid_t uid) {
+ static const int mode = O_WRONLY | O_APPEND |
+ O_CLOEXEC | O_NOFOLLOW | O_BINARY;
+
+ static bool one = true;
+ int fd = openFile(debug_event_log_tags, mode, one);
+ one = fd >= 0;
+ if (!one) return;
+
+ android::RWLock::AutoWLock writeLock(rwlock);
+
+ std::string ret = formatEntry_locked(tag, uid, false);
+ android::base::WriteStringToFd(ret, fd);
+ TEMP_FAILURE_RETRY(close(fd));
+
+ size_t size = 0;
+ file2watermark_const_iterator iwater;
+
+ iwater = file2watermark.find(debug_event_log_tags);
+ if (iwater != file2watermark.end()) size = iwater->second;
+
+ file2watermark[debug_event_log_tags] = size + ret.length();
+}
+
+// How we maintain some runtime or reboot stickiness
+void LogTags::WritePersistEventLogTags(uint32_t tag,
+ uid_t uid, const char* source) {
+ // very unlikely
+ bool etc = source && !strcmp(source, system_event_log_tags);
+ if (etc) return;
+
+ bool dynamic = source && !strcmp(source, dynamic_event_log_tags);
+ bool debug = (!dynamic &&
+ source &&
+ !strcmp(source, debug_event_log_tags)) ||
+ !__android_log_is_debuggable();
+
+ WritePmsgEventLogTags(tag, uid);
+
+ size_t lastTotal = 0;
+ {
+ android::RWLock::AutoRLock readLock(rwlock);
+
+ tag2total_const_iterator itot = tag2total.find(tag);
+ if (itot != tag2total.end()) lastTotal = itot->second;
+ }
+
+ if (lastTotal == 0) { // denotes first time for this one
+ if (!dynamic || !RebuildFileEventLogTags(dynamic_event_log_tags)) {
+ WriteDynamicEventLogTags(tag, uid);
+ }
+
+ if (!debug && !RebuildFileEventLogTags(debug_event_log_tags)) {
+ WriteDebugEventLogTags(tag, uid);
+ }
+ }
+
+ lastTotal = android::sizesTotal();
+ if (!lastTotal) ++lastTotal;
+
+ // record totals for next watermark.
+ android::RWLock::AutoWLock writeLock(rwlock);
+ tag2total[tag] = lastTotal;
+}
+
+// nameToTag converts a name into an event tag. If format is NULL, then we
+// are in readonly mode.
+uint32_t LogTags::nameToTag(uid_t uid, const char* name, const char* format) {
+ std::string Name = std::string(name);
+ bool write = format != NULL;
+ bool updateUid = uid != AID_ROOT;
+ bool updateFormat = format && *format;
+ bool unique;
+ uint32_t Tag;
+
+ {
+ android::RWLock::AutoRLock readLock(rwlock);
+
+ Tag = nameToTag_locked(Name, format, unique);
+ if (updateUid && (Tag != emptyTag) && !unique) {
+ tag2uid_const_iterator ut = tag2uid.find(Tag);
+ if (updateUid) {
+ if ((ut != tag2uid.end()) &&
+ (ut->second.find(uid) == ut->second.end())) {
+ unique = write; // write passthrough to update uid counts
+ if (!write) Tag = emptyTag; // deny read access
+ }
+ } else {
+ unique = write && (ut != tag2uid.end());
+ }
+ }
+ }
+
+ if (Tag == emptyTag) return Tag;
+ WritePmsgEventLogTags(Tag, uid); // record references periodically
+ if (!unique) return Tag;
+
+ bool updateWrite = false;
+ bool updateTag;
+
+ // Special case of AddEventLogTags, checks per-uid counter which makes
+ // no sense there, and is also optimized somewhat to reduce write times.
+ {
+ android::RWLock::AutoWLock writeLock(rwlock);
+
+ // double check after switch from read lock to write lock for Tag
+ updateTag = tag2name.find(Tag) == tag2name.end();
+ // unlikely, either update, race inviting conflict or multiple uids
+ if (!updateTag) {
+ Tag = nameToTag_locked(Name, format, unique);
+ if (Tag == emptyTag) return Tag;
+ // is it multiple uid's setting this value
+ if (!unique) {
+ tag2uid_const_iterator ut = tag2uid.find(Tag);
+ if (updateUid) {
+ // Add it to the uid list
+ if ((ut == tag2uid.end()) ||
+ (ut->second.find(uid) != ut->second.end())) return Tag;
+ const_cast<uid_list&>(ut->second).emplace(uid);
+ updateWrite = true;
+ } else {
+ if (ut == tag2uid.end()) return Tag;
+ // (system) adding a global one, erase the uid list
+ tag2uid.erase(ut);
+ updateWrite = true;
+ }
+ }
+ }
+
+ // Update section
+ size_t count;
+ if (updateUid) {
+ count = 0;
+ uid2count_const_iterator ci = uid2count.find(uid);
+ if (ci != uid2count.end()) {
+ count = ci->second;
+ if (count >= max_per_uid) {
+ if (!updateWrite) return emptyTag;
+ // If we are added to the per-Uid perms, leak the Tag
+ // if it already exists.
+ updateUid = false;
+ updateTag = false;
+ updateFormat = false;
+ }
+ }
+ }
+
+ // updateWrite -> trigger output on modified content, reset tag2total
+ // also sets static to dynamic entries if they are alterred,
+ // only occurs if they have a uid, and runtime adds another uid.
+ if (updateWrite) tag2total[Tag] = 0;
+
+ if (updateTag) {
+ // mark as a dynamic entry, but do not upset current total counter
+ tag2total_const_iterator itot = tag2total.find(Tag);
+ if (itot == tag2total.end()) tag2total[Tag] = 0;
+
+ if (*format) {
+ key2tag[Name + "+" + format] = Tag;
+ if (key2tag.find(Name) == key2tag.end()) key2tag[Name] = Tag;
+ } else {
+ key2tag[Name] = Tag;
+ }
+ tag2name[Tag] = Name;
+ }
+ if (updateFormat) tag2format[Tag] = format;
+
+ if (updateUid) {
+ tag2uid[Tag].emplace(uid);
+ uid2count[uid] = count + 1;
+ }
+ }
+
+ if (updateTag || updateFormat || updateWrite) {
+ WritePersistEventLogTags(Tag, uid);
+ }
+
+ return Tag;
+}
+
+std::string LogTags::formatEntry(uint32_t tag, uid_t uid,
+ const char* name,
+ const char* format) {
+ if (!format || !format[0]) {
+ return android::base::StringPrintf("%" PRIu32 "\t%s\n", tag, name);
+ }
+ size_t len = (strlen(name) + 7) / 8;
+ static const char tabs[] = "\t\t\t";
+ if (len > strlen(tabs)) len = strlen(tabs);
+ std::string Uid;
+ if (uid != AID_ROOT) Uid = android::base::StringPrintf(" # uid=%u", uid);
+ return android::base::StringPrintf("%" PRIu32 "\t%s%s\t%s%s\n",
+ tag, name, &tabs[len], format,
+ Uid.c_str());
+}
+
+std::string LogTags::formatEntry_locked(uint32_t tag, uid_t uid,
+ bool authenticate) {
+ const char* name = tag2name[tag].c_str();
+
+ const char* format = "";
+ tag2format_const_iterator iform = tag2format.find(tag);
+ if (iform != tag2format.end()) format = iform->second.c_str();
+
+ // Access permission test, do not report dynamic entries
+ // that do not belong to us.
+ tag2uid_const_iterator ut = tag2uid.find(tag);
+ if (ut == tag2uid.end()) {
+ return formatEntry(tag, AID_ROOT, name, format);
+ }
+ if (uid != AID_ROOT) {
+ if (authenticate && (ut->second.find(uid) == ut->second.end())) {
+ return std::string("");
+ }
+ return formatEntry(tag, uid, name, format);
+ }
+
+ // Show all, one for each registered uid (we are group root)
+ std::string ret;
+ for (auto &it : ut->second) {
+ ret += formatEntry(tag, it, name, format);
+ }
+ return ret;
+}
+
+std::string LogTags::formatGetEventTag(uid_t uid,
+ const char* name, const char* format) {
+ bool all = name && (name[0] == '*') && !name[1];
+ bool list = !name || all;
+ std::string ret;
+
+ if (!list) {
+ // switch to read entry only if format == "*"
+ if (format && (format[0] == '*') && !format[1]) format = NULL;
+
+ // WAI: for null format, only works for a single entry, we can have
+ // multiple entries, one for each format, so we find first entry
+ // recorded, or entry with no format associated with it.
+ // We may desire to print all that match the name, but we did not
+ // add a mapping table for that and the cost is too high.
+ uint32_t tag = nameToTag(uid, name, format);
+ if (tag == emptyTag) return std::string("-1 ESRCH");
+ if (uid == AID_ROOT) {
+ android::RWLock::AutoRLock readLock(rwlock);
+
+ // first uid in list so as to manufacture an accurate reference
+ tag2uid_const_iterator ut = tag2uid.find(tag);
+ if ((ut != tag2uid.end()) &&
+ (ut->second.begin() != ut->second.end())) {
+ uid = *(ut->second.begin());
+ }
+ }
+ ret = formatEntry(tag, uid, name, format ?: tagToFormat(tag));
+ if (!ret.length()) return std::string("-1 ESRCH");
+ return ret;
+ }
+
+ android::RWLock::AutoRLock readLock(rwlock);
+ if (all) {
+ // everything under the sun
+ for (const auto& it : tag2name) {
+ ret += formatEntry_locked(it.first, uid);
+ }
+ } else {
+ // set entries are dynamic
+ for (const auto& it : tag2total) {
+ ret += formatEntry_locked(it.first, uid);
+ }
+ }
+ return ret;
+}
diff --git a/logd/LogTags.h b/logd/LogTags.h
new file mode 100644
index 0000000..37a6d96
--- /dev/null
+++ b/logd/LogTags.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#ifndef _LOGD_LOG_TAGS_H__
+#define _LOGD_LOG_TAGS_H__
+
+#include <unordered_map>
+#include <unordered_set>
+#include <string>
+
+#include <utils/RWLock.h>
+
+class LogTags {
+ // This lock protects all the unordered_map accesses below. It
+ // is a reader/writer lock so that contentions are kept to a
+ // minimum since writes are rare, even administratably when
+ // reads are extended. Resist the temptation to use the writer
+ // lock to protect anything outside the following unordered_maps
+ // as that would increase the reader contentions. Use a separate
+ // mutex to protect the other entities.
+ android::RWLock rwlock;
+
+ // key is Name + "+" + Format
+ std::unordered_map<std::string, uint32_t> key2tag;
+ typedef std::unordered_map<std::string, uint32_t>::const_iterator key2tag_const_iterator;
+
+ // Allows us to manage access permissions based on uid registrants
+ // Global entries are specifically erased.
+ typedef std::unordered_set<uid_t> uid_list;
+ std::unordered_map<uint32_t, uid_list> tag2uid;
+ typedef std::unordered_map<uint32_t, uid_list>::const_iterator tag2uid_const_iterator;
+
+ std::unordered_map<uint32_t, std::string> tag2name;
+ typedef std::unordered_map<uint32_t, std::string>::const_iterator tag2name_const_iterator;
+
+ std::unordered_map<uint32_t, std::string> tag2format;
+ typedef std::unordered_map<uint32_t, std::string>::const_iterator tag2format_const_iterator;
+
+ static const size_t max_per_uid = 256; // Put a cap on the tags per uid
+ std::unordered_map<uid_t, size_t> uid2count;
+ typedef std::unordered_map<uid_t, size_t>::const_iterator uid2count_const_iterator;
+
+ // Dynamic entries are assigned
+ std::unordered_map<uint32_t, size_t> tag2total;
+ typedef std::unordered_map<uint32_t, size_t>::const_iterator tag2total_const_iterator;
+
+ // emplace unique tag
+ uint32_t nameToTag(uid_t uid, const char* name, const char* format);
+ // find unique or associated tag
+ uint32_t nameToTag_locked(const std::string& name, const char* format, bool &unique);
+
+ // Record expected file watermarks to detect corruption.
+ std::unordered_map<std::string, size_t> file2watermark;
+ typedef std::unordered_map<std::string, size_t>::const_iterator file2watermark_const_iterator;
+
+ void ReadPersistEventLogTags();
+
+ // format helpers
+ // format a single entry, does not need object data
+ static std::string formatEntry(uint32_t tag, uid_t uid,
+ const char* name, const char* format);
+ // caller locks, database lookup, authenticate against uid
+ std::string formatEntry_locked(uint32_t tag, uid_t uid,
+ bool authenticate = true);
+
+ bool RebuildFileEventLogTags(const char* filename, bool warn = true);
+
+ void AddEventLogTags(uint32_t tag, uid_t uid,
+ const std::string& Name, const std::string& Format,
+ const char* source = NULL, bool warn = false);
+
+ void WriteDynamicEventLogTags(uint32_t tag, uid_t uid);
+ void WriteDebugEventLogTags(uint32_t tag, uid_t uid);
+ // push tag details to persistent storage
+ void WritePersistEventLogTags(uint32_t tag,
+ uid_t uid = AID_ROOT,
+ const char* source = NULL);
+
+ static const uint32_t emptyTag = uint32_t(-1);
+
+public:
+
+ static const char system_event_log_tags[];
+ static const char dynamic_event_log_tags[];
+ // Only for userdebug and eng
+ static const char debug_event_log_tags[];
+
+ LogTags();
+
+ void WritePmsgEventLogTags(uint32_t tag, uid_t uid = AID_ROOT);
+ void ReadFileEventLogTags(const char* filename, bool warn = true);
+
+ // reverse lookup from tag
+ const char* tagToName(uint32_t tag) const;
+ const char* tagToFormat(uint32_t tag) const;
+ // find associated tag
+ uint32_t nameToTag(const char* name) const;
+
+ // emplace tag if necessary, provide event-log-tag formated output in string
+ std::string formatGetEventTag(uid_t uid,
+ const char* name,
+ const char* format);
+};
+
+#endif // _LOGD_LOG_TAGS_H__
diff --git a/logd/LogUtils.h b/logd/LogUtils.h
index 70f24e4..f044b27 100644
--- a/logd/LogUtils.h
+++ b/logd/LogUtils.h
@@ -39,8 +39,9 @@
char *pidToName(pid_t pid);
char *tidToName(pid_t tid);
-// Furnished in main.cpp. Thread safe.
-const char *tagToName(size_t *len, uint32_t tag);
+// Furnished in LogTags.cpp. Thread safe.
+const char *tagToName(uint32_t tag);
+void ReReadEventLogTags();
// Furnished by LogKlog.cpp.
const char* strnstr(const char* s, size_t len, const char* needle);
diff --git a/logd/event.logtags b/logd/event.logtags
index 0d24df0..39063a9 100644
--- a/logd/event.logtags
+++ b/logd/event.logtags
@@ -35,3 +35,4 @@
1003 auditd (avc|3)
1004 chatty (dropped|3)
+1005 tag_def (tag|1),(name|3),(format|3)
diff --git a/logd/logd.rc b/logd/logd.rc
index 54349dd..ee89b83 100644
--- a/logd/logd.rc
+++ b/logd/logd.rc
@@ -14,3 +14,10 @@
user logd
group logd
writepid /dev/cpuset/system-background/tasks
+
+on fs
+ write /dev/event-log-tags "# content owned by logd
+"
+ chown logd logd /dev/event-log-tags
+ chmod 0644 /dev/event-log-tags
+ restorecon /dev/event-log-tags
diff --git a/logd/logtagd.rc b/logd/logtagd.rc
new file mode 100644
index 0000000..46aa8c1
--- /dev/null
+++ b/logd/logtagd.rc
@@ -0,0 +1,9 @@
+#
+# logtagd event log tag service (debug only)
+#
+on post-fs-data
+ mkdir /data/misc/logd 0700 logd log
+ write /data/misc/logd/event-log-tags ""
+ chown logd log /data/misc/logd/event-log-tags
+ chmod 0600 /data/misc/logd/event-log-tags
+ restorecon /data/misc/logd/event-log-tags
diff --git a/logd/main.cpp b/logd/main.cpp
index 5878f15..2551f2e 100644
--- a/logd/main.cpp
+++ b/logd/main.cpp
@@ -244,7 +244,7 @@
// anything else, we have even lesser privileges and accept our fate. Not
// worth checking for error returns setting this thread's privileges.
(void)setgid(AID_SYSTEM); // readonly access to /data/system/packages.list
- (void)setuid(AID_LOGD); // access to everything logd.
+ (void)setuid(AID_LOGD); // access to everything logd, eg /data/misc/logd
while (reinit_running && !sem_wait(&reinit) && reinit_running) {
@@ -271,6 +271,7 @@
logBuf->init();
logBuf->initPrune(NULL);
}
+ android::ReReadEventLogTags();
}
return NULL;
@@ -304,24 +305,6 @@
sem_post(&reinit);
}
-// tagToName converts an events tag into a name
-const char *android::tagToName(size_t *len, uint32_t tag) {
- static const EventTagMap *map;
-
- if (!map) {
- sem_wait(&sem_name);
- if (!map) {
- map = android_openEventTagMap(NULL);
- }
- sem_post(&sem_name);
- if (!map) {
- if (len) len = 0;
- return NULL;
- }
- }
- return android_lookupEventTag_len(map, len, tag);
-}
-
static void readDmesg(LogAudit *al, LogKlog *kl) {
if (!al && !kl) {
return;
diff --git a/logd/tests/logd_test.cpp b/logd/tests/logd_test.cpp
index 2a6cdc8..adf583b 100644
--- a/logd/tests/logd_test.cpp
+++ b/logd/tests/logd_test.cpp
@@ -39,12 +39,8 @@
#include "../libaudit.h" // pickup AUDIT_RATE_LIMIT_*
#include "../LogReader.h" // pickup LOGD_SNDTIMEO
-/*
- * returns statistics
- */
-static void my_android_logger_get_statistics(char *buf, size_t len)
+static void send_to_control(char* buf, size_t len)
{
- snprintf(buf, len, "getStatistics 0 1 2 3 4");
int sock = socket_local_client("logd",
ANDROID_SOCKET_NAMESPACE_RESERVED,
SOCK_STREAM);
@@ -52,7 +48,7 @@
if (write(sock, buf, strlen(buf) + 1) > 0) {
ssize_t ret;
while ((ret = read(sock, buf, len)) > 0) {
- if ((size_t)ret == len) {
+ if (((size_t)ret == len) || (len < PAGE_SIZE)) {
break;
}
len -= ret;
@@ -74,6 +70,15 @@
}
}
+/*
+ * returns statistics
+ */
+static void my_android_logger_get_statistics(char *buf, size_t len)
+{
+ snprintf(buf, len, "getStatistics 0 1 2 3 4");
+ send_to_control(buf, len);
+}
+
static void alloc_statistics(char **buffer, size_t *length)
{
size_t len = 8192;
@@ -816,6 +821,44 @@
close(fd);
}
+TEST(logd, getEventTag_list) {
+#ifdef __ANDROID__
+ char buffer[256];
+ memset(buffer, 0, sizeof(buffer));
+ snprintf(buffer, sizeof(buffer), "getEventTag name=*");
+ send_to_control(buffer, sizeof(buffer));
+ buffer[sizeof(buffer) - 1] = '\0';
+ char *cp;
+ long ret = strtol(buffer, &cp, 10);
+ EXPECT_GT(ret, 4096);
+#else
+ GTEST_LOG_(INFO) << "This test does nothing.\n";
+#endif
+}
+
+TEST(logd, getEventTag_newentry) {
+#ifdef __ANDROID__
+ char buffer[256];
+ memset(buffer, 0, sizeof(buffer));
+ log_time now(CLOCK_MONOTONIC);
+ char name[64];
+ snprintf(name, sizeof(name), "a%" PRIu64, now.nsec());
+ snprintf(buffer, sizeof(buffer),
+ "getEventTag name=%s format=\"(new|1)\"", name);
+ send_to_control(buffer, sizeof(buffer));
+ buffer[sizeof(buffer) - 1] = '\0';
+ char *cp;
+ long ret = strtol(buffer, &cp, 10);
+ EXPECT_GT(ret, 16);
+ EXPECT_TRUE(strstr(buffer, "\t(new|1)") != NULL);
+ EXPECT_TRUE(strstr(buffer, name) != NULL);
+ // ToDo: also look for this in /data/misc/logd/event-log-tags and
+ // /dev/event-log-tags.
+#else
+ GTEST_LOG_(INFO) << "This test does nothing.\n";
+#endif
+}
+
static inline int32_t get4LE(const char* src)
{
return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);