/*

 * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "jvm.h"

#include "logging/log.hpp"

#include "logging/logConfiguration.hpp"

#include "logging/logDecorations.hpp"

#include "logging/logDecorators.hpp"

#include "logging/logDiagnosticCommand.hpp"

#include "logging/logFileOutput.hpp"

#include "logging/logOutput.hpp"

#include "logging/logSelectionList.hpp"

#include "logging/logStream.hpp"

#include "logging/logTagSet.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/semaphore.hpp"

#include "utilities/globalDefinitions.hpp"

LogOutput** LogConfiguration::_outputs = NULL;

size_t      LogConfiguration::_n_outputs = 0;

LogConfiguration::UpdateListenerFunction* LogConfiguration::_listener_callbacks = NULL;

size_t      LogConfiguration::_n_listener_callbacks = 0;

// LogFileOutput is the default type of output, its type prefix should be used if no type was specified

static const char* implicit_output_prefix = LogFileOutput::Prefix;

// Stack object to take the lock for configuring the logging.

// Should only be held during the critical parts of the configuration

// (when calling configure_output or reading/modifying the outputs array).

// Thread must never block when holding this lock.

class ConfigurationLock : public StackObj {

 private:

  // Semaphore used as lock

  static Semaphore _semaphore;

  debug_only(static intx _locking_thread_id;)

 public:

  ConfigurationLock() {

    _semaphore.wait();

    debug_only(_locking_thread_id = os::current_thread_id());

  }

  ~ConfigurationLock() {

    debug_only(_locking_thread_id = -1);

    _semaphore.signal();

  }

  debug_only(static bool current_thread_has_lock();)

};

Semaphore ConfigurationLock::_semaphore(1);

#ifdef ASSERT

intx ConfigurationLock::_locking_thread_id = -1;

bool ConfigurationLock::current_thread_has_lock() {

  return _locking_thread_id == os::current_thread_id();

}

#endif

void LogConfiguration::post_initialize() {

  // Reset the reconfigured status of all outputs

  for (size_t i = 0; i < _n_outputs; i++) {

    _outputs[i]->_reconfigured = false;

  }

  LogDiagnosticCommand::registerCommand();

  Log(logging) log;

  if (log.is_info()) {

    log.info("Log configuration fully initialized.");

    log_develop_info(logging)("Develop logging is available.");

    LogStream info_stream(log.info());

    describe_available(&info_stream);

    LogStream debug_stream(log.debug());

    LogTagSet::list_all_tagsets(&debug_stream);

    ConfigurationLock cl;

    describe_current_configuration(&info_stream);

  }

}

void LogConfiguration::initialize(jlong vm_start_time) {

  LogFileOutput::set_file_name_parameters(vm_start_time);

  LogDecorations::initialize(vm_start_time);

  assert(_outputs == NULL, "Should not initialize _outputs before this function, initialize called twice?");

  _outputs = NEW_C_HEAP_ARRAY(LogOutput*, 2, mtLogging);

  _outputs[0] = &StdoutLog;

  _outputs[1] = &StderrLog;

  _n_outputs = 2;

}

void LogConfiguration::finalize() {

  for (size_t i = _n_outputs; i > 0; i--) {

    disable_output(i - 1);

  }

  FREE_C_HEAP_ARRAY(LogOutput*, _outputs);

}

// Normalizes the given LogOutput name to type=name form.

// For example, foo, "foo", file="foo", will all be normalized to file=foo (no quotes, prefixed).

static bool normalize_output_name(const char* full_name, char* buffer, size_t len, outputStream* errstream) {

  const char* start_quote = strchr(full_name, '"');

  const char* equals = strchr(full_name, '=');

  const bool quoted = start_quote != NULL;

  const bool is_stdout_or_stderr = (strcmp(full_name, "stdout") == 0 || strcmp(full_name, "stderr") == 0);

  // ignore equals sign within quotes

  if (quoted && equals > start_quote) {

    equals = NULL;

  }

  const char* prefix = "";

  size_t prefix_len = 0;

  const char* name = full_name;

  if (equals != NULL) {

    // split on equals sign

    name = equals + 1;

    prefix = full_name;

    prefix_len = equals - full_name + 1;

  } else if (!is_stdout_or_stderr) {

    prefix = implicit_output_prefix;

    prefix_len = strlen(prefix);

  }

  size_t name_len = strlen(name);

  if (quoted) {

    const char* end_quote = strchr(start_quote + 1, '"');

    if (end_quote == NULL) {

      errstream->print_cr("Output name has opening quote but is missing a terminating quote.");

      return false;

    }

    if (start_quote != name || end_quote[1] != '\0') {

      errstream->print_cr("Output name can not be partially quoted."

                          " Either surround the whole name with quotation marks,"

                          " or do not use quotation marks at all.");

      return false;

    }

    // strip start and end quote

    name++;

    name_len -= 2;

  }

  int ret = jio_snprintf(buffer, len, "%.*s%.*s", prefix_len, prefix, name_len, name);

  assert(ret > 0, "buffer issue");

  return true;

}

size_t LogConfiguration::find_output(const char* name) {

  for (size_t i = 0; i < _n_outputs; i++) {

    if (strcmp(_outputs[i]->name(), name) == 0) {

      return i;

    }

  }

  return SIZE_MAX;

}

LogOutput* LogConfiguration::new_output(const char* name,

                                        const char* options,

                                        outputStream* errstream) {

  LogOutput* output;

  if (strncmp(name, LogFileOutput::Prefix, strlen(LogFileOutput::Prefix)) == 0) {

    output = new LogFileOutput(name);

  } else {

    errstream->print_cr("Unsupported log output type: %s", name);

    return NULL;

  }

  bool success = output->initialize(options, errstream);

  if (!success) {

    errstream->print_cr("Initialization of output '%s' using options '%s' failed.", name, options);

    delete output;

    return NULL;

  }

  return output;

}

size_t LogConfiguration::add_output(LogOutput* output) {

  size_t idx = _n_outputs++;

  _outputs = REALLOC_C_HEAP_ARRAY(LogOutput*, _outputs, _n_outputs, mtLogging);

  _outputs[idx] = output;

  return idx;

}

void LogConfiguration::delete_output(size_t idx) {

  assert(idx > 1 && idx < _n_outputs,

         "idx must be in range 1 < idx < _n_outputs, but idx = " SIZE_FORMAT

         " and _n_outputs = " SIZE_FORMAT, idx, _n_outputs);

  LogOutput* output = _outputs[idx];

  // Swap places with the last output and shrink the array

  _outputs[idx] = _outputs[--_n_outputs];

  _outputs = REALLOC_C_HEAP_ARRAY(LogOutput*, _outputs, _n_outputs, mtLogging);

  delete output;

}

void LogConfiguration::configure_output(size_t idx, const LogSelectionList& selections, const LogDecorators& decorators) {

  assert(ConfigurationLock::current_thread_has_lock(), "Must hold configuration lock to call this function.");

  assert(idx < _n_outputs, "Invalid index, idx = " SIZE_FORMAT " and _n_outputs = " SIZE_FORMAT, idx, _n_outputs);

  LogOutput* output = _outputs[idx];

  output->_reconfigured = true;

  size_t on_level[LogLevel::Count] = {0};

  bool enabled = false;

  for (LogTagSet* ts = LogTagSet::first(); ts != NULL; ts = ts->next()) {

    LogLevelType level = selections.level_for(*ts);

    // Ignore tagsets that do not, and will not log on the output

    if (!ts->has_output(output) && (level == LogLevel::NotMentioned || level == LogLevel::Off)) {

      on_level[LogLevel::Off]++;

      continue;

    }

    // Update decorators before adding/updating output level,

    // so that the tagset will have the necessary decorators when requiring them.

    if (level != LogLevel::Off) {

      ts->update_decorators(decorators);

    }

    // Set the new level, if it changed

    if (level != LogLevel::NotMentioned) {

      ts->set_output_level(output, level);

    } else {

      // Look up the previously set level for this output on this tagset

      level = ts->level_for(output);

    }

    if (level != LogLevel::Off) {

      // Keep track of whether or not the output is ever used by some tagset

      enabled = true;

    }

    // Track of the number of tag sets on each level

    on_level[level]++;

  }

  // It is now safe to set the new decorators for the actual output

  output->set_decorators(decorators);

  // Update the decorators on all tagsets to get rid of unused decorators

  for (LogTagSet* ts = LogTagSet::first(); ts != NULL; ts = ts->next()) {

    ts->update_decorators();

  }

  if (!enabled && idx > 1) {

    // Output is unused and should be removed, unless it is stdout/stderr (idx < 2)

    delete_output(idx);

    return;

  }

  output->update_config_string(on_level);

  assert(strlen(output->config_string()) > 0, "should always have a config description");

}

void LogConfiguration::disable_output(size_t idx) {

  assert(idx < _n_outputs, "invalid index: " SIZE_FORMAT " (_n_outputs: " SIZE_FORMAT ")", idx, _n_outputs);

  LogOutput* out = _outputs[idx];

  // Remove the output from all tagsets.

  for (LogTagSet* ts = LogTagSet::first(); ts != NULL; ts = ts->next()) {

    ts->set_output_level(out, LogLevel::Off);

    ts->update_decorators();

  }

  // Delete the output unless stdout or stderr (idx 0 or 1)

  if (idx > 1) {

    delete_output(idx);

  } else {

    out->set_config_string("all=off");

  }

}

void LogConfiguration::disable_logging() {

  ConfigurationLock cl;

  for (size_t i = _n_outputs; i > 0; i--) {

    disable_output(i - 1);

  }

  notify_update_listeners();

}

void LogConfiguration::configure_stdout(LogLevelType level, int exact_match, ...) {

  size_t i;

  va_list ap;

  LogTagType tags[LogTag::MaxTags];

  va_start(ap, exact_match);

  for (i = 0; i < LogTag::MaxTags; i++) {

    LogTagType tag = static_cast<LogTagType>(va_arg(ap, int));

    tags[i] = tag;

    if (tag == LogTag::__NO_TAG) {

      assert(i > 0, "Must specify at least one tag!");

      break;

    }

  }

  assert(i < LogTag::MaxTags || static_cast<LogTagType>(va_arg(ap, int)) == LogTag::__NO_TAG,

         "Too many tags specified! Can only have up to " SIZE_FORMAT " tags in a tag set.", LogTag::MaxTags);

  va_end(ap);

  LogSelection selection(tags, !exact_match, level);

  assert(selection.tag_sets_selected() > 0,

         "configure_stdout() called with invalid/non-existing log selection");

  LogSelectionList list(selection);

  // Apply configuration to stdout (output #0), with the same decorators as before.

  ConfigurationLock cl;

  configure_output(0, list, _outputs[0]->decorators());

  notify_update_listeners();

}

bool LogConfiguration::parse_command_line_arguments(const char* opts) {

  char* copy = os::strdup_check_oom(opts, mtLogging);

  // Split the option string to its colon separated components.

  char* str = copy;

  char* substrings[4] = {0};

  for (int i = 0 ; i < 4; i++) {

    substrings[i] = str;

    // Find the next colon or quote

    char* next = strpbrk(str, ":\"");

#ifdef _WINDOWS

    // Skip over Windows paths such as "C:\..."

    // Handle both C:\... and file=C:\..."

    if (next != NULL && next[0] == ':' && next[1] == '\\') {

      if (next == str + 1 || (strncmp(str, "file=", 5) == 0)) {

        next = strpbrk(next + 1, ":\"");

      }

    }

#endif

    while (next != NULL && *next == '"') {

      char* end_quote = strchr(next + 1, '"');

      if (end_quote == NULL) {

        log_error(logging)("Missing terminating quote in -Xlog option '%s'", str);

        os::free(copy);

        return false;

      }

      // Keep searching after the quoted substring

      next = strpbrk(end_quote + 1, ":\"");

    }

    if (next != NULL) {

      *next = '\0';

      str = next + 1;

    } else {

      break;

    }

  }

  // Parse and apply the separated configuration options

  char* what = substrings[0];

  char* output = substrings[1];

  char* decorators = substrings[2];

  char* output_options = substrings[3];

  char errbuf[512];

  stringStream ss(errbuf, sizeof(errbuf));

  bool success = parse_log_arguments(output, what, decorators, output_options, &ss);

  if (ss.size() > 0) {

    // If it failed, log the error. If it didn't fail, but something was written

    // to the stream, log it as a warning.

    LogLevelType level = success ? LogLevel::Warning : LogLevel::Error;

    Log(logging) log;

    char* start = errbuf;

    char* end = strchr(start, '\n');

    assert(end != NULL, "line must end with newline '%s'", start);

    do {

      assert(start < errbuf + sizeof(errbuf) &&

             end < errbuf + sizeof(errbuf),

             "buffer overflow");

      *end = '\0';

      log.write(level, "%s", start);

      start = end + 1;

      end = strchr(start, '\n');

      assert(end != NULL || *start == '\0', "line must end with newline '%s'", start);

    } while (end != NULL);

  }

  os::free(copy);

  return success;

}

bool LogConfiguration::parse_log_arguments(const char* outputstr,

                                           const char* selectionstr,

                                           const char* decoratorstr,

                                           const char* output_options,

                                           outputStream* errstream) {

  assert(errstream != NULL, "errstream can not be NULL");

  if (outputstr == NULL || strlen(outputstr) == 0) {

    outputstr = "stdout";

  }

  LogSelectionList selections;

  if (!selections.parse(selectionstr, errstream)) {

    return false;

  }

  LogDecorators decorators;

  if (!decorators.parse(decoratorstr, errstream)) {

    return false;

  }

  ConfigurationLock cl;

  size_t idx;

  if (outputstr[0] == '#') { // Output specified using index

    int ret = sscanf(outputstr + 1, SIZE_FORMAT, &idx);

    if (ret != 1 || idx >= _n_outputs) {

      errstream->print_cr("Invalid output index '%s'", outputstr);

      return false;

    }

  } else { // Output specified using name

    // Normalize the name, stripping quotes and ensures it includes type prefix

    size_t len = strlen(outputstr) + strlen(implicit_output_prefix) + 1;

    char* normalized = NEW_C_HEAP_ARRAY(char, len, mtLogging);

    if (!normalize_output_name(outputstr, normalized, len, errstream)) {

      return false;

    }

    idx = find_output(normalized);

    if (idx == SIZE_MAX) {

      // Attempt to create and add the output

      LogOutput* output = new_output(normalized, output_options, errstream);

      if (output != NULL) {

        idx = add_output(output);

      }

    } else if (output_options != NULL && strlen(output_options) > 0) {

      errstream->print_cr("Output options for existing outputs are ignored.");

    }

    FREE_C_HEAP_ARRAY(char, normalized);

    if (idx == SIZE_MAX) {

      return false;

    }

  }

  configure_output(idx, selections, decorators);

  notify_update_listeners();

  selections.verify_selections(errstream);

  return true;

}

void LogConfiguration::describe_available(outputStream* out) {

  out->print("Available log levels:");

  for (size_t i = 0; i < LogLevel::Count; i++) {

    out->print("%s %s", (i == 0 ? "" : ","), LogLevel::name(static_cast<LogLevelType>(i)));

  }

  out->cr();

  out->print("Available log decorators:");

  for (size_t i = 0; i < LogDecorators::Count; i++) {

    LogDecorators::Decorator d = static_cast<LogDecorators::Decorator>(i);

    out->print("%s %s (%s)", (i == 0 ? "" : ","), LogDecorators::name(d), LogDecorators::abbreviation(d));

  }

  out->cr();

  out->print("Available log tags:");

  LogTag::list_tags(out);

  LogTagSet::describe_tagsets(out);

}

void LogConfiguration::describe_current_configuration(outputStream* out) {

  out->print_cr("Log output configuration:");

  for (size_t i = 0; i < _n_outputs; i++) {

    out->print(" #" SIZE_FORMAT ": ", i);

    _outputs[i]->describe(out);

    if (_outputs[i]->is_reconfigured()) {

      out->print(" (reconfigured)");

    }

    out->cr();

  }

}

void LogConfiguration::describe(outputStream* out) {

  describe_available(out);

  ConfigurationLock cl;

  describe_current_configuration(out);

}