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

Commit 2238ce2d authored by Tom Cherry's avatar Tom Cherry
Browse files

liblog: remove stderr logger 

There are no users of the liblog stderr logger, but 66 users of
android::base::StderrLogger.  We'll prefer that format and work to
merge it into liblog.

Test: liblog-unit-tests
Change-Id: Ifad24b27ac0f51379b925f6644caa1f6f3d9ad81
parent 7d045f6b

liblog/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@ liblog_sources = [ 
    "logger_read.cpp",

    "logger_write.cpp",

    "logprint.cpp",

    "stderr_write.cpp",

]

liblog_host_sources = [

    "fake_log_device.cpp",

liblog/config_write.cpp

+0 −21
Original line number Diff line number Diff line
@@ -66,27 +66,6 @@ void __android_log_config_write() { 
    __android_log_add_transport(&__android_log_transport_write, &fakeLoggerWrite);

#endif

  }



  if (__android_log_transport & LOGGER_STDERR) {

    extern struct android_log_transport_write stderrLoggerWrite;



    /*

     * stderr logger should be primary if we can be the only one, or if

     * already in the primary list.  Otherwise land in the persist list.

     * Remember we can be called here if we are already initialized.

     */

    if (list_empty(&__android_log_transport_write)) {

      __android_log_add_transport(&__android_log_transport_write, &stderrLoggerWrite);

    } else {

      struct android_log_transport_write* transp;

      write_transport_for_each(transp, &__android_log_transport_write) {

        if (transp == &stderrLoggerWrite) {

          return;

        }

      }

      __android_log_add_transport(&__android_log_persist_write, &stderrLoggerWrite);

    }

  }

}



void __android_log_config_write_close() {

liblog/include/log/log_transport.h

+1 −1
Original line number Diff line number Diff line
@@ -22,7 +22,7 @@ extern "C" { 
#define LOGGER_KERNEL  0x02 /* Reserved/Deprecated */

#define LOGGER_NULL    0x04 /* Does not release resources of other selections */

#define LOGGER_RESERVED 0x08 /* Reserved, previously for logging to local memory */

#define LOGGER_STDERR  0x10 /* logs sent to stderr */

#define LOGGER_RESERVED2  0x10 /* Reserved, previously for logs sent to stderr */

/* clang-format on */



/* Both return the selected transport flag mask, or negative errno */

liblog/logger_write.cpp

+3 −3
Original line number Diff line number Diff line
@@ -586,9 +586,9 @@ int android_set_log_transport(int transport_flag) { 
    return retval;

  }



  __android_log_transport &= LOGGER_LOGD | LOGGER_STDERR;

  __android_log_transport &= LOGGER_LOGD;



  transport_flag &= LOGGER_LOGD | LOGGER_STDERR;

  transport_flag &= LOGGER_LOGD;



  if (__android_log_transport != transport_flag) {

    __android_log_transport = transport_flag;
@@ -614,7 +614,7 @@ int android_get_log_transport() { 
  if (write_to_log == __write_to_log_null) {

    ret = LOGGER_NULL;

  } else {

    __android_log_transport &= LOGGER_LOGD | LOGGER_STDERR;

    __android_log_transport &= LOGGER_LOGD;

    ret = __android_log_transport;

    if ((write_to_log != __write_to_log_init) && (write_to_log != __write_to_log_daemon)) {

      ret = -EINVAL;

liblog/stderr_write.cpp

deleted100644 → 0
+0 −209
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



/*

 * stderr write handler.  Output is logcat-like, and responds to

 * logcat's environment variables ANDROID_PRINTF_LOG and

 * ANDROID_LOG_TAGS to filter output.

 *

 * This transport only provides a writer, that means that it does not

 * provide an End-To-End capability as the logs are effectively _lost_

 * to the stderr file stream.  The purpose of this transport is to

 * supply a means for command line tools to report their logging

 * to the stderr stream, in line with all other activities.

 */



#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <unistd.h>



#include <log/event_tag_map.h>

#include <log/log.h>

#include <log/logprint.h>



#include "log_portability.h"

#include "logger.h"

#include "uio.h"



static int stderrOpen();

static void stderrClose();

static int stderrAvailable(log_id_t logId);

static int stderrWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr);



struct stderrContext {

  AndroidLogFormat* logformat;

#if defined(__ANDROID__)

  EventTagMap* eventTagMap;

#endif

};



struct android_log_transport_write stderrLoggerWrite = {

    .node = {&stderrLoggerWrite.node, &stderrLoggerWrite.node},

    .context.priv = NULL,

    .name = "stderr",

    .available = stderrAvailable,

    .open = stderrOpen,

    .close = stderrClose,

    .write = stderrWrite,

};



static int stderrOpen() {

  struct stderrContext* ctx;

  const char* envStr;

  bool setFormat;



  if (!stderr || (fileno(stderr) < 0)) {

    return -EBADF;

  }



  if (stderrLoggerWrite.context.priv) {

    return fileno(stderr);

  }



  ctx = static_cast<stderrContext*>(calloc(1, sizeof(stderrContext)));

  if (!ctx) {

    return -ENOMEM;

  }



  ctx->logformat = android_log_format_new();

  if (!ctx->logformat) {

    free(ctx);

    return -ENOMEM;

  }



  envStr = getenv("ANDROID_PRINTF_LOG");

  setFormat = false;



  if (envStr) {

    char* formats = strdup(envStr);

    char* sv = NULL;

    char* arg = formats;

    while (!!(arg = strtok_r(arg, ",:; \t\n\r\f", &sv))) {

      AndroidLogPrintFormat format = android_log_formatFromString(arg);

      arg = NULL;

      if (format == FORMAT_OFF) {

        continue;

      }

      if (android_log_setPrintFormat(ctx->logformat, format) <= 0) {

        continue;

      }

      setFormat = true;

    }

    free(formats);

  }

  if (!setFormat) {

    AndroidLogPrintFormat format = android_log_formatFromString("threadtime");

    android_log_setPrintFormat(ctx->logformat, format);

  }

  envStr = getenv("ANDROID_LOG_TAGS");

  if (envStr) {

    android_log_addFilterString(ctx->logformat, envStr);

  }

  stderrLoggerWrite.context.priv = ctx;



  return fileno(stderr);

}



static void stderrClose() {

  stderrContext* ctx = static_cast<stderrContext*>(stderrLoggerWrite.context.priv);



  if (ctx) {

    stderrLoggerWrite.context.priv = NULL;

    if (ctx->logformat) {

      android_log_format_free(ctx->logformat);

      ctx->logformat = NULL;

    }

#if defined(__ANDROID__)

    if (ctx->eventTagMap) {

      android_closeEventTagMap(ctx->eventTagMap);

      ctx->eventTagMap = NULL;

    }

#endif

  }

}



static int stderrAvailable(log_id_t logId) {

  if ((logId >= LOG_ID_MAX) || (logId == LOG_ID_KERNEL)) {

    return -EINVAL;

  }

  return 1;

}



static int stderrWrite(log_id_t logId, struct timespec* ts, struct iovec* vec, size_t nr) {

  struct log_msg log_msg;

  AndroidLogEntry entry;

  char binaryMsgBuf[1024];

  int err;

  size_t i;

  stderrContext* ctx = static_cast<stderrContext*>(stderrLoggerWrite.context.priv);



  if (!ctx) return -EBADF;

  if (!vec || !nr) return -EINVAL;



  log_msg.entry.len = 0;

  log_msg.entry.hdr_size = sizeof(log_msg.entry);

  log_msg.entry.pid = getpid();

#ifdef __BIONIC__

  log_msg.entry.tid = gettid();

#else

  log_msg.entry.tid = getpid();

#endif

  log_msg.entry.sec = ts->tv_sec;

  log_msg.entry.nsec = ts->tv_nsec;

  log_msg.entry.lid = logId;

  log_msg.entry.uid = __android_log_uid();



  for (i = 0; i < nr; ++i) {

    size_t len = vec[i].iov_len;

    if ((log_msg.entry.len + len) > LOGGER_ENTRY_MAX_PAYLOAD) {

      len = LOGGER_ENTRY_MAX_PAYLOAD - log_msg.entry.len;

    }

    if (!len) continue;

    memcpy(log_msg.entry.msg + log_msg.entry.len, vec[i].iov_base, len);

    log_msg.entry.len += len;

  }



  if ((logId == LOG_ID_EVENTS) || (logId == LOG_ID_SECURITY)) {

#if defined(__ANDROID__)

    if (!ctx->eventTagMap) {

      ctx->eventTagMap = android_openEventTagMap(NULL);

    }

#endif

    err = android_log_processBinaryLogBuffer(&log_msg.entry_v1, &entry,

#if defined(__ANDROID__)

                                             ctx->eventTagMap,

#else

                                             NULL,

#endif

                                             binaryMsgBuf, sizeof(binaryMsgBuf));

  } else {

    err = android_log_processLogBuffer(&log_msg.entry_v1, &entry);

  }



  /* print known truncated data, in essence logcat --debug */

  if ((err < 0) && !entry.message) return -EINVAL;



  if (!android_log_shouldPrintLine(ctx->logformat, entry.tag, entry.priority)) {

    return log_msg.entry.len;

  }



  err = android_log_printLogLine(ctx->logformat, fileno(stderr), &entry);

  if (err < 0) return errno ? -errno : -EINVAL;

  return log_msg.entry.len;

}