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

Commit 5d89604d authored by Tom Cherry's avatar Tom Cherry Committed by android-build-merger
Browse files

Merge "liblog: cleanup opaque type usage" 

am: 2ebe95ff

Change-Id: I88cb96e2bce5558e170782b9041a303efe83f3ff
parents 3ac9adff 2ebe95ff

liblog/log_event_list.cpp

+12 −36
Original line number Diff line number Diff line
@@ -47,9 +47,6 @@ struct android_log_context_internal { 
  uint8_t storage[LOGGER_ENTRY_MAX_PAYLOAD];

};



// TODO(tomcherry): real C++ structs.

typedef struct android_log_context_internal android_log_context_internal;



static void init_context(android_log_context_internal* context, uint32_t tag) {

  context->tag = tag;

  context->read_write_flag = kAndroidLoggerWrite;
@@ -110,11 +107,9 @@ int android_log_destroy(android_log_context* ctx) { 
  return 0;

}



int android_log_reset(android_log_context ctx) {

  android_log_context_internal* context;

int android_log_reset(android_log_context context) {

  uint32_t tag;



  context = (android_log_context_internal*)ctx;

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -126,10 +121,7 @@ int android_log_reset(android_log_context ctx) { 
  return 0;

}



int android_log_parser_reset(android_log_context ctx, const char* msg, size_t len) {

  android_log_context_internal* context;



  context = (android_log_context_internal*)ctx;

int android_log_parser_reset(android_log_context context, const char* msg, size_t len) {

  if (!context || (kAndroidLoggerRead != context->read_write_flag)) {

    return -EBADF;

  }
@@ -140,10 +132,7 @@ int android_log_parser_reset(android_log_context ctx, const char* msg, size_t le 
  return 0;

}



int android_log_write_list_begin(android_log_context ctx) {

  android_log_context_internal* context;



  context = (android_log_context_internal*)ctx;

int android_log_write_list_begin(android_log_context context) {

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -174,8 +163,7 @@ int android_log_write_list_begin(android_log_context ctx) { 
  return 0;

}



int android_log_write_int32(android_log_context ctx, int32_t value) {

  android_log_context_internal* context = (android_log_context_internal*)ctx;

int android_log_write_int32(android_log_context context, int32_t value) {

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -195,8 +183,7 @@ int android_log_write_int32(android_log_context ctx, int32_t value) { 
  return 0;

}



int android_log_write_int64(android_log_context ctx, int64_t value) {

  android_log_context_internal* context = (android_log_context_internal*)ctx;

int android_log_write_int64(android_log_context context, int64_t value) {

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -216,8 +203,7 @@ int android_log_write_int64(android_log_context ctx, int64_t value) { 
  return 0;

}



int android_log_write_string8_len(android_log_context ctx, const char* value, size_t maxlen) {

  android_log_context_internal* context = (android_log_context_internal*)ctx;

int android_log_write_string8_len(android_log_context context, const char* value, size_t maxlen) {

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -252,8 +238,7 @@ int android_log_write_string8(android_log_context ctx, const char* value) { 
  return android_log_write_string8_len(ctx, value, MAX_EVENT_PAYLOAD);

}



int android_log_write_float32(android_log_context ctx, float value) {

  android_log_context_internal* context = (android_log_context_internal*)ctx;

int android_log_write_float32(android_log_context context, float value) {

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -273,10 +258,7 @@ int android_log_write_float32(android_log_context ctx, float value) { 
  return 0;

}



int android_log_write_list_end(android_log_context ctx) {

  android_log_context_internal* context;



  context = (android_log_context_internal*)ctx;

int android_log_write_list_end(android_log_context context) {

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -303,8 +285,7 @@ int android_log_write_list_end(android_log_context ctx) { 
/*

 * Logs the list of elements to the event log.

 */

int android_log_write_list(android_log_context ctx, log_id_t id) {

  android_log_context_internal* context;

int android_log_write_list(android_log_context context, log_id_t id) {

  const char* msg;

  ssize_t len;
@@ -312,7 +293,6 @@ int android_log_write_list(android_log_context ctx, log_id_t id) { 
    return -EINVAL;

  }



  context = (android_log_context_internal*)ctx;

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -337,12 +317,10 @@ int android_log_write_list(android_log_context ctx, log_id_t id) { 
                                     : __android_log_security_bwrite(context->tag, msg, len));

}



int android_log_write_list_buffer(android_log_context ctx, const char** buffer) {

  android_log_context_internal* context;

int android_log_write_list_buffer(android_log_context context, const char** buffer) {

  const char* msg;

  ssize_t len;



  context = (android_log_context_internal*)ctx;

  if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

    return -EBADF;

  }
@@ -375,12 +353,10 @@ int android_log_write_list_buffer(android_log_context ctx, const char** buffer) 
 * this and continues to call this function, the behavior is undefined

 * (although it won't crash).

 */

static android_log_list_element android_log_read_next_internal(android_log_context ctx, int peek) {

static android_log_list_element android_log_read_next_internal(android_log_context context,

                                                               int peek) {

  android_log_list_element elem;

  unsigned pos;

  android_log_context_internal* context;



  context = (android_log_context_internal*)ctx;



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

liblog/logd_reader.cpp

+45 −60
Original line number Diff line number Diff line
@@ -39,47 +39,43 @@ 
#include "logd_reader.h"

#include "logger.h"



static int logdAvailable(log_id_t LogId);

static int logdVersion(struct android_log_logger* logger,

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 logdRead(struct android_log_logger_list* logger_list,

                    struct android_log_transport_context* transp, struct log_msg* log_msg);

static int logdPoll(struct android_log_logger_list* logger_list,

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 void logdClose(struct android_log_logger_list* logger_list,

                      struct android_log_transport_context* transp);

static int logdClear(struct android_log_logger* logger,

                     struct android_log_transport_context* transp);

static ssize_t logdSetSize(struct android_log_logger* logger,

                           struct android_log_transport_context* transp, size_t size);

static ssize_t logdGetSize(struct android_log_logger* logger,

                           struct android_log_transport_context* transp);

static ssize_t logdGetReadableSize(struct android_log_logger* logger,

                                   struct android_log_transport_context* transp);

static ssize_t logdGetPrune(struct android_log_logger_list* logger,

static ssize_t LogdGetPrune(struct logger_list* logger,

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

static ssize_t logdSetPrune(struct android_log_logger_list* logger,

static ssize_t LogdSetPrune(struct logger_list* logger,

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

static ssize_t logdGetStats(struct android_log_logger_list* logger,

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,

    .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) {

static int LogdAvailable(log_id_t logId) {

  if (logId >= LOG_ID_MAX) {

    return -EINVAL;

  }
@@ -120,8 +116,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 android_log_logger* logger, const char* msg, char* buf,

                            size_t buf_size) {

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

  ssize_t ret;

  size_t len;

  char* cp;
@@ -202,16 +197,14 @@ static int check_log_success(char* buf, ssize_t ret) { 
  return 0;

}



static int logdClear(struct android_log_logger* logger,

                     struct android_log_transport_context* transp __unused) {

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

  char buf[512];



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

}



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

static ssize_t logdGetSize(struct android_log_logger* logger,

                           struct android_log_transport_context* transp __unused) {

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

  char buf[512];



  ssize_t ret = send_log_msg(logger, "getLogSize %d", buf, sizeof(buf));
@@ -226,8 +219,8 @@ static ssize_t logdGetSize(struct android_log_logger* logger, 
  return atol(buf);

}



static ssize_t logdSetSize(struct android_log_logger* logger,

                           struct android_log_transport_context* transp __unused, size_t size) {

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

                           size_t size) {

  char buf[512];



  snprintf(buf, sizeof(buf), "setLogSize %d %zu", logger->logId, size);
@@ -239,8 +232,7 @@ static ssize_t logdSetSize(struct android_log_logger* logger, 
 * returns the readable size of the log's ring buffer (that is, amount of the

 * log consumed)

 */

static ssize_t logdGetReadableSize(struct android_log_logger* logger,

                                   struct android_log_transport_context* transp __unused) {

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

  char buf[512];



  ssize_t ret = send_log_msg(logger, "getLogSizeUsed %d", buf, sizeof(buf));
@@ -258,8 +250,7 @@ static ssize_t logdGetReadableSize(struct android_log_logger* logger, 
/*

 * returns the logger version

 */

static int logdVersion(struct android_log_logger* logger __unused,

                       struct android_log_transport_context* transp __unused) {

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;

}
@@ -267,10 +258,9 @@ static int logdVersion(struct android_log_logger* logger __unused, 
/*

 * returns statistics

 */

static ssize_t logdGetStats(struct android_log_logger_list* logger_list,

                            struct android_log_transport_context* transp __unused, char* buf,

                            size_t len) {

  struct android_log_logger* logger;

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;
@@ -294,14 +284,12 @@ static ssize_t logdGetStats(struct android_log_logger_list* logger_list, 
  return send_log_msg(NULL, NULL, buf, len);

}



static ssize_t logdGetPrune(struct android_log_logger_list* logger_list __unused,

                            struct android_log_transport_context* transp __unused, char* buf,

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);

}



static ssize_t logdSetPrune(struct android_log_logger_list* logger_list __unused,

                            struct android_log_transport_context* transp __unused, char* buf,

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;
@@ -316,9 +304,8 @@ static ssize_t logdSetPrune(struct android_log_logger_list* logger_list __unused 
  return check_log_success(buf, send_log_msg(NULL, NULL, buf, len));

}



static int logdOpen(struct android_log_logger_list* logger_list,

                    struct android_log_transport_context* transp) {

  struct android_log_logger* logger;

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;
@@ -404,8 +391,8 @@ static int logdOpen(struct android_log_logger_list* logger_list, 
}



/* Read from the selected logs */

static int logdRead(struct android_log_logger_list* logger_list,

                    struct android_log_transport_context* transp, struct log_msg* log_msg) {

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

                    struct log_msg* log_msg) {

  int ret = logdOpen(logger_list, transp);

  if (ret < 0) {

    return ret;
@@ -425,8 +412,7 @@ static int logdRead(struct android_log_logger_list* logger_list, 
  return ret;

}



static int logdPoll(struct android_log_logger_list* logger_list,

                    struct android_log_transport_context* transp) {

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

  struct pollfd p;



  int ret = logdOpen(logger_list, transp);
@@ -448,8 +434,7 @@ static int logdPoll(struct android_log_logger_list* logger_list, 
}



/* Close all the logs */

static void logdClose(struct android_log_logger_list* logger_list __unused,

                      struct android_log_transport_context* transp) {

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

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

  if (sock > 0) {

    close(sock);

liblog/logger.h

+25 −40
Original line number Diff line number Diff line
@@ -46,49 +46,37 @@ struct android_log_transport_write { 
               size_t nr);

};



struct android_log_logger_list;

struct android_log_transport_context;

struct android_log_logger;



struct android_log_transport_read {

  const char* name; /* human name to describe the transport */



  /* Does not cause resources to be taken */

  int (*available)(log_id_t logId);

  int (*version)(struct android_log_logger* logger,

                 struct android_log_transport_context* transp);

  int (*version)(struct logger* logger, struct android_log_transport_context* transp);

  /* Release resources taken by the following interfaces */

  void (*close)(struct android_log_logger_list* logger_list,

                struct android_log_transport_context* transp);

  void (*close)(struct logger_list* logger_list, struct android_log_transport_context* transp);

  /*

   * Expect all to instantiate open automagically on any call,

   * so we do not have an explicit open call.

   */

  int (*read)(struct android_log_logger_list* logger_list,

              struct android_log_transport_context* transp,

  int (*read)(struct logger_list* logger_list, struct android_log_transport_context* transp,

              struct log_msg* log_msg);

  /* Must only be called if not ANDROID_LOG_NONBLOCK (blocking) */

  int (*poll)(struct android_log_logger_list* logger_list,

              struct android_log_transport_context* transp);



  int (*clear)(struct android_log_logger* logger,

               struct android_log_transport_context* transp);

  ssize_t (*setSize)(struct android_log_logger* logger,

                     struct android_log_transport_context* transp, size_t size);

  ssize_t (*getSize)(struct android_log_logger* logger,

                     struct android_log_transport_context* transp);

  ssize_t (*getReadableSize)(struct android_log_logger* logger,

                             struct android_log_transport_context* transp);



  ssize_t (*getPrune)(struct android_log_logger_list* logger_list,

                      struct android_log_transport_context* transp, char* buf,

                      size_t len);

  ssize_t (*setPrune)(struct android_log_logger_list* logger_list,

                      struct android_log_transport_context* transp, char* buf,

                      size_t len);

  ssize_t (*getStats)(struct android_log_logger_list* logger_list,

                      struct android_log_transport_context* transp, char* buf,

                      size_t len);

  int (*poll)(struct logger_list* logger_list, struct android_log_transport_context* transp);



  int (*clear)(struct logger* logger, struct android_log_transport_context* transp);

  ssize_t (*setSize)(struct logger* logger, struct android_log_transport_context* transp,

                     size_t size);

  ssize_t (*getSize)(struct logger* logger, struct android_log_transport_context* transp);

  ssize_t (*getReadableSize)(struct logger* logger, struct android_log_transport_context* transp);



  ssize_t (*getPrune)(struct logger_list* logger_list, struct android_log_transport_context* transp,

                      char* buf, size_t len);

  ssize_t (*setPrune)(struct logger_list* logger_list, struct android_log_transport_context* transp,

                      char* buf, size_t len);

  ssize_t (*getStats)(struct logger_list* logger_list, struct android_log_transport_context* transp,

                      char* buf, size_t len);

};



struct android_log_transport_context {
@@ -98,7 +86,7 @@ struct android_log_transport_context { 
  unsigned logMask;      /* mask of requested log buffers */

};



struct android_log_logger_list {

struct logger_list {

  struct listnode logger;

  android_log_transport_context transport_context;

  bool transport_initialized;
@@ -108,22 +96,19 @@ struct android_log_logger_list { 
  pid_t pid;

};



struct android_log_logger {

struct logger {

  struct listnode node;

  struct android_log_logger_list* parent;

  struct logger_list* parent;



  log_id_t logId;

};



/* assumes caller has structures read-locked, single threaded, or fenced */

#define logger_for_each(logp, logger_list)                                      \

  for ((logp) = node_to_item((logger_list)->logger.next,            \

                             struct android_log_logger, node);      \

       ((logp) != node_to_item(&(logger_list)->logger,              \

                               struct android_log_logger, node)) && \

  for ((logp) = node_to_item((logger_list)->logger.next, struct logger, node);  \

       ((logp) != node_to_item(&(logger_list)->logger, struct logger, node)) && \

       ((logp)->parent == (logger_list));                                       \

       (logp) =                                                     \

           node_to_item((logp)->node.next, struct android_log_logger, node))

       (logp) = node_to_item((logp)->node.next, struct logger, node))



/* OS specific dribs and drabs */

liblog/logger_read.cpp

+65 −81

File changed.

Preview size limit exceeded, changes collapsed.

liblog/pmsg_reader.cpp

+20 −25
Original line number Diff line number Diff line
@@ -26,24 +26,22 @@ 


#include "logger.h"



static int pmsgAvailable(log_id_t logId);

static int pmsgVersion(struct android_log_logger* logger,

                       struct android_log_transport_context* transp);

static int pmsgRead(struct android_log_logger_list* logger_list,

                    struct android_log_transport_context* transp, struct log_msg* log_msg);

static void pmsgClose(struct android_log_logger_list* logger_list,

                      struct android_log_transport_context* transp);

static int pmsgClear(struct android_log_logger* logger,

static int PmsgAvailable(log_id_t logId);

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

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

                    struct log_msg* log_msg);

static void PmsgClose(struct logger_list* logger_list,

                      struct android_log_transport_context* transp);

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



struct android_log_transport_read pmsgLoggerRead = {

    .name = "pmsg",

    .available = pmsgAvailable,

    .version = pmsgVersion,

    .close = pmsgClose,

    .read = pmsgRead,

    .available = PmsgAvailable,

    .version = PmsgVersion,

    .close = PmsgClose,

    .read = PmsgRead,

    .poll = NULL,

    .clear = pmsgClear,

    .clear = PmsgClear,

    .setSize = NULL,

    .getSize = NULL,

    .getReadableSize = NULL,
@@ -52,7 +50,7 @@ struct android_log_transport_read pmsgLoggerRead = { 
    .getStats = NULL,

};



static int pmsgAvailable(log_id_t logId) {

static int PmsgAvailable(log_id_t logId) {

  if (logId > LOG_ID_SECURITY) {

    return -EINVAL;

  }
@@ -62,21 +60,19 @@ static int pmsgAvailable(log_id_t logId) { 
  return -EBADF;

}



static int pmsgClear(struct android_log_logger* logger __unused,

                     struct android_log_transport_context* transp __unused) {

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

  return unlink("/sys/fs/pstore/pmsg-ramoops-0");

}



/*

 * returns the logger version

 */

static int pmsgVersion(struct android_log_logger* logger __unused,

                       struct android_log_transport_context* transp __unused) {

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

  return 4;

}



static int pmsgRead(struct android_log_logger_list* logger_list,

                    struct android_log_transport_context* transp, struct log_msg* log_msg) {

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

                    struct log_msg* log_msg) {

  ssize_t ret;

  off_t current, next;

  struct __attribute__((__packed__)) {
@@ -192,8 +188,7 @@ static int pmsgRead(struct android_log_logger_list* logger_list, 
  }

}



static void pmsgClose(struct android_log_logger_list* logger_list __unused,

                      struct android_log_transport_context* transp) {

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

  int fd = atomic_exchange(&transp->context.fd, 0);

  if (fd > 0) {

    close(fd);
@@ -211,7 +206,7 @@ static void* realloc_or_free(void* ptr, size_t new_size) { 
ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* prefix,

                                     __android_log_pmsg_file_read_fn fn, void* arg) {

  ssize_t ret;

  struct android_log_logger_list logger_list;

  struct logger_list logger_list;

  struct android_log_transport_context transp;

  struct content {

    struct listnode node;
@@ -268,7 +263,7 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref 


  /* Read the file content */

  log_msg log_msg;

  while (pmsgRead(&logger_list, &transp, &log_msg) > 0) {

  while (PmsgRead(&logger_list, &transp, &log_msg) > 0) {

    const char* cp;

    size_t hdr_size = log_msg.entry.hdr_size;
@@ -426,7 +421,7 @@ ssize_t __android_log_pmsg_file_read(log_id_t logId, char prio, const char* pref 
    }

    list_add_head(node, &content->node);

  }

  pmsgClose(&logger_list, &transp);

  PmsgClose(&logger_list, &transp);



  /* Progress through all the collected files */

  list_for_each_safe(node, n, &name_list) {