void Stepper::log()
{
for ( ProcessVector::const_iterator i( theProcessVector.begin() ),
end( theProcessVector.end() );
i != end; ++i )
{
LoggerBroker::LoggersPerFullID loggers( (*i)->getLoggers() );
std::for_each( loggers.begin(), loggers.end(),
BindSecond( std::mem_fun( &Logger::log ),
theCurrentTime ) );
}
for ( VariableVector::const_iterator i( theVariableVector.begin() ),
end( theVariableVector.begin()
+ theReadOnlyVariableOffset );
i != end; ++i )
{
LoggerBroker::LoggersPerFullID loggers( (*i)->getLoggers() );
std::for_each( loggers.begin(), loggers.end(),
BindSecond( std::mem_fun( &Logger::log ),
theCurrentTime ) );
}
for ( SystemVector::const_iterator i( theSystemVector.begin() ),
end( theSystemVector.end() );
i != end; ++i )
{
LoggerBroker::LoggersPerFullID loggers( (*i)->getLoggers() );
std::for_each( loggers.begin(), loggers.end(),
BindSecond( std::mem_fun( &Logger::log ),
theCurrentTime ) );
}
}
void LoggerBase::popLogger()
{
if (loggers().empty()) {
throw "too many popLogger() calls";
} else {
loggers().pop_back();
}
}
LoggerBase &LoggerBase::instance()
{
// prevent destructing this instance as part of the executable's
// shutdown by allocating it dynamically, because it may be
// needed by other instances that get destructed later
// (order of global instance construction/destruction is
// undefined)
static LoggerStdout *DefaultLogger = new LoggerStdout;
if (!loggers().empty()) {
return *loggers()[loggers().size() - 1];
} else {
return *DefaultLogger;
}
}
void swi_log_trace(const char *module, swi_log_level_t severity, const char *format, ...)
{
char *user_message = NULL, *formatted_message = NULL;
va_list ap;
int ret;
if (!swi_log_musttrace(module, severity))
return;
va_start(ap, format);
ret = vasprintf(&user_message, format, ap);
(void)ret;
formatted_message = format_message(module, severity, user_message);
loggers(module, severity, formatted_message);
free(formatted_message);
free(user_message);
va_end(ap);
}
status_t LogSection::BlockingCall(int pipeWriteFd) const {
// Open log buffer and getting logs since last retrieved time if any.
unique_ptr<logger_list, void (*)(logger_list*)> loggers(
gLastLogsRetrieved.find(mLogID) == gLastLogsRetrieved.end()
? android_logger_list_alloc(ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK, 0, 0)
: android_logger_list_alloc_time(ANDROID_LOG_RDONLY | ANDROID_LOG_NONBLOCK,
gLastLogsRetrieved[mLogID], 0),
android_logger_list_free);
if (android_logger_open(loggers.get(), mLogID) == NULL) {
ALOGE("LogSection %s: Can't get logger.", this->name.string());
return -1;
}
log_msg msg;
log_time lastTimestamp(0);
ProtoOutputStream proto;
while (true) { // keeps reading until logd buffer is fully read.
status_t err = android_logger_list_read(loggers.get(), &msg);
// err = 0 - no content, unexpected connection drop or EOF.
// err = +ive number - size of retrieved data from logger
// err = -ive number, OS supplied error _except_ for -EAGAIN
// err = -EAGAIN, graceful indication for ANDRODI_LOG_NONBLOCK that this is the end of data.
if (err <= 0) {
if (err != -EAGAIN) {
ALOGW("LogSection %s: fails to read a log_msg.\n", this->name.string());
}
// dump previous logs and don't consider this error a failure.
break;
}
if (mBinary) {
// remove the first uint32 which is tag's index in event log tags
android_log_context context = create_android_log_parser(msg.msg() + sizeof(uint32_t),
msg.len() - sizeof(uint32_t));
;
android_log_list_element elem;
lastTimestamp.tv_sec = msg.entry_v1.sec;
lastTimestamp.tv_nsec = msg.entry_v1.nsec;
// format a BinaryLogEntry
uint64_t token = proto.start(LogProto::BINARY_LOGS);
proto.write(BinaryLogEntry::SEC, msg.entry_v1.sec);
proto.write(BinaryLogEntry::NANOSEC, msg.entry_v1.nsec);
proto.write(BinaryLogEntry::UID, (int)msg.entry_v4.uid);
proto.write(BinaryLogEntry::PID, msg.entry_v1.pid);
proto.write(BinaryLogEntry::TID, msg.entry_v1.tid);
proto.write(BinaryLogEntry::TAG_INDEX,
get4LE(reinterpret_cast<uint8_t const*>(msg.msg())));
do {
elem = android_log_read_next(context);
uint64_t elemToken = proto.start(BinaryLogEntry::ELEMS);
switch (elem.type) {
case EVENT_TYPE_INT:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_INT);
proto.write(BinaryLogEntry::Elem::VAL_INT32, (int)elem.data.int32);
break;
case EVENT_TYPE_LONG:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_LONG);
proto.write(BinaryLogEntry::Elem::VAL_INT64, (long long)elem.data.int64);
break;
case EVENT_TYPE_STRING:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_STRING);
proto.write(BinaryLogEntry::Elem::VAL_STRING, elem.data.string, elem.len);
break;
case EVENT_TYPE_FLOAT:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_FLOAT);
proto.write(BinaryLogEntry::Elem::VAL_FLOAT, elem.data.float32);
break;
case EVENT_TYPE_LIST:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_LIST);
break;
case EVENT_TYPE_LIST_STOP:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_LIST_STOP);
break;
case EVENT_TYPE_UNKNOWN:
proto.write(BinaryLogEntry::Elem::TYPE,
BinaryLogEntry::Elem::EVENT_TYPE_UNKNOWN);
break;
}
proto.end(elemToken);
} while ((elem.type != EVENT_TYPE_UNKNOWN) && !elem.complete);
proto.end(token);
if (context) {
android_log_destroy(&context);
}
} else {
AndroidLogEntry entry;
err = android_log_processLogBuffer(&msg.entry_v1, &entry);
if (err != NO_ERROR) {
ALOGW("LogSection %s: fails to process to an entry.\n", this->name.string());
break;
}
lastTimestamp.tv_sec = entry.tv_sec;
lastTimestamp.tv_nsec = entry.tv_nsec;
// format a TextLogEntry
uint64_t token = proto.start(LogProto::TEXT_LOGS);
proto.write(TextLogEntry::SEC, (long long)entry.tv_sec);
proto.write(TextLogEntry::NANOSEC, (long long)entry.tv_nsec);
proto.write(TextLogEntry::PRIORITY, (int)entry.priority);
proto.write(TextLogEntry::UID, entry.uid);
proto.write(TextLogEntry::PID, entry.pid);
proto.write(TextLogEntry::TID, entry.tid);
proto.write(TextLogEntry::TAG, entry.tag, trimTail(entry.tag, entry.tagLen));
proto.write(TextLogEntry::LOG, entry.message,
trimTail(entry.message, entry.messageLen));
proto.end(token);
}
}
gLastLogsRetrieved[mLogID] = lastTimestamp;
if (!proto.flush(pipeWriteFd) && errno == EPIPE) {
ALOGE("[%s] wrote to a broken pipe\n", this->name.string());
return EPIPE;
}
return NO_ERROR;
}
LoggerBase *LoggerBase::loggerAt(int index)
{
return index < 0 || index >= (int)loggers().size() ?
NULL :
loggers()[index];
}
int LoggerBase::numLoggers()
{
return (int)loggers().size();
}
void LoggerBase::pushLogger(LoggerBase *logger)
{
loggers().push_back(logger);
}
