Merge "Move ls implementation detail into ls."
diff --git a/logd/LogBuffer.cpp b/logd/LogBuffer.cpp
index d11b129..a5844a3 100644
--- a/logd/LogBuffer.cpp
+++ b/logd/LogBuffer.cpp
@@ -16,7 +16,6 @@
#include <ctype.h>
#include <stdio.h>
-#include <stdlib.h>
#include <string.h>
#include <sys/user.h>
#include <time.h>
@@ -281,15 +280,14 @@
size_t second_worst_sizes = 0;
if ((id != LOG_ID_CRASH) && mPrune.worstUidEnabled()) {
- const UidEntry **sorted = stats.sort(2, id);
+ std::unique_ptr<const UidEntry *[]> sorted = stats.sort(2, id);
- if (sorted) {
+ if (sorted.get()) {
if (sorted[0] && sorted[1]) {
worst = sorted[0]->getKey();
worst_sizes = sorted[0]->getSizes();
second_worst_sizes = sorted[1]->getSizes();
}
- delete [] sorted;
}
}
diff --git a/logd/LogBufferElement.h b/logd/LogBufferElement.h
index 0628d3e..93671da 100644
--- a/logd/LogBufferElement.h
+++ b/logd/LogBufferElement.h
@@ -24,6 +24,14 @@
#include <log/log.h>
#include <log/log_read.h>
+namespace android {
+
+// Furnished in main.cpp. Caller must own and free returned value
+// This function is designed for a single caller and is NOT thread-safe
+char *uidToName(uid_t uid);
+
+}
+
class LogBufferElement {
const log_id_t mLogId;
const uid_t mUid;
diff --git a/logd/LogStatistics.cpp b/logd/LogStatistics.cpp
index accd660..3fbcfd6 100644
--- a/logd/LogStatistics.cpp
+++ b/logd/LogStatistics.cpp
@@ -17,7 +17,6 @@
#include <algorithm> // std::max
#include <fcntl.h>
#include <stdio.h>
-#include <stdlib.h>
#include <string.h>
#include <unistd.h>
@@ -27,7 +26,8 @@
#include "LogStatistics.h"
-LogStatistics::LogStatistics() {
+LogStatistics::LogStatistics()
+ : enable(false) {
log_id_for_each(id) {
mSizes[id] = 0;
mElements[id] = 0;
@@ -36,8 +36,10 @@
}
}
+namespace android {
+
// caller must own and free character string
-char *LogStatistics::pidToName(pid_t pid) {
+static char *pidToName(pid_t pid) {
char *retval = NULL;
if (pid == 0) { // special case from auditd for kernel
retval = strdup("logd.auditd");
@@ -60,6 +62,8 @@
return retval;
}
+}
+
void LogStatistics::add(LogBufferElement *e) {
log_id_t log_id = e->getLogId();
unsigned short size = e->getMsgLen();
@@ -81,6 +85,31 @@
mSizesTotal[log_id] += size;
++mElementsTotal[log_id];
+
+ if (!enable) {
+ return;
+ }
+
+ pid_t pid = e->getPid();
+ hash = android::hash_type(pid);
+ index = pidTable.find(-1, hash, pid);
+ if (index == -1) {
+ PidEntry initEntry(pid, uid, android::pidToName(pid));
+ initEntry.add(size);
+ pidTable.add(hash, initEntry);
+ } else {
+ PidEntry &entry = pidTable.editEntryAt(index);
+ if (entry.getUid() != uid) {
+ entry.setUid(uid);
+ entry.setName(android::pidToName(pid));
+ } else if (!entry.getName()) {
+ char *name = android::pidToName(pid);
+ if (name) {
+ entry.setName(name);
+ }
+ }
+ entry.add(size);
+ }
}
void LogStatistics::subtract(LogBufferElement *e) {
@@ -99,33 +128,20 @@
table.removeAt(index);
}
}
-}
-// caller must own and delete UidEntry array
-const UidEntry **LogStatistics::sort(size_t n, log_id id) {
- if (!n) {
- return NULL;
+ if (!enable) {
+ return;
}
- const UidEntry **retval = new const UidEntry* [n];
- memset(retval, 0, sizeof(*retval) * n);
-
- uidTable_t &table = uidTable[id];
- ssize_t index = -1;
- while ((index = table.next(index)) >= 0) {
- const UidEntry &entry = table.entryAt(index);
- size_t s = entry.getSizes();
- ssize_t i = n - 1;
- while ((!retval[i] || (s > retval[i]->getSizes())) && (--i >= 0));
- if (++i < (ssize_t)n) {
- size_t b = n - i - 1;
- if (b) {
- memmove(&retval[i+1], &retval[i], b * sizeof(retval[0]));
- }
- retval[i] = &entry;
+ pid_t pid = e->getPid();
+ hash = android::hash_type(pid);
+ index = pidTable.find(-1, hash, pid);
+ if (index != -1) {
+ PidEntry &entry = pidTable.editEntryAt(index);
+ if (entry.subtract(size)) {
+ pidTable.removeAt(index);
}
}
- return retval;
}
// caller must own and free character string
@@ -145,8 +161,33 @@
++info;
}
+ // Parse /data/system/packages.list
+ char *name = android::uidToName(uid);
+ if (name) {
+ return name;
+ }
+
+ // report uid -> pid(s) -> pidToName if unique
+ ssize_t index = -1;
+ while ((index = pidTable.next(index)) != -1) {
+ const PidEntry &entry = pidTable.entryAt(index);
+
+ if (entry.getUid() == uid) {
+ const char *n = entry.getName();
+
+ if (n) {
+ if (!name) {
+ name = strdup(n);
+ } else if (strcmp(name, n)) {
+ free(name);
+ return NULL;
+ }
+ }
+ }
+ }
+
// No one
- return NULL;
+ return name;
}
static void format_line(android::String8 &output,
@@ -223,37 +264,23 @@
// 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;
}
- static const size_t maximum_sorted_entries = 32;
- const UidEntry **sorted = sort(maximum_sorted_entries, id);
-
- if (!sorted) {
- continue;
- }
-
- bool print = false;
- for(size_t index = 0; index < maximum_sorted_entries; ++index) {
+ 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];
-
- if (!entry) {
- break;
- }
-
- size_t sizes = entry->getSizes();
- if (sizes < (65536/100)) {
- break;
- }
-
uid_t u = entry->getKey();
if ((uid != AID_ROOT) && (u != uid)) {
continue;
}
- if (!print) {
+ if (!headerPrinted) {
if (uid == AID_ROOT) {
output.appendFormat(
"\n\nChattiest UIDs in %s:\n",
@@ -266,7 +293,7 @@
"\n\nLogging for your UID in %s:\n",
android_log_id_to_name(id));
}
- print = true;
+ headerPrinted = true;
}
android::String8 name("");
@@ -278,18 +305,61 @@
}
android::String8 size("");
- size.appendFormat("%zu", sizes);
+ size.appendFormat("%zu", entry->getSizes());
format_line(output, name, size);
}
+ }
- delete [] sorted;
+ if (enable) {
+ 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) {
+ if (uid == AID_ROOT) {
+ output.appendFormat("\n\nChattiest PIDs:\n");
+ } else {
+ output.appendFormat("\n\nLogging for this PID:\n");
+ }
+ android::String8 name(" PID/UID");
+ android::String8 size("Size");
+ format_line(output, name, size);
+ 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());
+
+ format_line(output, name, size);
+ }
}
*buf = strdup(output.string());
}
-uid_t LogStatistics::pidToUid(pid_t pid) {
+namespace android {
+
+uid_t pidToUid(pid_t pid) {
char buffer[512];
snprintf(buffer, sizeof(buffer), "/proc/%u/status", pid);
FILE *fp = fopen(buffer, "r");
@@ -305,3 +375,52 @@
}
return getuid(); // associate this with the logger
}
+
+}
+
+uid_t LogStatistics::pidToUid(pid_t pid) {
+ uid_t uid;
+ android::hash_t hash = android::hash_type(pid);
+ ssize_t index = pidTable.find(-1, hash, pid);
+ if (index == -1) {
+ uid = android::pidToUid(pid);
+ PidEntry initEntry(pid, uid, android::pidToName(pid));
+ pidTable.add(hash, initEntry);
+ } else {
+ PidEntry &entry = pidTable.editEntryAt(index);
+ if (!entry.getName()) {
+ char *name = android::pidToName(pid);
+ if (name) {
+ entry.setName(name);
+ }
+ }
+ uid = entry.getUid();
+ }
+ return uid;
+}
+
+// caller must free character string
+char *LogStatistics::pidToName(pid_t pid) {
+ char *name;
+
+ android::hash_t hash = android::hash_type(pid);
+ ssize_t index = pidTable.find(-1, hash, pid);
+ if (index == -1) {
+ name = android::pidToName(pid);
+ PidEntry initEntry(pid, android::pidToUid(pid), name ? strdup(name) : NULL);
+ pidTable.add(hash, initEntry);
+ } else {
+ PidEntry &entry = pidTable.editEntryAt(index);
+ const char *n = entry.getName();
+ if (n) {
+ name = strdup(n);
+ } else {
+ name = android::pidToName(pid);
+ if (name) {
+ entry.setName(strdup(name));
+ }
+ }
+ }
+
+ return name;
+}
diff --git a/logd/LogStatistics.h b/logd/LogStatistics.h
index d5b8762..a65ffe0 100644
--- a/logd/LogStatistics.h
+++ b/logd/LogStatistics.h
@@ -17,6 +17,8 @@
#ifndef _LOGD_LOG_STATISTICS_H__
#define _LOGD_LOG_STATISTICS_H__
+#include <memory>
+#include <stdlib.h>
#include <sys/types.h>
#include <log/log.h>
@@ -27,6 +29,52 @@
#define log_id_for_each(i) \
for (log_id_t i = LOG_ID_MIN; i < LOG_ID_MAX; i = (log_id_t) (i + 1))
+template <typename TKey, typename TEntry>
+class LogHashtable : public android::BasicHashtable<TKey, TEntry> {
+public:
+ std::unique_ptr<const TEntry *[]> sort(size_t n) {
+ if (!n) {
+ std::unique_ptr<const TEntry *[]> sorted(NULL);
+ return sorted;
+ }
+
+ const TEntry **retval = new const TEntry* [n];
+ memset(retval, 0, sizeof(*retval) * n);
+
+ ssize_t index = -1;
+ while ((index = android::BasicHashtable<TKey, TEntry>::next(index)) >= 0) {
+ const TEntry &entry = android::BasicHashtable<TKey, TEntry>::entryAt(index);
+ size_t s = entry.getSizes();
+ ssize_t i = n - 1;
+ while ((!retval[i] || (s > retval[i]->getSizes())) && (--i >= 0))
+ ;
+ if (++i < (ssize_t)n) {
+ size_t b = n - i - 1;
+ if (b) {
+ memmove(&retval[i+1], &retval[i], b * sizeof(retval[0]));
+ }
+ retval[i] = &entry;
+ }
+ }
+ std::unique_ptr<const TEntry *[]> sorted(retval);
+ return sorted;
+ }
+
+ // Iteration handler for the sort method output
+ static ssize_t next(ssize_t index, std::unique_ptr<const TEntry *[]> &sorted, size_t n) {
+ ++index;
+ if (!sorted.get() || (index < 0) || (n <= (size_t)index) || !sorted[index]
+ || (sorted[index]->getSizes() <= (sorted[0]->getSizes() / 100))) {
+ return -1;
+ }
+ return index;
+ }
+
+ ssize_t next(ssize_t index) {
+ return android::BasicHashtable<TKey, TEntry>::next(index);
+ }
+};
+
struct UidEntry {
const uid_t uid;
size_t size;
@@ -39,27 +87,55 @@
inline bool subtract(size_t s) { size -= s; return !size; }
};
+struct PidEntry {
+ const pid_t pid;
+ uid_t uid;
+ char *name;
+ size_t size;
+
+ PidEntry(pid_t p, uid_t u, char *n):pid(p),uid(u),name(n),size(0) { }
+ PidEntry(const PidEntry &c):
+ pid(c.pid),
+ uid(c.uid),
+ name(c.name ? strdup(c.name) : NULL),
+ size(c.size) { }
+ ~PidEntry() { free(name); }
+
+ const pid_t&getKey() const { return pid; }
+ const uid_t&getUid() const { return uid; }
+ uid_t&setUid(uid_t u) { return uid = u; }
+ const char*getName() const { return name; }
+ char *setName(char *n) { free(name); return name = n; }
+ size_t getSizes() const { return size; }
+ inline void add(size_t s) { size += s; }
+ inline bool subtract(size_t s) { size -= s; return !size; }
+};
+
// Log Statistics
class LogStatistics {
size_t mSizes[LOG_ID_MAX];
size_t mElements[LOG_ID_MAX];
size_t mSizesTotal[LOG_ID_MAX];
size_t mElementsTotal[LOG_ID_MAX];
+ bool enable;
// uid to size list
- typedef android::BasicHashtable<uid_t, UidEntry> uidTable_t;
+ typedef LogHashtable<uid_t, UidEntry> uidTable_t;
uidTable_t uidTable[LOG_ID_MAX];
+ // pid to uid list
+ typedef LogHashtable<pid_t, PidEntry> pidTable_t;
+ pidTable_t pidTable;
+
public:
LogStatistics();
- void enableStatistics() { }
+ void enableStatistics() { enable = true; }
void add(LogBufferElement *entry);
void subtract(LogBufferElement *entry);
- // Caller must delete array
- const UidEntry **sort(size_t n, log_id i);
+ std::unique_ptr<const UidEntry *[]> sort(size_t n, log_id i) { return uidTable[i].sort(n); }
// fast track current value by id only
size_t sizes(log_id_t id) const { return mSizes[id]; }
diff --git a/logd/main.cpp b/logd/main.cpp
index a61beff..1ffb8b0 100644
--- a/logd/main.cpp
+++ b/logd/main.cpp
@@ -143,6 +143,10 @@
// write(fdDmesg, "I am here\n", 10);
static int fdDmesg = -1;
+static sem_t uidName;
+static uid_t uid;
+static char *name;
+
static sem_t reinit;
static bool reinit_running = false;
static LogBuffer *logBuf = NULL;
@@ -151,10 +155,45 @@
prctl(PR_SET_NAME, "logd.daemon");
set_sched_policy(0, SP_BACKGROUND);
- setgid(AID_LOGD);
- setuid(AID_LOGD);
+ setgid(AID_SYSTEM);
+ setuid(AID_SYSTEM);
while (reinit_running && !sem_wait(&reinit) && reinit_running) {
+
+ // uidToName Privileged Worker
+ if (uid) {
+ name = NULL;
+
+ FILE *fp = fopen("/data/system/packages.list", "r");
+ if (fp) {
+ // This simple parser is sensitive to format changes in
+ // frameworks/base/services/core/java/com/android/server/pm/Settings.java
+ // A dependency note has been added to that file to correct
+ // this parser.
+
+ char *buffer = NULL;
+ size_t len;
+ while (getline(&buffer, &len, fp) > 0) {
+ char *userId = strchr(buffer, ' ');
+ if (!userId) {
+ continue;
+ }
+ *userId = '\0';
+ unsigned long value = strtoul(userId + 1, NULL, 10);
+ if (value != uid) {
+ continue;
+ }
+ name = strdup(buffer);
+ break;
+ }
+ free(buffer);
+ fclose(fp);
+ }
+ uid = 0;
+ sem_post(&uidName);
+ continue;
+ }
+
if (fdDmesg >= 0) {
static const char reinit_message[] = { KMSG_PRIORITY(LOG_INFO),
'l', 'o', 'g', 'd', '.', 'd', 'a', 'e', 'm', 'o', 'n', ':',
@@ -171,6 +210,20 @@
return NULL;
}
+char *android::uidToName(uid_t u) {
+ if (!u || !reinit_running) {
+ return NULL;
+ }
+
+ // Not multi-thread safe, we know there is only one caller
+ uid = u;
+
+ name = NULL;
+ sem_post(&reinit);
+ sem_wait(&uidName);
+ return name;
+}
+
// Serves as a global method to trigger reinitialization
// and as a function that can be provided to signal().
void reinit_signal_handler(int /*signal*/) {
@@ -223,6 +276,7 @@
// Reinit Thread
sem_init(&reinit, 0, 0);
+ sem_init(&uidName, 0, 0);
pthread_attr_t attr;
if (!pthread_attr_init(&attr)) {
struct sched_param param;