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 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 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 62 LogBufferElement::~LogBufferElement() { 63 delete[] mMsg; 64 } 65 66 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 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 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 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 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
