Merge "Revert "logd: remove start filtration from flushTo""
diff --git a/adb/adb.cpp b/adb/adb.cpp
index 23f6580..808d8ff 100644
--- a/adb/adb.cpp
+++ b/adb/adb.cpp
@@ -1241,10 +1241,7 @@
return true;
});
- D("update_transport_status: transports_ready = %s", result ? "true" : "false");
-
bool ready;
-
{
std::lock_guard<std::mutex> lock(init_mutex);
transports_ready = result;
@@ -1252,14 +1249,11 @@
}
if (ready) {
- D("update_transport_status: notifying");
init_cv.notify_all();
}
}
void adb_notify_device_scan_complete() {
- D("device scan complete");
-
{
std::lock_guard<std::mutex> lock(init_mutex);
device_scan_complete = true;
diff --git a/adb/client/usb_libusb.cpp b/adb/client/usb_libusb.cpp
index 18a8ff2..fc32469 100644
--- a/adb/client/usb_libusb.cpp
+++ b/adb/client/usb_libusb.cpp
@@ -151,10 +151,7 @@
static auto& usb_handles = *new std::unordered_map<std::string, std::unique_ptr<usb_handle>>();
static auto& usb_handles_mutex = *new std::mutex();
-static std::thread* device_poll_thread = nullptr;
-static bool terminate_device_poll_thread = false;
-static auto& device_poll_mutex = *new std::mutex();
-static auto& device_poll_cv = *new std::condition_variable();
+static libusb_hotplug_callback_handle hotplug_handle;
static std::string get_device_address(libusb_device* device) {
return StringPrintf("usb:%d:%d", libusb_get_bus_number(device),
@@ -175,6 +172,17 @@
path += "/serial";
return path;
}
+
+static std::string get_device_dev_path(libusb_device* device) {
+ uint8_t ports[7];
+ int port_count = libusb_get_port_numbers(device, ports, 7);
+ if (port_count < 0) return "";
+ return StringPrintf("/dev/bus/usb/%03u/%03u", libusb_get_bus_number(device), ports[0]);
+}
+
+static bool is_device_accessible(libusb_device* device) {
+ return access(get_device_dev_path(device).c_str(), R_OK | W_OK) == 0;
+}
#endif
static bool endpoint_is_output(uint8_t endpoint) {
@@ -229,7 +237,7 @@
// TODO: Is this assumption valid?
LOG(VERBOSE) << "skipping interface with incorrect num_altsetting at " << device_address
<< " (interface " << interface_num << ")";
- return;
+ continue;
}
const libusb_interface_descriptor& interface_desc = interface.altsetting[0];
@@ -237,7 +245,7 @@
interface_desc.bInterfaceProtocol)) {
LOG(VERBOSE) << "skipping non-adb interface at " << device_address << " (interface "
<< interface_num << ")";
- return;
+ continue;
}
LOG(VERBOSE) << "found potential adb interface at " << device_address << " (interface "
@@ -253,7 +261,7 @@
const uint8_t transfer_type = endpoint_attr & LIBUSB_TRANSFER_TYPE_MASK;
if (transfer_type != LIBUSB_TRANSFER_TYPE_BULK) {
- return;
+ continue;
}
if (endpoint_is_output(endpoint_addr) && !found_out) {
@@ -371,33 +379,62 @@
}
register_usb_transport(usb_handle_raw, device_serial.c_str(), device_address.c_str(), writable);
-
LOG(INFO) << "registered new usb device '" << device_serial << "'";
}
-static void poll_for_devices() {
- libusb_device** list;
- adb_thread_setname("device poll");
- while (true) {
- const ssize_t device_count = libusb_get_device_list(nullptr, &list);
+static std::atomic<int> connecting_devices(0);
- LOG(VERBOSE) << "found " << device_count << " attached devices";
-
- for (ssize_t i = 0; i < device_count; ++i) {
- process_device(list[i]);
+static void device_connected(libusb_device* device) {
+#if defined(__linux__)
+ // Android's host linux libusb uses netlink instead of udev for device hotplug notification,
+ // which means we can get hotplug notifications before udev has updated ownership/perms on the
+ // device. Since we're not going to be able to link against the system's libudev any time soon,
+ // hack around this by checking for accessibility in a loop.
+ ++connecting_devices;
+ auto thread = std::thread([device]() {
+ std::string device_path = get_device_dev_path(device);
+ auto start = std::chrono::steady_clock::now();
+ while (std::chrono::steady_clock::now() - start < 500ms) {
+ if (is_device_accessible(device)) {
+ break;
+ }
+ std::this_thread::sleep_for(10ms);
}
- libusb_free_device_list(list, 1);
+ process_device(device);
+ --connecting_devices;
+ });
+ thread.detach();
+#else
+ process_device(device);
+#endif
+}
- adb_notify_device_scan_complete();
+static void device_disconnected(libusb_device* device) {
+ std::string device_address = get_device_address(device);
- std::unique_lock<std::mutex> lock(device_poll_mutex);
- if (device_poll_cv.wait_for(lock, 500ms, []() { return terminate_device_poll_thread; })) {
- return;
+ LOG(INFO) << "device disconnected: " << device_address;
+ std::unique_lock<std::mutex> lock(usb_handles_mutex);
+ auto it = usb_handles.find(device_address);
+ if (it != usb_handles.end()) {
+ if (!it->second->device_handle) {
+ // If the handle is null, we were never able to open the device.
+ unregister_usb_transport(it->second.get());
}
+ usb_handles.erase(it);
}
}
+static int hotplug_callback(libusb_context*, libusb_device* device, libusb_hotplug_event event,
+ void*) {
+ if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED) {
+ device_connected(device);
+ } else if (event == LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT) {
+ device_disconnected(device);
+ }
+ return 0;
+}
+
void usb_init() {
LOG(DEBUG) << "initializing libusb...";
int rc = libusb_init(nullptr);
@@ -405,6 +442,24 @@
LOG(FATAL) << "failed to initialize libusb: " << libusb_error_name(rc);
}
+ // Register the hotplug callback.
+ rc = libusb_hotplug_register_callback(
+ nullptr, static_cast<libusb_hotplug_event>(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
+ LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
+ LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
+ LIBUSB_CLASS_PER_INTERFACE, hotplug_callback, nullptr, &hotplug_handle);
+
+ if (rc != LIBUSB_SUCCESS) {
+ LOG(FATAL) << "failed to register libusb hotplug callback";
+ }
+
+ // Wait for all of the connecting devices to finish.
+ while (connecting_devices != 0) {
+ std::this_thread::sleep_for(10ms);
+ }
+
+ adb_notify_device_scan_complete();
+
// Spawn a thread for libusb_handle_events.
std::thread([]() {
adb_thread_setname("libusb");
@@ -412,24 +467,10 @@
libusb_handle_events(nullptr);
}
}).detach();
-
- // Spawn a thread to do device enumeration.
- // TODO: Use libusb_hotplug_* instead?
- std::unique_lock<std::mutex> lock(device_poll_mutex);
- device_poll_thread = new std::thread(poll_for_devices);
}
void usb_cleanup() {
- {
- std::unique_lock<std::mutex> lock(device_poll_mutex);
- terminate_device_poll_thread = true;
-
- if (!device_poll_thread) {
- return;
- }
- }
- device_poll_cv.notify_all();
- device_poll_thread->join();
+ libusb_hotplug_deregister_callback(nullptr, hotplug_handle);
}
// Dispatch a libusb transfer, unlock |device_lock|, and then wait for the result.
diff --git a/adb/set_verity_enable_state_service.cpp b/adb/set_verity_enable_state_service.cpp
index b2b1c18..253d14a 100644
--- a/adb/set_verity_enable_state_service.cpp
+++ b/adb/set_verity_enable_state_service.cpp
@@ -139,25 +139,36 @@
bool any_changed = false;
bool enable = (cookie != NULL);
- if (!kAllowDisableVerity) {
- WriteFdFmt(fd, "%s-verity only works for userdebug builds\n",
- enable ? "enable" : "disable");
+
+ // Figure out if we're using VB1.0 or VB2.0 (aka AVB) - by
+ // contract, androidboot.vbmeta.digest is set by the bootloader
+ // when using AVB).
+ bool using_avb = !android::base::GetProperty("ro.boot.vbmeta.digest", "").empty();
+
+ // If using AVB, dm-verity is used on any build so we want it to
+ // be possible to disable/enable on any build (except USER). For
+ // VB1.0 dm-verity is only enabled on certain builds.
+ if (!using_avb) {
+ if (!kAllowDisableVerity) {
+ WriteFdFmt(fd, "%s-verity only works for userdebug builds\n",
+ enable ? "enable" : "disable");
+ }
+
+ if (!android::base::GetBoolProperty("ro.secure", false)) {
+ WriteFdFmt(fd, "verity not enabled - ENG build\n");
+ return;
+ }
}
- if (!android::base::GetBoolProperty("ro.secure", false)) {
- WriteFdFmt(fd, "verity not enabled - ENG build\n");
- return;
- }
+ // Should never be possible to disable dm-verity on a USER build
+ // regardless of using AVB or VB1.0.
if (!__android_log_is_debuggable()) {
WriteFdFmt(fd, "verity cannot be disabled/enabled - USER build\n");
return;
}
- // Figure out if we're using VB1.0 or VB2.0 (aka AVB).
- std::string vbmeta_hash = android::base::GetProperty("ro.boot.vbmeta.digest", "");
- if (vbmeta_hash != "") {
- // Yep, the system is using AVB (by contract, androidboot.vbmeta.hash is
- // set by the bootloader when using AVB).
+ if (using_avb) {
+ // Yep, the system is using AVB.
AvbOps* ops = avb_ops_user_new();
if (ops == nullptr) {
WriteFdFmt(fd, "Error getting AVB ops\n");
diff --git a/base/Android.bp b/base/Android.bp
index 81b96db..b636dc3 100644
--- a/base/Android.bp
+++ b/base/Android.bp
@@ -53,7 +53,6 @@
header_libs: [
"libbase_headers",
- "libutils_headers",
],
export_header_lib_headers: ["libbase_headers"],
diff --git a/base/file.cpp b/base/file.cpp
index 7fbebc5..a2f2887 100644
--- a/base/file.cpp
+++ b/base/file.cpp
@@ -32,13 +32,14 @@
#include "android-base/macros.h" // For TEMP_FAILURE_RETRY on Darwin.
#include "android-base/unique_fd.h"
#include "android-base/utf8.h"
-#include "utils/Compat.h"
#if defined(__APPLE__)
#include <mach-o/dyld.h>
#endif
#if defined(_WIN32)
#include <windows.h>
+#define O_CLOEXEC O_NOINHERIT
+#define O_NOFOLLOW 0
#endif
namespace android {
@@ -133,7 +134,7 @@
bool follow_symlinks) {
int flags = O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_BINARY |
(follow_symlinks ? 0 : O_NOFOLLOW);
- android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), flags, DEFFILEMODE)));
+ android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), flags, 0666)));
if (fd == -1) {
return false;
}
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index e1f289a..3e890c7 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1260,10 +1260,10 @@
fb_queue_command("flashing unlock_bootloader", "unlocking bootloader");
}
-static void do_oem_command(std::vector<std::string>* args) {
+static void do_oem_command(const std::string& cmd, std::vector<std::string>* args) {
if (args->empty()) syntax_error("empty oem command");
- std::string command("oem");
+ std::string command(cmd);
while (!args->empty()) {
command += " " + next_arg(args);
}
@@ -1766,7 +1766,7 @@
std::string filename = next_arg(&args);
fb_queue_upload(filename.c_str());
} else if (command == "oem") {
- do_oem_command(&args);
+ do_oem_command("oem", &args);
} else if (command == "flashing") {
if (args.empty()) {
syntax_error("missing 'flashing' command");
@@ -1776,7 +1776,7 @@
args[0] == "get_unlock_ability" ||
args[0] == "get_unlock_bootloader_nonce" ||
args[0] == "lock_bootloader")) {
- do_oem_command(&args);
+ do_oem_command("flashing", &args);
} else if (args.size() == 2 && args[0] == "unlock_bootloader") {
do_bypass_unlock_command(&args);
} else {
diff --git a/fs_mgr/fs_mgr_avb.cpp b/fs_mgr/fs_mgr_avb.cpp
index 2b32201..6618003 100644
--- a/fs_mgr/fs_mgr_avb.cpp
+++ b/fs_mgr/fs_mgr_avb.cpp
@@ -16,15 +16,14 @@
#include "fs_mgr_avb.h"
-#include <errno.h>
#include <fcntl.h>
-#include <inttypes.h>
#include <libgen.h>
-#include <stdio.h>
#include <string.h>
-#include <sys/stat.h>
+#include <sys/ioctl.h>
#include <sys/types.h>
-#include <unistd.h>
+
+#include <sstream>
+#include <string>
#include <vector>
#include <android-base/file.h>
@@ -33,11 +32,7 @@
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
-#include <cutils/properties.h>
#include <libavb/libavb.h>
-#include <openssl/sha.h>
-#include <sys/ioctl.h>
-#include <utils/Compat.h>
#include "fs_mgr.h"
#include "fs_mgr_priv.h"
@@ -45,48 +40,6 @@
#include "fs_mgr_priv_dm_ioctl.h"
#include "fs_mgr_priv_sha.h"
-/* The format of dm-verity construction parameters:
- * <version> <dev> <hash_dev> <data_block_size> <hash_block_size>
- * <num_data_blocks> <hash_start_block> <algorithm> <digest> <salt>
- */
-#define VERITY_TABLE_FORMAT \
- "%u %s %s %u %u " \
- "%" PRIu64 " %" PRIu64 " %s %s %s "
-
-#define VERITY_TABLE_PARAMS(hashtree_desc, blk_device, digest, salt) \
- hashtree_desc.dm_verity_version, blk_device, blk_device, hashtree_desc.data_block_size, \
- hashtree_desc.hash_block_size, \
- hashtree_desc.image_size / hashtree_desc.data_block_size, /* num_data_blocks. */ \
- hashtree_desc.tree_offset / hashtree_desc.hash_block_size, /* hash_start_block. */ \
- (char*)hashtree_desc.hash_algorithm, digest, salt
-
-#define VERITY_TABLE_OPT_RESTART "restart_on_corruption"
-#define VERITY_TABLE_OPT_IGNZERO "ignore_zero_blocks"
-
-/* The default format of dm-verity optional parameters:
- * <#opt_params> ignore_zero_blocks restart_on_corruption
- */
-#define VERITY_TABLE_OPT_DEFAULT_FORMAT "2 %s %s"
-#define VERITY_TABLE_OPT_DEFAULT_PARAMS VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART
-
-/* The FEC (forward error correction) format of dm-verity optional parameters:
- * <#opt_params> use_fec_from_device <fec_dev>
- * fec_roots <num> fec_blocks <num> fec_start <offset>
- * ignore_zero_blocks restart_on_corruption
- */
-#define VERITY_TABLE_OPT_FEC_FORMAT \
- "10 use_fec_from_device %s fec_roots %u fec_blocks %" PRIu64 " fec_start %" PRIu64 " %s %s"
-
-/* Note that fec_blocks is the size that FEC covers, *not* the
- * size of the FEC data. Since we use FEC for everything up until
- * the FEC data, it's the same as the offset (fec_start).
- */
-#define VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device) \
- blk_device, hashtree_desc.fec_num_roots, \
- hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_blocks */ \
- hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_start */ \
- VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART
-
static inline bool nibble_value(const char& c, uint8_t* value) {
FS_MGR_CHECK(value != nullptr);
@@ -280,10 +233,81 @@
return true;
}
-static bool hashtree_load_verity_table(struct dm_ioctl* io, const std::string& dm_device_name,
- int fd, const std::string& blk_device,
- const AvbHashtreeDescriptor& hashtree_desc,
- const std::string& salt, const std::string& root_digest) {
+// Constructs dm-verity arguments for sending DM_TABLE_LOAD ioctl to kernel.
+// See the following link for more details:
+// https://gitlab.com/cryptsetup/cryptsetup/wikis/DMVerity
+static std::string construct_verity_table(const AvbHashtreeDescriptor& hashtree_desc,
+ const std::string& salt, const std::string& root_digest,
+ const std::string& blk_device) {
+ // Loads androidboot.veritymode from kernel cmdline.
+ std::string verity_mode;
+ if (!fs_mgr_get_boot_config("veritymode", &verity_mode)) {
+ verity_mode = "enforcing"; // Defaults to enforcing when it's absent.
+ }
+
+ // Converts veritymode to the format used in kernel.
+ std::string dm_verity_mode;
+ if (verity_mode == "enforcing") {
+ dm_verity_mode = "restart_on_corruption";
+ } else if (verity_mode == "logging") {
+ dm_verity_mode = "ignore_corruption";
+ } else if (verity_mode != "eio") { // Default dm_verity_mode is eio.
+ LERROR << "Unknown androidboot.veritymode: " << verity_mode;
+ return "";
+ }
+
+ // dm-verity construction parameters:
+ // <version> <dev> <hash_dev>
+ // <data_block_size> <hash_block_size>
+ // <num_data_blocks> <hash_start_block>
+ // <algorithm> <digest> <salt>
+ // [<#opt_params> <opt_params>]
+ std::ostringstream verity_table;
+ verity_table << hashtree_desc.dm_verity_version << " " << blk_device << " " << blk_device << " "
+ << hashtree_desc.data_block_size << " " << hashtree_desc.hash_block_size << " "
+ << hashtree_desc.image_size / hashtree_desc.data_block_size << " "
+ << hashtree_desc.tree_offset / hashtree_desc.hash_block_size << " "
+ << hashtree_desc.hash_algorithm << " " << root_digest << " " << salt;
+
+ // Continued from the above optional parameters:
+ // [<#opt_params> <opt_params>]
+ int optional_argc = 0;
+ std::ostringstream optional_args;
+
+ // dm-verity optional parameters for FEC (forward error correction):
+ // use_fec_from_device <fec_dev>
+ // fec_roots <num>
+ // fec_blocks <num>
+ // fec_start <offset>
+ if (hashtree_desc.fec_size > 0) {
+ // Note that fec_blocks is the size that FEC covers, *NOT* the
+ // size of the FEC data. Since we use FEC for everything up until
+ // the FEC data, it's the same as the offset (fec_start).
+ optional_argc += 8;
+ // clang-format off
+ optional_args << "use_fec_from_device " << blk_device
+ << " fec_roots " << hashtree_desc.fec_num_roots
+ << " fec_blocks " << hashtree_desc.fec_offset / hashtree_desc.data_block_size
+ << " fec_start " << hashtree_desc.fec_offset / hashtree_desc.data_block_size
+ << " ";
+ // clang-format on
+ }
+
+ if (!dm_verity_mode.empty()) {
+ optional_argc += 1;
+ optional_args << dm_verity_mode << " ";
+ }
+
+ // Always use ignore_zero_blocks.
+ optional_argc += 1;
+ optional_args << "ignore_zero_blocks";
+
+ verity_table << " " << optional_argc << " " << optional_args.str();
+ return verity_table.str();
+}
+
+static bool load_verity_table(struct dm_ioctl* io, const std::string& dm_device_name, int fd,
+ uint64_t image_size, const std::string& verity_table) {
fs_mgr_verity_ioctl_init(io, dm_device_name, DM_STATUS_TABLE_FLAG);
// The buffer consists of [dm_ioctl][dm_target_spec][verity_params].
@@ -294,35 +318,25 @@
io->target_count = 1;
dm_target->status = 0;
dm_target->sector_start = 0;
- dm_target->length = hashtree_desc.image_size / 512;
+ dm_target->length = image_size / 512;
strcpy(dm_target->target_type, "verity");
// Builds the verity params.
char* verity_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
size_t bufsize = DM_BUF_SIZE - (verity_params - buffer);
- int res = 0;
- if (hashtree_desc.fec_size > 0) {
- res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT,
- VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
- salt.c_str()),
- VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device.c_str()));
- } else {
- res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT,
- VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
- salt.c_str()),
- VERITY_TABLE_OPT_DEFAULT_PARAMS);
- }
+ LINFO << "Loading verity table: '" << verity_table << "'";
- if (res < 0 || (size_t)res >= bufsize) {
- LERROR << "Error building verity table; insufficient buffer size?";
+ // Copies verity_table to verity_params (including the terminating null byte).
+ if (verity_table.size() > bufsize - 1) {
+ LERROR << "Verity table size too large: " << verity_table.size()
+ << " (max allowable size: " << bufsize - 1 << ")";
return false;
}
-
- LINFO << "Loading verity table: '" << verity_params << "'";
+ memcpy(verity_params, verity_table.c_str(), verity_table.size() + 1);
// Sets ext target boundary.
- verity_params += strlen(verity_params) + 1;
+ verity_params += verity_table.size() + 1;
verity_params = (char*)(((unsigned long)verity_params + 7) & ~7);
dm_target->next = verity_params - buffer;
@@ -362,9 +376,15 @@
return false;
}
+ std::string verity_table =
+ construct_verity_table(hashtree_desc, salt, root_digest, fstab_entry->blk_device);
+ if (verity_table.empty()) {
+ LERROR << "Failed to construct verity table.";
+ return false;
+ }
+
// Loads the verity mapping table.
- if (!hashtree_load_verity_table(io, mount_point, fd, std::string(fstab_entry->blk_device),
- hashtree_desc, salt, root_digest)) {
+ if (!load_verity_table(io, mount_point, fd, hashtree_desc.image_size, verity_table)) {
LERROR << "Couldn't load verity table!";
return false;
}
diff --git a/libcutils/ashmem-dev.c b/libcutils/ashmem-dev.c
index 92717c0..b4abb79 100644
--- a/libcutils/ashmem-dev.c
+++ b/libcutils/ashmem-dev.c
@@ -28,6 +28,7 @@
#include <string.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
+#include <sys/sysmacros.h>
#include <sys/types.h>
#include <unistd.h>
diff --git a/libmetricslogger/Android.bp b/libmetricslogger/Android.bp
index 75eab66..da8afe1 100644
--- a/libmetricslogger/Android.bp
+++ b/libmetricslogger/Android.bp
@@ -22,7 +22,7 @@
// 524291 corresponds to sysui_histogram, from
// frameworks/base/core/java/com/android/internal/logging/EventLogTags.logtags
- "-DHISTOGRAM_LOG_TAG=524291",
+ "-DHISTOGRAM_LOG_TAG=524292",
],
}
diff --git a/libmetricslogger/include/metricslogger/metrics_logger.h b/libmetricslogger/include/metricslogger/metrics_logger.h
index d30e56c..26aa189 100644
--- a/libmetricslogger/include/metricslogger/metrics_logger.h
+++ b/libmetricslogger/include/metricslogger/metrics_logger.h
@@ -24,5 +24,14 @@
// buffer.
void LogHistogram(const std::string& event, int32_t data);
+// TODO: replace these with the metric_logger.proto definitions
+enum {
+ LOGBUILDER_CATEGORY = 757,
+ LOGBUILDER_NAME = 799,
+ LOGBUILDER_BUCKET = 801,
+ LOGBUILDER_VALUE = 802,
+ LOGBUILDER_HISTOGRAM = 804,
+};
+
} // namespace metricslogger
} // namespace android
diff --git a/libmetricslogger/metrics_logger.cpp b/libmetricslogger/metrics_logger.cpp
index f8e0174..0d08f5c 100644
--- a/libmetricslogger/metrics_logger.cpp
+++ b/libmetricslogger/metrics_logger.cpp
@@ -23,9 +23,14 @@
namespace android {
namespace metricslogger {
+// Mirror com.android.internal.logging.MetricsLogger#histogram().
void LogHistogram(const std::string& event, int32_t data) {
android_log_event_list log(HISTOGRAM_LOG_TAG);
- log << event << data << LOG_ID_EVENTS;
+ log << LOGBUILDER_CATEGORY << LOGBUILDER_HISTOGRAM
+ << LOGBUILDER_NAME << event
+ << LOGBUILDER_BUCKET << data
+ << LOGBUILDER_VALUE << 1
+ << LOG_ID_EVENTS;
}
} // namespace metricslogger
diff --git a/libnetutils/Android.bp b/libnetutils/Android.bp
index f710ba2..68a74a0 100644
--- a/libnetutils/Android.bp
+++ b/libnetutils/Android.bp
@@ -17,3 +17,17 @@
export_include_dirs: ["include"],
}
+
+cc_binary {
+ name: "dhcptool",
+
+ srcs: [
+ "dhcptool.c",
+ ],
+
+ shared_libs: [
+ "libnetutils",
+ ],
+
+ cflags: ["-Werror"],
+}
diff --git a/libnetutils/dhcptool.c b/libnetutils/dhcptool.c
new file mode 100644
index 0000000..b3896c3
--- /dev/null
+++ b/libnetutils/dhcptool.c
@@ -0,0 +1,47 @@
+/*
+ * Copyright 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 <err.h>
+#include <errno.h>
+#include <error.h>
+#include <stdbool.h>
+#include <stdlib.h>
+
+#include <netutils/ifc.h>
+
+extern int do_dhcp(char*);
+
+int main(int argc, char* argv[]) {
+ if (argc != 2) {
+ error(EXIT_FAILURE, 0, "usage: %s INTERFACE", argv[0]);
+ }
+
+ char* interface = argv[1];
+ if (ifc_init()) {
+ err(errno, "dhcptool %s: ifc_init failed", interface);
+ ifc_close();
+ return EXIT_FAILURE;
+ }
+
+ int rc = do_dhcp(interface);
+ if (rc) {
+ err(errno, "dhcptool %s: do_dhcp failed", interface);
+ }
+
+ ifc_close();
+
+ return rc ? EXIT_FAILURE : EXIT_SUCCESS;
+}
diff --git a/logcat/logcat.cpp b/logcat/logcat.cpp
index 64d1d2f..e9ef9cc 100644
--- a/logcat/logcat.cpp
+++ b/logcat/logcat.cpp
@@ -530,6 +530,7 @@
" process — Display PID only.\n"
" raw — Display the raw log message, with no other metadata fields.\n"
" tag — Display the priority/tag only.\n"
+ " thread — Display priority, PID and TID of process issuing the message.\n"
" threadtime — Display the date, invocation time, priority, tag, and the PID\n"
" and TID of the thread issuing the message. (the default format).\n"
" time — Display the date, invocation time, priority/tag, and PID of the\n"
