Elliott Hughes | 13f5a58 | 2011-09-06 13:39:14 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | #include "logging.h" |
| 18 | |
Andreas Gampe | ed95754 | 2015-01-07 18:01:29 -0800 | [diff] [blame] | 19 | #include <iostream> |
Vladimir Marko | b8f2f63 | 2015-01-02 14:23:26 +0000 | [diff] [blame] | 20 | #include <limits> |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 21 | #include <sstream> |
| 22 | |
Elliott Hughes | 76b6167 | 2012-12-12 17:47:30 -0800 | [diff] [blame] | 23 | #include "base/mutex.h" |
Brian Carlstrom | a3d2718 | 2013-11-05 23:22:27 -0800 | [diff] [blame] | 24 | #include "thread-inl.h" |
Elliott Hughes | 13f5a58 | 2011-09-06 13:39:14 -0700 | [diff] [blame] | 25 | #include "utils.h" |
| 26 | |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 27 | // Headers for LogMessage::LogLine. |
Bilyan Borisov | bb661c0 | 2016-04-04 16:27:32 +0100 | [diff] [blame] | 28 | #ifdef ART_TARGET_ANDROID |
Mark Salyzyn | 0ad6c8f | 2016-09-28 15:29:14 -0700 | [diff] [blame] | 29 | #include <android/log.h> |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 30 | #else |
| 31 | #include <sys/types.h> |
| 32 | #include <unistd.h> |
| 33 | #endif |
| 34 | |
Elliott Hughes | f5a7a47 | 2011-10-07 14:31:02 -0700 | [diff] [blame] | 35 | namespace art { |
Elliott Hughes | 5fe594f | 2011-09-08 12:33:17 -0700 | [diff] [blame] | 36 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 37 | LogVerbosity gLogVerbosity; |
| 38 | |
Nicolas Geoffray | db97871 | 2014-12-09 13:33:38 +0000 | [diff] [blame] | 39 | unsigned int gAborting = 0; |
| 40 | |
Ian Rogers | 700a402 | 2014-05-19 16:49:03 -0700 | [diff] [blame] | 41 | static std::unique_ptr<std::string> gCmdLine; |
| 42 | static std::unique_ptr<std::string> gProgramInvocationName; |
| 43 | static std::unique_ptr<std::string> gProgramInvocationShortName; |
Elliott Hughes | 72395bf | 2012-04-24 13:45:26 -0700 | [diff] [blame] | 44 | |
Elliott Hughes | 0d39c12 | 2012-06-06 16:41:17 -0700 | [diff] [blame] | 45 | const char* GetCmdLine() { |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 46 | return (gCmdLine.get() != nullptr) ? gCmdLine->c_str() : nullptr; |
Elliott Hughes | 0d39c12 | 2012-06-06 16:41:17 -0700 | [diff] [blame] | 47 | } |
| 48 | |
| 49 | const char* ProgramInvocationName() { |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 50 | return (gProgramInvocationName.get() != nullptr) ? gProgramInvocationName->c_str() : "art"; |
Elliott Hughes | 0d39c12 | 2012-06-06 16:41:17 -0700 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | const char* ProgramInvocationShortName() { |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 54 | return (gProgramInvocationShortName.get() != nullptr) ? gProgramInvocationShortName->c_str() |
| 55 | : "art"; |
Elliott Hughes | 0d39c12 | 2012-06-06 16:41:17 -0700 | [diff] [blame] | 56 | } |
| 57 | |
David Sehr | f57589f | 2016-10-17 10:09:33 -0700 | [diff] [blame^] | 58 | void InitLogging(char* argv[], AbortFunction& abort_function) { |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 59 | if (gCmdLine.get() != nullptr) { |
Brian Carlstrom | fa42b44 | 2013-06-17 12:53:45 -0700 | [diff] [blame] | 60 | return; |
| 61 | } |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 62 | // TODO: Move this to a more obvious InitART... |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 63 | Locks::Init(); |
Ian Rogers | 00f7d0e | 2012-07-19 15:28:27 -0700 | [diff] [blame] | 64 | |
Elliott Hughes | 0d39c12 | 2012-06-06 16:41:17 -0700 | [diff] [blame] | 65 | // Stash the command line for later use. We can use /proc/self/cmdline on Linux to recover this, |
| 66 | // but we don't have that luxury on the Mac, and there are a couple of argv[0] variants that are |
| 67 | // commonly used. |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 68 | if (argv != nullptr) { |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 69 | gCmdLine.reset(new std::string(argv[0])); |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 70 | for (size_t i = 1; argv[i] != nullptr; ++i) { |
Brian Carlstrom | fa42b44 | 2013-06-17 12:53:45 -0700 | [diff] [blame] | 71 | gCmdLine->append(" "); |
| 72 | gCmdLine->append(argv[i]); |
| 73 | } |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 74 | gProgramInvocationName.reset(new std::string(argv[0])); |
Brian Carlstrom | fa42b44 | 2013-06-17 12:53:45 -0700 | [diff] [blame] | 75 | const char* last_slash = strrchr(argv[0], '/'); |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 76 | gProgramInvocationShortName.reset(new std::string((last_slash != nullptr) ? last_slash + 1 |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 77 | : argv[0])); |
Brian Carlstrom | fa42b44 | 2013-06-17 12:53:45 -0700 | [diff] [blame] | 78 | } else { |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 79 | // TODO: fall back to /proc/self/cmdline when argv is null on Linux. |
Ian Rogers | 1e363f9 | 2013-11-13 15:58:24 -0800 | [diff] [blame] | 80 | gCmdLine.reset(new std::string("<unset>")); |
Elliott Hughes | 0d39c12 | 2012-06-06 16:41:17 -0700 | [diff] [blame] | 81 | } |
Elliott Hughes | 72395bf | 2012-04-24 13:45:26 -0700 | [diff] [blame] | 82 | |
Andreas Gampe | 3fec9ac | 2016-09-13 10:47:28 -0700 | [diff] [blame] | 83 | #ifdef __ANDROID__ |
| 84 | #define INIT_LOGGING_DEFAULT_LOGGER android::base::LogdLogger() |
| 85 | #else |
| 86 | #define INIT_LOGGING_DEFAULT_LOGGER android::base::StderrLogger |
| 87 | #endif |
David Sehr | f57589f | 2016-10-17 10:09:33 -0700 | [diff] [blame^] | 88 | android::base::InitLogging(argv, INIT_LOGGING_DEFAULT_LOGGER, |
| 89 | std::move<AbortFunction>(abort_function)); |
Andreas Gampe | 3fec9ac | 2016-09-13 10:47:28 -0700 | [diff] [blame] | 90 | #undef INIT_LOGGING_DEFAULT_LOGGER |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 91 | } |
| 92 | |
Bilyan Borisov | bb661c0 | 2016-04-04 16:27:32 +0100 | [diff] [blame] | 93 | #ifdef ART_TARGET_ANDROID |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 94 | static const android_LogPriority kLogSeverityToAndroidLogPriority[] = { |
| 95 | ANDROID_LOG_VERBOSE, ANDROID_LOG_DEBUG, ANDROID_LOG_INFO, ANDROID_LOG_WARN, |
| 96 | ANDROID_LOG_ERROR, ANDROID_LOG_FATAL, ANDROID_LOG_FATAL |
| 97 | }; |
Andreas Gampe | 3fec9ac | 2016-09-13 10:47:28 -0700 | [diff] [blame] | 98 | static_assert(arraysize(kLogSeverityToAndroidLogPriority) == ::android::base::FATAL + 1, |
Andreas Gampe | 575e78c | 2014-11-03 23:41:03 -0800 | [diff] [blame] | 99 | "Mismatch in size of kLogSeverityToAndroidLogPriority and values in LogSeverity"); |
Ian Rogers | c7dd295 | 2014-10-21 23:31:19 -0700 | [diff] [blame] | 100 | #endif |
| 101 | |
Andreas Gampe | 3fec9ac | 2016-09-13 10:47:28 -0700 | [diff] [blame] | 102 | void LogHelper::LogLineLowStack(const char* file, |
| 103 | unsigned int line, |
| 104 | LogSeverity log_severity, |
| 105 | const char* message) { |
Bilyan Borisov | bb661c0 | 2016-04-04 16:27:32 +0100 | [diff] [blame] | 106 | #ifdef ART_TARGET_ANDROID |
Vladimir Marko | b8f2f63 | 2015-01-02 14:23:26 +0000 | [diff] [blame] | 107 | // Use android_writeLog() to avoid stack-based buffers used by android_printLog(). |
| 108 | const char* tag = ProgramInvocationShortName(); |
Andreas Gampe | 7fe3023 | 2016-03-25 16:58:00 -0700 | [diff] [blame] | 109 | int priority = kLogSeverityToAndroidLogPriority[static_cast<size_t>(log_severity)]; |
Vladimir Marko | b8f2f63 | 2015-01-02 14:23:26 +0000 | [diff] [blame] | 110 | char* buf = nullptr; |
| 111 | size_t buf_size = 0u; |
| 112 | if (priority == ANDROID_LOG_FATAL) { |
| 113 | // Allocate buffer for snprintf(buf, buf_size, "%s:%u] %s", file, line, message) below. |
| 114 | // If allocation fails, fall back to printing only the message. |
| 115 | buf_size = strlen(file) + 1 /* ':' */ + std::numeric_limits<typeof(line)>::max_digits10 + |
| 116 | 2 /* "] " */ + strlen(message) + 1 /* terminating 0 */; |
| 117 | buf = reinterpret_cast<char*>(malloc(buf_size)); |
| 118 | } |
| 119 | if (buf != nullptr) { |
| 120 | snprintf(buf, buf_size, "%s:%u] %s", file, line, message); |
| 121 | android_writeLog(priority, tag, buf); |
| 122 | free(buf); |
| 123 | } else { |
| 124 | android_writeLog(priority, tag, message); |
| 125 | } |
Ian Rogers | f4d4da1 | 2014-11-11 16:10:33 -0800 | [diff] [blame] | 126 | #else |
Andreas Gampe | 5fd66d0 | 2016-09-12 20:22:19 -0700 | [diff] [blame] | 127 | static constexpr char kLogCharacters[] = { 'V', 'D', 'I', 'W', 'E', 'F', 'F' }; |
Andreas Gampe | 3fec9ac | 2016-09-13 10:47:28 -0700 | [diff] [blame] | 128 | static_assert( |
| 129 | arraysize(kLogCharacters) == static_cast<size_t>(::android::base::FATAL) + 1, |
| 130 | "Wrong character array size"); |
Ian Rogers | f4d4da1 | 2014-11-11 16:10:33 -0800 | [diff] [blame] | 131 | |
| 132 | const char* program_name = ProgramInvocationShortName(); |
Elliott Hughes | 06f08e4 | 2015-05-12 21:25:36 -0700 | [diff] [blame] | 133 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, program_name, strlen(program_name))); |
| 134 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, " ", 1)); |
Andreas Gampe | 7fe3023 | 2016-03-25 16:58:00 -0700 | [diff] [blame] | 135 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, &kLogCharacters[static_cast<size_t>(log_severity)], 1)); |
Elliott Hughes | 06f08e4 | 2015-05-12 21:25:36 -0700 | [diff] [blame] | 136 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, " ", 1)); |
Ian Rogers | f4d4da1 | 2014-11-11 16:10:33 -0800 | [diff] [blame] | 137 | // TODO: pid and tid. |
Elliott Hughes | 06f08e4 | 2015-05-12 21:25:36 -0700 | [diff] [blame] | 138 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, file, strlen(file))); |
Ian Rogers | f4d4da1 | 2014-11-11 16:10:33 -0800 | [diff] [blame] | 139 | // TODO: line. |
| 140 | UNUSED(line); |
Elliott Hughes | 06f08e4 | 2015-05-12 21:25:36 -0700 | [diff] [blame] | 141 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, "] ", 2)); |
| 142 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, message, strlen(message))); |
| 143 | TEMP_FAILURE_RETRY(write(STDERR_FILENO, "\n", 1)); |
Bilyan Borisov | bb661c0 | 2016-04-04 16:27:32 +0100 | [diff] [blame] | 144 | #endif // ART_TARGET_ANDROID |
Ian Rogers | f4d4da1 | 2014-11-11 16:10:33 -0800 | [diff] [blame] | 145 | } |
| 146 | |
Elliott Hughes | f5a7a47 | 2011-10-07 14:31:02 -0700 | [diff] [blame] | 147 | } // namespace art |