blob: e1d367f5270a4bf8fc0a4de8f8510efbba39d121 [file] [log] [blame]
Mark Salyzyn0175b072014-02-26 09:50:16 -08001/*
2 * Copyright (C) 2012-2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Mark Salyzyn21fb7e02015-04-20 07:26:27 -070017#include <ctype.h>
Mark Salyzynab0dcf62015-03-16 12:04:09 -070018#include <endian.h>
Mark Salyzyn21fb7e02015-04-20 07:26:27 -070019#include <fcntl.h>
Mark Salyzyn0175b072014-02-26 09:50:16 -080020#include <stdio.h>
21#include <string.h>
22#include <time.h>
23#include <unistd.h>
24
25#include <log/logger.h>
Mark Salyzynab0dcf62015-03-16 12:04:09 -070026#include <private/android_logger.h>
Mark Salyzyn0175b072014-02-26 09:50:16 -080027
28#include "LogBufferElement.h"
Mark Salyzynab0dcf62015-03-16 12:04:09 -070029#include "LogCommand.h"
Mark Salyzyn0175b072014-02-26 09:50:16 -080030#include "LogReader.h"
31
Mark Salyzynf7c0f752015-03-03 13:39:37 -080032const uint64_t LogBufferElement::FLUSH_ERROR(0);
Mark Salyzynee49c6a2015-06-12 14:59:42 -070033atomic_int_fast64_t LogBufferElement::sequence(1);
Mark Salyzyn0175b072014-02-26 09:50:16 -080034
Mark Salyzyn7e2f83c2014-03-05 07:41:49 -080035LogBufferElement::LogBufferElement(log_id_t log_id, log_time realtime,
Mark Salyzynb992d0d2014-03-20 16:09:38 -070036 uid_t uid, pid_t pid, pid_t tid,
Mark Salyzyn77187782015-05-12 15:21:31 -070037 const char *msg, unsigned short len) :
38 mLogId(log_id),
39 mUid(uid),
40 mPid(pid),
41 mTid(tid),
42 mMsgLen(len),
43 mSequence(sequence.fetch_add(1, memory_order_relaxed)),
44 mRealTime(realtime) {
Mark Salyzyn0175b072014-02-26 09:50:16 -080045 mMsg = new char[len];
46 memcpy(mMsg, msg, len);
47}
48
49LogBufferElement::~LogBufferElement() {
50 delete [] mMsg;
51}
52
Mark Salyzyn344bff42015-04-13 14:24:45 -070053uint32_t LogBufferElement::getTag() const {
54 if ((mLogId != LOG_ID_EVENTS) || !mMsg || (mMsgLen < sizeof(uint32_t))) {
55 return 0;
56 }
57 return le32toh(reinterpret_cast<android_event_header_t *>(mMsg)->tag);
58}
59
Mark Salyzyn21fb7e02015-04-20 07:26:27 -070060// caller must own and free character string
Mark Salyzyn17ed6792015-04-20 13:35:15 -070061char *android::tidToName(pid_t tid) {
Mark Salyzyn21fb7e02015-04-20 07:26:27 -070062 char *retval = NULL;
63 char buffer[256];
64 snprintf(buffer, sizeof(buffer), "/proc/%u/comm", tid);
65 int fd = open(buffer, O_RDONLY);
66 if (fd >= 0) {
67 ssize_t ret = read(fd, buffer, sizeof(buffer));
68 if (ret >= (ssize_t)sizeof(buffer)) {
69 ret = sizeof(buffer) - 1;
70 }
71 while ((ret > 0) && isspace(buffer[ret - 1])) {
72 --ret;
73 }
74 if (ret > 0) {
75 buffer[ret] = '\0';
76 retval = strdup(buffer);
77 }
78 close(fd);
Mark Salyzynab0dcf62015-03-16 12:04:09 -070079 }
80
Mark Salyzyn21fb7e02015-04-20 07:26:27 -070081 // if nothing for comm, check out cmdline
82 char *name = android::pidToName(tid);
83 if (!retval) {
84 retval = name;
85 name = NULL;
86 }
87
88 // check if comm is truncated, see if cmdline has full representation
89 if (name) {
90 // impossible for retval to be NULL if name not NULL
91 size_t retval_len = strlen(retval);
92 size_t name_len = strlen(name);
93 // KISS: ToDo: Only checks prefix truncated, not suffix, or both
Mark Salyzynddda2122015-10-02 09:22:52 -070094 if ((retval_len < name_len)
95 && !fast<strcmp>(retval, name + name_len - retval_len)) {
Mark Salyzyn21fb7e02015-04-20 07:26:27 -070096 free(retval);
97 retval = name;
98 } else {
99 free(name);
100 }
101 }
102 return retval;
103}
104
105// assumption: mMsg == NULL
106size_t LogBufferElement::populateDroppedMessage(char *&buffer,
107 LogBuffer *parent) {
Mark Salyzyn047cc072015-06-04 13:35:30 -0700108 static const char tag[] = "chatty";
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700109
Mark Salyzync2e7d492015-11-16 19:00:41 +0000110 if (!__android_log_is_loggable(ANDROID_LOG_INFO, tag, ANDROID_LOG_VERBOSE)) {
Mark Salyzyne59c4692014-10-02 13:07:05 -0700111 return 0;
112 }
113
114 static const char format_uid[] = "uid=%u%s%s expire %u line%s";
Mark Salyzyned777e92015-06-24 16:22:54 -0700115 parent->lock();
Mark Salyzyn758058f2015-08-21 16:44:30 -0700116 const char *name = parent->uidToName(mUid);
Mark Salyzyned777e92015-06-24 16:22:54 -0700117 parent->unlock();
Mark Salyzyn758058f2015-08-21 16:44:30 -0700118 const char *commName = android::tidToName(mTid);
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700119 if (!commName && (mTid != mPid)) {
Mark Salyzyn17ed6792015-04-20 13:35:15 -0700120 commName = android::tidToName(mPid);
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700121 }
122 if (!commName) {
Mark Salyzyned777e92015-06-24 16:22:54 -0700123 parent->lock();
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700124 commName = parent->pidToName(mPid);
Mark Salyzyned777e92015-06-24 16:22:54 -0700125 parent->unlock();
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700126 }
Mark Salyzynddda2122015-10-02 09:22:52 -0700127 if (name && name[0] && commName && (name[0] == commName[0])) {
128 size_t len = strlen(name + 1);
129 if (!strncmp(name + 1, commName + 1, len)) {
130 if (commName[len + 1] == '\0') {
Mark Salyzyn758058f2015-08-21 16:44:30 -0700131 free(const_cast<char *>(commName));
Mark Salyzynddda2122015-10-02 09:22:52 -0700132 commName = NULL;
133 } else {
Mark Salyzyn758058f2015-08-21 16:44:30 -0700134 free(const_cast<char *>(name));
Mark Salyzynddda2122015-10-02 09:22:52 -0700135 name = NULL;
136 }
Mark Salyzyn047cc072015-06-04 13:35:30 -0700137 }
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700138 }
139 if (name) {
Mark Salyzyn758058f2015-08-21 16:44:30 -0700140 char *buf = NULL;
141 asprintf(&buf, "(%s)", name);
142 if (buf) {
143 free(const_cast<char *>(name));
144 name = buf;
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700145 }
146 }
147 if (commName) {
Mark Salyzyn758058f2015-08-21 16:44:30 -0700148 char *buf = NULL;
149 asprintf(&buf, " %s", commName);
150 if (buf) {
151 free(const_cast<char *>(commName));
152 commName = buf;
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700153 }
154 }
155 // identical to below to calculate the buffer size required
Mark Salyzynddda2122015-10-02 09:22:52 -0700156 size_t len = snprintf(NULL, 0, format_uid, mUid, name ? name : "",
157 commName ? commName : "",
158 mDropped, (mDropped > 1) ? "s" : "");
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700159
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700160 size_t hdrLen;
161 if (mLogId == LOG_ID_EVENTS) {
162 hdrLen = sizeof(android_log_event_string_t);
163 } else {
164 hdrLen = 1 + sizeof(tag);
165 }
166
167 buffer = static_cast<char *>(calloc(1, hdrLen + len + 1));
168 if (!buffer) {
Mark Salyzyn758058f2015-08-21 16:44:30 -0700169 free(const_cast<char *>(name));
170 free(const_cast<char *>(commName));
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700171 return 0;
172 }
173
174 size_t retval = hdrLen + len;
175 if (mLogId == LOG_ID_EVENTS) {
Mark Salyzyn758058f2015-08-21 16:44:30 -0700176 android_log_event_string_t *event =
177 reinterpret_cast<android_log_event_string_t *>(buffer);
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700178
Mark Salyzyn758058f2015-08-21 16:44:30 -0700179 event->header.tag = htole32(LOGD_LOG_TAG);
180 event->type = EVENT_TYPE_STRING;
181 event->length = htole32(len);
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700182 } else {
183 ++retval;
184 buffer[0] = ANDROID_LOG_INFO;
185 strcpy(buffer + 1, tag);
186 }
187
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700188 snprintf(buffer + hdrLen, len + 1, format_uid, mUid, name ? name : "",
189 commName ? commName : "",
190 mDropped, (mDropped > 1) ? "s" : "");
Mark Salyzyn758058f2015-08-21 16:44:30 -0700191 free(const_cast<char *>(name));
192 free(const_cast<char *>(commName));
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700193
194 return retval;
195}
196
Mark Salyzyn7b873652015-12-03 15:38:35 -0800197uint64_t LogBufferElement::flushTo(SocketClient *reader, LogBuffer *parent,
198 bool privileged) {
199 struct logger_entry_v4 entry;
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700200
Mark Salyzyn7b873652015-12-03 15:38:35 -0800201 memset(&entry, 0, sizeof(struct logger_entry_v4));
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700202
Mark Salyzyn7b873652015-12-03 15:38:35 -0800203 entry.hdr_size = privileged ?
204 sizeof(struct logger_entry_v4) :
205 sizeof(struct logger_entry_v3);
Mark Salyzyn0175b072014-02-26 09:50:16 -0800206 entry.lid = mLogId;
207 entry.pid = mPid;
Mark Salyzynb992d0d2014-03-20 16:09:38 -0700208 entry.tid = mTid;
Mark Salyzyn7b873652015-12-03 15:38:35 -0800209 entry.uid = mUid;
Mark Salyzyn0175b072014-02-26 09:50:16 -0800210 entry.sec = mRealTime.tv_sec;
211 entry.nsec = mRealTime.tv_nsec;
212
213 struct iovec iovec[2];
214 iovec[0].iov_base = &entry;
Mark Salyzyn7b873652015-12-03 15:38:35 -0800215 iovec[0].iov_len = entry.hdr_size;
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700216
217 char *buffer = NULL;
218
219 if (!mMsg) {
Mark Salyzyn21fb7e02015-04-20 07:26:27 -0700220 entry.len = populateDroppedMessage(buffer, parent);
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700221 if (!entry.len) {
222 return mSequence;
223 }
224 iovec[1].iov_base = buffer;
225 } else {
226 entry.len = mMsgLen;
227 iovec[1].iov_base = mMsg;
228 }
229 iovec[1].iov_len = entry.len;
230
231 uint64_t retval = reader->sendDatav(iovec, 2) ? FLUSH_ERROR : mSequence;
232
233 if (buffer) {
234 free(buffer);
Mark Salyzyn0175b072014-02-26 09:50:16 -0800235 }
236
Mark Salyzynab0dcf62015-03-16 12:04:09 -0700237 return retval;
Mark Salyzyn0175b072014-02-26 09:50:16 -0800238}