logd/LogBufferElement.cpp - platform/system/core - Git at Google

 /*
  * Copyright (C) 2012-2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "LogBufferElement.h"

 #include <ctype.h>
 #include <endian.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>

 #include <log/log_read.h>
 #include <private/android_logger.h>

 #include "LogStatistics.h"
 #include "LogUtils.h"

 LogBufferElement::LogBufferElement(log_id_t log_id, log_time realtime, uid_t uid, pid_t pid,
                                    pid_t tid, uint64_t sequence, const char* msg, uint16_t len)
     : uid_(uid),
       pid_(pid),
       tid_(tid),
       sequence_(sequence),
       realtime_(realtime),
       msg_len_(len),
       log_id_(log_id),
       dropped_(false) {
     msg_ = new char[len];
     memcpy(msg_, msg, len);
 }

 LogBufferElement::LogBufferElement(const LogBufferElement& elem)
     : uid_(elem.uid_),
       pid_(elem.pid_),
       tid_(elem.tid_),
       sequence_(elem.sequence_),
       realtime_(elem.realtime_),
       msg_len_(elem.msg_len_),
       log_id_(elem.log_id_),
       dropped_(elem.dropped_) {
     if (dropped_) {
         tag_ = elem.GetTag();
     } else {
         msg_ = new char[msg_len_];
         memcpy(msg_, elem.msg_, msg_len_);
     }
 }

 LogBufferElement::LogBufferElement(LogBufferElement&& elem) noexcept
     : uid_(elem.uid_),
       pid_(elem.pid_),
       tid_(elem.tid_),
       sequence_(elem.sequence_),
       realtime_(elem.realtime_),
       msg_len_(elem.msg_len_),
       log_id_(elem.log_id_),
       dropped_(elem.dropped_) {
     if (dropped_) {
         tag_ = elem.GetTag();
     } else {
         msg_ = elem.msg_;
         elem.msg_ = nullptr;
     }
 }

 LogBufferElement::~LogBufferElement() {
     if (!dropped_) {
         delete[] msg_;
     }
 }

 uint32_t LogBufferElement::GetTag() const {
     // Binary buffers have no tag.
     if (!IsBinary(log_id())) {
         return 0;
     }

     // Dropped messages store the tag in place of msg_.
     if (dropped_) {
         return tag_;
     }

     return MsgToTag(msg(), msg_len());
 }

 LogStatisticsElement LogBufferElement::ToLogStatisticsElement() const {
     // Estimate the size of this element in the parent std::list<> by adding two void*'s
     // corresponding to the next/prev pointers and aligning to 64 bit.
     uint16_t element_in_list_size =
             (sizeof(*this) + 2 * sizeof(void*) + sizeof(uint64_t) - 1) & -sizeof(uint64_t);
     return LogStatisticsElement{
             .uid = uid(),
             .pid = pid(),
             .tid = tid(),
             .tag = GetTag(),
             .realtime = realtime(),
             .msg = msg(),
             .msg_len = msg_len(),
             .dropped_count = dropped_count(),
             .log_id = log_id(),
             .total_len = static_cast<uint16_t>(element_in_list_size + msg_len()),
     };
 }

 uint16_t LogBufferElement::SetDropped(uint16_t value) {
     if (dropped_) {
         return dropped_count_ = value;
     }

     // The tag information is saved in msg_ data, which is in a union with tag_, used after dropped_
     // is set to true. Therefore we save the tag value aside, delete msg_, then set tag_ to the tag
     // value in its place.
     auto old_tag = GetTag();
     delete[] msg_;
     msg_ = nullptr;

     tag_ = old_tag;
     dropped_ = true;
     return dropped_count_ = value;
 }

 // caller must own and free character string
 char* android::tidToName(pid_t tid) {
     char* retval = nullptr;
     char buffer[256];
     snprintf(buffer, sizeof(buffer), "/proc/%u/comm", tid);
     int fd = open(buffer, O_RDONLY | O_CLOEXEC);
     if (fd >= 0) {
         ssize_t ret = read(fd, buffer, sizeof(buffer));
         if (ret >= (ssize_t)sizeof(buffer)) {
             ret = sizeof(buffer) - 1;
         }
         while ((ret > 0) && isspace(buffer[ret - 1])) {
             --ret;
         }
         if (ret > 0) {
             buffer[ret] = '\0';
             retval = strdup(buffer);
         }
         close(fd);
     }

     // if nothing for comm, check out cmdline
     char* name = android::pidToName(tid);
     if (!retval) {
         retval = name;
         name = nullptr;
     }

     // check if comm is truncated, see if cmdline has full representation
     if (name) {
         // impossible for retval to be NULL if name not NULL
         size_t retval_len = strlen(retval);
         size_t name_len = strlen(name);
         // KISS: ToDo: Only checks prefix truncated, not suffix, or both
         if ((retval_len < name_len) &&
             !fastcmp<strcmp>(retval, name + name_len - retval_len)) {
             free(retval);
             retval = name;
         } else {
             free(name);
         }
     }
     return retval;
 }

 // assumption: msg_ == NULL
 size_t LogBufferElement::PopulateDroppedMessage(char*& buffer, LogStatistics* stats,
                                                 bool lastSame) {
     static const char tag[] = "chatty";

     if (!__android_log_is_loggable_len(ANDROID_LOG_INFO, tag, strlen(tag),
                                        ANDROID_LOG_VERBOSE)) {
         return 0;
     }

     static const char format_uid[] = "uid=%u%s%s %s %u line%s";
     const char* name = stats->UidToName(uid_);
     const char* commName = android::tidToName(tid_);
     if (!commName && (tid_ != pid_)) {
         commName = android::tidToName(pid_);
     }
     if (!commName) {
         commName = stats->PidToName(pid_);
     }
     if (name && name[0] && commName && (name[0] == commName[0])) {
         size_t len = strlen(name + 1);
         if (!strncmp(name + 1, commName + 1, len)) {
             if (commName[len + 1] == '\0') {
                 free(const_cast<char*>(commName));
                 commName = nullptr;
             } else {
                 free(const_cast<char*>(name));
                 name = nullptr;
             }
         }
     }
     if (name) {
         char* buf = nullptr;
         int result = asprintf(&buf, "(%s)", name);
         if (result != -1) {
             free(const_cast<char*>(name));
             name = buf;
         }
     }
     if (commName) {
         char* buf = nullptr;
         int result = asprintf(&buf, " %s", commName);
         if (result != -1) {
             free(const_cast<char*>(commName));
             commName = buf;
         }
     }
     // identical to below to calculate the buffer size required
     const char* type = lastSame ? "identical" : "expire";
     size_t len = snprintf(nullptr, 0, format_uid, uid_, name ? name : "", commName ? commName : "",
                           type, dropped_count(), (dropped_count() > 1) ? "s" : "");

     size_t hdrLen;
     if (IsBinary(log_id())) {
         hdrLen = sizeof(android_log_event_string_t);
     } else {
         hdrLen = 1 + sizeof(tag);
     }

     buffer = static_cast<char*>(calloc(1, hdrLen + len + 1));
     if (!buffer) {
         free(const_cast<char*>(name));
         free(const_cast<char*>(commName));
         return 0;
     }

     size_t retval = hdrLen + len;
     if (IsBinary(log_id())) {
         android_log_event_string_t* event =
             reinterpret_cast<android_log_event_string_t*>(buffer);

         event->header.tag = htole32(CHATTY_LOG_TAG);
         event->type = EVENT_TYPE_STRING;
         event->length = htole32(len);
     } else {
         ++retval;
         buffer[0] = ANDROID_LOG_INFO;
         strcpy(buffer + 1, tag);
     }

     snprintf(buffer + hdrLen, len + 1, format_uid, uid_, name ? name : "", commName ? commName : "",
              type, dropped_count(), (dropped_count() > 1) ? "s" : "");
     free(const_cast<char*>(name));
     free(const_cast<char*>(commName));

     return retval;
 }

 bool LogBufferElement::FlushTo(LogWriter* writer, LogStatistics* stats, bool lastSame) {
     struct logger_entry entry = {};

     entry.hdr_size = sizeof(struct logger_entry);
     entry.lid = log_id_;
     entry.pid = pid_;
     entry.tid = tid_;
     entry.uid = uid_;
     entry.sec = realtime_.tv_sec;
     entry.nsec = realtime_.tv_nsec;

     char* buffer = nullptr;
     const char* msg;
     if (dropped_) {
         entry.len = PopulateDroppedMessage(buffer, stats, lastSame);
         if (!entry.len) return true;
         msg = buffer;
     } else {
         msg = msg_;
         entry.len = msg_len_;
     }

     bool retval = writer->Write(entry, msg);

     if (buffer) free(buffer);

     return retval;
 }
	/*
	* Copyright (C) 2012-2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "LogBufferElement.h"

	#include <ctype.h>
	#include <endian.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <string.h>
	#include <time.h>
	#include <unistd.h>

	#include <log/log_read.h>
	#include <private/android_logger.h>

	#include "LogStatistics.h"
	#include "LogUtils.h"

	LogBufferElement::LogBufferElement(log_id_t log_id, log_time realtime, uid_t uid, pid_t pid,
	pid_t tid, uint64_t sequence, const char* msg, uint16_t len)
	: uid_(uid),
	pid_(pid),
	tid_(tid),
	sequence_(sequence),
	realtime_(realtime),
	msg_len_(len),
	log_id_(log_id),
	dropped_(false) {
	msg_ = new char[len];
	memcpy(msg_, msg, len);
	}

	LogBufferElement::LogBufferElement(const LogBufferElement& elem)
	: uid_(elem.uid_),
	pid_(elem.pid_),
	tid_(elem.tid_),
	sequence_(elem.sequence_),
	realtime_(elem.realtime_),
	msg_len_(elem.msg_len_),
	log_id_(elem.log_id_),
	dropped_(elem.dropped_) {
	if (dropped_) {
	tag_ = elem.GetTag();
	} else {
	msg_ = new char[msg_len_];
	memcpy(msg_, elem.msg_, msg_len_);
	}
	}

	LogBufferElement::LogBufferElement(LogBufferElement&& elem) noexcept
	: uid_(elem.uid_),
	pid_(elem.pid_),
	tid_(elem.tid_),
	sequence_(elem.sequence_),
	realtime_(elem.realtime_),
	msg_len_(elem.msg_len_),
	log_id_(elem.log_id_),
	dropped_(elem.dropped_) {
	if (dropped_) {
	tag_ = elem.GetTag();
	} else {
	msg_ = elem.msg_;
	elem.msg_ = nullptr;
	}
	}

	LogBufferElement::~LogBufferElement() {
	if (!dropped_) {
	delete[] msg_;
	}
	}

	uint32_t LogBufferElement::GetTag() const {
	// Binary buffers have no tag.
	if (!IsBinary(log_id())) {
	return 0;
	}

	// Dropped messages store the tag in place of msg_.
	if (dropped_) {
	return tag_;
	}

	return MsgToTag(msg(), msg_len());
	}

	LogStatisticsElement LogBufferElement::ToLogStatisticsElement() const {
	// Estimate the size of this element in the parent std::list<> by adding two void*'s
	// corresponding to the next/prev pointers and aligning to 64 bit.
	uint16_t element_in_list_size =
	(sizeof(this) + 2 sizeof(void*) + sizeof(uint64_t) - 1) & -sizeof(uint64_t);
	return LogStatisticsElement{
	.uid = uid(),
	.pid = pid(),
	.tid = tid(),
	.tag = GetTag(),
	.realtime = realtime(),
	.msg = msg(),
	.msg_len = msg_len(),
	.dropped_count = dropped_count(),
	.log_id = log_id(),
	.total_len = static_cast<uint16_t>(element_in_list_size + msg_len()),
	};
	}

	uint16_t LogBufferElement::SetDropped(uint16_t value) {
	if (dropped_) {
	return dropped_count_ = value;
	}

	// The tag information is saved in msg_ data, which is in a union with tag_, used after dropped_
	// is set to true. Therefore we save the tag value aside, delete msg_, then set tag_ to the tag
	// value in its place.
	auto old_tag = GetTag();
	delete[] msg_;
	msg_ = nullptr;

	tag_ = old_tag;
	dropped_ = true;
	return dropped_count_ = value;
	}

	// caller must own and free character string
	char* android::tidToName(pid_t tid) {
	char* retval = nullptr;
	char buffer[256];
	snprintf(buffer, sizeof(buffer), "/proc/%u/comm", tid);
	int fd = open(buffer, O_RDONLY \| O_CLOEXEC);
	if (fd >= 0) {
	ssize_t ret = read(fd, buffer, sizeof(buffer));
	if (ret >= (ssize_t)sizeof(buffer)) {
	ret = sizeof(buffer) - 1;
	}
	while ((ret > 0) && isspace(buffer[ret - 1])) {
	--ret;
	}
	if (ret > 0) {
	buffer[ret] = '\0';
	retval = strdup(buffer);
	}
	close(fd);
	}

	// if nothing for comm, check out cmdline
	char* name = android::pidToName(tid);
	if (!retval) {
	retval = name;
	name = nullptr;
	}

	// check if comm is truncated, see if cmdline has full representation
	if (name) {
	// impossible for retval to be NULL if name not NULL
	size_t retval_len = strlen(retval);
	size_t name_len = strlen(name);
	// KISS: ToDo: Only checks prefix truncated, not suffix, or both
	if ((retval_len < name_len) &&
	!fastcmp<strcmp>(retval, name + name_len - retval_len)) {
	free(retval);
	retval = name;
	} else {
	free(name);
	}
	}
	return retval;
	}

	// assumption: msg_ == NULL
	size_t LogBufferElement::PopulateDroppedMessage(char& buffer, LogStatistics stats,
	bool lastSame) {
	static const char tag[] = "chatty";

	if (!__android_log_is_loggable_len(ANDROID_LOG_INFO, tag, strlen(tag),
	ANDROID_LOG_VERBOSE)) {
	return 0;
	}

	static const char format_uid[] = "uid=%u%s%s %s %u line%s";
	const char* name = stats->UidToName(uid_);
	const char* commName = android::tidToName(tid_);
	if (!commName && (tid_ != pid_)) {
	commName = android::tidToName(pid_);
	}
	if (!commName) {
	commName = stats->PidToName(pid_);
	}
	if (name && name[0] && commName && (name[0] == commName[0])) {
	size_t len = strlen(name + 1);
	if (!strncmp(name + 1, commName + 1, len)) {
	if (commName[len + 1] == '\0') {
	free(const_cast<char*>(commName));
	commName = nullptr;
	} else {
	free(const_cast<char*>(name));
	name = nullptr;
	}
	}
	}
	if (name) {
	char* buf = nullptr;
	int result = asprintf(&buf, "(%s)", name);
	if (result != -1) {
	free(const_cast<char*>(name));
	name = buf;
	}
	}
	if (commName) {
	char* buf = nullptr;
	int result = asprintf(&buf, " %s", commName);
	if (result != -1) {
	free(const_cast<char*>(commName));
	commName = buf;
	}
	}
	// identical to below to calculate the buffer size required
	const char* type = lastSame ? "identical" : "expire";
	size_t len = snprintf(nullptr, 0, format_uid, uid_, name ? name : "", commName ? commName : "",
	type, dropped_count(), (dropped_count() > 1) ? "s" : "");

	size_t hdrLen;
	if (IsBinary(log_id())) {
	hdrLen = sizeof(android_log_event_string_t);
	} else {
	hdrLen = 1 + sizeof(tag);
	}

	buffer = static_cast<char*>(calloc(1, hdrLen + len + 1));
	if (!buffer) {
	free(const_cast<char*>(name));
	free(const_cast<char*>(commName));
	return 0;
	}

	size_t retval = hdrLen + len;
	if (IsBinary(log_id())) {
	android_log_event_string_t* event =
	reinterpret_cast<android_log_event_string_t*>(buffer);

	event->header.tag = htole32(CHATTY_LOG_TAG);
	event->type = EVENT_TYPE_STRING;
	event->length = htole32(len);
	} else {
	++retval;
	buffer[0] = ANDROID_LOG_INFO;
	strcpy(buffer + 1, tag);
	}

	snprintf(buffer + hdrLen, len + 1, format_uid, uid_, name ? name : "", commName ? commName : "",
	type, dropped_count(), (dropped_count() > 1) ? "s" : "");
	free(const_cast<char*>(name));
	free(const_cast<char*>(commName));

	return retval;
	}

	bool LogBufferElement::FlushTo(LogWriter* writer, LogStatistics* stats, bool lastSame) {
	struct logger_entry entry = {};

	entry.hdr_size = sizeof(struct logger_entry);
	entry.lid = log_id_;
	entry.pid = pid_;
	entry.tid = tid_;
	entry.uid = uid_;
	entry.sec = realtime_.tv_sec;
	entry.nsec = realtime_.tv_nsec;

	char* buffer = nullptr;
	const char* msg;
	if (dropped_) {
	entry.len = PopulateDroppedMessage(buffer, stats, lastSame);
	if (!entry.len) return true;
	msg = buffer;
	} else {
	msg = msg_;
	entry.len = msg_len_;
	}

	bool retval = writer->Write(entry, msg);

	if (buffer) free(buffer);

	return retval;
	}