| /* |
| * Copyright (C) 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 <algorithm> // std::max |
| #include <fcntl.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <log/logger.h> |
| #include <private/android_filesystem_config.h> |
| #include <utils/String8.h> |
| |
| #include "LogStatistics.h" |
| |
| LogStatistics::LogStatistics() : enable(false) { |
| log_id_for_each(id) { |
| mSizes[id] = 0; |
| mElements[id] = 0; |
| mSizesTotal[id] = 0; |
| mElementsTotal[id] = 0; |
| } |
| } |
| |
| namespace android { |
| |
| // caller must own and free character string |
| char *pidToName(pid_t pid) { |
| char *retval = NULL; |
| if (pid == 0) { // special case from auditd/klogd for kernel |
| retval = strdup("logd"); |
| } else { |
| char buffer[512]; |
| snprintf(buffer, sizeof(buffer), "/proc/%u/cmdline", pid); |
| int fd = open(buffer, O_RDONLY); |
| if (fd >= 0) { |
| ssize_t ret = read(fd, buffer, sizeof(buffer)); |
| if (ret > 0) { |
| buffer[sizeof(buffer)-1] = '\0'; |
| // frameworks intermediate state |
| if (strcmp(buffer, "<pre-initialized>")) { |
| retval = strdup(buffer); |
| } |
| } |
| close(fd); |
| } |
| } |
| return retval; |
| } |
| |
| } |
| |
| void LogStatistics::add(LogBufferElement *e) { |
| log_id_t log_id = e->getLogId(); |
| unsigned short size = e->getMsgLen(); |
| mSizes[log_id] += size; |
| ++mElements[log_id]; |
| |
| mSizesTotal[log_id] += size; |
| ++mElementsTotal[log_id]; |
| |
| if (log_id == LOG_ID_KERNEL) { |
| return; |
| } |
| |
| uidTable[log_id].add(e->getUid(), e); |
| |
| if (!enable) { |
| return; |
| } |
| |
| pidTable.add(e->getPid(), e); |
| tidTable.add(e->getTid(), e); |
| |
| uint32_t tag = e->getTag(); |
| if (tag) { |
| tagTable.add(tag, e); |
| } |
| } |
| |
| void LogStatistics::subtract(LogBufferElement *e) { |
| log_id_t log_id = e->getLogId(); |
| unsigned short size = e->getMsgLen(); |
| mSizes[log_id] -= size; |
| --mElements[log_id]; |
| |
| if (log_id == LOG_ID_KERNEL) { |
| return; |
| } |
| |
| uidTable[log_id].subtract(e->getUid(), e); |
| |
| if (!enable) { |
| return; |
| } |
| |
| pidTable.subtract(e->getPid(), e); |
| tidTable.subtract(e->getTid(), e); |
| |
| uint32_t tag = e->getTag(); |
| if (tag) { |
| tagTable.subtract(tag, e); |
| } |
| } |
| |
| // Atomically set an entry to drop |
| // entry->setDropped(1) must follow this call, caller should do this explicitly. |
| void LogStatistics::drop(LogBufferElement *e) { |
| log_id_t log_id = e->getLogId(); |
| unsigned short size = e->getMsgLen(); |
| mSizes[log_id] -= size; |
| |
| uidTable[log_id].drop(e->getUid(), e); |
| |
| if (!enable) { |
| return; |
| } |
| |
| pidTable.drop(e->getPid(), e); |
| tidTable.drop(e->getTid(), e); |
| } |
| |
| // caller must own and free character string |
| char *LogStatistics::uidToName(uid_t uid) { |
| // Local hard coded favourites |
| if (uid == AID_LOGD) { |
| return strdup("auditd"); |
| } |
| |
| // Android hard coded |
| const struct android_id_info *info = android_ids; |
| |
| for (size_t i = 0; i < android_id_count; ++i) { |
| if (info->aid == uid) { |
| return strdup(info->name); |
| } |
| ++info; |
| } |
| |
| // Parse /data/system/packages.list |
| uid_t userId = uid % AID_USER; |
| char *name = android::uidToName(userId); |
| if (!name && (userId > (AID_SHARED_GID_START - AID_APP))) { |
| name = android::uidToName(userId - (AID_SHARED_GID_START - AID_APP)); |
| } |
| if (name) { |
| return name; |
| } |
| |
| // report uid -> pid(s) -> pidToName if unique |
| for(pidTable_t::iterator it = pidTable.begin(); it != pidTable.end(); ++it) { |
| const PidEntry &entry = it->second; |
| |
| if (entry.getUid() == uid) { |
| const char *n = entry.getName(); |
| |
| if (n) { |
| if (!name) { |
| name = strdup(n); |
| } else if (strcmp(name, n)) { |
| free(name); |
| name = NULL; |
| break; |
| } |
| } |
| } |
| } |
| |
| // No one |
| return name; |
| } |
| |
| static void format_line(android::String8 &output, |
| android::String8 &name, android::String8 &size, android::String8 &pruned) { |
| static const size_t pruned_len = 6; |
| static const size_t total_len = 70 + pruned_len; |
| |
| ssize_t drop_len = std::max(pruned.length() + 1, pruned_len); |
| ssize_t size_len = std::max(size.length() + 1, |
| total_len - name.length() - drop_len - 1); |
| |
| if (pruned.length()) { |
| output.appendFormat("%s%*s%*s\n", name.string(), |
| (int)size_len, size.string(), |
| (int)drop_len, pruned.string()); |
| } else { |
| output.appendFormat("%s%*s\n", name.string(), |
| (int)size_len, size.string()); |
| } |
| } |
| |
| void LogStatistics::format(char **buf, uid_t uid, unsigned int logMask) { |
| static const unsigned short spaces_total = 19; |
| |
| if (*buf) { |
| free(*buf); |
| *buf = NULL; |
| } |
| |
| // Report on total logging, current and for all time |
| |
| android::String8 output("size/num"); |
| size_t oldLength; |
| short spaces = 1; |
| |
| log_id_for_each(id) { |
| if (!(logMask & (1 << id))) { |
| continue; |
| } |
| oldLength = output.length(); |
| if (spaces < 0) { |
| spaces = 0; |
| } |
| output.appendFormat("%*s%s", spaces, "", android_log_id_to_name(id)); |
| spaces += spaces_total + oldLength - output.length(); |
| } |
| |
| spaces = 4; |
| output.appendFormat("\nTotal"); |
| |
| log_id_for_each(id) { |
| if (!(logMask & (1 << id))) { |
| continue; |
| } |
| oldLength = output.length(); |
| if (spaces < 0) { |
| spaces = 0; |
| } |
| output.appendFormat("%*s%zu/%zu", spaces, "", |
| sizesTotal(id), elementsTotal(id)); |
| spaces += spaces_total + oldLength - output.length(); |
| } |
| |
| spaces = 6; |
| output.appendFormat("\nNow"); |
| |
| log_id_for_each(id) { |
| if (!(logMask & (1 << id))) { |
| continue; |
| } |
| |
| size_t els = elements(id); |
| if (els) { |
| oldLength = output.length(); |
| if (spaces < 0) { |
| spaces = 0; |
| } |
| output.appendFormat("%*s%zu/%zu", spaces, "", sizes(id), els); |
| spaces -= output.length() - oldLength; |
| } |
| spaces += spaces_total; |
| } |
| |
| // Report on Chattiest |
| |
| // Chattiest by application (UID) |
| static const size_t maximum_sorted_entries = 32; |
| log_id_for_each(id) { |
| if (!(logMask & (1 << id))) { |
| continue; |
| } |
| |
| bool headerPrinted = false; |
| std::unique_ptr<const UidEntry *[]> sorted = sort(maximum_sorted_entries, id); |
| ssize_t index = -1; |
| while ((index = uidTable_t::next(index, sorted, maximum_sorted_entries)) >= 0) { |
| const UidEntry *entry = sorted[index]; |
| uid_t u = entry->getKey(); |
| if ((uid != AID_ROOT) && (u != uid)) { |
| continue; |
| } |
| |
| if (!headerPrinted) { |
| output.appendFormat("\n\n"); |
| android::String8 name(""); |
| if (uid == AID_ROOT) { |
| name.appendFormat( |
| "Chattiest UIDs in %s log buffer:", |
| android_log_id_to_name(id)); |
| } else { |
| name.appendFormat( |
| "Logging for your UID in %s log buffer:", |
| android_log_id_to_name(id)); |
| } |
| android::String8 size("Size"); |
| android::String8 pruned("Pruned"); |
| if (!worstUidEnabledForLogid(id)) { |
| pruned.setTo(""); |
| } |
| format_line(output, name, size, pruned); |
| |
| name.setTo("UID PACKAGE"); |
| size.setTo("BYTES"); |
| pruned.setTo("LINES"); |
| if (!worstUidEnabledForLogid(id)) { |
| pruned.setTo(""); |
| } |
| format_line(output, name, size, pruned); |
| |
| headerPrinted = true; |
| } |
| |
| android::String8 name(""); |
| name.appendFormat("%u", u); |
| char *n = uidToName(u); |
| if (n) { |
| name.appendFormat("%*s%s", (int)std::max(6 - name.length(), (size_t)1), "", n); |
| free(n); |
| } |
| |
| android::String8 size(""); |
| size.appendFormat("%zu", entry->getSizes()); |
| |
| android::String8 pruned(""); |
| size_t dropped = entry->getDropped(); |
| if (dropped) { |
| pruned.appendFormat("%zu", dropped); |
| } |
| |
| format_line(output, name, size, pruned); |
| } |
| } |
| |
| if (enable) { |
| // Pid table |
| bool headerPrinted = false; |
| std::unique_ptr<const PidEntry *[]> sorted = pidTable.sort(maximum_sorted_entries); |
| ssize_t index = -1; |
| while ((index = pidTable.next(index, sorted, maximum_sorted_entries)) >= 0) { |
| const PidEntry *entry = sorted[index]; |
| uid_t u = entry->getUid(); |
| if ((uid != AID_ROOT) && (u != uid)) { |
| continue; |
| } |
| |
| if (!headerPrinted) { |
| output.appendFormat("\n\n"); |
| android::String8 name(""); |
| if (uid == AID_ROOT) { |
| name.appendFormat("Chattiest PIDs:"); |
| } else { |
| name.appendFormat("Logging for this PID:"); |
| } |
| android::String8 size("Size"); |
| android::String8 pruned("Pruned"); |
| format_line(output, name, size, pruned); |
| |
| name.setTo(" PID/UID COMMAND LINE"); |
| size.setTo("BYTES"); |
| pruned.setTo("LINES"); |
| format_line(output, name, size, pruned); |
| |
| headerPrinted = true; |
| } |
| |
| android::String8 name(""); |
| name.appendFormat("%5u/%u", entry->getKey(), u); |
| const char *n = entry->getName(); |
| if (n) { |
| name.appendFormat("%*s%s", (int)std::max(12 - name.length(), (size_t)1), "", n); |
| } else { |
| char *un = uidToName(u); |
| if (un) { |
| name.appendFormat("%*s%s", (int)std::max(12 - name.length(), (size_t)1), "", un); |
| free(un); |
| } |
| } |
| |
| android::String8 size(""); |
| size.appendFormat("%zu", entry->getSizes()); |
| |
| android::String8 pruned(""); |
| size_t dropped = entry->getDropped(); |
| if (dropped) { |
| pruned.appendFormat("%zu", dropped); |
| } |
| |
| format_line(output, name, size, pruned); |
| } |
| } |
| |
| if (enable) { |
| // Tid table |
| bool headerPrinted = false; |
| // sort() returns list of references, unique_ptr makes sure self-delete |
| std::unique_ptr<const TidEntry *[]> sorted = tidTable.sort(maximum_sorted_entries); |
| ssize_t index = -1; |
| while ((index = tidTable.next(index, sorted, maximum_sorted_entries)) >= 0) { |
| const TidEntry *entry = sorted[index]; |
| uid_t u = entry->getUid(); |
| if ((uid != AID_ROOT) && (u != uid)) { |
| continue; |
| } |
| |
| if (!headerPrinted) { // Only print header if we have table to print |
| output.appendFormat("\n\n"); |
| android::String8 name("Chattiest TIDs:"); |
| android::String8 size("Size"); |
| android::String8 pruned("Pruned"); |
| format_line(output, name, size, pruned); |
| |
| name.setTo(" TID/UID COMM"); |
| size.setTo("BYTES"); |
| pruned.setTo("LINES"); |
| format_line(output, name, size, pruned); |
| |
| headerPrinted = true; |
| } |
| |
| android::String8 name(""); |
| name.appendFormat("%5u/%u", entry->getKey(), u); |
| const char *n = entry->getName(); |
| if (n) { |
| name.appendFormat("%*s%s", (int)std::max(12 - name.length(), (size_t)1), "", n); |
| } else { |
| // if we do not have a PID name, lets punt to try UID name? |
| char *un = uidToName(u); |
| if (un) { |
| name.appendFormat("%*s%s", (int)std::max(12 - name.length(), (size_t)1), "", un); |
| free(un); |
| } |
| // We tried, better to not have a name at all, we still |
| // have TID/UID by number to report in any case. |
| } |
| |
| android::String8 size(""); |
| size.appendFormat("%zu", entry->getSizes()); |
| |
| android::String8 pruned(""); |
| size_t dropped = entry->getDropped(); |
| if (dropped) { |
| pruned.appendFormat("%zu", dropped); |
| } |
| |
| format_line(output, name, size, pruned); |
| } |
| } |
| |
| if (enable && (logMask & (1 << LOG_ID_EVENTS))) { |
| // Tag table |
| bool headerPrinted = false; |
| std::unique_ptr<const TagEntry *[]> sorted = tagTable.sort(maximum_sorted_entries); |
| ssize_t index = -1; |
| while ((index = tagTable.next(index, sorted, maximum_sorted_entries)) >= 0) { |
| const TagEntry *entry = sorted[index]; |
| uid_t u = entry->getUid(); |
| if ((uid != AID_ROOT) && (u != uid)) { |
| continue; |
| } |
| |
| android::String8 pruned(""); |
| |
| if (!headerPrinted) { |
| output.appendFormat("\n\n"); |
| android::String8 name("Chattiest events log buffer TAGs:"); |
| android::String8 size("Size"); |
| format_line(output, name, size, pruned); |
| |
| name.setTo(" TAG/UID TAGNAME"); |
| size.setTo("BYTES"); |
| format_line(output, name, size, pruned); |
| |
| headerPrinted = true; |
| } |
| |
| android::String8 name(""); |
| if (u == (uid_t)-1) { |
| name.appendFormat("%7u", entry->getKey()); |
| } else { |
| name.appendFormat("%7u/%u", entry->getKey(), u); |
| } |
| const char *n = entry->getName(); |
| if (n) { |
| name.appendFormat("%*s%s", (int)std::max(14 - name.length(), (size_t)1), "", n); |
| } |
| |
| android::String8 size(""); |
| size.appendFormat("%zu", entry->getSizes()); |
| |
| format_line(output, name, size, pruned); |
| } |
| } |
| |
| *buf = strdup(output.string()); |
| } |
| |
| namespace android { |
| |
| uid_t pidToUid(pid_t pid) { |
| char buffer[512]; |
| snprintf(buffer, sizeof(buffer), "/proc/%u/status", pid); |
| FILE *fp = fopen(buffer, "r"); |
| if (fp) { |
| while (fgets(buffer, sizeof(buffer), fp)) { |
| int uid; |
| if (sscanf(buffer, "Uid: %d", &uid) == 1) { |
| fclose(fp); |
| return uid; |
| } |
| } |
| fclose(fp); |
| } |
| return AID_LOGD; // associate this with the logger |
| } |
| |
| } |
| |
| uid_t LogStatistics::pidToUid(pid_t pid) { |
| return pidTable.add(pid)->second.getUid(); |
| } |
| |
| // caller must free character string |
| char *LogStatistics::pidToName(pid_t pid) { |
| const char *name = pidTable.add(pid)->second.getName(); |
| if (!name) { |
| return NULL; |
| } |
| return strdup(name); |
| } |
