1 /* 2 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 #include "precompiled.hpp" 25 #include "logging/log.hpp" 26 #include "logging/logConfiguration.hpp" 27 #include "logging/logFileOutput.hpp" 28 #include "memory/allocation.inline.hpp" 29 #include "runtime/os.inline.hpp" 30 #include "utilities/globalDefinitions.hpp" 31 #include "utilities/defaultStream.hpp" 32 33 const char* LogFileOutput::FileOpenMode = "a"; 34 const char* LogFileOutput::PidFilenamePlaceholder = "%p"; 35 const char* LogFileOutput::TimestampFilenamePlaceholder = "%t"; 36 const char* LogFileOutput::TimestampFormat = "%Y-%m-%d_%H-%M-%S"; 37 const char* LogFileOutput::FileSizeOptionKey = "filesize"; 38 const char* LogFileOutput::FileCountOptionKey = "filecount"; 39 const char* LogFileOutput::ExistingFileModeKey = "mode"; 40 char LogFileOutput::_pid_str[PidBufferSize]; 41 char LogFileOutput::_vm_start_time_str[StartTimeBufferSize]; 42 43 LogFileOutput::LogFileOutput(const char* name) 44 : LogFileStreamOutput(NULL), _name(os::strdup_check_oom(name, mtLogging)), 45 _file_name(NULL), _archive_name(NULL), _archive_name_len(0), _current_size(0), 46 _rotate_size(0), _current_file(1), _file_count(0), _rotation_semaphore(1), 47 _existing_file_mode(Archive) { 48 _file_name = make_file_name(name, _pid_str, _vm_start_time_str); 49 } 50 51 void LogFileOutput::set_file_name_parameters(jlong vm_start_time) { 52 int res = jio_snprintf(_pid_str, sizeof(_pid_str), "%d", os::current_process_id()); 53 assert(res > 0, "PID buffer too small"); 54 55 struct tm local_time; 56 time_t utc_time = vm_start_time / 1000; 57 os::localtime_pd(&utc_time, &local_time); 58 res = (int)strftime(_vm_start_time_str, sizeof(_vm_start_time_str), TimestampFormat, &local_time); 59 assert(res > 0, "VM start time buffer too small."); 60 } 61 62 LogFileOutput::~LogFileOutput() { 63 if (_stream != NULL) { 64 if (_archive_name != NULL) { 65 archive(); 66 } 67 if (fclose(_stream) != 0) { 68 jio_fprintf(defaultStream::error_stream(), "Could not close log file '%s' (%s).\n", 69 _file_name, strerror(errno)); 70 } 71 } 72 os::free(_archive_name); 73 os::free(_file_name); 74 os::free(const_cast<char*>(_name)); 75 } 76 77 size_t parse_value(const char* value_str) { 78 char* end; 79 unsigned long long value = strtoull(value_str, &end, 10); 80 if (!isdigit(*value_str) || end != value_str + strlen(value_str) || value >= SIZE_MAX) { 81 return SIZE_MAX; 82 } 83 return value; 84 } 85 86 bool LogFileOutput::configure(const char* options) { 87 if (options == NULL || strlen(options) == 0) { 88 return true; 89 } 90 bool success = true; 91 char* opts = os::strdup_check_oom(options, mtLogging); 92 93 char* comma_pos; 94 char* pos = opts; 95 do { 96 comma_pos = strchr(pos, ','); 97 if (comma_pos != NULL) { 98 *comma_pos = '\0'; 99 } 100 101 char* equals_pos = strchr(pos, '='); 102 if (equals_pos == NULL) { 103 success = false; 104 break; 105 } 106 char* key = pos; 107 char* value_str = equals_pos + 1; 108 *equals_pos = '\0'; 109 110 if (strcmp(FileCountOptionKey, key) == 0) { 111 size_t value = parse_value(value_str); 112 if (value == SIZE_MAX || value >= UINT_MAX) { 113 success = false; 114 break; 115 } 116 _file_count = static_cast<uint>(value); 117 _file_count_max_digits = static_cast<uint>(log10(static_cast<double>(_file_count)) + 1); 118 _archive_name_len = 2 + strlen(_file_name) + _file_count_max_digits; 119 _archive_name = NEW_C_HEAP_ARRAY(char, _archive_name_len, mtLogging); 120 } else if (strcmp(FileSizeOptionKey, key) == 0) { 121 size_t value = parse_value(value_str); 122 if (value == SIZE_MAX || value > SIZE_MAX / K) { 123 success = false; 124 break; 125 } 126 _rotate_size = value * K; 127 } else if (strcmp(ExistingFileModeKey, key) == 0) { 128 if (strcmp("archive", value_str) == 0) { 129 _existing_file_mode = Archive; 130 } else if (strcmp("append", value_str) == 0) { 131 _existing_file_mode = Append; 132 } else if (strcmp("truncate", value_str) == 0) { 133 _existing_file_mode = Truncate; 134 } else { 135 success = false; 136 break; 137 } 138 } else { 139 success = false; 140 break; 141 } 142 pos = comma_pos + 1; 143 } while (comma_pos != NULL); 144 145 os::free(opts); 146 return success; 147 } 148 149 static bool file_exists(const char* filename) { 150 struct stat dummy_stat; 151 return os::stat(filename, &dummy_stat) == 0; 152 } 153 154 // Renames the given file (if it exists) from for example "jvm.log" to "jvm.log.X" 155 // where X is the lowest number such that the resulting filename doesn't already exist. 156 // This is done to prevent overwriting old log files by mistake. 157 static void archive_file(const char* filename) { 158 // Nothing to archive if the given file doesn't exist 159 if (!file_exists(filename)) { 160 return; 161 } 162 163 // Size should be filename-length + dot + max digits in SIZE_MAX + null char 164 const size_t size = strlen(filename) + ceil(log10(static_cast<double>(SIZE_MAX))) + 2; 165 char* archive_name = NEW_C_HEAP_ARRAY(char, size, mtLogging); 166 167 bool archived = false; 168 for (size_t i = 0; i < SIZE_MAX; i++) { 169 jio_snprintf(archive_name, size, "%s." SIZE_FORMAT, filename, i); 170 if (file_exists(archive_name)) { 171 continue; 172 } 173 // Unique archive name found! 174 int ret = rename(filename, archive_name); 175 if (ret == 0) { 176 archived = true; 177 } 178 break; 179 } 180 181 FREE_C_HEAP_ARRAY(char, archive_name); 182 if (archived) { 183 return; 184 } 185 186 jio_fprintf(defaultStream::error_stream(), 187 "Unable to archive pre-existing log file: %s. " 188 "File will be appended instead.\n", filename); 189 } 190 191 bool LogFileOutput::initialize(const char* options) { 192 if (!configure(options)) { 193 return false; 194 } 195 196 if (_existing_file_mode == Archive) { 197 archive_file(_file_name); 198 } 199 200 _stream = fopen(_file_name, FileOpenMode); 201 if (_stream == NULL) { 202 log_error(logging)("Could not open log file '%s' (%s).", _file_name, strerror(errno)); 203 return false; 204 } 205 206 if (_existing_file_mode == Truncate) { 207 os::ftruncate(fileno(_stream), 0); 208 } 209 210 return true; 211 } 212 213 int LogFileOutput::write(const LogDecorations& decorations, const char* msg) { 214 if (_stream == NULL) { 215 // An error has occurred with this output, avoid writing to it. 216 return 0; 217 } 218 219 _rotation_semaphore.wait(); 220 int written = LogFileStreamOutput::write(decorations, msg); 221 _current_size += written; 222 223 if (should_rotate()) { 224 rotate(); 225 } 226 _rotation_semaphore.signal(); 227 228 return written; 229 } 230 231 void LogFileOutput::archive() { 232 assert(_archive_name != NULL && _archive_name_len > 0, "Rotation must be configured before using this function."); 233 int ret = jio_snprintf(_archive_name, _archive_name_len, "%s.%0*u", 234 _file_name, _file_count_max_digits, _current_file); 235 assert(ret >= 0, "Buffer should always be large enough"); 236 237 // Attempt to remove possibly existing archived log file before we rename. 238 // Don't care if it fails, we really only care about the rename that follows. 239 remove(_archive_name); 240 241 // Rename the file from ex hotspot.log to hotspot.log.2 242 if (rename(_file_name, _archive_name) == -1) { 243 jio_fprintf(defaultStream::error_stream(), "Could not rename log file '%s' to '%s' (%s).\n", 244 _file_name, _archive_name, strerror(errno)); 245 } 246 } 247 248 void LogFileOutput::force_rotate() { 249 if (_file_count == 0) { 250 // Rotation not possible 251 return; 252 } 253 _rotation_semaphore.wait(); 254 rotate(); 255 _rotation_semaphore.signal(); 256 } 257 258 void LogFileOutput::rotate() { 259 260 if (fclose(_stream)) { 261 jio_fprintf(defaultStream::error_stream(), "Error closing file '%s' during log rotation (%s).\n", 262 _file_name, strerror(errno)); 263 } 264 265 // Archive the current log file 266 archive(); 267 268 // Open the active log file using the same stream as before 269 _stream = fopen(_file_name, FileOpenMode); 270 if (_stream == NULL) { 271 jio_fprintf(defaultStream::error_stream(), "Could not reopen file '%s' during log rotation (%s).\n", 272 _file_name, strerror(errno)); 273 return; 274 } 275 276 // Reset accumulated size, increase current file counter, and check for file count wrap-around. 277 _current_size = 0; 278 _current_file = (_current_file >= _file_count ? 1 : _current_file + 1); 279 } 280 281 char* LogFileOutput::make_file_name(const char* file_name, 282 const char* pid_string, 283 const char* timestamp_string) { 284 char* result = NULL; 285 286 // Lets start finding out if we have any %d and/or %t in the name. 287 // We will only replace the first occurrence of any placeholder 288 const char* pid = strstr(file_name, PidFilenamePlaceholder); 289 const char* timestamp = strstr(file_name, TimestampFilenamePlaceholder); 290 291 if (pid == NULL && timestamp == NULL) { 292 // We found no place-holders, return the simple filename 293 return os::strdup_check_oom(file_name, mtLogging); 294 } 295 296 // At least one of the place-holders were found in the file_name 297 const char* first = ""; 298 size_t first_pos = SIZE_MAX; 299 size_t first_replace_len = 0; 300 301 const char* second = ""; 302 size_t second_pos = SIZE_MAX; 303 size_t second_replace_len = 0; 304 305 // If we found a %p, then setup our variables accordingly 306 if (pid != NULL) { 307 if (timestamp == NULL || pid < timestamp) { 308 first = pid_string; 309 first_pos = pid - file_name; 310 first_replace_len = strlen(PidFilenamePlaceholder); 311 } else { 312 second = pid_string; 313 second_pos = pid - file_name; 314 second_replace_len = strlen(PidFilenamePlaceholder); 315 } 316 } 317 318 if (timestamp != NULL) { 319 if (pid == NULL || timestamp < pid) { 320 first = timestamp_string; 321 first_pos = timestamp - file_name; 322 first_replace_len = strlen(TimestampFilenamePlaceholder); 323 } else { 324 second = timestamp_string; 325 second_pos = timestamp - file_name; 326 second_replace_len = strlen(TimestampFilenamePlaceholder); 327 } 328 } 329 330 size_t first_len = strlen(first); 331 size_t second_len = strlen(second); 332 333 // Allocate the new buffer, size it to hold all we want to put in there +1. 334 size_t result_len = strlen(file_name) + first_len - first_replace_len + second_len - second_replace_len; 335 result = NEW_C_HEAP_ARRAY(char, result_len + 1, mtLogging); 336 337 // Assemble the strings 338 size_t file_name_pos = 0; 339 size_t i = 0; 340 while (i < result_len) { 341 if (file_name_pos == first_pos) { 342 // We are in the range of the first placeholder 343 strcpy(result + i, first); 344 // Bump output buffer position with length of replacing string 345 i += first_len; 346 // Bump source buffer position to skip placeholder 347 file_name_pos += first_replace_len; 348 } else if (file_name_pos == second_pos) { 349 // We are in the range of the second placeholder 350 strcpy(result + i, second); 351 i += second_len; 352 file_name_pos += second_replace_len; 353 } else { 354 // Else, copy char by char of the original file 355 result[i] = file_name[file_name_pos++]; 356 i++; 357 } 358 } 359 // Add terminating char 360 result[result_len] = '\0'; 361 return result; 362 }