/*

 * Copyright (c) 1997, 2011, 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 "compiler/compileLog.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/arguments.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/ostream.hpp"

#include "utilities/top.hpp"

#include "utilities/xmlstream.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "os_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "os_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "os_windows.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "os_bsd.inline.hpp"

#endif

extern "C" void jio_print(const char* s); // Declarationtion of jvm method

outputStream::outputStream(int width) {

  _width       = width;

  _position    = 0;

  _newlines    = 0;

  _precount    = 0;

  _indentation = 0;

}

outputStream::outputStream(int width, bool has_time_stamps) {

  _width       = width;

  _position    = 0;

  _newlines    = 0;

  _precount    = 0;

  _indentation = 0;

  if (has_time_stamps)  _stamp.update();

}

void outputStream::update_position(const char* s, size_t len) {

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

    char ch = s[i];

    if (ch == '\n') {

      _newlines += 1;

      _precount += _position + 1;

      _position = 0;

    } else if (ch == '\t') {

      int tw = 8 - (_position & 7);

      _position += tw;

      _precount -= tw-1;  // invariant:  _precount + _position == total count

    } else {

      _position += 1;

    }

  }

}

// Execute a vsprintf, using the given buffer if necessary.

// Return a pointer to the formatted string.

const char* outputStream::do_vsnprintf(char* buffer, size_t buflen,

                                       const char* format, va_list ap,

                                       bool add_cr,

                                       size_t& result_len) {

  const char* result;

  if (add_cr)  buflen--;

  if (!strchr(format, '%')) {

    // constant format string

    result = format;

    result_len = strlen(result);

    if (add_cr && result_len >= buflen)  result_len = buflen-1;  // truncate

  } else if (format[0] == '%' && format[1] == 's' && format[2] == '\0') {

    // trivial copy-through format string

    result = va_arg(ap, const char*);

    result_len = strlen(result);

    if (add_cr && result_len >= buflen)  result_len = buflen-1;  // truncate

  } else if (vsnprintf(buffer, buflen, format, ap) >= 0) {

    result = buffer;

    result_len = strlen(result);

  } else {

    DEBUG_ONLY(warning("increase O_BUFLEN in ostream.hpp -- output truncated");)

    result = buffer;

    result_len = buflen - 1;

    buffer[result_len] = 0;

  }

  if (add_cr) {

    if (result != buffer) {

      strncpy(buffer, result, buflen);

      result = buffer;

    }

    buffer[result_len++] = '\n';

    buffer[result_len] = 0;

  }

  return result;

}

void outputStream::print(const char* format, ...) {

  char buffer[O_BUFLEN];

  va_list ap;

  va_start(ap, format);

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, ap, false, len);

  write(str, len);

  va_end(ap);

}

void outputStream::print_cr(const char* format, ...) {

  char buffer[O_BUFLEN];

  va_list ap;

  va_start(ap, format);

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, ap, true, len);

  write(str, len);

  va_end(ap);

}

void outputStream::vprint(const char *format, va_list argptr) {

  char buffer[O_BUFLEN];

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, argptr, false, len);

  write(str, len);

}

void outputStream::vprint_cr(const char* format, va_list argptr) {

  char buffer[O_BUFLEN];

  size_t len;

  const char* str = do_vsnprintf(buffer, O_BUFLEN, format, argptr, true, len);

  write(str, len);

}

void outputStream::fill_to(int col) {

  int need_fill = col - position();

  sp(need_fill);

}

void outputStream::move_to(int col, int slop, int min_space) {

  if (position() >= col + slop)

    cr();

  int need_fill = col - position();

  if (need_fill < min_space)

    need_fill = min_space;

  sp(need_fill);

}

void outputStream::put(char ch) {

  assert(ch != 0, "please fix call site");

  char buf[] = { ch, '\0' };

  write(buf, 1);

}

#define SP_USE_TABS false

void outputStream::sp(int count) {

  if (count < 0)  return;

  if (SP_USE_TABS && count >= 8) {

    int target = position() + count;

    while (count >= 8) {

      this->write("\t", 1);

      count -= 8;

    }

    count = target - position();

  }

  while (count > 0) {

    int nw = (count > 8) ? 8 : count;

    this->write("        ", nw);

    count -= nw;

  }

}

void outputStream::cr() {

  this->write("\n", 1);

}

void outputStream::stamp() {

  if (! _stamp.is_updated()) {

    _stamp.update(); // start at 0 on first call to stamp()

  }

  // outputStream::stamp() may get called by ostream_abort(), use snprintf

  // to avoid allocating large stack buffer in print().

  char buf[40];

  jio_snprintf(buf, sizeof(buf), "%.3f", _stamp.seconds());

  print_raw(buf);

}

void outputStream::stamp(bool guard,

                         const char* prefix,

                         const char* suffix) {

  if (!guard) {

    return;

  }

  print_raw(prefix);

  stamp();

  print_raw(suffix);

}

void outputStream::date_stamp(bool guard,

                              const char* prefix,

                              const char* suffix) {

  if (!guard) {

    return;

  }

  print_raw(prefix);

  static const char error_time[] = "yyyy-mm-ddThh:mm:ss.mmm+zzzz";

  static const int buffer_length = 32;

  char buffer[buffer_length];

  const char* iso8601_result = os::iso8601_time(buffer, buffer_length);

  if (iso8601_result != NULL) {

    print_raw(buffer);

  } else {

    print_raw(error_time);

  }

  print_raw(suffix);

  return;

}

void outputStream::indent() {

  while (_position < _indentation) sp();

}

void outputStream::print_jlong(jlong value) {

  // N.B. Same as INT64_FORMAT

  print(os::jlong_format_specifier(), value);

}

void outputStream::print_julong(julong value) {

  // N.B. Same as UINT64_FORMAT

  print(os::julong_format_specifier(), value);

}

stringStream::stringStream(size_t initial_size) : outputStream() {

  buffer_length = initial_size;

  buffer        = NEW_RESOURCE_ARRAY(char, buffer_length);

  buffer_pos    = 0;

  buffer_fixed  = false;

}

// useful for output to fixed chunks of memory, such as performance counters

stringStream::stringStream(char* fixed_buffer, size_t fixed_buffer_size) : outputStream() {

  buffer_length = fixed_buffer_size;

  buffer        = fixed_buffer;

  buffer_pos    = 0;

  buffer_fixed  = true;

}

void stringStream::write(const char* s, size_t len) {

  size_t write_len = len;               // number of non-null bytes to write

  size_t end = buffer_pos + len + 1;    // position after write and final '\0'

  if (end > buffer_length) {

    if (buffer_fixed) {

      // if buffer cannot resize, silently truncate

      end = buffer_length;

      write_len = end - buffer_pos - 1; // leave room for the final '\0'

    } else {

      // For small overruns, double the buffer.  For larger ones,

      // increase to the requested size.

      if (end < buffer_length * 2) {

        end = buffer_length * 2;

      }

      char* oldbuf = buffer;

      buffer = NEW_RESOURCE_ARRAY(char, end);

      strncpy(buffer, oldbuf, buffer_pos);

      buffer_length = end;

    }

  }

  // invariant: buffer is always null-terminated

  guarantee(buffer_pos + write_len + 1 <= buffer_length, "stringStream oob");

  buffer[buffer_pos + write_len] = 0;

  strncpy(buffer + buffer_pos, s, write_len);

  buffer_pos += write_len;

  // Note that the following does not depend on write_len.

  // This means that position and count get updated

  // even when overflow occurs.

  update_position(s, len);

}

char* stringStream::as_string() {

  char* copy = NEW_RESOURCE_ARRAY(char, buffer_pos+1);

  strncpy(copy, buffer, buffer_pos);

  copy[buffer_pos] = 0;  // terminating null

  return copy;

}

stringStream::~stringStream() {}

xmlStream*   xtty;

outputStream* tty;

outputStream* gclog_or_tty;

extern Mutex* tty_lock;

fileStream::fileStream(const char* file_name) {

  _file = fopen(file_name, "w");

  _need_close = true;

}

fileStream::fileStream(const char* file_name, const char* opentype) {

  _file = fopen(file_name, opentype);

  _need_close = true;

}

void fileStream::write(const char* s, size_t len) {

  if (_file != NULL)  {

    // Make an unused local variable to avoid warning from gcc 4.x compiler.

    size_t count = fwrite(s, 1, len, _file);

  }

  update_position(s, len);

}

long fileStream::fileSize() {

  long size = -1;

  if (_file != NULL) {

    long pos  = ::ftell(_file);

    if (::fseek(_file, 0, SEEK_END) == 0) {

      size = ::ftell(_file);

    }

    ::fseek(_file, pos, SEEK_SET);

  }

  return size;

}

char* fileStream::readln(char *data, int count ) {

  char * ret = ::fgets(data, count, _file);

  //Get rid of annoying \n char

  data[::strlen(data)-1] = '\0';

  return ret;

}

fileStream::~fileStream() {

  if (_file != NULL) {

    if (_need_close) fclose(_file);

    _file      = NULL;

  }

}

void fileStream::flush() {

  fflush(_file);

}

fdStream::fdStream(const char* file_name) {

  _fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);

  _need_close = true;

}

fdStream::~fdStream() {

  if (_fd != -1) {

    if (_need_close) close(_fd);

    _fd = -1;

  }

}

void fdStream::write(const char* s, size_t len) {

  if (_fd != -1) {

    // Make an unused local variable to avoid warning from gcc 4.x compiler.

    size_t count = ::write(_fd, s, (int)len);

  }

  update_position(s, len);

}

rotatingFileStream::~rotatingFileStream() {

  if (_file != NULL) {

    if (_need_close) fclose(_file);

    _file      = NULL;

    _file_name = NULL;

  }

}

rotatingFileStream::rotatingFileStream(const char* file_name) {

  _cur_file_num = 0;

  _bytes_writen = 0L;

  jio_snprintf(_file_name, strlen(file_name)+10, "%s.%d", file_name, _cur_file_num);

  _file = fopen(_file_name, "w");

  _need_close = true;

}

rotatingFileStream::rotatingFileStream(const char* file_name, const char* opentype) {

  _cur_file_num = 0;

  _bytes_writen = 0L;

  jio_snprintf(_file_name, strlen(file_name)+10, "%s.%d", file_name, _cur_file_num);

  _file = fopen(_file_name, opentype);

  _need_close = true;

}

void rotatingFileStream::write(const char* s, size_t len) {

  if (_file != NULL)  {

    // Make an unused local variable to avoid warning from gcc 4.x compiler.

    size_t count = fwrite(s, 1, len, _file);

    Atomic::add((jlong)count, &_bytes_writen);

  }

  update_position(s, len);

}

// rotate_log must be called from VMThread at safepoint. In case need change parameters

// for gc log rotation from thread other than VMThread, a sub type of VM_Operation

// should be created and be submitted to VMThread's operation queue. DO NOT call this

// function directly. Currently, it is safe to rotate log at safepoint through VMThread.

// That is, no mutator threads and concurrent GC threads run parallel with VMThread to

// write to gc log file at safepoint. If in future, changes made for mutator threads or

// concurrent GC threads to run parallel with VMThread at safepoint, write and rotate_log

// must be synchronized.

void rotatingFileStream::rotate_log() {

  if (_bytes_writen < (jlong)GCLogFileSize) return;

#ifdef ASSERT

  Thread *thread = Thread::current();

  assert(thread == NULL ||

         (thread->is_VM_thread() && SafepointSynchronize::is_at_safepoint()),

         "Must be VMThread at safepoint");

#endif

  if (NumberOfGCLogFiles == 1) {

    // rotate in same file

    rewind();

    _bytes_writen = 0L;

    return;

  }

  // rotate file in names file.0, file.1, file.2, ..., file.<MaxGCLogFileNumbers-1>

  // close current file, rotate to next file

  if (_file != NULL) {

    _cur_file_num ++;

    if (_cur_file_num >= NumberOfGCLogFiles) _cur_file_num = 0;

    jio_snprintf(_file_name, strlen(Arguments::gc_log_filename()) + 10, "%s.%d",

             Arguments::gc_log_filename(), _cur_file_num);

    fclose(_file);

    _file = NULL;

  }

  _file = fopen(_file_name, "w");

  if (_file != NULL) {

    _bytes_writen = 0L;

    _need_close = true;

  } else {

    tty->print_cr("failed to open rotation log file %s due to %s\n",

                  _file_name, strerror(errno));

    _need_close = false;

  }

}

defaultStream* defaultStream::instance = NULL;

int defaultStream::_output_fd = 1;

int defaultStream::_error_fd  = 2;

FILE* defaultStream::_output_stream = stdout;

FILE* defaultStream::_error_stream  = stderr;

#define LOG_MAJOR_VERSION 160

#define LOG_MINOR_VERSION 1

void defaultStream::init() {

  _inited = true;

  if (LogVMOutput || LogCompilation) {

    init_log();

  }

}

bool defaultStream::has_log_file() {

  // lazily create log file (at startup, LogVMOutput is false even

  // if +LogVMOutput is used, because the flags haven't been parsed yet)

  // For safer printing during fatal error handling, do not init logfile

  // if a VM error has been reported.

  if (!_inited && !is_error_reported())  init();

  return _log_file != NULL;

}

static const char* make_log_name(const char* log_name, const char* force_directory) {

  const char* basename = log_name;

  char file_sep = os::file_separator()[0];

  const char* cp;

  for (cp = log_name; *cp != '\0'; cp++) {

    if (*cp == '/' || *cp == file_sep) {

      basename = cp+1;

    }

  }

  const char* nametail = log_name;

  // Compute buffer length

  size_t buffer_length;

  if (force_directory != NULL) {

    buffer_length = strlen(force_directory) + strlen(os::file_separator()) +

                    strlen(basename) + 1;

  } else {

    buffer_length = strlen(log_name) + 1;

  }

  const char* star = strchr(basename, '*');

  int star_pos = (star == NULL) ? -1 : (star - nametail);

  int skip = 1;

  if (star == NULL) {

    // Try %p

    star = strstr(basename, "%p");