1 /*
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
17 #include <ctype.h>
18 #include <endian.h>
19 #include <fcntl.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <time.h>
23 #include <unistd.h>
24
25 #include <private/android_logger.h>
26
27 #include "LogBuffer.h"
28 #include "LogBufferElement.h"
29 #include "LogCommand.h"
30 #include "LogReader.h"
31 #include "LogUtils.h"
32
33 const log_time LogBufferElement::FLUSH_ERROR((uint32_t)-1, (uint32_t)-1);
34 atomic_int_fast64_t LogBufferElement::sequence(1);
35
LogBufferElement(log_id_t log_id,log_time realtime,uid_t uid,pid_t pid,pid_t tid,const char * msg,unsigned short len)36 LogBufferElement::LogBufferElement(log_id_t log_id, log_time realtime,
37 uid_t uid, pid_t pid, pid_t tid,
38 const char* msg, unsigned short len)
39 : mUid(uid),
40 mPid(pid),
41 mTid(tid),
42 mRealTime(realtime),
43 mMsgLen(len),
44 mLogId(log_id),
45 mDropped(false) {
46 mMsg = new char[len];
47 memcpy(mMsg, msg, len);
48 }
49
LogBufferElement(const LogBufferElement & elem)50 LogBufferElement::LogBufferElement(const LogBufferElement& elem)
51 : mUid(elem.mUid),
52 mPid(elem.mPid),
53 mTid(elem.mTid),
54 mRealTime(elem.mRealTime),
55 mMsgLen(elem.mMsgLen),
56 mLogId(elem.mLogId),
57 mDropped(elem.mDropped) {
58 mMsg = new char[mMsgLen];
59 memcpy(mMsg, elem.mMsg, mMsgLen);
60 }
61
~LogBufferElement()62 LogBufferElement::~LogBufferElement() {
63 delete[] mMsg;
64 }
65
getTag() const66 uint32_t LogBufferElement::getTag() const {
67 return (isBinary() &&
68 ((mDropped && mMsg != nullptr) ||
69 (!mDropped && mMsgLen >= sizeof(android_event_header_t))))
70 ? reinterpret_cast<const android_event_header_t*>(mMsg)->tag
71 : 0;
72 }
73
setDropped(unsigned short value)74 unsigned short LogBufferElement::setDropped(unsigned short value) {
75 // The tag information is saved in mMsg data, if the tag is non-zero
76 // save only the information needed to get the tag.
77 if (getTag() != 0) {
78 if (mMsgLen > sizeof(android_event_header_t)) {
79 char* truncated_msg = new char[sizeof(android_event_header_t)];
80 memcpy(truncated_msg, mMsg, sizeof(android_event_header_t));
81 delete[] mMsg;
82 mMsg = truncated_msg;
83 } // mMsgLen == sizeof(android_event_header_t), already at minimum.
84 } else {
85 delete[] mMsg;
86 mMsg = nullptr;
87 }
88 mDropped = true;
89 return mDroppedCount = value;
90 }
91
92 // caller must own and free character string
tidToName(pid_t tid)93 char* android::tidToName(pid_t tid) {
94 char* retval = NULL;
95 char buffer[256];
96 snprintf(buffer, sizeof(buffer), "/proc/%u/comm", tid);
97 int fd = open(buffer, O_RDONLY);
98 if (fd >= 0) {
99 ssize_t ret = read(fd, buffer, sizeof(buffer));
100 if (ret >= (ssize_t)sizeof(buffer)) {
101 ret = sizeof(buffer) - 1;
102 }
103 while ((ret > 0) && isspace(buffer[ret - 1])) {
104 --ret;
105 }
106 if (ret > 0) {
107 buffer[ret] = '\0';
108 retval = strdup(buffer);
109 }
110 close(fd);
111 }
112
113 // if nothing for comm, check out cmdline
114 char* name = android::pidToName(tid);
115 if (!retval) {
116 retval = name;
117 name = NULL;
118 }
119
120 // check if comm is truncated, see if cmdline has full representation
121 if (name) {
122 // impossible for retval to be NULL if name not NULL
123 size_t retval_len = strlen(retval);
124 size_t name_len = strlen(name);
125 // KISS: ToDo: Only checks prefix truncated, not suffix, or both
126 if ((retval_len < name_len) &&
127 !fastcmp<strcmp>(retval, name + name_len - retval_len)) {
128 free(retval);
129 retval = name;
130 } else {
131 free(name);
132 }
133 }
134 return retval;
135 }
136
137 // assumption: mMsg == NULL
populateDroppedMessage(char * & buffer,LogBuffer * parent,bool lastSame)138 size_t LogBufferElement::populateDroppedMessage(char*& buffer, LogBuffer* parent,
139 bool lastSame) {
140 static const char tag[] = "chatty";
141
142 if (!__android_log_is_loggable_len(ANDROID_LOG_INFO, tag, strlen(tag),
143 ANDROID_LOG_VERBOSE)) {
144 return 0;
145 }
146
147 static const char format_uid[] = "uid=%u%s%s %s %u line%s";
148 parent->wrlock();
149 const char* name = parent->uidToName(mUid);
150 parent->unlock();
151 const char* commName = android::tidToName(mTid);
152 if (!commName && (mTid != mPid)) {
153 commName = android::tidToName(mPid);
154 }
155 if (!commName) {
156 parent->wrlock();
157 commName = parent->pidToName(mPid);
158 parent->unlock();
159 }
160 if (name && name[0] && commName && (name[0] == commName[0])) {
161 size_t len = strlen(name + 1);
162 if (!strncmp(name + 1, commName + 1, len)) {
163 if (commName[len + 1] == '\0') {
164 free(const_cast<char*>(commName));
165 commName = NULL;
166 } else {
167 free(const_cast<char*>(name));
168 name = NULL;
169 }
170 }
171 }
172 if (name) {
173 char* buf = NULL;
174 asprintf(&buf, "(%s)", name);
175 if (buf) {
176 free(const_cast<char*>(name));
177 name = buf;
178 }
179 }
180 if (commName) {
181 char* buf = NULL;
182 asprintf(&buf, " %s", commName);
183 if (buf) {
184 free(const_cast<char*>(commName));
185 commName = buf;
186 }
187 }
188 // identical to below to calculate the buffer size required
189 const char* type = lastSame ? "identical" : "expire";
190 size_t len = snprintf(NULL, 0, format_uid, mUid, name ? name : "",
191 commName ? commName : "", type, getDropped(),
192 (getDropped() > 1) ? "s" : "");
193
194 size_t hdrLen;
195 if (isBinary()) {
196 hdrLen = sizeof(android_log_event_string_t);
197 } else {
198 hdrLen = 1 + sizeof(tag);
199 }
200
201 buffer = static_cast<char*>(calloc(1, hdrLen + len + 1));
202 if (!buffer) {
203 free(const_cast<char*>(name));
204 free(const_cast<char*>(commName));
205 return 0;
206 }
207
208 size_t retval = hdrLen + len;
209 if (isBinary()) {
210 android_log_event_string_t* event =
211 reinterpret_cast<android_log_event_string_t*>(buffer);
212
213 event->header.tag = htole32(CHATTY_LOG_TAG);
214 event->type = EVENT_TYPE_STRING;
215 event->length = htole32(len);
216 } else {
217 ++retval;
218 buffer[0] = ANDROID_LOG_INFO;
219 strcpy(buffer + 1, tag);
220 }
221
222 snprintf(buffer + hdrLen, len + 1, format_uid, mUid, name ? name : "",
223 commName ? commName : "", type, getDropped(),
224 (getDropped() > 1) ? "s" : "");
225 free(const_cast<char*>(name));
226 free(const_cast<char*>(commName));
227
228 return retval;
229 }
230
flushTo(SocketClient * reader,LogBuffer * parent,bool privileged,bool lastSame)231 log_time LogBufferElement::flushTo(SocketClient* reader, LogBuffer* parent,
232 bool privileged, bool lastSame) {
233 struct logger_entry_v4 entry;
234
235 memset(&entry, 0, sizeof(struct logger_entry_v4));
236
237 entry.hdr_size = privileged ? sizeof(struct logger_entry_v4)
238 : sizeof(struct logger_entry_v3);
239 entry.lid = mLogId;
240 entry.pid = mPid;
241 entry.tid = mTid;
242 entry.uid = mUid;
243 entry.sec = mRealTime.tv_sec;
244 entry.nsec = mRealTime.tv_nsec;
245
246 struct iovec iovec[2];
247 iovec[0].iov_base = &entry;
248 iovec[0].iov_len = entry.hdr_size;
249
250 char* buffer = NULL;
251
252 if (mDropped) {
253 entry.len = populateDroppedMessage(buffer, parent, lastSame);
254 if (!entry.len) return mRealTime;
255 iovec[1].iov_base = buffer;
256 } else {
257 entry.len = mMsgLen;
258 iovec[1].iov_base = mMsg;
259 }
260 iovec[1].iov_len = entry.len;
261
262 log_time retval = reader->sendDatav(iovec, 1 + (entry.len != 0))
263 ? FLUSH_ERROR
264 : mRealTime;
265
266 if (buffer) free(buffer);
267
268 return retval;
269 }
270