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

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

Merge "liblog: simplify logd 'command' functions and struct logger"

parents fe983b66 9156c534

liblog/event_tag_map.cpp

+7 −3
Original line number Diff line number Diff line
@@ -494,7 +494,7 @@ void android_closeEventTagMap(EventTagMap* map) { 


// Cache miss, go to logd to acquire a public reference.

// Because we lack access to a SHARED PUBLIC /dev/event-log-tags file map?

static const TagFmt* __getEventTag(EventTagMap* map, unsigned int tag) {

static const TagFmt* __getEventTag([[maybe_unused]] EventTagMap* map, unsigned int tag) {

  // call event tag service to arrange for a new tag

  char* buf = NULL;

  // Can not use android::base::StringPrintf, asprintf + free instead.
@@ -515,8 +515,9 @@ static const TagFmt* __getEventTag(EventTagMap* map, unsigned int tag) { 
    } else {

      size = ret;

    }

#ifdef __ANDROID__

    // Ask event log tag service for an existing entry

    if (__send_log_msg(buf, size) >= 0) {

    if (SendLogdControlMessage(buf, size) >= 0) {

      buf[size - 1] = '\0';

      char* ep;

      unsigned long val = strtoul(buf, &ep, 10);  // return size
@@ -529,6 +530,7 @@ static const TagFmt* __getEventTag(EventTagMap* map, unsigned int tag) { 
        }

      }

    }

#endif

    free(buf);

  }

  return NULL;
@@ -618,8 +620,9 @@ int android_lookupEventTagNum(EventTagMap* map, const char* tagname, const char* 
    } else {

      size = ret;

    }

#ifdef __ANDROID__

    // Ask event log tag service for an allocation

    if (__send_log_msg(buf, size) >= 0) {

    if (SendLogdControlMessage(buf, size) >= 0) {

      buf[size - 1] = '\0';

      unsigned long val = strtoul(buf, &cp, 10);        // return size

      if ((buf != cp) && (val > 0) && (*cp == '\n')) {  // truncation OK
@@ -635,6 +638,7 @@ int android_lookupEventTagNum(EventTagMap* map, const char* tagname, const char* 
        }

      }

    }

#endif

    free(buf);

  }

liblog/fake_log_device.cpp

+0 −4
Original line number Diff line number Diff line
@@ -650,10 +650,6 @@ int fakeLogOpen(const char* pathName) { 
  return fd;

}



ssize_t __send_log_msg(char*, size_t) {

  return -ENODEV;

}



int __android_log_is_loggable(int prio, const char*, int def) {

  int logLevel = def;

  return logLevel >= 0 && prio >= logLevel;

liblog/fake_log_device.h

+0 −1
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ int fakeLogOpen(const char* pathName); 
int fakeLogClose(int fd);

ssize_t fakeLogWritev(int fd, const struct iovec* vector, int count);



ssize_t __send_log_msg(char*, size_t);

int __android_log_is_loggable(int prio, const char*, int def);

int __android_log_is_loggable_len(int prio, const char*, size_t, int def);

int __android_log_is_debuggable();

liblog/logd_reader.cpp

+68 −95
Original line number Diff line number Diff line
@@ -40,39 +40,16 @@ 
#include "logger.h"



static int LogdAvailable(log_id_t LogId);

static int LogdVersion(struct logger* logger, struct android_log_transport_context* transp);

static int LogdRead(struct logger_list* logger_list, struct android_log_transport_context* transp,

                    struct log_msg* log_msg);

static int LogdPoll(struct logger_list* logger_list, struct android_log_transport_context* transp);

static void LogdClose(struct logger_list* logger_list,

                      struct android_log_transport_context* transp);

static int LogdClear(struct logger* logger, struct android_log_transport_context* transp);

static ssize_t LogdSetSize(struct logger* logger, struct android_log_transport_context* transp,

                           size_t size);

static ssize_t LogdGetSize(struct logger* logger, struct android_log_transport_context* transp);

static ssize_t LogdGetReadableSize(struct logger* logger,

                                   struct android_log_transport_context* transp);

static ssize_t LogdGetPrune(struct logger_list* logger,

                            struct android_log_transport_context* transp, char* buf, size_t len);

static ssize_t LogdSetPrune(struct logger_list* logger,

                            struct android_log_transport_context* transp, char* buf, size_t len);

static ssize_t LogdGetStats(struct logger_list* logger,

                            struct android_log_transport_context* transp, char* buf, size_t len);



struct android_log_transport_read logdLoggerRead = {

    .name = "logd",

    .available = LogdAvailable,

    .version = LogdVersion,

    .close = LogdClose,

    .read = LogdRead,

    .poll = LogdPoll,

    .clear = LogdClear,

    .setSize = LogdSetSize,

    .getSize = LogdGetSize,

    .getReadableSize = LogdGetReadableSize,

    .getPrune = LogdGetPrune,

    .setPrune = LogdSetPrune,

    .getStats = LogdGetStats,

};



static int LogdAvailable(log_id_t logId) {
@@ -116,7 +93,7 @@ static int socket_local_client(const std::string& name, int type) { 
}



/* worker for sending the command to the logger */

static ssize_t send_log_msg(struct logger* logger, const char* msg, char* buf, size_t buf_size) {

ssize_t SendLogdControlMessage(char* buf, size_t buf_size) {

  ssize_t ret;

  size_t len;

  char* cp;
@@ -126,10 +103,6 @@ static ssize_t send_log_msg(struct logger* logger, const char* msg, char* buf, s 
    return sock;

  }



  if (msg) {

    snprintf(buf, buf_size, msg, logger ? logger->logId : (unsigned)-1);

  }



  len = strlen(buf) + 1;

  ret = TEMP_FAILURE_RETRY(write(sock, buf, len));

  if (ret <= 0) {
@@ -180,10 +153,6 @@ done: 
  return ret;

}



ssize_t __send_log_msg(char* buf, size_t buf_size) {

  return send_log_msg(NULL, NULL, buf, buf_size);

}



static int check_log_success(char* buf, ssize_t ret) {

  if (ret < 0) {

    return ret;
@@ -197,17 +166,28 @@ static int check_log_success(char* buf, ssize_t ret) { 
  return 0;

}



static int LogdClear(struct logger* logger, struct android_log_transport_context*) {

int android_logger_clear(struct logger* logger) {

  if (!android_logger_is_logd(logger)) {

    return -EINVAL;

  }

  uint32_t log_id = android_logger_get_id(logger);

  char buf[512];

  snprintf(buf, sizeof(buf), "clear %" PRIu32, log_id);



  return check_log_success(buf, send_log_msg(logger, "clear %d", buf, sizeof(buf)));

  return check_log_success(buf, SendLogdControlMessage(buf, sizeof(buf)));

}



/* returns the total size of the log's ring buffer */

static ssize_t LogdGetSize(struct logger* logger, struct android_log_transport_context*) {

long android_logger_get_log_size(struct logger* logger) {

  if (!android_logger_is_logd(logger)) {

    return -EINVAL;

  }



  uint32_t log_id = android_logger_get_id(logger);

  char buf[512];

  snprintf(buf, sizeof(buf), "getLogSize %" PRIu32, log_id);



  ssize_t ret = send_log_msg(logger, "getLogSize %d", buf, sizeof(buf));

  ssize_t ret = SendLogdControlMessage(buf, sizeof(buf));

  if (ret < 0) {

    return ret;

  }
@@ -219,23 +199,32 @@ static ssize_t LogdGetSize(struct logger* logger, struct android_log_transport_c 
  return atol(buf);

}



static ssize_t LogdSetSize(struct logger* logger, struct android_log_transport_context*,

                           size_t size) {

  char buf[512];

int android_logger_set_log_size(struct logger* logger, unsigned long size) {

  if (!android_logger_is_logd(logger)) {

    return -EINVAL;

  }



  snprintf(buf, sizeof(buf), "setLogSize %d %zu", logger->logId, size);

  uint32_t log_id = android_logger_get_id(logger);

  char buf[512];

  snprintf(buf, sizeof(buf), "setLogSize %" PRIu32 " %lu", log_id, size);



  return check_log_success(buf, send_log_msg(NULL, NULL, buf, sizeof(buf)));

  return check_log_success(buf, SendLogdControlMessage(buf, sizeof(buf)));

}



/*

 * returns the readable size of the log's ring buffer (that is, amount of the

 * log consumed)

 */

static ssize_t LogdGetReadableSize(struct logger* logger, struct android_log_transport_context*) {

long android_logger_get_log_readable_size(struct logger* logger) {

  if (!android_logger_is_logd(logger)) {

    return -EINVAL;

  }



  uint32_t log_id = android_logger_get_id(logger);

  char buf[512];

  snprintf(buf, sizeof(buf), "getLogSizeUsed %" PRIu32, log_id);



  ssize_t ret = send_log_msg(logger, "getLogSizeUsed %d", buf, sizeof(buf));

  ssize_t ret = SendLogdControlMessage(buf, sizeof(buf));

  if (ret < 0) {

    return ret;

  }
@@ -247,20 +236,15 @@ static ssize_t LogdGetReadableSize(struct logger* logger, struct android_log_tra 
  return atol(buf);

}



/*

 * returns the logger version

 */

static int LogdVersion(struct logger*, struct android_log_transport_context*) {

  uid_t uid = __android_log_uid();

  return ((uid != AID_ROOT) && (uid != AID_LOG) && (uid != AID_SYSTEM)) ? 3 : 4;

int android_logger_get_log_version(struct logger*) {

  return 4;

}



ssize_t android_logger_get_statistics(struct logger_list* logger_list, char* buf, size_t len) {

  if (logger_list->mode & ANDROID_LOG_PSTORE) {

    return -EINVAL;

  }



/*

 * returns statistics

 */

static ssize_t LogdGetStats(struct logger_list* logger_list, struct android_log_transport_context*,

                            char* buf, size_t len) {

  struct logger* logger;

  char* cp = buf;

  size_t remaining = len;

  size_t n;
@@ -270,27 +254,35 @@ static ssize_t LogdGetStats(struct logger_list* logger_list, struct android_log_ 
  remaining -= n;

  cp += n;



  logger_for_each(logger, logger_list) {

    n = snprintf(cp, remaining, " %d", logger->logId);

  for (size_t log_id = 0; log_id < LOG_ID_MAX; ++log_id) {

    if ((1 << log_id) & logger_list->log_mask) {

      n = snprintf(cp, remaining, " %zu", log_id);

      n = MIN(n, remaining);

      remaining -= n;

      cp += n;

    }

  }



  if (logger_list->pid) {

    snprintf(cp, remaining, " pid=%u", logger_list->pid);

  }



  return send_log_msg(NULL, NULL, buf, len);

  return SendLogdControlMessage(buf, len);

}

ssize_t android_logger_get_prune_list(struct logger_list* logger_list, char* buf, size_t len) {

  if (logger_list->mode & ANDROID_LOG_PSTORE) {

    return -EINVAL;

  }



static ssize_t LogdGetPrune(struct logger_list*, struct android_log_transport_context*, char* buf,

                            size_t len) {

  return send_log_msg(NULL, "getPruneList", buf, len);

  snprintf(buf, len, "getPruneList");

  return SendLogdControlMessage(buf, len);

}



int android_logger_set_prune_list(struct logger_list* logger_list, char* buf, size_t len) {

  if (logger_list->mode & ANDROID_LOG_PSTORE) {

    return -EINVAL;

  }



static ssize_t LogdSetPrune(struct logger_list*, struct android_log_transport_context*, char* buf,

                            size_t len) {

  const char cmd[] = "setPruneList ";

  const size_t cmdlen = sizeof(cmd) - 1;
@@ -301,11 +293,10 @@ static ssize_t LogdSetPrune(struct logger_list*, struct android_log_transport_co 
  buf[len - 1] = '\0';

  memcpy(buf, cmd, cmdlen);



  return check_log_success(buf, send_log_msg(NULL, NULL, buf, len));

  return check_log_success(buf, SendLogdControlMessage(buf, len));

}



static int logdOpen(struct logger_list* logger_list, struct android_log_transport_context* transp) {

  struct logger* logger;

  char buffer[256], *cp, c;

  int ret, remaining, sock;
@@ -333,13 +324,16 @@ static int logdOpen(struct logger_list* logger_list, struct android_log_transpor 
  cp += 5;

  c = '=';

  remaining = sizeof(buffer) - (cp - buffer);

  logger_for_each(logger, logger_list) {

    ret = snprintf(cp, remaining, "%c%u", c, logger->logId);



  for (size_t log_id = 0; log_id < LOG_ID_MAX; ++log_id) {

    if ((1 << log_id) & logger_list->log_mask) {

      ret = snprintf(cp, remaining, "%c%zu", c, log_id);

      ret = MIN(ret, remaining);

      remaining -= ret;

      cp += ret;

      c = ',';

    }

  }



  if (logger_list->tail) {

    ret = snprintf(cp, remaining, " tail=%u", logger_list->tail);
@@ -412,27 +406,6 @@ static int LogdRead(struct logger_list* logger_list, struct android_log_transpor 
  return ret;

}



static int LogdPoll(struct logger_list* logger_list, struct android_log_transport_context* transp) {

  struct pollfd p;



  int ret = logdOpen(logger_list, transp);

  if (ret < 0) {

    return ret;

  }



  memset(&p, 0, sizeof(p));

  p.fd = ret;

  p.events = POLLIN;

  ret = poll(&p, 1, 20);

  if ((ret > 0) && !(p.revents & POLLIN)) {

    ret = 0;

  }

  if ((ret == -1) && errno) {

    return -errno;

  }

  return ret;

}



/* Close all the logs */

static void LogdClose(struct logger_list*, struct android_log_transport_context* transp) {

  int sock = atomic_exchange(&transp->context.sock, -1);

liblog/logd_reader.h

+1 −1
Original line number Diff line number Diff line
@@ -22,6 +22,6 @@ 


__BEGIN_DECLS



ssize_t __send_log_msg(char* buf, size_t buf_size);

ssize_t SendLogdControlMessage(char* buf, size_t buf_size);



__END_DECLS