tools/ftrace_proto_gen/proto_gen_utils.cc - third_party/perfetto - Git at Google

 /*
  * Copyright (C) 2018 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 "tools/ftrace_proto_gen/proto_gen_utils.h"

 #include <fcntl.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <algorithm>
 #include <fstream>
 #include <regex>

 #include "perfetto/base/logging.h"
 #include "perfetto/ext/base/file_utils.h"
 #include "perfetto/ext/base/pipe.h"
 #include "perfetto/ext/base/string_splitter.h"
 #include "perfetto/ext/base/string_utils.h"

 namespace perfetto {

 namespace {

 std::string RunClangFmt(const std::string& input) {
   std::string output;
   pid_t pid;
   base::Pipe input_pipe = base::Pipe::Create(base::Pipe::kBothNonBlock);
   base::Pipe output_pipe = base::Pipe::Create(base::Pipe::kBothNonBlock);
   if ((pid = fork()) == 0) {
     // Child
     PERFETTO_CHECK(dup2(*input_pipe.rd, STDIN_FILENO) != -1);
     PERFETTO_CHECK(dup2(*output_pipe.wr, STDOUT_FILENO) != -1);
     input_pipe.wr.reset();
     output_pipe.rd.reset();
     PERFETTO_CHECK(execl("buildtools/linux64/clang-format", "clang-format",
                          nullptr) != -1);
   }
   PERFETTO_CHECK(pid > 0);
   // Parent
   size_t written = 0;
   size_t bytes_read = 0;
   input_pipe.rd.reset();
   output_pipe.wr.reset();
   // This cannot be left uninitialized because there's as continue statement
   // before the first assignment to this in the loop.
   ssize_t r = -1;
   do {
     if (written < input.size()) {
       ssize_t w =
           write(*input_pipe.wr, &(input[written]), input.size() - written);
       if (w == -1) {
         if (errno == EAGAIN || errno == EINTR)
           continue;
         PERFETTO_FATAL("write failed");
       }
       written += static_cast<size_t>(w);
       if (written == input.size())
         input_pipe.wr.reset();
     }

     if (bytes_read + base::kPageSize > output.size())
       output.resize(output.size() + base::kPageSize);
     r = read(*output_pipe.rd, &(output[bytes_read]), base::kPageSize);
     if (r == -1) {
       if (errno == EAGAIN || errno == EINTR)
         continue;
       PERFETTO_FATAL("read failed");
     }
     if (r > 0)
       bytes_read += static_cast<size_t>(r);
   } while (r != 0);
   output.resize(bytes_read);

   int wstatus;
   waitpid(pid, &wstatus, 0);
   PERFETTO_CHECK(WIFEXITED(wstatus) && WEXITSTATUS(wstatus) == 0);
   return output;
 }

 }  // namespace

 using base::Contains;
 using base::EndsWith;
 using base::StartsWith;
 using base::Uppercase;

 VerifyStream::VerifyStream(std::string filename)
     : filename_(std::move(filename)) {
   PERFETTO_CHECK(base::ReadFile(filename_, &expected_));
 }

 VerifyStream::~VerifyStream() {
   std::string tidied = str();
   if (EndsWith(filename_, "cc") || EndsWith(filename_, "proto"))
     tidied = RunClangFmt(str());
   if (expected_ != tidied) {
     PERFETTO_FATAL("%s is out of date. Please run tools/run_ftrace_proto_gen.",
                    filename_.c_str());
   }
 }

 FtraceEventName::FtraceEventName(const std::string& full_name) {
   if (full_name.rfind("removed", 0) != std::string::npos) {
     valid_ = false;
     return;
   }
   name_ = full_name.substr(full_name.find('/') + 1, std::string::npos);
   group_ = full_name.substr(0, full_name.find('/'));
   valid_ = true;
 }

 bool FtraceEventName::valid() const {
   return valid_;
 }

 const std::string& FtraceEventName::name() const {
   PERFETTO_CHECK(valid_);
   return name_;
 }

 const std::string& FtraceEventName::group() const {
   PERFETTO_CHECK(valid_);
   return group_;
 }

 std::string ToCamelCase(const std::string& s) {
   std::string result;
   result.reserve(s.size());
   bool upperCaseNextChar = true;
   for (size_t i = 0; i < s.size(); i++) {
     char c = s[i];
     if (c == '_') {
       upperCaseNextChar = true;
       continue;
     }
     if (upperCaseNextChar) {
       upperCaseNextChar = false;
       c = Uppercase(c);
     }
     result.push_back(c);
   }
   return result;
 }

 ProtoType ProtoType::GetSigned() const {
   PERFETTO_CHECK(type == NUMERIC);
   if (is_signed)
     return *this;

   if (size == 64) {
     return Numeric(64, true);
   }

   return Numeric(2 * size, true);
 }

 std::string ProtoType::ToString() const {
   switch (type) {
     case INVALID:
       PERFETTO_CHECK(false);
     case STRING:
       return "string";
     case NUMERIC: {
       std::string s;
       if (!is_signed)
         s += "u";
       s += "int";
       s += std::to_string(size);
       return s;
     }
   }
   PERFETTO_CHECK(false);  // for GCC.
 }

 // static
 ProtoType ProtoType::String() {
   return {STRING, 0, false};
 }

 // static
 ProtoType ProtoType::Invalid() {
   return {INVALID, 0, false};
 }

 // static
 ProtoType ProtoType::Numeric(uint16_t size, bool is_signed) {
   PERFETTO_CHECK(size == 32 || size == 64);
   return {NUMERIC, size, is_signed};
 }

 // static
 ProtoType ProtoType::FromDescriptor(
     google::protobuf::FieldDescriptor::Type type) {
   if (type == google::protobuf::FieldDescriptor::Type::TYPE_UINT64)
     return Numeric(64, false);

   if (type == google::protobuf::FieldDescriptor::Type::TYPE_INT64)
     return Numeric(64, true);

   if (type == google::protobuf::FieldDescriptor::Type::TYPE_UINT32)
     return Numeric(32, false);

   if (type == google::protobuf::FieldDescriptor::Type::TYPE_INT32)
     return Numeric(32, true);

   if (type == google::protobuf::FieldDescriptor::Type::TYPE_STRING)
     return String();

   return Invalid();
 }

 ProtoType GetCommon(ProtoType one, ProtoType other) {
   // Always need to prefer the LHS as it is the one already present
   // in the proto.
   if (one.type == ProtoType::STRING)
     return ProtoType::String();

   if (one.is_signed || other.is_signed) {
     one = one.GetSigned();
     other = other.GetSigned();
   }

   return ProtoType::Numeric(std::max(one.size, other.size), one.is_signed);
 }

 ProtoType InferProtoType(const FtraceEvent::Field& field) {
   // Fixed length strings: "char foo[16]"
   if (std::regex_match(field.type_and_name, std::regex(R"(char \w+\[\d+\])")))
     return ProtoType::String();

   // String pointers: "__data_loc char[] foo" (as in
   // 'cpufreq_interactive_boost').
   if (Contains(field.type_and_name, "char[] "))
     return ProtoType::String();
   if (Contains(field.type_and_name, "char * "))
     return ProtoType::String();

   // Variable length strings: "char* foo"
   if (StartsWith(field.type_and_name, "char *"))
     return ProtoType::String();

   // Variable length strings: "char foo" + size: 0 (as in 'print').
   if (StartsWith(field.type_and_name, "char ") && field.size == 0)
     return ProtoType::String();

   // ino_t, i_ino and dev_t are 32bit on some devices 64bit on others. For the
   // protos we need to choose the largest possible size.
   if (StartsWith(field.type_and_name, "ino_t ") ||
       StartsWith(field.type_and_name, "i_ino ") ||
       StartsWith(field.type_and_name, "dev_t ")) {
     return ProtoType::Numeric(64, /* is_signed= */ false);
   }

   // Ints of various sizes:
   if (field.size <= 4)
     return ProtoType::Numeric(32, field.is_signed);
   if (field.size <= 8)
     return ProtoType::Numeric(64, field.is_signed);
   return ProtoType::Invalid();
 }

 Proto::Proto(std::string evt_name, const google::protobuf::Descriptor& desc)
     : name(desc.name()), event_name(evt_name) {
   for (int i = 0; i < desc.field_count(); ++i) {
     const google::protobuf::FieldDescriptor* field = desc.field(i);
     PERFETTO_CHECK(field);
     AddField(Field{ProtoType::FromDescriptor(field->type()), field->name(),
                    uint32_t(field->number())});
   }
 }

 std::vector<const Proto::Field*> Proto::SortedFields() {
   std::vector<const Proto::Field*> sorted_fields;

   for (const auto& p : fields) {
     sorted_fields.emplace_back(&p.second);
   }
   std::sort(sorted_fields.begin(), sorted_fields.end(),
             [](const Proto::Field* a, const Proto::Field* b) {
               return a->number < b->number;
             });
   return sorted_fields;
 }

 std::string Proto::ToString() {
   std::string s;
   s += "message " + name + " {\n";
   for (const auto field : SortedFields()) {
     s += "  optional " + field->type.ToString() + " " + field->name + " = " +
          std::to_string(field->number) + ";\n";
   }
   s += "}\n";
   return s;
 }

 void Proto::MergeFrom(const Proto& other) {
   // Always keep number from the left hand side.
   PERFETTO_CHECK(name == other.name);
   for (const auto& p : other.fields) {
     auto it = fields.find(p.first);
     if (it == fields.end()) {
       Proto::Field field = p.second;
       field.number = ++max_id;
       AddField(std::move(field));
     } else {
       it->second.type = GetCommon(it->second.type, p.second.type);
     }
   }
 }

 void Proto::AddField(Proto::Field other) {
   max_id = std::max(max_id, other.number);
   fields.emplace(other.name, std::move(other));
 }

 }  // namespace perfetto
	/*
	* Copyright (C) 2018 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 "tools/ftrace_proto_gen/proto_gen_utils.h"

	#include <fcntl.h>
	#include <sys/wait.h>
	#include <unistd.h>
	#include <algorithm>
	#include <fstream>
	#include <regex>

	#include "perfetto/base/logging.h"
	#include "perfetto/ext/base/file_utils.h"
	#include "perfetto/ext/base/pipe.h"
	#include "perfetto/ext/base/string_splitter.h"
	#include "perfetto/ext/base/string_utils.h"

	namespace perfetto {

	namespace {

	std::string RunClangFmt(const std::string& input) {
	std::string output;
	pid_t pid;
	base::Pipe input_pipe = base::Pipe::Create(base::Pipe::kBothNonBlock);
	base::Pipe output_pipe = base::Pipe::Create(base::Pipe::kBothNonBlock);
	if ((pid = fork()) == 0) {
	// Child
	PERFETTO_CHECK(dup2(*input_pipe.rd, STDIN_FILENO) != -1);
	PERFETTO_CHECK(dup2(*output_pipe.wr, STDOUT_FILENO) != -1);
	input_pipe.wr.reset();
	output_pipe.rd.reset();
	PERFETTO_CHECK(execl("buildtools/linux64/clang-format", "clang-format",
	nullptr) != -1);
	}
	PERFETTO_CHECK(pid > 0);
	// Parent
	size_t written = 0;
	size_t bytes_read = 0;
	input_pipe.rd.reset();
	output_pipe.wr.reset();
	// This cannot be left uninitialized because there's as continue statement
	// before the first assignment to this in the loop.
	ssize_t r = -1;
	do {
	if (written < input.size()) {
	ssize_t w =
	write(*input_pipe.wr, &(input[written]), input.size() - written);
	if (w == -1) {
	if (errno == EAGAIN \|\| errno == EINTR)
	continue;
	PERFETTO_FATAL("write failed");
	}
	written += static_cast<size_t>(w);
	if (written == input.size())
	input_pipe.wr.reset();
	}

	if (bytes_read + base::kPageSize > output.size())
	output.resize(output.size() + base::kPageSize);
	r = read(*output_pipe.rd, &(output[bytes_read]), base::kPageSize);
	if (r == -1) {
	if (errno == EAGAIN \|\| errno == EINTR)
	continue;
	PERFETTO_FATAL("read failed");
	}
	if (r > 0)
	bytes_read += static_cast<size_t>(r);
	} while (r != 0);
	output.resize(bytes_read);

	int wstatus;
	waitpid(pid, &wstatus, 0);
	PERFETTO_CHECK(WIFEXITED(wstatus) && WEXITSTATUS(wstatus) == 0);
	return output;
	}

	} // namespace

	using base::Contains;
	using base::EndsWith;
	using base::StartsWith;
	using base::Uppercase;

	VerifyStream::VerifyStream(std::string filename)
	: filename_(std::move(filename)) {
	PERFETTO_CHECK(base::ReadFile(filename_, &expected_));
	}

	VerifyStream::~VerifyStream() {
	std::string tidied = str();
	if (EndsWith(filename_, "cc") \|\| EndsWith(filename_, "proto"))
	tidied = RunClangFmt(str());
	if (expected_ != tidied) {
	PERFETTO_FATAL("%s is out of date. Please run tools/run_ftrace_proto_gen.",
	filename_.c_str());
	}
	}

	FtraceEventName::FtraceEventName(const std::string& full_name) {
	if (full_name.rfind("removed", 0) != std::string::npos) {
	valid_ = false;
	return;
	}
	name_ = full_name.substr(full_name.find('/') + 1, std::string::npos);
	group_ = full_name.substr(0, full_name.find('/'));
	valid_ = true;
	}

	bool FtraceEventName::valid() const {
	return valid_;
	}

	const std::string& FtraceEventName::name() const {
	PERFETTO_CHECK(valid_);
	return name_;
	}

	const std::string& FtraceEventName::group() const {
	PERFETTO_CHECK(valid_);
	return group_;
	}

	std::string ToCamelCase(const std::string& s) {
	std::string result;
	result.reserve(s.size());
	bool upperCaseNextChar = true;
	for (size_t i = 0; i < s.size(); i++) {
	char c = s[i];
	if (c == '_') {
	upperCaseNextChar = true;
	continue;
	}
	if (upperCaseNextChar) {
	upperCaseNextChar = false;
	c = Uppercase(c);
	}
	result.push_back(c);
	}
	return result;
	}

	ProtoType ProtoType::GetSigned() const {
	PERFETTO_CHECK(type == NUMERIC);
	if (is_signed)
	return *this;

	if (size == 64) {
	return Numeric(64, true);
	}

	return Numeric(2 * size, true);
	}

	std::string ProtoType::ToString() const {
	switch (type) {
	case INVALID:
	PERFETTO_CHECK(false);
	case STRING:
	return "string";
	case NUMERIC: {
	std::string s;
	if (!is_signed)
	s += "u";
	s += "int";
	s += std::to_string(size);
	return s;
	}
	}
	PERFETTO_CHECK(false); // for GCC.
	}

	// static
	ProtoType ProtoType::String() {
	return {STRING, 0, false};
	}

	// static
	ProtoType ProtoType::Invalid() {
	return {INVALID, 0, false};
	}

	// static
	ProtoType ProtoType::Numeric(uint16_t size, bool is_signed) {
	PERFETTO_CHECK(size == 32 \|\| size == 64);
	return {NUMERIC, size, is_signed};
	}

	// static
	ProtoType ProtoType::FromDescriptor(
	google::protobuf::FieldDescriptor::Type type) {
	if (type == google::protobuf::FieldDescriptor::Type::TYPE_UINT64)
	return Numeric(64, false);

	if (type == google::protobuf::FieldDescriptor::Type::TYPE_INT64)
	return Numeric(64, true);

	if (type == google::protobuf::FieldDescriptor::Type::TYPE_UINT32)
	return Numeric(32, false);

	if (type == google::protobuf::FieldDescriptor::Type::TYPE_INT32)
	return Numeric(32, true);

	if (type == google::protobuf::FieldDescriptor::Type::TYPE_STRING)
	return String();

	return Invalid();
	}

	ProtoType GetCommon(ProtoType one, ProtoType other) {
	// Always need to prefer the LHS as it is the one already present
	// in the proto.
	if (one.type == ProtoType::STRING)
	return ProtoType::String();

	if (one.is_signed \|\| other.is_signed) {
	one = one.GetSigned();
	other = other.GetSigned();
	}

	return ProtoType::Numeric(std::max(one.size, other.size), one.is_signed);
	}

	ProtoType InferProtoType(const FtraceEvent::Field& field) {
	// Fixed length strings: "char foo[16]"
	if (std::regex_match(field.type_and_name, std::regex(R"(char \w+\[\d+\])")))
	return ProtoType::String();

	// String pointers: "__data_loc char[] foo" (as in
	// 'cpufreq_interactive_boost').
	if (Contains(field.type_and_name, "char[] "))
	return ProtoType::String();
	if (Contains(field.type_and_name, "char * "))
	return ProtoType::String();

	// Variable length strings: "char* foo"
	if (StartsWith(field.type_and_name, "char *"))
	return ProtoType::String();

	// Variable length strings: "char foo" + size: 0 (as in 'print').
	if (StartsWith(field.type_and_name, "char ") && field.size == 0)
	return ProtoType::String();

	// ino_t, i_ino and dev_t are 32bit on some devices 64bit on others. For the
	// protos we need to choose the largest possible size.
	if (StartsWith(field.type_and_name, "ino_t ") \|\|
	StartsWith(field.type_and_name, "i_ino ") \|\|
	StartsWith(field.type_and_name, "dev_t ")) {
	return ProtoType::Numeric(64, /* is_signed= */ false);
	}

	// Ints of various sizes:
	if (field.size <= 4)
	return ProtoType::Numeric(32, field.is_signed);
	if (field.size <= 8)
	return ProtoType::Numeric(64, field.is_signed);
	return ProtoType::Invalid();
	}

	Proto::Proto(std::string evt_name, const google::protobuf::Descriptor& desc)
	: name(desc.name()), event_name(evt_name) {
	for (int i = 0; i < desc.field_count(); ++i) {
	const google::protobuf::FieldDescriptor* field = desc.field(i);
	PERFETTO_CHECK(field);
	AddField(Field{ProtoType::FromDescriptor(field->type()), field->name(),
	uint32_t(field->number())});
	}
	}

	std::vector<const Proto::Field*> Proto::SortedFields() {
	std::vector<const Proto::Field*> sorted_fields;

	for (const auto& p : fields) {
	sorted_fields.emplace_back(&p.second);
	}
	std::sort(sorted_fields.begin(), sorted_fields.end(),
	[](const Proto::Field* a, const Proto::Field* b) {
	return a->number < b->number;
	});
	return sorted_fields;
	}

	std::string Proto::ToString() {
	std::string s;
	s += "message " + name + " {\n";
	for (const auto field : SortedFields()) {
	s += " optional " + field->type.ToString() + " " + field->name + " = " +
	std::to_string(field->number) + ";\n";
	}
	s += "}\n";
	return s;
	}

	void Proto::MergeFrom(const Proto& other) {
	// Always keep number from the left hand side.
	PERFETTO_CHECK(name == other.name);
	for (const auto& p : other.fields) {
	auto it = fields.find(p.first);
	if (it == fields.end()) {
	Proto::Field field = p.second;
	field.number = ++max_id;
	AddField(std::move(field));
	} else {
	it->second.type = GetCommon(it->second.type, p.second.type);
	}
	}
	}

	void Proto::AddField(Proto::Field other) {
	max_id = std::max(max_id, other.number);
	fields.emplace(other.name, std::move(other));
	}

	} // namespace perfetto