1// Copyright 2009 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include "v8.h"
29
30#include "log-utils.h"
31#include "string-stream.h"
32
33namespace v8 {
34namespace internal {
35
36
37const char* const Log::kLogToTemporaryFile = "&";
38
39
40Log::Log(Logger* logger)
41  : is_stopped_(false),
42    output_handle_(NULL),
43    ll_output_handle_(NULL),
44    mutex_(NULL),
45    message_buffer_(NULL),
46    logger_(logger) {
47}
48
49
50static void AddIsolateIdIfNeeded(StringStream* stream) {
51  Isolate* isolate = Isolate::Current();
52  if (isolate->IsDefaultIsolate()) return;
53  stream->Add("isolate-%p-", isolate);
54}
55
56
57void Log::Initialize() {
58  mutex_ = OS::CreateMutex();
59  message_buffer_ = NewArray<char>(kMessageBufferSize);
60
61  // --log-all enables all the log flags.
62  if (FLAG_log_all) {
63    FLAG_log_runtime = true;
64    FLAG_log_api = true;
65    FLAG_log_code = true;
66    FLAG_log_gc = true;
67    FLAG_log_suspect = true;
68    FLAG_log_handles = true;
69    FLAG_log_regexp = true;
70  }
71
72  // --prof implies --log-code.
73  if (FLAG_prof) FLAG_log_code = true;
74
75  // --prof_lazy controls --log-code, implies --noprof_auto.
76  if (FLAG_prof_lazy) {
77    FLAG_log_code = false;
78    FLAG_prof_auto = false;
79  }
80
81  bool open_log_file = FLAG_log || FLAG_log_runtime || FLAG_log_api
82      || FLAG_log_code || FLAG_log_gc || FLAG_log_handles || FLAG_log_suspect
83      || FLAG_log_regexp || FLAG_log_state_changes || FLAG_ll_prof;
84
85  // If we're logging anything, we need to open the log file.
86  if (open_log_file) {
87    if (strcmp(FLAG_logfile, "-") == 0) {
88      OpenStdout();
89    } else if (strcmp(FLAG_logfile, kLogToTemporaryFile) == 0) {
90      OpenTemporaryFile();
91    } else {
92      if (strchr(FLAG_logfile, '%') != NULL ||
93          !Isolate::Current()->IsDefaultIsolate()) {
94        // If there's a '%' in the log file name we have to expand
95        // placeholders.
96        HeapStringAllocator allocator;
97        StringStream stream(&allocator);
98        AddIsolateIdIfNeeded(&stream);
99        for (const char* p = FLAG_logfile; *p; p++) {
100          if (*p == '%') {
101            p++;
102            switch (*p) {
103              case '\0':
104                // If there's a % at the end of the string we back up
105                // one character so we can escape the loop properly.
106                p--;
107                break;
108              case 't': {
109                // %t expands to the current time in milliseconds.
110                double time = OS::TimeCurrentMillis();
111                stream.Add("%.0f", FmtElm(time));
112                break;
113              }
114              case '%':
115                // %% expands (contracts really) to %.
116                stream.Put('%');
117                break;
118              default:
119                // All other %'s expand to themselves.
120                stream.Put('%');
121                stream.Put(*p);
122                break;
123            }
124          } else {
125            stream.Put(*p);
126          }
127        }
128        SmartArrayPointer<const char> expanded = stream.ToCString();
129        OpenFile(*expanded);
130      } else {
131        OpenFile(FLAG_logfile);
132      }
133    }
134  }
135}
136
137
138void Log::OpenStdout() {
139  ASSERT(!IsEnabled());
140  output_handle_ = stdout;
141}
142
143
144void Log::OpenTemporaryFile() {
145  ASSERT(!IsEnabled());
146  output_handle_ = i::OS::OpenTemporaryFile();
147}
148
149
150// Extension added to V8 log file name to get the low-level log name.
151static const char kLowLevelLogExt[] = ".ll";
152
153// File buffer size of the low-level log. We don't use the default to
154// minimize the associated overhead.
155static const int kLowLevelLogBufferSize = 2 * MB;
156
157
158void Log::OpenFile(const char* name) {
159  ASSERT(!IsEnabled());
160  output_handle_ = OS::FOpen(name, OS::LogFileOpenMode);
161  if (FLAG_ll_prof) {
162    // Open the low-level log file.
163    size_t len = strlen(name);
164    ScopedVector<char> ll_name(static_cast<int>(len + sizeof(kLowLevelLogExt)));
165    memcpy(ll_name.start(), name, len);
166    memcpy(ll_name.start() + len, kLowLevelLogExt, sizeof(kLowLevelLogExt));
167    ll_output_handle_ = OS::FOpen(ll_name.start(), OS::LogFileOpenMode);
168    setvbuf(ll_output_handle_, NULL, _IOFBF, kLowLevelLogBufferSize);
169  }
170}
171
172
173FILE* Log::Close() {
174  FILE* result = NULL;
175  if (output_handle_ != NULL) {
176    if (strcmp(FLAG_logfile, kLogToTemporaryFile) != 0) {
177      fclose(output_handle_);
178    } else {
179      result = output_handle_;
180    }
181  }
182  output_handle_ = NULL;
183  if (ll_output_handle_ != NULL) fclose(ll_output_handle_);
184  ll_output_handle_ = NULL;
185
186  DeleteArray(message_buffer_);
187  message_buffer_ = NULL;
188
189  delete mutex_;
190  mutex_ = NULL;
191
192  is_stopped_ = false;
193  return result;
194}
195
196
197LogMessageBuilder::LogMessageBuilder(Logger* logger)
198  : log_(logger->log_),
199    sl(log_->mutex_),
200    pos_(0) {
201  ASSERT(log_->message_buffer_ != NULL);
202}
203
204
205void LogMessageBuilder::Append(const char* format, ...) {
206  Vector<char> buf(log_->message_buffer_ + pos_,
207                   Log::kMessageBufferSize - pos_);
208  va_list args;
209  va_start(args, format);
210  AppendVA(format, args);
211  va_end(args);
212  ASSERT(pos_ <= Log::kMessageBufferSize);
213}
214
215
216void LogMessageBuilder::AppendVA(const char* format, va_list args) {
217  Vector<char> buf(log_->message_buffer_ + pos_,
218                   Log::kMessageBufferSize - pos_);
219  int result = v8::internal::OS::VSNPrintF(buf, format, args);
220
221  // Result is -1 if output was truncated.
222  if (result >= 0) {
223    pos_ += result;
224  } else {
225    pos_ = Log::kMessageBufferSize;
226  }
227  ASSERT(pos_ <= Log::kMessageBufferSize);
228}
229
230
231void LogMessageBuilder::Append(const char c) {
232  if (pos_ < Log::kMessageBufferSize) {
233    log_->message_buffer_[pos_++] = c;
234  }
235  ASSERT(pos_ <= Log::kMessageBufferSize);
236}
237
238
239void LogMessageBuilder::Append(String* str) {
240  AssertNoAllocation no_heap_allocation;  // Ensure string stay valid.
241  int length = str->length();
242  for (int i = 0; i < length; i++) {
243    Append(static_cast<char>(str->Get(i)));
244  }
245}
246
247
248void LogMessageBuilder::AppendAddress(Address addr) {
249  Append("0x%" V8PRIxPTR, addr);
250}
251
252
253void LogMessageBuilder::AppendDetailed(String* str, bool show_impl_info) {
254  if (str == NULL) return;
255  AssertNoAllocation no_heap_allocation;  // Ensure string stay valid.
256  int len = str->length();
257  if (len > 0x1000)
258    len = 0x1000;
259  if (show_impl_info) {
260    Append(str->IsAsciiRepresentation() ? 'a' : '2');
261    if (StringShape(str).IsExternal())
262      Append('e');
263    if (StringShape(str).IsSymbol())
264      Append('#');
265    Append(":%i:", str->length());
266  }
267  for (int i = 0; i < len; i++) {
268    uc32 c = str->Get(i);
269    if (c > 0xff) {
270      Append("\\u%04x", c);
271    } else if (c < 32 || c > 126) {
272      Append("\\x%02x", c);
273    } else if (c == ',') {
274      Append("\\,");
275    } else if (c == '\\') {
276      Append("\\\\");
277    } else if (c == '\"') {
278      Append("\"\"");
279    } else {
280      Append("%lc", c);
281    }
282  }
283}
284
285
286void LogMessageBuilder::AppendStringPart(const char* str, int len) {
287  if (pos_ + len > Log::kMessageBufferSize) {
288    len = Log::kMessageBufferSize - pos_;
289    ASSERT(len >= 0);
290    if (len == 0) return;
291  }
292  Vector<char> buf(log_->message_buffer_ + pos_,
293                   Log::kMessageBufferSize - pos_);
294  OS::StrNCpy(buf, str, len);
295  pos_ += len;
296  ASSERT(pos_ <= Log::kMessageBufferSize);
297}
298
299
300void LogMessageBuilder::WriteToLogFile() {
301  ASSERT(pos_ <= Log::kMessageBufferSize);
302  const int written = log_->WriteToFile(log_->message_buffer_, pos_);
303  if (written != pos_) {
304    log_->stop();
305    log_->logger_->LogFailure();
306  }
307}
308
309
310} }  // namespace v8::internal
311