ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "logd: Use private interfaces for buffer size properties"

Browse source
This commit is contained in:
Mark Salyzyn 2016-10-19 14:31:04 +00:00 • committed by Gerrit Code Review
commit 6da6d37c81
3 changed files with 21 additions and 175 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

99
logd/LogBuffer.cpp
View file

@ -25,114 +25,21 @@
#include <unordered_map>
#include <cutils/properties.h>
#include <log/logger.h>
#include <private/android_logger.h>
#include "LogBuffer.h"
#include "LogKlog.h"
#include "LogReader.h"
// Default
#define LOG_BUFFER_SIZE (256 * 1024) // Tuned with ro.logd.size per-platform
#define log_buffer_size(id) mMaxSize[id]
#define LOG_BUFFER_MIN_SIZE (64 * 1024UL)
#define LOG_BUFFER_MAX_SIZE (256 * 1024 * 1024UL)
static bool valid_size(unsigned long value) {
if ((value < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < value)) {
return false;
}
long pages = sysconf(_SC_PHYS_PAGES);
if (pages < 1) {
return true;
}
long pagesize = sysconf(_SC_PAGESIZE);
if (pagesize <= 1) {
pagesize = PAGE_SIZE;
}
// maximum memory impact a somewhat arbitrary ~3%
pages = (pages + 31) / 32;
unsigned long maximum = pages * pagesize;
if ((maximum < LOG_BUFFER_MIN_SIZE) || (LOG_BUFFER_MAX_SIZE < maximum)) {
return true;
}
return value <= maximum;
}
static unsigned long property_get_size(const char *key) {
char property[PROPERTY_VALUE_MAX];
property_get(key, property, "");
char *cp;
unsigned long value = strtoul(property, &cp, 10);
switch(*cp) {
case 'm':
case 'M':
value *= 1024;
/* FALLTHRU */
case 'k':
case 'K':
value *= 1024;
/* FALLTHRU */
case '\0':
break;
default:
value = 0;
}
if (!valid_size(value)) {
value = 0;
}
return value;
}
void LogBuffer::init() {
static const char global_tuneable[] = "persist.logd.size"; // Settings App
static const char global_default[] = "ro.logd.size"; // BoardConfig.mk
unsigned long default_size = property_get_size(global_tuneable);
if (!default_size) {
default_size = property_get_size(global_default);
if (!default_size) {
default_size = property_get_bool("ro.config.low_ram",
BOOL_DEFAULT_FALSE)
? LOG_BUFFER_MIN_SIZE // 64K
: LOG_BUFFER_SIZE; // 256K
}
}
log_id_for_each(i) {
mLastSet[i] = false;
mLast[i] = mLogElements.begin();
char key[PROP_NAME_MAX];
snprintf(key, sizeof(key), "%s.%s",
global_tuneable, android_log_id_to_name(i));
unsigned long property_size = property_get_size(key);
if (!property_size) {
snprintf(key, sizeof(key), "%s.%s",
global_default, android_log_id_to_name(i));
property_size = property_get_size(key);
}
if (!property_size) {
property_size = default_size;
}
if (!property_size) {
property_size = LOG_BUFFER_SIZE;
}
if (setSize(i, property_size)) {
if (setSize(i, __android_logger_get_buffer_size(i))) {
setSize(i, LOG_BUFFER_MIN_SIZE);
}
}
@ -880,7 +787,7 @@ unsigned long LogBuffer::getSizeUsed(log_id_t id) {
// set the total space allocated to "id"
int LogBuffer::setSize(log_id_t id, unsigned long size) {
// Reasonable limits ...
if (!valid_size(size)) {
if (!__android_logger_valid_buffer_size(size)) {
return -1;
}
pthread_mutex_lock(&mLogElementsLock);

10
logd/LogUtils.h
View file

@ -45,16 +45,6 @@ const char *tagToName(size_t *len, uint32_t tag);
bool clientHasLogCredentials(uid_t uid, gid_t gid, pid_t pid);
bool clientHasLogCredentials(SocketClient *cli);
// Furnished in main.cpp
#define BOOL_DEFAULT_FLAG_TRUE_FALSE 0x1
#define BOOL_DEFAULT_FALSE 0x0 // false if property not present
#define BOOL_DEFAULT_TRUE 0x1 // true if property not present
#define BOOL_DEFAULT_FLAG_PERSIST 0x2 // <key>, persist.<key>, ro.<key>
#define BOOL_DEFAULT_FLAG_ENG 0x4 // off for user
#define BOOL_DEFAULT_FLAG_SVELTE 0x8 // off for low_ram
bool property_get_bool(const char *key, int def);
static inline bool worstUidEnabledForLogid(log_id_t id) {
return (id == LOG_ID_MAIN) || (id == LOG_ID_SYSTEM) ||
(id == LOG_ID_RADIO) || (id == LOG_ID_EVENTS);

87
logd/main.cpp
View file

@ -131,57 +131,6 @@ static bool check_flag(const char *prop, const char *flag) {
return !*cp || !!strchr(sep, *cp);
}
bool property_get_bool(const char *key, int flag) {
char def[PROPERTY_VALUE_MAX];
char property[PROPERTY_VALUE_MAX];
def[0] = '\0';
if (flag & BOOL_DEFAULT_FLAG_PERSIST) {
char newkey[PROPERTY_KEY_MAX];
snprintf(newkey, sizeof(newkey), "ro.%s", key);
property_get(newkey, property, "");
// persist properties set by /data require inoculation with
// logd-reinit. They may be set in init.rc early and function, but
// otherwise are defunct unless reset. Do not rely on persist
// properties for startup-only keys unless you are willing to restart
// logd daemon (not advised).
snprintf(newkey, sizeof(newkey), "persist.%s", key);
property_get(newkey, def, property);
}
property_get(key, property, def);
if (check_flag(property, "true")) {
return true;
}
if (check_flag(property, "false")) {
return false;
}
if (check_flag(property, "eng")) {
flag |= BOOL_DEFAULT_FLAG_ENG;
}
// this is really a "not" flag
if (check_flag(property, "svelte")) {
flag |= BOOL_DEFAULT_FLAG_SVELTE;
}
// Sanity Check
if (flag & (BOOL_DEFAULT_FLAG_SVELTE | BOOL_DEFAULT_FLAG_ENG)) {
flag &= ~BOOL_DEFAULT_FLAG_TRUE_FALSE;
flag |= BOOL_DEFAULT_TRUE;
}
if ((flag & BOOL_DEFAULT_FLAG_SVELTE)
&& property_get_bool("ro.config.low_ram",
BOOL_DEFAULT_FALSE)) {
return false;
}
if ((flag & BOOL_DEFAULT_FLAG_ENG) && !__android_log_is_debuggable()) {
return false;
}
return (flag & BOOL_DEFAULT_FLAG_TRUE_FALSE) != BOOL_DEFAULT_FALSE;
}
static int fdDmesg = -1;
void android::prdebug(const char *fmt, ...) {
if (fdDmesg < 0) {
@ -365,11 +314,11 @@ static void readDmesg(LogAudit *al, LogKlog *kl) {
// transitory per-client threads are created for each reader.
int main(int argc, char *argv[]) {
int fdPmesg = -1;
bool klogd = property_get_bool("logd.kernel",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST |
BOOL_DEFAULT_FLAG_ENG |
BOOL_DEFAULT_FLAG_SVELTE);
bool klogd = __android_logger_property_get_bool("logd.kernel",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST |
BOOL_DEFAULT_FLAG_ENG |
BOOL_DEFAULT_FLAG_SVELTE);
if (klogd) {
fdPmesg = open("/proc/kmsg", O_RDONLY | O_NDELAY);
}
@ -449,11 +398,11 @@ int main(int argc, char *argv[]) {
signal(SIGHUP, reinit_signal_handler);
if (property_get_bool("logd.statistics",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST |
BOOL_DEFAULT_FLAG_ENG |
BOOL_DEFAULT_FLAG_SVELTE)) {
if (__android_logger_property_get_bool("logd.statistics",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST |
BOOL_DEFAULT_FLAG_ENG |
BOOL_DEFAULT_FLAG_SVELTE)) {
logBuf->enableStatistics();
}
@ -487,17 +436,17 @@ int main(int argc, char *argv[]) {
// initiated log messages. New log entries are added to LogBuffer
// and LogReader is notified to send updates to connected clients.
bool auditd = property_get_bool("logd.auditd",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST);
bool auditd = __android_logger_property_get_bool("logd.auditd",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST);
LogAudit *al = NULL;
if (auditd) {
al = new LogAudit(logBuf, reader,
property_get_bool("logd.auditd.dmesg",
BOOL_DEFAULT_TRUE |
BOOL_DEFAULT_FLAG_PERSIST)
? fdDmesg
: -1);
__android_logger_property_get_bool(
"logd.auditd.dmesg",
BOOL_DEFAULT_TRUE | BOOL_DEFAULT_FLAG_PERSIST)
? fdDmesg
: -1);
}
LogKlog *kl = NULL;