Merge "Refactor incident_helper to use protoutil and cppstream plugin." (6b0ea8ae) · Commits · e / os / android_frameworks_base

Android.bp

+23 −1

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ cc_library {
		srcs: [
		"core/proto/*/.proto",
		"libs/incident/*/.proto",
		"tools/streaming_proto/stream.proto",
		],
		},
		android: {
		@@ -61,7 +62,7 @@ cc_library {
		"core/proto/android/os/pagetypeinfo.proto",
		"core/proto/android/os/procrank.proto",
		"core/proto/android/service/graphicsstats.proto",
		"libs/incident/proto/android/privacy.proto",
		"tools/streaming_proto/stream.proto",
		],
		shared: {
		enabled: false,
		@@ -70,6 +71,27 @@ cc_library {
		},
		}

		gensrcs {
		name: "gen-platform-proto-constants",
		depfile: true,

		tools: [
		"aprotoc",
		"protoc-gen-cppstream",
		],

		srcs: [
		"core/proto/android/os/kernelwake.proto",
		"core/proto/android/os/pagetypeinfo.proto",
		"core/proto/android/os/procrank.proto",
		],

		// Append protoc-gen-cppstream tool's PATH otherwise aprotoc can't find the plugin tool
		cmd: "PATH=$$PATH:$$(dirname $(location protoc-gen-cppstream)) $(location aprotoc) --plugin=protoc-gen-cpp-stream=$(location protoc-gen-cppstream) --dependency_out=$(depfile) --cppstream_out=$(genDir)/ -Iexternal/protobuf/src -I . $(in)",

		output_extension = "proto.h",
		}

		subdirs = [
		"cmds/*",
		"core/*",

Android.mk

+1 −0

Original line number	Diff line number	Diff line
		@@ -1553,6 +1553,7 @@ LOCAL_PROTOC_FLAGS := \
		-Iexternal/protobuf/src
		LOCAL_SOURCE_FILES_ALL_GENERATED := true
		LOCAL_SRC_FILES := \
		tools/streaming_proto/stream.proto \
		$(call all-proto-files-under, core/proto) \
		$(call all-proto-files-under, libs/incident/proto)
		include $(BUILD_HOST_JAVA_LIBRARY)

cmds/incident_helper/Android.bp

+20 −11

Original line number	Diff line number	Diff line
		@@ -8,44 +8,53 @@ cc_defaults {
		"-O0"
		],

		local_include_dirs: [
		"src/",
		"src/parsers/",
		],

		srcs: [
		"IncidentHelper.cpp",
		"ih_util.cpp",
		"src/parsers/*.cpp",
		"src/TextParserBase.cpp",
		"src/ih_util.cpp",
		],

		generated_headers: ["gen-platform-proto-constants"],

		shared_libs: [
		"libbase",
		"liblog",
		"libprotobuf-cpp-full",
		"libprotoutil",
		"libutils",
		],

		static_libs: [
		"libplatformprotos",
		],
		}

		cc_binary {
		name: "incident_helper",
		defaults: ["incident_helper_defaults"],
		srcs: ["main.cpp"],
		srcs: ["src/main.cpp"],
		}


		cc_test {
		name: "incident_helper_test",
		defaults: ["incident_helper_defaults"],
		local_include_dirs: ["src/"],

		srcs: [
		"tests/IncidentHelper_test.cpp",
		"tests/ih_util_test.cpp",
		"tests/*.cpp",
		],

		data: [
		"testdata/*",
		],

		shared_libs: [
		"libprotobuf-cpp-full",
		],

		static_libs: [
		"libgmock",
		"libplatformprotos"
		],
		}

cmds/incident_helper/IncidentHelper.cpp

deleted100644 → 0

+0 −327

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#define LOG_TAG "incident_helper"

		#include "IncidentHelper.h"
		#include "ih_util.h"

		#include "frameworks/base/core/proto/android/os/kernelwake.pb.h"
		#include "frameworks/base/core/proto/android/os/pagetypeinfo.pb.h"
		#include "frameworks/base/core/proto/android/os/procrank.pb.h"

		#include <android-base/file.h>
		#include <unistd.h>
		#include <string>
		#include <vector>

		using namespace android::base;
		using namespace android::os;
		using namespace google::protobuf;
		using namespace std;


		static const string TAB_DELIMITER = "\t";
		static const string COMMA_DELIMITER = ",";

		static inline int toInt(const string& s) {
		return atoi(s.c_str());
		}

		static inline long toLong(const string& s) {
		return atol(s.c_str());
		}

		/**
		* Sets the given protobuf message when the field name matches one of the
		* fields. It is useful to set values to proto from table-like plain texts.
		*/
		static bool
		SetTableField(::google::protobuf::Message* message, string field_name, string field_value) {
		const Descriptor* descriptor = message->GetDescriptor();
		const Reflection* reflection = message->GetReflection();

		const FieldDescriptor* field = descriptor->FindFieldByName(field_name);
		switch (field->type()) {
		case FieldDescriptor::TYPE_STRING:
		reflection->SetString(message, field, field_value);
		return true;
		case FieldDescriptor::TYPE_INT64:
		reflection->SetInt64(message, field, toLong(field_value));
		return true;
		case FieldDescriptor::TYPE_UINT64:
		reflection->SetUInt64(message, field, toLong(field_value));
		return true;
		case FieldDescriptor::TYPE_INT32:
		reflection->SetInt32(message, field, toInt(field_value));
		return true;
		case FieldDescriptor::TYPE_UINT32:
		reflection->SetUInt32(message, field, toInt(field_value));
		return true;
		default:
		// Add new scalar types
		return false;
		}
		}

		// ================================================================================
		status_t NoopParser::Parse(const int in, const int out) const
		{
		string content;
		if (!ReadFdToString(in, &content)) {
		fprintf(stderr, "[%s]Failed to read data from incidentd\n", this->name.string());
		return -1;
		}
		if (!WriteStringToFd(content, out)) {
		fprintf(stderr, "[%s]Failed to write data to incidentd\n", this->name.string());
		return -1;
		}
		return NO_ERROR;
		}

		// ================================================================================
		status_t ReverseParser::Parse(const int in, const int out) const
		{
		string content;
		if (!ReadFdToString(in, &content)) {
		fprintf(stderr, "[%s]Failed to read data from incidentd\n", this->name.string());
		return -1;
		}
		// reverse the content
		reverse(content.begin(), content.end());
		if (!WriteStringToFd(content, out)) {
		fprintf(stderr, "[%s]Failed to write data to incidentd\n", this->name.string());
		return -1;
		}
		return NO_ERROR;
		}

		// ================================================================================
		status_t KernelWakesParser::Parse(const int in, const int out) const {
		Reader reader(in);
		string line;
		header_t header; // the header of /d/wakeup_sources
		record_t record; // retain each record
		int nline = 0;

		KernelWakeSources proto;

		// parse line by line
		while (reader.readLine(&line)) {
		if (line.empty()) continue;
		// parse head line
		if (nline++ == 0) {
		header = parseHeader(line, TAB_DELIMITER);
		continue;
		}

		// parse for each record, the line delimiter is \t only!
		record = parseRecord(line, TAB_DELIMITER);

		if (record.size() != header.size()) {
		// TODO: log this to incident report!
		fprintf(stderr, "[%s]Line %d has missing fields\n%s\n", this->name.string(), nline, line.c_str());
		continue;
		}

		WakeupSourceProto* source = proto.add_wakeup_sources();
		for (int i=0; i<(int)record.size(); i++) {
		if (!SetTableField(source, header[i], record[i])) {
		fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",
		this->name.string(), nline, header[i].c_str(), record[i].c_str());
		}
		}
		}

		if (!reader.ok(&line)) {
		fprintf(stderr, "Bad read from fd %d: %s\n", in, line.c_str());
		return -1;
		}

		if (!proto.SerializeToFileDescriptor(out)) {
		fprintf(stderr, "[%s]Error writing proto back\n", this->name.string());
		return -1;
		}
		fprintf(stderr, "[%s]Proto size: %d bytes\n", this->name.string(), proto.ByteSize());
		return NO_ERROR;
		}

		// ================================================================================
		status_t ProcrankParser::Parse(const int in, const int out) const {
		Reader reader(in);
		string line;
		header_t header; // the header of /d/wakeup_sources
		record_t record; // retain each record
		int nline = 0;

		Procrank proto;

		// parse line by line
		while (reader.readLine(&line)) {
		if (line.empty()) continue;

		// parse head line
		if (nline++ == 0) {
		header = parseHeader(line);
		continue;
		}

		if (hasPrefix(&line, "ZRAM:")) {
		proto.mutable_summary()->mutable_zram()->set_raw_text(line);
		continue;
		}
		if (hasPrefix(&line, "RAM:")) {
		proto.mutable_summary()->mutable_ram()->set_raw_text(line);
		continue;
		}

		record = parseRecord(line);
		if (record.size() != header.size()) {
		if (record[record.size() - 1] == "TOTAL") { // TOTAL record
		ProcessProto* total = proto.mutable_summary()->mutable_total();
		for (int i=1; i<=(int)record.size(); i++) {
		SetTableField(total, header[header.size() - i], record[record.size() - i]);
		}
		} else {
		fprintf(stderr, "[%s]Line %d has missing fields\n%s\n", this->name.string(), nline,
		line.c_str());
		}
		continue;
		}

		ProcessProto* process = proto.add_processes();
		for (int i=0; i<(int)record.size(); i++) {
		if (!SetTableField(process, header[i], record[i])) {
		fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",
		this->name.string(), nline, header[i].c_str(), record[i].c_str());
		}
		}
		}

		if (!reader.ok(&line)) {
		fprintf(stderr, "Bad read from fd %d: %s\n", in, line.c_str());
		return -1;
		}

		if (!proto.SerializeToFileDescriptor(out)) {
		fprintf(stderr, "[%s]Error writing proto back\n", this->name.string());
		return -1;
		}
		fprintf(stderr, "[%s]Proto size: %d bytes\n", this->name.string(), proto.ByteSize());
		return NO_ERROR;
		}

		// ================================================================================
		status_t PageTypeInfoParser::Parse(const int in, const int out) const {
		Reader reader(in);
		string line;
		bool migrateTypeSession = false;
		int pageBlockOrder;
		header_t blockHeader;

		PageTypeInfo pageTypeInfo;

		while (reader.readLine(&line)) {
		if (line.empty()) {
		migrateTypeSession = false;
		blockHeader.clear();
		continue;
		}

		if (hasPrefix(&line, "Page block order:")) {
		pageBlockOrder = toInt(line);
		pageTypeInfo.set_page_block_order(pageBlockOrder);
		continue;
		}
		if (hasPrefix(&line, "Pages per block:")) {
		pageTypeInfo.set_pages_per_block(toInt(line));
		continue;
		}
		if (hasPrefix(&line, "Free pages count per migrate type at order")) {
		migrateTypeSession = true;
		continue;
		}
		if (hasPrefix(&line, "Number of blocks type")) {
		blockHeader = parseHeader(line);
		continue;
		}

		record_t record = parseRecord(line, COMMA_DELIMITER);
		if (migrateTypeSession && record.size() == 3) {
		MigrateTypeProto* migrateType = pageTypeInfo.add_migrate_types();
		// expect part 0 starts with "Node"
		if (hasPrefix(&record[0], "Node")) {
		migrateType->set_node(toInt(record[0]));
		} else goto ERROR;
		// expect part 1 starts with "zone"
		if (hasPrefix(&record[1], "zone")) {
		migrateType->set_zone(record[1]);
		} else goto ERROR;
		// expect part 2 starts with "type"
		if (hasPrefix(&record[2], "type")) {
		// expect the rest of part 2 has number of (pageBlockOrder + 2) parts
		// An example looks like:
		// header line: type 0 1 2 3 4 5 6 7 8 9 10
		// record line: Unmovable 426 279 226 1 1 1 0 0 2 2 0
		// The pageBlockOrder = 10 and it's zero-indexed. so total parts
		// are 10 + 1(zero-indexed) + 1(the type part) = 12.
		record_t pageCounts = parseRecord(record[2]);
		int pageCountsSize = pageBlockOrder + 2;
		if ((int)pageCounts.size() != pageCountsSize) goto ERROR;

		migrateType->set_type(pageCounts[0]);
		for (auto i=1; i<pageCountsSize; i++) {
		migrateType->add_free_pages_count(toInt(pageCounts[i]));
		}
		} else goto ERROR;
		continue;
		}

		if (!blockHeader.empty() && record.size() == 2) {
		BlockProto* block = pageTypeInfo.add_blocks();

		if (hasPrefix(&record[0], "Node")) {
		block->set_node(toInt(record[0]));
		} else goto ERROR;

		if (hasPrefix(&record[1], "zone")) {
		record_t blockCounts = parseRecord(record[1]);
		block->set_zone(blockCounts[0]);
		for (size_t i=0; i<blockHeader.size(); i++) {
		if (!SetTableField(block, blockHeader[i], blockCounts[i+1])) goto ERROR;
		}
		} else goto ERROR;

		continue;
		}

		ERROR: // print out error for this single line and continue parsing
		fprintf(stderr, "[%s]Bad line: %s\n", this->name.string(), line.c_str());
		}

		if (!reader.ok(&line)) {
		fprintf(stderr, "Bad read from fd %d: %s\n", in, line.c_str());
		return -1;
		}

		if (!pageTypeInfo.SerializeToFileDescriptor(out)) {
		fprintf(stderr, "[%s]Error writing proto back\n", this->name.string());
		return -1;
		}

		fprintf(stderr, "[%s]Proto size: %d bytes\n", this->name.string(), pageTypeInfo.ByteSize());
		return NO_ERROR;
		}

cmds/incident_helper/src/TextParserBase.cpp

0 → 100644

+56 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		#define LOG_TAG "incident_helper"

		#include "TextParserBase.h"

		#include <android-base/file.h>

		using namespace android::base;
		using namespace std;

		// ================================================================================
		status_t NoopParser::Parse(const int in, const int out) const
		{
		string content;
		if (!ReadFdToString(in, &content)) {
		fprintf(stderr, "[%s]Failed to read data from incidentd\n", this->name.string());
		return -1;
		}
		if (!WriteStringToFd(content, out)) {
		fprintf(stderr, "[%s]Failed to write data to incidentd\n", this->name.string());
		return -1;
		}
		return NO_ERROR;
		}

		// ================================================================================
		status_t ReverseParser::Parse(const int in, const int out) const
		{
		string content;
		if (!ReadFdToString(in, &content)) {
		fprintf(stderr, "[%s]Failed to read data from incidentd\n", this->name.string());
		return -1;
		}
		// reverse the content
		reverse(content.begin(), content.end());
		if (!WriteStringToFd(content, out)) {
		fprintf(stderr, "[%s]Failed to write data to incidentd\n", this->name.string());
		return -1;
		}
		return NO_ERROR;
		}
		No newline at end of file