Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit acd17330 authored by Tom Cherry's avatar Tom Cherry Committed by Gerrit Code Review
Browse files

Merge changes from topic "remove-log_to" 

* changes:
  base: remove LOG_TO(), PLOG_TO() and LOG_STREAM_TO() macros
  storaged: replace LOG_TO() macros with LOG()
parents 07892ea6 d044eaa4

base/include/android-base/logging.h

+28 −40
Original line number Diff line number Diff line
@@ -222,20 +222,16 @@ struct LogAbortAfterFullExpr { 
// 1) This will not check whether the severity is high enough. One should use WOULD_LOG to filter

//    usage manually.

// 2) This does not save and restore errno.

#define LOG_STREAM(severity) LOG_STREAM_TO(DEFAULT, severity)



// Get an ostream that can be used for logging at the given severity and to the

// given destination. The same notes as for LOG_STREAM apply.

#define LOG_STREAM_TO(dest, severity)                                           \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::dest,        \

                              SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL, -1) \

#define LOG_STREAM(severity)                                                                    \

  ::android::base::LogMessage(__FILE__, __LINE__, SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL, \

                              -1)                                                               \

      .stream()



// Logs a message to logcat on Android otherwise to stderr. If the severity is

// FATAL it also causes an abort. For example:

//

//     LOG(FATAL) << "We didn't expect to reach here";

#define LOG(severity) LOG_TO(DEFAULT, severity)

#define LOG(severity) LOGGING_PREAMBLE(severity) && LOG_STREAM(severity)



// Checks if we want to log something, and sets up appropriate RAII objects if

// so.
@@ -245,21 +241,12 @@ struct LogAbortAfterFullExpr { 
   ABORT_AFTER_LOG_EXPR_IF((SEVERITY_LAMBDA(severity)) == ::android::base::FATAL, true) && \

   ::android::base::ErrnoRestorer())



// Logs a message to logcat with the specified log ID on Android otherwise to

// stderr. If the severity is FATAL it also causes an abort.

// Use an expression here so we can support the << operator following the macro,

// like "LOG(DEBUG) << xxx;".

#define LOG_TO(dest, severity) LOGGING_PREAMBLE(severity) && LOG_STREAM_TO(dest, severity)



// A variant of LOG that also logs the current errno value. To be used when

// library calls fail.

#define PLOG(severity) PLOG_TO(DEFAULT, severity)



// Behaves like PLOG, but logs to the specified log ID.

#define PLOG_TO(dest, severity)                                                        \

#define PLOG(severity)                                                           \

  LOGGING_PREAMBLE(severity) &&                                                  \

      ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::dest,           \

                                  SEVERITY_LAMBDA(severity), _LOG_TAG_INTERNAL, errno) \

      ::android::base::LogMessage(__FILE__, __LINE__, SEVERITY_LAMBDA(severity), \

                                  _LOG_TAG_INTERNAL, errno)                      \

          .stream()



// Marker that code is yet to be implemented.
@@ -274,8 +261,8 @@ struct LogAbortAfterFullExpr { 
//       "Check failed: false == true".

#define CHECK(x)                                                                                 \

  LIKELY((x)) || ABORT_AFTER_LOG_FATAL_EXPR(false) ||                                            \

      ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT,  \

                                  ::android::base::FATAL, _LOG_TAG_INTERNAL, -1) \

      ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, _LOG_TAG_INTERNAL, \

                                  -1)                                                            \

              .stream()                                                                          \

          << "Check failed: " #x << " "
@@ -286,8 +273,7 @@ struct LogAbortAfterFullExpr { 
       UNLIKELY(!(_values.lhs OP _values.rhs));                                                  \

       /* empty */)                                                                              \

  ABORT_AFTER_LOG_FATAL                                                                          \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT,                    \

                              ::android::base::FATAL, _LOG_TAG_INTERNAL, -1)                   \

  ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::FATAL, _LOG_TAG_INTERNAL, -1) \

          .stream()                                                                              \

      << "Check failed: " << #LHS << " " << #OP << " " << #RHS << " (" #LHS "=" << _values.lhs   \

      << ", " #RHS "=" << _values.rhs << ") "
@@ -311,8 +297,8 @@ struct LogAbortAfterFullExpr { 
#define CHECK_STROP(s1, s2, sense)                                             \

  while (UNLIKELY((strcmp(s1, s2) == 0) != (sense)))                           \

    ABORT_AFTER_LOG_FATAL                                                      \

    ::android::base::LogMessage(__FILE__, __LINE__, ::android::base::DEFAULT,  \

                                ::android::base::FATAL, _LOG_TAG_INTERNAL, -1) \

    ::android::base::LogMessage(__FILE__, __LINE__,  ::android::base::FATAL,   \

                                 _LOG_TAG_INTERNAL, -1)                        \

        .stream()                                                              \

        << "Check failed: " << "\"" << (s1) << "\""                            \

        << ((sense) ? " == " : " != ") << "\"" << (s2) << "\""
@@ -431,8 +417,10 @@ class LogMessageData; 
// of a CHECK. The destructor will abort if the severity is FATAL.

class LogMessage {

 public:

  LogMessage(const char* file, unsigned int line, LogId id, LogSeverity severity, const char* tag,

  // LogId has been deprecated, but this constructor must exist for prebuilts.

  LogMessage(const char* file, unsigned int line, LogId, LogSeverity severity, const char* tag,

             int error);

  LogMessage(const char* file, unsigned int line, LogSeverity severity, const char* tag, int error);



  ~LogMessage();
@@ -441,8 +429,8 @@ class LogMessage { 
  std::ostream& stream();



  // The routine that performs the actual logging.

  static void LogLine(const char* file, unsigned int line, LogId id, LogSeverity severity,

                      const char* tag, const char* msg);

  static void LogLine(const char* file, unsigned int line, LogSeverity severity, const char* tag,

                      const char* msg);



 private:

  const std::unique_ptr<LogMessageData> data_;

base/logging.cpp

+16 −18
Original line number Diff line number Diff line
@@ -350,11 +350,10 @@ void SetAborter(AbortFunction&& aborter) { 
// checks/logging in a function.

class LogMessageData {

 public:

  LogMessageData(const char* file, unsigned int line, LogId id, LogSeverity severity,

                 const char* tag, int error)

  LogMessageData(const char* file, unsigned int line, LogSeverity severity, const char* tag,

                 int error)

      : file_(GetFileBasename(file)),

        line_number_(line),

        id_(id),

        severity_(severity),

        tag_(tag),

        error_(error) {}
@@ -373,10 +372,6 @@ class LogMessageData { 


  const char* GetTag() const { return tag_; }



  LogId GetId() const {

    return id_;

  }



  int GetError() const {

    return error_;

  }
@@ -393,7 +388,6 @@ class LogMessageData { 
  std::ostringstream buffer_;

  const char* const file_;

  const unsigned int line_number_;

  const LogId id_;

  const LogSeverity severity_;

  const char* const tag_;

  const int error_;
@@ -401,9 +395,13 @@ class LogMessageData { 
  DISALLOW_COPY_AND_ASSIGN(LogMessageData);

};



LogMessage::LogMessage(const char* file, unsigned int line, LogId id, LogSeverity severity,

LogMessage::LogMessage(const char* file, unsigned int line, LogId, LogSeverity severity,

                       const char* tag, int error)

    : data_(new LogMessageData(file, line, id, severity, tag, error)) {}

    : LogMessage(file, line, severity, tag, error) {}



LogMessage::LogMessage(const char* file, unsigned int line, LogSeverity severity, const char* tag,

                       int error)

    : data_(new LogMessageData(file, line, severity, tag, error)) {}



LogMessage::~LogMessage() {

  // Check severity again. This is duplicate work wrt/ LOG macros, but not LOG_STREAM.
@@ -429,16 +427,16 @@ LogMessage::~LogMessage() { 
    // Do the actual logging with the lock held.

    std::lock_guard<std::mutex> lock(LoggingLock());

    if (msg.find('\n') == std::string::npos) {

      LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(), data_->GetSeverity(),

              data_->GetTag(), msg.c_str());

      LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetSeverity(), data_->GetTag(),

              msg.c_str());

    } else {

      msg += '\n';

      size_t i = 0;

      while (i < msg.size()) {

        size_t nl = msg.find('\n', i);

        msg[nl] = '\0';

        LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetId(), data_->GetSeverity(),

                data_->GetTag(), &msg[i]);

        LogLine(data_->GetFile(), data_->GetLineNumber(), data_->GetSeverity(), data_->GetTag(),

                &msg[i]);

        // Undo the zero-termination so we can give the complete message to the aborter.

        msg[nl] = '\n';

        i = nl + 1;
@@ -456,16 +454,16 @@ std::ostream& LogMessage::stream() { 
  return data_->GetBuffer();

}



void LogMessage::LogLine(const char* file, unsigned int line, LogId id, LogSeverity severity,

                         const char* tag, const char* message) {

void LogMessage::LogLine(const char* file, unsigned int line, LogSeverity severity, const char* tag,

                         const char* message) {

  if (tag == nullptr) {

    std::lock_guard<std::recursive_mutex> lock(TagLock());

    if (gDefaultTag == nullptr) {

      gDefaultTag = new std::string(getprogname());

    }

    Logger()(id, severity, gDefaultTag->c_str(), file, line, message);

    Logger()(DEFAULT, severity, gDefaultTag->c_str(), file, line, message);

  } else {

    Logger()(id, severity, tag, file, line, message);

    Logger()(DEFAULT, severity, tag, file, line, message);

  }

}

storaged/main.cpp

+5 −3
Original line number Diff line number Diff line
@@ -51,7 +51,7 @@ void* storaged_main(void* /* unused */) { 
    storaged_sp->init();

    storaged_sp->report_storage_info();



    LOG_TO(SYSTEM, INFO) << "storaged: Start";

    LOG(INFO) << "storaged: Start";



    for (;;) {

        storaged_sp->event_checked();
@@ -76,6 +76,8 @@ int main(int argc, char** argv) { 
    bool flag_dump_perf = false;

    int opt;



    android::base::InitLogging(argv, android::base::LogdLogger(android::base::SYSTEM));



    for (;;) {

        int opt_idx = 0;

        static struct option long_options[] = {
@@ -124,13 +126,13 @@ int main(int argc, char** argv) { 
        pthread_t storaged_main_thread;

        errno = pthread_create(&storaged_main_thread, NULL, storaged_main, NULL);

        if (errno != 0) {

            PLOG_TO(SYSTEM, ERROR) << "Failed to create main thread";

            PLOG(ERROR) << "Failed to create main thread";

            return -1;

        }



        if (StoragedService::start() != android::OK ||

            StoragedPrivateService::start() != android::OK) {

            PLOG_TO(SYSTEM, ERROR) << "Failed to start storaged service";

            PLOG(ERROR) << "Failed to start storaged service";

            return -1;

        }

storaged/storaged.cpp

+15 −19
Original line number Diff line number Diff line
@@ -97,25 +97,23 @@ void storaged_t::init_health_service() { 


    health = get_health_service();

    if (health == NULL) {

        LOG_TO(SYSTEM, WARNING) << "health: failed to find IHealth service";

        LOG(WARNING) << "health: failed to find IHealth service";

        return;

    }



    BatteryStatus status = BatteryStatus::UNKNOWN;

    auto ret = health->getChargeStatus([&](Result r, BatteryStatus v) {

        if (r != Result::SUCCESS) {

            LOG_TO(SYSTEM, WARNING)

                << "health: cannot get battery status " << toString(r);

            LOG(WARNING) << "health: cannot get battery status " << toString(r);

            return;

        }

        if (v == BatteryStatus::UNKNOWN) {

            LOG_TO(SYSTEM, WARNING) << "health: invalid battery status";

            LOG(WARNING) << "health: invalid battery status";

        }

        status = v;

    });

    if (!ret.isOk()) {

        LOG_TO(SYSTEM, WARNING) << "health: get charge status transaction error "

            << ret.description();

        LOG(WARNING) << "health: get charge status transaction error " << ret.description();

    }



    mUidm.init(is_charger_on(status));
@@ -126,11 +124,11 @@ void storaged_t::init_health_service() { 


void storaged_t::serviceDied(uint64_t cookie, const wp<::android::hidl::base::V1_0::IBase>& who) {

    if (health != NULL && interfacesEqual(health, who.promote())) {

        LOG_TO(SYSTEM, ERROR) << "health service died, exiting";

        LOG(ERROR) << "health service died, exiting";

        android::hardware::IPCThreadState::self()->stopProcess();

        exit(1);

    } else {

        LOG_TO(SYSTEM, ERROR) << "unknown service died";

        LOG(ERROR) << "unknown service died";

    }

}
@@ -192,7 +190,7 @@ void storaged_t::load_proto(userid_t user_id) { 
        reinterpret_cast<const Bytef*>(uid_io_usage.SerializeAsString().c_str()),

        uid_io_usage.ByteSize());

    if (proto.crc() != computed_crc) {

        LOG_TO(SYSTEM, WARNING) << "CRC mismatch in " << proto_file;

        LOG(WARNING) << "CRC mismatch in " << proto_file;

        return;

    }
@@ -228,8 +226,7 @@ char* storaged_t:: prepare_proto(userid_t user_id, StoragedProto* proto) { 
    char* data = nullptr;

    if (posix_memalign(reinterpret_cast<void**>(&data),

                       pagesize, proto->ByteSize())) {

        PLOG_TO(SYSTEM, ERROR) << "Faied to alloc aligned buffer (size: "

                               << proto->ByteSize() << ")";

        PLOG(ERROR) << "Faied to alloc aligned buffer (size: " << proto->ByteSize() << ")";

        return data;

    }
@@ -246,7 +243,7 @@ void storaged_t::flush_proto_data(userid_t user_id, 
                    (user_id == USER_SYSTEM ? O_DIRECT : 0),

                 S_IRUSR | S_IWUSR)));

    if (fd == -1) {

        PLOG_TO(SYSTEM, ERROR) << "Faied to open tmp file: " << tmp_file;

        PLOG(ERROR) << "Faied to open tmp file: " << tmp_file;

        return;

    }
@@ -261,7 +258,7 @@ void storaged_t::flush_proto_data(userid_t user_id, 
            start = steady_clock::now();

            ret = write(fd, data, MIN(benchmark_unit_size, size));

            if (ret <= 0) {

                PLOG_TO(SYSTEM, ERROR) << "Faied to write tmp file: " << tmp_file;

                PLOG(ERROR) << "Faied to write tmp file: " << tmp_file;

                return;

            }

            end = steady_clock::now();
@@ -284,7 +281,7 @@ void storaged_t::flush_proto_data(userid_t user_id, 
        }

    } else {

        if (!WriteFully(fd, data, size)) {

            PLOG_TO(SYSTEM, ERROR) << "Faied to write tmp file: " << tmp_file;

            PLOG(ERROR) << "Faied to write tmp file: " << tmp_file;

            return;

        }

    }
@@ -343,21 +340,20 @@ void storaged_t::event_checked(void) { 
    if (mConfig.event_time_check_usec &&

        clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_ts) < 0) {

        check_time = false;

        PLOG_TO(SYSTEM, ERROR) << "clock_gettime() failed";

        PLOG(ERROR) << "clock_gettime() failed";

    }



    event();



    if (mConfig.event_time_check_usec && check_time) {

        if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end_ts) < 0) {

            PLOG_TO(SYSTEM, ERROR) << "clock_gettime() failed";

            PLOG(ERROR) << "clock_gettime() failed";

            return;

        }

        int64_t cost = (end_ts.tv_sec - start_ts.tv_sec) * SEC_TO_USEC +

                       (end_ts.tv_nsec - start_ts.tv_nsec) / USEC_TO_NSEC;

        if (cost > mConfig.event_time_check_usec) {

            LOG_TO(SYSTEM, ERROR)

                << "event loop spent " << cost << " usec, threshold "

            LOG(ERROR) << "event loop spent " << cost << " usec, threshold "

                       << mConfig.event_time_check_usec << " usec";

        }

    }

storaged/storaged_diskstats.cpp

+11 −11
Original line number Diff line number Diff line
@@ -41,8 +41,8 @@ void log_debug_disk_perf(struct disk_perf* perf, const char* type) { 
    // skip if the input structure are all zeros

    if (perf == NULL || perf->is_zero()) return;



    LOG_TO(SYSTEM, INFO) << "disk_perf " << type

              << " rd: " << perf->read_perf << " kbps, " << perf->read_ios << " iops"

    LOG(INFO) << "disk_perf " << type << " rd: " << perf->read_perf << " kbps, " << perf->read_ios

              << " iops"

              << " wr: " << perf->write_perf << " kbps, " << perf->write_ios << " iops"

              << " q: " << perf->queue;

}
@@ -71,7 +71,7 @@ bool get_time(struct timespec* ts) { 
    // when system is running.

    int ret = clock_gettime(CLOCK_MONOTONIC, ts);

    if (ret < 0) {

        PLOG_TO(SYSTEM, ERROR) << "clock_gettime() failed";

        PLOG(ERROR) << "clock_gettime() failed";

        return false;

    }

    return true;
@@ -93,7 +93,7 @@ bool parse_disk_stats(const char* disk_stats_path, struct disk_stats* stats) { 


    std::string buffer;

    if (!android::base::ReadFileToString(disk_stats_path, &buffer)) {

        PLOG_TO(SYSTEM, ERROR) << disk_stats_path << ": ReadFileToString failed.";

        PLOG(ERROR) << disk_stats_path << ": ReadFileToString failed.";

        return false;

    }
@@ -130,12 +130,12 @@ bool get_disk_stats_from_health_hal(const sp<IHealth>& service, struct disk_stat 
    bool success = false;

    auto ret = service->getDiskStats([&success, stats](auto result, const auto& halStats) {

        if (result == Result::NOT_SUPPORTED) {

            LOG_TO(SYSTEM, DEBUG) << "getDiskStats is not supported on health HAL.";

            LOG(DEBUG) << "getDiskStats is not supported on health HAL.";

            return;

        }

        if (result != Result::SUCCESS || halStats.size() == 0) {

            LOG_TO(SYSTEM, ERROR) << "getDiskStats failed with result " << toString(result)

                                  << " and size " << halStats.size();

            LOG(ERROR) << "getDiskStats failed with result " << toString(result) << " and size "

                       << halStats.size();

            return;

        }
@@ -144,7 +144,7 @@ bool get_disk_stats_from_health_hal(const sp<IHealth>& service, struct disk_stat 
    });



    if (!ret.isOk()) {

        LOG_TO(SYSTEM, ERROR) << "getDiskStats failed with " << ret.description();

        LOG(ERROR) << "getDiskStats failed with " << ret.description();

        return false;

    }
@@ -199,9 +199,9 @@ void get_inc_disk_stats(const struct disk_stats* prev, const struct disk_stats* 
void add_disk_stats(struct disk_stats* src, struct disk_stats* dst)

{

    if (dst->end_time != 0 && dst->end_time != src->start_time) {

        LOG_TO(SYSTEM, WARNING) << "Two dis-continuous periods of diskstats"

            << " are added. dst end with " << dst->end_time

            << ", src start with " << src->start_time;

        LOG(WARNING) << "Two dis-continuous periods of diskstats"

                     << " are added. dst end with " << dst->end_time << ", src start with "

                     << src->start_time;

    }



    *dst += *src;